@hed-hog/finance 0.0.239 → 0.0.240

package/src/finance.service.ts

@@ -1,13 +1,17 @@
 import { getLocaleText } from '@hed-hog/api-locale';
 import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
-import { AiService } from '@hed-hog/core';
+import { AiService, FileService } from '@hed-hog/core';
 import {
-    BadRequestException,
-    Injectable,
-    Logger,
-    NotFoundException,
+  BadRequestException,
+  forwardRef,
+  Inject,
+  Injectable,
+  Logger,
+  NotFoundException,
 } from '@nestjs/common';
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
 import { CreateBankAccountDto } from './dto/create-bank-account.dto';
 import { CreateCostCenterDto } from './dto/create-cost-center.dto';
 import { CreateFinanceCategoryDto } from './dto/create-finance-category.dto';
@@ -31,7 +35,6 @@ type InstallmentStatus =
   | 'overdue';
 type TitleStatus =
   | 'draft'
-  | 'approved'
   | 'open'
   | 'partial'
   | 'settled'
@@ -46,6 +49,8 @@ export class FinanceService {
     private readonly prisma: PrismaService,
     private readonly paginationService: PaginationService,
     private readonly ai: AiService,
+    @Inject(forwardRef(() => FileService))
+    private readonly fileService: FileService,
   ) {}
 
   async getAgentExtractInfoFromFile(
@@ -848,6 +853,15 @@ export class FinanceService {
     return this.createTitle(data, 'payable', locale, userId);
   }
 
+  async updateAccountsPayableTitle(
+    id: number,
+    data: CreateFinancialTitleDto,
+    locale: string,
+    userId?: number,
+  ) {
+    return this.updateDraftTitle(id, data, 'payable', locale, userId);
+  }
+
   async approveAccountsPayableTitle(id: number, locale: string, userId?: number) {
     return this.approveTitle(id, 'payable', locale, userId);
   }
@@ -861,6 +875,15 @@ export class FinanceService {
     return this.rejectTitle(id, data, 'payable', locale, userId);
   }
 
+  async cancelAccountsPayableTitle(
+    id: number,
+    data: RejectTitleDto,
+    locale: string,
+    userId?: number,
+  ) {
+    return this.cancelTitle(id, data, 'payable', locale, userId);
+  }
+
   async settleAccountsPayableInstallment(
     id: number,
     data: SettleInstallmentDto,
@@ -895,6 +918,15 @@ export class FinanceService {
     return this.createTitle(data, 'receivable', locale, userId);
   }
 
+  async updateAccountsReceivableTitle(
+    id: number,
+    data: CreateFinancialTitleDto,
+    locale: string,
+    userId?: number,
+  ) {
+    return this.updateDraftTitle(id, data, 'receivable', locale, userId);
+  }
+
   async approveAccountsReceivableTitle(
     id: number,
     locale: string,
@@ -903,6 +935,15 @@ export class FinanceService {
     return this.approveTitle(id, 'receivable', locale, userId);
   }
 
+  async cancelAccountsReceivableTitle(
+    id: number,
+    data: RejectTitleDto,
+    locale: string,
+    userId?: number,
+  ) {
+    return this.cancelTitle(id, data, 'receivable', locale, userId);
+  }
+
   async settleAccountsReceivableInstallment(
     id: number,
     data: SettleInstallmentDto,
@@ -1248,6 +1289,497 @@ export class FinanceService {
     }));
   }
 
+  async exportBankStatementsCsv(bankAccountId: number) {
+    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: number,
+    file: MulterFile,
+    locale: string,
+    userId?: number,
+  ) {
+    if (!file) {
+      throw new BadRequestException('File is required');
+    }
+
+    const bankAccount = await this.prisma.bank_account.findUnique({
+      where: { id: bankAccountId },
+      select: { id: true },
+    });
+
+    if (!bankAccount) {
+      throw new NotFoundException(
+        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 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) as Array<{
+      postedDate: Date;
+      amountCents: number;
+      externalId: string | null;
+      description: string;
+      dedupeKey: string;
+    }>;
+
+    if (normalizedEntries.length === 0) {
+      throw new 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,
+    };
+  }
+
+  private detectStatementSourceType(file: MulterFile): 'csv' | 'ofx' {
+    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 BadRequestException('Only CSV and OFX files are supported');
+  }
+
+  private async getUploadedFileText(file: MulterFile): Promise<string> {
+    let buffer = file.buffer;
+
+    if (!buffer && file.path) {
+      buffer = await readFile(file.path);
+    }
+
+    if (!buffer || buffer.length === 0) {
+      throw new BadRequestException('Uploaded file is empty');
+    }
+
+    const utf8 = buffer.toString('utf8');
+    if (utf8.includes('�')) {
+      return buffer.toString('latin1');
+    }
+
+    return utf8;
+  }
+
+  private parseCsvStatements(content: string) {
+    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?.trim() || 'Movimentação importada',
+          externalId: externalIdRaw?.trim() || null,
+        };
+      })
+      .filter(Boolean) as Array<{
+      postedDate: string;
+      amount: number;
+      description: string;
+      externalId: string | null;
+    }>;
+  }
+
+  private parseOfxStatements(content: string) {
+    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) => {
+        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 = this.extractOfxTag(segment, 'TRNTYPE')?.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) as Array<{
+      postedDate: string;
+      amount: number;
+      description: string;
+      externalId: string | null;
+    }>;
+  }
+
+  private detectCsvDelimiter(line: string) {
+    const delimiters = [';', ',', '\t'];
+    const counts = delimiters.map((delimiter) => ({
+      delimiter,
+      count: (line.match(new RegExp(`\\${delimiter}`, 'g')) || []).length,
+    }));
+
+    return counts.sort((a, b) => b.count - a.count)[0]?.delimiter || ';';
+  }
+
+  private parseCsvLine(line: string, delimiter: string) {
+    const result: string[] = [];
+    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;
+  }
+
+  private normalizeCsvHeader(value: string) {
+    return String(value || '')
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]/g, '');
+  }
+
+  private findFirstHeaderIndex(headers: string[], candidates: string[]) {
+    return headers.findIndex((header) =>
+      candidates.some((candidate) => header.includes(candidate)),
+    );
+  }
+
+  private parseStatementDate(value?: string) {
+    const raw = String(value || '').trim();
+    if (!raw) {
+      return '';
+    }
+
+    const onlyDateDigits = raw.match(/^(\d{8})/);
+    if (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 '';
+  }
+
+  private resolveCsvAmount(
+    amountRaw?: string,
+    debitRaw?: string,
+    creditRaw?: string,
+  ): number | null {
+    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;
+  }
+
+  private extractOfxTag(segment: string, tag: string) {
+    const regex = new RegExp(`<${tag}>([^\n\r<]*)`, 'i');
+    const match = segment.match(regex);
+    return match?.[1]?.trim() || '';
+  }
+
+  private createShortHash(input: string, length = 40) {
+    return createHash('sha256').update(input).digest('hex').slice(0, length);
+  }
+
+  private escapeCsvCell(value: string | number | null | undefined) {
+    const normalizedValue = String(value ?? '');
+    const escapedValue = normalizedValue.replace(/"/g, '""');
+
+    return `"${escapedValue}"`;
+  }
+
   async createBankAccount(data: CreateBankAccountDto, userId?: number) {
     const accountType = this.mapAccountTypeFromPt(data.type);
 
@@ -1785,6 +2317,255 @@ export class FinanceService {
     return this.mapTitleToFront(createdTitle, data.payment_channel);
   }
 
+  private async updateDraftTitle(
+    titleId: number,
+    data: CreateFinancialTitleDto,
+    titleType: TitleType,
+    locale: string,
+    userId?: number,
+  ) {
+    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 NotFoundException(
+          getLocaleText(
+            'itemNotFound',
+            locale,
+            `Financial title with ID ${titleId} not found`,
+          ).replace('{{item}}', 'Financial title'),
+        );
+      }
+
+      if (title.status !== 'draft') {
+        throw new 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 BadRequestException(
+          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 BadRequestException(
+            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 BadRequestException(
+            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 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 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 NotFoundException('Financial title not found');
+    }
+
+    return this.mapTitleToFront(updatedTitle, data.payment_channel);
+  }
+
   private normalizeAndValidateInstallments(
     data: CreateFinancialTitleDto,
     locale: string,
@@ -1896,7 +2677,7 @@ export class FinanceService {
       await tx.financial_title.update({
         where: { id: title.id },
         data: {
-          status: 'approved',
+          status: 'open',
         },
       });
 
@@ -1907,7 +2688,7 @@ export 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({
@@ -2002,6 +2783,82 @@ export class FinanceService {
     return this.mapTitleToFront(updatedTitle);
   }
 
+  private async cancelTitle(
+    titleId: number,
+    data: RejectTitleDto,
+    titleType: TitleType,
+    locale: string,
+    userId?: number,
+  ) {
+    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 NotFoundException(
+          getLocaleText(
+            'itemNotFound',
+            locale,
+            `Financial title with ID ${titleId} not found`,
+          ).replace('{{item}}', 'Financial title'),
+        );
+      }
+
+      if (title.status === 'settled' || title.status === 'canceled') {
+        throw new 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?.reason || null,
+        }),
+      });
+
+      return tx.financial_title.findFirst({
+        where: {
+          id: title.id,
+          title_type: titleType,
+        },
+        include: this.defaultTitleInclude(),
+      });
+    });
+
+    if (!updatedTitle) {
+      throw new NotFoundException('Financial title not found');
+    }
+
+    return this.mapTitleToFront(updatedTitle);
+  }
+
   private async settleTitleInstallment(
     titleId: number,
     data: SettleInstallmentDto,
@@ -2044,9 +2901,9 @@ export class FinanceService {
         );
       }
 
-      if (!['approved', 'open', 'partial'].includes(title.status)) {
+      if (!['open', 'partial'].includes(title.status)) {
         throw new BadRequestException(
-          'Only approved/open/partial titles can be settled',
+          'Only open/partial titles can be settled',
         );
       }
 
@@ -2863,7 +3720,6 @@ export class FinanceService {
   private mapStatusToPt(status?: string | null) {
     const statusMap = {
       draft: 'rascunho',
-      approved: 'aprovado',
       open: 'aberto',
       partial: 'parcial',
       settled: 'liquidado',
@@ -2895,7 +3751,7 @@ export class FinanceService {
 
     const statusMap = {
       rascunho: 'draft',
-      aprovado: 'approved',
+      aprovado: 'open',
       aberto: 'open',
       parcial: 'partial',
       liquidado: 'settled',