include qcFlags

Author: xsalonx

lib/database/adapters/RunAdapter.js

@@ -75,6 +75,11 @@ class RunAdapter {
          */
         this.userAdapter = null;
 
+        /**
+         * @type {QcFlagAdapter|null}
+         */
+        this.qcFlagAdapter = null;
+
         this.toEntity = this.toEntity.bind(this);
         this.toDatabase = this.toDatabase.bind(this);
         this.toMinifiedEntity = this.toMinifiedEntity.bind(this);
@@ -167,6 +172,7 @@ class RunAdapter {
             phaseShiftAtEndBeam2,
             userStart,
             userStop,
+            qcFlags,
         } = databaseObject;
 
         /**
@@ -281,6 +287,8 @@ class RunAdapter {
             entityObject.muInelasticInteractionRate = null;
         }
 
+        entityObject.qcFlags = qcFlags ? qcFlags.map(this.qcFlagAdapter.toEntity) : [];
+
         return entityObject;
     }
 

lib/database/adapters/index.js

@@ -139,6 +139,7 @@ runAdapter.logAdapter = logAdapter;
 runAdapter.runTypeAdapter = runTypeAdapter;
 runAdapter.tagAdapter = tagAdapter;
 runAdapter.userAdapter = userAdapter;
+runAdapter.qcFlagAdapter = qcFlagAdapter;
 
 simulationPassQcFlagAdapter.simulationPassAdapter = simulationPassAdapter;
 simulationPassQcFlagAdapter.qcFlagAdapter = qcFlagAdapter;

lib/domain/dtos/filters/RunFilterDto.js

@@ -90,6 +90,7 @@ exports.RunFilterDto = Joi.object({
     odcTopologyFullName: Joi.string().trim(),
     detectors: DetectorsFilterDto,
     lhcPeriods: Joi.string().trim(),
+    lhcPeriodIds: Joi.array().items(Joi.number().positive().integer()),
     dataPassIds: Joi.array().items(Joi.number()),
     simulationPassIds: Joi.array().items(Joi.number()),
     runTypes: CustomJoi.stringArray().items(Joi.string()).single().optional(),

lib/usecases/run/GetAllRunsUseCase.js

@@ -51,6 +51,7 @@ class GetAllRunsUseCase {
                 epn,
                 fillNumbers,
                 lhcPeriods,
+                lhcPeriodIds,
                 dataPassIds,
                 simulationPassIds,
                 nDetectors,
@@ -340,6 +341,19 @@ class GetAllRunsUseCase {
                 });
             }
 
+            if (lhcPeriodIds) {
+                const runNumbers = (await RunRepository.findAll({
+                    attributes: ['runNumber'],
+                    raw: true,
+                    include: {
+                        association: 'lhcPeriod',
+                        attributes: [],
+                        where: { id: { [Op.in]: lhcPeriodIds } },
+                    },
+                })).map(({ runNumber }) => runNumber);
+                filteringQueryBuilder.where('runNumber').oneOf(...runNumbers);
+            }
+
             if (dataPassIds) {
                 const runNumbers = (await RunRepository.findAll({
                     attributes: ['runNumber'],
@@ -460,6 +474,71 @@ class GetAllRunsUseCase {
             fetchQueryBuilder.orderBy(property, sort[property]);
         }
 
+        if (filter?.include?.effectiveQcFlags) {
+            const [dataPassId] = filter?.dataPassIds ?? [];
+            const [simulationPassId] = filter?.simulationPassIds ?? [];
+            const [lhcPeriodId] = filter?.lhcPeriodIds ?? [];
+
+            if (Boolean(dataPassId) + Boolean(simulationPassId) + Boolean(lhcPeriodId) > 1) {
+                throw new BadParameterError('If including QC flags, one and exactly one'
+                    + 'of `dataPassId`, `simulationPassId` and `lhcPeriodId` is required');
+            }
+
+            if (dataPassId) {
+                fetchQueryBuilder.include({
+                    association: 'qcFlags',
+                    required: false,
+                    include: [
+                        {
+                            association: 'dataPasses',
+                            required: true,
+                            where: { id: dataPassId },
+                        },
+                        {
+                            association: 'effectivePeriods',
+                            required: true,
+                        },
+                    ],
+                });
+            } else if (simulationPassId) {
+                fetchQueryBuilder.include({
+                    association: 'qcFlags',
+                    required: false,
+                    include: [
+                        {
+                            association: 'simulationPasses',
+                            required: true,
+                            where: { id: simulationPassId },
+                        },
+                        {
+                            association: 'effectivePeriods',
+                            required: true,
+                        },
+                    ],
+                });
+            } else {
+                fetchQueryBuilder.include({
+                    association: 'qcFlags',
+                    required: false,
+                    include: [
+                        {
+                            association: 'simulationPasses',
+                            required: false,
+                        },
+                        {
+                            association: 'dataPasses',
+                            required: false,
+                        },
+                        {
+                            association: 'effectivePeriods',
+                            required: true,
+                        },
+                    ],
+                }).where('$qcFlags.dataPasses.id$').is(null)
+                    .where('$qcFlags.simulationPasses.id$').is(null);
+            }
+        }
+
         const runs = (await RunRepository.findAll(fetchQueryBuilder)).map(runAdapter.toEntity);
 
         return { count, runs };