147 lines
4.1 KiB
TypeScript
147 lines
4.1 KiB
TypeScript
import { provaQueue } from '../workers/ProvaWorker';
|
|
import { prisma } from '../config/database';
|
|
import { createHash } from 'crypto';
|
|
import { PDFDocument, StandardFonts } from 'pdf-lib';
|
|
import * as OpenTimestamps from 'opentimestamps';
|
|
import sharp from 'sharp';
|
|
import { promises as fs } from 'fs';
|
|
|
|
export class ProvaService {
|
|
private fileValidator: FileValidator;
|
|
private reportGenerator: ReportGenerator;
|
|
|
|
constructor() {
|
|
this.fileValidator = new FileValidator();
|
|
this.reportGenerator = new ReportGenerator();
|
|
}
|
|
|
|
async processFile(file: Express.Multer.File, metadata: any) {
|
|
try {
|
|
console.log('Iniciando processamento do arquivo:', file.originalname); // Debug log
|
|
|
|
// Validar arquivo e metadados
|
|
if (!file.buffer || !file.originalname) {
|
|
throw new Error('Arquivo inválido');
|
|
}
|
|
|
|
// Criar registro inicial
|
|
const prova = await prisma.prova.create({
|
|
data: {
|
|
fileName: file.originalname,
|
|
mimeType: file.mimetype,
|
|
status: 'PENDENTE',
|
|
metadata: {
|
|
...metadata,
|
|
fileSize: file.size,
|
|
originalName: file.originalname
|
|
}
|
|
}
|
|
});
|
|
|
|
console.log('Registro criado com sucesso:', prova.id); // Debug log
|
|
|
|
// Adicionar à fila
|
|
await provaQueue.add('processar-prova', {
|
|
provaId: prova.id,
|
|
fileData: file.buffer.toString('base64'),
|
|
metadata
|
|
});
|
|
|
|
return prova;
|
|
} catch (error) {
|
|
console.error('Erro detalhado no processamento:', error);
|
|
throw new Error(`Erro ao processar arquivo ${file.originalname}: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
private generateChecksums(buffer: Buffer) {
|
|
return {
|
|
sha256: createHash('sha256').update(buffer).digest('hex'),
|
|
sha512: createHash('sha512').update(buffer).digest('hex'),
|
|
md5: createHash('md5').update(buffer).digest('hex')
|
|
};
|
|
}
|
|
|
|
private async registerTimestamp(buffer: Buffer) {
|
|
const digest = createHash('sha256').update(buffer).digest();
|
|
const timestamp = await OpenTimestamps.stamp(digest);
|
|
return timestamp;
|
|
}
|
|
|
|
private async processFileByType(file: Express.Multer.File) {
|
|
if (file.mimetype.startsWith('image/')) {
|
|
return await this.processImage(file.buffer);
|
|
}
|
|
return file.buffer;
|
|
}
|
|
|
|
private async processImage(buffer: Buffer) {
|
|
return await sharp(buffer)
|
|
.resize(1200, 900, {
|
|
fit: 'inside',
|
|
withoutEnlargement: true
|
|
})
|
|
.toBuffer();
|
|
}
|
|
|
|
private async generateReport(data: any) {
|
|
const pdfDoc = await PDFDocument.create();
|
|
const page = pdfDoc.addPage();
|
|
const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
|
|
|
|
// Adicionar conteúdo ao PDF
|
|
// ... implementar a geração do relatório ...
|
|
|
|
return {
|
|
path: '/path/to/report.pdf',
|
|
buffer: await pdfDoc.save()
|
|
};
|
|
}
|
|
|
|
async verifyFile(hash: string) {
|
|
try {
|
|
const prova = await prisma.prova.findFirst({
|
|
where: { checksumSha256: hash }
|
|
});
|
|
|
|
if (!prova) {
|
|
return {
|
|
verified: false,
|
|
message: 'Documento não encontrado ou hash inválido'
|
|
};
|
|
}
|
|
|
|
// Verificar se o arquivo ainda existe
|
|
const filePath = prova.filePath;
|
|
if (filePath) {
|
|
try {
|
|
await fs.access(filePath);
|
|
} catch {
|
|
return {
|
|
verified: false,
|
|
message: 'Arquivo original não encontrado'
|
|
};
|
|
}
|
|
}
|
|
|
|
return {
|
|
verified: true,
|
|
message: 'Documento verificado com sucesso',
|
|
prova: {
|
|
fileName: prova.fileName,
|
|
checksumSha256: prova.checksumSha256,
|
|
checksumSha512: prova.checksumSha512,
|
|
checksumMd5: prova.checksumMd5,
|
|
timestamp: prova.timestamp,
|
|
metadata: prova.metadata,
|
|
dataCriacao: prova.dataCriacao,
|
|
dataValida: prova.dataAtualizacao
|
|
},
|
|
timestamp: prova.timestamp ? JSON.parse(prova.timestamp) : null
|
|
};
|
|
} catch (error) {
|
|
console.error('Erro ao verificar arquivo:', error);
|
|
throw new Error(`Erro ao verificar arquivo: ${error.message}`);
|
|
}
|
|
}
|
|
} |