rodrigo/advx
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix atendimentos.ts

Browse Source 
Signed-off-by: Rodrigo Martins <rodrigo.sousa.577@gmail.com>
This commit is contained in:
rodrigo committed 2025-04-13 03:17:58 -03:00
1 parent 33d9fe8688
commit b5cb009737
7 files changed
+334 -150
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/server/services/PdfService.ts
+205 -128
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,112 +165,73 @@ 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' }
});
// 2. Gerar PDF do conteúdo
const browser = await puppeteer.launch({
headless: 'new',
args: ['--no-sandbox']
});
const page = await browser.newPage();
console.log('Buscando configurações do documento...');
const config = await this.getConfiguracao();
console.log('Iniciando geração de PDF com Chromium...');
// 1. Primeiro gerar o PDF do conteúdo
const browser = await puppeteer.launch({
executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || '/usr/bin/chromium-browser',
headless: true,
args: ['--no-sandbox', '--disable-setuid-sandbox']
});
// 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">
<meta charset="UTF-8">
<style>
body {
font-family: 'Fira Sans', Arial, sans-serif;
font-family: Arial, sans-serif;
font-size: 11pt;
line-height: 1.3;
margin: 0;
@@ -299,59 +259,176 @@ export class PdfService {
// Processar o template substituindo variáveis
const templateProcessado = template.replace(/\{\{(.+?)\}\}/g, (match, key) => {
return escritorio[key.trim()] || match;
const keyParts = key.trim().split('.');
let value = escritorio;
for (const part of keyParts) {
value = value?.[part];
if (value === undefined) break;
}
return value || match;
});
let contentPdfBuffer;
try {
const page = await browser.newPage();
await page.setContent(templateProcessado, { waitUntil: 'networkidle0' });
// Usar margens do template se existirem
const margens = config?.margensTemplate || {
top: '35mm',
bottom: '29mm',
left: '25mm',
right: '25mm'
};
contentPdfBuffer = await page.pdf({
format: 'A4',
margin: margens,
printBackground: true
});
console.log('PDF do conteúdo gerado com sucesso:', contentPdfBuffer.length, 'bytes');
} finally {
await browser.close();
}
// 2. Verificar se existe timbrado para combinar
if (config.timbradoUrl) {
try {
console.log('Combinando com timbrado...');
// Caminho do arquivo timbrado
let timbradoPath;
// Se o caminho começa com /uploads, procurar na pasta public
if (config.timbradoUrl.startsWith('/uploads')) {
timbradoPath = path.join(process.cwd(), 'public', config.timbradoUrl);
} else {
timbradoPath = path.join(process.cwd(), 'public', 'uploads', 'Timbrado_2025.pdf');
}
console.log('Procurando timbrado em:', timbradoPath);
// Verificar se o arquivo existe
try {
await fs.access(timbradoPath);
console.log('Arquivo de timbrado encontrado');
} catch (err) {
console.error('Arquivo de timbrado não encontrado:', err);
return contentPdfBuffer; // Retornar apenas o conteúdo se não encontrar o timbrado
}
// Ler o arquivo de timbrado
const templateBytes = await fs.readFile(timbradoPath);
console.log('Arquivo de timbrado lido:', templateBytes.length, 'bytes');
// Carregar os PDFs
const templateDoc = await PDFDocument.load(templateBytes);
const contentDoc = await PDFDocument.load(contentPdfBuffer);
// Criar documento final
const pdfDoc = await PDFDocument.create();
// Obter página do template e páginas do conteúdo
const [templatePage] = await pdfDoc.copyPages(templateDoc, [0]);
const contentPages = await pdfDoc.copyPages(contentDoc, contentDoc.getPageIndices());
// Para cada página do conteúdo, criar uma página com template e conteúdo
for (let i = 0; i < contentPages.length; i++) {
// Adicionar página do template
pdfDoc.addPage(templatePage);
const page = pdfDoc.getPage(i);
// Desenhar o conteúdo sobre o template
page.drawPage(contentPages[i], {
x: 0,
y: 0,
opacity: 1
});
}
// Gerar PDF final
const pdfBytes = await pdfDoc.save();
console.log('PDF final gerado com sucesso:', pdfBytes.length, 'bytes');
return Buffer.from(pdfBytes);
} catch (err) {
console.error('Erro ao combinar PDFs:', err);
// Em caso de erro, retornar apenas o conteúdo
return contentPdfBuffer;
}
}
// Se não houver timbrado, retornar apenas o conteúdo
return contentPdfBuffer;
} catch (error) {
console.error('Erro ao gerar PDF:', error);
// Fallback simplificado em caso de erro
try {
console.log('Usando método alternativo de geração...');
const pdfDoc = await PDFDocument.create();
const page = pdfDoc.addPage([595, 842]); // A4
const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
// Adicionar texto básico
page.drawText('Documento Gerado pelo Sistema', {
x: 50,
y: 800,
font,
size: 16
});
// Adicionar conteúdo como texto plano
const plainText = conteudo.replace(/<[^>]*>/g, ' ').slice(0, 2000);
const linhas = [];
for (let i = 0; i < plainText.length; i += 80) {
linhas.push(plainText.substring(i, i + 80));
}
linhas.forEach((linha, index) => {
page.drawText(linha, {
x: 50,
y: 750 - (index * 15),
font,
size: 10
});
});
const pdfBytes = await pdfDoc.save();
return Buffer.from(pdfBytes);
} catch (fallbackError) {
console.error('Erro no método alternativo:', fallbackError);
throw new Error('Falha ao gerar PDF');
}
}
}
await page.setContent(templateProcessado);
const margens = config?.margensTemplate || {
top: '35mm',
bottom: '29mm',
left: '25mm',
right: '25mm'
};
const contentPdfBuffer = await page.pdf({
// Método antigo mantido para compatibilidade
async gerarPDFAntigo(html: string): Promise<Buffer> {
try {
const config = await this.getConfiguracao();
const htmlCompleto = this.gerarHTML(html, config);
const browser = await puppeteer.launch({
executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || '/usr/bin/chromium-browser',
headless: true,
args: ['--no-sandbox', '--disable-setuid-sandbox']
});
const page = await browser.newPage();
await page.setContent(htmlCompleto, { waitUntil: 'networkidle0' });
const pdf = 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);
}
// 6. Gerar PDF final
const pdfBytes = await pdfDoc.save();
return Buffer.from(pdfBytes);
await browser.close();
return pdf;
} catch (error) {
console.error('Erro ao gerar PDF:', error);
throw new Error('Falha ao gerar PDF');