Merge pull request #37 from Libertech-FR/function-disable-enable

Function disable enable

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

@@ -1,7 +1,7 @@
 import {
   BadRequestException,
-  HttpException,
   HttpStatus,
+  HttpException,
   Injectable,
   RequestTimeoutException,
   UnprocessableEntityException,
@@ -11,24 +11,24 @@ import { Document, ModifyResult, Query, Types } from 'mongoose';
 import { AbstractQueueProcessor } from '~/_common/abstracts/abstract.queue.processor';
 import { IdentityState } from '~/management/identities/_enums/states.enum';
 import { Identities } from '~/management/identities/_schemas/identities.schema';
-import { IdentitiesService } from '~/management/identities/identities.service';
+import { IdentitiesCrudService } from '~/management/identities/identities-crud.service';
 import { JobState } from '../jobs/_enums/state.enum';
 import { Jobs } from '../jobs/_schemas/jobs.schema';
 import { JobsService } from '../jobs/jobs.service';
 import { Tasks } from '../tasks/_schemas/tasks.schema';
 import { TasksService } from '../tasks/tasks.service';
 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 { WorkerResultInterface } from '~/core/backends/_interfaces/worker-result.interface';
+import { DataStatusEnum } from '~/management/identities/_enums/data-status';
 
 const DEFAULT_SYNC_TIMEOUT = 30_000;
 
 @Injectable()
 export class BackendsService extends AbstractQueueProcessor {
   public constructor(
     protected moduleRef: ModuleRef,
-    protected identitiesService: IdentitiesService,
+    protected identitiesService: IdentitiesCrudService,
     protected jobsService: JobsService,
     protected tasksService: TasksService,
   ) {
@@ -265,6 +265,50 @@ 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}  has never been synched`,
+          identity,
+        });
+      }
+      identities.push({
+        action: ActionType.IDENTITY_DISABLE,
+        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;
@@ -273,6 +317,57 @@ export class BackendsService extends AbstractQueueProcessor {
     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}  has never been synched`,
+          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;
+      console.log(res);
+    }
+    return result;
+  }
+  public async activationIdentity(payload: string, status: boolean, options?: ExecuteJobOptions) {
+    let result = null;
+    if (status === true) {
+      result = await this.enableIdentities([payload], options );
+    } else {
+      result = await this.disableIdentities([payload], options);
+    }
+    return result[payload];
+  }
   public async executeJob(
     actionType: ActionType,
     concernedTo?: Types.ObjectId,
@@ -289,7 +384,7 @@ export class BackendsService extends AbstractQueueProcessor {
       },
       {
         ...options?.job,
-        jobId: (new Types.ObjectId()).toHexString(),
+        jobId: (new Types.ObjectId() ).toHexString(),
         attempts: 1,
       },
     );

src/management/identities/_dto/_parts/activation-dto.ts

@@ -0,0 +1,12 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsBoolean, IsString } from 'class-validator';
+
+export class ActivationDto {
+  @IsString()
+  @ApiProperty({ example: '66d80ab41821baca9bf965b2', description: 'Id of identity', type: String })
+  public id: string;
+
+  @IsBoolean()
+  @ApiProperty({ example: 'true', description: 'true or false to enable or disable the identity', type: String })
+  public status: boolean;
+}

src/management/identities/_dto/identities.dto.ts

@@ -8,6 +8,7 @@ import { additionalFieldsPartDto } from './_parts/additionalFields.dto';
 import { MetadataDto } from '~/_common/abstracts/dto/metadata.dto';
 import { InitStatesEnum } from '~/management/identities/_enums/init-state.enum';
 import { CustomFieldsDto } from '~/_common/abstracts/dto/custom-fields.dto';
