6967830491

Committed 23 Nov 2023 09:27AM UTC coverage: 23.594% (+0.1%) from 23.472%

Build # 6967830491

Build Type

push

github

Committed by

gustavo-salazar

Commit Message

Merge branch 'master' into future

Run Details

908 of 5355 branches covered (0.0%)

Branch coverage included in aggregate %.

0 of 6 new or added lines in 2 files covered. (0.0%)

2 existing lines in 1 file now uncovered.

2210 of 7860 relevant lines covered (28.12%)

47.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/pages/endpoint-page.js

import React, { PureComponent } from 'react';
import T from 'prop-types';
import { dataPropType } from 'higherOrder/loadData/dataPropTypes';
import { Helmet } from 'react-helmet-async';

import { createSelector } from 'reselect';
import Link from 'components/generic/Link';

import ErrorBoundary, {
  UnconnectedErrorBoundary,
} from 'wrappers/ErrorBoundary';
import Switch from 'components/generic/Switch';
import { mainDBLocationSelector } from 'reducers/custom-location/description';
import { getUrlForApi, getUrlForMeta } from 'higherOrder/loadData/defaults';
import loadData from 'higherOrder/loadData';
import { edgeCases } from 'utils/server-message';
import { toPlural } from 'utils/pages';

import Loading from 'components/SimpleCommonComponents/Loading';
import EntryMenu from 'components/EntryMenu';
import RemovedEntrySummary from 'components/Entry/RemovedEntrySummary';
import Title from 'components/Title';
import EdgeCase from 'components/EdgeCase';
import { getMessageIfLocationRemoved } from 'utils/removed-pages';

import {
  // schemaProcessDataRecord,
  schemaProcessMainEntity,
} from 'schema_org/processors';
import loadable from 'higherOrder/loadable';

import { foundationPartial } from 'styles/foundation';

import pageStyle from './style.css';
import fonts from 'EBI-Icon-fonts/fonts.css';
import ebiGlobalStyles from 'ebi-framework/css/ebi-global.css';

const f = foundationPartial(ebiGlobalStyles, fonts, pageStyle);

const SchemaOrgData = loadable({
  loader: () => import(/* webpackChunkName: "schemaOrg" */ 'schema_org'),
  loading: () => null,
});

const propTypes = {
  data: dataPropType.isRequired,
  isStale: T.bool.isRequired,
  customLocation: T.shape({
    description: T.object.isRequired,
  }).isRequired,
  match: T.string,
  dataBase: dataPropType.isRequired,
  subPagesForEndpoint: T.oneOfType([T.func, T.object]),
};

class SummaryComponent extends PureComponent {
  static propTypes = {
    data: dataPropType.isRequired,
    dataBase: dataPropType.isRequired,
    customLocation: T.object.isRequired,
    SummaryAsync: T.oneOfType([T.func, T.object]),
  };

  render() {
    const {
      data: { payload, loading },
      dataBase: { payload: payloadDB, loading: loadingDB },
      customLocation,
      SummaryAsync,
    } = this.props;
    const db =
      (!loadingDB &&
        payloadDB &&
        payloadDB.databases &&
        payloadDB.databases[customLocation.description.entry.db]) ||
      {};
    return (
      <SummaryAsync
        data={payload}
        dbInfo={db}
        customLocation={customLocation}
        loading={loading && loadingDB}
      />
    );
  }
}

const locationhasDetailOrFilter = createSelector(
  (customLocation) => {
    const { key } = customLocation.description.main;
    return (
      customLocation.description[key].detail ||
      (Object.entries(customLocation.description).find(
        ([_key, value]) => value.isFilter,
      ) || [])[0]
    );
  },
  (value) => value,
);

const STATUS_GONE = 410;
class Summary extends PureComponent {
  static propTypes = propTypes;

