[TECH] Déplacer la route des contenus formatifs vers le domaine Dev Comp (PIX-16249).

 #11285

Author: pix-service-auto-merge

api/lib/application/target-profiles/index.js

@@ -7,7 +7,6 @@ import * as frameworks from './application/frameworks/index.js';
 import * as memberships from './application/memberships/index.js';
 import * as organizations from './application/organizations/index.js';
 import * as scoOrganizationLearners from './application/sco-organization-learners/index.js';
-import * as targetProfiles from './application/target-profiles/index.js';
 import * as users from './application/users/index.js';
 
 const routes = [
@@ -19,7 +18,6 @@ const routes = [
   memberships,
   organizations,
   scoOrganizationLearners,
-  targetProfiles,
   frameworks,
   users,
 ];

api/lib/application/target-profiles/target-profile-controller.js

@@ -286,6 +286,35 @@ const register = async function (server) {
         ],
       },
     },
+    {
+      method: 'GET',
+      path: '/api/admin/target-profiles/{id}/training-summaries',
+      config: {
+        pre: [
+          {
+            method: (request, h) =>
+              securityPreHandlers.hasAtLeastOneAccessOf([
+                securityPreHandlers.checkAdminMemberHasRoleSuperAdmin,
+                securityPreHandlers.checkAdminMemberHasRoleSupport,
+                securityPreHandlers.checkAdminMemberHasRoleMetier,
+              ])(request, h),
+            assign: 'hasAuthorizationToAccessAdminScope',
+          },
+        ],
+        validate: {
+          params: Joi.object({
+            id: identifiersType.targetProfileId,
+          }),
+        },
+        handler: trainingsController.findPaginatedTrainingsSummariesByTargetProfileId,
+        tags: ['api', 'admin', 'target-profiles', 'trainings'],
+        notes: [
+          "- **Cette route est restreinte aux utilisateurs authentifiés ayant les droits d'accès**\n" +
+            '- Elle permet de récupérer les résumés des contenus formatifs liés au profil cible',
+        ],
+      },
+    },
+
     {
       method: 'DELETE',
       path: '/api/admin/trainings/{trainingId}/target-profiles/{targetProfileId}',

api/lib/routes.js

@@ -77,8 +77,24 @@ const detachTargetProfile = async function (request, h) {
   return h.response({}).code(204);
 };
 
+const findPaginatedTrainingsSummariesByTargetProfileId = async function (
+  request,
+  h,
+  dependencies = { trainingSummarySerializer },
+) {
+  const { page } = request.query;
+  const targetProfileId = request.params.id;
+
+  const { trainings, meta } = await usecases.findPaginatedTargetProfileTrainingSummaries({
+    targetProfileId,
+    page,
+  });
+  return dependencies.trainingSummarySerializer.serialize(trainings, meta);
+};
+
 const trainingController = {
   findPaginatedTrainingSummaries,
+  findPaginatedTrainingsSummariesByTargetProfileId,
   findTargetProfileSummaries,
   getById,
   create,

api/src/devcomp/application/trainings/index.js

@@ -552,4 +552,48 @@ describe('Acceptance | Controller | training-controller', function () {
       expect(result).to.deepEqualArray([]);
     });
   });
+
+  describe('GET /api/admin/target-profiles/{id}/training-summaries', function () {
+    let user;
+    let targetProfileId;
+    let training;
+
+    beforeEach(async function () {
+      targetProfileId = databaseBuilder.factory.buildTargetProfile().id;
+      training = databaseBuilder.factory.buildTraining();
+      databaseBuilder.factory.buildTargetProfileTraining({ targetProfileId, trainingId: training.id });
+      user = databaseBuilder.factory.buildUser.withRole();
+
+      await databaseBuilder.commit();
+    });
+
+    it('should return 200', async function () {
+      const options = {
+        method: 'GET',
+        url: `/api/admin/target-profiles/${targetProfileId}/training-summaries`,
+        headers: generateAuthenticatedUserRequestHeaders({ userId: user.id }),
+      };
+
+      // when
+      const response = await server.inject(options);
+
+      // then
+      expect(response.statusCode).to.equal(200);
+      const expectedData = [
+        {
+          type: 'training-summaries',
+          id: training.id.toString(),
+          attributes: {
+            'goal-threshold': undefined,
+            'prerequisite-threshold': undefined,
+            'is-disabled': false,
+            'target-profiles-count': 1,
+            title: 'title',
+            'internal-title': 'internal title',
+          },
+        },
+      ];
+      expect(response.result.data).to.deep.equal(expectedData);
+    });
+  });
 });

