[O2B-905] Add endpoint to fetch all replies to a given log using its id (#1423)

* O2B-905: Added endpoint to fetch all replies to a given log using its id

* O2B-905: Service tests added

* O2B-905: Code review tasks implemented, not final.

* O2B-905: Log API tests updated

* [O2B-905] last code review comments implemented

* [O2B-905] Code review changes, dto, naming

Author: AnoeBanoe

lib/server/controllers/logs.controller.js

@@ -37,6 +37,7 @@ const { updateExpressResponseFromNativeError } = require('../express/updateExpre
 const { countedItemsToHttpView } = require('../utilities/countedItemsToHttpView');
 const { PaginationDto } = require('../../domain/dtos');
 const { DtoFactory } = require('../../domain/dtos/DtoFactory');
+const EntityIdDto = require('../../domain/dtos/EntityIdDto');
 
 /**
  * Create a new log
@@ -286,14 +287,9 @@ const getLogById = async (request, response, next) => {
     }
 };
 
+// eslint-disable-next-line valid-jsdoc
 /**
  * Get all root logs
- *
- * @param {Object} request The *request* object represents the HTTP request and has properties for the request query
- *                         string, parameters, body, HTTP headers, and so on.
- * @param {Object} response The *response* object represents the HTTP response that an Express app sends when it gets an
- *                          HTTP request.
- * @returns {undefined}
  */
 const getRootLogsHandler = async (request, response) => {
     const requestDto = await dtoValidator(
@@ -320,6 +316,33 @@ const getRootLogsHandler = async (request, response) => {
     }
 };
 
+// eslint-disable-next-line valid-jsdoc
+/**
+ * Get all child logs by parent id
+ */
+const getChildLogsByParentIdHandler = async (request, response) => {
+    const requestDto = await dtoValidator(
+        DtoFactory.paramsOnly({
+            logId: EntityIdDto,
+        }),
+        request,
+        response,
+    );
+
+    if (requestDto) {
+        try {
+            const { params: { logId: parentLogId } } = requestDto;
+            const childLogs = await logService.getChildLogsByParentId(parentLogId);
+
+            await response.status(200).json({
+                data: childLogs,
+            });
+        } catch (error) {
+            updateExpressResponseFromNativeError(response, error);
+        }
+    }
+};
+
 module.exports = {
     createLog,
     getAllAttachments,
@@ -330,4 +353,5 @@ module.exports = {
     getLogTree,
     patchRun,
     getRootLogsHandler,
+    getChildLogsByParentIdHandler,
 };

lib/server/routers/logs.router.js

@@ -61,6 +61,11 @@ module.exports = {
                     path: 'tree',
                     controller: LogsController.getLogTree,
                 },
+                {
+                    method: 'get',
+                    path: 'children',
+                    controller: LogsController.getChildLogsByParentIdHandler,
+                },
             ],
         },
     ],

lib/server/services/log/LogService.js

@@ -85,6 +85,19 @@ class LogService {
         return { count, logIds };
     }
 
+    /**
+     * Retrieves a list of replies to a log based off the given logId
+     * @param {number} logId The id of the log of which the child logs are retrieved
+     * @return {Promise<Log[]>} A promise that resolves with the replies logs
+     */
+    async getChildLogsByParentId(logId) {
+        const childLogQueryBuilder = this._createFindQueryBuilder()
+            .where('parentLogId').is(logId);
+
+        const childLogs = await LogRepository.findAll(childLogQueryBuilder);
+        return this._prepareLogsEntities(childLogs);
+    }
+
     /**
      * Returns all the logs related to a given LHC fill
      *
@@ -131,17 +144,36 @@ class LogService {
      * @return {Promise<Log[]>} the resulting logs
      */
     async _getAllByIds(logIds) {
-        const logQueryBuilder = dataSource.createQueryBuilder()
-            .where('id').oneOf(...logIds)
-            .include({ association: 'runs', attributes: ['id', 'runNumber'] })
-            .include({ association: 'lhcFills', attributes: ['fillNumber'] })
-            .include({ association: 'environments', attributes: ['id'] });
+        const logQueryBuilder = this._createFindQueryBuilder();
 
+        logQueryBuilder.where('id').oneOf(...logIds);
         const logs = await LogRepository.findAll(logQueryBuilder);
+        return this._prepareLogsEntities(logs);
+    }
+
+    /**
+     * Return all the logs after preparing them to entities and adding childrenCount
+     *
+     * @param {SequelizeLog[]} logs the list of logs to prepare
+     * @return {Promise<Log[]>} the resulting prepared logs
+     */
+    _prepareLogsEntities(logs) {
         const logEntities = logs.map(logAdapter.toEntity);
         return LogRepository.addChildrenCountByLog(logEntities);
     }
 
+    /**
+     * Return a standard log QueryBuilder
+     *
+     * @return {QueryBuilder} the resulting QueryBuilder
+     */
+    _createFindQueryBuilder() {
+        return dataSource.createQueryBuilder()
+            .include({ association: 'runs', attributes: ['id', 'runNumber'] })
+            .include({ association: 'lhcFills', attributes: ['fillNumber'] })
+            .include({ association: 'environments', attributes: ['id'] });
+    }
+
     /**
      * Create a log in the database and return the created instance
      *

test/api/logs.test.js

@@ -46,6 +46,15 @@ module.exports = () => {
         }
     });
 
+    const logWithChildren = {
+        id: 117,
+        expectedAmountOfChildren: 2,
+    };
+    const logWithoutChildren = {
+        id: 122,
+        expectedAmountOfChildren: 0,
+    };
+
     let logWithAttachmentsId = 0;
     let attachmentId = 0;
 
@@ -1575,4 +1584,27 @@ module.exports = () => {
                 });
         });
     });
+
+    describe('GET /api/logs/:logId/children', () => {
+        it('should return the correct child logs of a parent log', async () => {
+            const response = await request(server).get(`/api/logs/${logWithChildren.id}/children`);
+            expect(response.status).to.equal(200);
+            expect(response.body.data.length).to.equal(logWithChildren.expectedAmountOfChildren);
+            expect(response.body.data.every((log) => log.parentLogId === logWithChildren.id));
+        });
+
+        it('should return 400 if the log id is not a number', async () => {
+            const response = await request(server).get('/api/logs/abc/children');
+            const { errors } = response.body;
+            const titleError = errors.find((err) => err.source.pointer === '/data/attributes/params/logId');
+            expect(response.status).to.equal(400);
+            expect(titleError.detail).to.equal('"params.logId" must be a number');
+        });
+
+        it('should return an empty array if the log has no children', async () => {
+            const response = await request(server).get(`/api/logs/${logWithoutChildren.id}/children`);
+            expect(response.status).to.equal(200);
+            expect(response.body.data).to.be.empty;
+        });
+    });
 };

test/lib/server/services/log/LogService.test.js

@@ -66,4 +66,28 @@ module.exports = () => {
         expect(rootLogsFirstPage.logs[0].id).to.equal(1);
         expect(rootLogsSecondPage.logs[0].id).to.equal(5);
     });
+
+    it('Should successfully return child logs of their parent log', async () => {
+        const logWithChildrenId = 117;
+        const expectedAmountOfChildren = 2;
+        const childLogs = await logService.getChildLogsByParentId(logWithChildrenId);
+
+        expect(childLogs.length).to.equal(expectedAmountOfChildren);
+        childLogs.forEach((log) => expect(log.parentLogId === logWithChildrenId));
+    });
+
+    it('Should successfully return an empty array if parent has no children', async () => {
+        const logWithoutChildrenId = 122;
+        const childLogs = await logService.getChildLogsByParentId(logWithoutChildrenId);
+
+        expect(childLogs).to.be.empty;
+    });
+
+    it('Should successfully return correct count when children are not found', async () => {
+        const logWithoutChildrenId = 122;
+        const expectedAmountOfChildren = 0;
+        const childLogs = await logService.getChildLogsByParentId(logWithoutChildrenId);
+
+        expect(childLogs.length).to.equal(expectedAmountOfChildren);
+    });
 };