@hed-hog/finance 0.0.261 → 0.0.266

package/dist/finance.service.js

@@ -22,10 +22,11 @@ const common_1 = require("@nestjs/common");
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
 let FinanceService = FinanceService_1 = class FinanceService {
-    constructor(prisma, paginationService, ai, fileService) {
+    constructor(prisma, paginationService, ai, settingService, fileService) {
         this.prisma = prisma;
         this.paginationService = paginationService;
         this.ai = ai;
+        this.settingService = settingService;
         this.fileService = fileService;
         this.logger = new common_1.Logger(FinanceService_1.name);
     }
@@ -503,17 +504,22 @@ let FinanceService = FinanceService_1 = class FinanceService {
         const num = Number(normalized);
         return Number.isFinite(num) ? num : null;
     }
-    async getData() {
-        const [payablesResult, receivablesResult, peopleResult, categoriesResult, costCentersResult, bankAccountsResult, tagsResult, auditLogsResult, openPeriodResult,] = await Promise.allSettled([
+    async getData(filters) {
+        const today = this.startOfDay(new Date());
+        const [payablesResult, receivablesResult, peopleResult, categoriesResult, costCentersResult, bankAccountsResult, bankStatementsResult, collectionsDefaultResult, tagsResult, auditLogsResult, openPeriodResult, scenarioSettingsResult, confirmedSettlementsResult,] = await Promise.allSettled([
             this.loadTitles('payable'),
             this.loadTitles('receivable'),
             this.loadPeople(),
             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 : [];
         const receivables = receivablesResult.status === 'fulfilled' ? receivablesResult.value : [];
@@ -521,9 +527,27 @@ let FinanceService = FinanceService_1 = class FinanceService {
         const categories = categoriesResult.status === 'fulfilled' ? categoriesResult.value : [];
         const costCenters = 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 === null || filters === void 0 ? void 0 : filters.horizonteDias, scenarioSettings.defaultHorizonDays);
+        const cenario = this.resolveForecastScenario(filters === null || filters === void 0 ? void 0 : filters.cenario, scenarioSettings.defaultScenario);
+        const forecastEnd = this.addDays(today, horizonteDias);
         if (payablesResult.status === 'rejected') {
             this.logger.error('Failed to load finance payables', payablesResult.reason);
         }
@@ -542,6 +566,12 @@ let FinanceService = FinanceService_1 = 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);
         }
@@ -551,6 +581,12 @@ let FinanceService = FinanceService_1 = 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) => title.status === 'rascunho')
             .map((title) => ({
@@ -563,30 +599,356 @@ let FinanceService = FinanceService_1 = class FinanceService {
             dataSolicitacao: title.criadoEm,
         }));
         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, data) {
+        const scenarioSlug = this.resolveForecastScenarioStrict(scenario);
+        if (data.atrasoMedio < 0 || data.atrasoMedio > 365) {
+            throw new common_1.BadRequestException('Invalid average delay value');
+        }
+        if (data.taxaInadimplencia < 0 || data.taxaInadimplencia > 100) {
+            throw new common_1.BadRequestException('Invalid default rate value');
+        }
+        if (data.crescimentoReceita < -100 || data.crescimentoReceita > 1000) {
+            throw new common_1.BadRequestException('Invalid revenue growth value');
+        }
+        const prefix = `finance-scenario-${scenarioSlug === 'pessimista'
+            ? 'pessimistic'
+            : scenarioSlug === 'otimista'
+                ? 'optimistic'
+                : 'base'}`;
+        const settingUpdates = [
+            {
+                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,
+        });
+        const settings = await this.loadFinancialScenarioSettings();
+        return {
+            success: true,
+            cenarios: settings.cenarios,
+            defaultScenario: settings.defaultScenario,
+        };
+    }
+    resolveHorizonDays(value, 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;
+    }
+    resolveForecastScenario(value, fallback = 'base') {
+        if (value === 'pessimista') {
+            return 'pessimista';
+        }
+        if (value === 'otimista') {
+            return 'otimista';
+        }
+        return fallback;
+    }
+    resolveForecastScenarioStrict(value) {
+        if (value === 'base' || value === 'pessimista' || value === 'otimista') {
+            return value;
+        }
+        throw new common_1.BadRequestException('Invalid scenario');
+    }
+    buildCashFlowForecastData(payables, receivables, confirmedSettlements, initialBalance, fromDate, toDate, scenarioConfig) {
+        const scenarioMultiplier = this.resolveScenarioMultiplier(scenarioConfig);
+        const entradasPrevistas = this.buildExpectedCashFlowEntries(receivables, fromDate, toDate, 'inflow').map((item) => (Object.assign(Object.assign({}, item), { valor: Number((item.valor * scenarioMultiplier.inflow).toFixed(2)) })));
+        const saidasPrevistas = this.buildExpectedCashFlowEntries(payables, fromDate, toDate, 'outflow').map((item) => (Object.assign(Object.assign({}, item), { valor: Number((item.valor * scenarioMultiplier.outflow).toFixed(2)) })));
+        const expectedByDate = new Map();
+        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 = [];
+        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,
+        };
+    }
+    resolveScenarioMultiplier(scenarioConfig) {
+        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,
+        };
+    }
+    clampNumber(value, min, max) {
+        if (!Number.isFinite(value)) {
+            return min;
+        }
+        return Math.min(max, Math.max(min, value));
+    }
+    async loadFinancialScenarioSettings() {
+        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 = Object.assign(Object.assign({}, 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 = Object.assign(Object.assign({}, 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 = Object.assign(Object.assign({}, 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) => (Object.assign(Object.assign({}, 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,
+        };
+        return {
+            defaultScenario,
+            defaultHorizonDays: this.resolveHorizonDays(values['finance-default-horizon-days'], defaultSettings.defaultHorizonDays),
+            cenarios,
+            map,
+        };
+    }
+    getDefaultFinancialScenarioSettings() {
+        const base = {
+            id: 'base',
+            nome: 'Base',
+            descricao: 'Cenário de referência para projeções',
+            atrasoMedio: 5,
+            taxaInadimplencia: 3,
+            crescimentoReceita: 5,
+            padrao: true,
+        };
+        const pessimista = {
+            id: 'pessimista',
+            nome: 'Pessimista',
+            descricao: 'Premissas conservadoras com maior risco',
+            atrasoMedio: 12,
+            taxaInadimplencia: 6,
+            crescimentoReceita: -5,
+            padrao: false,
+        };
+        const otimista = {
+            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,
+            },
+        };
+    }
+    numberSetting(value, fallback) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : fallback;
+    }
+    buildExpectedCashFlowEntries(titles, fromDate, toDate, direction) {
+        return (titles || [])
+            .flatMap((title) => ((title === null || title === void 0 ? void 0 : 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 === null || title === void 0 ? void 0 : title.descricao) ||
+                (direction === 'inflow' ? title === null || title === void 0 ? void 0 : title.cliente : title === null || title === void 0 ? void 0 : 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());
+    }
+    buildReceivablesCalendarData(receivables) {
+        const recebiveis = receivables
+            .flatMap((title) => (title.parcelas || []).map((installment) => {
+            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();
+        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,
+        };
+    }
+    mapReceivableCalendarStatus(status) {
+        const normalized = (status || '').toLowerCase();
+        if (normalized === 'liquidado') {
+            return 'liquidado';
+        }
+        if (['aberto', 'aprovado', 'parcial'].includes(normalized)) {
+            return 'confirmado';
+        }
+        return 'pendente';
+    }
+    mapReceivableChannelLabel(channel) {
+        const normalized = (channel || '').toLowerCase();
+        const channelMap = {
+            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() {
         var _a;
         const today = this.startOfDay(new Date());
@@ -746,6 +1108,7 @@ let FinanceService = FinanceService_1 = class FinanceService {
         const baseInstallmentCents = Math.floor(totalAmountCents / data.installments);
         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,
@@ -765,6 +1128,7 @@ let FinanceService = FinanceService_1 = class FinanceService {
             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 this.assertDateNotInClosedPeriod(tx, dueDate, 'register collection agreement installment');
                 await tx.financial_installment.create({
                     data: {
                         title_id: title.id,
@@ -1245,6 +1609,7 @@ let FinanceService = FinanceService_1 = class FinanceService {
         const description = ((_a = data.description) === null || _a === void 0 ? void 0 : _a.trim()) || 'Transferência bancária';
         const transferReference = `transfer:${Date.now()}-${Math.round(Math.random() * 1000000)}`;
         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,
@@ -1607,6 +1972,7 @@ let FinanceService = FinanceService_1 = class FinanceService {
         const description = ((_a = data.description) === null || _a === void 0 ? void 0 : _a.trim()) || `Ajuste: ${data.type}`;
         const reference = `adjustment:${Date.now()}-${Math.round(Math.random() * 1000000)}`;
         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,
@@ -1701,34 +2067,43 @@ let FinanceService = FinanceService_1 = class FinanceService {
             file.size,
             normalizedEntries.length,
         ].join('|'), 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 },
-        });
-        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,
+        const statement = await this.prisma.$transaction(async (tx) => {
+            const uniquePostedDates = [
+                ...new Set(normalizedEntries.map((entry) => entry.postedDate.toISOString().slice(0, 10))),
+            ];
+            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 {
             statementId: String(statement.id),
@@ -1977,38 +2352,43 @@ let FinanceService = FinanceService_1 = class FinanceService {
         const accountType = this.mapAccountTypeFromPt(data.type);
         const code = this.generateBankAccountCode(data.bank, data.account);
         const name = ((_a = data.description) === null || _a === void 0 ? void 0 : _a.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({
-                data: {
-                    bank_account_id: createdAccount.id,
-                    source_type: 'csv',
-                    imported_at: new Date(),
-                    imported_by_user_id: userId,
-                },
-            });
-            await this.prisma.bank_statement_line.create({
+        const createdAccount = await this.prisma.$transaction(async (tx) => {
+            const account = await tx.bank_account.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()}`,
+                    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 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 },
             include: {
@@ -3400,6 +3780,25 @@ let FinanceService = FinanceService_1 = class FinanceService {
             data: log.created_at.toISOString(),
         }));
     }
+    async loadConfirmedSettlements(fromDate, toDate) {
+        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',
+            },
+        });
+    }
     async loadOpenPeriod() {
         var _a, _b, _c, _d;
         const openPeriod = await this.prisma.period_close.findFirst({
@@ -3898,10 +4297,12 @@ let FinanceService = FinanceService_1 = class FinanceService {
 exports.FinanceService = FinanceService;
 exports.FinanceService = FinanceService = FinanceService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.FileService))),
+    __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.SettingService))),
+    __param(4, (0, common_1.Inject)((0, common_1.forwardRef)(() => core_1.FileService))),
     __metadata("design:paramtypes", [api_prisma_1.PrismaService,
         api_pagination_1.PaginationService,
         core_1.AiService,
+        core_1.SettingService,
         core_1.FileService])
 ], FinanceService);
 //# sourceMappingURL=finance.service.js.map