@tomei/media 0.1.0 → 0.2.0

package/src/medias.ts

@@ -1,5 +1,5 @@
 import { BlobServiceClient } from '@azure/storage-blob';
-import { BadRequestException } from '@nestjs/common';
+import { BadRequestException, NotFoundException } from '@nestjs/common';
 import * as crypto from 'crypto';
 import * as fs from 'fs';
 import { CommonService } from './common/common.service';
@@ -9,6 +9,10 @@ import { MediasModel } from './entities/medias.entity';
 import { IBaseMediasAttr } from './interfaces/base.medias-attr.interface';
 import { IMediasRepository } from './interfaces/medias.repository.interface';
 import { Readable } from 'stream';
+import { InternalMediaDto } from './dto/internal-medias.dto';
+import { ExternalMediaDto } from './dto/external-media.dto';
+import * as cuid from 'cuid';
+import { Op } from 'sequelize';
 
 type MediaFile = {
   buffer: Buffer;
@@ -31,11 +35,11 @@ export class Medias extends BaseMedias {
   entity = typeof MediasModel;
 
   constructor(
-    mediaRepository: IMediasRepository,
+    mediasRepository: IMediasRepository,
     commonService: CommonService,
     media?: IBaseMediasAttr,
   ) {
-    super(mediaRepository, media);
+    super(mediasRepository, media);
     this.commonService = commonService;
     try {
       this.container = process.env.MEDIA_AZUREBLOB_CONTAINER_NAME;
@@ -60,6 +64,7 @@ export class Medias extends BaseMedias {
         activityDescription = `Added a new media Id: ${this.MediaId}.`;
         await this.createInternalMedias(stream);
       }
+
       if (media) {
         await this.commonService.addActivityHistory(
           {
@@ -73,7 +78,7 @@ export class Medias extends BaseMedias {
             PerformedAt: this.CreatedAt,
           },
           this.entity,
-          '',
+          'create',
         );
       }
       return media;
@@ -87,7 +92,9 @@ export class Medias extends BaseMedias {
     stream?: Express.Multer.File,
   ) {
     try {
-      const oldMedia = await super.findOne({where: { MediaId: this.MediaId}});
+      const oldMedia = await super.findOne({
+        where: { MediaId: this.MediaId },
+      });
       const media = await super.update();
       let activityDescription = `Updated external media Id: ${this.MediaId}.`;
       if (!isExternalMedias) {
@@ -109,7 +116,7 @@ export class Medias extends BaseMedias {
             PerformedAt: this.UpdatedAt,
           },
           this.entity,
-          '',
+          'update',
         );
       }
 
@@ -137,7 +144,7 @@ export class Medias extends BaseMedias {
       this.FileName = this.FileName.replace(/\.[^/.]+$/, '');
 
       let file: MediaFile;
-      if (this.IsEncryptedYN == 'Y') {
+      if (this.IsEncryptedYN === 'Y') {
         file = await this.encrypt(stream.buffer);
       } else {
         file = {
@@ -160,7 +167,7 @@ export class Medias extends BaseMedias {
         const isDir = await isDirExist(filePath);
         if (isDir) {
           fs.unlinkSync(this.FilePath);
-          if (this.IsEncryptedYN == 'Y') {
+          if (this.IsEncryptedYN === 'Y') {
             fs.unlinkSync(this.getIvPath());
           }
         }
@@ -178,7 +185,7 @@ export class Medias extends BaseMedias {
       this.FileExtension = this.FileExtension.split('.')[0];
       this.FileName = this.FileName.replace(/\.[^/.]+$/, '');
       let file: MediaFile;
-      if (this.IsEncryptedYN == 'Y') {
+      if (this.IsEncryptedYN === 'Y') {
         file = await this.encrypt(stream.buffer);
       } else {
         file = {
@@ -224,8 +231,8 @@ export class Medias extends BaseMedias {
   }
 
   private async deleteUploadedFileFromLocal(
-    path:string,
-    isEncryptedYN:string,
+    path: string,
+    isEncryptedYN: string,
   ): Promise<void> {
     try {
       const isDirExist = util.promisify(fs.exists);
@@ -233,7 +240,7 @@ export class Medias extends BaseMedias {
       if (isDir) {
         const deleteFile = util.promisify(fs.unlink);
         await deleteFile(path);
-        if (isEncryptedYN == 'Y') {
+        if (isEncryptedYN === 'Y') {
           await deleteFile(this.getIvPath());
         }
       }
@@ -252,18 +259,18 @@ export class Medias extends BaseMedias {
     );
 
     let ivPath: string;
-    if (this.IsEncryptedYN == 'Y') {
+    if (this.IsEncryptedYN === 'Y') {
       ivPath = await this.uploadFileToAzureStorage(
         file.iv,
         this.ObjectType,
         this.ObjectId,
-        this.FileName+"iv",
+        this.FileName + 'iv',
         'iv',
       );
     }
 
     const path: FilePath = {
-      filePath: filePath,
+      filePath,
       ivFilePath: ivPath,
     };
 
@@ -277,9 +284,17 @@ export class Medias extends BaseMedias {
     isEncryptedYN: string,
   ): Promise<void> {
     try {
-      await this.deleteUploadedFileToAzureStorage(path, FileName, FileExtension);
-      if (isEncryptedYN == 'Y') {
-        await this.deleteUploadedFileToAzureStorage(path, FileName+"iv", '.iv');
+      await this.deleteUploadedFileToAzureStorage(
+        path,
+        FileName,
+        FileExtension,
+      );
+      if (isEncryptedYN === 'Y') {
+        await this.deleteUploadedFileToAzureStorage(
+          path,
+          FileName + 'iv',
+          '.iv',
+        );
       }
     } catch (error) {
       throw error;
@@ -307,7 +322,7 @@ export class Medias extends BaseMedias {
     }
   }
 
-  async deleteUploadedFileToAzureStorage(
+  private async deleteUploadedFileToAzureStorage(
     path: string,
     FileName: string,
     FileExtension: string,
@@ -334,7 +349,7 @@ export class Medias extends BaseMedias {
     }
   }
 
-  async getFile(): Promise<Buffer> {
+  async findFile(): Promise<Buffer> {
     try {
       let fileBuffer: Buffer;
       if (this.IsStorageTypeAzure()) {
@@ -355,8 +370,8 @@ export class Medias extends BaseMedias {
         if (this.IsStorageTypeAzure()) {
           file.iv = await this.getFileFromAzure(
             this.URL,
-            this.FileName+"iv",
-            'iv'
+            this.FileName + 'iv',
+            'iv',
           );
         } else {
           file.iv = await this.getFileFromLocal(this.getIvPath());
@@ -369,7 +384,9 @@ export class Medias extends BaseMedias {
     }
   }
 
-  private async stream2buffer(stream: Readable | fs.ReadStream): Promise<Buffer> {
+  private async stream2buffer(
+    stream: Readable | fs.ReadStream,
+  ): Promise<Buffer> {
     return new Promise<Buffer>((resolve, reject) => {
       const buffer = Array<any>();
 
@@ -391,9 +408,11 @@ export class Medias extends BaseMedias {
         `${fileName}.${FileExtension}`,
       );
       const downloadResponse = await blockBlobClient.download();
-      const ReadStream = new Readable().wrap(downloadResponse.readableStreamBody);
+      const ReadStream = new Readable().wrap(
+        downloadResponse.readableStreamBody,
+      );
       const file = await this.stream2buffer(ReadStream);
-      return file
+      return file;
     } catch (error) {
       throw error;
     }
@@ -422,7 +441,7 @@ export class Medias extends BaseMedias {
 
       const result: MediaFile = {
         buffer: resultBuffer,
-        iv: iv,
+        iv,
         isEncrypted: true,
       };
 
@@ -453,10 +472,10 @@ export class Medias extends BaseMedias {
     }
   }
 
-  async delete(): Promise<any> {
+  public async delete(): Promise<any> {
     try {
       const data: MediasModel = await super.delete();
-      if (this.IsExternalYN == 'N') {
+      if (this.IsExternalYN === 'N') {
         if (this.IsStorageTypeAzure()) {
           await this.deleteUploadedFileFromAzure(
             this.URL,
@@ -465,10 +484,7 @@ export class Medias extends BaseMedias {
             this.IsEncryptedYN,
           );
         } else {
-          await this.deleteUploadedFileFromLocal(
-            this.URL,
-            this.IsEncryptedYN
-          );
+          await this.deleteUploadedFileFromLocal(this.URL, this.IsEncryptedYN);
         }
       }
 
@@ -484,11 +500,185 @@ export class Medias extends BaseMedias {
           PerformedAt: new Date(),
         },
         this.entity,
-        '',
+        'delete',
       );
-      return { message: 'Media has been deleted.' }
+      return { message: 'Media has been deleted.' };
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async postInternal(
+    fileStream: Express.Multer.File,
+    createMediaDto: InternalMediaDto,
+    userId: string,
+  ) {
+    try {
+      const mediaAttr: IBaseMediasAttr = {
+        ...createMediaDto,
+        MediaId: cuid(),
+        IsExternalYN: 'N',
+        ExternalSource: '',
+        URL: '',
+        FilePath: '',
+        CreatedAt: new Date(),
+        UpdatedAt: new Date(),
+        CreatedById: userId,
+        UpdatedById: userId,
+      };
+
+      this.init(mediaAttr);
+      const createdData = await this.createMedias(false, fileStream);
+      return createdData;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async postExternal(createMediaDto: ExternalMediaDto, userId: string) {
+    const mediaAttr: IBaseMediasAttr = {
+      ...createMediaDto,
+      MediaId: cuid(),
+      IsExternalYN: 'Y',
+      CreatedAt: new Date(),
+      UpdatedAt: new Date(),
+      IsEncryptedYN: 'N',
+      FilePath: '',
+      FileName: '',
+      FileExtension: '',
+      CreatedById: userId,
+      UpdatedById: userId,
+    };
+    this.init(mediaAttr);
+    await this.createMedias(true);
+    return mediaAttr;
+  }
+
+  async getAll(rows: number, page: number, search: string) {
+    let searchObj: any;
+    try {
+      searchObj = search ? JSON.parse(search) : {};
+    } catch (err) {
+      throw new BadRequestException('Bad value for search.');
+    }
+
+    const { ...mediaFilter } = searchObj;
+    const queryObj = {};
+
+    Object.entries(mediaFilter).forEach(([key, value]) => {
+      queryObj[key] = {
+        [Op.substring]: value,
+      };
+    });
+
+    const offset = rows * (page - 1);
+
+    const options = {
+      order: [['CreatedAt', 'DESC']],
+      limit: rows,
+      offset,
+      where: queryObj,
+      distinct: true,
+    };
+
+    return this.findAllWithPagination(options);
+  }
+
+  async getOne(id: string) {
+    try {
+      const media = await this.findOne({ where: { MediaId: id } });
+      if (!media) {
+        throw new NotFoundException(`Media not found with id ${id}`);
+      }
+      return media;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async getFile(id: string) {
+    try {
+      const media = await this.findOne({ where: { MediaId: id } });
+      if (!media) {
+        throw new NotFoundException(`Media not found with id ${id}`);
+      }
+      this.init({ ...media.get({ plain: true }) });
+      const fileBuffer: Buffer = await this.findFile();
+      return {
+        fileBuffer: fileBuffer,
+        resOption: {
+          'Content-Type': 'application/octet-stream',
+          'Content-Disposition': `attachment; filename=${media.FileName}.${media.FileExtension}`,
+          'Content-Length': fileBuffer.length,
+        },
+      };
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async remove(id: string, userId: string) {
+    try {
+      const media = await this.findOne({ where: { MediaId: id } });
+      if (!media) {
+        throw new NotFoundException(`Media not found with id ${id}`);
+      }
+      const mediaAttr: IBaseMediasAttr = {
+        ...media.get({ plain: true }),
+        UpdatedAt: new Date(),
+        UpdatedById: userId,
+      };
+      this.init(mediaAttr);
+      return await this.delete();
     } catch (error) {
-      throw error
+      throw error;
+    }
+  }
+
+  async putExternal(
+    id: string,
+    updatedMediaDto: ExternalMediaDto,
+    userId: string,
+  ) {
+    try {
+      const media = await this.findOne({ where: { MediaId: id } });
+      if (!media) {
+        throw new NotFoundException(`Media not found with id ${id}`);
+      }
+      const mediaAttr: IBaseMediasAttr = {
+        ...media.get({ plain: true }),
+        ...updatedMediaDto,
+        UpdatedAt: new Date(),
+        UpdatedById: userId,
+      };
+      this.init(mediaAttr);
+      return await this.updateMedias(true);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async putInternal(
+    fileStream: Express.Multer.File,
+    id: string,
+    updatedMediaDto: InternalMediaDto,
+    userId: string
+  ) {
+    try {
+      const media = await this.findOne({ where: { MediaId: id } });
+      if (!media) {
+        throw new NotFoundException(`Media not found with id ${id}`);
+      }
+      const mediaAttr: IBaseMediasAttr = {
+        ...media.get({ plain: true }),
+        ...updatedMediaDto,
+        UpdatedAt: new Date(),
+        UpdatedById: userId,
+      };
+      this.init(mediaAttr);
+      return await this.updateMedias(true,fileStream);
+    } catch (error) {
+      throw error;
     }
   }
 }

package/src/pipe/validate-search.pipe.ts

@@ -7,7 +7,10 @@ import {
 
 @Injectable()
 export class ValidateSearchPipe implements PipeTransform {
-  constructor(private model: any, private additonalAttributes: string[] = []) {}
+  constructor(
+    private model: any,
+    private additionalAttributes: string[] = [],
+  ) {}
 
   transform(value: string) {
     let search = {};
@@ -19,12 +22,12 @@ export class ValidateSearchPipe implements PipeTransform {
         throw new BadRequestException('Bad value for search.');
       }
       const attributes: string[] = [
-        ...this.additonalAttributes,
-        ...Object.keys(this.model['tableAttributes']),
+        ...this.additionalAttributes,
+        ...Object.keys(this.model.tableAttributes),
       ];
       const searchAttributes: string[] = Object.keys(search);
       const invalidKeys = searchAttributes.filter(
-        (value) => !attributes.includes(value),
+        (attr) => !attributes.includes(attr),
       );
 
       if (invalidKeys.length > 0) {

package/src/medias.controller.ts

@@ -1,244 +0,0 @@
-import {
-  DefaultValuePipe,
-  Get,
-  Inject,
-  ParseIntPipe,
-  Query,
-  Body,
-  Controller,
-  Post,
-  UploadedFile,
-  UseInterceptors,
-  BadRequestException,
-  Delete,
-  Param,
-  Put,
-  StreamableFile,
-  Res,
-  HttpException,
-} from '@nestjs/common';
-import { FileInterceptor } from '@nestjs/platform-express';
-import { ApiOkResponse, ApiOperation } from '@nestjs/swagger';
-import * as cuid from 'cuid';
-import { CommonService } from './common/common.service';
-import { ValidateSearchPipe } from './pipe/validate-search.pipe';
-import { ExternalMediaDto } from './dto/external-media.dto';
-import { InternalMediaDto } from './dto/internal-medias.dto';
-import { MediasModel } from './entities/medias.entity';
-import { IBaseMediasAttr } from './interfaces/base.medias-attr.interface';
-import { IMediasRepository } from './interfaces/medias.repository.interface';
-import { Medias } from './medias';
-import { Op } from 'sequelize';
-import { ValidateIdPipe } from './pipe/validate-id.pipe';
-import { Response } from 'express';
-import { throwException } from './helpers';
-
-@Controller('medias')
-export class MediasController {
-  constructor(
-    @Inject('MediasRepository')
-    private readonly mediaRepository: IMediasRepository,
-    private readonly commonService: CommonService,
-  ) {}
-  @Post('internal')
-  @UseInterceptors(FileInterceptor('FileStream'))
-  async createInternal(
-    @UploadedFile() fileStream: Express.Multer.File,
-    @Body() createMedia: InternalMediaDto,
-  ) {
-    try {
-      const mediaAttr: IBaseMediasAttr = {
-        ...createMedia,
-        MediaId: cuid(),
-        IsExternalYN: 'N',
-        ExternalSource: '',
-        URL: '',
-        FilePath: '',
-        CreatedAt: new Date(),
-        UpdatedAt: new Date(),
-        CreatedById: 'test_user',
-        UpdatedById: 'test_user',
-      };
-      const media = new Medias(
-        this.mediaRepository,
-        this.commonService,
-        mediaAttr,
-      );
-      const createdData = await media.createMedias(false, fileStream);
-      return createdData;
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  @Post('/external')
-  async createExternal(@Body() createMedia: ExternalMediaDto) {
-    const mediaAttr: IBaseMediasAttr = {
-      ...createMedia,
-      MediaId: cuid(),
-      IsExternalYN: 'Y',
-      CreatedAt: new Date(),
-      UpdatedAt: new Date(),
-      IsEncryptedYN: 'N',
-      FilePath: '',
-      FileName: '',
-      FileExtension: '',
-      CreatedById: 'test_user',
-      UpdatedById: 'test_user',
-    };
-    const media = new Medias(
-      this.mediaRepository,
-      this.commonService,
-      mediaAttr,
-    );
-    await media.createMedias(true);
-    return mediaAttr;
-  }
-
-  @Get()
-  @ApiOperation({
-    summary: 'Get all Medias',
-  })
-  @ApiOkResponse({
-    description: 'Paginanted Medias',
-  })
-  async findAll(
-    @Query('rows', new DefaultValuePipe(10), ParseIntPipe) rows: number,
-    @Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number,
-    @Query(
-      'search',
-      new ValidateSearchPipe(MediasModel, ['ObjectId', 'ObjectType', 'Title']),
-    )
-    search: string,
-  ) {
-    let searchObj: any;
-    try {
-      searchObj = search ? JSON.parse(search) : {};
-    } catch (err) {
-      throw new BadRequestException('Bad value for search.');
-    }
-
-    const { ...mediaFilter } = searchObj;
-    const queryObj = {};
-
-    Object.entries(mediaFilter).forEach(([key, value]) => {
-      queryObj[key] = {
-        [Op.substring]: value,
-      };
-    });
-
-    const offset = rows * (page - 1);
-
-    const options = {
-      order: [['CreatedAt', 'DESC']],
-      limit: rows,
-      offset: offset,
-      where: queryObj,
-      distinct: true,
-    };
-
-    const media = new Medias(this.mediaRepository, this.commonService);
-
-    return media.findAllWithPagination(options);
-  }
-
-  @Get('/:id')
-  @ApiOperation({ summary: 'Get media by MediaId' })
-  @ApiOkResponse({
-    description: 'The found media',
-    type: MediasModel,
-  })
-  async findOne(@Param('id', new ValidateIdPipe()) id: string) {
-    const media = new Medias(this.mediaRepository, this.commonService);
-    const file = await media.findOne({where: { MediaId: id}});
-    return file;
-  }
-
-  @Get('/:id/file')
-  @ApiOperation({ summary: 'Get media file by MediaId' })
-  @ApiOkResponse({
-    description: 'filestream',
-    type: Buffer,
-  })
-  async getFile(
-    @Param('id', new ValidateIdPipe()) id: string,
-    @Res({ passthrough: true }) res: Response,
-  ) {
-    let media = new Medias(this.mediaRepository, this.commonService);
-    const mediaData = await media.findOne({where: { MediaId: id}});
-    media = new Medias(this.mediaRepository, this.commonService, {
-      ...mediaData.get({ plain: true }),
-    });
-    const fileBuffer: Buffer = await media.getFile();
-
-    res.set({
-      'Content-Type': 'application/octet-stream',
-      'Content-Disposition': `attachment; filename=${mediaData.FileName}.${mediaData.FileExtension}`,
-      'Content-Length': fileBuffer.length,
-    });
-    return new StreamableFile(fileBuffer);
-  }
-
-  @Delete('/:id')
-  @ApiOperation({ summary: 'Delete media by MediaId' })
-  async delete(@Param('id', new ValidateIdPipe()) id: string) {
-    try {
-      let media = new Medias(this.mediaRepository, this.commonService);
-      const mediaData = await media.findOne({where: { MediaId: id}});
-
-      const mediaAttr: IBaseMediasAttr = {
-        ...mediaData.get({ plain: true }),
-        UpdatedAt: new Date(),
-        UpdatedById: 'test_user',
-      };
-      media = new Medias(this.mediaRepository, this.commonService, mediaAttr);
-      return await media.delete();
-    } catch (error) {
-      throw error;
-    }
-  }
-
-  @Put('/external/:id')
-  async updateExternal(
-    @Param('id', new ValidateIdPipe()) id: string,
-    @Body() updatedMedia: ExternalMediaDto,
-  ) {
-    let media = new Medias(this.mediaRepository, this.commonService);
-
-    const mediaData = await media.findOne({where: { MediaId: id}});
-
-    const mediaAttr: IBaseMediasAttr = {
-      ...mediaData.get({ plain: true }),
-      ...updatedMedia,
-      UpdatedAt: new Date(),
-      UpdatedById: 'test_user',
-    };
-    media = new Medias(this.mediaRepository, this.commonService, mediaAttr);
-    await media.updateMedias(true);
-  }
-
-  @Put('/internal/:id')
-  @UseInterceptors(FileInterceptor('FileStream'))
-  async updateInternal(
-    @UploadedFile() fileStream: Express.Multer.File,
-    @Param('id', new ValidateIdPipe()) id: string,
-    @Body() updatedMedia: InternalMediaDto,
-  ) {
-    try {
-      let media = new Medias(this.mediaRepository, this.commonService);
-
-      const mediaData = await media.findOne({where: { MediaId: id}});
-      const mediaAttr: IBaseMediasAttr = {
-        ...mediaData.get({ plain: true }),
-        ...updatedMedia,
-        UpdatedAt: new Date(),
-        UpdatedById: 'test_user',
-      };
-      media = new Medias(this.mediaRepository, this.commonService, mediaAttr);
-      await media.updateMedias(false, fileStream);
-      return mediaAttr;
-    } catch (error) {
-      throw error;
-    }
-  }
-}