snglpi/src/services/glpiCommentService.js

// src/services/glpiCommentService.js
const TicketSnModel = require('../models/ticketSnModel');
const TicketGlpiModel = require('../models/ticketGlpiModel');
const TicketSyncModel = require('../models/ticketSyncModel');
const TicketUpdateModel = require('../models/ticketUpdateModel');
const { logInfo, logError } = require('../utils/logger');
const { getTicketSysId, createCommentInServiceNow } = require('./servicenowService');


// Sincroniza comentários do GLPI para o Banco de Dados local
const syncCommentsGlpi = async () => {
    try {

        // Função interna para sincronizar comentário no ServiceNow
        const syncCommentToServiceNow = async (ticketNumber, comment) => {
            const snSysId = await getTicketSysId(ticketNumber);
            if (!snSysId) {
                logError(`❌ sys_id do ServiceNow não encontrado para o ticket SN Ticket: ${ticketNumber}`);
                return null;
            }
            return await createCommentInServiceNow(snSysId, comment.content);
        };
        
        logInfo('🔄 Iniciando sincronização de comments do GLPI para o Service Now iniciada...');
        const effectiveTickets = await TicketSyncModel.getTicketsToSync();
        logInfo(`🔍 ${effectiveTickets.length} tickets encontrados para sincronização de comentários`, { step: 1 });

        for (const ticket of effectiveTickets) {

            logInfo(`Buscando comentários para o ticket GLPI ID: ${ticket.glpi_ticket_id}`);
            const comments = await TicketGlpiModel.getFollowupsByItemId(ticket.glpi_ticket_id);
            logInfo(`📝 ${comments.length} comentários encontrados para o ticket GLPI ID: ${ticket.glpi_ticket_id}`, { step: 2 });

            for (const comment of comments) {

                const existingComment = await TicketUpdateModel.getCommentSync(ticket.glpi_ticket_id, comment.id);

                if (existingComment) {
                    logInfo(`Comentário ID ${comment.id} já sincronizado, pulando...`, { step: 3 });
                    continue;
                }

                const snCommentId = await syncCommentToServiceNow(ticket.sn_ticket_id, comment);

                const sync_id = await TicketSyncModel.getIdSyncByGlpiId(ticket.glpi_ticket_id);

                const commentData = {
                    ticket_sync_id: sync_id,
                    source_system: 'glpi',
                    content: comment.content,
                    created_at: new Date(comment.date_creation),
                    updated_at: new Date(comment.date_mod),
                    source_id: comment.id,
                    destiny_id: snCommentId
                };


                const insertResult = await TicketUpdateModel.insert(commentData);
                if (insertResult.success) {
                    logInfo(`✅ Comentário ID ${comment.id} sincronizado com sucesso! Novo ID: ${insertResult.newId}`, { step: 4 });
                } else {
                    logError(`❌ Erro ao sincronizar comentário ID ${comment.id}: ${insertResult.error}`, { step: 4 });
                }

                const hasError = !insertResult.success;
                const snStatus =  'pending';
                const glpiStatus = hasError ? 'Error' :'updated';
                await TicketSyncModel.updateStatus(ticket.id, glpiStatus, snStatus);
                logInfo(`Status de sincronização para o ticket ID ${ticket.id} atualizado para GLPI: '${glpiStatus}', SN: '${snStatus}'.`);
            }
        }
    }catch (error) {
        logError(error, 'GLPI Tickets');
    }
}




/**
 * @module glpiCommentService
 * @description Este módulo fornece serviços para sincronizar comentários do GLPI para o banco de dados local.
 * A função syncCommentsGlpi busca tickets que foram criados com sucesso e sincroniza seus comentários,
 * garantindo que apenas novos comentários sejam inseridos no banco de dados.
 * Utiliza os modelos TicketSnModel, TicketGlpiModel, TicketSyncModel e TicketUpdateModel para interagir com o banco de dados.
 * Atualiza o status de sincronização após cada comentário processado. 
* Inclui logging detalhado para monitorar o progresso e identificar erros durante o processo de sincronização.
 */
module.exports = {
    syncCommentsGlpi
};