snglpi/src/models/ticketUpdateModel.js

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


class TicketUpdateModel {

    static async insert(updateData) {
        const query = `
            INSERT INTO ticket_updates (ticket_sync_id, update_type, source_system, content, author, created_at, updated_at, source_id, destiny_id)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
            ON CONFLICT (source_id) DO UPDATE SET
                ticket_sync_id = $1,
                update_type = $2,
                source_system = $3,
                content = $4,
                author = $5,
                created_at = $6,
                updated_at = $7,
                destiny_id = $9
            RETURNING *;
        `;
        const values = [
            updateData.ticket_sync_id,
            'note',
            updateData.source_system,
            updateData.content,
            updateData.author,
            updateData.created_at,
            updateData.updated_at,
            updateData.source_id,
            updateData.destiny_id
        ];
        try {
            const { rows } = await pool.query(query, values);
            return { success: true, newId: rows[0].id };
        } catch (error) {
            logError(error, '❌ Erro ao inserir ticket_update');
            return { success: false, error: error.message };
        }
    }

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

    static async getByTicketSyncIdAndSourceId(ticketSyncId, sourceId) {
        try {
            const query = `
                SELECT * FROM ticket_updates 
                WHERE ticket_sync_id = $1 AND source_id = $2
            `;
            const { rows } = await pool.query(query, [ticketSyncId, sourceId]);
            return rows[0] || null;
        } catch (error) {
            logError(error, `❌ Erro ao buscar update por ticket_sync_id e source_id`);
            throw error;
        }
    }
    static async getCommentSync(sourceId) {

        const ticketSyncId = await TicketUpdateModel.getIdSyncBySourceId(sourceId);
        if (!ticketSyncId) {
            return null;
        }
        
        return await this.getByTicketSyncIdAndSourceId(ticketSyncId, sourceId);
    }

    static async getDestinyIdBySourceId(sourceId) {
        try {
            const query = `
                SELECT destiny_id FROM ticket_updates
                WHERE source_id = $1
            `;
            const { rows } = await pool.query(query, [sourceId]);
            return rows[0] ? rows[0].destiny_id : null;
        } catch (error) {
            logError(error, '❌ Erro ao buscar destiny_id por source_id');
            throw error;
        }
    }

    static async updateDestinyId(sourceId, destinyId) {
        try {
            const query = `
                UPDATE ticket_updates
                SET destiny_id = $1
                WHERE source_id = $2
            `;
            await pool.query(query, [destinyId, sourceId]);
            return { success: true, destiny_id: destinyId };
        } catch (error) {
            logError(error, '❌ Erro ao atualizar destiny_id por source_id');
            throw error;
        }
    }

}
module.exports = TicketUpdateModel;