4123

pending completion

Build # 4123

Build Type

push

travis-ci-com

Committed by

web-flow

Commit Message

Merge pull request #666 from akashgp09/series-api-browse-request

API: add browse requests for series

Run Details

1593 of 4020 branches covered (39.63%)

12 of 12 new or added lines in 2 files covered. (100.0%)

4464 of 7305 relevant lines covered (61.11%)

32.08 hits per line

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

28.0

/src/api/routes/series.js

/*
 * Copyright (C) 2021  Akash Gupta
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

import * as utils from '../helpers/utils';

import {formatQueryParameters, loadEntityRelationshipsForBrowse, validateBrowseRequestQueryParameters} from '../helpers/middleware';
import {getEntityAliases, getEntityIdentifiers, getEntityRelationships, getSeriesBasicInfo} from '../helpers/formatEntityData';
import {Router} from 'express';
import {makeEntityLoader} from '../helpers/entityLoader';
import {toLower} from 'lodash';


const router = Router();

const seriesBasicRelations = [
        'defaultAlias.language',
        'disambiguation',
        'seriesOrderingType'
];

const seriesError = 'Series not found';

/**
 *@swagger
 * components:
 *   schemas:
 *     SeriesDetail:
 *      type: object
 *      properties:
 *        bbid:
 *          type: string
 *          format: uuid
 *          example: '2e5f49a8-6a38-4cc7-97c7-8e624e1fc2c1'
 *        seriesOrderingType:
 *          type: string
 *          example: 'Automatic'
 *        seriesType:
 *          type: string
 *          example: 'Work'
 *        defaultAlias:
 *            $ref: '#/components/schemas/Alias'
 *        disambiguation:
 *          type: string
 *          example: 'series of three epic fantasy'
 *     BrowsedSeries:
 *       type: object
 *       properties:
 *         bbid:
 *           type: string
 *           format: uuid
 *           example: 'f94d74ce-c748-4130-8d59-38b290af8af3'
 *         series:
 *           type: array
 *           items:
 *             type: object
 *             properties:
 *               entity:
 *                 $ref: '#/components/schemas/SeriesDetail'
 *               relationships:
 *                 type: array
 *                 items:
 *                   type: object
 *                   properties:
 *                      relationshipTypeID:
 *                        type: number
 *                        example: 71
 *                      relationshipType:
 *                        type: string
 *                        example: 'Work Series'
 */


/**
 *@swagger
 *'/series/{bbid}':
 *  get:
 *     tags:
 *       - Lookup Requests
 *     summary: Lookup Series by BBID
 *     description: Returns the basic details of an Series
 *     operationId: getSeriesByBbid
 *     parameters:
 *       - name: bbid
 *         in: path
 *         description: BBID of the Series
 *         required: true
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: Basic information of an Series entity
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/SeriesDetail'
 *       404:
 *         description: Series not found
 *       400:
 *         description: Invalid BBID
 */

router.get('/:bbid',
        makeEntityLoader('Series', seriesBasicRelations, seriesError),
        async (req, res) => {
                const seriesBasicInfo = await getSeriesBasicInfo(res.locals.entity);
                return res.status(200).send(seriesBasicInfo);
        });


/**
 *        @swagger
 * '/series/{bbid}/aliases':
 *   get:
 *     tags:
 *       - Lookup Requests
 *     summary: Get list of aliases of an Series by BBID
 *     description: Returns the list of aliases of an Series
 *     operationId: getAliasesOfSeriesByBbid
 *     parameters:
 *       - name: bbid
 *         in: path
 *         description: BBID of the Series
 *         required: true
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: List of aliases with BBID of an Series entity
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/Aliases'
 *       404:
 *         description: Series not found
 *       400:
 *         description: Invalid BBID
 */

router.get('/:bbid/aliases',
        makeEntityLoader('Series', utils.aliasesRelations, seriesError),
        async (req, res) => {
                const seriesAliasesList = await getEntityAliases(res.locals.entity);
                return res.status(200).send(seriesAliasesList);
        });

/**
 *        @swagger
 * '/series/{bbid}/identifiers':
 *   get:
 *     tags:
 *       - Lookup Requests
 *     summary: Get list of identifiers of an Series by BBID
 *     description: Returns the list of identifiers of an Series
 *     operationId: getIdentifiersOfSeriesByBbid
 *     parameters:
 *       - name: bbid
 *         in: path
 *         description: BBID of the Series
 *         required: true
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: List of identifiers with BBID of an Series entity
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/Identifiers'
 *       404:
 *         description: Series not found
 *       400:
 *         description: Invalid BBID
 */

