@mbc-cqrs-serverless/master 0.1.66-beta.0 → 0.1.68-beta.0

package/src/templates/master/master-data.controller.ts

@@ -0,0 +1,98 @@
+import {
+  DetailDto,
+  getUserContext,
+  IInvoke,
+  INVOKE_CONTEXT,
+} from '@mbc-cqrs-serverless/core'
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Injectable,
+  Param,
+  Post,
+  Put,
+  Query,
+} from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+
+import { MasterDataCreateDto } from './dto/master-data-create.dto'
+import { MasterDataSearchDto } from './dto/master-data-search.dto'
+import { MasterDataUpdateDto } from './dto/master-data-update.dto'
+import { parsePk } from './helpers'
+import { CustomMasterDataService } from './master-data.service'
+
+@ApiTags('master-data')
+@Controller('api/master-data')
+@Injectable()
+export class MasterDataController {
+  constructor(private readonly masterDataService: CustomMasterDataService) {}
+
+  @Get('/')
+  async list(
+    @Query() searchDto: MasterDataSearchDto,
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+  ) {
+    return this.masterDataService.list(searchDto, invokeContext)
+  }
+
+  @Get('/:pk/:sk')
+  async getDetail(@Param() key: DetailDto) {
+    return this.masterDataService.getDetail(key)
+  }
+
+  @Post('/')
+  async create(
+    @Body() createDto: MasterDataCreateDto,
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+  ) {
+    return this.masterDataService.create(createDto, invokeContext)
+  }
+
+  @Put('/:pk/:sk')
+  async update(
+    @Param() key: DetailDto,
+    @Body() updateDto: MasterDataUpdateDto,
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+  ) {
+    const userContext = getUserContext(invokeContext)
+
+    const { tenantCode } = parsePk(key.pk)
+
+    if (userContext.tenantCode !== tenantCode) {
+      throw new BadRequestException('Invalid tenant code')
+    }
+    return this.masterDataService.update(key, updateDto, invokeContext)
+  }
+
+  @Delete('/:pk/:sk')
+  async delete(
+    @Param() key: DetailDto,
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+  ) {
+    const userContext = getUserContext(invokeContext)
+
+    const { tenantCode } = parsePk(key.pk)
+
+    if (userContext.tenantCode !== tenantCode) {
+      throw new BadRequestException('Invalid tenant code')
+    }
+
+    return this.masterDataService.delete(key, invokeContext)
+  }
+
+  @Post('/check-exist/:settingCode/:code')
+  async checkExistCode(
+    @Param('settingCode') settingCode: string,
+    @Param('code') code: string,
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+  ) {
+    return this.masterDataService.checkExistCode(
+      settingCode,
+      code,
+      invokeContext,
+    )
+  }
+}

package/src/templates/master/master-data.service.ts

