first commit

src/repositories/BaseRepository.ts

@@ -0,0 +1,9 @@
+export abstract class BaseRepository<T> {
+  constructor(protected collection: string) {}
+
+  abstract create(item: T): Promise<T>;
+  abstract update(id: string, item: Partial<T>): Promise<T>;
+  abstract delete(id: string): Promise<boolean>;
+  abstract findById(id: string): Promise<T | null>;
+  abstract findAll(): Promise<T[]>;
+}

src/repositories/ClienteRepository.ts

@@ -0,0 +1,169 @@
+import { prisma } from "../config/database";
+import { Cliente, Prisma } from "@prisma/client";
+
+export class ClienteRepository {
+  async findAll(): Promise<Cliente[]> {
+    try {
+      const clientes = await prisma.cliente.findMany({
+        include: {
+          filhos: true,
+          processos: {
+            select: {
+              id: true,
+              numero: true,
+              natureza: true,
+              status: true,
+              dataCriacao: true,
+            },
+          },
+        },
+        orderBy: {
+          nome: "asc",
+        },
+      });
+
+      return clientes;
+    } catch (error) {
+      console.error("Erro ao buscar todos os clientes:", error);
+      throw error;
+    }
+  }
+
+  async findById(id: string): Promise<Cliente | null> {
+    try {
+      const cliente = await prisma.cliente.findUnique({
+        where: { id },
+        include: {
+          filhos: true,
+          processos: true,
+        },
+      });
+
+      return cliente;
+    } catch (error) {
+      console.error("Erro ao buscar cliente por ID:", error);
+      throw error;
+    }
+  }
+
+  async findByCpfCnpj(cpfCnpj: string): Promise<Cliente | null> {
+    try {
+      const cliente = await prisma.cliente.findUnique({
+        where: { cpfCnpj },
+      });
+
+      return cliente;
+    } catch (error) {
+      console.error("Erro ao buscar cliente por CPF/CNPJ:", error);
+      throw error;
+    }
+  }
+
+  async create(data: Prisma.ClienteCreateInput): Promise<Cliente> {
+    try {
+      // Verificar se já existe cliente com esse CPF/CNPJ
+      const existingCliente = await this.findByCpfCnpj(data.cpfCnpj);
+      if (existingCliente) {
+        throw new Error(`Cliente com CPF/CNPJ '${data.cpfCnpj}' já existe`);
+      }
+
+      // Criar o cliente
+      const cliente = await prisma.cliente.create({
+        data,
+        include: {
+          filhos: true,
+        },
+      });
+
+      return cliente;
+    } catch (error) {
+      console.error("Erro ao criar cliente:", error);
+      throw error;
+    }
+  }
+
+  async update(id: string, data: Prisma.ClienteUpdateInput): Promise<Cliente> {
+    try {
+      // Verificar CPF/CNPJ duplicado
+      if (typeof data.cpfCnpj === "string") {
+        const existingCliente = await prisma.cliente.findFirst({
+          where: {
+            cpfCnpj: data.cpfCnpj as string,
+            NOT: { id },
+          },
+        });
+
+        if (existingCliente) {
+          throw new Error(`Cliente com CPF/CNPJ '${data.cpfCnpj}' já existe`);
+        }
+      }
+
+      // Formatar dados
+      const formattedData = {
+        ...data,
+        // Garantir que a data de nascimento seja um Date válido
+        dataNascimento: data.dataNascimento
+          ? new Date(data.dataNascimento as string)
+          : undefined,
+        // Campos opcionais como undefined em vez de null/empty
+        orgaoEmissor: data.orgaoEmissor || undefined,
+        estadoRg: data.estadoRg || undefined,
+        rg: data.rg || undefined,
+        renda: data.renda ? Number(data.renda) : undefined,
+        // Garantir que booleanos sejam boolean
+        usaDNI: typeof data.usaDNI === "boolean" ? data.usaDNI : undefined,
+        possuiFilhos:
+          typeof data.possuiFilhos === "boolean"
+            ? data.possuiFilhos
+            : undefined,
+        declaraIR:
+          typeof data.declaraIR === "boolean" ? data.declaraIR : undefined,
+        contribuiPrevidencia:
+          typeof data.contribuiPrevidencia === "boolean"
+            ? data.contribuiPrevidencia
+            : undefined,
+      };
+
+      // Atualizar cliente
+      return await prisma.cliente.update({
+        where: { id },
+        data: formattedData,
+        include: {
+          filhos: true,
+        },
+      });
+    } catch (error) {
+      console.error("Erro ao atualizar cliente:", error);
+      throw error;
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    try {
+      await prisma.cliente.delete({
+        where: { id },
+      });
+    } catch (error) {
+      console.error("Erro ao excluir cliente:", error);
+      throw error;
+    }
+  }
+
+  async search(term: string): Promise<Cliente[]> {
+    try {
+      const clientes = await prisma.cliente.findMany({
+        where: {
+          OR: [
+            { nome: { contains: term, mode: "insensitive" } },
+            { cpfCnpj: { contains: term } },
+          ],
+        },
+      });
+
+      return clientes;
+    } catch (error) {
+      console.error("Erro ao pesquisar clientes:", error);
+      throw error;
+    }
+  }
+}

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;
+    }
+  }
+}

