@webex/contact-center 3.12.0-llmrefactor.2 → 3.12.0-llmrefactor.3

package/test/unit/spec/services/task/state-machine/uiControlsComputer.ts

@@ -1,8 +1,13 @@
-import {TASK_CHANNEL_TYPE, VOICE_VARIANT} from '../../../../../../src/services/task/types';
+import {
+  CONSULT_TRANSFER_DESTINATION_TYPE,
+  TASK_CHANNEL_TYPE,
+  VOICE_VARIANT,
+} from '../../../../../../src/services/task/types';
 import {TaskState} from '../../../../../../src/services/task/state-machine/constants';
 import {
   computeUIControls,
   getDefaultUIControls,
+  haveUIControlsChanged,
 } from '../../../../../../src/services/task/state-machine/uiControlsComputer';
 import {getTaskStateForUiControls} from '../../../../../../src/services/task/state-machine/actions';
 import {TaskContext} from '../../../../../../src/services/task/state-machine/types';
@@ -554,6 +559,27 @@ function createVoiceContext(overrides: Partial<TaskContext> = {}): TaskContext {
   };
 }
 
+function createConsultTransferContext(
+  taskData = createTaskData(),
+  overrides: Partial<NonNullable<TaskContext['uiControlConfig']['consultTransferConfig']>> = {}
+): TaskContext {
+  const context = createVoiceContext({taskData});
+
+  return {
+    ...context,
+    uiControlConfig: {
+      ...context.uiControlConfig,
+      consultTransferConfig: {
+        allowConsultToQueue: true,
+        accessQueue: 'ALL',
+        accessEntryPoint: 'ALL',
+        accessBuddyTeam: 'ALL',
+        ...overrides,
+      },
+    },
+  };
+}
+
 function createTaskData1LikeConferenceConsultTaskData() {
   return createTaskData({
     agentId: '058b3e7c-8fcf-45ee-b0c4-4ef546d360b9',
@@ -613,7 +639,10 @@ function createTaskData1LikeConferenceConsultTaskData() {
           mediaResourceId: '66cc5edd-8ac9-4f27-8f48-286edea460b2',
           mType: 'consult',
           isHold: false,
-          participants: ['747a2138-0a24-48fc-8d69-3a336d9b7158', '058b3e7c-8fcf-45ee-b0c4-4ef546d360b9'],
+          participants: [
+            '747a2138-0a24-48fc-8d69-3a336d9b7158',
+            '058b3e7c-8fcf-45ee-b0c4-4ef546d360b9',
+          ],
         },
       } as any,
       owner: 'e271075a-077d-42d0-9ae4-2a43cb847664',
@@ -1258,7 +1287,11 @@ describe('uiControlsComputer consult initiator controls', () => {
         agentId: 'agent-1',
       },
     });
-    const createdControls = computeUIControls(TaskState.CONSULTING, createdContext, createdTaskData);
+    const createdControls = computeUIControls(
+      TaskState.CONSULTING,
+      createdContext,
+      createdTaskData
+    );
 
     expect(createdControls.consult.transferConference).toEqual({isVisible: true, isEnabled: false});
 
@@ -1274,7 +1307,10 @@ describe('uiControlsComputer consult initiator controls', () => {
       consultingTaskData
     );
 
-    expect(consultingControls.consult.transferConference).toEqual({isVisible: true, isEnabled: true});
+    expect(consultingControls.consult.transferConference).toEqual({
+      isVisible: true,
+      isEnabled: true,
+    });
   });
 
   it('hides exitConference on main leg for consult initiator before destination joins', () => {
@@ -1919,7 +1955,6 @@ describe('uiControlsComputer consult initiator controls', () => {
     expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: true});
     expect(uiControls.consult.endConsult).toEqual({isVisible: false, isEnabled: false});
   });
