debug license

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

@@ -123,7 +123,9 @@ export class AdminUsersService {
         create: {
           starts_at: license.starts_at,
           expires_at: new Date(
-            new Date(license.starts_at).getFullYear() + 1,
+            new Date(license.starts_at).setFullYear(
+              new Date(license.starts_at).getFullYear() + 1,
+            ),
           ).toISOString(),
           status: LicenseStatus.ACTIVE,
           partner: {

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

@@ -1,5 +1,5 @@
 import { LicenseStatus } from '@/generated/prisma/enums'
-import { ApiProperty, OmitType, PartialType } from '@nestjs/swagger'
+import { ApiProperty, PartialType } from '@nestjs/swagger'
 import { IsDateString, IsEnum } from 'class-validator'
 
 export class CreateLicenseDto {
@@ -21,16 +21,7 @@ export class CreateLicenseDto {
   partner_id: string
 }
 
-export class UpdateLicenseDto extends OmitType(PartialType(CreateLicenseDto), [
-  'starts_at',
-]) {
-  @ApiProperty({ required: true, default: new Date().toISOString() })
-  @IsDateString(
-    { strict: true },
-    { message: 'invoice_date must be a valid ISO-8601 string' },
-  )
-  starts_at: Date
-
+export class UpdateLicenseDto extends PartialType(CreateLicenseDto) {
   @ApiProperty({ enum: LicenseStatus })
   @IsEnum(LicenseStatus)
   status?: LicenseStatus

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

@@ -1,6 +1,7 @@
 import { LicenseStatus } from '@/generated/prisma/enums'
+import { LicenseUpdateInput } from '@/generated/prisma/models'
 import { PrismaService } from '@/prisma/prisma.service'
-import { Injectable } from '@nestjs/common'
+import { BadRequestException, Injectable } from '@nestjs/common'
 import { ResponseMapper } from 'common/response/response-mapper'
 import { CreateLicenseDto, UpdateLicenseDto } from './dto/license.dto'
 
@@ -25,7 +26,7 @@ export class LicensesService {
             id: data.partner_id,
           },
         },
-        consumers: {
+        consumer: {
           connect: {
             id: consumerId,
           },
@@ -37,13 +38,54 @@ export class LicensesService {
   }
 
   async update(id: string, data: UpdateLicenseDto) {
-    const { starts_at, expires_at } = data
+    const { starts_at, expires_at, partner_id } = data
+    const currentLicense = await this.prisma.license.findUnique({
+      where: { id },
+      select: {
+        partner_id: true,
+      },
+    })
+
+    if (partner_id && currentLicense?.partner_id !== partner_id) {
+      const partner = await this.prisma.partner.findUnique({
+        where: {
+          id: partner_id,
+        },
+        select: {
+          name: true,
+          license_quota: true,
+          _count: {
+            select: {
+              licenses: true,
+            },
+          },
+        },
+      })
+
+      if (!((partner?.license_quota || 0) - (partner?._count.licenses || 0))) {
+        throw new BadRequestException(`تعداد لایسنس‌های ${partner?.name} کافی نیست.`)
+      }
+    }
+
+    const dataToUpdate: LicenseUpdateInput = {}
+
+    if (partner_id) {
+      dataToUpdate.partner = {
+        connect: {
+          id: partner_id,
+        },
+      }
+    }
+
+    if (starts_at) {
+      dataToUpdate.starts_at = starts_at
+      dataToUpdate.expires_at = this.setExpireDate(starts_at)
+    }
+
     const license = await this.prisma.license.update({
       where: { id },
       data: {
-        ...data,
-        starts_at,
-        expires_at: expires_at ?? this.setExpireDate(starts_at),
+        ...dataToUpdate,
       },
     })
     return ResponseMapper.update(license)

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

@@ -1,4 +1,4 @@
-import { LicenseInclude } from '@/generated/prisma/models'
+import { LicenseSelect } from '@/generated/prisma/models'
 import { PrismaService } from '@/prisma/prisma.service'
 import { Injectable } from '@nestjs/common'
 import { ResponseMapper } from 'common/response/response-mapper'
@@ -8,80 +8,52 @@ import { UpdateLicenseDto } from './dto/license.dto'
 export class PartnerLicensesService {
   constructor(private readonly prisma: PrismaService) {}
 
-  private readonly licenseInclude = {
-    partner: true,
-    pos: {
-      include: {
-        complex: true,
-        provider: true,
-        accounts: {
-          include: {
-            user: true,
-          },
-          omit: {
-            business_id: true,
-            partner_id: true,
-            provider_id: true,
-            pos_id: true,
-          },
-        },
-        device: {
-          include: {
-            brand: true,
-          },
-          omit: {
-            brand_id: true,
-          },
-        },
+  private readonly licenseDefaultSelect: LicenseSelect = {
+    id: true,
+    starts_at: true,
+    expires_at: true,
+    status: true,
+    consumer: {
+      select: {
+        first_name: true,
+        last_name: true,
+        mobile_number: true,
+        status: true,
       },
     },
-  } as LicenseInclude
+    partner: {
+      select: {
+        id: true,
+        name: true,
+      },
+    },
+  }
 
-  async findAll() {
+  async findAll(page = 1, pageSize = 10) {
     const [licenses, count] = await this.prisma.$transaction([
       this.prisma.license.findMany({
-        include: this.licenseInclude,
-        omit: {
-          partner_id: true,
-        },
+        select: this.licenseDefaultSelect,
+        skip: (page - 1) * pageSize,
+        take: pageSize,
       }),
       this.prisma.license.count(),
     ])
-    return ResponseMapper.paginate(
-      licenses.map(license => {
-        const { ...rest } = license
-        // @ts-ignore
-        const { accounts, ...posRest } = pos
-        return {
-          account: accounts[0],
-          pos: posRest,
-          ...rest,
-        }
-      }),
-      {
-        count,
-      },
-    )
+
+    return ResponseMapper.paginate(licenses, {
+      count,
+      page,
+      pageSize,
+    })
   }
 
   async findOne(id: string) {
     const license = await this.prisma.license.findFirst({
       where: { id },
-      include: this.licenseInclude,
+      include: this.licenseDefaultSelect,
       omit: {
         partner_id: true,
       },
     })
-    if (license) {
-      const { ...rest } = license
-      // @ts-ignore
-      const { accounts, ...posRest } = pos
-      return ResponseMapper.single({
-        account: accounts[0],
-        pos: posRest,
-        ...rest,
-      })
-    }
 
     return ResponseMapper.single(license)
   }
@@ -93,9 +65,4 @@ export class PartnerLicensesService {
     })
     return ResponseMapper.update(license)
   }
-
-  async delete(id: string) {
-    await this.prisma.license.delete({ where: { id } })
-    return ResponseMapper.delete()
-  }
 }

src/modules/admin/partners/licenses/licenses.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 { CreatePartnerLicenseDto, UpdateLicenseDto } from './dto/license.dto'
 import { PartnerLicensesService } from './licenses.service'
 
@@ -32,9 +32,4 @@ export class PartnerLicensesController {
   ) {
     return this.licensesService.update(partnerId, id, data)
   }
-
-  @Delete(':id')
-  async delete(@Param('partnerId') partnerId: string, @Param('id') id: string) {
-    return this.licensesService.delete(partnerId, id)
-  }
 }

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

@@ -7,52 +7,39 @@ import { CreatePartnerLicenseDto, UpdateLicenseDto } from './dto/license.dto'
 export class PartnerLicensesService {
   constructor(private readonly prisma: PrismaService) {}
 
-  async findAll(partnerId: string) {
-    // const licenses = await this.prisma.license.findMany({
-    //   where: { partner_id: partnerId },
-    //   include: {
-    //     pos: {
-    //       include: {
-    //         complex: true,
-    //         provider: true,
-    //         accounts: {
-    //           include: {
-    //             user: true,
-    //           },
-    //           omit: {
-    //             business_id: true,
-    //             partner_id: true,
-    //             provider_id: true,
-    //             pos_id: true,
-    //           },
-    //         },
-    //         device: {
-    //           include: {
-    //             brand: true,
-    //           },
-    //           omit: {
-    //             brand_id: true,
-    //           },
-    //         },
-    //       },
-    //     },
-    //   },
-    //   omit: {
-    //     pos_id: true,
-    //     partner_id: true,
-    //   },
-    // })
-    // return ResponseMapper.list(
-    //   licenses.map(license => {
-    //     const { pos, ...rest } = license
-    //     const { accounts, ...posRest } = pos
-    //     return {
-    //       account: accounts[0],
-    //       pos: posRest,
-    //       ...rest,
-    //     }
-    //   }),
-    // )
+  async findAll(partner_id: string, page = 1, pageSize = 10) {
+    const [licenses, count] = await this.prisma.$transaction(async tx => [
+      await tx.license.findMany({
+        where: {
+          partner_id,
+        },
+        skip: (page - 1) * pageSize,
+        take: pageSize,
+        select: {
+          id: true,
+          starts_at: true,
+          expires_at: true,
+          consumer: {
+            select: {
+              id: true,
+              first_name: true,
+              last_name: true,
+            },
+          },
+        },
+      }),
+      await tx.license.count({
+        where: {
+          partner_id,
+        },
+      }),
+    ])
+
+    return ResponseMapper.paginate(licenses, {
+      page,
+      pageSize,
+      count,
+    })
   }
 
   async findOne(partnerId: string, id: string) {