@webex/contact-center 3.9.0-next.2 → 3.9.0-next.4

package/src/services/task/index.ts

@@ -1,7 +1,11 @@
 import EventEmitter from 'events';
 import {CALL_EVENT_KEYS, LocalMicrophoneStream} from '@webex/calling';
 import {CallId} from '@webex/calling/dist/types/common/types';
-import {getErrorDetails} from '../core/Utils';
+import {
+  getErrorDetails,
+  deriveConsultTransferDestinationType,
+  getDestinationAgentId,
+} from '../core/Utils';
 import {LoginOption} from '../../types';
 import {TASK_FILE} from '../../constants';
 import {METHODS} from './constants';
@@ -19,7 +23,6 @@ import {
   ConsultEndPayload,
   TransferPayLoad,
   DESTINATION_TYPE,
-  CONSULT_TRANSFER_DESTINATION_TYPE,
   ConsultTransferPayLoad,
   MEDIA_CHANNEL,
 } from './types';
@@ -1308,61 +1311,78 @@ export default class Task extends EventEmitter implements ITask {
    * ```
    */
   public async consultTransfer(
-    consultTransferPayload: ConsultTransferPayLoad
+    consultTransferPayload?: ConsultTransferPayLoad
   ): Promise<TaskResponse> {
     try {
-      LoggerProxy.info(`Initiating consult transfer to ${consultTransferPayload.to}`, {
-        module: TASK_FILE,
-        method: METHODS.CONSULT_TRANSFER,
-        interactionId: this.data.interactionId,
-      });
+      // Get the destination agent ID using custom logic from participants data
+      const destAgentId = getDestinationAgentId(
+        this.data.interaction?.participants,
+        this.data.agentId
+      );
+
+      // Resolve the target id (queue consult transfers go to the accepted agent)
+      if (!destAgentId) {
+        throw new Error('No agent has accepted this queue consult yet');
+      }
 
-      // For queue destinations, use the destAgentId from task data
-      if (consultTransferPayload.destinationType === CONSULT_TRANSFER_DESTINATION_TYPE.QUEUE) {
-        if (!this.data.destAgentId) {
-          throw new Error('No agent has accepted this queue consult yet');
+      LoggerProxy.info(
+        `Initiating consult transfer to ${consultTransferPayload?.to || destAgentId}`,
+        {
+          module: TASK_FILE,
+          method: METHODS.CONSULT_TRANSFER,
+          interactionId: this.data.interactionId,
         }
+      );
+      // Obtain payload based on desktop logic using TaskData
+      const finalDestinationType = deriveConsultTransferDestinationType(this.data);
 
-        // Override the destination with the agent who accepted the queue consult
-        consultTransferPayload = {
-          to: this.data.destAgentId,
-          destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.AGENT,
-        };
-      }
+      // By default we always use the computed destAgentId as the target id
+      const consultTransferRequest: ConsultTransferPayLoad = {
+        to: destAgentId,
+        destinationType: finalDestinationType,
+      };
 
       const result = await this.contact.consultTransfer({
         interactionId: this.data.interactionId,
-        data: consultTransferPayload,
+        data: consultTransferRequest,
       });
 
       this.metricsManager.trackEvent(
         METRIC_EVENT_NAMES.TASK_TRANSFER_SUCCESS,
         {
           taskId: this.data.interactionId,
-          destination: consultTransferPayload.to,
-          destinationType: consultTransferPayload.destinationType,
+          destination: consultTransferRequest.to,
+          destinationType: consultTransferRequest.destinationType,
           isConsultTransfer: true,
           ...MetricsManager.getCommonTrackingFieldForAQMResponse(result),
         },
         ['operational', 'behavioral', 'business']
       );
 
-      LoggerProxy.log(`Consult transfer completed successfully to ${consultTransferPayload.to}`, {
-        module: TASK_FILE,
-        method: METHODS.CONSULT_TRANSFER,
-        trackingId: result.trackingId,
-        interactionId: this.data.interactionId,
-      });
+      LoggerProxy.log(
+        `Consult transfer completed successfully to ${consultTransferPayload?.to || destAgentId}`,
+        {
+          module: TASK_FILE,
+          method: METHODS.CONSULT_TRANSFER,
+          trackingId: result.trackingId,
+          interactionId: this.data.interactionId,
+        }
+      );
 
       return result;
     } catch (error) {
       const {error: detailedError} = getErrorDetails(error, METHODS.CONSULT_TRANSFER, TASK_FILE);
+      const failedDestinationType = deriveConsultTransferDestinationType(this.data);
+      const failedDestAgentId = getDestinationAgentId(
+        this.data.interaction?.participants,
+        this.data.agentId
+      );
       this.metricsManager.trackEvent(
         METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED,
         {
           taskId: this.data.interactionId,
-          destination: consultTransferPayload.to,
-          destinationType: consultTransferPayload.destinationType,
+          destination: failedDestAgentId || '',
+          destinationType: failedDestinationType,
           isConsultTransfer: true,
           error: error.toString(),
           ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(error.details || {}),

package/test/unit/spec/services/core/Utils.ts

@@ -276,4 +276,54 @@ describe('Utils', () => {
       });
     });
   });
+
+  describe('getDestinationAgentId', () => {
+    const currentAgentId = 'agent-current-123';
+
+    it('returns another Agent id when present and not in wrap-up', () => {
+      const participants: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        agent1: {type: 'Agent', id: 'agent-1', isWrapUp: false},
+        customer1: {type: 'Customer', id: 'cust-1', isWrapUp: false},
+      };
+
+      const result = Utils.getDestinationAgentId(participants, currentAgentId);
+      expect(result).toBe('agent-1');
+    });
+
+    it('ignores self and wrap-up participants', () => {
+      const participants: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        agentWrap: {type: 'Agent', id: 'agent-wrap', isWrapUp: true},
+      };
+
+      const result = Utils.getDestinationAgentId(participants, currentAgentId);
+      expect(result).toBe('');
+    });
+
+    it('supports DN, EpDn and entryPoint types', () => {
+      const participantsDN: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        dn1: {type: 'DN', id: 'dn-1', isWrapUp: false},
+      };
+      expect(Utils.getDestinationAgentId(participantsDN, currentAgentId)).toBe('dn-1');
+
+      const participantsEpDn: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        epdn1: {type: 'EpDn', id: 'epdn-1', isWrapUp: false},
+      };
+      expect(Utils.getDestinationAgentId(participantsEpDn, currentAgentId)).toBe('epdn-1');
+
+      const participantsEntry: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        entry1: {type: 'entryPoint', id: 'entry-1', isWrapUp: false},
+      };
+      expect(Utils.getDestinationAgentId(participantsEntry, currentAgentId)).toBe('entry-1');
+    });
+
+    it('returns empty string when participants is missing or empty', () => {
+      expect(Utils.getDestinationAgentId(undefined as any, currentAgentId)).toBe('');
+      expect(Utils.getDestinationAgentId({} as any, currentAgentId)).toBe('');
+    });
+  });
 });

package/test/unit/spec/services/task/TaskManager.ts

@@ -658,6 +658,13 @@ describe('TaskManager', () => {
   });
 
   it('should emit TASK_CONSULT_ACCEPTED event on AGENT_CONSULTING event', () => {
+    const initialConsultingPayload = {
+      data: {
+        ...initalPayload.data,
+        type: CC_EVENTS.AGENT_OFFER_CONSULT,
+      },
+    };
+
     const consultingPayload = {
       data: {
         ...initalPayload.data,
@@ -672,8 +679,8 @@ describe('TaskManager', () => {
     });
 
     const taskEmitSpy = jest.spyOn(taskManager.getTask(taskId), 'emit');
+    webSocketManagerMock.emit('message', JSON.stringify(initialConsultingPayload));
     webSocketManagerMock.emit('message', JSON.stringify(consultingPayload));
-    expect(taskManager.getTask(taskId).updateTaskData).toHaveBeenCalledWith(consultingPayload.data);
     expect(taskManager.getTask(taskId).data.isConsulted).toBe(true);
     expect(taskEmitSpy).toHaveBeenCalledWith(
       TASK_EVENTS.TASK_CONSULT_ACCEPTED,

package/test/unit/spec/services/task/index.ts

@@ -39,6 +39,7 @@ describe('Task', () => {
   let loggerInfoSpy;
   let loggerLogSpy;
   let loggerErrorSpy;
+  let getDestinationAgentIdSpy;
 
   const taskId = '0ae913a4-c857-4705-8d49-76dd3dde75e4';
   const mockTrack = {} as MediaStreamTrack;
@@ -141,6 +142,11 @@ describe('Task', () => {
       },
     };
 
+    // Mock destination agent id resolution from participants
+    getDestinationAgentIdSpy = jest
+      .spyOn(Utils, 'getDestinationAgentId')
+      .mockReturnValue(taskDataMock.destAgentId);
+
     // Create an instance of Task
     task = new Task(contactMock, webCallingService, taskDataMock);
 
@@ -163,6 +169,7 @@ describe('Task', () => {
 
   afterEach(() => {
     jest.clearAllMocks();
+    jest.restoreAllMocks();
   });
 
   it('test the on spy', async () => {
@@ -754,29 +761,81 @@ describe('Task', () => {
     expect(contactMock.consult).toHaveBeenCalledWith({interactionId: taskId, data: consultPayload});
     expect(response).toEqual(expectedResponse);
 
-    const consultTransferPayload: ConsultTransferPayLoad = {
-      to: '1234',
-      destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.AGENT,
-    };
-
-    const consultTransferResponse = await task.consultTransfer(consultTransferPayload);
+    const consultTransferResponse = await task.consultTransfer();
     expect(contactMock.consultTransfer).toHaveBeenCalledWith({
       interactionId: taskId,
-      data: consultTransferPayload,
+      data: {
+        to: taskDataMock.destAgentId,
+        destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.AGENT,
+      },
     });
     expect(mockMetricsManager.trackEvent).toHaveBeenNthCalledWith(
       2,
       METRIC_EVENT_NAMES.TASK_TRANSFER_SUCCESS,
       {
         taskId: taskDataMock.interactionId,
-        destination: consultTransferPayload.to,
-        destinationType: consultTransferPayload.destinationType,
+        destination: taskDataMock.destAgentId,
+        destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.AGENT,
         isConsultTransfer: true,
       },
       ['operational', 'behavioral', 'business']
     );
   });
 
+  it('should send DIALNUMBER when task destinationType is DN during consultTransfer', async () => {
+    const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
+    contactMock.consultTransfer.mockResolvedValue(expectedResponse);
+
+    // Ensure task data indicates DN scenario
+    task.data.destinationType = 'DN' as unknown as string;
+
+    await task.consultTransfer();
+
+    expect(contactMock.consultTransfer).toHaveBeenCalledWith({
+      interactionId: taskId,
+      data: {
+        to: taskDataMock.destAgentId,
+        destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.DIALNUMBER,
+      },
+    });
+  });
+
+  it('should send ENTRYPOINT when task destinationType is EPDN during consultTransfer', async () => {
+    const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
+    contactMock.consultTransfer.mockResolvedValue(expectedResponse);
+
+    // Ensure task data indicates EP/EPDN scenario
+    task.data.destinationType = 'EPDN' as unknown as string;
+
+    await task.consultTransfer();
+
+    expect(contactMock.consultTransfer).toHaveBeenCalledWith({
+      interactionId: taskId,
+      data: {
+        to: taskDataMock.destAgentId,
+        destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.ENTRYPOINT,
+      },
+    });
+  });
+
+  it('should keep AGENT when task destinationType is neither DN nor EPDN/ENTRYPOINT', async () => {
+    const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
+    contactMock.consultTransfer.mockResolvedValue(expectedResponse);
+
+    // Ensure task data indicates non-DN and non-EP/EPDN scenario
+    task.data.destinationType = 'SOMETHING_ELSE' as unknown as string;
+
+    await task.consultTransfer();
+
+    expect(contactMock.consultTransfer).toHaveBeenCalledWith({
+      interactionId: taskId,
+      data: {
+        to: taskDataMock.destAgentId,
+        destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.AGENT,
+      },
+    });
+  });
+
   it('should do consult transfer to a queue by using the destAgentId from task data', async () => {
     const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
     contactMock.consultTransfer.mockResolvedValue(expectedResponse);
@@ -811,6 +870,9 @@ describe('Task', () => {
       destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.QUEUE,
     };
 
+    // For this negative case, ensure computed destination is empty
+    getDestinationAgentIdSpy.mockReturnValueOnce('');
+
     await expect(
       taskWithoutDestAgentId.consultTransfer(queueConsultTransferPayload)
     ).rejects.toThrow('Error while performing consultTransfer');
@@ -855,8 +917,8 @@ describe('Task', () => {
       METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED,
       {
         taskId: taskDataMock.interactionId,
-        destination: consultTransferPayload.to,
-        destinationType: consultTransferPayload.destinationType,
+        destination: taskDataMock.destAgentId,
+        destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.AGENT,
         isConsultTransfer: true,
         error: error.toString(),
         ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(error.details),