create token decorator and consumer module

src/modules/consumer/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('consumer/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/consumer/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 ConsumerAccountsModule {}

src/modules/consumer/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/consumer/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/consumer/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/consumer/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/consumer/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/consumer/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/consumer/business-activities/business-activities.controller.ts

@@ -0,0 +1,28 @@
+import { TokenAccount } from '@/common/decorators/tokenInfo.decorator'
+import { Body, Controller, Get, Param, Patch } from '@nestjs/common'
+import { BusinessActivitiesService } from './business-activities.service'
+import { UpdateBusinessActivityDto } from './dto/create-business-activities.dto'
+
+@Controller('consumer/business_activities')
+export class BusinessActivitiesController {
+  constructor(private readonly service: BusinessActivitiesService) {}
+
+  @Get()
+  async findAll(@TokenAccount('userId') userId: string) {
+    return this.service.findAll(userId)
+  }
+
+  @Get(':id')
+  async findOne(@TokenAccount('userId') userId: string, @Param('id') id: string) {
+    return this.service.findOne(userId, id)
+  }
+
+  @Patch(':id')
+  async update(
+    @TokenAccount('userId') userId: string,
+    @Param('id') id: string,
+    @Body() data: UpdateBusinessActivityDto,
+  ) {
+    return this.service.update(userId, id, data)
+  }
+}

src/modules/consumer/business-activities/business-activities.module.ts

@@ -0,0 +1,12 @@
+import { PrismaModule } from '@/prisma/prisma.module'
+import { Module } from '@nestjs/common'
+import { BusinessActivitiesController } from './business-activities.controller'
+import { BusinessActivitiesService } from './business-activities.service'
+import { ConsumerBusinessActivityComplexesModule } from './complexes/complexes.module'
+
+@Module({
+  imports: [PrismaModule, ConsumerBusinessActivityComplexesModule],
+  controllers: [BusinessActivitiesController],
+  providers: [BusinessActivitiesService],
+})
+export class ConsumerBusinessActivitiesModule {}

src/modules/consumer/business-activities/business-activities.service.ts

@@ -0,0 +1,49 @@
+import { BusinessActivitySelect } from '@/generated/prisma/models'
+import { PrismaService } from '@/prisma/prisma.service'
+import { Injectable } from '@nestjs/common'
+import { ResponseMapper } from 'common/response/response-mapper'
+
+@Injectable()
+export class BusinessActivitiesService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  defaultSelect = {
+    guild: {
+      select: {
+        id: true,
+        code: true,
+        name: true,
+      },
+    },
+    id: true,
+    name: true,
+    created_at: true,
+  } as BusinessActivitySelect
+
+  async findAll(user_id: string) {
+    const businessActivities = await this.prisma.businessActivity.findMany({
+      where: {
+        user_id,
+      },
+      select: this.defaultSelect,
+    })
+    return ResponseMapper.list(businessActivities)
+  }
+
+  async findOne(user_id: string, id: string) {
+    const businessActivity = await this.prisma.businessActivity.findUniqueOrThrow({
+      where: { user_id, id },
+      select: this.defaultSelect,
+    })
+    return ResponseMapper.single(businessActivity)
+  }
+
+  async update(user_id: string, id: string, data: any) {
+    const businessActivity = await this.prisma.businessActivity.update({
+      where: { id, user_id },
+      data,
+      select: this.defaultSelect,
+    })
+    return ResponseMapper.update(businessActivity)
+  }
+}

src/modules/consumer/business-activities/complexes/complexes.controller.ts

@@ -0,0 +1,38 @@
+import { TokenAccount } from '@/common/decorators/tokenInfo.decorator'
+import { Body, Controller, Get, Param, Patch } from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+import { BusinessActivityComplexesService } from './complexes.service'
+import { UpdateComplexDto } from './dto/complex.dto'
+
+@ApiTags('AdminBusinessActivityComplexes')
+@Controller('consumer/business_activities/:businessActivityId/complexes')
+export class BusinessActivityComplexesController {
+  constructor(private readonly service: BusinessActivityComplexesService) {}
+
+  @Get()
+  async findAll(
+    @TokenAccount('userId') userId: string,
+    @Param('businessActivityId') businessActivityId: string,
+  ) {
+    return this.service.findAll(userId, businessActivityId)
+  }
+
+  @Get(':id')
+  async findOne(
+    @TokenAccount('userId') userId: string,
+    @Param('businessActivityId') businessActivityId: string,
+    @Param('id') id: string,
+  ) {
+    return this.service.findOne(userId, businessActivityId, id)
+  }
+
+  @Patch(':id')
+  async update(
+    @TokenAccount('userId') userId: string,
+    @Param('businessActivityId') businessActivityId: string,
+    @Param('id') id: string,
+    @Body() data: UpdateComplexDto,
+  ) {
+    return this.service.update(userId, businessActivityId, id, data)
+  }
+}

