feat(api): implement check and update for inactif confirme candidacies

- add cron job to check and update inactive candidacies to INACTIF_CONFIRME status
- create archiveCandidacies function to handle archiving of candidacies
- add new types for archiving candidacies in candidacy.types.ts
- implement checkAndUpdateCandidaciesInactifConfirme function for batch processing

Author: ThomasDos

packages/reva-api/infra/cron.ts

@@ -5,6 +5,7 @@ import path from "path";
 import { CronJob } from "cron";
 import dotenv from "dotenv";
 
+import { checkAndUpdateCandidaciesInactifConfirme } from "@/modules/candidacy/features/checkAndUpdateCandidaciesInactifConfirme";
 import { checkAndUpdateCandidaciesInactifEnAttente } from "@/modules/candidacy/features/checkAndUpdateCandidaciesInactifEnAttente";
 
 import { deleteExpiredCandidacies } from "../modules/candidacy/features/deleteExpiredCandidacies";
@@ -24,6 +25,7 @@ dotenv.config({ path: path.join(process.cwd(), "..", "..", ".env") });
 
 const EVERY_DAY_AT_1_AM = "0 1 * * *";
 const EVERY_DAY_AT_1_30_AM = "30 1 * * *";
+const EVERY_DAY_AT_1_45_AM = "45 1 * * *";
 const EVERY_DAY_AT_2_AM = "0 2 * * *";
 const EVERY_DAY_AT_3_AM = "0 3 * * *";
 
@@ -222,4 +224,23 @@ CronJob.from({
   timeZone: "Europe/Paris",
 });
 
+// Vérification de l'activité des candidatures inactives en attente
+// Si la candidature est inactive depuis 15 jours, on la met à jour en INACTIF_CONFIRME
+// Mise à jour de l'activité des candidatures du statut INACTIF_EN_ATTENTE vers INACTIF_CONFIRME
+CronJob.from({
+  cronTime:
+    process.env.BATCH_UPDATE_CANDIDACIES_INACTIF_CONFIRME_CRONTIME ||
+    EVERY_DAY_AT_1_45_AM,
+  onTick: () =>
+    runBatchIfActive({
+      batchKey: "batch.update-candidacies-inactif-confirme",
+      batchCallback: async () => {
+        logger.info("Running batch.update-candidacies-inactif-confirme");
+        await checkAndUpdateCandidaciesInactifConfirme();
+      },
+    }),
+  start: true,
+  timeZone: "Europe/Paris",
+});
+
 logger.info(`Started cron jobs with APP_ENV = "${process.env.APP_ENV}"`);

packages/reva-api/modules/candidacy/candidacy.types.ts

@@ -109,3 +109,9 @@ export interface ArchiveCandidacyParams {
   archivingReason: CandidacyArchivingReason;
   archivingReasonAdditionalInformation?: string | null;
 }
+
+export interface ArchiveCandidaciesParams {
+  candidacyIds: string[];
+  archivingReason: CandidacyArchivingReason;
+  archivingReasonAdditionalInformation?: string | null;
+}

packages/reva-api/modules/candidacy/features/archiveCandidacies.ts

@@ -0,0 +1,58 @@
+import { logger } from "@/modules/shared/logger";
+import { prismaClient } from "@/prisma/client";
+
+import { ArchiveCandidaciesParams } from "../candidacy.types";
+
+export const archiveCandidacies = async (params: ArchiveCandidaciesParams) => {
+  const candidaciesToArchive = await prismaClient.candidacy.findMany({
+    where: {
+      id: {
+        in: params.candidacyIds,
+      },
+      status: {
+        not: "ARCHIVE",
+      },
+    },
+    select: {
+      id: true,
+    },
+  });
+
+  if (candidaciesToArchive.length === 0) {
+    return [];
+  }
+
+  const candidaciesToArchiveIds = candidaciesToArchive.map(
+    (candidacy) => candidacy.id,
+  );
+
+  try {
+    return prismaClient.$transaction(async (tx) => {
+      await tx.candidacy.updateMany({
+        where: {
+          id: {
+            in: candidaciesToArchiveIds,
+          },
+        },
+        data: {
+          status: "ARCHIVE",
+          archivingReason: params.archivingReason,
+          archivingReasonAdditionalInformation:
+            params.archivingReasonAdditionalInformation || null,
+        },
+      });
+
+      await tx.candidaciesStatus.createMany({
+        data: candidaciesToArchive.map((candidacy) => ({
+          candidacyId: candidacy.id,
+          status: "ARCHIVE",
+        })),
+      });
+    });
+  } catch (e) {
+    logger.error(e);
+    throw new Error(
+      `Erreur lors de l'archivage des candidatures ${params.candidacyIds.join(", ")}`,
+    );
+  }
+};

