refactor user accounts structure

src/modules/admin/admin.module.ts

@@ -1,6 +1,7 @@
 import { MiddlewareConsumer, Module, NestModule, RequestMethod } from '@nestjs/common'
 import { AdminController } from './admin.controller'
 import { AdminMiddleware } from './admin.middleware'
+import { AdminConsumersModule } from './consumers/consumers.module'
 import { AdminDeviceBrandsModule } from './device-brands/device-brands.module'
 import { AdminDevicesModule } from './devices/devices.module'
 import { AdminGuildsModule } from './guilds/guilds.module'
@@ -24,6 +25,7 @@ import { AdminUsersModule } from './users/users.module'
     AdminDeviceBrandsModule,
     AdminDevicesModule,
     AdminLicensesModule,
+    AdminConsumersModule,
   ],
 })
 export class AdminModule implements NestModule {

src/modules/admin/consumers/accounts/accounts.controller.ts

@@ -0,0 +1,38 @@
+import { Body, Controller, Get, Param, Patch, Post } from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+import { AccountsService } from './accounts.service'
+import { CreateConsumerAccountDto, UpdateAccountDto } from './dto/account.dto'
+
+@ApiTags('ConsumerAccounts')
+@Controller('admin/consumers/:consumerId/accounts')
+export class AccountsController {
+  constructor(private readonly accountsService: AccountsService) {}
+
+  @Get()
+  async findAll(@Param('consumerId') consumerId: string) {
+    return this.accountsService.findAll(consumerId)
+  }
+
+  @Get(':id')
+  async findOne(@Param('id') id: string) {
+    return this.accountsService.findOne(id)
+  }
+
+  @Post()
+  async create(
+    @Param('consumerId') consumerId: string,
+    @Body() data: CreateConsumerAccountDto,
+  ) {
+    return this.accountsService.create(consumerId, data)
+  }
+
+  @Patch(':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/consumers/accounts/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 AdminUserAccountsModule {}

src/modules/admin/consumers/accounts/accounts.service.ts

@@ -0,0 +1,79 @@
+import { PasswordUtil } from '@/common/utils/password.util'
+import { AccountStatus, AccountType } from '@/generated/prisma/enums'
+import { PrismaService } from '@/prisma/prisma.service'
+import { Injectable } from '@nestjs/common'
+import { ResponseMapper } from 'common/response/response-mapper'
+import { CreateConsumerAccountDto, UpdateAccountDto } from './dto/account.dto'
+
+@Injectable()
+export class AccountsService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll(consumerId: string) {
+    const accounts = await this.prisma.consumerAccount.findMany({
+      where: { user_id: consumerId },
+      select: {
+        id: true,
+        role: true,
+        created_at: true,
+        account: {
+          select: {
+            username: true,
+            status: true,
+          },
+        },
+      },
+    })
+    return ResponseMapper.list(accounts)
+  }
+
+  async findOne(id: string) {
+    const account = await this.prisma.consumerAccount.findMany({
+      where: { id },
+      select: {
+        id: true,
+        role: true,
+        created_at: true,
+        account: {
+          select: {
+            username: true,
+            status: true,
+          },
+        },
+      },
+    })
+    return ResponseMapper.single(account)
+  }
+
+  async create(consumerId: string, data: CreateConsumerAccountDto) {
+    const account = await this.prisma.consumerAccount.create({
+      data: {
+        role: data.role,
+        account: {
+          create: {
+            password: await PasswordUtil.hash(data.password),
+            status: AccountStatus.ACTIVE,
+            type: AccountType.CONSUMER,
+            username: data.username,
+          },
+        },
+        user: {
+          connect: {
+            id: consumerId,
+          },
+        },
+      },
+    })
+    return ResponseMapper.create(account)
+  }
+
+  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/consumers/accounts/dto/account.dto.ts

@@ -0,0 +1,24 @@
+import { ApiProperty, PartialType } from '@nestjs/swagger'
+import { IsEnum, IsOptional, IsString } from 'class-validator'
+import { AccountStatus, ConsumerRole } from 'generated/prisma/enums'
+
+export class CreateConsumerAccountDto {
+  @IsString()
+  @ApiProperty({ required: true })
+  username: string
+
+  @IsString()
+  @ApiProperty({ required: true })
+  password: string
+
+  @IsEnum(ConsumerRole)
+  @ApiProperty({ required: true, enum: ConsumerRole })
+  role: ConsumerRole
+}
+
+export class UpdateAccountDto extends PartialType(CreateConsumerAccountDto) {
+  @IsOptional()
+  @IsEnum(AccountStatus)
+  @ApiProperty({ enum: AccountStatus })
+  status?: AccountStatus
+}

src/modules/admin/consumers/accounts/permissions/dto/permission.dto.ts

@@ -0,0 +1,24 @@
+import { ApiProperty, PartialType } from '@nestjs/swagger'
+import { IsEnum, IsOptional, IsString } from 'class-validator'
+import { AccountStatus, AccountType } from 'generated/prisma/enums'
+
+export class CreateAccountDto {
+  @IsString()
+  @ApiProperty()
+  username: string
+
+  @IsString()
+  @ApiProperty()
+  password: string
+
+  @IsEnum(AccountType)
+  @ApiProperty({ enum: AccountType })
+  type: AccountType
+}
+
+export class UpdateAccountDto extends PartialType(CreateAccountDto) {
+  @IsOptional()
+  @IsEnum(AccountStatus)
+  @ApiProperty({ enum: AccountStatus })
+  status?: AccountStatus
+}

src/modules/admin/consumers/accounts/permissions/permissions.controller.ts

@@ -0,0 +1,20 @@
+import { Body, Controller, Get, Param, Post } from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+import { CreateAccountDto } from './dto/permission.dto'
+import { AccountsService } from './permissions.service'
+
+@ApiTags('AdminAccounts')
+@Controller('admin/users/:userId/accounts/:accountId/permissions')
+export class AccountPermissionsController {
+  constructor(private readonly service: AccountsService) {}
+
+  @Get()
+  async findAll(@Param('userId') userId: string, @Param('accountId') accountId: string) {
+    return this.service.findAll(userId, accountId)
+  }
+
+  @Post()
+  async create(@Param('userId') userId: string, @Body() data: CreateAccountDto) {
+    return this.service.create(userId, data)
+  }
+}

src/modules/admin/consumers/accounts/permissions/permissions.module.ts

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

src/modules/admin/consumers/accounts/permissions/permissions.service.ts

@@ -0,0 +1,116 @@
+import { PrismaService } from '@/prisma/prisma.service'
+import { Injectable } from '@nestjs/common'
+import { ResponseMapper } from 'common/response/response-mapper'
+import { CreateAccountDto } from './dto/permission.dto'
+
+@Injectable()
+export class AccountsService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll(userId: string, account_id: string) {
+    const businessActivities = await this.prisma.businessActivity.findMany({
+      where: {
+        user_id: userId,
+      },
+      select: {
+        id: true,
+        name: true,
+        complexes: {
+          select: {
+            id: true,
+            name: true,
+            pos_list: {
+              select: {
+                id: true,
+                name: true,
+              },
+            },
+          },
+        },
+      },
+    })
+
+    const permissions = await this.prisma.permissionConsumer.findMany({
+      where: {
+        account_id,
+      },
+      select: {
+        posPermissions: {
+          select: {
+            pos_id: true,
+            role: true,
+          },
+        },
+        businessPermissions: {
+          select: {
+            business_id: true,
+            role: true,
+          },
+        },
+        complexPermissions: {
+          select: {
+            complex_id: true,
+            role: true,
+          },
+        },
+      },
+    })
+
+    const businesses = [] as any
+    const complexes = [] as any
+    const poses = [] as any
+
+    businessActivities.forEach(businessActivity => {
+      businesses.push({
+        id: businessActivity.id,
+        name: businessActivity.name,
+        hasAccess: false,
+        role: null,
+      })
+
+      businessActivity.complexes.forEach(complex => {
+        complexes.push({
+          id: complex.id,
+          name: complex.name,
+          hasAccess: false,
+          role: null,
+        })
+
+        complex.pos_list.forEach(pos => {
+          poses.push({
+            id: pos.id,
+            name: pos.name,
+            hasAccess: false,
+            role: null,
+          })
+        })
+      })
+    })
+
+    permissions.forEach(permission => {
+      permission.posPermissions.forEach(posPermission => {
+        poses.map(pos => {
+          if (pos.id === posPermission.pos_id) {
+            return {
+              ...pos,
+              role: posPermission.role,
+              hasAccess: true,
+            }
+          }
+          return pos
+        })
+      })
+    })
+  }
+
+  async findOne(id: string) {
+    const account = await this.prisma.account.findUnique({
+      where: { id },
+    })
+    return ResponseMapper.single(account)
+  }
+
+  async create(userId: string, data: CreateAccountDto) {
+    return ResponseMapper.create({})
+  }
+}

src/modules/admin/consumers/business-activities/business-activities.controller.ts

@@ -2,35 +2,35 @@ import { Body, Controller, Get, Param, Post } from '@nestjs/common'
 import { BusinessActivitiesService } from './business-activities.service'
 import { CreateBusinessActivitiesDto } from './dto/create-business-activities.dto'
 
-@Controller('admin/users/:userId/business_activities')
+@Controller('admin/consumers/:consumerId/business_activities')
 export class BusinessActivitiesController {
   constructor(private readonly businessActivitiesService: BusinessActivitiesService) {}
 
   @Get()
-  async findAll(@Param('userId') userId: string) {
-    return this.businessActivitiesService.findAll(userId)
+  async findAll(@Param('consumerId') consumerId: string) {
+    return this.businessActivitiesService.findAll(consumerId)
   }
 
   @Get(':id')
-  async findOne(@Param('userId') userId: string, @Param('id') id: string) {
-    return this.businessActivitiesService.findOne(userId, id)
+  async findOne(@Param('consumerId') consumerId: string, @Param('id') id: string) {
+    return this.businessActivitiesService.findOne(consumerId, id)
   }
 
   @Post()
   async create(
-    @Param('userId') userId: string,
+    @Param('consumerId') consumerId: string,
     @Body() data: CreateBusinessActivitiesDto,
   ) {
-    return this.businessActivitiesService.create(userId, data)
+    return this.businessActivitiesService.create(consumerId, data)
   }
 
   // @Put(':id')
   // async update(
-  //   @Param('userId') userId: string,
+  //   @Param('consumerId') consumerId: string,
   //   @Param('id') id: string,
   //   @Body() data: UpdateBusinessActivityDto,
   // ) {
-  //   return this.businessActivitiesService.update(userId, id, data)
+  //   return this.businessActivitiesService.update(consumerId, id, data)
   // }
 
   // @Delete(':id')

src/modules/admin/consumers/business-activities/business-activities.module.ts

@@ -9,4 +9,4 @@ import { AdminBusinessActivityComplexesModule } from './complexes/complexes.modu
   controllers: [BusinessActivitiesController],
   providers: [BusinessActivitiesService],
 })
-export class AdminUserBusinessActivitiesModule {}
+export class AdminConsumerBusinessActivitiesModule {}

src/modules/admin/consumers/business-activities/business-activities.service.ts

@@ -24,7 +24,7 @@ export class BusinessActivitiesService {
   async findAll(userId: string) {
     const businessActivities = await this.prisma.businessActivity.findMany({
       where: {
-        owner_id: userId,
+        user_id: userId,
       },
       select: this.defaultSelect,
     })
@@ -33,7 +33,7 @@ export class BusinessActivitiesService {
 
   async findOne(userId: string, id: string) {
     const businessActivity = await this.prisma.businessActivity.findUnique({
-      where: { owner_id: userId, id },
+      where: { user_id: userId, id },
       select: this.defaultSelect,
     })
     return ResponseMapper.single(businessActivity)

src/modules/admin/consumers/business-activities/complexes/complexes.controller.ts

@@ -4,25 +4,27 @@ import { BusinessActivityComplexesService } from './complexes.service'
 import { CreateComplexDto, UpdateComplexDto } from './dto/complex.dto'
 
 @ApiTags('AdminBusinessActivityComplexes')
-@Controller('admin/users/:userId/business_activities/:businessActivityId/complexes')
+@Controller(
+  'admin/consumers/:consumerId/business_activities/:businessActivityId/complexes',
+)
 export class BusinessActivityComplexesController {
   constructor(private readonly service: BusinessActivityComplexesService) {}
 
   @Get()
   async findAll(
-    @Param('userId') userId: string,
+    @Param('consumerId') consumerId: string,
     @Param('businessActivityId') businessActivityId: string,
   ) {
-    return this.service.findAll(userId, businessActivityId)
+    return this.service.findAll(consumerId, businessActivityId)
   }
 
   @Get(':id')
   async findOne(
-    @Param('userId') userId: string,
+    @Param('consumerId') consumerId: string,
     @Param('businessActivityId') businessActivityId: string,
     @Param('id') id: string,
   ) {
-    return this.service.findOne(userId, businessActivityId, id)
+    return this.service.findOne(consumerId, businessActivityId, id)
   }
 
   @Post()
@@ -36,11 +38,11 @@ export class BusinessActivityComplexesController {
   @Patch(':id')
   async update(
     @Param('id') id: string,
-    @Param('userId') userId: string,
+    @Param('consumerId') consumerId: string,
     @Param('businessActivityId') businessActivityId: string,
     @Body() data: UpdateComplexDto,
   ) {
-    return this.service.update(userId, businessActivityId, id, data)
+    return this.service.update(consumerId, businessActivityId, id, data)
   }
 
   // @Delete(':id')

src/modules/admin/consumers/consumers.controller.ts

@@ -0,0 +1,33 @@
+import { Body, Controller, Delete, Get, Param, Patch, Post } from '@nestjs/common'
+import { AdminUsersService } from './consumers.service'
+import { CreateConsumerDto, UpdateConsumerDto } from './dto/consumer.dto'
+
+@Controller('admin/consumers')
+export class AdminUsersController {
+  constructor(private readonly usersService: AdminUsersService) {}
+
+  @Get()
+  async findAll() {
+    return this.usersService.findAll()
+  }
+
+  @Get(':id')
+  async findOne(@Param('id') id: string) {
+    return this.usersService.findOne(id)
+  }
+
+  @Post()
+  async create(@Body() data: CreateConsumerDto) {
+    return this.usersService.create(data)
+  }
+
+  @Patch(':id')
+  async update(@Param('id') id: string, @Body() data: UpdateConsumerDto) {
+    return this.usersService.update(id, data)
+  }
+
+  @Delete(':id')
+  async delete(@Param('id') id: string) {
+    return this.usersService.delete(id)
+  }
+}

src/modules/admin/consumers/consumers.module.ts

@@ -0,0 +1,14 @@
+import { PrismaModule } from '@/prisma/prisma.module'
+import { Module } from '@nestjs/common'
+import { AdminUserAccountsModule } from './accounts/accounts.module'
+import { AdminConsumerBusinessActivitiesModule } from './business-activities/business-activities.module'
+import { AdminUsersController } from './consumers.controller'
+import { AdminUsersService } from './consumers.service'
+
+@Module({
+  imports: [PrismaModule, AdminUserAccountsModule, AdminConsumerBusinessActivitiesModule],
+  controllers: [AdminUsersController],
+  providers: [AdminUsersService],
+  exports: [AdminUserAccountsModule],
+})
+export class AdminConsumersModule {}

src/modules/admin/consumers/consumers.service.ts

@@ -0,0 +1,83 @@
+import { PasswordUtil } from '@/common/utils/password.util'
+import { AccountStatus, AccountType, ConsumerRole } from '@/generated/prisma/enums'
+import { PrismaService } from '@/prisma/prisma.service'
+import { Injectable } from '@nestjs/common'
+import { ResponseMapper } from 'common/response/response-mapper'
+import { CreateConsumerDto, UpdateConsumerDto } from './dto/consumer.dto'
+
+@Injectable()
+export class AdminUsersService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll() {
+    const [consumers, count] = await this.prisma.$transaction([
+      this.prisma.consumer.findMany({
+        select: {
+          id: true,
+          first_name: true,
+          last_name: true,
+          mobile_number: true,
+          status: true,
+          created_at: true,
+        },
+      }),
+      this.prisma.consumer.count(),
+    ])
+    return ResponseMapper.paginate(
+      consumers.map(consumer => ({
+        ...consumer,
+        fullname: `${consumer.first_name} ${consumer.last_name}`,
+      })),
+      { count },
+    )
+  }
+
+  async findOne(id: string) {
+    const consumer = await this.prisma.consumer.findUniqueOrThrow({
+      where: { id },
+      select: {
+        id: true,
+        first_name: true,
+        last_name: true,
+        mobile_number: true,
+        status: true,
+        created_at: true,
+      },
+    })
+
+    return ResponseMapper.single({
+      ...consumer,
+      fullname: `${consumer?.first_name} ${consumer?.last_name}`,
+    })
+  }
+
+  async create(data: CreateConsumerDto) {
+    const { username, password, ...rest } = data
+    return this.prisma.consumer.create({
+      data: {
+        ...rest,
+        accounts: {
+          create: {
+            role: ConsumerRole.OWNER,
+            account: {
+              create: {
+                username,
+                password: await PasswordUtil.hash(password),
+                type: AccountType.CONSUMER,
+                status: AccountStatus.ACTIVE,
+              },
+            },
+          },
+        },
+      },
+    })
+  }
+
+  async update(id: string, data: UpdateConsumerDto) {
+    return this.prisma.admin.update({ where: { id }, data })
+  }
+
+  async delete(id: string) {
+    return this.prisma.admin.delete({ where: { id } })
+  }
+}

src/modules/admin/consumers/dto/consumer.dto.ts

@@ -0,0 +1,30 @@
+import { ConsumerStatus } from '@/generated/prisma/enums'
+import { ApiProperty, PartialType } from '@nestjs/swagger'
+import { IsEnum, IsString } from 'class-validator'
+
+export class CreateConsumerDto {
+  @IsString()
+  @ApiProperty({ required: true })
+  mobile_number: string
+
+  @IsString()
+  @ApiProperty({ required: true })
+  first_name: string
+
+  @IsString()
+  @ApiProperty({ required: true })
+  last_name: string
+
+  @IsString()
+  @ApiProperty({ required: true })
+  username: string
+
+  @IsString()
+  @ApiProperty({ required: true })
+  password: string
+}
+export class UpdateConsumerDto extends PartialType(CreateConsumerDto) {
+  @IsEnum(ConsumerStatus)
+  @ApiProperty({ enum: ConsumerStatus })
+  status: ConsumerStatus
+}

src/modules/admin/guilds/goods/goods.service.ts

@@ -14,15 +14,16 @@ export class GoodsService {
     base_sale_price: true,
     is_default_guild_good: true,
     local_sku: true,
-    guild_id: true,
   } as GoodOmit
 
   async findAll(guildId: string) {
     const [goods, count] = await this.prisma.$transaction([
       this.prisma.good.findMany({
         where: {
-          guild_id: guildId,
           is_default_guild_good: true,
+          category: {
+            guild_id: guildId,
+          },
         },
         include: {
           category: {
@@ -44,9 +45,11 @@ export class GoodsService {
   async findOne(guild_id: string, id: string) {
     const good = await this.prisma.good.findUnique({
       where: {
-        guild_id,
         id,
         is_default_guild_good: true,
+        category: {
+          guild_id,
+        },
       },
 
       include: {
@@ -69,11 +72,6 @@ export class GoodsService {
 
     const good = await this.prisma.good.create({
       data: {
-        guild: {
-          connect: {
-            id: guild_id,
-          },
-        },
         category: {
           connect: {
             id: category_id,

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

@@ -1,16 +1,32 @@
-import { IsNumber, IsOptional, IsString } from 'class-validator'
+import { PartnerStatus } from '@/generated/prisma/enums'
+import { ApiProperty, PartialType } from '@nestjs/swagger'
+import { IsEnum, IsNumber, IsOptional, IsString } from 'class-validator'
 
 export class CreatePartnerDto {
   @IsString()
+  @ApiProperty({ required: true })
   name: string
 
-  @IsOptional()
   @IsString()
-  code?: string
+  @ApiProperty({ required: true })
+  code: string
 
   @IsOptional()
   @IsNumber()
+  @ApiProperty({ required: true })
   license_quota?: number
+
+  @IsString()
+  @ApiProperty({ required: true })
+  username: string
+
+  @IsString()
+  @ApiProperty({ required: true })
+  password: string
 }
 
-export class UpdatePartnerDto extends CreatePartnerDto {}
+export class UpdatePartnerDto extends PartialType(CreatePartnerDto) {
+  @IsEnum(PartnerStatus)
+  @ApiProperty({ enum: PartnerStatus })
+  status: PartnerStatus
+}

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

@@ -8,101 +8,100 @@ 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,
-        }
-      }),
-    )
+    // 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,
+    // 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,
-      })
-    }
+    //         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)
+    return ResponseMapper.single({})
   }
 
   async create(partnerId: string, data: CreatePartnerLicenseDto) {

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

@@ -1,6 +1,6 @@
 import { Body, Controller, Delete, Get, Param, Patch, Post } from '@nestjs/common'
 import { AccountsService } from './accounts.service'
-import { CreateAccountDto, UpdateAccountDto } from './dto/account.dto'
+import { CreatePartnerAccountDto, UpdateAccountDto } from './dto/account.dto'
 
 @Controller('admin/partners/:partnerId/accounts')
 export class AccountsController {
@@ -17,7 +17,10 @@ export class AccountsController {
   }
 
   @Post()
-  async create(@Param('partnerId') partnerId: string, @Body() data: CreateAccountDto) {
+  async create(
+    @Param('partnerId') partnerId: string,
+    @Body() data: CreatePartnerAccountDto,
+  ) {
     return this.accountsService.create(partnerId, data)
   }
 

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

@@ -1,67 +1,66 @@
+import { PartnerAccountSelect } from '@/generated/prisma/models'
 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 { AccountStatus, AccountType } from 'generated/prisma/enums'
-import { CreateAccountDto, UpdateAccountDto } from './dto/account.dto'
+import { AccountStatus, AccountType, PartnerRole } from 'generated/prisma/enums'
+import { CreatePartnerAccountDto, 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,
+  private readonly defaultSelect = {
+    id: true,
+    role: true,
+    created_at: true,
+    account: {
+      select: {
+        username: true,
+        status: true,
       },
+    },
+  } as PartnerAccountSelect
+
+  async findAll(partnerId: string) {
+    const accounts = await this.prisma.partnerAccount.findMany({
+      where: { user_id: partnerId },
+      select: this.defaultSelect,
     })
     return ResponseMapper.list(accounts)
   }
 
   async findOne(id: string) {
-    const account = await this.prisma.account.findUnique({
+    const account = await this.prisma.partnerAccount.findUnique({
       where: { id },
-      omit: { password: true, user_id: true },
-      include: {
-        partner: true,
-        user: true,
-      },
+      select: this.defaultSelect,
     })
     return ResponseMapper.single(account)
   }
 
-  async create(partnerId: string, data: CreateAccountDto) {
-    const { username, password, ...userData } = data
+  async create(partnerId: string, data: CreatePartnerAccountDto) {
+    const { username, password } = 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: AccountStatus.ACTIVE,
-        password: hashedPassword,
-        user_id: user.id,
-        type: AccountType.PARTNER,
-        partner_id: partnerId, // Connect account to partner
-      }
-
-      const account = await tx.account.create({
-        data: dataToCreate,
+      const account = await tx.partnerAccount.create({
+        data: {
+          role: PartnerRole.MANAGER,
+          account: {
+            create: {
+              username,
+              password: hashedPassword,
+              status: AccountStatus.ACTIVE,
+              type: AccountType.PARTNER,
+            },
+          },
+          user: {
+            connect: {
+              id: partnerId,
+            },
+          },
+        },
       })
 
       return account

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

@@ -1,37 +1,20 @@
+import { ApiProperty, PartialType } from '@nestjs/swagger'
 import { IsEnum, IsOptional, IsString } from 'class-validator'
-import { AccountStatus, AccountType } from 'generated/prisma/enums'
-import { CreateUserDto } from '../../../users/dto/user.dto'
+import { PartnerRole } from 'generated/prisma/enums'
 
-export class CreateAccountDto extends CreateUserDto {
+export class CreatePartnerAccountDto {
   @IsString()
+  @ApiProperty({})
   username: string
 
-  @IsOptional()
-  @IsEnum(AccountType)
-  type?: AccountType
-
   @IsString()
+  @ApiProperty({})
   password: string
 }
 
-export class UpdateAccountDto {
+export class UpdateAccountDto extends PartialType(CreatePartnerAccountDto) {
   @IsOptional()
-  @IsString()
-  username?: string
-
-  @IsOptional()
-  @IsEnum(AccountType)
-  type?: AccountType
-
-  @IsOptional()
-  @IsEnum(AccountStatus)
-  status?: AccountStatus
-
-  @IsOptional()
-  @IsString()
-  password?: string
-
-  // @IsOptional()
-  // @IsString()
-  // user_id?: string
+  @IsEnum(PartnerRole)
+  @ApiProperty({ enum: PartnerRole })
+  role?: PartnerRole
 }

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

@@ -1,3 +1,10 @@
+import { PasswordUtil } from '@/common/utils/password.util'
+import {
+  AccountStatus,
+  AccountType,
+  PartnerRole,
+  PartnerStatus,
+} from '@/generated/prisma/enums'
 import { PrismaService } from '@/prisma/prisma.service'
 import { Injectable } from '@nestjs/common'
 import { ResponseMapper } from 'common/response/response-mapper'
@@ -8,23 +15,7 @@ export class PartnersService {
   constructor(private readonly prisma: PrismaService) {}
 
   async findAll() {
-    // const partners = await this.prisma.$transaction(async tx => {
-    //   const partners = await this.prisma.partner.findMany().then()
-    //   const preparedPartners = await partners.map(async partner => {
-    //     const relatedLicenseCount = await this.prisma.license.count({
-    //       where: {
-    //         partner_id: partner.id,
-    //       },
-    //     })
-
-    //     return {
-    //       ...partner,
-    //       remained_license: Math.min((partner?.licenseQuota, 0) - relatedLicenseCount, 0),
-    //     }
-    //   })
-    //   console.log(preparedPartners)
     const partners = await this.prisma.partner.findMany()
-
     return ResponseMapper.list(partners)
   }
 
@@ -39,14 +30,37 @@ export class PartnersService {
         },
       }),
     ])
+
     return ResponseMapper.single({
       ...partner,
-      remained_license: Math.min((partner?.license_quota, 0) - relatedLicenseCount, 0),
+      remained_license: Math.max(
+        (partner?.license_quota || 0) - (relatedLicenseCount || 0),
+        0,
+      ),
     })
   }
 
   async create(data: CreatePartnerDto) {
-    const partner = await this.prisma.partner.create({ data })
+    const { username, password, ...rest } = data
+    const partner = await this.prisma.partner.create({
+      data: {
+        ...rest,
+        status: PartnerStatus.ACTIVE,
+        accounts: {
+          create: {
+            role: PartnerRole.OWNER,
+            account: {
+              create: {
+                username,
+                password: await PasswordUtil.hash(data.password),
+                status: AccountStatus.ACTIVE,
+                type: AccountType.PARTNER,
+              },
+            },
+          },
+        },
+      },
+    })
     return ResponseMapper.create(partner)
   }
 

src/modules/admin/providers/dto/provider.dto.ts

@@ -1,15 +1,23 @@
-import { ApiProperty } from '@nestjs/swagger'
+import { ApiProperty, PartialType } from '@nestjs/swagger'
 import { IsOptional, IsString } from 'class-validator'
 
 export class CreateProviderDto {
   @IsString()
-  @ApiProperty()
+  @ApiProperty({ required: true })
   name: string
 
   @IsOptional()
   @IsString()
   @ApiProperty()
-  code?: string
+  code: string
+
+  @IsString()
+  @ApiProperty({ required: true })
+  username: string
+
+  @IsString()
+  @ApiProperty({ required: true })
+  password: string
 }
 
-export class UpdateProviderDto extends CreateProviderDto {}
+export class UpdateProviderDto extends PartialType(CreateProviderDto) {}

src/modules/admin/providers/providers.controller.ts

@@ -1,4 +1,4 @@
-import { Body, Controller, Delete, Get, Param, Patch, Post } from '@nestjs/common'
+import { Body, Controller, Get, Param, Patch, Post } from '@nestjs/common'
 import { ApiTags } from '@nestjs/swagger'
 import { CreateProviderDto, UpdateProviderDto } from './dto/provider.dto'
 import { ProvidersService } from './providers.service'
@@ -28,8 +28,8 @@ export class ProvidersController {
     return this.providersService.update(id, data)
   }
 
-  @Delete(':id')
-  async delete(@Param('id') id: string) {
-    return this.providersService.delete(id)
-  }
+  // @Delete(':id')
+  // async delete(@Param('id') id: string) {
+  //   return this.providersService.delete(id)
+  // }
 }

src/modules/admin/providers/providers.service.ts

@@ -1,3 +1,5 @@
+import { PasswordUtil } from '@/common/utils/password.util'
+import { AccountStatus, AccountType, ProviderRole } from '@/generated/prisma/enums'
 import { PrismaService } from '@/prisma/prisma.service'
 import { Injectable } from '@nestjs/common'
 import { ResponseMapper } from 'common/response/response-mapper'
@@ -15,13 +17,31 @@ export class ProvidersService {
   async findOne(id: string) {
     const provider = await this.prisma.provider.findUnique({
       where: { id },
-      include: { pos_list: true, accounts: true },
+      include: { pos_list: true },
     })
     return ResponseMapper.single(provider)
   }
 
   async create(data: CreateProviderDto) {
-    const provider = await this.prisma.provider.create({ data })
+    const { username, password, ...rest } = data
+    const provider = await this.prisma.provider.create({
+      data: {
+        ...rest,
+        accounts: {
+          create: {
+            role: ProviderRole.OWNER,
+            account: {
+              create: {
+                username,
+                password: await PasswordUtil.hash(password),
+                status: AccountStatus.ACTIVE,
+                type: AccountType.PROVIDER,
+              },
+            },
+          },
+        },
+      },
+    })
     return ResponseMapper.create(provider)
   }
 
@@ -30,8 +50,8 @@ export class ProvidersService {
     return ResponseMapper.update(provider)
   }
 
-  async delete(id: string) {
-    await this.prisma.provider.delete({ where: { id } })
-    return ResponseMapper.delete()
-  }
+  // async delete(id: string) {
+  //   await this.prisma.provider.delete({ where: { id } })
+  //   return ResponseMapper.delete()
+  // }
 }

src/modules/admin/users/accounts/accounts.service.ts

@@ -1,5 +1,3 @@
-import { PasswordUtil } from '@/common/utils/password.util'
-import { AccountStatus } from '@/generated/prisma/enums'
 import { PrismaService } from '@/prisma/prisma.service'
 import { Injectable } from '@nestjs/common'
 import { ResponseMapper } from 'common/response/response-mapper'
@@ -10,42 +8,37 @@ export class AccountsService {
   constructor(private readonly prisma: PrismaService) {}
 
   async findAll(userId: string) {
-    const accounts = await this.prisma.account.findMany({
-      where: { user_id: userId },
-      omit: { password: true, user_id: true },
-    })
-    return ResponseMapper.list(accounts)
+    console.log('first')
+
+    // const accounts = await this.prisma.account.findMany({
+    //   where: { user_id: userId },
+    //   omit: { password: true, user_id: true },
+    // })
+    return ResponseMapper.list([])
   }
 
   async findOne(id: string) {
-    const account = await this.prisma.account.findUnique({
-      where: { id },
-      omit: { password: true, user_id: true },
-      include: {
-        pos: true,
-        business: true,
-        provider: true,
-        partner: true,
-      },
-    })
-    return ResponseMapper.single(account)
+    // const account = await this.prisma.account.findUnique({
+    //   where: { id },
+    //   omit: { password: true, user_id: true },
+    // })
+    return ResponseMapper.single({})
   }
 
   async create(userId: string, data: CreateAccountDto) {
-    // Assuming password hashing is handled elsewhere or add bcrypt here
-    const account = await this.prisma.account.create({
-      data: {
-        ...data,
-        password: await PasswordUtil.hash(data.password),
-        status: AccountStatus.ACTIVE,
-        user: {
-          connect: {
-            id: userId,
-          },
-        },
-      },
-    })
-    return ResponseMapper.create(account)
+    // const account = await this.prisma.account.create({
+    //   data: {
+    //     ...data,
+    //     password: await PasswordUtil.hash(data.password),
+    //     status: AccountStatus.ACTIVE,
+    //     user: {
+    //       connect: {
+    //         id: userId,
+    //       },
+    //     },
+    //   },
+    // })
+    return ResponseMapper.create({})
   }
 
   async update(id: string, data: UpdateAccountDto) {

src/modules/admin/users/accounts/dto/account.dto.ts

@@ -1,35 +1,24 @@
+import { ApiProperty, PartialType } from '@nestjs/swagger'
 import { IsEnum, IsOptional, IsString } from 'class-validator'
 import { AccountStatus, AccountType } from 'generated/prisma/enums'
 
 export class CreateAccountDto {
   @IsString()
+  @ApiProperty()
   username: string
 
-  @IsEnum(AccountType)
-  type: AccountType
-
   @IsString()
+  @ApiProperty()
   password: string
+
+  @IsEnum(AccountType)
+  @ApiProperty({ enum: AccountType })
+  type: AccountType
 }
 
-export class UpdateAccountDto {
-  @IsOptional()
-  @IsString()
-  username?: string
-
-  @IsOptional()
-  @IsEnum(AccountType)
-  type?: AccountType
-
+export class UpdateAccountDto extends PartialType(CreateAccountDto) {
   @IsOptional()
   @IsEnum(AccountStatus)
+  @ApiProperty({ enum: AccountStatus })
   status?: AccountStatus
-
-  @IsOptional()
-  @IsString()
-  password?: string
-
-  @IsOptional()
-  @IsString()
-  user_id?: string
 }

src/modules/admin/users/accounts/permissions/dto/permission.dto.ts

@@ -0,0 +1,24 @@
+import { ApiProperty, PartialType } from '@nestjs/swagger'
+import { IsEnum, IsOptional, IsString } from 'class-validator'
+import { AccountStatus, AccountType } from 'generated/prisma/enums'
+
+export class CreateAccountDto {
+  @IsString()
+  @ApiProperty()
+  username: string
+
+  @IsString()
+  @ApiProperty()
+  password: string
+
+  @IsEnum(AccountType)
+  @ApiProperty({ enum: AccountType })
+  type: AccountType
+}
+
+export class UpdateAccountDto extends PartialType(CreateAccountDto) {
+  @IsOptional()
+  @IsEnum(AccountStatus)
+  @ApiProperty({ enum: AccountStatus })
+  status?: AccountStatus
+}

src/modules/admin/users/accounts/permissions/permissions.controller.ts

@@ -0,0 +1,20 @@
+import { Body, Controller, Get, Param, Post } from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+import { CreateAccountDto } from './dto/permission.dto'
+import { AccountsService } from './permissions.service'
+
+@ApiTags('AdminAccounts')
+@Controller('admin/users/:userId/accounts/:accountId/permissions')
+export class AccountPermissionsController {
+  constructor(private readonly service: AccountsService) {}
+
+  @Get()
+  async findAll(@Param('userId') userId: string, @Param('accountId') accountId: string) {
+    return this.service.findAll(userId, accountId)
+  }
+
+  @Post()
+  async create(@Param('userId') userId: string, @Body() data: CreateAccountDto) {
+    return this.service.create(userId, data)
+  }
+}

src/modules/admin/users/accounts/permissions/permissions.module.ts

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

src/modules/admin/users/accounts/permissions/permissions.service.ts

@@ -0,0 +1,116 @@
+import { PrismaService } from '@/prisma/prisma.service'
+import { Injectable } from '@nestjs/common'
+import { ResponseMapper } from 'common/response/response-mapper'
+import { CreateAccountDto } from './dto/permission.dto'
+
+@Injectable()
+export class AccountsService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async findAll(userId: string, account_id: string) {
+    const businessActivities = await this.prisma.businessActivity.findMany({
+      where: {
+        user_id: userId,
+      },
+      select: {
+        id: true,
+        name: true,
+        complexes: {
+          select: {
+            id: true,
+            name: true,
+            pos_list: {
+              select: {
+                id: true,
+                name: true,
+              },
+            },
+          },
+        },
+      },
+    })
+
+    const permissions = await this.prisma.permissionConsumer.findMany({
+      where: {
+        account_id,
+      },
+      select: {
+        posPermissions: {
+          select: {
+            pos_id: true,
+            role: true,
+          },
+        },
+        businessPermissions: {
+          select: {
+            business_id: true,
+            role: true,
+          },
+        },
+        complexPermissions: {
+          select: {
+            complex_id: true,
+            role: true,
+          },
+        },
+      },
+    })
+
+    const businesses = [] as any
+    const complexes = [] as any
+    const poses = [] as any
+
+    businessActivities.forEach(businessActivity => {
+      businesses.push({
+        id: businessActivity.id,
+        name: businessActivity.name,
+        hasAccess: false,
+        role: null,
+      })
+
+      businessActivity.complexes.forEach(complex => {
+        complexes.push({
+          id: complex.id,
+          name: complex.name,
+          hasAccess: false,
+          role: null,
+        })
+
+        complex.pos_list.forEach(pos => {
+          poses.push({
+            id: pos.id,
+            name: pos.name,
+            hasAccess: false,
+            role: null,
+          })
+        })
+      })
+    })
+
+    permissions.forEach(permission => {
+      permission.posPermissions.forEach(posPermission => {
+        poses.map(pos => {
+          if (pos.id === posPermission.pos_id) {
+            return {
+              ...pos,
+              role: posPermission.role,
+              hasAccess: true,
+            }
+          }
+          return pos
+        })
+      })
+    })
+  }
+
+  async findOne(id: string) {
+    const account = await this.prisma.account.findUnique({
+      where: { id },
+    })
+    return ResponseMapper.single(account)
+  }
+
+  async create(userId: string, data: CreateAccountDto) {
+    return ResponseMapper.create({})
+  }
+}

src/modules/admin/users/business-activities/accounts/accounts.controller.ts

@@ -1,57 +0,0 @@
-import { Body, Controller, Get, Param, Patch, Post } from '@nestjs/common'
-import { ApiTags } from '@nestjs/swagger'
-import { BusinessActivityAccountsService } from './accounts.service'
-import { CreateAccountDto, UpdateAccountDto } from './dto/account.dto'
-
-@ApiTags('AdminAccounts')
-@Controller('admin/users/:userId/business_activities/:businessActivityId/accounts')
-export class BusinessActivityAccountsController {
-  constructor(
-    private readonly businessActivityAccountsService: BusinessActivityAccountsService,
-  ) {}
-
-  @Get()
-  async findAll(
-    @Param('userId') userId: string,
-    @Param('businessActivityId') businessActivityId: string,
-  ) {
-    return this.businessActivityAccountsService.findAll(userId, businessActivityId)
-  }
-
-  @Get(':id')
-  async findOne(
-    @Param('id') id: string,
-    @Param('businessActivityId') businessActivityId: string,
-  ) {
-    return this.businessActivityAccountsService.findOne(id, businessActivityId)
-  }
-
-  @Post()
-  async create(
-    @Param('userId') userId: string,
-    @Param('businessActivityId') businessActivityId: string,
-    @Body() data: CreateAccountDto,
-  ) {
-    return this.businessActivityAccountsService.create(userId, businessActivityId, data)
-  }
-
-  @Patch(':id')
-  async update(
-    @Param('userId') userId: string,
-    @Param('businessActivityId') businessActivityId: string,
-    @Param('id') id: string,
-    @Body() data: UpdateAccountDto,
-  ) {
-    return this.businessActivityAccountsService.update(
-      userId,
-      businessActivityId,
-      id,
-      data,
-    )
-  }
-
-  // @Delete(':id')
-  // async delete(@Param('id') id: string) {
-  //   return this.businessActivityAccountsService.delete(id)
-  // }
-}

src/modules/admin/users/business-activities/accounts/accounts.module.ts

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

src/modules/admin/users/business-activities/accounts/accounts.service.ts

@@ -1,77 +0,0 @@
-import { PasswordUtil } from '@/common/utils/password.util'
-import { AccountStatus, AccountType } from '@/generated/prisma/enums'
-import { PrismaService } from '@/prisma/prisma.service'
-import { Injectable } from '@nestjs/common'
-import { ResponseMapper } from 'common/response/response-mapper'
-import { CreateAccountDto, UpdateAccountDto } from './dto/account.dto'
-
-@Injectable()
-export class BusinessActivityAccountsService {
-  constructor(private readonly prisma: PrismaService) {}
-
-  async findAll(userId: string, business_id: string) {
-    const accounts = await this.prisma.account.findMany({
-      where: { user_id: userId, business_id },
-      select: {
-        id: true,
-        username: true,
-        status: true,
-      },
-    })
-    return ResponseMapper.list(accounts)
-  }
-
-  async findOne(business_id: string, id: string) {
-    const account = await this.prisma.account.findUnique({
-      where: { business_id, id },
-      select: {
-        id: true,
-        username: true,
-        status: true,
-      },
-    })
-    return ResponseMapper.single(account)
-  }
-
-  async create(userId: string, business_id: string, data: CreateAccountDto) {
-    // Assuming password hashing is handled elsewhere or add bcrypt here
-    const account = await this.prisma.account.create({
-      data: {
-        ...data,
-        password: await PasswordUtil.hash(data.password),
-        status: AccountStatus.ACTIVE,
-        type: AccountType.BUSINESS,
-        user: {
-          connect: {
-            id: userId,
-          },
-        },
-        business: {
-          connect: {
-            id: business_id,
-          },
-        },
-      },
-    })
-    return ResponseMapper.create(account)
-  }
-
-  async update(user_id: string, business_id: string, id: string, data: UpdateAccountDto) {
-    const account = await this.prisma.account.update({
-      where: {
-        user_id_business_id: {
-          user_id,
-          business_id,
-        },
-        id,
-      },
-      data,
-    })
-    return ResponseMapper.update(account)
-  }
-
-  async delete(id: string) {
-    await this.prisma.account.delete({ where: { id } })
-    return ResponseMapper.delete()
-  }
-}

src/modules/admin/users/business-activities/accounts/dto/account.dto.ts

@@ -1,28 +0,0 @@
-import { IsEnum, IsOptional, IsString } from 'class-validator'
-import { AccountStatus } from 'generated/prisma/enums'
-
-export class CreateAccountDto {
-  @IsString()
-  username: string
-
-  @IsString()
-  password: string
-}
-
-export class UpdateAccountDto {
-  @IsOptional()
-  @IsString()
-  username?: string
-
-  @IsOptional()
-  @IsEnum(AccountStatus)
-  status?: AccountStatus
-
-  @IsOptional()
-  @IsString()
-  password?: string
-
-  @IsOptional()
-  @IsString()
-  user_id?: string
-}

src/modules/admin/users/users.module.ts

@@ -1,12 +1,11 @@
 import { PrismaModule } from '@/prisma/prisma.module'
 import { Module } from '@nestjs/common'
 import { AdminUserAccountsModule } from './accounts/accounts.module'
-import { AdminUserBusinessActivitiesModule } from './business-activities/business-activities.module'
 import { AdminUsersController } from './users.controller'
 import { AdminUsersService } from './users.service'
 
 @Module({
-  imports: [PrismaModule, AdminUserAccountsModule, AdminUserBusinessActivitiesModule],
+  imports: [PrismaModule, AdminUserAccountsModule],
   controllers: [AdminUsersController],
   providers: [AdminUsersService],
   exports: [AdminUserAccountsModule],

src/modules/admin/users/users.service.ts

@@ -9,8 +9,8 @@ export class AdminUsersService {
 
   async findAll() {
     const [users, count] = await this.prisma.$transaction([
-      this.prisma.user.findMany(),
-      this.prisma.user.count(),
+      this.prisma.admin.findMany(),
+      this.prisma.admin.count(),
     ])
     return ResponseMapper.paginate(
       users.map(user => ({ ...user, fullname: `${user.first_name} ${user.last_name}` })),
@@ -19,7 +19,7 @@ export class AdminUsersService {
   }
 
   async findOne(id: string) {
-    const user = await this.prisma.user.findUnique({
+    const user = await this.prisma.admin.findUnique({
       where: { id },
     })
 
@@ -33,14 +33,14 @@ export class AdminUsersService {
   }
 
   async create(data: CreateUserDto) {
-    return this.prisma.user.create({ data })
+    return this.prisma.admin.create({ data })
   }
 
   async update(id: string, data: UpdateUserDto) {
-    return this.prisma.user.update({ where: { id }, data })
+    return this.prisma.admin.update({ where: { id }, data })
   }
 
   async delete(id: string) {
-    return this.prisma.user.delete({ where: { id } })
+    return this.prisma.admin.delete({ where: { id } })
   }
 }