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

import { PrismaService } from '@/prisma/prisma.service'
import { Injectable } from '@nestjs/common'
import { ResponseMapper } from 'common/response/response-mapper'
import { CreateLicenseDto, UpdateLicenseDto } from './dto/license.dto'

@Injectable()
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 findOne(partnerId: string, id: string) {
    const license = await this.prisma.license.findFirst({
      where: { id, partner_id: partnerId },
      include: {
        pos: {
          include: {
            complex: true,
            provider: true,

            accounts: {
              include: {
                user: true,
              },
              omit: {
                business_id: true,
                partner_id: true,
                provider_id: true,
                pos_id: true,
              },
            },
            device: {
              include: {
                brand: true,
              },
              omit: {
                brand_id: true,
              },
            },
          },
        },
      },
      omit: {
        pos_id: true,
        partner_id: true,
      },
    })
    if (license) {
      const { pos, ...rest } = license
      const { accounts, ...posRest } = pos
      return ResponseMapper.single({
        account: accounts[0],
        pos: posRest,
        ...rest,
      })
    }

    return ResponseMapper.single(license)
  }

  async create(partnerId: string, data: CreateLicenseDto) {
    // const license = await this.prisma.$transaction(async tx => {
    //   const user = await tx.user.upsert({
    //     where: {
    //       mobile_number: data.mobile_number,
    //     },
    //     update: {},
    //     create: {
    //       first_name: data.first_name,
    //       last_name: data.last_name,
    //       mobile_number: data.mobile_number,
    //       national_code: data.national_code,
    //     },
    //   })

    //     const business = await tx.businessActivity.create({
    //       data: {
    //         name: data.business_activity_name,
    //         guild_id: data.guild,
    //         user: {
    //           connect: {
    //             id: user.id,
    //           },
    //         },
    //       },
    //     })

    //   const complex = await tx.complex.create({
    //     data: {
    //       name: data.complex_name,
    //       tax_id: data.tax_id,
    //       business_activity_id: business.id,
    //     },
    //   })

    //   const pos = await tx.pos.create({
    //     data: {
    //       pos_type: data.pos_type,
    //       serial: data.pos_serial,
    //       device_id: data.pos_device,
    //       complex_id: complex.id,
    //     },
    //   })

    //   const date = new Date()
    //   const expiresAt = new Date(date.setFullYear(date.getFullYear() + 1))

    //   const license = await tx.license.create({
    //     data: {
    //       partner_id: partnerId,
    //       pos_id: pos.id,
    //       starts_at: data.starts_at || new Date(),
    //       expires_at: data.expires_at || expiresAt,
    //       status: LicenseStatus.ACTIVE,
    //     },
    //   })

    //   const hashedPassword = await PasswordUtil.hash(data.password)

    //   const account = await tx.account.create({
    //     data: {
    //       username: data.username,
    //       password: hashedPassword,
    //       type: AccountType.POS,
    //       user_id: user.id,
    //       pos_id: pos.id,
    //       status: data.account_status,
    //     },
    //   })

    //   return {
    //     license,
    //   }
    // })
    return ResponseMapper.create('license')
  }

  async update(partnerId: string, id: string, data: UpdateLicenseDto) {
    const license = await this.prisma.license.update({
      where: { id },
      data: { ...data, partner_id: partnerId },
    })
    return ResponseMapper.update(license)
  }

  async delete(partnerId: string, id: string) {
    await this.prisma.license.delete({ where: { id } })
    return ResponseMapper.delete()
  }
}