feat(api) add CappedTubeRequirement

Author: frinyvonnick

api/src/quest/domain/models/Requirement.js

@@ -8,6 +8,7 @@ export const COMPARISONS = {
 export const TYPES = {
   COMPOSE: 'compose',
   SKILL_PROFILE: 'skillProfile',
+  CAPPED_TUBES_PROFILE: 'cappedTubesProfile',
   OBJECT: {
     ORGANIZATION_LEARNER: 'organizationLearner',
     ORGANIZATION: 'organization',
@@ -167,6 +168,48 @@ export class SkillProfileRequirement extends BaseRequirement {
   }
 }
 
+export class CappedTubesProfileRequirement extends BaseRequirement {
+  #cappedTubes;
+  #threshold;
+
+  constructor({ data }) {
+    super({ requirement_type: TYPES.CAPPED_TUBES_PROFILE, comparison: null });
+    this.#cappedTubes = data.cappedTubes;
+    this.#threshold = data.threshold;
+  }
+
+  /**
+   * @returns {Object}
+   */
+  get data() {
+    return {
+      cappedTubes: Object.freeze(this.#cappedTubes),
+      threshold: this.#threshold,
+    };
+  }
+
+  /**
+   * @param {Eligibility|Success} dataInput
+   * @returns {Boolean}
+   */
+  isFulfilled(dataInput) {
+    const masteryPercentage = dataInput.getMasteryPercentageForCappedTubes(this.#cappedTubes);
+    return masteryPercentage >= this.#threshold;
+  }
+
+  /**
+   * @returns {Object}
+   */
+  toDTO() {
+    const superDto = super.toDTO();
+    delete superDto.comparison;
+    return {
+      ...superDto,
+      data: this.data,
+    };
+  }
+}
+
 /**
  * @param {Object} params
  * @param {string} params.requirement_type
@@ -182,6 +225,8 @@ export function buildRequirement({ requirement_type, data, comparison }) {
     return new ObjectRequirement({ requirement_type, data, comparison });
   } else if (requirement_type === TYPES.SKILL_PROFILE) {
     return new SkillProfileRequirement({ data });
+  } else if (requirement_type === TYPES.CAPPED_TUBES_PROFILE) {
+    return new CappedTubesProfileRequirement({ data });
   }
   throw new Error(`Unknown requirement_type "${requirement_type}"`);
 }

api/src/quest/domain/models/Success.js

@@ -1,3 +1,5 @@
+import uniqBy from 'lodash/uniqBy.js';
+
 import { KnowledgeElement } from '../../../shared/domain/models/index.js';
 
 export class Success {
@@ -28,26 +30,28 @@ export class Success {
    * @param {Array<{tubeId: string, level: number}>} cappedTubes
    * @returns {number}
    */
-  // Pour cette implémentation, ne tient pas compte des versions d'acquis obtenus dans les campagnes
-  // potentiellement effectuées dans le cadre de la quête, mais seulement du profil de l'utilisateur
-  // pour que ça marche efficacement, ajouter une condition d'éligibilité qui impose d'être allé au bout
-  // de la participation, on s'assure ainsi qu'il a bien un KE pour chaque acquis des campagnes et qu'il
-  // n'obtienne pas l'attestation sans avoir effectivement participé
-
-  // L'autre solution serait de baser les cappedTubes sur l'ensemble des lots d'acquis des campagnes
-  // concernées peut-être ?
-  /*getMasteryPercentageForCappedTubes(cappedTubes) {
-    if (!cappedTubes?.length) {
-      return 0;
+  getMasteryPercentageForCappedTubes(cappedTubes) {
+    const uniqCampaignSkills = uniqBy(this.campaignSkills, 'id');
+    const sortedKEByDateDesc = this.knowledgeElements.sort((keA, keB) => keB.createdAt - keA.createdAt);
+    let total = 0;
+    let validated = 0;
+    for (const cappedTube of cappedTubes) {
+      const skillsInTubeWithinMaxDifficulty = uniqCampaignSkills.filter(
+        ({ tubeId, difficulty }) => tubeId === cappedTube.tubeId && difficulty <= cappedTube.level,
+      );
+      const skillsByDifficulty = Object.groupBy(skillsInTubeWithinMaxDifficulty, ({ difficulty }) => difficulty);
+      for (const skills of Object.values(skillsByDifficulty)) {
+        ++total;
+        const skillIds = skills.map(({ id }) => id);
+        const ke = sortedKEByDateDesc.find(({ skillId }) => skillIds.includes(skillId));
+        if (ke?.status === KnowledgeElement.StatusType.VALIDATED) {
+          ++validated;
+        }
+      }
     }
 
-    let sumTotal = 0;
-    let sumValidated = 0;
-    for (const { tubeId, level } of cappedTubes) {
-      sumTotal += level; // ceci est très cavalier, je présuppose que le référentiel n'a aucun trou \o/
-      const dataForTubeId = this.#dataByTubeId[tubeId] ?? [];
-      sumValidated += dataForTubeId.filter(({ isValidated, difficulty }) => isValidated && difficulty <= level).length;
-    }
-    return Math.round((sumValidated * 100) / sumTotal);
-  }*/
+    if (total === 0) return 0;
+
+    return (validated / total) * 100;
+  }
 }