save split des classes

Author: alainabbas

src/core/backends/backends.service.ts

@@ -1,7 +1,7 @@
 import {
   BadRequestException,
-  HttpException,
   HttpStatus,
+  HttpException,
   Injectable,
   RequestTimeoutException,
   UnprocessableEntityException,
@@ -11,25 +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 {DataStatusEnum} from "~/management/identities/_enums/data-status";
+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,
   ) {
@@ -377,7 +376,7 @@ export class BackendsService extends AbstractQueueProcessor {
       },
       {
         ...options?.job,
-        jobId: (new Types.ObjectId()).toHexString(),
+        jobId: (new Types.ObjectId() ).toHexString(),
         attempts: 1,
       },
     );

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();
+  }
+}