feat(api): introduce new requirement CappedTubesProfile

laura-bergoens · xav-car · commit c945fac81d6d · 2025-02-18T16:04:35.000+01:00
diff --git a/api/src/quest/domain/models/Requirement.js b/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}"`);
 }
diff --git a/api/src/quest/domain/models/Success.js b/api/src/quest/domain/models/Success.js
@@ -1,10 +1,28 @@
 import { KnowledgeElement } from '../../../shared/domain/models/index.js';
 
 export class Success {
-  constructor({ knowledgeElements }) {
+  #dataByTubeId;
+  constructor({ knowledgeElements, skills }) {
     this.knowledgeElements = knowledgeElements;
+    this.skillsForKnowledgeElements = skills;
+    this.#dataByTubeId = this.knowledgeElements.reduce((acc, nextKe) => {
+      const skill = this.skillsForKnowledgeElements.find((sk) => sk.id === nextKe.skillId);
+      if (!acc[skill.tubeId]) {
+        acc[skill.tubeId] = [];
+      }
+      acc[skill.tubeId].push({
+        isValidated: nextKe.status === KnowledgeElement.StatusType.VALIDATED,
+        difficulty: skill.difficulty,
+      });
+      return acc;
+    }, {});
   }
 
+  /**
+   *
+   * @param {Array<string>} skillIds
+   * @returns {number}
+   */
   getMasteryPercentageForSkills(skillIds) {
     // genre de doublon avec api/src/shared/domain/models/CampaignParticipationResult.js:64
     const totalSkillsCount = skillIds?.length;
@@ -16,4 +34,32 @@ export class Success {
     ).length;
     return Math.round((validatedSkillsCount * 100) / totalSkillsCount);
   }
+
+  /**
+   *
+   * @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;
+    }
+
+    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);
+  }
 }
diff --git a/api/src/quest/infrastructure/repositories/index.js b/api/src/quest/infrastructure/repositories/index.js
@@ -1,4 +1,5 @@
 import * as knowledgeElementsApi from '../../../evaluation/application/api/knowledge-elements-api.js';
+import * as skillsApi from '../../../learning-content/application/api/skills-api.js';
 import * as organizationLearnerWithParticipationApi from '../../../prescription/organization-learner/application/api/organization-learners-with-participations-api.js';
 import * as profileRewardApi from '../../../profile/application/api/profile-reward-api.js';
 import * as rewardApi from '../../../profile/application/api/reward-api.js';
@@ -21,6 +22,7 @@ const repositoriesWithoutInjectedDependencies = {
 const dependencies = {
   organizationLearnerWithParticipationApi,
   knowledgeElementsApi,
+  skillsApi,
   profileRewardApi,
   profileRewardTemporaryStorage,
   rewardApi,
diff --git a/api/src/quest/infrastructure/repositories/success-repository.js b/api/src/quest/infrastructure/repositories/success-repository.js
@@ -1,6 +1,8 @@
 import { Success } from '../../domain/models/Success.js';
 
-export const find = async ({ userId, knowledgeElementsApi }) => {
+export const find = async ({ userId, knowledgeElementsApi, skillsApi }) => {
   const knowledgeElements = await knowledgeElementsApi.findFilteredMostRecentByUser({ userId });
-  return new Success({ knowledgeElements });
+  const skillIds = knowledgeElements.map((ke) => ke.skillId);
+  const skills = await skillsApi.findByIds({ ids: skillIds });
+  return new Success({ knowledgeElements, skills });
 };
diff --git a/api/tests/quest/integration/domain/usecases/reward-user_test.js b/api/tests/quest/integration/domain/usecases/reward-user_test.js
@@ -37,7 +37,14 @@ const setupContext = async (
       status: hasValidatedKnowledgeElements ? VALIDATED : INVALIDATED,
     },
   ];
-  userKnowledgeElements.map(databaseBuilder.factory.buildKnowledgeElement);
+  userKnowledgeElements.map((ke) => {
+    databaseBuilder.factory.buildKnowledgeElement(ke);
+    databaseBuilder.factory.learningContent.buildSkill({
+      id: ke.skillId,
+      tubeId: `tubeFor${ke.skillId}`,
+      difficulty: 1,
+    });
+  });
 
   const organization = databaseBuilder.factory.buildOrganization({ type: userOrganization });
   const { id: organizationLearnerId } = databaseBuilder.factory.buildOrganizationLearner({
@@ -128,7 +135,14 @@ describe('Quest | Integration | Domain | Usecases | RewardUser', function () {
           status: VALIDATED,
         },
       ];
-      userKnowledgeElements.map(databaseBuilder.factory.buildKnowledgeElement);
+      userKnowledgeElements.map((ke) => {
+        databaseBuilder.factory.buildKnowledgeElement(ke);
+        databaseBuilder.factory.learningContent.buildSkill({
+          id: ke.skillId,
+          tubeId: `tubeFor${ke.skillId}`,
+          difficulty: 1,
+        });
+      });
 
       const organization = databaseBuilder.factory.buildOrganization({ type: questOrganization });
       const { id: organizationLearnerId } = databaseBuilder.factory.buildOrganizationLearner({
diff --git a/api/tests/quest/unit/domain/models/Quest_test.js b/api/tests/quest/unit/domain/models/Quest_test.js
@@ -103,6 +103,12 @@ describe('Quest | Unit | Domain | Models | Quest ', function () {
           { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skillC' },
           { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skillD' },
         ],
+        skills: [
+          { id: 'skillA', tubeId: 'tubeA', difficulty: 1 },
+          { id: 'skillB', tubeId: 'tubeA', difficulty: 1 },
+          { id: 'skillC', tubeId: 'tubeA', difficulty: 1 },
+          { id: 'skillD', tubeId: 'tubeA', difficulty: 1 },
+        ],
       });
 
       expect(quest.isSuccessful(success)).to.be.true;
@@ -136,6 +142,12 @@ describe('Quest | Unit | Domain | Models | Quest ', function () {
           { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skillC' },
           { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skillD' },
         ],
+        skills: [
+          { id: 'skillA', tubeId: 'tubeA', difficulty: 1 },
+          { id: 'skillB', tubeId: 'tubeA', difficulty: 1 },
+          { id: 'skillC', tubeId: 'tubeA', difficulty: 1 },
+          { id: 'skillD', tubeId: 'tubeA', difficulty: 1 },
+        ],
       });
 
       expect(quest.isSuccessful(success)).to.be.false;
@@ -169,6 +181,12 @@ describe('Quest | Unit | Domain | Models | Quest ', function () {
           { status: KnowledgeElement.StatusType.INVALIDATED, skillId: 'skillC' },
           { status: KnowledgeElement.StatusType.INVALIDATED, skillId: 'skillD' },
         ],
+        skills: [
+          { id: 'skillA', tubeId: 'tubeA', difficulty: 1 },
+          { id: 'skillB', tubeId: 'tubeA', difficulty: 1 },
+          { id: 'skillC', tubeId: 'tubeA', difficulty: 1 },
+          { id: 'skillD', tubeId: 'tubeA', difficulty: 1 },
+        ],
       });
 
       expect(quest.isSuccessful(success)).to.be.false;
diff --git a/api/tests/quest/unit/domain/models/Requirement_test.js b/api/tests/quest/unit/domain/models/Requirement_test.js
diff --git a/api/tests/quest/unit/domain/models/Success_test.js b/api/tests/quest/unit/domain/models/Success_test.js
diff --git a/api/tests/quest/unit/infrastructure/repositories/success-repository_test.js b/api/tests/quest/unit/infrastructure/repositories/success-repository_test.js
