add new proofsystem

Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>

backend/app.ts

@@ -0,0 +1,24 @@
+import express from "express";
+import cors from "cors";
+import { PrismaClient } from "@prisma/client";
+import usuariosRoutes from "./routes/usuarios";
+import clientesRoutes from "./routes/clientes";
+import processosRoutes from "./routes/processos";
+import audienciasRoutes from "./routes/audiencias";
+
+const app = express();
+const prisma = new PrismaClient();
+
+app.use(cors());
+app.use(express.json());
+
+app.use("/api/usuarios", usuariosRoutes);
+app.use("/api/clientes", clientesRoutes);
+app.use("/api/processos", processosRoutes);
+app.use("/api/audiencias", audienciasRoutes);
+
+app.get("/", (req, res) => {
+  res.json({ message: "API is running" });
+});
+
+export default app;

backend/controllers/audienciasController.ts

@@ -0,0 +1,20 @@
+import { Request, Response } from "express";
+import prisma from "../prisma/client";
+
+// Lista todas as audiências
+export async function getAudiencias(req: Request, res: Response) {
+  try {
+    const audiencias = await prisma.audiencia.findMany({
+      orderBy: { data: "asc" },
+      include: {
+        processo: {
+          select: { numero: true, nomeContraparte: true }
+        }
+      }
+    });
+    res.json(audiencias);
+  } catch (error) {
+    console.error("Erro ao buscar audiências:", error);
+    res.status(500).json({ error: "Erro ao buscar audiências" });
+  }
+}

backend/routes/audiencias.ts

@@ -0,0 +1,9 @@
+import { Router } from "express";
+import { getAudiencias } from "../controllers/audienciasController";
+
+const router = Router();
+
+// GET /api/audiencias - Lista todas as audiências
+router.get("/", getAudiencias);
+
+export default router;

package.json

@@ -12,14 +12,20 @@
     "prisma:migrate": "prisma migrate dev",
     "prisma:studio": "prisma studio",
     "prisma:seed": "ts-node -T prisma/seed.ts",
-    "postinstall": "prisma generate && npx puppeteer browsers install chrome",
+    "postinstall": "prisma generate && npx playwright install chromium",
     "server": "ts-node --transpile-only src/server/index.ts",
     "dev:full": "concurrently -n \"frontend,backend\" -c \"blue,green\" \"npm run dev\" \"npm run server\"",
     "lint": "eslint . --ext .ts,.tsx",
     "lint:fix": "eslint . --ext .ts,.tsx --fix",
     "create-admin": "ts-node scripts/create_admin_user.ts",
     "worker": "ts-node src/workers/startWorker.ts",
