ajout d'un mode automatique pour la synchronisation

SESAME_IDENTITY_SYNC_MODE — valeurs manual (défaut) ou auto.
manuel : comportement par defaut, les identités modifiées restent à synchroniser
auto : les identitées qui sont modifiées sont automatiquement modifiées

le endpoint upsert

Author: alainabbas

apps/api/.env.example

@@ -9,3 +9,4 @@ SESAME_REDIS_URI="redis://sesame-redis:6379/0"
 SESAME_MONGO_URI="mongodb://sesame-mongodb:27017/sesame"
 # Adresse du frontal de changement de mot de passe
 SESAME_FRONT_MDP="http://localhost:3000"
+SESAME_IDENTITY_SYNC_MODE=manual

apps/api/src/config.ts

@@ -110,13 +110,28 @@ export const validationSchema = Joi.object({
 
   SESAME_IDENTITY_DOUBLON_SEARCH_ATTRIBUTES: Joi.string().default(''),
 
+  /**
+   * Mode de synchronisation des identités après une modification.
+   * - `manual` (défaut) : l'identité passe en TO_VALIDATE et attend une validation puis une synchronisation manuelle.
+   * - `auto` : l'identité passe directement en TO_SYNC et la synchronisation vers les backends est déclenchée.
+   */
+  SESAME_IDENTITY_SYNC_MODE: Joi.string().valid('manual', 'auto').default('manual'),
+
   /**
    * Active trust proxy Express (1 hop) pour que req.ip / X-Forwarded-For reflètent le client derrière un reverse-proxy.
    * @see https://expressjs.com/en/guide/behind-proxies.html
    */
   SESAME_TRUST_PROXY: Joi.string().valid('0', '1', 'false', 'true', 'on', 'off', '').default('0'),
 });
 
