fix atendimentos.ts

Signed-off-by: Rodrigo Martins <rodrigo.sousa.577@gmail.com>
This commit is contained in:
rodrigo committed 2025-04-13 18:22:05 -03:00
1 parent 33d9fe8688
commit 7fca13c529
7 files changed
+565 -187

No files matched your search

+436 -165
View File
@@ -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,467 @@ 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;
/**
* 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);
// 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');
}
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) {
try {
// 1. Buscar configuração do template
const config = await prisma.configuracaoDocumento.findFirst({
orderBy: { criadoEm: 'desc' }
});
// 2. Gerar PDF do conteúdo
const browser = await puppeteer.launch({
headless: 'new',
args: ['--no-sandbox']
});
const page = await browser.newPage();
// 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;
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;
}
.content {
margin: 0;
padding: 0;
min-height: calc(100vh - 58mm);
position: relative;
// 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`
}
});
}
p { margin: 0.7em 0; }
h1, h2, h3 { margin: 0.8em 0; }
</style>
</head>
<body>
<div class="content">
${conteudo}
</div>
</body>
</html>
`;
// 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]);
} 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'
);
}
}
}
};
// 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);
// Gerar PDF de alta fidelidade com Puppeteer
const pdfBytes = await converterHtmlParaPdf(processedContent);
console.log(`PDF gerado com sucesso: ${pdfBytes.length} bytes`);
return pdfBytes;
} catch (error) {
console.error('Erro ao gerar PDF:', error);
throw error;
}
// 6. Gerar PDF final
const pdfBytes = await pdfDoc.save();
return Buffer.from(pdfBytes);
} 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;
});
}
}