@hed-hog/finance 0.0.239 → 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') {
@@ -598,12 +604,18 @@ 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);
     }
@@ -613,9 +625,15 @@ let FinanceService = FinanceService_1 = class FinanceService {
     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);
     }
@@ -857,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);
@@ -1272,6 +1652,192 @@ let FinanceService = FinanceService_1 = class FinanceService {
         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 (!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');
+        }
+        return this.mapTitleToFront(updatedTitle, data.payment_channel);
+    }
     normalizeAndValidateInstallments(data, locale) {
         const fallbackDueDate = data.due_date;
         const totalAmountCents = this.toCents(data.total_amount);
@@ -1328,7 +1894,7 @@ let FinanceService = FinanceService_1 = class FinanceService {
             await tx.financial_title.update({
                 where: { id: title.id },
                 data: {
-                    status: 'approved',
+                    status: 'open',
                 },
             });
             await this.createAuditLog(tx, {
@@ -1338,7 +1904,7 @@ let FinanceService = FinanceService_1 = class FinanceService {
                 actorUserId: userId,
                 summary: `Approved ${titleType} title ${title.id}`,
                 beforeData: JSON.stringify({ status: title.status }),
-                afterData: JSON.stringify({ status: 'approved' }),
+                afterData: JSON.stringify({ status: 'open' }),
             });
             return tx.financial_title.findFirst({
                 where: {
@@ -1404,6 +1970,57 @@ let FinanceService = FinanceService_1 = class FinanceService {
         }
         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) {
@@ -1430,8 +2047,8 @@ let FinanceService = FinanceService_1 = class FinanceService {
             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 (!['approved', 'open', 'partial'].includes(title.status)) {
-                throw new common_1.BadRequestException('Only approved/open/partial titles can be settled');
+            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({
@@ -2029,7 +2646,6 @@ let FinanceService = FinanceService_1 = class FinanceService {
     mapStatusToPt(status) {
         const statusMap = {
             draft: 'rascunho',
-            approved: 'aprovado',
             open: 'aberto',
             partial: 'parcial',
             settled: 'liquidado',
@@ -2056,7 +2672,7 @@ let FinanceService = FinanceService_1 = class FinanceService {
         }
         const statusMap = {
             rascunho: 'draft',
-            aprovado: 'approved',
+            aprovado: 'open',
             aberto: 'open',
             parcial: 'partial',
             liquidado: 'settled',
@@ -2277,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