image upload

Author: KirschbaumP

backend/src/core/configuration.ts

@@ -47,8 +47,8 @@ const MinioConfig = registerAs(ConfigKey.Minio, () => ({
   useSsl: process.env.MINIO_USE_SSL === 'true',
   accessKey: process.env.MINIO_ACCESS_KEY,
   secretKey: process.env.MINIO_SECRET_KEY,
-  uploadExpiry: process.env.MINIO_UPLOAD_EXPIRY,
-  downloadExpiry: process.env.MINIO_DOWNLOAD_EXPIRY,
+  uploadExpiry: Number(process.env.MINIO_UPLOAD_EXPIRY),
+  downloadExpiry: Number(process.env.MINIO_DOWNLOAD_EXPIRY),
   bucketName: process.env.MINIO_BUCKET_NAME,
 }));
 

backend/src/core/services/amqp.service.spec.ts

@@ -15,4 +15,4 @@ describe('AmqpService', () => {
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
-});
+});

backend/src/core/services/request-context.service.ts

@@ -5,12 +5,12 @@ import { AsyncLocalStorage } from 'async_hooks';
 export class RequestContextService {
   private readonly als = new AsyncLocalStorage<Map<string, string>>();
 
-  run(callback: () => void, context: Record<string, any>) {
+  run(callback: () => void, context: Record<string, string>) {
     const store = new Map(Object.entries(context));
     this.als.run(store, callback);
   }
 
-  set(key: string, value: any) {
+  set(key: string, value: string) {
     const store = this.als.getStore();
     if (store) {
       store.set(key, value);

backend/src/core/services/storage/image.service.ts

@@ -1,5 +1,4 @@
-import { Injectable } from '@nestjs/common';
-import { BucketEventRecordS3Object } from './dto/minio-listener/bucket-event.dto';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { MinioService } from './minio.service';
 import * as sharp from 'sharp';
 import { Sharp } from 'sharp';
@@ -8,16 +7,17 @@ import { DeviceService } from '../../../inventory/device/device.service';
 @Injectable()
 export class ImageService {
   static readonly sizes = [200, 480, 800, 1200, 1600, 2000, 4000];
+  static readonly blurredSizes = [600];
+  static readonly previewSuffix = '-webp-480';
 
   constructor(
+    @Inject(forwardRef(() => MinioService))
     private readonly minioService: MinioService,
+    @Inject(forwardRef(() => DeviceService))
     private readonly deivceService: DeviceService,
   ) {}
 
-  public async processDevice(
-    key: string,
-    bucketObject: BucketEventRecordS3Object,
-  ) {
+  public async processDevice(key: string) {
     try {
       const img = await this.loadImage(key);
       await this.convertImage(key, img);
@@ -54,15 +54,20 @@ export class ImageService {
   }
 
   private async blurredImage(key: string, img: Sharp) {
-    const size = 600;
-    const buffer = await img
-      .resize(size, null, { fit: 'inside' })
-      .blur(40)
-      .toBuffer();
+    for (const size of ImageService.blurredSizes) {
+      const buffer = await img
+        .resize(size, null, { fit: 'inside' })
+        .blur(40)
+        .toBuffer();
 
-    await this.minioService.putObject(key + '-webp-' + size + '-blur', buffer, {
-      'Content-Type': 'image/webp',
-    });
+      await this.minioService.putObject(
+        key + '-webp-' + size + '-blur',
+        buffer,
+        {
+          'Content-Type': 'image/webp',
+        },
+      );
+    }
   }
 
   private async loadImage(key: string): Promise<Sharp> {

backend/src/core/services/storage/minio-listener.service.ts

@@ -65,7 +65,7 @@ export class MinioListenerService implements OnApplicationBootstrap {
 
     if (key.startsWith('devices/')) {
       if (imageType) {
-        await services.imageService.processDevice(key, bucketObject);
+        await services.imageService.processDevice(key);
       }
     }
   }

backend/src/core/services/storage/minio.service.ts

@@ -1,14 +1,14 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { Client, ItemBucketMetadata } from 'minio';
+import { ImageService } from './image.service';
 
 @Injectable()
 export class MinioService {
   private readonly allowedImageTypes = [
     'image/jpeg',
     'image/png',
     'image/tiff',
-    'image/heic',
   ];
 
   private client: Client;
@@ -21,6 +21,8 @@ export class MinioService {
   constructor(
     private readonly configService: ConfigService,
     private readonly logger: Logger,
+    @Inject(forwardRef(() => ImageService))
+    private readonly imageService: ImageService,
   ) {
     const accessKey = this.configService.get<string>('MINIO.accessKey');
     const secretKey = this.configService.get<string>('MINIO.secretKey');
@@ -63,14 +65,22 @@ export class MinioService {
     );
   }
 
+  public async generatePresignedGetUrl(file: string): Promise<string> {
+    return this.client.presignedGetObject(
+      this.bucketName,
+      file,
+      this.downloadExpiry,
+    );
+  }
+
   public async generatePresignedPostUrl(
     file: string,
     contentType: string,
     fileSizeMb: number,
   ): Promise<{
     postURL: string;
     formData: {
-      [key: string]: any;
+      [key: string]: unknown;
     };
   }> {
     const policy = this.client.newPostPolicy();
@@ -93,7 +103,11 @@ export class MinioService {
     return this.client.getObject(this.bucketName, key);
   }
 
-  public putObject(key: string, webpBuffer: Buffer, metaData?: ItemBucketMetadata) {
+  public putObject(
+    key: string,
+    webpBuffer: Buffer,
+    metaData?: ItemBucketMetadata,
+  ) {
     return this.client.putObject(
       this.bucketName,
       key,
@@ -102,4 +116,21 @@ export class MinioService {
       metaData,
     );
   }
+
+  public async deleteObject(key: string) {
+    await this.client.removeObject(this.bucketName, key);
+  }
+
+  async deleteImages(entity: string, id: number, imageId: string) {
+    await Promise.all([
+      ...ImageService.sizes.map(async (size) =>
+        this.deleteObject(`devices/${id}/images/${imageId}-webp-${size}`),
+      ),
+      ...ImageService.blurredSizes.map(async (size) =>
+        this.deleteObject(`devices/${id}/images/${imageId}-webp-${size}-blur`),
+      ),
+      this.deleteObject(`devices/${id}/images/${imageId}`),
+      this.deleteObject(`devices/${id}/images/${imageId}-webp`),
+    ]);
+  }
 }

backend/src/core/user/user.controller.ts

@@ -76,7 +76,7 @@ export class UserController {
     roles: [Role.UserManage],
     noContent: true,
   })
-  public deleteUser(@Param() params: IdGuidDto): Observable<void> {
+  public deleteUser(@Param() params: IdGuidDto): Observable<unknown> {
     return this.userService.deleteUser(params.id);
   }
 

backend/src/core/user/user.service.ts

@@ -83,7 +83,7 @@ export class UserService {
     );
   }
 
-  deleteUser(id: string): Observable<void> {
+  deleteUser(id: string): Observable<unknown> {
     return this.keycloakService.deleteUser(id).pipe(
       catchError((error: InternalErrorDto) => {
         if (error.code === 404) {

backend/src/inventory/consumable-group/consumable-group-db.service.ts

@@ -74,4 +74,4 @@ export class ConsumableGroupDbService {
     const result = await this.repo.delete(id);
     return (result.affected ?? 0) > 0;
   }
-}
+}

backend/src/inventory/consumable-group/consumable-group.controller.ts

@@ -65,7 +65,9 @@ export class ConsumableGroupController {
     notFound: true,
     roles: [Role.ConsumableGroupManage],
   })
-  public create(@Body() body: ConsumableGroupCreateDto): Promise<ConsumableGroupDto> {
+  public create(
+    @Body() body: ConsumableGroupCreateDto,
+  ): Promise<ConsumableGroupDto> {
     return this.service.create(body);
   }
 
@@ -93,4 +95,4 @@ export class ConsumableGroupController {
   public async delete(@Param() params: IdNumberDto): Promise<void> {
     await this.service.delete(params.id);
   }
-}
+}