@hed-hog/finance 0.0.235 → 0.0.237

package/src/finance.service.ts

@@ -9,8 +9,14 @@ import {
     NotFoundException
 } from '@nestjs/common';
 import { CreateBankAccountDto } from './dto/create-bank-account.dto';
+import { CreateCostCenterDto } from './dto/create-cost-center.dto';
+import { CreateFinanceCategoryDto } from './dto/create-finance-category.dto';
 import { CreateFinancialTitleDto } from './dto/create-financial-title.dto';
+import { CreatePeriodCloseDto } from './dto/create-period-close.dto';
+import { MoveFinanceCategoryDto } from './dto/move-finance-category.dto';
 import { UpdateBankAccountDto } from './dto/update-bank-account.dto';
+import { UpdateCostCenterDto } from './dto/update-cost-center.dto';
+import { UpdateFinanceCategoryDto } from './dto/update-finance-category.dto';
 
 type TitleType = 'payable' | 'receivable';
 
@@ -797,6 +803,221 @@ export class FinanceService {
     return bankAccounts.map((bankAccount) => this.mapBankAccountToFront(bankAccount));
   }
 
+  async listCostCenters() {
+    const costCenters = await this.prisma.cost_center.findMany({
+      orderBy: [{ code: 'asc' }, { name: 'asc' }],
+    });
+
+    return costCenters.map((costCenter) => this.mapCostCenterToFront(costCenter));
+  }
+
+  async listAuditLogs(
+    paginationParams,
+    filters?: {
+      search?: string;
+      action?: string;
+      entity_table?: string;
+      actor_user_id?: string;
+      from?: string;
+      to?: string;
+    },
+  ) {
+    const actorUserId = filters?.actor_user_id
+      ? Number.parseInt(filters.actor_user_id, 10)
+      : undefined;
+
+    const fromDate = filters?.from ? new Date(filters.from) : undefined;
+    const toDate = filters?.to ? new Date(filters.to) : undefined;
+
+    const where: any = {
+      ...(filters?.action ? { action: filters.action } : {}),
+      ...(filters?.entity_table ? { entity_table: filters.entity_table } : {}),
+      ...(Number.isNaN(actorUserId) || !actorUserId
+        ? {}
+        : { actor_user_id: actorUserId }),
+      ...((fromDate || toDate) &&
+      !(fromDate && Number.isNaN(fromDate.getTime())) &&
+      !(toDate && Number.isNaN(toDate.getTime()))
+        ? {
+            created_at: {
+              ...(fromDate ? { gte: fromDate } : {}),
+              ...(toDate ? { lte: toDate } : {}),
+            },
+          }
+        : {}),
+    };
+
+    const search = filters?.search?.trim();
+    if (search) {
+      where.OR = [
+        { action: { contains: search, mode: 'insensitive' } },
+        { entity_table: { contains: search, mode: 'insensitive' } },
+        { entity_id: { contains: search, mode: 'insensitive' } },
+        { summary: { contains: search, mode: 'insensitive' } },
+        { ip_address: { contains: search, mode: 'insensitive' } },
+      ];
+    }
+
+    const paginated = await this.paginationService.paginatePrismaModel(
+      this.prisma.audit_log,
+      {
+        page: paginationParams?.page,
+        pageSize: paginationParams?.pageSize,
+        sortField: paginationParams?.sortField || 'created_at',
+        sortOrder: paginationParams?.sortOrder || 'desc',
+        validSortFields: [
+          'id',
+          'created_at',
+          'action',
+          'entity_table',
+          'entity_id',
+        ],
+        where,
+        include: {
+          user: {
+            select: {
+              id: true,
+              name: true,
+            },
+          },
+        },
+      },
+    );
+
+    return {
+      ...paginated,
+      data: (paginated.data || []).map((log) => ({
+        id: String(log.id),
+        actorUserId: log.actor_user_id ? String(log.actor_user_id) : null,
+        actorName: log.user?.name || '-',
+        actorEmail: '',
+        action: log.action,
+        entityTable: log.entity_table,
+        entityId: log.entity_id,
+        summary: log.summary || '',
+        ipAddress: log.ip_address || '',
+        beforeData: log.before_data || '',
+        afterData: log.after_data || '',
+        createdAt: log.created_at?.toISOString?.() || null,
+      })),
+    };
+  }
+
+  async listFinanceCategories() {
+    const categories = await this.prisma.finance_category.findMany({
+      orderBy: [{ parent_id: 'asc' }, { updated_at: 'asc' }, { name: 'asc' }],
+    });
+
+    return categories.map((category) => this.mapFinanceCategoryToFront(category));
+  }
+
+  async listPeriodClose(
+    paginationParams: PaginationDTO,
+    filters?: {
+      search?: string;
+      status?: string;
+      user?: string;
+      from?: string;
+      to?: string;
+    },
+  ) {
+    const fromDate = filters?.from ? new Date(filters.from) : undefined;
+    const toDate = filters?.to ? new Date(filters.to) : undefined;
+    const userNumericId = filters?.user
+      ? Number.parseInt(filters.user, 10)
+      : undefined;
+
+    const andConditions: any[] = [];
+
+    if (filters?.status && filters.status !== 'all') {
+      andConditions.push({ status: filters.status });
+    }
+
+    if (
+      (fromDate && !Number.isNaN(fromDate.getTime())) ||
+      (toDate && !Number.isNaN(toDate.getTime()))
+    ) {
+      andConditions.push({
+        period_start: {
+          ...(fromDate && !Number.isNaN(fromDate.getTime())
+            ? { gte: fromDate }
+            : {}),
+        },
+      });
+
+      andConditions.push({
+        period_end: {
+          ...(toDate && !Number.isNaN(toDate.getTime()) ? { lte: toDate } : {}),
+        },
+      });
+    }
+
+    const search = filters?.search?.trim();
+    if (search) {
+      andConditions.push({
+        OR: [
+          { notes: { contains: search, mode: 'insensitive' } },
+          { user: { is: { name: { contains: search, mode: 'insensitive' } } } },
+          {
+            user: { is: { email: { contains: search, mode: 'insensitive' } } },
+          },
+        ],
+      });
+    }
+
+    if (filters?.user?.trim()) {
+      andConditions.push({
+        OR: [
+          ...(Number.isNaN(userNumericId) || !userNumericId
+            ? []
+            : [{ closed_by_user_id: userNumericId }]),
+          { user: { is: { name: { contains: filters.user, mode: 'insensitive' } } } },
+          {
+            user: {
+              is: { email: { contains: filters.user, mode: 'insensitive' } },
+            },
+          },
+        ],
+      });
+    }
+
+    const where = andConditions.length > 0 ? { AND: andConditions } : {};
+
+    const paginated = await this.paginationService.paginatePrismaModel(
+      this.prisma.period_close,
+      {
+        page: paginationParams?.page,
+        pageSize: paginationParams?.pageSize,
+        sortField: paginationParams?.sortField || 'period_start',
+        sortOrder: paginationParams?.sortOrder || 'desc',
+        validSortFields: [
+          'id',
+          'period_start',
+          'period_end',
+          'status',
+          'closed_at',
+          'created_at',
+        ],
+        where,
+        include: {
+          user: {
+            select: {
+              id: true,
+              name: true,
+            },
+          },
+        },
+      },
+    );
+
+    return {
+      ...paginated,
+      data: (paginated.data || []).map((period) =>
+        this.mapPeriodCloseToFront(period),
+      ),
+    };
+  }
+
   async listBankStatements(bankAccountId?: number) {
     const statements = await this.prisma.bank_statement_line.findMany({
       where: {
@@ -879,6 +1100,89 @@ export class FinanceService {
     return this.mapBankAccountToFront(account);
   }
 
+  async createCostCenter(data: CreateCostCenterDto) {
+    const code = await this.generateCostCenterCode(data.name);
+
+    const created = await this.prisma.cost_center.create({
+      data: {
+        code,
+        name: data.name.trim(),
+        status: 'active',
+      },
+    });
+
+    return this.mapCostCenterToFront(created);
+  }
+
+  async createFinanceCategory(data: CreateFinanceCategoryDto) {
+    if (data.parent_id) {
+      await this.ensureFinanceCategoryExists(data.parent_id);
+    }
+
+    const created = await this.prisma.finance_category.create({
+      data: {
+        code: await this.generateFinanceCategoryCode(),
+        name: data.name.trim(),
+        kind: this.mapCategoryKindFromPt(data.kind),
+        status: 'active',
+        parent_id: data.parent_id || null,
+      },
+    });
+
+    return this.mapFinanceCategoryToFront(created);
+  }
+
+  async createPeriodClose(data: CreatePeriodCloseDto, userId?: number) {
+    const periodStart = new Date(data.period_start);
+    const periodEnd = new Date(data.period_end);
+
+    if (
+      Number.isNaN(periodStart.getTime()) ||
+      Number.isNaN(periodEnd.getTime())
+    ) {
+      throw new BadRequestException('Invalid period dates');
+    }
+
+    if (periodStart > periodEnd) {
+      throw new BadRequestException('period_start must be before period_end');
+    }
+
+    const overlapped = await this.prisma.period_close.findFirst({
+      where: {
+        period_start: { lte: periodEnd },
+        period_end: { gte: periodStart },
+      },
+      select: { id: true },
+    });
+
+    if (overlapped) {
+      throw new BadRequestException('There is already a period in this range');
+    }
+
+    const status = data.status || 'closed';
+
+    const created = await this.prisma.period_close.create({
+      data: {
+        period_start: periodStart,
+        period_end: periodEnd,
+        status,
+        closed_at: status === 'closed' ? new Date() : null,
+        closed_by_user_id: status === 'closed' ? userId || null : null,
+        notes: data.notes?.trim() || null,
+      },
+      include: {
+        user: {
+          select: {
+            id: true,
+            name: true,
+          },
+        },
+      },
+    });
+
+    return this.mapPeriodCloseToFront(created);
+  }
+
   async updateBankAccount(id: number, data: UpdateBankAccountDto) {
     const current = await this.prisma.bank_account.findUnique({
       where: { id },
@@ -912,6 +1216,104 @@ export class FinanceService {
     return this.mapBankAccountToFront(updated);
   }
 
+  async updateCostCenter(id: number, data: UpdateCostCenterDto) {
+    const current = await this.prisma.cost_center.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!current) {
+      throw new NotFoundException('Cost center not found');
+    }
+
+    const updated = await this.prisma.cost_center.update({
+      where: { id },
+      data: {
+        name: data.name?.trim(),
+        status: data.status,
+      },
+    });
+
+    return this.mapCostCenterToFront(updated);
+  }
+
+  async updateFinanceCategory(id: number, data: UpdateFinanceCategoryDto) {
+    const current = await this.prisma.finance_category.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!current) {
+      throw new NotFoundException('Finance category not found');
+    }
+
+    if (data.parent_id) {
+      await this.ensureFinanceCategoryExists(data.parent_id);
+      await this.ensureNoFinanceCategoryCycle(id, data.parent_id);
+    }
+
+    const updated = await this.prisma.finance_category.update({
+      where: { id },
+      data: {
+        name: data.name?.trim(),
+        kind: data.kind ? this.mapCategoryKindFromPt(data.kind) : undefined,
+        parent_id: data.parent_id,
+        status: data.status,
+      },
+    });
+
+    return this.mapFinanceCategoryToFront(updated);
+  }
+
+  async moveFinanceCategory(id: number, data: MoveFinanceCategoryDto) {
+    const current = await this.prisma.finance_category.findUnique({
+      where: { id },
+      select: { id: true, parent_id: true },
+    });
+
+    if (!current) {
+      throw new NotFoundException('Finance category not found');
+    }
+
+    const targetParentId = data.parent_id || null;
+
+    if (targetParentId) {
+      await this.ensureFinanceCategoryExists(targetParentId);
+      await this.ensureNoFinanceCategoryCycle(id, targetParentId);
+    }
+
+    await this.prisma.finance_category.update({
+      where: { id },
+      data: { parent_id: targetParentId },
+    });
+
+    const siblings = await this.prisma.finance_category.findMany({
+      where: { parent_id: targetParentId },
+      select: { id: true },
+      orderBy: [{ updated_at: 'asc' }, { name: 'asc' }],
+    });
+
+    const siblingIds = siblings.map((item) => item.id).filter((item) => item !== id);
+    const targetPosition = Math.max(
+      0,
+      Math.min(data.position ?? siblingIds.length, siblingIds.length),
+    );
+    siblingIds.splice(targetPosition, 0, id);
+
+    await this.prisma.$transaction(
+      siblingIds.map((categoryId) =>
+        this.prisma.finance_category.update({
+          where: { id: categoryId },
+          data: {
+            parent_id: targetParentId,
+          },
+        }),
+      ),
+    );
+
+    return { success: true };
+  }
+
   async deleteBankAccount(id: number) {
     const current = await this.prisma.bank_account.findUnique({
       where: { id },
@@ -932,6 +1334,46 @@ export class FinanceService {
     return { success: true };
   }
 
+  async deleteCostCenter(id: number) {
+    const current = await this.prisma.cost_center.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!current) {
+      throw new NotFoundException('Cost center not found');
+    }
+
+    await this.prisma.cost_center.update({
+      where: { id },
+      data: {
+        status: 'inactive',
+      },
+    });
+
+    return { success: true };
+  }
+
+  async deleteFinanceCategory(id: number) {
+    const current = await this.prisma.finance_category.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!current) {
+      throw new NotFoundException('Finance category not found');
+    }
+
+    await this.prisma.finance_category.update({
+      where: { id },
+      data: {
+        status: 'inactive',
+      },
+    });
+
+    return { success: true };
+  }
+
   private async listTitles(
     titleType: TitleType,
     paginationParams: PaginationDTO,
@@ -1096,14 +1538,6 @@ export class FinanceService {
 
   private async loadPeople() {
     const people = await this.prisma.person.findMany({
-      include: {
-        document: {
-          select: {
-            value: true,
-          },
-          take: 1,
-        },
-      },
       orderBy: { name: 'asc' },
     });
 
@@ -1111,7 +1545,7 @@ export class FinanceService {
       id: String(person.id),
       nome: person.name,
       tipo: 'ambos',
-      documento: person.document[0]?.value || '',
+      documento: '',
     }));
   }
 
@@ -1394,6 +1828,76 @@ export class FinanceService {
     };
   }
 
+  private mapCostCenterToFront(costCenter: any) {
+    return {
+      id: String(costCenter.id),
+      codigo: costCenter.code,
+      nome: costCenter.name,
+      status: costCenter.status,
+      ativo: costCenter.status === 'active',
+    };
+  }
+
+  private mapCategoryKindToPt(kind?: string | null) {
+    const kindMap = {
+      revenue: 'receita',
+      expense: 'despesa',
+      transfer: 'transferencia',
+      adjustment: 'ajuste',
+      other: 'outro',
+    };
+
+    return kindMap[kind] || 'outro';
+  }
+
+  private mapCategoryKindFromPt(kind?: string | null) {
+    const normalized = (kind || '').toLowerCase();
+    const kindMap = {
+      receita: 'revenue',
+      revenue: 'revenue',
+      despesa: 'expense',
+      expense: 'expense',
+      transferencia: 'transfer',
+      transferência: 'transfer',
+      transfer: 'transfer',
+      ajuste: 'adjustment',
+      adjustment: 'adjustment',
+      outro: 'other',
+      other: 'other',
+    };
+
+    return kindMap[normalized] || 'other';
+  }
+
+  private mapFinanceCategoryToFront(category: any) {
+    return {
+      id: String(category.id),
+      codigo: category.code,
+      nome: category.name,
+      parentId: category.parent_id ? String(category.parent_id) : null,
+      natureza: this.mapCategoryKindToPt(category.kind),
+      status: category.status,
+      ativo: category.status === 'active',
+    };
+  }
+
+  private mapPeriodCloseToFront(period: any) {
+    return {
+      id: String(period.id),
+      periodStart: period.period_start?.toISOString?.() || null,
+      periodEnd: period.period_end?.toISOString?.() || null,
+      status: period.status,
+      closedAt: period.closed_at?.toISOString?.() || null,
+      closedByUserId: period.closed_by_user_id
+        ? String(period.closed_by_user_id)
+        : null,
+      closedByName: period.user?.name || '-',
+      closedByEmail: '',
+      notes: period.notes || '',
+      createdAt: period.created_at?.toISOString?.() || null,
+    };
+  }
+
   private mapStatementStatusToPt(status?: string | null) {
     const statusMap = {
       pending: 'pendente',
@@ -1419,6 +1923,71 @@ export class FinanceService {
     return `${bankPrefix || 'ACC'}-${accountSuffix}`;
   }
 
+  private async generateCostCenterCode(name?: string) {
+    const sanitizedName = (name || 'CENTRO')
+      .trim()
+      .replace(/\s+/g, '-')
+      .replace(/[^A-Za-z0-9-]/g, '')
+      .toUpperCase();
+
+    const basePrefix = sanitizedName.slice(0, 8) || 'CENTRO';
+
+    const lastCostCenter = await this.prisma.cost_center.findFirst({
+      orderBy: { id: 'desc' },
+      select: { id: true },
+    });
+
+    const suffix = String((lastCostCenter?.id || 0) + 1).padStart(4, '0');
+
+    return `${basePrefix}-${suffix}`;
+  }
+
+  private async generateFinanceCategoryCode() {
+    const lastCategory = await this.prisma.finance_category.findFirst({
+      orderBy: { id: 'desc' },
+      select: { id: true },
+    });
+
+    const suffix = String((lastCategory?.id || 0) + 1).padStart(4, '0');
+
+    return `CAT-${suffix}`;
+  }
+
+  private async ensureFinanceCategoryExists(id: number) {
+    const category = await this.prisma.finance_category.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!category) {
+      throw new NotFoundException('Finance category not found');
+    }
+  }
+
+  private async ensureNoFinanceCategoryCycle(
+    categoryId: number,
+    targetParentId: number,
+  ) {
+    if (categoryId === targetParentId) {
+      throw new BadRequestException('Category cannot be parent of itself');
+    }
+
+    let currentParentId: number | null = targetParentId;
+
+    while (currentParentId) {
+      if (currentParentId === categoryId) {
+        throw new BadRequestException('Invalid parent category hierarchy');
+      }
+
+      const parent = await this.prisma.finance_category.findUnique({
+        where: { id: currentParentId },
+        select: { parent_id: true },
+      });
+
+      currentParentId = parent?.parent_id || null;
+    }
+  }
+
   private toCents(value: number) {
     return Math.round(value * 100);
   }

package/src/index.ts

@@ -1,7 +1,11 @@
 export * from './dto/create-financial-title.dto';
+export * from './finance-audit-logs.controller';
 export * from './finance-bank-accounts.controller';
+export * from './finance-categories.controller';
+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-statements.controller';
 export * from './finance.module';
 export * from './finance.service';