psp_api/src/modules/consumer/business-activities/complexes/poses/poses.service.ts

import { PasswordUtil } from '@/common/utils/password.util'
import {
  AccountStatus,
  AccountType,
  ConsumerRole,
  POSStatus,
} from '@/generated/prisma/enums'
import { PosCreateInput, PosSelect, PosWhereInput } from '@/generated/prisma/models'
import { getBusinessActivityRemainingAccounts } from '@/modules/consumer/utils/getBusinessActivityRemainingAccounts.util'
import { PrismaService } from '@/prisma/prisma.service'
import { BadRequestException, Injectable } from '@nestjs/common'
import { ResponseMapper } from 'common/response/response-mapper'
import { CreatePosDto, UpdatePosDto } from './dto/pos.dto'

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

  defaultSelect: PosSelect = {
    id: true,
    name: true,
    model: true,
    serial_number: true,
    status: true,
    created_at: true,
    pos_type: true,

    provider: {
      select: {
        id: true,
        name: true,
      },
    },
    device: {
      select: {
        name: true,
        id: true,
        brand: {
          select: {
            id: true,
            name: true,
          },
        },
      },
    },
    complex: {
      select: {
        id: true,
        name: true,
        business_activity: {
          select: {
            id: true,
            name: true,
          },
        },
      },
    },
  }

  defaultWhere = (
    consumer_id: string,
    business_activity_id: string,
    complex_id: string,
  ): PosWhereInput => ({
    complex: {
      id: complex_id,
      business_activity: {
        id: business_activity_id,
        consumer_id,
      },
    },
  })

  defaultInsert = async (
    consumer_id: string,
    complex_id: string,
    data: CreatePosDto,
  ): Promise<PosCreateInput> => {
    const { device_id, provider_id, username, password, ...rest } = data

    return {
      ...rest,
      complex: {
        connect: {
          id: complex_id,
        },
      },
      account: {
        create: {
          role: ConsumerRole.OPERATOR,
          account: {
            create: {
              username,
              password: await PasswordUtil.hash(password),
              type: AccountType.CONSUMER,
              status: AccountStatus.ACTIVE,
            },
          },
          consumer: {
            connect: {
              id: consumer_id,
            },
          },
        },
      },
      provider: provider_id
        ? {
            connect: {
              id: provider_id,
            },
          }
        : undefined,
      device: device_id
        ? {
            connect: {
              id: device_id,
            },
          }
        : undefined,
    }
  }

  async findAll(consumer_id: string, business_activity_id: string, complex_id: string) {
    const poses = await this.prisma.pos.findMany({
      where: this.defaultWhere(consumer_id, business_activity_id, complex_id),
      select: this.defaultSelect,
    })

    return ResponseMapper.list(poses)
  }

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

  async create(
    consumer_id: string,
    business_activity_id: string,
    complex_id: string,
    data: CreatePosDto,
  ) {
    const pos = await this.prisma.$transaction(async tx => {
      const quota = await getBusinessActivityRemainingAccounts(tx, {
        consumer_id,
        business_activity_id,
      })

      if (quota.remaining_accounts <= 0) {
        throw new BadRequestException(
          `تعداد کاربرهای تخصیص داده شده برای این فعالیت تجاری به پایان رسیده است.`,
        )
      }

      return await tx.pos.create({
        data: {
          ...(await this.defaultInsert(consumer_id, complex_id, data)),
          status: POSStatus.ACTIVE,
        },
      })
    })
    return ResponseMapper.create(pos)
  }

  async update(
    consumer_id: string,
    business_activity_id: string,
    complex_id: string,
    id: string,
    data: UpdatePosDto,
  ) {
    const { device_id, provider_id, ...rest } = data
    const pos = await this.prisma.pos.update({
      where: {
        ...(this.defaultWhere(consumer_id, business_activity_id, complex_id) as any),
        id,
      },
      data: {
        complex: {
          connect: {
            id: complex_id,
          },
        },
        provider: provider_id
          ? {
              connect: {
                id: provider_id,
              },
            }
          : undefined,
        device: device_id
          ? {
              connect: {
                id: device_id,
              },
            }
          : undefined,
        ...rest,
      },
    })
    return ResponseMapper.update(pos)
  }
}