[O2B-1503] LHCFills page, fill-number filter added

lib/domain/dtos/filters/LhcFillsFilterDto.js

@@ -11,7 +11,11 @@
  *  or submit itself to any jurisdiction.
  */
 const Joi = require('joi');
+const { validateRange } = require('../../../utilities/rangeUtils');
 
 exports.LhcFillsFilterDto = Joi.object({
     hasStableBeams: Joi.boolean(),
+    fillNumbers: Joi.string().trim().custom(validateRange).messages({
+        'any.invalid': '{{#message}}',
+    }),
 });

lib/domain/dtos/filters/RunFilterDto.js

@@ -18,6 +18,7 @@ const { IntegerComparisonDto, FloatComparisonDto } = require('./NumericalCompari
 const { RUN_CALIBRATION_STATUS } = require('../../enums/RunCalibrationStatus.js');
 const { RUN_DEFINITIONS } = require('../../enums/RunDefinition.js');
 const { singleRunsCollectionCustomCheck } = require('../utils.js');
+const { validateRange } = require('../../../utilities/rangeUtils.js');
 
 const DetectorsFilterDto = Joi.object({
     operator: Joi.string().valid('or', 'and', 'none').required(),
@@ -30,35 +31,6 @@ const EorReasonFilterDto = Joi.object({
     description: Joi.string(),
 });
 
-/**
- * Validates run numbers ranges to not exceed 100 runs
- *
- * @param {*} value  The value to validate
- * @param {*} helpers The helpers object
- * @returns {Object} The value if validation passes
- */
-const validateRange = (value, helpers) => {
-    const MAX_RANGE_SIZE = 100;
-
-    const runNumbers = value.split(',').map((runNumber) => runNumber.trim());
-
-    for (const runNumber of runNumbers) {
-        if (runNumber.includes('-')) {
-            const [start, end] = runNumber.split('-').map((n) => parseInt(n, 10));
-            if (Number.isNaN(start) || Number.isNaN(end) || start > end) {
-                return helpers.error('any.invalid', { message: `Invalid range: ${runNumber}` });
-            }
-            const rangeSize = end - start + 1;
-
-            if (rangeSize > MAX_RANGE_SIZE) {
-                return helpers.error('any.invalid', { message: `Given range exceeds max size of ${MAX_RANGE_SIZE} runs: ${runNumber}` });
-            }
-        }
-    }
-
-    return value;
-};
-
 exports.RunFilterDto = Joi.object({
     runNumbers: Joi.string().trim().custom(validateRange).messages({
         'any.invalid': '{{#message}}',

lib/public/components/Filters/LhcFillsFilter/fillNumberFilter.js

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright CERN and copyright holders of ALICE Trg. 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-Trg.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 { rawTextFilter } from '../common/filters/rawTextFilter.js';
+
+/**
+ * Component to filter LHC-fills by fill number
+ *
+ * @param {RawTextFilterModel} filterModel the filter model
+ * @returns {Component} the text field
+ */
+export const fillNumberFilter = (filterModel) => rawTextFilter(
+    filterModel,
+    { classes: ['w-100', 'fill-numbers-filter'], placeholder: 'e.g. 11392, 11383, 7625' },
+);

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

@@ -24,6 +24,7 @@ import { infologgerLinksComponents } from '../../../components/common/externalLi
 import { formatBeamType } from '../../../utilities/formatting/formatBeamType.js';
 import { frontLink } from '../../../components/common/navigation/frontLink.js';
 import { toggleStableBeamOnlyFilter } from '../../../components/Filters/LhcFillsFilter/stableBeamFilter.js';
+import { fillNumberFilter } from '../../../components/Filters/LhcFillsFilter/fillNumberFilter.js';
 
 /**
  * List of active columns for a lhc fills table
@@ -49,6 +50,7 @@ export const lhcFillsActiveColumns = {
                 ),
             ],
         ),
+        filter: (lhcFillModel) => fillNumberFilter(lhcFillModel.filteringModel.get('fillNumbers')),
         profiles: {
             lhcFill: true,
             environment: true,

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

@@ -14,6 +14,7 @@
 import { buildUrl } from '/js/src/index.js';
 import { FilteringModel } from '../../../components/Filters/common/FilteringModel.js';
 import { StableBeamFilterModel } from '../../../components/Filters/LhcFillsFilter/StableBeamFilterModel.js';
+import { RawTextFilterModel } from '../../../components/Filters/common/filters/RawTextFilterModel.js';
 import { OverviewPageModel } from '../../../models/OverviewModel.js';
 import { addStatisticsToLhcFill } from '../../../services/lhcFill/addStatisticsToLhcFill.js';
 
@@ -32,6 +33,7 @@ export class LhcFillsOverviewModel extends OverviewPageModel {
         super();
 
         this._filteringModel = new FilteringModel({
+            fillNumbers: new RawTextFilterModel(),
             hasStableBeams: new StableBeamFilterModel(),
         });
 

lib/usecases/lhcFill/GetAllLhcFillsUseCase.js

@@ -22,6 +22,8 @@ const {
 const { lhcFillAdapter } = require('../../database/adapters/index.js');
 const { ApiConfig } = require('../../config/index.js');
 const { RunDefinition } = require('../../domain/enums/RunDefinition.js');
+const { unpackNumberRange } = require('../../utilities/rangeUtils.js');
+const { splitStringToStringsTrimmed } = require('../../utilities/stringUtils.js');
 
 /**
  * GetAllLhcFillsUseCase
@@ -38,14 +40,28 @@ class GetAllLhcFillsUseCase {
         const { filter, page = {} } = query;
         const { limit = ApiConfig.pagination.limit, offset = 0 } = page;
 
+        const SEARCH_ITEMS_SEPARATOR = ',';
+
         const queryBuilder = new QueryBuilder();
 
         if (filter) {
-            const { hasStableBeams } = filter;
+            const { hasStableBeams, fillNumbers } = filter;
             if (hasStableBeams) {
                 // For now, if a stableBeamsStart is present, then a beam is stable
                 queryBuilder.where('stableBeamsStart').not().is(null);
             }
+
+            if (fillNumbers) {
+                const fillNumberCriteria = splitStringToStringsTrimmed(fillNumbers, SEARCH_ITEMS_SEPARATOR);
+
+                const finalFillnumberList = Array.from(unpackNumberRange(fillNumberCriteria));
+
+                // Check that the final fill numbers list contains at least one valid fill number
+                if (finalFillnumberList.length > 0) {
+                    finalFillnumberList.length === 1 ? queryBuilder.where('fillNumber').is(finalFillnumberList[0])
+                        : queryBuilder.where('fillNumber').oneOf(...finalFillnumberList);
+                }
+            }
         }
 
         const { count, rows } = await TransactionHelper.provide(async () => {

lib/usecases/run/GetAllRunsUseCase.js

@@ -23,6 +23,8 @@ const { BadParameterError } = require('../../server/errors/BadParameterError');
 const { gaqService } = require('../../server/services/qualityControlFlag/GaqService.js');
 const { qcFlagSummaryService } = require('../../server/services/qualityControlFlag/QcFlagSummaryService.js');
 const { DetectorType } = require('../../domain/enums/DetectorTypes.js');
+const { unpackNumberRange } = require('../../utilities/rangeUtils.js');
+const { splitStringToStringsTrimmed } = require('../../utilities/stringUtils.js');
 
 /**
  * GetAllRunsUseCase
@@ -83,29 +85,9 @@ class GetAllRunsUseCase {
             } = filter;
 
             if (runNumbers) {
-                const runNumberCriteria = runNumbers.split(SEARCH_ITEMS_SEPARATOR)
-                    .map((runNumbers) => runNumbers.trim())
-                    .filter(Boolean);
-
-                const runNumberSet = new Set();
-
-                runNumberCriteria.forEach((runNumber) => {
-                    if (runNumber.includes('-')) {
-                        const [start, end] = runNumber.split('-').map((n) => parseInt(n, 10));
-                        if (!Number.isNaN(start) && !Number.isNaN(end)) {
-                            for (let i = start; i <= end; i++) {
-                                runNumberSet.add(i);
-                            }
-                        }
-                    } else {
-                        const parsedRunNumber = parseInt(runNumber, 10);
-                        if (!Number.isNaN(parsedRunNumber)) {
-                            runNumberSet.add(parsedRunNumber);
-                        }
-                    }
-                });
+                const runNumberCriteria = splitStringToStringsTrimmed(runNumbers, SEARCH_ITEMS_SEPARATOR);
 
-                const finalRunNumberList = Array.from(runNumberSet);
+                const finalRunNumberList = Array.from(unpackNumberRange(runNumberCriteria));
 
                 // Check that the final run numbers list contains at least one valid run number
                 if (finalRunNumberList.length > 0) {

lib/utilities/rangeUtils.js

@@ -0,0 +1,79 @@
+/**
+ * @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.
+ */
+
+/**
+ * Validates numbers ranges to not exceed 100 entities
+ * Expects a string containing comma seperated number values.
+ *
+ * @param {string} value  The value to validate
+ * @param {*} helpers The helpers object
+ * @returns {Object} The value if validation passes
+ */
+export const validateRange = (value, helpers) => {
+    const MAX_RANGE_SIZE = 100;
+
+    const numbers = value.split(',').map((number) => number.trim());
+
+    for (const number of numbers) {
+        if (number.includes('-')) {
+            // Check if '-' occurs more than once in this part of the range
+            if (number.lastIndexOf('-') !== number.indexOf('-')) {
+                return helpers.error('any.invalid', { message: `Invalid range: ${number}` });
+            }
+            const [start, end] = number.split('-').map((n) => Number(n));
+            if (Number.isNaN(start) || Number.isNaN(end) || start > end) {
+                return helpers.error('any.invalid', { message: `Invalid range: ${number}` });
+            }
+            const rangeSize = end - start + 1;
+
+            if (rangeSize > MAX_RANGE_SIZE) {
+                return helpers.error('any.invalid', { message: `Given range exceeds max size of ${MAX_RANGE_SIZE} range: ${number}` });
+            }
+        } else {
+            // Prevent non-numeric input.
+            if (isNaN(number)) {
+                return helpers.error('any.invalid', { message: `Invalid number: ${number}` });
+            }
+        }
+    }
+
+    return value;
+};
+
+/**
+ * Unpacks a given string containing number ranges.
+ * E.G. input: 5,7-9 => output: 5,7,8,9
+ * @param {string[]} numbersRanges numbers that may or may not contain ranges.
+ * @param {string} rangeSplitter string used to indicate and unpack a range.
+ * @returns {Set<Number>} set containing the unpacked range.
+ */
+export function unpackNumberRange(numbersRanges, rangeSplitter = '-') {
+    // Set to prevent duplicate values.
+    const resultNumbers = new Set();
+
+    numbersRanges.forEach((number) => {
+        if (number.includes(rangeSplitter)) {
+            const [start, end] = number.split(rangeSplitter).map((n) => parseInt(n, 10));
+            if (!Number.isNaN(start) && !Number.isNaN(end)) {
+                for (let i = start; i <= end; i++) {
+                    resultNumbers.add(Number(i));
+                }
+            }
+        } else {
+            if (!isNaN(number)) {
+                resultNumbers.add(Number(number));
+            }
+        }
+    });
+    return resultNumbers;
+}

lib/utilities/stringUtils.js

@@ -62,6 +62,16 @@ const snakeToCamel = (snake) => snake.toLowerCase()
  */
 const snakeToPascal = (snake) => ucFirst(snakeToCamel(snake));
 
+/**
+ * Split the received string to an array of trimmed strings.
+ * Boolean trick: https://michaeluloth.com/javascript-filter-boolean/
+ * @param {string} stringCollection String containing other strings withing split by seperator.
+ * @param {string} stringSeperator Used to seperate the stringCollection.
+ */
+const splitStringToStringsTrimmed = (stringCollection, stringSeperator = ',') => stringCollection.split(stringSeperator)
+    .map((string) => string.trim())
+    .filter(Boolean);
+
 exports.ucFirst = ucFirst;
 
 exports.lcFirst = lcFirst;
@@ -73,3 +83,5 @@ exports.pascalToSnake = pascalToSnake;
 exports.snakeToCamel = snakeToCamel;
 
 exports.snakeToPascal = snakeToPascal;
+
+exports.splitStringToStringsTrimmed = splitStringToStringsTrimmed;

test/api/runs.test.js

@@ -166,7 +166,7 @@ module.exports = () => {
             expect(response.status).to.equal(400);
             const { errors: [error] } = response.body;
             expect(error.title).to.equal('Invalid Attribute');
-            expect(error.detail).to.equal(`Given range exceeds max size of ${MAX_RANGE_SIZE} runs: ${runNumberRange}`);
+            expect(error.detail).to.equal(`Given range exceeds max size of ${MAX_RANGE_SIZE} range: ${runNumberRange}`);
         });
 
         it('should return 400 if the calibration status filter is invalid', async () => {

test/lib/usecases/lhcFill/GetAllLhcFillsUseCase.test.js

@@ -40,4 +40,64 @@ module.exports = () => {
             expect(lhcFill.stableBeamsStart).to.not.be.null;
         });
     });
+
+    // Fill number filter tests
+
+    it('should only contain specified fill number', async () => {
+        getAllLhcFillsDto.query = { filter: { hasStableBeams: true, fillNumbers: '6' } };
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto);
+        expect(lhcFills).to.be.an('array').and.lengthOf(1)
+
+        lhcFills.forEach((lhcFill) => {
+            expect(lhcFill.fillNumber).to.equal(6)
+        });
+    })
+
+    it('should only contain specified fill numbers', async () => {
+        getAllLhcFillsDto.query = { filter: { hasStableBeams: true, fillNumbers: '6,3' } };
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto);
+
+
+        expect(lhcFills).to.be.an('array').and.lengthOf(2)
+
+        lhcFills.forEach((lhcFill) => {
+            expect(lhcFill.fillNumber).oneOf([6,3])
+        });
+    })
+
+    it('should only contain specified fill numbers, range', async () => {
+        getAllLhcFillsDto.query = { filter: { hasStableBeams: true, fillNumbers: '1-3,6' } };
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto);
+
+
+        expect(lhcFills).to.be.an('array').and.lengthOf(4)
+
+        lhcFills.forEach((lhcFill) => {
+            expect(lhcFill.fillNumber).oneOf([1,2,3,6])
+        });
+    })
+
+    it('should only contain specified fill numbers, whitespace', async () => {
+        getAllLhcFillsDto.query = { filter: { hasStableBeams: true, fillNumbers: ' 6 , 3 ' } };
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto);
+
+
+        expect(lhcFills).to.be.an('array').and.lengthOf(2)
+
+        lhcFills.forEach((lhcFill) => {
+            expect(lhcFill.fillNumber).oneOf([6,3])
+        });
+    })
+
+    it('should only contain specified fill numbers, comma misplacement', async () => {
+        getAllLhcFillsDto.query = { filter: { hasStableBeams: true, fillNumbers: ',6,3,' } };
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto);
+
+
+        expect(lhcFills).to.be.an('array').and.lengthOf(2)
+
+        lhcFills.forEach((lhcFill) => {
+            expect(lhcFill.fillNumber).oneOf([6,3])
+        });
+    })
 };

test/lib/utilities/index.js

@@ -14,11 +14,13 @@
 const cacheAsyncFunctionTest = require('./cacheAsyncFunction.test.js');
 const deepmerge = require('./deepmerge.test.js');
 const isPromise = require('./isPromise.test.js');
+const rangeUtilsTest = require('./rangeUtils.test.js');
 const stringUtilsTest = require('./stringUtils.test.js');
 
 module.exports = () => {
     describe('cacheFunction', cacheAsyncFunctionTest);
     describe('deepmerge', deepmerge);
     describe('isPromise', isPromise);
     describe('stringUtils', stringUtilsTest);
+    describe('rangeUtils', rangeUtilsTest)
 };