Extract dedicated services for GAQ and QC summaries

Author: martinboulais

lib/server/controllers/qcFlag.controller.js

@@ -19,6 +19,8 @@ const { PaginationDto } = require('../../domain/dtos');
 const { ApiConfig } = require('../../config');
 const { countedItemsToHttpView } = require('../utilities/countedItemsToHttpView');
 const { qcFlagService } = require('../services/qualityControlFlag/QcFlagService.js');
+const { gaqService } = require('../services/qualityControlFlag/GaqService.js');
+const { qcFlagSummaryService } = require('../services/qualityControlFlag/QcFlagSummaryService.js');
 
 // eslint-disable-next-line valid-jsdoc
 /**
@@ -324,7 +326,7 @@ const getQcFlagsSummaryHandler = async (req, res) => {
                 mcReproducibleAsNotBad = false,
             } = validatedDTO.query;
 
-            const data = await qcFlagService.getQcFlagsSummary({ dataPassId, simulationPassId, lhcPeriodId }, { mcReproducibleAsNotBad });
+            const data = await qcFlagSummaryService.getQcFlagsSummary({ dataPassId, simulationPassId, lhcPeriodId }, { mcReproducibleAsNotBad });
             res.json({ data });
         } catch (error) {
             updateExpressResponseFromNativeError(res, error);
@@ -349,7 +351,7 @@ const getGaqQcFlagsHandler = async (request, response) => {
         try {
             const { dataPassId, runNumber } = validatedDTO.query;
 
-            const data = await qcFlagService.getGaqFlags(dataPassId, runNumber);
+            const data = await gaqService.getFlagsForDataPassAndRun(dataPassId, runNumber);
             response.json({ data });
         } catch (error) {
             updateExpressResponseFromNativeError(response, error);
@@ -374,7 +376,7 @@ const getGaqSummaryHandler = async (request, response) => {
         try {
             const { dataPassId, mcReproducibleAsNotBad = false } = validatedDTO.query;
 
-            const data = await qcFlagService.getGaqSummary(dataPassId, { mcReproducibleAsNotBad });
+            const data = await gaqService.getSummary(dataPassId, { mcReproducibleAsNotBad });
             response.json({ data });
         } catch (error) {
             updateExpressResponseFromNativeError(response, error);

lib/server/services/qualityControlFlag/GaqService.js

@@ -0,0 +1,113 @@
+/**
+ *  @license
+ *  Copyright CERN and copyright holders of ALICE O2. This software is
+ *  distributed under the terms of the GNU General Public License v3 (GPL
+ *  Version 3), copied verbatim in the file "COPYING".
+ *
+ *  See http://alice-o2.web.cern.ch/license for full licensing information.
+ *
+ *  In applying this license CERN does not waive the privileges and immunities
+ *  granted to it by virtue of its status as an Intergovernmental Organization
+ *  or submit itself to any jurisdiction.
+ */
+import { getOneDataPassOrFail } from '../dataPasses/getOneDataPassOrFail.js';
+import { Op } from 'sequelize';
+import { qcFlagAdapter } from '../../../database/adapters/index.js';
+import { QcFlagRepository } from '../../../database/repositories/index.js';
+import { QcFlagSummaryService } from './QcFlagSummaryService.js';
+
+const QC_SUMMARY_PROPERTIES = {
+    badEffectiveRunCoverage: 'badEffectiveRunCoverage',
+    explicitlyNotBadEffectiveRunCoverage: 'explicitlyNotBadEffectiveRunCoverage',
+    missingVerificationsCount: 'missingVerificationsCount',
+    mcReproducible: 'mcReproducible',
+};
+
+/**
+ * Globally aggregated quality (QC flags aggregated for a predefined list of detectors per runs) service
+ */
+export class GaqService {
+    /**
+     * Get GAQ summary
+     *
+     * @param {number} dataPassId id of data pass id
+     * @param {object} [options] additional options
+     * @param {boolean} [options.mcReproducibleAsNotBad = false] if set to true,
+     * `Limited Acceptance MC Reproducible` flag type is treated as good one
+     * @return {Promise<GaqSummary[]>} Resolves with the GAQ Summary
+     */
+    async getSummary(dataPassId, { mcReproducibleAsNotBad = false } = {}) {
+        await getOneDataPassOrFail({ id: dataPassId });
+        const runGaqSubSummaries = await QcFlagRepository.getRunGaqSubSummaries(dataPassId, { mcReproducibleAsNotBad });
+
+        const summary = {};
+        const flagsAndVerifications = {};
+
+        // Fold list of subSummaries into one summary
+        for (const subSummary of runGaqSubSummaries) {
+            const {
+                runNumber,
+                flagsIds,
+                verifiedFlagsIds,
+            } = subSummary;
+
+            if (!summary[runNumber]) {
+                summary[runNumber] = { [QC_SUMMARY_PROPERTIES.mcReproducible]: false };
+            }
+            if (!flagsAndVerifications[runNumber]) {
+                flagsAndVerifications[runNumber] = {};
+            }
+
+            const runSummary = summary[runNumber];
+
+            const distinctRunFlagsIds = flagsAndVerifications[runNumber]?.distinctFlagsIds ?? [];
+            const distinctRunVerifiedFlagsIds = flagsAndVerifications[runNumber]?.distinctVerifiedFlagsIds ?? [];
+
+            flagsAndVerifications[runNumber] = {
+                distinctFlagsIds: new Set([...distinctRunFlagsIds, ...flagsIds]),
+                distinctVerifiedFlagsIds: new Set([...distinctRunVerifiedFlagsIds, ...verifiedFlagsIds]),
+            };
+
+            QcFlagSummaryService.mergeIntoSummaryUnit(runSummary, subSummary);
+        }
+
+        for (const [runNumber, { distinctFlagsIds, distinctVerifiedFlagsIds }] of Object.entries(flagsAndVerifications)) {
+            summary[runNumber][QC_SUMMARY_PROPERTIES.missingVerificationsCount] = distinctFlagsIds.size - distinctVerifiedFlagsIds.size;
+        }
+
+        return summary;
+    }
+
+    /**
+     * Find QC flags in GAQ effective periods for given data pass and run
+     *
+     * @param {number} dataPassId id od data pass
+     * @param {number} runNumber run number
+     * @return {Promise<GaqFlags[]>} promise of aggregated QC flags
+     */
+    async getFlagsForDataPassAndRun(dataPassId, runNumber) {
+        const gaqPeriods = await QcFlagRepository.findGaqPeriods(dataPassId, runNumber);
+        const qcFlags = (await QcFlagRepository.findAll({
+            where: { id: { [Op.in]: gaqPeriods.flatMap(({ contributingFlagIds }) => contributingFlagIds) } },
+            include: [
+                { association: 'flagType' },
+                { association: 'createdBy' },
+                { association: 'verifications', include: [{ association: 'createdBy' }] },
+            ],
+        })).map(qcFlagAdapter.toEntity);
+
+        const idToFlag = Object.fromEntries(qcFlags.map((flag) => [flag.id, flag]));
+
+        return gaqPeriods.map(({
+            contributingFlagIds,
+            from,
+            to,
+        }) => ({
+            from,
+            to,
+            contributingFlags: contributingFlagIds.map((id) => idToFlag[id]),
+        }));
+    }
+}
+
+export const gaqService = new GaqService();