transform core api codes into this project, update modules as admin/pos context modules

src/modules/admin/licenses/dto/license.dto.ts

@@ -0,0 +1,41 @@
+import { ApiProperty } from '@nestjs/swagger'
+import { IsDateString, IsEnum, IsOptional, IsString } from 'class-validator'
+import { LicenseStatus } from 'generated/prisma/enums'
+
+export class CreateLicenseDto {
+  @IsString()
+  @ApiProperty()
+  account_id: string
+
+  @IsString()
+  @ApiProperty()
+  pos_id: string
+
+  @IsString()
+  @ApiProperty({ required: true })
+  partner_id: string
+
+  @IsDateString()
+  @IsOptional()
+  @ApiProperty({ required: false })
+  starts_at: string
+
+  @IsDateString()
+  @IsOptional()
+  @ApiProperty({ required: false })
+  expires_at: string
+}
+
+export class UpdateLicenseDto {
+  @IsString()
+  pos_id?: string
+
+  @IsDateString()
+  starts_at?: string
+
+  @IsDateString()
+  expires_at?: string
+
+  @IsEnum(LicenseStatus)
+  status?: LicenseStatus
+}

src/modules/admin/licenses/licenses.controller.ts

@@ -0,0 +1,33 @@
+import { Body, Controller, Get, Param, Post, Put } from '@nestjs/common'
+import { CreateLicenseDto, UpdateLicenseDto } from './dto/license.dto'
+import { PartnerLicensesService } from './licenses.service'
+
+@Controller('admin/licenses')
+export class LicensesController {
+  constructor(private readonly licensesService: PartnerLicensesService) {}
+
+  @Get()
+  async findAll() {
+    return this.licensesService.findAll()
+  }
+
+  @Get(':id')
+  async findOne(@Param('id') id: string) {
+    return this.licensesService.findOne(id)
+  }
+
+  @Post()
+  async create(@Body() data: CreateLicenseDto) {
+    return this.licensesService.create(data)
+  }
+
+  @Put(':id')
+  async update(@Param('id') id: string, @Body() data: UpdateLicenseDto) {
+    return this.licensesService.update(id, data)
+  }
+
+  // @Delete(':id')
+  // async delete(@Param('id') id: string) {
+  //   return this.licensesService.delete(id)
+  // }
+}

src/modules/admin/licenses/licenses.module.ts

@@ -0,0 +1,12 @@
+import { PrismaModule } from '@/prisma/prisma.module'
+import { Module } from '@nestjs/common'
+import { LicensesController } from './licenses.controller'
+import { PartnerLicensesService } from './licenses.service'
+
+@Module({
+  imports: [PrismaModule],
+  controllers: [LicensesController],
+  providers: [PartnerLicensesService],
+  exports: [PartnerLicensesService],
+})
+export class AdminLicensesModule {}

src/modules/admin/licenses/licenses.service.ts

@@ -0,0 +1,122 @@
+import { LicenseInclude } from '@/generated/prisma/models'
+import { PrismaService } from '@/prisma/prisma.service'
+import { Injectable } from '@nestjs/common'
+import { ResponseMapper } from 'common/response/response-mapper'
+import { LicenseStatus } from 'generated/prisma/enums'
+import { CreateLicenseDto, UpdateLicenseDto } from './dto/license.dto'
+
+@Injectable()
+export class PartnerLicensesService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  private readonly licenseInclude = {
+    partner: true,
+    pos: {
+      include: {
+        complex: true,
+        provider: true,
+        accounts: {
+          include: {
+            user: true,
+          },
+          omit: {
+            business_id: true,
+            partner_id: true,
+            provider_id: true,
+            pos_id: true,
+          },
+        },
+        device: {
+          include: {
+            brand: true,
+          },
+          omit: {
+            brand_id: true,
+          },
+        },
+      },
+    },
+  } as LicenseInclude
+
+  async findAll() {
+    const [licenses, count] = await this.prisma.$transaction([
+      this.prisma.license.findMany({
+        include: this.licenseInclude,
+        omit: {
+          pos_id: true,
+          partner_id: true,
+        },
+      }),
+      this.prisma.license.count(),
+    ])
+    return ResponseMapper.paginate(
+      licenses.map(license => {
+        const { pos, ...rest } = license
+        // @ts-ignore
+        const { accounts, ...posRest } = pos
+        return {
+          account: accounts[0],
+          pos: posRest,
+          ...rest,
+        }
+      }),
+      {
+        count,
+      },
+    )
+  }
+
+  async findOne(id: string) {
+    const license = await this.prisma.license.findFirst({
+      where: { id },
+      include: this.licenseInclude,
+      omit: {
+        pos_id: true,
+        partner_id: true,
+      },
+    })
+    if (license) {
+      const { pos, ...rest } = license
+      // @ts-ignore
+      const { accounts, ...posRest } = pos
+      return ResponseMapper.single({
+        account: accounts[0],
+        pos: posRest,
+        ...rest,
+      })
+    }
+
+    return ResponseMapper.single(license)
+  }
+
+  async create(data: CreateLicenseDto) {
+    const date = new Date(data.starts_at || '')
+    const expiresAt =
+      data.expires_at || new Date(date.setFullYear(date.getFullYear() + 1))
+
+    const license = await this.prisma.license.create({
+      data: {
+        partner_id: data.partner_id,
+        pos_id: data.pos_id,
+        starts_at: date,
+        expires_at: expiresAt,
+        status: LicenseStatus.ACTIVE,
+      },
+    })
+
+    return ResponseMapper.create(license)
+  }
+
+  async update(id: string, data: UpdateLicenseDto) {
+    const license = await this.prisma.license.update({
+      where: { id },
+      data: { ...data },
+    })
+    return ResponseMapper.update(license)
+  }
+
+  async delete(id: string) {
+    await this.prisma.license.delete({ where: { id } })
+    return ResponseMapper.delete()
+  }
+}