@hed-hog/finance 0.0.225 → 0.0.227

package/src/dto/update-bank-account.dto.ts

@@ -0,0 +1,45 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsOptional, IsString } from 'class-validator';
+
+export class UpdateBankAccountDto {
+  @IsOptional()
+  @IsString({
+    message: (args) => getLocaleText('validation.bankMustBeString', args.value),
+  })
+  bank?: string;
+
+  @IsOptional()
+  @IsString({
+    message: (args) =>
+      getLocaleText('validation.branchMustBeString', args.value),
+  })
+  branch?: string;
+
+  @IsOptional()
+  @IsString({
+    message: (args) =>
+      getLocaleText('validation.accountMustBeString', args.value),
+  })
+  account?: string;
+
+  @IsOptional()
+  @IsString({
+    message: (args) =>
+      getLocaleText('validation.accountTypeMustBeString', args.value),
+  })
+  type?: string;
+
+  @IsOptional()
+  @IsString({
+    message: (args) =>
+      getLocaleText('validation.descriptionMustBeString', args.value),
+  })
+  description?: string;
+
+  @IsOptional()
+  @IsString({
+    message: (args) =>
+      getLocaleText('validation.statusMustBeString', args.value),
+  })
+  status?: 'active' | 'inactive';
+}

package/src/finance-bank-accounts.controller.ts

@@ -0,0 +1,43 @@
+import { Role, User } from '@hed-hog/api';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+} from '@nestjs/common';
+import { CreateBankAccountDto } from './dto/create-bank-account.dto';
+import { UpdateBankAccountDto } from './dto/update-bank-account.dto';
+import { FinanceService } from './finance.service';
+
+@Role()
+@Controller('finance')
+export class FinanceBankAccountsController {
+  constructor(private readonly financeService: FinanceService) {}
+
+  @Get('bank-accounts')
+  async listBankAccounts() {
+    return this.financeService.listBankAccounts();
+  }
+
+  @Post('bank-accounts')
+  async createBankAccount(@Body() data: CreateBankAccountDto, @User() user) {
+    return this.financeService.createBankAccount(data, user?.id);
+  }
+
+  @Patch('bank-accounts/:id')
+  async updateBankAccount(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() data: UpdateBankAccountDto,
+  ) {
+    return this.financeService.updateBankAccount(id, data);
+  }
+
+  @Delete('bank-accounts/:id')
+  async deleteBankAccount(@Param('id', ParseIntPipe) id: number) {
+    return this.financeService.deleteBankAccount(id);
+  }
+}

package/src/finance-data.controller.ts

@@ -0,0 +1,14 @@
+import { Role } from '@hed-hog/api';
+import { Controller, Get } from '@nestjs/common';
+import { FinanceService } from './finance.service';
+
+@Role()
+@Controller('finance')
+export class FinanceDataController {
+  constructor(private readonly financeService: FinanceService) {}
+
+  @Get('data')
+  async getData() {
+    return this.financeService.getData();
+  }
+}

package/src/{finance.controller.ts → finance-installments.controller.ts}

@@ -2,27 +2,22 @@ import { Role, User } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
-  Body,
-  Controller,
-  Get,
-  Param,
-  ParseIntPipe,
-  Post,
-  Query,
+    Body,
+    Controller,
+    Get,
+    Param,
+    ParseIntPipe,
+    Post,
+    Query,
 } from '@nestjs/common';
 import { CreateFinancialTitleDto } from './dto/create-financial-title.dto';
 import { FinanceService } from './finance.service';
 
 @Role()
 @Controller('finance')
