@tomei/media 0.1.0

package/src/medias.ts

@@ -0,0 +1,494 @@
+import { BlobServiceClient } from '@azure/storage-blob';
+import { BadRequestException } from '@nestjs/common';
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import { CommonService } from './common/common.service';
+import * as util from 'util';
+import { BaseMedias } from './base/base.medias';
+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';
+
+type MediaFile = {
+  buffer: Buffer;
+  iv?: Buffer;
+  isEncrypted?: boolean;
+};
+
+type FilePath = {
+  filePath: string;
+  ivFilePath: string;
+};
+
+export class Medias extends BaseMedias {
+  blobServiceClient = BlobServiceClient.fromConnectionString(
+    process.env.AZURE_STORAGE_CONNECTION_STRING,
+  );
+  container: string;
+  algorithm = 'aes-256-cbc';
+  commonService: CommonService;
+  entity = typeof MediasModel;
+
+  constructor(
+    mediaRepository: IMediasRepository,
+    commonService: CommonService,
+    media?: IBaseMediasAttr,
+  ) {
+    super(mediaRepository, media);
+    this.commonService = commonService;
+    try {
+      this.container = process.env.MEDIA_AZUREBLOB_CONTAINER_NAME;
+      if (!this.container && this.IsStorageTypeAzure()) {
+        throw new BadRequestException(
+          'CONTAINER_NAME Environtment Variable name not found',
+        );
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async createMedias(
+    isExternalMedias: boolean,
+    stream?: Express.Multer.File,
+  ) {
+    try {
+      const media = await super.create();
+      let activityDescription = `Added a new external media Id: ${this.MediaId}.`;
+      if (!isExternalMedias) {
+        activityDescription = `Added a new media Id: ${this.MediaId}.`;
+        await this.createInternalMedias(stream);
+      }
+      if (media) {
+        await this.commonService.addActivityHistory(
+          {
+            Action: 'Add',
+            Activity: 'Add New Media',
+            Description: activityDescription,
+            EntityId: this.MediaId,
+            EntityValueBefore: '',
+            EntityValueAfter: JSON.stringify({ ...media.get({ plain: true }) }),
+            PerformedById: this.CreatedById,
+            PerformedAt: this.CreatedAt,
+          },
+          this.entity,
+          '',
+        );
+      }
+      return media;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async updateMedias(
+    isExternalMedias: boolean,
+    stream?: Express.Multer.File,
+  ) {
+    try {
+      const oldMedia = await super.findOne({where: { MediaId: this.MediaId}});
+      const media = await super.update();
+      let activityDescription = `Updated external media Id: ${this.MediaId}.`;
+      if (!isExternalMedias) {
+        await this.updateInternalMedia(stream, oldMedia);
+        activityDescription = `Updated media Id: ${this.MediaId}.`;
+      }
+      if (media) {
+        await this.commonService.addActivityHistory(
+          {
+            Action: 'Update',
+            Activity: 'Update Media',
+            Description: activityDescription,
+            EntityId: this.MediaId,
+            EntityValueBefore: JSON.stringify({
+              ...oldMedia.get({ plain: true }),
+            }),
+            EntityValueAfter: JSON.stringify({ ...media.get({ plain: true }) }),
+            PerformedById: this.UpdatedById,
+            PerformedAt: this.UpdatedAt,
+          },
+          this.entity,
+          '',
+        );
+      }
+
+      return media;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  private IsStorageTypeAzure(): boolean {
+    const mediaStorageType = process.env.MEDIA_STORAGE_TYPE;
+    if (mediaStorageType === 'azure') {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  private async updateInternalMedia(
+    stream: Express.Multer.File,
+    oldMedia: MediasModel,
+  ): Promise<void> {
+    try {
+      this.FileExtension = this.FileExtension.split('.')[0];
+      this.FileName = this.FileName.replace(/\.[^/.]+$/, '');
+
+      let file: MediaFile;
+      if (this.IsEncryptedYN == 'Y') {
+        file = await this.encrypt(stream.buffer);
+      } else {
+        file = {
+          buffer: stream.buffer,
+          isEncrypted: false,
+        };
+      }
+      if (this.IsStorageTypeAzure()) {
+        await this.deleteUploadedFileFromAzure(
+          oldMedia.URL,
+          oldMedia.FileName,
+          oldMedia.FileExtension,
+          oldMedia.IsEncryptedYN,
+        );
+
+        await this.uploadFileToAzure(file);
+      } else {
+        const filePath = super.createSaveLocation();
+        const isDirExist = util.promisify(fs.exists);
+        const isDir = await isDirExist(filePath);
+        if (isDir) {
+          fs.unlinkSync(this.FilePath);
+          if (this.IsEncryptedYN == 'Y') {
+            fs.unlinkSync(this.getIvPath());
+          }
+        }
+        await this.uploadFileToLocal(file);
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  private async createInternalMedias(
+    stream: Express.Multer.File,
+  ): Promise<void> {
+    try {
+      this.FileExtension = this.FileExtension.split('.')[0];
+      this.FileName = this.FileName.replace(/\.[^/.]+$/, '');
+      let file: MediaFile;
+      if (this.IsEncryptedYN == 'Y') {
+        file = await this.encrypt(stream.buffer);
+      } else {
+        file = {
+          buffer: stream.buffer,
+          isEncrypted: false,
+        };
+      }
+      if (this.IsStorageTypeAzure()) {
+        this.uploadFileToAzure(file);
+      } else {
+        this.uploadFileToLocal(file);
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  private getIvPath() {
+    return super.createSaveLocation() + `/${this.FileName}iv.iv`;
+  }
+
+  private async uploadFileToLocal(file: MediaFile): Promise<FilePath> {
+    try {
+      const savelocation = super.createSaveLocation();
+      const isDirExist = util.promisify(fs.exists);
+      const createDir = util.promisify(fs.mkdir);
+      const isDir = await isDirExist(savelocation);
+      if (!isDir) {
+        await createDir(savelocation, { recursive: true });
+      }
+
+      fs.createWriteStream(this.FilePath).write(file.buffer);
+      fs.createWriteStream(this.getIvPath()).write(file.iv);
+      const path: FilePath = {
+        filePath: super.createSaveLocation(),
+        ivFilePath: this.getIvPath(),
+      };
+
+      return path;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  private async deleteUploadedFileFromLocal(
+    path:string,
+    isEncryptedYN:string,
+  ): Promise<void> {
+    try {
+      const isDirExist = util.promisify(fs.exists);
+      const isDir = await isDirExist(path);
+      if (isDir) {
+        const deleteFile = util.promisify(fs.unlink);
+        await deleteFile(path);
+        if (isEncryptedYN == 'Y') {
+          await deleteFile(this.getIvPath());
+        }
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  private async uploadFileToAzure(file: MediaFile): Promise<FilePath> {
+    const filePath = await this.uploadFileToAzureStorage(
+      file.buffer,
+      this.ObjectType,
+      this.ObjectId,
+      this.FileName,
+      this.FileExtension,
+    );
+
+    let ivPath: string;
+    if (this.IsEncryptedYN == 'Y') {
+      ivPath = await this.uploadFileToAzureStorage(
+        file.iv,
+        this.ObjectType,
+        this.ObjectId,
+        this.FileName+"iv",
+        'iv',
+      );
+    }
+
+    const path: FilePath = {
+      filePath: filePath,
+      ivFilePath: ivPath,
+    };
+
+    return path;
+  }
+
+  private async deleteUploadedFileFromAzure(
+    path: string,
+    FileName: string,
+    FileExtension: string,
+    isEncryptedYN: string,
+  ): Promise<void> {
+    try {
+      await this.deleteUploadedFileToAzureStorage(path, FileName, FileExtension);
+      if (isEncryptedYN == 'Y') {
+        await this.deleteUploadedFileToAzureStorage(path, FileName+"iv", '.iv');
+      }
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  private async uploadFileToAzureStorage(
+    bufferFile: Buffer,
+    ObjectType: string,
+    ObjectId: string,
+    FileName: string,
+    FileExtension: string,
+  ): Promise<string> {
+    try {
+      const fileName = FileName.replace(/\.[^/.]+$/, '');
+      const path = `${this.container}/${ObjectType}/${ObjectId}`;
+      const blobcontainer = this.blobServiceClient.getContainerClient(path);
+      const blockBlobClient = await blobcontainer.getBlockBlobClient(
+        `${fileName}.${FileExtension}`,
+      );
+      await blockBlobClient.uploadData(bufferFile);
+      return path;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async deleteUploadedFileToAzureStorage(
+    path: string,
+    FileName: string,
+    FileExtension: string,
+  ): Promise<any> {
+    const fileName = FileName.replace(/\.[^/.]+$/, '');
+    const blobcontainer = this.blobServiceClient.getContainerClient(path);
+    const blockBlobClient = await blobcontainer.getBlockBlobClient(
+      `${fileName}.${FileExtension}`,
+    );
+    return await blockBlobClient.deleteIfExists();
+  }
+
+  private setKey(): string {
+    try {
+      const key = process.env.MEDIA_ENCRYPT_KEY;
+      if (!key) {
+        throw new BadRequestException(
+          'MEDIA_ENCRYPT_KEY Environtment Variable name not found',
+        );
+      }
+      return key;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async getFile(): Promise<Buffer> {
+    try {
+      let fileBuffer: Buffer;
+      if (this.IsStorageTypeAzure()) {
+        fileBuffer = await this.getFileFromAzure(
+          this.URL,
+          this.FileName,
+          this.FileExtension,
+        );
+      } else {
+        fileBuffer = await this.getFileFromLocal(this.FilePath);
+      }
+
+      let file: MediaFile = {
+        buffer: fileBuffer,
+        isEncrypted: this.IsEncryptedYN === 'Y' ? true : false,
+      };
+      if (file.isEncrypted) {
+        if (this.IsStorageTypeAzure()) {
+          file.iv = await this.getFileFromAzure(
+            this.URL,
+            this.FileName+"iv",
+            'iv'
+          );
+        } else {
+          file.iv = await this.getFileFromLocal(this.getIvPath());
+        }
+        file = await this.decrypt(file);
+      }
+      return file.buffer;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  private async stream2buffer(stream: Readable | fs.ReadStream): Promise<Buffer> {
+    return new Promise<Buffer>((resolve, reject) => {
+      const buffer = Array<any>();
+
+      stream.on('data', (chunk) => buffer.push(chunk));
+      stream.on('end', () => resolve(Buffer.concat(buffer)));
+      stream.on('error', (err) => reject(`error converting stream - ${err}`));
+    });
+  }
+
+  private async getFileFromAzure(
+    path: string,
+    FileName: string,
+    FileExtension: string,
+  ): Promise<Buffer> {
+    try {
+      const fileName = FileName.replace(/\.[^/.]+$/, '');
+      const blobcontainer = this.blobServiceClient.getContainerClient(path);
+      const blockBlobClient = await blobcontainer.getBlockBlobClient(
+        `${fileName}.${FileExtension}`,
+      );
+      const downloadResponse = await blockBlobClient.download();
+      const ReadStream = new Readable().wrap(downloadResponse.readableStreamBody);
+      const file = await this.stream2buffer(ReadStream);
+      return file
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  private async getFileFromLocal(pathfile: string): Promise<Buffer> {
+    try {
+      const stream = fs.createReadStream(pathfile);
+      const file = await this.stream2buffer(stream);
+      return file;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async encrypt(fileBuffer: Buffer): Promise<MediaFile> {
+    try {
+      const key = this.setKey();
+      const iv = crypto.randomBytes(16);
+
+      const cipher = crypto.createCipheriv(this.algorithm, key, iv);
+      const resultBuffer = Buffer.concat([
+        cipher.update(fileBuffer),
+        cipher.final(),
+      ]);
+
+      const result: MediaFile = {
+        buffer: resultBuffer,
+        iv: iv,
+        isEncrypted: true,
+      };
+
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async decrypt(file: MediaFile): Promise<MediaFile> {
+    try {
+      const key = this.setKey();
+      const iv = file.iv;
+      const decipher = crypto.createDecipheriv(this.algorithm, key, iv);
+      const resultBuffer = Buffer.concat([
+        decipher.update(file.buffer),
+        decipher.final(),
+      ]);
+
+      const result: MediaFile = {
+        buffer: resultBuffer,
+        isEncrypted: false,
+      };
+
+      return result;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async delete(): Promise<any> {
+    try {
+      const data: MediasModel = await super.delete();
+      if (this.IsExternalYN == 'N') {
+        if (this.IsStorageTypeAzure()) {
+          await this.deleteUploadedFileFromAzure(
+            this.URL,
+            this.FileName,
+            this.FileExtension,
+            this.IsEncryptedYN,
+          );
+        } else {
+          await this.deleteUploadedFileFromLocal(
+            this.URL,
+            this.IsEncryptedYN
+          );
+        }
+      }
+
+      await this.commonService.addActivityHistory(
+        {
+          Action: 'Delete',
+          Activity: 'Delete Media',
+          Description: `Deleted media (ID: ${this.MediaId})`,
+          EntityId: this.MediaId,
+          EntityValueBefore: JSON.stringify(data),
+          EntityValueAfter: '',
+          PerformedById: this.UpdatedById,
+          PerformedAt: new Date(),
+        },
+        this.entity,
+        '',
+      );
+      return { message: 'Media has been deleted.' }
+    } catch (error) {
+      throw error
+    }
+  }
+}

package/src/pipe/append-id.pipe.ts

@@ -0,0 +1,15 @@
+import { Injectable, PipeTransform } from '@nestjs/common';
+import * as cuid from 'cuid';
+
+@Injectable()
+export class AppendIdPipe implements PipeTransform {
+  private readonly idName: string;
+
+  constructor(idName: string) {
+    this.idName = idName;
+  }
+
+  transform(value: any) {
+    return { ...value, [this.idName]: cuid() };
+  }
+}

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

@@ -0,0 +1,31 @@
+import { BadRequestException, PipeTransform } from '@nestjs/common';
+import { isDefined, isEnum } from 'class-validator';
+
+export class ValidateEnumPipe
+  implements PipeTransform<string, Promise<any> | string | string[]>
+{
+  constructor(private enumEntity: any) {}
+
+  transform(value: string): Promise<any> | string | string[] {
+    const validateEnum = (enumValue) => {
+      if (isDefined(enumValue)) {
+        if (isEnum(enumValue, this.enumEntity)) {
+          return this.enumEntity[enumValue];
+        } else {
+          const errorMessage = `the value ${enumValue} is not valid. See the acceptable values: ${Object.keys(
+            this.enumEntity,
+          ).map((key) => this.enumEntity[key])}`;
+          throw new BadRequestException(errorMessage);
+        }
+      } else {
+        return value;
+      }
+    };
+
+    if (Array.isArray(value)) {
+      return value.map((item) => validateEnum(item));
+    } else {
+      return validateEnum(value);
+    }
+  }
+}

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

@@ -0,0 +1,18 @@
+import { BadRequestException, Injectable, PipeTransform } from '@nestjs/common';
+import * as cuid from 'cuid';
+
+@Injectable()
+export class ValidateIdPipe implements PipeTransform {
+  errorMessage: string;
+
+  constructor(messageOverrides = 'Invalid id.') {
+    this.errorMessage = messageOverrides;
+  }
+
+  transform(value: string) {
+    if (value && !cuid.isCuid(value)) {
+      throw new BadRequestException(this.errorMessage);
+    }
+    return value;
+  }
+}

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

@@ -0,0 +1,41 @@
+import {
+  BadRequestException,
+  Injectable,
+  // Logger,
+  PipeTransform,
+} from '@nestjs/common';
+
+@Injectable()
+export class ValidateSearchPipe implements PipeTransform {
+  constructor(private model: any, private additonalAttributes: string[] = []) {}
+
+  transform(value: string) {
+    let search = {};
+
+    if (value) {
+      try {
+        search = JSON.parse(value);
+      } catch (err) {
+        throw new BadRequestException('Bad value for search.');
+      }
+      const attributes: string[] = [
+        ...this.additonalAttributes,
+        ...Object.keys(this.model['tableAttributes']),
+      ];
+      const searchAttributes: string[] = Object.keys(search);
+      const invalidKeys = searchAttributes.filter(
+        (value) => !attributes.includes(value),
+      );
+
+      if (invalidKeys.length > 0) {
+        throw new BadRequestException(
+          `${invalidKeys} ${
+            invalidKeys.length > 1 ? 'are invalid keys' : 'is an invalid key'
+          } for search query`,
+        );
+      }
+    }
+
+    return value;
+  }
+}

package/src/responses/deleted.response.ts

@@ -0,0 +1,6 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class DeletedMediasResponse {
+  @ApiProperty({ example: 'EzCash slot group has been deleted.' })
+  message: string;
+}

package/src/responses/pagination.response.ts

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { MediasModel } from '../entities/medias.entity';
+
+export class PaginatedMediasResponse {
+  @ApiProperty()
+  count: number;
+
+  @ApiProperty({ isArray: true, type: MediasModel })
+  rows: MediasModel[];
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "moduleResolution": "node",
+    "target": "es2017",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+    "paths": {
+      "@app/media": [
+        "libs/media/src"
+      ],
+      "@app/media/*": [
+        "libs/media/src/*"
+      ]
+    }
+  }
+}

package/tslint.json

@@ -0,0 +1,18 @@
+{
+  "defaultSeverity": "error",
+  "extends": ["tslint:recommended"],
+  "jsRules": {
+    "no-unused-expression": true
+  },
+  "rules": {
+    "quotemark": [true, "single"],
+    "member-access": [false],
+    "ordered-imports": [false],
+    "max-line-length": [true, 150],
+    "member-ordering": [false],
+    "interface-name": [false],
+    "arrow-parens": false,
+    "object-literal-sort-keys": false
+  },
+  "rulesDirectory": []
+}