@hed-hog/finance 0.0.257 → 0.0.261

package/src/finance.service.ts

@@ -18,14 +18,18 @@ import {
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { CreateBankAccountDto } from './dto/create-bank-account.dto';
+import { CreateBankStatementAdjustmentDto } from './dto/create-bank-statement-adjustment.dto';
 import { CreateCostCenterDto } from './dto/create-cost-center.dto';
 import { CreateFinanceCategoryDto } from './dto/create-finance-category.dto';
 import { CreateFinanceTagDto } from './dto/create-finance-tag.dto';
 import { CreateFinancialTitleDto } from './dto/create-financial-title.dto';
 import { CreatePeriodCloseDto } from './dto/create-period-close.dto';
+import { CreateTransferDto } from './dto/create-transfer.dto';
 import { MoveFinanceCategoryDto } from './dto/move-finance-category.dto';
+import { RegisterCollectionAgreementDto } from './dto/register-collection-agreement.dto';
 import { RejectTitleDto } from './dto/reject-title.dto';
 import { ReverseSettlementDto } from './dto/reverse-settlement.dto';
+import { SendCollectionDto } from './dto/send-collection.dto';
 import { SettleInstallmentDto } from './dto/settle-installment.dto';
 import { UpdateBankAccountDto } from './dto/update-bank-account.dto';
 import { UpdateCostCenterDto } from './dto/update-cost-center.dto';
@@ -829,6 +833,298 @@ export class FinanceService {
     };
   }
 
