[O2B-1552] Move ad hoc filters inside runs overviews model to filtering model (#2106)

Notable changes for users:
- The monte carlo reproducable as not bad filters from the runs per .... overview pages has been changed to also be cleared when the 'reset all filters' button is pressed to be in line with all other filters.

Notable changes for developers:

**Filter restructuring**

- `ddflpFilter`, `dcsFilter`, and `epnFilter` have been moved to the `filteringModel`.
- `detectorsQc[_id][notBadFraction]` filters have been moved to a new model: `MultiCompositeFilterModel`.
- `gaq[notBadFraction]` now uses its own filter model with unique normalization logic: `GaqFilterModel`.

**New filter models**
- **`GaqFilterModel`**
  - Dedicated model for `gaq[notBadFraction]`.
  - Implements custom normalization logic.

- **`ToggleFilterModel`**
  - Introduced for toggle-based filters.
  - `mcReproducibleAsNotBad` has been converted to use this model.
- **`MultiCompositeFilterModel`**
  - New flexible model:
    - Can be instantiated with filters.
    - Supports adding filters dynamically after instantiation.
  - Computes normalized values based on:
    - Insertion keys
    - Normalized child filters

**Shared filter behavior**
- `mcReproducibleAsNotBad`:
  - Converted into a `ToggleFilterModel`.
  - Integrated into both:
    - `GaqFilterModel`
    - `MultiCompositeFilterModel`
  - **Important:** both models must use the same instance for correct behavior.

**New components**
- `RadioButtonFilter`
  - Replaces filters associated with the restructured filter models.
- `ToggleFilter` (component + model)
  - Introduced alongside `ToggleFilterModel`.

**Renaming**

- `detectorsQc[_id][notBadFraction]` → `detectorsQcNotBadFraction[_id]`
  - Reduces nesting within the `filterModel`.

**Implementation note**

- This approach avoids:
  - Creating a custom wrapper around `NumericalComparisonFilterModel` solely for normalization, or
  - Nesting `MultiCompositeFilterModel` within another `MultiCompositeFilterModel` to achieve automatic normalization.

Author: NarrowsProjects

lib/domain/dtos/filters/RunFilterDto.js

@@ -88,26 +88,27 @@ exports.RunFilterDto = Joi.object({
     inelasticInteractionRateAtEnd: FloatComparisonDto,
 
     gaq: Joi.object({
-        notBadFraction: FloatComparisonDto.when(
-            'dataPassIds',
-            {
-                is: Joi.array().length(1),
-                then: FloatComparisonDto,
-                otherwise: Joi.forbidden().error(new Error('Filtering by GAQ is enabled only when filtering with one dataPassId')),
-            },
-        ),
+        notBadFraction: FloatComparisonDto.custom((value, helpers) => {
+            const [, { dataPassIds }] = helpers.state.ancestors;
+
+            if (!dataPassIds || dataPassIds.length !== 1) {
+                return helpers.message('Filtering by GAQ is enabled only when filtering with one dataPassId');
+            }
+
+            return value;
+        }),
         mcReproducibleAsNotBad: Joi.boolean().optional(),
     }),
 
-    detectorsQc: Joi.object()
+    detectorsQcNotBadFraction: Joi.object()
         .pattern(
             Joi.string().regex(/^_\d+$/), // Detector id with '_' prefix
-            Joi.object({ notBadFraction: FloatComparisonDto }),
+            FloatComparisonDto,
         )
         .keys({
             mcReproducibleAsNotBad: Joi.boolean().optional(),
         })
-        .custom((detectorsQcObj, helpers) => {
+        .custom((detectorsQcNotBadFractionObj, helpers) => {
             const [{ dataPassIds, simulationPassIds, lhcPeriodIds }] = helpers.state.ancestors;
 
             singleRunsCollectionCustomCheck(
@@ -117,6 +118,6 @@ exports.RunFilterDto = Joi.object({
                 'the dataPassIds, simulationPassIds and lhcPeriodIds filters collectively contain exactly one ID',
             );
 
-            return detectorsQcObj;
+            return detectorsQcNotBadFractionObj;
         }),
 });

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

@@ -0,0 +1,89 @@
+/**
+ * @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 { FilterModel } from '../common/FilterModel.js';
+import { NumericalComparisonFilterModel } from '../common/filters/NumericalComparisonFilterModel.js';
+
+/**
+ * FilterModel that filters by the fraction of gaq that was not bad
+ */
+export class GaqFilterModel extends FilterModel {
+    /**
+     * Constructor
+     * @param {ToggleFilterModel} mcReproducibleAsNotBad model that determines if a 'not bad' status was reproduceable for a Monte Carlo.
+     * This param is required as multiple other filters models need to make use of the same ToggleFilterModel instance
+     */
+    constructor(mcReproducibleAsNotBad) {
+        super();
+
+        this._notBadFraction = new NumericalComparisonFilterModel({ scale: 0.01, integer: false });
+        this._addSubmodel(this._notBadFraction);
+        this._mcReproducibleAsNotBad = mcReproducibleAsNotBad;
+
+        /**
+         * _mcReproducableAsNotBad will only be added to the normalize call notBadFraction is not empty
+         * So, notifying when it is empty will just send an unneeded request.
+         */
+        this._mcReproducibleAsNotBad.visualChange$.bubbleTo(this._visualChange$);
+        this._mcReproducibleAsNotBad.observe(() => {
+            if (!this.notBadFraction.isEmpty) {
+                this.notify();
+            }
+        });
+    }
+
+    /**
+     * @inheritDoc
+     */
+    reset() {
+        this._notBadFraction.reset();
+    }
+
+    /**
+     * @inheritDoc
+     */
+    get isEmpty() {
+        return this._notBadFraction.isEmpty;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    get normalized() {
+        const normalized = { notBadFraction: this._notBadFraction.normalized };
+
+        if (!this.isEmpty) {
+            normalized.mcReproducibleAsNotBad = this._mcReproducibleAsNotBad.isToggled;
+        }
+
+        return normalized;
+    }
+
+    /**
+     * Return the underlying notBadFraction model
+     *
+     * @return {NumericalComparisonFilterModel} the filter model
+     */
+    get notBadFraction() {
+        return this._notBadFraction;
+    }
+
+    /**
+     * Return the underlying mcReproducibleAsNotBad model
+     *
+     * @return {ToggleFilterModel} the filter model
+     */
+    get mcReproducibleAsNotBad() {
+        return this._mcReproducibleAsNotBad;
+    }
+}

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

@@ -0,0 +1,92 @@
+/**
+ * @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 { FilterModel } from '../common/FilterModel.js';
+
+/**
+ * FilterModel that allows devs to create custom filters from multiple other filters during instantiation, or using putFilter
+ */
+export class MultiCompositionFilterModel extends FilterModel {
+    /**
+     * Constructor
+     * @param {Object<string|number, FilterModel|SelectionModel>} filters the filters that will make up the composite filter
+     */
+    constructor(filters = {}) {
+        super();
+
+        /**
+         * @type {Object<string|number, FilterModel|SelectionModel>}
+         */
+        this._filters = {};
+
+        Object.entries(filters).forEach(([key, filter]) => this.putFilter(key, filter));
+    }
+
+    /**
+     * Return a subfilter by key
+     *
+     * @param {string} key the key of the subfilter
+     * @return {FilterModel} the subfilter
+     */
+    putFilter(key, filterModel) {
+        if (key in this._filters) {
+            return;
+        }
+
+        this._filters[key] = filterModel;
+        this._addSubmodel(filterModel);
+    }
+
+    /**
+     * Add new subfilter
+     *
+     * @param {string} key key of the subfilter
+     * @param {FilterModel} filter the the subfilter
+     */
+    getFilter(key) {
+        if (!(key in this._filters)) {
+            throw new Error(`No filter found with key ${key}`);
+        }
+
+        return this._filters[key];
+    }
+
+    /**
+     * @inheritDoc
+     */
+    reset() {
+        Object.values(this._filters).forEach((filter) => filter.reset());
+    }
+
+    /**
+     * @inheritDoc
+     */
+    get isEmpty() {
+        return Object.values(this._filters).every((filter) => filter.isEmpty);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    get normalized() {
+        const normalized = {};
+
+        for (const [id, filter] of Object.entries(this._filters)) {
+            if (!filter.isEmpty) {
+                normalized[id] = filter.normalized;
+            }
+        }
+
+        return normalized;
+    }
+}