-    "install-deps": "npm install ua-parser-js uuid axios xlsx"
+    "install-deps": "npm install ua-parser-js uuid axios xlsx html2canvas puppeteer-core chrome-aws-lambda jspdf canvas ws socket.io socket.io-client",
+    "install-web-proof-deps": "npm install html2canvas puppeteer-core chrome-aws-lambda jspdf canvas node-html-to-image playwright ws socket.io socket.io-client",
+    "prisma:resolve-migration": "npx prisma migrate resolve --applied",
+    "prisma:sync-schema": "npx prisma db push && npx prisma generate",
+    "prisma:reset-migrations": "npx prisma migrate reset --force",
+    "prisma:fix-manual-migration": "npx prisma migrate status && npx prisma db push && npx prisma generate",
+    "prisma:mark-applied": "npx prisma migrate resolve --applied"
   },
   "dependencies": {
     "@emotion/react": "^11.11.3",
@@ -49,9 +55,17 @@
     "multer": "^1.4.5-lts.1",
     "opentimestamps-javascript": "^1.0.1",
     "pdf-lib": "^1.17.1",
-    "pdfkit": "^0.13.0",
+    "html2canvas": "^1.4.1",
-    "puppeteer": "^24.5.0",
+    "puppeteer-core": "^24.15.0",
-    "qrcode": "^1.5.3",
+    "jspdf": "^2.5.1",
+    "canvas": "^3.1.2",
+    "screenshot-desktop": "^1.12.7",
+    "node-html-to-image": "^4.0.0",
+    "playwright": "^1.40.0",
+    "ws": "^8.14.2",
+    "socket.io": "^4.7.4",
+    "socket.io-client": "^4.7.4",
+    "@types/ws": "^8.5.10",
     "react": "^18.2.0",
     "react-beautiful-dnd": "^13.1.1",
     "react-dom": "^18.2.0",
@@ -87,9 +101,6 @@
     "autoprefixer": "^10.4.17",
     "concurrently": "^9.1.2",
     "eslint": "^9.23.0",
-    "eslint-config-prettier": "^10.1.1",
-    "eslint-plugin-prettier": "^5.2.5",
-    "eslint-plugin-react": "^7.37.4",
     "eslint-plugin-react-hooks": "^5.2.0",
     "postcss": "^8.4.33",
     "prettier": "^3.5.3",
@@ -97,7 +108,10 @@
     "tailwindcss": "^3.4.1",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.2",
-    "vite": "^6.2.4"
+    "vite": "^6.2.4",
+    "@types/html2canvas": "^1.0.0",
+    "@types/canvas": "^2.11.6",
+    "@types/node-html-to-image": "^4.0.0"
   },
   "prisma": {
     "seed": "ts-node prisma/seed.ts"

prisma/schema.prisma

@@ -1067,3 +1067,30 @@ model CalculoPensaoAlimenticia {
 
   @@map("calculos_pensao_alimenticia")
 }
+
+model WebProofSession {
+  id              String    @id @default(cuid())
+  sessionId       String    @unique
+  targetUrl       String
+  description     String?
+  status          String    @default("PENDENTE")
+  metadata        Json?
+  environment     Json?
+  screenshots     String[]
+  sessionHash     String?
+  contentHash     String?
+  pageHash        String?
+  reportPath      String?
+  networkData     Json?
+  trustedTimestamp String?
+  error           String?
+  createdAt       DateTime  @default(now())
+  updatedAt       DateTime  @updatedAt
+  processedAt     DateTime?
+
+  @@index([sessionId])
+  @@index([status])
+  @@index([createdAt])
+  @@index([contentHash])
+  @@map("web_proof_sessions")
+}

src/App.tsx

@@ -48,6 +48,10 @@ import { CalculosList } from './components/calculos/CalculosList';
 import { NovoCalculo } from './components/calculos/NovoCalculo';
 import { DetalhesCalculo } from './components/calculos/DetalhesCalculo';
 import { NovoPensaoAlimenticia } from './components/calculos/NovoPensaoAlimenticia';
+import { DetalhePensaoAlimenticia } from './components/calculos/DetalhePensaoAlimenticia';
+import WebProofCapture from './components/provas/WebProofCapture';
+import WebProofReport from './components/provas/WebProofReport';
+import WebProofList from './components/provas/WebProofList';
 
 const queryClient = new QueryClient();
 
@@ -114,7 +118,7 @@ const router = createBrowserRouter(
           } />
           
           {/* Rotas para Pensão Alimentícia */}
-          <Route path="/pensao-alimenticia/nova" element={
+          <Route path="/pensao-alimenticia/novo" element={
             <ProtectedRoute>
               <NovoPensaoAlimenticia />
             </ProtectedRoute>
@@ -122,9 +126,14 @@ const router = createBrowserRouter(
           
           <Route path="/pensao-alimenticia/:id" element={
             <ProtectedRoute>
-              <DetalhesCalculo />
+              <DetalhePensaoAlimenticia />
             </ProtectedRoute>
           } />
+          
+          {/* Rotas de Captura Web */}
+          <Route path="/web-proofs" element={<WebProofList />} />
+          <Route path="/web-proofs/capture" element={<WebProofCapture />} />
+          <Route path="/web-proofs/relatorio/:sessionId" element={<WebProofReport />} />
         </Route>
       </Route>
       <Route path="*" element={<Navigate to="/login" />} />

src/components/calculos/CalculosList.tsx

@@ -144,12 +144,20 @@ export function CalculosList() {
     <div className="container mx-auto px-4 py-8">
       <div className="flex justify-between items-center mb-6">
         <h1 className="text-2xl font-bold text-gray-900">Cálculos Judiciais</h1>
-        <Link
+        <div className="flex gap-3">
-          to="/calculos/novo"
+          <Link
-          className="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-blue-600 hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500"
+            to="/calculos/novo"
-        >
+            className="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-blue-600 hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500"
-          Novo Cálculo
+          >
-        </Link>
+            Novo Cálculo Judicial
+          </Link>
+          <Link
+            to="/pensao-alimenticia/novo"
+            className="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-green-600 hover:bg-green-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-green-500"
+          >
+            Novo Cálculo de Pensão
+          </Link>
+        </div>
       </div>
       
       {/* Filtros */}

src/components/calculos/DetalhePensaoAlimenticia.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect, useState } from 'react';
-import { useParams } from 'react-router-dom';
+import { useParams, useNavigate } from 'react-router-dom'; // Adicionar useNavigate
 import { toast } from 'react-toastify';
 import api from '../../services/api';
 
@@ -27,17 +27,36 @@ interface CalculoPensao {
 
 export function DetalhePensaoAlimenticia() {
   const { id } = useParams<{ id: string }>();
+  const navigate = useNavigate(); // Adicionar hook de navegação
   const [calculo, setCalculo] = useState<CalculoPensao | null>(null);
   const [loading, setLoading] = useState(true);
 
   useEffect(() => {
+    // Verificação extra para garantir que o id está definido
+    if (!id || id === "novo") {
+      setLoading(false);
+      setCalculo(null);
+      return;
+    }
     const loadCalculo = async () => {
       try {
-        const response = await api.get(`/pensao-alimenticia/${id}`);
+        console.log('[DetalhePensaoAlimenticia] Buscando cálculo para id:', id);
+        const response = await api.get(`/api/calculos/pensao-alimenticia/${id}`);
         setCalculo(response.data);
-      } catch (error) {
+      } catch (error: any) {
-        console.error('Erro ao carregar cálculo:', error);
+        // Log detalhado para depuração
-        toast.error('Falha ao carregar dados do cálculo');
+        console.error('[DetalhePensaoAlimenticia] Erro ao carregar cálculo:', error);
+
+        // Tratamento específico para erro 404 (cálculo não encontrado)
+        if (error?.response?.status === 404) {
+          toast.warn('Cálculo de pensão alimentícia não encontrado.');
+        } else {
+          toast.error(
+            error?.response?.data?.message ||
+            'Falha ao buscar cálculo de pensão alimentícia.'
+          );
+        }
+        setCalculo(null);
       } finally {
         setLoading(false);
       }
@@ -51,7 +70,17 @@ export function DetalhePensaoAlimenticia() {
   }
 
   if (!calculo) {
-    return <div>Cálculo não encontrado</div>;
+    return (
+      <div className="bg-white shadow-md rounded-lg p-6 flex flex-col items-center">
+        <div className="text-lg mb-4 text-gray-700">Nenhum cálculo de pensão alimentícia encontrado.</div>
+        <button
+          className="px-4 py-2 bg-blue-600 text-white rounded-md shadow hover:bg-blue-700"
+          onClick={() => navigate('/pensao-alimenticia/novo')}
+        >
+          Criar novo cálculo
+        </button>
+      </div>
+    );
   }
 
   return (
@@ -90,6 +119,15 @@ export function DetalhePensaoAlimenticia() {
           <p className="text-gray-700">{calculo.observacoes}</p>
         </div>
       )}
+
+      <div className="mt-8 flex justify-end">
+        <button
+          className="px-4 py-2 bg-blue-600 text-white rounded-md shadow hover:bg-blue-700"
+          onClick={() => navigate('/pensao-alimenticia/novo')}
+        >
+          Criar novo cálculo
+        </button>
+      </div>
     </div>
   );
 }

src/components/calculos/NovoPensaoAlimenticia.tsx

@@ -1,6 +1,7 @@
 import { useState, useEffect } from 'react';
 import { useNavigate } from 'react-router-dom';
 import { toast } from 'react-toastify';
+import { useAuth } from '../../contexts/AuthContext';
 import { formatarPercentual, parsePercentual } from '../../utils/formatters';
 
 interface ProcessoOption {
@@ -16,6 +17,7 @@ interface ClienteOption {
 
 export function NovoPensaoAlimenticia() {
   const navigate = useNavigate();
+  const { getToken } = useAuth();
   const [loading, setLoading] = useState(false);
   const [formData, setFormData] = useState({
     titulo: '',
@@ -101,13 +103,21 @@ export function NovoPensaoAlimenticia() {
         ...formData,
         percentualSalarioMinimo: percentual,
         multaPactuada: formData.multaPactuada ? parsePercentual(formData.multaPactuada) : undefined,
+        processoId: formData.processoId || undefined, // Corrigir aqui
+        clienteId: formData.clienteId || undefined,   // Corrigir aqui
       };
 
+      const token = getToken();
+      if (!token) {
+        throw new Error('Usuário não autenticado. Faça login novamente.');
+      }
+
       // Enviar solicitação para criar cálculo
       const response = await fetch('/api/pensao-alimenticia', {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}` // Adicionar o token aqui
         },
         body: JSON.stringify(dadosParaEnviar),
       });

src/components/clientes/ClienteModal.tsx

@@ -212,25 +212,24 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
       );
 
       if (response.data && !response.data.erro) {
-        // Usar estado local para garantir re-renderização imediata
         const endereco = response.data.logradouro || "";
         const bairro = response.data.bairro || "";
         const cidade = response.data.localidade || "";
         const estado = response.data.uf || "";
 
-        // Atualizar valores no formulário
+        // Só preencher endereço/bairro se vier valor da API
-        setValue("endereco", endereco, { shouldValidate: true });
+        if (endereco) setValue("endereco", endereco, { shouldValidate: true });
-        setValue("bairro", bairro, { shouldValidate: true });
+        if (bairro) setValue("bairro", bairro, { shouldValidate: true });
         setValue("cidade", cidade, { shouldValidate: true });
         setValue("estado", estado, { shouldValidate: true });
 
-        // Atualizar o estado para re-renderização do componente
+        // Atualizar estado apenas para cidade/estado (não controlar endereço/bairro)
         setEnderecoState({
-          endereco,
+          endereco: endereco,
-          bairro,
+          bairro: bairro,
-          cidade,
+          cidade: cidade,
-          estado,
+          estado: estado,
-          preenchido: true,
+          preenchido: false, // Não usar mais para travar campos
         });
 
         // Focar no próximo campo apenas se o usuário não estiver digitando ativamente
@@ -251,6 +250,18 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
           }, 100);
         }
       } else {
+        // Se CEP não encontrado, limpar campos e permitir edição manual
+        setEnderecoState({
+          endereco: "",
+          bairro: "",
+          cidade: "",
+          estado: "",
+          preenchido: false,
+        });
+        setValue("endereco", "");
+        setValue("bairro", "");
+        setValue("cidade", "");
+        setValue("estado", "");
         console.error("CEP não encontrado");
         alert("CEP não encontrado. Por favor, verifique o CEP informado.");
       }
@@ -622,10 +633,9 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
                             required: "Endereço é obrigatório",
                           })}
                           error={errors.endereco?.message}
-                          value={enderecoState.preenchido ? enderecoState.endereco : undefined}
+                          // Remover value/controlado por enderecoState, deixar react-hook-form controlar
                           onChange={(e) => {
-                            setValue("endereco", e.target.value);
+                            setValue("endereco", e.target.value, { shouldValidate: true });
-                            setEnderecoState(prev => ({...prev, endereco: e.target.value}));
                           }}
                         />
                         <FormInput
@@ -645,10 +655,9 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
                             required: "Bairro é obrigatório",
                           })}
                           error={errors.bairro?.message}
-                          value={enderecoState.preenchido ? enderecoState.bairro : undefined}
+                          // Remover value/controlado por enderecoState, deixar react-hook-form controlar
                           onChange={(e) => {
-                            setValue("bairro", e.target.value);
+                            setValue("bairro", e.target.value, { shouldValidate: true });
-                            setEnderecoState(prev => ({...prev, bairro: e.target.value}));
                           }}
                         />
                         <FormInput
@@ -657,9 +666,9 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
                             required: "Cidade é obrigatória",
                           })}
                           error={errors.cidade?.message}
-                          value={enderecoState.preenchido ? enderecoState.cidade : undefined}
+                          value={typeof watch("cidade") === "string" ? watch("cidade") : enderecoState.cidade}
                           onChange={(e) => {
-                            setValue("cidade", e.target.value);
+                            setValue("cidade", e.target.value, { shouldValidate: true });
                             setEnderecoState(prev => ({...prev, cidade: e.target.value}));
                           }}
                         />
@@ -670,9 +679,9 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
                           })}
                           options={estadosOptions}
                           error={errors.estado?.message}
-                          value={enderecoState.preenchido ? enderecoState.estado : undefined}
+                          value={typeof watch("estado") === "string" ? watch("estado") : enderecoState.estado}
                           onChange={(e) => {
-                            setValue("estado", e.target.value);
+                            setValue("estado", e.target.value, { shouldValidate: true });
                             setEnderecoState(prev => ({...prev, estado: e.target.value}));
                           }}
                         />

src/components/dashboard/BenchmarkingEscritorio.tsx

@@ -0,0 +1,65 @@
+import React from 'react';
+import { useBenchmarking } from '../../hooks/useBenchmarking';
+import { CheckCircleIcon, XCircleIcon, FolderOpenIcon } from '@heroicons/react/24/solid';
+
+export const BenchmarkingEscritorio: React.FC = () => {
+  // Hook para buscar e calcular benchmarking
+  const { data: benchmarking, isLoading, error } = useBenchmarking();
+
+  if (isLoading) return <div>Carregando benchmarking...</div>;
+  if (error) return <div className="text-red-600">Erro ao buscar benchmarking</div>;
+  if (!benchmarking) return null;
+
+  // Cálculo da porcentagem de sucesso das causas
+  const totalCausas = benchmarking.procedentes + benchmarking.improcedentesOuSemMerito;
+  const sucessoPercent = totalCausas > 0 ? Math.round((benchmarking.procedentes / totalCausas) * 100) : 0;
+
+  return (
+    <div className="border rounded-xl p-6 shadow-lg bg-white dark:bg-gray-900 flex flex-col gap-6 max-w-md mx-auto">
+      <div className="grid grid-cols-2 gap-4">
+        <div className="flex items-center gap-2 bg-blue-50 dark:bg-blue-900 rounded-lg p-3">
+          <FolderOpenIcon className="h-7 w-7 text-blue-600" />
+          <div>
+            <div className="text-xs text-gray-500">Total de processos</div>
+            <div className="text-lg font-bold text-blue-700 dark:text-blue-300">{benchmarking.totalProcessos}</div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2 bg-green-50 dark:bg-green-900 rounded-lg p-3">
+          <CheckCircleIcon className="h-7 w-7 text-green-600" />
+          <div>
+            <div className="text-xs text-gray-500">Processos ativos</div>
+            <div className="text-lg font-bold text-green-700 dark:text-green-300">{benchmarking.ativos}</div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2 bg-green-50 dark:bg-green-900 rounded-lg p-3">
+          <CheckCircleIcon className="h-7 w-7 text-green-600" />
+          <div>
+            <div className="text-xs text-gray-500">Julgados procedentes</div>
+            <div className="text-lg font-bold text-green-700 dark:text-green-300">{benchmarking.procedentes}</div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2 bg-red-50 dark:bg-red-900 rounded-lg p-3">
+          <XCircleIcon className="h-7 w-7 text-red-600" />
+          <div>
+            <div className="text-xs text-gray-500">Improcedentes/Sem mérito</div>
+            <div className="text-lg font-bold text-red-700 dark:text-red-300">{benchmarking.improcedentesOuSemMerito}</div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2 bg-indigo-50 dark:bg-indigo-900 rounded-lg p-3">
+          <FolderOpenIcon className="h-7 w-7 text-indigo-600" />
+          <div>
+            <div className="text-xs text-gray-500">Ajuizados últimos 7 dias</div>
+            <div className="text-lg font-bold text-indigo-700 dark:text-indigo-300">{benchmarking.ajuizados7dias}</div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2 bg-teal-50 dark:bg-teal-900 rounded-lg p-3">
+          <CheckCircleIcon className="h-7 w-7 text-teal-600" />
+          <div>
+            <div className="text-xs text-gray-500">% de sucesso das causas</div>
+            <div className="text-lg font-extrabold text-teal-700 dark:text-teal-300">{sucessoPercent}%</div>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};

src/components/dashboard/CalendarioAtendimentos.tsx

@@ -0,0 +1,117 @@
+import React from 'react';
+import { useCalendarioAtendimentos } from '../../hooks/useCalendarioAtendimentos';
+import { CalendarIcon, UserIcon, PresentationChartBarIcon } from '@heroicons/react/24/outline';
+
+export const CalendarioAtendimentos: React.FC = () => {
+  const { data: eventos = [], isLoading, error } = useCalendarioAtendimentos();
+
+  // Estado para mês e ano selecionados
+  const hoje = new Date();
+  const [mesSelecionado, setMesSelecionado] = React.useState(hoje.getMonth() + 1);
+  const [anoSelecionado, setAnoSelecionado] = React.useState(hoje.getFullYear());
+  const diasMes = Array.from({ length: new Date(anoSelecionado, mesSelecionado, 0).getDate() }, (_, i) => i + 1);
+  const mesStr = mesSelecionado.toString().padStart(2, '0');
+  const anoStr = anoSelecionado.toString();
+
+  // Atualiza data selecionada ao trocar mês/ano
+  const [dataSelecionada, setDataSelecionada] = React.useState(`${anoStr}-${mesStr}-${hoje.getDate().toString().padStart(2, '0')}`);
+  React.useEffect(() => {
+    setDataSelecionada(`${anoStr}-${mesStr}-${hoje.getDate().toString().padStart(2, '0')}`);
+  }, [mesSelecionado, anoSelecionado]);
+
+  // Separar eventos futuros/próximos e passados considerando ano/mês
+  const hojeStr = `${anoStr}-${mesStr}-${hoje.getDate().toString().padStart(2, '0')}`;
+  const eventosProximos = eventos
+    .filter(ev => ev.data >= hojeStr)
+    .sort((a, b) => a.data.localeCompare(b.data))
+    .slice(0, 10);
+  const eventosPassados = eventos
+    .filter(ev => ev.data < hojeStr)
+    .sort((a, b) => b.data.localeCompare(a.data))
+    .slice(0, 10);
+
+  const eventosDoDia = eventos.filter(e => e.data === dataSelecionada);
+
+  if (isLoading) return <div>Carregando calendário...</div>;
+  if (error) return <div className="text-red-600">Erro ao buscar eventos</div>;
+
+  return (
+    <div className="border rounded-xl p-4 shadow-lg bg-white dark:bg-gray-900 flex flex-col gap-6 max-w-4xl mx-auto">
+      <h2 className="text-lg font-bold text-gray-800 dark:text-gray-100 mb-2 flex items-center gap-2">
+        <CalendarIcon className="h-6 w-6 text-blue-600" /> Calendário de Atendimentos e Audiências
+      </h2>
+      <div className="flex items-center gap-4 mb-2">
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setMesSelecionado(m => m === 1 ? 12 : m - 1)}>&lt;</button>
+        <span className="font-semibold text-lg">{mesStr}/{anoStr}</span>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setMesSelecionado(m => m === 12 ? 1 : m + 1)}>&gt;</button>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setAnoSelecionado(a => a - 1)}>&lt; Ano</button>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setAnoSelecionado(a => a + 1)}>Ano &gt;</button>
+      </div>
+      <div className="grid grid-cols-7 gap-2 mb-4">
+        {diasMes.map((dia) => {
+          const dataStr = `${anoStr}-${mesStr}-${dia.toString().padStart(2, '0')}`;
+          const eventosDia = eventos.filter(e => e.data === dataStr);
+          const selecionado = dataStr === dataSelecionada;
+          return (
+            <button
+              key={dia}
+              type="button"
+              onClick={() => setDataSelecionada(dataStr)}
+              className={`h-12 w-full flex flex-col items-center justify-center border rounded-lg shadow-sm transition-all text-[11px] focus:outline-none ${selecionado ? 'ring-2 ring-blue-500 border-blue-500 bg-blue-100 dark:bg-blue-900' : eventosDia.length ? 'bg-blue-50 dark:bg-blue-900 border-blue-400' : 'bg-gray-50 dark:bg-gray-800'}`}
+            >
+              <span className="font-bold text-[11px] text-gray-700 dark:text-gray-200">{dia}</span>
+              {eventosDia.map((ev) => (
+                <span key={ev.id} className={`text-[10px] font-semibold flex items-center gap-1 whitespace-nowrap ${ev.tipo === 'Audiência' ? 'text-red-600' : 'text-blue-700'}`}> 
+                  {ev.tipo === 'Audiência' ? <PresentationChartBarIcon className="h-3 w-3" /> : <UserIcon className="h-3 w-3" />} {ev.tipo}
+                </span>
+              ))}
+            </button>
+          );
+        })}
+      </div>
+      <div className="mb-6">
+        <h3 className="font-semibold mb-2 flex items-center gap-2"><CalendarIcon className="h-5 w-5 text-blue-600" /> Eventos do dia {dataSelecionada.split('-').reverse().join('/')}</h3>
+        <ul className="text-xs divide-y divide-gray-200 dark:divide-gray-700">
+          {eventosDoDia.length === 0 && <li className="text-gray-400">Não existem eventos no dia selecionado.</li>}
+          {eventosDoDia.map((ev) => (
+            <li key={ev.id} className="py-2 flex flex-wrap items-center gap-3">
+              {ev.tipo === 'Audiência' ? <PresentationChartBarIcon className="h-4 w-4 text-red-600" /> : <UserIcon className="h-4 w-4 text-blue-600" />}
+              <span className="px-2 py-1 rounded text-xs font-semibold bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 min-w-[80px] text-center">{ev.tipo}</span>
+              <span className="text-gray-600 dark:text-gray-300 break-words max-w-xs">{ev.descricao}</span>
+            </li>
+          ))}
+        </ul>
+      </div>
+      <div className="grid grid-cols-2 gap-8">
+        <div>
+          <h3 className="font-semibold mb-2 flex items-center gap-2"><CalendarIcon className="h-5 w-5 text-blue-600" /> Próximos eventos</h3>
+          <ul className="text-xs divide-y divide-gray-200 dark:divide-gray-700">
+            {eventosProximos.length === 0 && <li className="text-gray-400">Nenhum evento futuro</li>}
+            {eventosProximos.map((ev) => (
+              <li key={ev.id} className="py-2 flex flex-wrap items-center gap-3">
+                {ev.tipo === 'Audiência' ? <PresentationChartBarIcon className="h-4 w-4 text-red-600" /> : <UserIcon className="h-4 w-4 text-blue-600" />}
+                <span className="font-bold min-w-[70px]">{ev.data}</span>
+                <span className="px-2 py-1 rounded text-xs font-semibold bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 min-w-[80px] text-center">{ev.tipo}</span>
+                <span className="text-gray-600 dark:text-gray-300 break-words max-w-xs">{ev.descricao}</span>
+              </li>
+            ))}
+          </ul>
+        </div>
+        <div>
+          <h3 className="font-semibold mb-2 flex items-center gap-2"><CalendarIcon className="h-5 w-5 text-gray-500" /> Últimos eventos</h3>
+          <ul className="text-xs divide-y divide-gray-200 dark:divide-gray-700">
+            {eventosPassados.length === 0 && <li className="text-gray-400">Nenhum evento anterior</li>}
+            {eventosPassados.map((ev) => (
+              <li key={ev.id} className="py-2 flex flex-wrap items-center gap-3">
+                {ev.tipo === 'Audiência' ? <PresentationChartBarIcon className="h-4 w-4 text-red-600" /> : <UserIcon className="h-4 w-4 text-blue-600" />}
+                <span className="font-bold min-w-[70px]">{ev.data}</span>
+                <span className="px-2 py-1 rounded text-xs font-semibold bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 min-w-[80px] text-center">{ev.tipo}</span>
+                <span className="text-gray-600 dark:text-gray-300 break-words max-w-xs">{ev.descricao}</span>
+              </li>
+            ))}
+          </ul>
+        </div>
+      </div>
+    </div>
+  );
+};

src/components/dashboard/DashboardLayout.tsx

@@ -1,52 +1,30 @@
 import React from 'react';
-import { useAuth } from '../../contexts/AuthContext';
+import { WorkflowTarefas } from './WorkflowTarefas';
-import { useDashboardStats } from '../../hooks/useDashboardStats';
+import { CalendarioAtendimentos } from './CalendarioAtendimentos';
-import { ProcessosStats } from './stats/ProcessosStats';
+import { BenchmarkingEscritorio } from './BenchmarkingEscritorio';
-import { TarefasStats } from './stats/TarefasStats';
+import { PainelFinanceiro } from './PainelFinanceiro';
-import { AtendimentosStats } from './stats/AtendimentosStats';
-import { FinanceiroStats } from './stats/FinanceiroStats';
-import { AlertasPrazos } from './AlertasPrazos';
-import { AtividadesRecentes } from './AtividadesRecentes';
-import { TaxaSucessoCard } from './TaxaSucessoCard';
-import { KPIsFinanceiros } from './stats/KPIsFinanceiros';
 
 export const DashboardLayout: React.FC = () => {
-  const { user } = useAuth();
-  const {
-    processosStats,
-    tarefasStats,
-    atendimentosStats,
-    financeiroStats,
-    proximosPrazos,
-    atividades
-  } = useDashboardStats();
-
-  const isAdminOrAdvogado = ['ADVOGADO_ADMIN', 'ADVOGADO'].includes(user?.perfil || '');
 
   return (
-    <div className="space-y-6 p-6">
+    <div className="grid grid-cols-1 lg:grid-cols-3 gap-6 p-6">
-      {/* Stats Cards */}
+      {/* Coluna 1: Workflow de Tarefas */}
-      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-6">
+      <div className="space-y-6">
-        {processosStats.data && <ProcessosStats data={processosStats.data} />}
+        <h2 className="text-xl font-bold">Workflow de Tarefas</h2>
-        {tarefasStats.data && <TarefasStats data={tarefasStats.data} />}
+        <WorkflowTarefas />
-        {atendimentosStats.data && <AtendimentosStats data={atendimentosStats.data} />}
-        {isAdminOrAdvogado && financeiroStats.data && (
-          <FinanceiroStats data={financeiroStats.data} />
-        )}
       </div>
 
-      <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
+      {/* Coluna 2: Calendário de Atendimentos, Compromissos e Diligências */}
-        {/* Coluna da esquerda */}
+      <div className="space-y-6">
-        <div className="lg:col-span-2 space-y-6">
+        <h2 className="text-xl font-bold">Calendário</h2>
-          <TaxaSucessoCard />
+        <CalendarioAtendimentos />
-          {isAdminOrAdvogado && <KPIsFinanceiros />}
+      </div>
-        </div>
 
-        {/* Coluna da direita */}
+      {/* Coluna 3: Benchmarking do Escritório */}
-        <div className="space-y-6">
+      <div className="space-y-6">
-          <AlertasPrazos />
+        <h2 className="text-xl font-bold">Benchmarking do Escritório</h2>
-          <AtividadesRecentes />
+        <BenchmarkingEscritorio />
-        </div>
+        <PainelFinanceiro />
       </div>
     </div>
   );

src/components/dashboard/PainelFinanceiro.tsx

@@ -0,0 +1,83 @@
+import React from 'react';
+import { useFinanceiroPainel } from '../../hooks/useFinanceiroPainel';
+import { CurrencyDollarIcon, ArrowDownCircleIcon, ArrowUpCircleIcon } from '@heroicons/react/24/solid';
+
+export const PainelFinanceiro: React.FC = () => {
+  const hoje = new Date();
+  const [mes, setMes] = React.useState(hoje.getMonth() + 1);
+  const [ano, setAno] = React.useState(hoje.getFullYear());
+  const { data, isLoading, error } = useFinanceiroPainel(mes, ano);
+
+  const mesesNomes = ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'];
+
+  return (
+    <div className="border rounded-xl p-6 shadow-lg bg-white dark:bg-gray-900 flex flex-col gap-6 max-w-4xl mx-auto mt-8">
+      <h2 className="text-lg font-bold text-gray-800 dark:text-gray-100 mb-2 flex items-center gap-2">
+        <CurrencyDollarIcon className="h-6 w-6 text-green-600" /> Painel Financeiro
+      </h2>
+      <div className="flex items-center gap-4 mb-2">
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setMes(m => m === 1 ? 12 : m - 1)}>&lt;</button>
+        <span className="font-semibold text-lg">{mesesNomes[mes - 1]}/{ano}</span>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setMes(m => m === 12 ? 1 : m + 1)}>&gt;</button>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setAno(a => a - 1)}>&lt; Ano</button>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setAno(a => a + 1)}>Ano &gt;</button>
+      </div>
+      {isLoading && <div>Carregando dados financeiros...</div>}
+      {error && <div className="text-red-600">Erro ao buscar dados financeiros</div>}
+      {data && (
+        <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mb-6">
+          <div className="flex flex-col items-center bg-green-50 dark:bg-green-900 rounded-lg p-4">
+            <CurrencyDollarIcon className="h-7 w-7 text-green-600 mb-1" />
+            <span className="text-xs text-gray-500">Honorários a receber</span>
+            <span className="text-lg font-bold text-green-700 dark:text-green-300">R$ {data.honorariosAReceber.toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+          </div>
+          <div className="flex flex-col items-center bg-blue-50 dark:bg-blue-900 rounded-lg p-4">
+            <ArrowUpCircleIcon className="h-7 w-7 text-blue-600 mb-1" />
+            <span className="text-xs text-gray-500">Honorários recebidos no mês</span>
+            <span className="text-lg font-bold text-blue-700 dark:text-blue-300">R$ {data.honorariosRecebidosMes.toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+          </div>
+          <div className="flex flex-col items-center bg-red-50 dark:bg-red-900 rounded-lg p-4">
+            <ArrowDownCircleIcon className="h-7 w-7 text-red-600 mb-1" />
+            <span className="text-xs text-gray-500">Custas a pagar</span>
+            <span className="text-lg font-bold text-red-700 dark:text-red-300">R$ {data.custasAPagar.toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+          </div>
+          <div className="flex flex-col items-center bg-teal-50 dark:bg-teal-900 rounded-lg p-4">
+            <ArrowUpCircleIcon className="h-7 w-7 text-teal-600 mb-1" />
+            <span className="text-xs text-gray-500">Custas pagas no mês</span>
+            <span className="text-lg font-bold text-teal-700 dark:text-teal-300">R$ {data.custasPagasMes.toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+          </div>
+        </div>
+      )}
+      {data && (
+        <div className="grid grid-cols-1 md:grid-cols-2 gap-8">
+          <div>
+            <h3 className="font-semibold mb-2 text-green-700 dark:text-green-300">Honorários recebidos no mês</h3>
+            <ul className="text-xs divide-y divide-gray-200 dark:divide-gray-700">
+              {data.detalhesHonorarios.length === 0 && <li className="text-gray-400">Nenhum recebimento registrado neste mês.</li>}
+              {data.detalhesHonorarios.map((item, idx) => (
+                <li key={idx} className="py-2 flex flex-col">
+                  <span className="font-bold">Contrato: {item.contrato?.processoId || 'N/A'}</span>
+                  <span>Parcela: {item.parcela?.numeroParcela || 'N/A'} - Valor: R$ {Number(item.parcela?.valorPago || item.parcela?.valor || 0).toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+                  <span className="text-gray-500">Pago em: {item.parcela?.dataPagamento ? new Date(item.parcela.dataPagamento).toLocaleDateString('pt-br') : '-'}</span>
+                </li>
+              ))}
+            </ul>
+          </div>
+          <div>
+            <h3 className="font-semibold mb-2 text-red-700 dark:text-red-300">Custas pagas no mês</h3>
+            <ul className="text-xs divide-y divide-gray-200 dark:divide-gray-700">
+              {data.detalhesCustas.length === 0 && <li className="text-gray-400">Nenhuma custa paga neste mês.</li>}
+              {data.detalhesCustas.map((c, idx) => (
+                <li key={idx} className="py-2 flex flex-col">
+                  <span className="font-bold">Processo: {c.processoId || 'N/A'}</span>
+                  <span>Tipo: {c.tipo || 'N/A'} - Valor: R$ {Number(c.valor || 0).toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+                  <span className="text-gray-500">Pago em: {c.dataPagamento ? new Date(c.dataPagamento).toLocaleDateString('pt-br') : '-'}</span>
+                </li>
+              ))}
+            </ul>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};

src/components/dashboard/WorkflowTarefas.tsx

@@ -0,0 +1,106 @@
+import React from 'react';
+import { useAuth } from '../../contexts/AuthContext';
+import { useTarefas } from '../../hooks/useTarefas';
+import { Tarefa } from '../../types/entities';
+import { PencilIcon, TrashIcon } from '@heroicons/react/24/outline';
+
+export const WorkflowTarefas: React.FC = () => {
+  const { user } = useAuth();
+  const { tarefas, isLoading, deleteTarefa } = useTarefas();
+
+  const canDelete = user && ['ADVOGADO_ADMIN', 'ADVOGADO'].includes(user.perfil);
+
+  const handleEdit = (tarefa: Tarefa) => {
+    // Implemente a lógica de edição conforme necessário
+    alert(`Editar tarefa: ${tarefa.titulo}`);
+  };
+
+  const handleDelete = async (id: string) => {
+    if (!window.confirm('Tem certeza que deseja excluir esta tarefa?')) return;
+    try {
+      await deleteTarefa.mutateAsync(id);
+    } catch (error) {
+      console.error('Erro ao excluir tarefa:', error);
+      alert('Erro ao excluir tarefa');
+    }
+  };
+
+  if (isLoading) {
+    return (
+      <div className="bg-white dark:bg-gray-800 shadow rounded-lg p-4 text-center text-gray-500 dark:text-gray-400">
+        Carregando tarefas...
+      </div>
+    );
+  }
+
+  if (!tarefas || tarefas.length === 0) {
+    return (
+      <div className="bg-white dark:bg-gray-800 shadow rounded-lg p-4 text-center text-gray-500 dark:text-gray-400">
+        Nenhuma tarefa encontrada.
+      </div>
+    );
+  }
+
+  // Exibir apenas tarefas que não estão concluídas ou canceladas
+  const tarefasAtivas = tarefas.filter((t: Tarefa) => t.status !== 'CONCLUIDA' && t.status !== 'CANCELADA');
+
+  return (
+    <div className="flex flex-col gap-4">
+      {tarefasAtivas.map((tarefa: Tarefa) => (
+        <div key={tarefa.id} className="border rounded-lg p-4 shadow flex flex-col gap-2 bg-white dark:bg-gray-800">
+          <div className="flex flex-col md:flex-row md:justify-between md:items-center gap-2">
+            <div className="flex items-center gap-3">
+              <span className="font-medium text-lg text-gray-900 dark:text-white">{tarefa.titulo}</span>
+              {/* Exibe o grau de prioridade com cor */}
+              <span className={`px-2 py-1 rounded text-xs font-semibold border ${
+                tarefa.prioridade === 'URGENTE' ? 'bg-red-100 text-red-700 border-red-300' :
+                tarefa.prioridade === 'ALTA' ? 'bg-orange-100 text-orange-700 border-orange-300' :
+                tarefa.prioridade === 'MEDIA' ? 'bg-yellow-100 text-yellow-700 border-yellow-300' :
+                'bg-green-100 text-green-700 border-green-300'
+              }`}>
+                {tarefa.prioridade === 'URGENTE' ? 'Urgente' : tarefa.prioridade === 'ALTA' ? 'Alta' : tarefa.prioridade === 'MEDIA' ? 'Média' : 'Baixa'}
+              </span>
+            </div>
+            <div className="flex items-center gap-3">
+              {/* Status da tarefa */}
+              <span className={`px-2 py-1 rounded text-xs font-semibold border ${
+                tarefa.status === 'CONCLUIDA' ? 'bg-green-100 text-green-700 border-green-300' :
+                tarefa.status === 'EM_ANDAMENTO' ? 'bg-blue-100 text-blue-700 border-blue-300' :
+                tarefa.status === 'PENDENTE' ? 'bg-gray-100 text-gray-700 border-gray-300' :
+                'bg-red-100 text-red-700 border-red-300'
+              }`}>
+                {tarefa.status.replace('_', ' ')}
+              </span>
+              <button
+                onClick={() => handleEdit(tarefa)}
+                className="text-blue-600 dark:text-blue-400 hover:text-blue-900 dark:hover:text-blue-300"
+                title="Editar"
+              >
+                <PencilIcon className="h-5 w-5" />
+              </button>
+              {canDelete && (
+                <button
+                  onClick={() => handleDelete(tarefa.id)}
+                  className="text-red-600 dark:text-red-400 hover:text-red-900 dark:hover:text-red-300"
+                  title="Excluir"
+                >
+                  <TrashIcon className="h-5 w-5" />
+                </button>
+              )}
+            </div>
+          </div>
+          {/* Listagem das subtarefas vinculadas */}
+          {tarefa.subtarefas && tarefa.subtarefas.length > 0 && (
+            <ul className="mt-2 ml-2 list-disc text-sm text-gray-700 dark:text-gray-300">
+              {tarefa.subtarefas.map((sub) => (
+                <li key={sub.id} className={sub.concluida ? 'line-through text-gray-400' : ''}>
+                  {sub.titulo} {sub.concluida ? '(Concluída)' : ''}
+                </li>
+              ))}
+            </ul>
+          )}
+        </div>
+      ))}
+    </div>
+  );
+};

src/components/layout/Sidebar.tsx

@@ -0,0 +1,104 @@
+import React from 'react';
+import { Link, useLocation } from 'react-router-dom';
+import { useAuth } from '../../hooks/useAuth';
+import {
+  HomeIcon,
+  DocumentTextIcon,
+  UserIcon,
+  CogIcon,
+  LogoutIcon,
+  ShieldCheckIcon,
+  ViewGridIcon,
+  ClipboardListIcon
+} from '@heroicons/react/outline';
+
+const Sidebar: React.FC = () => {
+  const { pathname } = useLocation();
+  const { user, logout } = useAuth();
+
+  const isActive = (path: string) => {
+    return pathname === path ? 'bg-blue-500 text-white' : 'text-gray-700';
+  };
+
+  const menuItems = [
+    {
+      name: 'Início',
+      icon: HomeIcon,
+      href: '/'
+    },
+    {
+      name: 'Provas Digitais',
+      icon: DocumentTextIcon,
+      children: [
+        { name: 'Verificar Prova', href: '/provas/verificar' },
+        { name: 'Enviar Prova', href: '/provas/upload' },
+        { name: 'Status da Prova', href: '/provas/status' },
+        { name: 'Captura Web', href: '/web-proofs/capture' },
+        { name: 'Relatórios Web', href: '/web-proofs' }
+      ]
+    },
+    {
+      name: 'Usuário',
+      icon: UserIcon,
+      href: '/profile'
+    },
+    {
+      name: 'Configurações',
+      icon: CogIcon,
+      href: '/settings'
+    },
+    {
+      name: 'Sair',
+      icon: LogoutIcon,
+      action: logout
+    }
+  ];
+
+  return (
+    <div className="bg-white shadow-md rounded-lg p-4">
+      <div className="flex items-center justify-between mb-4">
+        <h2 className="text-lg font-semibold text-gray-800">Painel de Controle</h2>
+      </div>
+
+      <nav>
+        <ul className="space-y-2">
+          {menuItems.map((item) => (
+            <li key={item.name}>
+              {item.children ? (
+                <div>
+                  <p className="text-xs font-semibold text-gray-500 uppercase">{item.name}</p>
+                  <ul className="mt-1 space-y-1">
+                    {item.children.map((child) => (
+                      <li key={child.name}>
+                        <Link
+                          to={child.href}
+                          className={`flex items-center p-2 text-sm rounded-md transition-all duration-200
+                            ${isActive(child.href)} hover:bg-blue-600 hover:text-white`}
+                        >
+                          <ViewGridIcon className="w-5 h-5 mr-2" />
+                          {child.name}
+                        </Link>
+                      </li>
+                    ))}
+                  </ul>
+                </div>
+              ) : (
+                <Link
+                  to={item.href}
+                  onClick={item.action}
+                  className={`flex items-center p-2 text-sm rounded-md transition-all duration-200
+                    ${isActive(item.href)} hover:bg-blue-600 hover:text-white`}
+                >
+                  <item.icon className="w-5 h-5 mr-2" />
+                  {item.name}
+                </Link>
+              )}
+            </li>
+          ))}
+        </ul>
+      </nav>
+    </div>
+  );
+};
+
+export default Sidebar;

src/components/provas/ClientProvaUpload.tsx

@@ -3,6 +3,8 @@ import { useNavigate } from 'react-router-dom';
 import { useDropzone } from 'react-dropzone';
 import { toast } from 'react-toastify';
 
+// Página pública: NÃO requer autenticação do usuário
+
 export function ClientProvaUpload() {
   const [file, setFile] = useState<File | null>(null);
   const [uploading, setUploading] = useState(false);
@@ -43,9 +45,31 @@ export function ClientProvaUpload() {
     }
   }, []);
 
+  // Validação extra do arquivo antes do upload
+  function validateFile(file: File | null): string | null {
+    if (!file) return 'Nenhum arquivo selecionado.';
+    const allowedTypes = [
+      'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'application/pdf'
+    ];
+    if (!allowedTypes.includes(file.type)) {
+      return 'Tipo de arquivo não suportado. Use JPG, PNG, GIF, WEBP ou PDF.';
+    }
+    if (file.size > 10 * 1024 * 1024) {
+      return 'Arquivo excede o tamanho máximo de 10MB.';
+    }
+    return null;
+  }
+
   const onDrop = useCallback(async (acceptedFiles: File[]) => {
     if (acceptedFiles.length > 0) {
       const selectedFile = acceptedFiles[0];
+      const validationError = validateFile(selectedFile);
+      if (validationError) {
+        toast.error(validationError);
+        setFile(null);
+        setFilePreview(null);
+        return;
+      }
       setFile(selectedFile);
       
       // Criar preview para imagens
@@ -77,6 +101,12 @@ export function ClientProvaUpload() {
         toast.error('Por favor, selecione um arquivo primeiro');
         return;
       }
+      // Validação extra antes do envio
+      const validationError = validateFile(file);
+      if (validationError) {
+        toast.error(validationError);
+        return;
+      }
 
       setUploading(true);
       setUploadProgress(0);
@@ -120,7 +150,7 @@ export function ClientProvaUpload() {
       // Adicionar timestamp preciso do cliente
       formData.append('client_timestamp', new Date().toISOString());
 
-      // Criar simulação de progresso
+      // Simulação de progresso
       const progressInterval = setInterval(() => {
         setUploadProgress(prev => {
           if (prev >= 95) {
@@ -131,10 +161,18 @@ export function ClientProvaUpload() {
         });
       }, 300);
 
-      const response = await fetch('/api/provas/upload', {
+      // Upload sem autenticação (página pública)
-        method: 'POST',
+      let response: Response;
-        body: formData,
+      try {
-      });
+        response = await fetch('/api/provas/upload', {
+          method: 'POST',
+          body: formData,
+        });
+      } catch (networkError) {
+        clearInterval(progressInterval);
+        setUploadProgress(0);
+        throw new Error('Erro de conexão. Verifique sua internet e tente novamente.');
+      }
 
       clearInterval(progressInterval);
       setUploadProgress(100);
@@ -155,9 +193,14 @@ export function ClientProvaUpload() {
       }
 
       // Ler o corpo da resposta
-      const result = await response.json();
+      let result: any;
+      try {
+        result = await response.json();
+      } catch {
+        throw new Error('Resposta inesperada do servidor.');
+      }
 
-      if (result.id) {
+      if (result && result.id) {
         toast.success('Arquivo enviado com sucesso!');
         // Navegar para a página de status
         navigate(`/public/provas/status/${result.id}`);
@@ -165,10 +208,10 @@ export function ClientProvaUpload() {
         throw new Error('ID do documento não encontrado na resposta');
       }
       
-    } catch (error) {
+    } catch (error: any) {
       console.error('Erro detalhado no upload:', error);
       setError(error.message || 'Erro ao enviar arquivo. Por favor, tente novamente.');
-      toast.error('Falha no upload: ' + error.message);
+      toast.error('Falha no upload: ' + (error.message || 'Erro desconhecido'));
     } finally {
       setUploading(false);
     }

src/components/provas/WebProofCapture.tsx

@@ -0,0 +1,501 @@
+import React, { useState, useRef, useEffect, useCallback } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { toast } from 'react-toastify';
+
+interface CaptureSession {
+  id: string;
+  startTime: string;
+  status: 'PREPARANDO' | 'ATIVO' | 'GRAVANDO' | 'FINALIZANDO' | 'CONCLUIDO' | 'ERRO';
+  environment: {
+    sessionId: string;
+    userAgent: string;
+    viewportSize: { width: number; height: number };
+    ipAddress: string;
+    timestamp: string;
+  };
+}
+
+interface WebProofMetadata {
+  networkData: {
+    sourceIP: string;
+    targetIP: string;
+    routePath: string[];
+    dnsRecords: any[];
+  };
+  timestamps: {
+    sessionStart: string;
+    captureStart: string;
+    captureEnd: string;
+    trustedTimestamp?: string;
+  };
+  hashes: {
+    sessionHash: string;
+    contentHash: string;
+    videoHash?: string;
+    pageHash: string;
+  };
+  technicalData: {
+    browserFingerprint: string;
+    navigationTrace: any[];
+    domSnapshot: string;
+    screenshots: string[];
+  };
+}
+
+const SESSION_STATES = {
+  PREPARING: 'PREPARANDO',
+  ACTIVE: 'ATIVO',
+  RECORDING: 'GRAVANDO',
+  FINALIZING: 'FINALIZANDO',
+  COMPLETED: 'CONCLUIDO',
+  ERROR: 'ERRO'
+} as const;
+
+export function WebProofCapture() {
+  const [session, setSession] = useState<CaptureSession | null>(null);
+  const [isRecording, setIsRecording] = useState(false);
+  const [targetUrl, setTargetUrl] = useState('');
+  const [captureDescription, setCaptureDescription] = useState('');
+  const [metadata, setMetadata] = useState<WebProofMetadata | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [progress, setProgress] = useState(0);
+  const [screenshots, setScreenshots] = useState<string[]>([]);
+  
+  const iframeRef = useRef<HTMLIFrameElement>(null);
+  const recordedChunksRef = useRef<Blob[]>([]);
+  const navigate = useNavigate();
+
+  // Inicializar ambiente isolado
+  const initializeIsolatedEnvironment = useCallback(async () => {
+    try {
+      setProgress(10);
+      setError(null);
+      
+      // Simular criação de ambiente isolado
+      const sessionId = `webproof_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      
+      // Coletar informações do ambiente
+      const environmentData = {
+        sessionId,
+        userAgent: navigator.userAgent,
+        viewportSize: {
+          width: window.innerWidth,
+          height: window.innerHeight
+        },
+        ipAddress: await getClientIP(),
+        timestamp: new Date().toISOString()
+      };
+
+      setProgress(30);
+
+      const newSession: CaptureSession = {
+        id: sessionId,
+        startTime: new Date().toISOString(),
+        status: SESSION_STATES.PREPARING,
+        environment: environmentData
+      };
+
+      setSession(newSession);
+      setProgress(50);
+
+      // Inicializar coleta de metadados
+      await initializeMetadataCollection(sessionId);
+      setProgress(100);
+
+      setSession(prev => prev ? { ...prev, status: SESSION_STATES.ACTIVE } : null);
+      
+    } catch (error) {
+      console.error('Erro ao inicializar ambiente:', error);
+      setError('Falha ao inicializar ambiente isolado');
+    }
+  }, []);
+
+  // Obter IP do cliente
+  const getClientIP = async (): Promise<string> => {
+    try {
+      const response = await fetch('/api/web-proofs/client-info');
+      if (!response.ok) {
+        throw new Error('Falha ao obter informações do cliente');
+      }
+      const data = await response.json();
+      return data.ip || '127.0.0.1';
+    } catch (error) {
+      console.warn('Erro ao obter IP do cliente:', error);
+      return '127.0.0.1';
+    }
+  };
+
+  // Inicializar coleta de metadados
+  const initializeMetadataCollection = async (sessionId: string) => {
+    const initialMetadata: WebProofMetadata = {
+      networkData: {
+        sourceIP: await getClientIP(),
+        targetIP: '',
+        routePath: [],
+        dnsRecords: []
+      },
+      timestamps: {
+        sessionStart: new Date().toISOString(),
+        captureStart: '',
+        captureEnd: ''
+      },
+      hashes: {
+        sessionHash: await generateHash(sessionId),
+        contentHash: '',
+        pageHash: ''
+      },
+      technicalData: {
+        browserFingerprint: generateBrowserFingerprint(),
+        navigationTrace: [],
+        domSnapshot: '',
+        screenshots: []
+      }
+    };
+
+    setMetadata(initialMetadata);
+  };
+
+  // Gerar hash seguro
+  const generateHash = async (data: string): Promise<string> => {
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(data + Date.now());
+    const hashBuffer = await crypto.subtle.digest('SHA-256', dataBuffer);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+  };
+
+  // Gerar fingerprint do navegador
+  const generateBrowserFingerprint = (): string => {
+    const fingerprint = {
+      userAgent: navigator.userAgent,
+      language: navigator.language,
+      platform: navigator.platform,
+      cookieEnabled: navigator.cookieEnabled,
+      doNotTrack: navigator.doNotTrack,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      screen: {
+        width: screen.width,
+        height: screen.height,
+        colorDepth: screen.colorDepth
+      }
+    };
+    
+    return btoa(JSON.stringify(fingerprint));
+  };
+
+  // Validar URL
+  const validateUrl = (url: string): boolean => {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  // Iniciar captura
+  const startCapture = async () => {
+    if (!targetUrl.trim()) {
+      toast.error('Por favor, insira uma URL válida');
+      return;
+    }
+
+    if (!validateUrl(targetUrl)) {
+      toast.error('URL inválida. Use formato: https://exemplo.com');
+      return;
+    }
+
+    try {
+      setIsRecording(true);
+      setSession(prev => prev ? { ...prev, status: SESSION_STATES.RECORDING } : null);
+      
+      // Atualizar metadados com início da captura
+      if (metadata) {
+        const updatedMetadata = {
+          ...metadata,
+          timestamps: {
+            ...metadata.timestamps,
+            captureStart: new Date().toISOString()
+          }
+        };
+        setMetadata(updatedMetadata);
+      }
+
+      // Navegar para URL alvo no iframe
+      if (iframeRef.current) {
+        iframeRef.current.src = targetUrl;
+      }
+
+      toast.success('Captura iniciada - ambiente isolado ativo');
+      
+    } catch (error) {
+      console.error('Erro ao iniciar captura:', error);
+      setError('Falha ao iniciar captura');
+      setIsRecording(false);
+    }
+  };
+
+  // Capturar screenshot
+  const captureScreenshot = async () => {
+    try {
+      if (!iframeRef.current) return;
+
+      // Simular captura de screenshot
+      const timestamp = new Date().toISOString();
+      const screenshotData = `screenshot_${Date.now()}`;
+      
+      setScreenshots(prev => [...prev, screenshotData]);
+      
+      // Registrar ação nos metadados
+      if (metadata && isRecording) {
+        const updatedMetadata = {
+          ...metadata,
+          technicalData: {
+            ...metadata.technicalData,
+            screenshots: [...metadata.technicalData.screenshots, screenshotData],
+            navigationTrace: [...metadata.technicalData.navigationTrace, {
+              type: 'screenshot',
+              timestamp,
+              url: targetUrl
+            }]
+          }
+        };
+        setMetadata(updatedMetadata);
+      }
+
+      toast.success('Screenshot capturado');
+    } catch (error) {
+      console.error('Erro ao capturar screenshot:', error);
+      toast.error('Falha ao capturar screenshot');
+    }
+  };
+
+  // Finalizar captura
+  const finalizeCaptureSession = async () => {
+    try {
+      setSession(prev => prev ? { ...prev, status: SESSION_STATES.FINALIZING } : null);
+      setIsRecording(false);
+
+      if (!metadata || !session) {
+        throw new Error('Sessão ou metadados não encontrados');
+      }
+
+      // Finalizar metadados
+      const finalMetadata = {
+        ...metadata,
+        timestamps: {
+          ...metadata.timestamps,
+          captureEnd: new Date().toISOString(),
+          trustedTimestamp: await getTrustedTimestamp()
+        },
+        hashes: {
+          ...metadata.hashes,
+          contentHash: await generateHash(targetUrl + Date.now()),
+          pageHash: await generateHash(`page_${session.id}_${targetUrl}`)
+        }
+      };
+
+      // Enviar para processamento
+      const response = await fetch('/api/web-proofs/sessions', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          sessionId: session.id,
+          targetUrl,
+          description: captureDescription,
+          metadata: finalMetadata,
+          environment: session.environment,
+          screenshots
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error('Falha ao processar sessão');
+      }
+
+      const result = await response.json();
+      
+      setSession(prev => prev ? { ...prev, status: SESSION_STATES.COMPLETED } : null);
+      toast.success('Captura finalizada com sucesso');
+      
+      // Navegar para relatório
+      navigate(`/web-proofs/relatorio/${result.sessionId}`);
+      
+    } catch (error) {
+      console.error('Erro ao finalizar captura:', error);
+      setError('Falha ao finalizar captura');
+      setSession(prev => prev ? { ...prev, status: SESSION_STATES.ERROR } : null);
+    }
+  };
+
+  // Obter timestamp confiável
+  const getTrustedTimestamp = async (): Promise<string> => {
+    try {
+      const response = await fetch('/api/web-proofs/trusted-timestamp');
+      const data = await response.json();
+      return data.timestamp;
+    } catch {
+      return new Date().toISOString();
+    }
+  };
+
+  return (
+    <div className="min-h-screen bg-gray-50 py-8 px-4 sm:px-6 lg:px-8">
+      <div className="max-w-7xl mx-auto">
+        <div className="text-center mb-8">
+          <h1 className="text-3xl font-bold text-gray-900">Captura de Provas Web</h1>
+          <p className="mt-2 text-lg text-gray-600">
+            Coleta forense de evidências digitais em ambiente isolado
+          </p>
+        </div>
+
+        {!session && (
+          <div className="max-w-2xl mx-auto bg-white rounded-lg shadow p-6">
+            <h2 className="text-xl font-semibold mb-4">Inicializar Ambiente Seguro</h2>
+            <p className="text-gray-600 mb-6">
+              O sistema criará um ambiente virtual isolado para garantir a integridade da captura.
+            </p>
+            
+            <button
+              onClick={initializeIsolatedEnvironment}
+              className="w-full bg-blue-600 text-white py-3 px-4 rounded-lg hover:bg-blue-700 transition-colors"
+            >
+              Inicializar Ambiente Isolado
+            </button>
+            
+            {progress > 0 && (
+              <div className="mt-4">
+                <div className="w-full bg-gray-200 rounded-full h-2">
+                  <div 
+                    className="bg-blue-600 h-2 rounded-full transition-all duration-300" 
+                    style={{ width: `${progress}%` }}
+                  />
+                </div>
+                <p className="text-sm text-gray-500 mt-2">Preparando ambiente... {progress}%</p>
+              </div>
+            )}
+          </div>
+        )}
+
+        {session && session.status === SESSION_STATES.ACTIVE && (
+          <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
+            <div className="lg:col-span-1 bg-white rounded-lg shadow p-6">
+              <h2 className="text-xl font-semibold mb-4">Configuração da Captura</h2>
+              
+              <div className="space-y-4">
+                <div>
+                  <label className="block text-sm font-medium text-gray-700 mb-2">
+                    URL de Destino
+                  </label>
+                  <input
+                    type="url"
+                    value={targetUrl}
+                    onChange={(e) => setTargetUrl(e.target.value)}
+                    placeholder="https://exemplo.com"
+                    className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500"
+                  />
+                </div>
+                
+                <div>
+                  <label className="block text-sm font-medium text-gray-700 mb-2">
+                    Descrição da Prova
+                  </label>
+                  <textarea
+                    value={captureDescription}
+                    onChange={(e) => setCaptureDescription(e.target.value)}
+                    rows={3}
+                    placeholder="Descreva o que será capturado..."
+                    className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500"
+                  />
+                </div>
+                
+                <button
+                  onClick={startCapture}
+                  disabled={!targetUrl.trim() || isRecording}
+                  className="w-full bg-green-600 text-white py-2 px-4 rounded-md hover:bg-green-700 disabled:bg-gray-400 transition-colors"
+                >
+                  {isRecording ? 'Capturando...' : 'Iniciar Captura'}
+                </button>
+              </div>
+            </div>
+            
+            <div className="lg:col-span-2 bg-white rounded-lg shadow p-6">
+              <h2 className="text-xl font-semibold mb-4">Ambiente Virtual Isolado</h2>
+              
+              <div className="border-2 border-gray-200 rounded-lg h-96 bg-gray-50 flex items-center justify-center">
+                {isRecording && targetUrl ? (
+                  <iframe
+                    ref={iframeRef}
+                    src={targetUrl}
+                    className="w-full h-full rounded"
+                    title="Captura Web"
+                    sandbox="allow-scripts allow-same-origin"
+                  />
+                ) : (
+                  <p className="text-gray-500">Ambiente aguardando URL de destino</p>
+                )}
+              </div>
+              
+              <div className="mt-4 flex gap-2">
+                <button
+                  onClick={captureScreenshot}
+                  disabled={!isRecording}
+                  className="bg-blue-600 text-white px-4 py-2 rounded hover:bg-blue-700 disabled:bg-gray-400 transition-colors"
+                >
+                  Capturar Screenshot
+                </button>
+                
+                <button
+                  onClick={finalizeCaptureSession}
+                  disabled={!isRecording}
+                  className="bg-red-600 text-white px-4 py-2 rounded hover:bg-red-700 disabled:bg-gray-400 transition-colors"
+                >
+                  Finalizar Captura
+                </button>
+              </div>
+              
+              {screenshots.length > 0 && (
+                <div className="mt-4">
+                  <p className="text-sm text-gray-600">
+                    Screenshots capturados: {screenshots.length}
+                  </p>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+
+        {session && session.status === SESSION_STATES.RECORDING && (
+          <div className="fixed top-4 right-4 bg-red-600 text-white px-4 py-2 rounded-lg shadow-lg">
+            <div className="flex items-center">
+              <div className="w-3 h-3 bg-white rounded-full mr-2 animate-pulse"></div>
+              GRAVANDO
+            </div>
+          </div>
+        )}
+
+        {error && (
+          <div className="max-w-2xl mx-auto mt-6 bg-red-50 border border-red-200 rounded-lg p-4">
+            <div className="flex">
+              <div className="text-red-600">
+                <svg className="w-5 h-5" fill="currentColor" viewBox="0 0 20 20">
+                  <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clipRule="evenodd" />
+                </svg>
+              </div>
+              <div className="ml-3">
+                <h3 className="text-sm font-medium text-red-800">Erro na Captura</h3>
+                <div className="mt-2 text-sm text-red-700">
+                  <p>{error}</p>
+                </div>
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+export default WebProofCapture;

src/components/provas/WebProofList.tsx

@@ -0,0 +1,227 @@
+import React, { useState, useEffect } from 'react';
+import { Link } from 'react-router-dom';
+import { format } from 'date-fns';
+import { ptBR } from 'date-fns/locale';
+
+interface WebProofSession {
+  sessionId: string;
+  targetUrl: string;
+  description: string;
+  status: string;
+  createdAt: string;
+  processedAt?: string;
+  error?: string;
+}
+
+export function WebProofList() {
+  const [sessions, setSessions] = useState<WebProofSession[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    const fetchSessions = async () => {
+      try {
+        const response = await fetch('/api/web-proofs/admin/sessions?limit=50');
+        
+        if (!response.ok) {
+          throw new Error('Erro ao carregar sessões');
+        }
+        
+        const data = await response.json();
+        setSessions(data.sessions || data); // Compatibilidade com formato paginado
+        
+      } catch (error) {
+        console.error('Erro ao buscar sessões:', error);
+        setError('Erro ao carregar lista de sessões');
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchSessions();
+  }, []);
+
+  const formatDate = (dateString: string) => {
+    try {
+      return format(new Date(dateString), 'dd/MM/yyyy HH:mm', { locale: ptBR });
+    } catch {
+      return 'Data inválida';
+    }
+  };
+
+  const getStatusColor = (status: string) => {
+    switch (status) {
+      case 'CONCLUIDO':
+        return 'bg-green-100 text-green-800';
+      case 'PROCESSANDO':
+        return 'bg-blue-100 text-blue-800';
+      case 'ERRO':
+        return 'bg-red-100 text-red-800';
+      default:
+        return 'bg-gray-100 text-gray-800';
+    }
+  };
+
+  if (loading) {
+    return (
+      <div className="p-6">
+        <div className="bg-white rounded-lg shadow p-6">
+          <div className="animate-pulse">
+            <div className="h-6 bg-gray-300 rounded w-1/4 mb-4"></div>
+            <div className="space-y-3">
+              <div className="h-4 bg-gray-300 rounded"></div>
+              <div className="h-4 bg-gray-300 rounded w-5/6"></div>
+              <div className="h-4 bg-gray-300 rounded w-4/6"></div>
+            </div>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <div className="p-6">
+        <div className="bg-white rounded-lg shadow p-6 text-center">
+          <div className="text-red-600 mb-4">{error}</div>
+          <button 
+            onClick={() => window.location.reload()}
+            className="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700"
+          >
+            Tentar Novamente
+          </button>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="p-6">
+      <div className="bg-white rounded-lg shadow">
+        <div className="px-6 py-4 border-b border-gray-200">
+          <div className="flex justify-between items-center">
+            <div>
+              <h1 className="text-xl font-semibold text-gray-900">Capturas Web Forenses</h1>
+              <p className="mt-1 text-sm text-gray-600">
+                Lista de todas as sessões de captura web processadas
+              </p>
+            </div>
+            <Link
+              to="/web-proofs/capture"
+              className="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700"
+            >
+              Nova Captura
+            </Link>
+          </div>
+        </div>
+
+        <div className="overflow-x-auto">
+          <table className="min-w-full divide-y divide-gray-200">
+            <thead className="bg-gray-50">
+              <tr>
+                <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                  URL / Descrição
+                </th>
+                <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                  Status
+                </th>
+                <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                  Data
+                </th>
+                <th className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                  Ações
+                </th>
+              </tr>
+            </thead>
+            <tbody className="bg-white divide-y divide-gray-200">
+              {sessions.map((session) => (
+                <tr key={session.sessionId} className="hover:bg-gray-50">
+                  <td className="px-6 py-4">
+                    <div>
+                      <div className="text-sm font-medium text-gray-900 truncate max-w-xs">
+                        {session.targetUrl}
+                      </div>
+                      {session.description && (
+                        <div className="text-sm text-gray-500 truncate max-w-xs">
+                          {session.description}
+                        </div>
+                      )}
+                      <div className="text-xs text-gray-400 font-mono">
+                        {session.sessionId}
+                      </div>
+                    </div>
+                  </td>
+                  <td className="px-6 py-4">
+                    <span className={`inline-flex px-2 py-1 text-xs font-semibold rounded-full ${getStatusColor(session.status)}`}>
+                      {session.status}
+                    </span>
+                    {session.error && (
+                      <div className="text-xs text-red-600 mt-1 max-w-xs truncate" title={session.error}>
+                        {session.error}
+                      </div>
+                    )}
+                  </td>
+                  <td className="px-6 py-4 text-sm text-gray-500">
+                    <div>Criado: {formatDate(session.createdAt)}</div>
+                    {session.processedAt && (
+                      <div>Processado: {formatDate(session.processedAt)}</div>
+                    )}
+                  </td>
+                  <td className="px-6 py-4 text-sm font-medium space-x-2">
+                    <Link
+                      to={`/web-proofs/relatorio/${session.sessionId}`}
+                      className="text-blue-600 hover:text-blue-900"
+                    >
+                      Ver Relatório
+                    </Link>
+                    
+                    {session.status === 'CONCLUIDO' && (
+                      <>
+                        <span className="text-gray-300">|</span>
+                        <a
+                          href={`/api/web-proofs/relatorio/${session.sessionId}`}
+                          target="_blank"
+                          rel="noopener noreferrer"
+                          className="text-green-600 hover:text-green-900"
+                        >
+                          Download PDF
+                        </a>
+                        <span className="text-gray-300">|</span>
+                        <a
+                          href={`/api/web-proofs/verify/${session.sessionId}`}
+                          target="_blank"
+                          rel="noopener noreferrer"
+                          className="text-purple-600 hover:text-purple-900"
+                        >
+                          Verificar
+                        </a>
+                      </>
+                    )}
+                  </td>
+                </tr>
+              ))}
+            </tbody>
+          </table>
+          
+          {sessions.length === 0 && (
+            <div className="text-center py-12">
+              <svg className="w-12 h-12 text-gray-400 mx-auto mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+              </svg>
+              <h3 className="text-lg font-medium text-gray-900 mb-1">Nenhuma captura encontrada</h3>
+              <p className="text-gray-500 mb-4">Comece criando sua primeira captura web forense</p>
+              <Link
+                to="/web-proofs/capture"
+                className="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md text-white bg-blue-600 hover:bg-blue-700"
+              >
+                Criar Primeira Captura
+              </Link>
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export default WebProofList;

src/components/provas/WebProofReport.tsx

@@ -0,0 +1,348 @@
+import React, { useState, useEffect } from 'react';
+import { useParams, Link } from 'react-router-dom';
+import { format } from 'date-fns';
+import { ptBR } from 'date-fns/locale';
+import { toast } from 'react-toastify';
+
+interface WebProofSession {
+  sessionId: string;
+  targetUrl: string;
+  description: string;
+  status: string;
+  metadata: any;
+  environment: any;
+  sessionHash: string;
+  contentHash: string;
+  pageHash: string;
+  trustedTimestamp: string;
+  networkData: any;
+  screenshots: string[];
+  createdAt: string;
+  processedAt: string;
+}
+
+interface VerificationResult {
+  verified: boolean;
+  sessionValid: boolean;
+  contentValid: boolean;
+  timestampValid: boolean;
+  details: any;
+}
+
+export function WebProofReport() {
+  const { sessionId } = useParams<{ sessionId: string }>();
+  const [session, setSession] = useState<WebProofSession | null>(null);
+  const [verification, setVerification] = useState<VerificationResult | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [verifying, setVerifying] = useState(false);
+
+  useEffect(() => {
+    const fetchSessionData = async () => {
+      try {
+        setLoading(true);
+        
+        const response = await fetch(`/api/web-proofs/sessions/${sessionId}/status`);
+        
+        if (!response.ok) {
+          throw new Error('Sessão não encontrada');
+        }
+        
+        const data = await response.json();
+        setSession(data);
+        
+        // Verificar automaticamente se a sessão estiver completa
+        if (data.status === 'CONCLUIDO') {
+          await verifySession(data.sessionId);
+        }
+        
+      } catch (error) {
+        console.error('Erro ao buscar dados da sessão:', error);
+        setError('Não foi possível carregar os dados da sessão');
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    if (sessionId) {
+      fetchSessionData();
+    }
+  }, [sessionId]);
+
+  const verifySession = async (sessionIdToVerify: string) => {
+    try {
+      setVerifying(true);
+      
+      const response = await fetch(`/api/web-proofs/verify/${sessionIdToVerify}`);
+      const result = await response.json();
+      
+      setVerification(result);
+      
+      if (result.verified) {
+        toast.success('Sessão verificada com sucesso');
+      } else {
+        toast.warning('Verificação da sessão inconclusiva');
+      }
+      
+    } catch (error) {
+      console.error('Erro na verificação:', error);
+      toast.error('Erro ao verificar sessão');
+    } finally {
+      setVerifying(false);
+    }
+  };
+
+  const formatDate = (dateString: string) => {
+    try {
+      return format(new Date(dateString), 'dd/MM/yyyy HH:mm:ss', { locale: ptBR });
+    } catch {
+      return 'Data inválida';
+    }
+  };
+
+  const downloadReport = () => {
+    if (session?.sessionId) {
+      window.open(`/api/web-proofs/relatorio/${session.sessionId}`, '_blank');
+    }
+  };
+
+  if (loading) {
+    return (
+      <div className="min-h-screen bg-gray-50 py-12 px-4 sm:px-6 lg:px-8">
+        <div className="max-w-4xl mx-auto">
+          <div className="bg-white rounded-lg shadow p-6">
+            <div className="animate-pulse">
+              <div className="h-6 bg-gray-300 rounded w-3/4 mb-4"></div>
+              <div className="h-4 bg-gray-300 rounded w-1/2 mb-2"></div>
+              <div className="h-4 bg-gray-300 rounded w-2/3"></div>
+            </div>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  if (error || !session) {
+    return (
+      <div className="min-h-screen bg-gray-50 py-12 px-4 sm:px-6 lg:px-8">
+        <div className="max-w-4xl mx-auto">
+          <div className="bg-white rounded-lg shadow p-6 text-center">
+            <svg className="w-16 h-16 text-red-500 mx-auto mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
+            </svg>
+            <h2 className="text-2xl font-bold text-red-600 mb-4">Relatório não encontrado</h2>
+            <p className="text-gray-600 mb-6">{error}</p>
+            <Link 
+              to="/web-proofs" 
+              className="inline-flex items-center px-4 py-2 bg-blue-600 text-white font-medium rounded-md hover:bg-blue-700"
+            >
+              Voltar às Capturas Web
+            </Link>
+          </div>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="min-h-screen bg-gray-50 py-12 px-4 sm:px-6 lg:px-8">
+      <div className="max-w-6xl mx-auto">
+        <div className="bg-white rounded-lg shadow overflow-hidden">
+          {/* Cabeçalho */}
+          <div className="bg-blue-700 text-white px-6 py-4">
+            <h1 className="text-2xl font-bold">Relatório de Captura Web Forense</h1>
+            <p className="text-blue-100 mt-1">Sessão: {session.sessionId}</p>
+          </div>
+
+          {/* Status da Verificação */}
+          <div className="border-b border-gray-200 p-6">
+            <div className="flex items-center justify-between">
+              <div>
+                <h2 className="text-lg font-semibold text-gray-900">Status da Verificação</h2>
+                {verification ? (
+                  <div className={`mt-2 inline-flex items-center px-3 py-1 rounded-full text-sm font-medium ${
+                    verification.verified 
+                      ? 'bg-green-100 text-green-800' 
+                      : 'bg-yellow-100 text-yellow-800'
+                  }`}>
+                    {verification.verified ? '✓ Verificado' : '⚠ Verificação Inconclusiva'}
+                  </div>
+                ) : (
+                  <div className="mt-2 inline-flex items-center px-3 py-1 rounded-full text-sm font-medium bg-gray-100 text-gray-800">
+                    Aguardando verificação
+                  </div>
+                )}
+              </div>
+              
+              <div className="flex gap-3">
+                <button
+                  onClick={() => verifySession(session.sessionId)}
+                  disabled={verifying}
+                  className="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700 disabled:bg-gray-400"
+                >
+                  {verifying ? 'Verificando...' : 'Verificar Novamente'}
+                </button>
+                
+                <button
+                  onClick={downloadReport}
+                  className="px-4 py-2 bg-green-600 text-white rounded hover:bg-green-700"
+                >
+                  Baixar PDF
+                </button>
+              </div>
+            </div>
+          </div>
+
+          {/* Informações da Sessão */}
+          <div className="p-6 grid grid-cols-1 lg:grid-cols-2 gap-6">
+            <div>
+              <h3 className="text-lg font-semibold mb-4">Informações da Captura</h3>
+              <div className="space-y-3">
+                <DetailItem label="URL Capturada" value={session.targetUrl} />
+                <DetailItem label="Descrição" value={session.description || 'Não especificada'} />
+                <DetailItem label="Status" value={session.status} />
+                <DetailItem label="Data de Criação" value={formatDate(session.createdAt)} />
+                {session.processedAt && (
+                  <DetailItem label="Data de Processamento" value={formatDate(session.processedAt)} />
+                )}
+              </div>
+            </div>
+
+            <div>
+              <h3 className="text-lg font-semibold mb-4">Ambiente de Captura</h3>
+              <div className="space-y-3">
+                <DetailItem 
+                  label="User Agent" 
+                  value={session.environment?.userAgent || 'Não disponível'} 
+                />
+                <DetailItem 
+                  label="Viewport" 
+                  value={session.environment?.viewportSize ? 
+                    `${session.environment.viewportSize.width}x${session.environment.viewportSize.height}` : 
+                    'Não disponível'
+                  } 
+                />
+                <DetailItem 
+                  label="Endereço IP" 
+                  value={session.environment?.ipAddress || 'Não disponível'} 
+                />
+                <DetailItem 
+                  label="Timestamp do Ambiente" 
+                  value={session.environment?.timestamp ? formatDate(session.environment.timestamp) : 'Não disponível'} 
+                />
+              </div>
+            </div>
+          </div>
+
+          {/* Hashes de Integridade */}
+          <div className="border-t border-gray-200 p-6">
+            <h3 className="text-lg font-semibold mb-4">Hashes de Integridade</h3>
+            <div className="bg-gray-50 rounded-lg p-4 space-y-3 font-mono text-sm">
+              <DetailItem label="Hash da Sessão (SHA-256)" value={session.sessionHash} />
+              <DetailItem label="Hash do Conteúdo (SHA-256)" value={session.contentHash} />
+              <DetailItem label="Hash da Página (SHA-512)" value={session.pageHash} />
+            </div>
+          </div>
+
+          {/* Timestamp Confiável */}
+          {session.trustedTimestamp && (
+            <div className="border-t border-gray-200 p-6">
+              <h3 className="text-lg font-semibold mb-4">Timestamp Confiável</h3>
+              <div className="bg-green-50 rounded-lg p-4">
+                <DetailItem 
+                  label="Timestamp Certificado" 
+                  value={formatDate(session.trustedTimestamp)} 
+                />
+                <p className="text-sm text-green-700 mt-2">
+                  Este timestamp foi emitido por uma autoridade certificadora confiável
+                </p>
+              </div>
+            </div>
+          )}
+
+          {/* Dados de Rede */}
+          {session.networkData && (
+            <div className="border-t border-gray-200 p-6">
+              <h3 className="text-lg font-semibold mb-4">Informações de Rede</h3>
+              <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+                <DetailItem label="Domínio" value={session.networkData.domain} />
+                <DetailItem label="Protocolo" value={session.networkData.protocol} />
+                <DetailItem label="Porta" value={session.networkData.port} />
+                <DetailItem label="IP Resolvido" value={session.networkData.resolvedIP} />
+              </div>
+            </div>
+          )}
+
+          {/* Screenshots */}
+          {session.screenshots && session.screenshots.length > 0 && (
+            <div className="border-t border-gray-200 p-6">
+              <h3 className="text-lg font-semibold mb-4">Capturas Realizadas</h3>
+              <div className="bg-blue-50 rounded-lg p-4">
+                <p className="text-blue-800">
+                  <span className="font-semibold">{session.screenshots.length}</span> screenshot(s) capturado(s) durante a sessão
+                </p>
+                <p className="text-sm text-blue-600 mt-1">
+                  As capturas estão incluídas no relatório PDF completo
+                </p>
+              </div>
+            </div>
+          )}
+
+          {/* Detalhes da Verificação */}
+          {verification && (
+            <div className="border-t border-gray-200 p-6">
+              <h3 className="text-lg font-semibold mb-4">Detalhes da Verificação</h3>
+              <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
+                <div className={`p-4 rounded-lg ${verification.sessionValid ? 'bg-green-50' : 'bg-red-50'}`}>
+                  <div className={`font-medium ${verification.sessionValid ? 'text-green-800' : 'text-red-800'}`}>
+                    Hash da Sessão
+                  </div>
+                  <div className={`text-sm ${verification.sessionValid ? 'text-green-600' : 'text-red-600'}`}>
+                    {verification.sessionValid ? 'Válido' : 'Inválido'}
+                  </div>
+                </div>
+                
+                <div className={`p-4 rounded-lg ${verification.contentValid ? 'bg-green-50' : 'bg-red-50'}`}>
+                  <div className={`font-medium ${verification.contentValid ? 'text-green-800' : 'text-red-800'}`}>
+                    Hash do Conteúdo
+                  </div>
+                  <div className={`text-sm ${verification.contentValid ? 'text-green-600' : 'text-red-600'}`}>
+                    {verification.contentValid ? 'Válido' : 'Inválido'}
+                  </div>
+                </div>
+                
+                <div className={`p-4 rounded-lg ${verification.timestampValid ? 'bg-green-50' : 'bg-yellow-50'}`}>
+                  <div className={`font-medium ${verification.timestampValid ? 'text-green-800' : 'text-yellow-800'}`}>
+                    Timestamp
+                  </div>
+                  <div className={`text-sm ${verification.timestampValid ? 'text-green-600' : 'text-yellow-600'}`}>
+                    {verification.timestampValid ? 'Válido' : 'Não verificado'}
+                  </div>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* Rodapé */}
+          <div className="bg-gray-50 px-6 py-4 text-center border-t border-gray-200">
+            <p className="text-sm text-gray-500">
+              Relatório gerado pelo sistema AdvX Web Proof Capture - 
+              Preservando a integridade e autenticidade de evidências digitais
+            </p>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function DetailItem({ label, value }: { label: string; value: string }) {
+  return (
+    <div>
+      <dt className="text-sm font-medium text-gray-500">{label}</dt>
+      <dd className="mt-1 text-sm text-gray-900 break-words">{value}</dd>
+    </div>
+  );
+}
+
+export default WebProofReport;

src/components/tarefas/TarefaModal.tsx

@@ -168,6 +168,18 @@ export const TarefaModal: React.FC<TarefaModalProps> = ({ isOpen, onClose, taref
                         <option value="URGENTE">Urgente</option>
                       </select>
 
+                      {/* Campo para alterar o status da tarefa conforme banco de dados */}
+                      <select
+                        {...register('status')}
+                        className="w-full p-2 rounded-lg border border-gray-300 dark:border-gray-600 bg-white dark:bg-gray-700 text-gray-900 dark:text-white"
+                      >
+                        <option value="PENDENTE">Pendente</option>
+                        {/* Exibe 'Em andamento' sem underline */}
+                        <option value="EM_ANDAMENTO">Em andamento</option>
+                        <option value="CONCLUIDA">Concluída</option>
+                        <option value="CANCELADA">Cancelada</option>
+                      </select>
+
                       <select
                         {...register('responsavelId')}
                         className="w-full p-2 rounded-lg border border-gray-300 dark:border-gray-600 bg-white dark:bg-gray-700 text-gray-900 dark:text-white"

src/hooks/useAudiencias.ts

@@ -1,5 +1,6 @@
-import { useMutation, useQueryClient } from "react-query";
+import { useMutation, useQuery, useQueryClient } from "react-query";
 import axios from "axios";
+import api from "../services/api";
 
 export function useAudiencias(processoId: string) {
   const queryClient = useQueryClient();
@@ -49,9 +50,15 @@ export function useAudiencias(processoId: string) {
     },
   );
 
+  const { data: audiencias } = useQuery("audiencias", async () => {
+    const { data } = await api.get("/audiencias");
+    return data;
+  });
+
   return {
     addAudiencia: addAudiencia.mutateAsync,
     updateAudiencia: updateAudiencia.mutateAsync,
     deleteAudiencia: deleteAudiencia.mutateAsync,
+    audiencias,
   };
 }

src/hooks/useBenchmarking.ts

@@ -0,0 +1,44 @@
+import { useQuery } from 'react-query';
+import { Processo } from '../types/entities';
+import api from '../services/api';
+
+interface Benchmarking {
+  totalProcessos: number;
+  ativos: number;
+  procedentes: number;
+  improcedentesOuSemMerito: number;
+  ajuizados7dias: number;
+}
+
+// Hook para calcular benchmarking do escritório
+export function useBenchmarking() {
+  return useQuery<Benchmarking>('benchmarking', async () => {
+    // Buscar todos os processos
+    const res = await api.get<Processo[]>('/processos');
+    const processos = res.data;
+
+    // Total de processos
+    const totalProcessos = processos.length;
+    // Total de processos ativos
+    const ativos = processos.filter(p => p.statusAtividade === 'ATIVO').length;
+    // Julgados procedentes
+    const procedentes = processos.filter(p => p.resultado === 'PROCEDENTE').length;
+    // Julgados improcedentes ou sem análise de mérito
+    const improcedentesOuSemMerito = processos.filter(p => p.resultado === 'IMPROCEDENTE' || p.resultado === 'SEM_ANALISE_MERITO').length;
+    // Processos ajuizados nos últimos 7 dias
+    const seteDiasAtras = new Date();
+    seteDiasAtras.setDate(seteDiasAtras.getDate() - 7);
+    const ajuizados7dias = processos.filter(p => {
+      const criacao = p.dataCriacao ? new Date(p.dataCriacao) : null;
+      return criacao && criacao >= seteDiasAtras;
+    }).length;
+
+    return {
+      totalProcessos,
+      ativos,
+      procedentes,
+      improcedentesOuSemMerito,
+      ajuizados7dias,
+    };
+  });
+}

src/hooks/useCalendarioAtendimentos.ts

@@ -0,0 +1,41 @@
+import { useQuery } from 'react-query';
+import api from '../services/api';
+
+export interface EventoCalendario {
+  id: string;
+  data: string;
+  tipo: string;
+  descricao: string;
+}
+
+// Hook para buscar atendimentos e audiências do calendário
+export function useCalendarioAtendimentos() {
+  return useQuery<EventoCalendario[]>('calendarioAtendimentos', async () => {
+    // Buscar atendimentos
+    const atendimentosRes = await api.get('/atendimentos');
+    const atendimentos = atendimentosRes.data.map((a: any) => ({
+      id: a.id,
+      data: a.dataAtendimento?.slice(0, 10),
+      tipo: 'Atendimento',
+      descricao: a.titulo || 'Atendimento',
+    }));
+
+    // Buscar audiências, tratar erro 404
+    let audiencias: EventoCalendario[] = [];
+    try {
+      const audienciasRes = await api.get('/audiencias');
+      audiencias = audienciasRes.data.map((a: any) => ({
+        id: a.id,
+        data: a.data?.slice(0, 10),
+        tipo: 'Audiência',
+        descricao: a.tipo || 'Audiência',
+      }));
+    } catch (error: any) {
+      if (error?.response?.status !== 404) throw error;
+      // Se for 404, ignora audiências
+    }
+
+    // Junta todos eventos
+    return [...atendimentos, ...audiencias];
+  });
+}

src/hooks/useFinanceiroPainel.ts

@@ -0,0 +1,31 @@
+import { useQuery } from 'react-query';
+import api from '../services/api';
+
+export interface FinanceiroResumo {
+  honorariosAReceber: number;
+  honorariosRecebidosMes: number;
+  custasAPagar: number;
+  custasPagasMes: number;
+  detalhesHonorarios: any[];
+  detalhesCustas: any[];
+}
+
+// Hook para buscar dados financeiros do painel diretamente do backend
+export function useFinanceiroPainel(mes: number, ano: number) {
+  return useQuery<FinanceiroResumo>(['financeiroPainel', mes, ano], async () => {
+    try {
+      const res = await api.get(`/financeiro-painel?mes=${mes}&ano=${ano}`);
+      return res.data;
+    } catch (error: any) {
+      // Se der erro, retorna tudo zerado
+      return {
+        honorariosAReceber: 0,
+        honorariosRecebidosMes: 0,
+        custasAPagar: 0,
+        custasPagasMes: 0,
+        detalhesHonorarios: [],
+        detalhesCustas: [],
+      };
+    }
+  });
+}

src/server/app.ts

@@ -1,40 +1,41 @@
 import express from 'express';
-import bodyParser from 'body-parser';
 import cors from 'cors';
-import dotenv from 'dotenv';
+import { json, urlencoded } from 'body-parser';
+import { createServer } from 'http';
+import { Server } from 'socket.io';
 import path from 'path';
-import { PrismaClient } from '@prisma/client';
+import { fileURLToPath } from 'url';
-import provasRoutes from './routes/provas';
-import calculosJudiciaisRoutes from './routes/calculosJudiciais';
-import indicesMonetariosRoutes from './routes/indicesMonetarios';
-import pensaoAlimenticiaRoutes from './routes/pensaoAlimenticia';
 
-dotenv.config();
+import provasRoutes from './routes/provas';
+import webProofsRoutes from './routes/webProofs';
 
 const app = express();
-const prisma = new PrismaClient();
+const httpServer = createServer(app);
-
+const io = new Server(httpServer);
-// Configurar para confiar em proxies, permitindo a leitura de X-Forwarded-For
-// Isso é necessário se sua aplicação estiver atrás de um balanceador de carga, 
-// proxy reverso ou Cloudflare
-app.set('trust proxy', true);
 
+// Middleware
 app.use(cors());
-app.use(bodyParser.json());
+app.use(json());
-app.use(bodyParser.urlencoded({ extended: true }));
+app.use(urlencoded({ extended: true }));
-
-app.use('/api/provas', provasRoutes);
-app.use('/api/calculos', calculosJudiciaisRoutes);
-app.use('/api/indices', indicesMonetariosRoutes);
-app.use('/api/pensao-alimenticia', pensaoAlimenticiaRoutes);
 
+// Definir diretório público para arquivos estáticos
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 app.use(express.static(path.join(__dirname, 'public')));
-app.set('trust proxy', true); // Importante para obter o IP real em ambientes com proxy
 
-const PORT = process.env.PORT || 5000;
+// Rotas
+app.use('/api/provas', provasRoutes);
+app.use('/api/web-proofs', webProofsRoutes);
 
-app.listen(PORT, () => {
+// Rota padrão
-  console.log(`Server is running on port ${PORT}`);
+app.get('/', (req, res) => {
+  res.send('API do sistema de validação de provas digitais');
 });
 
-export { app, prisma };
+// Inicializar servidor
+const PORT = process.env.PORT || 5000;
+httpServer.listen(PORT, () => {
+  console.log(`Servidor rodando na porta ${PORT}`);
+});
+
+export default app;

src/server/controllers/audienciasController.ts

@@ -0,0 +1,20 @@
+import { Request, Response } from "express";
+import { prisma } from "../prismaClient";
+
+// Função para listar todas as audiências
+export async function getAudiencias(req: Request, res: Response) {
+  try {
+    const audiencias = await prisma.audiencia.findMany({
+      orderBy: { data: "asc" },
+      include: {
+        processo: {
+          select: { numero: true, nomeContraparte: true }
+        }
+      }
+    });
+    res.json(audiencias);
+  } catch (error) {
+    console.error("Erro ao buscar audiências:", error);
+    res.status(500).json({ error: "Erro ao buscar audiências" });
+  }
+}

src/server/index.ts

@@ -24,7 +24,10 @@ import processosAdministrativosRoutes from './routes/processosAdministrativos';
 import provasRouter from './routes/provas';
 import calculosJudiciaisRoutes from './routes/calculosJudiciais';
 import indicesMonetariosRoutes from './routes/indicesMonetarios';
-import pensaoAlimenticiaRoutes from './routes/pensaoAlimenticia';
+import pensaoAlimenticiaRouter from './routes/pensaoAlimenticia'; // Importar router de pensão alimentícia
+import financeiroPainelRoutes from './routes/financeiroPainel'; // Importar rotas do financeiro painel
+import audienciasRoutes from './routes/audiencias'; // Importar rotas de audiências
+
 
 const app = express();
 const port = process.env.PORT || 5000;
@@ -47,7 +50,8 @@ app.use((req, res, next) => {
   next();
 });
 
-app.use(express.json());
+app.use(express.json({ limit: '20mb' }));
+app.use(express.urlencoded({ extended: true, limit: '20mb' }));
 
 const clienteRepository = new ClienteRepository();
 const processoRepository = new ProcessoRepository();
@@ -1475,4 +1479,6 @@ app.use('/api/documentos-modelos', documentosModelosRouter);
 app.use('/api/processos-administrativos', processosAdministrativosRoutes);
 app.use('/api/calculos', calculosJudiciaisRoutes);
 app.use('/api/indices', indicesMonetariosRoutes);
-app.use('/api/pensao-alimenticia', pensaoAlimenticiaRoutes);
+app.use('/api/pensao-alimenticia', pensaoAlimenticiaRouter);
+app.use('/api/financeiro-painel', financeiroPainelRoutes); // Adicionar uso das rotas do financeiro painel
+app.use('/api/audiencias', audienciasRoutes); // Adicionar uso das rotas de audiências

src/server/routes/audiencias.ts

@@ -0,0 +1,9 @@
+import { Router } from "express";
+import { getAudiencias } from "../controllers/audienciasController";
+
+const router = Router();
+
+// GET /api/audiencias - Lista todas as audiências
+router.get("/", getAudiencias);
+
+export default router;

src/server/routes/calculosJudiciais.ts

@@ -83,11 +83,9 @@ router.get('/:id', async (req, res) => {
   try {
     const { id } = req.params;
     const calculo = await calculoService.buscarCalculo(id);
-    
     if (!calculo) {
       return res.status(404).json({ error: 'Cálculo não encontrado' });
     }
-    
     res.json(calculo);
   } catch (error) {
     console.error('Erro ao buscar cálculo:', error);

src/server/routes/financeiroPainel.ts

@@ -0,0 +1,99 @@
+import express from 'express';
+import { prisma } from '../prismaClient';
+
+const router = express.Router();
+
+// GET /api/financeiro-painel?mes=6&ano=2024
+router.get('/', async (req, res) => {
+  try {
+    const mes = parseInt(req.query.mes as string) || (new Date().getMonth() + 1);
+    const ano = parseInt(req.query.ano as string) || (new Date().getFullYear());
+    if (isNaN(mes) || isNaN(ano)) {
+      return res.status(400).json({ error: 'Parâmetros de mês e ano inválidos.' });
+    }
+    // Datas para filtro
+    const dataInicio = new Date(ano, mes - 1, 1);
+    const dataFim = new Date(ano, mes, 1);
+
+    // Honorários a receber: parcelas pendentes ou vencidas
+    const honorariosAReceber = await prisma.parcelaHonorario.aggregate({
+      _sum: { valor: true },
+      where: {
+        OR: [{ status: 'PENDENTE' }, { status: 'VENCIDO' }],
+      },
+    });
+
+    // Honorários recebidos no mês
+    const honorariosRecebidosMes = await prisma.parcelaHonorario.aggregate({
+      _sum: { valorPago: true },
+      where: {
+        status: 'PAGO',
+        dataPagamento: {
+          gte: dataInicio,
+          lt: dataFim,
+        },
+      },
+    });
+
+    // Detalhes das parcelas recebidas no mês
+    const detalhesHonorarios = await prisma.parcelaHonorario.findMany({
+      where: {
+        status: 'PAGO',
+        dataPagamento: {
+          gte: dataInicio,
+          lt: dataFim,
+        },
+      },
+      include: { honorario: true },
+      orderBy: { dataPagamento: 'desc' },
+      take: 10,
+    });
+
+    // Custas a pagar
+    const custasAPagar = await prisma.custaProcessual.aggregate({
+      _sum: { valor: true },
+      where: {
+        OR: [{ status: 'PENDENTE' }, { status: 'VENCIDO' }],
+      },
+    });
+
+    // Custas pagas no mês
+    const custasPagasMes = await prisma.custaProcessual.aggregate({
+      _sum: { valor: true },
+      where: {
+        status: 'PAGO',
+        dataPagamento: {
+          gte: dataInicio,
+          lt: dataFim,
+        },
+      },
+    });
+
+    // Detalhes das custas pagas no mês
+    const detalhesCustas = await prisma.custaProcessual.findMany({
+      where: {
+        status: 'PAGO',
+        dataPagamento: {
+          gte: dataInicio,
+          lt: dataFim,
+        },
+      },
+      orderBy: { dataPagamento: 'desc' },
+      take: 10,
+    });
+
+    res.json({
+      honorariosAReceber: honorariosAReceber._sum.valor || 0,
+      honorariosRecebidosMes: honorariosRecebidosMes._sum.valorPago || 0,
+      custasAPagar: custasAPagar._sum.valor || 0,
+      custasPagasMes: custasPagasMes._sum.valor || 0,
+      detalhesHonorarios,
+      detalhesCustas,
+    });
+  } catch (error) {
+    console.error('Erro no financeiroPainel:', error);
+    res.status(500).json({ error: 'Erro ao buscar dados financeiros.' });
+  }
+});
+
+export default router;

src/server/routes/pensaoAlimenticia.ts

@@ -55,7 +55,7 @@ router.post('/', async (req, res) => {
 router.get('/:id', async (req, res) => {
   try {
     const { id } = req.params;
-    
+    console.log('[pensaoAlimenticia] Buscando cálculo por ID:', id); // Log para depuração
     const calculo = await prisma.calculoPensaoAlimenticia.findUnique({
       where: { id },
       include: {
@@ -70,15 +70,14 @@ router.get('/:id', async (req, res) => {
         }
       }
     });
-
     if (!calculo) {
+      console.warn('[pensaoAlimenticia] Cálculo não encontrado para ID:', id); // Log para depuração
       return res.status(404).json({ error: 'Cálculo não encontrado' });
     }
-
     res.json(calculo);
   } catch (error) {
-    console.error('Erro ao buscar cálculo:', error);
+    console.error('[pensaoAlimenticia] Erro ao buscar cálculo:', error);
-    res.status(500).json({ error: 'Falha ao buscar cálculo' });
+    res.status(500).json({ error: 'Falha ao buscar cálculo', details: error.message });
   }
 });
 

src/server/routes/webProofs.ts

@@ -0,0 +1,296 @@
+import express from 'express';
+import { WebProofService } from '../services/WebProofService';
+import { prisma } from '../prismaClient';
+import * as path from 'path';
+import * as fs from 'fs';
+
+const router = express.Router();
+const webProofService = new WebProofService();
+
+// Criar nova sessão de captura web
+router.post('/sessions', async (req, res) => {
+  try {
+    const {
+      sessionId,
+      targetUrl,
+      description,
+      metadata,
+      environment,
+      screenshots
+    } = req.body;
+
+    // Validar dados de entrada
+    if (!sessionId || !targetUrl || !metadata || !environment) {
+      return res.status(400).json({ 
+        error: 'Dados obrigatórios não fornecidos',
+        required: ['sessionId', 'targetUrl', 'metadata', 'environment']
+      });
+    }
+
+    // Validar URL
+    try {
+      new URL(targetUrl);
+    } catch {
+      return res.status(400).json({ error: 'URL inválida fornecida' });
+    }
+
+    // Coletar informações de rede do cliente
+    const clientInfo = {
+      ip: req.headers['x-forwarded-for']?.toString().split(',')[0].trim() || 
+          req.ip || 
+          req.socket.remoteAddress || 
+          '127.0.0.1',
+      port: req.socket.remotePort || 0,
+      userAgent: req.headers['user-agent'] || '',
+      timestamp: new Date().toISOString()
+    };
+
+    // Processar sessão de captura
+    const result = await webProofService.processWebCapture({
+      sessionId,
+      targetUrl,
+      description,
+      metadata: {
+        ...metadata,
+        clientInfo,
+        serverInfo: {
+          hostname: require('os').hostname(),
+          nodeVersion: process.version,
+          timestamp: new Date().toISOString()
+        }
+      },
+      environment,
+      screenshots: screenshots || []
+    });
+
+    res.json({
+      success: true,
+      sessionId: result.id,
+      status: result.status,
+      message: 'Sessão de captura processada com sucesso'
+    });
+
+  } catch (error) {
+    console.error('Erro ao processar sessão de captura:', error);
+    res.status(500).json({ 
+      error: 'Falha ao processar sessão de captura',
+      details: error.message 
+    });
+  }
+});
+
+// Obter status da sessão
+router.get('/sessions/:sessionId/status', async (req, res) => {
+  try {
+    const { sessionId } = req.params;
+
+    const session = await prisma.webProofSession.findUnique({
+      where: { sessionId }
+    });
+
+    if (!session) {
+      return res.status(404).json({ error: 'Sessão não encontrada' });
+    }
+
+    res.json({
+      sessionId: session.sessionId,
+      status: session.status,
+      targetUrl: session.targetUrl,
+      description: session.description,
+      createdAt: session.createdAt,
+      updatedAt: session.updatedAt,
+      reportPath: session.reportPath,
+      error: session.error
+    });
+
+  } catch (error) {
+    console.error('Erro ao buscar status da sessão:', error);
+    res.status(500).json({ error: 'Erro ao buscar status da sessão' });
+  }
+});
+
+// Obter timestamp confiável
+router.get('/trusted-timestamp', async (req, res) => {
+  try {
+    // Simular obtenção de timestamp de autoridade certificadora
+    const trustedTimestamp = await webProofService.getTrustedTimestamp();
+    
+    res.json({
+      timestamp: trustedTimestamp.timestamp,
+      authority: trustedTimestamp.authority,
+      signature: trustedTimestamp.signature
+    });
+
+  } catch (error) {
+    console.error('Erro ao obter timestamp confiável:', error);
+    res.status(500).json({ 
+      error: 'Erro ao obter timestamp confiável',
+      fallback: new Date().toISOString()
+    });
+  }
+});
+
+// Obter informações do cliente
+router.get('/client-info', async (req, res) => {
+  try {
+    const clientInfo = {
+      ip: req.headers['x-forwarded-for']?.toString().split(',')[0].trim() || 
+          req.ip || 
+          req.socket.remoteAddress || 
+          '127.0.0.1',
+      port: req.socket.remotePort || 0,
+      userAgent: req.headers['user-agent'] || '',
+      timestamp: new Date().toISOString(),
+      headers: {
+        'x-forwarded-for': req.headers['x-forwarded-for'],
+        'user-agent': req.headers['user-agent'],
+        'accept-language': req.headers['accept-language']
+      }
+    };
+
+    res.json(clientInfo);
+
+  } catch (error) {
+    console.error('Erro ao obter informações do cliente:', error);
+    res.status(500).json({ 
+      error: 'Erro ao obter informações do cliente',
+      fallback: {
+        ip: '127.0.0.1',
+        port: 0,
+        timestamp: new Date().toISOString()
+      }
+    });
+  }
+});
+
+// Verificar autenticidade de captura web com detalhes aprimorados
+router.get('/verify/:sessionId', async (req, res) => {
+  try {
+    const { sessionId } = req.params;
+
+    if (!sessionId || typeof sessionId !== 'string') {
+      return res.status(400).json({ 
+        verified: false,
+        error: 'SessionId inválido'
+      });
+    }
+
+    const verification = await webProofService.verifyWebCapture(sessionId);
+
+    res.json({
+      verified: verification.verified,
+      sessionId,
+      sessionValid: verification.sessionValid || false,
+      contentValid: verification.contentValid || false,
+      timestampValid: verification.timestampValid || false,
+      verificationDetails: verification.details,
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('Erro ao verificar captura:', error);
+    res.status(500).json({ 
+      verified: false,
+      sessionValid: false,
+      contentValid: false,
+      timestampValid: false,
+      error: 'Erro ao verificar captura web'
+    });
+  }
+});
+
+// Baixar relatório com validação aprimorada
+router.get('/relatorio/:sessionId', async (req, res) => {
+  try {
+    const { sessionId } = req.params;
+
+    if (!sessionId || typeof sessionId !== 'string') {
+      return res.status(400).json({ error: 'SessionId inválido' });
+    }
+
+    const session = await prisma.webProofSession.findUnique({
+      where: { sessionId }
+    });
+
+    if (!session) {
+      return res.status(404).json({ error: 'Sessão não encontrada' });
+    }
+
+    if (session.status !== 'CONCLUIDO') {
+      return res.status(400).json({ 
+        error: 'Relatório ainda não está disponível',
+        status: session.status
+      });
+    }
+
+    const reportPath = path.join(process.cwd(), 'storage', 'web-proofs', `${sessionId}_report.pdf`);
+
+    if (!fs.existsSync(reportPath)) {
+      console.error('Arquivo de relatório não encontrado:', reportPath);
+      return res.status(404).json({ error: 'Arquivo do relatório não encontrado' });
+    }
+
+    res.setHeader('Content-Type', 'application/pdf');
+    res.setHeader('Content-Disposition', `inline; filename="captura_web_${sessionId}_relatorio.pdf"`);
+    res.setHeader('Cache-Control', 'public, max-age=3600'); // Cache de 1 hora
+
+    const fileStream = fs.createReadStream(reportPath);
+    fileStream.on('error', (error) => {
+      console.error('Erro ao ler arquivo de relatório:', error);
+      if (!res.headersSent) {
+        res.status(500).json({ error: 'Erro ao ler arquivo de relatório' });
+      }
+    });
+    
+    fileStream.pipe(res);
+
+  } catch (error) {
+    console.error('Erro ao servir relatório:', error);
+    if (!res.headersSent) {
+      res.status(500).json({ error: 'Erro ao gerar relatório' });
+    }
+  }
+});
+
+// Listar sessões com paginação
+router.get('/admin/sessions', async (req, res) => {
+  try {
+    const page = parseInt(req.query.page as string) || 1;
+    const limit = parseInt(req.query.limit as string) || 100;
+    const offset = (page - 1) * limit;
+
+    const [sessions, total] = await Promise.all([
+      prisma.webProofSession.findMany({
+        orderBy: { createdAt: 'desc' },
+        skip: offset,
+        take: limit,
+        select: {
+          sessionId: true,
+          targetUrl: true,
+          description: true,
+          status: true,
+          createdAt: true,
+          processedAt: true,
+          error: true
+        }
+      }),
+      prisma.webProofSession.count()
+    ]);
+
+    res.json({
+      sessions,
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages: Math.ceil(total / limit)
+      }
+    });
+
+  } catch (error) {
+    console.error('Erro ao listar sessões:', error);
+    res.status(500).json({ error: 'Erro ao listar sessões' });
+  }
+});
+
+export default router;

src/server/services/PdfService copy 2.ts

@@ -1,634 +0,0 @@
-import puppeteer from 'puppeteer';
-import { prisma } from '../prismaClient';
-import { PDFDocument, rgb, StandardFonts } from 'pdf-lib';
-import fs from 'fs/promises';
-import path from 'path';
-
-/**
- * Serviço para geração e manipulação de arquivos PDF
- */
-export class PdfService {
-  /**
-   * Cria um documento PDF básico
-   * @returns Documento PDF
-   */
-  async criarDocumento() {
-    return await PDFDocument.create();
-  }
-  
-  /**
-   * Carrega um documento PDF existente
-   * @param pdfBytes - Bytes do PDF
-   * @returns Documento PDF
-   */
-  async carregarDocumento(pdfBytes: Uint8Array) {
-    return await PDFDocument.load(pdfBytes);
-  }
-  
-  /**
-   * Adiciona uma página ao documento
-   * @param doc - Documento PDF
-   * @param tamanho - Tamanho da página (padrão: A4)
-   * @returns Página adicionada
-   */
-  adicionarPagina(doc: any, tamanho = [595.28, 841.89]) {
-    return doc.addPage(tamanho);
-  }
-  
-  /**
-   * Salva o documento como buffer
-   * @param doc - Documento PDF
-   * @returns Buffer do PDF
-   */
-  async salvarComoBuffer(doc: any): Promise<Buffer> {
-    const pdfBytes = await doc.save();
-    return Buffer.from(pdfBytes);
-  }
-  
-  /**
-   * Carrega uma fonte padrão
-   * @param doc - Documento PDF
-   * @param fonte - Nome da fonte padrão
-   * @returns Fonte carregada
-   */
-  async carregarFonte(doc: any, fonte: StandardFonts) {
-    return await doc.embedFont(fonte);
-  }
-  
-  /**
-   * Desenha texto em uma página
-   * @param pagina - Página do PDF
-   * @param texto - Texto a ser desenhado
-   * @param x - Posição X
-   * @param y - Posição Y
-   * @param fonte - Fonte a ser usada
-   * @param tamanho - Tamanho da fonte
-   * @param cor - Cor do texto (padrão: preto)
-   */
-  desenharTexto(
-    pagina: any,
-    texto: string,
-    x: number,
-    y: number,
-    fonte: any,
-    tamanho: number,
-    cor = rgb(0, 0, 0)
-  ) {
-    pagina.drawText(texto, {
-      x,
-      y,
-      font: fonte,
-      size: tamanho,
-      color: cor,
-    });
-  }
-  
-  /**
-   * Cria um cabeçalho para o documento
-   * @param pagina - Página do PDF
-   * @param titulo - Título do cabeçalho
-   * @param fonte - Fonte a ser usada
-   * @param margemSuperior - Margem superior
-   * @param margem - Margem lateral
-   * @returns Posição Y após o cabeçalho
-   */
-  criarCabecalho(
-    pagina: any,
-    titulo: string,
-    fonte: any,
-    margemSuperior: number,
-    margem: number
-  ): number {
-    const yPos = pagina.getHeight() - margemSuperior;
-    
-    this.desenharTexto(
-      pagina,
-      titulo,
-      margem,
-      yPos,
-      fonte,
-      18,
-      rgb(0, 0, 0.7)
-    );
-    
-    // Linha separadora
-    pagina.drawLine({
-      start: { x: margem, y: yPos - 10 },
-      end: { x: pagina.getWidth() - margem, y: yPos - 10 },
-      thickness: 1,
-      color: rgb(0, 0, 0.5),
-    });
-    
-    return yPos - 30; // Retorna a posição Y após o cabeçalho
-  }
-  
-  /**
-   * Cria um rodapé para o documento
-   * @param pagina - Página do PDF
-   * @param texto - Texto do rodapé
-   * @param fonte - Fonte a ser usada
-   * @param margem - Margem
-   */
-  criarRodape(pagina: any, texto: string, fonte: any, margem: number) {
-    const yPos = margem / 2;
-    
-    this.desenharTexto(
-      pagina,
-      texto,
-      margem,
-      yPos,
-      fonte,
-      8,
-      rgb(0.5, 0.5, 0.5)
-    );
-  }
-
-  private async getConfiguracao() {
-    try {
-      // Buscar configuração ou usar valores padrão
-      const config = await prisma.configuracaoDocumento.findFirst({
-        orderBy: { criadoEm: 'desc' },
-        select: {
-          id: true,
-          timbradoUrl: true,
-          timbradoMarginTop: true,
-          timbradoMarginBottom: true,
-          timbradoMarginLeft: true,
-          timbradoMarginRight: true,
-          templatePadrao: true,
-          margensTemplate: true,
-          criadoEm: true
-        }
-      });
-
-      console.log('Configuração encontrada:', config); // Debug
-
-      // Retornar configuração padrão se não existir
-      return {
-        // Valores padrão
-        cabecalhoHtml: `
-          <div style="text-align: center; padding: 20px;">
-            <h2 style="margin:0;font-size:14pt">{{escritorio.nome}}</h2>
-          </div>
-        `,
-        rodapeHtml: `
-          <div style="text-align: center; font-size: 10pt;">
-            {{escritorio.endereco}}<br>
-            Tel: {{escritorio.telefone}} | Email: {{escritorio.email}}
-          </div>
-        `,
-        // Campos que existem no modelo
-        timbradoUrl: config?.timbradoUrl || '',
-        timbradoMarginTop: config?.timbradoMarginTop || 100,
-        timbradoMarginBottom: config?.timbradoMarginBottom || 50,
-        timbradoMarginLeft: config?.timbradoMarginLeft || 50,
-        timbradoMarginRight: config?.timbradoMarginRight || 50,
-        templatePadrao: config?.templatePadrao || null,
-        margensTemplate: config?.margensTemplate || null
-      };
-    } catch (error) {
-      console.error('Erro ao buscar configuração:', error);
-      // Retornar configuração padrão para não interromper o fluxo
-      return {
-        cabecalhoHtml: `<div style="text-align: center; padding: 20px;"><h2 style="margin:0;font-size:14pt">Documento</h2></div>`,
-        rodapeHtml: `<div style="text-align: center; font-size: 10pt;">Documento gerado pelo sistema</div>`,
-        timbradoUrl: '',
-        timbradoMarginTop: 100,
-        timbradoMarginBottom: 50,
-        timbradoMarginLeft: 50,
-        timbradoMarginRight: 50,
-        templatePadrao: null,
-        margensTemplate: null
-      };
-    }
-  }
-
-  /**
-   * Gera um PDF a partir do conteúdo HTML simples (apenas texto) e dados do escritório,
-   * encaixando o texto sobre o timbrado (PDF de fundo) em todas as páginas.
-   * Não usa Puppeteer, apenas PDF-LIB.
-   */
-  async gerarPDF(conteudo: string, escritorio: any = {}): Promise<Buffer> {
-    try {
-      console.log('Buscando configurações do documento...');
-      const config = await this.getConfiguracao();
-
-      // Verificar se temos um timbrado para usar
-      const temTimbrado = !!config.timbradoUrl;
-      let timbradoPath = '';
-      let timbradoExists = false;
-
-      if (temTimbrado) {
-        if (config.timbradoUrl.startsWith('/uploads')) {
-          timbradoPath = path.join(process.cwd(), 'public', config.timbradoUrl);
-        } else {
-          timbradoPath = path.join(process.cwd(), 'public', 'uploads', path.basename(config.timbradoUrl));
-        }
-        try {
-          await fs.access(timbradoPath);
-          timbradoExists = true;
-        } catch (e) {
-          timbradoExists = false;
-        }
-      }
-
-      // Margens
-      const margens = config.margensTemplate || {
-        top: config.timbradoMarginTop || 100,
-        left: config.timbradoMarginLeft || 50,
-        right: config.timbradoMarginRight || 50,
-        bottom: config.timbradoMarginBottom || 50
-      };
-
-      // Parâmetros de página
-      const PAGE_WIDTH = 595.28; // A4
-      const PAGE_HEIGHT = 841.89; // A4
-      const FONT_SIZE = 12;
-      const LINE_HEIGHT = FONT_SIZE * 1.5;
-      const MAX_WIDTH = PAGE_WIDTH - margens.left - margens.right;
-
-      // Crie o PDFDocument ANTES de tentar usar pdfDoc para embedFont!
-      let pdfDoc: PDFDocument = await PDFDocument.create();
-
-      // Fonte padrão do pdf-lib: TimesRoman, TimesBold, TimesItalic
-      const font = await pdfDoc.embedFont('Times-Roman');
-      const fontBold = await pdfDoc.embedFont('Times-Bold');
-      const fontItalic = await pdfDoc.embedFont('Times-Italic');
-      const fontBoldItalic = fontBold;
-
-      // Função para decodificar entidades HTML comuns (acentuação, símbolos, º, etc)
-      function decodeHtmlEntities(str: string): string {
-        if (!str) return '';
-        return str
-          // Acentos minúsculos e maiúsculos
-          .replace(/&Aacute;/g, 'Á').replace(/&aacute;/g, 'á')
-          .replace(/&Eacute;/g, 'É').replace(/&eacute;/g, 'é')
-          .replace(/&Iacute;/g, 'Í').replace(/&iacute;/g, 'í')
-          .replace(/&Oacute;/g, 'Ó').replace(/&oacute;/g, 'ó')
-          .replace(/&Uacute;/g, 'Ú').replace(/&uacute;/g, 'ú')
-          .replace(/&Agrave;/g, 'À').replace(/&agrave;/g, 'à')
-          .replace(/&Egrave;/g, 'È').replace(/&egrave;/g, 'è')
-          .replace(/&Igrave;/g, 'Ì').replace(/&igrave;/g, 'ì')
-          .replace(/&Ograve;/g, 'Ò').replace(/&ograve;/g, 'ò')
-          .replace(/&Ugrave;/g, 'Ù').replace(/&ugrave;/g, 'ù')
-          .replace(/&Acirc;/g, 'Â').replace(/&acirc;/g, 'â')
-          .replace(/&Ecirc;/g, 'Ê').replace(/&ecirc;/g, 'ê')
-          .replace(/&Icirc;/g, 'Î').replace(/&icirc;/g, 'î')
-          .replace(/&Ocirc;/g, 'Ô').replace(/&ocirc;/g, 'ô')
-          .replace(/&Ucirc;/g, 'Û').replace(/&ucirc;/g, 'û')
-          .replace(/&Atilde;/g, 'Ã').replace(/&atilde;/g, 'ã')
-          .replace(/&Otilde;/g, 'Õ').replace(/&otilde;/g, 'õ')
-          .replace(/&Ccedil;/g, 'Ç').replace(/&ccedil;/g, 'ç')
-          .replace(/&Ntilde;/g, 'Ñ').replace(/&ntilde;/g, 'ñ')
-          .replace(/&Uuml;/g, 'Ü').replace(/&uuml;/g, 'ü')
-          // Símbolos comuns
-          .replace(/&ordm;/gi, 'º')
-          .replace(/&ordf;/gi, 'ª')
-          .replace(/&sect;/gi, '§')
-          .replace(/&deg;/gi, '°')
-          .replace(/&copy;/gi, '©')
-          .replace(/&reg;/gi, '®')
-          .replace(/&para;/gi, '¶')
-          .replace(/&bull;/gi, '•')
-          .replace(/&ndash;/gi, '–')
-          .replace(/&mdash;/gi, '—')
-          .replace(/&laquo;/gi, '«')
-          .replace(/&raquo;/gi, '»')
-          .replace(/&lsquo;/gi, '‘')
-          .replace(/&rsquo;/gi, '’')
-          .replace(/&ldquo;/gi, '“')
-          .replace(/&rdquo;/gi, '”')
-          .replace(/&euro;/gi, '€')
-          .replace(/&yen;/gi, '¥')
-          .replace(/&pound;/gi, '£')
-          .replace(/&cent;/gi, '¢')
-          .replace(/&nbsp;/gi, ' ')
-          .replace(/&amp;/gi, '&')
-          .replace(/&quot;/gi, '"')
-          .replace(/&#39;/g, "'")
-          .replace(/&lt;/gi, '<')
-          .replace(/&gt;/gi, '>')
-          // Numéricos
-          .replace(/&#(\d+);/g, (m, code) => String.fromCharCode(code));
-      }
-
-      // Função para remover todas as tags HTML, exceto as de formatação suportadas
-      function stripUnsupportedTags(html: string): string {
-        // Remove todas as tags, exceto <b>, <strong>, <i>, <em>, <u>, <br>, <p>, <span style="text-indent:2em;">, <span style="text-align:center;">
-        // Remove atributos de <span> exceto text-indent e text-align
-        return html
-          // Mantém apenas <span> com text-indent ou text-align:center
-          .replace(/<span\b(?:(?!text-indent|text-align)[^>])*?>/gi, '')
-          // Remove atributos de <b>, <strong>, <i>, <em>, <u>, <p>
-          .replace(/<(b|strong|i|em|u|p)[^>]*>/gi, '<$1>')
-          // Remove todas as outras tags e atributos
-          .replace(/<(?!\/?(b|strong|i|em|u|br|p|span)[ >])[^>]+>/gi, '')
-          // Remove spans sem text-indent ou text-align
-          .replace(/<span>(.*?)<\/span>/gi, '$1')
-          // Remove comentários HTML
-          .replace(/<!--[\s\S]*?-->/g, '');
-      }
-
-      // Função para renderizar texto com formatação inline (negrito, itálico, sublinhado) e controle de quebra de linha e recuo
-      function renderInlineFormattedParagraph(
-        page,
-        text: string,
-        x: number,
-        y: number,
-        font,
-        fontBold,
-        fontItalic,
-        fontBoldItalic,
-        fontSize: number,
-        color,
-        align: string,
-        maxWidth: number,
-        indent: boolean,
-        topMargin: number,
-        bottomMargin: number,
-        pageHeight: number
-      ) {
-        let regex = /(<\/?(b|strong|i|em|u)>)/gi;
-        let tokens: { text: string, bold: boolean, italic: boolean, underline: boolean }[] = [];
-        let lastIndex = 0;
-        let match;
-        let currentStyle = { bold: false, italic: false, underline: false };
-        while ((match = regex.exec(text)) !== null) {
-          if (match.index > lastIndex) {
-            tokens.push({
-              text: text.substring(lastIndex, match.index),
-              bold: currentStyle.bold,
-              italic: currentStyle.italic,
-              underline: currentStyle.underline
-            });
-          }
-          if (/^<(b|strong)>$/i.test(match[0])) currentStyle.bold = true;
-          if (/^<\/(b|strong)>$/i.test(match[0])) currentStyle.bold = false;
-          if (/^<(i|em)>$/i.test(match[0])) currentStyle.italic = true;
-          if (/^<\/(i|em)>$/i.test(match[0])) currentStyle.italic = false;
-          if (/^<u>$/i.test(match[0])) currentStyle.underline = true;
-          if (/^<\/u>$/i.test(match[0])) currentStyle.underline = false;
-          lastIndex = regex.lastIndex;
-        }
-        if (lastIndex < text.length) {
-          tokens.push({
-            text: text.substring(lastIndex),
-            bold: currentStyle.bold,
-            italic: currentStyle.italic,
-            underline: currentStyle.underline
-          });
-        }
-
-        let words: { text: string, font: any, underline: boolean, bold: boolean, italic: boolean }[] = [];
-        for (const token of tokens) {
-          let usedFont = font;
-          if (token.bold && token.italic) usedFont = fontBoldItalic;
-          else if (token.bold) usedFont = fontBold;
-          else if (token.italic) usedFont = fontItalic;
-          // Corrige: split por espaço, mas preserva espaços como tokens separados
-          const split = token.text.split(/(\s+)/);
-          for (const part of split) {
-            words.push({ text: part, font: usedFont, underline: token.underline, bold: token.bold, italic: token.italic });
-          }
-        }
-
-        let lines: { tokens: { text: string, font: any, underline: boolean, bold: boolean, italic: boolean }[] }[] = [];
-        let currentTokens: { text: string, font: any, underline: boolean, bold: boolean, italic: boolean }[] = [];
-        let currentWidth = 0;
-
-        for (const [i, word] of words.entries()) {
-          const wordWidth = word.font.widthOfTextAtSize(word.text, fontSize);
-          if (currentWidth + wordWidth > maxWidth && currentTokens.length > 0) {
-            lines.push({ tokens: currentTokens });
-            currentTokens = [word];
-            currentWidth = wordWidth;
-          } else {
-            currentTokens.push(word);
-            currentWidth += wordWidth;
-          }
-        }
-        if (currentTokens.length > 0) {
-          lines.push({ tokens: currentTokens });
-        }
-
-        // Ajuste: Força alinhamento consistente para todas as linhas do parágrafo
-        // Se align === 'center', todas as linhas centralizadas
-        // Se align === 'justify', todas as linhas justificadas (exceto a última ou linhas curtas)
-        // Se align === 'left' ou outro, todas à esquerda
-
-        for (let i = 0; i < lines.length; i++) {
-          if (y < bottomMargin + fontSize * 1.5) {
-            return null;
-          }
-          let line = lines[i];
-          let drawX = x;
-
-          // Remove espaços no início e fim da linha para não justificar esses espaços
-          let trimmedTokens = [...line.tokens];
-          while (trimmedTokens.length && /^\s+$/.test(trimmedTokens[0].text)) trimmedTokens.shift();
-          while (trimmedTokens.length && /^\s+$/.test(trimmedTokens[trimmedTokens.length - 1].text)) trimmedTokens.pop();
-
-          let totalWidth = trimmedTokens.reduce((acc, t) => acc + t.font.widthOfTextAtSize(t.text, fontSize), 0);
-
-          // Corrige centralização: centraliza a linha inteira, inclusive se for a única linha do parágrafo
-          if (align === 'center') {
-            drawX = x + (maxWidth - totalWidth) / 2;
-            for (const t of trimmedTokens) {
-              page.drawText(t.text, {
-                x: drawX,
-                y,
-                size: fontSize,
-                font: t.font,
-                color
-              });
-              if (t.underline && t.text.trim() !== '') {
-                const underlineY = y - 1.5;
-                page.drawLine({
-                  start: { x: drawX, y: underlineY },
-                  end: { x: drawX + t.font.widthOfTextAtSize(t.text, fontSize), y: underlineY },
-                  thickness: 0.75,
-                  color
-                });
-              }
-              drawX += t.font.widthOfTextAtSize(t.text, fontSize);
-            }
-          } else if (align === 'justify' && i < lines.length - 1 && trimmedTokens.length > 2) {
-            // Justify: distribui espaço entre palavras, exceto na última linha ou linhas curtas
-            const spaces = trimmedTokens.filter(t => /^\s+$/.test(t.text));
-            const numSpaces = spaces.length;
-            const lineTextWidth = trimmedTokens.reduce((acc, t) => acc + t.font.widthOfTextAtSize(t.text, fontSize), 0);
-            const extraSpace = maxWidth - lineTextWidth;
-            let spaceWidth = 0;
-            // Só justifica se houver pelo menos 2 espaços e a linha não for muito curta
-            if (numSpaces > 0 && extraSpace > 0) {
-              spaceWidth = extraSpace / numSpaces;
-            }
-            let localDrawX = x;
-            for (const t of trimmedTokens) {
-              page.drawText(t.text, {
-                x: localDrawX,
-                y,
-                size: fontSize,
-                font: t.font,
-                color
-              });
-              if (t.underline && t.text.trim() !== '') {
-                const underlineY = y - 1.5;
-                page.drawLine({
-                  start: { x: localDrawX, y: underlineY },
-                  end: { x: localDrawX + t.font.widthOfTextAtSize(t.text, fontSize), y: underlineY },
-                  thickness: 0.75,
-                  color
-                });
-              }
-              if (/^\s+$/.test(t.text) && spaceWidth > 0) {
-                localDrawX += t.font.widthOfTextAtSize(t.text, fontSize) + spaceWidth;
-              } else {
-                localDrawX += t.font.widthOfTextAtSize(t.text, fontSize);
-              }
-            }
-          } else {
-            // Alinhamento à esquerda (padrão) ou última linha de parágrafo justificado
-            for (const t of trimmedTokens) {
-              page.drawText(t.text, {
-                x: drawX,
-                y,
-                size: fontSize,
-                font: t.font,
-                color
-              });
-              if (t.underline && t.text.trim() !== '') {
-                const underlineY = y - 1.5;
-                page.drawLine({
-                  start: { x: drawX, y: underlineY },
-                  end: { x: drawX + t.font.widthOfTextAtSize(t.text, fontSize), y: underlineY },
-                  thickness: 0.75,
-                  color
-                });
-              }
-              drawX += t.font.widthOfTextAtSize(t.text, fontSize);
-            }
-          }
-          y -= fontSize * 1.5;
-        }
-        return y;
-      }
-
-      const texto = decodeHtmlEntities(
-        stripUnsupportedTags(
-          this.processarTemplate(conteudo, escritorio)
-            .replace(/<br\s*\/?>/gi, '\n')
-            .replace(/<\/p>/gi, '\n\n')
-            .replace(/<p[^>]*>/gi, '') 
-            .replace(/<span[^>]*text-indent[^>]*>/gi, '§§INDENT§§')
-            .replace(/<span[^>]*text-align\s*:\s*center[^>]*>/gi, '§§CENTER§§')
-            .replace(/<\/span>/gi, '')
-            .replace(/\r\n/g, '\n')
-            .replace(/\r/g, '\n')
-            .replace(/\n{3,}/g, '\n\n')
-            .trim()
-        )
-      );
-
-      const paragrafos = texto.split(/\n{2,}/).map(p => p.trim()).filter(Boolean);
-
-      let timbradoPdf: PDFDocument | null = null;
-      let timbradoPageCount = 0;
-      let timbradoPages: any[] = [];
-      if (timbradoExists) {
-        const timbradoBytes = await fs.readFile(timbradoPath);
-        timbradoPdf = await PDFDocument.load(timbradoBytes);
-        timbradoPageCount = timbradoPdf.getPageCount();
-        timbradoPages = [];
-        for (let i = 0; i < timbradoPageCount; i++) {
-          const [embedded] = await pdfDoc.embedPages([timbradoPdf.getPage(i)]);
-          timbradoPages.push(embedded);
-        }
-      }
-
-      let currentPar = 0;
-      let pageIndex = 0;
-      while (currentPar < paragrafos.length) {
-        let page = pdfDoc.addPage([PAGE_WIDTH, PAGE_HEIGHT]);
-        if (timbradoPages.length > 0) {
-          const embedded = timbradoPages[pageIndex % timbradoPages.length];
-          page.drawPage(embedded, {
-            x: 0,
-            y: 0,
-            width: PAGE_WIDTH,
-            height: PAGE_HEIGHT
-          });
-        }
-        let y = PAGE_HEIGHT - margens.top;
-        while (currentPar < paragrafos.length) {
-          let indent = paragrafos[currentPar].startsWith('§§INDENT§§');
-          let center = paragrafos[currentPar].startsWith('§§CENTER§§');
-          let align: 'center' | 'justify' | 'left' = center ? 'center' : 'justify';
-          let text = paragrafos[currentPar].replace(/^§§INDENT§§/, '').replace(/^§§CENTER§§/, '').trim();
-
-          // Se o parágrafo for centralizado, força alinhamento center e ignora recuo
-          if (center) {
-            indent = false;
-            align = 'center';
-          }
-
-          text = decodeHtmlEntities(text);
-
-          let x = margens.left;
-          let parWidth = MAX_WIDTH;
-
-          let yAfter = renderInlineFormattedParagraph(
-            page,
-            text,
-            x,
-            y,
-            font,
-            fontBold,
-            fontItalic,
-            fontBoldItalic,
-            FONT_SIZE,
-            rgb(0, 0, 0),
-            align,
-            parWidth,
-            indent,
-            margens.top,
-            margens.bottom,
-            PAGE_HEIGHT
-          );
-          if (yAfter === null) {
-            pageIndex++;
-            break;
-          }
-          y = yAfter - FONT_SIZE * 0.5;
-          currentPar++;
-          if (y < margens.bottom + FONT_SIZE * 1.5) break;
-        }
-        pageIndex++;
-      }
-
-      const pdfBytes = await pdfDoc.save();
-      return Buffer.from(pdfBytes);
-    } catch (error) {
-      console.error('Erro geral ao gerar PDF:', error);
-      throw error;
-    }
-  }
-
-  private processarTemplate(template: string, dados: any): string {
-    return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
-      const keyParts = key.trim().split('.');
-      let value = dados;
-      
-      for (const part of keyParts) {
-        if (value && typeof value === 'object' && part in value) {
-          value = value[part];
-        } else {
-          value = undefined;
-          break;
-        }
-      }
-      
-      return value !== undefined ? value : match;
-    });
-  }
-}

src/server/services/PdfService copy 3.ts

@@ -1,219 +0,0 @@
-import puppeteer from 'puppeteer';
-import { PDFDocument } from 'pdf-lib';
-import fs from 'fs/promises';
-import path from 'path';
-import { prisma } from '../prismaClient';
-
-// Função utilitária para converter pixels em milímetros (1px ≈ 0.264583 mm)
-function pxToMm(px: number | null | undefined): string {
-  if (!px) return '0mm';
-  return (px * 0.264583).toFixed(2) + 'mm';
-}
-
-export class PdfService {
-  // Busca configuração do documento, usando apenas campos válidos do schema
-  private async getConfiguracao() {
-    try {
-      const config = await prisma.configuracaoDocumento.findFirst({
-        orderBy: { criadoEm: 'desc' },
-        select: {
-          id: true,
-          timbradoUrl: true,
-          timbradoMarginTop: true,
-          timbradoMarginBottom: true,
-          timbradoMarginLeft: true,
-          timbradoMarginRight: true,
-          templatePadrao: true,
-          margensTemplate: true,
-          criadoEm: true
-        }
-      });
-      // Extrai recuo de primeira linha se existir em margensTemplate
-      let firstLineIndent = '0mm';
-      if (config?.margensTemplate) {
-        try {
-          const margens = typeof config.margensTemplate === 'string' ? JSON.parse(config.margensTemplate) : config.margensTemplate;
-          if (margens && margens.firstLineIndent) {
-            firstLineIndent = `${margens.firstLineIndent}mm`;
-          }
-        } catch (e) {
-          // Se der erro, ignora e usa padrão
-        }
-      }
-      return {
-        timbradoUrl: config?.timbradoUrl || '',
-        timbradoMarginTop: config?.timbradoMarginTop ?? 100,
-        timbradoMarginBottom: config?.timbradoMarginBottom ?? 50,
-        timbradoMarginLeft: config?.timbradoMarginLeft ?? 50,
-        timbradoMarginRight: config?.timbradoMarginRight ?? 50,
-        templatePadrao: config?.templatePadrao || '',
-        firstLineIndent
-      };
-    } catch (error) {
-      console.error('Erro ao buscar configuração:', error);
-      throw new Error('Falha ao buscar configuração');
-    }
-  }
-
-  // Gera HTML com timbrado e margens
-  private gerarHTML(content: string, config: any) {
-    // Limpa espaços, quebras de linha e tags vazias do final do conteúdo
-    let cleanContent = content
-      .replace(/(\s|<br\s*\/?>|<p>\s*<\/p>)+$/gi, '')
-      .replace(/(<p>\s*<\/p>)+/gi, '');
-    const timbradoUrl = config.timbradoUrl
-      ? `${process.env.FRONTEND_URL || 'http://localhost:5000'}${config.timbradoUrl}`
-      : '';
-    // Adiciona log para debug
-    if (timbradoUrl) {
-      console.log('[PDF] Timbrado inserido no HTML:', timbradoUrl);
-    }
-    return `
-      <!DOCTYPE html>
-      <html>
-      <head>
-        <meta charset="UTF-8">
-        <link href="https://fonts.googleapis.com/css2?family=Fira+Sans:wght@400;500;600&display=swap" rel="stylesheet">
-        <style>
-          @page {
-            margin-top: ${pxToMm(config.timbradoMarginTop)};
-            margin-bottom: ${pxToMm(config.timbradoMarginBottom)};
-            margin-left: ${pxToMm(config.timbradoMarginLeft)};
-            margin-right: ${pxToMm(config.timbradoMarginRight)};
-            size: A4;
-          }
-          html, body {
-            height: 100%;
-            margin: 0;
-            padding: 0;
-            font-family: 'Fira Sans', Arial, sans-serif;
-            font-size: 11pt;
-            line-height: 1.5;
-            background: none;
-          }
-          body {
-            position: relative;
-            min-height: 100vh;
-            /* Remove background-image do body para evitar problemas no Puppeteer */
-          }
-          .timbrado-bg {
-            position: fixed;
-            top: 0;
-            left: 0;
-            width: 100vw;
-            height: 100vh;
-            z-index: 0;
-            ${timbradoUrl ? `background-image: url('${timbradoUrl}'); background-size: cover; background-position: center; background-repeat: no-repeat;` : ''}
-            pointer-events: none;
-          }
-          .content {
-            position: relative;
-            z-index: 1;
-            box-sizing: border-box;
-            width: 100%;
-            /* Removido padding-top e padding-bottom para evitar recuo duplo com as margens do PDF */
-            padding-left: ${pxToMm(config.timbradoMarginLeft)};
-            padding-right: ${pxToMm(config.timbradoMarginRight)};
-            overflow-wrap: break-word;
-            word-break: break-word;
-            /* Permite múltiplas páginas e evita corte de conteúdo */
-            break-inside: auto;
-            page-break-inside: auto;
-          }
-          .content p {
-            text-indent: ${config.firstLineIndent || '0mm'};
-          }
-          /* Corrige recuo exagerado apenas na primeira linha do primeiro parágrafo da primeira página */
-          .content p:first-child {
-            text-indent: 0mm !important;
-          }
-          /* Corrige recuo exagerado apenas na última linha do último parágrafo da última página */
-          .content p:last-child {
-            margin-bottom: 0 !important;
-            padding-bottom: 0 !important;
-          }
-        </style>
-      </head>
-      <body>
-        ${timbradoUrl ? '<div class="timbrado-bg"></div>' : ''}
-        <div class="content">
-          ${cleanContent}
-        </div>
-      </body>
-      </html>
-    `;
-  }
-
-  // Gera PDF a partir do HTML, depois sobrepõe o timbrado em cada página
-  async gerarPDF(conteudo: string) {
-    try {
-      const config = await this.getConfiguracao();
-      // Usa templatePadrao se não houver conteúdo
-      const html = this.gerarHTML(conteudo || config.templatePadrao, config);
-      const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox'] });
-      const page = await browser.newPage();
-      await page.setContent(html, {
-        waitUntil: ['networkidle0', 'load'],
-        timeout: 30000
-      });
-      const margin = {
-        top: pxToMm(config.timbradoMarginTop),
-        bottom: pxToMm(config.timbradoMarginBottom),
-        left: pxToMm(config.timbradoMarginLeft),
-        right: pxToMm(config.timbradoMarginRight)
-      };
-      const pdfBuffer = await page.pdf({
-        format: 'A4',
-        printBackground: true,
-        margin,
-        preferCSSPageSize: true
-      });
-      await browser.close();
-
-      // Se não houver timbrado, retorna direto
-      if (!config.timbradoUrl) {
-        return Buffer.from(pdfBuffer);
-      }
-
-      // Caminho absoluto do PDF de timbrado
-      const timbradoPath = config.timbradoUrl.startsWith('/uploads')
-        ? path.join(process.cwd(), 'public', config.timbradoUrl)
-        : path.join(process.cwd(), 'public', 'uploads', path.basename(config.timbradoUrl));
-      let timbradoBytes: Buffer;
-      try {
-        timbradoBytes = await fs.readFile(timbradoPath);
-      } catch (e) {
-        console.error('Timbrado não encontrado:', timbradoPath);
-        return Buffer.from(pdfBuffer);
-      }
-
-      // Mescla cada página do PDF gerado com o timbrado
-      const pdfDoc = await PDFDocument.load(pdfBuffer);
-      const timbradoDoc = await PDFDocument.load(timbradoBytes);
-      const timbradoPage = timbradoDoc.getPage(0);
-      const [timbradoEmbed] = await pdfDoc.embedPages([timbradoPage]);
-      const pageCount = pdfDoc.getPageCount();
-      for (let i = 0; i < pageCount; i++) {
-        const page = pdfDoc.getPage(i);
-        page.drawPage(timbradoEmbed, { x: 0, y: 0, width: page.getWidth(), height: page.getHeight() });
-      }
-      // Remove última página se estiver vazia (sem conteúdo visível)
-      if (pdfDoc.getPageCount() > 1) {
-        const lastPage = pdfDoc.getPage(pdfDoc.getPageCount() - 1);
-        const textContent = lastPage.getTextContent ? await lastPage.getTextContent() : null;
-        // pdf-lib não tem getTextContent, então alternativa: verifica se altura do conteúdo é mínima
-        if (lastPage.getHeight && lastPage.getWidth && lastPage.getHeight() > 0 && lastPage.getWidth() > 0) {
-          // Heurística: verifica se a página tem apenas o timbrado (sem outros objetos)
-          if (lastPage.node.Contents().size() === 0) {
-            pdfDoc.removePage(pdfDoc.getPageCount() - 1);
-          }
-        }
-      }
-      const mergedPdf = await pdfDoc.save();
-      return Buffer.from(mergedPdf);
-    } catch (error) {
-      console.error('Erro ao gerar PDF:', error);
-      throw new Error('Falha ao gerar PDF');
-    }
-  }
-}

src/server/services/PdfService copy.ts

@@ -1,47 +1,53 @@
 import puppeteer from 'puppeteer';
+import { PDFDocument } from 'pdf-lib';
+import fs from 'fs/promises';
+import path from 'path';
 import { prisma } from '../prismaClient';
 
+// Função utilitária para converter pixels em milímetros (1px ≈ 0.264583 mm)
+function pxToMm(px: number | null | undefined): string {
+  if (!px) return '0mm';
+  return (px * 0.264583).toFixed(2) + 'mm';
+}
+
 export class PdfService {
+  // Busca configuração do documento, usando apenas campos válidos do schema
   private async getConfiguracao() {
     try {
-      // Buscar configuração ou usar valores padrão
       const config = await prisma.configuracaoDocumento.findFirst({
         orderBy: { criadoEm: 'desc' },
         select: {
           id: true,
-          headerImageUrl: true,
-          footerImageUrl: true,
-          logoUrl: true,
           timbradoUrl: true,
           timbradoMarginTop: true,
           timbradoMarginBottom: true,
           timbradoMarginLeft: true,
           timbradoMarginRight: true,
+          templatePadrao: true,
+          margensTemplate: true,
           criadoEm: true
         }
       });
-
+      // Extrai recuo de primeira linha se existir em margensTemplate
-      console.log('Configuração encontrada:', config); // Debug
+      let firstLineIndent = '0mm';
-
+      if (config?.margensTemplate) {
-      // Retornar configuração padrão se não existir
+        try {
+          const margens = typeof config.margensTemplate === 'string' ? JSON.parse(config.margensTemplate) : config.margensTemplate;
+          if (margens && margens.firstLineIndent) {
+            firstLineIndent = `${margens.firstLineIndent}mm`;
+          }
+        } catch (e) {
+          // Se der erro, ignora e usa padrão
+        }
+      }
       return {
-        cabecalhoHtml: config?.cabecalhoHtml || `
-          <div style="text-align: center; padding: 20px;">
-            <h2 style="margin:0;font-size:14pt">{{escritorio.nome}}</h2>
-          </div>
-        `,
-        rodapeHtml: config?.rodapeHtml || `
-          <div style="text-align: center; font-size: 10pt;">
-            {{escritorio.endereco}}<br>
-            Tel: {{escritorio.telefone}} | Email: {{escritorio.email}}
-          </div>
-        `,
-        logoUrl: config?.logoUrl || '',
         timbradoUrl: config?.timbradoUrl || '',
-        timbradoMarginTop: config?.timbradoMarginTop || 100,
+        timbradoMarginTop: config?.timbradoMarginTop ?? 100,
-        timbradoMarginBottom: config?.timbradoMarginBottom || 50,
+        timbradoMarginBottom: config?.timbradoMarginBottom ?? 50,
-        timbradoMarginLeft: config?.timbradoMarginLeft || 50,
+        timbradoMarginLeft: config?.timbradoMarginLeft ?? 50,
-        timbradoMarginRight: config?.timbradoMarginRight || 50
+        timbradoMarginRight: config?.timbradoMarginRight ?? 50,
+        templatePadrao: config?.templatePadrao || '',
+        firstLineIndent
       };
     } catch (error) {
       console.error('Erro ao buscar configuração:', error);
@@ -49,13 +55,19 @@ export class PdfService {
     }
   }
 
+  // Gera HTML com timbrado e margens
   private gerarHTML(content: string, config: any) {
+    // Limpa espaços, quebras de linha e tags vazias do final do conteúdo
+    let cleanContent = content
+      .replace(/(\s|<br\s*\/?>|<p>\s*<\/p>)+$/gi, '')
+      .replace(/(<p>\s*<\/p>)+/gi, '');
     const timbradoUrl = config.timbradoUrl
-      ? `${process.env.BACKEND_URL || 'http://localhost:5000'}${config.timbradoUrl}`
+      ? `${process.env.FRONTEND_URL || 'http://localhost:5000'}${config.timbradoUrl}`
       : '';
-
+    // Adiciona log para debug
-    console.log('Gerando PDF com timbrado:', timbradoUrl);
+    if (timbradoUrl) {
-
+      console.log('[PDF] Timbrado inserido no HTML:', timbradoUrl);
+    }
     return `
       <!DOCTYPE html>
       <html>
@@ -64,87 +76,158 @@ export class PdfService {
         <link href="https://fonts.googleapis.com/css2?family=Fira+Sans:wght@400;500;600&display=swap" rel="stylesheet">
         <style>
           @page {
-            margin: 0;
+            margin-top: ${pxToMm(config.timbradoMarginTop)};
+            margin-bottom: ${pxToMm(config.timbradoMarginBottom)};
+            margin-left: ${pxToMm(config.timbradoMarginLeft)};
+            margin-right: ${pxToMm(config.timbradoMarginRight)};
             size: A4;
           }
-          
+          html, body {
-          body { 
+            height: 100%;
             margin: 0;
             padding: 0;
             font-family: 'Fira Sans', Arial, sans-serif;
             font-size: 11pt;
             line-height: 1.5;
+            background: none;
+          }
+          body {
             position: relative;
             min-height: 100vh;
+            /* Remove background-image do body para evitar problemas no Puppeteer */
           }
-
+          .timbrado-bg {
-          .page {
+            position: fixed;
-            position: relative;
+            top: 0;
-            width: 21cm;
+            left: 0;
-            min-height: 29.7cm;
+            width: 100vw;
-            padding: ${config.timbradoMarginTop || 100}px ${config.timbradoMarginRight || 50}px ${config.timbradoMarginBottom || 50}px ${config.timbradoMarginLeft || 50}px;
+            height: 100vh;
-            background: ${timbradoUrl ? `url('${timbradoUrl}')` : 'none'};
+            z-index: 0;
-            background-size: cover;
+            ${timbradoUrl ? `background-image: url('${timbradoUrl}'); background-size: cover; background-position: center; background-repeat: no-repeat;` : ''}
-            background-position: center;
+            pointer-events: none;
-            background-repeat: no-repeat;
-            box-sizing: border-box;
           }
-
           .content {
             position: relative;
             z-index: 1;
+            box-sizing: border-box;
+            width: 100%;
+            /* Removido padding-top e padding-bottom para evitar recuo duplo com as margens do PDF */
+            padding-left: ${pxToMm(config.timbradoMarginLeft)};
+            padding-right: ${pxToMm(config.timbradoMarginRight)};
+            overflow-wrap: break-word;
+            word-break: break-word;
+            /* Permite múltiplas páginas e evita corte de conteúdo */
+            break-inside: auto;
+            page-break-inside: auto;
+          }
+          .content p {
+            text-indent: ${config.firstLineIndent || '0mm'};
+          }
+          /* Corrige recuo exagerado apenas na primeira linha do primeiro parágrafo da primeira página */
+          .content p:first-child {
+            text-indent: 0mm !important;
+          }
+          /* Corrige recuo exagerado apenas na última linha do último parágrafo da última página */
+          .content p:last-child {
+            margin-bottom: 0 !important;
+            padding-bottom: 0 !important;
           }
         </style>
       </head>
       <body>
-        <div class="page">
+        ${timbradoUrl ? '<div class="timbrado-bg"></div>' : ''}
-          <div class="content">
+        <div class="content">
-            ${content}
+          ${cleanContent}
-          </div>
         </div>
       </body>
       </html>
     `;
   }
 
-  async gerarPDF(conteudo: string, escritorio: any) {
+  // Gera PDF a partir do HTML, depois sobrepõe o timbrado em cada página
+  async gerarPDF(conteudo: string) {
     try {
-      const config = await prisma.configuracaoDocumento.findFirst({
+      const config = await this.getConfiguracao();
-        orderBy: { criadoEm: 'desc' }
+      // Usa templatePadrao se não houver conteúdo
-      });
+      const html = this.gerarHTML(conteudo || config.templatePadrao, config);
-
+      const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox'] });
-      console.log('Configuração do PDF:', config);
-      
-      const html = this.gerarHTML(conteudo, config);
-      
-      const browser = await puppeteer.launch({
-        headless: 'new',
-        args: ['--no-sandbox']
-      });
-
       const page = await browser.newPage();
-      
-      await page.setViewport({
-        width: 794, // A4 width in pixels (72 dpi)
-        height: 1123,
-        deviceScaleFactor: 2
-      });
-
       await page.setContent(html, {
         waitUntil: ['networkidle0', 'load'],
         timeout: 30000
       });
-
+      const margin = {
+        top: pxToMm(config.timbradoMarginTop),
+        bottom: pxToMm(config.timbradoMarginBottom),
+        left: pxToMm(config.timbradoMarginLeft),
+        right: pxToMm(config.timbradoMarginRight)
+      };
       const pdfBuffer = await page.pdf({
         format: 'A4',
         printBackground: true,
-        margin: { top: '0', right: '0', bottom: '0', left: '0' },
+        margin,
         preferCSSPageSize: true
       });
-
       await browser.close();
-      return Buffer.from(pdfBuffer);
 
+      // Se não houver timbrado, retorna direto
+      if (!config.timbradoUrl) {
+        return Buffer.from(pdfBuffer);
+      }
+
+      // Caminho absoluto do PDF de timbrado
+      const timbradoPath = config.timbradoUrl.startsWith('/uploads')
+        ? path.join(process.cwd(), 'public', config.timbradoUrl)
+        : path.join(process.cwd(), 'public', 'uploads', path.basename(config.timbradoUrl));
+      let timbradoBytes: Buffer;
+      try {
+        timbradoBytes = await fs.readFile(timbradoPath);
+      } catch (e) {
+        console.error('Timbrado não encontrado:', timbradoPath);
+        return Buffer.from(pdfBuffer);
+      }
+
+      // Mescla cada página do PDF gerado com o timbrado
+      const pdfDoc = await PDFDocument.load(pdfBuffer);
+      const timbradoDoc = await PDFDocument.load(timbradoBytes);
+      const timbradoPage = timbradoDoc.getPage(0);
+      const [timbradoEmbed] = await pdfDoc.embedPages([timbradoPage]);
+      const pageCount = pdfDoc.getPageCount();
+      for (let i = 0; i < pageCount; i++) {
+        const page = pdfDoc.getPage(i);
+        page.drawPage(timbradoEmbed, { x: 0, y: 0, width: page.getWidth(), height: page.getHeight() });
+      }
+      // Após mesclar o timbrado
+      const pageCountBefore = pdfDoc.getPageCount();
+      if (pageCountBefore > 1) {
+        // Heurística aprimorada: remove a última página apenas se estiver realmente vazia (sem texto, imagens ou gráficos)
+        const lastPage = pdfDoc.getPage(pageCountBefore - 1);
+        let isBlank = true;
+        // Verifica se há texto
+        const annotations = lastPage.node.Annots;
+        if (annotations && annotations.length > 0) {
+          isBlank = false;
+        }
+        // Verifica se há objetos gráficos (imagens, paths, etc.)
+        if (isBlank && typeof lastPage.node?.Resources === 'function') {
+          const resourcesDict = lastPage.node.Resources();
+          if (resourcesDict && typeof resourcesDict === 'object') {
+            // Corrige: usa PDFName para acessar o XObject
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { PDFName } = require('pdf-lib');
+            const xObject = resourcesDict.get(PDFName.of('XObject'));
+            if (xObject && typeof xObject === 'object' && Object.keys(xObject).length > 0) {
+              isBlank = false;
+            }
+          }
+        }
+        // Só remove se realmente não houver nada
+        if (isBlank) {
+          pdfDoc.removePage(pageCountBefore - 1);
+        }
+      }
+      const mergedPdf = await pdfDoc.save();
+      return Buffer.from(mergedPdf);
     } catch (error) {
       console.error('Erro ao gerar PDF:', error);
       throw new Error('Falha ao gerar PDF');

src/server/services/PdfService.ts

@@ -187,8 +187,32 @@ export class PdfService {
         return Buffer.from(pdfBuffer);
       }
 
-      // Mescla cada página do PDF gerado com o timbrado
+      // Remove página vazia do final ANTES de mesclar o timbrado
-      const pdfDoc = await PDFDocument.load(pdfBuffer);
+      let pdfDoc = await PDFDocument.load(pdfBuffer);
+      let pageCountBefore = pdfDoc.getPageCount();
+      if (pageCountBefore > 1) {
+        const lastPage = pdfDoc.getPage(pageCountBefore - 1);
+        const contentStreams = (lastPage as any).node.Contents?.();
+        let isBlank = false;
+
+        if (!contentStreams) {
+          isBlank = true;
+        } else if (Array.isArray(contentStreams)) {
+          isBlank = contentStreams.every(
+            (stream: any) =>
+              !stream.contents ||
+              (typeof stream.contents.length === 'number' && stream.contents.length < 5)
+          );
+        } else if (contentStreams.contents && typeof contentStreams.contents.length === 'number') {
+          isBlank = contentStreams.contents.length < 5;
+        }
+
+        if (isBlank) {
+          pdfDoc.removePage(pageCountBefore - 1);
+        }
+      }
+
+      // Agora sim, mescle o timbrado nas páginas restantes
       const timbradoDoc = await PDFDocument.load(timbradoBytes);
       const timbradoPage = timbradoDoc.getPage(0);
       const [timbradoEmbed] = await pdfDoc.embedPages([timbradoPage]);
@@ -197,16 +221,7 @@ export class PdfService {
         const page = pdfDoc.getPage(i);
         page.drawPage(timbradoEmbed, { x: 0, y: 0, width: page.getWidth(), height: page.getHeight() });
       }
-      // Após mesclar o timbrado
+
-      const pageCountBefore = pdfDoc.getPageCount();
-      if (pageCountBefore > 1) {
-        // Heurística: remove a última página se ela estiver completamente em branco (sem texto)
-        const lastPage = pdfDoc.getPage(pageCountBefore - 1);
-        const text = await lastPage.getTextContent?.();
-        if (!text || (Array.isArray(text.items) && text.items.length === 0)) {
-          pdfDoc.removePage(pageCountBefore - 1);
-        }
-      }
       const mergedPdf = await pdfDoc.save();
       return Buffer.from(mergedPdf);
     } catch (error) {

src/services/WebProofService.ts

@@ -0,0 +1,381 @@
+import { prisma } from '../prismaClient';
+import { createHash } from 'crypto';
+import { PDFDocument, StandardFonts, rgb } from 'pdf-lib';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+interface WebCaptureData {
+  sessionId: string;
+  targetUrl: string;
+  description: string;
+  metadata: any;
+  environment: any;
+  screenshots: string[];
+}
+
+interface TrustedTimestamp {
+  timestamp: string;
+  authority: string;
+  signature: string;
+}
+
+export class WebProofService {
+  
+  // Processar captura web completa
+  async processWebCapture(data: WebCaptureData) {
+    try {
+      console.log('Iniciando processamento de captura web:', data.sessionId);
+
+      // Criar registro da sessão
+      const session = await prisma.webProofSession.create({
+        data: {
+          sessionId: data.sessionId,
+          targetUrl: data.targetUrl,
+          description: data.description,
+          status: 'PROCESSANDO',
+          metadata: data.metadata,
+          environment: data.environment,
+          screenshots: data.screenshots
+        }
+      });
+
+      // Processar em background
+      this.processInBackground(session.id, data);
+
+      return session;
+
+    } catch (error) {
+      console.error('Erro ao processar captura web:', error);
+      throw new Error(`Falha no processamento: ${error.message}`);
+    }
+  }
+
+  // Processamento em background
+  private async processInBackground(sessionDbId: string, data: WebCaptureData) {
+    try {
+      // Simular processamento complexo
+      await this.delay(2000);
+
+      // Gerar hashes da sessão
+      const sessionHash = await this.generateSessionHash(data);
+      const contentHash = await this.generateContentHash(data.targetUrl, data.metadata);
+      const pageHash = await this.generatePageHash(data.targetUrl, data.environment);
+
+      // Coletar dados de rede simulados
+      const networkData = await this.collectNetworkData(data.targetUrl);
+
+      // Obter timestamp confiável
+      const trustedTimestamp = await this.getTrustedTimestamp();
+
+      // Gerar relatório PDF
+      const reportPath = await this.generateWebProofReport({
+        ...data,
+        sessionHash,
+        contentHash,
+        pageHash,
+        networkData,
+        trustedTimestamp
+      });
+
+      // Atualizar status para concluído
+      await prisma.webProofSession.update({
+        where: { id: sessionDbId },
+        data: {
+          status: 'CONCLUIDO',
+          sessionHash,
+          contentHash,
+          pageHash,
+          reportPath,
+          networkData,
+          trustedTimestamp: trustedTimestamp.timestamp,
+          processedAt: new Date()
+        }
+      });
+
+      console.log('Processamento de captura web concluído:', data.sessionId);
+
+    } catch (error) {
+      console.error('Erro no processamento em background:', error);
+      
+      await prisma.webProofSession.update({
+        where: { id: sessionDbId },
+        data: {
+          status: 'ERRO',
+          error: error.message
+        }
+      });
+    }
+  }
+
+  // Gerar hash da sessão
+  private async generateSessionHash(data: WebCaptureData): Promise<string> {
+    const sessionData = JSON.stringify({
+      sessionId: data.sessionId,
+      targetUrl: data.targetUrl,
+      environment: data.environment,
+      timestamp: data.metadata.timestamps?.sessionStart
+    });
+    
+    return createHash('sha256').update(sessionData).digest('hex');
+  }
+
+  // Gerar hash do conteúdo
+  private async generateContentHash(url: string, metadata: any): Promise<string> {
+    const contentData = JSON.stringify({
+      url,
+      timestamp: metadata.timestamps?.captureStart,
+      browserFingerprint: metadata.technicalData?.browserFingerprint
+    });
+    
+    return createHash('sha256').update(contentData).digest('hex');
+  }
+
+  // Gerar hash da página
+  private async generatePageHash(url: string, environment: any): Promise<string> {
+    const pageData = JSON.stringify({
+      url,
+      environment,
+      timestamp: new Date().toISOString()
+    });
+    
+    return createHash('sha512').update(pageData).digest('hex');
+  }
+
+  // Coletar dados de rede (simulado)
+  private async collectNetworkData(targetUrl: string) {
+    try {
+      const url = new URL(targetUrl);
+      
+      // Simular coleta de dados de rede
+      return {
+        domain: url.hostname,
+        protocol: url.protocol,
+        port: url.port || (url.protocol === 'https:' ? '443' : '80'),
+        path: url.pathname,
+        resolvedIP: '192.168.1.1', // Simulado
+        routeTrace: ['10.0.0.1', '192.168.1.1'], // Simulado
+        dnsRecords: [
+          { type: 'A', value: '192.168.1.1' },
+          { type: 'MX', value: 'mail.example.com' }
+        ]
+      };
+    } catch {
+      return {
+        domain: 'unknown',
+        error: 'Falha na resolução de rede'
+      };
+    }
+  }
+
+  // Obter timestamp confiável
+  async getTrustedTimestamp(): Promise<TrustedTimestamp> {
+    // Simular autoridade certificadora de tempo
+    const timestamp = new Date().toISOString();
+    const signature = createHash('sha256')
+      .update(timestamp + 'trusted_authority_key')
+      .digest('hex');
+
+    return {
+      timestamp,
+      authority: 'AdvX Timestamp Authority',
+      signature
+    };
+  }
+
+  // Gerar relatório PDF da captura web
+  private async generateWebProofReport(data: any): Promise<string> {
+    try {
+      const pdfDoc = await PDFDocument.create();
+      const helveticaFont = await pdfDoc.embedFont(StandardFonts.Helvetica);
+      const helveticaBold = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
+
+      // Página principal
+      const page = pdfDoc.addPage([595, 842]); // A4
+      const { width, height } = page.getSize();
+
+      // Cabeçalho
+      page.drawText('RELATÓRIO DE CAPTURA WEB FORENSE', {
+        x: 50,
+        y: height - 50,
+        size: 18,
+        font: helveticaBold,
+        color: rgb(0, 0, 0.8)
+      });
+
+      // Informações da sessão
+      let yPosition = height - 100;
+      const addSection = (title: string, content: string) => {
+        page.drawText(title, {
+          x: 50,
+          y: yPosition,
+          size: 12,
+          font: helveticaBold
+        });
+        yPosition -= 20;
+        
+        const lines = content.split('\n');
+        lines.forEach(line => {
+          page.drawText(line, {
+            x: 50,
+            y: yPosition,
+            size: 10,
+            font: helveticaFont
+          });
+          yPosition -= 15;
+        });
+        yPosition -= 10;
+      };
+
+      addSection('IDENTIFICAÇÃO DA SESSÃO:', 
+        `ID: ${data.sessionId}\nURL Capturada: ${data.targetUrl}\nDescrição: ${data.description || 'Não especificada'}`
+      );
+
+      addSection('INFORMAÇÕES TEMPORAIS:', 
+        `Início da Sessão: ${data.metadata.timestamps?.sessionStart || 'N/A'}\nInício da Captura: ${data.metadata.timestamps?.captureStart || 'N/A'}\nFim da Captura: ${data.metadata.timestamps?.captureEnd || 'N/A'}\nTimestamp Confiável: ${data.trustedTimestamp || 'N/A'}`
+      );
+
+      addSection('HASHES DE INTEGRIDADE:', 
+        `Hash da Sessão (SHA-256): ${data.sessionHash}\nHash do Conteúdo (SHA-256): ${data.contentHash}\nHash da Página (SHA-512): ${data.pageHash}`
+      );
+
+      addSection('AMBIENTE DE CAPTURA:', 
+        `User Agent: ${data.environment.userAgent}\nTamanho da Viewport: ${data.environment.viewportSize?.width}x${data.environment.viewportSize?.height}\nEndereço IP: ${data.environment.ipAddress}\nTimestamp do Ambiente: ${data.environment.timestamp}`
+      );
+
+      if (data.networkData) {
+        addSection('DADOS DE REDE:', 
+          `Domínio: ${data.networkData.domain}\nProtocolo: ${data.networkData.protocol}\nPorta: ${data.networkData.port}\nIP Resolvido: ${data.networkData.resolvedIP || 'N/A'}`
+        );
+      }
+
+      if (data.screenshots && data.screenshots.length > 0) {
+        addSection('CAPTURAS REALIZADAS:', 
+          `Número de Screenshots: ${data.screenshots.length}\nTimestamps: ${data.screenshots.map((_, i) => `Screenshot ${i + 1}`).join(', ')}`
+        );
+      }
+
+      // Rodapé
+      page.drawText('Este relatório foi gerado automaticamente pelo sistema AdvX Web Proof Capture', {
+        x: 50,
+        y: 50,
+        size: 8,
+        font: helveticaFont,
+        color: rgb(0.5, 0.5, 0.5)
+      });
+
+      // Salvar PDF
+      const pdfBytes = await pdfDoc.save();
+      const reportDir = path.join(process.cwd(), 'storage', 'web-proofs');
+      await fs.mkdir(reportDir, { recursive: true });
+      
+      const reportPath = path.join(reportDir, `${data.sessionId}_report.pdf`);
+      await fs.writeFile(reportPath, pdfBytes);
+
+      return reportPath;
+
+    } catch (error) {
+      console.error('Erro ao gerar relatório PDF:', error);
+      throw new Error('Falha na geração do relatório');
+    }
+  }
+
+  // Verificar autenticidade da captura
+  async verifyWebCapture(sessionId: string) {
+    try {
+      const session = await prisma.webProofSession.findUnique({
+        where: { sessionId }
+      });
+
+      if (!session) {
+        return {
+          verified: false,
+          details: 'Sessão não encontrada'
+        };
+      }
+
+      // Verificar integridade dos hashes
+      const sessionHashValid = await this.verifySessionHash(session);
+      const contentHashValid = await this.verifyContentHash(session);
+      const timestampValid = this.verifyTimestamp(session.trustedTimestamp);
+
+      return {
+        verified: sessionHashValid && contentHashValid && timestampValid,
+        sessionValid: sessionHashValid,
+        contentValid: contentHashValid,
+        timestampValid: timestampValid,
+        details: {
+          sessionId: session.sessionId,
+          targetUrl: session.targetUrl,
+          status: session.status,
+          sessionHashValid,
+          contentHashValid,
+          timestampValid,
+          createdAt: session.createdAt,
+          processedAt: session.processedAt
+        }
+      };
+
+    } catch (error) {
+      console.error('Erro na verificação:', error);
+      return {
+        verified: false,
+        sessionValid: false,
+        contentValid: false,
+        timestampValid: false,
+        details: 'Erro durante a verificação'
+      };
+    }
+  }
+
+  // Verificar hash da sessão
+  private async verifySessionHash(session: any): Promise<boolean> {
+    try {
+      const expectedHash = await this.generateSessionHash({
+        sessionId: session.sessionId,
+        targetUrl: session.targetUrl,
+        metadata: session.metadata,
+        environment: session.environment,
+        screenshots: session.screenshots
+      });
+      
+      return expectedHash === session.sessionHash;
+    } catch {
+      return false;
+    }
+  }
+
+  // Verificar hash do conteúdo
+  private async verifyContentHash(session: any): Promise<boolean> {
+    try {
+      const expectedHash = await this.generateContentHash(
+        session.targetUrl, 
+        session.metadata
+      );
+      
+      return expectedHash === session.contentHash;
+    } catch {
+      return false;
+    }
+  }
+
+  // Verificar timestamp confiável
+  private verifyTimestamp(trustedTimestamp: string | null): boolean {
+    if (!trustedTimestamp) return false;
+    
+    try {
+      const timestamp = new Date(trustedTimestamp);
+      const now = new Date();
+      const diffInHours = Math.abs(now.getTime() - timestamp.getTime()) / (1000 * 60 * 60);
+      
+      // Considerar válido se o timestamp for de até 24 horas atrás
+      return diffInHours <= 24;
+    } catch {
+      return false;
+    }
+  }
+
+  // Função auxiliar para delay
+  private delay(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}