fix(stats): close stats periods

.talismanrc

@@ -1,8 +1,8 @@
 fileignoreconfig:
 - filename: _scripts/db/dumps/domifa_test.postgres.restore-data-only.sql
-  checksum: efba4cbbb8096c89a0c7dc6bc3923186d659b235b19d71ff2a97bb92fd799e41
+  checksum: 5a6dd4fe960a2aaaf31ac459b0e88e54b9b972e2cc2ba0d625e5c0de52155b1a
 - filename: _scripts/db/dumps/domifa_test.postgres.truncate-restore-data-only.sql
-  checksum: d0dac15ae96ec0a7e3045051f1640293934148cadb08aaaa5121b0e1070cc8fa
+  checksum: 0241639f53b87b4d8ab0e8ab8a733f7460fac1dac4dc2b05f0c9f7ac3bd169f0
 - filename: packages/backend/src/_common/decorators/IsValidPasswordDecorator.ts
   checksum: f0d4b3cd2e6e2d9b1e0271c34d64adacf87a5f1e7a505402a20869962543608d
 - filename: packages/backend/src/_migrations/1699910877010-auto-migration.ts

packages/backend/src/_migrations/1704813167013-manual-migration.ts

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class ManualMigration1704813167013 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`update usager_history set migrated = false`);
+  }
+
+  public async down(_queryRunner: QueryRunner): Promise<void> {
+    //
+  }
+}

packages/backend/src/_migrations/1704813169210-update-end-date-migration.ts

@@ -0,0 +1,79 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { In, MigrationInterface, QueryRunner } from "typeorm";
+import { UsagerHistory, UsagerHistoryState } from "../_common/model";
+import { usagerHistoryRepository } from "../database";
+import { getHistoryEndDateFromNextBeginDate } from "../usagers/services";
+
+export class UpdateEndDateHistoryMigration1704813169210
+  implements MigrationInterface
+{
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const total = await this.countHistoriesToMigrate();
+
+    console.log(total);
+
+    for (let cpt = 0; cpt <= total; cpt = cpt + 2000) {
+      console.log(`${cpt}/${total} migrated`);
+      const usagerHistories: UsagerHistory[] =
+        await usagerHistoryRepository.find({
+          where: { migrated: false },
+          order: {
+            structureId: "DESC",
+            usagerRef: "DESC",
+          },
+          take: 2000,
+        });
+
+      await queryRunner.startTransaction();
+      const uuidsToUpdate = [];
+      for (const history of usagerHistories) {
+        let needUdpate = false;
+
+        const states: UsagerHistoryState[] = history.states;
+
+        for (let i = 0; i < states.length - 1; i++) {
+          const state = states[i];
+
+          const nextState = states[i + 1];
+          if (typeof nextState !== "undefined" && !state?.historyEndDate) {
+            needUdpate = true;
+            states[i].historyEndDate = getHistoryEndDateFromNextBeginDate(
+              nextState.historyBeginDate
+            );
+            console.log({
+              structureId: history.structureId,
+              usagerRef: history.usagerRef,
+              historyBeginDate: state.historyBeginDate,
+              historyEndDate: state.historyEndDate,
+              NewHistoryEndDate: states[i].historyEndDate,
+            });
+            console.log();
+          }
+        }
+
+        if (needUdpate) {
+          await usagerHistoryRepository.update(
+            { uuid: history.uuid },
+            { states: history.states }
+          );
+        }
+
+        uuidsToUpdate.push(history.uuid);
+      }
+
+      await usagerHistoryRepository.update(
+        { uuid: In(uuidsToUpdate) },
+        { migrated: true }
+      );
+      await queryRunner.commitTransaction();
+    }
+  }
+
+  public async down(_queryRunner: QueryRunner): Promise<void> {
+    //
+  }
+
+  private countHistoriesToMigrate(): Promise<number> {
+    return usagerHistoryRepository.countBy({ migrated: false });
+  }
+}

packages/backend/src/database/services/_scripts/data-anonymizer/dataUsagerAnonymizer.ts

@@ -12,6 +12,7 @@ import { usagerRepository } from "../../usager/usagerRepository.service";
 import { dataGenerator } from "./dataGenerator.service";
 import { dataStructureAnonymizer } from "./dataStructureAnonymizer";
 import { UsagerAyantDroit, UsagerDecision } from "@domifa/common";
