tech(api): add campaign skills in Success model

laura-bergoens · frinyvonnick · xav-car · laura-bergoens · commit de2d59f6cd0b · 2025-03-13T21:50:10.000+01:00
Co-authored-by: Yvonnick Frin &lt;yvonnick.frin@pix.fr&gt;
Co-authored-by: Xavier Carron &lt;xavier.carron@pix.fr&gt;
diff --git a/api/src/quest/domain/models/Success.js b/api/src/quest/domain/models/Success.js
@@ -1,10 +1,16 @@
 import { KnowledgeElement } from '../../../shared/domain/models/index.js';
 
 export class Success {
-  constructor({ knowledgeElements }) {
+  constructor({ knowledgeElements, campaignSkills }) {
     this.knowledgeElements = knowledgeElements;
+    this.campaignSkills = campaignSkills;
   }
 
+  /**
+   *
+   * @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 +22,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,6 @@
 import * as knowledgeElementsApi from '../../../evaluation/application/api/knowledge-elements-api.js';
+import * as skillsApi from '../../../learning-content/application/api/skills-api.js';
+import * as campaignsApi from '../../../prescription/campaign/application/api/campaigns-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 +23,8 @@ const repositoriesWithoutInjectedDependencies = {
 const dependencies = {
   organizationLearnerWithParticipationApi,
   knowledgeElementsApi,
+  campaignsApi,
+  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, campaignParticipationIds, knowledgeElementsApi, skillsApi, campaignsApi }) => {
   const knowledgeElements = await knowledgeElementsApi.findFilteredMostRecentByUser({ userId });
-  return new Success({ knowledgeElements });
+  const campaignSkillIds = await campaignsApi.findCampaignSkillIdsForCampaignParticipations(campaignParticipationIds);
+  const campaignSkills = await skillsApi.findByIds({ ids: campaignSkillIds });
+  return new Success({ knowledgeElements, campaignSkills });
 };
diff --git a/api/tests/quest/unit/domain/models/Quest_test.js b/api/tests/quest/unit/domain/models/Quest_test.js
@@ -107,6 +107,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 },
+        ],
       });
       const data = new DataForQuest({ success });
 
@@ -141,6 +147,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 },
+        ],
       });
       const data = new DataForQuest({ success });
 
@@ -175,6 +187,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 },
+        ],
       });
       const data = new DataForQuest({ success });
 
diff --git a/api/tests/quest/unit/domain/models/Success_test.js b/api/tests/quest/unit/domain/models/Success_test.js
@@ -15,6 +15,11 @@ describe('Quest | Unit | Domain | Models | Success ', function () {
             { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skillB' },
             { status: KnowledgeElement.StatusType.INVALIDATED, skillId: 'skillC' },
           ],
+          skills: [
+            { id: 'skillA', tubeId: 'tubeA', difficulty: 1 },
+            { id: 'skillB', tubeId: 'tubeB', difficulty: 1 },
+            { id: 'skillC', tubeId: 'tubeC', difficulty: 1 },
+          ],
         });
 
         // when
@@ -37,6 +42,12 @@ describe('Quest | Unit | Domain | Models | Success ', function () {
             { status: KnowledgeElement.StatusType.INVALIDATED, skillId: 'skillC' },
             { status: KnowledgeElement.StatusType.INVALIDATED, skillId: 'skillD' },
           ],
+          skills: [
+            { id: 'skillA', tubeId: 'tubeA', difficulty: 1 },
+            { id: 'skillB', tubeId: 'tubeB', difficulty: 1 },
+            { id: 'skillC', tubeId: 'tubeC', difficulty: 1 },
+            { id: 'skillD', tubeId: 'tubeD', difficulty: 1 },
+          ],
         });
 
         // when
@@ -48,4 +59,78 @@ describe('Quest | Unit | Domain | Models | Success ', function () {
       });
     });
   });
+  /*
+  describe('#getMasteryPercentageForCappedTubes', function () {
+    context('when no cappedTubes provided', function () {
+      it('should return 0', function () {
+        // given
+        const cappedTubesEmpty = [];
+        const brokenCappedTubes = null;
+        const success = new Success({
+          knowledgeElements: [
+            { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skillA' },
+            { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skillB' },
+            { status: KnowledgeElement.StatusType.INVALIDATED, skillId: 'skillC' },
+          ],
+          skills: [
+            { id: 'skillA', tubeId: 'tubeA', difficulty: 1 },
+            { id: 'skillB', tubeId: 'tubeB', difficulty: 1 },
+            { id: 'skillC', tubeId: 'tubeC', difficulty: 1 },
+          ],
+        });
+
+        // when
+        const masteryPercentageEmpty = success.getMasteryPercentageForCappedTubes(cappedTubesEmpty);
+        const masteryPercentageBroken = success.getMasteryPercentageForCappedTubes(brokenCappedTubes);
+
+        // then
+        expect(masteryPercentageEmpty).to.equal(0);
+        expect(masteryPercentageBroken).to.equal(0);
+      });
+    });
+    context('when cappedTubes are provided', function () {
+      it('should return the expected mastery percentage according to knowledge elements by tube in Success model', function () {
+        // given
+        const success = new Success({
+          // 1/2 sur tubeA cappé 2
+          // 2/3 sur tubeB cappé 3
+          // au final ça donne 3 / 5 -> 60%
+          knowledgeElements: [
+            { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skill1tubeA' },
+            { status: KnowledgeElement.StatusType.INVALIDATED, skillId: 'skill2tubeA' },
+            { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skill3tubeA' }, // ignoré, hors cap
+            { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skill4tubeA' }, // ignoré, hors cap
+            { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skill1tubeB' },
+            { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skill2tubeB' },
+            { status: KnowledgeElement.StatusType.INVALIDATED, skillId: 'skill3tubeB' },
+            { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skillTubeC' }, // ignoré, hors scope
+            { status: KnowledgeElement.StatusType.VALIDATED, skillId: 'skillTubeD' }, // ignoré, hors scope
+          ],
+          skills: [
+            { id: 'skill1tubeA', tubeId: 'tubeA', difficulty: 1 },
+            { id: 'skill2tubeA', tubeId: 'tubeA', difficulty: 2 },
+            { id: 'skill3tubeA', tubeId: 'tubeA', difficulty: 3 },
+            { id: 'skill4tubeA', tubeId: 'tubeA', difficulty: 4 },
+            { id: 'skill1tubeB', tubeId: 'tubeB', difficulty: 1 },
+            { id: 'skill2tubeB', tubeId: 'tubeB', difficulty: 2 },
+            { id: 'skill3tubeB', tubeId: 'tubeB', difficulty: 3 },
+            { id: 'skillTubeC', tubeId: 'tubeC', difficulty: 1 },
+            { id: 'skillTubeD', tubeId: 'tubeD', difficulty: 1 },
+          ],
+        });
+
+        // when
+        const cappedTubes = [
+          { tubeId: 'tubeA', level: 2 },
+          { tubeId: 'tubeB', level: 3 },
+        ];
+        const masteryPercentage = success.getMasteryPercentageForCappedTubes(cappedTubes);
+
+        // then
+        const expectedMasteryPercentage = 60;
+        expect(masteryPercentage).to.be.equal(expectedMasteryPercentage);
+      });
+    });
+  });
+  */
 });
