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 16:48:27 -03:00
1 parent 33d9fe8688
commit 89f1ad96eb
7 files changed
+747 -183
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Dockerfile
+10 -3
View File
@@ -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
docker-compose.yml
+13
View File
@@ -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
package.json
+1 -6
View File
@@ -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"
}
}
}
scripts/fix-uuid.sql
+9
View File
@@ -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}$';
src/components/clientes/ClienteModal.tsx
+19 -11
View File
@@ -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.");
src/server/index.ts
+77 -2
View File
@@ -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(
(
src/server/services/PdfService.ts
+618 -161
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,653 @@ 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 apenas no pdf-lib para maximizar consistência
try {
console.log('Gerando PDF com pdf-lib e tratamento aprimorado de HTML...');
// 1. Primeiro carregar o timbrado se existir
let pdfDoc;
const fontSize = 11;
const lineHeight = fontSize * 1.4;
let font, boldFont;
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 {
// Criar documento em branco
console.log('Criando novo documento sem timbrado...');
pdfDoc = await PDFDocument.create();
pdfDoc.addPage([pageWidth, pageHeight]);
}
// 2. Carregar fontes
font = await pdfDoc.embedFont(StandardFonts.Helvetica);
boldFont = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
// 3. Processar e formatar o HTML de forma mais precisa
console.log('Processando conteúdo HTML com tratamento aprimorado...');
// Processar variáveis de template
const processedContent = this.processarTemplate(conteudo, escritorio);
// Função para decodificar entidades HTML
const decodeHtmlEntities = (text) => {
const entities = {
'&nbsp;': ' ',
'&amp;': '&',
'&lt;': '<',
'&gt;': '>',
'&quot;': '"',
'&apos;': "'",
'&cent;': '¢',
'&pound;': '£',
'&yen;': '¥',
'&euro;': '€',
'&copy;': '©',
'&reg;': '®',
'&trade;': '™',
'&Aacute;': 'Á',
'&aacute;': 'á',
'&Eacute;': 'É',
'&eacute;': 'é',
'&Iacute;': 'Í',
'&iacute;': 'í',
'&Oacute;': 'Ó',
'&oacute;': 'ó',
'&Uacute;': 'Ú',
'&uacute;': 'ú',
'&Ccedil;': 'Ç',
'&ccedil;': 'ç',
'&Atilde;': 'Ã',
'&atilde;': 'ã',
'&Otilde;': 'Õ',
'&otilde;': 'õ',
'&Acirc;': 'Â',
'&acirc;': 'â',
'&Ecirc;': 'Ê',
'&ecirc;': 'ê',
'&Ocirc;': 'Ô',
'&ocirc;': 'ô',
'&ndash;': '–',
'&mdash;': '—',
'&minus;': '−'
};
return text.replace(/&([a-z0-9]+|#[0-9]{1,6}|#x[0-9a-fA-F]{1,6});/gi, (match) => {
if (entities[match]) {
return entities[match];
} else if (match.startsWith('&#x')) {
// Hexadecimal Unicode
const hex = match.substring(3, match.length - 1);
return String.fromCodePoint(parseInt(hex, 16));
} else if (match.startsWith('&#')) {
// Decimal Unicode
const decimal = match.substring(2, match.length - 1);
return String.fromCodePoint(parseInt(decimal, 10));
}
return match; // Se não foi possível decodificar, manter original
});
};
// Processa o HTML de forma mais estruturada
const processHtml = (html) => {
// Substituir tags comuns por marcadores para melhor formatação
let processed = html
// Corrigir múltiplos &nbsp; para evitar espaços excessivos
.replace(/(&nbsp;){2,}/g, ' ')
.replace(/&nbsp;/g, ' ')
// Preservar quebras de linha
.replace(/<br\s*\/?>/gi, '\n')
.replace(/<\/p>\s*<p[^>]*>/gi, '\n\n')
.replace(/<\/div>\s*<div[^>]*>/gi, '\n')
// Preservar parágrafos
.replace(/<p[^>]*>/gi, '')
.replace(/<\/p>/gi, '\n\n')
// Preservar divisões
.replace(/<div[^>]*>/gi, '')
.replace(/<\/div>/gi, '\n')
// Preservar cabeçalhos e listas
.replace(/<h1[^>]*>(.*?)<\/h1>/gi, '# $1\n\n')
.replace(/<h2[^>]*>(.*?)<\/h2>/gi, '## $1\n\n')
.replace(/<h3[^>]*>(.*?)<\/h3>/gi, '### $1\n\n')
.replace(/<h4[^>]*>(.*?)<\/h4>/gi, '#### $1\n\n')
.replace(/<li[^>]*>(.*?)<\/li>/gi, '• $1\n')
// Preservar negrito e itálico
.replace(/<strong[^>]*>(.*?)<\/strong>/gi, '*$1*')
.replace(/<b[^>]*>(.*?)<\/b>/gi, '*$1*')
.replace(/<em[^>]*>(.*?)<\/em>/gi, '_$1_')
.replace(/<i[^>]*>(.*?)<\/i>/gi, '_$1_')
// Remover tags restantes
.replace(/<[^>]*>/g, '');
// Decodificar entidades HTML
processed = decodeHtmlEntities(processed);
// Tratar linhas em branco múltiplas
processed = processed.replace(/\n{3,}/g, '\n\n');
// Dividir em linhas
return processed.split('\n').map(line => line.trim());
};
// Processar linhas do HTML
const lines = processHtml(processedContent);
// 4. Renderizar o conteúdo no PDF
console.log(`Renderizando ${lines.length} linhas de conteúdo...`);
// Obter primeira página do documento
let currentPage = pdfDoc.getPage(0);
let y = pageHeight - margens.top;
let pageIndex = 0;
// Adicionar cabeçalho com título do documento e data
y -= 10;
currentPage.drawText(escritorio.nome || 'Documento', {
x: margens.left,
y,
font: boldFont,
size: fontSize * 1.3
});
y -= lineHeight * 1.5;
const today = new Date().toLocaleDateString('pt-BR');
currentPage.drawText(`Data: ${today}`, {
x: margens.left,
y,
font,
size: fontSize
});
y -= lineHeight * 2;
// Função para quebrar texto em linhas de acordo com a largura disponível
const wrapTextToLines = (text, maxWidth) => {
const words = text.split(' ');
const lines = [];
let currentLine = '';
for (const word of words) {
const testLine = currentLine ? `${currentLine} ${word}` : word;
// Calcular largura aproximada do texto (melhor estimativa possível)
const testWidth = testLine.length * (fontSize * 0.55);
if (testWidth > maxWidth) {
if (currentLine) {
lines.push(currentLine);
currentLine = word;
} else {
// Palavra muito grande, não quebrar
lines.push(word);
}
} else {
currentLine = testLine;
}
}
body {
margin: 0;
padding: 0;
font-family: 'Fira Sans', Arial, sans-serif;
font-size: 11pt;
line-height: 1.5;
position: relative;
min-height: 100vh;
if (currentLine) {
lines.push(currentLine);
}
.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;
return lines;
};
// Função para adicionar nova página quando necessário
const addNewPageIfNeeded = (minSpace) => {
if (y - minSpace < margens.bottom) {
try {
// Criar nova página
const newPage = pdfDoc.addPage([pageWidth, pageHeight]);
currentPage = newPage;
pageIndex++;
y = pageHeight - margens.top;
return true;
} catch (error) {
console.error('Erro ao adicionar nova página:', error);
return false;
}
}
.content {
position: relative;
z-index: 1;
return false;
};
// Processar cada linha de texto
for (const line of lines) {
if (!line.trim()) {
// Linha vazia, adicionar espaço
y -= lineHeight * 0.5;
continue;
}
</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;
// Determinar formatação com base na linha
let currentFont = font;
let currentSize = fontSize;
let extraSpace = 0;
// Verificar se é título
if (line.startsWith('# ')) {
currentFont = boldFont;
currentSize = fontSize * 1.8;
extraSpace = lineHeight * 0.5;
// Desenhar texto sem o marcador
const titleText = line.substring(2).trim();
addNewPageIfNeeded(lineHeight * 2);
// Centralizar título
const titleWidth = titleText.length * (currentSize * 0.55);
const centerX = Math.max(margens.left, (pageWidth - titleWidth) / 2);
currentPage.drawText(titleText, {
x: centerX,
y,
font: currentFont,
size: currentSize
});
y -= lineHeight + extraSpace;
continue;
} else if (line.startsWith('## ')) {
currentFont = boldFont;
currentSize = fontSize * 1.5;
extraSpace = lineHeight * 0.3;
const titleText = line.substring(3).trim();
addNewPageIfNeeded(lineHeight * 1.8);
currentPage.drawText(titleText, {
x: margens.left,
y,
font: currentFont,
size: currentSize
});
y -= lineHeight + extraSpace;
continue;
} else if (line.startsWith('### ')) {
currentFont = boldFont;
currentSize = fontSize * 1.2;
const titleText = line.substring(4).trim();
addNewPageIfNeeded(lineHeight * 1.5);
currentPage.drawText(titleText, {
x: margens.left,
y,
font: currentFont,
size: currentSize
});
y -= lineHeight + extraSpace;
continue;
} else if (line.startsWith('• ')) {
// Lista com marcador
addNewPageIfNeeded(lineHeight);
const bulletText = line.trim();
const availableWidth = pageWidth - margens.left - margens.right - 10; // Espaço para o marcador
// Quebrar o texto em linhas
const bulletWrappedLines = wrapTextToLines(bulletText, availableWidth);
for (let i = 0; i < bulletWrappedLines.length; i++) {
if (i === 0) {
// Primeira linha com marcador
currentPage.drawText(bulletWrappedLines[i], {
x: margens.left,
y,
font: currentFont,
size: currentSize
});
} else {
// Linhas seguintes alinhadas com o texto após o marcador
currentPage.drawText(bulletWrappedLines[i], {
x: margens.left + 10,
y,
font: currentFont,
size: currentSize
});
}
.content {
margin: 0;
padding: 0;
min-height: calc(100vh - 58mm);
position: relative;
y -= lineHeight;
if (i < bulletWrappedLines.length - 1) {
addNewPageIfNeeded(lineHeight);
}
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]);
}
continue;
}
// Verificar se texto contém formatação (negrito/itálico)
const formattedLine = line
.replace(/\*([^*]+)\*/g, '$1') // Remover negrito por enquanto
.replace(/_([^_]+)_/g, '$1'); // Remover itálico por enquanto
// Calcular largura disponível
const availableWidth = pageWidth - margens.left - margens.right;
// Quebrar texto em linhas ajustadas à largura
const wrappedLines = wrapTextToLines(formattedLine, availableWidth);
// Adicionar cada linha ao PDF
for (const wrappedLine of wrappedLines) {
addNewPageIfNeeded(lineHeight);
currentPage.drawText(wrappedLine, {
x: margens.left,
y,
font: currentFont,
size: currentSize
});
y -= lineHeight;
}
// Adicionar espaço extra após parágrafos
if (wrappedLines.length > 0) {
y -= lineHeight * 0.2;
}
}
// Segundo: criar nova página
const newPage = pdfDoc.addPage([page.width, page.height]);
// Adicionar rodapé na última página com dados do escritório
if (escritorio.nome || escritorio.endereco || escritorio.telefone || escritorio.email) {
const footerY = margens.bottom - 20;
try {
if (escritorio.nome) {
currentPage.drawText(escritorio.nome, {
x: margens.left,
y: footerY,
size: 8,
font
});
}
if (escritorio.endereco) {
currentPage.drawText(escritorio.endereco, {
x: margens.left,
y: footerY - 10,
size: 8,
font
});
}
if (escritorio.telefone || escritorio.email) {
let contactInfo = '';
if (escritorio.telefone) contactInfo += `Tel: ${escritorio.telefone}`;
if (escritorio.telefone && escritorio.email) contactInfo += ' | ';
if (escritorio.email) contactInfo += `Email: ${escritorio.email}`;
currentPage.drawText(contactInfo, {
x: margens.left,
y: footerY - 20,
size: 8,
font
});
}
} catch (footerError) {
console.error('Erro ao adicionar rodapé:', footerError);
}
}
// Terceiro: desenhar template e conteúdo
newPage.drawPage(page);
newPage.drawPage(contentPage);
console.log('Salvando documento final...');
const pdfBytes = await pdfDoc.save();
console.log(`PDF gerado com sucesso: ${pdfBytes.length} bytes`);
return Buffer.from(pdfBytes);
} catch (error) {
console.error('Erro ao gerar PDF:', error);
// Fallback absolutamente mínimo e à prova de falhas
try {
console.log('Usando fallback ultra-minimalista...');
// Criar documento do zero da forma mais simples possível
const pdfDoc = await PDFDocument.create();
const page = pdfDoc.addPage();
const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
// Desenhar texto mínimo
page.drawText('Documento', {
x: 50,
y: 800,
size: 14,
font
});
page.drawText('Gerado em: ' + new Date().toLocaleString('pt-BR'), {
x: 50,
y: 780,
size: 10,
font
});
// Extrair e adicionar apenas parte do texto
const plainText = conteudo.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
// Garantir que não exceda limite seguro
const safeText = plainText.substring(0, Math.min(plainText.length, 1000));
// Adicionar linhas de texto com posições absolutos
const maxLines = 30;
const lineLength = 60;
for (let i = 0; i < safeText.length && i/lineLength < maxLines; i += lineLength) {
const line = safeText.substring(i, i + lineLength);
const lineY = 750 - Math.floor(i/lineLength) * 12;
if (lineY < 50) break; // Evitar desenhar fora da página
page.drawText(line, {
x: 50,
y: lineY,
size: 9,
font
});
}
// Salvar PDF
const pdfBytes = await pdfDoc.save();
return Buffer.from(pdfBytes);
} catch (fallbackError) {
console.error('Erro no fallback:', fallbackError);
// Criar um PDF manualmente como último recurso
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');
}
}
// 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);
// Método de fallback extremamente básico
try {
console.log('Usando método de fallback simples...');
const pdfDoc = await PDFDocument.create();
const page = pdfDoc.addPage([595, 842]);
const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
// Título
page.drawText('Documento de Emergência', {
x: 50,
y: 800,
size: 16,
font
});
// Mensagem de erro
page.drawText('Este documento foi gerado em modo de emergência.', {
x: 50,
y: 760,
size: 10,
font
});
// Adicionar parte do conteúdo como texto plano
const plainText = conteudo.replace(/<[^>]*>/g, ' ').slice(0, 1000);
// Quebrar em linhas
const lines = [];
for (let i = 0; i < plainText.length; i += 70) {
lines.push(plainText.substring(i, i + 70));
}
// Adicionar no máximo 30 linhas
lines.slice(0, 30).forEach((line, index) => {
page.drawText(line, {
x: 50,
y: 720 - (index * 12),
size: 8,
font
});
});
const pdfBytes = await pdfDoc.save();
return Buffer.from(pdfBytes);
} catch (fallbackError) {
console.error('Falha no fallback:', fallbackError);
throw new Error('Falha completa ao gerar PDF');
}
}
}
/**
* Processa um template HTML substituindo variáveis pelos valores do objeto
* @param template - Template HTML com variáveis no formato {{variavel}}
* @param dados - Objeto com valores para substituir
* @returns Template processado
*/
private processarTemplate(template: string, dados: any): string {
return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
const keyParts = key.trim().split('.');
let value = dados;
// Acessar propriedades aninhadas (ex: escritorio.nome)
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;
});
}
}