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

import {
  generateTrackingCode,
  isTrackingCodeUniqueViolation,
} from '@/common/utils/tracking-code-generator.util'
import {
  LicenseChargeTransactionSelect,
  LicenseChargeTransactionWhereInput,
  LicenseCreateInput,
} from '@/generated/prisma/models'
import { PrismaService } from '@/prisma/prisma.service'
import { BadRequestException, Injectable } from '@nestjs/common'
import { ResponseMapper } from 'common/response/response-mapper'
import { ChargeLicenseDto } from './dto/chargedLicenseTransactions.dto'

@Injectable()
export class PartnerLicenseChargeTransactionService {
  constructor(private readonly prisma: PrismaService) {}

  private readonly TRACKING_CODE_LENGTH = 8
  private readonly TRACKING_CODE_MAX_ATTEMPTS = 5

  private readonly mappedTransaction = (transaction: any) => {
    const { licenses, purchased_count, _count, ...rest } = transaction

    const activation_count = _count.licenses

    return {
      ...rest,
      charged_license_count: purchased_count,
      activation_count,
      remained_license_count: purchased_count - activation_count,
    }
  }

  private readonly defaultSelect: LicenseChargeTransactionSelect = {
    id: true,
    created_at: true,
    activation_expires_at: true,
    tracking_code: true,
    purchased_count: true,
    _count: {
      select: {
        licenses: {
          where: {
            activation: {
              isNot: null,
            },
          },
        },
      },
    },
  }

  async findAll(partner_id: string, page = 1, pageSize = 10) {
    const defaultWhere: LicenseChargeTransactionWhereInput = {
      partner_id,
    }

    const [transactions, count] = await this.prisma.$transaction(async tx => [
      await tx.licenseChargeTransaction.findMany({
        where: defaultWhere,
        skip: (page - 1) * pageSize,
        take: pageSize,
        select: this.defaultSelect,
      }),
      await tx.licenseChargeTransaction.count({
        where: defaultWhere,
      }),
    ])

    const mappedTransactions = transactions.map(this.mappedTransaction)

    return ResponseMapper.paginate(mappedTransactions, {
      page,
      pageSize,
      count,
    })
  }

  async findOne(partner_id: string, id: string) {
    const transaction = this.prisma.licenseChargeTransaction.findUniqueOrThrow({
      where: {
        id,
        partner_id,
      },
      select: this.defaultSelect,
    })
    return ResponseMapper.single(this.mappedTransaction(transaction))
  }

  async create(partner_id: string, data: ChargeLicenseDto) {
    try {
      return await this.prisma.$transaction(async tx => {
        let transaction: { id: string } | null = null

        for (let attempt = 0; attempt < this.TRACKING_CODE_MAX_ATTEMPTS; attempt++) {
          try {
            transaction = await tx.licenseChargeTransaction.create({
              data: {
                activation_expires_at: data.activated_expires_at,
                tracking_code: generateTrackingCode('LIC', this.TRACKING_CODE_LENGTH),
                purchased_count: data.quantity,
                partner: { connect: { id: partner_id } },
              },
            })
            break
          } catch (error) {
            if (
              isTrackingCodeUniqueViolation(error) &&
              attempt < this.TRACKING_CODE_MAX_ATTEMPTS - 1
            ) {
              continue
            }
            throw error
          }
        }

        if (!transaction) {
          throw new BadRequestException('متاسفانه مشکلی پیش آمده است.')
        }

        const licenseCreationPromises: any[] = []
        for (let i = 0; i < data.quantity; i++) {
          const license: LicenseCreateInput = {
            charge_transaction: {
              connect: {
                id: transaction.id,
              },
            },
          }

          licenseCreationPromises.push(tx.license.create({ data: license }))
        }
        const createdLicenses = await Promise.all(licenseCreationPromises)

        if (
          createdLicenses.some(createdLicense => createdLicense.activation_id === null)
        ) {
          throw new BadRequestException('متاسفانه مشکلی پیش آمده است. ')
        }
        return { transaction, createdLicenses }
      })
    } catch (error) {
      throw error
    }
  }
}