@hed-hog/finance 0.0.261 → 0.0.266

package/src/finance.service.ts

@@ -1,19 +1,19 @@
 import { getLocaleText } from '@hed-hog/api-locale';
 import {
-    PageOrderDirection,
-    PaginationDTO,
-    PaginationService,
+  PageOrderDirection,
+  PaginationDTO,
+  PaginationService,
 } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
-import { AiService, FileService } from '@hed-hog/core';
+import { AiService, FileService, SettingService } from '@hed-hog/core';
 import {
-    BadRequestException,
-    ConflictException,
-    forwardRef,
-    Inject,
-    Injectable,
-    Logger,
-    NotFoundException,
+  BadRequestException,
+  ConflictException,
+  forwardRef,
+  Inject,
+  Injectable,
+  Logger,
+  NotFoundException,
 } from '@nestjs/common';
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
@@ -50,6 +50,25 @@ type TitleStatus =
   | 'canceled'
   | 'overdue';
 
+type ForecastScenario = 'base' | 'pessimista' | 'otimista';
+
+type FinancialScenarioConfig = {
+  id: ForecastScenario;
+  nome: string;
+  descricao: string;
+  atrasoMedio: number;
+  taxaInadimplencia: number;
+  crescimentoReceita: number;
+  padrao: boolean;
+};
+
+type FinancialScenarioSettings = {
+  defaultScenario: ForecastScenario;
+  defaultHorizonDays: number;
+  cenarios: FinancialScenarioConfig[];
+  map: Record<ForecastScenario, FinancialScenarioConfig>;
+};
+
 @Injectable()
 export class FinanceService {
   private readonly logger = new Logger(FinanceService.name);
@@ -58,6 +77,8 @@ export class FinanceService {
     private readonly prisma: PrismaService,
     private readonly paginationService: PaginationService,
     private readonly ai: AiService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
     @Inject(forwardRef(() => FileService))
     private readonly fileService: FileService,
   ) {}
@@ -727,7 +748,9 @@ export class FinanceService {
     return Number.isFinite(num) ? num : null;
   }
 
-  async getData() {
+  async getData(filters?: { horizonteDias?: string | number; cenario?: string }) {
+    const today = this.startOfDay(new Date());
+
     const [
       payablesResult,
       receivablesResult,
@@ -735,9 +758,13 @@ export class FinanceService {
       categoriesResult,
       costCentersResult,
       bankAccountsResult,
+      bankStatementsResult,
+      collectionsDefaultResult,
       tagsResult,
       auditLogsResult,
       openPeriodResult,
+      scenarioSettingsResult,
+      confirmedSettlementsResult,
     ] = await Promise.allSettled([
       this.loadTitles('payable'),
       this.loadTitles('receivable'),
@@ -745,9 +772,13 @@ export class FinanceService {
       this.loadCategories(),
       this.loadCostCenters(),
       this.loadBankAccounts(),
+      this.listBankStatements(),
+      this.getAccountsReceivableCollectionsDefault(),
       this.loadTags(),
       this.loadAuditLogs(),
       this.loadOpenPeriod(),
+      this.loadFinancialScenarioSettings(),
+      this.loadConfirmedSettlements(today, this.addDays(today, 365)),
     ]);
 
     const payables = payablesResult.status === 'fulfilled' ? payablesResult.value : [];
@@ -760,11 +791,40 @@ export class FinanceService {
       costCentersResult.status === 'fulfilled' ? costCentersResult.value : [];
     const bankAccounts =
       bankAccountsResult.status === 'fulfilled' ? bankAccountsResult.value : [];
+    const bankStatements =
+      bankStatementsResult.status === 'fulfilled'
+        ? bankStatementsResult.value
+        : [];
+    const collectionsDefault =
+      collectionsDefaultResult.status === 'fulfilled'
+        ? collectionsDefaultResult.value
+        : {
+            agingInadimplencia: [],
+            historicoContatos: [],
+          };
     const tags = tagsResult.status === 'fulfilled' ? tagsResult.value : [];
     const auditLogs =
       auditLogsResult.status === 'fulfilled' ? auditLogsResult.value : [];
     const openPeriod =
       openPeriodResult.status === 'fulfilled' ? openPeriodResult.value : null;
+    const confirmedSettlements =
+      confirmedSettlementsResult.status === 'fulfilled'
+        ? confirmedSettlementsResult.value
+        : [];
+    const scenarioSettings =
+      scenarioSettingsResult.status === 'fulfilled'
+        ? scenarioSettingsResult.value
+        : this.getDefaultFinancialScenarioSettings();
+
+    const horizonteDias = this.resolveHorizonDays(
+      filters?.horizonteDias,
+      scenarioSettings.defaultHorizonDays,
+    );
+    const cenario = this.resolveForecastScenario(
+      filters?.cenario,
+      scenarioSettings.defaultScenario,
+    );
+    const forecastEnd = this.addDays(today, horizonteDias);
 
     if (payablesResult.status === 'rejected') {
       this.logger.error('Failed to load finance payables', payablesResult.reason);
@@ -784,6 +844,18 @@ export class FinanceService {
     if (bankAccountsResult.status === 'rejected') {
       this.logger.error('Failed to load finance bank accounts', bankAccountsResult.reason);
     }
+    if (bankStatementsResult.status === 'rejected') {
+      this.logger.error(
+        'Failed to load finance bank statements',
+        bankStatementsResult.reason,
+      );
+    }
+    if (collectionsDefaultResult.status === 'rejected') {
+      this.logger.error(
+        'Failed to load finance collections default',
+        collectionsDefaultResult.reason,
+      );
+    }
     if (tagsResult.status === 'rejected') {
       this.logger.error('Failed to load finance tags', tagsResult.reason);
     }
@@ -793,6 +865,18 @@ export class FinanceService {
     if (openPeriodResult.status === 'rejected') {
       this.logger.error('Failed to load finance open period', openPeriodResult.reason);
     }
+    if (confirmedSettlementsResult.status === 'rejected') {
+      this.logger.error(
+        'Failed to load finance confirmed settlements',
+        confirmedSettlementsResult.reason,
+      );
+    }
+    if (scenarioSettingsResult.status === 'rejected') {
+      this.logger.error(
+        'Failed to load finance scenario settings',
+        scenarioSettingsResult.reason,
+      );
+    }
 
     const aprovacoesPendentes = payables
       .filter((title: any) => title.status === 'rascunho')
@@ -807,32 +891,581 @@ export class FinanceService {
       }));
 
     const kpis = this.calculateDashboardKpis(payables, receivables, bankAccounts);
+    const { recebiveis, adquirentes } =
+      this.buildReceivablesCalendarData(receivables);
+    const { fluxoCaixaPrevisto, entradasPrevistas, saidasPrevistas } =
+      this.buildCashFlowForecastData(
+        payables,
+        receivables,
+        confirmedSettlements,
+        kpis.saldoCaixa,
+        today,
+        forecastEnd,
+        scenarioSettings.map[cenario],
+      );
 
     return {
       kpis,
-      fluxoCaixaPrevisto: [],
+      defaultScenario: scenarioSettings.defaultScenario,
+      defaultHorizonDays: scenarioSettings.defaultHorizonDays,
+      fluxoCaixaPrevisto,
       titulosPagar: payables,
       titulosReceber: receivables,
-      extratos: [],
+      extratos: bankStatements,
       contasBancarias: bankAccounts,
       pessoas: people,
       categorias: categories,
       centrosCusto: costCenters,
       aprovacoesPendentes,
-      agingInadimplencia: [],
-      cenarios: [],
+      agingInadimplencia: collectionsDefault.agingInadimplencia,
+      cenarios: scenarioSettings.cenarios,
       transferencias: [],
       tags,
       logsAuditoria: auditLogs,
-      recebiveis: [],
-      adquirentes: [],
-      historicoContatos: [],
-      entradasPrevistas: [],
-      saidasPrevistas: [],
+      recebiveis,
+      adquirentes,
+      historicoContatos: collectionsDefault.historicoContatos,
+      entradasPrevistas,
+      saidasPrevistas,
       periodoAberto: openPeriod,
     };
   }
 
+  async updateScenarioSettings(
+    scenario: string,
+    data: {
+      atrasoMedio: number;
+      taxaInadimplencia: number;
+      crescimentoReceita: number;
+      setAsDefault?: boolean;
+    },
+  ) {
+    const scenarioSlug = this.resolveForecastScenarioStrict(scenario);
+
+    if (data.atrasoMedio < 0 || data.atrasoMedio > 365) {
+      throw new BadRequestException('Invalid average delay value');
+    }
+
+    if (data.taxaInadimplencia < 0 || data.taxaInadimplencia > 100) {
+      throw new BadRequestException('Invalid default rate value');
+    }
+
+    if (data.crescimentoReceita < -100 || data.crescimentoReceita > 1000) {
+      throw new BadRequestException('Invalid revenue growth value');
+    }
+
+    const prefix = `finance-scenario-${
+      scenarioSlug === 'pessimista'
+        ? 'pessimistic'
+        : scenarioSlug === 'otimista'
+          ? 'optimistic'
+          : 'base'
+    }`;
+
+    const settingUpdates: Array<{ slug: string; value: string }> = [
+      {
+        slug: `${prefix}-average-delay-days`,
+        value: String(data.atrasoMedio),
+      },
+      {
+        slug: `${prefix}-default-rate-percent`,
+        value: String(data.taxaInadimplencia),
+      },
+      {
+        slug: `${prefix}-revenue-growth-percent`,
+        value: String(data.crescimentoReceita),
+      },
+    ];
+
+    if (data.setAsDefault !== false) {
+      settingUpdates.push({
+        slug: 'finance-default-scenario',
+        value: scenarioSlug,
+      });
+    }
+
+    await this.settingService.setManySettings({
+      setting: settingUpdates,
+    } as any);
+
+    const settings = await this.loadFinancialScenarioSettings();
+    return {
+      success: true,
+      cenarios: settings.cenarios,
+      defaultScenario: settings.defaultScenario,
+    };
+  }
+
+  private resolveHorizonDays(value?: string | number, fallback = 90) {
+    const parsed = Number(value);
+    const allowed = new Set([30, 60, 90, 180, 365]);
+
+    if (!Number.isFinite(parsed)) {
+      return allowed.has(fallback) ? fallback : 90;
+    }
+
+    return allowed.has(parsed) ? parsed : allowed.has(fallback) ? fallback : 90;
+  }
+
+  private resolveForecastScenario(
+    value?: string,
+    fallback: ForecastScenario = 'base',
+  ): ForecastScenario {
+    if (value === 'pessimista') {
+      return 'pessimista';
+    }
+
+    if (value === 'otimista') {
+      return 'otimista';
+    }
+
+    return fallback;
+  }
+
+  private resolveForecastScenarioStrict(value?: string): ForecastScenario {
+    if (value === 'base' || value === 'pessimista' || value === 'otimista') {
+      return value;
+    }
+
+    throw new BadRequestException('Invalid scenario');
+  }
+
+  private buildCashFlowForecastData(
+    payables: any[],
+    receivables: any[],
+    confirmedSettlements: Array<{
+      settled_at: Date;
+      amount_cents: bigint;
+      settlement_type: string;
+    }>,
+    initialBalance: number,
+    fromDate: Date,
+    toDate: Date,
+    scenarioConfig: FinancialScenarioConfig,
+  ) {
+    const scenarioMultiplier = this.resolveScenarioMultiplier(scenarioConfig);
+
+    const entradasPrevistas = this.buildExpectedCashFlowEntries(
+      receivables,
+      fromDate,
+      toDate,
+      'inflow',
+    ).map((item) => ({
+      ...item,
+      valor: Number((item.valor * scenarioMultiplier.inflow).toFixed(2)),
+    }));
+
+    const saidasPrevistas = this.buildExpectedCashFlowEntries(
+      payables,
+      fromDate,
+      toDate,
+      'outflow',
+    ).map((item) => ({
+      ...item,
+      valor: Number((item.valor * scenarioMultiplier.outflow).toFixed(2)),
+    }));
+
+    const expectedByDate = new Map<
+      string,
+      { entradas: number; saidas: number; realizado: number }
+    >();
+
+    for (const entry of entradasPrevistas) {
+      const dateKey = entry.vencimento.slice(0, 10);
+      const current = expectedByDate.get(dateKey) || {
+        entradas: 0,
+        saidas: 0,
+        realizado: 0,
+      };
+      current.entradas = Number((current.entradas + Number(entry.valor || 0)).toFixed(2));
+      expectedByDate.set(dateKey, current);
+    }
+
+    for (const outflow of saidasPrevistas) {
+      const dateKey = outflow.vencimento.slice(0, 10);
+      const current = expectedByDate.get(dateKey) || {
+        entradas: 0,
+        saidas: 0,
+        realizado: 0,
+      };
+      current.saidas = Number((current.saidas + Number(outflow.valor || 0)).toFixed(2));
+      expectedByDate.set(dateKey, current);
+    }
+
+    for (const settlement of confirmedSettlements) {
+      const dateKey = settlement.settled_at.toISOString().slice(0, 10);
+      const current = expectedByDate.get(dateKey) || {
+        entradas: 0,
+        saidas: 0,
+        realizado: 0,
+      };
+
+      const amount = this.fromCents(settlement.amount_cents);
+      if (settlement.settlement_type === 'payable') {
+        current.realizado = Number((current.realizado - amount).toFixed(2));
+      } else if (settlement.settlement_type === 'receivable') {
+        current.realizado = Number((current.realizado + amount).toFixed(2));
+      }
+
+      expectedByDate.set(dateKey, current);
+    }
+
+    const fluxoCaixaPrevisto: Array<{
+      data: string;
+      saldoPrevisto: number;
+      saldoRealizado: number;
+    }> = [];
+
+    let runningProjectedBalance = Number(initialBalance || 0);
+    let runningActualBalance = Number(initialBalance || 0);
+
+    for (
+      let cursor = this.startOfDay(fromDate);
+      cursor <= toDate;
+      cursor = this.addDays(cursor, 1)
+    ) {
+      const key = cursor.toISOString().slice(0, 10);
+      const dayData = expectedByDate.get(key) || {
+        entradas: 0,
+        saidas: 0,
+        realizado: 0,
+      };
+
+      runningProjectedBalance = Number(
+        (runningProjectedBalance + dayData.entradas - dayData.saidas).toFixed(2),
+      );
+      runningActualBalance = Number(
+        (runningActualBalance + dayData.realizado).toFixed(2),
+      );
+
+      fluxoCaixaPrevisto.push({
+        data: cursor.toISOString(),
+        saldoPrevisto: runningProjectedBalance,
+        saldoRealizado: runningActualBalance,
+      });
+    }
+
+    return {
+      fluxoCaixaPrevisto,
+      entradasPrevistas,
+      saidasPrevistas,
+    };
+  }
+
+  private resolveScenarioMultiplier(scenarioConfig: FinancialScenarioConfig) {
+    const growthRate = scenarioConfig.crescimentoReceita / 100;
+    const defaultRate = scenarioConfig.taxaInadimplencia / 100;
+    const delayImpact = Math.max(0.5, 1 - scenarioConfig.atrasoMedio / 100);
+
+    const inflow = this.clampNumber(
+      (1 + growthRate) * (1 - defaultRate) * delayImpact,
+      0.1,
+      3,
+    );
+
+    const outflow = this.clampNumber(
+      1 + Math.max(0, -growthRate) * 0.4 + defaultRate * 0.2,
+      0.1,
+      3,
+    );
+
+    return {
+      inflow,
+      outflow,
+    };
+  }
+
+  private clampNumber(value: number, min: number, max: number) {
+    if (!Number.isFinite(value)) {
+      return min;
+    }
+
+    return Math.min(max, Math.max(min, value));
+  }
+
+  private async loadFinancialScenarioSettings(): Promise<FinancialScenarioSettings> {
+    const defaultSettings = this.getDefaultFinancialScenarioSettings();
+    const values = await this.settingService.getSettingValues([
+      'finance-default-scenario',
+      'finance-default-horizon-days',
+      'finance-scenario-base-average-delay-days',
+      'finance-scenario-base-default-rate-percent',
+      'finance-scenario-base-revenue-growth-percent',
+      'finance-scenario-pessimistic-average-delay-days',
+      'finance-scenario-pessimistic-default-rate-percent',
+      'finance-scenario-pessimistic-revenue-growth-percent',
+      'finance-scenario-optimistic-average-delay-days',
+      'finance-scenario-optimistic-default-rate-percent',
+      'finance-scenario-optimistic-revenue-growth-percent',
+    ]);
+
+    const base: FinancialScenarioConfig = {
+      ...defaultSettings.map.base,
+      atrasoMedio: this.numberSetting(
+        values['finance-scenario-base-average-delay-days'],
+        defaultSettings.map.base.atrasoMedio,
+      ),
+      taxaInadimplencia: this.numberSetting(
+        values['finance-scenario-base-default-rate-percent'],
+        defaultSettings.map.base.taxaInadimplencia,
+      ),
+      crescimentoReceita: this.numberSetting(
+        values['finance-scenario-base-revenue-growth-percent'],
+        defaultSettings.map.base.crescimentoReceita,
+      ),
+      padrao: false,
+    };
+
+    const pessimista: FinancialScenarioConfig = {
+      ...defaultSettings.map.pessimista,
+      atrasoMedio: this.numberSetting(
+        values['finance-scenario-pessimistic-average-delay-days'],
+        defaultSettings.map.pessimista.atrasoMedio,
+      ),
+      taxaInadimplencia: this.numberSetting(
+        values['finance-scenario-pessimistic-default-rate-percent'],
+        defaultSettings.map.pessimista.taxaInadimplencia,
+      ),
+      crescimentoReceita: this.numberSetting(
+        values['finance-scenario-pessimistic-revenue-growth-percent'],
+        defaultSettings.map.pessimista.crescimentoReceita,
+      ),
+      padrao: false,
+    };
+
+    const otimista: FinancialScenarioConfig = {
+      ...defaultSettings.map.otimista,
+      atrasoMedio: this.numberSetting(
+        values['finance-scenario-optimistic-average-delay-days'],
+        defaultSettings.map.otimista.atrasoMedio,
+      ),
+      taxaInadimplencia: this.numberSetting(
+        values['finance-scenario-optimistic-default-rate-percent'],
+        defaultSettings.map.otimista.taxaInadimplencia,
+      ),
+      crescimentoReceita: this.numberSetting(
+        values['finance-scenario-optimistic-revenue-growth-percent'],
+        defaultSettings.map.otimista.crescimentoReceita,
+      ),
+      padrao: false,
+    };
+
+    const defaultScenario = this.resolveForecastScenario(
+      String(values['finance-default-scenario'] || ''),
+      defaultSettings.defaultScenario,
+    );
+
+    const cenarios = [base, pessimista, otimista].map((item) => ({
+      ...item,
+      padrao: item.id === defaultScenario,
+    }));
+
+    const map = {
+      base: cenarios.find((item) => item.id === 'base') || defaultSettings.map.base,
+      pessimista:
+        cenarios.find((item) => item.id === 'pessimista') ||
+        defaultSettings.map.pessimista,
+      otimista:
+        cenarios.find((item) => item.id === 'otimista') ||
+        defaultSettings.map.otimista,
+    } as Record<ForecastScenario, FinancialScenarioConfig>;
+
+    return {
+      defaultScenario,
+      defaultHorizonDays: this.resolveHorizonDays(
+        values['finance-default-horizon-days'],
+        defaultSettings.defaultHorizonDays,
+      ),
+      cenarios,
+      map,
+    };
+  }
+
+  private getDefaultFinancialScenarioSettings(): FinancialScenarioSettings {
+    const base: FinancialScenarioConfig = {
+      id: 'base',
+      nome: 'Base',
+      descricao: 'Cenário de referência para projeções',
+      atrasoMedio: 5,
+      taxaInadimplencia: 3,
+      crescimentoReceita: 5,
+      padrao: true,
+    };
+
+    const pessimista: FinancialScenarioConfig = {
+      id: 'pessimista',
+      nome: 'Pessimista',
+      descricao: 'Premissas conservadoras com maior risco',
+      atrasoMedio: 12,
+      taxaInadimplencia: 6,
+      crescimentoReceita: -5,
+      padrao: false,
+    };
+
+    const otimista: FinancialScenarioConfig = {
+      id: 'otimista',
+      nome: 'Otimista',
+      descricao: 'Premissas favoráveis de crescimento',
+      atrasoMedio: 2,
+      taxaInadimplencia: 1.5,
+      crescimentoReceita: 10,
+      padrao: false,
+    };
+
+    const cenarios = [base, pessimista, otimista];
+
+    return {
+      defaultScenario: 'base',
+      defaultHorizonDays: 90,
+      cenarios,
+      map: {
+        base,
+        pessimista,
+        otimista,
+      },
+    };
+  }
+
+  private numberSetting(value: any, fallback: number) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+
+  private buildExpectedCashFlowEntries(
+    titles: any[],
+    fromDate: Date,
+    toDate: Date,
+    direction: 'inflow' | 'outflow',
+  ) {
+    return (titles || [])
+      .flatMap((title) =>
+        (title?.parcelas || [])
+          .filter((installment) => {
+            const dueDate = this.startOfDay(new Date(installment.vencimento));
+            if (Number.isNaN(dueDate.getTime())) return false;
+
+            const openAmount = Number(installment.valorAberto || 0);
+            const status = String(installment.status || '').toLowerCase();
+            const isOpen =
+              status === 'aberto' || status === 'vencido' || status === 'parcial';
+
+            return (
+              dueDate >= fromDate &&
+              dueDate <= toDate &&
+              isOpen &&
+              openAmount > 0
+            );
+          })
+          .map((installment) => ({
+            categoria:
+              title?.descricao ||
+              (direction === 'inflow' ? title?.cliente : title?.fornecedor) ||
+              'Sem categoria',
+            vencimento: installment.vencimento,
+            valor: Number(installment.valorAberto || installment.valor || 0),
+          })),
+      )
+      .sort(
+        (a, b) =>
+          new Date(a.vencimento).getTime() - new Date(b.vencimento).getTime(),
+      );
+  }
+
+  private buildReceivablesCalendarData(receivables: any[]) {
+    const recebiveis = receivables
+      .flatMap((title: any) =>
+        (title.parcelas || []).map((installment: any) => {
+          const bruto = Number(installment.valor || 0);
+          const canal = this.mapReceivableChannelLabel(
+            installment.metodoPagamento || title.canal,
+          );
+          const taxaPercentual =
+            canal === 'Cartão'
+              ? 0.03
+              : canal === 'Boleto'
+                ? 0.015
+                : canal === 'Pix'
+                  ? 0.005
+                  : 0.01;
+          const taxas = Number((bruto * taxaPercentual).toFixed(2));
+          const liquido = Number((bruto - taxas).toFixed(2));
+
+          return {
+            id: `${title.id}-${installment.id}`,
+            canal,
+            adquirente: title.cliente || '-',
+            dataPrevista: installment.vencimento,
+            bruto,
+            taxas,
+            liquido,
+            status: this.mapReceivableCalendarStatus(installment.status),
+          };
+        }),
+      )
+      .sort(
+        (a, b) =>
+          new Date(a.dataPrevista).getTime() - new Date(b.dataPrevista).getTime(),
+      );
+
+    const adquirenteMap = new Map<
+      string,
+      { nome: string; transacoes: number; total: number }
+    >();
+
+    for (const recebivel of recebiveis) {
+      const current = adquirenteMap.get(recebivel.adquirente) || {
+        nome: recebivel.adquirente,
+        transacoes: 0,
+        total: 0,
+      };
+
+      current.transacoes += 1;
+      current.total = Number((current.total + recebivel.liquido).toFixed(2));
+      adquirenteMap.set(recebivel.adquirente, current);
+    }
+
+    const adquirentes = Array.from(adquirenteMap.values()).sort(
+      (a, b) => b.total - a.total,
+    );
+
+    return {
+      recebiveis,
+      adquirentes,
+    };
+  }
+
+  private mapReceivableCalendarStatus(status?: string | null) {
+    const normalized = (status || '').toLowerCase();
+
+    if (normalized === 'liquidado') {
+      return 'liquidado';
+    }
+
+    if (['aberto', 'aprovado', 'parcial'].includes(normalized)) {
+      return 'confirmado';
+    }
+
+    return 'pendente';
+  }
+
+  private mapReceivableChannelLabel(channel?: string | null) {
+    const normalized = (channel || '').toLowerCase();
+    const channelMap: Record<string, string> = {
+      cartao: 'Cartão',
+      cartão: 'Cartão',
+      pix: 'Pix',
+      boleto: 'Boleto',
+      transferencia: 'Transferência',
+      transferência: 'Transferência',
+      ted: 'Transferência',
+      doc: 'Transferência',
+      dinheiro: 'Dinheiro',
+      cheque: 'Cheque',
+    };
+
+    return channelMap[normalized] || 'Transferência';
+  }
+
   async getAccountsReceivableCollectionsDefault() {
     const today = this.startOfDay(new Date());
 
@@ -1036,6 +1669,12 @@ export class FinanceService {
     const remainder = totalAmountCents % data.installments;
 
     const created = await this.prisma.$transaction(async (tx) => {
+      await this.assertDateNotInClosedPeriod(
+        tx,
+        firstDueDate,
+        'register collection agreement',
+      );
+
       const title = await tx.financial_title.create({
         data: {
           person_id: person.id,
@@ -1058,6 +1697,12 @@ export class FinanceService {
         const amountCents =
           baseInstallmentCents + (index === data.installments - 1 ? remainder : 0);
 
+        await this.assertDateNotInClosedPeriod(
+          tx,
+          dueDate,
+          'register collection agreement installment',
+        );
+
         await tx.financial_installment.create({
           data: {
             title_id: title.id,
@@ -1798,6 +2443,8 @@ export class FinanceService {
     )}`;
 
     await this.prisma.$transaction(async (tx) => {
+      await this.assertDateNotInClosedPeriod(tx, postedDate, 'create transfer');
+
       const sourceStatement = await tx.bank_statement.create({
         data: {
           bank_account_id: sourceAccountId,
@@ -2257,6 +2904,12 @@ export class FinanceService {
     const reference = `adjustment:${Date.now()}-${Math.round(Math.random() * 1_000_000)}`;
 
     const created = await this.prisma.$transaction(async (tx) => {
+      await this.assertDateNotInClosedPeriod(
+        tx,
+        postedAt,
+        'create bank statement adjustment',
+      );
+
       const statement = await tx.bank_statement.create({
         data: {
           bank_account_id: bankAccountId,
@@ -2393,35 +3046,53 @@ export class FinanceService {
       24,
     );
 
-    const statement = await this.prisma.bank_statement.create({
-      data: {
-        bank_account_id: bankAccountId,
-        source_type: sourceType,
-        idempotency_key: `import-${uploadedFile.id}-${statementFingerprint}`,
-        period_start: normalizedEntries
-          .map((entry) => entry.postedDate)
-          .sort((a, b) => a.getTime() - b.getTime())[0],
-        period_end: normalizedEntries
-          .map((entry) => entry.postedDate)
-          .sort((a, b) => b.getTime() - a.getTime())[0],
-        imported_at: new Date(),
-        imported_by_user_id: userId || null,
-      },
-      select: { id: true },
-    });
+    const statement = await this.prisma.$transaction(async (tx) => {
+      const uniquePostedDates = [
+        ...new Set(
+          normalizedEntries.map((entry) => entry.postedDate.toISOString().slice(0, 10)),
+        ),
+      ];
 
-    await this.prisma.bank_statement_line.createMany({
-      data: normalizedEntries.map((entry) => ({
-        bank_statement_id: statement.id,
-        bank_account_id: bankAccountId,
-        external_id: entry.externalId,
-        posted_date: entry.postedDate,
-        amount_cents: entry.amountCents,
-        description: entry.description,
-        status: 'imported',
-        dedupe_key: entry.dedupeKey,
-      })),
-      skipDuplicates: true,
+      for (const postedDateText of uniquePostedDates) {
+        await this.assertDateNotInClosedPeriod(
+          tx,
+          new Date(`${postedDateText}T00:00:00.000Z`),
+          'import bank statements',
+        );
+      }
+
+      const createdStatement = await tx.bank_statement.create({
+        data: {
+          bank_account_id: bankAccountId,
+          source_type: sourceType,
+          idempotency_key: `import-${uploadedFile.id}-${statementFingerprint}`,
+          period_start: normalizedEntries
+            .map((entry) => entry.postedDate)
+            .sort((a, b) => a.getTime() - b.getTime())[0],
+          period_end: normalizedEntries
+            .map((entry) => entry.postedDate)
+            .sort((a, b) => b.getTime() - a.getTime())[0],
+          imported_at: new Date(),
+          imported_by_user_id: userId || null,
+        },
+        select: { id: true },
+      });
+
+      await tx.bank_statement_line.createMany({
+        data: normalizedEntries.map((entry) => ({
+          bank_statement_id: createdStatement.id,
+          bank_account_id: bankAccountId,
+          external_id: entry.externalId,
+          posted_date: entry.postedDate,
+          amount_cents: entry.amountCents,
+          description: entry.description,
+          status: 'imported',
+          dedupe_key: entry.dedupeKey,
+        })),
+        skipDuplicates: true,
+      });
+
+      return createdStatement;
     });
 
     return {
@@ -2755,40 +3426,51 @@ export class FinanceService {
     const code = this.generateBankAccountCode(data.bank, data.account);
     const name = data.description?.trim() || data.bank;
 
-    const createdAccount = await this.prisma.bank_account.create({
-      data: {
-        code,
-        name,
-        bank_name: data.bank,
-        agency: data.branch || null,
-        account_number: data.account || null,
-        account_type: accountType,
-        status: 'active',
-      },
-    });
-
-    if (data.initial_balance && data.initial_balance > 0) {
-      const statement = await this.prisma.bank_statement.create({
+    const createdAccount = await this.prisma.$transaction(async (tx) => {
+      const account = await tx.bank_account.create({
         data: {
-          bank_account_id: createdAccount.id,
-          source_type: 'csv',
-          imported_at: new Date(),
-          imported_by_user_id: userId,
+          code,
+          name,
+          bank_name: data.bank,
+          agency: data.branch || null,
+          account_number: data.account || null,
+          account_type: accountType,
+          status: 'active',
         },
       });
 
-      await this.prisma.bank_statement_line.create({
-        data: {
-          bank_statement_id: statement.id,
-          bank_account_id: createdAccount.id,
-          posted_date: new Date(),
-          amount_cents: this.toCents(data.initial_balance),
-          description: 'Saldo inicial',
-          status: 'reconciled',
-          dedupe_key: `initial-balance-${createdAccount.id}-${Date.now()}`,
-        },
-      });
-    }
+      if (data.initial_balance && data.initial_balance > 0) {
+        const postedDate = new Date();
+        await this.assertDateNotInClosedPeriod(
+          tx,
+          postedDate,
+          'create bank account initial balance',
+        );
+
+        const statement = await tx.bank_statement.create({
+          data: {
+            bank_account_id: account.id,
+            source_type: 'csv',
+            imported_at: postedDate,
+            imported_by_user_id: userId,
+          },
+        });
+
+        await tx.bank_statement_line.create({
+          data: {
+            bank_statement_id: statement.id,
+            bank_account_id: account.id,
+            posted_date: postedDate,
+            amount_cents: this.toCents(data.initial_balance),
+            description: 'Saldo inicial',
+            status: 'reconciled',
+            dedupe_key: `initial-balance-${account.id}-${Date.now()}`,
+          },
+        });
+      }
+
+      return account;
+    });
 
     const account = await this.prisma.bank_account.findUnique({
       where: { id: createdAccount.id },
@@ -4707,6 +5389,26 @@ export class FinanceService {
     }));
   }
 
+  private async loadConfirmedSettlements(fromDate: Date, toDate: Date) {
+    return this.prisma.settlement.findMany({
+      where: {
+        status: 'confirmed',
+        settled_at: {
+          gte: fromDate,
+          lte: toDate,
+        },
+      },
+      select: {
+        settled_at: true,
+        amount_cents: true,
+        settlement_type: true,
+      },
+      orderBy: {
+        settled_at: 'asc',
+      },
+    });
+  }
+
   private async loadOpenPeriod() {
     const openPeriod = await this.prisma.period_close.findFirst({
       where: {