+  async getAccountsReceivableCollectionsDefault() {
+    const today = this.startOfDay(new Date());
+
+    const overdueInstallments = await this.prisma.financial_installment.findMany({
+      where: {
+        open_amount_cents: {
+          gt: 0,
+        },
+        due_date: {
+          lt: today,
+        },
+        financial_title: {
+          title_type: 'receivable',
+        },
+      },
+      select: {
+        due_date: true,
+        open_amount_cents: true,
+        amount_cents: true,
+        financial_title: {
+          select: {
+            person_id: true,
+            person: {
+              select: {
+                name: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const byCustomer = new Map<
+      number,
+      {
+        clienteId: string;
+        cliente: string;
+        bucket0_30: number;
+        bucket31_60: number;
+        bucket61_90: number;
+        bucket90plus: number;
+        total: number;
+      }
+    >();
+
+    for (const installment of overdueInstallments) {
+      const personId = installment.financial_title.person_id;
+      const personName = installment.financial_title.person?.name || `Cliente ${personId}`;
+      const openAmount =
+        installment.open_amount_cents > 0
+          ? installment.open_amount_cents
+          : installment.amount_cents;
+      const amount = this.fromCents(openAmount);
+      const diffDays = Math.floor(
+        (today.getTime() - this.startOfDay(installment.due_date).getTime()) /
+          86_400_000,
+      );
+
+      if (!byCustomer.has(personId)) {
+        byCustomer.set(personId, {
+          clienteId: String(personId),
+          cliente: personName,
+          bucket0_30: 0,
+          bucket31_60: 0,
+          bucket61_90: 0,
+          bucket90plus: 0,
+          total: 0,
+        });
+      }
+
+      const customer = byCustomer.get(personId)!;
+
+      if (diffDays <= 30) {
+        customer.bucket0_30 += amount;
+      } else if (diffDays <= 60) {
+        customer.bucket31_60 += amount;
+      } else if (diffDays <= 90) {
+        customer.bucket61_90 += amount;
+      } else {
+        customer.bucket90plus += amount;
+      }
+
+      customer.total += amount;
+    }
+
+    const agingInadimplencia = Array.from(byCustomer.values())
+      .map((item) => ({
+        ...item,
+        bucket0_30: Number(item.bucket0_30.toFixed(2)),
+        bucket31_60: Number(item.bucket31_60.toFixed(2)),
+        bucket61_90: Number(item.bucket61_90.toFixed(2)),
+        bucket90plus: Number(item.bucket90plus.toFixed(2)),
+        total: Number(item.total.toFixed(2)),
+      }))
+      .sort((a, b) => b.total - a.total);
+
+    const contactHistory = await this.prisma.audit_log.findMany({
+      where: {
+        entity_table: {
+          in: ['financial_collection_contact', 'financial_collection_agreement'],
+        },
+      },
+      include: {
+        user: {
+          select: {
+            name: true,
+          },
+        },
+      },
+      orderBy: {
+        created_at: 'desc',
+      },
+      take: 500,
+    });
+
+    const historicoContatos = contactHistory.map((log) => {
+      const afterData = this.parseAiJson(log.after_data || '{}');
+
+      return {
+        clienteId: log.entity_id,
+        tipo: this.mapCollectionActionToType(log.action, afterData?.channel),
+        data: log.created_at.toISOString(),
+        descricao: log.summary || '',
+        responsavel: log.user?.name || 'Sistema',
+      };
+    });
+
+    return {
+      agingInadimplencia,
+      historicoContatos,
+    };
+  }
+
+  async sendCollection(personId: number, data: SendCollectionDto, actorUserId?: number) {
+    const person = await this.prisma.person.findUnique({
+      where: {
+        id: personId,
+      },
+      select: {
+        id: true,
+        name: true,
+      },
+    });
+
+    if (!person) {
+      throw new NotFoundException('Person not found');
+    }
+
+    const log = await this.prisma.audit_log.create({
+      data: {
+        actor_user_id: actorUserId || null,
+        action: 'collection_sent',
+        entity_table: 'financial_collection_contact',
+        entity_id: String(person.id),
+        summary: `Cobrança enviada via e-mail para ${person.name}`,
+        after_data: JSON.stringify({
+          message: data.message,
+          subject: data.subject || null,
+        }),
+      },
+    });
+
+    return {
+      id: String(log.id),
+      success: true,
+    };
+  }
+
+  async registerCollectionAgreement(
+    personId: number,
+    data: RegisterCollectionAgreementDto,
+    actorUserId?: number,
+  ) {
+    const person = await this.prisma.person.findUnique({
+      where: {
+        id: personId,
+      },
+      select: {
+        id: true,
+        name: true,
+      },
+    });
+
+    if (!person) {
+      throw new NotFoundException('Person not found');
+    }
+
+    const firstDueDate = new Date(data.first_due_date);
+
+    if (Number.isNaN(firstDueDate.getTime())) {
+      throw new BadRequestException('Invalid first due date');
+    }
+
+    const totalAmountCents = this.toCents(Number(data.amount));
+
+    if (totalAmountCents <= 0) {
+      throw new BadRequestException('Invalid agreement amount');
+    }
+
+    const baseInstallmentCents = Math.floor(totalAmountCents / data.installments);
+    const remainder = totalAmountCents % data.installments;
+
+    const created = await this.prisma.$transaction(async (tx) => {
+      const title = await tx.financial_title.create({
+        data: {
+          person_id: person.id,
+          title_type: 'receivable',
+          status: 'open',
+          document_number: `ACD-${Date.now()}`,
+          description: data.notes || 'Acordo de cobrança',
+          competence_date: firstDueDate,
+          issue_date: new Date(),
+          total_amount_cents: totalAmountCents,
+          created_by_user_id: actorUserId || null,
+        },
+        select: {
+          id: true,
+        },
+      });
+
+      for (let index = 0; index < data.installments; index += 1) {
+        const dueDate = this.addMonths(firstDueDate, index);
+        const amountCents =
+          baseInstallmentCents + (index === data.installments - 1 ? remainder : 0);
+
+        await tx.financial_installment.create({
+          data: {
+            title_id: title.id,
+            installment_number: index + 1,
+            competence_date: dueDate,
+            due_date: dueDate,
+            amount_cents: amountCents,
+            open_amount_cents: amountCents,
+            status: this.resolveInstallmentStatus(
+              amountCents,
+              amountCents,
+              dueDate,
+              'open',
+            ),
+            notes: data.notes || null,
+          },
+        });
+      }
+
+      const log = await tx.audit_log.create({
+        data: {
+          actor_user_id: actorUserId || null,
+          action: 'collection_agreement_registered',
+          entity_table: 'financial_collection_agreement',
+          entity_id: String(person.id),
+          summary: `Acordo registrado para ${person.name}: ${data.installments}x`,
+          after_data: JSON.stringify({
+            title_id: title.id,
+            installments: data.installments,
+            amount: data.amount,
+            first_due_date: data.first_due_date,
+            notes: data.notes || null,
+          }),
+        },
+        select: {
+          id: true,
+        },
+      });
+
+      return {
+        titleId: title.id,
+        auditLogId: log.id,
+      };
+    });
+
+    return {
+      success: true,
+      titleId: String(created.titleId),
+      auditLogId: String(created.auditLogId),
+    };
+  }
+
+  private mapCollectionActionToType(action?: string | null, channel?: string | null) {
+    if (action === 'collection_agreement_registered') {
+      return 'Acordo';
+    }
+
+    if (channel) {
+      const normalized = String(channel).toLowerCase();
+      if (normalized === 'email') return 'E-mail';
+      if (normalized === 'whatsapp') return 'WhatsApp';
+      if (normalized === 'sms') return 'SMS';
+    }
+
+    return 'Contato';
+  }
+
   private calculateDashboardKpis(
     payables: any[],
     receivables: any[],
@@ -922,6 +1218,12 @@ export class FinanceService {
     return next;
   }
 
+  private addMonths(date: Date, months: number) {
+    const next = new Date(date);
+    next.setMonth(next.getMonth() + months);
+    return next;
+  }
+
   async listAccountsPayableInstallments(
     paginationParams: PaginationDTO,
     status?: string,
@@ -1335,6 +1637,228 @@ export class FinanceService {
     return bankAccounts.map((bankAccount) => this.mapBankAccountToFront(bankAccount));
   }
 
+  async listTransfers(filters?: {
+    search?: string;
+    bank_account_id?: string;
+  }) {
+    const search = filters?.search?.trim();
+    const parsedBankAccountId = filters?.bank_account_id
+      ? Number.parseInt(filters.bank_account_id, 10)
+      : undefined;
+    const bankAccountId =
+      parsedBankAccountId && !Number.isNaN(parsedBankAccountId)
+        ? parsedBankAccountId
+        : undefined;
+
+    let transferKeys: string[] | undefined;
+
+    if (search || bankAccountId) {
+      const filteredLines = await this.prisma.bank_statement_line.findMany({
+        where: {
+          external_id: {
+            startsWith: 'transfer:',
+          },
+          ...(search
+            ? {
+                description: {
+                  contains: search,
+                  mode: 'insensitive',
+                },
+              }
+            : {}),
+          ...(bankAccountId ? { bank_account_id: bankAccountId } : {}),
+        },
+        select: {
+          external_id: true,
+        },
+      });
+
+      transferKeys = Array.from(
+        new Set(
+          filteredLines
+            .map((line) => line.external_id)
+            .filter((externalId): externalId is string => !!externalId),
+        ),
+      );
+
+      if (transferKeys.length === 0) {
+        return [];
+      }
+    }
+
+    const transferLines = await this.prisma.bank_statement_line.findMany({
+      where: {
+        ...(transferKeys
+          ? {
+              external_id: {
+                in: transferKeys,
+              },
+            }
+          : {
+              external_id: {
+                startsWith: 'transfer:',
+              },
+            }),
+      },
+      select: {
+        id: true,
+        external_id: true,
+        bank_account_id: true,
+        posted_date: true,
+        amount_cents: true,
+        description: true,
+      },
+      orderBy: [{ posted_date: 'desc' }, { id: 'desc' }],
+    });
+
+    const groupedByTransfer = new Map<string, (typeof transferLines)[number][]>();
+
+    for (const line of transferLines) {
+      const transferKey = line.external_id;
+      if (!transferKey) {
+        continue;
+      }
+
+      const current = groupedByTransfer.get(transferKey) || [];
+      current.push(line);
+      groupedByTransfer.set(transferKey, current);
+    }
+
+    const transfers = Array.from(groupedByTransfer.entries())
+      .map(([transferKey, lines]) => {
+        const sourceLine = lines.find((line) => line.amount_cents < 0);
+        const destinationLine = lines.find((line) => line.amount_cents > 0);
+
+        if (!sourceLine || !destinationLine) {
+          return null;
+        }
+
+        return {
+          id: transferKey.replace('transfer:', ''),
+          contaOrigemId: String(sourceLine.bank_account_id),
+          contaDestinoId: String(destinationLine.bank_account_id),
+          data: sourceLine.posted_date.toISOString(),
+          valor: this.fromCents(Math.abs(sourceLine.amount_cents)),
+          descricao: sourceLine.description || destinationLine.description || '',
+        };
+      })
+      .filter(Boolean);
+
+    return transfers;
+  }
+
+  async createTransfer(data: CreateTransferDto, userId?: number) {
+    const sourceAccountId = Number(data.source_account_id);
+    const destinationAccountId = Number(data.destination_account_id);
+    const amount = Number(data.amount);
+    const postedDate = new Date(data.date);
+
+    if (
+      Number.isNaN(sourceAccountId) ||
+      Number.isNaN(destinationAccountId) ||
+      sourceAccountId <= 0 ||
+      destinationAccountId <= 0
+    ) {
+      throw new BadRequestException('Invalid bank account ids');
+    }
+
+    if (sourceAccountId === destinationAccountId) {
+      throw new BadRequestException(
+        'Source and destination accounts must be different',
+      );
+    }
+
+    if (Number.isNaN(amount) || amount <= 0) {
+      throw new BadRequestException('amount must be greater than zero');
+    }
+
+    if (Number.isNaN(postedDate.getTime())) {
+      throw new BadRequestException('Invalid transfer date');
+    }
+
+    const accounts = await this.prisma.bank_account.findMany({
+      where: {
+        id: {
+          in: [sourceAccountId, destinationAccountId],
+        },
+      },
+      select: {
+        id: true,
+      },
+    });
+
+    if (accounts.length !== 2) {
+      throw new NotFoundException('Bank account not found');
+    }
+
+    const amountCents = this.toCents(amount);
+    const description = data.description?.trim() || 'Transferência bancária';
+    const transferReference = `transfer:${Date.now()}-${Math.round(
+      Math.random() * 1_000_000,
+    )}`;
+
+    await this.prisma.$transaction(async (tx) => {
+      const sourceStatement = await tx.bank_statement.create({
+        data: {
+          bank_account_id: sourceAccountId,
+          source_type: 'manual',
+          imported_at: new Date(),
+          imported_by_user_id: userId,
+          idempotency_key: `${transferReference}:source`,
+          period_start: postedDate,
+          period_end: postedDate,
+        },
+      });
+
+      const destinationStatement = await tx.bank_statement.create({
+        data: {
+          bank_account_id: destinationAccountId,
+          source_type: 'manual',
+          imported_at: new Date(),
+          imported_by_user_id: userId,
+          idempotency_key: `${transferReference}:destination`,
+          period_start: postedDate,
+          period_end: postedDate,
+        },
+      });
+
+      await tx.bank_statement_line.create({
+        data: {
+          bank_statement_id: sourceStatement.id,
+          bank_account_id: sourceAccountId,
+          external_id: transferReference,
+          posted_date: postedDate,
+          amount_cents: -Math.abs(amountCents),
+          description,
+          status: 'reconciled',
+          dedupe_key: `${transferReference}:source`,
+        },
+      });
+
+      await tx.bank_statement_line.create({
+        data: {
+          bank_statement_id: destinationStatement.id,
+          bank_account_id: destinationAccountId,
+          external_id: transferReference,
+          posted_date: postedDate,
+          amount_cents: Math.abs(amountCents),
+          description,
+          status: 'reconciled',
+          dedupe_key: `${transferReference}:destination`,
+        },
+      });
+    });
+
+    return {
+      id: transferReference.replace('transfer:', ''),
+      contaOrigemId: String(sourceAccountId),
+      contaDestinoId: String(destinationAccountId),
+      data: postedDate.toISOString(),
+      valor: amount,
+      descricao: description,
+    };
+  }
+
   async listCostCenters() {
     const costCenters = await this.prisma.cost_center.findMany({
       orderBy: [{ code: 'asc' }, { name: 'asc' }],
@@ -1550,10 +2074,20 @@ export class FinanceService {
     };
   }
 
-  async listBankStatements(bankAccountId?: number) {
+  async listBankStatements(bankAccountId?: number, search?: string) {
+    const trimmedSearch = search?.trim();
+
     const statements = await this.prisma.bank_statement_line.findMany({
       where: {
         ...(bankAccountId ? { bank_account_id: bankAccountId } : {}),
+        ...(trimmedSearch
+          ? {
+              description: {
+                contains: trimmedSearch,
+                mode: 'insensitive',
+              },
+            }
+          : {}),
       },
       include: {
         bank_account: {
@@ -1576,8 +2110,83 @@ export class FinanceService {
     }));
   }
 
-  async exportBankStatementsCsv(bankAccountId: number) {
-    const statements = await this.listBankStatements(bankAccountId);
+  async getBankReconciliationSummary(bankAccountId: number) {
+    const pendingStatements = await this.prisma.bank_statement_line.findMany({
+      where: {
+        bank_account_id: bankAccountId,
+        status: {
+          in: ['pending', 'imported'],
+        },
+      },
+      select: {
+        amount_cents: true,
+      },
+    });
+
+    const openInstallments = await this.prisma.financial_installment.findMany({
+      where: {
+        open_amount_cents: {
+          gt: 0,
+        },
+        status: {
+          in: ['open', 'partial', 'overdue'],
+        },
+        financial_title: {
+          status: {
+            in: ['open', 'partial', 'overdue'],
+          },
+          title_type: {
+            in: ['payable', 'receivable'],
+          },
+        },
+      },
+      select: {
+        open_amount_cents: true,
+        financial_title: {
+          select: {
+            title_type: true,
+          },
+        },
+      },
+    });
+
+    const payableAmounts = new Set<number>();
+    const receivableAmounts = new Set<number>();
+
+    for (const installment of openInstallments) {
+      const amount = Math.abs(installment.open_amount_cents);
+      if (installment.financial_title.title_type === 'payable') {
+        payableAmounts.add(amount);
+      } else if (installment.financial_title.title_type === 'receivable') {
+        receivableAmounts.add(amount);
+      }
+    }
+
+    let discrepancyCount = 0;
+    let differenceCents = 0;
+
+    for (const statement of pendingStatements) {
+      const normalizedAmount = Math.abs(statement.amount_cents);
+      differenceCents += statement.amount_cents;
+
+      const hasPossibleMatch =
+        statement.amount_cents < 0
+          ? payableAmounts.has(normalizedAmount)
+          : receivableAmounts.has(normalizedAmount);
+
+      if (!hasPossibleMatch) {
+        discrepancyCount += 1;
+      }
+    }
+
+    return {
+      discrepancies: discrepancyCount,
+      difference: this.fromCents(differenceCents),
+    };
+  }
+
+  async exportBankStatementsCsv(bankAccountId: number, search?: string) {
+    const statements = await this.listBankStatements(bankAccountId, search);
 
     const headers = [
       'id',
@@ -1614,6 +2223,79 @@ export class FinanceService {
     };
   }
 
+  async createBankStatementAdjustment(
+    data: CreateBankStatementAdjustmentDto,
+    userId?: number,
+  ) {
+    const bankAccountId = Number(data.bank_account_id);
+    const amount = Number(data.amount);
+    const postedAt = data.date ? new Date(data.date) : new Date();
+
+    if (Number.isNaN(bankAccountId) || bankAccountId <= 0) {
+      throw new BadRequestException('bank_account_id is required');
+    }
+
+    if (Number.isNaN(amount) || amount <= 0) {
+      throw new BadRequestException('amount must be greater than zero');
+    }
+
+    if (Number.isNaN(postedAt.getTime())) {
+      throw new BadRequestException('Invalid adjustment date');
+    }
+
+    const bankAccount = await this.prisma.bank_account.findUnique({
+      where: { id: bankAccountId },
+      select: { id: true },
+    });
+
+    if (!bankAccount) {
+      throw new NotFoundException('Bank account not found');
+    }
+
+    const adjustedAmountCents = -Math.abs(this.toCents(amount));
+    const description = data.description?.trim() || `Ajuste: ${data.type}`;
+    const reference = `adjustment:${Date.now()}-${Math.round(Math.random() * 1_000_000)}`;
+
+    const created = await this.prisma.$transaction(async (tx) => {
+      const statement = await tx.bank_statement.create({
+        data: {
+          bank_account_id: bankAccountId,
+          source_type: 'manual',
+          imported_at: new Date(),
+          imported_by_user_id: userId,
+          idempotency_key: reference,
+          period_start: postedAt,
+          period_end: postedAt,
+        },
+      });
+
+      const line = await tx.bank_statement_line.create({
+        data: {
+          bank_statement_id: statement.id,
+          bank_account_id: bankAccountId,
+          external_id: reference,
+          posted_date: postedAt,
+          amount_cents: adjustedAmountCents,
+          description,
+          status: 'adjusted',
+          dedupe_key: reference,
+        },
+      });
+
+      return line;
+    });
+
+    return {
+      id: String(created.id),
+      contaBancariaId: String(created.bank_account_id),
+      data: created.posted_date.toISOString(),
+      descricao: created.description,
+      valor: this.fromCents(created.amount_cents),
+      tipo: created.amount_cents >= 0 ? 'entrada' : 'saida',
+      statusConciliacao: this.mapStatementStatusToPt(created.status),
+    };
+  }
+
   async importBankStatements(
     bankAccountId: number,
     file: MulterFile,
@@ -3319,6 +4001,83 @@ export class FinanceService {
         },
       });
 
+      let reconciliationId: number | null = null;
+
+      if (data.bank_statement_line_id) {
+        const statementLine = await tx.bank_statement_line.findUnique({
+          where: {
+            id: data.bank_statement_line_id,
+          },
+          select: {
+            id: true,
+            bank_account_id: true,
+            amount_cents: true,
+            status: true,
+          },
+        });
+
+        if (!statementLine) {
+          throw new NotFoundException('Bank statement line not found');
+        }
+
+        if (
+          data.bank_account_id &&
+          statementLine.bank_account_id !== data.bank_account_id
+        ) {
+          throw new ConflictException(
+            'Bank statement line does not belong to informed bank account',
+          );
+        }
+
+        if (Math.abs(statementLine.amount_cents) !== amountCents) {
+          throw new ConflictException(
+            'Bank statement amount and settlement amount must match',
+          );
+        }
+
+        const hasReconciliation = await tx.bank_reconciliation.findFirst({
+          where: {
+            bank_statement_line_id: statementLine.id,
+            status: 'reconciled',
+          },
+          select: {
+            id: true,
+          },
+        });
+
+        if (hasReconciliation) {
+          throw new ConflictException('Bank statement line already reconciled');
+        }
+
+        const createdReconciliation = await tx.bank_reconciliation.create({
+          data: {
+            bank_statement_line_id: statementLine.id,
+            settlement_id: settlement.id,
+            status: 'reconciled',
+            matched_at: settledAt,
+            reconciled_at: settledAt,
+            matched_by_user_id: userId || null,
+            reconciled_by_user_id: userId || null,
+          },
+          select: {
+            id: true,
+          },
+        });
+
+        reconciliationId = createdReconciliation.id;
+
+        if (statementLine.status !== 'reconciled') {
+          await tx.bank_statement_line.update({
+            where: {
+              id: statementLine.id,
+            },
+            data: {
+              status: 'reconciled',
+            },
+          });
+        }
+      }
+
       await tx.settlement_allocation.create({
         data: {
           settlement: {
@@ -3410,6 +4169,7 @@ export class FinanceService {
           title_status: nextTitleStatus,
           installment_open_amount_cents: updatedInstallment.open_amount_cents,
           settlement_id: settlement.id,
+          bank_reconciliation_id: reconciliationId,
         }),
       });
 
@@ -3428,12 +4188,16 @@ export class FinanceService {
         return {
           title: updatedTitle,
           settlementId: settlement.id,
+          reconciliationId,
         };
       });
 
       return {
         ...this.mapTitleToFront(result.title),
         settlementId: String(result.settlementId),
+        reconciliationId: result.reconciliationId
+          ? String(result.reconciliationId)
+          : null,
       };
     } catch (error: any) {
       const message = String(error?.message || '');
@@ -4234,8 +4998,14 @@ export class FinanceService {
         paymentChannelOverride ||
         'transferencia',
       ...(title.title_type === 'payable'
-        ? { fornecedorId: String(title.person_id) }
-        : { clienteId: String(title.person_id) }),
+        ? {
+            fornecedorId: String(title.person_id),
+            fornecedor: title.person?.name || '',
+          }
+        : {
+            clienteId: String(title.person_id),
+            cliente: title.person?.name || '',
+          }),
     };
   }