feat: create summary views for runs

Author: NarrowsProjects

lib/database/adapters/EorReasonAdapter.js

@@ -25,6 +25,7 @@ class EorReasonAdapter {
         this.reasonTypeAdapter = null;
 
         this.toEntity = this.toEntity.bind(this);
+        this.toSummary = this.toSummary.bind(this);
         this.toDatabase = this.toDatabase.bind(this);
     }
 
@@ -34,21 +35,31 @@ class EorReasonAdapter {
      * @returns {EorReason} Converted entity object.
      */
     toEntity({ id, description, runId, reasonTypeId, reasonType, lastEditedName, createdAt, updatedAt }) {
-        const entityObject = {
+        return {
+            ...this.toSummary({ description, reasonType }),
             id,
-            description,
-            lastEditedName,
-            reasonTypeId,
             runId,
+            reasonTypeId,
+            lastEditedName,
             createdAt: new Date(createdAt).getTime(),
             updatedAt: new Date(updatedAt).getTime(),
         };
+    }
+
+    /**
+     * Converts the given end of run reason database object to an summary reason object.
+     * @param {SequelizeEorReason} databaseObject Object to convert.
+     * @returns {EorReason} Converted summary object.
+     */
+    toSummary({ description, reasonType }) {
+        const entityObject = { description };
 
         if (reasonType) {
             const reasonTypeEntity = this.reasonTypeAdapter.toEntity(reasonType);
             entityObject.category = reasonTypeEntity.category;
             entityObject.title = reasonTypeEntity.title;
         }
+
         return entityObject;
     }
 

lib/database/adapters/QcFlagAdapter.js

@@ -20,13 +20,31 @@ class QcFlagAdapter {
      */
     constructor() {
         this.toEntity = this.toEntity.bind(this);
+        this.toSummary = this.toSummary.bind(this);
 
         this.qcFlagTypeAdapter = null;
         this.qcFlagVerificationAdapter = null;
         this.qcFlagEffectivePeriodAdapter = null;
         this.userAdapter = null;
     }
 
+    /**
+     * Converts the given database object to an summary object.
+     *
+     * @param {SequelizeQcFlag} databaseObject Object to convert.
+     * @returns {QcFlag} Converted summary object.
+     */
+    toSummary(databaseObject) {
+        const { effectivePeriods = [], detectorId, flagType, id } = databaseObject;
+
+        return {
+            id,
+            dplDetectorId: detectorId,
+            flagType: flagType ? { name: flagType.name } : null,
+            effectivePeriods: effectivePeriods.map(this.qcFlagEffectivePeriodAdapter.toEntity),
+        };
+    }
+
     /**
      * Converts the given database object to an entity object.
      *

lib/database/adapters/RunAdapter.js

@@ -87,6 +87,7 @@ class RunAdapter {
         this.qcFlagAdapter = null;
 
         this.toEntity = this.toEntity.bind(this);
+        this.toSummary = this.toSummary.bind(this);
         this.toLhcFillSummary = this.toLhcFillSummary.bind(this);
         this.toDatabase = this.toDatabase.bind(this);
         this.toMinifiedEntity = this.toMinifiedEntity.bind(this);
@@ -119,6 +120,26 @@ class RunAdapter {
         }
     }
 
+    /**
+     * Adds detectors along with their qualities to an entity
+     *
+     * @param {Detector[]} detectors the list of detector models
+     * @param {object} entityObject the entity object that is to be modified
+     * @param {boolean} [addDetectorQuality = true] if detectorQuality should be included
+     * @returns {void}
+     */
+    _computeQcFlags(qcFlags = [], entityObject, isSummary = false) {
+        const adaptedQcFlags = isSummary
+            ? qcFlags.map(this.qcFlagAdapter.toSummary)
+            : qcFlags.map(this.qcFlagAdapter.toEntity);
+
+        entityObject.qcFlags = adaptedQcFlags.reduce((acc, qcFlag) => {
+            acc[qcFlag.dplDetectorId] = acc[qcFlag.dplDetectorId] ?? [];
+            acc[qcFlag.dplDetectorId].push(qcFlag);
+            return acc;
+        }, {});
+    }
+
     /**
      * Converts the given database object to an entity object.
      *
@@ -311,12 +332,91 @@ class RunAdapter {
             ? lhcFill.collidingBunchesCount ?? extractNumberOfCollidingLhcBunchCrossings(lhcFill.fillingSchemeName)
             : null;
 
-        const adaptedQcFlags = qcFlags ? qcFlags.map(this.qcFlagAdapter.toEntity) : [];
-        entityObject.qcFlags = adaptedQcFlags.reduce((acc, qcFlag) => {
-            acc[qcFlag.dplDetectorId] = acc[qcFlag.dplDetectorId] ?? [];
-            acc[qcFlag.dplDetectorId].push(qcFlag);
-            return acc;
-        }, {});
+        this._computeQcFlags(qcFlags, entityObject);
+
+        return entityObject;
+    }
+
+    /**
+     * Converts the given database object to an summary object.
+     *
+     * @param {SequelizeRun} databaseObject Object to convert.
+     * @returns {Run} Converted summary object.
+     */
+    toSummary(databaseObject) {
+        const {
+            detectors,
+            eorReasons,
+            runNumber,
+            timeO2Start,
+            timeO2End,
+            timeTrgStart,
+            timeTrgEnd,
+            firstTfTimestamp,
+            lastTfTimestamp,
+            qcTimeStart,
+            qcTimeEnd,
+            inelasticInteractionRateAvg,
+            inelasticInteractionRateAtStart,
+            inelasticInteractionRateAtMid,
+            inelasticInteractionRateAtEnd,
+            aliceL3Polarity,
+            aliceL3Current,
+            aliceDipolePolarity,
+            aliceDipoleCurrent,
+            qcFlags = [],
+        } = databaseObject;
+
+        /**
+         * @type {Run}
+         */
+        const entityObject = {
+            runNumber,
+            timeO2Start: timeO2Start ? new Date(timeO2Start).getTime() : timeO2Start,
+            timeO2End: timeO2End ? new Date(timeO2End).getTime() : timeO2End,
+            timeTrgStart: timeTrgStart ? new Date(timeTrgStart).getTime() : timeTrgStart,
+            timeTrgEnd: timeTrgEnd ? new Date(timeTrgEnd).getTime() : timeTrgEnd,
+            firstTfTimestamp: firstTfTimestamp ? new Date(firstTfTimestamp).getTime() : firstTfTimestamp,
+            lastTfTimestamp: lastTfTimestamp ? new Date(lastTfTimestamp).getTime() : lastTfTimestamp,
+            qcTimeStart: qcTimeStart ? new Date(qcTimeStart).getTime() : qcTimeStart,
+            qcTimeEnd: qcTimeEnd ? new Date(qcTimeEnd).getTime() : qcTimeEnd,
+            id: databaseObject.id,
+            runDuration: databaseObject.runDuration,
+            environmentId: databaseObject.environmentId,
+            runType: databaseObject.runType,
+            definition: databaseObject.definition,
+            calibrationStatus: databaseObject.calibrationStatus,
+            runQuality: databaseObject.runQuality,
+            nDetectors: databaseObject.nDetectors,
+            nFlps: databaseObject.nFlps,
+            nEpns: databaseObject.nEpns,
+            dd_flp: databaseObject.dd_flp,
+            dcs: databaseObject.dcs,
+            epn: databaseObject.epn,
+            epnTopology: databaseObject.epnTopology,
+            nSubtimeframes: databaseObject.nSubtimeframes,
+            bytesReadOut: databaseObject.bytesReadOut,
+            fillNumber: databaseObject.fillNumber,
+            lhcBeamMode: databaseObject.lhcBeamMode,
+            odcTopologyFullName: databaseObject.odcTopologyFullName,
+            triggerValue: databaseObject.triggerValue,
+            tags: databaseObject.tags,
+            pdpBeamType: databaseObject.pdpBeamType,
+            lhcPeriod: databaseObject.lhcPeriod,
+            aliceL3Polarity,
+            aliceL3Current,
+            aliceDipolePolarity,
+            aliceDipoleCurrent,
+        };
+
+        entityObject.eorReasons = eorReasons ? eorReasons.map(this.eorReasonAdapter.toSummary) : [];
+        entityObject.inelasticInteractionRateAvg = inelasticInteractionRateAvg;
+        entityObject.inelasticInteractionRateAtStart = inelasticInteractionRateAtStart;
+        entityObject.inelasticInteractionRateAtMid = inelasticInteractionRateAtMid;
+        entityObject.inelasticInteractionRateAtEnd = inelasticInteractionRateAtEnd;
+
+        this._addDetectorsToObject(detectors, entityObject);
+        this._computeQcFlags(qcFlags, entityObject, true);
 
         return entityObject;
     }

lib/server/views/runs/summary.js

@@ -0,0 +1,73 @@
+/**
+ * @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.
+ */
+
+export const runSummary = {
+    attributes: [
+        'id',
+        'runNumber',
+        'nDetectors',
+        'lhcBeamMode',
+        'timeO2Start',
+        'timeTrgEnd',
+        'timeTrgStart',
+        'timeO2End',
+        'firstTfTimestamp',
+        'lastTfTimestamp',
+        'triggerValue',
+        'runDuration',
+        'definition',
+        'calibrationStatus',
+        'environmentId',
+        'runQuality',
+        'nEpns',
+        'pdpBeamType',
+        'nFlps',
+        'nSubtimeframes',
+        'bytesReadOut',
+        'dd_flp',
+        'dcs',
+        'epn',
+        'qcTimeStart',
+        'qcTimeEnd',
+        'epnTopology',
+        'odcTopologyFullName',
+        'inelasticInteractionRateAvg',
+        'inelasticInteractionRateAtStart',
+        'inelasticInteractionRateAtMid',
+        'inelasticInteractionRateAtEnd',
+        'aliceDipolePolarity',
+        'aliceDipoleCurrent',
+        'aliceL3Polarity',
+        'aliceL3Current',
+        'fillNumber',
+    ],
+    include: [
+        { association: 'runType', attributes: ['name'] },
+        { association: 'tags', attributes: ['text', 'id'] },
+        {
+            association: 'detectors',
+            attributes: ['name'],
+            through: {
+                attributes: ['quality'],
+            },
+        },
+        {
+            association: 'eorReasons',
+            attributes: ['description'],
+            include: {
+                association: 'reasonType',
+            },
+        },
+        { association: 'lhcPeriod', attributes: ['name'] },
+    ],
+};

lib/usecases/run/GetAllRunsUseCase.js

@@ -26,6 +26,7 @@ const { DetectorType } = require('../../domain/enums/DetectorTypes.js');
 const { unpackNumberRange } = require('../../utilities/rangeUtils.js');
 const { splitStringToStringsTrimmed } = require('../../utilities/stringUtils.js');
 const { setTimeRangeQuery } = require('../../utilities/setTimeRangeQuery.js');
+const { runSummary } = require('../../server/views/runs/summary.js');
 
 /**
  * GetAllRunsUseCase
@@ -491,18 +492,9 @@ class GetAllRunsUseCase {
         const { count, rows } = await RunRepository.findAndCountAll(filteringQueryBuilder);
 
         const fetchQueryBuilder = new QueryBuilder();
-        fetchQueryBuilder.include({ association: 'runType' });
-        fetchQueryBuilder.include({ association: 'lhcFill' });
-        fetchQueryBuilder.include({ association: 'tags' });
-        fetchQueryBuilder.include({ association: 'detectors' });
-        fetchQueryBuilder.include({
-            association: 'eorReasons',
-            include: {
-                association: 'reasonType',
-                attributes: ['category', 'title'],
-            },
-        });
-        fetchQueryBuilder.include({ association: 'lhcPeriod' });
+        fetchQueryBuilder.selectAttributes([...runSummary.attributes]);
+        fetchQueryBuilder.includeAll([...runSummary.include]);
+
         fetchQueryBuilder.where('id').oneOf(...rows.map(({ id }) => id));
         for (const property in sort) {
             fetchQueryBuilder.orderBy(property, sort[property]);
@@ -524,6 +516,7 @@ class GetAllRunsUseCase {
 
             const qcFlagsAssociationDef = {
                 association: 'qcFlags',
+                attributes: ['id', 'detectorId'],
                 required: false,
                 separate: true,
                 order: [['from', 'ASC']],
@@ -535,10 +528,10 @@ class GetAllRunsUseCase {
                     )`),
                 ] },
                 include: [
-                    { association: 'effectivePeriods', required: true, separate: true },
-                    { association: 'flagType' },
-                    { association: 'detector', required: true },
-                    { association: 'createdBy' },
+                    { association: 'effectivePeriods', required: true, separate: true, attributes: ['from', 'to'] },
+                    { association: 'flagType', attributes: ['name'] },
+                    { association: 'detector', attributes: ['name'], required: true },
+                    { association: 'createdBy', attributes: [], required: true },
                 ],
             };
 
@@ -557,9 +550,9 @@ class GetAllRunsUseCase {
             }
         }
 
-        const runs = (await RunRepository.findAll(fetchQueryBuilder)).map(runAdapter.toEntity);
+        const runs = await RunRepository.findAll(fetchQueryBuilder);
 
-        return { count, runs };
+        return { count, runs: runs.map(runAdapter.toSummary) };
     }
 }