feat(plugin-cc): refactored-tasks

Author: adhmenon

docs/samples/contact-center/app.js

@@ -610,8 +610,12 @@ function registerTaskListeners(task) {
   });
 
   // Consult flows
-  task.on('task:consultOfferCreated', (task) => {
-    console.log('Consult offer created');
+  task.on('task:consultCreated', (task) => {
+    console.info('Consult created');
+  });
+
+  task.on('task:offerConsult', (task) => {
+    console.info('Received consult offer from another agent');
   });
 
   task.on('task:consultAccepted', (task) => {
@@ -671,19 +675,6 @@ function registerTaskListeners(task) {
     }
   });
 
-  task.on('task:rejected', (reason) => {
-    console.info('Task is rejected with reason:', reason);
-    if (reason === 'RONA_TIMER_EXPIRED') {
-      answerElm.disabled = true;
-      declineElm.disabled = true;
-      if(task.data.isConsulted) {
-        updateButtonsPostEndCall();
-        incomingDetailsElm.innerText = '';
-        currentTask = undefined;
-      }
-    }
-  });
-  
   task.on('task:rejected', (reason) => {
     console.info('Task is rejected with reason:', reason);
     showAgentStatePopup(reason);

packages/@webex/plugin-cc/src/cc.ts

@@ -21,6 +21,11 @@ import {
   EMPTY_STRING,
   AGENT_STATE_CHANGE,
   AGENT_MULTI_LOGIN,
+  AGENT_STATION_LOGIN_SUCCESS,
+  AGENT_STATION_LOGIN_FAILED,
+  AGENT_LOGOUT_SUCCESS,
+  AGENT_LOGOUT_FAILED,
+  AGENT_DN_REGISTERED,
   OUTDIAL_DIRECTION,
   ATTRIBUTES,
   OUTDIAL_MEDIA_TYPE,
@@ -34,13 +39,7 @@ import WebexRequest from './services/core/WebexRequest';
 import LoggerProxy from './logger-proxy';
 import {StateChange, Logout, StateChangeSuccess} from './services/agent/types';
 import {getErrorDetails} from './services/core/Utils';
-import {
-  Profile,
-  WelcomeEvent,
-  CC_EVENTS,
-  CC_AGENT_EVENTS,
-  ContactServiceQueue,
-} from './services/config/types';
+import {Profile, WelcomeEvent, CC_EVENTS, ContactServiceQueue} from './services/config/types';
 import {
   AGENT_STATE_AVAILABLE,
   AGENT_STATE_AVAILABLE_ID,
@@ -559,20 +558,43 @@ export default class ContactCenter extends WebexPlugin implements IContactCenter
 
   private handleWebSocketMessage = (event: string) => {
     const eventData = JSON.parse(event);
-    // Re-emit the events related to agent
-    if (Object.values(CC_AGENT_EVENTS).includes(eventData.data?.type)) {
+    // Re-emit all the events related to agent except keep-alives
+    if (!eventData.keepalive) {
       // @ts-ignore
       this.emit(eventData.data.type, eventData.data);
     }
 
-    if (eventData.type === CC_EVENTS.AGENT_STATE_CHANGE) {
-      // @ts-ignore
-      this.emit(AGENT_STATE_CHANGE, eventData.data);
-    }
-
-    if (eventData.type === CC_EVENTS.AGENT_MULTI_LOGIN) {
-      // @ts-ignore
-      this.emit(AGENT_MULTI_LOGIN, eventData.data);
+    switch (eventData.type) {
+      case CC_EVENTS.AGENT_STATION_LOGIN_SUCCESS:
+        // @ts-ignore
+        this.emit(AGENT_STATION_LOGIN_SUCCESS, eventData.data);
+        break;
+      case CC_EVENTS.AGENT_STATION_LOGIN_FAILED:
+        // @ts-ignore
+        this.emit(AGENT_STATION_LOGIN_FAILED, eventData.data);
+        break;
+      case CC_EVENTS.AGENT_LOGOUT_SUCCESS:
+        // @ts-ignore
+        this.emit(AGENT_LOGOUT_SUCCESS, eventData.data);
+        break;
+      case CC_EVENTS.AGENT_LOGOUT_FAILED:
+        // @ts-ignore
+        this.emit(AGENT_LOGOUT_FAILED, eventData.data);
+        break;
+      case CC_EVENTS.AGENT_STATE_CHANGE:
+        // @ts-ignore
+        this.emit(AGENT_STATE_CHANGE, eventData.data);
+        break;
+      case CC_EVENTS.AGENT_MULTI_LOGIN:
+        // @ts-ignore
+        this.emit(AGENT_MULTI_LOGIN, eventData.data);
+        break;
+      case CC_EVENTS.AGENT_DN_REGISTERED:
+        // @ts-ignore
+        this.emit(AGENT_DN_REGISTERED, eventData.data);
+        break;
+      default:
+        break;
     }
   };
 

packages/@webex/plugin-cc/src/constants.ts

@@ -15,6 +15,11 @@ export const WEBEX_REQUEST_FILE = 'WebexRequest';
 export const TASK_MANAGER_FILE = 'TaskManager';
 export const AGENT_STATE_CHANGE = 'agent:stateChange';
 export const AGENT_MULTI_LOGIN = 'agent:multiLogin';
+export const AGENT_STATION_LOGIN_SUCCESS = 'agent:stationLoginSuccess';
+export const AGENT_STATION_LOGIN_FAILED = 'agent:stationLoginFailed';
+export const AGENT_LOGOUT_SUCCESS = 'agent:logoutSuccess';
+export const AGENT_LOGOUT_FAILED = 'agent:logoutFailed';
+export const AGENT_DN_REGISTERED = 'agent:dnRegistered';
 // AGENT OUTDIAL CONSTANTS
 export const OUTDIAL_DIRECTION = 'OUTBOUND';
 export const ATTRIBUTES = {};

packages/@webex/plugin-cc/src/services/task/TaskManager.ts

@@ -178,15 +178,15 @@ export default class TaskManager extends EventEmitter {
               ...payload.data,
               isConsulted: false, // This ensures that the task consult status is always reset
             });
-            // Do not emit anything since this be received only as a result of an API invocation(handled by a promise)
+            task.emit(TASK_EVENTS.TASK_CONSULT_CREATED, task);
             break;
           case CC_EVENTS.AGENT_OFFER_CONSULT:
             // Received when other agent sends us a consult offer
             task = this.updateTaskData(task, {
               ...payload.data,
               isConsulted: true, // This ensures that the task is marked as us being requested for a consult
             });
-
+            task.emit(TASK_EVENTS.TASK_OFFER_CONSULT, task);
             break;
           case CC_EVENTS.AGENT_CONSULTING:
             // Received when agent is in an active consult state
@@ -222,8 +222,25 @@ export default class TaskManager extends EventEmitter {
             task = this.updateTaskData(task, payload.data);
             break;
           case CC_EVENTS.AGENT_WRAPPEDUP:
+            task.emit(TASK_EVENTS.TASK_WRAPPEDUP, task);
             this.removeTaskFromCollection(task);
             break;
+          case CC_EVENTS.CONTACT_RECORDING_PAUSED:
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_RECORDING_PAUSED, task);
+            break;
+          case CC_EVENTS.CONTACT_RECORDING_PAUSE_FAILED:
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_RECORDING_PAUSE_FAILED, payload.data);
+            break;
+          case CC_EVENTS.CONTACT_RECORDING_RESUMED:
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_RECORDING_RESUMED, task);
+            break;
+          case CC_EVENTS.CONTACT_RECORDING_RESUME_FAILED:
+            task = this.updateTaskData(task, payload.data);
+            task.emit(TASK_EVENTS.TASK_RECORDING_RESUME_FAILED, payload.data);
+            break;
           default:
             break;
         }

packages/@webex/plugin-cc/src/services/task/types.ts

@@ -48,10 +48,17 @@ export const TASK_EVENTS = {
   TASK_CONSULT_QUEUE_FAILED: 'task:consultQueueFailed',
   TASK_CONSULT_ACCEPTED: 'task:consultAccepted',
   TASK_CONSULTING: 'task:consulting',
+  TASK_CONSULT_CREATED: 'task:consultCreated',
+  TASK_OFFER_CONSULT: 'task:offerConsult',
   TASK_PAUSE: 'task:pause',
   TASK_RESUME: 'task:resume',
   TASK_END: 'task:end',
   TASK_WRAPUP: 'task:wrapup',
+  TASK_WRAPPEDUP: 'task:wrappedup',
+  TASK_RECORDING_PAUSED: 'task:recordingPaused',
+  TASK_RECORDING_PAUSE_FAILED: 'task:recordingPauseFailed',
+  TASK_RECORDING_RESUMED: 'task:recordingResumed',
+  TASK_RECORDING_RESUME_FAILED: 'task:recordingResumeFailed',
   TASK_REJECT: 'task:rejected',
   TASK_HYDRATE: 'task:hydrate',
 } as const;

packages/@webex/plugin-cc/test/unit/spec/cc.ts

@@ -20,6 +20,11 @@ import {
   CC_FILE,
   AGENT_STATE_CHANGE,
   AGENT_MULTI_LOGIN,
+  AGENT_STATION_LOGIN_SUCCESS,
+  AGENT_STATION_LOGIN_FAILED,
+  AGENT_LOGOUT_SUCCESS,
+  AGENT_LOGOUT_FAILED,
+  AGENT_DN_REGISTERED,
   OUTDIAL_DIRECTION,
   OUTBOUND_TYPE,
   ATTRIBUTES,
@@ -1513,4 +1518,30 @@ describe('webex.cc', () => {
       );
     });
   });
+
+  describe('handleWebSocketMessage events', () => {
+    let messageCallback;
+    let emitSpy;
+
+    beforeEach(() => {
+      emitSpy = jest.spyOn(webex.cc, 'emit');
+      messageCallback = mockWebSocketManager.on.mock.calls.find((c) => c[0] === 'message')[1];
+    });
+
+    [
+      { ccEvent: CC_EVENTS.AGENT_STATION_LOGIN_SUCCESS, constant: AGENT_STATION_LOGIN_SUCCESS },
+      { ccEvent: CC_EVENTS.AGENT_STATION_LOGIN_FAILED, constant: AGENT_STATION_LOGIN_FAILED },
+      { ccEvent: CC_EVENTS.AGENT_LOGOUT_SUCCESS, constant: AGENT_LOGOUT_SUCCESS },
+      { ccEvent: CC_EVENTS.AGENT_LOGOUT_FAILED, constant: AGENT_LOGOUT_FAILED },
+      { ccEvent: CC_EVENTS.AGENT_DN_REGISTERED, constant: AGENT_DN_REGISTERED },
+      { ccEvent: CC_EVENTS.AGENT_MULTI_LOGIN, constant: AGENT_MULTI_LOGIN },
+      { ccEvent: CC_EVENTS.AGENT_STATE_CHANGE, constant: AGENT_STATE_CHANGE },
+    ].forEach(({ ccEvent, constant }) => {
+      it(`should emit ${constant} on ${ccEvent}`, () => {
+        const sample = { foo: 'bar' };
+        messageCallback(JSON.stringify({type: ccEvent, data: sample}));
+        expect(emitSpy).toHaveBeenCalledWith(constant, sample);
+      });
+    });
+  });
 });