router.get('/:bbid/identifiers',
        makeEntityLoader('Series', utils.identifiersRelations, seriesError),
        async (req, res) => {
                const seriesIdentifiersList = await getEntityIdentifiers(res.locals.entity);
                return res.status(200).send(seriesIdentifiersList);
        });

/**
 *        @swagger
 * '/series/{bbid}/relationships':
 *   get:
 *     tags:
 *       - Lookup Requests
 *     summary: Get list of relationships of an Series by BBID
 *     description: Returns the list of relationships of an Series
 *     operationId: getRelationshipsOfSeriesByBbid
 *     parameters:
 *       - name: bbid
 *         in: path
 *         description: BBID of the Series
 *         required: true
 *         schema:
 *           type: string
 *     responses:
 *       200:
 *         description: List of relationships with BBID of an Series entity
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/Relationships'
 *       404:
 *         description: Series not found
 *       400:
 *         description: Invalid BBID
 */

router.get('/:bbid/relationships',
        makeEntityLoader('Series', utils.relationshipsRelations, seriesError),
        async (req, res) => {
                const seriesRelationshipList = await getEntityRelationships(res.locals.entity);
                return res.status(200).send(seriesRelationshipList);
        });

/**
 *        @swagger
 * '/series':
 *   get:
 *     tags:
 *       - Browse Requests
 *     summary: Gets a list of Series related to another Entity
 *     description: BBID of an Author or an Edition or an EditionGroup or a Publisher or a Work is passed as query parameter and it's Series are fetched
 *     operationId: getRelatedSeriesByBbid
 *     parameters:
 *       - name: author
 *         in: query
 *         description: BBID of the corresponding Author
 *         required: false
 *         schema:
 *           type: string
 *           format: uuid
 *       - name: work
 *         in: query
 *         description: BBID of the corresponding Work
 *         required: false
 *         schema:
 *           type: string
 *           format: uuid
 *       - name: edition
 *         in: query
 *         description: BBID of the corresponding Edition
 *         required: false
 *         schema:
 *           type: string
 *           format: uuid
 *       - name: edition-group
 *         in: query
 *         description: BBID of the corresponding Edition Group
 *         required: false
 *         schema:
 *           type: string
 *           format: uuid
 *       - name: publisher
 *         in: query
 *         description: BBID of the corresponding Publisher
 *         required: false
 *         schema:
 *           type: string
 *           format: uuid
 *       - name: orderingType
 *         in: query
 *         description: filter by Series Ordering Type
 *         required: false
 *         schema:
 *           type: string
 *           enum: [Automatic, Manual]
 *     responses:
 *       200:
 *         description: List of Series related to another Entity
 *         content:
 *           application/json:
 *             schema:
 *               $ref: '#/components/schemas/BrowsedSeries'
 *       404:
 *         description: author/work/edition/edition-group/publisher (other entity) not found
 *       400:
 *         description: Invalid BBID passed in the query params OR Multiple browsed entities passed in parameters
 */

router.get('/',
        formatQueryParameters(),
        validateBrowseRequestQueryParameters(['edition', 'author', 'edition-group', 'work', 'publisher']),
        makeEntityLoader(null, utils.relationshipsRelations, 'Entity not found', true),
        loadEntityRelationshipsForBrowse(),
        async (req, res) => {
                function relationshipsFilterMethod(relatedEntity) {
                        if (req.query.orderingtype) {
                                return toLower(relatedEntity.seriesOrderingType) === toLower(req.query.orderingtype);
                        }
                        return true;
                }

                const seriesRelationshipList = await utils.getBrowsedRelationships(
                        req.app.locals.orm, res.locals, 'Series',
                        getSeriesBasicInfo, seriesBasicRelations, relationshipsFilterMethod
                );

                return res.status(200).send({
                        bbid: req.query.bbid,
                        series: seriesRelationshipList
                });
        });

export default router;

