snglpi/src/services/glpiTicketService.js

// src/services/glpiService.js
const TicketSnModel = require('../models/ticketSnModel');
const TicketGlpiModel = require('../models/ticketGlpiModel');
const TicketSyncModel = require('../models/ticketSyncModel');
const { logInfo, logError } = require('../utils/logger');

// Método principal que o controller vai chamar
const syncTicketsToGlpi = async () => {
    try {
        logInfo('🔄 Iniciando sincronização para GLPI...');
        // 1. Buscar tickets pendentes
        const pendingTickets = await TicketSnModel.getPendingTickets();

        if (pendingTickets.length === 0) {
            logInfo('✅ Nenhum ticket pendente para sincronizar');
            return;
        }

        logInfo(`📋 Encontrados ${pendingTickets.length} tickets para sincronizar`);
        
        // 2. Processar cada ticket
        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;
    }
};

// Processar um ticket individual
const processSingleTicket = async (ticket) => {
    
    try {
        logInfo(`🔍 Processando ticket: ${ticket.ticket_number}`);

        // 1. Verifica se o ticket já possui um ID do GLPI no nosso banco de sincronização.
        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;
        }

        // 2. Se não tem ID local, verifica se o ticket existe no GLPI (buscando pelo número).
        const existingTicket = await TicketGlpiModel.ticketExists(ticket.ticket_number);

        if (existingTicket) {
            logInfo(`✅ Ticket ${ticket.ticket_number} encontrado no GLPI. Atualizando registro local com o ID: ${existingTicket}`);
            // Atualiza nosso registro de sincronização com o ID do GLPI encontrado.
            await TicketSyncModel.updateStatusAndGlpiTicket(ticket.id, 'synced', 'synced', existingTicket);
            logInfo(`✅ Ticket ${ticket.ticket_number} já existe no GLPI! GLPI ID: ${existingTicket}`);
            return;
        }

        // 3. Converter dados para formato GLPI
        const glpiData = {
            ticket_number: ticket.ticket_number,
            short_description: ticket.short_description,
            description: ticket.description,
            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
        };

        // 3. Inserir no GLPI
        const glpiTicketId = await TicketGlpiModel.createTicket(glpiData);

        // 4. Atualizar registro de sincronização
        await TicketSyncModel.updateStatus(ticket.id, 'synced', 'synced');

        logInfo(`✅ Ticket ${ticket.ticket_number} sincronizado! GLPI ID: ${glpiTicketId}`);

    } catch (error) {
        logError(error, `❌ Erro no ticket ${ticket.ticket_number}`);
        
        // Se temos um registro de sync, atualizar o status para error
        try {
         await TicketSyncModel.updateStatus(idSyncRecord.id, 'error', 'synced');
        } catch (innerError) {
                logError(innerError, `❌ Erro ao registrar falha de sincronização para ticket ${ticket.id}`);
        }
    }
};

module.exports = {
    syncTicketsToGlpi
};