Ajouter la méthode syncAllIdentities dans le contrôleur BackendsController

Author: tacxou

src/core/backends/backends.controller.ts

@@ -20,6 +20,8 @@ import { ExecuteJobDto } from './_dto/execute-job.dto';
 import { BackendsService } from './backends.service';
 import { SyncIdentitiesDto } from './_dto/sync-identities.dto';
 import { Types } from 'mongoose';
+import { IdentityState } from '~/management/identities/_enums/states.enum';
+import { Identities } from '~/management/identities/_schemas/identities.schema';
 
 function fireMessage(observer: Subscriber<MessageEvent>, channel: string, message: any, loggername: string) {
   try {
@@ -56,6 +58,19 @@ export class BackendsController {
     return res.status(HttpStatus.ACCEPTED).json({ async, data });
   }
 
+  @Post('syncall')
+  public async syncAllIdentities(
+    @Res() res: Response,
+    @Body() body: SyncIdentitiesDto,
+    @Query('async') asyncQuery: string,
+  ) {
+    const async = /true|on|yes|1/i.test(asyncQuery);
+    const data = await this.backendsService.syncAllIdentities({
+      async,
+    });
+    return res.status(HttpStatus.ACCEPTED).json({ async, data });
+  }
+
   @Post('execute')
   public async executeJob(
     @Res() res: Response,

src/core/backends/backends.service.ts

@@ -108,12 +108,45 @@ export class BackendsService extends AbstractQueueProcessor {
     });
   }
 
+  public async syncAllIdentities(options?: ExecuteJobOptions): Promise<any> {
+    const syncAllIdentities = (await this.identitiesService.find<Identities>({
+      state: IdentityState.TO_SYNC,
+    })) as unknown as Identities[];
+    const identities = syncAllIdentities.map((identity: Identities) => {
+      return {
+        action: ActionType.IDENTITY_UPDATE,
+        identity,
+      };
+    });
+
+    const task: Tasks = await this.tasksService.create<Tasks>({
+      jobs: identities.map((identity) => identity.identity._id),
+    });
+
+    const result = {};
+    for (const identity of identities) {
+      const [executedJob] = await this.executeJob(
+        identity.action,
+        identity.identity._id,
+        { identity },
+        {
+          ...options,
+          task: task._id,
+        },
+      );
+      result[identity.identity._id] = executedJob;
+    }
+    return result;
+  }
+
   public async syncIdentities(payload: string[], options?: ExecuteJobOptions): Promise<any> {
     const identities: {
       action: ActionType;
       identity: Identities;
     }[] = [];
 
+    if (!payload.length) throw new BadRequestException('No identities to sync');
+
     for (const key of payload) {
       const identity = await this.identitiesService.findById<Identities>(key);
       if (identity.state !== IdentityState.TO_SYNC) {