@hed-hog/finance 0.0.238 → 0.0.240

package/dist/finance.service.js

@@ -8,6 +8,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 var FinanceService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FinanceService = void 0;
@@ -16,11 +19,14 @@ const api_pagination_1 = require("@hed-hog/api-pagination");
 const api_prisma_1 = require("@hed-hog/api-prisma");
 const core_1 = require("@hed-hog/core");
 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) {
+    constructor(prisma, paginationService, ai, fileService) {
         this.prisma = prisma;
         this.paginationService = paginationService;
         this.ai = ai;
+        this.fileService = fileService;
         this.logger = new common_1.Logger(FinanceService_1.name);
     }
     async getAgentExtractInfoFromFile(file, fileId, titleType = 'payable') {
@@ -540,6 +546,17 @@ let FinanceService = FinanceService_1 = class FinanceService {
         if (auditLogsResult.status === 'rejected') {
             this.logger.error('Failed to load finance audit logs', auditLogsResult.reason);
         }
+        const aprovacoesPendentes = payables
+            .filter((title) => title.status === 'rascunho')
+            .map((title) => ({
+            id: String(title.id),
+            tituloId: String(title.id),
+            solicitante: '-',
+            valor: Number(title.valorTotal || 0),
+            politica: 'Aprovação financeira',
+            urgencia: 'media',
+            dataSolicitacao: title.criadoEm,
+        }));
         return {
             kpis: {
                 saldoCaixa: 0,
@@ -557,7 +574,7 @@ let FinanceService = FinanceService_1 = class FinanceService {
             pessoas: people,
             categorias: categories,
             centrosCusto: costCenters,
-            aprovacoesPendentes: [],
+            aprovacoesPendentes,
             agingInadimplencia: [],
             cenarios: [],
             transferencias: [],
@@ -587,9 +604,42 @@ let FinanceService = FinanceService_1 = class FinanceService {
     async createAccountsPayableTitle(data, locale, userId) {
         return this.createTitle(data, 'payable', locale, userId);
     }
+    async updateAccountsPayableTitle(id, data, locale, userId) {
+        return this.updateDraftTitle(id, data, 'payable', locale, userId);
+    }
+    async approveAccountsPayableTitle(id, locale, userId) {
+        return this.approveTitle(id, 'payable', locale, userId);
+    }
+    async rejectAccountsPayableTitle(id, data, locale, userId) {
+        return this.rejectTitle(id, data, 'payable', locale, userId);
+    }
+    async cancelAccountsPayableTitle(id, data, locale, userId) {
+        return this.cancelTitle(id, data, 'payable', locale, userId);
+    }
+    async settleAccountsPayableInstallment(id, data, locale, userId) {
+        return this.settleTitleInstallment(id, data, 'payable', locale, userId);
+    }
+    async reverseAccountsPayableSettlement(id, settlementId, data, locale, userId) {
+        return this.reverseTitleSettlement(id, settlementId, data, 'payable', locale, userId);
+    }
     async createAccountsReceivableTitle(data, locale, userId) {
         return this.createTitle(data, 'receivable', locale, userId);
     }
+    async updateAccountsReceivableTitle(id, data, locale, userId) {
+        return this.updateDraftTitle(id, data, 'receivable', locale, userId);
+    }
+    async approveAccountsReceivableTitle(id, locale, userId) {
+        return this.approveTitle(id, 'receivable', locale, userId);
+    }
+    async cancelAccountsReceivableTitle(id, data, locale, userId) {
+        return this.cancelTitle(id, data, 'receivable', locale, userId);
+    }
+    async settleAccountsReceivableInstallment(id, data, locale, userId) {
+        return this.settleTitleInstallment(id, data, 'receivable', locale, userId);
+    }
+    async reverseAccountsReceivableSettlement(id, settlementId, data, locale, userId) {
+        return this.reverseTitleSettlement(id, settlementId, data, 'receivable', locale, userId);
+    }
     async createTag(data) {
         const slug = this.normalizeTagSlug(data.name);
         if (!slug) {
@@ -825,6 +875,368 @@ let FinanceService = FinanceService_1 = class FinanceService {
             statusConciliacao: this.mapStatementStatusToPt(statement.status),
         }));
     }
+    async exportBankStatementsCsv(bankAccountId) {
+        const statements = await this.listBankStatements(bankAccountId);
+        const headers = [
+            'id',
+            'data',
+            'descricao',
+            'valor',
+            'tipo',
+            'status_conciliacao',
+            'conta_bancaria_id',
+        ];
+        const lines = statements.map((statement) => {
+            const columns = [
+                statement.id,
+                statement.data,
+                statement.descricao,
+                String(statement.valor),
+                statement.tipo,
+                statement.statusConciliacao,
+                statement.contaBancariaId,
+            ];
+            return columns.map((column) => this.escapeCsvCell(column)).join(';');
+        });
+        const csv = ['\uFEFF' + headers.join(';'), ...lines].join('\n');
+        const fileName = `extrato-bancario-${bankAccountId}-${new Date()
+            .toISOString()
+            .slice(0, 10)}.csv`;
+        return {
+            csv,
+            fileName,
+        };
+    }
+    async importBankStatements(bankAccountId, file, locale, userId) {
+        if (!file) {
+            throw new common_1.BadRequestException('File is required');
+        }
+        const bankAccount = await this.prisma.bank_account.findUnique({
+            where: { id: bankAccountId },
+            select: { id: true },
+        });
+        if (!bankAccount) {
+            throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('itemNotFound', locale, 'Bank account not found').replace('{{item}}', 'Bank account'));
+        }
+        const sourceType = this.detectStatementSourceType(file);
+        const uploadedFile = await this.fileService.upload('finance/statements', file);
+        const rawContent = await this.getUploadedFileText(file);
+        const parsedEntries = sourceType === 'ofx'
+            ? this.parseOfxStatements(rawContent)
+            : this.parseCsvStatements(rawContent);
+        if (parsedEntries.length === 0) {
+            throw new common_1.BadRequestException('No valid statement rows were found in the uploaded file');
+        }
+        const normalizedEntries = parsedEntries
+            .filter((entry) => entry.postedDate && Number.isFinite(entry.amount))
+            .map((entry, index) => {
+            const postedDate = new Date(entry.postedDate);
+            if (Number.isNaN(postedDate.getTime())) {
+                return null;
+            }
+            const amountCents = this.toCents(entry.amount);
+            if (!Number.isFinite(amountCents) || amountCents === 0) {
+                return null;
+            }
+            const dedupeBase = [
+                bankAccountId,
+                postedDate.toISOString().slice(0, 10),
+                amountCents,
+                entry.externalId || '',
+                entry.description || '',
+                index,
+            ].join('|');
+            return {
+                postedDate,
+                amountCents,
+                externalId: entry.externalId || null,
+                description: (entry.description || 'Lançamento importado').slice(0, 1000),
+                dedupeKey: this.createShortHash(`statement-line:${dedupeBase}`, 64),
+            };
+        })
+            .filter(Boolean);
+        if (normalizedEntries.length === 0) {
+            throw new common_1.BadRequestException('No valid financial entries were parsed');
+        }
+        const statementFingerprint = this.createShortHash([
+            bankAccountId,
+            sourceType,
+            uploadedFile.id,
+            file.originalname,
+            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,
+        });
+        return {
+            statementId: String(statement.id),
+            fileId: String(uploadedFile.id),
+            importedRows: normalizedEntries.length,
+            sourceType,
+        };
+    }
+    detectStatementSourceType(file) {
+        const filename = (file.originalname || '').toLowerCase();
+        const mimetype = (file.mimetype || '').toLowerCase();
+        if (filename.endsWith('.ofx') ||
+            mimetype.includes('ofx') ||
+            mimetype.includes('x-ofx')) {
+            return 'ofx';
+        }
+        if (filename.endsWith('.csv') ||
+            mimetype.includes('csv') ||
+            mimetype.includes('comma-separated-values')) {
+            return 'csv';
+        }
+        throw new common_1.BadRequestException('Only CSV and OFX files are supported');
+    }
+    async getUploadedFileText(file) {
+        let buffer = file.buffer;
+        if (!buffer && file.path) {
+            buffer = await (0, promises_1.readFile)(file.path);
+        }
+        if (!buffer || buffer.length === 0) {
+            throw new common_1.BadRequestException('Uploaded file is empty');
+        }
+        const utf8 = buffer.toString('utf8');
+        if (utf8.includes('�')) {
+            return buffer.toString('latin1');
+        }
+        return utf8;
+    }
+    parseCsvStatements(content) {
+        const normalizedContent = content.replace(/^\uFEFF/, '').trim();
+        if (!normalizedContent) {
+            return [];
+        }
+        const rows = normalizedContent
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => !!line);
+        if (rows.length === 0) {
+            return [];
+        }
+        const delimiter = this.detectCsvDelimiter(rows[0]);
+        const headerCells = this.parseCsvLine(rows[0], delimiter);
+        const normalizedHeaders = headerCells.map((cell) => this.normalizeCsvHeader(cell));
+        const headerIndexes = {
+            date: this.findFirstHeaderIndex(normalizedHeaders, [
+                'data',
+                'dt',
+                'posteddate',
+                'lancamento',
+                'movimento',
+            ]),
+            description: this.findFirstHeaderIndex(normalizedHeaders, [
+                'descricao',
+                'historico',
+                'memo',
+                'complemento',
+            ]),
+            amount: this.findFirstHeaderIndex(normalizedHeaders, [
+                'valor',
+                'amount',
+                'montante',
+            ]),
+            debit: this.findFirstHeaderIndex(normalizedHeaders, ['debito', 'debit']),
+            credit: this.findFirstHeaderIndex(normalizedHeaders, [
+                'credito',
+                'credit',
+            ]),
+            externalId: this.findFirstHeaderIndex(normalizedHeaders, [
+                'id',
+                'documento',
+                'numero',
+                'fitid',
+            ]),
+        };
+        const hasHeader = headerIndexes.date >= 0 ||
+            headerIndexes.description >= 0 ||
+            headerIndexes.amount >= 0 ||
+            headerIndexes.debit >= 0 ||
+            headerIndexes.credit >= 0;
+        const dataRows = hasHeader ? rows.slice(1) : rows;
+        return dataRows
+            .map((line) => this.parseCsvLine(line, delimiter))
+            .map((columns) => {
+            const dateRaw = (headerIndexes.date >= 0
+                ? columns[headerIndexes.date]
+                : columns[0]) || '';
+            const descriptionRaw = (headerIndexes.description >= 0
+                ? columns[headerIndexes.description]
+                : columns[1]) || '';
+            const amountRaw = headerIndexes.amount >= 0 ? columns[headerIndexes.amount] : '';
+            const debitRaw = headerIndexes.debit >= 0 ? columns[headerIndexes.debit] : '';
+            const creditRaw = headerIndexes.credit >= 0 ? columns[headerIndexes.credit] : '';
+            const fallbackAmountRaw = columns[2] || '';
+            const externalIdRaw = headerIndexes.externalId >= 0 ? columns[headerIndexes.externalId] : '';
+            const postedDate = this.parseStatementDate(dateRaw);
+            if (!postedDate) {
+                return null;
+            }
+            const amount = this.resolveCsvAmount(amountRaw || fallbackAmountRaw, debitRaw, creditRaw);
+            if (amount === null) {
+                return null;
+            }
+            return {
+                postedDate,
+                amount,
+                description: (descriptionRaw === null || descriptionRaw === void 0 ? void 0 : descriptionRaw.trim()) || 'Movimentação importada',
+                externalId: (externalIdRaw === null || externalIdRaw === void 0 ? void 0 : externalIdRaw.trim()) || null,
+            };
+        })
+            .filter(Boolean);
+    }
+    parseOfxStatements(content) {
+        const normalized = content.replace(/\r/g, '');
+        const segments = normalized
+            .split(/<STMTTRN>/i)
+            .slice(1)
+            .map((segment) => segment.split(/<\/STMTTRN>/i)[0]);
+        return segments
+            .map((segment) => {
+            var _a;
+            const dateRaw = this.extractOfxTag(segment, 'DTPOSTED');
+            const amountRaw = this.extractOfxTag(segment, 'TRNAMT');
+            const fitId = this.extractOfxTag(segment, 'FITID');
+            const memo = this.extractOfxTag(segment, 'MEMO');
+            const name = this.extractOfxTag(segment, 'NAME');
+            const trnType = (_a = this.extractOfxTag(segment, 'TRNTYPE')) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+            const postedDate = this.parseStatementDate(dateRaw);
+            const amount = this.toNullableNumber(amountRaw);
+            if (!postedDate || amount === null) {
+                return null;
+            }
+            let normalizedAmount = amount;
+            if (['debit', 'payment', 'withdrawal'].includes(trnType || '') &&
+                normalizedAmount > 0) {
+                normalizedAmount *= -1;
+            }
+            const description = [memo, name].filter(Boolean).join(' - ').trim();
+            return {
+                postedDate,
+                amount: normalizedAmount,
+                description: description || 'Movimentação OFX',
+                externalId: fitId || null,
+            };
+        })
+            .filter(Boolean);
+    }
+    detectCsvDelimiter(line) {
+        var _a;
+        const delimiters = [';', ',', '\t'];
+        const counts = delimiters.map((delimiter) => ({
+            delimiter,
+            count: (line.match(new RegExp(`\\${delimiter}`, 'g')) || []).length,
+        }));
+        return ((_a = counts.sort((a, b) => b.count - a.count)[0]) === null || _a === void 0 ? void 0 : _a.delimiter) || ';';
+    }
+    parseCsvLine(line, delimiter) {
+        const result = [];
+        let current = '';
+        let inQuotes = false;
+        for (let i = 0; i < line.length; i++) {
+            const char = line[i];
+            const next = line[i + 1];
+            if (char === '"') {
+                if (inQuotes && next === '"') {
+                    current += '"';
+                    i++;
+                }
+                else {
+                    inQuotes = !inQuotes;
+                }
+                continue;
+            }
+            if (char === delimiter && !inQuotes) {
+                result.push(current.trim());
+                current = '';
+                continue;
+            }
+            current += char;
+        }
+        result.push(current.trim());
+        return result;
+    }
+    normalizeCsvHeader(value) {
+        return String(value || '')
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .toLowerCase()
+            .replace(/[^a-z0-9]/g, '');
+    }
+    findFirstHeaderIndex(headers, candidates) {
+        return headers.findIndex((header) => candidates.some((candidate) => header.includes(candidate)));
+    }
+    parseStatementDate(value) {
+        const raw = String(value || '').trim();
+        if (!raw) {
+            return '';
+        }
+        const onlyDateDigits = raw.match(/^(\d{8})/);
+        if (onlyDateDigits === null || onlyDateDigits === void 0 ? void 0 : onlyDateDigits[1]) {
+            const v = onlyDateDigits[1];
+            return `${v.slice(0, 4)}-${v.slice(4, 6)}-${v.slice(6, 8)}`;
+        }
+        const normalized = this.normalizeDate(raw);
+        if (normalized) {
+            return normalized;
+        }
+        return '';
+    }
+    resolveCsvAmount(amountRaw, debitRaw, creditRaw) {
+        const amount = this.toNullableNumber(amountRaw);
+        const debit = this.toNullableNumber(debitRaw);
+        const credit = this.toNullableNumber(creditRaw);
+        if (credit !== null || debit !== null) {
+            return (credit || 0) - (debit || 0);
+        }
+        if (amount === null) {
+            return null;
+        }
+        return amount;
+    }
+    extractOfxTag(segment, tag) {
+        var _a;
+        const regex = new RegExp(`<${tag}>([^\n\r<]*)`, 'i');
+        const match = segment.match(regex);
+        return ((_a = match === null || match === void 0 ? void 0 : match[1]) === null || _a === void 0 ? void 0 : _a.trim()) || '';
+    }
+    createShortHash(input, length = 40) {
+        return (0, node_crypto_1.createHash)('sha256').update(input).digest('hex').slice(0, length);
+    }
+    escapeCsvCell(value) {
+        const normalizedValue = String(value !== null && value !== void 0 ? value : '');
+        const escapedValue = normalizedValue.replace(/"/g, '""');
+        return `"${escapedValue}"`;
+    }
     async createBankAccount(data, userId) {
         var _a;
         const accountType = this.mapAccountTypeFromPt(data.type);
@@ -1124,110 +1536,759 @@ let FinanceService = FinanceService_1 = class FinanceService {
         return title;
     }
     async createTitle(data, titleType, locale, userId) {
-        const person = await this.prisma.person.findUnique({
-            where: { id: data.person_id },
-            select: { id: true },
-        });
-        if (!person) {
-            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personNotFound', locale, 'Person not found'));
-        }
-        if (data.finance_category_id) {
-            const category = await this.prisma.finance_category.findUnique({
-                where: { id: data.finance_category_id },
+        const installments = this.normalizeAndValidateInstallments(data, locale);
+        const createdTitleId = await this.prisma.$transaction(async (tx) => {
+            const person = await tx.person.findUnique({
+                where: { id: data.person_id },
                 select: { id: true },
             });
-            if (!category) {
-                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('categoryNotFound', locale, 'Category not found'));
+            if (!person) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personNotFound', locale, 'Person not found'));
             }
-        }
-        if (data.cost_center_id) {
-            const costCenter = await this.prisma.cost_center.findUnique({
-                where: { id: data.cost_center_id },
+            if (data.finance_category_id) {
+                const category = await tx.finance_category.findUnique({
+                    where: { id: data.finance_category_id },
+                    select: { id: true },
+                });
+                if (!category) {
+                    throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('categoryNotFound', locale, 'Category not found'));
+                }
+            }
+            if (data.cost_center_id) {
+                const costCenter = await tx.cost_center.findUnique({
+                    where: { id: data.cost_center_id },
+                    select: { id: true },
+                });
+                if (!costCenter) {
+                    throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('costCenterNotFound', locale, 'Cost center not found'));
+                }
+            }
+            const attachmentFileIds = [
+                ...new Set((data.attachment_file_ids || []).filter((fileId) => fileId > 0)),
+            ];
+            if (attachmentFileIds.length > 0) {
+                const existingFiles = await tx.file.findMany({
+                    where: {
+                        id: { in: attachmentFileIds },
+                    },
+                    select: {
+                        id: true,
+                    },
+                });
+                const existingFileIds = new Set(existingFiles.map((file) => file.id));
+                const invalidFileIds = attachmentFileIds.filter((fileId) => !existingFileIds.has(fileId));
+                if (invalidFileIds.length > 0) {
+                    throw new common_1.BadRequestException(`Invalid attachment file IDs: ${invalidFileIds.join(', ')}`);
+                }
+            }
+            await this.assertDateNotInClosedPeriod(tx, data.competence_date
+                ? new Date(data.competence_date)
+                : new Date(installments[0].due_date), 'create title');
+            const title = await tx.financial_title.create({
+                data: {
+                    person_id: data.person_id,
+                    title_type: titleType,
+                    status: 'draft',
+                    document_number: data.document_number,
+                    description: data.description,
+                    competence_date: data.competence_date
+                        ? new Date(data.competence_date)
+                        : null,
+                    issue_date: data.issue_date ? new Date(data.issue_date) : null,
+                    total_amount_cents: this.toCents(data.total_amount),
+                    finance_category_id: data.finance_category_id,
+                    created_by_user_id: userId,
+                },
+            });
+            if (attachmentFileIds.length > 0) {
+                await tx.financial_title_attachment.createMany({
+                    data: attachmentFileIds.map((fileId) => ({
+                        title_id: title.id,
+                        file_id: fileId,
+                        uploaded_by_user_id: userId,
+                    })),
+                });
+            }
+            for (let index = 0; index < installments.length; index++) {
+                const installment = installments[index];
+                const amountCents = installment.amount_cents;
+                const createdInstallment = await tx.financial_installment.create({
+                    data: {
+                        title_id: title.id,
+                        installment_number: installment.installment_number,
+                        competence_date: data.competence_date
+                            ? new Date(data.competence_date)
+                            : new Date(installment.due_date),
+                        due_date: new Date(installment.due_date),
+                        amount_cents: amountCents,
+                        open_amount_cents: amountCents,
+                        status: this.resolveInstallmentStatus(amountCents, amountCents, new Date(installment.due_date)),
+                        notes: data.description,
+                    },
+                });
+                if (data.cost_center_id) {
+                    await tx.installment_allocation.create({
+                        data: {
+                            installment_id: createdInstallment.id,
+                            cost_center_id: data.cost_center_id,
+                            allocated_amount_cents: amountCents,
+                        },
+                    });
+                }
+            }
+            await this.createAuditLog(tx, {
+                action: 'CREATE_TITLE',
+                entityTable: 'financial_title',
+                entityId: String(title.id),
+                actorUserId: userId,
+                summary: `Created ${titleType} title ${title.id} in draft`,
+                afterData: JSON.stringify({
+                    status: 'draft',
+                    total_amount_cents: this.toCents(data.total_amount),
+                }),
+            });
+            return title.id;
+        });
+        const createdTitle = await this.getTitleById(createdTitleId, titleType, locale);
+        return this.mapTitleToFront(createdTitle, data.payment_channel);
+    }
+    async updateDraftTitle(titleId, data, titleType, locale, userId) {
+        const installments = this.normalizeAndValidateInstallments(data, locale);
+        const updatedTitle = await this.prisma.$transaction(async (tx) => {
+            const title = await tx.financial_title.findFirst({
+                where: {
+                    id: titleId,
+                    title_type: titleType,
+                },
+                include: {
+                    financial_installment: {
+                        select: {
+                            id: true,
+                        },
+                    },
+                },
+            });
+            if (!title) {
+                throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('itemNotFound', locale, `Financial title with ID ${titleId} not found`).replace('{{item}}', 'Financial title'));
+            }
+            if (title.status !== 'draft') {
+                throw new common_1.BadRequestException('Only draft titles can be edited');
+            }
+            const person = await tx.person.findUnique({
+                where: { id: data.person_id },
                 select: { id: true },
             });
-            if (!costCenter) {
-                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('costCenterNotFound', locale, 'Cost center not found'));
+            if (!person) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('personNotFound', locale, 'Person not found'));
+            }
+            if (data.finance_category_id) {
+                const category = await tx.finance_category.findUnique({
+                    where: { id: data.finance_category_id },
+                    select: { id: true },
+                });
+                if (!category) {
+                    throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('categoryNotFound', locale, 'Category not found'));
+                }
+            }
+            if (data.cost_center_id) {
+                const costCenter = await tx.cost_center.findUnique({
+                    where: { id: data.cost_center_id },
+                    select: { id: true },
+                });
+                if (!costCenter) {
+                    throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('costCenterNotFound', locale, 'Cost center not found'));
+                }
+            }
+            const attachmentFileIds = [
+                ...new Set((data.attachment_file_ids || []).filter((fileId) => fileId > 0)),
+            ];
+            if (attachmentFileIds.length > 0) {
+                const existingFiles = await tx.file.findMany({
+                    where: {
+                        id: { in: attachmentFileIds },
+                    },
+                    select: {
+                        id: true,
+                    },
+                });
+                const existingFileIds = new Set(existingFiles.map((file) => file.id));
+                const invalidFileIds = attachmentFileIds.filter((fileId) => !existingFileIds.has(fileId));
+                if (invalidFileIds.length > 0) {
+                    throw new common_1.BadRequestException(`Invalid attachment file IDs: ${invalidFileIds.join(', ')}`);
+                }
+            }
+            await this.assertDateNotInClosedPeriod(tx, data.competence_date
+                ? new Date(data.competence_date)
+                : new Date(installments[0].due_date), 'update title');
+            const installmentIds = title.financial_installment.map((item) => item.id);
+            if (installmentIds.length > 0) {
+                const hasSettlements = await tx.settlement_allocation.findFirst({
+                    where: {
+                        installment_id: {
+                            in: installmentIds,
+                        },
+                    },
+                    select: {
+                        id: true,
+                    },
+                });
+                if (hasSettlements) {
+                    throw new common_1.BadRequestException('Cannot edit title with settled installments');
+                }
+            }
+            await tx.financial_title.update({
+                where: { id: title.id },
+                data: {
+                    person_id: data.person_id,
+                    document_number: data.document_number,
+                    description: data.description,
+                    competence_date: data.competence_date
+                        ? new Date(data.competence_date)
+                        : null,
+                    issue_date: data.issue_date ? new Date(data.issue_date) : null,
+                    total_amount_cents: this.toCents(data.total_amount),
+                    finance_category_id: data.finance_category_id,
+                },
+            });
+            if (installmentIds.length > 0) {
+                await tx.installment_allocation.deleteMany({
+                    where: {
+                        installment_id: {
+                            in: installmentIds,
+                        },
+                    },
+                });
+                await tx.financial_installment_tag.deleteMany({
+                    where: {
+                        installment_id: {
+                            in: installmentIds,
+                        },
+                    },
+                });
+                await tx.financial_installment.deleteMany({
+                    where: {
+                        title_id: title.id,
+                    },
+                });
+            }
+            for (const installment of installments) {
+                const amountCents = installment.amount_cents;
+                const createdInstallment = await tx.financial_installment.create({
+                    data: {
+                        title_id: title.id,
+                        installment_number: installment.installment_number,
+                        competence_date: data.competence_date
+                            ? new Date(data.competence_date)
+                            : new Date(installment.due_date),
+                        due_date: new Date(installment.due_date),
+                        amount_cents: amountCents,
+                        open_amount_cents: amountCents,
+                        status: this.resolveInstallmentStatus(amountCents, amountCents, new Date(installment.due_date)),
+                        notes: data.description,
+                    },
+                });
+                if (data.cost_center_id) {
+                    await tx.installment_allocation.create({
+                        data: {
+                            installment_id: createdInstallment.id,
+                            cost_center_id: data.cost_center_id,
+                            allocated_amount_cents: amountCents,
+                        },
+                    });
+                }
+            }
+            if (data.attachment_file_ids) {
+                await tx.financial_title_attachment.deleteMany({
+                    where: {
+                        title_id: title.id,
+                    },
+                });
+                if (attachmentFileIds.length > 0) {
+                    await tx.financial_title_attachment.createMany({
+                        data: attachmentFileIds.map((fileId) => ({
+                            title_id: title.id,
+                            file_id: fileId,
+                            uploaded_by_user_id: userId,
+                        })),
+                    });
+                }
             }
+            await this.createAuditLog(tx, {
+                action: 'UPDATE_TITLE',
+                entityTable: 'financial_title',
+                entityId: String(title.id),
+                actorUserId: userId,
+                summary: `Updated draft ${titleType} title ${title.id}`,
+                beforeData: JSON.stringify({ status: title.status }),
+                afterData: JSON.stringify({
+                    status: title.status,
+                    total_amount_cents: this.toCents(data.total_amount),
+                }),
+            });
+            return tx.financial_title.findFirst({
+                where: {
+                    id: title.id,
+                    title_type: titleType,
+                },
+                include: this.defaultTitleInclude(),
+            });
+        });
+        if (!updatedTitle) {
+            throw new common_1.NotFoundException('Financial title not found');
         }
-        const installments = data.installments && data.installments.length > 0
+        return this.mapTitleToFront(updatedTitle, data.payment_channel);
+    }
+    normalizeAndValidateInstallments(data, locale) {
+        const fallbackDueDate = data.due_date;
+        const totalAmountCents = this.toCents(data.total_amount);
+        const sourceInstallments = data.installments && data.installments.length > 0
             ? data.installments
             : [
                 {
                     installment_number: 1,
-                    due_date: data.due_date,
+                    due_date: fallbackDueDate,
                     amount: data.total_amount,
                 },
             ];
-        const title = await this.prisma.financial_title.create({
-            data: {
-                person_id: data.person_id,
-                title_type: titleType,
-                status: 'open',
-                document_number: data.document_number,
-                description: data.description,
-                competence_date: data.competence_date
-                    ? new Date(data.competence_date)
-                    : null,
-                issue_date: data.issue_date ? new Date(data.issue_date) : null,
-                total_amount_cents: this.toCents(data.total_amount),
-                finance_category_id: data.finance_category_id,
-                created_by_user_id: userId,
-            },
+        const normalizedInstallments = sourceInstallments.map((installment, index) => {
+            const installmentDueDate = installment.due_date || fallbackDueDate;
+            if (!installmentDueDate) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('installmentDueDateRequired', locale, 'Installment due date is required'));
+            }
+            const amountCents = this.toCents(installment.amount);
+            if (amountCents <= 0) {
+                throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('installmentAmountInvalid', locale, 'Installment amount must be greater than zero'));
+            }
+            return {
+                installment_number: installment.installment_number || index + 1,
+                due_date: installmentDueDate,
+                amount_cents: amountCents,
+            };
         });
-        const attachmentFileIds = [
-            ...new Set((data.attachment_file_ids || []).filter((fileId) => fileId > 0)),
-        ];
-        if (attachmentFileIds.length > 0) {
-            const existingFiles = await this.prisma.file.findMany({
+        const installmentsTotalCents = normalizedInstallments.reduce((acc, installment) => acc + installment.amount_cents, 0);
+        if (installmentsTotalCents !== totalAmountCents) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('installmentsTotalMismatch', locale, 'Installments total must be equal to title total amount'));
+        }
+        return normalizedInstallments;
+    }
+    async approveTitle(titleId, titleType, locale, userId) {
+        const updatedTitle = await this.prisma.$transaction(async (tx) => {
+            const title = await tx.financial_title.findFirst({
                 where: {
-                    id: { in: attachmentFileIds },
+                    id: titleId,
+                    title_type: titleType,
                 },
                 select: {
                     id: true,
+                    status: true,
+                    competence_date: true,
                 },
             });
-            const existingFileIds = new Set(existingFiles.map((file) => file.id));
-            const invalidFileIds = attachmentFileIds.filter((fileId) => !existingFileIds.has(fileId));
-            if (invalidFileIds.length > 0) {
-                throw new common_1.BadRequestException(`Invalid attachment file IDs: ${invalidFileIds.join(', ')}`);
+            if (!title) {
+                throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('itemNotFound', locale, `Financial title with ID ${titleId} not found`).replace('{{item}}', 'Financial title'));
             }
-            await this.prisma.financial_title_attachment.createMany({
-                data: attachmentFileIds.map((fileId) => ({
-                    title_id: title.id,
-                    file_id: fileId,
-                    uploaded_by_user_id: userId,
-                })),
+            await this.assertDateNotInClosedPeriod(tx, title.competence_date, 'approve title');
+            if (title.status !== 'draft') {
+                throw new common_1.BadRequestException('Only draft titles can be approved');
+            }
+            await tx.financial_title.update({
+                where: { id: title.id },
+                data: {
+                    status: 'open',
+                },
             });
+            await this.createAuditLog(tx, {
+                action: 'APPROVE_TITLE',
+                entityTable: 'financial_title',
+                entityId: String(title.id),
+                actorUserId: userId,
+                summary: `Approved ${titleType} title ${title.id}`,
+                beforeData: JSON.stringify({ status: title.status }),
+                afterData: JSON.stringify({ status: 'open' }),
+            });
+            return tx.financial_title.findFirst({
+                where: {
+                    id: title.id,
+                    title_type: titleType,
+                },
+                include: this.defaultTitleInclude(),
+            });
+        });
+        if (!updatedTitle) {
+            throw new common_1.NotFoundException('Financial title not found');
         }
-        for (let index = 0; index < installments.length; index++) {
-            const installment = installments[index];
-            const amountCents = this.toCents(installment.amount);
-            const createdInstallment = await this.prisma.financial_installment.create({
+        return this.mapTitleToFront(updatedTitle);
+    }
+    async rejectTitle(titleId, data, titleType, locale, userId) {
+        const updatedTitle = await this.prisma.$transaction(async (tx) => {
+            const title = await tx.financial_title.findFirst({
+                where: {
+                    id: titleId,
+                    title_type: titleType,
+                },
+                select: {
+                    id: true,
+                    status: true,
+                    competence_date: true,
+                },
+            });
+            if (!title) {
+                throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('itemNotFound', locale, `Financial title with ID ${titleId} not found`).replace('{{item}}', 'Financial title'));
+            }
+            await this.assertDateNotInClosedPeriod(tx, title.competence_date, 'reject title');
+            if (title.status !== 'draft') {
+                throw new common_1.BadRequestException('Only draft titles can be rejected');
+            }
+            await tx.financial_title.update({
+                where: { id: title.id },
+                data: {
+                    status: 'canceled',
+                },
+            });
+            await this.createAuditLog(tx, {
+                action: 'REJECT_TITLE',
+                entityTable: 'financial_title',
+                entityId: String(title.id),
+                actorUserId: userId,
+                summary: `Rejected ${titleType} title ${title.id}`,
+                beforeData: JSON.stringify({ status: title.status }),
+                afterData: JSON.stringify({
+                    status: 'canceled',
+                    reason: (data === null || data === void 0 ? void 0 : data.reason) || null,
+                }),
+            });
+            return tx.financial_title.findFirst({
+                where: {
+                    id: title.id,
+                    title_type: titleType,
+                },
+                include: this.defaultTitleInclude(),
+            });
+        });
+        if (!updatedTitle) {
+            throw new common_1.NotFoundException('Financial title not found');
+        }
+        return this.mapTitleToFront(updatedTitle);
+    }
+    async cancelTitle(titleId, data, titleType, locale, userId) {
+        const updatedTitle = await this.prisma.$transaction(async (tx) => {
+            const title = await tx.financial_title.findFirst({
+                where: {
+                    id: titleId,
+                    title_type: titleType,
+                },
+                select: {
+                    id: true,
+                    status: true,
+                    competence_date: true,
+                },
+            });
+            if (!title) {
+                throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('itemNotFound', locale, `Financial title with ID ${titleId} not found`).replace('{{item}}', 'Financial title'));
+            }
+            if (title.status === 'settled' || title.status === 'canceled') {
+                throw new common_1.BadRequestException('Title cannot be canceled in current status');
+            }
+            await this.assertDateNotInClosedPeriod(tx, title.competence_date, 'cancel title');
+            await tx.financial_title.update({
+                where: { id: title.id },
                 data: {
+                    status: 'canceled',
+                },
+            });
+            await this.createAuditLog(tx, {
+                action: 'CANCEL_TITLE',
+                entityTable: 'financial_title',
+                entityId: String(title.id),
+                actorUserId: userId,
+                summary: `Canceled ${titleType} title ${title.id}`,
+                beforeData: JSON.stringify({ status: title.status }),
+                afterData: JSON.stringify({
+                    status: 'canceled',
+                    reason: (data === null || data === void 0 ? void 0 : data.reason) || null,
+                }),
+            });
+            return tx.financial_title.findFirst({
+                where: {
+                    id: title.id,
+                    title_type: titleType,
+                },
+                include: this.defaultTitleInclude(),
+            });
+        });
+        if (!updatedTitle) {
+            throw new common_1.NotFoundException('Financial title not found');
+        }
+        return this.mapTitleToFront(updatedTitle);
+    }
+    async settleTitleInstallment(titleId, data, titleType, locale, userId) {
+        const amountCents = this.toCents(data.amount);
+        if (amountCents <= 0) {
+            throw new common_1.BadRequestException('Settlement amount must be greater than zero');
+        }
+        const settledAt = data.settled_at ? new Date(data.settled_at) : new Date();
+        if (Number.isNaN(settledAt.getTime())) {
+            throw new common_1.BadRequestException('Invalid settlement date');
+        }
+        const result = await this.prisma.$transaction(async (tx) => {
+            var _a;
+            const title = await tx.financial_title.findFirst({
+                where: {
+                    id: titleId,
+                    title_type: titleType,
+                },
+                select: {
+                    id: true,
+                    person_id: true,
+                    status: true,
+                    competence_date: true,
+                },
+            });
+            if (!title) {
+                throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('itemNotFound', locale, `Financial title with ID ${titleId} not found`).replace('{{item}}', 'Financial title'));
+            }
+            if (!['open', 'partial'].includes(title.status)) {
+                throw new common_1.BadRequestException('Only open/partial titles can be settled');
+            }
+            await this.assertDateNotInClosedPeriod(tx, title.competence_date, 'settle installment');
+            const installment = await tx.financial_installment.findFirst({
+                where: {
+                    id: data.installment_id,
                     title_id: title.id,
-                    installment_number: installment.installment_number || index + 1,
-                    competence_date: data.competence_date
-                        ? new Date(data.competence_date)
-                        : new Date(installment.due_date),
-                    due_date: new Date(installment.due_date),
+                },
+                select: {
+                    id: true,
+                    title_id: true,
+                    amount_cents: true,
+                    open_amount_cents: true,
+                    due_date: true,
+                    status: true,
+                },
+            });
+            if (!installment) {
+                throw new common_1.BadRequestException('Installment not found for this title');
+            }
+            if (installment.status === 'settled' || installment.status === 'canceled') {
+                throw new common_1.BadRequestException('This installment cannot be settled');
+            }
+            if (amountCents > installment.open_amount_cents) {
+                throw new common_1.BadRequestException('Settlement amount exceeds open amount');
+            }
+            const paymentMethodId = await this.resolvePaymentMethodId(tx, data.payment_channel);
+            const settlement = await tx.settlement.create({
+                data: {
+                    person_id: title.person_id,
+                    bank_account_id: data.bank_account_id || null,
+                    payment_method_id: paymentMethodId,
+                    settlement_type: titleType,
+                    status: 'confirmed',
+                    settled_at: settledAt,
                     amount_cents: amountCents,
-                    open_amount_cents: amountCents,
-                    status: 'open',
-                    notes: data.description,
+                    description: ((_a = data.description) === null || _a === void 0 ? void 0 : _a.trim()) || null,
+                    created_by_user_id: userId,
                 },
             });
-            if (data.cost_center_id) {
-                await this.prisma.installment_allocation.create({
+            await tx.settlement_allocation.create({
+                data: {
+                    settlement_id: settlement.id,
+                    installment_id: installment.id,
+                    allocated_amount_cents: amountCents,
+                    discount_cents: this.toCents(data.discount || 0),
+                    interest_cents: this.toCents(data.interest || 0),
+                    penalty_cents: this.toCents(data.penalty || 0),
+                },
+            });
+            const decrementResult = await tx.financial_installment.updateMany({
+                where: {
+                    id: installment.id,
+                    open_amount_cents: {
+                        gte: amountCents,
+                    },
+                },
+                data: {
+                    open_amount_cents: {
+                        decrement: amountCents,
+                    },
+                },
+            });
+            if (decrementResult.count !== 1) {
+                throw new common_1.BadRequestException('Installment was updated concurrently, please try again');
+            }
+            const updatedInstallment = await tx.financial_installment.findUnique({
+                where: {
+                    id: installment.id,
+                },
+                select: {
+                    id: true,
+                    amount_cents: true,
+                    open_amount_cents: true,
+                    due_date: true,
+                    status: true,
+                },
+            });
+            if (!updatedInstallment) {
+                throw new common_1.NotFoundException('Installment not found');
+            }
+            const nextInstallmentStatus = this.resolveInstallmentStatus(updatedInstallment.amount_cents, updatedInstallment.open_amount_cents, updatedInstallment.due_date);
+            if (updatedInstallment.status !== nextInstallmentStatus) {
+                await tx.financial_installment.update({
+                    where: {
+                        id: updatedInstallment.id,
+                    },
+                    data: {
+                        status: nextInstallmentStatus,
+                    },
+                });
+            }
+            const previousTitleStatus = title.status;
+            const nextTitleStatus = await this.recalculateTitleStatus(tx, title.id);
+            await this.createAuditLog(tx, {
+                action: 'SETTLE_INSTALLMENT',
+                entityTable: 'financial_title',
+                entityId: String(title.id),
+                actorUserId: userId,
+                summary: `Settled installment ${installment.id} of title ${title.id}`,
+                beforeData: JSON.stringify({
+                    title_status: previousTitleStatus,
+                    installment_open_amount_cents: installment.open_amount_cents,
+                }),
+                afterData: JSON.stringify({
+                    title_status: nextTitleStatus,
+                    installment_open_amount_cents: updatedInstallment.open_amount_cents,
+                    settlement_id: settlement.id,
+                }),
+            });
+            const updatedTitle = await tx.financial_title.findFirst({
+                where: {
+                    id: title.id,
+                    title_type: titleType,
+                },
+                include: this.defaultTitleInclude(),
+            });
+            if (!updatedTitle) {
+                throw new common_1.NotFoundException('Financial title not found');
+            }
+            return {
+                title: updatedTitle,
+                settlementId: settlement.id,
+            };
+        });
+        return Object.assign(Object.assign({}, this.mapTitleToFront(result.title)), { settlementId: String(result.settlementId) });
+    }
+    async reverseTitleSettlement(titleId, settlementId, data, titleType, locale, userId) {
+        const updatedTitle = await this.prisma.$transaction(async (tx) => {
+            const title = await tx.financial_title.findFirst({
+                where: {
+                    id: titleId,
+                    title_type: titleType,
+                },
+                select: {
+                    id: true,
+                    status: true,
+                    competence_date: true,
+                },
+            });
+            if (!title) {
+                throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('itemNotFound', locale, `Financial title with ID ${titleId} not found`).replace('{{item}}', 'Financial title'));
+            }
+            await this.assertDateNotInClosedPeriod(tx, title.competence_date, 'reverse settlement');
+            const settlement = await tx.settlement.findFirst({
+                where: {
+                    id: settlementId,
+                    settlement_type: titleType,
+                    settlement_allocation: {
+                        some: {
+                            financial_installment: {
+                                title_id: title.id,
+                            },
+                        },
+                    },
+                },
+                include: {
+                    settlement_allocation: {
+                        include: {
+                            financial_installment: {
+                                select: {
+                                    id: true,
+                                    amount_cents: true,
+                                    open_amount_cents: true,
+                                    due_date: true,
+                                    status: true,
+                                },
+                            },
+                        },
+                    },
+                },
+            });
+            if (!settlement) {
+                throw new common_1.NotFoundException('Settlement not found for this title');
+            }
+            if (settlement.status === 'reversed') {
+                throw new common_1.BadRequestException('This settlement is already reversed');
+            }
+            for (const allocation of settlement.settlement_allocation) {
+                const installment = allocation.financial_installment;
+                if (!installment) {
+                    continue;
+                }
+                const nextOpenAmountCents = installment.open_amount_cents + allocation.allocated_amount_cents;
+                if (nextOpenAmountCents > installment.amount_cents) {
+                    throw new common_1.BadRequestException(`Reverse would exceed installment amount for installment ${installment.id}`);
+                }
+                const nextInstallmentStatus = this.resolveInstallmentStatus(installment.amount_cents, nextOpenAmountCents, installment.due_date);
+                await tx.financial_installment.update({
+                    where: {
+                        id: installment.id,
+                    },
                     data: {
-                        installment_id: createdInstallment.id,
-                        cost_center_id: data.cost_center_id,
-                        allocated_amount_cents: amountCents,
+                        open_amount_cents: nextOpenAmountCents,
+                        status: nextInstallmentStatus,
                     },
                 });
             }
+            await tx.settlement.update({
+                where: {
+                    id: settlement.id,
+                },
+                data: {
+                    status: 'reversed',
+                    description: [
+                        settlement.description,
+                        data.reason ? `Reversed: ${data.reason.trim()}` : 'Reversed',
+                    ]
+                        .filter(Boolean)
+                        .join(' | '),
+                },
+            });
+            const previousTitleStatus = title.status;
+            const nextTitleStatus = await this.recalculateTitleStatus(tx, title.id);
+            await this.createAuditLog(tx, {
+                action: 'REVERSE_SETTLEMENT',
+                entityTable: 'financial_title',
+                entityId: String(title.id),
+                actorUserId: userId,
+                summary: `Reversed settlement ${settlement.id} from title ${title.id}`,
+                beforeData: JSON.stringify({
+                    title_status: previousTitleStatus,
+                    settlement_status: settlement.status,
+                }),
+                afterData: JSON.stringify({
+                    title_status: nextTitleStatus,
+                    settlement_status: 'reversed',
+                }),
+            });
+            return tx.financial_title.findFirst({
+                where: {
+                    id: title.id,
+                    title_type: titleType,
+                },
+                include: this.defaultTitleInclude(),
+            });
+        });
+        if (!updatedTitle) {
+            throw new common_1.NotFoundException('Financial title not found');
         }
-        const createdTitle = await this.getTitleById(title.id, titleType, locale);
-        return this.mapTitleToFront(createdTitle, data.payment_channel);
+        return this.mapTitleToFront(updatedTitle);
     }
     async updateTitleTags(titleId, titleType, tagIds, locale) {
         const title = await this.getTitleById(titleId, titleType, locale);
@@ -1377,6 +2438,124 @@ let FinanceService = FinanceService_1 = class FinanceService {
             data: log.created_at.toISOString(),
         }));
     }
+    async resolvePaymentMethodId(tx, paymentChannel) {
+        const paymentType = this.mapPaymentMethodFromPt(paymentChannel);
+        if (!paymentType) {
+            return null;
+        }
+        const paymentMethod = await tx.payment_method.findFirst({
+            where: {
+                type: paymentType,
+                status: 'active',
+            },
+            select: {
+                id: true,
+            },
+        });
+        return (paymentMethod === null || paymentMethod === void 0 ? void 0 : paymentMethod.id) || null;
+    }
+    async assertDateNotInClosedPeriod(tx, competenceDate, operation) {
+        if (!competenceDate) {
+            return;
+        }
+        const closedPeriod = await tx.period_close.findFirst({
+            where: {
+                status: 'closed',
+                period_start: {
+                    lte: competenceDate,
+                },
+                period_end: {
+                    gte: competenceDate,
+                },
+            },
+            select: {
+                id: true,
+            },
+        });
+        if (closedPeriod) {
+            throw new common_1.BadRequestException(`Cannot ${operation}: competence is in a closed period`);
+        }
+    }
+    resolveInstallmentStatus(amountCents, openAmountCents, dueDate, currentStatus) {
+        if (currentStatus === 'canceled') {
+            return 'canceled';
+        }
+        if (openAmountCents <= 0) {
+            return 'settled';
+        }
+        if (openAmountCents < amountCents) {
+            return 'partial';
+        }
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        const dueDateOnly = new Date(dueDate);
+        dueDateOnly.setHours(0, 0, 0, 0);
+        if (dueDateOnly < today) {
+            return 'overdue';
+        }
+        return 'open';
+    }
+    deriveTitleStatusFromInstallments(installments) {
+        if (installments.length === 0) {
+            return 'open';
+        }
+        const effectiveStatuses = installments.map((installment) => this.resolveInstallmentStatus(installment.amount_cents, installment.open_amount_cents, installment.due_date, installment.status));
+        if (effectiveStatuses.every((status) => status === 'settled')) {
+            return 'settled';
+        }
+        const hasPayment = installments.some((installment) => installment.open_amount_cents < installment.amount_cents);
+        if (hasPayment) {
+            return 'partial';
+        }
+        return 'open';
+    }
+    async recalculateTitleStatus(tx, titleId) {
+        const title = await tx.financial_title.findUnique({
+            where: {
+                id: titleId,
+            },
+            select: {
+                id: true,
+                status: true,
+                financial_installment: {
+                    select: {
+                        amount_cents: true,
+                        open_amount_cents: true,
+                        due_date: true,
+                        status: true,
+                    },
+                },
+            },
+        });
+        if (!title) {
+            throw new common_1.NotFoundException('Financial title not found');
+        }
+        const nextStatus = this.deriveTitleStatusFromInstallments(title.financial_installment);
+        if (title.status !== nextStatus) {
+            await tx.financial_title.update({
+                where: {
+                    id: title.id,
+                },
+                data: {
+                    status: nextStatus,
+                },
+            });
+        }
+        return nextStatus;
+    }
+    async createAuditLog(tx, data) {
+        await tx.audit_log.create({
+            data: {
+                actor_user_id: data.actorUserId || null,
+                action: data.action,
+                entity_table: data.entityTable,
+                entity_id: data.entityId,
+                summary: data.summary || null,
+                before_data: data.beforeData || null,
+                after_data: data.afterData || null,
+            },
+        });
+    }
     mapTitleToFront(title, paymentChannelOverride) {
         var _a;
         const allocations = title.financial_installment.flatMap((installment) => installment.installment_allocation);
@@ -1397,21 +2576,26 @@ let FinanceService = FinanceService_1 = class FinanceService {
                 numero: installment.installment_number,
                 vencimento: installment.due_date.toISOString(),
                 valor: this.fromCents(installment.amount_cents),
-                status: this.mapStatusToPt(installment.status),
+                valorAberto: this.fromCents(installment.open_amount_cents),
+                status: this.mapStatusToPt(this.resolveInstallmentStatus(installment.amount_cents, installment.open_amount_cents, installment.due_date, installment.status)),
                 metodoPagamento: this.mapPaymentMethodToPt((_c = (_b = (_a = installment.settlement_allocation[0]) === null || _a === void 0 ? void 0 : _a.settlement) === null || _b === void 0 ? void 0 : _b.payment_method) === null || _c === void 0 ? void 0 : _c.type) || paymentChannelOverride || 'transferencia',
                 liquidacoes: installment.settlement_allocation.map((allocation) => {
-                    var _a, _b, _c, _d, _e;
+                    var _a, _b, _c, _d, _e, _f, _g;
                     return ({
                         id: String(allocation.id),
-                        data: (_b = (_a = allocation.settlement) === null || _a === void 0 ? void 0 : _a.settled_at) === null || _b === void 0 ? void 0 : _b.toISOString(),
+                        settlementId: ((_a = allocation.settlement) === null || _a === void 0 ? void 0 : _a.id)
+                            ? String(allocation.settlement.id)
+                            : null,
+                        data: (_c = (_b = allocation.settlement) === null || _b === void 0 ? void 0 : _b.settled_at) === null || _c === void 0 ? void 0 : _c.toISOString(),
                         valor: this.fromCents(allocation.allocated_amount_cents),
                         juros: this.fromCents(allocation.interest_cents || 0),
                         desconto: this.fromCents(allocation.discount_cents || 0),
                         multa: this.fromCents(allocation.penalty_cents || 0),
-                        contaBancariaId: ((_c = allocation.settlement) === null || _c === void 0 ? void 0 : _c.bank_account_id)
+                        contaBancariaId: ((_d = allocation.settlement) === null || _d === void 0 ? void 0 : _d.bank_account_id)
                             ? String(allocation.settlement.bank_account_id)
                             : null,
-                        metodo: this.mapPaymentMethodToPt((_e = (_d = allocation.settlement) === null || _d === void 0 ? void 0 : _d.payment_method) === null || _e === void 0 ? void 0 : _e.type) || 'transferencia',
+                        status: ((_e = allocation.settlement) === null || _e === void 0 ? void 0 : _e.status) || null,
+                        metodo: this.mapPaymentMethodToPt((_g = (_f = allocation.settlement) === null || _f === void 0 ? void 0 : _f.payment_method) === null || _g === void 0 ? void 0 : _g.type) || 'transferencia',
                     });
                 }),
             });
@@ -1462,7 +2646,6 @@ let FinanceService = FinanceService_1 = class FinanceService {
     mapStatusToPt(status) {
         const statusMap = {
             draft: 'rascunho',
-            approved: 'aprovado',
             open: 'aberto',
             partial: 'parcial',
             settled: 'liquidado',
@@ -1489,7 +2672,7 @@ let FinanceService = FinanceService_1 = class FinanceService {
         }
         const statusMap = {
             rascunho: 'draft',
-            aprovado: 'approved',
+            aprovado: 'open',
             aberto: 'open',
             parcial: 'partial',
             liquidado: 'settled',
@@ -1510,6 +2693,27 @@ let FinanceService = FinanceService_1 = class FinanceService {
         };
         return paymentMethodMap[paymentMethodType] || undefined;
     }
+    mapPaymentMethodFromPt(paymentMethodType) {
+        if (!paymentMethodType) {
+            return undefined;
+        }
+        const paymentMethodMap = {
+            boleto: 'boleto',
+            pix: 'pix',
+            transferencia: 'ted',
+            transferência: 'ted',
+            ted: 'ted',
+            doc: 'doc',
+            cartao: 'card',
+            cartão: 'card',
+            dinheiro: 'cash',
+            cheque: 'other',
+            cash: 'cash',
+            card: 'card',
+            other: 'other',
+        };
+        return paymentMethodMap[(paymentMethodType || '').toLowerCase()];
+    }
     mapAccountTypeToPt(accountType) {
         const accountTypeMap = {
             checking: 'corrente',
@@ -1689,8 +2893,10 @@ 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))),
     __metadata("design:paramtypes", [api_prisma_1.PrismaService,
         api_pagination_1.PaginationService,
-        core_1.AiService])
+        core_1.AiService,
+        core_1.FileService])
 ], FinanceService);
 //# sourceMappingURL=finance.service.js.map