diff --git a/api/tests/quest/unit/infrastructure/repositories/success-repository_test.js b/api/tests/quest/unit/infrastructure/repositories/success-repository_test.js
@@ -2,28 +2,65 @@ import sinon from 'sinon';
 
 import { Success } from '../../../../../src/quest/domain/models/Success.js';
 import * as successRepository from '../../../../../src/quest/infrastructure/repositories/success-repository.js';
-import { expect } from '../../../../test-helper.js';
+import { expect, preventStubsToBeCalledUnexpectedly } from '../../../../test-helper.js';
 
 describe('Quest | Unit | Infrastructure | repositories | success', function () {
   describe('#find', function () {
-    it('should call Knowledge Elements API', async function () {
+    let knowledgeElementsApi_findFilteredMostRecentByUserStub;
+    let skillsApi_findByIdsStub;
+    let campaignsApi_findCampaignSkillIdsForCampaignParticipationsStub;
+
+    beforeEach(function () {
+      knowledgeElementsApi_findFilteredMostRecentByUserStub = sinon.stub().named('findFilteredMostRecentByUser');
+      skillsApi_findByIdsStub = sinon.stub().named('findByIds');
+      campaignsApi_findCampaignSkillIdsForCampaignParticipationsStub = sinon
+        .stub()
+        .named('findCampaignSkillIdsForCampaignParticipations');
+      preventStubsToBeCalledUnexpectedly([
+        knowledgeElementsApi_findFilteredMostRecentByUserStub,
+        skillsApi_findByIdsStub,
+        campaignsApi_findCampaignSkillIdsForCampaignParticipationsStub,
+      ]);
+    });
+
+    it('should return a Success model according to data fetched from diverse APIs', async function () {
       // given
       const userId = Symbol('userId');
-      const knowledgeElements = Symbol('knowledgeElements');
+      const knowledgeElements = [{ skillId: 'A' }, { skillId: 'B' }];
+      const campaignParticipationIds = Symbol('campaignParticipationIds');
+      const campaignSkillIds = Symbol('campaignSkillIds');
+      const skills = [
+        { id: 'A', tubeId: 'AA' },
+        { id: 'B', tubeId: 'BB' },
+      ];
       const knowledgeElementsApi = {
-        findFilteredMostRecentByUser: sinon.stub(),
+        findFilteredMostRecentByUser: knowledgeElementsApi_findFilteredMostRecentByUserStub,
+      };
+      const skillsApi = {
+        findByIds: skillsApi_findByIdsStub,
+      };
+      const campaignsApi = {
+        findCampaignSkillIdsForCampaignParticipations: campaignsApi_findCampaignSkillIdsForCampaignParticipationsStub,
       };
-      knowledgeElementsApi.findFilteredMostRecentByUser.withArgs({ userId }).resolves(knowledgeElements);
+      knowledgeElementsApi_findFilteredMostRecentByUserStub.withArgs({ userId }).resolves(knowledgeElements);
+      campaignsApi.findCampaignSkillIdsForCampaignParticipations
+        .withArgs(campaignParticipationIds)
+        .resolves(campaignSkillIds);
+      skillsApi_findByIdsStub.withArgs({ ids: campaignSkillIds }).resolves(skills);
 
       // when
       const result = await successRepository.find({
         userId,
+        campaignParticipationIds,
         knowledgeElementsApi,
+        campaignsApi,
+        skillsApi,
       });
 
       // then
       expect(result).to.be.an.instanceof(Success);
-      expect(result.knowledgeElements).to.equal(knowledgeElements);
+      expect(result.knowledgeElements).to.deepEqualArray(knowledgeElements);
+      expect(result.skillsForKnowledgeElements).to.equal(skills);
     });
   });
 });
