@webex/contact-center 0.0.0-next.1

package/src/services/core/websocket/connection-service.ts

@@ -0,0 +1,142 @@
+import {EventEmitter} from 'events';
+import {WebSocketManager} from './WebSocketManager';
+import LoggerProxy from '../../../logger-proxy';
+import {ConnectionServiceOptions, ConnectionLostDetails, ConnectionProp} from './types';
+import {
+  LOST_CONNECTION_RECOVERY_TIMEOUT,
+  WS_DISCONNECT_ALLOWED,
+  CONNECTIVITY_CHECK_INTERVAL,
+  METHODS,
+} from '../constants';
+import {CONNECTION_SERVICE_FILE} from '../../../constants';
+import {SubscribeRequest} from '../../../types';
+
+export class ConnectionService extends EventEmitter {
+  private connectionProp: ConnectionProp = {
+    lostConnectionRecoveryTimeout: LOST_CONNECTION_RECOVERY_TIMEOUT,
+  };
+
+  private wsDisconnectAllowed = WS_DISCONNECT_ALLOWED;
+  private reconnectingTimer: ReturnType<typeof setTimeout>;
+  private restoreTimer: ReturnType<typeof setTimeout>;
+  private isConnectionLost: boolean;
+  private isRestoreFailed: boolean;
+  private isSocketReconnected: boolean;
+  private isKeepAlive: boolean;
+  private reconnectInterval: ReturnType<typeof setInterval>;
+  private webSocketManager: WebSocketManager;
+  private subscribeRequest: SubscribeRequest;
+
+  constructor(options: ConnectionServiceOptions) {
+    super();
+    this.webSocketManager = options.webSocketManager;
+    this.subscribeRequest = options.subscribeRequest;
+
+    this.isConnectionLost = false;
+    this.isRestoreFailed = false;
+    this.isSocketReconnected = false;
+    this.isKeepAlive = false;
+
+    this.setupEventListeners();
+  }
+
+  private setupEventListeners() {
+    this.webSocketManager.on('message', this.onPing.bind(this));
+    this.webSocketManager.on('socketClose', this.onSocketClose.bind(this));
+  }
+
+  private dispatchConnectionEvent(socketReconnected = false): void {
+    const event: ConnectionLostDetails = {
+      isConnectionLost: this.isConnectionLost,
+      isRestoreFailed: this.isRestoreFailed,
+      isSocketReconnected:
+        !this.webSocketManager.isSocketClosed && (socketReconnected || this.isSocketReconnected),
+      isKeepAlive: this.isKeepAlive,
+    };
+    this.webSocketManager.handleConnectionLost(event);
+    LoggerProxy.info(`Dispatching connection event`, {
+      module: CONNECTION_SERVICE_FILE,
+      method: METHODS.DISPATCH_CONNECTION_EVENT,
+    });
+    this.emit('connectionLost', event);
+  }
+
+  private handleConnectionLost = (): void => {
+    this.isConnectionLost = true;
+    this.dispatchConnectionEvent();
+  };
+
+  private clearTimerOnRestoreFailed = async () => {
+    if (this.reconnectInterval) {
+      clearInterval(this.reconnectInterval);
+    }
+  };
+
+  private handleRestoreFailed = async () => {
+    this.isRestoreFailed = true;
+    this.webSocketManager.shouldReconnect = false;
+    this.dispatchConnectionEvent();
+    await this.clearTimerOnRestoreFailed();
+  };
+
+  private updateConnectionData = (): void => {
+    this.isRestoreFailed = false;
+    this.isConnectionLost = false;
+    this.isSocketReconnected = false;
+  };
+
+  public setConnectionProp(prop: ConnectionProp): void {
+    this.connectionProp = prop;
+  }
+
+  private onPing = (event: any): void => {
+    const parsedEvent = JSON.parse(event);
+    if (this.reconnectingTimer) {
+      clearTimeout(this.reconnectingTimer);
+    }
+    if (this.restoreTimer) {
+      clearTimeout(this.restoreTimer);
+    }
+    this.isKeepAlive = parsedEvent.keepalive === 'true';
+
+    if (
+      ((this.isConnectionLost && !this.isRestoreFailed) || this.isKeepAlive) &&
+      !this.isSocketReconnected
+    ) {
+      this.updateConnectionData();
+      this.dispatchConnectionEvent();
+    } else if (this.isSocketReconnected && this.isKeepAlive) {
+      this.updateConnectionData();
+      this.dispatchConnectionEvent(true);
+    }
+
+    this.reconnectingTimer = setTimeout(this.handleConnectionLost, this.wsDisconnectAllowed);
+    this.restoreTimer = setTimeout(
+      this.handleRestoreFailed,
+      this.connectionProp && this.connectionProp.lostConnectionRecoveryTimeout
+    );
+  };
+
+  private handleSocketClose = async (): Promise<void> => {
+    LoggerProxy.info(`event=socketConnectionRetry | Trying to reconnect to websocket`, {
+      module: CONNECTION_SERVICE_FILE,
+      method: METHODS.HANDLE_SOCKET_CLOSE,
+    });
+    const onlineStatus = navigator.onLine;
+    if (onlineStatus) {
+      await this.webSocketManager.initWebSocket({body: this.subscribeRequest});
+      await this.clearTimerOnRestoreFailed();
+      this.isSocketReconnected = true;
+    } else {
+      throw new Error('event=socketConnectionRetry | browser network not available');
+    }
+  };
+
+  private onSocketClose = (): void => {
+    this.clearTimerOnRestoreFailed();
+
+    this.reconnectInterval = setInterval(async () => {
+      await this.handleSocketClose();
+    }, CONNECTIVITY_CHECK_INTERVAL);
+  };
+}

