Merge branch 'main' into improv/O2B-1534/Migrate-Log-Overview-to-use-FilteringModel-pattern

Author: NarrowsProjects

lib/domain/dtos/filters/LhcFillsFilterDto.js

@@ -14,6 +14,7 @@ const Joi = require('joi');
 const { validateRange, RANGE_INVALID } = require('../../../utilities/rangeUtils');
 const { validateBeamTypes, BEAM_TYPE_INVALID } = require('../../../utilities/beamTypeUtils');
 const { validateTimeDuration } = require('../../../utilities/validateTime');
+const { FromToFilterDto } = require('./FromToFilterDto.js');
 
 exports.LhcFillsFilterDto = Joi.object({
     hasStableBeams: Joi.boolean(),
@@ -23,6 +24,8 @@ exports.LhcFillsFilterDto = Joi.object({
     }),
     runDuration: validateTimeDuration,
     beamDuration: validateTimeDuration,
+    stableBeamsStart: FromToFilterDto,
+    stableBeamsEnd: FromToFilterDto,
     schemeName: Joi.string().trim().max(64),
     beamTypes: Joi.string()
         .trim()

lib/public/views/LhcFills/ActiveColumns/lhcFillsActiveColumns.js

@@ -28,6 +28,7 @@ import { fillNumberFilter } from '../../../components/Filters/LhcFillsFilter/fil
 import { durationFilter } from '../../../components/Filters/LhcFillsFilter/durationFilter.js';
 import { beamTypeFilter } from '../../../components/Filters/LhcFillsFilter/beamTypeFilter.js';
 import { schemeNameFilter } from '../../../components/Filters/LhcFillsFilter/schemeNameFilter.js';
+import { timeRangeFilter } from '../../../components/Filters/common/filters/timeRangeFilter.js';
 
 /**
  * List of active columns for a lhc fills table
@@ -65,6 +66,14 @@ export const lhcFillsActiveColumns = {
         visible: true,
         size: 'w-8',
         format: (timestamp) => formatTimestamp(timestamp, false),
+
+        /**
+         * Stable Beam start filter component
+         *
+         * @param {RunsOverviewModel} lhcFillsOverviewModel the lhcFills overview model
+         * @return {Component} the filter component
+         */
+        filter: (lhcFillsOverviewModel) => timeRangeFilter(lhcFillsOverviewModel.filteringModel.get('stableBeamsStart').timeRangeInputModel),
         profiles: {
             lhcFill: true,
             environment: true,
@@ -80,6 +89,14 @@ export const lhcFillsActiveColumns = {
         visible: true,
         size: 'w-8',
         format: (timestamp) => formatTimestamp(timestamp, false),
+
+        /**
+         * Stable Beam end filter component
+         *
+         * @param {LhcFillsOverviewModel} lhcFillsOverviewModel the lhcFills overview model
+         * @return {Component} the filter component
+         */
+        filter: (lhcFillsOverviewModel) => timeRangeFilter(lhcFillsOverviewModel.filteringModel.get('stableBeamsEnd').timeRangeInputModel),
         profiles: {
             lhcFill: true,
             environment: true,

lib/public/views/LhcFills/Overview/LhcFillsOverviewModel.js

@@ -19,6 +19,7 @@ import { OverviewPageModel } from '../../../models/OverviewModel.js';
 import { addStatisticsToLhcFill } from '../../../services/lhcFill/addStatisticsToLhcFill.js';
 import { BeamTypeFilterModel } from '../../../components/Filters/LhcFillsFilter/BeamTypeFilterModel.js';
 import { TextComparisonFilterModel } from '../../../components/Filters/common/filters/TextComparisonFilterModel.js';
+import { TimeRangeFilterModel } from '../../../components/Filters/RunsFilter/TimeRangeFilter.js';
 
 /**
  * Model for the LHC fills overview page
@@ -39,6 +40,8 @@ export class LhcFillsOverviewModel extends OverviewPageModel {
             beamDuration: new TextComparisonFilterModel(),
             runDuration: new TextComparisonFilterModel(),
             hasStableBeams: new StableBeamFilterModel(),
+            stableBeamsStart: new TimeRangeFilterModel(),
+            stableBeamsEnd: new TimeRangeFilterModel(),
             beamTypes: new BeamTypeFilterModel(),
             schemeName: new RawTextFilterModel(),
         });

lib/usecases/environment/GetAllEnvironmentsUseCase.js

@@ -69,18 +69,11 @@ class GetAllEnvironmentsUseCase {
         const { filter, page = {} } = query;
         const { limit = ApiConfig.pagination.limit, offset = 0 } = page;
 
-        /**
-         * Prepare a query builder with ordering, limit and offset
-         *
-         * @return {QueryBuilder} the created query builder
-         */
-        const prepareQueryBuilder = () => dataSource.createQueryBuilder()
+        const queryBuilder = dataSource.createQueryBuilder()
             .orderBy('updatedAt', 'desc')
             .limit(limit)
             .offset(offset);
 
-        const fetchQueryBuilder = prepareQueryBuilder();
-
         if (filter) {
             const {
                 ids: idsExpression,
@@ -90,38 +83,36 @@ class GetAllEnvironmentsUseCase {
                 created,
             } = filter;
 
-            const filterQueryBuilder = prepareQueryBuilder();
-
             if (created) {
                 const from = created.from !== undefined ? created.from : 0;
                 const to = created.to !== undefined ? created.to : Date.now();
-                filterQueryBuilder.where('createdAt').between(from, to);
+                queryBuilder.where('createdAt').between(from, to);
             }
 
             if (idsExpression) {
                 const filters = idsExpression.split(',').map((id) => id.trim());
 
                 // Filter should be like with only one filter
                 if (filters.length === 1) {
-                    filterQueryBuilder.where('id').substring(filters[0]);
+                    queryBuilder.where('id').substring(filters[0]);
                 }
 
                 // Filters should be exact with more than one filter
                 if (filters.length > 1) {
-                    filterQueryBuilder.andWhere({ id: { [Op.in]: filters } });
+                    queryBuilder.andWhere({ id: { [Op.in]: filters } });
                 }
             }
 
             if (currentStatusExpression) {
                 const filters = currentStatusExpression.split(',').map((status) => status.trim());
 
                 // Filter the environments by current status using the subquery
-                filterQueryBuilder.literalWhere(
+                queryBuilder.literalWhere(
                     `${ENVIRONMENT_LATEST_HISTORY_ITEM_SUBQUERY} IN (:filters)`,
                     { filters },
                 );
 
-                filterQueryBuilder.includeAttribute({
+                queryBuilder.includeAttribute({
                     query: ENVIRONMENT_LATEST_HISTORY_ITEM_SUBQUERY,
                     alias: 'currentStatus',
                 });
@@ -157,7 +148,7 @@ class GetAllEnvironmentsUseCase {
                      * Use OR condition to match subsequences ending with either DESTROYED or DONE
                      * Filter the environments by using LIKE for subsequence matching
                      */
-                    filterQueryBuilder.literalWhere(
+                    queryBuilder.literalWhere(
                         `(${ENVIRONMENT_STATUS_HISTORY_SUBQUERY} LIKE :statusFiltersWithDestroyed OR ` +
                         `${ENVIRONMENT_STATUS_HISTORY_SUBQUERY} LIKE :statusFiltersWithDone)`,
                         {
@@ -166,17 +157,17 @@ class GetAllEnvironmentsUseCase {
                         },
                     );
 
-                    filterQueryBuilder.includeAttribute({
+                    queryBuilder.includeAttribute({
                         query: ENVIRONMENT_STATUS_HISTORY_SUBQUERY,
                         alias: 'statusHistory',
                     });
                 } else {
-                    filterQueryBuilder.literalWhere(
+                    queryBuilder.literalWhere(
                         `${ENVIRONMENT_STATUS_HISTORY_SUBQUERY} LIKE :statusFilters`,
                         { statusFilters: `%${statusFilters.join(',')}%` },
                     );
 
-                    filterQueryBuilder.includeAttribute({
+                    queryBuilder.includeAttribute({
                         query: ENVIRONMENT_STATUS_HISTORY_SUBQUERY,
                         alias: 'statusHistory',
                     });
@@ -190,30 +181,20 @@ class GetAllEnvironmentsUseCase {
 
                 // Check that the final run numbers list contains at least one valid run number
                 if (finalRunNumberList.length > 0) {
-                    filterQueryBuilder.include({
+                    queryBuilder.include({
                         association: 'runs',
                         where: {
                             // Filter should be like with only one filter and exact with more than one filter
                             runNumber: { [finalRunNumberList.length === 1 ? Op.substring : Op.in]: finalRunNumberList },
                         },
                     });
                 }
-            };
-
-            const filteredEnvironmentsIds = (await EnvironmentRepository.findAll(filterQueryBuilder)).map(({ id }) => id);
-            // If no environments match the filter, return an empty result
-            if (filteredEnvironmentsIds.length === 0) {
-                return {
-                    count: 0,
-                    environments: [],
-                };
             }
-            fetchQueryBuilder.where('id').oneOf(filteredEnvironmentsIds);
         }
 
-        fetchQueryBuilder.include({ association: 'runs' });
-        fetchQueryBuilder.include({ association: 'historyItems' });
-        const { count, rows } = await EnvironmentRepository.findAndCountAll(fetchQueryBuilder);
+        queryBuilder.include({ association: 'runs' });
+        queryBuilder.include({ association: 'historyItems' });
+        const { count, rows } = await EnvironmentRepository.findAndCountAll(queryBuilder);
         return {
             count,
             environments: rows.map((environment) => environmentAdapter.toEntity(environment)),

lib/usecases/lhcFill/GetAllLhcFillsUseCase.js

@@ -47,12 +47,24 @@ class GetAllLhcFillsUseCase {
         let associatedStatisticsRequired = false;
 
         if (filter) {
-            const { hasStableBeams, fillNumbers, schemeName, beamDuration, runDuration, beamTypes } = filter;
+            const { hasStableBeams, fillNumbers, schemeName, beamDuration, stableBeamsStart, stableBeamsEnd, runDuration, beamTypes } = filter;
             if (hasStableBeams) {
                 // For now, if a stableBeamsStart is present, then a beam is stable
                 queryBuilder.where('stableBeamsStart').not().is(null);
             }
 
+            if (stableBeamsStart) {
+                const from = stableBeamsStart.from !== undefined ? stableBeamsStart.from : 0;
+                const to = stableBeamsStart.to !== undefined ? stableBeamsStart.to : new Date().getTime();
+                queryBuilder.where('stableBeamsStart').between(from, to);
+            }
+
+            if (stableBeamsEnd) {
+                const from = stableBeamsEnd.from !== undefined ? stableBeamsEnd.from : 0;
+                const to = stableBeamsEnd.to !== undefined ? stableBeamsEnd.to : new Date().getTime();
+                queryBuilder.where('stableBeamsEnd').between(from, to);
+            }
+
             if (fillNumbers) {
                 const fillNumberCriteria = splitStringToStringsTrimmed(fillNumbers, SEARCH_ITEMS_SEPARATOR);