1	/*
2	* Copyright (C) 2021 Akash Gupta
3	*
4	* This program is free software; you can redistribute it and/or modify
5	* it under the terms of the GNU General Public License as published by
6	* the Free Software Foundation; either version 2 of the License, or
7	* (at your option) any later version.
8	*
9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*
14	* You should have received a copy of the GNU General Public License along
15	* with this program; if not, write to the Free Software Foundation, Inc.,
16	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17	*/
18
19	import * as utils from '../helpers/utils';	2✔
20
21	import {formatQueryParameters, loadEntityRelationshipsForBrowse, validateBrowseRequestQueryParameters} from '../helpers/middleware';	2✔
22	import {getEntityAliases, getEntityIdentifiers, getEntityRelationships, getSeriesBasicInfo} from '../helpers/formatEntityData';	2✔
23	import {Router} from 'express';	2✔
24	import {makeEntityLoader} from '../helpers/entityLoader';	2✔
25	import {toLower} from 'lodash';
26
27
28	const router = Router();	2✔
29
30	const seriesBasicRelations = [	2✔
31	'defaultAlias.language',
32	'disambiguation',
33	'seriesOrderingType'
34	];
35
36	const seriesError = 'Series not found';	2✔
37
38	/**
39	*@swagger
40	* components:
41	* schemas:
42	* SeriesDetail:
43	* type: object
44	* properties:
45	* bbid:
46	* type: string
47	* format: uuid
48	* example: '2e5f49a8-6a38-4cc7-97c7-8e624e1fc2c1'
49	* seriesOrderingType:
50	* type: string
51	* example: 'Automatic'
52	* seriesType:
53	* type: string
54	* example: 'Work'
55	* defaultAlias:
56	* $ref: '#/components/schemas/Alias'
57	* disambiguation:
58	* type: string
59	* example: 'series of three epic fantasy'
60	* BrowsedSeries:
61	* type: object
62	* properties:
63	* bbid:
64	* type: string
65	* format: uuid
66	* example: 'f94d74ce-c748-4130-8d59-38b290af8af3'
67	* series:
68	* type: array
69	* items:
70	* type: object
71	* properties:
72	* entity:
73	* $ref: '#/components/schemas/SeriesDetail'
74	* relationships:
75	* type: array
76	* items:
77	* type: object
78	* properties:
79	* relationshipTypeID:
80	* type: number
81	* example: 71
82	* relationshipType:
83	* type: string
84	* example: 'Work Series'
85	*/
86
87
88	/**
89	*@swagger
90	*'/series/{bbid}':
91	* get:
92	* tags:
93	* - Lookup Requests
94	* summary: Lookup Series by BBID
95	* description: Returns the basic details of an Series
96	* operationId: getSeriesByBbid
97	* parameters:
98	* - name: bbid
99	* in: path
100	* description: BBID of the Series
101	* required: true
102	* schema:
103	* type: string
104	* responses:
105	* 200:
106	* description: Basic information of an Series entity
107	* content:
108	* application/json:
109	* schema:
110	* $ref: '#/components/schemas/SeriesDetail'
111	* 404:
112	* description: Series not found
113	* 400:
114	* description: Invalid BBID
115	*/
116
117	router.get('/:bbid',	6✔
118	makeEntityLoader('Series', seriesBasicRelations, seriesError),
119	async (req, res) => {	×
120	const seriesBasicInfo = await getSeriesBasicInfo(res.locals.entity);	×
121	return res.status(200).send(seriesBasicInfo);
122	});
123
124
125	/**
126	* @swagger
127	* '/series/{bbid}/aliases':
128	* get:
129	* tags:
130	* - Lookup Requests
131	* summary: Get list of aliases of an Series by BBID
132	* description: Returns the list of aliases of an Series
133	* operationId: getAliasesOfSeriesByBbid
134	* parameters:
135	* - name: bbid
136	* in: path
137	* description: BBID of the Series
138	* required: true
139	* schema:
140	* type: string
141	* responses:
142	* 200:
143	* description: List of aliases with BBID of an Series entity
144	* content:
145	* application/json:
146	* schema:
147	* $ref: '#/components/schemas/Aliases'
148	* 404:
149	* description: Series not found
150	* 400:
151	* description: Invalid BBID
152	*/
153
154	router.get('/:bbid/aliases',	6✔
155	makeEntityLoader('Series', utils.aliasesRelations, seriesError),
156	async (req, res) => {	×
157	const seriesAliasesList = await getEntityAliases(res.locals.entity);	×
158	return res.status(200).send(seriesAliasesList);
159	});
160
161	/**
162	* @swagger
163	* '/series/{bbid}/identifiers':
164	* get:
165	* tags:
166	* - Lookup Requests
167	* summary: Get list of identifiers of an Series by BBID
168	* description: Returns the list of identifiers of an Series
169	* operationId: getIdentifiersOfSeriesByBbid
170	* parameters:
171	* - name: bbid
172	* in: path
173	* description: BBID of the Series
174	* required: true
175	* schema:
176	* type: string
177	* responses:
178	* 200:
179	* description: List of identifiers with BBID of an Series entity
180	* content:
181	* application/json:
182	* schema:
183	* $ref: '#/components/schemas/Identifiers'
184	* 404:
185	* description: Series not found
186	* 400:
187	* description: Invalid BBID
188	*/
189
190	router.get('/:bbid/identifiers',	6✔
191	makeEntityLoader('Series', utils.identifiersRelations, seriesError),
192	async (req, res) => {	×
193	const seriesIdentifiersList = await getEntityIdentifiers(res.locals.entity);	×
194	return res.status(200).send(seriesIdentifiersList);
195	});
196
197	/**
198	* @swagger
199	* '/series/{bbid}/relationships':
200	* get:
201	* tags:
202	* - Lookup Requests
203	* summary: Get list of relationships of an Series by BBID
204	* description: Returns the list of relationships of an Series
205	* operationId: getRelationshipsOfSeriesByBbid
206	* parameters:
207	* - name: bbid
208	* in: path
209	* description: BBID of the Series
210	* required: true
211	* schema:
212	* type: string
213	* responses:
214	* 200:
215	* description: List of relationships with BBID of an Series entity
216	* content:
217	* application/json:
218	* schema:
219	* $ref: '#/components/schemas/Relationships'
220	* 404:
221	* description: Series not found
222	* 400:
223	* description: Invalid BBID
224	*/
225
226	router.get('/:bbid/relationships',	6✔
227	makeEntityLoader('Series', utils.relationshipsRelations, seriesError),
228	async (req, res) => {	×
229	const seriesRelationshipList = await getEntityRelationships(res.locals.entity);	×
230	return res.status(200).send(seriesRelationshipList);
231	});
232
233	/**
234	* @swagger
235	* '/series':
236	* get:
237	* tags:
238	* - Browse Requests
239	* summary: Gets a list of Series related to another Entity
240	* description: BBID of an Author or an Edition or an EditionGroup or a Publisher or a Work is passed as query parameter and it's Series are fetched
241	* operationId: getRelatedSeriesByBbid
242	* parameters:
243	* - name: author
244	* in: query
245	* description: BBID of the corresponding Author
246	* required: false
247	* schema:
248	* type: string
249	* format: uuid
250	* - name: work
251	* in: query
252	* description: BBID of the corresponding Work
253	* required: false
254	* schema:
255	* type: string
256	* format: uuid
257	* - name: edition
258	* in: query
259	* description: BBID of the corresponding Edition
260	* required: false
261	* schema:
262	* type: string
263	* format: uuid
264	* - name: edition-group
265	* in: query
266	* description: BBID of the corresponding Edition Group
267	* required: false
268	* schema:
269	* type: string
270	* format: uuid
271	* - name: publisher
272	* in: query
273	* description: BBID of the corresponding Publisher
274	* required: false
275	* schema:
276	* type: string
277	* format: uuid
278	* - name: orderingType
279	* in: query
280	* description: filter by Series Ordering Type
281	* required: false
282	* schema:
283	* type: string
284	* enum: [Automatic, Manual]
285	* responses:
286	* 200:
287	* description: List of Series related to another Entity
288	* content:
289	* application/json:
290	* schema:
291	* $ref: '#/components/schemas/BrowsedSeries'
292	* 404:
293	* description: author/work/edition/edition-group/publisher (other entity) not found
294	* 400:
295	* description: Invalid BBID passed in the query params OR Multiple browsed entities passed in parameters
296	*/
297
298	router.get('/',	6✔
299	formatQueryParameters(),
300	validateBrowseRequestQueryParameters(['edition', 'author', 'edition-group', 'work', 'publisher']),
301	makeEntityLoader(null, utils.relationshipsRelations, 'Entity not found', true),
302	loadEntityRelationshipsForBrowse(),
303	async (req, res) => {	×
304	function relationshipsFilterMethod(relatedEntity) {	×
305	if (req.query.orderingtype) {	×
306	return toLower(relatedEntity.seriesOrderingType) === toLower(req.query.orderingtype);	×
307	}
308	return true;	×
309	}
310
311	const seriesRelationshipList = await utils.getBrowsedRelationships(	×
312	req.app.locals.orm, res.locals, 'Series',
313	getSeriesBasicInfo, seriesBasicRelations, relationshipsFilterMethod
314	);
315
316	return res.status(200).send({
317	bbid: req.query.bbid,
318	series: seriesRelationshipList
319	});
320	});
321
322	export default router;	2✔

bookbrainz / bookbrainz-site / 4123

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