🚧 api: uncancel route

Author: AndreiaPena

api/src/certification/session-management/application/cancellation-controller.js

@@ -9,8 +9,10 @@ const cancel = async function (request, h) {
 };
 
 const uncancel = async function (request, h) {
+  const juryId = request.auth.credentials.userId;
   const certificationCourseId = request.params.certificationCourseId;
-  await usecases.uncancelCertificationCourse({ certificationCourseId });
+  await usecases.uncancel({ certificationCourseId, juryId });
+
   return h.response().code(204);
 };
 

api/src/certification/session-management/domain/usecases/cancel.js

@@ -35,5 +35,5 @@ export const cancel = async function ({
     juryId,
   });
 
-  return certificationRescoringRepository.execute({ certificationCancelledEvent });
+  return certificationRescoringRepository.execute({ event: certificationCancelledEvent });
 };

api/src/certification/session-management/domain/usecases/uncancel-certification-course.js

@@ -0,0 +1,33 @@
+/**
+ * @typedef {import('./index.js'.CertificationCourseRepository} CertificationCourseRepository
+ * @typedef {import('./index.js'.CertificationRescoringRepository} CertificationRescoringRepository
+ */
+
+import CertificationUncancelled from '../../../../shared/domain/events/CertificationUncancelled.js';
+
+/**
+ * @param {Object} params
+ * @param {number} params.certificationCourseId
+ * @param {number} params.juryId
+ * @param {CertificationCourseRepository} params.certificationCourseRepository
+ * @param {CertificationRescoringRepository} params.certificationRescoringRepository
+ */
+const uncancel = async function ({
+  certificationCourseId,
+  juryId,
+  certificationCourseRepository,
+  certificationRescoringRepository,
+}) {
+  const certificationCourse = await certificationCourseRepository.get({ id: certificationCourseId });
+  certificationCourse.uncancel();
+  await certificationCourseRepository.update({ certificationCourse });
+
+  const certificationUncancelledEvent = new CertificationUncancelled({
+    certificationCourseId: certificationCourse.getId(),
+    juryId,
+  });
+
+  return certificationRescoringRepository.execute({ event: certificationUncancelledEvent });
+};
+
+export { uncancel };

api/src/certification/session-management/domain/usecases/uncancel.js

@@ -1,15 +1,14 @@
 /**
- * @typedef {import('../../../../../src/shared/domain/events/CertificationCancelled.js'} CertificationCancelled
  * @typedef {import('./index.js'.LibServices} LibServices
  */
 
 /**
  * @param {Object} params
- * @param {CertificationCancelled} params.certificationCancelledEvent
+ * @param {??} params.event
  * @param {LibServices} params.libServices
  */