src/modules/consumer/business-activities/complexes/complexes.module.ts

@@ -0,0 +1,12 @@
+import { PrismaModule } from '@/prisma/prisma.module'
+import { Module } from '@nestjs/common'
+import { BusinessActivityComplexesController } from './complexes.controller'
+import { BusinessActivityComplexesService } from './complexes.service'
+import { ConsumerComplexPosesModule } from './poses/poses.module'
+
+@Module({
+  imports: [PrismaModule, ConsumerComplexPosesModule],
+  controllers: [BusinessActivityComplexesController],
+  providers: [BusinessActivityComplexesService],
+})
+export class ConsumerBusinessActivityComplexesModule {}

src/modules/consumer/business-activities/complexes/complexes.service.ts

@@ -0,0 +1,75 @@
+import { ComplexSelect } from '@/generated/prisma/models'
+import { PrismaService } from '@/prisma/prisma.service'
+import { Injectable } from '@nestjs/common'
+import { ResponseMapper } from 'common/response/response-mapper'
+import { UpdateComplexDto } from './dto/complex.dto'
+
+@Injectable()
+export class BusinessActivityComplexesService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  defaultSelect = {
+    id: true,
+    name: true,
+    address: true,
+    tax_id: true,
+    created_at: true,
+  } as ComplexSelect
+
+  async findAll(user_id: string, business_activity_id: string) {
+    const accounts = await this.prisma.complex.findMany({
+      where: {
+        business_activity: {
+          id: business_activity_id,
+          user: {
+            id: user_id,
+          },
+        },
+      },
+      select: this.defaultSelect,
+    })
+    return ResponseMapper.list(accounts)
+  }
+
+  async findOne(user_id: string, business_activity_id: string, id: string) {
+    const account = await this.prisma.complex.findUnique({
+      where: {
+        business_activity: {
+          id: business_activity_id,
+          user: {
+            id: user_id,
+          },
+        },
+        id,
+      },
+      select: this.defaultSelect,
+    })
+    return ResponseMapper.single(account)
+  }
+
+  async update(
+    user_id: string,
+    business_activity_id: string,
+    id: string,
+    data: UpdateComplexDto,
+  ) {
+    const account = await this.prisma.complex.update({
+      where: {
+        business_activity: {
+          id: business_activity_id,
+          user: {
+            id: user_id,
+          },
+        },
+        id,
+      },
+      data,
+    })
+    return ResponseMapper.update(account)
+  }
+
+  // async delete(id: string) {
+  //   await this.prisma.complex.delete({ where: { id } })
+  //   return ResponseMapper.delete()
+  // }
+}

src/modules/consumer/business-activities/complexes/dto/complex.dto.ts

@@ -0,0 +1,18 @@
+import { ApiProperty, PartialType } from '@nestjs/swagger'
+import { IsString } from 'class-validator'
+
+export class CreateComplexDto {
+  @IsString()
+  @ApiProperty({})
+  name: string
+
+  @IsString()
+  @ApiProperty({})
+  tax_id: string
+
+  @IsString()
+  @ApiProperty({})
+  address: string
+}
+
+export class UpdateComplexDto extends PartialType(CreateComplexDto) {}

src/modules/consumer/business-activities/complexes/poses/dto/pos.dto.ts

@@ -0,0 +1,39 @@
+import { POSStatus, POSType } from '@/generated/prisma/enums'
+import { ApiProperty, PartialType } from '@nestjs/swagger'
+import { IsEnum, IsOptional, IsString } from 'class-validator'
+
+export class CreatePosDto {
+  @IsString()
+  @ApiProperty({})
+  name: string
+
+  @IsString()
+  @ApiProperty({})
+  serial: string
+
+  // @IsString()
+  // @IsOptional()
+  // @ApiProperty({ required: false })
+  // model: string
+
+  @IsEnum(POSType)
+  @ApiProperty({ enum: POSType })
+  pos_type: POSType
+
+  @IsString()
+  @IsOptional()
+  @ApiProperty({})
+  device_id: string
+
+  @IsString()
+  @IsOptional()
+  @ApiProperty()
+  provider_id: string
+}
+
+export class UpdatePosDto extends PartialType(CreatePosDto) {
+  @IsEnum(POSStatus)
+  @IsOptional()
+  @ApiProperty({ enum: POSStatus })
+  status: POSStatus
+}

