fix

Author: xsalonx

lib/public/views/Runs/RunPerDataPass/RunsPerDataPassOverviewModel.js

@@ -139,6 +139,9 @@ export class RunsPerDataPassOverviewModel extends FixedPdpBeamTypeRunsOverviewMo
                 mcReproducibleAsNotBad: this._mcReproducibleAsNotBad,
             };
         }
+        filter.detectorsQc = {
+            mcReproducibleAsNotBad: this._mcReproducibleAsNotBad,
+        };
 
         return buildUrl(super.getRootEndpoint(), { filter });
     }

lib/usecases/run/GetAllRunsUseCase.js

@@ -396,31 +396,33 @@ class GetAllRunsUseCase {
                 const [lhcPeriodId] = lhcPeriodIds ?? [];
                 const { mcReproducibleAsNotBad } = detectorsQc;
                 delete detectorsQc.mcReproducibleAsNotBad;
-                delete detectorsQc.operator;
-
-                const qcSummary = await qcFlagSummaryService.getSummary(
-                    {
-                        dataPassId,
-                        simulationPassId,
-                        lhcPeriodId,
-                        dplDetectorIds: Object.keys(detectorsQc).map((id) => parseInt(id.slice(1), 10)),
-                    },
-                    { mcReproducibleAsNotBad },
-                );
 
-                const runNumbers = Object.entries(qcSummary)
-                    .filter(([_, runSummary]) => {
-                        const mask = Object.entries(runSummary).map(([dplDetecotrId, { badEffectiveRunCoverage }]) => {
-                            if (!(`_${dplDetecotrId}` in detectorsQc)) {
-                                return false;
-                            }
-                            const { operator: forDetectorOperator, limit } = detectorsQc[`_${dplDetecotrId}`].notBadFraction;
-                            return badEffectiveRunCoverageComparison(badEffectiveRunCoverage, forDetectorOperator, limit);
-                        });
-                        return mask.every((valid) => valid);
-                    })
-                    .map(([runNumber]) => runNumber);
-                filteringQueryBuilder.where('runNumber').oneOf(...runNumbers);
+                const dplDetectorIds = Object.keys(detectorsQc).map((id) => parseInt(id.slice(1), 10));
+                if (dplDetectorIds.length > 0) {
+                    const qcSummary = await qcFlagSummaryService.getSummary(
+                        {
+                            dataPassId,
+                            simulationPassId,
+                            lhcPeriodId,
+                            dplDetectorIds,
+                        },
+                        { mcReproducibleAsNotBad },
+                    );
+
+                    const runNumbers = Object.entries(qcSummary)
+                        .filter(([_, runSummary]) => {
+                            const mask = Object.entries(runSummary).map(([dplDetecotrId, { badEffectiveRunCoverage }]) => {
+                                if (!(`_${dplDetecotrId}` in detectorsQc)) {
+                                    return false;
+                                }
+                                const { operator: forDetectorOperator, limit } = detectorsQc[`_${dplDetecotrId}`].notBadFraction;
+                                return badEffectiveRunCoverageComparison(badEffectiveRunCoverage, forDetectorOperator, limit);
+                            });
+                            return mask.every((valid) => valid);
+                        })
+                        .map(([runNumber]) => runNumber);
+                    filteringQueryBuilder.where('runNumber').oneOf(...runNumbers);
+                }
             }
 
             if (simulationPassIds) {

test/lib/usecases/run/GetAllRunsUseCase.test.js

@@ -795,4 +795,58 @@ module.exports = () => {
             expect(runs).to.have.lengthOf(0);
         }
     });
+
+    it('should successfully filter by detectors\' notBadFraction', async () => {
+        const dataPassIds = [1];
+        {
+            const { runs } = await new GetAllRunsUseCase().execute({
+                query: {
+                    filter: {
+                        dataPassIds,
+                        detectorsQc: {  '_1': { notBadFraction: { operator: '<', limit: 0.7 } } },
+                    },
+                },
+            });
+            expect(runs).to.be.an('array');
+            expect(runs.map(({ runNumber }) => runNumber)).to.have.all.members([106]);
+        }
+        {
+            const { runs } = await new GetAllRunsUseCase().execute({
+                query: {
+                    filter: {
+                        dataPassIds,
+                        detectorsQc: {  '_1': { notBadFraction: { operator: '<', limit: 0.8 } } },
+                    },
+                },
+            });
+            expect(runs.map(({ runNumber }) => runNumber)).to.have.all.members([107, 106]);
+        }
+
+        {
+            const { runs } = await new GetAllRunsUseCase().execute({
+                query: {
+                    filter: {
+                        dataPassIds,
+                        detectorsQc: {  '_1': { notBadFraction: { operator: '<', limit: 0.8 } }, mcReproducibleAsNotBad: true },
+                    },
+                },
+            });
+            expect(runs.map(({ runNumber }) => runNumber)).to.have.all.members([106]);
+        }
+
+        {
+            const { runs } = await new GetAllRunsUseCase().execute({
+                query: {
+                    filter: {
+                        dataPassIds,
+                        detectorsQc: {
+                            '_2': { notBadFraction: { operator: '>', limit: 0.8 } },
+                            '_1': { notBadFraction: {operator: '<', limit: 0.8 } },
+                        },
+                    },
+                },
+            });
+            expect(runs.map(({ runNumber }) => runNumber)).to.have.all.members([107]);
+        }
+    });
 };