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

src/modules/admin/partners/dto/partner.dto.ts

@@ -0,0 +1,20 @@
+import { IsOptional, IsString } from 'class-validator'
+
+export class CreatePartnerDto {
+  @IsString()
+  name: string
+
+  @IsOptional()
+  @IsString()
+  code?: string
+}
+
+export class UpdatePartnerDto {
+  @IsOptional()
+  @IsString()
+  name?: string
+
+  @IsOptional()
+  @IsString()
+  code?: string
+}

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

@@ -0,0 +1,71 @@
+import { IsDateString, IsEnum, IsOptional, IsString } from 'class-validator'
+import { AccountStatus, LicenseStatus, POSType } from 'generated/prisma/enums'
+
+export class CreateLicenseDto {
+  @IsString()
+  first_name: string
+
+  @IsString()
+  last_name: string
+
+  @IsString()
+  mobile_number: string
+
+  @IsString()
+  national_code: string
+
+  @IsString()
+  username: string
+
+  @IsString()
+  password: string
+
+  @IsEnum(AccountStatus)
+  account_status: AccountStatus
+
+  @IsString()
+  guild: string
+
+  @IsString()
+  business_activity_name: string
+
+  @IsString()
+  tax_id: string
+
+  @IsString()
+  complex_name: string
+
+  @IsString()
+  pos_serial: string
+
+  @IsString()
+  pos_status: string
+
+  @IsEnum(POSType)
+  pos_type: POSType
+
+  @IsString()
+  pos_device: string
+
+  @IsDateString()
+  @IsOptional()
+  starts_at: string
+
+  @IsDateString()
+  @IsOptional()
+  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/partners/licenses/licenses.controller.ts

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

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

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

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

@@ -0,0 +1,197 @@
+import { PrismaService } from '@/prisma/prisma.service'
+import { Injectable } from '@nestjs/common'
+import { ResponseMapper } from 'common/response/response-mapper'
+import { CreateLicenseDto, UpdateLicenseDto } from './dto/license.dto'
+
+@Injectable()
+export class PartnerLicensesService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll(partnerId: string) {
+    const licenses = await this.prisma.license.findMany({
+      where: { partner_id: partnerId },
+      include: {
+        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,
+              },
+            },
+          },
+        },
+      },
+      omit: {
+        pos_id: true,
+        partner_id: true,
+      },
+    })
+    return ResponseMapper.list(
+      licenses.map(license => {
+        const { pos, ...rest } = license
+        const { accounts, ...posRest } = pos
+        return {
+          account: accounts[0],
+          pos: posRest,
+          ...rest,
+        }
+      }),
+    )
+  }
+
+  async findOne(partnerId: string, id: string) {
+    const license = await this.prisma.license.findFirst({
+      where: { id, partner_id: partnerId },
+      include: {
+        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,
+              },
+            },
+          },
+        },
+      },
+      omit: {
+        pos_id: true,
+        partner_id: true,
+      },
+    })
+    if (license) {
+      const { pos, ...rest } = license
+      const { accounts, ...posRest } = pos
+      return ResponseMapper.single({
+        account: accounts[0],
+        pos: posRest,
+        ...rest,
+      })
+    }
+
+    return ResponseMapper.single(license)
+  }
+
+  async create(partnerId: string, data: CreateLicenseDto) {
+    // const license = await this.prisma.$transaction(async tx => {
+    //   const user = await tx.user.upsert({
+    //     where: {
+    //       mobile_number: data.mobile_number,
+    //     },
+    //     update: {},
+    //     create: {
+    //       first_name: data.first_name,
+    //       last_name: data.last_name,
+    //       mobile_number: data.mobile_number,
+    //       national_code: data.national_code,
+    //     },
+    //   })
+
+    //     const business = await tx.businessActivity.create({
+    //       data: {
+    //         name: data.business_activity_name,
+    //         guild_id: data.guild,
+    //         user: {
+    //           connect: {
+    //             id: user.id,
+    //           },
+    //         },
+    //       },
+    //     })
+
+    //   const complex = await tx.complex.create({
+    //     data: {
+    //       name: data.complex_name,
+    //       tax_id: data.tax_id,
+    //       business_activity_id: business.id,
+    //     },
+    //   })
+
+    //   const pos = await tx.pos.create({
+    //     data: {
+    //       pos_type: data.pos_type,
+    //       serial: data.pos_serial,
+    //       device_id: data.pos_device,
+    //       complex_id: complex.id,
+    //     },
+    //   })
+
+    //   const date = new Date()
+    //   const expiresAt = new Date(date.setFullYear(date.getFullYear() + 1))
+
+    //   const license = await tx.license.create({
+    //     data: {
+    //       partner_id: partnerId,
+    //       pos_id: pos.id,
+    //       starts_at: data.starts_at || new Date(),
+    //       expires_at: data.expires_at || expiresAt,
+    //       status: LicenseStatus.ACTIVE,
+    //     },
+    //   })
+
+    //   const hashedPassword = await PasswordUtil.hash(data.password)
+
+    //   const account = await tx.account.create({
+    //     data: {
+    //       username: data.username,
+    //       password: hashedPassword,
+    //       type: AccountType.POS,
+    //       user_id: user.id,
+    //       pos_id: pos.id,
+    //       status: data.account_status,
+    //     },
+    //   })
+
+    //   return {
+    //     license,
+    //   }
+    // })
+    return ResponseMapper.create('license')
+  }
+
+  async update(partnerId: string, id: string, data: UpdateLicenseDto) {
+    const license = await this.prisma.license.update({
+      where: { id },
+      data: { ...data, partner_id: partnerId },
+    })
+    return ResponseMapper.update(license)
+  }
+
+  async delete(partnerId: string, id: string) {
+    await this.prisma.license.delete({ where: { id } })
+    return ResponseMapper.delete()
+  }
+}