+import { myDataSource } from "../../_postgres";
 
 export const dataUsagerAnonymizer = {
   anonymizeUsagers,
@@ -45,16 +46,23 @@ async function anonymizeUsagers() {
   });
 
   const usagersToAnonymize = usagers.filter((x) => isUsagerToAnonymize(x));
-
+  const queryRunner = myDataSource.createQueryRunner();
   appLogger.warn(
     `[dataUsagerAnonymizer] ${usagersToAnonymize.length}/${usagers.length} usagers to anonymize`
   );
   for (let i = 0; i < usagersToAnonymize.length; i++) {
     const usager = usagersToAnonymize[i];
+
+    if (i === 0) {
+      await queryRunner.startTransaction();
+    }
     if (i !== 0 && i % 5000 === 0) {
+      await queryRunner.commitTransaction();
+
       appLogger.warn(
         `[dataUsagerAnonymizer] ${i}/${usagersToAnonymize.length} usagers anonymized`
       );
+      await queryRunner.startTransaction();
     }
 
     try {
@@ -63,6 +71,7 @@ async function anonymizeUsagers() {
       console.log(e);
     }
   }
+  await queryRunner.commitTransaction();
 }
 
 function isUsagerToAnonymize(x: Usager): unknown {
@@ -113,7 +122,7 @@ async function _anonymizeUsager(usager: Usager) {
     return usager;
   }
 
-  return usagerRepository.updateOneAndReturn(usager.uuid, attributesToUpdate);
+  return usagerRepository.update({ uuid: usager.uuid }, attributesToUpdate);
 }
 
 function anonymizeAyantDroits(

packages/backend/src/usagers/controllers/usagers.controller.ts

@@ -189,7 +189,6 @@ export class UsagersController {
 
     await usagerHistoryStateManager.updateHistoryStateWithoutDecision({
       usager: currentUsager,
-
       createdEvent: "update-usager",
     });
 

packages/backend/src/usagers/services/usagerHistoryStateManager.service.ts

@@ -25,7 +25,7 @@ function getHistoryBeginDate(date: Date) {
   return startOfDay(new Date(date));
 }
 
-function getHistoryEndDateFromNextBeginDate(date: Date) {
+export function getHistoryEndDateFromNextBeginDate(date: Date) {
   return endOfDay(subDays(new Date(date), 1));
 }
 
@@ -141,42 +141,30 @@ function addNewStateToHistory({
   usagerHistory: UsagerHistory;
   newHistoryState: UsagerHistoryState;
 }) {
-  const states: UsagerHistoryState[] = [
-    ...usagerHistory.states.map((state, i) => {
-      // TODO: s'il s'agit d'une décision, rechercher la précédente décision pour indiquer qu'elle n'est plus valable
-      if (i === usagerHistory.states.length - 1) {
-        // finish previous history state
-        state.historyEndDate = getHistoryEndDateFromNextBeginDate(
-          newHistoryState.historyBeginDate
-        );
-      }
-      return state;
-    }),
-    newHistoryState,
-  ];
-
-  return {
-    ...usagerHistory,
-    states,
-  };
+  if (
+    typeof usagerHistory.states[usagerHistory.states.length - 1] !== "undefined"
+  ) {
+    usagerHistory.states[usagerHistory.states.length - 1].historyEndDate =
+      getHistoryEndDateFromNextBeginDate(newHistoryState.historyBeginDate);
+  }
+  usagerHistory.states.push(newHistoryState);
+  return usagerHistory;
 }
 
 async function updateHistoryStateWithoutDecision({
   usager,
-  createdAt = new Date(),
   createdEvent,
-  historyBeginDate = createdAt,
 }: {
   usager: Usager;
-
-  createdAt?: Date;
   createdEvent: UsagerHistoryStateCreationEvent;
-  historyBeginDate?: Date;
 }): Promise<UsagerHistory> {
   const usagerHistory: UsagerHistory = await usagerHistoryRepository.findOneBy({
     usagerUUID: usager.uuid,
   });
 
+  const createdAt = new Date();
+  const historyBeginDate = createdAt;
+
   const newHistoryState: UsagerHistoryState = buildHistoryState({
     usager,
     usagerHistory,