src/repositories/DialogParcela.tsx

@@ -0,0 +1,153 @@
+import { Fragment } from "react";
+import { Dialog, Transition } from "@headlessui/react";
+import { XMarkIcon } from "@heroicons/react/24/outline";
+import { DatePicker } from "@mui/x-date-pickers";
+import { AdapterDateFns } from "@mui/x-date-pickers/AdapterDateFns";
+import { LocalizationProvider } from "@mui/x-date-pickers/LocalizationProvider";
+import ptBR from "date-fns/locale/pt-BR";
+
+interface DialogParcelaProps {
+  isOpen: boolean;
+  onClose: () => void;
+  onSave: (data: any) => Promise<void>;
+  parcela?: any;
+  tipo: "honorario" | "custa";
+}
+
+export function DialogParcela({
+  isOpen,
+  onClose,
+  onSave,
+  parcela,
+  tipo,
+}: DialogParcelaProps) {
+  const [formData, setFormData] = useState({
+    status: parcela?.status || "PENDENTE",
+    dataPagamento: parcela?.dataPagamento
+      ? new Date(parcela?.dataPagamento)
+      : null,
+    comprovante: parcela?.comprovante || "",
+    observacoes: parcela?.observacoes || "",
+  });
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    await onSave(formData);
+    onClose();
+  };
+
+  return (
+    <Transition appear show={isOpen} as={Fragment}>
+      <Dialog as="div" className="relative z-50" onClose={onClose}>
+        <div className="fixed inset-0 bg-black/30 backdrop-blur-sm" />
+
+        <div className="fixed inset-0 overflow-y-auto">
+          <div className="flex min-h-full items-center justify-center p-4">
+            <Dialog.Panel className="w-full max-w-md transform overflow-hidden rounded-2xl bg-white p-6 text-left align-middle shadow-xl transition-all">
+              <Dialog.Title
+                as="div"
+                className="flex items-center justify-between mb-4"
+              >
+                <h3 className="text-lg font-medium leading-6 text-gray-900">
+                  Atualizar Parcela {parcela?.numeroParcela}
+                </h3>
+                <button
+                  type="button"
+                  className="text-gray-400 hover:text-gray-500"
+                  onClick={onClose}
+                >
+                  <XMarkIcon className="h-6 w-6" />
+                </button>
+              </Dialog.Title>
+
+              <form onSubmit={handleSubmit} className="space-y-4">
+                <div>
+                  <label className="block text-sm font-medium text-gray-700">
+                    Status
+                  </label>
+                  <select
+                    value={formData.status}
+                    onChange={(e) =>
+                      setFormData({ ...formData, status: e.target.value })
+                    }
+                    className="mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500"
+                  >
+                    {Object.values(StatusPagamento).map((status) => (
+                      <option key={status} value={status}>
+                        {status.replace(/_/g, " ")}
+                      </option>
+                    ))}
+                  </select>
+                </div>
+
+                {formData.status === "PAGO" && (
+                  <div>
+                    <label className="block text-sm font-medium text-gray-700">
+                      Data do Pagamento
+                    </label>
+                    <LocalizationProvider
+                      dateAdapter={AdapterDateFns}
+                      adapterLocale={ptBR}
+                    >
+                      <DatePicker
+                        value={formData.dataPagamento}
+                        onChange={(date) =>
+                          setFormData({ ...formData, dataPagamento: date })
+                        }
+                        className="mt-1 block w-full"
+                      />
+                    </LocalizationProvider>
+                  </div>
+                )}
+
+                <div>
+                  <label className="block text-sm font-medium text-gray-700">
+                    Comprovante (URL)
+                  </label>
+                  <input
+                    type="text"
+                    value={formData.comprovante}
+                    onChange={(e) =>
+                      setFormData({ ...formData, comprovante: e.target.value })
+                    }
+                    className="mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500"
+                  />
+                </div>
+
+                <div>
+                  <label className="block text-sm font-medium text-gray-700">
+                    Observações
+                  </label>
+                  <textarea
+                    value={formData.observacoes}
+                    onChange={(e) =>
+                      setFormData({ ...formData, observacoes: e.target.value })
+                    }
+                    rows={3}
+                    className="mt-1 block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500"
+                  />
+                </div>
+
+                <div className="mt-6 flex justify-end space-x-3">
+                  <button
+                    type="button"
+                    onClick={onClose}
+                    className="px-4 py-2 text-sm font-medium text-gray-700 hover:bg-gray-50 focus:outline-none focus:ring-2 focus:ring-gray-500 focus:ring-offset-2"
+                  >
+                    Cancelar
+                  </button>
+                  <button
+                    type="submit"
+                    className="inline-flex justify-center rounded-md border border-transparent bg-blue-600 px-4 py-2 text-sm font-medium text-white hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2"
+                  >
+                    Salvar
+                  </button>
+                </div>
+              </form>
+            </Dialog.Panel>
+          </div>
+        </div>
+      </Dialog>
+    </Transition>
+  );
+}

