[TECH] Ne plus planifier de job unitaire pour chaque calcul de certificabilité.

 #11287

Author: pix-service-auto-merge

api/src/prescription/learner-management/application/jobs/schedule-compute-organization-learners-certificability-job-controller.js

@@ -8,6 +8,7 @@ import { DomainTransaction } from '../../../../shared/domain/DomainTransaction.j
 import * as organizationLearnerRepository from '../../../../shared/infrastructure/repositories/organization-learner-repository.js';
 import { logger } from '../../../../shared/infrastructure/utils/logger.js';
 import { computeCertificabilityJobRepository } from '../../../learner-management/infrastructure/repositories/jobs/compute-certificability-job-repository.js';
+import { usecases } from '../../domain/usecases/index.js';
 
 class ScheduleComputeOrganizationLearnersCertificabilityJobController extends JobScheduleController {
   constructor() {
@@ -26,8 +27,11 @@ class ScheduleComputeOrganizationLearnersCertificabilityJobController extends Jo
   }) {
     const skipLoggedLastDayCheck = data?.skipLoggedLastDayCheck;
     const onlyNotComputed = data?.onlyNotComputed;
-    const chunkSize = dependencies.config.features.scheduleComputeOrganizationLearnersCertificability.chunkSize;
-    const cronConfig = dependencies.config.features.scheduleComputeOrganizationLearnersCertificability.cron;
+    const {
+      chunkSize,
+      cron: cronConfig,
+      synchronously,
+    } = dependencies.config.features.scheduleComputeOrganizationLearnersCertificability;
 
     const isolationLevel = 'repeatable read';
 
@@ -71,6 +75,17 @@ class ScheduleComputeOrganizationLearnersCertificabilityJobController extends Jo
             `ScheduleComputeOrganizationLearnersCertificabilityJobHandler - Ids count  : ${organizationLearnerIds.length}`,
           );
 
+          if (synchronously) {
+            for (const organizationLearnerId of organizationLearnerIds) {
+              await usecases.computeOrganizationLearnerCertificability({ organizationLearnerId });
+            }
+
+            dependencies.logger.info(
+              `ScheduleComputeOrganizationLearnersCertificabilityJobHandler - Certificability computed count : ${organizationLearnerIds.length}`,
+            );
+            continue;
+          }
+
           const jobsToInsert = organizationLearnerIds.map(
             (organizationLearnerId) => new ComputeCertificabilityJob({ organizationLearnerId }),
           );
@@ -83,6 +98,13 @@ class ScheduleComputeOrganizationLearnersCertificabilityJobController extends Jo
           );
         }
 
+        if (synchronously) {
+          dependencies.logger.info(
+            `ScheduleComputeOrganizationLearnersCertificabilityJobHandler - Total certificability computed count : ${totalJobsInserted}`,
+          );
+
+          return;
+        }
         dependencies.logger.info(
           `ScheduleComputeOrganizationLearnersCertificabilityJobHandler - Total jobs inserted count : ${totalJobsInserted}`,
         );

api/src/shared/config.js

@@ -249,6 +249,7 @@ const configuration = (function () {
       scheduleComputeOrganizationLearnersCertificability: {
         cron: process.env.SCHEDULE_COMPUTE_LEARNERS_CERTIFICABILITY_JOB_CRON || '0 21 * * *',
         chunkSize: process.env.SCHEDULE_COMPUTE_LEARNERS_CERTIFICABILITY_CHUNK_SIZE || 1000,
+        synchronously: process.env.SCHEDULE_COMPUTE_LEARNERS_CERTIFICABILITY_SYNCHRONOUSLY || false,
       },
       scoAccountRecoveryKeyLifetimeMinutes: process.env.SCO_ACCOUNT_RECOVERY_KEY_LIFETIME_MINUTES,
     },

api/tests/prescription/learner-management/integration/application/jobs/schedule-compute-organization-learners-certificability-job-controller_test.js

@@ -32,31 +32,64 @@ describe('Integration | Infrastructure | Jobs | scheduleComputeOrganizationLearn
       };
     });
 
-    it('should schedule multiple ComputeCertificabilityJob', async function () {
-      // given
-      const scheduleComputeOrganizationLearnersCertificabilityJobHandler =
-        new ScheduleComputeOrganizationLearnersCertificabilityJobController();
-
-      // when
-      await scheduleComputeOrganizationLearnersCertificabilityJobHandler.handle({
-        data: { skipLoggedLastDayCheck: true, onlyNotComputed: false },
-        dependencies: {
-          logger,
-          organizationLearnerRepository,
-          computeCertificabilityJobRepository,
-          config: {
-            features: {
-              scheduleComputeOrganizationLearnersCertificability: {
-                chunkSize: 2,
-                cron: '0 21 * * *',
+    context('when computation is asynchronous', function () {
+      it('should schedule multiple ComputeCertificabilityJob', async function () {
+        // given
+        const scheduleComputeOrganizationLearnersCertificabilityJobHandler =
+          new ScheduleComputeOrganizationLearnersCertificabilityJobController();
+
+        // when
+        await scheduleComputeOrganizationLearnersCertificabilityJobHandler.handle({
+          data: { skipLoggedLastDayCheck: true, onlyNotComputed: false },
+          dependencies: {
+            logger,
+            organizationLearnerRepository,
+            computeCertificabilityJobRepository,
+            config: {
+              features: {
+                scheduleComputeOrganizationLearnersCertificability: {
+                  chunkSize: 2,
+                  cron: '0 21 * * *',
+                  synchronously: false,
+                },
               },
             },
           },
-        },
+        });
+
+        // then
+        await expect('ComputeCertificabilityJob').to.have.been.performed.withJobsCount(2);
       });
-      // then
+    });
 
-      await expect('ComputeCertificabilityJob').to.have.been.performed.withJobsCount(2);
+    context('when computation is synchronous', function () {
+      it('should not schedule any ComputeCertificabilityJob', async function () {
+        // given
+        const scheduleComputeOrganizationLearnersCertificabilityJobHandler =
+          new ScheduleComputeOrganizationLearnersCertificabilityJobController();
+
+        // when
+        await scheduleComputeOrganizationLearnersCertificabilityJobHandler.handle({
+          data: { skipLoggedLastDayCheck: true, onlyNotComputed: false },
+          dependencies: {
+            logger,
+            organizationLearnerRepository,
+            computeCertificabilityJobRepository,
+            config: {
+              features: {
+                scheduleComputeOrganizationLearnersCertificability: {
+                  chunkSize: 2,
+                  cron: '0 21 * * *',
+                  synchronously: true,
+                },
+              },
+            },
+          },
+        });
+
+        // then
+        await expect('ComputeCertificabilityJob').to.have.been.performed.withJobsCount(0);
+      });
     });
   });
 });