bugfix(api): add script to re-finalize not fully finalized ession

Author: alexandrecoin

api/scripts/certification/fix-not-fully-finalized-session.js

@@ -0,0 +1,64 @@
+import 'dotenv/config';
+
+import { usecases } from '../../src/certification/session-management/domain/usecases/index.js';
+import * as sessionRepository from '../../src/certification/session-management/infrastructure/repositories/session-repository.js';
+import * as certificationReportRepository from '../../src/certification/shared/infrastructure/repositories/certification-report-repository.js';
+import { Script } from '../../src/shared/application/scripts/script.js';
+import { ScriptRunner } from '../../src/shared/application/scripts/script-runner.js';
+import { DomainTransaction } from '../../src/shared/domain/DomainTransaction.js';
+
+export class FixNotFullyFinalizedSession extends Script {
+  constructor() {
+    super({
+      description: 'Re-finalize session without finalized-session entry',
+      permanent: false,
+      options: {
+        sessionId: {
+          type: 'integer',
+          describe: 'Id of the session to be finalized',
+          demandOption: true,
+          requiresArg: true,
+        },
+      },
+    });
+  }
+
+  async handle({
+    options,
+    logger,
+    finalizeSession = usecases.finalizeSession,
+    unfinalizeSession = usecases.unfinalizeSession,
+    processAutoJury = usecases.processAutoJury,
+    registerPublishableSession = usecases.registerPublishableSession,
+  } = {}) {
+    await DomainTransaction.execute(async () => {
+      const { sessionId } = options;
+      this.logger = logger;
+
+      this.logger.info(`Updating session ${sessionId}.`);
+
+      await unfinalizeSession({ sessionId });
+
+      const { examinerGlobalComment, hasIncident, hasJoiningIssue } = await sessionRepository.get({ id: sessionId });
+      const certificationReports = await certificationReportRepository.findBySessionId({ sessionId });
+
+      const sessionFinalized = await finalizeSession({
+        sessionId,
+        certificationReports,
+        examinerGlobalComment,
+        hasIncident,
+        hasJoiningIssue,
+      });
+
+      const autoJuryDone = await processAutoJury({ sessionFinalized });
+
+      await registerPublishableSession({ autoJuryDone });
+
+      this.logger.info(`${sessionId} finalized`);
+
+      return 0;
+    });
+  }
+}
+
+await ScriptRunner.execute(import.meta.url, FixNotFullyFinalizedSession);

api/tests/integration/scripts/certification/fix-not-fully-finalized-session_test.js

@@ -0,0 +1,64 @@
+import { FixNotFullyFinalizedSession } from '../../../../scripts/certification/fix-not-fully-finalized-session.js';
+import { databaseBuilder, expect, knex, sinon } from '../../../test-helper.js';
+
+describe('Integration | Scripts | Certification | fix not fully finalized session', function () {
+  let assessment, certificationCourse, session, fixNotFullyFinalizedSessionScript, logger;
+
+  beforeEach(async function () {
+    session = databaseBuilder.factory.buildSession({
+      version: 2,
+      finalizedAt: new Date('2024-01-02T00:00:00Z'),
+    });
+    const user = databaseBuilder.factory.buildUser();
+    databaseBuilder.factory.buildCertificationCandidate({
+      sessionId: session.id,
+      userId: user.id,
+    });
+    certificationCourse = databaseBuilder.factory.buildCertificationCourse({
+      createdAt: new Date('2024-02-01T00:00:00Z'),
+      sessionId: session.id,
+      userId: user.id,
+      completedAt: new Date('2024-02-01T08:00:00Z'),
+      isPublished: false,
+      isCancelled: false,
+      abortReason: null,
+      version: 2,
+      isRejectedForFraud: false,
+      endedAt: null,
+    });
+    assessment = databaseBuilder.factory.buildAssessment({
+      certificationCourseId: certificationCourse.id,
+      userId: user.id,
+      type: 'CERTIFICATION',
+      state: 'completed',
+      method: 'CERTIFICATION_DETERMINED',
+    });
+    databaseBuilder.factory.buildAssessmentResult({
+      assessmentId: assessment.id,
+      userId: user.id,
+      type: 'CERTIFICATION',
+      status: 'validated',
+    });
+
+    await databaseBuilder.commit();
+
+    logger = { info: sinon.stub() };
+    fixNotFullyFinalizedSessionScript = new FixNotFullyFinalizedSession();
+  });
+
+  it('creates a finalized session', async function () {
+    // when
+    await fixNotFullyFinalizedSessionScript.handle({
+      options: { sessionId: session.id },
+      logger,
+    });
+
+    // then
+    const { count: finalizedSessionCount } = await knex('finalized-sessions')
+      .where({ sessionId: session.id })
+      .count()
+      .first();
+
+    expect(finalizedSessionCount).to.equal(1);
+  });
+});