[FEATURE] Mettre à jour la route de récupération de stages dans orga (P…

…IX-8914)

api/lib/domain/usecases/get-campaign-participations-counts-by-stage.js

@@ -1,46 +1,62 @@
 // eslint-disable-next-line eslint-comments/disable-enable-pair
 /* eslint-disable import/no-restricted-paths */
-import * as stageCollectionRepository from '../../infrastructure/repositories/user-campaign-results/stage-collection-repository.js';
+import * as defaultStageRepository from '../../infrastructure/repositories/stage-repository.js';
+import * as defaultStageAcquisitionRepository from '../../infrastructure/repositories/stage-acquisition-repository.js';
 import { UserNotAuthorizedToAccessEntityError, NoStagesForCampaign } from '../errors.js';
+import * as defaultStageAndStageAcquisitionComparisonService from '../services/stages/stage-and-stage-acquisition-comparison-service.js';
 
 const getCampaignParticipationsCountByStage = async function ({
   userId,
   campaignId,
   campaignRepository,
-  campaignParticipationRepository,
+  stageRepository = defaultStageRepository,
+  stageAndStageAcquisitionComparisonService = defaultStageAndStageAcquisitionComparisonService,
+  stageAcquisitionRepository = defaultStageAcquisitionRepository,
 }) {
   if (!(await campaignRepository.checkIfUserOrganizationHasAccessToCampaign(campaignId, userId))) {
     throw new UserNotAuthorizedToAccessEntityError('User does not belong to the organization that owns the campaign');
   }
 
-  const stageCollection = await stageCollectionRepository.findStageCollection({ campaignId });
+  const stages = await stageRepository.getByCampaignId(campaignId);
 
-  if (!stageCollection.hasStage) {
+  if (!stages.length) {
     throw new NoStagesForCampaign();
   }
 
-  const participantsResults = await campaignParticipationRepository.getAllParticipationsByCampaignId(campaignId);
+  const stageAcquisitions = await stageAcquisitionRepository.getByCampaignId(campaignId);
 
-  const participantsByStage = stageCollection.stages.map((stage, index) => ({
+  const uniqueCampaignParticipationIds = [
+    ...new Set(stageAcquisitions.map((stageAcquisition) => stageAcquisition.campaignParticipationId)),
+  ];
+
+  const stagesInfos = stages.map((stage, index) => ({
     id: stage.id,
     value: 0,
     reachedStage: index + 1,
-    totalStage: stageCollection.totalStages,
+    totalStage: stages.length,
     title: stage.prescriberTitle,
     description: stage.prescriberDescription,
   }));
 
-  participantsResults.forEach((participantResult) => {
-    const stageReached = stageCollection.getReachedStage(
-      participantResult.validatedSkillsCount,
-      participantResult.masteryRate * 100,
+  uniqueCampaignParticipationIds.forEach((campaignParticipationId) => {
+    const stageAcquisitionForCampaignParticipation = stageAcquisitions.filter(
+      (stageAcquisition) => stageAcquisition.campaignParticipationId === campaignParticipationId,
+    );
+
+    const stagesInformation = stageAndStageAcquisitionComparisonService.compare(
+      stages,
+      stageAcquisitionForCampaignParticipation,
     );
 
-    const stageIndex = participantsByStage.findIndex((data) => data.id === stageReached.id);
-    participantsByStage[stageIndex].value++;
+    const stageReached = stagesInformation.reachedStage;
+
+    if (!stageReached) return;
+
+    const stageIndex = stagesInfos.findIndex((data) => data.id === stageReached.id);
+    stagesInfos[stageIndex].value++;
   });
 
-  return participantsByStage;
+  return stagesInfos;
 };
 
 export { getCampaignParticipationsCountByStage };

api/lib/infrastructure/repositories/stage-acquisition-repository.js

@@ -29,7 +29,6 @@ const toDomain = (stageAcquisitionData) =>
 
 /**
  * @param {Knex} knexConnection
- * @param {string[]} selectedFields
  *
  * @returns {*}
  */
@@ -90,6 +89,25 @@ const getByCampaignIdAndUserId = async (campaignId, userId, knexConnection = kne
       .orderBy(`${STAGE_ACQUISITIONS_TABLE_NAME}.id`),
   );
 
+/**
+ * @param {number} campaignId
+ * @param {Knex} knexConnection
+ *
+ * @returns {Promise<StageAcquisition[]>}
+ */
+const getByCampaignId = async (campaignId, knexConnection = knex) =>
+  toDomain(
+    await buildSelectAllQuery(knexConnection)
+      .join(
+        'campaign-participations',
+        'campaign-participations.id',
+        `${STAGE_ACQUISITIONS_TABLE_NAME}.${CAMPAIGN_PARTICIPATION_ID_COLUMN}`,
+      )
+      .join('campaigns', 'campaigns.id', 'campaign-participations.campaignId')
+      .where('campaigns.id', campaignId)
+      .orderBy(`${STAGE_ACQUISITIONS_TABLE_NAME}.id`),
+  );
+
 /**
  * @param {Stage[]} stages
  * @param {number} userId
@@ -108,9 +126,10 @@ const saveStages = async (stages, userId, campaignParticipationId, knexConnectio
 };
 
 export {
-  getByCampaignParticipations,
+  getByCampaignId,
   getByCampaignIdAndUserId,
-  saveStages,
   getByCampaignParticipation,
+  getByCampaignParticipations,
   getStageIdsByCampaignParticipation,
+  saveStages,
 };

api/tests/acceptance/application/campaigns/campaign-stats-controller_test.js

@@ -16,7 +16,7 @@ describe('Acceptance | API | Campaign Stats Controller', function () {
   });
 
   describe('GET /api/campaigns/{id}/stats/participations-by-stage', function () {
-    it('should return the campaign by id', async function () {
+    it('should return the campaign with stages information', async function () {
       // given
       const learningContentObjects = learningContentBuilder.fromAreas([
         {
@@ -58,7 +58,32 @@ describe('Acceptance | API | Campaign Stats Controller', function () {
       databaseBuilder.factory.buildCampaignSkill({ campaignId: campaign.id, skillId: 'recSkillId1' });
       databaseBuilder.factory.buildCampaignSkill({ campaignId: campaign.id, skillId: 'recSkillId2' });
       const userId = databaseBuilder.factory.buildUser().id;
+      const anotherUserId = databaseBuilder.factory.buildUser().id;
       databaseBuilder.factory.buildMembership({ organizationId: campaign.organizationId, userId });
+      databaseBuilder.factory.buildMembership({ organizationId: campaign.organizationId, userId: anotherUserId });
+      const campaignParticipation = databaseBuilder.factory.buildCampaignParticipation({
+        userId,
+        campaignId: campaign.id,
+      });
+      const anotherCampaignParticipation = databaseBuilder.factory.buildCampaignParticipation({
+        userId: anotherUserId,
+        campaignId: campaign.id,
+      });
+      databaseBuilder.factory.buildStageAcquisition({
+        stageId: stage1.id,
+        userId,
+        campaignParticipationId: campaignParticipation.id,
+      });
+      databaseBuilder.factory.buildStageAcquisition({
+        stageId: stage2.id,
+        userId,
+        campaignParticipationId: campaignParticipation.id,
+      });
+      databaseBuilder.factory.buildStageAcquisition({
+        stageId: stage1.id,
+        userId: anotherUserId,
+        campaignParticipationId: anotherCampaignParticipation.id,
+      });
       await databaseBuilder.commit();
 
       // when
@@ -74,13 +99,20 @@ describe('Acceptance | API | Campaign Stats Controller', function () {
       expect(response.result.data.attributes.data).to.deep.equal([
         {
           id: stage1.id,
-          value: 0,
+          value: 1,
           title: stage1.prescriberTitle,
           description: stage1.prescriberDescription,
           'reached-stage': 1,
           'total-stage': 2,
         },
-        { id: stage2.id, value: 0, title: null, description: null, 'reached-stage': 2, 'total-stage': 2 },
+        {
+          id: stage2.id,
+          value: 1,
+          title: stage2.prescriberTitle,
+          description: stage2.prescriberDescription,
+          'reached-stage': 2,
+          'total-stage': 2,
+        },
       ]);
     });
 

api/tests/integration/domain/usecases/get-campaign-participations-counts-by-stage_test.js

@@ -14,6 +14,7 @@ describe('Integration | UseCase | get-campaign-participations-counts-by-stage',
   let campaignId;
   let userId;
   let stage1, stage2, stage3;
+  let campaignParticipation1, campaignParticipation2, campaignParticipation3, campaignParticipation4;
 
   beforeEach(async function () {
     const learningContentObjects = learningContentBuilder.fromAreas([
@@ -58,10 +59,12 @@ describe('Integration | UseCase | get-campaign-participations-counts-by-stage',
     stage2 = databaseBuilder.factory.buildStage({ targetProfileId, threshold: 30 });
     stage3 = databaseBuilder.factory.buildStage({ targetProfileId, threshold: 70 });
     campaignId = databaseBuilder.factory.buildCampaign({ organizationId, targetProfileId }).id;
-    databaseBuilder.factory.buildCampaignSkill({ campaignId, skillId: 'recSkillId1' });
-    databaseBuilder.factory.buildCampaignSkill({ campaignId, skillId: 'recSkillId2' });
-    databaseBuilder.factory.buildCampaignSkill({ campaignId, skillId: 'recSkillId3' });
-    databaseBuilder.factory.buildCampaignSkill({ campaignId, skillId: 'recSkillId4' });
+    campaignParticipation1 = databaseBuilder.factory.buildCampaignParticipation({ campaignId });
+    campaignParticipation2 = databaseBuilder.factory.buildCampaignParticipation({ campaignId });
+    campaignParticipation3 = databaseBuilder.factory.buildCampaignParticipation({ campaignId });
+    campaignParticipation4 = databaseBuilder.factory.buildCampaignParticipation({ campaignId });
+
+    await databaseBuilder.commit();
   });
 
   context('when requesting user is not allowed to access campaign informations', function () {
@@ -81,8 +84,9 @@ describe('Integration | UseCase | get-campaign-participations-counts-by-stage',
     });
   });
 
-  context('when the campaign doesnt manage stages', function () {
+  context('when the campaign has no stages', function () {
     it('should throw a NoStagesForCampaign error', async function () {
+      // given
       const campaign2 = databaseBuilder.factory.buildCampaign({ organizationId });
       databaseBuilder.factory.buildCampaignSkill({ campaignId: campaign2.id, skillId: 'recSkillId1' });
       await databaseBuilder.commit();
@@ -99,11 +103,48 @@ describe('Integration | UseCase | get-campaign-participations-counts-by-stage',
     });
   });
 
-  context('when the campaign manage stages', function () {
-    it('should return participations counts by stages', async function () {
-      databaseBuilder.factory.buildCampaignParticipation({ campaignId, masteryRate: 0 });
-      databaseBuilder.factory.buildCampaignParticipation({ campaignId, masteryRate: 0.31 });
-      databaseBuilder.factory.buildCampaignParticipation({ campaignId, masteryRate: 0.72 });
+  context('when the campaign has stages', function () {
+    it('should return acquisitions counts by stages', async function () {
+      // given
+      [
+        // campaignParticipation1
+        {
+          stageId: stage1.id,
+          campaignParticipationId: campaignParticipation1.id,
+        },
+        {
+          stageId: stage2.id,
+          campaignParticipationId: campaignParticipation1.id,
+        },
+        {
+          stageId: stage3.id,
+          campaignParticipationId: campaignParticipation1.id,
+        },
+        // campaignParticipation2
+        {
+          stageId: stage1.id,
+          campaignParticipationId: campaignParticipation2.id,
+        },
+        {
+          stageId: stage2.id,
+          campaignParticipationId: campaignParticipation2.id,
+        },
+        // campaignParticipation3
+        {
+          stageId: stage1.id,
+          campaignParticipationId: campaignParticipation3.id,
+        },
+        // campaignParticipation4
+        {
+          stageId: stage1.id,
+          campaignParticipationId: campaignParticipation4.id,
+        },
+        {
+          stageId: stage2.id,
+          campaignParticipationId: campaignParticipation4.id,
+        },
+      ].map(databaseBuilder.factory.buildStageAcquisition);
+
       await databaseBuilder.commit();
 
       // when
@@ -119,14 +160,12 @@ describe('Integration | UseCase | get-campaign-participations-counts-by-stage',
           reachedStage: 1,
           totalStage: 3,
         },
-        { id: stage2.id, value: 1, title: null, description: null, reachedStage: 2, totalStage: 3 },
+        { id: stage2.id, value: 2, title: null, description: null, reachedStage: 2, totalStage: 3 },
         { id: stage3.id, value: 1, title: null, description: null, reachedStage: 3, totalStage: 3 },
       ]);
     });
 
-    it('should set to 0 all participation counts when no participations', async function () {
-      await databaseBuilder.commit();
-
+    it('should set to 0 all participation counts when no stage acquisitions', async function () {
       // when
       const result = await usecases.getCampaignParticipationsCountByStage({ userId, campaignId });
 

api/tests/integration/infrastructure/repositories/stage-acquisition-repository_test.js

@@ -1,5 +1,6 @@
 import { expect, databaseBuilder, knex } from '../../../test-helper.js';
 import {
+  getByCampaignId,
   getByCampaignIdAndUserId,
   getByCampaignParticipation,
   getByCampaignParticipations,
@@ -108,6 +109,8 @@ describe('Integration | Repository | Stage Acquisition', function () {
 
       // then
       expect(result.length).to.deep.equal(2);
+      expect(result[0].campaignParticipationId).to.equal(firstStage.campaignParticipationId);
+      expect(result[1].campaignParticipationId).to.equal(secondStage.campaignParticipationId);
     });
   });
 
@@ -156,6 +159,62 @@ describe('Integration | Repository | Stage Acquisition', function () {
     });
   });
 
+  describe('getByCampaignId', function () {
+    let stage;
+    let campaign;
+    let campaignParticipation, campaignParticipation2, campaignParticipation3;
+    let targetProfile;
+
+    beforeEach(async function () {
+      // given
+      targetProfile = databaseBuilder.factory.buildTargetProfile();
+      databaseBuilder.factory.buildStage({ targetProfileId: targetProfile.id });
+      campaign = databaseBuilder.factory.buildCampaign({ targetProfileId: targetProfile.id });
+      stage = databaseBuilder.factory.buildStage({ campaignId: campaign.id });
+      campaignParticipation = databaseBuilder.factory.buildCampaignParticipation({ campaignId: campaign.id });
+      campaignParticipation2 = databaseBuilder.factory.buildCampaignParticipation({ campaignId: campaign.id });
+      campaignParticipation3 = databaseBuilder.factory.buildCampaignParticipation({ campaignId: campaign.id });
+      databaseBuilder.factory.buildStageAcquisition({
+        campaignParticipationId: campaignParticipation.id,
+        stageId: stage.id,
+      });
+      databaseBuilder.factory.buildStageAcquisition({
+        campaignParticipationId: campaignParticipation2.id,
+        stageId: stage.id,
+      });
+      databaseBuilder.factory.buildStageAcquisition({
+        campaignParticipationId: campaignParticipation3.id,
+        stageId: stage.id,
+      });
+
+      await databaseBuilder.commit();
+    });
+
+    afterEach(async function () {
+      await knex('stage-acquisitions').delete();
+    });
+
+    it('should return StageAcquisition instances', async function () {
+      // when
+      const stageAcquisitions = await getByCampaignId(campaign.id);
+
+      // then
+      expect(stageAcquisitions[0]).to.be.instanceof(StageAcquisition);
+      expect(stageAcquisitions.length).to.equal(3);
+      expect(stageAcquisitions[0].campaignParticipationId).to.equal(campaignParticipation.id);
+      expect(stageAcquisitions[1].campaignParticipationId).to.equal(campaignParticipation2.id);
+      expect(stageAcquisitions[2].campaignParticipationId).to.equal(campaignParticipation3.id);
+    });
+
+    it('should return the expected stages', async function () {
+      // when
+      const result = await getByCampaignId(campaign.id);
+
+      // then
+      expect(result[0].stageId).to.deep.equal(stage.id);
+    });
+  });
+
   describe('saveStages', function () {
     let targetProfile;
     let stages;