Push Notifications

const terminals = new Map();

function handleTerminalStatusUpdate(message) {
  const { terminalId, status, terminalInfo } = message;

  switch (status) {
    case 'connected':
      terminals.set(terminalId, terminalInfo);
      console.log(`Terminal ${terminalId} is now online`);
      updateUI('terminal-online', terminalId);
      break;

    case 'reconnecting':
      const terminal = terminals.get(terminalId);
      if (terminal) {
        terminal.status = 'reconnecting';
      }
      console.log(`Terminal ${terminalId} is reconnecting (60s grace period)`);
      updateUI('terminal-reconnecting', terminalId);
      break;

    case 'disconnected':
      terminals.delete(terminalId);
      console.log(`Terminal ${terminalId} is offline`);
      updateUI('terminal-offline', terminalId);
      break;
  }
}

ws.on('message', (data) => {
  const message = JSON.parse(data.toString());

  if (message.action === 'terminalStatusUpdate') {
    handleTerminalStatusUpdate(message);
  }
});

const pendingPayments = new Map();

function handlePaymentComplete(message) {
  const { paymentResponse } = message;
  const { transactionId, status } = paymentResponse;

  // Remove from pending
  pendingPayments.delete(transactionId);

  switch (status) {
    case 'SUCCESS':
      console.log(`Payment ${transactionId} successful`);
      console.log(`Authorization: ${paymentResponse.authorizationCode}`);

      // Update order status
      updateOrderStatus(paymentResponse.metadata.orderId, 'PAID');

      // Print receipt
      if (paymentResponse.receiptData) {
        printReceipt(paymentResponse.receiptData);
      }

      // Notify staff
      showNotification('Payment successful', 'success');
      break;

    case 'FAILED':
      console.log(`Payment ${transactionId} failed: ${paymentResponse.errorMessage}`);

      // Update order status
      updateOrderStatus(paymentResponse.metadata.orderId, 'PAYMENT_FAILED');

      // Notify staff with error
      showNotification(`Payment failed: ${paymentResponse.errorMessage}`, 'error');
      break;

    case 'CANCELLED':
      console.log(`Payment ${transactionId} cancelled`);
      updateOrderStatus(paymentResponse.metadata.orderId, 'CANCELLED');
      showNotification('Payment cancelled', 'warning');
      break;

    case 'PENDING':
      console.log(`Payment ${transactionId} pending`);
      // Re-add to pending with timeout check
      pendingPayments.set(transactionId, paymentResponse);
      break;
  }
}

ws.on('message', (data) => {
  const message = JSON.parse(data.toString());

  if (message.action === 'paymentComplete') {
    handlePaymentComplete(message);
  }
});

function handlePaymentVoided(message) {
  const { transactionId, reason, originalPaymentResponse } = message;

  console.log(`Payment ${transactionId} was automatically voided`);
  console.log(`Reason: ${reason}`);
  console.log(`Original amount: ${originalPaymentResponse.amount}`);

  // Update order to require new payment
  updateOrderStatus(transactionId, 'VOIDED');

  // Alert staff
  showNotification(
    `Payment for ${originalPaymentResponse.amount} ${originalPaymentResponse.currency} ` +
    `was voided: Terminal reconnected too late. Please retry the payment.`,
    'warning'
  );

  // Log for audit
  logVoidedPayment({
    transactionId,
    reason,
    originalAmount: originalPaymentResponse.amount,
    voidedAt: message.timestamp
  });
}

ws.on('message', (data) => {
  const message = JSON.parse(data.toString());

  if (message.action === 'paymentVoided') {
    handlePaymentVoided(message);
  }
});

const WebSocket = require('ws');

const ws = new WebSocket('wss://{your-api-endpoint}/v1', {
  headers: { 'x-api-key': process.env.MODULUS_API_KEY }
});

ws.on('message', (data) => {
  const message = JSON.parse(data.toString());

  switch (message.action) {
    // Actions responses
    case 'terminalsResponse':
      handleTerminalsResponse(message);
      break;
    case 'pong':
      handlePong();
      break;

    // Push notifications
    case 'terminalStatusUpdate':
      handleTerminalStatusUpdate(message);
      break;
    case 'paymentComplete':
      handlePaymentComplete(message);
      break;
    case 'paymentVoided':
      handlePaymentVoided(message);
      break;

    // Connection events
    case 'forceDisconnect':
      handleForceDisconnect(message);
      break;

    // Errors
    case undefined:
      if (message.error) {
        handleError(message);
      }
      break;

    default:
      console.log('Unknown message:', message);
  }
});