-
 });
 
 describe('uiControlsComputer outdial accept/decline controls', () => {
@@ -2064,7 +2099,10 @@ describe('uiControlsComputer conference controls', () => {
     });
   }
 
-  function createConferenceContext(participantCount: number, overrides: Partial<TaskContext> = {}): TaskContext {
+  function createConferenceContext(
+    participantCount: number,
+    overrides: Partial<TaskContext> = {}
+  ): TaskContext {
     return {
       taskData: createConferenceTaskData(participantCount),
       consultInitiator: true,
@@ -2414,7 +2452,6 @@ describe('uiControlsComputer conference controls', () => {
     expect(uiControls.main.exitConference).toEqual({isVisible: true, isEnabled: true});
   });
 
-
   it('post_call after customer exit: only exitConference and end enabled during EP-DN pending merge (CAI-8329)', () => {
     const taskData = createTaskData({
       agentId: 'agent-1',
@@ -2577,6 +2614,115 @@ describe('uiControlsComputer conference controls', () => {
   });
 });
 
+describe('uiControlsComputer consult/transfer destinations', () => {
+  const AGENT = CONSULT_TRANSFER_DESTINATION_TYPE.AGENT;
+  const QUEUE = CONSULT_TRANSFER_DESTINATION_TYPE.QUEUE;
+  const DIAL_NUMBER = CONSULT_TRANSFER_DESTINATION_TYPE.DIALNUMBER;
+  const ENTRY_POINT = CONSULT_TRANSFER_DESTINATION_TYPE.ENTRYPOINT;
+
+  it('returns the default destination order and applies the action-specific inbound voice queue rule', () => {
+    const taskData = createTaskData({
+      interaction: {contactDirection: {type: 'INBOUND'}} as any,
+    });
+    const context = createConsultTransferContext(taskData, {allowConsultToQueue: false});
+
+    const controls = computeUIControls(TaskState.CONNECTED, context, taskData);
+
+    expect(controls.consultTransferDestinations.consult).toEqual([AGENT, DIAL_NUMBER, ENTRY_POINT]);
+    expect(controls.consultTransferDestinations.transfer).toEqual([
+      AGENT,
+      QUEUE,
+      DIAL_NUMBER,
+      ENTRY_POINT,
+    ]);
+  });
+
+  it('reads the outbound queue-transfer flag from callProcessingDetails', () => {
+    const disabledTaskData = createTaskData({
+      interaction: {
+        contactDirection: {type: 'OUTBOUND'},
+        callProcessingDetails: {outdialTransferToQueueEnabled: false},
+      } as any,
+    });
+    const disabledContext = createConsultTransferContext(disabledTaskData);
+    const disabledControls = computeUIControls(
+      TaskState.CONNECTED,
+      disabledContext,
+      disabledTaskData
+    );
+
+    expect(disabledControls.consultTransferDestinations.transfer).toEqual([
+      AGENT,
+      DIAL_NUMBER,
+      ENTRY_POINT,
+    ]);
+
+    const enabledTaskData = createTaskData({
+      interaction: {
+        contactDirection: {type: 'OUTBOUND'},
+        callProcessingDetails: {outdialTransferToQueueEnabled: true},
+      } as any,
+    });
+    const enabledContext = createConsultTransferContext(enabledTaskData);
+    const enabledControls = computeUIControls(TaskState.CONNECTED, enabledContext, enabledTaskData);
+
+    expect(enabledControls.consultTransferDestinations.transfer).toEqual([
+      AGENT,
+      QUEUE,
+      DIAL_NUMBER,
+      ENTRY_POINT,
+    ]);
+    expect(haveUIControlsChanged(disabledControls, enabledControls)).toBe(true);
+  });
+
+  it('hides profile-disabled destinations and does not allow queue transfer for unknown voice direction', () => {
+    const taskData = createTaskData({
+      interaction: {contactDirection: {type: 'UNKNOWN'}} as any,
+    });
+    const context = createConsultTransferContext(taskData, {
+      accessQueue: 'NONE',
+      accessEntryPoint: 'NONE',
+      accessBuddyTeam: 'NONE',
+    });
+
+    const controls = computeUIControls(TaskState.CONNECTED, context, taskData);
+
+    expect(controls.consultTransferDestinations).toEqual({
+      consult: [DIAL_NUMBER],
+      transfer: [DIAL_NUMBER],
+    });
+  });
+
+  it('returns only agents and queues for digital tasks', () => {
+    const taskData = createTaskData({
+      interaction: {mediaType: 'chat'} as any,
+    });
+    const voiceContext = createConsultTransferContext(taskData, {allowConsultToQueue: false});
+    const context: TaskContext = {
+      ...voiceContext,
+      uiControlConfig: {
+        ...voiceContext.uiControlConfig,
+        channelType: TASK_CHANNEL_TYPE.DIGITAL,
+      },
+    };
+
+    const controls = computeUIControls(TaskState.CONNECTED, context, taskData);
+
+    expect(controls.consultTransferDestinations).toEqual({
+      consult: [AGENT, QUEUE],
+      transfer: [AGENT, QUEUE],
+    });
+  });
+
+  it('returns no destinations when no agent-profile policy was configured', () => {
+    const context = createVoiceContext();
+
+    const controls = computeUIControls(TaskState.CONNECTED, context, context.taskData);
+
+    expect(controls.consultTransferDestinations).toEqual({consult: [], transfer: []});
+  });
+});
+
 describe('uiControlsComputer post-call consult controls (customer left)', () => {
   function createPostCallConsultTaskData() {
     return createTaskData({
@@ -2661,3 +2807,295 @@ describe('uiControlsComputer post-call consult controls (customer left)', () =>
     expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: false});
   });
 });
+
+// ---------------------------------------------------------------------------
+// WXCC-6026: wxApp thick-client answer UI controls
+// ---------------------------------------------------------------------------
+
+const WX_APP_DEVICE = {
+  deviceType: 'wxApp',
+  deviceId: 'device-id-1',
+  deviceCallId: 'call-id-1',
+};
+
+function createWxAppContext(
+  overrides: Partial<{
+    enableWxBetterTogether: boolean;
+    wxAppAnswerPending: boolean;
+    wxAppAcceptInFlight: boolean;
+  }> = {}
+): TaskContext {
+  return {
+    taskData: createTaskData({
+      agentId: 'agent-1',
+      mediaResourceId: 'interaction-1',
+      interaction: {
+        interactionId: 'interaction-1',
+        participants: {
+          'agent-1': {id: 'agent-1', pType: 'Agent', ...WX_APP_DEVICE},
+          'customer-1': {id: 'customer-1', pType: 'Customer'},
+        } as any,
+        media: {
+          'interaction-1': {mediaResourceId: 'interaction-1', isHold: false},
+        } as any,
+      } as any,
+    }),
+    consultInitiator: false,
+    exitingConference: false,
+    consultFromConference: false,
+    transferConferenceRequested: false,
+    consultDestinationType: null,
+    consultDestinationAgentId: null,
+    consultDestinationAgentJoined: false,
+    consultCallHeld: false,
+    hideBlindTransferForEpDnPendingMerge: false,
+    recordingControlsAvailable: false,
+    recordingInProgress: false,
+    uiControlConfig: {
+      isEndTaskEnabled: true,
+      isEndConsultEnabled: false,
+      channelType: TASK_CHANNEL_TYPE.VOICE,
+      isRecordingEnabled: false,
+      agentId: 'agent-1',
+      enableWxBetterTogether: overrides.enableWxBetterTogether ?? true,
+      wxAppAnswerPending: overrides.wxAppAnswerPending,
+      wxAppAcceptInFlight: overrides.wxAppAcceptInFlight,
+    },
+    uiControls: getDefaultUIControls(),
+  };
+}
+
+describe('uiControlsComputer wxApp thick-client answer (WXCC-6026)', () => {
+  describe('accept and decline when wxApp offer and enableWxBetterTogether=true', () => {
+    it('accept is visible and enabled in OFFERED state with wxApp participant', () => {
+      const ctx = createWxAppContext();
+      const controls = computeUIControls(TaskState.OFFERED, ctx, ctx.taskData);
+
+      expect(controls.main.accept).toEqual({isVisible: true, isEnabled: true});
+    });
+
+    it('decline is visible and enabled in OFFERED state with wxApp participant', () => {
+      const ctx = createWxAppContext();
+      const controls = computeUIControls(TaskState.OFFERED, ctx, ctx.taskData);
+
+      expect(controls.main.decline).toEqual({isVisible: true, isEnabled: true});
+    });
+
+    it('accept is visible but disabled while wxAppAcceptInFlight on inbound offer', () => {
+      const ctx = createWxAppContext({wxAppAcceptInFlight: true});
+      const controls = computeUIControls(TaskState.OFFERED, ctx, ctx.taskData);
+
+      expect(controls.main.accept).toEqual({isVisible: true, isEnabled: false});
+    });
+
+    it('accept is visible but disabled while wxAppAnswerPending on inbound offer', () => {
+      const ctx = createWxAppContext({wxAppAnswerPending: true});
+      const controls = computeUIControls(TaskState.OFFERED, ctx, ctx.taskData);
+
+      expect(controls.main.accept).toEqual({isVisible: true, isEnabled: false});
+    });
+
+    it('decline is visible but disabled while wxAppAnswerPending on inbound offer', () => {
+      const ctx = createWxAppContext({wxAppAnswerPending: true});
+      const controls = computeUIControls(TaskState.OFFERED, ctx, ctx.taskData);
+
+      expect(controls.main.decline).toEqual({isVisible: true, isEnabled: false});
+    });
+
+    it('decline is visible but disabled while wxAppAcceptInFlight on outdial offer', () => {
+      const ctx = createWxAppContext({wxAppAcceptInFlight: true, wxAppAnswerPending: true});
+      ctx.taskData.interaction.outboundType = 'OUTDIAL';
+      const controls = computeUIControls(TaskState.OFFERED, ctx, ctx.taskData);
+
+      expect(controls.main.decline).toEqual({isVisible: true, isEnabled: false});
+    });
+
+    it('decline is visible and enabled while wxAppAnswerPending on outdial offer (Calling phase)', () => {
+      const ctx = createWxAppContext({wxAppAnswerPending: true});
+      ctx.taskData.interaction.outboundType = 'OUTDIAL';
+      const controls = computeUIControls(TaskState.OFFERED, ctx, ctx.taskData);
+
+      expect(controls.main.decline).toEqual({isVisible: true, isEnabled: true});
+    });
+
+    it('keypad is disabled in OFFERED state (not yet engaged)', () => {
+      const ctx = createWxAppContext();
+      const controls = computeUIControls(TaskState.OFFERED, ctx, ctx.taskData);
+
+      expect(controls.main.keypad).toEqual({isVisible: false, isEnabled: false});
+    });
+  });
+
+  describe('mute and keypad when wxApp engaged (CONNECTED state)', () => {
+    it('mute is visible and enabled in CONNECTED state', () => {
+      const ctx = createWxAppContext();
+      const controls = computeUIControls(TaskState.CONNECTED, ctx, ctx.taskData);
+
+      expect(controls.main.mute).toEqual({isVisible: true, isEnabled: true});
+    });
+
+    it('keypad is visible and enabled in CONNECTED state', () => {
+      const ctx = createWxAppContext();
+      const controls = computeUIControls(TaskState.CONNECTED, ctx, ctx.taskData);
+
+      expect(controls.main.keypad).toEqual({isVisible: true, isEnabled: true});
+    });
+
+    it('keypad is disabled in WRAPPING_UP state', () => {
+      const ctx = createWxAppContext();
+      const controls = computeUIControls(TaskState.WRAPPING_UP, ctx, ctx.taskData);
+
+      expect(controls.main.keypad).toEqual({isVisible: false, isEnabled: false});
+    });
+
+    it('mute is disabled in WRAPPING_UP state', () => {
+      const ctx = createWxAppContext();
+      const controls = computeUIControls(TaskState.WRAPPING_UP, ctx, ctx.taskData);
+
+      expect(controls.main.mute).toEqual({isVisible: false, isEnabled: false});
+    });
+  });
+
+  describe('when enableWxBetterTogether=false', () => {
+    it('accept falls back to standard WebRTC logic (disabled for non-WebRTC)', () => {
+      const ctx = createWxAppContext({enableWxBetterTogether: false});
+      const controls = computeUIControls(TaskState.OFFERED, ctx, ctx.taskData);
+
+      // Without WebRTC variant, accept should be visible but disabled per existing logic
+      expect(controls.main.accept.isVisible).toBe(true);
+      // isEnabled is false without webRTC variant
+      expect(controls.main.accept.isEnabled).toBe(false);
+    });
+
+    it('keypad is always disabled when enableWxBetterTogether=false', () => {
+      const ctx = createWxAppContext({enableWxBetterTogether: false});
+      const controls = computeUIControls(TaskState.CONNECTED, ctx, ctx.taskData);
+
+      expect(controls.main.keypad).toEqual({isVisible: false, isEnabled: false});
+    });
+
+    it('mute is disabled for non-WebRTC when enableWxBetterTogether=false', () => {
+      const ctx = createWxAppContext({enableWxBetterTogether: false});
+      const controls = computeUIControls(TaskState.CONNECTED, ctx, ctx.taskData);
+
+      expect(controls.main.mute).toEqual({isVisible: false, isEnabled: false});
+    });
+  });
+
+  describe('default keypad state without wxApp', () => {
+    it('keypad is disabled for standard non-wxApp tasks', () => {
+      const ctx: TaskContext = {
+        taskData: createTaskData(),
+        consultInitiator: false,
+        exitingConference: false,
+        consultFromConference: false,
+        transferConferenceRequested: false,
+        consultDestinationType: null,
+        consultDestinationAgentId: null,
+        consultDestinationAgentJoined: false,
+        consultCallHeld: false,
+        hideBlindTransferForEpDnPendingMerge: false,
+        recordingControlsAvailable: false,
+        recordingInProgress: false,
+        uiControlConfig: {
+          isEndTaskEnabled: true,
+          isEndConsultEnabled: false,
+          channelType: TASK_CHANNEL_TYPE.VOICE,
+          isRecordingEnabled: false,
+        },
+        uiControls: getDefaultUIControls(),
+      };
+      const controls = computeUIControls(TaskState.CONNECTED, ctx, ctx.taskData);
+
+      expect(controls.main.keypad).toEqual({isVisible: false, isEnabled: false});
+    });
+  });
+
+  describe('wxApp engaged through consult and hold phases', () => {
+    it('enables main mute and keypad during consult-requested phase on main leg', () => {
+      const ctx = createWxAppContext();
+      ctx.taskData = createTaskData({
+        agentId: 'agent-1',
+        consultMediaResourceId: 'consult-media',
+        interaction: {
+          interactionId: 'interaction-1',
+          mainInteractionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              consultState: 'consultInitiated',
+              ...WX_APP_DEVICE,
+            },
+            'customer-1': {id: 'customer-1', pType: 'Customer'},
+          } as any,
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              isHold: false,
+              participants: ['agent-1', 'customer-1'],
+            },
+            'consult-media': {
+              mediaResourceId: 'consult-media',
+              mType: 'consult',
+              participants: ['agent-1'],
+            },
+          } as any,
+        } as any,
+      });
+      ctx.consultInitiator = true;
+      ctx.consultDestinationAgentJoined = false;
+
+      const controls = computeUIControls(TaskState.CONNECTED, ctx, ctx.taskData);
+
+      expect(controls.main.mute).toEqual({isVisible: true, isEnabled: true});
+      expect(controls.main.keypad).toEqual({isVisible: true, isEnabled: true});
+    });
+
+    it('enables main mute and keypad while consulting with main leg held', () => {
+      const taskData = createConsultTaskData();
+      taskData.interaction!.participants!['agent-1'] = {
+        id: 'agent-1',
+        pType: 'AGENT',
+        hasLeft: false,
+        consultState: 'consulting',
+        ...WX_APP_DEVICE,
+      };
+      const ctx = createVoiceContext({
+        taskData,
+        uiControlConfig: {
+          ...createVoiceContext().uiControlConfig,
+          enableWxBetterTogether: true,
+        },
+      });
+
+      const controls = computeUIControls(TaskState.CONSULTING, ctx, taskData);
+
+      expect(controls.main.mute).toEqual({isVisible: true, isEnabled: true});
+      expect(controls.main.keypad).toEqual({isVisible: true, isEnabled: true});
+      expect(controls.consult.mute).toEqual({isVisible: false, isEnabled: false});
+    });
+
+    it('keeps BROWSER consult mute enabled when enableWxBetterTogether is true and wxApp is not engaged', () => {
+      const consultedTaskData = createConsultedAgentInconsistentTaskData();
+      const consultedContext = createVoiceContext({
+        consultInitiator: false,
+        taskData: consultedTaskData,
+        uiControlConfig: {
+          ...createVoiceContext().uiControlConfig,
+          agentId: 'agent-2',
+          voiceVariant: VOICE_VARIANT.WEBRTC,
+          enableWxBetterTogether: true,
+        },
+      });
+
+      const controls = computeUIControls(
+        TaskState.CONNECTED,
+        consultedContext,
+        consultedTaskData
+      );
+
+      expect(controls.main.mute).toEqual({isVisible: true, isEnabled: true});
+    });
+  });
+});