packages/reva-api/modules/candidacy/features/checkAndUpdateCandidaciesInactifConfirme.ts

@@ -0,0 +1,114 @@
+import { ActiviteStatut } from "@prisma/client";
+import { subDays } from "date-fns";
+
+import { logger } from "@/modules/shared/logger";
+import { prismaClient } from "@/prisma/client";
+
+import {
+  INACTIF_CONFIRME_TRIGGER_DAYS,
+  INACTIF_TRIGGER_AFTER_FEASIBILITY_CANDIDACY_STATUSES,
+  INACTIF_TRIGGER_BEFORE_FEASIBILITY_CANDIDACY_STATUSES,
+} from "../constants/candidacy-inactif.constant";
+
+import { archiveCandidacies } from "./archiveCandidacies";
+import { dropOutCandidacies } from "./dropOutCandidacies";
+
+export const checkAndUpdateCandidaciesInactifConfirme = async () => {
+  const thresholdDateInactifConfirme = subDays(
+    new Date(),
+    INACTIF_CONFIRME_TRIGGER_DAYS,
+  );
+
+  try {
+    // Candidatures inactives en attente avant d'avoir un dossier de faisabilité admissible
+    const candidaciesInactifEnAttenteBeforeFeasibilityAdmissibleToArchive =
+      await prismaClient.candidacy.findMany({
+        where: {
+          activite: ActiviteStatut.INACTIF_EN_ATTENTE,
+          status: {
+            in: INACTIF_TRIGGER_BEFORE_FEASIBILITY_CANDIDACY_STATUSES,
+          },
+          dateInactifEnAttente: {
+            lte: thresholdDateInactifConfirme,
+          },
+          candidacyDropOut: {
+            is: null,
+          },
+        },
+        select: {
+          id: true,
+        },
+      });
+
+    const candidaciesToArchiveIds =
+      candidaciesInactifEnAttenteBeforeFeasibilityAdmissibleToArchive.map(
+        ({ id }) => id,
+      );
+    if (candidaciesToArchiveIds.length) {
+      await archiveCandidacies({
+        candidacyIds: candidaciesToArchiveIds,
+        archivingReason: "INACTIVITE_CANDIDAT",
+      });
+      await prismaClient.candidacy.updateMany({
+        where: {
+          id: {
+            in: candidaciesToArchiveIds,
+          },
+        },
+        data: {
+          activite: ActiviteStatut.INACTIF_CONFIRME,
+        },
+      });
+    }
+
+    // Candidatures inactives en attente après avoir un dossier de faisabilité admissible
+    const candidaciesInactifEnAttenteAfterFeasibilityAdmissibleToDropOut =
+      await prismaClient.candidacy.findMany({
+        where: {
+          activite: ActiviteStatut.INACTIF_EN_ATTENTE,
+          status: {
+            in: INACTIF_TRIGGER_AFTER_FEASIBILITY_CANDIDACY_STATUSES,
+          },
+          dateInactifEnAttente: {
+            lte: thresholdDateInactifConfirme,
+          },
+          candidacyDropOut: {
+            is: null,
+          },
+        },
+        select: {
+          id: true,
+        },
+      });
+
+    const candidacyToDropOutIds =
+      candidaciesInactifEnAttenteAfterFeasibilityAdmissibleToDropOut.map(
+        ({ id }) => id,
+      );
+
+    if (candidacyToDropOutIds.length) {
+      const dropOutReasonId = await prismaClient.dropOutReason.findFirst({
+        where: {
+          label: "Inactivité depuis 6 mois",
+        },
+      });
+      await dropOutCandidacies({
+        candidacyIds: candidacyToDropOutIds,
+        dropOutReasonId: dropOutReasonId?.id || "",
+      });
+
+      await prismaClient.candidacy.updateMany({
+        where: {
+          id: {
+            in: candidacyToDropOutIds,
+          },
+        },
+        data: {
+          activite: ActiviteStatut.INACTIF_CONFIRME,
+        },
+      });
+    }
+  } catch (error) {
+    logger.error(error);
+  }
+};