+/**
+ * Mode de synchronisation des identités après une modification
+ *
+ * @description `manual` conserve l'étape de validation avant synchronisation,
+ * `auto` déclenche la synchronisation vers les backends dès la modification.
+ */
+export type IdentitySyncMode = 'manual' | 'auto';
+
 /**
  * Configuration d'un plugin Mongoose
  *
@@ -214,6 +229,8 @@ export interface ConfigInstance {
   };
   identities: {
     doublonSearchAttributes: string[];
+    /** Mode de synchronisation appliqué après la modification d'une identité. */
+    syncMode: IdentitySyncMode;
   };
   swagger: {
     path: string;
@@ -355,6 +372,7 @@ export default (): ConfigInstance => ({
     doublonSearchAttributes: process.env['SESAME_IDENTITY_DOUBLON_SEARCH_ATTRIBUTES']
       ? process.env['SESAME_IDENTITY_DOUBLON_SEARCH_ATTRIBUTES'].split(',').map((attr) => attr.trim())
       : ['additionalFields.attributes.supannPerson.supannOIDCDatedeNaissance', 'inetOrgPerson.givenName'],
+    syncMode: /^auto$/i.test(process.env['SESAME_IDENTITY_SYNC_MODE'] || '') ? 'auto' : 'manual',
   },
   sms: {
     host: process.env['SESAME_SMPP_SERVER'] || '',

apps/api/src/management/identities/identities-crud.service.ts

@@ -17,6 +17,7 @@ import { Identities } from '~/management/identities/_schemas/identities.schema';
 import { BadRequestException, HttpException } from '@nestjs/common';
 import { CountOptions } from 'mongodb';
 import { IdentityLifecycleDefault, IdentityLifecycleState } from './_enums/lifecycle.enum';
+import { IdentitySyncMode } from '~/config';
 
 export const COUNT_ALL_MAX_ITERATIONS = 500;
 
@@ -70,7 +71,20 @@ export class IdentitiesCrudService extends AbstractIdentitiesService {
     //pour la validation le employeeNumber doit exister on en met un avec une valeur par defaut
     check.attributes.inetOrgPerson.employeeNumber = ['1'];
     const validations = await this._validation.validate(check);
+
+    // En mode <auto> (SESAME_IDENTITY_SYNC_MODE), l'identité est synchronisée dès sa création,
+    // sans passer par l'étape de validation manuelle.
+    const autoSync = this.isAutoSyncEnabled() && (data.state === undefined || data.state === IdentityState.TO_CREATE);
+    if (autoSync) {
+      data.state = IdentityState.TO_SYNC;
+    }
+
     const created: Document<T, any, T> = await super.create(data, options);
+
+    if (autoSync) {
+      await this.triggerAutoSync(created._id);
+    }
+
     return created;
   }
 
@@ -125,7 +139,9 @@ export class IdentitiesCrudService extends AbstractIdentitiesService {
       throw new HttpException('Uid ou mail déjà présent dans une autre identité', 400);
     }
     // if (update.state === IdentityState.TO_COMPLETE) {
-    update = { ...update, state: IdentityState.TO_VALIDATE };
+    // En mode <auto> (SESAME_IDENTITY_SYNC_MODE), l'identité est synchronisée sans validation manuelle.
+    const autoSync = this.isAutoSyncEnabled();
+    update = { ...update, state: autoSync ? IdentityState.TO_SYNC : IdentityState.TO_VALIDATE };
 
     await this.checkInetOrgPersonJpegPhoto(update);
 
@@ -135,8 +151,44 @@ export class IdentitiesCrudService extends AbstractIdentitiesService {
     // }
     //update.state = IdentityState.TO_VALIDATE;
     const updated = await super.update(_id, update, options);
-    //TODO: add backends service logic here (TO_SYNC)
-    return await this.generateFingerprint(updated as unknown as Identities);
+    const identity = await this.generateFingerprint<T>(updated as unknown as Identities);
+
+    if (autoSync) {
+      await this.triggerAutoSync(_id);
+    }
+
+    return identity;
+  }
+
+  /**
+   * Indique si la synchronisation automatique après modification est activée
+   *
+   * @returns true si SESAME_IDENTITY_SYNC_MODE vaut <auto>, false en mode manuel (défaut)
+   */
+  protected isAutoSyncEnabled(): boolean {
+    return this.config.get<IdentitySyncMode>('identities.syncMode') === 'auto';
+  }
+
+  /**
+   * Déclenche la synchronisation vers les backends d'une identité modifiée
+   *
+   * @description Une erreur de synchronisation n'invalide pas la modification : l'identité reste
+   * en état TO_SYNC et pourra être resynchronisée manuellement ou par un syncall.
+   * @param _id - Identifiant de l'identité à synchroniser
+   */
+  protected async triggerAutoSync(_id: Types.ObjectId | any): Promise<void> {
+    try {
+      await this.backends.syncIdentities([`${_id}`], {
+        async: true,
+        // L'identité bascule en PROCESSING dès la mise en file : elle n'apparaît pas
+        // dans les <identités à synchroniser> en attente d'une action manuelle.
+        switchToProcessing: true,
+        comment: 'Synchronisation automatique après modification',
+      });
+      this.logger.log(`Auto sync triggered for identity <${_id}>`);
+    } catch (error) {
+      this.logger.error(`Auto sync failed for identity <${_id}>: ${error?.message}`, error?.stack);
+    }
   }
 
   public async updateLifecycle<T extends AbstractSchema | Document>(

apps/web/src/layouts/default.vue

@@ -20,7 +20,6 @@ q-layout(view="hHh LpR lff" style="margin-top: -1px;")
 </template>
 
 <script lang="ts">
-import { IdentityState } from '~/constants/enums'
 import { useIdentityStateStore } from '~/stores/identityState'
 import { loadingBarDefaults } from '~/composables/useLoadingBarHijackFilter'
 import { attachSocketIoDebug } from '~/composables/useSocketIoDebug'
@@ -82,7 +81,8 @@ export default defineNuxtComponent({
       menuParts,
       getMenuByPart,
       identityStateStore,
-      eventSeamlessTotal: identityStateStore.getStateValue(IdentityState.PROCESSING),
+      // Le total est alimenté par l'action « tout synchroniser » ou déduit des jobs reçus via websocket.
+      eventSeamlessTotal: 0,
     }
   },
   computed: {
@@ -144,9 +144,11 @@ export default defineNuxtComponent({
         void this.fetchDaemonUpdateInfo(payload.version)
       }
     },
-    syncing(payload: { count: number }) {
-      this.eventSeamlessTotal = payload.count
+    syncing(payload: { count: number | string }) {
+      const total = Number(payload.count)
+      this.eventSeamlessTotal = Number.isFinite(total) ? total : 0
       this.eventSeamlessCurrent = 0
+      this.eventSeamlessCurrentJobs = {}
       this.eventSeamless = true
     },
     connectBackendsSocket(auth: ReturnType<typeof useAuth>): void {
@@ -207,19 +209,19 @@ export default defineNuxtComponent({
           return
         }
 
-        if (/^job:/.test(data.channel)) {
-          if (this.eventSeamlessTotal === 0) {
-            await this.identityStateStore.fetchAllStateCount()
-            this.eventSeamlessTotal = this.identityStateStore.getStateValue(IdentityState.PROCESSING)
-          }
-        }
-
         switch (data.channel) {
           case 'job:added':
             this.eventSeamless = true
             if (data.payload?.jobId) {
               this.eventSeamlessCurrentJobs[data.payload.jobId] = data.payload
             }
+            // Jobs non déclenchés par « tout synchroniser » (synchronisation automatique après
+            // modification par exemple) : le total est déduit des jobs reçus, sinon le panneau
+            // resterait affiché indéfiniment.
+            this.eventSeamlessTotal = Math.max(
+              this.eventSeamlessTotal,
+              this.eventSeamlessCurrent + Object.keys(this.eventSeamlessCurrentJobs).length,
+            )
             break
 
           case 'job:failed':
@@ -229,8 +231,12 @@ export default defineNuxtComponent({
             }
             this.eventSeamlessCurrent++
 
-            if (this.eventSeamlessCurrent >= this.eventSeamlessTotal) {
+            if (
+              this.eventSeamlessCurrent >= this.eventSeamlessTotal &&
+              Object.keys(this.eventSeamlessCurrentJobs).length === 0
+            ) {
               this.eventSeamlessCurrent = 0
+              this.eventSeamlessTotal = 0
               this.eventSeamlessCurrentJobs = {}
               setTimeout(() => {
                 this.eventSeamless = false