@@ -0,0 +1,181 @@
+import {
+  DataService,
+  DetailDto,
+  getUserContext,
+  IInvoke,
+  UserContext,
+} from '@mbc-cqrs-serverless/core'
+import { MasterDataService } from '@mbc-cqrs-serverless/master'
+import { Injectable, NotFoundException, Param } from '@nestjs/common'
+import { Prisma } from '@prisma/client'
+import { PrismaService } from 'src/prisma'
+import { ulid } from 'ulid'
+
+import { MasterDataCreateDto } from './dto/master-data-create.dto'
+import { MasterDataSearchDto } from './dto/master-data-search.dto'
+import { MasterDataUpdateDto } from './dto/master-data-update.dto'
+import { MasterRdsEntity } from './dto/master-rds.entity'
+import { MasterRdsListEntity } from './dto/master-rds-list.entity'
+import { DATA_SK_PREFIX, getOrderBys, SETTING_SK_PREFIX } from './helpers'
+
+@Injectable()
+export class CustomMasterDataService {
+  constructor(
+    private readonly masterDataService: MasterDataService,
+    private readonly prismaService: PrismaService,
+    private readonly dataService: DataService,
+  ) {}
+
+  async list(searchDto: MasterDataSearchDto, invokeContext: IInvoke) {
+    const userContext = getUserContext(invokeContext)
+    const deletedSettingData = await this.prismaService.master.findMany({
+      where: {
+        tenantCode: this.getTenantCode(userContext),
+        isDeleted: true,
+        masterType: SETTING_SK_PREFIX,
+      },
+      select: {
+        masterCode: true,
+      },
+    })
+
+    const deletedSettingCode = deletedSettingData.map(
+      (setting) => setting.masterCode,
+    )
+
+    const where: Prisma.MasterWhereInput = {
+      tenantCode: this.getTenantCode(userContext),
+      masterType: DATA_SK_PREFIX,
+    }
+
+    if (deletedSettingCode.length > 0) {
+      where.masterTypeCode = {
+        notIn: deletedSettingCode,
+      }
+    }
+
+    if (searchDto.isDeleted === false || searchDto.isDeleted === undefined) {
+      where.isDeleted = false
+    }
+
+    const andConditions: Prisma.MasterWhereInput[] = []
+
+    if (searchDto.keyword?.trim()) {
+      andConditions.push({
+        name: { contains: searchDto.keyword.trim() },
+      })
+    }
+
+    if (searchDto.code?.trim()) {
+      andConditions.push({
+        masterCode: { contains: searchDto.code.trim() },
+      })
+    }
+
+    if (searchDto.settingCode?.trim()) {
+      andConditions.push({
+        masterTypeCode: searchDto.settingCode.trim(),
+      })
+    }
+
+    if (andConditions.length) {
+      where.AND = andConditions
+    }
+
+    const {
+      pageSize = 10,
+      page = 1,
+      orderBys = ['seq', 'masterCode'],
+    } = searchDto
+
+    const [total, items] = await Promise.all([
+      this.prismaService.master.count({ where }),
+      this.prismaService.master.findMany({
+        where,
+        take: pageSize,
+        skip: pageSize * (page - 1),
+        orderBy: getOrderBys<Prisma.MasterOrderByWithRelationInput>(orderBys),
+      }),
+    ])
+
+    return new MasterRdsListEntity({
+      total,
+      items: items.map((item) => new MasterRdsEntity(item)),
+    })
+  }
+
+  async getDetail(@Param() key: DetailDto) {
+    const data = await this.dataService.getItem(key)
+
+    if (!data) throw new NotFoundException()
+
+    return new MasterRdsEntity(data)
+  }
+
+  async create(createDto: MasterDataCreateDto, invokeContext: IInvoke) {
+    const userContext = getUserContext(invokeContext)
+    let seq = createDto?.seq
+    if (!seq) {
+      const maxSeq = await this.prismaService.master.aggregate({
+        _max: {
+          seq: true,
+        },
+        where: {
+          tenantCode: userContext.tenantCode,
+          masterType: DATA_SK_PREFIX,
+          masterTypeCode: createDto.settingCode,
+        },
+      })
+      seq = (maxSeq._max.seq ?? 0) + 1
+      createDto.attributes['seq'] = seq
+    }
+
+    return await this.masterDataService.create(
+      {
+        code: createDto.code ?? ulid(),
+        tenantCode: userContext.tenantCode,
+        name: createDto.name,
+        settingCode: createDto.settingCode,
+        attributes: createDto.attributes ?? {},
+        seq,
+      },
+      { invokeContext },
+    )
+  }
+
+  async update(
+    key: DetailDto,
+    updateDto: MasterDataUpdateDto,
+    invokeContext: IInvoke,
+  ) {
+    return await this.masterDataService.update(
+      key,
+      {
+        ...updateDto,
+      },
+      { invokeContext },
+    )
+  }
+
+  async delete(key: DetailDto, invokeContext: IInvoke) {
+    return this.masterDataService.delete(key, { invokeContext })
+  }
+
+  async checkExistCode(
+    settingCode: string,
+    code: string,
+    invokeContext: IInvoke,
+  ) {
+    const userContext = getUserContext(invokeContext)
+
+    return this.masterDataService.checkExistCode(
+      userContext.tenantCode,
+      settingCode,
+      code,
+    )
+  }
+
+  private getTenantCode(userContext: UserContext): string {
+    return userContext.tenantCode
+  }
+}

package/src/templates/master/master-setting.controller.ts

