184 lines
8.9 KiB
JavaScript
184 lines
8.9 KiB
JavaScript
const TicketSnModel = require('../models/ticketSnModel');
|
|
const TicketGlpiModel = require('../models/ticketGlpiModel');
|
|
const TicketUpdateModel = require('../models/ticketUpdateModel');
|
|
const TicketSyncModel = require('../models/ticketSyncModel');
|
|
const { logInfo, logError } = require('../utils/logger');
|
|
const { addWorkNoteToServiceNow } = require('./servicenowService');
|
|
|
|
const syncTicketsToGlpi = async () => {
|
|
try {
|
|
logInfo('🔄 Iniciando sincronização para GLPI...');
|
|
const pendingTickets = await TicketSnModel.getPendingTickets();
|
|
|
|
if (pendingTickets.length === 0) {
|
|
logInfo('✅ Nenhum ticket pendente para sincronizar');
|
|
return;
|
|
}
|
|
|
|
logInfo(`📋 Encontrados ${pendingTickets.length} tickets para sincronizar`);
|
|
|
|
for (const ticket of pendingTickets) {
|
|
await processSingleTicket(ticket);
|
|
}
|
|
|
|
logInfo('🎉 Sincronização com GLPI concluída!');
|
|
|
|
} catch (error) {
|
|
logError(error, '❌ Erro na sincronização GLPI');
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
const processSingleTicket = async (ticket) => {
|
|
|
|
try {
|
|
logInfo(`🔍 Processando ticket: ${ticket.ticket_number}`);
|
|
|
|
if (ticket.glpi_ticket_id) {
|
|
logInfo(`✅ Ticket ${ticket.ticket_number} já possui GLPI ID (${ticket.glpi_ticket_id}) registrado. Apenas atualizando status.`);
|
|
await TicketSyncModel.updateStatus(ticket.id, 'synced', 'synced');
|
|
return;
|
|
}
|
|
|
|
const existingTicket = await TicketGlpiModel.ticketExists(ticket.ticket_number);
|
|
await TicketSyncModel.updateLastSync(ticket.id, 'glpi');
|
|
|
|
if (existingTicket) {
|
|
logInfo(`✅ Ticket ${ticket.ticket_number} encontrado no GLPI. Atualizando registro local com o ID: ${existingTicket}`);
|
|
|
|
const glpiLiveStatus = await TicketGlpiModel.getTicketStatus(existingTicket);
|
|
if (glpiLiveStatus === 6) {
|
|
logInfo(`Ticket GLPI ${existingTicket} já está Fechado. Marcando ticket SN ${ticket.ticket_number} como 'closed'/'ignored' e não monitorado.`);
|
|
await TicketSyncModel.updateStatusAndGlpiTicket(ticket.id, 'ignored', 'closed', existingTicket);
|
|
return;
|
|
}
|
|
await TicketSyncModel.updateStatusAndGlpiTicket(ticket.id, 'synced', 'synced', existingTicket);
|
|
logInfo(`✅ Ticket ${ticket.ticket_number} já existe no GLPI! GLPI ID: ${existingTicket}`);
|
|
return;
|
|
}
|
|
|
|
const glpiData = {
|
|
ticket_number: ticket.ticket_number,
|
|
short_description: ticket.short_description,
|
|
description: ticket.description,
|
|
justificativa: ticket.justificativa,
|
|
caller_id: ticket.caller_id,
|
|
caller_email: ticket.caller_email,
|
|
caller_phone: ticket.telefone,
|
|
caller_ramal: ticket.ramal,
|
|
type: ticket.tipo,
|
|
state: ticket.status,
|
|
priority: '3',
|
|
location_id: ticket.location_id,
|
|
location_name: ticket.location_name,
|
|
opened_at: ticket.opened_at,
|
|
updated_at: ticket.updated_at
|
|
};
|
|
const glpiTicketId = await TicketGlpiModel.createTicket(glpiData);
|
|
await TicketSyncModel.updateLastSync(ticket.id, 'glpi');
|
|
await TicketSyncModel.updateStatusAndGlpiTicket(ticket.id, 'synced', 'synced', glpiTicketId);
|
|
|
|
logInfo(`✅ Ticket ${ticket.ticket_number} sincronizado! GLPI ID: ${glpiTicketId}`);
|
|
|
|
} catch (error) {
|
|
logError(error, `❌ Erro no ticket ${ticket.ticket_number}`);
|
|
try {
|
|
await TicketSyncModel.updateStatus(ticket.id, 'error', 'collected');
|
|
} catch (innerError) {
|
|
logError(innerError, `❌ Erro ao registrar falha de sincronização para ticket ${ticket.id}`);
|
|
}
|
|
}
|
|
};
|
|
|
|
const checkGlpiStatusChanges = async () => {
|
|
try {
|
|
logInfo('📡 Verificando mudanças de status nos tickets do GLPI...');
|
|
|
|
const ticketsToMonitor = await TicketSyncModel.getTicketsToMonitor();
|
|
|
|
if (ticketsToMonitor.length === 0) {
|
|
logInfo('Nenhum ticket ativo para verificar status no GLPI.');
|
|
return;
|
|
}
|
|
|
|
for (const ticket of ticketsToMonitor) {
|
|
const glpiStatus = await TicketGlpiModel.getTicketStatus(ticket.glpi_ticket_id);
|
|
|
|
const currentDbStatus = ticket.glpi_sync_status;
|
|
const glpiStatusAsString = TicketGlpiModel.mapGlpiStatusToString(glpiStatus).toLowerCase().replace(/ /g, '_');
|
|
|
|
if (glpiStatus === 5 && currentDbStatus !== 'solved' && currentDbStatus !== 'closed') {
|
|
logInfo(`Ticket GLPI ${ticket.glpi_ticket_id} foi Solucionado. Preparando para sincronização...`);
|
|
|
|
const solution = await TicketGlpiModel.getTicketSolution(ticket.glpi_ticket_id);
|
|
|
|
if (solution?.solutiontypes_id === 27) {
|
|
logInfo(`REGRA DETECTADA: Ticket ${ticket.glpi_ticket_id} está fora do escopo (SolutionType ID: 27).`);
|
|
const justification = solution?.content || 'Ticket marcado como "Fora do escopo" no GLPI.';
|
|
await addWorkNoteToServiceNow(ticket.sn_ticket_id, `Ticket fechado no GLPI com a justificativa: ${justification}`);
|
|
await TicketSyncModel.updateStatus(ticket.sn_ticket_id, 'closed', 'ignored');
|
|
await TicketGlpiModel.forceCloseTicket(ticket.glpi_ticket_id);
|
|
continue;
|
|
}
|
|
|
|
const sanitizedContent = solution?.content ? stripHTML(solution.content) : 'Chamado solucionado sem notas.';
|
|
await TicketUpdateModel.insert({
|
|
ticket_sync_id: ticket.id,
|
|
source_system: 'glpi',
|
|
update_type: 'close_message',
|
|
content: sanitizedContent,
|
|
author: null,
|
|
created_at: solution?.date_mod || new Date(),
|
|
source_id: `solution-${ticket.glpi_ticket_id}`,
|
|
});
|
|
await TicketSyncModel.updateStatusAndSourceLast(ticket.sn_ticket_id, 'solved', 'pending_solve', 'GLPI');
|
|
|
|
} else if (glpiStatus === 6 && currentDbStatus !== 'closed') {
|
|
logInfo(`Ticket GLPI ${ticket.glpi_ticket_id} foi Fechado permanentemente. Marcando como 'closed'.`);
|
|
await TicketSyncModel.updateStatus(ticket.sn_ticket_id, 'closed', ticket.sn_sync_status);
|
|
|
|
} else if (glpiStatus < 5 && glpiStatusAsString !== currentDbStatus && ticket.source_last !== 'GLPI') {
|
|
logInfo(`Mudança de status (aberto) detectada no GLPI para o ticket ${ticket.glpi_ticket_id}. De '${currentDbStatus}' para '${glpiStatusAsString}'.`);
|
|
await TicketSyncModel.updateSourceLast(ticket.sn_ticket_id, 'GLPI');
|
|
}
|
|
}
|
|
} catch (error) {
|
|
logError(error, '🚨Falha ao verificar mudanças de status no GLPI');
|
|
}
|
|
};
|
|
|
|
const closeTicketInGlpi = async (ticket) => {
|
|
try {
|
|
logInfo(`🔒 Iniciando fechamento do chamado GLPI ${ticket.glpi_ticket_id}...`);
|
|
|
|
const closeMessageRecord = await TicketUpdateModel.getLatestUpdate(ticket.id, 'servicenow');
|
|
const solutionContent = closeMessageRecord?.content || 'Chamado encerrado via integração com o ServiceNow.';
|
|
|
|
await TicketGlpiModel.closeTicket(ticket.glpi_ticket_id, solutionContent);
|
|
await TicketSyncModel.updateLastSync(ticket.sn_ticket_id, 'glpi');
|
|
|
|
logInfo(`✅ Chamado ${ticket.glpi_ticket_id} solucionado com sucesso no GLPI.`);
|
|
} catch (error) {
|
|
logError(error, `🚨Falha ao fechar chamado no GLPI: ${ticket.glpi_ticket_id}`);
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
module.exports = {
|
|
syncTicketsToGlpi,
|
|
checkGlpiStatusChanges,
|
|
closeTicketInGlpi
|
|
};
|
|
|
|
/**
|
|
* @module glpiTicketService
|
|
* @description Este serviço contém a lógica de negócio para a criação e atualização de tickets no GLPI.
|
|
* Ele atua como um intermediário entre os controladores e os modelos de dados.
|
|
*
|
|
* Principais Funcionalidades:
|
|
* - `syncTicketsToGlpi()`: Função principal que busca tickets pendentes no banco de dados local (previamente coletados do ServiceNow) e orquestra sua criação no GLPI.
|
|
* - `processSingleTicket(ticket)`: Processa um único ticket. Verifica se ele já existe no GLPI para evitar duplicatas. Se não existir, formata os dados (incluindo o enriquecimento da descrição para requisições) e chama o `TicketGlpiModel` para criar o ticket. Se já existir, apenas atualiza o registro de sincronização.
|
|
* - `checkGlpiStatusChanges()`: (Atualmente não utilizado no fluxo principal, sua lógica foi integrada ao `processStatusController`) Função projetada para detectar proativamente mudanças de status no GLPI.
|
|
* - `closeTicketInGlpi(ticket)`: Orquestra o processo de fechamento de um ticket no GLPI. Ele busca a nota de resolução vinda do ServiceNow e a utiliza para adicionar uma solução no GLPI antes de mudar o status para "Solucionado".
|
|
*/
|