+import {DataStatusEnum} from "~/management/identities/_enums/data-status";
 
 export class IdentitiesCreateDto extends IntersectionType(CustomFieldsDto, MetadataDto) {
   @IsNumber()
@@ -20,6 +21,11 @@ export class IdentitiesCreateDto extends IntersectionType(CustomFieldsDto, Metad
   @ApiProperty({ enum: InitStatesEnum })
   public initState: InitStatesEnum;
 
+  @IsNumber()
+  @IsEnum(DataStatusEnum)
+  @ApiProperty({ enum: DataStatusEnum })
+  public dataStatus: DataStatusEnum;
+
   @IsNumber()
   @IsOptional()
   @IsEnum(IdentityLifecycle)

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;
 

src/management/identities/_stubs/identities.dto.stub.ts

@@ -5,6 +5,7 @@ import { IdentityState } from '~/management/identities/_enums/states.enum';
 import { additionalFieldsPartDtoStub } from './_parts/addtionalFields.dto.stub';
 import { inetOrgPersonDtoStub } from './_parts/inetOrgPerson.dto.stub';
 import { InitStatesEnum } from '~/management/identities/_enums/init-state.enum';
+import { DataStatusEnum } from '~/management/identities/_enums/data-status';
 
 export const IdentitiesDtoStub = (): IdentitiesDto => {
   return {
@@ -13,6 +14,7 @@ export const IdentitiesDtoStub = (): IdentitiesDto => {
     inetOrgPerson: inetOrgPersonDtoStub(),
     additionalFields: additionalFieldsPartDtoStub(),
     initState: InitStatesEnum.NOSENT,
+    dataStatus: DataStatusEnum.ACTIVE,
   };
 };
 
@@ -23,6 +25,7 @@ export const IdentitiesUpdateDtoStub = (): IdentitiesUpdateDto => {
     state: IdentityState.TO_COMPLETE,
     lifecycle: IdentityLifecycle.INACTIVE,
     initState: InitStatesEnum.NOSENT,
+    dataStatus: DataStatusEnum.ACTIVE,
     inetOrgPerson,
     additionalFields: additionalFieldsPartDtoStub(),
   };

src/management/identities/abstract-identities.service.ts

@@ -0,0 +1,140 @@
+import { BadRequestException, forwardRef, HttpException, Inject, Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Document, Model, ModifyResult, Query, Types } from 'mongoose';
+import { AbstractServiceSchema } from '~/_common/abstracts/abstract.service.schema';
+import { AbstractSchema } from '~/_common/abstracts/schemas/abstract.schema';
+import { ValidationConfigException, ValidationSchemaException } from '~/_common/errors/ValidationException';
+import { IdentitiesUpsertDto } from './_dto/identities.dto';
+import { IdentityState } from './_enums/states.enum';
+import { Identities } from './_schemas/identities.schema';
+import { IdentitiesValidationService } from './validations/identities.validation.service';
+import { FactorydriveService } from '@the-software-compagny/nestjs_module_factorydrive';
+import { BackendsService } from '~/core/backends/backends.service';
+import { construct, omit } from 'radash';
+import { toPlainAndCrush } from '~/_common/functions/to-plain-and-crush';
+import { createHash } from 'node:crypto';
+
+@Injectable()
+export abstract class AbstractIdentitiesService extends AbstractServiceSchema {
+  public constructor(
+    @InjectModel(Identities.name) protected _model: Model<Identities>,
+    protected readonly _validation: IdentitiesValidationService,
+    protected readonly storage: FactorydriveService,
+    @Inject(forwardRef(() => BackendsService)) protected readonly backends: BackendsService,
+  ) {
+    super();
+  }
+
+  protected handleValidationError(
+    error: Error | HttpException,
+    identity: Identities | IdentitiesUpsertDto,
+    logPrefix: string,
+  ): any {
+    if (error instanceof ValidationConfigException) {
+      this.logger.error(`${logPrefix} Validation config error. ${JSON.stringify(error.getValidations())}`);
+      throw new ValidationConfigException(error.getPayload());
+    }
+
+    if (error instanceof ValidationSchemaException) {
+      this.logger.warn(`${logPrefix} Validation schema error. ${JSON.stringify(error.getValidations())}`);
+      identity.additionalFields.validations = error.getValidations() as any;
+      // console.log('identity.state', identity.state)
+      if (identity.state === IdentityState.TO_CREATE) {
+        this.logger.warn(`${logPrefix} State set to TO_COMPLETE.`);
+        identity.state = IdentityState.TO_COMPLETE;
+        return identity;
+      } else {
+        this.logger.error(`${logPrefix} Validation schema error. ${JSON.stringify(error.getValidations())}`);
+        throw new ValidationSchemaException(error.getPayload());
+      }
+    } else {
+      this.logger.error(`${logPrefix} Unhandled error: ${error.message}`);
+      throw error; // Rethrow the original error if it's not one of the handled types.
+    }
+  }
+
+  public transformNullsToString(obj) {
+    if (obj === null) {
+      return '';
+    }
+
+    if (Array.isArray(obj)) {
+      return obj.map(this.transformNullsToString);
+    }
+
+    if (typeof obj === 'object' && !(obj instanceof Types.ObjectId)) {
+      for (const key in obj) {
+        if (obj[key] === null) {
+          obj[key] = '';
+        } else if (typeof obj[key] === 'object') {
+          // console.log('key', key);
+          obj[key] = this.transformNullsToString(obj[key]);
+        }
+      }
+    }
+
+    return obj;
+  }
+
+  protected async checkInetOrgPersonJpegPhoto(data: any) {
+    if (data?.inetOrgPerson?.jpegPhoto) {
+      let reqStorage;
+      const [disk, path] = data.inetOrgPerson.jpegPhoto.split(':');
+
+      try {
+        reqStorage = await this.storage.getDisk(disk).exists(path);
+      } catch (error) {
+        throw new BadRequestException(`Error while checking photo in storage: ${error.message}`);
+      }
+
+      if (!reqStorage.exists) {
+        throw new BadRequestException(`Photo not found in storage: ${data.inetOrgPerson.jpegPhoto}`);
+      }
+    }
+  }
+  protected async generateFingerprint<T extends AbstractSchema | Document>(
+    identity: Identities,
+    fingerprint?: string,
+  ): Promise<ModifyResult<Query<T, T, any, T>>> {
+    if (!fingerprint) {
+      fingerprint = await this.previewFingerprint(identity.toJSON());
+    }
+
+    const updated = await this.model.findOneAndUpdate(
+      { _id: identity._id, fingerprint: { $ne: fingerprint } },
+      { fingerprint },
+      {
+        new: true,
+      },
+    );
+
+    if (!updated) {
+      this.logger.verbose(`Fingerprint already up to date for <${identity._id}>.`);
+      return identity as unknown as ModifyResult<Query<T, T, any, T>>;
+    }
+
+    this.logger.debug(`Fingerprint updated for <${identity._id}>: ${fingerprint}`);
+    return updated as unknown as ModifyResult<Query<T, T, any, T>>;
+  }
+  protected async previewFingerprint(identity: any): Promise<string> {
+    const additionalFields = omit(identity.additionalFields, ['validations']);
+    const data = JSON.stringify(
+      construct(
+        omit(
+          toPlainAndCrush({
+            inetOrgPerson: identity.inetOrgPerson,
+            additionalFields,
+          }) as any,
+          [
+            //TODO: add configurable fields to exclude
+            /* 'additionalFields.attributes.supannPerson.supannOIDCGenre' */
+          ],
+        ),
+      ),
+    );
+
+    const hash = createHash('sha256');
+    hash.update(data);
+    return hash.digest('hex').toString();
+  }
+}