@hed-hog/finance 0.0.223 → 0.0.225

package/src/finance.service.ts

@@ -0,0 +1,529 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+    BadRequestException,
+    Injectable,
+    NotFoundException,
+} from '@nestjs/common';
+import { CreateFinancialTitleDto } from './dto/create-financial-title.dto';
+
+type TitleType = 'payable' | 'receivable';
+
+@Injectable()
+export class FinanceService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  async getData() {
+    const [
+      payables,
+      receivables,
+      people,
+      categories,
+      costCenters,
+      bankAccounts,
+      tags,
+      auditLogs,
+    ] = await Promise.all([
+      this.loadTitles('payable'),
+      this.loadTitles('receivable'),
+      this.loadPeople(),
+      this.loadCategories(),
+      this.loadCostCenters(),
+      this.loadBankAccounts(),
+      this.loadTags(),
+      this.loadAuditLogs(),
+    ]);
+
+    return {
+      kpis: {
+        saldoCaixa: 0,
+        aPagar30dias: 0,
+        aPagar7dias: 0,
+        aReceber30dias: 0,
+        aReceber7dias: 0,
+        inadimplencia: 0,
+      },
+      fluxoCaixaPrevisto: [],
+      titulosPagar: payables,
+      titulosReceber: receivables,
+      extratos: [],
+      contasBancarias: bankAccounts,
+      pessoas: people,
+      categorias: categories,
+      centrosCusto: costCenters,
+      aprovacoesPendentes: [],
+      agingInadimplencia: [],
+      cenarios: [],
+      transferencias: [],
+      tags,
+      logsAuditoria: auditLogs,
+      recebiveis: [],
+      adquirentes: [],
+      historicoContatos: [],
+      entradasPrevistas: [],
+      saidasPrevistas: [],
+    };
+  }
+
+  async listAccountsPayableInstallments(
+    paginationParams: PaginationDTO,
+    status?: string,
+  ) {
+    return this.listTitles('payable', paginationParams, status);
+  }
+
+  async listAccountsReceivableInstallments(
+    paginationParams: PaginationDTO,
+    status?: string,
+  ) {
+    return this.listTitles('receivable', paginationParams, status);
+  }
+
+  async getAccountsPayableInstallment(id: number, locale: string) {
+    const title = await this.getTitleById(id, 'payable', locale);
+    return this.mapTitleToFront(title);
+  }
+
+  async getAccountsReceivableInstallment(id: number, locale: string) {
+    const title = await this.getTitleById(id, 'receivable', locale);
+    return this.mapTitleToFront(title);
+  }
+
+  async createAccountsPayableTitle(
+    data: CreateFinancialTitleDto,
+    locale: string,
+    userId?: number,
+  ) {
+    return this.createTitle(data, 'payable', locale, userId);
+  }
+
+  async createAccountsReceivableTitle(
+    data: CreateFinancialTitleDto,
+    locale: string,
+    userId?: number,
+  ) {
+    return this.createTitle(data, 'receivable', locale, userId);
+  }
+
+  private async listTitles(
+    titleType: TitleType,
+    paginationParams: PaginationDTO,
+    status?: string,
+  ) {
+    const prismaStatus = this.mapStatusFromPt(status);
+    const where: any = {
+      title_type: titleType,
+    };
+
+    if (prismaStatus) {
+      where.status = prismaStatus;
+    }
+
+    return this.paginationService.paginate(
+      this.prisma.financial_title,
+      paginationParams,
+      {
+        where,
+        include: this.defaultTitleInclude(),
+        orderBy: { created_at: 'desc' },
+      },
+    );
+  }
+
+  private async getTitleById(id: number, titleType: TitleType, locale: string) {
+    const title = await this.prisma.financial_title.findFirst({
+      where: {
+        id,
+        title_type: titleType,
+      },
+      include: this.defaultTitleInclude(),
+    });
+
+    if (!title) {
+      throw new NotFoundException(
+        getLocaleText(
+          'itemNotFound',
+          locale,
+          `Financial title with ID ${id} not found`,
+        ).replace('{{item}}', 'Financial title'),
+      );
+    }
+
+    return title;
+  }
+
+  private async createTitle(
+    data: CreateFinancialTitleDto,
+    titleType: TitleType,
+    locale: string,
+    userId?: number,
+  ) {
+    const person = await this.prisma.person.findUnique({
+      where: { id: data.person_id },
+      select: { id: true },
+    });
+
+    if (!person) {
+      throw new BadRequestException(
+        getLocaleText('personNotFound', locale, 'Person not found'),
+      );
+    }
+
+    if (data.finance_category_id) {
+      const category = await this.prisma.finance_category.findUnique({
+        where: { id: data.finance_category_id },
+        select: { id: true },
+      });
+
+      if (!category) {
+        throw new BadRequestException(
+          getLocaleText('categoryNotFound', locale, 'Category not found'),
+        );
+      }
+    }
+
+    if (data.cost_center_id) {
+      const costCenter = await this.prisma.cost_center.findUnique({
+        where: { id: data.cost_center_id },
+        select: { id: true },
+      });
+
+      if (!costCenter) {
+        throw new BadRequestException(
+          getLocaleText('costCenterNotFound', locale, 'Cost center not found'),
+        );
+      }
+    }
+
+    const installments =
+      data.installments && data.installments.length > 0
+        ? data.installments
+        : [
+            {
+              installment_number: 1,
+              due_date: data.due_date,
+              amount: data.total_amount,
+            },
+          ];
+
+    const title = await this.prisma.financial_title.create({
+      data: {
+        person_id: data.person_id,
+        title_type: titleType,
+        status: 'open',
+        document_number: data.document_number,
+        description: data.description,
+        competence_date: data.competence_date
+          ? new Date(data.competence_date)
+          : null,
+        issue_date: data.issue_date ? new Date(data.issue_date) : null,
+        total_amount_cents: this.toCents(data.total_amount),
+        finance_category_id: data.finance_category_id,
+        created_by_user_id: userId,
+      },
+    });
+
+    for (let index = 0; index < installments.length; index++) {
+      const installment = installments[index];
+      const amountCents = this.toCents(installment.amount);
+
+      const createdInstallment = await this.prisma.financial_installment.create({
+        data: {
+          title_id: title.id,
+          installment_number: installment.installment_number || index + 1,
+          competence_date: data.competence_date
+            ? new Date(data.competence_date)
+            : new Date(installment.due_date),
+          due_date: new Date(installment.due_date),
+          amount_cents: amountCents,
+          open_amount_cents: amountCents,
+          status: 'open',
+          notes: data.description,
+        },
+      });
+
+      if (data.cost_center_id) {
+        await this.prisma.installment_allocation.create({
+          data: {
+            installment_id: createdInstallment.id,
+            cost_center_id: data.cost_center_id,
+            allocated_amount_cents: amountCents,
+          },
+        });
+      }
+    }
+
+    const createdTitle = await this.getTitleById(title.id, titleType, locale);
+    return this.mapTitleToFront(createdTitle, data.payment_channel);
+  }
+
+  private async loadTitles(type: TitleType) {
+    const titles = await this.prisma.financial_title.findMany({
+      where: { title_type: type },
+      include: this.defaultTitleInclude(),
+      orderBy: { created_at: 'desc' },
+    });
+
+    return titles.map((title) => this.mapTitleToFront(title));
+  }
+
+  private async loadPeople() {
+    const people = await this.prisma.person.findMany({
+      include: {
+        document: {
+          select: {
+            value: true,
+          },
+          take: 1,
+        },
+      },
+      orderBy: { name: 'asc' },
+    });
+
+    return people.map((person) => ({
+      id: String(person.id),
+      nome: person.name,
+      tipo: 'ambos',
+      documento: person.document[0]?.value || '',
+    }));
+  }
+
+  private async loadCategories() {
+    const categories = await this.prisma.finance_category.findMany({
+      orderBy: [{ code: 'asc' }, { name: 'asc' }],
+    });
+
+    return categories.map((category) => ({
+      id: String(category.id),
+      codigo: category.code,
+      nome: category.name,
+      natureza:
+        category.kind === 'revenue'
+          ? 'receita'
+          : category.kind === 'expense'
+            ? 'despesa'
+            : category.kind,
+      status: category.status,
+    }));
+  }
+
+  private async loadCostCenters() {
+    const costCenters = await this.prisma.cost_center.findMany({
+      orderBy: [{ code: 'asc' }, { name: 'asc' }],
+    });
+
+    return costCenters.map((costCenter) => ({
+      id: String(costCenter.id),
+      codigo: costCenter.code,
+      nome: costCenter.name,
+      status: costCenter.status,
+    }));
+  }
+
+  private async loadBankAccounts() {
+    const bankAccounts = await this.prisma.bank_account.findMany({
+      orderBy: [{ code: 'asc' }, { name: 'asc' }],
+    });
+
+    return bankAccounts.map((bankAccount) => ({
+      id: String(bankAccount.id),
+      codigo: bankAccount.code,
+      descricao: bankAccount.name,
+      banco: bankAccount.bank_name,
+      agencia: bankAccount.agency,
+      conta: bankAccount.account_number,
+      ativo: bankAccount.status === 'active',
+    }));
+  }
+
+  private async loadTags() {
+    const tags = await this.prisma.tag.findMany({
+      orderBy: { slug: 'asc' },
+    });
+
+    return tags.map((tag) => ({
+      id: String(tag.id),
+      nome: tag.slug,
+      cor: tag.color,
+    }));
+  }
+
+  private async loadAuditLogs() {
+    const logs = await this.prisma.audit_log.findMany({
+      orderBy: { created_at: 'desc' },
+      take: 500,
+    });
+
+    return logs.map((log) => ({
+      id: String(log.id),
+      entidade: log.entity_table === 'financial_title' ? 'TituloPagar' : log.entity_table,
+      entidadeId: log.entity_id,
+      usuarioId: log.actor_user_id ? String(log.actor_user_id) : null,
+      acao: log.action,
+      detalhes: log.summary,
+      antes: log.before_data,
+      depois: log.after_data,
+      data: log.created_at.toISOString(),
+    }));
+  }
+
+  private mapTitleToFront(title: any, paymentChannelOverride?: string) {
+    const allocations = title.financial_installment.flatMap(
+      (installment) => installment.installment_allocation,
+    );
+    const firstCostCenter = allocations[0]?.cost_center_id;
+
+    const tags = [
+      ...new Set(
+        title.financial_installment
+          .flatMap((installment) => installment.financial_installment_tag)
+          .map((tagRelation) => String(tagRelation.tag_id)),
+      ),
+    ];
+
+    const channelFromSettlement = title.financial_installment
+      .flatMap((installment) => installment.settlement_allocation)
+      .map((allocation) => allocation.settlement?.payment_method?.type)
+      .find(Boolean);
+
+    const mappedInstallments = title.financial_installment.map((installment) => ({
+      id: String(installment.id),
+      numero: installment.installment_number,
+      vencimento: installment.due_date.toISOString(),
+      valor: this.fromCents(installment.amount_cents),
+      status: this.mapStatusToPt(installment.status),
+      metodoPagamento:
+        this.mapPaymentMethodToPt(
+          installment.settlement_allocation[0]?.settlement?.payment_method?.type,
+        ) || paymentChannelOverride || 'transferencia',
+      liquidacoes: installment.settlement_allocation.map((allocation) => ({
+        id: String(allocation.id),
+        data: allocation.settlement?.settled_at?.toISOString(),
+        valor: this.fromCents(allocation.allocated_amount_cents),
+        juros: this.fromCents(allocation.interest_cents || 0),
+        desconto: this.fromCents(allocation.discount_cents || 0),
+        multa: this.fromCents(allocation.penalty_cents || 0),
+        contaBancariaId: allocation.settlement?.bank_account_id
+          ? String(allocation.settlement.bank_account_id)
+          : null,
+        metodo:
+          this.mapPaymentMethodToPt(
+            allocation.settlement?.payment_method?.type,
+          ) || 'transferencia',
+      })),
+    }));
+
+    return {
+      id: String(title.id),
+      documento: title.document_number || `TIT-${title.id}`,
+      descricao: title.description || '',
+      competencia: title.competence_date
+        ? title.competence_date.toISOString().slice(0, 7)
+        : '',
+      valorTotal: this.fromCents(title.total_amount_cents),
+      status: this.mapStatusToPt(title.status),
+      criadoEm: title.created_at.toISOString(),
+      categoriaId: title.finance_category_id ? String(title.finance_category_id) : null,
+      centroCustoId: firstCostCenter ? String(firstCostCenter) : null,
+      anexos: title.financial_title_attachment.map(
+        (attachment) => attachment.file?.filename || attachment.file?.path,
+      ),
+      tags,
+      parcelas: mappedInstallments,
+      canal:
+        this.mapPaymentMethodToPt(channelFromSettlement) ||
+        paymentChannelOverride ||
+        'transferencia',
+      ...(title.title_type === 'payable'
+        ? { fornecedorId: String(title.person_id) }
+        : { clienteId: String(title.person_id) }),
+    };
+  }
+
+  private defaultTitleInclude() {
+    return {
+      person: true,
+      financial_title_attachment: {
+        include: {
+          file: true,
+        },
+      },
+      financial_installment: {
+        include: {
+          installment_allocation: true,
+          financial_installment_tag: true,
+          settlement_allocation: {
+            include: {
+              settlement: {
+                include: {
+                  payment_method: true,
+                },
+              },
+            },
+          },
+        },
+        orderBy: {
+          installment_number: 'asc' as const,
+        },
+      },
+    };
+  }
+
+  private mapStatusToPt(status?: string | null) {
+    const statusMap = {
+      draft: 'rascunho',
+      approved: 'aprovado',
+      open: 'aberto',
+      partial: 'parcial',
+      settled: 'liquidado',
+      canceled: 'cancelado',
+      overdue: 'vencido',
+    };
+
+    return statusMap[status] || 'aberto';
+  }
+
+  private mapStatusFromPt(status?: string) {
+    if (!status || status === 'all') {
+      return undefined;
+    }
+
+    const statusMap = {
+      rascunho: 'draft',
+      aprovado: 'approved',
+      aberto: 'open',
+      parcial: 'partial',
+      liquidado: 'settled',
+      cancelado: 'canceled',
+      vencido: 'overdue',
+    };
+
+    return statusMap[status];
+  }
+
+  private mapPaymentMethodToPt(paymentMethodType?: string | null) {
+    const paymentMethodMap = {
+      boleto: 'boleto',
+      pix: 'pix',
+      ted: 'transferencia',
+      doc: 'transferencia',
+      card: 'cartao',
+      cash: 'dinheiro',
+      other: 'transferencia',
+    };
+
+    return paymentMethodMap[paymentMethodType] || undefined;
+  }
+
+  private toCents(value: number) {
+    return Math.round(value * 100);
+  }
+
+  private fromCents(value: number) {
+    return Number((value / 100).toFixed(2));
+  }
+}

package/src/index.ts

@@ -1 +1,5 @@
+export * from './dto/create-financial-title.dto';
+export * from './finance.controller';
 export * from './finance.module';
+export * from './finance.service';
+