src/modules/admin/partners/partnerAccounts/accounts.controller.ts

@@ -0,0 +1,33 @@
+import { Body, Controller, Delete, Get, Param, Post, Put } from '@nestjs/common'
+import { AccountsService } from './accounts.service'
+import { CreateAccountDto, UpdateAccountDto } from './dto/account.dto'
+
+@Controller('admin/partners/:partnerId/accounts')
+export class AccountsController {
+  constructor(private readonly accountsService: AccountsService) {}
+
+  @Get()
+  async findAll(@Param('partnerId') partnerId: string) {
+    return this.accountsService.findAll(partnerId)
+  }
+
+  @Get(':id')
+  async findOne(@Param('id') id: string) {
+    return this.accountsService.findOne(id)
+  }
+
+  @Post()
+  async create(@Param('partnerId') partnerId: string, @Body() data: CreateAccountDto) {
+    return this.accountsService.create(partnerId, data)
+  }
+
+  @Put(':id')
+  async update(@Param('id') id: string, @Body() data: UpdateAccountDto) {
+    return this.accountsService.update(id, data)
+  }
+
+  @Delete(':id')
+  async delete(@Param('id') id: string) {
+    return this.accountsService.delete(id)
+  }
+}

src/modules/admin/partners/partnerAccounts/accounts.module.ts

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

src/modules/admin/partners/partnerAccounts/accounts.service.ts

@@ -0,0 +1,82 @@
+import { PrismaService } from '@/prisma/prisma.service'
+import { Injectable } from '@nestjs/common'
+import { ResponseMapper } from 'common/response/response-mapper'
+import { PasswordUtil } from 'common/utils/password.util'
+import { AccountType } from 'generated/prisma/enums'
+import { CreateAccountDto, UpdateAccountDto } from './dto/account.dto'
+
+@Injectable()
+export class AccountsService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll(partnerId: string) {
+    const accounts = await this.prisma.account.findMany({
+      where: { partner_id: partnerId },
+      omit: {
+        password: true,
+        user_id: true,
+        partner_id: true,
+        type: true,
+        pos_id: true,
+        provider_id: true,
+        business_id: true,
+      },
+    })
+    return ResponseMapper.list(accounts)
+  }
+
+  async findOne(id: string) {
+    const account = await this.prisma.account.findUnique({
+      where: { id },
+      omit: { password: true, user_id: true },
+      include: {
+        partner: true,
+        user: true,
+      },
+    })
+    return ResponseMapper.single(account)
+  }
+
+  async create(partnerId: string, data: CreateAccountDto) {
+    const { username, status, password, ...userData } = data
+
+    const result = await this.prisma.$transaction(async tx => {
+      let user = await tx.user.upsert({
+        where: {
+          mobile_number: userData.mobile_number,
+        },
+        update: {},
+        create: userData,
+      })
+
+      const hashedPassword = await PasswordUtil.hash(password)
+
+      const dataToCreate = {
+        username,
+        status,
+        password: hashedPassword,
+        user_id: user.id,
+        type: AccountType.PARTNER,
+        partner_id: partnerId, // Connect account to partner
+      }
+
+      const account = await tx.account.create({
+        data: dataToCreate,
+      })
+
+      return account
+    })
+
+    return ResponseMapper.create(result)
+  }
+
+  async update(id: string, data: UpdateAccountDto) {
+    const account = await this.prisma.account.update({ where: { id }, data })
+    return ResponseMapper.update(account)
+  }
+
+  async delete(id: string) {
+    await this.prisma.account.delete({ where: { id } })
+    return ResponseMapper.delete()
+  }
+}

