[FEATURE] ajoute le fitre lacune dans la route /assessment-results (pix-16350)

pix-service-auto-merge · web-flow · commit 9f9eb0f04d92 · 2025-02-17T15:24:36.000+01:00
#11392
diff --git a/api/db/seeds/data/team-prescription/build-campaigns.js b/api/db/seeds/data/team-prescription/build-campaigns.js
@@ -143,6 +143,10 @@ async function _createProGenericCampaigns(databaseBuilder) {
 }
 
 async function _createProCampaigns(databaseBuilder) {
+  await databaseBuilder.factory.buildTargetProfileShare({
+    targetProfileId: TARGET_PROFILE_BADGES_STAGES_ID,
+    organizationId: PRO_ORGANIZATION_ID,
+  });
   await createProfilesCollectionCampaign({
     campaignId: CAMPAIGN_PROCOLMUL_ID,
     databaseBuilder,
diff --git a/api/db/seeds/data/team-prescription/build-target-profiles.js b/api/db/seeds/data/team-prescription/build-target-profiles.js
@@ -70,7 +70,7 @@ async function _createTargetProfileWithBadgesStages(databaseBuilder) {
     cappedTubesDTO,
     badgeId: BADGES_TUBES_CAMP_ID,
     altMessage: '1 RT double critère Campaign & Tubes',
-    imageUrl: 'some_image.svg',
+    imageUrl: 'https://images.pix.fr/badges/abcpix_je_navigue_sur_internet.svg',
     message: '1 RT double critère Campaign & Tubes',
     title: '1 RT double critère Campaign & Tubes',
     key: `SOME_KEY_FOR_RT_${BADGES_TUBES_CAMP_ID}`,
@@ -84,7 +84,7 @@ async function _createTargetProfileWithBadgesStages(databaseBuilder) {
     cappedTubesDTO,
     badgeId: BADGES_CAMP_ID,
     altMessage: '1 RT simple critère Campaign',
-    imageUrl: 'some_other_image.svg',
+    imageUrl: 'https://images.pix.fr/badges/Badge_OLYMPIX.svg',
     message: '1 RT simple critère Campaign',
     title: '1 RT simple critère Campaign',
     key: `SOME_KEY_FOR_RT_${BADGES_CAMP_ID}`,
diff --git a/api/src/prescription/campaign/application/campaign-results-controller.js b/api/src/prescription/campaign/application/campaign-results-controller.js
@@ -5,27 +5,20 @@ import * as campaignAssessmentResultMinimalSerializer from '../infrastructure/se
 import * as campaignCollectiveResultSerializer from '../infrastructure/serializers/jsonapi/campaign-collective-result-serializer.js';
 import * as campaignProfilesCollectionParticipationSummarySerializer from '../infrastructure/serializers/jsonapi/campaign-profiles-collection-participation-summary-serializer.js';
 
-const findAssessmentParticipationResults = async function (request) {
+const findAssessmentParticipationResults = async function (
+  request,
+  h,
+  dependencies = { campaignAssessmentResultMinimalSerializer },
+) {
   const { campaignId } = request.params;
   const { page, filter: filters } = request.query;
-  if (filters.divisions && !Array.isArray(filters.divisions)) {
-    filters.divisions = [filters.divisions];
-  }
-  if (filters.groups && !Array.isArray(filters.groups)) {
-    filters.groups = [filters.groups];
-  }
-  if (filters.badges && !Array.isArray(filters.badges)) {
-    filters.badges = [filters.badges];
-  }
-  if (filters.stages && !Array.isArray(filters.stages)) {
-    filters.stages = [filters.stages];
-  }
+
   const paginatedParticipations = await usecases.findAssessmentParticipationResultList({
     campaignId,
     page,
     filters,
   });
-  return campaignAssessmentResultMinimalSerializer.serialize(paginatedParticipations);
+  return dependencies.campaignAssessmentResultMinimalSerializer.serialize(paginatedParticipations);
 };
 
 const findProfilesCollectionParticipations = async function (request) {
diff --git a/api/src/prescription/campaign/application/campaign-results-route.js b/api/src/prescription/campaign/application/campaign-results-route.js
@@ -19,8 +19,9 @@ const register = async function (server) {
             filter: Joi.object({
               divisions: Joi.array().items(Joi.string()),
               groups: Joi.array().items(Joi.string()),
-              badges: [Joi.number().integer(), Joi.array().items(Joi.number().integer())],
-              stages: [Joi.number().integer(), Joi.array().items(Joi.number().integer())],
+              badges: Joi.array().items(Joi.number().integer()),
+              unacquiredBadges: Joi.array().items(Joi.number().integer()),
+              stages: Joi.array().items(Joi.number().integer()),
               search: Joi.string().empty(''),
             }).default({}),
             page: {
diff --git a/api/src/prescription/campaign/domain/errors.js b/api/src/prescription/campaign/domain/errors.js
@@ -58,8 +58,18 @@ class CampaignParticipationDoesNotBelongToUser extends DomainError {
   }
 }
 
+class AssessmentParticipationResultFilterError extends DomainError {
+  constructor() {
+    super(
+      'Filtering on both acquired and unacquired using the same badge id is impossible',
+      'ASSESSMENT_PARTICIPATION_RESULT_FILTER_ERROR',
+    );
+  }
+}
+
 export {
   ArchivedCampaignError,
+  AssessmentParticipationResultFilterError,
   CampaignCodeFormatError,
   CampaignParticipationDoesNotBelongToUser,
   CampaignUniqueCodeError,
diff --git a/api/src/prescription/campaign/domain/usecases/find-assessment-participation-result-list.js b/api/src/prescription/campaign/domain/usecases/find-assessment-participation-result-list.js
@@ -1,9 +1,14 @@
+import { AssessmentParticipationResultFilterError } from '../errors.js';
+
 async function findAssessmentParticipationResultList({
   campaignId,
   filters,
   page,
   campaignAssessmentParticipationResultListRepository,
 }) {
+  if (filters?.badges?.some((id) => filters?.unacquiredBadges?.includes(id))) {
+    throw new AssessmentParticipationResultFilterError();
+  }
   return campaignAssessmentParticipationResultListRepository.findPaginatedByCampaignId({ campaignId, filters, page });
 }
 
diff --git a/api/src/prescription/campaign/infrastructure/repositories/campaign-assessment-participation-result-list-repository.js b/api/src/prescription/campaign/infrastructure/repositories/campaign-assessment-participation-result-list-repository.js
@@ -32,7 +32,8 @@ function _getParticipantsResultList(campaignId, stageCollection, filters) {
     .with('campaign_participation_summaries', (qb) => _getParticipations(qb, campaignId, stageCollection, filters))
     .select('*')
     .from('campaign_participation_summaries')
-    .modify(_filterByBadgeAcquisitionsOut, filters)
+    .modify(_filterByAcquiredBadges, filters)
+    .modify(_filterByUnacquiredBadges, filters)
     .orderByRaw('LOWER(??) ASC, LOWER(??) ASC', ['lastName', 'firstName']);
 }
 
@@ -116,10 +117,10 @@ function _filterBySearch(queryBuilder, filters) {
 }
 
 function _addAcquiredBadgeIds(queryBuilder, filters) {
-  if (filters.badges) {
+  if (filters.badges || filters.unacquiredBadges) {
     queryBuilder
       .select(knex.raw('ARRAY_AGG("badgeId") OVER (PARTITION BY "campaign-participations"."id") as badges_acquired'))
-      .join('badge-acquisitions', 'badge-acquisitions.campaignParticipationId', 'campaign-participations.id')
+      .leftJoin('badge-acquisitions', 'badge-acquisitions.campaignParticipationId', 'campaign-participations.id')
       .distinctOn('campaign-participations.id', 'campaign-participations.organizationLearnerId');
   }
 }
@@ -133,18 +134,26 @@ function _orderBy(queryBuilder, filters) {
       nulls: 'last',
     },
   ];
-  if (filters.badges) {
+  if (filters.badges || filters.unacquiredBadges) {
     orderByClauses.unshift({ column: 'campaign-participations.id' });
   }
   queryBuilder.orderBy(orderByClauses);
 }
 
-function _filterByBadgeAcquisitionsOut(queryBuilder, filters) {
+function _filterByAcquiredBadges(queryBuilder, filters) {
   if (filters.badges) {
     queryBuilder.whereRaw(':badgeIds <@ "badges_acquired"', { badgeIds: filters.badges });
   }
 }
 
+function _filterByUnacquiredBadges(queryBuilder, filters) {
+  if (filters.unacquiredBadges) {
+    queryBuilder.whereRaw(':badgeIds && "badges_acquired" is false', {
+      badgeIds: filters.unacquiredBadges,
+    });
+  }
+}
+
 function _filterByStage(queryBuilder, stageCollection, filters) {
   if (!filters.stages) return;
   const allBoundaries = stageCollection.getThresholdBoundaries();
diff --git a/api/tests/prescription/campaign/integration/infrastructure/repositories/campaign-assessment-participation-result-list-repository_test.js b/api/tests/prescription/campaign/integration/infrastructure/repositories/campaign-assessment-participation-result-list-repository_test.js
@@ -934,6 +934,137 @@ describe('Integration | Repository | Campaign Assessment Participation Result Li
       });
     });
 
+    context('when there is a filter on unacquiredBadges', function () {
+      let badge1, badge2;
+      let user1, user2;
+      let participation1, participation2;
+
+      beforeEach(async function () {
+        campaign = databaseBuilder.factory.buildAssessmentCampaignForSkills({}, [{ id: 'Skill1' }]);
+        badge1 = databaseBuilder.factory.buildBadge({ key: 'badge1', targetProfileId: campaign.targetProfileId });
+        badge2 = databaseBuilder.factory.buildBadge({ key: 'badge2', targetProfileId: campaign.targetProfileId });
+        user1 = databaseBuilder.factory.buildUser();
+        user2 = databaseBuilder.factory.buildUser();
+
+        participation1 = databaseBuilder.factory.buildCampaignParticipation({
+          campaignId: campaign.id,
+          userId: user1.id,
+        });
+        participation2 = databaseBuilder.factory.buildCampaignParticipation({
+          campaignId: campaign.id,
+          userId: user2.id,
+        });
+
+        await databaseBuilder.commit();
+      });
+
+      it('returns participants which does not have badge1', async function () {
+        databaseBuilder.factory.buildBadgeAcquisition({
+          badgeId: badge1.id,
+          userId: participation1.userId,
+          campaignParticipationId: participation1.id,
+        });
+        databaseBuilder.factory.buildBadgeAcquisition({
+          badgeId: badge2.id,
+          userId: participation2.userId,
+          campaignParticipationId: participation2.id,
+        });
+        await databaseBuilder.commit();
+
+        // when
+        const { participations } = await campaignAssessmentParticipationResultListRepository.findPaginatedByCampaignId({
+          campaignId: campaign.id,
+          filters: { unacquiredBadges: [badge1.id] },
+        });
+
+        const participantExternalIds = participations.map((result) => result.campaignParticipationId);
+
+        // then
+        expect(participantExternalIds).to.exactlyContain([participation2.id]);
+      });
+
+      it('returns participants which does not have badge1 nor badge2', async function () {
+        databaseBuilder.factory.buildBadgeAcquisition({
+          badgeId: badge1.id,
+          userId: participation1.userId,
+          campaignParticipationId: participation1.id,
+        });
+        await databaseBuilder.commit();
+
+        // when
+        const { participations } = await campaignAssessmentParticipationResultListRepository.findPaginatedByCampaignId({
+          campaignId: campaign.id,
+          filters: { unacquiredBadges: [badge1.id, badge2.id] },
+        });
+
+        const participantExternalIds = participations.map((result) => result.campaignParticipationId);
+
+        // then
+        expect(participantExternalIds).to.exactlyContain([participation2.id]);
+      });
+
+      it('returns no participant that have badge1 or badge2', async function () {
+        databaseBuilder.factory.buildBadgeAcquisition({
+          badgeId: badge1.id,
+          userId: participation1.userId,
+          campaignParticipationId: participation1.id,
+        });
+
+        databaseBuilder.factory.buildBadgeAcquisition({
+          badgeId: badge2.id,
+          userId: participation2.userId,
+          campaignParticipationId: participation2.id,
+        });
+        await databaseBuilder.commit();
+
+        // when
+        const { participations } = await campaignAssessmentParticipationResultListRepository.findPaginatedByCampaignId({
+          campaignId: campaign.id,
+          filters: { unacquiredBadges: [badge1.id, badge2.id] },
+        });
+
+        // then
+        expect(participations).to.be.empty;
+      });
+    });
+
+    context('when there is a filter on both unacquiredBadges and badges', function () {
+      let badge1;
+      let user1;
+      let participation1;
+
+      beforeEach(async function () {
+        campaign = databaseBuilder.factory.buildAssessmentCampaignForSkills({}, [{ id: 'Skill1' }]);
+        badge1 = databaseBuilder.factory.buildBadge({ key: 'badge1', targetProfileId: campaign.targetProfileId });
+        user1 = databaseBuilder.factory.buildUser();
+
+        participation1 = databaseBuilder.factory.buildCampaignParticipation({
+          campaignId: campaign.id,
+          userId: user1.id,
+        });
+        await databaseBuilder.commit();
+      });
+
+      it('returns no participant if acquired and unacquired badge have an id in common', async function () {
+        databaseBuilder.factory.buildBadgeAcquisition({
+          badgeId: badge1.id,
+          userId: participation1.userId,
+          campaignParticipationId: participation1.id,
+        });
+
+        await databaseBuilder.commit();
+
+        // when
+        const { participations } = await campaignAssessmentParticipationResultListRepository.findPaginatedByCampaignId({
+          campaignId: campaign.id,
+          filters: { badges: [badge1.id], unacquiredBadges: [badge1.id] },
+        });
+
+        // then
+        expect(participations).to.be.empty;
+      });
+    });
+
     context('when there is a filter on stage', function () {
       beforeEach(async function () {
         const learningContent = [
diff --git a/api/tests/prescription/campaign/unit/application/campaign-results-controller_test.js b/api/tests/prescription/campaign/unit/application/campaign-results-controller_test.js
@@ -64,4 +64,52 @@ describe('Unit | Application | Controller | Campaign Results', function () {
       expect(errorCatched).to.be.instanceof(UserNotAuthorizedToAccessEntityError);
     });
   });
+
+  describe('#findAssessmentParticipationResults', function () {
+    const campaignId = 1;
+    const userId = 1;
+    const locale = FRENCH_SPOKEN;
+    let campaignAssessmentResultMinimalSerializer;
+    let pageSymbol, filterSymbol, resultSymbol, serializerResponseSymbol;
+
+    beforeEach(function () {
+      sinon.stub(usecases, 'findAssessmentParticipationResultList');
+      campaignAssessmentResultMinimalSerializer = {
+        serialize: sinon.stub(),
+      };
+      pageSymbol = Symbol('pageSymbol');
+      filterSymbol = Symbol('filter');
+      resultSymbol = Symbol('result');
+      serializerResponseSymbol = Symbol('serialize');
+    });
+
+    it('should return serialized results', async function () {
+      // given
+      usecases.findAssessmentParticipationResultList
+        .withArgs({
+          campaignId,
+          page: pageSymbol,
+          filters: filterSymbol,
+        })
+        .resolves(resultSymbol);
+      campaignAssessmentResultMinimalSerializer.serialize.withArgs(resultSymbol).resolves(serializerResponseSymbol);
+      const request = {
+        auth: { credentials: { userId } },
+        params: { campaignId },
+        query: {
+          page: pageSymbol,
+          filter: filterSymbol,
+        },
+        headers: { 'accept-language': locale },
+      };
+
+      // when
+      const response = await campaignResultsController.findAssessmentParticipationResults(request, hFake, {
+        campaignAssessmentResultMinimalSerializer,
+      });
+
+      // then
+      expect(response).to.equal(serializerResponseSymbol);
+    });
+  });
 });
diff --git a/api/tests/prescription/campaign/unit/domain/usecases/find-assessment-participation-result-list_test.js b/api/tests/prescription/campaign/unit/domain/usecases/find-assessment-participation-result-list_test.js
@@ -1,26 +1,38 @@
+import { AssessmentParticipationResultFilterError } from '../../../../../../src/prescription/campaign/domain/errors.js';
 import { findAssessmentParticipationResultList } from '../../../../../../src/prescription/campaign/domain/usecases/find-assessment-participation-result-list.js';
-import { expect, sinon } from '../../../../../test-helper.js';
+import { catchErr, expect, sinon } from '../../../../../test-helper.js';
 
 describe('Unit | UseCase | find-assessment-participation-result-list', function () {
   it('return the assessmentParticipationResultMinimal list', async function () {
     const findPaginatedByCampaignId = sinon.stub();
-    const checkIfUserOrganizationHasAccessToCampaign = sinon.stub();
     const campaignId = 1;
     const filters = Symbol('filters');
     const page = Symbol('page');
     const participations = Symbol('participations');
     findPaginatedByCampaignId.resolves(participations);
-    checkIfUserOrganizationHasAccessToCampaign.resolves(true);
 
     const results = await findAssessmentParticipationResultList({
       campaignId,
       filters,
       page,
       campaignAssessmentParticipationResultListRepository: { findPaginatedByCampaignId },
-      campaignRepository: { checkIfUserOrganizationHasAccessToCampaign },
     });
 
     expect(findPaginatedByCampaignId).to.have.been.calledWithExactly({ page, campaignId, filters });
     expect(results).to.equal(participations);
   });
+
+  it('throw when filter contain the same id on both badge and unacquiredBadge filters', async function () {
+    const campaignId = 1;
+    const filters = { unacquiredBadges: [1, 3], badges: [1, 2] };
+    const page = Symbol('page');
+
+    const error = await catchErr(findAssessmentParticipationResultList)({
+      campaignId,
+      filters,
+      page,
+    });
+
+    expect(error).instanceOf(AssessmentParticipationResultFilterError);
+  });
 });