package/src/services/core/websocket/keepalive.worker.js

@@ -0,0 +1,88 @@
+// TODO: Try to find alternative to using Blob and script here
+const workerScript = `
+console.log("*** Keepalive Worker Thread ***");
+let intervalId, intervalDuration, timeOutId, isSocketClosed, closeSocketTimeout;
+let initialised = false;
+let initiateWebSocketClosure = false;
+
+const resetOfflineHandler = function () {
+  if (timeOutId) {
+    initialised = false;
+    clearTimeout(timeOutId);
+    timeOutId = null;
+  }
+};
+
+const checkOnlineStatus = function () {
+  const onlineStatus = navigator.onLine;
+  console.log(
+    \`[WebSocketStatus] event=checkOnlineStatus | online status=\`,
+    onlineStatus
+  );
+  return onlineStatus;
+};
+
+// Checks network status and if it's offline then force closes WebSocket
+const checkNetworkStatus = function () {
+  const onlineStatus = checkOnlineStatus();
+  postMessage({ type: "keepalive", onlineStatus });
+  if (!onlineStatus && !initialised) {
+    initialised = true;
+    // Sets a timeout of 16s, checks if socket didn't close then it closes forcefully
+    timeOutId = setTimeout(() => {
+      if (!isSocketClosed) {
+        initiateWebSocketClosure = true;
+        postMessage({ type: "closeSocket" });
+      }
+    }, closeSocketTimeout);
+  }
+
+  if (onlineStatus && initialised) {
+    initialised = false;
+  }
+
+  if (initiateWebSocketClosure) {
+    initiateWebSocketClosure = false;
+    clearTimeout(timeOutId);
+    timeOutId = null;
+  }
+};
+
+addEventListener("message", (event) => {
+  if (event.data?.type === "start") {
+    intervalDuration = event.data?.intervalDuration || 4000;
+    closeSocketTimeout = event.data?.closeSocketTimeout || 5000;
+    console.log("event=Websocket startWorker | keepalive Worker started");
+    intervalId = setInterval(
+      (checkIfSocketClosed) => {
+        checkNetworkStatus();
+        isSocketClosed = checkIfSocketClosed;
+      },
+      intervalDuration,
+      event.data?.isSocketClosed
+    );
+
+    resetOfflineHandler();
+  }
+
+  if (event.data?.type === "terminate" && intervalId) {
+    console.log("event=Websocket terminateWorker | keepalive Worker stopped");
+    clearInterval(intervalId);
+    intervalId = null;
+    resetOfflineHandler();
+  }
+});
+
+// Listen for online and offline events
+self.addEventListener('online', () => {
+  console.log('Network status: online');
+  checkNetworkStatus();
+});
+
+self.addEventListener('offline', () => {
+  console.log('Network status: offline');
+  checkNetworkStatus();
+});
+`;
+
+export default workerScript;

