notificationHelper.js

Go to the documentation of this file.

const pool = require('../services/db');
 
/**
 * Create a notification and optionally send to Slack
 * @param {object} options - Notification options
 * @param {number|null} options.userId - User ID to notify (null for system-wide)
 * @param {number|null} options.customerId - Customer ID related to notification
 * @param {string} options.title - Notification title
 * @param {string} options.message - Notification message
 * @param {string} options.type - Notification type (e.g., 'ticket', 'alert', 'agent', 'system')
 * @param {number|null} options.tenantId - Tenant ID for multi-tenancy
 * @returns {Promise<object>} Created notification object
 */
async function createNotification({ userId = null, customerId = null, title, message, type, tenantId = null }) {
  try {
    // Insert notification into database
    const result = await pool.query(
      `INSERT INTO notifications (user_id, customer_id, title, message, type, tenant_id) 
       VALUES ($1, $2, $3, $4, $5, $6) RETURNING *`,
      [userId, customerId, title, message, type, tenantId]
    );
 
    const notification = result.rows[0];
 
    // Try to send to Slack if integration is configured
    try {
      const slackRes = await pool.query(
        `SELECT config FROM integrations 
         WHERE tenant_id = $1 AND integration_type = 'slack' AND is_active = true LIMIT 1`,
        [tenantId]
      );
 
      if (slackRes.rows.length) {
        const slackCfg = slackRes.rows[0].config;
        const webhookUrl = slackCfg.webhookUrl;
        const channel = slackCfg.channel || '';
 
        if (webhookUrl) {
          const payload = {
            text: `*${title}*\n${message}`,
            channel: channel || undefined
          };
 
          await fetch(webhookUrl, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(payload)
          });
        }
      }
    } catch (slackError) {
      console.error('Slack notification error:', slackError);
      // Don't fail the notification creation if Slack fails
    }
 
    return notification;
  } catch (err) {
    console.error('Error creating notification:', err);
    throw err;
  }
}
 
/**
 * Create a notification for a new ticket
 * @param {object} ticket - Ticket object
 * @param {number} ticket.ticket_id - Ticket ID
 * @param {string} ticket.title - Ticket title
 * @param {string} ticket.description - Ticket description
 * @param {string} ticket.priority - Ticket priority
 * @param {number} ticket.assigned_to - User ID of assigned user
 * @param {number} ticket.customer_id - Customer ID
 * @param {number} ticket.tenant_id - Tenant ID
 */
async function notifyTicketCreated(ticket) {
  const { ticket_id, title, description, priority, assigned_to, customer_id, tenant_id } = ticket;
 
  // Notify assigned user if specified
  if (assigned_to) {
    await createNotification({
      userId: assigned_to,
      customerId: customer_id,
      title: `New ticket assigned: ${title}`,
      message: `You have been assigned ${priority} priority ticket #${ticket_id}: ${description.substring(0, 100)}${description.length > 100 ? '...' : ''}`,
      type: 'ticket',
      tenantId: tenant_id
    });
  }
 
  // Notify admins if no one is assigned (system notification for tenant)
  if (!assigned_to) {
    await createNotification({
      userId: null, // System notification
      customerId: customer_id,
      title: `Unassigned ticket created: ${title}`,
      message: `A new ${priority} priority ticket #${ticket_id} needs assignment: ${description.substring(0, 100)}${description.length > 100 ? '...' : ''}`,
      type: 'ticket',
      tenantId: tenant_id
    });
  }
}
 
/**
 * Create a notification for agent status changes
 * @param {object} agent - Agent object
 * @param {number} agent.agent_id - Agent ID
 * @param {string} agent.hostname - Agent hostname
 * @param {string} agent.status - Agent status (online/offline)
 * @param {number} agent.customer_id - Customer ID
 * @param {number} agent.tenant_id - Tenant ID
 */
async function notifyAgentStatusChange(agent) {
  const { agent_id, hostname, status, customer_id, tenant_id } = agent;
 
  if (status === 'offline') {
    await createNotification({
      userId: null, // System notification for tenant
      customerId: customer_id,
      title: `Agent Offline: ${hostname}`,
      message: `Agent ${hostname} (ID: ${agent_id}) has gone offline and may require attention.`,
      type: 'agent',
      tenantId: tenant_id
    });
  }
}
 
/**
 * Create a notification for monitoring alerts
 * @param {object} alert - Alert object
 * @param {number} alert.agent_id - Agent ID
 * @param {string} alert.hostname - Agent hostname
 * @param {string} alert.alertType - Type of alert (cpu, memory, disk, service)
 * @param {string} alert.message - Alert message
 * @param {number} alert.value - Current value
 * @param {number} alert.threshold - Threshold value
 * @param {number} alert.customer_id - Customer ID
 * @param {number} alert.tenant_id - Tenant ID
 */
async function notifyMonitoringAlert(alert) {
  const { agent_id, hostname, alertType, message, value, threshold, customer_id, tenant_id } = alert;
 
  let title = `Alert: ${hostname}`;
  switch (alertType) {
    case 'cpu':
      title = `CPU Alert: ${hostname}`;
      break;
    case 'memory':
      title = `Memory Alert: ${hostname}`;
      break;
    case 'disk':
      title = `Disk Space Alert: ${hostname}`;
      break;
    case 'service':
      title = `Service Alert: ${hostname}`;
      break;
  }
 
  await createNotification({
    userId: null, // System notification for tenant
    customerId: customer_id,
    title: title,
    message: message || `${alertType.toUpperCase()} on ${hostname} (Agent ${agent_id}): ${value}% exceeds threshold of ${threshold}%`,
    type: 'alert',
    tenantId: tenant_id
  });
}
 
module.exports = {
  createNotification,
  notifyTicketCreated,
  notifyAgentStatusChange,
  notifyMonitoringAlert
};