[O2B-1530] Lhc fills add sb duration filter

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/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);
 

test/api/lhcFills.test.js

@@ -503,6 +503,7 @@ module.exports = () => {
                 });
         });
 
+
         it('should return 200 and an LHCFill array for runs duration filter, > 03:00:00', (done) => {
             request(server)
                 .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[runDuration][operator]=>&filter[runDuration][limit]=03:00:00')
@@ -519,6 +520,177 @@ module.exports = () => {
                     done();
                 });
         });
+
+        it('should return 400 when stableBeamEnd filter "from" is greater than the current time', (done) => {
+            request(server)
+                .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[stableBeamsEnd][from]=2647867600000')
+                .expect(400)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    const { errors: [error] } = res.body;
+                    expect(error.title).to.equal('Invalid Attribute');
+                    expect(error.detail).to.equal('"query.filter.stableBeamsEnd.from" must be less than "now"');
+                    done()
+                });
+        });
+
+        it('should return 400 when stableBeamStart filter "from" is greater than the current time', (done) => {
+            request(server)
+                .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[stableBeamsStart][from]=2647867600000')
+                .expect(400)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    const { errors: [error] } = res.body;
+                    expect(error.title).to.equal('Invalid Attribute');
+                    expect(error.detail).to.equal('"query.filter.stableBeamsStart.from" must be less than "now"');
+                    done()
+                });
+        });
+
+        it('should return 400 when stableBeamEnd filter "from" is greater than "to"', (done) => {
+            request(server)
+                .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[stableBeamsEnd][from]=1647867699999&filter[stableBeamsEnd][to]=1647867600000')
+                .expect(400)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    const { errors: [error] } = res.body;
+                    expect(error.title).to.equal('Invalid Attribute');
+                    expect(error.detail).to.equal('"query.filter.stableBeamsEnd.to" must be greater than "ref:from"');
+                    done()
+                });
+        });
+
+        it('should return 400 when stableBeamStart filters are strings', (done) => {
+            request(server)
+            .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[stableBeamsStart][from]=bogus&filter[stableBeamsStart][to]=bogus')
+            .expect(400)
+            .end((err, res) => {
+                if (err) {
+                    done(err);
+                    return;
+                }
+
+                const { errors } = res.body;
+
+                expect(errors.map(e => e.detail)).to.have.members([
+                    '"query.filter.stableBeamsStart.from" must be a valid date',
+                    '"query.filter.stableBeamsStart.to" must be a valid date',
+                ]);
+
+                expect(errors.every(e => e.title === 'Invalid Attribute')).to.be.true;
+                done()
+            });
+        });
+
+        it('should return 400 when stableBeamEnd filters are strings', (done) => {
+            request(server)
+                .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[stableBeamsEnd][from]=bogus&filter[stableBeamsEnd][to]=bogus')
+                .expect(400)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    const { errors } = res.body;
+
+                    expect(errors.map(e => e.detail)).to.have.members([
+                        '"query.filter.stableBeamsEnd.from" must be a valid date',
+                        '"query.filter.stableBeamsEnd.to" must be a valid date',
+                    ]);
+
+                    expect(errors.every(e => e.title === 'Invalid Attribute')).to.be.true;
+                    done()
+                });
+        });
+
+        it('should return 400 when stableBeamStart filter "from" is greater than "to"', (done) => {
+            request(server)
+                .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[stableBeamsStart][from]=1647867699999&filter[stableBeamsStart][to]=1647867600000')
+                .expect(400)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    const { errors: [error] } = res.body;
+                    expect(error.title).to.equal('Invalid Attribute');
+                    expect(error.detail).to.equal('"query.filter.stableBeamsStart.to" must be greater than "ref:from"');
+                    done()
+                });
+        });
+
+        it('should return 200 and a LHCFill array for only "from" filters set for stableBeamStart and end', (done) => {
+            const fromValue = 1647867600000;
+
+            request(server)
+                .get(`/api/lhcFills?page[offset]=0&page[limit]=15&filter[stableBeamsStart][from]=${fromValue}&filter[stableBeamsEnd][from]=${fromValue}`)
+                .expect(200)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    expect(res.body.data).to.have.lengthOf(3);
+                    res.body.data.forEach(fill => {
+                        expect(fill.stableBeamsStart).to.be.at.least(fromValue);
+                        expect(fill.stableBeamsEnd).to.be.at.least(fromValue);
+                    });
+
+                    done();
+                });
+        });
+
+        it('should return 200 and a LHCFill array for only "to" filters set for stableBeamStart and end', (done) => {
+            const toValue = 2000000000000;
+
+            request(server)
+                .get(`/api/lhcFills?page[offset]=0&page[limit]=15&filter[stableBeamsStart][to]=${toValue}&filter[stableBeamsEnd][to]=${toValue}`)
+                .expect(200)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    expect(res.body.data).to.have.lengthOf(4);
+
+                    res.body.data.forEach(fill => {
+                        expect(fill.stableBeamsStart).to.be.at.most(toValue);
+                        expect(fill.stableBeamsEnd).to.be.at.most(toValue);
+                    });
+                    done();
+                });
+        });
+
+        it('should return 200 and a LHCFill array for stableBeamStart and end filter set', (done) => {
+            request(server)
+                .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[stableBeamsStart][from]=1647867600000&filter[stableBeamsStart][to]=1647867600001&filter[stableBeamsEnd][from]=1647961200000&filter[stableBeamsEnd][to]=1647961200001')
+                .expect(200)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    expect(res.body.data).to.have.lengthOf(3);
+                    done();
+                });
+        });
 
         it('should return 200 and an LHCFill array for beam types filter, correct', (done) => {
             request(server)

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

@@ -317,4 +317,60 @@ module.exports = () => {
 
         expect(lhcFills).to.be.an('array').and.lengthOf(0)
     })
+
+    it('should return an array with only \'from\' values given', async () => {
+        getAllLhcFillsDto.query = {
+            filter: {
+                stableBeamsStart: {
+                    from: 1647867600000,
+                },
+                stableBeamsEnd: {
+                    from: 1647867600000,
+                },
+            },
+        };
+
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto);
+
+        expect(lhcFills).to.be.an('array');
+        expect(lhcFills).to.have.lengthOf(3);
+    });
+
+    it('should return an array with only \'to\' values given', async () => {
+        getAllLhcFillsDto.query = {
+            filter: {
+                stableBeamsStart: { 
+                    to: 2000000000000 
+                },
+                stableBeamsEnd: { 
+                    to: 2000000000000 
+                },
+            },
+        };
+
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto);
+
+        expect(lhcFills).to.be.an('array');
+        expect(lhcFills).to.have.lengthOf(4);
+    });
+
+    it('should return an array with fills on certain timestamps', async () => {
+        getAllLhcFillsDto.query = {
+            filter: {
+                stableBeamsStart: {
+                    from: 1647867600000,
+                    to: 1647867600000,
+                },
+                stableBeamsEnd: {
+                    from: 1647961200000,
+                    to: 1647961200000,
+                },
+            },
+        };
+
+        const { lhcFills } = await new GetAllLhcFillsUseCase().execute(getAllLhcFillsDto);
+
+        expect(lhcFills).to.be.an('array');
+        expect(lhcFills).to.have.lengthOf(3);
+    });
 };