src/modules/consumer/business-activities/complexes/poses/poses.controller.ts

@@ -0,0 +1,49 @@
+import { TokenAccount } from '@/common/decorators/tokenInfo.decorator'
+import { Body, Controller, Get, Param, Patch, Post } from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+import { CreatePosDto, UpdatePosDto } from './dto/pos.dto'
+import { ComplexPosesService } from './poses.service'
+
+@ApiTags('ConsumerComplexPoses')
+@Controller('consumer/business_activities/:businessActivityId/complexes/:complexId/poses')
+export class ComplexPosesController {
+  constructor(private readonly service: ComplexPosesService) {}
+
+  @Get()
+  async findAll(
+    @TokenAccount('userId') userId: string,
+    @Param('businessActivityId') businessActivityId: string,
+    @Param('complexId') complexId: string,
+  ) {
+    return this.service.findAll(userId, businessActivityId, complexId)
+  }
+
+  @Get(':id')
+  async findOne(
+    @Param('businessActivityId') businessActivityId: string,
+    @Param('complexId') complexId: string,
+    @Param('id') id: string,
+  ) {
+    return this.service.findOne(businessActivityId, complexId, id)
+  }
+
+  @Post()
+  async create(@Param('complexId') complexId: string, @Body() data: CreatePosDto) {
+    return this.service.create(complexId, data)
+  }
+
+  @Patch(':id')
+  async update(
+    @Param('businessActivityId') businessActivityId: string,
+    @Param('complexId') complexId: string,
+    @Param('id') id: string,
+    @Body() data: UpdatePosDto,
+  ) {
+    return this.service.update(businessActivityId, complexId, id, data)
+  }
+
+  // @Delete(':id')
+  // async delete(@Param('id') id: string) {
+  //   return this.businessActivityAccountsService.delete(id)
+  // }
+}

src/modules/consumer/business-activities/complexes/poses/poses.module.ts

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

src/modules/consumer/business-activities/complexes/poses/poses.service.ts

@@ -0,0 +1,171 @@
+import { POSStatus } from '@/generated/prisma/enums'
+import { PosCreateInput, PosSelect } from '@/generated/prisma/models'
+import { PrismaService } from '@/prisma/prisma.service'
+import { Injectable } from '@nestjs/common'
+import { ResponseMapper } from 'common/response/response-mapper'
+import { CreatePosDto, UpdatePosDto } from './dto/pos.dto'
+
+@Injectable()
+export class ComplexPosesService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  defaultSelect = {
+    id: true,
+    name: true,
+    model: true,
+    serial: true,
+    status: true,
+    created_at: true,
+    pos_type: true,
+
+    provider: {
+      select: {
+        id: true,
+        name: true,
+      },
+    },
+    device: {
+      select: {
+        name: true,
+        id: true,
+        brand: {
+          select: {
+            id: true,
+            name: true,
+          },
+        },
+      },
+    },
+    complex: {
+      select: {
+        id: true,
+        name: true,
+        business_activity: {
+          select: {
+            id: true,
+            name: true,
+          },
+        },
+      },
+    },
+  } as PosSelect
+
+  defaultInsert = (data: CreatePosDto, complex_id: string) => {
+    const { device_id, provider_id, ...rest } = data
+
+    return {
+      ...rest,
+      complex: {
+        connect: {
+          id: complex_id,
+        },
+      },
+      provider: provider_id
+        ? {
+            connect: {
+              id: provider_id,
+            },
+          }
+        : undefined,
+      device: device_id
+        ? {
+            connect: {
+              id: device_id,
+            },
+          }
+        : undefined,
+    } as PosCreateInput
+  }
+
+  async findAll(user_id: string, business_activity_id: string, complex_id: string) {
+    const poses = await this.prisma.pos.findMany({
+      where: {
+        complex: {
+          id: complex_id,
+          business_activity: {
+            id: business_activity_id,
+            user_id,
+          },
+        },
+      },
+      select: this.defaultSelect,
+    })
+    console.log(poses)
+
+    return ResponseMapper.list(poses)
+  }
+
+  async findOne(business_activity_id: string, complex_id: string, id: string) {
+    const account = await this.prisma.pos.findUnique({
+      where: {
+        complex: {
+          id: complex_id,
+          business_activity: {
+            id: business_activity_id,
+          },
+        },
+        id,
+      },
+      select: this.defaultSelect,
+    })
+    return ResponseMapper.single(account)
+  }
+
+  async create(complex_id: string, data: CreatePosDto) {
+    const account = await this.prisma.pos.create({
+      data: {
+        ...this.defaultInsert(data, complex_id),
+        status: POSStatus.ACTIVE,
+      },
+    })
+    return ResponseMapper.create(account)
+  }
+
+  async update(
+    business_activity_id: string,
+    complex_id: string,
+    id: string,
+    data: UpdatePosDto,
+  ) {
+    const { device_id, provider_id, ...rest } = data
+    const account = await this.prisma.pos.update({
+      where: {
+        complex: {
+          id: complex_id,
+          business_activity: {
+            id: business_activity_id,
+          },
+        },
+        id,
+      },
+      data: {
+        complex: {
+          connect: {
+            id: complex_id,
+          },
+        },
+        provider: provider_id
+          ? {
+              connect: {
+                id: provider_id,
+              },
+            }
+          : undefined,
+        device: device_id
+          ? {
+              connect: {
+                id: device_id,
+              },
+            }
+          : undefined,
+        ...rest,
+      },
+    })
+    return ResponseMapper.update(account)
+  }
+
+  // async delete(id: string) {
+  //   await this.prisma.complex.delete({ where: { id } })
+  //   return ResponseMapper.delete()
+  // }
+}