  render() {
    const {
      data: { status, loading, payload },
      dataBase: { payload: payloadDB, loading: loadingDB },
      customLocation,
      subPagesForEndpoint,
    } = this.props;
    const {
      description: {
        main: { key: endpoint },
      },
    } = customLocation;

    if (loading) {
      return <Loading />;
    }

    if (payload && status === STATUS_GONE) {
      const db =
        (!loadingDB &&
          payloadDB &&
          payloadDB.databases &&
          payloadDB.databases[customLocation.description.entry.db]) ||
        {};

      return <RemovedEntrySummary {...payload} dbInfo={db} />;
    }

    const removedPageMesagge = getMessageIfLocationRemoved(
      customLocation.description,
    );
    if (removedPageMesagge) {
      return (
        <EdgeCase
          text={removedPageMesagge}
          status={410}
          shouldRedirect={false}
        />
      );
    }

    if (edgeCases.has(status)) {
      const edgeCaseText = edgeCases.get(status);
      if (edgeCaseText) {
        return <EdgeCase text={edgeCaseText} status={status} />;
      }
    }

    if (!locationhasDetailOrFilter(customLocation) && !payload) {
      return <Loading />;
    }

    return (
      <>
        {payload?.metadata?.accession && (
          <>
            {/* <SchemaOrgData
              data={{
                data: payload,
                endpoint,
                version: databases && databases.uniprot.version,
              }}
              processData={schemaProcessDataRecord}
            /> */}
            <SchemaOrgData
              data={{
                data: payload.metadata,
                type: endpoint,
              }}
              processData={schemaProcessMainEntity}
            />
          </>
        )}

        <div className={f('row')}>
          <div className={f('medium-12', 'large-12', 'columns')}>
            <UnconnectedErrorBoundary customLocation={customLocation}>
              {loading ? <Loading /> : null}
              {!loading && (!payload || !payload.metadata) ? null : (
                <Title metadata={payload.metadata} mainType={endpoint} />
              )}
            </UnconnectedErrorBoundary>
          </div>
        </div>
        <div className={f('row')}>
          <div className={f('medium-12', 'large-12', 'columns')}>
            <section className={f('menu-and-content')}>
              <nav>
                <UnconnectedErrorBoundary customLocation={customLocation}>
                  <EntryMenu metadata={payload.metadata} />
                </UnconnectedErrorBoundary>
              </nav>
              <section>
                <UnconnectedErrorBoundary customLocation={customLocation}>
                  <Switch
                    {...this.props}
                    locationSelector={locationhasDetailOrFilter}
                    indexRoute={SummaryComponent}
                    childRoutes={subPagesForEndpoint}
                  />
                </UnconnectedErrorBoundary>
              </section>
            </section>
          </div>
        </div>
      </>
    );
  }
}

class Overview extends PureComponent {
  static propTypes = propTypes;

  render() {
    const {
      data: { payload },
      customLocation: {
        description: {
          main: { key },
        },
      },
    } = this.props;
    const keyS = toPlural(key);
    const _payload = payload || {};
    return (
      <ul>
        {Object.entries(_payload[keyS] || {}).map(([name, count]) => (
          <li key={name}>
            <Link
              to={{
                description: {
                  main: { key },
                  [key]: { db: name },
                },
              }}
            >
              {name}
              {Number.isFinite(count) ? ` (${count})` : ''}
            </Link>
          </li>
        ))}
      </ul>
    );
  }
}

const locationHasAccessionOrFilters = createSelector(
  (customLocation) => {
    const { key } = customLocation.description.main;
    return (
      customLocation.description[key].accession ||
      customLocation.description[key].memberDBAccession ||
      (Object.entries(customLocation.description).find(
        ([_key, value]) => value.isFilter,
      ) || [])[0]
    );
  },
  (value) => value,
);

// Keep outside! Otherwise will be redefined at each render of the outer Switch
class InnerSwitch extends PureComponent {
  static propTypes = {
    subpagesRoutes: T.object.isRequired,
    children: T.any,
    listOfEndpointEntities: T.func,
  };

  render() {
    const { subpagesRoutes, listOfEndpointEntities } = this.props;
    const childRoutes = new Map([[subpagesRoutes, Summary]]);
    return (
      <ErrorBoundary>
        <Switch
          {...this.props}
          locationSelector={locationHasAccessionOrFilters}
          indexRoute={listOfEndpointEntities}
          childRoutes={childRoutes}
          catchAll={listOfEndpointEntities}
        />
      </ErrorBoundary>
    );
  }
}

class EndPointPage extends PureComponent {
  static propTypes = {
    data: T.object.isRequired,
    children: T.any,
    mainEndpoint: T.object,
    hasFilters: T.bool,
  };