package/src/services/core/websocket/types.ts

@@ -0,0 +1,40 @@
+import {SubscribeRequest} from '../../../types';
+import {WebSocketManager} from './WebSocketManager';
+
+/**
+ * Options for initializing a connection service.
+ * @typedef ConnectionServiceOptions
+ * @property {WebSocketManager} webSocketManager - The WebSocket manager instance.
+ * @property {SubscribeRequest} subscribeRequest - The subscribe request payload.
+ * @ignore
+ */
+export type ConnectionServiceOptions = {
+  webSocketManager: WebSocketManager;
+  subscribeRequest: SubscribeRequest;
+};
+
+/**
+ * Details about the state of a lost connection and recovery attempts.
+ * @typedef ConnectionLostDetails
+ * @property {boolean} isConnectionLost - Indicates if the connection is currently lost.
+ * @property {boolean} isRestoreFailed - Indicates if restoring the connection has failed.
+ * @property {boolean} isSocketReconnected - Indicates if the socket has been reconnected.
+ * @property {boolean} isKeepAlive - Indicates if the keep-alive mechanism is active.
+ * @ignore
+ */
+export type ConnectionLostDetails = {
+  isConnectionLost: boolean;
+  isRestoreFailed: boolean;
+  isSocketReconnected: boolean;
+  isKeepAlive: boolean;
+};
+
+/**
+ * Properties for connection configuration.
+ * @typedef ConnectionProp
+ * @property {number} lostConnectionRecoveryTimeout - Timeout in milliseconds for lost connection recovery.
+ * @ignore
+ */
+export type ConnectionProp = {
+  lostConnectionRecoveryTimeout: number;
+};

package/src/services/index.ts