src/modules/admin/partners/partnerAccounts/dto/account.dto.ts

@@ -0,0 +1,36 @@
+import { IsEnum, IsOptional, IsString } from 'class-validator'
+import { AccountStatus, AccountType } from 'generated/prisma/enums'
+import { CreateUserDto } from '../../../users/dto/user.dto'
+
+export class CreateAccountDto extends CreateUserDto {
+  @IsString()
+  username: string
+
+  @IsEnum(AccountStatus)
+  status: AccountStatus
+
+  @IsString()
+  password: string
+}
+
+export class UpdateAccountDto {
+  @IsOptional()
+  @IsString()
+  username?: string
+
+  @IsOptional()
+  @IsEnum(AccountType)
+  type?: AccountType
+
+  @IsOptional()
+  @IsEnum(AccountStatus)
+  status?: AccountStatus
+
+  @IsOptional()
+  @IsString()
+  password?: string
+
+  @IsOptional()
+  @IsString()
+  user_id?: string
+}

src/modules/admin/partners/partners.controller.ts

@@ -0,0 +1,33 @@
+import { Body, Controller, Delete, Get, Param, Post, Put } from '@nestjs/common'
+import { CreatePartnerDto, UpdatePartnerDto } from './dto/partner.dto'
+import { PartnersService } from './partners.service'
+
+@Controller('admin/partners')
+export class PartnersController {
+  constructor(private readonly partnersService: PartnersService) {}
+
+  @Get()
+  async findAll() {
+    return this.partnersService.findAll()
+  }
+
+  @Get(':id')
+  async findOne(@Param('id') id: string) {
+    return this.partnersService.findOne(id)
+  }
+
+  @Post()
+  async create(@Body() data: CreatePartnerDto) {
+    return this.partnersService.create(data)
+  }
+
+  @Put(':id')
+  async update(@Param('id') id: string, @Body() data: UpdatePartnerDto) {
+    return this.partnersService.update(id, data)
+  }
+
+  @Delete(':id')
+  async delete(@Param('id') id: string) {
+    return this.partnersService.delete(id)
+  }
+}

src/modules/admin/partners/partners.module.ts

@@ -0,0 +1,15 @@
+import { PrismaModule } from '@/prisma/prisma.module'
+import { Module } from '@nestjs/common'
+
+import { AdminPartnerLicensesModule } from './licenses/licenses.module'
+import { AdminPartnerAccountsModule } from './partnerAccounts/accounts.module'
+import { PartnersController } from './partners.controller'
+import { PartnersService } from './partners.service'
+
+@Module({
+  imports: [PrismaModule, AdminPartnerLicensesModule, AdminPartnerAccountsModule],
+  controllers: [PartnersController],
+  providers: [PartnersService],
+  exports: [PartnersService],
+})
+export class AdminPartnersModule {}

src/modules/admin/partners/partners.service.ts

@@ -0,0 +1,36 @@
+import { PrismaService } from '@/prisma/prisma.service'
+import { Injectable } from '@nestjs/common'
+import { ResponseMapper } from 'common/response/response-mapper'
+import { CreatePartnerDto, UpdatePartnerDto } from './dto/partner.dto'
+
+@Injectable()
+export class PartnersService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll() {
+    const partners = await this.prisma.partner.findMany()
+    return ResponseMapper.list(partners)
+  }
+
+  async findOne(id: string) {
+    const partner = await this.prisma.partner.findUnique({
+      where: { id },
+    })
+    return ResponseMapper.single(partner)
+  }
+
+  async create(data: CreatePartnerDto) {
+    const partner = await this.prisma.partner.create({ data })
+    return ResponseMapper.create(partner)
+  }
+
+  async update(id: string, data: UpdatePartnerDto) {
+    const partner = await this.prisma.partner.update({ where: { id }, data })
+    return ResponseMapper.update(partner)
+  }
+
+  async delete(id: string) {
+    await this.prisma.partner.delete({ where: { id } })
+    return ResponseMapper.delete()
+  }
+}