@tomei/media 0.1.0

package/src/interfaces/medias.repository.interface.ts

@@ -0,0 +1,4 @@
+import { IBaseRepository } from '../base/base.repository.interface';
+import { MediasModel } from '../entities/medias.entity';
+
+export type IMediasRepository = IBaseRepository<MediasModel>;

package/src/medias.controller.ts

@@ -0,0 +1,244 @@
+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;
+    }
+  }
+}

package/src/medias.module.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { SequelizeModule } from '@nestjs/sequelize';
+import { CommonModule } from './common/common.module';
+import { MediasController } from './medias.controller';
+import { MediasRepository } from './medias.repository';
+import { MediasModel } from './entities/medias.entity';
+
+@Module({
+  controllers: [MediasController],
+  providers: [
+    {
+      provide: 'MediasRepository',
+      useClass: MediasRepository,
+    },
+  ],
+  imports: [SequelizeModule.forFeature([MediasModel], process.env.SEQUELIZE_DB_NAME), CommonModule],
+  exports: [SequelizeModule],
+})
+export class MediasModule {}

package/src/medias.repository.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/sequelize';
+import { BaseRepository } from './base/base.repository.abstract';
+import { MediasModel } from './entities/medias.entity';
+import { IBaseMediasAttr } from './interfaces/base.medias-attr.interface';
+import { IMediasRepository } from './interfaces/medias.repository.interface';
+
+@Injectable()
+export class MediasRepository
+  extends BaseRepository<MediasModel>
+  implements IMediasRepository
+{
+  constructor(
+    @InjectModel(MediasModel, 'csmsDB')
+    private readonly mediasModel: typeof MediasModel,
+  ) {
+    super(mediasModel);
+  }
+
+  create(
+    data: IBaseMediasAttr,
+    options?: any,
+  ): Promise<MediasModel> | any {
+    return this.mediasModel.create({ ...data }, options);
+  }
+
+  findAll(options: any): Promise<MediasModel[]> {
+    return this.mediasModel.findAll(options);
+  }
+
+  findAllWithPagination(
+    options: any,
+  ): Promise<{ count: number; rows: MediasModel[] }> {
+    return this.mediasModel.findAndCountAll(options);
+  }
+
+  findOne(options: any): Promise<MediasModel> {
+    return this.mediasModel.findOne(options);
+  }
+
+  update(data: IBaseMediasAttr, options?: any): any {
+    return this.mediasModel.update({ ...data }, options);
+  }
+}