snglpi/src/models/ticketSyncModel.js

// src/models/ticketSyncModel.js
const { query } = require('winston');
const pool = require('../data/database');
const { logError } = require('../utils/logger');

class TicketSyncModel {

    // Cria um registro de sincronização para um ticket
    static async createSyncRecord(data) {
        try {

            
            const query = `INSERT INTO ticket_sync (
            sn_ticket_id,
            glpi_ticket_id,
            last_sn_sync,
            last_glpi_sync,
            created_at,
            updated_at,
            sn_sync_status,
            glpi_sync_status
            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING id`;

            const values = [
                data.sn_ticket_id,
                data.glpi_ticket,
                data.last_sn_sync,
                data.last_glpi_sync,
                data.created_at,
                data.updated_at,
                data.sn_sync_status,
                data.glpi_sync_status

            ]


            await pool.query(query, values);   
            
        } catch (error) {
            logError(error, '❌ Erro ao criar registro de sincronização');
            throw error;
        }
    }


    // Buscar tickets que foram criados com sucesso para sincronizar comentários
    static async getTicketsToSync(glpi_sync_status, sn_sync_status) {
        try {
            const query = 'SELECT id, glpi_ticket_id, sn_ticket_id FROM ticket_sync WHERE glpi_sync_status = $1 AND sn_sync_status = $2';
            const values =[glpi_sync_status , sn_sync_status];
            const { rows } = await pool.query(query, values);
            return rows;
        } catch (error) {
            logError(error, '❌ Erro ao buscar tickets para sincronizar');
            throw error;
        }
    }

    // Atualiza o status de sincronização de um ticket
    static async updateStatus(ticketSyncId, glpiStatus, snStatus) {
        try {
            const query = 'UPDATE ticket_sync SET glpi_sync_status = $1, sn_sync_status = $2 WHERE sn_ticket_id = $3';
            await pool.query(query, [glpiStatus, snStatus, ticketSyncId]);
        } catch (error) {
            logError(`${error} ❌ Erro ao atualizar status de sincronização para o ID: ${ticketSyncId}`);
            throw error;
        }
    }

    static async updateStatusAndGlpiTicket(ticketSyncId, glpiStatus, snStatus, glpiTicketId) {
        try {
            const query = 'UPDATE ticket_sync SET glpi_sync_status = $1, sn_sync_status = $2, glpi_ticket_id = $4 WHERE sn_ticket_id = $3';
            await pool.query(query, [glpiStatus, snStatus, ticketSyncId, glpiTicketId]);
        } catch (error) {
            logError(error, `❌ Erro ao atualizar status de sincronização para o ID: ${ticketSyncId}`);
            throw error;
        }
    }

    // Buscar o ID de sincronização baseado no glpi_ticket_id
    static async getIdSyncByGlpiId(glpiTicketId) {
        try {
            const query = 'SELECT id FROM ticket_sync WHERE glpi_ticket_id = $1';
            const { rows } = await pool.query(query, [glpiTicketId]);
            return rows[0] ? rows[0].id : null;
        } catch (error) {
            logError(error, `❌ Erro ao buscar ID de sincronização por GLPI ID: ${glpiTicketId}`);
            throw error;
        }
    }

    // Buscar o ID de sincronização baseado no sn_ticket_id
    static async getIdSyncBySnId(snTicketId) {
        try {
            const query = 'SELECT id FROM ticket_sync WHERE sn_ticket_id = $1';
            const { rows } = await pool.query(query, [snTicketId]);
            return rows[0] ? rows[0].id : null;
        } catch (error) {
            logError(error, `❌ Erro ao buscar ID de sincronização por GLPI ID: ${glpiTicketId}`);
            throw error;
        }
    }
    static async getByTicketNumber(ticketNumber) {
        try {
            console.log(ticketNumber)
            const query = 'SELECT * FROM ticket_sync WHERE sn_ticket_id = $1';
            const { rows } = await pool.query(query, [ticketNumber]);
            return rows[0] || null;

        } catch (error) {
            logError(`${error}, ❌ Erro ao buscar ticket ${ticketNumber}}` )
        }
        
    }

    // Buscar tickets que estão sincronizados
    static async getTicketsSynced() {
        try {
            const query = `
                SELECT 
                    tsync.id, 
                    tsync.glpi_ticket_id, 
                    tsync.sn_ticket_id,
                    tsn.sys_id
                FROM ticket_sync tsync
                JOIN tickets_sn tsn ON tsync.sn_ticket_id = tsn.id
                WHERE tsync.glpi_sync_status = 'synced' AND tsync.sn_sync_status = 'synced'`;
            const { rows } = await pool.query(query);
            return rows;
        } catch (error) {
            logError(error, '❌ Erro ao buscar tickets para sincronizar');
            throw error;
        }
    }



}
/**
 * @module TicketSyncModel
 * @description Este módulo fornece métodos para interagir com a tabela de sincronização de tickets (ticket_sync) no banco de dados. 
 * Inclui funcionalidades para buscar tickets para sincronização, atualizar o status de sincronização
 *  e buscar o ID de sincronização baseado no glpi_ticket_id.
 *
 * A função getTicketsToSync busca todos os tickets que possuem IDs tanto no GLPI quanto no ServiceNow.
 * A função updateStatus atualiza os status de sincronização do GLPI e do ServiceNow para um ticket específico.
 * A função getIdSyncByGlpiId retorna o ID de sincronização baseado no glpi_ticket_id.
 * Essas funcionalidades são essenciais para manter a consistência e o rastreamento dos tickets entre os dois sistemas.
 */


module.exports = TicketSyncModel;