@tomei/media 0.1.0

package/src/base/base.medias.ts

@@ -0,0 +1,200 @@
+import { MediaType } from '../enum/medias.enum';
+import * as cuid from 'cuid';
+import { BadRequestException } from '@nestjs/common';
+import { IMediasRepository } from '../interfaces/medias.repository.interface';
+import { MediasModel } from '../entities/medias.entity';
+import { IBaseMediasAttr } from '../interfaces/base.medias-attr.interface';
+import { throwException } from '../helpers';
+
+export abstract class BaseMedias {
+  MediaId: string;
+  ObjectId: string;
+  ObjectType: string;
+  Title: string;
+  Description: string;
+  Type: MediaType;
+  IsExternalYN: string;
+  ExternalSource: string;
+  IsEncryptedYN: string;
+  FileName: string;
+  FileExtension: string;
+  FilePath: string;
+  URL: string;
+  CreatedById: string;
+  CreatedAt: Date;
+  UpdatedById: string;
+  UpdatedAt: Date;
+  mediasRepository: IMediasRepository;
+  container: string;
+
+  protected constructor(
+    mediasRepository: IMediasRepository,
+    media?: IBaseMediasAttr,
+  ) {
+    this.mediasRepository = mediasRepository;
+    if (media) {
+      this.MediaId = media.MediaId ? media.MediaId : cuid();
+      this.ObjectId = media.ObjectId;
+      this.ObjectType = media.ObjectType;
+      this.Title = media.Title;
+      this.Description = media.Description;
+      this.Type = media.Type;
+      this.IsExternalYN = media.IsExternalYN;
+      this.ExternalSource = media.ExternalSource;
+      this.IsEncryptedYN = media.IsEncryptedYN;
+      this.FileName = media.FileName;
+      this.FileExtension = media.FileExtension;
+      this.URL = media.URL && media.IsExternalYN == "Y" ? media.URL : this.createSaveLocation();
+      this.FilePath = media.FilePath && media.IsExternalYN == "Y" ? media.FilePath : this.createFilePath();
+      this.CreatedById = media.CreatedById;
+      this.CreatedAt = media.CreatedAt;
+      this.UpdatedById = media.UpdatedById;
+      this.UpdatedAt = media.UpdatedAt;
+    }
+  }
+
+  createSaveLocation(): string {
+    try {
+      const mediaFileStorageType = process.env.MEDIA_STORAGE_TYPE;
+      let basePath: string;
+      if (mediaFileStorageType === 'local') {
+        basePath = process.env.MEDIA_LOCAL_STORAGE_PATH;
+      } else {
+        basePath = process.env.MEDIA_AZUREBLOB_CONTAINER_NAME;
+      }
+
+      if (!basePath) {
+        throw new BadRequestException(
+          'MEDIA_LOCAL_STORAGE_PATH and or MEDIA_AZUREBLOB_CONTAINER_NAME not found.',
+        );
+      }
+      return basePath + `/${this.ObjectType}/${this.ObjectId}`;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  createFilePath(): string {
+    try {
+      const fileLocation = this.createSaveLocation();
+      return `${fileLocation}/${this.FileName}.${this.FileExtension}`;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  async create(options?: any): Promise<MediasModel> {
+    try {
+      return this.mediasRepository.create(
+        {
+          MediaId: this.MediaId,
+          ObjectId: this.ObjectId,
+          ObjectType: this.ObjectType,
+          Title: this.Title,
+          Description: this.Description,
+          Type: this.Type,
+          IsExternalYN: this.IsExternalYN,
+          ExternalSource: this.ExternalSource,
+          IsEncryptedYN: this.IsEncryptedYN,
+          FileName: this.FileName,
+          FileExtension: this.FileExtension,
+          FilePath: this.FilePath,
+          URL: this.URL,
+          CreatedById: this.CreatedById,
+          CreatedAt: this.CreatedAt,
+          UpdatedById: this.UpdatedById,
+          UpdatedAt: this.UpdatedAt,
+        },
+        options,
+      );
+    } catch (error) {
+      throw error
+    }
+  }
+
+  async update(options?: any): Promise<MediasModel | any> {
+    try {
+      const media = await this.mediasRepository.findOne({
+        where: {
+          MediaId: this.MediaId,
+        },
+      });
+
+      if (!media) {
+        throw new BadRequestException('Media not found.');
+      }
+      return await media.update(
+        {
+          MediaId: this.MediaId,
+          ObjectId: this.ObjectId,
+          ObjectType: this.ObjectType,
+          Title: this.Title,
+          Description: this.Description,
+          Type: this.Type,
+          IsExternalYN: this.IsExternalYN,
+          ExternalSource: this.ExternalSource,
+          IsEncryptedYN: this.IsEncryptedYN,
+          FileName: this.FileName,
+          FileExtension: this.FileExtension,
+          FilePath: this.FilePath,
+          URL: this.URL,
+          CreatedById: this.CreatedById,
+          CreatedAt: this.CreatedAt,
+          UpdatedById: this.UpdatedById,
+          UpdatedAt: this.UpdatedAt,
+        },
+        options,
+      );
+    } catch (error) {
+      throw error
+    }
+  }
+
+  async delete(options?: any): Promise<MediasModel> {
+    try {
+      const media = await this.mediasRepository.findOne({
+        where: {
+          MediaId: this.MediaId,
+        },
+      });
+
+      const data = {
+        ...media.get({plain: true}),
+      }
+
+      if (!media) {
+        throw new BadRequestException('Media not found.');
+      }
+      await media.destroy(options);
+      return data;
+    } catch (error) {
+      throw error
+    }
+  }
+
+  async findAll(options?: any): Promise<MediasModel[]> {
+    try {
+      return this.mediasRepository.findAll(options);
+    } catch (error) {
+      throw error
+    }
+  }
+
+  async findAllWithPagination(
+    options?: any,
+  ): Promise<{ count: number; rows: MediasModel[] }> {
+    try {
+      return this.mediasRepository.findAllWithPagination(options);
+    } catch (error) {
+      throw error
+    }
+  }
+
+  async findOne(options?: any): Promise<MediasModel> {
+    try {
+      return this.mediasRepository.findOne(options);
+    } catch (error) {
+      throw error
+    }
+  }
+}

package/src/base/base.repository.abstract.ts

@@ -0,0 +1,28 @@
+import { IBaseRepository } from './base.repository.interface';
+
+export abstract class BaseRepository<T> implements IBaseRepository<T> {
+  private model: any;
+  // private id: string;
+
+  protected constructor(model: any) {
+    this.model = model;
+  }
+
+  public async create(data: any, options?: any): Promise<void | T> {
+    return this.model.create(data, options);
+  }
+
+  public async findAll(options: any): Promise<T[]> {
+    return this.model.findAll(options);
+  }
+
+  public async findAllWithPagination(
+    options: any,
+  ): Promise<{ count: number; rows: T[] }> {
+    return this.model.findAndCountAll(options);
+  }
+
+  public async findOne(options: any): Promise<T> {
+    return this.model.findOne(options);
+  }
+}

package/src/base/base.repository.interface.ts

@@ -0,0 +1,9 @@
+export interface IBaseRepository<T> {
+  create(data: T | any, options?: any): Promise<T> | any;
+
+  findAll(options: any): Promise<T[]>;
+
+  findAllWithPagination(options: any): Promise<{ count: number; rows: T[] }>;
+
+  findOne(options: any): Promise<T>;
+}

package/src/common/common.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { CommonService } from './common.service';
+
+@Module({
+  providers: [CommonService],
+  imports:[ConfigModule],
+  exports: [CommonService],
+})
+export class CommonModule {}

package/src/common/common.service.ts

@@ -0,0 +1,109 @@
+import {
+  HttpException,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import axios from 'axios';
+import * as cuid from 'cuid';
+import { omit, omitBy, keys, pick } from 'lodash';
+import { AddFieldTranslationDto } from './dto/add-field-translation.dto';
+import { GetMediaDto } from './dto/get-media.dto';
+@Injectable()
+export class CommonService {
+  private readonly commonApiUrl: string;
+
+  constructor(private configService: ConfigService) {
+    this.commonApiUrl = this.configService.get('COMMON_API_URL');
+  }
+
+  handleAxiosError(err) {
+    if (err.response) {
+      throw new HttpException(err.response.data, err.response.status);
+    } else if (err.request) {
+      throw new HttpException(err.request, 500);
+    } else {
+      throw new InternalServerErrorException(err.message);
+    }
+  }
+
+  async addActivityHistory(record, entity, method) {
+    const activity =
+      method === 'create'
+        ? 'Insert new'
+        : method === 'update'
+        ? 'Update'
+        : 'Delete';
+
+    const filteredRecord = omit(record.EntityValueAfter, [
+      'CreatedById',
+      'CreatedAt',
+      'UpdatedById',
+      'UpdatedAt',
+    ]);
+
+    const filteredRecordBefore = pick(
+      record.EntityValueBefore,
+      keys(filteredRecord),
+    );
+
+    const payload = {
+      Action: record.Action || (method === 'create' ? 'Insert' : activity),
+      Activity: record.Activity || `${activity} ${entity}`,
+      Description: record.Description || `${activity} details of ${entity}`,
+      EntityType: record?.EntityType || entity,
+      EntityValueBefore:
+        method === 'create'
+          ? {}
+          : method === 'update'
+          ? filteredRecordBefore
+          : record.EntityValueBefore,
+      EntityValueAfter: record.EntityId
+        ? omitBy(filteredRecord, record.EntityId)
+        : filteredRecord,
+      PerformedById: record.PerformedById,
+      PerformedAt: record.PerformedAt || Date.now(),
+      EntityId: record.EntityId ? record.EntityId : cuid(),
+    };
+
+    try {
+      const { data } = await axios.post(
+        `${this.commonApiUrl}/activity-histories`,
+        payload,
+      );
+      return data.EntityId;
+    } catch (err) {
+      this.handleAxiosError(err);
+    }
+  }
+
+  async getList(listName: string): Promise<[]> {
+    try {
+      const { data } = await axios.get(`${this.commonApiUrl}/lists/items`, {
+        params: { ListName: listName },
+      });
+      return data?.rows;
+    } catch (err) {
+      this.handleAxiosError(err);
+    }
+  }
+
+  async addFieldTranslation(payload: AddFieldTranslationDto) {
+    try {
+      await axios.post(`${this.commonApiUrl}/field-translations`, payload);
+    } catch (err) {
+      this.handleAxiosError(err);
+    }
+  }
+
+  async getMedia(query: GetMediaDto) {
+    try {
+      const { data } = await axios.get(`${this.commonApiUrl}/medias`, {
+        params: query,
+      });
+      return data?.rows;
+    } catch (err) {
+      this.handleAxiosError(err);
+    }
+  }
+}

package/src/common/dto/add-field-translation.dto.ts

@@ -0,0 +1,23 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class AddFieldTranslationDto {
+  @IsNotEmpty()
+  @IsString()
+  ObjectTable: string;
+
+  @IsNotEmpty()
+  @IsString()
+  ObjectField: string;
+
+  @IsNotEmpty()
+  @IsString()
+  ObjectId: string;
+
+  @IsNotEmpty()
+  @IsString()
+  LanguageCode: string;
+
+  @IsNotEmpty()
+  @IsString()
+  Translation: string;
+}

package/src/common/dto/get-media.dto.ts

@@ -0,0 +1,12 @@
+import { IsString } from 'class-validator';
+
+export class GetMediaDto {
+  @IsString()
+  ObjectID?: string;
+
+  @IsString()
+  ObjectType?: string;
+
+  @IsString()
+  Title: string;
+}

package/src/dto/external-media.dto.ts

@@ -0,0 +1,49 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEnum, IsNotEmpty, IsString, MaxLength } from 'class-validator';
+import { MediaType } from '../enum/medias.enum';
+
+export class ExternalMediaDto {
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(30)
+  @ApiProperty({ type: String, description: 'ObjectID' })
+  ObjectId: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(200)
+  @ApiProperty({ type: String, description: 'ObjectType' })
+  ObjectType: string;
+
+  @IsNotEmpty()
+  @ApiProperty({
+    type: String,
+    description: 'Enum  either Photo, Video, Document',
+  })
+  @IsEnum(MediaType)
+  Type: MediaType;
+
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(200)
+  @ApiProperty({ type: String, description: 'URL whre the file stored' })
+  URL: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(200)
+  @ApiProperty({ type: String, description: 'external source of the file' })
+  ExternalSource: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(100)
+  @ApiProperty({ type: String, description: 'title of the media' })
+  Title: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(1000)
+  @ApiProperty({ type: String, description: 'Description of the media' })
+  Description: string;
+}

package/src/dto/internal-medias.dto.ts

@@ -0,0 +1,64 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEnum, IsNotEmpty, IsString, MaxLength } from 'class-validator';
+import { MediaType } from '../enum/medias.enum';
+
+export class InternalMediaDto {
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(30)
+  @ApiProperty({ type: String, description: 'ObjectID' })
+  ObjectId: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(200)
+  @ApiProperty({ type: String, description: 'ObjectType' })
+  ObjectType: string;
+
+  @IsNotEmpty()
+  @ApiProperty({
+    type: String,
+    description: 'Enum  either Photo, Video, Document',
+  })
+  @IsEnum(MediaType)
+  Type: MediaType;
+
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(200)
+  @ApiProperty({ type: String, description: 'file name without extension' })
+  FileName: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(10)
+  @ApiProperty({ type: String, description: 'extention of file in jpg etc' })
+  FileExtension: string;
+
+  @ApiProperty({
+    type: String,
+    description: 'File stream buffer',
+    format: 'binary',
+  })
+  FileStream: any;
+
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(100)
+  @ApiProperty({ type: String, description: 'title of the media' })
+  Title: string;
+
+  @IsNotEmpty()
+  @IsString()
+  @MaxLength(1000)
+  @ApiProperty({ type: String, description: 'Description of the media' })
+  Description: string;
+
+  @IsNotEmpty()
+  @IsEnum(['N', 'Y'])
+  @ApiProperty({
+    type: String,
+    description: 'Option if media needed to be encryped : Y or N',
+  })
+  IsEncryptedYN: string;
+}

package/src/entities/medias.entity.ts

@@ -0,0 +1,125 @@
+import { ApiProperty } from '@nestjs/swagger';
+import {
+  Column,
+  CreatedAt,
+  Model,
+  Table,
+  UpdatedAt,
+} from 'sequelize-typescript';
+import { MediaType } from '../enum';
+
+@Table({ tableName: 'common_Media', createdAt: false, updatedAt: false })
+export class MediasModel extends Model {
+  @Column({
+    primaryKey: true,
+    allowNull: false,
+  })
+  @ApiProperty({ type: String, description: 'MediaID' })
+  MediaId: string;
+
+  @Column({
+    allowNull: false,
+  })
+  @ApiProperty({ type: String, description: 'ObjectID' })
+  ObjectId: string;
+
+  @Column({
+    allowNull: false,
+  })
+  @ApiProperty({ type: String, description: 'ObjectType' })
+  ObjectType: string;
+
+  @Column({
+    allowNull: true,
+  })
+  @ApiProperty({ type: String, description: 'title of the media' })
+  Title: string;
+
+  @Column({
+    allowNull: true,
+  })
+  @ApiProperty({ type: String, description: 'Description of the media' })
+  Description: string;
+
+  @Column({
+    allowNull: false,
+  })
+  @ApiProperty({
+    type: String,
+    description: 'Enum  either Photo, Video, Document',
+  })
+  Type: MediaType;
+
+  @Column({
+    allowNull: false,
+  })
+  @ApiProperty({ type: String, description: 'isExternal either Y, N' })
+  IsExternalYN: string;
+
+  @Column({
+    allowNull: true,
+  })
+  @ApiProperty({ type: String, description: 'External surce for the file' })
+  ExternalSource: string;
+
+  @Column({
+    allowNull: false,
+  })
+  @ApiProperty({ type: String, description: 'isExternal either Y, N' })
+  IsEncryptedYN: string;
+
+  @Column({
+    allowNull: true,
+  })
+  @ApiProperty({ type: String, description: 'file name without extension' })
+  FileName: string;
+
+  @Column({
+    allowNull: true,
+  })
+  @ApiProperty({ type: String, description: 'extention of file in jpg etc' })
+  FileExtension: string;
+
+  @Column({
+    allowNull: true,
+  })
+  @ApiProperty({
+    type: String,
+    description: 'location on the media in term of path',
+  })
+  FilePath: string;
+
+  @Column({
+    allowNull: true,
+  })
+  @ApiProperty({ type: String, description: 'URl of the media' })
+  URL: string;
+
+  @ApiProperty({
+    example: new Date(),
+    description: 'Timestamp for data creation.',
+  })
+  @CreatedAt
+  CreatedAt: Date;
+
+  @ApiProperty({
+    example: '138140891dd211b288d34bc7b4312a49',
+    description: 'The CreatedById for Media.',
+  })
+  @Column({ allowNull: false })
+  CreatedById: string;
+
+  @ApiProperty({
+    example: new Date(),
+    description: 'Timestamp for latest data modification',
+  })
+  @UpdatedAt
+  UpdatedAt: Date;
+
+  @ApiProperty({
+    example: '138140891dd211b288d34bc7b4312a49',
+    description: 'The UpdatedById for Media.',
+  })
+  @Column({ allowNull: false })
+  UpdatedById: string;
+}

package/src/enum/index.ts

@@ -0,0 +1,3 @@
+import { MediaType } from './medias.enum';
+
+export { MediaType };

package/src/enum/medias.enum.ts

@@ -0,0 +1,5 @@
+export enum MediaType {
+  Photo = 'Photo',
+  Video = 'Video',
+  Document = 'Document',
+}

package/src/helpers/error.ts

@@ -0,0 +1,12 @@
+import { HttpException } from '@nestjs/common';
+
+export function throwException(err) {
+  if (err.response) {
+    throw err;
+  } else {
+    throw new HttpException(
+      'Something went wrong. Please see application log.',
+      err.statusCode,
+    );
+  }
+}

package/src/helpers/index.ts

@@ -0,0 +1,3 @@
+import { throwException } from './error';
+
+export { throwException };

package/src/index.ts

@@ -0,0 +1,13 @@
+import { MediasModule } from "./medias.module";
+import { MediasController } from "./medias.controller";
+import { MediasRepository } from "./medias.repository";
+import { MediasModel } from "./entities/medias.entity";
+import { Medias } from "./medias";
+
+export {
+    MediasModule,
+    MediasController,
+    MediasRepository,
+    MediasModel,
+    Medias,
+}

package/src/interfaces/base.medias-attr.interface.ts

@@ -0,0 +1,21 @@
+import { MediaType } from '../enum/medias.enum';
+
+export interface IBaseMediasAttr {
+  MediaId: string;
+  ObjectId: string;
+  ObjectType: string;
+  Title: string;
+  Description: string;
+  Type: MediaType;
+  IsExternalYN: string;
+  ExternalSource: string;
+  IsEncryptedYN: string;
+  FileName: string;
+  FileExtension: string;
+  FilePath: string;
+  URL: string;
+  CreatedAt: Date;
+  UpdatedAt: Date;
+  CreatedById: string;
+  UpdatedById: string;
+}