-export class FinanceController {
+export class FinanceInstallmentsController {
   constructor(private readonly financeService: FinanceService) {}
 
-  @Get('data')
-  async getData() {
-    return this.financeService.getData();
-  }
-
   @Get('accounts-payable/installments')
   async listAccountsPayableInstallments(
     @Pagination() paginationParams,

package/src/finance.module.ts

@@ -3,7 +3,9 @@ import { PaginationModule } from '@hed-hog/api-pagination';
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
-import { FinanceController } from './finance.controller';
+import { FinanceBankAccountsController } from './finance-bank-accounts.controller';
+import { FinanceDataController } from './finance-data.controller';
+import { FinanceInstallmentsController } from './finance-installments.controller';
 import { FinanceService } from './finance.service';
 
 @Module({
@@ -13,7 +15,11 @@ import { FinanceService } from './finance.service';
     forwardRef(() => PrismaModule),
     forwardRef(() => LocaleModule)
   ],
-  controllers: [FinanceController],
+  controllers: [
+    FinanceDataController,
+    FinanceInstallmentsController,
+    FinanceBankAccountsController,
+  ],
   providers: [FinanceService],
   exports: [FinanceService],
 })

package/src/finance.service.ts

@@ -6,7 +6,9 @@ import {
     Injectable,
     NotFoundException,
 } from '@nestjs/common';
+import { CreateBankAccountDto } from './dto/create-bank-account.dto';
 import { CreateFinancialTitleDto } from './dto/create-financial-title.dto';
+import { UpdateBankAccountDto } from './dto/update-bank-account.dto';
 
 type TitleType = 'payable' | 'receivable';
 
@@ -109,6 +111,131 @@ export class FinanceService {
     return this.createTitle(data, 'receivable', locale, userId);
   }
 
+  async listBankAccounts() {
+    const bankAccounts = await this.prisma.bank_account.findMany({
+      include: {
+        bank_statement_line: {
+          select: {
+            amount_cents: true,
+            status: true,
+          },
+        },
+      },
+      orderBy: [{ code: 'asc' }, { name: 'asc' }],
+    });
+
+    return bankAccounts.map((bankAccount) => this.mapBankAccountToFront(bankAccount));
+  }
+
+  async createBankAccount(data: CreateBankAccountDto, userId?: number) {
+    const accountType = this.mapAccountTypeFromPt(data.type);
+
+    const code = this.generateBankAccountCode(data.bank, data.account);
+    const name = data.description?.trim() || data.bank;
+
+    const createdAccount = await this.prisma.bank_account.create({
+      data: {
+        code,
+        name,
+        bank_name: data.bank,
+        agency: data.branch || null,
+        account_number: data.account || null,
+        account_type: accountType,
+        status: 'active',
+      },
+    });
+
+    if (data.initial_balance && data.initial_balance > 0) {
+      const statement = await this.prisma.bank_statement.create({
+        data: {
+          bank_account_id: createdAccount.id,
+          source_type: 'csv',
+          imported_at: new Date(),
+          imported_by_user_id: userId,
+        },
+      });
+
+      await this.prisma.bank_statement_line.create({
+        data: {
+          bank_statement_id: statement.id,
+          bank_account_id: createdAccount.id,
+          posted_date: new Date(),
+          amount_cents: this.toCents(data.initial_balance),
+          description: 'Saldo inicial',
+          status: 'reconciled',
+          dedupe_key: `initial-balance-${createdAccount.id}-${Date.now()}`,
+        },
+      });
+    }
+
+    const account = await this.prisma.bank_account.findUnique({
+      where: { id: createdAccount.id },
+      include: {
+        bank_statement_line: {
+          select: {
+            amount_cents: true,
+            status: true,
+          },
+        },
+      },
+    });
+
+    return this.mapBankAccountToFront(account);
+  }
+
+  async updateBankAccount(id: number, data: UpdateBankAccountDto) {
+    const current = await this.prisma.bank_account.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!current) {
+      throw new NotFoundException('Bank account not found');
+    }
+
+    const updated = await this.prisma.bank_account.update({
+      where: { id },
+      data: {
+        bank_name: data.bank,
+        agency: data.branch,
+        account_number: data.account,
+        name: data.description,
+        account_type: data.type ? this.mapAccountTypeFromPt(data.type) : undefined,
+        status: data.status,
+      },
+      include: {
+        bank_statement_line: {
+          select: {
+            amount_cents: true,
+            status: true,
+          },
+        },
+      },
+    });
+
+    return this.mapBankAccountToFront(updated);
+  }
+
+  async deleteBankAccount(id: number) {
+    const current = await this.prisma.bank_account.findUnique({
+      where: { id },
+      select: { id: true },
+    });
+
+    if (!current) {
+      throw new NotFoundException('Bank account not found');
+    }
+
+    await this.prisma.bank_account.update({
+      where: { id },
+      data: {
+        status: 'inactive',
+      },
+    });
+
+    return { success: true };
+  }
+
   private async listTitles(
     titleType: TitleType,
     paginationParams: PaginationDTO,
@@ -326,18 +453,18 @@ export class FinanceService {
 
   private async loadBankAccounts() {
     const bankAccounts = await this.prisma.bank_account.findMany({
+      include: {
+        bank_statement_line: {
+          select: {
+            amount_cents: true,
+            status: true,
+          },
+        },
+      },
       orderBy: [{ code: 'asc' }, { name: 'asc' }],
     });
 
-    return bankAccounts.map((bankAccount) => ({
-      id: String(bankAccount.id),
-      codigo: bankAccount.code,
-      descricao: bankAccount.name,
-      banco: bankAccount.bank_name,
-      agencia: bankAccount.agency,
-      conta: bankAccount.account_number,
-      ativo: bankAccount.status === 'active',
-    }));
+    return bankAccounts.map((bankAccount) => this.mapBankAccountToFront(bankAccount));
   }
 
   private async loadTags() {
@@ -519,6 +646,72 @@ export class FinanceService {
     return paymentMethodMap[paymentMethodType] || undefined;
   }
 
+  private mapAccountTypeToPt(accountType?: string | null) {
+    const accountTypeMap = {
+      checking: 'corrente',
+      savings: 'poupanca',
+      investment: 'investimento',
+      cash: 'caixa',
+      other: 'corrente',
+    };
+
+    return accountTypeMap[accountType] || 'corrente';
+  }
+
+  private mapAccountTypeFromPt(accountType?: string | null) {
+    const accountTypeMap = {
+      corrente: 'checking',
+      poupanca: 'savings',
+      investimento: 'investment',
+      caixa: 'cash',
+      other: 'other',
+    };
+
+    return accountTypeMap[accountType] || 'checking';
+  }
+
+  private mapBankAccountToFront(bankAccount: any) {
+    const currentCents = (bankAccount.bank_statement_line || []).reduce(
+      (acc, line) => acc + line.amount_cents,
+      0,
+    );
+
+    const reconciledCents = (bankAccount.bank_statement_line || []).reduce(
+      (acc, line) =>
+        line.status === 'reconciled' || line.status === 'adjusted'
+          ? acc + line.amount_cents
+          : acc,
+      0,
+    );
+
+    return {
+      id: String(bankAccount.id),
+      codigo: bankAccount.code,
+      descricao: bankAccount.name,
+      banco: bankAccount.bank_name || bankAccount.name,
+      agencia: bankAccount.agency || '-',
+      conta: bankAccount.account_number || '-',
+      tipo: this.mapAccountTypeToPt(bankAccount.account_type),
+      saldoAtual: this.fromCents(currentCents),
+      saldoConciliado: this.fromCents(reconciledCents),
+      ativo: bankAccount.status === 'active',
+    };
+  }
+
+  private generateBankAccountCode(bankName?: string, accountNumber?: string) {
+    const bankPrefix = (bankName || 'ACC')
+      .replace(/[^A-Za-z0-9]/g, '')
+      .slice(0, 4)
+      .toUpperCase();
+
+    const accountSuffix = (accountNumber || '')
+      .replace(/\D/g, '')
+      .slice(-4)
+      .padStart(4, '0');
+
+    return `${bankPrefix || 'ACC'}-${accountSuffix}`;
+  }
+
   private toCents(value: number) {
     return Math.round(value * 100);
   }

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from './dto/create-financial-title.dto';
-export * from './finance.controller';
+export * from './finance-bank-accounts.controller';
+export * from './finance-data.controller';
+export * from './finance-installments.controller';
 export * from './finance.module';
 export * from './finance.service';