chore: Update filestorage configuration for identities module

Author: tacxou

src/config.ts

@@ -117,10 +117,10 @@ export default (): ConfigInstance => ({
             root: process.cwd() + '/storage',
           },
         },
-        pictures: {
+        identities: {
           driver: 'local',
           config: {
-            root: process.cwd() + '/storage/pictures',
+            root: process.cwd() + '/storage/identities',
           },
         },
       },

src/core/filestorage/_dto/filestorage.dto.ts

@@ -26,6 +26,11 @@ export class FilestorageCreateDto extends CustomFieldsDto {
   @Matches(/^\/(\.?[^\/\0]+\/?)+$/, { message: 'Path must be a valid path' })
   public path: string
 
+  @IsOptional()
+  @IsString()
+  @ApiProperty({ type: String, required: false })
+  public fingerprint?: string
+
   @IsOptional()
   @IsMongoId()
   @ApiProperty({ type: String, required: false })

src/core/filestorage/_schemas/filestorage.schema.ts

@@ -32,6 +32,12 @@ export class Filestorage extends AbstractSchema {
   })
   public path: string
 
+  @Prop({
+    required: true,
+    type: String,
+  })
+  public fingerprint: string
+
   @Prop({
     required: false,
     type: String,

src/core/filestorage/filestorage.module.ts

@@ -14,8 +14,8 @@ import { TransformersFilestorageService } from '~/core/filestorage/_services/tra
       },
     ]),
   ],
-  providers: [FilestorageService, TransformersFilestorageService],
   controllers: [FilestorageController],
-  exports: [FilestorageService],
+  providers: [FilestorageService, TransformersFilestorageService],
+  exports: [FilestorageService, TransformersFilestorageService],
 })
 export class FilestorageModule { }

src/core/filestorage/filestorage.service.ts

@@ -1,6 +1,6 @@
 // noinspection ExceptionCaughtLocallyJS
 
-import { BadRequestException, Inject, Injectable, Scope } from '@nestjs/common'
+import { BadRequestException, HttpException, HttpStatus, Inject, Injectable, Scope } from '@nestjs/common'
 import { InjectModel } from '@nestjs/mongoose'
 import { Filestorage } from './_schemas/filestorage.schema'
 import { Document, FilterQuery, Model, ModifyResult, ProjectionType, Query, QueryOptions, SaveOptions, Types, UpdateQuery } from 'mongoose'
@@ -11,6 +11,7 @@ import { FilestorageCreateDto } from '~/core/filestorage/_dto/filestorage.dto'
 import { FsType } from '~/core/filestorage/_enum/fs-type.enum'
 import { omit } from 'radash'
 import { ModuleRef } from '@nestjs/core'
+import { createHash } from 'node:crypto'
 
 export const EMBED_SEPARATOR = '#'
 
@@ -61,7 +62,12 @@ export class FilestorageService extends AbstractServiceSchema {
           break
         }
       }
+
+      const fingerprint = createHash('sha256');
+      fingerprint.update(file.buffer);
+      payload.fingerprint = fingerprint.digest('hex').toString();
       payload.path = partPath.join('/')
