psp_api/src/modules/partners/consumers/business-activities/complexes/complexes.service.ts

import { QUERY_CONSTANTS } from '@/common/queryConstants'
import { ComplexSelect, ComplexWhereInput } from '@/generated/prisma/models'
import { PrismaService } from '@/prisma/prisma.service'
import { BadRequestException, Injectable } from '@nestjs/common'
import { ResponseMapper } from 'common/response/response-mapper'
import { CreateComplexDto, UpdateComplexDto } from './dto/complex.dto'

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

  private readonly defaultSelect: ComplexSelect = {
    id: true,
    name: true,
    address: true,
    branch_code: true,
    created_at: true,
  }

  private readonly defaultWhere = (
    partner_id,
    consumer_id,
    business_activity_id,
  ): ComplexWhereInput => ({
    business_activity: {
      id: business_activity_id,
      consumer: {
        id: consumer_id,
        OR: [
          {
            legal: {
              partner_id,
            },
          },
          {
            individual: {
              partner_id,
            },
          },
        ],
      },
    },
  })

  async findAll(partner_id: string, consumer_id: string, business_activity_id: string) {
    const complexes = await this.prisma.complex.findMany({
      where: this.defaultWhere(partner_id, consumer_id, business_activity_id),
      select: {
        ...this.defaultSelect,
        _count: {
          select: {
            pos_list: true,
          },
        },
      },
    })

    const mappedComplexes = complexes.map(complex => {
      const { _count, ...rest } = complex
      return {
        ...rest,
        pos_count: _count.pos_list,
      }
    })
    return ResponseMapper.list(mappedComplexes)
  }

  async findOne(
    partner_id: string,
    consumer_id: string,
    business_activity_id: string,
    id: string,
  ) {
    const complex = await this.prisma.complex.findUnique({
      where: {
        ...this.defaultWhere(partner_id, consumer_id, business_activity_id),
        id,
      },
      select: this.defaultSelect,
    })
    return ResponseMapper.single(complex)
  }

  async create(partner_id: string, business_id: string, data: CreateComplexDto) {
    const complex = this.prisma.$transaction(async tx => {
      const relatedLicense = await tx.licenseAccountAllocation.findFirst({
        where: {
          license_activation: {
            license: {
              charge_transaction: {
                partner_id,
              },
            },
            business_activity: {
              id: business_id,
            },
            ...QUERY_CONSTANTS.LICENSE_ACTIVATION.activeOnDate(),
          },
          account_id: null,
        },
        select: {
          id: true,
        },
      })

      if (!relatedLicense) {
        throw new BadRequestException(
          `متاسفانه به دلیل به پایان رسیدن محدودیت تعریف کاربران برای این فعالیت اقتصادی،‌امکان ایجاد شعبه‌ی جدید وجود ندارد.`,
        )
      }

      return await this.prisma.complex.create({
        data: {
          ...data,
          business_activity: {
            connect: {
              id: business_id,
            },
          },
        },
      })
    })

    return ResponseMapper.create(complex)
  }

  async update(
    partner_id: string,
    consumer_id: string,
    business_activity_id: string,
    id: string,
    data: UpdateComplexDto,
  ) {
    const complex = await this.prisma.complex.update({
      where: { ...this.defaultWhere(partner_id, consumer_id, business_activity_id), id },
      data,
    })
    return ResponseMapper.update(complex)
  }

  // async delete(id: string) {
  //   await this.prisma.complex.delete({ where: { id } })
  //   return ResponseMapper.delete()
  // }
}