psp_api/src/suppliers/suppliers.service.ts

import { Injectable } from '@nestjs/common'
import { ResponseMapper } from '../common/response/response-mapper'
import { PrismaService } from '../prisma/prisma.service'

@Injectable()
export class SuppliersService {
  constructor(private prisma: PrismaService) {}
  async create(data: any) {
    const item = await this.prisma.supplier.create({ data })
    return ResponseMapper.create(item)
  }

  async findAll() {
    const items = await this.prisma.supplier.findMany()
    return ResponseMapper.list(items)
  }

  async findOne(id: number) {
    const item = await this.prisma.supplier.findUnique({ where: { id } })
    if (!item) return null
    const receiptsInfo = await this.prisma.purchaseReceipt.aggregate({
      where: {
        supplierId: id,
      },
      _count: true,
      _sum: {
        totalAmount: true,
      },
    })

    return ResponseMapper.single({
      ...item,
      receiptsOverview: {
        totalPayment: receiptsInfo._sum.totalAmount,
        count: receiptsInfo._count,
      },
    })
  }

  async getInvoices(supplierId: number) {
    const items = await this.prisma.purchaseReceipt.findMany({
      where: {
        supplierId,
      },
      include: {
        inventory: {
          select: {
            id: true,
            name: true,
          },
        },
        items: {
          select: {
            id: true,
            count: true,
            fee: true,
            total: true,
            product: {
              select: {
                id: true,
                name: true,
                sku: true,
              },
            },
          },
        },
        payments: {
          select: {
            id: true,
            amount: true,
          },
        },
      },
      omit: {
        inventoryId: true,
        supplierId: true,
      },
    })
    return ResponseMapper.list(items)
  }

  async getInvoice(supplierId: number, invoiceId: number) {
    const invoice = await this.prisma.purchaseReceipt.findUnique({
      where: {
        id: invoiceId,
        supplierId,
      },
      include: {
        inventory: {
          select: {
            id: true,
            name: true,
          },
        },
        items: true,
      },
      omit: {
        inventoryId: true,
        supplierId: true,
      },
    })
    return ResponseMapper.single(invoice)
  }

  async update(id: number, data: any) {
    const item = await this.prisma.supplier.update({ where: { id }, data })
    return ResponseMapper.update(item)
  }

  async remove(id: number) {
    const item = await this.prisma.supplier.delete({ where: { id } })
    return ResponseMapper.single(item)
  }
}