+
       return super.create(payload, options)
     } catch (e) {
       if (e.code === 'E_INVALID_CONFIG') {
@@ -160,5 +166,56 @@ export class FilestorageService extends AbstractServiceSchema {
 
     return updated
   }
+
+  public async upsertFile<T extends AbstractSchema | Document>(
+    filter?: FilterQuery<T>,
+    data?: FilestorageCreateDto & { file?: Express.Multer.File },
+    options?: QueryOptions<T> & { rawResult: true },
+  ) {
+    let stored: Document<any, any, Filestorage> & Filestorage
+    try {
+      stored = await this.findOne<Filestorage>(filter, options)
+    } catch (e) {
+      if (e.status !== HttpStatus.NOT_FOUND) throw e
+    }
+
+    if (stored) {
+      const update = { ...omit(data, ['file']) }
+
+      const fingerprint = createHash('sha256');
+      fingerprint.update(data.file.buffer);
+      update.fingerprint = fingerprint.digest('hex').toString();
+
+      await this.checkFingerprint(
+        { _id: stored._id },
+        update.fingerprint,
+      )
+
+      const updated = await this.update(stored._id, update, options)
+      this.storage.getDisk(stored.namespace).put(stored.path, data.file.buffer)
+
+      return updated
+    } else {
+      return await this.create(data, options)
+    }
+  }
+
+  public async checkFingerprint<T extends AbstractSchema | Document>(
+    filters: FilterQuery<T>,
+    fingerprint: string,
+  ): Promise<void> {
+    const file = await this.model
+      .findOne(
+        { ...filters, fingerprint },
+        {
+          _id: 1,
+        },
+      )
+      .exec();
+    if (file) {
+      this.logger.debug(`Fingerprint matched for <${file._id}> (${fingerprint}).`);
+      throw new HttpException('Fingerprint matched.', HttpStatus.NOT_MODIFIED);
+    }
+  }
   /* eslint-enable */
 }

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

@@ -87,6 +87,11 @@ export class inetOrgPersonCreateDto {
   @ApiProperty({ required: false })
   @IsOptional()
   userPassword?: string;
+
+  @IsString()
+  @ApiProperty({ required: false })
+  @IsOptional()
+  jpegPhoto?: string;
 }
 
 export class inetOrgPersonDto extends inetOrgPersonCreateDto { }

src/management/identities/identities.controller.ts

@@ -6,12 +6,15 @@ import {
   Get,
   HttpStatus,
   Param,
+  ParseFilePipe,
   Patch,
   Post,
   Query,
-  Res
+  Res,
+  UploadedFile,
+  UseInterceptors
 } from '@nestjs/common';
-import { ApiOperation, ApiParam, ApiTags } from '@nestjs/swagger';
+import { ApiOperation, ApiParam, ApiTags, PartialType } from '@nestjs/swagger';
 import { FilterOptions, FilterSchema, SearchFilterOptions, SearchFilterSchema } from '@the-software-compagny/nestjs_module_restools';
 import { Response } from 'express';
 import { Document, Types, isValidObjectId } from 'mongoose';
@@ -30,6 +33,14 @@ import { IdentityState } from './_enums/states.enum';
 import { Identities } from './_schemas/identities.schema';
 import { IdentitiesService } from './identities.service';
 import { IdentitiesValidationService } from './validations/identities.validation.service';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { ApiFileUploadDecorator } from '~/_common/decorators/api-file-upload.decorator';
+import { FilestorageCreateDto, FilestorageDto, FileUploadDto } from '~/core/filestorage/_dto/filestorage.dto';
+import { FilestorageService } from '~/core/filestorage/filestorage.service';
+import { FsType } from '~/core/filestorage/_enum/fs-type.enum';
+import { join } from 'node:path';
+import { omit } from 'radash';
+import { TransformersFilestorageService } from '~/core/filestorage/_services/transformers-filestorage.service';
 // import { IdentitiesValidationFilter } from '~/_common/filters/identities-validation.filter';
 
 // @UseFilters(new IdentitiesValidationFilter())
@@ -39,6 +50,8 @@ export class IdentitiesController extends AbstractController {
   constructor(
     protected readonly _service: IdentitiesService,
     protected readonly _validation: IdentitiesValidationService,
+    protected readonly filestorage: FilestorageService,
+    private readonly transformerService: TransformersFilestorageService,
   ) {
     super();
   }
@@ -282,4 +295,55 @@ export class IdentitiesController extends AbstractController {
       });
     }
   }
+
+  @Post('upsert/photo')
+  @UseInterceptors(FileInterceptor('file'))
+  @ApiFileUploadDecorator(FileUploadDto, PartialType(FilestorageCreateDto), FilestorageDto)
+  public async upsertInetOrgPersonJpegPhoto(
+    @Res() res: Response,
+    @Body() body: Partial<FilestorageCreateDto>,
+    @SearchFilterSchema() searchFilterSchema: FilterSchema,
+    @UploadedFile(new ParseFilePipe({ fileIsRequired: false })) file?: Express.Multer.File,
+  ): Promise<Response> {
+    const identity = await this._service.findOne<Identities>(searchFilterSchema)
+    const filter = {
+      namespace: 'identities',
+      path: join([
+        identity.inetOrgPerson?.employeeType,
+        identity.inetOrgPerson?.employeeNumber,
+        'jpegPhoto.jpg',
+      ].join('/')),
+    }
+
+    const data = await this.filestorage.upsertFile(filter, {
+      ...filter,
+      type: FsType.FILE,
+      file,
+      ...omit(body, ['namespace', 'path', 'type', 'file'] as any),
+    })
+
+    return res.status(HttpStatus.OK).json({
+      statusCode: HttpStatus.OK,
+      data,
+    })
+  }
+
+  @Get('photo/raw')
+  @ApiReadResponseDecorator(FilestorageDto)
+  public async readPhotoRaw(
+    @Res() res: Response,
+    @SearchFilterSchema() searchFilterSchema: FilterSchema,
+    @Query('mime') mime: string = '',
+  ): Promise<void> {
+    const identity = await this._service.findOne<Identities>(searchFilterSchema)
+    const [data, stream, parent] = await this.filestorage.findOneWithRawData({
+      namespace: 'identities',
+      path: join([
+        identity.inetOrgPerson?.employeeType,
+        identity.inetOrgPerson?.employeeNumber,
+        'jpegPhoto.jpg',
+      ].join('/')),
+    })
+    await this.transformerService.transform(mime, res, data, stream, parent)
+  }
 }

