fix atendimentos.ts

Signed-off-by: Rodrigo Martins <rodrigo.sousa.577@gmail.com>
2025-04-13 18:25:44 -03:00
1 parent 33d9fe8688
commit 9a5764b1ab
@@ -1,11 +1,18 @@
 FROM node:20-slim

+# Configurar Puppeteer para usar o Chromium do sistema
+ENV PUPPETEER_SKIP_CHROMIUM_DOWNLOAD=true
+ENV PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium-browser
+
 # Instalar dependências do sistema
-RUN apt-get update && apt-get install -y \
-    chromium \
+RUN apt-get update && apt-get install -y chromium \
    libgconf-2-4 \
    postgresql-client \
-    && rm -rf /var/lib/apt/lists/*
+    && rm -rf /var/lib/apt/lists/* \
+    && ln -sf /usr/bin/chromium /usr/bin/chromium-browser
+
+# Verificar a instalação do Chromium
+RUN chromium --version

 # Criar diretório da aplicação
 WORKDIR /usr/src/app
@@ -0,0 +1,13 @@
+version: '3.8'
+services:
+  backend:
+    build: .
+    ports:
+      - "5000:5000"
+    environment:
+      - NODE_ENV=production
+      - CHROME_BIN=/usr/bin/google-chrome-stable
+      # ... outras variáveis de ambiente existentes ...
+    volumes:
+      - .:/usr/src/app
+      - /usr/src/app/node_modules
@@ -49,6 +49,7 @@
    "multer": "^1.4.5-lts.1",
    "opentimestamps-javascript": "^1.0.1",
    "pdf-lib": "^1.17.1",
+    "pdfkit": "^0.13.0",
    "puppeteer": "^24.5.0",
    "qrcode": "^1.5.3",
    "react": "^18.2.0",
@@ -111,11 +112,5 @@
      "--disable-gpu",
      "--window-size=1920x1080"
    ]
-  },
-  "puppeteerOptions": {
-    "browserFetcher": {
-      "platform": "win32",
-      "downloadPath": ".cache/puppeteer"
-    }
  }
 }
@@ -0,0 +1,9 @@
+-- Identificar registros com UUID inválido
+SELECT id, uuid_column
+FROM atendimento
+WHERE uuid_column !~ '^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$';
+
+-- Atualizar registros com UUID inválido
+UPDATE atendimento
+SET uuid_column = gen_random_uuid()
+WHERE uuid_column !~ '^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$';
@@ -200,7 +200,7 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
  // Monitorar o valor do CEP para autopreenchimento
  const cepValue = watch("cep");

-  // Função para buscar dados do CEP - versão com gerenciamento de estados do componente
+  // Função para buscar dados do CEP - versão corrigida
  const fetchAddressByCep = useCallback(async (cep: string) => {
    if (!cep || cep.length !== 8) return;

@@ -213,7 +213,6 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({

      if (response.data && !response.data.erro) {
        // Usar estado local para garantir re-renderização imediata
-        // Forçar preenchimento dos campos e atualização da interface
        const endereco = response.data.logradouro || "";
        const bairro = response.data.bairro || "";
        const cidade = response.data.localidade || "";
@@ -225,8 +224,7 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
        setValue("cidade", cidade, { shouldValidate: true });
        setValue("estado", estado, { shouldValidate: true });

-        // Garantir re-renderização do componente
-        // Esta é a parte crucial: forçar o componente a re-renderizar com novo estado
+        // Atualizar o estado para re-renderização do componente
        setEnderecoState({
          endereco,
          bairro,
@@ -235,13 +233,23 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
          preenchido: true,
        });

-        // Focar no próximo campo
-        setTimeout(() => {
-          const numeroInput = document.querySelector(
-            'input[name="numero"]'
-          ) as HTMLInputElement;
-          if (numeroInput) numeroInput.focus();
-        }, 100);
+        // Focar no próximo campo apenas se o usuário não estiver digitando ativamente
+        // Esta alteração evita interromper o fluxo natural de preenchimento
+        const activeElement = document.activeElement;
+        const isUserTyping = 
+          activeElement && 
+          (activeElement.tagName === 'INPUT' || activeElement.tagName === 'SELECT') && 
+          activeElement !== document.querySelector('input[name="cep"]');
+        
+        // Só focar no campo número se o usuário não estiver digitando em outro campo
+        if (!isUserTyping) {
+          setTimeout(() => {
+            const numeroInput = document.querySelector(
+              'input[name="numero"]'
+            ) as HTMLInputElement;
+            if (numeroInput) numeroInput.focus();
+          }, 100);
+        }
      } else {
        console.error("CEP não encontrado");
        alert("CEP não encontrado. Por favor, verifique o CEP informado.");
@@ -55,6 +55,13 @@ const orgaoJulgadorRepository = new OrgaoJulgadorRepository();
 const custaProcessualRepository = new CustaProcessualRepository();
 const honorarioRepository = new HonorarioRepository();

+// Atualizar a função isValidUUID para ser mais robusta
+const isValidUUID = (uuid: string | null | undefined): boolean => {
+  if (!uuid) return false;
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(uuid);
+};
+
 // Middleware para extrair usuário do token
 // Remover este middleware pois já temos o auth.ts
 // const extractUser = (req: any, res: any, next: any) => { ... }
@@ -1000,9 +1007,9 @@ app.post("/api/atendimentos", authMiddleware, async (req, res) => {
          conteudo,
          cliente: { connect: { id: clienteId } },
          usuario: { connect: { id: req.user!.id } },
-          ...(processoId && { processo: { connect: { id: processoId } } }),
+          ...(processoId && { processo: { connect: { id: processoId } } }), // Adicionar vírgula aqui
          status: 'ATIVO',
-          dataAtualizacao: new Date(),
+          dataAtualizacao: new Date()
        },
        include: {
          cliente: true,
@@ -1337,6 +1344,74 @@ app.delete("/api/agendamentos/:id", authMiddleware, async (req, res) => {
  }
 });

+// Atualizar a rota de agendamentos
+app.get("/api/atendimentos/agendamentos", async (req, res) => {
+  try {
+    const { data } = req.query;
+    
+    if (!data || typeof data !== 'string') {
+      return res.status(400).json({ error: 'Data inválida' });
+    }
+
+    const dataConsulta = new Date(data);
+    
+    // Validar se a data é válida
+    if (isNaN(dataConsulta.getTime())) {
+      return res.status(400).json({ error: 'Formato de data inválido' });
+    }
+
+    // Definir início e fim do dia
+    const inicioDia = new Date(dataConsulta.setHours(0, 0, 0, 0));
+    const fimDia = new Date(dataConsulta.setHours(23, 59, 59, 999));
+
+    // Buscar na tabela correta com filtros apropriados
+    const agendamentos = await prisma.agendamentoAtendimento.findMany({
+      where: {
+        data: {
+          gte: inicioDia,
+          lte: fimDia
+        }
+      },
+      include: {
+        cliente: {
+          select: {
+            id: true,
+            nome: true,
+            cpfCnpj: true,
+            telefone: true
+          }
+        },
+        usuario: {
+          select: {
+            id: true,
+            nome: true
+          }
+        }
+      },
+      orderBy: {
+        data: 'asc'
+      }
+    });
+
+    // Filtrar apenas agendamentos com UUIDs válidos
+    const validAgendamentos = agendamentos.filter(agendamento => 
+      isValidUUID(agendamento.id) && 
+      isValidUUID(agendamento.clienteId) && 
+      isValidUUID(agendamento.usuarioId)
+    );
+
+    console.log(`Encontrados ${validAgendamentos.length} agendamentos válidos para ${data}`);
+    
+    res.json(validAgendamentos);
+  } catch (error) {
+    console.error('Erro ao buscar agendamentos:', error);
+    res.status(500).json({ 
+      error: 'Erro ao buscar agendamentos',
+      details: error instanceof Error ? error.message : 'Erro desconhecido'
+    });
+  }
+});
+
 // Erro handling middleware
 app.use(
  (
@@ -150,14 +150,13 @@ export class PdfService {
        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
        }
      });
@@ -166,195 +165,568 @@ export class PdfService {

      // Retornar configuração padrão se não existir
      return {
-        cabecalhoHtml: config?.cabecalhoHtml || `
+        // Valores padrão
+        cabecalhoHtml: `
          <div style="text-align: center; padding: 20px;">
            <h2 style="margin:0;font-size:14pt">{{escritorio.nome}}</h2>
          </div>
        `,
-        rodapeHtml: config?.rodapeHtml || `
+        rodapeHtml: `
          <div style="text-align: center; font-size: 10pt;">
            {{escritorio.endereco}}<br>
            Tel: {{escritorio.telefone}} | Email: {{escritorio.email}}
          </div>
        `,
-        logoUrl: config?.logoUrl || '',
+        // Campos que existem no modelo
        timbradoUrl: config?.timbradoUrl || '',
        timbradoMarginTop: config?.timbradoMarginTop || 100,
        timbradoMarginBottom: config?.timbradoMarginBottom || 50,
        timbradoMarginLeft: config?.timbradoMarginLeft || 50,
-        timbradoMarginRight: config?.timbradoMarginRight || 50
+        timbradoMarginRight: config?.timbradoMarginRight || 50,
+        templatePadrao: config?.templatePadrao || null,
+        margensTemplate: config?.margensTemplate || null
      };
    } catch (error) {
      console.error('Erro ao buscar configuração:', error);
-      throw new Error('Falha ao buscar configuração');
+      // 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
+      };
    }
  }

-  private gerarHTML(content: string, config: any) {
-    const timbradoUrl = config.timbradoUrl 
-      ? `${process.env.BACKEND_URL || 'http://localhost:5000'}${config.timbradoUrl}`
-      : '';
-
-    console.log('Gerando PDF com timbrado:', 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: 0;
-            size: A4;
-          }
-          
-          body { 
-            margin: 0;
-            padding: 0;
-            font-family: 'Fira Sans', Arial, sans-serif;
-            font-size: 11pt;
-            line-height: 1.5;
-            position: relative;
-            min-height: 100vh;
-          }
-
-          .page {
-            position: relative;
-            width: 21cm;
-            min-height: 29.7cm;
-            padding: ${config.timbradoMarginTop || 100}px ${config.timbradoMarginRight || 50}px ${config.timbradoMarginBottom || 50}px ${config.timbradoMarginLeft || 50}px;
-            background: ${timbradoUrl ? `url('${timbradoUrl}')` : 'none'};
-            background-size: cover;
-            background-position: center;
-            background-repeat: no-repeat;
-            box-sizing: border-box;
-          }
-
-          .content {
-            position: relative;
-            z-index: 1;
-          }
-        </style>
-      </head>
-      <body>
-        <div class="page">
-          <div class="content">
-            ${content}
-          </div>
-        </div>
-      </body>
-      </html>
-    `;
-  }
-
-  async gerarPDF(conteudo: string, escritorio: any) {
+  /**
+   * Gera um PDF a partir do conteúdo HTML e dados do escritório
+   * @param conteudo - Conteúdo HTML para o PDF
+   * @param escritorio - Dados do escritório para substituir no template
+   * @returns Buffer contendo o PDF gerado
+   */
+  async gerarPDF(conteudo: string, escritorio: any = {}): Promise<Buffer> {
    try {
-      // 1. Buscar configuração do template
-      const config = await prisma.configuracaoDocumento.findFirst({
-        orderBy: { criadoEm: 'desc' }
-      });
+      console.log('Buscando configurações do documento...');
+      const config = await this.getConfiguracao();
      
-      // 2. Gerar PDF do conteúdo
-      const browser = await puppeteer.launch({
-        headless: 'new',
-        args: ['--no-sandbox']
-      });
+      // Verificar se temos um timbrado para usar
+      const temTimbrado = !!config.timbradoUrl;
      
-      const page = await browser.newPage();
+      console.log(`Iniciando geração de PDF ${temTimbrado ? 'com' : 'sem'} timbrado...`);
      
-      // Usar template padrão ou fallback para o template básico
-      const template = config?.templatePadrao || `
-        <!DOCTYPE html>
-        <html>
-          <head>
-            <link href="https://fonts.googleapis.com/css2?family=Fira+Sans:wght@400;500;700&display=swap" rel="stylesheet">
-            <style>
-              body {
-                font-family: 'Fira Sans', Arial, sans-serif;
-                font-size: 11pt;
-                line-height: 1.3;
-                margin: 0;
-                padding: 0;
-              }
+      // Se temos timbrado, vamos primeiro verificar se ele existe
+      let timbradoPath = '';
+      let timbradoExists = false;
      
-              .content {
-                margin: 0;
-                padding: 0;
-                min-height: calc(100vh - 58mm);
-                position: relative;
-              }
+      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));
+        }
        
-              p { margin: 0.7em 0; }
-              h1, h2, h3 { margin: 0.8em 0; }
-            </style>
-          </head>
-          <body>
-            <div class="content">
-              ${conteudo}
-            </div>
-          </body>
-        </html>
-      `;
+        console.log('Verificando timbrado em:', timbradoPath);
        
-      // Processar o template substituindo variáveis
-      const templateProcessado = template.replace(/\{\{(.+?)\}\}/g, (match, key) => {
-        return escritorio[key.trim()] || match;
-      });
-
-      await page.setContent(templateProcessado);
-
-      const margens = config?.margensTemplate || {
-        top: '35mm',
-        bottom: '29mm',
-        left: '25mm',
-        right: '25mm'
-      };
-
-      const contentPdfBuffer = await page.pdf({
-        format: 'A4',
-        margin: margens,
-        displayHeaderFooter: false,
-        printBackground: true
-      });
-
-      await browser.close();
-
-      // 2. Carregar os PDFs
-      const templatePath = path.join(process.cwd(), 'public', 'uploads', 'Timbrado_2025.pdf');
-      const templateBytes = await fs.readFile(templatePath);
-      
-      const templateDoc = await PDFDocument.load(templateBytes);
-      const contentDoc = await PDFDocument.load(contentPdfBuffer);
-
-      // 3. Criar documento final
-      const pdfDoc = await PDFDocument.create();
-
-      // 4. Copiar template e conteúdo
-      const [templatePage] = await templateDoc.copyPages(templateDoc, [0]);
-      const contentPages = await contentDoc.getPages();
-
-      // 5. Para cada página do conteúdo
-      for (let i = 0; i < contentPages.length; i++) {
-        // Primeiro: adicionar template
-        const page = await pdfDoc.embedPage(templatePage);
-        const contentPage = await pdfDoc.embedPage(contentPages[i]);
-        
-        // Segundo: criar nova página
-        const newPage = pdfDoc.addPage([page.width, page.height]);
-        
-        // Terceiro: desenhar template e conteúdo
-        newPage.drawPage(page);
-        newPage.drawPage(contentPage);
+        try {
+          await fs.access(timbradoPath);
+          timbradoExists = true;
+          console.log('Timbrado encontrado');
+        } catch (e) {
+          console.error('Timbrado não encontrado:', e);
+        }
      }
      
-      // 6. Gerar PDF final
-      const pdfBytes = await pdfDoc.save();
-      return Buffer.from(pdfBytes);
+      // Margens definidas no template ou padrão
+      const margens = config.margensTemplate || {
+        top: config.timbradoMarginTop || 100,
+        left: config.timbradoMarginLeft || 50,
+        right: config.timbradoMarginRight || 50,
+        bottom: config.timbradoMarginBottom || 50
+      };
      
+      console.log('Usando margens:', margens);
+      
+      // Abordagem focada em PDF de alta qualidade com formatação precisa
+      try {
+        console.log('Gerando PDF com formatação avançada...');
+        
+        // 1. Primeiro carregar o timbrado se existir
+        let pdfDoc;
+        const fontSize = 11;
+        const lineHeight = fontSize * 1.5; // Espaçamento entre linhas um pouco maior para melhor legibilidade
+        const pageWidth = 595;
+        const pageHeight = 842;
+        
+        if (timbradoExists) {
+          console.log('Usando timbrado como base do documento...');
+          // Carregar o arquivo de timbrado
+          const timbradoBytes = await fs.readFile(timbradoPath);
+          try {
+            pdfDoc = await PDFDocument.load(timbradoBytes);
+            console.log('Timbrado carregado com sucesso');
+            
+            // Verificar se o timbrado tem páginas
+            if (pdfDoc.getPageCount() === 0) {
+              console.log('Timbrado não contém páginas, adicionando página padrão');
+              pdfDoc.addPage([pageWidth, pageHeight]);
+            }
+          } catch (loadError) {
+            console.error('Erro ao carregar timbrado:', loadError);
+            // Se falhar ao carregar o timbrado, criar novo documento
+            pdfDoc = await PDFDocument.create();
+            pdfDoc.addPage([pageWidth, pageHeight]);
+          }
+        } else {
+          console.log('Criando novo documento sem timbrado...');
+          pdfDoc = await PDFDocument.create();
+          pdfDoc.addPage([pageWidth, pageHeight]);
+        }
+        
+        // 2. Carregar fontes
+        console.log('Carregando fontes...');
+        let font, boldFont, italicFont;
+        
+        try {
+          // Verificar se temos a fonte Fira Sans disponível
+          const firaSansPath = path.join(process.cwd(), 'public', 'fonts', 'FiraSans-Regular.ttf');
+          const firaSansBoldPath = path.join(process.cwd(), 'public', 'fonts', 'FiraSans-Bold.ttf');
+          
+          // Verificar se o arquivo existe
+          let firaSansExists = false;
+          try {
+            await fs.access(firaSansPath);
+            firaSansExists = true;
+            console.log('Fonte Fira Sans encontrada, utilizando-a para o documento');
+          } catch (e) {
+            console.log('Fonte Fira Sans não encontrada, usando Helvetica como fallback');
+          }
+          
+          if (firaSansExists) {
+            // Carregar as fontes Fira Sans
+            try {
+              const firaSansBytes = await fs.readFile(firaSansPath);
+              font = await pdfDoc.embedFont(firaSansBytes);
+              
+              try {
+                const firaSansBoldBytes = await fs.readFile(firaSansBoldPath);
+                boldFont = await pdfDoc.embedFont(firaSansBoldBytes);
+              } catch (e) {
+                console.log('Fira Sans Bold não encontrada, usando regular como fallback');
+                boldFont = font;
+              }
+              
+              // Não temos itálico, usar regular
+              italicFont = font;
+            } catch (fontError) {
+              console.error('Erro ao carregar Fira Sans:', fontError);
+              throw fontError; // Forçar fallback para Helvetica
+            }
+          } else {
+            throw new Error('Fira Sans não encontrada');
+          }
+        } catch (error) {
+          // Fallback para Helvetica
+          console.log('Usando Helvetica como fallback');
+          font = await pdfDoc.embedFont(StandardFonts.Helvetica);
+          boldFont = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
+          italicFont = await pdfDoc.embedFont(StandardFonts.HelveticaOblique);
+        }
+        
+        // 3. Processar e formatar o HTML com preservação de estrutura
+        console.log('Processando HTML com preservação de estrutura...');
+        
+        // Processar variáveis
+        const processedContent = this.processarTemplate(conteudo, escritorio);
+        
+        // Função melhorada para decodificar entidades HTML
+        const decodeHtmlEntities = (text: string): string => {
+          // Criar um elemento temporário para decodificar as entidades HTML corretamente
+          if (typeof text !== 'string') return '';
+          
+          // Lista ampliada de entidades HTML comuns em português
+          const entities: Record<string, string> = {
+            "&nbsp;": " ", "&amp;": "&", "&lt;": "<", "&gt;": ">", "&quot;": "\"", "&apos;": "'",
+            "&cent;": "¢", "&pound;": "£", "&yen;": "¥", "&euro;": "€", "&copy;": "©", "&reg;": "®",
+            "&Agrave;": "À", "&agrave;": "à", "&Aacute;": "Á", "&aacute;": "á", 
+            "&Acirc;": "Â", "&acirc;": "â", "&Atilde;": "Ã", "&atilde;": "ã",
+            "&Auml;": "Ä", "&auml;": "ä", "&Aring;": "Å", "&aring;": "å", 
+            "&AElig;": "Æ", "&aelig;": "æ", "&Ccedil;": "Ç", "&ccedil;": "ç",
+            "&Egrave;": "È", "&egrave;": "è", "&Eacute;": "É", "&eacute;": "é", 
+            "&Ecirc;": "Ê", "&ecirc;": "ê", "&Euml;": "Ë", "&euml;": "ë",
+            "&Igrave;": "Ì", "&igrave;": "ì", "&Iacute;": "Í", "&iacute;": "í", 
+            "&Icirc;": "Î", "&icirc;": "î", "&Iuml;": "Ï", "&iuml;": "ï",
+            "&ETH;": "Ð", "&eth;": "ð", "&Ntilde;": "Ñ", "&ntilde;": "ñ", 
+            "&Ograve;": "Ò", "&ograve;": "ò", "&Oacute;": "Ó", "&oacute;": "ó",
+            "&Ocirc;": "Ô", "&ocirc;": "ô", "&Otilde;": "Õ", "&otilde;": "õ", 
+            "&Ouml;": "Ö", "&ouml;": "ö", "&Oslash;": "Ø", "&oslash;": "ø",
+            "&Ugrave;": "Ù", "&ugrave;": "ù", "&Uacute;": "Ú", "&uacute;": "ú", 
+            "&Ucirc;": "Û", "&ucirc;": "û", "&Uuml;": "Ü", "&uuml;": "ü", 
+            "&Yacute;": "Ý", "&yacute;": "ý", "&yuml;": "ÿ", "&szlig;": "ß"
+          };
+          
+          // Substituir todas as entidades HTML conhecidas
+          let decoded = text;
+          for (const [entity, char] of Object.entries(entities)) {
+            decoded = decoded.split(entity).join(char);
+          }
+          
+          // Usar expressão regular para capturar entidades numéricas
+          return decoded.replace(/&#(\d+);/g, (_, dec) => String.fromCharCode(parseInt(dec, 10)));
+        };
+        
+        // Uma abordagem completamente nova para processar HTML
+        // Usando a biblioteca puppeteer para renderizar HTML com alta fidelidade
+        const converterHtmlParaPdf = async (htmlContent: string): Promise<Buffer> => {
+          console.log('Usando Puppeteer para renderização de alta fidelidade...');
+          
+          try {
+            // Garantir que o HTML tenha metadados de codificação adequados
+            const completeHtml = `
+              <!DOCTYPE html>
+              <html>
+                <head>
+                  <meta charset="UTF-8">
+                  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                  <style>
+                    body {
+                      font-family: Arial, Helvetica, sans-serif;
+                      font-size: 11pt;
+                      line-height: 1.5;
+                      margin: ${margens.top}px ${margens.right}px ${margens.bottom}px ${margens.left}px;
+                      text-align: justify;
+                    }
+                    p {
+                      margin: 0 0 0.5em 0;
+                      text-align: justify;
+                    }
+                    h1, h2, h3, h4, h5, h6 {
+                      margin-top: 1em;
+                      margin-bottom: 0.5em;
+                    }
+                    strong, b {
+                      font-weight: bold;
+                    }
+                    em, i {
+                      font-style: italic;
+                    }
+                    u {
+                      text-decoration: underline;
+                    }
+                    .justify {
+                      text-align: justify;
+                    }
+                    .indent {
+                      text-indent: 2em;
+                    }
+                  </style>
+                </head>
+                <body>
+                  ${htmlContent}
+                </body>
+              </html>
+            `;
+            
+            // Iniciar navegador headless
+            const browser = await puppeteer.launch({
+              args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage'],
+              headless: true
+            });
+            
+            try {
+              const page = await browser.newPage();
+              await page.setContent(completeHtml, { waitUntil: 'networkidle0' });
+              
+              // Definir o tamanho da página para A4
+              await page.setViewport({ width: pageWidth, height: pageHeight });
+              
+              // Se tiver timbrado, usamos a abordagem pdf-lib + Puppeteer
+              if (timbradoExists) {
+                // Gerar PDF temporário sem timbrado
+                const tmpPdfBuffer = await page.pdf({
+                  format: 'A4',
+                  printBackground: true,
+                  margin: {
+                    top: '0',
+                    right: '0',
+                    bottom: '0',
+                    left: '0'
+                  }
+                });
+                
+                // Carregar o PDF gerado pelo Puppeteer
+                const contentPdf = await PDFDocument.load(tmpPdfBuffer);
+                
+                // Combinar com o timbrado
+                const combinedPdf = await PDFDocument.create();
+                
+                // Para cada página do conteúdo
+                for (let i = 0; i < contentPdf.getPageCount(); i++) {
+                  // Copiar a página do timbrado
+                  const [timbradoPage] = await combinedPdf.copyPages(pdfDoc, [0]);
+                  const page = combinedPdf.addPage(timbradoPage);
+                  
+                  // Copiar o conteúdo sobre o timbrado
+                  const [contentPage] = await combinedPdf.copyPages(contentPdf, [i]);
+                  page.drawPage(contentPage, {
+                    x: 0, y: 0,
+                    width: page.getWidth(),
+                    height: page.getHeight(),
+                    opacity: 1
+                  });
+                }
+                
+                const combinedBytes = await combinedPdf.save();
+                return Buffer.from(combinedBytes);
+              } else {
+                // Gerar PDF direto do Puppeteer
+                return await page.pdf({
+                  format: 'A4',
+                  printBackground: true,
+                  margin: {
+                    top: `${margens.top}px`,
+                    right: `${margens.right}px`,
+                    bottom: `${margens.bottom}px`,
+                    left: `${margens.left}px`
+                  }
+                });
+              }
+            } finally {
+              await browser.close();
+            }
+          } catch (puppeteerError) {
+            console.error('Erro ao renderizar com Puppeteer:', puppeteerError);
+            
+            // Método de fallback simplificado e à prova de falhas
+            console.log('Usando método de fallback simplificado...');
+            
+            try {
+              // Criar um novo documento PDF do zero
+              const fallbackPdf = await PDFDocument.create();
+              let fallbackPage = fallbackPdf.addPage([pageWidth, pageHeight]);
+              
+              // Definir variáveis locais para esse método
+              const fallbackFont = await fallbackPdf.embedFont(StandardFonts.Helvetica);
+              const fallbackBoldFont = await fallbackPdf.embedFont(StandardFonts.HelveticaBold);
+              let fallbackY = pageHeight - margens.top;
+              const fallbackSize = 11;
+              const fallbackLineHeight = fallbackSize * 1.5;
+              
+              // Decodificar e limpar o HTML
+              const fallbackText = htmlContent
+                .replace(/<[^>]*>/g, ' ')
+                .replace(/&[a-zA-Z]+;/g, ' ')
+                .replace(/\s+/g, ' ')
+                .trim();
+              
+              // Titulo do documento
+              fallbackPage.drawText('Documento gerado pelo sistema', {
+                x: margens.left,
+                y: fallbackY,
+                font: fallbackBoldFont,
+                size: fallbackSize + 2
+              });
+              
+              // Adicionar texto simples em linhas
+              let currentY = fallbackY - fallbackLineHeight * 2;
+              const maxCharsPerLine = 80;
+              
+              // Dividir texto em linhas sem exceder a largura disponível
+              for (let i = 0; i < fallbackText.length; i += maxCharsPerLine) {
+                const line = fallbackText.substring(i, i + maxCharsPerLine);
+                
+                // Verificar se ainda há espaço na página
+                if (currentY < margens.bottom) {
+                  const newPage = fallbackPdf.addPage([pageWidth, pageHeight]);
+                  fallbackPage = newPage;
+                  currentY = pageHeight - margens.top;
+                }
+                
+                fallbackPage.drawText(line, {
+                  x: margens.left,
+                  y: currentY,
+                  font: fallbackFont,
+                  size: fallbackSize
+                });
+                
+                currentY -= fallbackLineHeight;
+              }
+              
+              // Adicionar rodapé com data e hora
+              fallbackPage.drawText(`Gerado em: ${new Date().toLocaleString('pt-BR')}`, {
+                x: margens.left,
+                y: margens.bottom,
+                font: fallbackFont,
+                size: 8,
+                color: rgb(0.5, 0.5, 0.5)
+              });
+              
+              const fallbackBytes = await fallbackPdf.save();
+              return Buffer.from(fallbackBytes);
+            } catch (fallbackError) {
+              console.error('Erro no método de fallback:', fallbackError);
+              
+              // Último recurso: PDF mínimo com texto simples
+              try {
+                const minimalPdf = await PDFDocument.create();
+                const minimalPage = minimalPdf.addPage();
+                const minimalFont = await minimalPdf.embedFont(StandardFonts.Helvetica);
+                
+                minimalPage.drawText('Falha ao gerar documento. Contate o suporte.', {
+                  x: 50,
+                  y: minimalPage.getHeight() - 50,
+                  font: minimalFont,
+                  size: 12
+                });
+                
+                const minimalBytes = await minimalPdf.save();
+                return Buffer.from(minimalBytes);
+              } catch (criticalError) {
+                console.error('Falha crítica na geração do PDF:', criticalError);
+                
+                // Se chegou aqui, vamos retornar um PDF vazio
+                return Buffer.from(
+                  '%PDF-1.4\n1 0 obj\n<</Type/Catalog/Pages 2 0 R>>\nendobj\n2 0 obj\n<</Type/Pages/Kids[3 0 R]/Count 1>>\nendobj\n3 0 obj\n<</Type/Page/MediaBox[0 0 595 842]/Parent 2 0 R/Resources<<>>>>\nendobj\nxref\n0 4\n0000000000 65535 f\n0000000015 00000 n\n0000000060 00000 n\n0000000111 00000 n\ntrailer\n<</Size 4/Root 1 0 R>>\nstartxref\n190\n%%EOF'
+                );
+              }
+            }
+          }
+        };
+        
+        // Método simplificado para combinar um PDF com timbrado
+        const combinarComTimbrado = async (contentBuffer: Buffer): Promise<Buffer> => {
+          try {
+            console.log('Combinando conteúdo com timbrado de forma simplificada...');
+            
+            // Carregar documentos
+            const contentPdf = await PDFDocument.load(contentBuffer);
+            const timbradoPdf = await PDFDocument.load(await fs.readFile(timbradoPath));
+            
+            // Verificar se timbrado tem página
+            if (timbradoPdf.getPageCount() === 0) {
+              console.log('Timbrado sem páginas, retornando conteúdo original');
+              return contentBuffer;
+            }
+            
+            // Criar novo documento
+            const combinedDoc = await PDFDocument.create();
+            
+            // Copiar a página de timbrado como template
+            const [timbradoTemplate] = await combinedDoc.copyPages(timbradoPdf, [0]);
+            
+            // Para cada página do conteúdo, criar nova página baseada no timbrado
+            for (let i = 0; i < contentPdf.getPageCount(); i++) {
+              // Primeiro adicionar a página do timbrado
+              const newPage = combinedDoc.addPage([pageWidth, pageHeight]);
+              
+              // Desenhar o timbrado como imagem de fundo
+              // Em vez de usar drawPage, vamos extrair e usar como imagem se necessário
+              try {
+                newPage.drawPage(timbradoTemplate, {
+                  x: 0, y: 0,
+                  width: pageWidth,
+                  height: pageHeight,
+                  opacity: 0.99  // Ligeiramente transparente para evitar problemas de renderização
+                });
+              } catch (pageDrawError) {
+                console.warn('Não foi possível desenhar o timbrado como página, ignorando');
+              }
+              
+              // Copiar e desenhar o conteúdo sobre o timbrado
+              try {
+                const [contentPage] = await combinedDoc.copyPages(contentPdf, [i]);
+                
+                // Em vez de desenhar a página inteira, vamos extrair o conteúdo como imagem
+                const { width, height } = contentPage.getSize();
+                
+                // Calcular as dimensões mantendo proporção mas dentro das margens
+                const contentWidth = pageWidth - margens.left - margens.right;
+                const contentHeight = (contentWidth / width) * height;
+                
+                // Ajustar de acordo com as margens
+                newPage.drawPage(contentPage, {
+                  x: margens.left, 
+                  y: margens.bottom,
+                  width: contentWidth,
+                  height: contentHeight,
+                  opacity: 1
+                });
+              } catch (contentError) {
+                console.error('Erro ao desenhar conteúdo na página:', contentError);
+              }
+            }
+            
+            const combinedBytes = await combinedDoc.save();
+            return Buffer.from(combinedBytes);
+          } catch (combineError) {
+            console.error('Erro ao combinar com timbrado:', combineError);
+            return contentBuffer; // Se falhar, retorna o conteúdo original
+          }
+        };
+        
+        try {
+          // Gerar PDF de alta fidelidade com Puppeteer
+          let pdfBytes = await converterHtmlParaPdf(processedContent);
+          
+          // Se tiver timbrado, tentar aplicá-lo em um passo adicional
+          if (timbradoExists) {
+            try {
+              console.log('Tentando aplicar timbrado ao documento...');
+              pdfBytes = await combinarComTimbrado(pdfBytes);
+            } catch (timbradoError) {
+              console.error('Erro ao aplicar timbrado (usando conteúdo original):', timbradoError);
+            }
+          }
+          
+          console.log(`PDF gerado com sucesso: ${pdfBytes.length} bytes`);
+          return pdfBytes;
+        } catch (finalError) {
+          console.error('Erro final na geração de PDF:', finalError);
+          
+          // Em último caso, gerar PDF mínimo com texto
+          const minimalPdf = await PDFDocument.create();
+          const minimalPage = minimalPdf.addPage();
+          const minimalFont = await minimalPdf.embedFont(StandardFonts.Helvetica);
+          
+          minimalPage.drawText('Falha ao gerar documento. Contate o suporte.', {
+            x: 50,
+            y: minimalPage.getHeight() - 50,
+            font: minimalFont,
+            size: 12
+          });
+          
+          const minimalBytes = await minimalPdf.save();
+          return Buffer.from(minimalBytes);
+        }
+      } catch (error) {
+        console.error('Erro ao gerar PDF:', error);
+        throw error;
+      }
    } catch (error) {
-      console.error('Erro ao gerar PDF:', error);
-      throw new Error('Falha ao gerar PDF');
+      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;
+    });
+  }
 }