first commit

src/repositories/CustaProcessualRepository.ts

@@ -0,0 +1,138 @@
+import { prisma } from "../config/database";
+import {
+  CustaProcessual,
+  TipoCustaProcessual,
+  StatusPagamento,
+  Prisma,
+} from "@prisma/client";
+
+/**
+ * Repositório para gerenciar custas processuais
+ */
+export class CustaProcessualRepository {
+  /**
+   * Cria uma nova custa processual
+   */
+  async create(data: any): Promise<CustaProcessual> {
+    try {
+      // Validar dados obrigatórios
+      if (!data.processoId) throw new Error("ID do processo é obrigatório");
+      if (!data.tipo) throw new Error("Tipo da custa é obrigatório");
+      if (!data.descricao) throw new Error("Descrição da custa é obrigatória");
+      if (data.valor === undefined || data.valor === null)
+        throw new Error("Valor da custa é obrigatório");
+
+      // Criar custa
+      const novaCusta = await prisma.custaProcessual.create({
+        data: {
+          processoId: data.processoId,
+          tipo: data.tipo as TipoCustaProcessual,
+          descricao: data.descricao,
+          valor: Number(data.valor),
+          percentual: data.percentual ? Number(data.percentual) : null,
+          status: (data.status || "PENDENTE") as StatusPagamento,
+          vencimento: data.vencimento ? new Date(data.vencimento) : null,
+          dataPagamento: data.dataPagamento
+            ? new Date(data.dataPagamento)
+            : null,
+          observacoes: data.observacoes || null,
+          numeroParcelas: Number(data.numeroParcelas || 1),
+          parcelaAtual: Number(data.parcelaAtual || 1),
+          comprovante: data.comprovante || null,
+        },
+      });
+
+      return novaCusta;
+    } catch (error) {
+      console.error("Erro ao criar custa processual:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Atualiza uma custa processual existente
+   */
+  async update(id: string, data: any): Promise<CustaProcessual> {
+    try {
+      // Preparar dados para atualização
+      const updateData: Prisma.CustaProcessualUpdateInput = {
+        tipo: data.tipo,
+        descricao: data.descricao,
+        valor: data.valor !== undefined ? Number(data.valor) : undefined,
+        percentual:
+          data.percentual !== undefined ? Number(data.percentual) : undefined,
+        status: data.status,
+        observacoes: data.observacoes,
+        numeroParcelas:
+          data.numeroParcelas !== undefined
+            ? Number(data.numeroParcelas)
+            : undefined,
+        parcelaAtual:
+          data.parcelaAtual !== undefined
+            ? Number(data.parcelaAtual)
+            : undefined,
+        comprovante: data.comprovante,
+      };
+
+      if (data.vencimento) {
+        updateData.vencimento = new Date(data.vencimento);
+      }
+
+      if (data.dataPagamento) {
+        updateData.dataPagamento = new Date(data.dataPagamento);
+      }
+
+      // Atualizar a custa
+      return await prisma.custaProcessual.update({
+        where: { id },
+        data: updateData,
+      });
+    } catch (error) {
+      console.error("Erro ao atualizar custa processual:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Remove uma custa processual
+   */
+  async delete(id: string): Promise<void> {
+    try {
+      await prisma.custaProcessual.delete({
+        where: { id },
+      });
+    } catch (error) {
+      console.error("Erro ao excluir custa processual:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Busca todas as custas de um processo
+   */
+  async findByProcesso(processoId: string): Promise<CustaProcessual[]> {
+    try {
+      return await prisma.custaProcessual.findMany({
+        where: { processoId },
+        orderBy: { dataCriacao: "desc" },
+      });
+    } catch (error) {
+      console.error("Erro ao buscar custas do processo:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Busca uma custa pelo ID
+   */
+  async findById(id: string): Promise<CustaProcessual | null> {
+    try {
+      return await prisma.custaProcessual.findUnique({
+        where: { id },
+      });
+    } catch (error) {
+      console.error("Erro ao buscar custa processual:", error);
+      throw error;
+    }
+  }
+}