@@ -0,0 +1,71 @@
+import routingAgent from './agent';
+import routingContact from './task/contact';
+import AgentConfigService from './config';
+import AqmReqs from './core/aqm-reqs';
+import {WebSocketManager} from './core/websocket/WebSocketManager';
+import {ConnectionService} from './core/websocket/connection-service';
+import {WebexSDK, SubscribeRequest} from '../types';
+import aqmDialer from './task/dialer';
+
+/**
+ * Services class provides centralized access to all contact center plugin services
+ * using a singleton pattern to ensure a single instance throughout the application.
+ * @private
+ * @ignore
+ * @class
+ */
+export default class Services {
+  /** Agent services for managing agent state and capabilities */
+  public readonly agent: ReturnType<typeof routingAgent>;
+  /** Configuration services for agent settings */
+  public readonly config: AgentConfigService;
+  /** Contact services for managing customer interactions */
+  public readonly contact: ReturnType<typeof routingContact>;
+  /** Dialer services for outbound calling features */
+  public readonly dialer: ReturnType<typeof aqmDialer>;
+  /** WebSocket manager for handling real-time communications */
+  public readonly webSocketManager: WebSocketManager;
+  /** Connection service for managing websocket connections */
+  public readonly connectionService: ConnectionService;
+  /** Singleton instance of the Services class */
+  private static instance: Services;
+
+  /**
+   * Creates a new Services instance
+   * @param options - Configuration options
+   * @param options.webex - WebexSDK instance
+   * @param options.connectionConfig - Subscription configuration for websocket connection
+   */
+  constructor(options: {webex: WebexSDK; connectionConfig: SubscribeRequest}) {
+    const {webex, connectionConfig} = options;
+    this.webSocketManager = new WebSocketManager({webex});
+    const aqmReq = new AqmReqs(this.webSocketManager);
+    this.config = new AgentConfigService();
+    this.agent = routingAgent(aqmReq);
+    this.contact = routingContact(aqmReq);
+    this.dialer = aqmDialer(aqmReq);
+    this.connectionService = new ConnectionService({
+      webSocketManager: this.webSocketManager,
+      subscribeRequest: connectionConfig,
+    });
+  }
+
+  /**
+   * Gets singleton instance of Services class
+   * Creates a new instance if one doesn't exist
+   * @param options - Configuration options
+   * @param options.webex - WebexSDK instance
+   * @param options.connectionConfig - Subscription configuration for websocket connection
+   * @returns The singleton Services instance
+   */
+  public static getInstance(options: {
+    webex: WebexSDK;
+    connectionConfig: SubscribeRequest;
+  }): Services {
+    if (!this.instance) {
+      this.instance = new Services(options);
+    }
+
+    return this.instance;
+  }
+}

package/src/services/task/AutoWrapup.ts

@@ -0,0 +1,86 @@
+import LoggerProxy from '../../logger-proxy';
+
+/**
+ * AutoWrapup class implements a timer for automatic wrap-up functionality.
+ * It handles timing the wrap-up period and executing a callback when the timer completes.
+ */
+export default class AutoWrapup {
+  private timer: ReturnType<typeof setTimeout> | null = null;
+  private startTime = 0;
+  private readonly interval: number;
+  public allowCancelAutoWrapup = false;
+
+  /**
+   * Creates a new AutoWrapup timer
+   * @param interval - Time in milliseconds before auto wrap-up executes
+   *  @param allowCancelAutoWrapup - Whether to allow canceling the auto wrap-up
+   */
+  constructor(interval: number, allowCancelAutoWrapup = false) {
+    this.interval = interval;
+    this.allowCancelAutoWrapup = allowCancelAutoWrapup;
+  }
+
+  /**
+   * Starts the auto wrap-up timer
+   * @param onComplete - Callback function to execute when timer completes
+   */
+  public start(onComplete: () => void): void {
+    LoggerProxy.info('AutoWrapup: clear called', {
+      module: 'AutoWrapup',
+      method: 'clear',
+    });
+
+    if (this.timer) {
+      this.clear();
+    }
+
+    this.startTime = Date.now();
+
+    this.timer = setTimeout(() => {
+      onComplete();
+      this.timer = null;
+    }, this.interval);
+  }
+
+  /**
+   * Clears the auto wrap-up timer if it's running
+   */
+  public clear(): void {
+    LoggerProxy.info('AutoWrapup: clear called', {
+      module: 'AutoWrapup',
+      method: 'clear',
+    });
+
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+      this.startTime = 0;
+    }
+  }
+
+  /**
+   * Gets the remaining time in milliseconds
+   * @returns Time left in milliseconds
+   */
+  public getTimeLeft(): number {
+    const elapsed = Date.now() - this.startTime;
+
+    return Math.max(0, this.interval - elapsed);
+  }
+
+  /**
+   * Checks if the timer is currently running
+   * @returns True if the timer is running, false otherwise
+   */
+  public isRunning(): boolean {
+    return this.timer !== null;
+  }
+
+  /**
+   * Gets the remaining time in seconds (rounded)
+   * @returns Time left in seconds
+   */
+  public getTimeLeftSeconds(): number {
+    return Math.ceil(this.getTimeLeft() / 1000);
+  }
+}