api/src/devcomp/application/trainings/training-controller.js

@@ -1624,4 +1624,79 @@ describe('Integration | Devcomp | Application | Trainings | Router | training-ro
       });
     });
   });
+
+  describe('GET /api/admin/target-profiles/{id}/training-summaries', function () {
+    const method = 'GET';
+    const url = '/api/admin/target-profiles/1/training-summaries';
+
+    context('when user has role "SUPER_ADMIN", "SUPPORT" or "METIER"', function () {
+      it('should return a response with an HTTP status code 200', async function () {
+        // given
+        sinon
+          .stub(securityPreHandlers, 'hasAtLeastOneAccessOf')
+          .withArgs([
+            securityPreHandlers.checkAdminMemberHasRoleSuperAdmin,
+            securityPreHandlers.checkAdminMemberHasRoleSupport,
+            securityPreHandlers.checkAdminMemberHasRoleMetier,
+          ])
+          .callsFake(() => (request, h) => h.response(true));
+        sinon
+          .stub(trainingController, 'findPaginatedTrainingsSummariesByTargetProfileId')
+          .callsFake((request, h) => h.response('ok').code(200));
+        const httpTestServer = new HttpTestServer();
+        await httpTestServer.register(moduleUnderTest);
+
+        // when
+        const { statusCode } = await httpTestServer.request(method, url);
+
+        // then
+        expect(statusCode).to.equal(200);
+      });
+
+      context('when id is not an integer', function () {
+        it('should reject request with HTTP code 400', async function () {
+          // given
+          const httpTestServer = new HttpTestServer();
+          await httpTestServer.register(moduleUnderTest);
+
+          // when
+          const { statusCode } = await httpTestServer.request(
+            method,
+            '/api/admin/target-profiles/azerty/training-summaries',
+          );
+
+          // then
+          expect(statusCode).to.equal(400);
+        });
+      });
+    });
+
+    context('when user has role "CERTIF"', function () {
+      it('should return a response with an HTTP status code 403', async function () {
+        // given
+        sinon
+          .stub(securityPreHandlers, 'hasAtLeastOneAccessOf')
+          .withArgs([
+            securityPreHandlers.checkAdminMemberHasRoleSuperAdmin,
+            securityPreHandlers.checkAdminMemberHasRoleSupport,
+            securityPreHandlers.checkAdminMemberHasRoleMetier,
+          ])
+          .callsFake(
+            () => (request, h) =>
+              h
+                .response({ errors: new Error('forbidden') })
+                .code(403)
+                .takeover(),
+          );
+        const httpTestServer = new HttpTestServer();
+        await httpTestServer.register(moduleUnderTest);
+
+        // when
+        const { statusCode } = await httpTestServer.request(method, url);
+
+        // then
+        expect(statusCode).to.equal(403);
+      });
+    });
+  });
 });

api/tests/acceptance/application/target-profiles/index_test.js

@@ -356,4 +356,46 @@ describe('Unit | Devcomp | Application | Trainings | Controller | training-contr
       expect(usecases.attachTargetProfilesToTraining).to.have.been.calledWithExactly({ trainingId, targetProfileIds });
     });
   });
+
+  describe('#findPaginatedTrainingsSummariesByTargetProfileId', function () {
+    it('should return trainings summaries', async function () {
+      // given
+      const targetProfileId = 123;
+      const expectedResult = Symbol('serialized-training-summaries');
+      const trainingSummaries = Symbol('trainingSummaries');
+      const meta = Symbol('meta');
+      const useCaseParameters = {
+        targetProfileId,
+        page: { size: 2, number: 1 },
+      };
+
+      sinon.stub(usecases, 'findPaginatedTargetProfileTrainingSummaries').resolves({
+        trainings: trainingSummaries,
+        meta,
+      });
+
+      const trainingSummarySerializer = {
+        serialize: sinon.stub(),
+      };
+      trainingSummarySerializer.serialize.withArgs(trainingSummaries, meta).returns(expectedResult);
+
+      // when
+      const response = await trainingController.findPaginatedTrainingsSummariesByTargetProfileId(
+        {
+          params: {
+            id: targetProfileId,
+          },
+          query: {
+            page: { size: 2, number: 1 },
+          },
+        },
+        hFake,
+        { trainingSummarySerializer },
+      );
+
+      // then
+      expect(usecases.findPaginatedTargetProfileTrainingSummaries).to.have.been.calledWithExactly(useCaseParameters);
+      expect(response).to.deep.equal(expectedResult);
+    });
+  });
 });