backend: fix PDFService.ts

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) {
-    const timbradoUrl = config.timbradoUrl 
+    // Limpa espaços, quebras de linha e tags vazias do final do conteúdo
-      ? `${process.env.BACKEND_URL || 'http://localhost:5000'}${config.timbradoUrl}`
+    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
-    console.log('Gerando PDF com timbrado:', timbradoUrl);
+    if (timbradoUrl) {
-
+      console.log('[PDF] Timbrado inserido no HTML:', timbradoUrl);
+    }
     return `
       <!DOCTYPE html>
       <html>
@@ -63,91 +75,162 @@ export class PdfService {
         <meta charset="UTF-8">
         <link href="https://fonts.googleapis.com/css2?family=Fira+Sans:wght@400;500;600&display=swap" rel="stylesheet">
         <style>
-          @page { 
+          @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.setContent(html, {
-      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

@@ -198,32 +198,27 @@ export class PdfService {
         page.drawPage(timbradoEmbed, { x: 0, y: 0, width: page.getWidth(), height: page.getHeight() });
       }
       // Após mesclar o timbrado
-      const pageCountBefore = pdfDoc.getPageCount();
+      let pageCountBefore = pdfDoc.getPageCount();
-      if (pageCountBefore > 1) {
+      // Remove páginas em branco no final do PDF (heurística baseada no tamanho do conteúdo)
-        // Heurística aprimorada: remove a última página apenas se estiver realmente vazia (sem texto, imagens ou gráficos)
+      while (pageCountBefore > 1) {
         const lastPage = pdfDoc.getPage(pageCountBefore - 1);
-        let isBlank = true;
+        const contentStreams = (lastPage as any).node.Contents();
-        // Verifica se há texto
+        // Se não houver conteúdo, é uma página em branco
-        const annotations = lastPage.node.Annots;
+        if (!contentStreams || contentStreams.length === 0) {
-        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);
+          pageCountBefore = pdfDoc.getPageCount();
+          continue;
+        }
+        // Soma o tamanho dos streams de conteúdo
+        const totalLength = contentStreams
+          .map((stream: any) => stream.contents.length)
+          .reduce((acc: number, len: number) => acc + len, 0);
+        // Se o conteúdo for muito pequeno (< 30 bytes), considera em branco
+        if (totalLength < 30) {
+          pdfDoc.removePage(pageCountBefore - 1);
+          pageCountBefore = pdfDoc.getPageCount();
+        } else {
+          break;
         }
       }
       const mergedPdf = await pdfDoc.save();