@@ -0,0 +1,103 @@
+import {
+  DetailDto,
+  getUserContext,
+  IInvoke,
+  INVOKE_CONTEXT,
+} from '@mbc-cqrs-serverless/core'
+import { CommonSettingDto } from '@mbc-cqrs-serverless/master/dist/dto'
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Injectable,
+  Param,
+  Post,
+  Put,
+  Query,
+} from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+
+import { MasterCopyDto } from './dto/master-copy.dto'
+import { MasterSettingSearchDto } from './dto/master-setting-search.dto'
+import { MasterSettingUpdateDto } from './dto/master-setting-update.dto'
+import { parsePk } from './helpers'
+import { CustomMasterSettingService } from './master-setting.service'
+
+@ApiTags('master-setting')
+@Controller('api/master-setting')
+@Injectable()
+export class MasterSettingController {
+  constructor(
+    private readonly masterSettingService: CustomMasterSettingService,
+  ) {}
+
+  @Get('/')
+  async list(
+    @Query() searchDto: MasterSettingSearchDto,
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+  ) {
+    return this.masterSettingService.list(searchDto, invokeContext)
+  }
+
+  @Get('/:pk/:sk')
+  async getDetail(@Param() key: DetailDto) {
+    return this.masterSettingService.getDetail(key)
+  }
+
+  @Post('/')
+  async create(
+    @Body() createDto: CommonSettingDto,
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+  ) {
+    return this.masterSettingService.create(createDto, invokeContext)
+  }
+
+  @Put('/:pk/:sk')
+  async update(
+    @Param() key: DetailDto,
+    @Body() updateDto: MasterSettingUpdateDto,
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+  ) {
+    const userContext = getUserContext(invokeContext)
+
+    const { tenantCode } = parsePk(key.pk)
+
+    if (userContext.tenantCode !== tenantCode) {
+      throw new BadRequestException('Invalid tenant code')
+    }
+    return this.masterSettingService.update(key, updateDto, invokeContext)
+  }
+
+  @Delete('/:pk/:sk')
+  async delete(
+    @Param() key: DetailDto,
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+  ) {
+    const userContext = getUserContext(invokeContext)
+
+    const { tenantCode } = parsePk(key.pk)
+
+    if (userContext.tenantCode !== tenantCode) {
+      throw new BadRequestException('Invalid tenant code')
+    }
+    return this.masterSettingService.delete(key, invokeContext)
+  }
+
+  @Post('/check-exist/:code')
+  async checkExistCode(
+    @Param('code') code: string,
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+  ) {
+    return this.masterSettingService.checkExistCode(code, invokeContext)
+  }
+
+  @Post('/copy')
+  async copyMaster(
+    @INVOKE_CONTEXT() invokeContext: IInvoke,
+    @Body() masterCopyDto: MasterCopyDto,
+  ): Promise<any> {
+    return this.masterSettingService.copy(masterCopyDto, { invokeContext })
+  }
+}

package/src/templates/master/master-setting.service.ts