src/management/identities/identities.module.ts

@@ -9,6 +9,7 @@ import { IdentitiesJsonformsService } from './jsonforms/identities.jsonforms.ser
 import { IdentitiesJsonformsModule } from './jsonforms/identities.jsonforms.module';
 import { APP_FILTER } from '@nestjs/core';
 import { IdentitiesValidationFilter } from '~/_common/filters/identities-validation.filter';
+import { FilestorageModule } from '~/core/filestorage/filestorage.module';
 
 @Module({
   imports: [
@@ -20,6 +21,7 @@ import { IdentitiesValidationFilter } from '~/_common/filters/identities-validat
         useFactory: () => IdentitiesSchema,
       },
     ]),
+    FilestorageModule,
   ],
   providers: [
     IdentitiesService,
@@ -33,4 +35,4 @@ import { IdentitiesValidationFilter } from '~/_common/filters/identities-validat
   controllers: [IdentitiesController],
   exports: [IdentitiesService],
 })
-export class IdentitiesModule {}
+export class IdentitiesModule { }

src/management/identities/identities.service.ts

@@ -21,12 +21,14 @@ 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';
 
 @Injectable()
 export class IdentitiesService extends AbstractServiceSchema {
   constructor(
     @InjectModel(Identities.name) protected _model: Model<Identities>,
     protected readonly _validation: IdentitiesValidationService,
+    protected readonly storage: FactorydriveService,
   ) {
     super();
   }
@@ -35,6 +37,7 @@ export class IdentitiesService extends AbstractServiceSchema {
     data?: any,
     options?: SaveOptions,
   ): Promise<Document<T, any, T>> {
+    await this.checkInetOrgPersonJpegPhoto(data);
     const created: Document<T, any, T> = await super.create(data, options);
     return created;
     //TODO: add backends service logic here
@@ -66,6 +69,8 @@ export class IdentitiesService extends AbstractServiceSchema {
       throw new BadRequestException('inetOrgPerson.employeeNumber and inetOrgPerson.employeeType are required for create identity.');
     }
 
+    await this.checkInetOrgPersonJpegPhoto(data);
+
     const logPrefix = `Validation [${data?.inetOrgPerson?.employeeType}:${data?.inetOrgPerson?.employeeNumber}]:`;
     try {
       this.logger.log(`${logPrefix} Starting additionalFields validation.`);
@@ -140,6 +145,8 @@ export class IdentitiesService extends AbstractServiceSchema {
     // if (update.state === IdentityState.TO_COMPLETE) {
     update = { ...update, state: IdentityState.TO_VALIDATE };
 
+    await this.checkInetOrgPersonJpegPhoto(update);
+
     // }
     // if (update.state === IdentityState.SYNCED) {
     //   update = { ...update, state: IdentityState.TO_VALIDATE };
@@ -286,4 +293,21 @@ export class IdentitiesService extends AbstractServiceSchema {
       throw error; // Rethrow the original error if it's not one of the handled types.
     }
   }
+
+  private 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}`);
+      }
+    }
+  }
 }

src/management/identities/jsonforms/_config/inetorgperson.ui.yml

@@ -69,3 +69,12 @@ elements:
   - type: Control
     label: Titre
     scope: "#/properties/title"
+
+- type: HorizontalLayout
+  elements:
+  - type: Control
+    label: Photo
+    scope: "#/properties/jpegPhoto"
+    options:
+      format: file
+      storage: picture