hubxglpi/src/infra/db/repositories/hubsoft/tickets.repository.js

//src/infra/db/repositories/hubsoft/ticket.repository.js

const db = require('../../connections/hubsoft.pg.js')
const { logError } = require('../../../../shared/utils/logger.js')

async function getTicketsByTipo({
  tipoAtendimento,
  usuarioAbertura = null,
  usuariosResponsaveisIds = null,
  watermark = null
}) {
  try {
    const isImplantacao = Number(tipoAtendimento) === 21;
    const isCancelamento = Number(tipoAtendimento) === 27;
    const istrocaTitularidade = Number(tipoAtendimento) === 60;

    let select = `
      a.id_atendimento,
      a.id_usuario_abertura,
      a.id_atendimento_status,
      a.protocolo,
      a.descricao_abertura,
      a.data_cadastro,
      a.nome_contato,
      c.codigo_cliente::text AS codigo_cliente,
      s.descricao AS servico_nome,
      cs.id_cliente_servico
    `;

    let joins = `
      FROM atendimento AS a
      INNER JOIN cliente_servico AS cs ON a.id_cliente_servico = cs.id_cliente_servico
      INNER JOIN cliente AS c ON cs.id_cliente = c.id_cliente
      INNER JOIN servico AS s ON cs.id_servico = s.id_servico
    `;

    if (isImplantacao || isCancelamento || istrocaTitularidade) {
      select += `,
        u.name AS vendedor,
        c.nome_razaosocial,
        c.telefone_primario AS telefone,
        c.cpf_cnpj,
        c.tipo_pessoa,
        c.email_principal AS email,
        en.endereco,
        en.numero,
        en.complemento,
        en.bairro,
        en.cep,
        ci.nome AS cidade,
        es.sigla AS estado
      `;

      joins += `
        INNER JOIN cliente_servico_endereco AS cse
          ON cse.id_cliente_servico = cs.id_cliente_servico
          AND cse.tipo = 'instalacao'
        INNER JOIN endereco_numero AS en
          ON en.id_endereco_numero = cse.id_endereco_numero
        INNER JOIN cidade AS ci
          ON ci.id_cidade = en.id_cidade
        INNER JOIN estado AS es
          ON es.id_estado = ci.id_estado
        INNER JOIN users AS u
          ON u.id = a.id_usuario_abertura
      `;
    }

    let query = `
      SELECT ${select}
      ${joins}
      WHERE a.id_tipo_atendimento = $1
        AND a.id_atendimento_status IN (1, 2, 33)
        AND s.ativo = true
    `;

    const params = [tipoAtendimento];
    let paramIndex = 2;

    if (usuarioAbertura) {
      query += ` AND a.id_usuario_abertura = $${paramIndex++}`;
      params.push(usuarioAbertura);
    }

    const responsibleUserIds = normalizeUserIds(usuariosResponsaveisIds);

    if (responsibleUserIds.length) {
      const responsibleIdsParam = paramIndex++;

      query += `
        AND EXISTS (
          SELECT 1
          FROM atendimento_usuario_responsavel AS aur
          WHERE aur.id_atendimento = a.id_atendimento
            AND aur.id_usuario = ANY($${responsibleIdsParam}::int[])
        )
      `;

      params.push(responsibleUserIds);
    }

    if (watermark) {
      query += ` AND a.data_cadastro > $${paramIndex++}`;
      params.push(watermark);
    }

    const { rows } = await db.query(query, params);
    return rows;

  } catch (error) {
    logError('Erro ao buscar tickets HubSoft', error);
    throw error;
  }
}

function normalizeUserIds(values) {
  return (values || [])
    .map(value => Number(value))
    .filter(Number.isInteger);
}

async function getTicketsClosedSince(thresholdDate) {
  try {

      if (process.env.HUBSOFT_MOCK_ENABLED === 'true') {
    return [
      {
        id_atendimento: 2949,
        protocolo: '20260120133512641803',
        hubsoft_closed_at: new Date('2026-01-06T08:20:45')
      },
      {
        id_atendimento: 2950,
        protocolo: '20260120133618108141',
        hubsoft_closed_at: new Date('2026-01-06T10:02:13')
      },
      {
        id_atendimento: 2955,
        protocolo: '20260120134024457448',
        hubsoft_closed_at: new Date('2025-12-18T14:35:56')
      }
    ]
  }
    const mundialeUserId = process.env.HUBSOFT_MUNDIALE_USER_ID;

    if (!mundialeUserId) {
      throw new Error('HUBSOFT_MUNDIALE_USER_ID não definido no .env');
    }

    const query = `
      SELECT
        id_atendimento,
        protocolo,
        data_fechamento AS hubsoft_closed_at
      FROM atendimento
      WHERE id_usuario_abertura = $1
        AND data_fechamento > $2
    `;

    const params = [
      Number(mundialeUserId),
      thresholdDate
    ];

    const { rows } = await db.query(query, params);
    return rows;

  } catch (error) {
    logError('Erro ao buscar tickets fechados HubSoft (Watchdog)', error);
    throw error;
  }
}


module.exports = {
  getTicketsByTipo,
  getTicketsClosedSince
}