[O2B-1503] fillNumbers work, todo ranges

Author: Houwie7000

lib/domain/dtos/filters/LhcFillsFilterDto.js

@@ -11,7 +11,11 @@
  *  or submit itself to any jurisdiction.
  */
 const Joi = require('joi');
+const { validateRange } = require('../../../utilities/validateRange');
 
 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/validateRange.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/usecases/lhcFill/GetAllLhcFillsUseCase.js

@@ -41,11 +41,20 @@ class GetAllLhcFillsUseCase {
         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 fillNumbersSplit = fillNumbers.split(',');
+
+                const fillNumbersValidated = fillNumbersSplit.filter((number) => !Number.isNaN(number));
+                if (fillNumbersValidated.length > 0) {
+                    queryBuilder.where('fillNumber').oneOf(...fillNumbersValidated);
+                }
+            }
         }
 
         const { count, rows } = await TransactionHelper.provide(async () => {

lib/utilities/validateRange.js

@@ -0,0 +1,28 @@
+/**
+ * Validates numbers ranges to not exceed 100 entities
+ *
+ * @param {*} 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((runNumber) => runNumber.trim());
+
+    for (const number of numbers) {
+        if (number.includes('-')) {
+            const [start, end] = number.split('-').map((n) => parseInt(n, 10));
+            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}` });
+            }
+        }
+    }
+
+    return value;
+};

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,52 @@ 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, 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])
+        });
+    })
 };