-export const execute = async ({ certificationCancelledEvent, libServices }) => {
+export const execute = async ({ event, libServices }) => {
   return libServices.handleCertificationRescoring({
-    event: certificationCancelledEvent,
+    event,
   });
 };

api/src/certification/session-management/infrastructure/repositories/certification-rescoring-repository.js

@@ -0,0 +1,15 @@
+import { assertNotNullOrUndefined } from '../models/asserts.js';
+
+export default class CertificationUncancelled {
+  /**
+   * @param {Object} params
+   * @param {number} params.certificationCourseId - certification course that will be rescored
+   * @param {number} params.juryId - Id of the jury member who uncancelled the certification
+   */
+  constructor({ certificationCourseId, juryId }) {
+    assertNotNullOrUndefined(certificationCourseId);
+    this.certificationCourseId = certificationCourseId;
+    assertNotNullOrUndefined(juryId);
+    this.juryId = juryId;
+  }
+}

api/src/shared/domain/events/CertificationUncancelled.js

@@ -15,6 +15,7 @@ import { CertificationResult } from '../models/index.js';
 import CertificationCancelled from './CertificationCancelled.js';
 import { CertificationCourseUnrejected } from './CertificationCourseUnrejected.js';
 import { CertificationRescoringCompleted } from './CertificationRescoringCompleted.js';
+import CertificationUncancelled from './CertificationUncancelled.js';
 import { checkEventTypes } from './check-event-types.js';
 
 const eventTypes = [
@@ -25,6 +26,7 @@ const eventTypes = [
   CertificationCourseUnrejected,
   CertificationCancelled,
   CertificationRescoredByScript,
+  CertificationUncancelled,
 ];
 
 /**
@@ -190,7 +192,11 @@ function _getEmitterFromEvent(event) {
     emitter = CertificationResult.emitters.PIX_ALGO_NEUTRALIZATION;
   }
 
-  if (event instanceof CertificationJuryDone || event instanceof CertificationRescoredByScript) {
+  if (
+    event instanceof CertificationJuryDone ||
+    event instanceof CertificationRescoredByScript ||
+    event instanceof CertificationUncancelled
+  ) {
     emitter = CertificationResult.emitters.PIX_ALGO_AUTO_JURY;
   }
 

api/src/shared/domain/events/handle-certification-rescoring.js

@@ -11,7 +11,7 @@ describe('Integration | Repository | certification-rescoring-repository', functi
 
       // when
       const error = await catchErr(sessionRepositories.certificationRescoringRepository.execute)({
-        certificationCancelledEvent,
+        event: certificationCancelledEvent,
       });
 
       // then

api/tests/certification/session-management/integration/infrastructure/repositories/certification-rescoring-repository_test.js

@@ -30,22 +30,27 @@ describe('Certification | Session-management | Unit | Application | Controller |
     });
   });
 
-  describe('#uncancelCertificationCourse', function () {
-    it('should call uncancel-certification-course usecase', async function () {
+  describe('#uncancel', function () {
+    it('should call uncancel usecase', async function () {
       // given
-      sinon.stub(usecases, 'uncancelCertificationCourse');
+      sinon.stub(usecases, 'uncancel');
       const request = {
+        auth: {
+          credentials: {
+            userId: 345,
+          },
+        },
         params: {
           certificationCourseId: 123,
         },
       };
-      usecases.uncancelCertificationCourse.resolves();
+      usecases.uncancel.resolves();
 
       // when
       await cancellationController.uncancel(request, hFake);
 
       // then
-      expect(usecases.uncancelCertificationCourse).to.have.been.calledWithExactly({ certificationCourseId: 123 });
+      expect(usecases.uncancel).to.have.been.calledWithExactly({ certificationCourseId: 123, juryId: 345 });
     });
   });
 });

api/tests/certification/session-management/unit/application/cancellation-controller_test.js

@@ -41,7 +41,7 @@ describe('Certification | Session-management | Unit | Domain | UseCases | cancel
       expect(certificationCourse.cancel).to.have.been.calledOnce;
       expect(certificationCourseRepository.update).to.have.been.calledWithExactly({ certificationCourse });
       expect(certificationRescoringRepository.execute).to.have.been.calledWithExactly({
-        certificationCancelledEvent: new CertificationCancelled({
+        event: new CertificationCancelled({
           certificationCourseId: certificationCourse.getId(),
           juryId,
         }),

api/tests/certification/session-management/unit/domain/usecases/cancel_test.js

@@ -1,26 +1,40 @@
-import { uncancelCertificationCourse } from '../../../../../../src/certification/session-management/domain/usecases/uncancel-certification-course.js';
+import { uncancel } from '../../../../../../src/certification/session-management/domain/usecases/uncancel.js';
+import CertificationUncancelled from '../../../../../../src/shared/domain/events/CertificationUncancelled.js';
 import { domainBuilder, expect, sinon } from '../../../../../test-helper.js';
 
-describe('Certification | Session-management | Unit | Domain | UseCases | uncancel-certification-course', function () {
+describe('Certification | Session-management | Unit | Domain | UseCases | uncancel', function () {
   it('should uncancel the certification course', async function () {
     // given
+    const juryId = 123;
     const certificationCourse = domainBuilder.buildCertificationCourse({ id: 123 });
     sinon.spy(certificationCourse, 'uncancel');
     const certificationCourseRepository = {
       update: sinon.stub(),
       get: sinon.stub(),
     };
+    const certificationRescoringRepository = {
+      execute: sinon.stub(),
+    };
     certificationCourseRepository.get.withArgs({ id: 123 }).resolves(certificationCourse);
     certificationCourseRepository.update.resolves();
+    certificationRescoringRepository.execute.resolves();
 
     // when
-    await uncancelCertificationCourse({
+    await uncancel({
       certificationCourseId: 123,
+      juryId,
       certificationCourseRepository,
+      certificationRescoringRepository,
     });
 
     // then
     expect(certificationCourse.uncancel).to.have.been.calledOnce;
     expect(certificationCourseRepository.update).to.have.been.calledWithExactly({ certificationCourse });
+    expect(certificationRescoringRepository.execute).to.have.been.calledWithExactly({
+      event: new CertificationUncancelled({
+        certificationCourseId: certificationCourse.getId(),
+        juryId,
+      }),
+    });
   });
 });