packages/@webex/plugin-cc/test/unit/spec/services/task/TaskManager.ts

@@ -489,14 +489,18 @@ describe('TaskManager', () => {
     };
 
     webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
-    const taskUpdateTaskDataSpy = jest.spyOn(taskManager.getTask(taskId), 'updateTaskData');
+    const task = taskManager.getTask(taskId);
+    const taskUpdateTaskDataSpy = jest.spyOn(task, 'updateTaskData');
+    const taskEmitSpy = jest.spyOn(task, 'emit');
+
     webSocketManagerMock.emit('message', JSON.stringify(payload));
+
     expect(taskUpdateTaskDataSpy).toHaveBeenCalledWith({
       ...payload.data,
       isConsulted: false,
     });
-    const task = taskManager.getTask(taskId);
     expect(task.data.isConsulted).toBe(false);
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_CONSULT_CREATED, task);
   });
 
   it('handle AGENT_OFFER_CONTACT event', () => {
@@ -550,17 +554,21 @@ describe('TaskManager', () => {
     };
 
     webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
-    taskManager.getTask(taskId).updateTaskData = jest.fn().mockImplementation((newData) => {
-      taskManager.getTask(taskId).data = {...newData, isConsulted: true};
-      return taskManager.getTask(taskId);
+    const task = taskManager.getTask(taskId);
+    task.updateTaskData = jest.fn().mockImplementation((newData) => {
+      task.data = {...newData, isConsulted: true};
+      return task;
     });
+    const taskEmitSpy = jest.spyOn(task, 'emit');
 
     webSocketManagerMock.emit('message', JSON.stringify(payload));
-    expect(taskManager.getTask(taskId).updateTaskData).toHaveBeenCalledWith({
+
+    expect(task.updateTaskData).toHaveBeenCalledWith({
       ...payload.data,
       isConsulted: true,
     });
-    expect(taskManager.getTask(taskId).data.isConsulted).toBe(true);
+    expect(task.data.isConsulted).toBe(true);
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_OFFER_CONSULT, task);
   });
 
   it('should emit TASK_CONSULT_ACCEPTED event on AGENT_CONSULTING event', () => {
@@ -747,10 +755,13 @@ describe('TaskManager', () => {
       },
     };
 
-    taskManager.taskCollection[taskId] = taskManager.getTask(taskId);
+    webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
+    const task = taskManager.getTask(taskId);
+    const taskEmitSpy = jest.spyOn(task, 'emit');
 
     webSocketManagerMock.emit('message', JSON.stringify(payload));
 
+    expect(taskEmitSpy).toHaveBeenCalledWith(TASK_EVENTS.TASK_WRAPPEDUP, task);
     expect(taskManager.getTask(taskId)).toBeUndefined();
   });
 
@@ -1176,5 +1187,20 @@ describe('TaskManager', () => {
     expect(unregisterSpy).not.toHaveBeenCalled();
     expect(cleanUpCallSpy).not.toHaveBeenCalled();
   });
+
+  // Tests for recording pause/resume events
+  ['PAUSED', 'PAUSE_FAILED', 'RESUMED', 'RESUME_FAILED'].forEach((suffix) => {
+    const ccEvent = CC_EVENTS[`CONTACT_RECORDING_${suffix}`];
+    const taskEvent = TASK_EVENTS[`TASK_RECORDING_${suffix}`];
+    it(`should emit ${taskEvent} on ${ccEvent} event`, () => {
+      const payload = {data: {...initalPayload.data, type: ccEvent}};
+      webSocketManagerMock.emit('message', JSON.stringify(initalPayload)); // setup
+      const task = taskManager.getTask(taskId);
+      const spy = jest.spyOn(task, 'emit');
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+      expect(spy).toHaveBeenCalledWith(taskEvent, suffix.includes('FAILED') ? payload.data : task);
+    });
+  });
 });