@hed-hog/finance 0.0.279 → 0.0.285

package/src/finance.service.ts

@@ -1,19 +1,19 @@
 import { getLocaleText } from '@hed-hog/api-locale';
 import {
-  PageOrderDirection,
-  PaginationDTO,
-  PaginationService,
+    PageOrderDirection,
+    PaginationDTO,
+    PaginationService,
 } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import { AiService, FileService, SettingService } 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';
@@ -52,6 +52,7 @@ type TitleStatus =
   | 'overdue';
 
 type ForecastScenario = 'base' | 'pessimista' | 'otimista';
+type FinanceReportGroupBy = 'day' | 'week' | 'month' | 'year';
 
 type FinancialScenarioConfig = {
   id: ForecastScenario;
@@ -932,6 +933,465 @@ export class FinanceService {
     };
   }
 
+  async getOverviewResultsReport(filters?: {
+    from?: string;
+    to?: string;
+    groupBy?: FinanceReportGroupBy;
+  }) {
+    const { fromDate, toDate } = this.resolveReportDateRange(
+      filters?.from,
+      filters?.to,
+    );
+    const groupBy = this.resolveReportGroupBy(filters?.groupBy);
+    const installments = await this.prisma.financial_installment.findMany({
+      where: {
+        competence_date: {
+          gte: fromDate,
+          lte: toDate,
+        },
+        status: {
+          not: 'canceled',
+        },
+        financial_title: {
+          status: {
+            notIn: ['draft', 'canceled'],
+          },
+        },
+      },
+      select: {
+        competence_date: true,
+        amount_cents: true,
+        financial_title: {
+          select: {
+            title_type: true,
+            finance_category: {
+              select: {
+                code: true,
+                name: true,
+                kind: true,
+              },
+            },
+          },
+        },
+      },
+      orderBy: {
+        competence_date: 'asc',
+      },
+    });
+
+    const grouped = new Map<
+      string,
+      {
+        period: string;
+        faturamento: number;
+        despesasEmprestimos: number;
+        diferenca: number;
+        aporteInvestidor: number;
+        emprestimoBanco: number;
+        despesas: number;
+      }
+    >();
+
+    for (const installment of installments) {
+      const category = installment.financial_title.finance_category;
+
+      if (this.isTransferReportCategory(category)) {
+        continue;
+      }
+
+      const period = this.getReportBucketKey(
+        installment.competence_date,
+        groupBy,
+      );
+      const current = grouped.get(period) || {
+        period,
+        faturamento: 0,
+        despesasEmprestimos: 0,
+        diferenca: 0,
+        aporteInvestidor: 0,
+        emprestimoBanco: 0,
+        despesas: 0,
+      };
+      const amount = this.fromCents(installment.amount_cents);
+
+      if (installment.financial_title.title_type === 'receivable') {
+        if (this.isInvestorContributionReportCategory(category)) {
+          current.aporteInvestidor += amount;
+        } else if (this.isLoanReportCategory(category)) {
+          current.emprestimoBanco += amount;
+        } else {
+          current.faturamento += amount;
+        }
+      } else if (this.isLoanReportCategory(category)) {
+        current.emprestimoBanco += amount;
+      } else {
+        current.despesas += amount;
+      }
+
+      current.despesasEmprestimos =
+        current.despesas + current.emprestimoBanco;
+      current.diferenca = current.faturamento - current.despesasEmprestimos;
+
+      grouped.set(period, current);
+    }
+
+    const rows = Array.from(grouped.values())
+      .sort((a, b) => this.sortReportBuckets(a.period, b.period, groupBy))
+      .map((row) => ({
+        period: row.period,
+        faturamento: this.roundCurrency(row.faturamento),
+        despesasEmprestimos: this.roundCurrency(row.despesasEmprestimos),
+        diferenca: this.roundCurrency(row.diferenca),
+        aporteInvestidor: this.roundCurrency(row.aporteInvestidor),
+        emprestimoBanco: this.roundCurrency(row.emprestimoBanco),
+        despesas: this.roundCurrency(row.despesas),
+      }));
+
+    const totals = rows.reduce(
+      (acc, row) => {
+        acc.faturamento += row.faturamento;
+        acc.despesasEmprestimos += row.despesasEmprestimos;
+        acc.diferenca += row.diferenca;
+        acc.aporteInvestidor += row.aporteInvestidor;
+        acc.emprestimoBanco += row.emprestimoBanco;
+        acc.despesas += row.despesas;
+        return acc;
+      },
+      {
+        faturamento: 0,
+        despesasEmprestimos: 0,
+        diferenca: 0,
+        aporteInvestidor: 0,
+        emprestimoBanco: 0,
+        despesas: 0,
+      },
+    );
+
+    return {
+      rows,
+      totals: {
+        faturamento: this.roundCurrency(totals.faturamento),
+        despesasEmprestimos: this.roundCurrency(totals.despesasEmprestimos),
+        diferenca: this.roundCurrency(totals.diferenca),
+        aporteInvestidor: this.roundCurrency(totals.aporteInvestidor),
+        emprestimoBanco: this.roundCurrency(totals.emprestimoBanco),
+        despesas: this.roundCurrency(totals.despesas),
+        margem:
+          totals.faturamento > 0
+            ? this.roundCurrency(
+                (totals.diferenca / Math.abs(totals.faturamento)) * 100,
+              )
+            : 0,
+      },
+    };
+  }
+
+  async getTopCustomersReport(filters?: {
+    from?: string;
+    to?: string;
+    groupBy?: FinanceReportGroupBy;
+    topN?: number;
+    search?: string;
+  }) {
+    const { fromDate, toDate } = this.resolveReportDateRange(
+      filters?.from,
+      filters?.to,
+    );
+    const groupBy = this.resolveReportGroupBy(filters?.groupBy);
+    const topN = this.resolveTopN(filters?.topN);
+    const normalizedSearch = this.normalizeReportText(filters?.search || '');
+    const installments = await this.prisma.financial_installment.findMany({
+      where: {
+        competence_date: {
+          gte: fromDate,
+          lte: toDate,
+        },
+        status: {
+          not: 'canceled',
+        },
+        financial_title: {
+          title_type: 'receivable',
+          status: {
+            notIn: ['draft', 'canceled'],
+          },
+        },
+      },
+      select: {
+        competence_date: true,
+        amount_cents: true,
+        financial_title: {
+          select: {
+            person_id: true,
+            person: {
+              select: {
+                name: true,
+              },
+            },
+            finance_category: {
+              select: {
+                code: true,
+                name: true,
+                kind: true,
+              },
+            },
+          },
+        },
+      },
+      orderBy: {
+        competence_date: 'asc',
+      },
+    });
+
+    const byCustomer = new Map<string, { customer: string; value: number }>();
+    const byBucket = new Map<string, number>();
+
+    for (const installment of installments) {
+      const category = installment.financial_title.finance_category;
+
+      if (
+        this.isTransferReportCategory(category) ||
+        this.isLoanReportCategory(category) ||
+        this.isInvestorContributionReportCategory(category)
+      ) {
+        continue;
+      }
+
+      const customer =
+        installment.financial_title.person?.name ||
+        `Customer ${installment.financial_title.person_id}`;
+      const amount = this.fromCents(installment.amount_cents);
+      const current = byCustomer.get(customer) || { customer, value: 0 };
+
+      current.value += amount;
+      byCustomer.set(customer, current);
+
+      const period = this.getReportBucketKey(
+        installment.competence_date,
+        groupBy,
+      );
+
+      byBucket.set(period, (byBucket.get(period) || 0) + amount);
+    }
+
+    const filteredCustomers = Array.from(byCustomer.values())
+      .filter((item) =>
+        normalizedSearch.length === 0
+          ? true
+          : this.normalizeReportText(item.customer).includes(normalizedSearch),
+      )
+      .sort((a, b) => b.value - a.value);
+
+    const topCustomers = filteredCustomers.slice(0, topN).map((item) => ({
+      customer: item.customer,
+      value: this.roundCurrency(item.value),
+    }));
+    const total = this.roundCurrency(
+      topCustomers.reduce((acc, item) => acc + item.value, 0),
+    );
+    const top5 = this.roundCurrency(
+      topCustomers.slice(0, 5).reduce((acc, item) => acc + item.value, 0),
+    );
+    const pieData = topCustomers.slice(0, 9).map((item) => ({
+      customer: item.customer,
+      value: item.value,
+    }));
+    const othersValue = this.roundCurrency(
+      topCustomers.slice(9).reduce((acc, item) => acc + item.value, 0),
+    );
+
+    if (othersValue > 0) {
+      pieData.push({
+        customer: 'Outros',
+        value: othersValue,
+      });
+    }
+
+    const groupedPeriods = Array.from(byBucket.entries())
+      .map(([period, value]) => ({
+        period,
+        value: this.roundCurrency(value),
+      }))
+      .sort((a, b) => this.sortReportBuckets(a.period, b.period, groupBy));
+
+    return {
+      total,
+      top5Percent: total > 0 ? this.roundCurrency((top5 / total) * 100) : 0,
+      topCustomers,
+      pieData,
+      groupedPeriods,
+      leader: topCustomers[0] || null,
+    };
+  }
+
+  async getTopOperationalExpensesReport(filters?: {
+    from?: string;
+    to?: string;
+    groupBy?: FinanceReportGroupBy;
+    topN?: number;
+    search?: string;
+  }) {
+    const { fromDate, toDate } = this.resolveReportDateRange(
+      filters?.from,
+      filters?.to,
+    );
+    const groupBy = this.resolveReportGroupBy(filters?.groupBy);
+    const topN = this.resolveTopN(filters?.topN);
+    const normalizedSearch = this.normalizeReportText(filters?.search || '');
+    const installments = await this.prisma.financial_installment.findMany({
+      where: {
+        competence_date: {
+          gte: fromDate,
+          lte: toDate,
+        },
+        status: {
+          not: 'canceled',
+        },
+        financial_title: {
+          title_type: 'payable',
+          status: {
+            notIn: ['draft', 'canceled'],
+          },
+        },
+      },
+      select: {
+        competence_date: true,
+        amount_cents: true,
+        installment_allocation: {
+          select: {
+            allocated_amount_cents: true,
+            cost_center: {
+              select: {
+                name: true,
+              },
+            },
+          },
+        },
+        financial_title: {
+          select: {
+            finance_category: {
+              select: {
+                code: true,
+                name: true,
+                kind: true,
+              },
+            },
+          },
+        },
+      },
+      orderBy: {
+        competence_date: 'asc',
+      },
+    });
+
+    const byExpense = new Map<
+      string,
+      { category: string; costCenter: string; label: string; value: number }
+    >();
+    const byCostCenter = new Map<string, number>();
+    const byBucket = new Map<string, number>();
+
+    for (const installment of installments) {
+      const category = installment.financial_title.finance_category;
+
+      if (
+        this.isTransferReportCategory(category) ||
+        this.isLoanReportCategory(category)
+      ) {
+        continue;
+      }
+
+      const allocations =
+        installment.installment_allocation.length > 0
+          ? installment.installment_allocation.map((allocation) => ({
+              costCenter: allocation.cost_center?.name || 'N/A',
+              amount: this.fromCents(allocation.allocated_amount_cents),
+            }))
+          : [
+              {
+                costCenter: 'N/A',
+                amount: this.fromCents(installment.amount_cents),
+              },
+            ];
+
+      const period = this.getReportBucketKey(
+        installment.competence_date,
+        groupBy,
+      );
+
+      for (const allocation of allocations) {
+        const categoryName = category?.name || 'Sem categoria';
+        const key = `${categoryName}::${allocation.costCenter}`;
+        const current = byExpense.get(key) || {
+          category: categoryName,
+          costCenter: allocation.costCenter,
+          label: `${categoryName} - ${allocation.costCenter}`,
+          value: 0,
+        };
+
+        current.value += allocation.amount;
+        byExpense.set(key, current);
+        byCostCenter.set(
+          allocation.costCenter,
+          (byCostCenter.get(allocation.costCenter) || 0) + allocation.amount,
+        );
+        byBucket.set(period, (byBucket.get(period) || 0) + allocation.amount);
+      }
+    }
+
+    const filteredExpenses = Array.from(byExpense.values())
+      .filter((item) =>
+        normalizedSearch.length === 0
+          ? true
+          : this.normalizeReportText(
+              `${item.category} ${item.costCenter}`,
+            ).includes(normalizedSearch),
+      )
+      .sort((a, b) => b.value - a.value);
+
+    const topExpenses = filteredExpenses.slice(0, topN).map((item) => ({
+      category: item.category,
+      costCenter: item.costCenter,
+      label: item.label,
+      value: this.roundCurrency(item.value),
+    }));
+    const total = this.roundCurrency(
+      topExpenses.reduce((acc, item) => acc + item.value, 0),
+    );
+    const pieByCostCenter = new Map<string, number>();
+
+    for (const item of topExpenses) {
+      pieByCostCenter.set(
+        item.costCenter,
+        (pieByCostCenter.get(item.costCenter) || 0) + item.value,
+      );
+    }
+
+    const pieData = Array.from(pieByCostCenter.entries())
+      .map(([name, value]) => ({
+        name,
+        value: this.roundCurrency(value),
+      }))
+      .sort((a, b) => b.value - a.value);
+    const groupedPeriods = Array.from(byBucket.entries())
+      .map(([period, value]) => ({
+        period,
+        value: this.roundCurrency(value),
+      }))
+      .sort((a, b) => this.sortReportBuckets(a.period, b.period, groupBy));
+
+    return {
+      total,
+      average:
+        topExpenses.length > 0
+          ? this.roundCurrency(total / topExpenses.length)
+          : 0,
+      topExpenses,
+      pieData,
+      groupedPeriods,
+      highest: topExpenses[0] || null,
+    };
+  }
+
   async updateScenarioSettings(
     scenario: string,
     data: {
@@ -6153,6 +6613,181 @@ export class FinanceService {
     }
   }
 
+  private resolveReportDateRange(from?: string, to?: string) {
+    const fromDate = from
+      ? new Date(`${from}T00:00:00.000`)
+      : new Date('2021-01-01T00:00:00.000');
+    const toDate = to
+      ? new Date(`${to}T23:59:59.999`)
+      : new Date('2026-12-31T23:59:59.999');
+
+    if (
+      Number.isNaN(fromDate.getTime()) ||
+      Number.isNaN(toDate.getTime()) ||
+      fromDate > toDate
+    ) {
+      throw new BadRequestException('Invalid report date range');
+    }
+
+    return { fromDate, toDate };
+  }
+
+  private resolveReportGroupBy(groupBy?: string): FinanceReportGroupBy {
+    if (groupBy === 'day' || groupBy === 'week' || groupBy === 'month') {
+      return groupBy;
+    }
+
+    return 'year';
+  }
+
+  private resolveTopN(topN?: number) {
+    if (!topN || !Number.isFinite(topN)) {
+      return 20;
+    }
+
+    return Math.max(1, Math.min(100, Math.trunc(topN)));
+  }
+
+  private getReportBucketKey(date: Date, groupBy: FinanceReportGroupBy) {
+    const baseDate = this.startOfDay(date);
+
+    if (groupBy === 'day') {
+      return baseDate.toISOString().slice(0, 10);
+    }
+
+    if (groupBy === 'week') {
+      const weekStart = this.startOfWeek(baseDate);
+      const isoWeek = this.getIsoWeek(weekStart);
+
+      return `${weekStart.getFullYear()}-W${String(isoWeek).padStart(2, '0')}`;
+    }
+
+    if (groupBy === 'month') {
+      return `${baseDate.getFullYear()}-${String(baseDate.getMonth() + 1).padStart(2, '0')}`;
+    }
+
+    return String(baseDate.getFullYear());
+  }
+
+  private sortReportBuckets(
+    a: string,
+    b: string,
+    groupBy: FinanceReportGroupBy,
+  ) {
+    if (groupBy === 'year' || groupBy === 'month' || groupBy === 'day') {
+      return a.localeCompare(b);
+    }
+
+    const [aYear, aWeek] = a.split('-W');
+    const [bYear, bWeek] = b.split('-W');
+    const yearDiff = Number(aYear) - Number(bYear);
+
+    if (yearDiff !== 0) {
+      return yearDiff;
+    }
+
+    return Number(aWeek) - Number(bWeek);
+  }
+
+  private startOfWeek(date: Date) {
+    const current = new Date(date);
+    const day = current.getDay();
+    const diff = day === 0 ? -6 : 1 - day;
+
+    current.setDate(current.getDate() + diff);
+    current.setHours(0, 0, 0, 0);
+
+    return current;
+  }
+
+  private getIsoWeek(date: Date) {
+    const current = new Date(
+      Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()),
+    );
+    const dayNum = current.getUTCDay() || 7;
+
+    current.setUTCDate(current.getUTCDate() + 4 - dayNum);
+
+    const yearStart = new Date(Date.UTC(current.getUTCFullYear(), 0, 1));
+
+    return Math.ceil(
+      ((current.getTime() - yearStart.getTime()) / 86_400_000 + 1) / 7,
+    );
+  }
+
+  private normalizeReportText(value: string) {
+    return value
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .toLowerCase()
+      .trim();
+  }
+
+  private isTransferReportCategory(category?: {
+    code?: string | null;
+    name?: string | null;
+    kind?: string | null;
+  } | null) {
+    if (!category) {
+      return false;
+    }
+
+    if (category.kind === 'transfer') {
+      return true;
+    }
+
+    const haystack = this.normalizeReportText(
+      `${category.code || ''} ${category.name || ''}`,
+    );
+
+    return haystack.includes('transfer');
+  }
+
+  private isLoanReportCategory(category?: {
+    code?: string | null;
+    name?: string | null;
+    kind?: string | null;
+  } | null) {
+    if (!category) {
+      return false;
+    }
+
+    const haystack = this.normalizeReportText(
+      `${category.code || ''} ${category.name || ''}`,
+    );
+
+    return (
+      haystack.includes('emprestimo') ||
+      haystack.includes('financiamento') ||
+      haystack.includes('loan')
+    );
+  }
+
+  private isInvestorContributionReportCategory(category?: {
+    code?: string | null;
+    name?: string | null;
+    kind?: string | null;
+  } | null) {
+    if (!category) {
+      return false;
+    }
+
+    const haystack = this.normalizeReportText(
+      `${category.code || ''} ${category.name || ''}`,
+    );
+
+    return (
+      haystack.includes('aporte') ||
+      haystack.includes('investidor') ||
+      haystack.includes('capital') ||
+      haystack.includes('socio')
+    );
+  }
+
+  private roundCurrency(value: number) {
+    return Number(value.toFixed(2));
+  }
+
   private toCents(value: number) {
     return Math.round(value * 100);
   }

package/src/index.ts

@@ -7,6 +7,7 @@ export * from './finance-cost-centers.controller';
 export * from './finance-data.controller';
 export * from './finance-installments.controller';
 export * from './finance-period-close.controller';
+export * from './finance-reports.controller';
 export * from './finance-statements.controller';
 export * from './finance-transfers.controller';
 export * from './finance.module';