410 lines
12 KiB
TypeScript
410 lines
12 KiB
TypeScript
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 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 {
|
|
console.log('Buscando configurações do documento...');
|
|
const config = await this.getConfiguracao();
|
|
|
|
// Verificar se temos um timbrado para usar
|
|
const temTimbrado = !!config.timbradoUrl;
|
|
|
|
console.log(`Iniciando geração de PDF ${temTimbrado ? 'com' : 'sem'} timbrado...`);
|
|
|
|
// Se temos timbrado, vamos primeiro verificar se ele existe
|
|
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));
|
|
}
|
|
|
|
console.log('Verificando timbrado em:', timbradoPath);
|
|
|
|
try {
|
|
await fs.access(timbradoPath);
|
|
timbradoExists = true;
|
|
console.log('Timbrado encontrado');
|
|
} catch (e) {
|
|
console.error('Timbrado não encontrado:', e);
|
|
}
|
|
}
|
|
|
|
// 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);
|
|
|
|
/**
|
|
* Gera o PDF final combinando o timbrado com o conteúdo
|
|
*/
|
|
const gerarPdfComTimbrado = async (
|
|
content: string,
|
|
pageW: number,
|
|
pageH: number,
|
|
margins: any,
|
|
usesTimbrado: boolean,
|
|
timbradoFilePath: string
|
|
): Promise<Buffer> => {
|
|
console.log('Gerando PDF com timbrado...');
|
|
|
|
// 1. Se tem timbrado, carregar e validar primeiro
|
|
let timbradoTemplate = null;
|
|
if (usesTimbrado) {
|
|
try {
|
|
const timbradoBytes = await fs.readFile(timbradoFilePath);
|
|
const timbradoPdf = await PDFDocument.load(timbradoBytes);
|
|
|
|
if (timbradoPdf.getPageCount() > 0) {
|
|
// Criar um novo documento só para o template
|
|
const templateDoc = await PDFDocument.create();
|
|
const [templatePage] = await templateDoc.copyPages(timbradoPdf, [0]);
|
|
templateDoc.addPage(templatePage);
|
|
timbradoTemplate = templateDoc;
|
|
}
|
|
} catch (e) {
|
|
console.error('Erro ao carregar timbrado, prosseguindo sem ele:', e);
|
|
}
|
|
}
|
|
|
|
// 2. Gerar o PDF do conteúdo
|
|
const browser = await puppeteer.launch({
|
|
args: ['--no-sandbox', '--disable-setuid-sandbox'],
|
|
headless: true
|
|
});
|
|
|
|
try {
|
|
// Criar PDF do conteúdo
|
|
const page = await browser.newPage();
|
|
await page.setContent(`
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<meta charset="UTF-8">
|
|
<style>
|
|
@page { size: A4; margin: 0; }
|
|
body {
|
|
font-family: Arial, sans-serif;
|
|
font-size: 11pt;
|
|
line-height: 1.5;
|
|
margin: ${margins.top}px ${margins.right}px ${margins.bottom}px ${margins.left}px;
|
|
text-align: justify;
|
|
}
|
|
p { margin: 0 0 0.5em 0; text-align: justify; }
|
|
strong, b { font-weight: bold; }
|
|
em, i { font-style: italic; }
|
|
u { text-decoration: underline; }
|
|
</style>
|
|
</head>
|
|
<body>${content}</body>
|
|
</html>
|
|
`, { waitUntil: 'networkidle0' });
|
|
|
|
// Gerar PDF do conteúdo
|
|
const contentBuffer = await page.pdf({
|
|
format: 'A4',
|
|
printBackground: true,
|
|
margin: {
|
|
top: '0',
|
|
right: '0',
|
|
bottom: '0',
|
|
left: '0'
|
|
}
|
|
});
|
|
|
|
// Se não tem timbrado válido, retornar apenas o conteúdo
|
|
if (!timbradoTemplate) {
|
|
return contentBuffer;
|
|
}
|
|
|
|
// 3. Combinar timbrado com conteúdo
|
|
try {
|
|
const contentPdf = await PDFDocument.load(contentBuffer);
|
|
const finalPdf = await PDFDocument.create();
|
|
|
|
// Para cada página do conteúdo
|
|
for (let i = 0; i < contentPdf.getPageCount(); i++) {
|
|
// Copiar a página do timbrado primeiro
|
|
const [newTimbradoPage] = await finalPdf.copyPages(timbradoTemplate, [0]);
|
|
finalPdf.addPage(newTimbradoPage);
|
|
|
|
// Copiar e sobrepor o conteúdo
|
|
const [contentPage] = await finalPdf.copyPages(contentPdf, [i]);
|
|
const { width: contentWidth, height: contentHeight } = contentPage.getSize();
|
|
|
|
// Ajustar as dimensões se necessário
|
|
newTimbradoPage.drawPage(contentPage, {
|
|
x: 0,
|
|
y: 0,
|
|
width: contentWidth,
|
|
height: contentHeight,
|
|
opacity: 1
|
|
});
|
|
}
|
|
|
|
const finalBytes = await finalPdf.save();
|
|
return Buffer.from(finalBytes);
|
|
} catch (mergeError) {
|
|
console.error('Erro ao combinar PDFs, retornando conteúdo original:', mergeError);
|
|
return contentBuffer;
|
|
}
|
|
} finally {
|
|
await browser.close();
|
|
}
|
|
};
|
|
|
|
// Processar o conteúdo e gerar o PDF
|
|
const processedContent = this.processarTemplate(conteudo, escritorio);
|
|
const pageWidth = 595;
|
|
const pageHeight = 842;
|
|
const pdfBytes = await gerarPdfComTimbrado(
|
|
processedContent,
|
|
pageWidth,
|
|
pageHeight,
|
|
margens,
|
|
timbradoExists,
|
|
timbradoPath
|
|
);
|
|
console.log(`PDF gerado com sucesso: ${pdfBytes.length} bytes`);
|
|
return 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;
|
|
});
|
|
}
|
|
}
|