src/repositories/HonorarioRepository.ts

@@ -0,0 +1,131 @@
+import { prisma } from "../config/database";
+import { Honorario, FormaPagamento, StatusPagamento } from "@prisma/client";
+
+export class HonorarioRepository {
+  async create(dados: any): Promise<Honorario> {
+    try {
+      // Criar honorário
+      const honorario = await prisma.honorario.create({
+        data: {
+          processoId: dados.processoId,
+          formaPagamento: dados.formaPagamento,
+          status: dados.status || "PENDENTE",
+          dataVencimento: new Date(dados.dataVencimento || new Date()),
+          dataContrato: new Date(),
+          observacoes: dados.observacoes || null,
+          valorFixo: dados.valorFixo ? Number(dados.valorFixo) : null,
+          percentualCausa: dados.percentualCausa
+            ? Number(dados.percentualCausa)
+            : null,
+          percentualExito: dados.percentualExito
+            ? Number(dados.percentualExito)
+            : null,
+          valorEntrada: dados.valorEntrada ? Number(dados.valorEntrada) : null,
+          numeroParcelas: Number(dados.numeroParcelas || 1),
+          valorParcela: dados.valorParcela ? Number(dados.valorParcela) : null,
+          diaVencimento: Number(dados.diaVencimento || 10),
+        },
+      });
+
+      // Se for parcelado, criar parcelas
+      if (
+        honorario &&
+        (honorario.formaPagamento === "PARCELADO" ||
+          honorario.formaPagamento === "ENTRADA_MAIS_PARCELAS")
+      ) {
+        const parcelas = [];
+        const numParcelas = honorario.numeroParcelas;
+        const valorParcela = honorario.valorParcela || 0;
+
+        for (let i = 1; i <= numParcelas; i++) {
+          const dataVencimento = new Date(honorario.dataVencimento);
+          dataVencimento.setMonth(dataVencimento.getMonth() + (i - 1));
+
+          parcelas.push({
+            honorarioId: honorario.id,
+            numeroParcela: i,
+            valor: valorParcela,
+            vencimento: dataVencimento,
+            status: "PENDENTE" as StatusPagamento,
+          });
+        }
+
+        if (parcelas.length > 0) {
+          await prisma.parcelaHonorario.createMany({
+            data: parcelas,
+          });
+        }
+      }
+
+      // Retornar honorário com parcelas
+      return (await prisma.honorario.findUnique({
+        where: { id: honorario.id },
+        include: { parcelas: true },
+      })) as Honorario;
+    } catch (error) {
+      console.error("Erro ao criar honorário:", error);
+      throw error;
+    }
+  }
+
+  async update(id: string, data: any): Promise<Honorario> {
+    return await prisma.honorario.update({
+      where: { id },
+      data,
+      include: { parcelas: true },
+    });
+  }
+
+  async updateParcela(id: string, data: any): Promise<void> {
+    try {
+      console.log("Dados recebidos para atualização:", { id, data });
+
+      await prisma.parcelaHonorario.update({
+        where: { id },
+        data: {
+          status: data.status,
+          valorPago: data.valorPago ? Number(data.valorPago) : null,
+          dataPagamento: data.dataPagamento
+            ? new Date(data.dataPagamento)
+            : null,
+          comprovante: data.comprovante,
+          observacoes: data.observacoes,
+        },
+      });
+    } catch (error) {
+      console.error("Erro ao atualizar parcela:", error);
+      throw error;
+    }
+  }
+
+  async updateParcela(id: string, data: any) {
+    try {
+      return await prisma.parcelaHonorario.update({
+        where: { id },
+        data: {
+          status: data.status,
+          valorPago: data.valorPago ? Number(data.valorPago) : null,
+          dataPagamento: data.dataPagamento
+            ? new Date(data.dataPagamento)
+            : null,
+          comprovante: data.comprovante,
+          observacoes: data.observacoes,
+        },
+      });
+    } catch (error) {
+      console.error("Erro ao atualizar parcela:", error);
+      throw error;
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    await prisma.honorario.delete({ where: { id } });
+  }
+
+  async findByProcesso(processoId: string): Promise<Honorario[]> {
+    return await prisma.honorario.findMany({
+      where: { processoId },
+      include: { parcelas: true },
+    });
+  }
+}

src/repositories/OrgaoJulgadorRepository.ts

@@ -0,0 +1,43 @@
+import { BaseRepository } from "./BaseRepository";
+import prisma from "../config/database";
+
+export class OrgaoJulgadorRepository extends BaseRepository<any> {
+  constructor() {
+    super("orgaosJulgadores");
+  }
+
+  async findAll() {
+    return await prisma.orgaoJulgador.findMany({
+      orderBy: {
+        nome: "asc",
+      },
+    });
+  }
+
+  async create(data: { nome: string }) {
+    return await prisma.orgaoJulgador.create({
+      data: {
+        nome: data.nome,
+      },
+    });
+  }
+
+  async findByNome(nome: string) {
+    return await prisma.orgaoJulgador.findUnique({
+      where: { nome },
+    });
+  }
+
+  async findById(id: string) {
+    return await prisma.orgaoJulgador.findUnique({
+      where: { id },
+    });
+  }
+
+  async delete(id: string) {
+    await prisma.orgaoJulgador.delete({
+      where: { id },
+    });
+    return true;
+  }
+}

src/repositories/ProcessoAdministrativoRepository.ts

@@ -0,0 +1,236 @@
+import { prisma } from "../config/database";
+import { ProcessoAdministrativo, MovimentacaoAdministrativa, CustaAdministrativa, Prisma } from "@prisma/client";
+
+export class ProcessoAdministrativoRepository {
+  async findAll(): Promise<ProcessoAdministrativo[]> {
+    try {
+      return await prisma.processoAdministrativo.findMany({
+        include: {
+          cliente: true,
+          movimentacoes: {
+            orderBy: {
+              data: 'desc'
+            }
+          }
+        }
+      });
+    } catch (error) {
+      console.error("Erro ao buscar processos administrativos:", error);
+      throw error;
+    }
+  }
+
+  async findById(id: string): Promise<ProcessoAdministrativo | null> {
+    try {
+      return await prisma.processoAdministrativo.findUnique({
+        where: { id },
+        include: {
+          cliente: true,
+          movimentacoes: {
+            orderBy: {
+              data: 'desc'
+            }
+          }
+        }
+      });
+    } catch (error) {
+      console.error("Erro ao buscar processo administrativo:", error);
+      throw error;
+    }
+  }
+
+  async create(data: Partial<ProcessoAdministrativo>): Promise<ProcessoAdministrativo> {
+    try {
+      // Validar campos obrigatórios
+      if (!data.numero) throw new Error("Número é obrigatório");
+      if (!data.descricao) throw new Error("Descrição é obrigatória");
+      if (!data.orgao) throw new Error("Órgão é obrigatório");
+      if (!data.clienteId) throw new Error("Cliente é obrigatório");
+      if (!data.tipoParteCliente) throw new Error("Tipo de parte é obrigatório");
+
+      return await prisma.processoAdministrativo.create({
+        data: {
+          ...data,
+          valorPretensao: data.valorPretensao ? Number(data.valorPretensao) : null,
+        },
+        include: {
+          cliente: true,
+          movimentacoes: true
+        }
+      });
+    } catch (error) {
+      console.error("Erro ao criar processo administrativo:", error);
+      throw error;
+    }
+  }
+
+  async addMovimentacao(
+    processoId: string, 
+    data: Partial<MovimentacaoAdministrativa>
+  ): Promise<MovimentacaoAdministrativa> {
+    try {
+      // Validar campos obrigatórios
+      if (!data.descricao) throw new Error("Descrição é obrigatória");
+      if (!data.tipoMovimentacao) throw new Error("Tipo de movimentação é obrigatório");
+      if (!data.data) throw new Error("Data é obrigatória");
+
+      return await prisma.movimentacaoAdministrativa.create({
+        data: {
+          ...data,
+          processoId,
+        }
+      });
+    } catch (error) {
+      console.error("Erro ao adicionar movimentação:", error);
+      throw error;
+    }
+  }
+
+  async updateMovimentacao(
+    id: string,
+    data: Partial<MovimentacaoAdministrativa>
+  ): Promise<MovimentacaoAdministrativa> {
+    try {
+      // Validar campos obrigatórios
+      if (!data.descricao) throw new Error("Descrição é obrigatória");
+      if (!data.tipoMovimentacao) throw new Error("Tipo de movimentação é obrigatório");
+      if (!data.data) throw new Error("Data é obrigatória");
+
+      const { processoId, dataCriacao, ...updateData } = data;
+
+      return await prisma.movimentacaoAdministrativa.update({
+        where: { id },
+        data: {
+          ...updateData,
+          data: new Date(updateData.data),
+        }
+      });
+    } catch (error) {
+      console.error("Erro ao atualizar movimentação:", error);
+      throw error;
+    }
+  }
+
+  async deleteMovimentacao(id: string): Promise<void> {
+    try {
+      await prisma.movimentacaoAdministrativa.delete({
+        where: { id }
+      });
+    } catch (error) {
+      console.error("Erro ao excluir movimentação:", error);
+      throw error;
+    }
+  }
+
+  async update(id: string, data: Partial<ProcessoAdministrativo>): Promise<ProcessoAdministrativo> {
+    try {
+      // Extrair campos de relacionamento
+      const { clienteId, movimentacoes, ...updateData } = data;
+
+      // Remover campos que não devem ser atualizados diretamente
+      const { id: _id, dataCriacao: _dc, dataAtualizacao: _da, ...cleanData } = updateData;
+
+      return await prisma.processoAdministrativo.update({
+        where: { id },
+        data: {
+          ...cleanData,
+          valorPretensao: cleanData.valorPretensao ? Number(cleanData.valorPretensao) : null,
+          // Atualizar relação com cliente se houver clienteId
+          ...(clienteId && {
+            cliente: {
+              connect: { id: clienteId }
+            }
+          }),
+          // Remover atualização de movimentações - elas devem ser gerenciadas separadamente
+          movimentacoes: undefined
+        },
+        include: {
+          cliente: true,
+          movimentacoes: {
+            orderBy: {
+              data: 'desc'
+            }
+          }
+        }
+      });
+    } catch (error) {
+      console.error("Erro ao atualizar processo administrativo:", error);
+      throw error;
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    try {
+      await prisma.processoAdministrativo.delete({
+        where: { id }
+      });
+    } catch (error) {
+      console.error("Erro ao excluir processo administrativo:", error);
+      throw error;
+    }
+  }
+
+  async findCustasByProcesso(processoId: string) {
+    try {
+      return await prisma.custaAdministrativa.findMany({
+        where: { processoId },
+        orderBy: [
+          { dataCriacao: 'desc' }
+        ]
+      });
+    } catch (error) {
+      console.error("Erro ao buscar custas do processo:", error);
+      throw error;
+    }
+  }
+
+  async addCusta(processoId: string, data: Partial<CustaAdministrativa>) {
+    try {
+      // Validar campos obrigatórios
+      if (!data.tipo) throw new Error("Tipo é obrigatório");
+      if (!data.descricao) throw new Error("Descrição é obrigatória");
+      if (!data.valor) throw new Error("Valor é obrigatório");
+
+      return await prisma.custaAdministrativa.create({
+        data: {
+          ...data,
+          processoId,
+          valor: new Prisma.Decimal(data.valor.toString()),
+          vencimento: data.vencimento ? new Date(data.vencimento) : null,
+          dataPagamento: data.dataPagamento ? new Date(data.dataPagamento) : null
+        }
+      });
+    } catch (error) {
+      console.error("Erro ao adicionar custa:", error);
+      throw error;
+    }
+  }
+
+  async updateCusta(id: string, data: Partial<CustaAdministrativa>) {
+    try {
+      return await prisma.custaAdministrativa.update({
+        where: { id },
+        data: {
+          ...data,
+          valor: data.valor ? new Prisma.Decimal(data.valor.toString()) : undefined,
+          vencimento: data.vencimento ? new Date(data.vencimento) : null,
+          dataPagamento: data.dataPagamento ? new Date(data.dataPagamento) : null
+        }
+      });
+    } catch (error) {
+      console.error("Erro ao atualizar custa:", error);
+      throw error;
+    }
+  }
+
+  async deleteCusta(id: string) {
+    try {
+      await prisma.custaAdministrativa.delete({
+        where: { id }
+      });
+    } catch (error) {
+      console.error("Erro ao excluir custa:", error);
+      throw error;
+    }
+  }
+}

src/repositories/ProcessoRepository.ts

@@ -0,0 +1,248 @@
+import { prisma } from "../config/database";
+import { Processo, Prisma } from "@prisma/client";
+
+export class ProcessoRepository {
+  async create(data: any): Promise<Processo> {
+    try {
+      // Validar campos obrigatórios
+      if (!data.tribunalUF) throw new Error("UF do Tribunal é obrigatória");
+      if (!data.tribunal) throw new Error("Tribunal é obrigatório");
+
+      // Verificar se processo com este número já existe
+      const existingProcesso = await prisma.processo.findUnique({
+        where: { numero: data.numero },
+      });
+
+      if (existingProcesso) {
+        throw new Error("Já existe um processo com este número");
+      }
+
+      const dadosDatajud = data.dadosDatajud;
+
+      const dadosProcesso = {
+        ...data,
+        dataAjuizamento: dadosDatajud?.dataAjuizamento
+          ? new Date(dadosDatajud.dataAjuizamento)
+          : undefined,
+        classeProcessual: dadosDatajud?.classe?.nome,
+        assuntos: dadosDatajud?.assuntos?.map((a) => a.nome) || [],
+        nivelSigilo: dadosDatajud?.nivelSigilo,
+        dadosDatajud: dadosDatajud || undefined,
+      };
+
+      // Criar processo
+      const processo = await prisma.processo.create({
+        data: dadosProcesso,
+        include: {
+          cliente: true,
+          partes: true,
+        },
+      });
+
+      return processo;
+    } catch (error) {
+      console.error("Erro ao criar processo:", error);
+      throw error;
+    }
+  }
+
+  async update(id: string, data: any): Promise<Processo> {
+    try {
+      // Extrair campos relacionados que não devem ser atualizados diretamente
+      const {
+        partes,
+        diligencias,
+        audiencias,
+        documentos,
+        movimentacoes,
+        honorarios,
+        custas,
+        ...processData
+      } = data;
+
+      const dadosDatajud = processData.dadosDatajud;
+
+      const dadosProcesso = {
+        ...processData,
+        dataAjuizamento: dadosDatajud?.dataAjuizamento
+          ? new Date(dadosDatajud.dataAjuizamento)
+          : undefined,
+        classeProcessual: dadosDatajud?.classe?.nome,
+        assuntos: dadosDatajud?.assuntos?.map((a) => a.nome) || undefined,
+        nivelSigilo: dadosDatajud?.nivelSigilo,
+        dadosDatajud: dadosDatajud || undefined,
+      };
+
+      // Atualizar processo sem as relações
+      const processo = await prisma.processo.update({
+        where: { id },
+        data: dadosProcesso,
+        include: {
+          cliente: true,
+          partes: {
+            include: {
+              cliente: true,
+            },
+          },
+        },
+      });
+
+      // Se existirem partes para atualizar
+      if (partes && Array.isArray(partes)) {
+        // Primeiro deletar partes existentes
+        await prisma.parteProcesso.deleteMany({
+          where: { processoId: id },
+        });
+
+        // Depois criar as novas partes
+        if (partes.length > 0) {
+          await prisma.parteProcesso.createMany({
+            data: partes.map((parte) => ({
+              processoId: id,
+              clienteId: parte.clienteId,
+              tipo: parte.tipo,
+              nome: parte.nome,
+              cpfCnpj: parte.cpfCnpj || "",
+              principal: parte.principal || false,
+              observacoes: parte.observacoes || "",
+            })),
+          });
+        }
+      }
+
+      // Buscar processo atualizado com todas as relações
+      return await prisma.processo.findUniqueOrThrow({
+        where: { id },
+        include: {
+          cliente: true,
+          partes: {
+            include: {
+              cliente: true,
+            },
+          },
+        },
+      });
+    } catch (error) {
+      console.error("Erro ao atualizar processo:", error);
+      throw error;
+    }
+  }
+
+  async findAll(): Promise<Processo[]> {
+    try {
+      const processos = await prisma.processo.findMany({
+        include: {
+          cliente: true,
+          partes: {
+            include: {
+              cliente: true,
+            },
+          },
+        },
+        orderBy: {
+          dataCriacao: "desc",
+        },
+      });
+
+      return processos;
+    } catch (error) {
+      console.error("Erro ao buscar todos os processos:", error);
+      throw error;
+    }
+  }
+
+  async findById(id: string): Promise<Processo | null> {
+    try {
+      const processo = await prisma.processo.findUnique({
+        where: { id },
+        include: {
+          cliente: true,
+          partes: {
+            include: {
+              cliente: true,
+            },
+          },
+          audiencias: true,
+          diligencias: true,
+          movimentacoes: true,
+          documentos: true,
+          honorarios: {
+            include: {
+              parcelas: true,
+            },
+          },
+          custas: true,
+        },
+      });
+
+      return processo;
+    } catch (error) {
+      console.error("Erro ao buscar processo por ID:", error);
+      throw error;
+    }
+  }
+
+  async findByNumero(numero: string): Promise<Processo | null> {
+    try {
+      const processo = await prisma.processo.findUnique({
+        where: { numero },
+      });
+
+      return processo;
+    } catch (error) {
+      console.error("Erro ao buscar processo por número:", error);
+      throw error;
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    try {
+      await prisma.processo.delete({
+        where: { id },
+      });
+    } catch (error) {
+      console.error("Erro ao excluir processo:", error);
+      throw error;
+    }
+  }
+
+  async findByCliente(clienteId: string): Promise<Processo[]> {
+    try {
+      const processos = await prisma.processo.findMany({
+        where: { clienteId },
+        include: {
+          cliente: true,
+          partes: true,
+        },
+        orderBy: {
+          dataCriacao: "desc",
+        },
+      });
+
+      return processos;
+    } catch (error) {
+      console.error("Erro ao buscar processos por cliente:", error);
+      throw error;
+    }
+  }
+
+  async search(term: string): Promise<Processo[]> {
+    try {
+      return await prisma.processo.findMany({
+        where: {
+          OR: [
+            { numero: { contains: term } },
+            { nomeContraparte: { contains: term, mode: "insensitive" } },
+            { orgaoJulgador: { contains: term, mode: "insensitive" } },
+          ],
+        },
+        include: {
+          cliente: true,
+        },
+      });
+    } catch (error) {
+      console.error("Erro ao pesquisar processos:", error);
+      throw error;
+    }
+  }
+}

src/repositories/UsuarioRepository.ts

@@ -0,0 +1,58 @@
+import { prisma } from "../config/database";
+import { Usuario } from "@prisma/client";
+
+export class UsuarioRepository {
+  async findByEmail(email: string): Promise<Usuario | null> {
+    console.log("Repository - Buscando usuário:", email); // Debug
+
+    try {
+      const usuario = await prisma.usuario.findUnique({
+        where: { email },
+        select: {
+          id: true,
+          nome: true,
+          email: true,
+          senha: true,
+          perfil: true,
+          ativo: true,
+        },
+      });
+
+      console.log("Repository - Usuário encontrado:", usuario ? "Sim" : "Não"); // Debug
+      return usuario;
+    } catch (error) {
+      console.error("Repository - Erro ao buscar usuário:", error);
+      throw error;
+    }
+  }
+
+  async create(usuario: Usuario): Promise<Usuario> {
+    return await prisma.usuario.create({
+      data: usuario,
+    });
+  }
+
+  async update(id: string, data: Partial<Usuario>): Promise<Usuario> {
+    return await prisma.usuario.update({
+      where: { id },
+      data,
+    });
+  }
+
+  async delete(id: string): Promise<boolean> {
+    await prisma.usuario.delete({
+      where: { id },
+    });
+    return true;
+  }
+
+  async findById(id: string): Promise<Usuario | null> {
+    return await prisma.usuario.findUnique({
+      where: { id },
+    });
+  }
+
+  async findAll(): Promise<Usuario[]> {
+    return await prisma.usuario.findMany();
+  }
+}