src/modules/consumer/business-activities/dto/create-business-activities.dto.ts

@@ -0,0 +1,10 @@
+import { ApiProperty, PartialType } from '@nestjs/swagger'
+import { IsString } from 'class-validator'
+
+export class CreateBusinessActivityDto {
+  @IsString()
+  @ApiProperty({ required: true })
+  name: string
+}
+
+export class UpdateBusinessActivityDto extends PartialType(CreateBusinessActivityDto) {}

src/modules/consumer/consumer.controller.ts

@@ -0,0 +1,6 @@
+import { Controller } from '@nestjs/common'
+import { ApiTags } from '@nestjs/swagger'
+
+@ApiTags('Consumer')
+@Controller('consumer')
+export class ConsumerController {}

src/modules/consumer/consumer.guard.ts

@@ -0,0 +1,14 @@
+// import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common'
+// import { Observable } from 'rxjs'
+
+// @Injectable()
+// export class AdminGuard implements CanActivate {
+//   canActivate(
+//     _context: ExecutionContext,
+//   ): boolean | Promise<boolean> | Observable<boolean> {
+//     // Replace with real auth/permission checks (e.g., check JWT claims)
+//     const request = _context.switchToHttp().getRequest()
+//     const isAdminHeader = request.headers['x-admin']
+//     return isAdminHeader === 'true' || request.isAdminRequest === true
+//   }
+// }

src/modules/consumer/consumer.middleware.ts

@@ -0,0 +1,20 @@
+import { checkAndDecodeJwtToken } from '@/common/utils/jwt-user.util'
+import { AccountType } from '@/generated/prisma/enums'
+import { Injectable, NestMiddleware, UnauthorizedException } from '@nestjs/common'
+import { JwtService } from '@nestjs/jwt'
+import { NextFunction, Request, Response } from 'express'
+
+@Injectable()
+export class ConsumerMiddleware implements NestMiddleware {
+  constructor(private jwtService: JwtService) {}
+  use(req: Request, _res: Response, next: NextFunction) {
+    const decodedToken = checkAndDecodeJwtToken(req, this.jwtService)
+    if (decodedToken?.type === AccountType.CONSUMER) {
+      req.decodedToken = decodedToken
+
+      return next()
+    }
+
+    throw new UnauthorizedException('شما دسترسی لازم را ندارید.')
+  }
+}

src/modules/consumer/consumer.module.ts

@@ -0,0 +1,21 @@
+import { MiddlewareConsumer, Module, NestModule, RequestMethod } from '@nestjs/common'
+import { JwtService } from '@nestjs/jwt'
+import { ConsumerAccountsModule } from './accounts/accounts.module'
+import { ConsumerBusinessActivitiesModule } from './business-activities/business-activities.module'
+import { ConsumerController } from './consumer.controller'
+import { ConsumerMiddleware } from './consumer.middleware'
+
+@Module({
+  controllers: [ConsumerController],
+  imports: [ConsumerAccountsModule, ConsumerBusinessActivitiesModule],
+  providers: [JwtService],
+})
+export class ConsumerModule implements NestModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer.apply(ConsumerMiddleware).forRoutes({
+      path: '/consumer*path',
+      method: RequestMethod.ALL,
+      version: '1',
+    })
+  }
+}