save

Author: alainabbas

src/core/backends/_enum/action-type.enum.ts

@@ -7,4 +7,6 @@ export enum ActionType {
   IDENTITY_DELETE = 'IDENTITY_DELETE',
   IDENTITY_PASSWORD_RESET = 'IDENTITY_PASSWORD_RESET',
   IDENTITY_PASSWORD_CHANGE = 'IDENTITY_PASSWORD_CHANGE',
+  IDENTITY_DISABLE = 'IDENTITY_DISABLE',
+  IDENTITY_ENABLE = 'IDENTITY_ENABLE',
 }

src/core/backends/_interfaces/execute-job-options.interface.ts

@@ -11,5 +11,6 @@ export interface ExecuteJobOptions {
   switchToProcessing?: boolean;
   comment?: string;
   targetState?: any;
+  dataState?: any;
   task?: Types.ObjectId;
 }

src/core/backends/backends.service.ts

@@ -21,6 +21,7 @@ import { ActionType } from './_enum/action-type.enum';
 import { ExecuteJobOptions } from './_interfaces/execute-job-options.interface';
 import { BackendResultInterface } from "~/core/backends/_interfaces/backend-result.interface";
 import { WorkerResultInterface } from "~/core/backends/_interfaces/worker-result.interface";
+import {DataStatusEnum} from "~/management/identities/_enums/data-status";
 
 const DEFAULT_SYNC_TIMEOUT = 30_000;
 
@@ -265,6 +266,93 @@ export class BackendsService extends AbstractQueueProcessor {
         updateStatus: true,
         switchToProcessing: false,
         targetState: IdentityState.DONT_SYNC,
+        dataState: DataStatusEnum.DELETED,
+        task: task._id,
+      });
+      result[identity.identity._id] = executedJob;
+      console.log(res);
+    }
+    return result;
+  }
+
+  public async disableIdentities(payload: string[], options?: ExecuteJobOptions): Promise<any> {
+    const identities: {
+      action: ActionType;
+      identity: Identities;
+    }[] = [];
+
+    if (!payload.length) throw new BadRequestException('No identities to disable');
+
+    for (const key of payload) {
+      const identity = await this.identitiesService.findById<Identities>(key);
+      if (!identity.lastBackendSync) {
+        throw new BadRequestException({
+          status: HttpStatus.BAD_REQUEST,
+          message: `Identity ${key} is not in state TO_DELETE`,
+          identity,
+        });
+      }
+      identities.push({
+        action: ActionType.IDENTITY_ENABLE,
+        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, res] = await this.executeJob(identity.action, identity.identity._id, identity.identity, {
+        ...options,
+        updateStatus: true,
+        switchToProcessing: false,
+        targetState: IdentityState.SYNCED,
+        dataState: DataStatusEnum.INACTIVE,
+        task: task._id,
+      });
+      result[identity.identity._id] = executedJob;
+      console.log(res);
+    }
+    return result;
+  }
+
+  public async enableIdentities(payload: string[], options?: ExecuteJobOptions): Promise<any> {
+    const identities: {
+      action: ActionType;
+      identity: Identities;
+    }[] = [];
+
+    if (!payload.length) throw new BadRequestException('No identities to disable');
+
+    for (const key of payload) {
+      const identity = await this.identitiesService.findById<Identities>(key);
+      if (!identity.lastBackendSync) {
+        throw new BadRequestException({
+          status: HttpStatus.BAD_REQUEST,
+          message: `Identity ${key} is not in state TO_DELETE`,
+          identity,
+        });
+      }
+      identities.push({
+        action: ActionType.IDENTITY_ENABLE,
+        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, res] = await this.executeJob(identity.action, identity.identity._id, identity.identity, {
+        ...options,
+        updateStatus: true,
+        switchToProcessing: false,
+        targetState: IdentityState.SYNCED,
+        dataState: DataStatusEnum.ACTIVE,
         task: task._id,
       });
       result[identity.identity._id] = executedJob;

src/management/identities/_enums/data-status.ts

@@ -0,0 +1,9 @@
+//status de l enregistrement pour le soft delete
+//ACTIVE quand l'enregistrement est actif
+//INACTIVE quand l' identité doit etre disable sur les backend
+//DELETED : soft delete
+export enum DataStatusEnum {
+  ACTIVE = 1,
+  INACTIVE = 0,
+  DELETED = -1,
+}

src/management/identities/_schemas/identities.schema.ts

@@ -10,6 +10,7 @@ import { InitInfoPart, InitInfoPartSchema } from '~/management/identities/_schem
 import { MixedValue } from '~/_common/types/mixed-value.type';
 import { AutoIncrementPlugin } from '~/_common/plugins/mongoose/auto-increment.plugin';
 import { AutoIncrementPluginOptions } from '~/_common/plugins/mongoose/auto-increment.interface';
+import { DataStatusEnum } from '~/management/identities/_enums/data-status';
 
 export type IdentitiesDocument = Identities & Document;
 
@@ -21,6 +22,9 @@ export class Identities extends AbstractSchema {
   @Prop({ type: Number, enum: IdentityLifecycle, default: IdentityLifecycle.INACTIVE })
   public lifecycle: IdentityLifecycle;
 
+  @Prop({ type: Number, enum: DataStatusEnum, default: DataStatusEnum.ACTIVE })
+  public dataStatus: DataStatusEnum;
+
   @Prop({ type: inetOrgPersonSchema, required: true })
   public inetOrgPerson: inetOrgPerson;