  render() {
    const { mainEndpoint, hasFilters, data } = this.props;
    // eslint-disable-next-line camelcase
    const db = data?.payload?.metadata?.source_database;
    const accession = data?.payload?.metadata?.accession;
    const hasCanonical =
      mainEndpoint.accession &&
      !mainEndpoint.detail &&
      !hasFilters &&
      mainEndpoint.db;
    return (
      <ErrorBoundary>
        <Helmet>
          <title>Browse</title>
          {hasCanonical && (
            <link
              rel="canonical"
              href={`https://www.ebi.ac.uk/interpro/${mainEndpoint.type}/${db}/${accession}`}
            />
          )}
        </Helmet>
        <Switch
          {...this.props}
          locationSelector={mainDBLocationSelector}
          indexRoute={Overview}
          catchAll={InnerSwitch}
        />
      </ErrorBoundary>
    );
  }
}

const mapStateToProps = createSelector(
  (state) => state.customLocation.description.main.key,
  (state) =>
    state.customLocation.description[state.customLocation.description.main.key],
  (state) =>
    (
      Object.entries(state.customLocation.description || {}).find(
        ([_key, value]) => value.isFilter,
      ) || []
    ).length > 0,
  (key, mainEndpoint, hasFilters) => ({
    mainEndpoint: { ...mainEndpoint, type: key },
    hasFilters,
  }),
);

export default loadData({
  getUrl: getUrlForMeta,
  propNamespace: 'Base',
  mapStateToProps,
})(loadData(getUrlForApi)(EndPointPage));

