[O2B-1552] Move ad hoc filters inside runs overviews model to filtering model

lib/domain/dtos/filters/RunFilterDto.js

@@ -99,10 +99,10 @@ exports.RunFilterDto = Joi.object({
         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(),

lib/public/components/Filters/RunsFilter/GaqFilterModel.js

@@ -0,0 +1,79 @@
+/**
+ * @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;
+        this._addSubmodel(this._mcReproducibleAsNotBad);
+    }
+
+    /**
+     * @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/RunsFilter/MultiCompositionFilterModel.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, detector] of Object.entries(this._filters)) {
+            if (!detector.isEmpty) {
+                normalized[id] = detector.normalized;
+            }
+        }
+
+        return normalized;
+    }
+}