@@ -0,0 +1,201 @@
+import {
+  DataService,
+  DetailDto,
+  getUserContext,
+  IInvoke,
+  UserContext,
+} from '@mbc-cqrs-serverless/core'
+import { MasterSettingService } from '@mbc-cqrs-serverless/master'
+import { CommonSettingDto } from '@mbc-cqrs-serverless/master/dist/dto'
+import { TaskService } from '@mbc-cqrs-serverless/task'
+import {
+  BadRequestException,
+  Injectable,
+  Logger,
+  NotFoundException,
+} from '@nestjs/common'
+import { Prisma } from '@prisma/client'
+import { PrismaService } from 'src/prisma'
+
+import { DataCopyMode, MasterCopyDto } from './dto/master-copy.dto'
+import { MasterRdsEntity } from './dto/master-rds.entity'
+import { MasterRdsListEntity } from './dto/master-rds-list.entity'
+import { MasterSettingSearchDto } from './dto/master-setting-search.dto'
+import { MasterSettingUpdateDto } from './dto/master-setting-update.dto'
+import {
+  getOrderBys,
+  MASTER_COPY_SK_PREFIX,
+  parseId,
+  SETTING_SK_PREFIX,
+} from './helpers'
+
+@Injectable()
+export class CustomMasterSettingService {
+  private readonly logger = new Logger(CustomMasterSettingService.name)
+
+  constructor(
+    private readonly masterSettingService: MasterSettingService,
+    private readonly prismaService: PrismaService,
+    private readonly dataService: DataService,
+    private readonly taskService: TaskService,
+  ) {}
+
+  async list(searchDto: MasterSettingSearchDto, invokeContext: IInvoke) {
+    const userContext = getUserContext(invokeContext)
+
+    const where: Prisma.MasterWhereInput = {
+      tenantCode: this.getUserTenantCode(userContext),
+      masterType: SETTING_SK_PREFIX,
+    }
+
+    if (searchDto.isDeleted === false || searchDto.isDeleted === undefined) {
+      where.isDeleted = false
+    }
+
+    const andConditions: Prisma.MasterWhereInput[] = []
+
+    if (searchDto.name?.trim()) {
+      andConditions.push({
+        name: { contains: searchDto.name.trim() },
+      })
+    }
+
+    if (searchDto.keyword?.trim()) {
+      andConditions.push({
+        attributes: {
+          path: 'description',
+          string_contains: searchDto.keyword.trim(),
+        },
+      })
+    }
+
+    if (searchDto.code?.trim()) {
+      andConditions.push({
+        masterCode: { contains: searchDto.code.trim() },
+      })
+    }
+
+    if (andConditions.length) {
+      where.AND = andConditions
+    }
+
+    const { pageSize = 10, page = 1, orderBys = ['-createdAt'] } = searchDto
+
+    const [total, items] = await Promise.all([
+      this.prismaService.master.count({ where }),
+      this.prismaService.master.findMany({
+        where,
+        take: pageSize,
+        skip: pageSize * (page - 1),
+        orderBy: getOrderBys<Prisma.MasterOrderByWithRelationInput>(orderBys),
+      }),
+    ])
+
+    return new MasterRdsListEntity({
+      total,
+      items: items.map((item) => new MasterRdsEntity(item)),
+    })
+  }
+
+  async getDetail(key: DetailDto) {
+    const data = await this.dataService.getItem(key)
+
+    if (!data) throw new NotFoundException()
+
+    return new MasterRdsEntity(data)
+  }
+
+  async create(createDto: CommonSettingDto, invokeContext: IInvoke) {
+    const userContext = getUserContext(invokeContext)
+    return await this.masterSettingService.createTenantSetting(
+      {
+        ...createDto,
+        tenantCode: userContext.tenantCode,
+      },
+      { invokeContext },
+    )
+  }
+
+  async update(
+    key: DetailDto,
+    updateDto: MasterSettingUpdateDto,
+    invokeContext: IInvoke,
+  ) {
+    const code = key.sk.split('#')[1]
+    const userContext = getUserContext(invokeContext)
+
+    return await this.masterSettingService.updateSetting(
+      key,
+      {
+        code,
+        tenantCode: userContext.tenantCode,
+        name: updateDto.name,
+        settingValue: updateDto.attributes,
+      },
+      {
+        invokeContext,
+      },
+    )
+  }
+
+  async delete(key: DetailDto, invokeContext: IInvoke) {
+    return this.masterSettingService.deleteSetting(key, { invokeContext })
+  }
+
+  async checkExistCode(code: string, invokeContext: IInvoke) {
+    const userContext = getUserContext(invokeContext)
+
+    const item = await this.prismaService.master.findFirst({
+      where: {
+        tenantCode: userContext.tenantCode,
+        masterType: SETTING_SK_PREFIX,
+        masterCode: code,
+      },
+    })
+
+    return !!item && !item.isDeleted
+  }
+
+  async copy(
+    masterCopyDto: MasterCopyDto,
+    opts: { invokeContext: IInvoke },
+  ): Promise<any> {
+    this.logger.debug('cmd:', JSON.stringify(masterCopyDto))
+
+    const userContext = getUserContext(opts.invokeContext)
+
+    const { masterSettingId, targetTenants, dataCopyOption } = masterCopyDto
+
+    if (dataCopyOption?.mode === DataCopyMode.PARTIAL) {
+      if (!dataCopyOption.id?.length) {
+        throw new BadRequestException('Must provide ID when mode is PARTIAL.')
+      }
+    }
+
+    const setting = await this.dataService.getItem(parseId(masterSettingId))
+
+    if (!setting || setting.isDeleted) {
+      throw new BadRequestException('Master setting does not exist')
+    }
+
+    const item = targetTenants.map((tenant) => ({
+      ...masterCopyDto,
+      targetTenants: [tenant],
+    }))
+
+    const taskItem = await this.taskService.createStepFunctionTask(
+      {
+        input: item,
+        taskType: `${MASTER_COPY_SK_PREFIX}_${masterSettingId.split('#').at(-1)}`,
+        tenantCode: userContext.tenantCode,
+      },
+      opts,
+    )
+
+    return taskItem
+  }
+
+  private getUserTenantCode(userContext: UserContext): string {
+    return userContext.tenantCode
+  }
+}

package/src/templates/master/master.module.ts

@@ -0,0 +1,36 @@
+import { CommandModule } from '@mbc-cqrs-serverless/core'
+import { MasterModule as CoreMasterModule } from '@mbc-cqrs-serverless/master'
+import { SequencesModule } from '@mbc-cqrs-serverless/sequence'
+import { Module } from '@nestjs/common'
+import { CustomTaskModule } from 'src/custom-task/custom-task.module'
+
+import { MasterDataSyncRdsHandler } from './handler/master-rds.handler'
+import { MasterSfnTaskEventHandler } from './handler/master-sfn-task.handler'
+import { MasterDataController } from './master-data.controller'
+import { CustomMasterDataService } from './master-data.service'
+import { MasterSettingController } from './master-setting.controller'
+import { CustomMasterSettingService } from './master-setting.service'
+
+@Module({
+  imports: [
+    CommandModule.register({
+      tableName: 'master',
+      dataSyncHandlers: [MasterDataSyncRdsHandler],
+    }),
+
+    CoreMasterModule.register({
+      enableController: false,
+      dataSyncHandlers: [MasterDataSyncRdsHandler],
+    }),
+    CustomTaskModule,
+    SequencesModule,
+  ],
+  controllers: [MasterDataController, MasterSettingController],
+  providers: [
+    CustomMasterDataService,
+    CustomMasterSettingService,
+    MasterSfnTaskEventHandler,
+  ],
+  exports: [CustomMasterSettingService, CoreMasterModule],
+})
+export class MasterModule {}