feat: add response DTOs for various services across modules

- Created response DTOs for ConfigService, AppService, AuthService, CatalogsService, AccountsService, BusinessActivityComplexesService, ComplexPosesService, SalesInvoicesService, BusinessActivitiesService, ConsumerBusinessActivityGoodsService, and others.
- Implemented Create, FindAll, FindOne, and Update response types for services in consumer, partners, and POS modules.
- Added request DTOs for creating and updating goods in the consumer business activities module.
- Introduced filtering DTO for partner licenses.
- Enhanced response mapping for partner license activations.

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

@@ -2,6 +2,7 @@ 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'
+import type { AccountsServiceCreateResponseDto, AccountsServiceFindAllResponseDto, AccountsServiceFindOneResponseDto, AccountsServiceUpdateResponseDto } from './dto/accounts-response.dto'
 
 @ApiTags('AdminConsumerAccounts')
 @Controller('admin/consumers/:consumerId/accounts')
@@ -9,12 +10,12 @@ export class AccountsController {
   constructor(private readonly accountsService: AccountsService) {}
 
   @Get()
-  async findAll(@Param('consumerId') consumerId: string) {
+  async findAll(@Param('consumerId') consumerId: string): Promise<AccountsServiceFindAllResponseDto> {
     return this.accountsService.findAll(consumerId)
   }
 
   @Get(':id')
-  async findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string): Promise<AccountsServiceFindOneResponseDto> {
     return this.accountsService.findOne(id)
   }
 
@@ -22,12 +23,12 @@ export class AccountsController {
   async create(
     @Param('consumerId') consumerId: string,
     @Body() data: CreateConsumerAccountDto,
-  ) {
+  ): Promise<AccountsServiceCreateResponseDto> {
     return this.accountsService.create(consumerId, data)
   }
 
   @Patch(':id')
-  async update(@Param('id') id: string, @Body() data: UpdateAccountDto) {
+  async update(@Param('id') id: string, @Body() data: UpdateAccountDto): Promise<AccountsServiceUpdateResponseDto> {
     return this.accountsService.update(id, data)
   }
 

src/modules/admin/consumers/accounts/dto/accounts-response.dto.ts

@@ -0,0 +1,7 @@
+import type { AccountsService } from '../accounts.service'
+
+export type AccountsServiceCreateResponseDto = Awaited<ReturnType<AccountsService['create']>>
+export type AccountsServiceDeleteResponseDto = Awaited<ReturnType<AccountsService['delete']>>
+export type AccountsServiceFindAllResponseDto = Awaited<ReturnType<AccountsService['findAll']>>
+export type AccountsServiceFindOneResponseDto = Awaited<ReturnType<AccountsService['findOne']>>
+export type AccountsServiceUpdateResponseDto = Awaited<ReturnType<AccountsService['update']>>

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

@@ -1,17 +1,18 @@
 import { Controller, Get, Param } from '@nestjs/common'
 import { BusinessActivitiesService } from './business-activities.service'
+import type { BusinessActivitiesServiceFindAllResponseDto, BusinessActivitiesServiceFindOneResponseDto } from './dto/business-activities-response.dto'
 
 @Controller('admin/consumers/:consumerId/business_activities')
 export class BusinessActivitiesController {
   constructor(private readonly businessActivitiesService: BusinessActivitiesService) {}
 
   @Get()
-  async findAll(@Param('consumerId') consumerId: string) {
+  async findAll(@Param('consumerId') consumerId: string): Promise<BusinessActivitiesServiceFindAllResponseDto> {
     return this.businessActivitiesService.findAll(consumerId)
   }
 
   @Get(':id')
-  async findOne(@Param('consumerId') consumerId: string, @Param('id') id: string) {
+  async findOne(@Param('consumerId') consumerId: string, @Param('id') id: string): Promise<BusinessActivitiesServiceFindOneResponseDto> {
     return this.businessActivitiesService.findOne(consumerId, id)
   }
 

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

@@ -1,6 +1,7 @@
 import { Controller, Get, Param } from '@nestjs/common'
 import { ApiTags } from '@nestjs/swagger'
 import { BusinessActivityComplexesService } from './complexes.service'
+import type { BusinessActivityComplexesServiceFindAllResponseDto, BusinessActivityComplexesServiceFindOneResponseDto } from './dto/complexes-response.dto'
 
 @ApiTags('AdminBusinessActivityComplexes')
 @Controller(
@@ -13,7 +14,7 @@ export class BusinessActivityComplexesController {
   async findAll(
     @Param('consumerId') consumerId: string,
     @Param('businessActivityId') businessActivityId: string,
-  ) {
+  ): Promise<BusinessActivityComplexesServiceFindAllResponseDto> {
     return this.service.findAll(consumerId, businessActivityId)
   }
 
@@ -22,7 +23,7 @@ export class BusinessActivityComplexesController {
     @Param('consumerId') consumerId: string,
     @Param('businessActivityId') businessActivityId: string,
     @Param('id') id: string,
-  ) {
+  ): Promise<BusinessActivityComplexesServiceFindOneResponseDto> {
     return this.service.findOne(consumerId, businessActivityId, id)
   }
 

src/modules/admin/consumers/business-activities/complexes/dto/complexes-response.dto.ts

@@ -0,0 +1,4 @@
+import type { BusinessActivityComplexesService } from '../complexes.service'
+
+export type BusinessActivityComplexesServiceFindAllResponseDto = Awaited<ReturnType<BusinessActivityComplexesService['findAll']>>
+export type BusinessActivityComplexesServiceFindOneResponseDto = Awaited<ReturnType<BusinessActivityComplexesService['findOne']>>

src/modules/admin/consumers/business-activities/complexes/poses/dto/poses-response.dto.ts

@@ -0,0 +1,4 @@
+import type { ComplexPosesService } from '../poses.service'
+
+export type ComplexPosesServiceFindAllResponseDto = Awaited<ReturnType<ComplexPosesService['findAll']>>
+export type ComplexPosesServiceFindOneResponseDto = Awaited<ReturnType<ComplexPosesService['findOne']>>

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

@@ -1,6 +1,7 @@
 import { Controller, Get, Param } from '@nestjs/common'
 import { ApiTags } from '@nestjs/swagger'
 import { ComplexPosesService } from './poses.service'
+import type { ComplexPosesServiceFindAllResponseDto, ComplexPosesServiceFindOneResponseDto } from './dto/poses-response.dto'
 
 @ApiTags('AdminComplexPoses')
 @Controller('admin/business_activities/:businessActivityId/complexes/:complexId/poses')
@@ -11,7 +12,7 @@ export class ComplexPosesController {
   async findAll(
     @Param('businessActivityId') businessActivityId: string,
     @Param('complexId') complexId: string,
-  ) {
+  ): Promise<ComplexPosesServiceFindAllResponseDto> {
     return this.service.findAll(businessActivityId, complexId)
   }
 
@@ -20,7 +21,7 @@ export class ComplexPosesController {
     @Param('businessActivityId') businessActivityId: string,
     @Param('complexId') complexId: string,
     @Param('id') id: string,
-  ) {
+  ): Promise<ComplexPosesServiceFindOneResponseDto> {
     return this.service.findOne(businessActivityId, complexId, id)
   }
 

src/modules/admin/consumers/business-activities/dto/business-activities-response.dto.ts

@@ -0,0 +1,4 @@
+import type { BusinessActivitiesService } from '../business-activities.service'
+
+export type BusinessActivitiesServiceFindAllResponseDto = Awaited<ReturnType<BusinessActivitiesService['findAll']>>
+export type BusinessActivitiesServiceFindOneResponseDto = Awaited<ReturnType<BusinessActivitiesService['findOne']>>

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

@@ -1,17 +1,18 @@
 import { Controller, Get, Param } from '@nestjs/common'
 import { AdminConsumersService } from './consumers.service'
+import type { AdminConsumersServiceFindAllResponseDto, AdminConsumersServiceFindOneResponseDto } from './dto/consumers-response.dto'
 
 @Controller('admin/consumers')
 export class AdminUsersController {
   constructor(private readonly usersService: AdminConsumersService) {}
 
   @Get()
-  async findAll() {
+  async findAll(): Promise<AdminConsumersServiceFindAllResponseDto> {
     return this.usersService.findAll()
   }
 
   @Get(':id')
-  async findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string): Promise<AdminConsumersServiceFindOneResponseDto> {
     return this.usersService.findOne(id)
   }
 

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

@@ -1,5 +1,6 @@
+import { QUERY_CONSTANTS } from '@/common/queryConstants'
+import consumer_mappersUtil from '@/common/utils/mappers/consumer_mappers.util'
 import { ConsumerSelect } from '@/generated/prisma/models'
-import mapConsumerWithLicenseUtil from '@/modules/consumer/utils/mapConsumerWithLicense.util'
 import { PrismaService } from '@/prisma/prisma.service'
 import { Injectable } from '@nestjs/common'
 import { ResponseMapper } from 'common/response/response-mapper'
@@ -8,41 +9,41 @@ import { ResponseMapper } from 'common/response/response-mapper'
 export class AdminConsumersService {
   constructor(private readonly prisma: PrismaService) {}
 
+  private readonly now = new Date()
+
   private readonly defaultSelect: ConsumerSelect = {
     id: true,
-    first_name: true,
-    last_name: true,
-    mobile_number: true,
+    type: true,
+    ...QUERY_CONSTANTS.CONSUMER.infoSelect,
     status: true,
-    partner: {
+
+    created_at: true,
+    _count: {
       select: {
-        id: true,
-        name: true,
-        code: true,
+        business_activities: {
+          where: {
+            license_activation: {
+              OR: [
+                {
+                  expires_at: {
+                    gt: this.now,
+                  },
+                },
+                {
+                  license_renews: {
+                    some: {
+                      expires_at: {
+                        gt: this.now,
+                      },
+                    },
+                  },
+                },
+              ],
+            },
+          },
+        },
       },
     },
-    created_at: true,
-    // activation: {
-    //   select: {
-    //     id: true,
-    //     starts_at: true,
-    //     expires_at: true,
-    //     license: {
-    //       select: {
-    //         charge_transaction: {
-    //           select: {
-    //             partner: {
-    //               select: {
-    //                 id: true,
-    //                 name: true,
-    //               },
-    //             },
-    //           },
-    //         },
-    //       },
-    //     },
-    //   },
-    // },
   }
 
   async findAll() {
@@ -53,7 +54,7 @@ export class AdminConsumersService {
       this.prisma.consumer.count(),
     ])
 
-    return ResponseMapper.paginate(consumers.map(mapConsumerWithLicenseUtil), { total })
+    return ResponseMapper.paginate(consumers.map(consumer_mappersUtil), { total })
   }
 
   async findOne(id: string) {
@@ -62,7 +63,7 @@ export class AdminConsumersService {
       select: this.defaultSelect,
     })
 
-    return ResponseMapper.single(mapConsumerWithLicenseUtil(consumer))
+    return ResponseMapper.single(consumer_mappersUtil(consumer))
   }
 
   // async create(data: CreateConsumerDto) {
@@ -72,7 +73,7 @@ export class AdminConsumersService {
   //   const { username, password, partner_id, ...rest } = data
   //   const dataToCreate: ConsumerCreateInput = {
   //     ...rest,
-  //     consumer_accounts: {
+  //     accounts: {
   //       create: {
   //         role: ConsumerRole.OWNER,
   //         account: {

src/modules/admin/consumers/dto/consumers-response.dto.ts

@@ -0,0 +1,4 @@
+import type { AdminConsumersService } from '../consumers.service'
+
+export type AdminConsumersServiceFindAllResponseDto = Awaited<ReturnType<AdminConsumersService['findAll']>>
+export type AdminConsumersServiceFindOneResponseDto = Awaited<ReturnType<AdminConsumersService['findOne']>>

src/modules/admin/consumers/licenses/dto/licenses-response.dto.ts

@@ -0,0 +1,3 @@
+import type { LicensesService } from '../licenses.service'
+
+export type LicensesServiceFindAllResponseDto = Awaited<ReturnType<LicensesService['findAll']>>

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

@@ -1,6 +1,7 @@
 import { Controller, Get, Param } from '@nestjs/common'
 import { ApiTags } from '@nestjs/swagger'
 import { LicensesService } from './licenses.service'
+import type { LicensesServiceFindAllResponseDto } from './dto/licenses-response.dto'
 
 @ApiTags('AdminConsumerAccounts')
 @Controller('admin/consumers/:consumerId/licenses')
@@ -8,7 +9,7 @@ export class LicensesController {
   constructor(private readonly service: LicensesService) {}
 
   @Get()
-  async findAll(@Param('consumerId') consumerId: string) {
+  async findAll(@Param('consumerId') consumerId: string): Promise<LicensesServiceFindAllResponseDto> {
     return this.service.findAll(consumerId)
   }
 

src/modules/admin/device-brands/device-brands.controller.ts

@@ -2,33 +2,34 @@ import { Body, Controller, Delete, Get, Param, Patch, Post } from '@nestjs/commo
 import { DeviceBrandsService } from './device-brands.service'
 import { CreateDeviceBrandDto } from './dto/create-device-brand.dto'
 import { UpdateDeviceBrandDto } from './dto/update-device-brand.dto'
+import type { DeviceBrandsServiceCreateResponseDto, DeviceBrandsServiceDeleteResponseDto, DeviceBrandsServiceFindAllResponseDto, DeviceBrandsServiceFindOneResponseDto, DeviceBrandsServiceUpdateResponseDto } from './dto/device-brands-response.dto'
 
 @Controller('admin/device_brands')
 export class DeviceBrandsController {
   constructor(private readonly deviceBrandsService: DeviceBrandsService) {}
 
   @Get()
-  async findAll() {
+  async findAll(): Promise<DeviceBrandsServiceFindAllResponseDto> {
     return this.deviceBrandsService.findAll()
   }
 
   @Get(':id')
-  async findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string): Promise<DeviceBrandsServiceFindOneResponseDto> {
     return this.deviceBrandsService.findOne(id)
   }
 
   @Post()
-  async create(@Body() data: CreateDeviceBrandDto) {
+  async create(@Body() data: CreateDeviceBrandDto): Promise<DeviceBrandsServiceCreateResponseDto> {
     return this.deviceBrandsService.create(data)
   }
 
   @Patch(':id')
-  async update(@Param('id') id: string, @Body() data: UpdateDeviceBrandDto) {
+  async update(@Param('id') id: string, @Body() data: UpdateDeviceBrandDto): Promise<DeviceBrandsServiceUpdateResponseDto> {
     return this.deviceBrandsService.update(id, data)
   }
 
   @Delete(':id')
-  async delete(@Param('id') id: string) {
+  async delete(@Param('id') id: string): Promise<DeviceBrandsServiceDeleteResponseDto> {
     return this.deviceBrandsService.delete(id)
   }
 }

src/modules/admin/device-brands/dto/device-brands-response.dto.ts

@@ -0,0 +1,7 @@
+import type { DeviceBrandsService } from '../device-brands.service'
+
+export type DeviceBrandsServiceCreateResponseDto = Awaited<ReturnType<DeviceBrandsService['create']>>
+export type DeviceBrandsServiceDeleteResponseDto = Awaited<ReturnType<DeviceBrandsService['delete']>>
+export type DeviceBrandsServiceFindAllResponseDto = Awaited<ReturnType<DeviceBrandsService['findAll']>>
+export type DeviceBrandsServiceFindOneResponseDto = Awaited<ReturnType<DeviceBrandsService['findOne']>>
+export type DeviceBrandsServiceUpdateResponseDto = Awaited<ReturnType<DeviceBrandsService['update']>>

src/modules/admin/devices/devices.controller.ts

@@ -1,33 +1,34 @@
 import { Body, Controller, Delete, Get, Param, Patch, Post } from '@nestjs/common'
 import { DevicesService } from './devices.service'
 import { CreateDeviceDto, UpdateDeviceDto } from './dto/device.dto'
+import type { DevicesServiceCreateResponseDto, DevicesServiceDeleteResponseDto, DevicesServiceFindAllResponseDto, DevicesServiceFindOneResponseDto, DevicesServiceUpdateResponseDto } from './dto/devices-response.dto'
 
 @Controller('admin/devices')
 export class DevicesController {
   constructor(private readonly devicesService: DevicesService) {}
 
   @Get()
-  async findAll() {
+  async findAll(): Promise<DevicesServiceFindAllResponseDto> {
     return this.devicesService.findAll()
   }
 
   @Get(':id')
-  async findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string): Promise<DevicesServiceFindOneResponseDto> {
     return this.devicesService.findOne(id)
   }
 
   @Post()
-  async create(@Body() data: CreateDeviceDto) {
+  async create(@Body() data: CreateDeviceDto): Promise<DevicesServiceCreateResponseDto> {
     return this.devicesService.create(data)
   }
 
   @Patch(':id')
-  async update(@Param('id') id: string, @Body() data: UpdateDeviceDto) {
+  async update(@Param('id') id: string, @Body() data: UpdateDeviceDto): Promise<DevicesServiceUpdateResponseDto> {
     return this.devicesService.update(id, data)
   }
 
   @Delete(':id')
-  async delete(@Param('id') id: string) {
+  async delete(@Param('id') id: string): Promise<DevicesServiceDeleteResponseDto> {
     return this.devicesService.delete(id)
   }
 }

src/modules/admin/devices/dto/devices-response.dto.ts

@@ -0,0 +1,7 @@
+import type { DevicesService } from '../devices.service'
+
+export type DevicesServiceCreateResponseDto = Awaited<ReturnType<DevicesService['create']>>
+export type DevicesServiceDeleteResponseDto = Awaited<ReturnType<DevicesService['delete']>>
+export type DevicesServiceFindAllResponseDto = Awaited<ReturnType<DevicesService['findAll']>>
+export type DevicesServiceFindOneResponseDto = Awaited<ReturnType<DevicesService['findOne']>>
+export type DevicesServiceUpdateResponseDto = Awaited<ReturnType<DevicesService['update']>>

src/modules/admin/guilds/dto/guilds-response.dto.ts

@@ -0,0 +1,6 @@
+import type { GuildsService } from '../guilds.service'
+
+export type GuildsServiceCreateResponseDto = Awaited<ReturnType<GuildsService['create']>>
+export type GuildsServiceFindAllResponseDto = Awaited<ReturnType<GuildsService['findAll']>>
+export type GuildsServiceFindOneResponseDto = Awaited<ReturnType<GuildsService['findOne']>>
+export type GuildsServiceUpdateResponseDto = Awaited<ReturnType<GuildsService['update']>>

src/modules/admin/guilds/good-categories/dto/good-categories-response.dto.ts

@@ -0,0 +1,6 @@
+import type { GoodCategoriesService } from '../good-categories.service'
+
+export type GoodCategoriesServiceCreateResponseDto = Awaited<ReturnType<GoodCategoriesService['create']>>
+export type GoodCategoriesServiceFindAllResponseDto = Awaited<ReturnType<GoodCategoriesService['findAll']>>
+export type GoodCategoriesServiceFindOneResponseDto = Awaited<ReturnType<GoodCategoriesService['findOne']>>
+export type GoodCategoriesServiceUpdateResponseDto = Awaited<ReturnType<GoodCategoriesService['update']>>

src/modules/admin/guilds/goods/dto/goods-response.dto.ts

@@ -0,0 +1,6 @@
+import type { GoodsService } from '../goods.service'
+
+export type GoodsServiceCreateResponseDto = Awaited<ReturnType<GoodsService['create']>>
+export type GoodsServiceFindAllResponseDto = Awaited<ReturnType<GoodsService['findAll']>>
+export type GoodsServiceFindOneResponseDto = Awaited<ReturnType<GoodsService['findOne']>>
+export type GoodsServiceUpdateResponseDto = Awaited<ReturnType<GoodsService['update']>>

src/modules/admin/guilds/goods/images/dto/images-response.dto.ts

@@ -0,0 +1,6 @@
+import type { GuildGoodImagesService } from '../images.service'
+
+export type GuildGoodImagesServiceUploadFileResponseDto = Awaited<ReturnType<GuildGoodImagesService['uploadFile']>>
+export type GuildGoodImagesControllerUploadImageResponseDto = {
+  url: GuildGoodImagesServiceUploadFileResponseDto
+}

src/modules/admin/guilds/goods/images/images.controller.ts

@@ -11,6 +11,7 @@ import {
 import { FileInterceptor } from '@nestjs/platform-express'
 import { ApiBody, ApiConsumes } from '@nestjs/swagger'
 import { GuildGoodImagesService } from './images.service'
+import type { GuildGoodImagesControllerUploadImageResponseDto } from './dto/images-response.dto'
 
 @Controller('admin/guilds/:guildId/goods/:goodId/images')
 export class GuildGoodImagesController {
@@ -32,7 +33,7 @@ export class GuildGoodImagesController {
     @Param('guildId') guildId: string,
     @Param('goodId') goodId: string,
     @UploadedFile() file: Express.Multer.File,
-  ) {
+  ): Promise<GuildGoodImagesControllerUploadImageResponseDto> {
     if (!file) {
       throw new BadRequestException('فایل را وارد کنید')
     }

src/modules/admin/guilds/guilds.controller.ts

@@ -3,6 +3,12 @@ import { ApiTags } from '@nestjs/swagger'
 import { CreateGuildDto } from './dto/create-guild.dto'
 import { UpdateGuildDto } from './dto/update-guild.dto'
 import { GuildsService } from './guilds.service'
+import type {
+  GuildsServiceCreateResponseDto,
+  GuildsServiceFindAllResponseDto,
+  GuildsServiceFindOneResponseDto,
+  GuildsServiceUpdateResponseDto,
+} from './dto/guilds-response.dto'
 
 @ApiTags('guilds')
 @Controller('admin/guilds')
@@ -10,22 +16,25 @@ export class GuildsController {
   constructor(private readonly guildsService: GuildsService) {}
 
   @Get()
-  async findAll() {
+  async findAll(): Promise<GuildsServiceFindAllResponseDto> {
     return this.guildsService.findAll()
   }
 
   @Get(':id')
-  async findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string): Promise<GuildsServiceFindOneResponseDto> {
     return this.guildsService.findOne(id)
   }
 
   @Post()
-  async create(@Body() data: CreateGuildDto) {
+  async create(@Body() data: CreateGuildDto): Promise<GuildsServiceCreateResponseDto> {
     return await this.guildsService.create(data)
   }
 
   @Patch(':id')
-  async update(@Param('id') id: string, @Body() data: UpdateGuildDto) {
+  async update(
+    @Param('id') id: string,
+    @Body() data: UpdateGuildDto,
+  ): Promise<GuildsServiceUpdateResponseDto> {
     return await this.guildsService.update(id, data)
   }
 

src/modules/admin/licenses/dto/licenses-response.dto.ts

@@ -0,0 +1,4 @@
+import type { PartnerLicensesService } from '../licenses.service'
+
+export type PartnerLicensesServiceFindAllResponseDto = Awaited<ReturnType<PartnerLicensesService['findAll']>>
+export type PartnerLicensesServiceFindOneResponseDto = Awaited<ReturnType<PartnerLicensesService['findOne']>>

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

@@ -1,17 +1,18 @@
 import { Controller, Get, Param } from '@nestjs/common'
 import { PartnerLicensesService } from './licenses.service'
+import type { PartnerLicensesServiceFindAllResponseDto, PartnerLicensesServiceFindOneResponseDto } from './dto/licenses-response.dto'
 
 @Controller('admin/licenses')
 export class LicensesController {
   constructor(private readonly licensesService: PartnerLicensesService) {}
 
   @Get()
-  async findAll() {
+  async findAll(): Promise<PartnerLicensesServiceFindAllResponseDto> {
     return this.licensesService.findAll()
   }
 
   @Get(':id')
-  async findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string): Promise<PartnerLicensesServiceFindOneResponseDto> {
     return this.licensesService.findOne(id)
   }
 

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

@@ -1,3 +1,5 @@
+import { QUERY_CONSTANTS } from '@/common/queryConstants'
+import consumer_mappersUtil from '@/common/utils/mappers/consumer_mappers.util'
 import { LicenseActivationSelect } from '@/generated/prisma/models'
 import { PrismaService } from '@/prisma/prisma.service'
 import { Injectable } from '@nestjs/common'
@@ -18,8 +20,7 @@ export class PartnerLicensesService {
         consumer: {
           select: {
             id: true,
-            first_name: true,
-            last_name: true,
+            ...QUERY_CONSTANTS.CONSUMER.infoSelect,
           },
         },
       },
@@ -49,7 +50,7 @@ export class PartnerLicensesService {
   }
 
   async findAll(page = 1, perPage = 10) {
-    const [licenses, total] = await this.prisma.$transaction([
+    const [activatedLicenses, total] = await this.prisma.$transaction([
       this.prisma.licenseActivation.findMany({
         select: this.licenseDefaultSelect,
         skip: (page - 1) * perPage,
@@ -58,7 +59,22 @@ export class PartnerLicensesService {
       this.prisma.licenseActivation.count(),
     ])
 
-    return ResponseMapper.paginate(licenses, {
+    const mappedLicenses = activatedLicenses.map(license => {
+      const { business_activity, ...rest } = license
+      const { consumer, ...businessActivityRest } = business_activity as any
+
+      const mappedConsumer = consumer_mappersUtil(consumer)
+
+      return {
+        ...rest,
+        business_activity: {
+          ...businessActivityRest,
+          mappedConsumer,
+        },
+      }
+    })
+
+    return ResponseMapper.paginate(activatedLicenses, {
       total,
       page,
       perPage,

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

@@ -1,6 +1,7 @@
 import { Controller, Get, Param } from '@nestjs/common'
 import { ApiTags } from '@nestjs/swagger'
 import { PartnerActivatedLicensesService } from './activatedLicenses.service'
+import type { PartnerActivatedLicensesServiceFindAllResponseDto } from './dto/activatedLicenses-response.dto'
 
 @ApiTags('AdminPartnerActivatedLicenses')
 @Controller('admin/partners/:partnerId/activated-licenses')
@@ -8,7 +9,7 @@ export class PartnerLicensesController {
   constructor(private readonly service: PartnerActivatedLicensesService) {}
 
   @Get()
-  async findAll(@Param('partnerId') partnerId: string) {
+  async findAll(@Param('partnerId') partnerId: string): Promise<PartnerActivatedLicensesServiceFindAllResponseDto> {
     return this.service.findAll(partnerId)
   }
 

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

@@ -1,3 +1,5 @@
+import { QUERY_CONSTANTS } from '@/common/queryConstants'
+import consumer_mappersUtil from '@/common/utils/mappers/consumer_mappers.util'
 import { LicenseActivationWhereInput } from '@/generated/prisma/models'
 import { PrismaService } from '@/prisma/prisma.service'
 import { Injectable } from '@nestjs/common'
@@ -15,7 +17,7 @@ export class PartnerActivatedLicensesService {
         },
       },
     }
-    const [licenses, total] = await this.prisma.$transaction(async tx => [
+    const [activatedLicense, total] = await this.prisma.$transaction(async tx => [
       await tx.licenseActivation.findMany({
         where: defaultWhere,
         skip: (page - 1) * perPage,
@@ -38,8 +40,7 @@ export class PartnerActivatedLicensesService {
               consumer: {
                 select: {
                   id: true,
-                  first_name: true,
-                  last_name: true,
+                  ...QUERY_CONSTANTS.CONSUMER.infoSelect,
                 },
               },
             },
@@ -51,8 +52,11 @@ export class PartnerActivatedLicensesService {
       }),
     ])
 
-    const mappedLicenses = licenses.map(license => {
+    const mappedLicenses = activatedLicense.map(license => {
       const { account_allocations, business_activity, ...rest } = license
+      const { consumer, ...businessActivityRest } = business_activity
+
+      const mappedConsumer = consumer_mappersUtil(consumer)
 
       return {
         ...rest,
@@ -64,7 +68,7 @@ export class PartnerActivatedLicensesService {
         },
         business_activity: {
           ...business_activity,
-          consumer_name: `${business_activity.consumer.first_name} ${business_activity.consumer.last_name}`,
+          consumer_name: mappedConsumer.name,
         },
       }
     })

src/modules/admin/partners/activatedLicenses/dto/activatedLicenses-response.dto.ts

@@ -0,0 +1,4 @@
+import type { PartnerActivatedLicensesService } from '../activatedLicenses.service'
+
+export type PartnerActivatedLicensesServiceDeleteResponseDto = Awaited<ReturnType<PartnerActivatedLicensesService['delete']>>
+export type PartnerActivatedLicensesServiceFindAllResponseDto = Awaited<ReturnType<PartnerActivatedLicensesService['findAll']>>

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

@@ -1,6 +1,7 @@
 import { Controller, Get, Param } from '@nestjs/common'
 import { ApiTags } from '@nestjs/swagger'
 import { PartnerAllocatedAccountsService } from './allocatedAccounts.service'
+import type { PartnerAllocatedAccountsServiceFindAllResponseDto } from './dto/allocatedAccounts-response.dto'
 
 @ApiTags('AdminPartnerAllocatedAccounts')
 @Controller('admin/partners/:partnerId/allocated-accounts')
@@ -8,7 +9,7 @@ export class PartnerAllocatedAccountsController {
   constructor(private readonly service: PartnerAllocatedAccountsService) {}
 
   @Get()
-  async findAll(@Param('partnerId') partnerId: string) {
+  async findAll(@Param('partnerId') partnerId: string): Promise<PartnerAllocatedAccountsServiceFindAllResponseDto> {
     return this.service.findAll(partnerId)
   }
 }

src/modules/admin/partners/allocatedAccounts/dto/allocatedAccounts-response.dto.ts

@@ -0,0 +1,3 @@
+import type { PartnerAllocatedAccountsService } from '../allocatedAccounts.service'
+
+export type PartnerAllocatedAccountsServiceFindAllResponseDto = Awaited<ReturnType<PartnerAllocatedAccountsService['findAll']>>

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

@@ -2,6 +2,7 @@ import { Body, Controller, Get, Param, Post } from '@nestjs/common'
 import { ApiTags } from '@nestjs/swagger'
 import { PartnerAccountChargeTransactionService } from './chargeAccountQuotaTransactions.service'
 import { ChargeAccountQuotaDto } from './dto/chargeAccountQuotaTransactions.dto'
+import type { PartnerAccountChargeTransactionServiceCreateResponseDto, PartnerAccountChargeTransactionServiceFindAllResponseDto, PartnerAccountChargeTransactionServiceFindOneResponseDto } from './dto/chargeAccountQuotaTransactions-response.dto'
 
 @ApiTags('Admin Partner Account Charge')
 @Controller('admin/partners/:partnerId/charge-account-transactions')
@@ -9,12 +10,12 @@ export class PartnerAccountChargeTransactionController {
   constructor(private readonly service: PartnerAccountChargeTransactionService) {}
 
   @Get()
-  async findAll(@Param('partnerId') partnerId: string) {
+  async findAll(@Param('partnerId') partnerId: string): Promise<PartnerAccountChargeTransactionServiceFindAllResponseDto> {
     return this.service.findAll(partnerId)
   }
 
   @Get(':id')
-  async findOne(@Param('partnerId') partnerId: string, @Param('id') id: string) {
+  async findOne(@Param('partnerId') partnerId: string, @Param('id') id: string): Promise<PartnerAccountChargeTransactionServiceFindOneResponseDto> {
     return this.service.findOne(partnerId, id)
   }
 
@@ -22,7 +23,7 @@ export class PartnerAccountChargeTransactionController {
   async create(
     @Param('partnerId') partnerId: string,
     @Body() data: ChargeAccountQuotaDto,
-  ) {
+  ): Promise<PartnerAccountChargeTransactionServiceCreateResponseDto> {
     return this.service.create(partnerId, data)
   }
 

src/modules/admin/partners/chargeAccountQoutaTransactions/dto/chargeAccountQuotaTransactions-response.dto.ts

@@ -0,0 +1,5 @@
+import type { PartnerAccountChargeTransactionService } from '../chargeAccountQuotaTransactions.service'
+
+export type PartnerAccountChargeTransactionServiceCreateResponseDto = Awaited<ReturnType<PartnerAccountChargeTransactionService['create']>>
+export type PartnerAccountChargeTransactionServiceFindAllResponseDto = Awaited<ReturnType<PartnerAccountChargeTransactionService['findAll']>>
+export type PartnerAccountChargeTransactionServiceFindOneResponseDto = Awaited<ReturnType<PartnerAccountChargeTransactionService['findOne']>>

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

@@ -2,6 +2,7 @@ import { Body, Controller, Get, Param, Post } from '@nestjs/common'
 import { ApiTags } from '@nestjs/swagger'
 import { PartnerLicenseChargeTransactionService } from './chargedLicenseTransactions.service'
 import { ChargeLicenseDto } from './dto/chargedLicenseTransactions.dto'
+import type { PartnerLicenseChargeTransactionServiceCreateResponseDto, PartnerLicenseChargeTransactionServiceFindAllResponseDto, PartnerLicenseChargeTransactionServiceFindOneResponseDto } from './dto/chargedLicenseTransactions-response.dto'
 
 @ApiTags('AdminPartnerLicenseChargeTransaction')
 @Controller('admin/partners/:partnerId/charge-license-transactions')
@@ -9,17 +10,17 @@ export class PartnerLicenseChargeTransactionController {
   constructor(private readonly service: PartnerLicenseChargeTransactionService) {}
 
   @Get()
-  async findAll(@Param('partnerId') partnerId: string) {
+  async findAll(@Param('partnerId') partnerId: string): Promise<PartnerLicenseChargeTransactionServiceFindAllResponseDto> {
     return this.service.findAll(partnerId)
   }
 
   @Get(':id')
-  async findOne(@Param('partnerId') partnerId: string, @Param('id') id: string) {
+  async findOne(@Param('partnerId') partnerId: string, @Param('id') id: string): Promise<PartnerLicenseChargeTransactionServiceFindOneResponseDto> {
     return this.service.findOne(partnerId, id)
   }
 
   @Post()
-  async create(@Param('partnerId') partnerId: string, @Body() data: ChargeLicenseDto) {
+  async create(@Param('partnerId') partnerId: string, @Body() data: ChargeLicenseDto): Promise<PartnerLicenseChargeTransactionServiceCreateResponseDto> {
     return this.service.create(partnerId, data)
   }
 

src/modules/admin/partners/chargedLicenseTransactions/dto/chargedLicenseTransactions-response.dto.ts

@@ -0,0 +1,5 @@
+import type { PartnerLicenseChargeTransactionService } from '../chargedLicenseTransactions.service'
+
+export type PartnerLicenseChargeTransactionServiceCreateResponseDto = Awaited<ReturnType<PartnerLicenseChargeTransactionService['create']>>
+export type PartnerLicenseChargeTransactionServiceFindAllResponseDto = Awaited<ReturnType<PartnerLicenseChargeTransactionService['findAll']>>
+export type PartnerLicenseChargeTransactionServiceFindOneResponseDto = Awaited<ReturnType<PartnerLicenseChargeTransactionService['findOne']>>

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

@@ -23,6 +23,10 @@ export class CreatePartnerDto {
   @IsString()
   @ApiProperty({ required: true })
   password: string
+
+  @IsOptional()
+  @ApiProperty({ required: false, type: 'string', format: 'binary' })
+  logo?: any
 }
 
 export class UpdatePartnerDto extends PartialType(CreatePartnerDto) {

src/modules/admin/partners/dto/partners-response.dto.ts

@@ -0,0 +1,7 @@
+import type { PartnersService } from '../partners.service'
+
+export type PartnersServiceCreateResponseDto = Awaited<ReturnType<PartnersService['create']>>
+export type PartnersServiceDeleteResponseDto = Awaited<ReturnType<PartnersService['delete']>>
+export type PartnersServiceFindAllResponseDto = Awaited<ReturnType<PartnersService['findAll']>>
+export type PartnersServiceFindOneResponseDto = Awaited<ReturnType<PartnersService['findOne']>>
+export type PartnersServiceUpdateResponseDto = Awaited<ReturnType<PartnersService['update']>>

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

@@ -1,18 +1,19 @@
 import { Body, Controller, Delete, Get, Param, Patch, Post } from '@nestjs/common'
 import { AccountsService } from './accounts.service'
 import { CreatePartnerAccountDto, UpdateAccountDto } from './dto/account.dto'
+import type { AccountsServiceCreateResponseDto, AccountsServiceDeleteResponseDto, AccountsServiceFindAllResponseDto, AccountsServiceFindOneResponseDto, AccountsServiceUpdateResponseDto } from './dto/accounts-response.dto'
 
 @Controller('admin/partners/:partnerId/accounts')
 export class AccountsController {
   constructor(private readonly accountsService: AccountsService) {}
 
   @Get()
-  async findAll(@Param('partnerId') partnerId: string) {
+  async findAll(@Param('partnerId') partnerId: string): Promise<AccountsServiceFindAllResponseDto> {
     return this.accountsService.findAll(partnerId)
   }
 
   @Get(':id')
-  async findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string): Promise<AccountsServiceFindOneResponseDto> {
     return this.accountsService.findOne(id)
   }
 
@@ -20,17 +21,17 @@ export class AccountsController {
   async create(
     @Param('partnerId') partnerId: string,
     @Body() data: CreatePartnerAccountDto,
-  ) {
+  ): Promise<AccountsServiceCreateResponseDto> {
     return this.accountsService.create(partnerId, data)
   }
 
   @Patch(':id')
-  async update(@Param('id') id: string, @Body() data: UpdateAccountDto) {
+  async update(@Param('id') id: string, @Body() data: UpdateAccountDto): Promise<AccountsServiceUpdateResponseDto> {
     return this.accountsService.update(id, data)
   }
 
   @Delete(':id')
-  async delete(@Param('id') id: string) {
+  async delete(@Param('id') id: string): Promise<AccountsServiceDeleteResponseDto> {
     return this.accountsService.delete(id)
   }
 }

src/modules/admin/partners/partnerAccounts/dto/accounts-response.dto.ts

@@ -0,0 +1,7 @@
+import type { AccountsService } from '../accounts.service'
+
+export type AccountsServiceCreateResponseDto = Awaited<ReturnType<AccountsService['create']>>
+export type AccountsServiceDeleteResponseDto = Awaited<ReturnType<AccountsService['delete']>>
+export type AccountsServiceFindAllResponseDto = Awaited<ReturnType<AccountsService['findAll']>>
+export type AccountsServiceFindOneResponseDto = Awaited<ReturnType<AccountsService['findOne']>>
+export type AccountsServiceUpdateResponseDto = Awaited<ReturnType<AccountsService['update']>>

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

@@ -1,4 +1,16 @@
-import { Body, Controller, Get, Param, Patch, Post } from '@nestjs/common'
+import { multerImageOptions } from '@/multer.config'
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  Patch,
+  Post,
+  UploadedFile,
+  UseInterceptors,
+} from '@nestjs/common'
+import { FileInterceptor } from '@nestjs/platform-express'
+import { ApiBody, ApiConsumes } from '@nestjs/swagger'
 import { CreatePartnerDto, UpdatePartnerDto } from './dto/partner.dto'
 import { PartnersService } from './partners.service'
 
@@ -7,23 +19,47 @@ export class PartnersController {
   constructor(private readonly partnersService: PartnersService) {}
 
   @Get()
-  async findAll() {
+  async findAll(): Promise<PartnersServiceFindAllResponseDto> {
     return this.partnersService.findAll()
   }
 
   @Get(':id')
-  async findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string): Promise<PartnersServiceFindOneResponseDto> {
     return this.partnersService.findOne(id)
   }
 
   @Post()
-  async create(@Body() data: CreatePartnerDto) {
-    return this.partnersService.create(data)
+  @UseInterceptors(FileInterceptor('logo', multerImageOptions))
+  @ApiConsumes('multipart/form-data')
+  @ApiBody({
+    schema: {
+      type: 'object',
+      properties: {
+        logo: { type: 'string', format: 'binary' },
+      },
+    },
+  })
+  async create(@Body() data: CreatePartnerDto, @UploadedFile() logo: any): Promise<PartnersServiceCreateResponseDto> {
+    return this.partnersService.create(data, logo)
   }
 
   @Patch(':id')
-  async update(@Param('id') id: string, @Body() data: UpdatePartnerDto) {
-    return this.partnersService.update(id, data)
+  @UseInterceptors(FileInterceptor('logo', multerImageOptions))
+  @ApiConsumes('multipart/form-data')
+  @ApiBody({
+    schema: {
+      type: 'object',
+      properties: {
+        logo: { type: 'string', format: 'binary' },
+      },
+    },
+  })
+  async update(
+    @Param('id') id: string,
+    @Body() data: UpdatePartnerDto,
+    @UploadedFile() logo: Express.Multer.File,
+  ): Promise<PartnersServiceUpdateResponseDto> {
+    return this.partnersService.update(id, data, logo)
   }
 
   // @Delete(':id')
@@ -31,3 +67,5 @@ export class PartnersController {
   //   return this.partnersService.delete(id)
   // }
 }
+
+import type { PartnersServiceCreateResponseDto, PartnersServiceFindAllResponseDto, PartnersServiceFindOneResponseDto, PartnersServiceUpdateResponseDto } from './dto/partners-response.dto'

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

@@ -1,3 +1,4 @@
+import { UploaderModule } from '@/modules/uploader/uploader.module'
 import { PrismaModule } from '@/prisma/prisma.module'
 import { Module } from '@nestjs/common'
 
@@ -11,6 +12,7 @@ import { PartnersService } from './partners.service'
 @Module({
   imports: [
     PrismaModule,
+    UploaderModule,
     AdminPartnerLicenseChargeTransactionModule,
     AdminPartnerActivatedLicensesModule,
     // AdminPartnerAllocatedAccountsModule,

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

@@ -1,3 +1,4 @@
+import { UploadedFileTypes } from '@/common/enums/enums'
 import { PasswordUtil } from '@/common/utils/password.util'
 import {
   AccountStatus,
@@ -6,6 +7,7 @@ import {
   PartnerStatus,
 } from '@/generated/prisma/enums'
 import { PartnerSelect } from '@/generated/prisma/models'
+import { UploaderService } from '@/modules/uploader/uploader.service'
 import { PrismaService } from '@/prisma/prisma.service'
 import { Injectable } from '@nestjs/common'
 import { ResponseMapper } from 'common/response/response-mapper'
@@ -14,13 +16,17 @@ import { CreatePartnerDto, UpdatePartnerDto } from './dto/partner.dto'
 @Injectable()
 export class PartnersService {
   private now = new Date().getTime()
-  constructor(private readonly prisma: PrismaService) {}
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly uploaderService: UploaderService,
+  ) {}
 
   private readonly defaultSelect: PartnerSelect = {
     id: true,
     name: true,
     code: true,
     status: true,
+    logo_url: true,
     created_at: true,
     license_charge_transactions: {
       select: {
@@ -145,19 +151,26 @@ export class PartnersService {
     return ResponseMapper.single(this.mapPartner(partner))
   }
 
-  async create(data: CreatePartnerDto) {
-    const { username, password, ...rest } = data
+  async create(data: CreatePartnerDto, logo?: any) {
+    const { username, password, ...rest } = data as any
+    delete rest.logo
+
+    const logo_url = logo
+      ? await this.uploaderService.uploadFile(logo, UploadedFileTypes.PARTNER_LOGO)
+      : undefined
+
     const partner = await this.prisma.partner.create({
       data: {
         ...rest,
         status: PartnerStatus.ACTIVE,
-        partner_accounts: {
+        ...(logo_url ? { logo_url } : {}),
+        accounts: {
           create: {
             role: PartnerRole.OWNER,
             account: {
               create: {
                 username,
-                password: await PasswordUtil.hash(data.password),
+                password: await PasswordUtil.hash(password),
                 status: AccountStatus.ACTIVE,
                 type: AccountType.PARTNER,
               },
@@ -170,12 +183,39 @@ export class PartnersService {
     return ResponseMapper.create(partner)
   }
 
-  async update(id: string, data: UpdatePartnerDto) {
-    const partner = await this.prisma.partner.update({
-      where: { id },
-      data,
-      select: this.defaultSelect,
+  async update(id: string, data: UpdatePartnerDto, logo?: any) {
+    const rest = { ...(data as any) }
+    delete rest.logo
+
+    const partner = await this.prisma.$transaction(async tx => {
+      let logo_url = ''
+      if (logo) {
+        const uploadedUrl = await this.uploaderService.uploadFile(
+          logo,
+          UploadedFileTypes.PARTNER_LOGO,
+        )
+        logo_url = uploadedUrl || ''
+      }
+
+      const prevLogo = await tx.partner.findUnique({
+        where: { id },
+        select: { logo_url: true },
+      })
+
+      if (logo_url && prevLogo?.logo_url) {
+        this.uploaderService.deleteFile(prevLogo.logo_url, UploadedFileTypes.PARTNER_LOGO)
+      }
+
+      return tx.partner.update({
+        where: { id },
+        data: {
+          ...rest,
+          ...(logo_url ? { logo_url } : {}),
+        },
+        select: this.defaultSelect,
+      })
     })
+
     return ResponseMapper.update(partner)
   }
 

src/modules/admin/providers/dto/providers-response.dto.ts

@@ -0,0 +1,6 @@
+import type { ProvidersService } from '../providers.service'
+
+export type ProvidersServiceCreateResponseDto = Awaited<ReturnType<ProvidersService['create']>>
+export type ProvidersServiceFindAllResponseDto = Awaited<ReturnType<ProvidersService['findAll']>>
+export type ProvidersServiceFindOneResponseDto = Awaited<ReturnType<ProvidersService['findOne']>>
+export type ProvidersServiceUpdateResponseDto = Awaited<ReturnType<ProvidersService['update']>>

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

@@ -2,6 +2,7 @@ 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'
+import type { ProvidersServiceCreateResponseDto, ProvidersServiceFindAllResponseDto, ProvidersServiceFindOneResponseDto, ProvidersServiceUpdateResponseDto } from './dto/providers-response.dto'
 
 @ApiTags('Admin Providers')
 @Controller('admin/providers')
@@ -9,22 +10,22 @@ export class ProvidersController {
   constructor(private readonly providersService: ProvidersService) {}
 
   @Get()
-  async findAll() {
+  async findAll(): Promise<ProvidersServiceFindAllResponseDto> {
     return this.providersService.findAll()
   }
 
   @Get(':id')
-  async findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string): Promise<ProvidersServiceFindOneResponseDto> {
     return this.providersService.findOne(id)
   }
 
   @Post()
-  async create(@Body() data: CreateProviderDto) {
+  async create(@Body() data: CreateProviderDto): Promise<ProvidersServiceCreateResponseDto> {
     return this.providersService.create(data)
   }
 
   @Patch(':id')
-  async update(@Param('id') id: string, @Body() data: UpdateProviderDto) {
+  async update(@Param('id') id: string, @Body() data: UpdateProviderDto): Promise<ProvidersServiceUpdateResponseDto> {
     return this.providersService.update(id, data)
   }
 

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

@@ -27,7 +27,7 @@ export class ProvidersService {
     const provider = await this.prisma.provider.create({
       data: {
         ...rest,
-        provider_accounts: {
+        accounts: {
           create: {
             role: ProviderRole.OWNER,
             account: {

src/modules/admin/translate/dto/translate-response.dto.ts

@@ -0,0 +1,3 @@
+import type { TranslateService } from '../translate.service'
+
+export type TranslateServiceGetTranslationsResponseDto = Awaited<ReturnType<TranslateService['getTranslations']>>

src/modules/admin/translate/translate.controller.ts

@@ -1,12 +1,13 @@
 import { Controller, Get } from '@nestjs/common'
 import { TranslateService } from './translate.service'
+import type { TranslateServiceGetTranslationsResponseDto } from './dto/translate-response.dto'
 
 @Controller('admin/translates')
 export class TranslateController {
   constructor(private readonly translateService: TranslateService) {}
 
   @Get()
-  async getTranslations() {
+  async getTranslations(): Promise<TranslateServiceGetTranslationsResponseDto> {
     return this.translateService.getTranslations()
   }
 }

src/modules/admin/translate/translate.service.ts

@@ -40,11 +40,11 @@ export class TranslateService {
         guild_goods: 'کالا',
         guild_good_categories: 'دسته‌بندی کالا',
         partners: 'شریک تجاری',
-        partner_accounts: 'حساب',
+        accounts: 'حساب',
         partner_licenses: 'مجوز',
         providers: 'ارائه‌دهنده',
-        provider_accounts: 'حساب',
-        accounts: 'حساب کاربری',
+        // accounts: 'حساب',
+        // accounts: 'حساب کاربری',
         licenses: 'لایسنس',
         business_activities: 'فعالیت‌ اقتصادی',
       },
@@ -56,11 +56,11 @@ export class TranslateService {
         guild_goods: 'کالاها',
         guild_good_categories: 'دسته‌بندی کالاها',
         partners: 'شرکای تجاری',
-        partner_accounts: 'حساب‌های شریک تجاری',
+        accounts: 'حساب‌های شریک تجاری',
         partner_licenses: 'مجوزهای داده شده',
         providers: 'ارائه‌دهندگان',
-        provider_accounts: 'حساب‌های ارائه‌دهنده',
-        accounts: 'حساب‌های کاربری',
+        // accounts: 'حساب‌های ارائه‌دهنده',
+        // accounts: 'حساب‌های کاربری',
         licenses: 'لایسنس‌ها',
         business_activities: 'فعالیت‌های اقتصادی',
       },

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

@@ -2,29 +2,30 @@ import { Body, Controller, Get, Param, Patch, Post } from '@nestjs/common'
 import { ApiTags } from '@nestjs/swagger'
 import { AccountsService } from './accounts.service'
 import { CreateAccountDto, UpdateAccountDto } from './dto/account.dto'
+import type { AccountsServiceCreateResponseDto, AccountsServiceFindAllResponseDto, AccountsServiceFindOneResponseDto, AccountsServiceUpdateResponseDto } from './dto/accounts-response.dto'
 
-@ApiTags('AdminAccounts')
+@ApiTags('accounts')
 @Controller('admin/users/:userId/accounts')
 export class AccountsController {
   constructor(private readonly accountsService: AccountsService) {}
 
   @Get()
-  async findAll(@Param('userId') userId: string) {
+  async findAll(@Param('userId') userId: string): Promise<AccountsServiceFindAllResponseDto> {
     return this.accountsService.findAll(userId)
   }
 
   @Get(':id')
-  async findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string): Promise<AccountsServiceFindOneResponseDto> {
     return this.accountsService.findOne(id)
   }
 
   @Post()
-  async create(@Param('userId') userId: string, @Body() data: CreateAccountDto) {
+  async create(@Param('userId') userId: string, @Body() data: CreateAccountDto): Promise<AccountsServiceCreateResponseDto> {
     return this.accountsService.create(userId, data)
   }
 
   @Patch(':id')
-  async update(@Param('id') id: string, @Body() data: UpdateAccountDto) {
+  async update(@Param('id') id: string, @Body() data: UpdateAccountDto): Promise<AccountsServiceUpdateResponseDto> {
     return this.accountsService.update(id, data)
   }
 

src/modules/admin/users/accounts/dto/accounts-response.dto.ts

@@ -0,0 +1,7 @@
+import type { AccountsService } from '../accounts.service'
+
+export type AccountsServiceCreateResponseDto = Awaited<ReturnType<AccountsService['create']>>
+export type AccountsServiceDeleteResponseDto = Awaited<ReturnType<AccountsService['delete']>>
+export type AccountsServiceFindAllResponseDto = Awaited<ReturnType<AccountsService['findAll']>>
+export type AccountsServiceFindOneResponseDto = Awaited<ReturnType<AccountsService['findOne']>>
+export type AccountsServiceUpdateResponseDto = Awaited<ReturnType<AccountsService['update']>>

src/modules/admin/users/dto/users-response.dto.ts

@@ -0,0 +1,7 @@
+import type { AdminUsersService } from '../users.service'
+
+export type AdminUsersServiceCreateResponseDto = Awaited<ReturnType<AdminUsersService['create']>>
+export type AdminUsersServiceDeleteResponseDto = Awaited<ReturnType<AdminUsersService['delete']>>
+export type AdminUsersServiceFindAllResponseDto = Awaited<ReturnType<AdminUsersService['findAll']>>
+export type AdminUsersServiceFindOneResponseDto = Awaited<ReturnType<AdminUsersService['findOne']>>
+export type AdminUsersServiceUpdateResponseDto = Awaited<ReturnType<AdminUsersService['update']>>

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

@@ -1,33 +1,34 @@
 import { Body, Controller, Delete, Get, Param, Patch, Post } from '@nestjs/common'
 import { CreateUserDto, UpdateUserDto } from './dto/user.dto'
 import { AdminUsersService } from './users.service'
+import type { AdminUsersServiceCreateResponseDto, AdminUsersServiceDeleteResponseDto, AdminUsersServiceFindAllResponseDto, AdminUsersServiceFindOneResponseDto, AdminUsersServiceUpdateResponseDto } from './dto/users-response.dto'
 
 @Controller('admin/users')
 export class AdminUsersController {
   constructor(private readonly usersService: AdminUsersService) {}
 
   @Get()
-  async findAll() {
+  async findAll(): Promise<AdminUsersServiceFindAllResponseDto> {
     return this.usersService.findAll()
   }
 
   @Get(':id')
-  async findOne(@Param('id') id: string) {
+  async findOne(@Param('id') id: string): Promise<AdminUsersServiceFindOneResponseDto> {
     return this.usersService.findOne(id)
   }
 
   @Post()
-  async create(@Body() data: any) {
+  async create(@Body() data: any): Promise<AdminUsersServiceCreateResponseDto> {
     return this.usersService.create(data as CreateUserDto)
   }
 
   @Patch(':id')
-  async update(@Param('id') id: string, @Body() data: any) {
+  async update(@Param('id') id: string, @Body() data: any): Promise<AdminUsersServiceUpdateResponseDto> {
     return this.usersService.update(id, data as UpdateUserDto)
   }
 
   @Delete(':id')
-  async delete(@Param('id') id: string) {
+  async delete(@Param('id') id: string): Promise<AdminUsersServiceDeleteResponseDto> {
     return this.usersService.delete(id)
   }
 }