[O2B-1508] LHCfills beam types filter

lib/database/utilities/QueryBuilder.js

@@ -33,7 +33,7 @@
     /**
      * Sets an exact match filter using the provided value.
      *
      * @param {*} value The required value.
      * @returns {QueryBuilder} The current QueryBuilder instance.
      */
     is(value) {
@@ -54,7 +54,7 @@
      * or
      * * if value is null
      *
      * @param {*} value The required value.
      * @returns {QueryBuilder} The current QueryBuilder instance.
      */
     isOrNull(value) {
@@ -72,7 +72,7 @@
     /**
      * Sets an **AND** match filter using the provided values.
      *
      * @param  {...any} values The required values.
      * @returns {QueryBuilder} The current QueryBuilder instance.
      */
     allOf(...values) {
@@ -88,7 +88,7 @@
     }
 
     /**
-     * Sets an **OR** match filter using the provided values.
+     * Sets an **IN** match filter using the provided values.
      *
      * @param  {...any} values The required values.
      * @returns {QueryBuilder} The current QueryBuilder instance.

lib/domain/dtos/filters/LhcFillsFilterDto.js

@@ -22,4 +22,5 @@ exports.LhcFillsFilterDto = Joi.object({
     }),
     runDuration: validateTimeDuration,
     beamDuration: validateTimeDuration,
+    beamType: Joi.string(),
 });

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

@@ -0,0 +1,36 @@
+/**
+ * @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 { beamTypesProvider } from '../../../services/beamTypes/beamTypesProvider.js';
+import { SelectionFilterModel } from '../common/filters/SelectionFilterModel.js';
+
+/**
+ * Beam type filter model
+ */
+export class BeamTypeFilterModel extends SelectionFilterModel {
+    /**
+     * Constructor
+     */
+    constructor() {
+        super({ multiple: true, allowEmpty: true });
+
+        beamTypesProvider.items$.observe(() => {
+            beamTypesProvider.items$.getCurrent().apply({
+                Success: (types) => {
+                    const beamTypes = types.map((type) => ({ value: type.beam_type }));
+                    this._selectionModel.setAvailableOptions(beamTypes);
+                },
+            });
+        });
+    }
+}

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

@@ -0,0 +1,26 @@
+/**
+ * @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.
+ */
+
+import { checkboxes } from '../common/filters/checkboxFilter.js';
+
+/**
+ * Renders a list of checkboxes that lets the user look for beam types
+ *
+ * @param {BeamTypeFilterModel} beamTypeFilterModel beamTypeFilterModel
+ * @return {Component} the filter
+ */
+export const beamTypeFilter = (beamTypeFilterModel) =>
+    checkboxes(
+        beamTypeFilterModel.selectionModel,
+        { selector: 'beam-types' },
+    );

lib/public/services/beamTypes/beamTypesProvider.js

@@ -0,0 +1,30 @@
+/**
+ * @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.
+ */
+
+import { getRemoteData } from '../../utilities/fetch/getRemoteData.js';
+import { RemoteDataProvider } from '../RemoteDataProvider.js';
+
+/**
+ * Service class to fetch beams types from the backend
+ */
+export class BeamTypesProvider extends RemoteDataProvider {
+    /**
+     * @inheritDoc
+     */
+    async getRemoteData() {
+        const { data } = await getRemoteData('/api/lhcFills/beamTypes');
+        return data;
+    }
+}
+
+export const beamTypesProvider = new BeamTypesProvider();

lib/public/views/Home/Overview/HomePageModel.js

@@ -32,7 +32,7 @@ export class HomePageModel extends Observable {
         this._logsOverviewModel = new LogsOverviewModel(model, true);
         this._logsOverviewModel.bubbleTo(this);
 
-        this._lhcFillsOverviewModel = new LhcFillsOverviewModel(model, true);
+        this._lhcFillsOverviewModel = new LhcFillsOverviewModel(true);
         this._lhcFillsOverviewModel.bubbleTo(this);
     }
 

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

@@ -26,6 +26,7 @@ import { frontLink } from '../../../components/common/navigation/frontLink.js';
 import { toggleStableBeamOnlyFilter } from '../../../components/Filters/LhcFillsFilter/stableBeamFilter.js';
 import { fillNumberFilter } from '../../../components/Filters/LhcFillsFilter/fillNumberFilter.js';
 import { durationFilter } from '../../../components/Filters/LhcFillsFilter/durationFilter.js';
+import { beamTypeFilter } from '../../../components/Filters/LhcFillsFilter/beamTypeFilter.js';
 
 /**
  * List of active columns for a lhc fills table
@@ -161,6 +162,7 @@ export const lhcFillsActiveColumns = {
         visible: true,
         size: 'w-8',
         format: (value) => formatBeamType(value),
+        filter: (lhcFillModel) => beamTypeFilter(lhcFillModel.filteringModel.get('beamType')),
     },
     collidingBunches: {
         name: 'Colliding bunches',

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

@@ -17,6 +17,7 @@ import { StableBeamFilterModel } from '../../../components/Filters/LhcFillsFilte
 import { RawTextFilterModel } from '../../../components/Filters/common/filters/RawTextFilterModel.js';
 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';
 
 /**
@@ -38,6 +39,7 @@ export class LhcFillsOverviewModel extends OverviewPageModel {
             beamDuration: new TextComparisonFilterModel(),
             runDuration: new TextComparisonFilterModel(),
             hasStableBeams: new StableBeamFilterModel(),
+            beamType: new BeamTypeFilterModel(),
         });
 
         this._filteringModel.observe(() => this._applyFilters());

lib/server/controllers/lhcFill.controller.js

@@ -35,6 +35,7 @@ const { ApiConfig } = require('../../config/index.js');
 const { DtoFactory } = require('../../domain/dtos/DtoFactory.js');
 const Joi = require('joi');
 const { logService } = require('../services/log/LogService.js');
+const { getAllBeamTypes } = require('../services/beam/getAllBeamTypes.js');
 const { updateExpressResponseFromNativeError } = require('../express/updateExpressResponseFromNativeError.js');
 const { lhcFillService } = require('../services/lhcFill/LhcFillService.js');
 const { runToHttpView } = require('./runsToHttpView.js');
@@ -256,6 +257,30 @@ const getAllLhcFillsWithStableBeamsEndedInPeriodHandler = async (request, respon
     }
 };
 
+/**
+ * Retrieve a list of unique beam types
+ *
+ * @param {Object} _request The *request* object represents the HTTP request and has properties for the request query
+ *                         string, parameters, body, HTTP headers, and so on.
+ * @param {Object} response The *response* object represents the HTTP response that an Express app sends when it gets
+ *     an HTTP request.
+ * @param {NextFunction} _next The *next* object represents the next middleware function which is used to pass control to
+ *     the next middleware function.
+ * @returns {undefined}
+ */
+const listBeamTypes = async (_request, response, _next) => {
+    try {
+        const beamTypes = await getAllBeamTypes();
+        if (beamTypes && beamTypes.length > 0) {
+            response.status(200).json({ data: beamTypes });
+        } else {
+            response.status(204).json({ data: [] });
+        }
+    } catch {
+        response.status(502).json({ errors: ['Unable to retrieve list of beam types'] });
+    }
+};
+
 module.exports = {
     createLhcFill,
     listLhcFills,
@@ -265,4 +290,5 @@ module.exports = {
     getLhcFillById,
     getAllLhcFillLogsHandler,
     getAllLhcFillsWithStableBeamsEndedInPeriodHandler,
+    listBeamTypes,
 };

lib/server/routers/lhcFills.router.js

@@ -24,6 +24,11 @@ module.exports = {
             method: 'post',
             controller: LhcFillsController.createLhcFill,
         },
+        {
+            method: 'get',
+            path: 'beamTypes',
+            controller: LhcFillsController.listBeamTypes,
+        },
         {
             path: 'stable-beams-ended-within',
             method: 'get',

lib/server/services/beam/getAllBeamTypes.js

@@ -0,0 +1,34 @@
+/**
+ * @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.
+ */
+
+const { repositories: { LhcFillRepository }, sequelize } = require('../../../database');
+const { Op } = require('sequelize');
+
+/**
+ * Return the a list of unique beam types which is built from the runs data
+ *
+ * @returns {Promise<SequelizeBeamType[]>} Promise resolving with the list of unique beam types
+ */
+exports.getAllBeamTypes = async () => {
+    const beamTypes = await LhcFillRepository.findAll({
+        attributes: [[sequelize.fn('DISTINCT', sequelize.col('beam_type')), 'beam_type']],
+        where: {
+            beam_type: {
+                [Op.ne]: null,
+            },
+        },
+        order: [['beam_type', 'ASC']],
+        raw: true,
+    });
+    return beamTypes;
+};

lib/usecases/lhcFill/GetAllLhcFillsUseCase.js

@@ -47,7 +47,7 @@ class GetAllLhcFillsUseCase {
         let associatedStatisticsRequired = false;
 
         if (filter) {
-            const { hasStableBeams, fillNumbers, beamDuration, runDuration } = filter;
+            const { hasStableBeams, fillNumbers, beamDuration, runDuration, beamType } = filter;
             if (hasStableBeams) {
                 // For now, if a stableBeamsStart is present, then a beam is stable
                 queryBuilder.where('stableBeamsStart').not().is(null);
@@ -85,6 +85,11 @@ class GetAllLhcFillsUseCase {
             if (beamDuration?.limit !== undefined && beamDuration?.operator) {
                 queryBuilder.where('stableBeamsDuration').applyOperator(beamDuration.operator, beamDuration.limit);
             }
+
+            if (beamType) {
+                const beamTypes = beamType.split(',');
+                queryBuilder.where('beamType').oneOf(beamTypes);
+            }
         }
 
         const { count, rows } = await TransactionHelper.provide(async () => {

test/api/lhcFills.test.js

@@ -519,6 +519,90 @@ module.exports = () => {
                     done();
                 });
         });
+
+        it('should return 200 and an LHCFill array for beam types filter, correct', (done) => {
+            request(server)
+                .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[beamType]=Pb-Pb')
+                .expect(200)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    expect(res.body.data).to.have.lengthOf(1);
+                    expect(res.body.data[0].fillNumber).to.equal(3);
+
+                    done();
+                });
+        });
+
+        it('should return 200 and an LHCFill array for beam types filter, multiple correct', (done) => {
+            request(server)
+                .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[beamType]=Pb-Pb,p-p,p-Pb')
+                .expect(200)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    expect(res.body.data).to.have.lengthOf(4);
+                    expect(res.body.data[0].fillNumber).to.equal(4);
+
+                    done();
+                });
+        });
+
+        // API accepts filters that do not exist, this is because it does not affect the results
+        it('should return 200 for beam types filter, one wrong', (done) => {
+            request(server)
+                .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[beamType]=Pb-Pb,Hello-World,p-p,p-Pb')
+                .expect(200)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    expect(res.body.data).to.have.lengthOf(4);
+                    expect(res.body.data[0].fillNumber).to.equal(4);
+
+                    done();
+                });
+        });
+
+        it('should return 200 and an empty LHC Fill array for beam types filter that does not exist', (done) => {
+            request(server)
+                .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[beamType]=Hello-World')
+                .expect(200)
+                .end((err, res) => {
+                    if (err) {
+                        done(err);
+                        return;
+                    }
+
+                    expect(res.body.data).to.have.lengthOf(0);
+                    done();
+                });
+        });
+
+        it('should return 400 for beam types filter that is empty', (done) => {
+            request(server)
+                .get('/api/lhcFills?page[offset]=0&page[limit]=15&filter[beamType]=')
+                .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.beamType" is not allowed to be empty');
+                    done();
+                });
+        });
     });
     describe('POST /api/lhcFills', () => {
         it('should return 201 if valid data is provided', async () => {