1	import React, { PureComponent } from 'react';
2	import T from 'prop-types';
3	import { dataPropType } from 'higherOrder/loadData/dataPropTypes';
4	import { Helmet } from 'react-helmet-async';
5
6	import { createSelector } from 'reselect';
7	import Link from 'components/generic/Link';
8
9	import ErrorBoundary, {
10	UnconnectedErrorBoundary,
11	} from 'wrappers/ErrorBoundary';
12	import Switch from 'components/generic/Switch';
13	import { mainDBLocationSelector } from 'reducers/custom-location/description';
14	import { getUrlForApi, getUrlForMeta } from 'higherOrder/loadData/defaults';
15	import loadData from 'higherOrder/loadData';
16	import { edgeCases } from 'utils/server-message';
17	import { toPlural } from 'utils/pages';
18
19	import Loading from 'components/SimpleCommonComponents/Loading';
20	import EntryMenu from 'components/EntryMenu';
21	import RemovedEntrySummary from 'components/Entry/RemovedEntrySummary';
22	import Title from 'components/Title';
23	import EdgeCase from 'components/EdgeCase';
24	import { getMessageIfLocationRemoved } from 'utils/removed-pages';
25
26	import {
27	// schemaProcessDataRecord,
28	schemaProcessMainEntity,
29	} from 'schema_org/processors';
30	import loadable from 'higherOrder/loadable';
31
32	import { foundationPartial } from 'styles/foundation';
33
34	import pageStyle from './style.css';
35	import fonts from 'EBI-Icon-fonts/fonts.css';
36	import ebiGlobalStyles from 'ebi-framework/css/ebi-global.css';
37
38	const f = foundationPartial(ebiGlobalStyles, fonts, pageStyle);	×
39
40	const SchemaOrgData = loadable({	×
41	loader: () => import(/* webpackChunkName: "schemaOrg" */ 'schema_org'),	×
42	loading: () => null,	×
43	});
44
45	const propTypes = {	×
46	data: dataPropType.isRequired,
47	isStale: T.bool.isRequired,
48	customLocation: T.shape({
49	description: T.object.isRequired,
50	}).isRequired,
51	match: T.string,
52	dataBase: dataPropType.isRequired,
53	subPagesForEndpoint: T.oneOfType([T.func, T.object]),
54	};
55
56	class SummaryComponent extends PureComponent {
57	static propTypes = {	×
58	data: dataPropType.isRequired,
59	dataBase: dataPropType.isRequired,
60	customLocation: T.object.isRequired,
61	SummaryAsync: T.oneOfType([T.func, T.object]),
62	};
63
64	render() {
65	const {
66	data: { payload, loading },
67	dataBase: { payload: payloadDB, loading: loadingDB },
68	customLocation,
69	SummaryAsync,
70	} = this.props;	×
71	const db =
72	(!loadingDB &&	×
73	payloadDB &&
74	payloadDB.databases &&
75	payloadDB.databases[customLocation.description.entry.db]) \|\|
76	{};
77	return (	×
78	<SummaryAsync
79	data={payload}
80	dbInfo={db}
81	customLocation={customLocation}
82	loading={loading && loadingDB}	×
83	/>
84	);
85	}
86	}
87
88	const locationhasDetailOrFilter = createSelector(	×
89	(customLocation) => {
90	const { key } = customLocation.description.main;	×
91	return (	×
92	customLocation.description[key].detail \|\|	×
93	(Object.entries(customLocation.description).find(	×
94	([_key, value]) => value.isFilter,	×
95	) \|\| [])[0]
96	);
97	},
98	(value) => value,	×
99	);
100
101	const STATUS_GONE = 410;	×
102	class Summary extends PureComponent {
103	static propTypes = propTypes;	×
104
105	render() {
106	const {
107	data: { status, loading, payload },
108	dataBase: { payload: payloadDB, loading: loadingDB },
109	customLocation,
110	subPagesForEndpoint,
111	} = this.props;	×
112	const {
113	description: {
114	main: { key: endpoint },
115	},
116	} = customLocation;	×
117
118	if (loading) {	×
119	return <Loading />;	×
120	}
121
122	if (payload && status === STATUS_GONE) {	×
123	const db =
124	(!loadingDB &&	×
125	payloadDB &&
126	payloadDB.databases &&
127	payloadDB.databases[customLocation.description.entry.db]) \|\|
128	{};
129
130	return <RemovedEntrySummary {...payload} dbInfo={db} />;	×
131	}
132
NEW 133	const removedPageMesagge = getMessageIfLocationRemoved(	×
134	customLocation.description,
135	);
NEW 136	if (removedPageMesagge) {	×
NEW 137	return (	×
138	<EdgeCase
139	text={removedPageMesagge}
140	status={410}
141	shouldRedirect={false}
142	/>
143	);
144	}
145
146	if (edgeCases.has(status)) {	×
147	const edgeCaseText = edgeCases.get(status);	×
148	if (edgeCaseText) {	×
149	return <EdgeCase text={edgeCaseText} status={status} />;	×
150	}
151	}
152
153	if (!locationhasDetailOrFilter(customLocation) && !payload) {	×
154	return <Loading />;	×
155	}
156
157	return (	×
158	<>
159	{payload?.metadata?.accession && (	×
160	<>
161	{/* <SchemaOrgData
162	data={{
163	data: payload,
164	endpoint,
165	version: databases && databases.uniprot.version,
166	}}
167	processData={schemaProcessDataRecord}
168	/> */}
169	<SchemaOrgData
170	data={{
171	data: payload.metadata,
172	type: endpoint,
173	}}
174	processData={schemaProcessMainEntity}
175	/>
176	</>
177	)}
178
179	<div className={f('row')}>
180	<div className={f('medium-12', 'large-12', 'columns')}>
181	<UnconnectedErrorBoundary customLocation={customLocation}>
182	{loading ? <Loading /> : null}	×
183	{!loading && (!payload \|\| !payload.metadata) ? null : (	×
184	<Title metadata={payload.metadata} mainType={endpoint} />
185	)}
186	</UnconnectedErrorBoundary>
187	</div>
188	</div>
189	<div className={f('row')}>
190	<div className={f('medium-12', 'large-12', 'columns')}>
191	<section className={f('menu-and-content')}>
192	<nav>
193	<UnconnectedErrorBoundary customLocation={customLocation}>
194	<EntryMenu metadata={payload.metadata} />
195	</UnconnectedErrorBoundary>
196	</nav>
197	<section>
198	<UnconnectedErrorBoundary customLocation={customLocation}>
199	<Switch
200	{...this.props}
201	locationSelector={locationhasDetailOrFilter}
202	indexRoute={SummaryComponent}
203	childRoutes={subPagesForEndpoint}
204	/>
205	</UnconnectedErrorBoundary>
206	</section>
207	</section>
208	</div>
209	</div>
210	</>
211	);
212	}
213	}
214
215	class Overview extends PureComponent {
216	static propTypes = propTypes;	×
217
218	render() {
219	const {
220	data: { payload },
221	customLocation: {
222	description: {
223	main: { key },
224	},
225	},
226	} = this.props;	×
227	const keyS = toPlural(key);	×
228	const _payload = payload \|\| {};	×
229	return (	×
230	<ul>
231	{Object.entries(_payload[keyS] \|\| {}).map(([name, count]) => (	×
232	<li key={name}>	×
233	<Link
234	to={{
235	description: {
236	main: { key },
237	[key]: { db: name },
238	},
239	}}
240	>
241	{name}
242	{Number.isFinite(count) ? ` (${count})` : ''}	×
243	</Link>
244	</li>
245	))}
246	</ul>
247	);
248	}
249	}
250
251	const locationHasAccessionOrFilters = createSelector(	×
252	(customLocation) => {
253	const { key } = customLocation.description.main;	×
254	return (	×
255	customLocation.description[key].accession \|\|	×
256	customLocation.description[key].memberDBAccession \|\|
257	(Object.entries(customLocation.description).find(	×
258	([_key, value]) => value.isFilter,	×
259	) \|\| [])[0]
260	);
261	},
262	(value) => value,	×
263	);
264
265	// Keep outside! Otherwise will be redefined at each render of the outer Switch
266	class InnerSwitch extends PureComponent {
267	static propTypes = {	×
268	subpagesRoutes: T.object.isRequired,
269	children: T.any,
270	listOfEndpointEntities: T.func,
271	};
272
273	render() {
274	const { subpagesRoutes, listOfEndpointEntities } = this.props;	×
275	const childRoutes = new Map([[subpagesRoutes, Summary]]);	×
276	return (	×
277	<ErrorBoundary>
278	<Switch
279	{...this.props}
280	locationSelector={locationHasAccessionOrFilters}
281	indexRoute={listOfEndpointEntities}
282	childRoutes={childRoutes}
283	catchAll={listOfEndpointEntities}
284	/>
285	</ErrorBoundary>
286	);
287	}
288	}
289
290	class EndPointPage extends PureComponent {
291	static propTypes = {	×
292	data: T.object.isRequired,
293	children: T.any,
294	mainEndpoint: T.object,
295	hasFilters: T.bool,
296	};
297
298	render() {
299	const { mainEndpoint, hasFilters, data } = this.props;	×
300	// eslint-disable-next-line camelcase
301	const db = data?.payload?.metadata?.source_database;	×
302	const accession = data?.payload?.metadata?.accession;	×
303	const hasCanonical =
304	mainEndpoint.accession &&	×
305	!mainEndpoint.detail &&
306	!hasFilters &&
307	mainEndpoint.db;
308	return (	×
309	<ErrorBoundary>
310	<Helmet>
311	<title>Browse</title>
312	{hasCanonical && (	×
313	<link
314	rel="canonical"
315	href={`https://www.ebi.ac.uk/interpro/${mainEndpoint.type}/${db}/${accession}`}
316	/>
317	)}
318	</Helmet>
319	<Switch
320	{...this.props}
321	locationSelector={mainDBLocationSelector}
322	indexRoute={Overview}
323	catchAll={InnerSwitch}
324	/>
325	</ErrorBoundary>
326	);
327	}
328	}
329
330	const mapStateToProps = createSelector(	×
331	(state) => state.customLocation.description.main.key,	×
332	(state) =>
333	state.customLocation.description[state.customLocation.description.main.key],	×
334	(state) =>
335	(	×
336	Object.entries(state.customLocation.description \|\| {}).find(	×
337	([_key, value]) => value.isFilter,	×
338	) \|\| []
339	).length > 0,
340	(key, mainEndpoint, hasFilters) => ({	×
341	mainEndpoint: { ...mainEndpoint, type: key },
342	hasFilters,
343	}),
344	);
345
346	export default loadData({
347	getUrl: getUrlForMeta,
348	propNamespace: 'Base',
349	mapStateToProps,
350	})(loadData(getUrlForApi)(EndPointPage));

ProteinsWebTeam / interpro7-client / 6967830491

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous