@hed-hog/finance 0.0.252 → 0.0.256

package/src/finance.service.ts

@@ -1,15 +1,19 @@
 import { getLocaleText } from '@hed-hog/api-locale';
-import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import {
+    PageOrderDirection,
+    PaginationDTO,
+    PaginationService,
+} from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import { AiService, FileService } from '@hed-hog/core';
 import {
-  BadRequestException,
-  ConflictException,
-  forwardRef,
-  Inject,
-  Injectable,
-  Logger,
-  NotFoundException,
+    BadRequestException,
+    ConflictException,
+    forwardRef,
+    Inject,
+    Injectable,
+    Logger,
+    NotFoundException,
 } from '@nestjs/common';
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
@@ -1067,6 +1071,192 @@ export class FinanceService {
     );
   }
 
+  async getTitleSettlementsHistory(titleId: number, locale: string) {
+    const title = await this.prisma.financial_title.findUnique({
+      where: { id: titleId },
+      select: { id: true },
+    });
+
+    if (!title) {
+      throw new NotFoundException(
+        getLocaleText(
+          'itemNotFound',
+          locale,
+          `Financial title with ID ${titleId} not found`,
+        ).replace('{{item}}', 'Financial title'),
+      );
+    }
+
+    const rows = await this.prisma.$queryRaw<
+      Array<{
+        normal_id: number;
+        normal_paid_at: Date;
+        normal_amount_cents: number;
+        normal_method: string | null;
+        normal_account_id: number | null;
+        normal_account_name: string | null;
+        normal_created_at: Date;
+        normal_created_by: string | null;
+        normal_memo: string | null;
+        reconciliation_id: number | null;
+        reconciliation_status: string | null;
+        installment_id: number;
+        installment_seq: number;
+        allocation_amount_cents: number;
+        reversal_id: number | null;
+        reversal_paid_at: Date | null;
+        reversal_amount_cents: number | null;
+        reversal_created_at: Date | null;
+        reversal_created_by: string | null;
+        reversal_memo: string | null;
+      }>
+    >`
+      SELECT
+        s.id AS normal_id,
+        s.settled_at AS normal_paid_at,
+        s.amount_cents AS normal_amount_cents,
+        pm.type::text AS normal_method,
+        s.bank_account_id AS normal_account_id,
+        ba.name AS normal_account_name,
+        s.created_at AS normal_created_at,
+        u.name AS normal_created_by,
+        s.description AS normal_memo,
+        br.id AS reconciliation_id,
+        br.status::text AS reconciliation_status,
+        fi.id AS installment_id,
+        fi.installment_number AS installment_seq,
+        COALESCE(sa.amount_cents, sa.allocated_amount_cents) AS allocation_amount_cents,
+        r.id AS reversal_id,
+        r.settled_at AS reversal_paid_at,
+        r.amount_cents AS reversal_amount_cents,
+        r.created_at AS reversal_created_at,
+        ur.name AS reversal_created_by,
+        r.description AS reversal_memo
+      FROM settlement s
+      INNER JOIN settlement_allocation sa ON sa.settlement_id = s.id
+      INNER JOIN financial_installment fi ON fi.id = sa.installment_id
+      LEFT JOIN payment_method pm ON pm.id = s.payment_method_id
+      LEFT JOIN bank_account ba ON ba.id = s.bank_account_id
+      LEFT JOIN "user" u ON u.id = s.created_by_user_id
+      LEFT JOIN bank_reconciliation br ON br.settlement_id = s.id
+      LEFT JOIN settlement r ON r.reverses_settlement_id = s.id
+      LEFT JOIN "user" ur ON ur.id = r.created_by_user_id
+      WHERE fi.title_id = ${titleId}
+        AND COALESCE(s.entry_type::text, 'normal') = 'normal'
+      ORDER BY s.settled_at DESC, s.id DESC, fi.installment_number ASC
+    `;
+
+    const groups = new Map<string, any>();
+
+    for (const row of rows) {
+      const key = String(row.normal_id);
+      const existing = groups.get(key);
+
+      if (!existing) {
+        groups.set(key, {
+          normal: {
+            id: key,
+            paidAt: row.normal_paid_at?.toISOString?.() || null,
+            amountCents: Number(row.normal_amount_cents || 0),
+            type: 'NORMAL',
+            method: this.mapPaymentMethodToPt(row.normal_method) || row.normal_method,
+            account: row.normal_account_name || null,
+            accountId: row.normal_account_id
+              ? String(row.normal_account_id)
+              : null,
+            createdAt: row.normal_created_at?.toISOString?.() || null,
+            createdBy: row.normal_created_by || null,
+            memo: row.normal_memo || null,
+            reconciled: row.reconciliation_status === 'reconciled',
+            reconciliationId: row.reconciliation_id
+              ? String(row.reconciliation_id)
+              : null,
+          },
+          reversal: row.reversal_id
+            ? {
+                id: String(row.reversal_id),
+                paidAt: row.reversal_paid_at?.toISOString?.() || null,
+                amountCents: Number(row.reversal_amount_cents || 0),
+                type: 'REVERSAL',
+                createdAt: row.reversal_created_at?.toISOString?.() || null,
+                createdBy: row.reversal_created_by || null,
+                memo: row.reversal_memo || null,
+              }
+            : null,
+          allocations: [],
+          statusLabel: row.reversal_id ? 'ESTORNADO' : 'ATIVO',
+        });
+      }
+
+      groups.get(key).allocations.push({
+        installmentId: String(row.installment_id),
+        installmentSeq: Number(row.installment_seq || 0),
+        amountCents: Number(row.allocation_amount_cents || 0),
+      });
+    }
+
+    return Array.from(groups.values());
+  }
+
+  async reverseSettlementById(
+    settlementId: number,
+    data: ReverseSettlementDto,
+    locale: string,
+    userId?: number,
+  ) {
+    const updatedTitle = await this.reverseSettlementInternal(
+      settlementId,
+      data,
+      locale,
+      userId,
+    );
+
+    return this.mapTitleToFront(updatedTitle);
+  }
+
+  async unreconcileBankReconciliation(id: number, userId?: number) {
+    const reconciliation = await this.prisma.bank_reconciliation.findUnique({
+      where: { id },
+      select: {
+        id: true,
+        settlement_id: true,
+        bank_statement_line_id: true,
+      },
+    });
+
+    if (!reconciliation) {
+      throw new NotFoundException('Conciliação bancária não encontrada');
+    }
+
+    await this.prisma.$transaction(async (tx) => {
+      await tx.bank_reconciliation.delete({
+        where: { id: reconciliation.id },
+      });
+
+      await tx.bank_statement_line.updateMany({
+        where: {
+          id: reconciliation.bank_statement_line_id,
+          status: {
+            in: ['reconciled', 'adjusted'],
+          },
+        },
+        data: {
+          status: 'pending',
+        },
+      });
+
+      await this.createAuditLog(tx, {
+        action: 'UNRECONCILE_SETTLEMENT',
+        entityTable: 'bank_reconciliation',
+        entityId: String(reconciliation.id),
+        actorUserId: userId,
+        summary: `Unreconciled settlement ${reconciliation.settlement_id}`,
+      });
+    });
+
+    return { success: true };
+  }
+
   async createTag(data: CreateFinanceTagDto) {
     const slug = this.normalizeTagSlug(data.name);
 
@@ -2213,6 +2403,7 @@ export class FinanceService {
     status?: string,
   ) {
     const prismaStatus = this.mapStatusFromPt(status);
+    const search = paginationParams?.search?.trim();
     const where: any = {
       title_type: titleType,
     };
@@ -2221,15 +2412,45 @@ export class FinanceService {
       where.status = prismaStatus;
     }
 
-    return this.paginationService.paginate(
+    if (search) {
+      where.OR = [
+        {
+          document_number: {
+            contains: search,
+            mode: 'insensitive',
+          },
+        },
+        {
+          person: {
+            name: {
+              contains: search,
+              mode: 'insensitive',
+            },
+          },
+        },
+      ];
+    }
+
+    const normalizedPaginationParams: PaginationDTO = {
+      ...paginationParams,
+      sortField: paginationParams?.sortField || 'created_at',
+      sortOrder: paginationParams?.sortOrder || PageOrderDirection.Desc,
+    };
+
+    const paginated = await this.paginationService.paginate(
       this.prisma.financial_title,
-      paginationParams,
+      normalizedPaginationParams,
       {
         where,
         include: this.defaultTitleInclude(),
         orderBy: { created_at: 'desc' },
       },
     );
+
+    return {
+      ...paginated,
+      data: (paginated.data || []).map((title) => this.mapTitleToFront(title)),
+    };
   }
 
   private async getTitleById(id: number, titleType: TitleType, locale: string) {
@@ -2914,21 +3135,20 @@ export class FinanceService {
         throw new BadRequestException('Title cannot be canceled in current status');
       }
 
-      const hasActiveSettlements = await tx.settlement_allocation.findFirst({
-        where: {
-          financial_installment: {
-            title_id: title.id,
-          },
-          settlement: {
-            status: {
-              not: 'reversed',
-            },
-          },
-        },
-        select: {
-          id: true,
-        },
-      });
+      const activeSettlements = await tx.$queryRaw<Array<{ has_active: boolean }>>`
+        SELECT EXISTS (
+          SELECT 1
+          FROM settlement_allocation sa
+          INNER JOIN financial_installment fi ON fi.id = sa.installment_id
+          INNER JOIN settlement s ON s.id = sa.settlement_id
+          LEFT JOIN settlement r ON r.reverses_settlement_id = s.id
+          WHERE fi.title_id = ${title.id}
+            AND COALESCE(s.entry_type::text, 'normal') = 'normal'
+            AND r.id IS NULL
+        ) AS has_active
+      `;
+
+      const hasActiveSettlements = activeSettlements[0]?.has_active;
 
       if (hasActiveSettlements) {
         throw new ConflictException(
@@ -3101,9 +3321,18 @@ export class FinanceService {
 
       await tx.settlement_allocation.create({
         data: {
-          settlement_id: settlement.id,
-          installment_id: installment.id,
+          settlement: {
+            connect: {
+              id: settlement.id,
+            },
+          },
+          financial_installment: {
+            connect: {
+              id: installment.id,
+            },
+          },
           allocated_amount_cents: amountCents,
+          amount_cents: amountCents,
           discount_cents: this.toCents(data.discount || 0),
           interest_cents: this.toCents(data.interest || 0),
           penalty_cents: this.toCents(data.penalty || 0),
@@ -3227,97 +3456,251 @@ export class FinanceService {
     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,
-        },
-      });
+    const updatedTitle = await this.reverseSettlementInternal(
+      settlementId,
+      data,
+      locale,
+      userId,
+      {
+        titleId,
+        titleType,
+      },
+    );
 
-      if (!title) {
-        throw new NotFoundException(
-          getLocaleText(
-            'itemNotFound',
-            locale,
-            `Financial title with ID ${titleId} not found`,
-          ).replace('{{item}}', 'Financial title'),
-        );
+    if (!updatedTitle) {
+      throw new NotFoundException('Financial title not found');
+    }
+
+    return this.mapTitleToFront(updatedTitle);
+  }
+
+  private async reverseSettlementInternal(
+    settlementId: number,
+    data: ReverseSettlementDto,
+    locale: string,
+    userId?: number,
+    scope?: {
+      titleId?: number;
+      titleType?: TitleType;
+    },
+  ) {
+    const { title } = await this.prisma.$transaction(async (tx) => {
+      const settlementRows = await tx.$queryRaw<
+        Array<{
+          id: number;
+          settlement_type: string;
+          settled_at: Date;
+          amount_cents: number;
+          description: string | null;
+          person_id: number | null;
+          bank_account_id: number | null;
+          payment_method_id: number | null;
+          created_by_user_id: number | null;
+          entry_type: string | null;
+          title_id: number;
+          title_type: string;
+          title_status: string;
+          title_competence_date: Date | null;
+        }>
+      >`
+        SELECT
+          s.id,
+          s.settlement_type::text,
+          s.settled_at,
+          s.amount_cents,
+          s.description,
+          s.person_id,
+          s.bank_account_id,
+          s.payment_method_id,
+          s.created_by_user_id,
+          COALESCE(s.entry_type::text, 'normal') AS entry_type,
+          ft.id AS title_id,
+          ft.title_type::text AS title_type,
+          ft.status::text AS title_status,
+          ft.competence_date AS title_competence_date
+        FROM settlement s
+        INNER JOIN settlement_allocation sa ON sa.settlement_id = s.id
+        INNER JOIN financial_installment fi ON fi.id = sa.installment_id
+        INNER JOIN financial_title ft ON ft.id = fi.title_id
+        WHERE s.id = ${settlementId}
+        LIMIT 1
+        FOR UPDATE OF s
+      `;
+
+      const settlement = settlementRows[0];
+
+      if (!settlement) {
+        throw new NotFoundException('Settlement not found');
+      }
+
+      if (scope?.titleId && settlement.title_id !== scope.titleId) {
+        throw new NotFoundException('Settlement not found for this title');
+      }
+
+      if (scope?.titleType && settlement.title_type !== scope.titleType) {
+        throw new NotFoundException('Settlement not found for this title type');
+      }
+
+      if (settlement.entry_type !== 'normal') {
+        throw new BadRequestException('Somente liquidações normais podem ser estornadas');
       }
 
       await this.assertDateNotInClosedPeriod(
         tx,
-        title.competence_date,
+        settlement.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,
-                },
-              },
-            },
-          },
-        },
-      });
+      const alreadyReversed = await tx.$queryRaw<Array<{ id: number }>>`
+        SELECT id
+        FROM settlement
+        WHERE reverses_settlement_id = ${settlement.id}
+        LIMIT 1
+      `;
 
-      if (!settlement) {
-        throw new NotFoundException('Settlement not found for this title');
+      if (alreadyReversed.length > 0) {
+        throw new ConflictException('Liquidação já estornada.');
       }
 
-      if (settlement.status === 'reversed') {
-        throw new ConflictException('Liquidação já estornada.');
+      const isReconciled = await tx.$queryRaw<Array<{ id: number }>>`
+        SELECT id
+        FROM bank_reconciliation
+        WHERE settlement_id = ${settlement.id}
+          AND status = 'reconciled'
+        LIMIT 1
+      `;
+
+      if (isReconciled.length > 0) {
+        throw new ConflictException('Desconciliar primeiro');
       }
 
-      for (const allocation of settlement.settlement_allocation) {
-        const installment = allocation.financial_installment;
+      const allocations = await tx.$queryRaw<
+        Array<{
+          id: number;
+          installment_id: number;
+          allocated_amount_cents: number;
+          amount_cents: number | null;
+          discount_cents: number;
+          interest_cents: number;
+          penalty_cents: number;
+          installment_amount_cents: number;
+          installment_open_amount_cents: number;
+          installment_due_date: Date;
+          installment_status: string;
+        }>
+      >`
+        SELECT
+          sa.id,
+          sa.installment_id,
+          sa.allocated_amount_cents,
+          sa.amount_cents,
+          sa.discount_cents,
+          sa.interest_cents,
+          sa.penalty_cents,
+          fi.amount_cents AS installment_amount_cents,
+          fi.open_amount_cents AS installment_open_amount_cents,
+          fi.due_date AS installment_due_date,
+          fi.status::text AS installment_status
+        FROM settlement_allocation sa
+        INNER JOIN financial_installment fi ON fi.id = sa.installment_id
+        WHERE sa.settlement_id = ${settlement.id}
+        FOR UPDATE OF fi
+      `;
+
+      if (allocations.length === 0) {
+        throw new BadRequestException('Settlement has no allocations to reverse');
+      }
 
-        if (!installment) {
-          continue;
-        }
+      const reversalMemo = data.reason?.trim() || data.memo?.trim() || 'Estorno';
+      const reversalAmountCents = -Math.abs(Number(settlement.amount_cents || 0));
+
+      const reversalResult = await tx.$queryRaw<Array<{ id: number }>>`
+        INSERT INTO settlement (
+          person_id,
+          bank_account_id,
+          payment_method_id,
+          settlement_type,
+          entry_type,
+          status,
+          settled_at,
+          amount_cents,
+          description,
+          external_reference,
+          created_by_user_id,
+          reverses_settlement_id,
+          created_at,
+          updated_at
+        )
+        VALUES (
+          ${settlement.person_id},
+          ${settlement.bank_account_id},
+          ${settlement.payment_method_id},
+          ${settlement.settlement_type}::settlement_settlement_type_enum,
+          'reversal'::settlement_entry_type_enum,
+          'confirmed'::settlement_status_enum,
+          NOW(),
+          ${reversalAmountCents},
+          ${reversalMemo},
+          NULL,
+          ${userId || settlement.created_by_user_id || null},
+          ${settlement.id},
+          NOW(),
+          NOW()
+        )
+        RETURNING id
+      `;
+
+      const reversalId = reversalResult[0]?.id;
+
+      if (!reversalId) {
+        throw new BadRequestException('Could not create reversal settlement');
+      }
+
+      for (const allocation of allocations) {
+        const originalAmount = Number(
+          allocation.amount_cents ?? allocation.allocated_amount_cents ?? 0,
+        );
+
+        await tx.settlement_allocation.create({
+          data: {
+            settlement: {
+              connect: {
+                id: reversalId,
+              },
+            },
+            financial_installment: {
+              connect: {
+                id: allocation.installment_id,
+              },
+            },
+            allocated_amount_cents: -Math.abs(originalAmount),
+            amount_cents: -Math.abs(originalAmount),
+            discount_cents: -Math.abs(allocation.discount_cents || 0),
+            interest_cents: -Math.abs(allocation.interest_cents || 0),
+            penalty_cents: -Math.abs(allocation.penalty_cents || 0),
+          },
+        });
 
         const nextOpenAmountCents =
-          installment.open_amount_cents + allocation.allocated_amount_cents;
+          Number(allocation.installment_open_amount_cents || 0) +
+          Math.abs(originalAmount);
 
-        if (nextOpenAmountCents > installment.amount_cents) {
-          throw new BadRequestException(
-            `Reverse would exceed installment amount for installment ${installment.id}`,
+        if (nextOpenAmountCents > Number(allocation.installment_amount_cents || 0)) {
+          throw new ConflictException(
+            `Estorno excederia o valor original da parcela ${allocation.installment_id}`,
           );
         }
 
         const nextInstallmentStatus = this.resolveInstallmentStatus(
-          installment.amount_cents,
+          Number(allocation.installment_amount_cents || 0),
           nextOpenAmountCents,
-          installment.due_date,
+          new Date(allocation.installment_due_date),
+          allocation.installment_status,
         );
 
         await tx.financial_installment.update({
           where: {
-            id: installment.id,
+            id: allocation.installment_id,
           },
           data: {
             open_amount_cents: nextOpenAmountCents,
@@ -3326,76 +3709,47 @@ export class FinanceService {
         });
       }
 
-      await tx.settlement.update({
-        where: {
-          id: settlement.id,
-        },
-        data: {
-          status: 'reversed',
-          description: [
-            settlement.description,
-            data.reason ? `Reversed: ${data.reason.trim()}` : 'Reversed',
-          ]
-            .filter(Boolean)
-            .join(' | '),
-        },
-      });
-
-      await tx.bank_reconciliation.updateMany({
-        where: {
-          settlement_id: settlement.id,
-          status: 'pending',
-        },
-        data: {
-          status: 'reversed',
-        },
-      });
-
-      await tx.bank_reconciliation.updateMany({
-        where: {
-          settlement_id: settlement.id,
-          status: {
-            in: ['reconciled', 'adjusted'],
-          },
-        },
-        data: {
-          status: 'adjusted',
-        },
-      });
-
-      const previousTitleStatus = title.status;
-      const nextTitleStatus = await this.recalculateTitleStatus(tx, title.id);
+      const nextTitleStatus = await this.recalculateTitleStatus(
+        tx,
+        settlement.title_id,
+      );
 
       await this.createAuditLog(tx, {
         action: 'REVERSE_SETTLEMENT',
         entityTable: 'financial_title',
-        entityId: String(title.id),
+        entityId: String(settlement.title_id),
         actorUserId: userId,
-        summary: `Reversed settlement ${settlement.id} from title ${title.id}`,
+        summary: `Created reversal ${reversalId} for settlement ${settlement.id}`,
         beforeData: JSON.stringify({
-          title_status: previousTitleStatus,
-          settlement_status: settlement.status,
+          title_status: settlement.title_status,
+          settlement_id: settlement.id,
+          settlement_entry_type: settlement.entry_type,
         }),
         afterData: JSON.stringify({
           title_status: nextTitleStatus,
-          settlement_status: 'reversed',
+          settlement_id: settlement.id,
+          reversal_settlement_id: reversalId,
         }),
       });
 
-      return tx.financial_title.findFirst({
+      const updatedTitle = await tx.financial_title.findFirst({
         where: {
-          id: title.id,
-          title_type: titleType,
+          id: settlement.title_id,
+          title_type: settlement.title_type as TitleType,
         },
         include: this.defaultTitleInclude(),
       });
-    });
 
-    if (!updatedTitle) {
-      throw new NotFoundException('Financial title not found');
-    }
+      if (!updatedTitle) {
+        throw new NotFoundException('Financial title not found');
+      }
 
-    return this.mapTitleToFront(updatedTitle);
+      return {
+        title: updatedTitle,
+      };
+    });
+
+    return title;
   }
 
   private async updateTitleTags(
@@ -4213,7 +4567,28 @@ export class FinanceService {
     return Math.round(value * 100);
   }
 
-  private fromCents(value: number) {
-    return Number((value / 100).toFixed(2));
+  private fromCents(value: number | bigint | string | null | undefined) {
+    if (value === null || value === undefined) {
+      return 0;
+    }
+
+    if (typeof value === 'bigint') {
+      const isNegative = value < BigInt(0);
+      const absoluteValue = isNegative ? -value : value;
+      const whole = absoluteValue / BigInt(100);
+      const cents = absoluteValue % BigInt(100);
+      const composedValue = Number(whole) + Number(cents) / 100;
+
+      return Number((isNegative ? -composedValue : composedValue).toFixed(2));
+    }
+
+    const numericValue =
+      typeof value === 'string' ? Number(value) : Number(value || 0);
+
+    if (!Number.isFinite(numericValue)) {
+      return 0;
+    }
+
+    return Number((numericValue / 100).toFixed(2));
   }
 }