@webex/contact-center 3.11.0-next.21 → 3.11.0-next.23

package/src/services/task/TaskManager.ts

@@ -15,6 +15,7 @@ import {METRIC_EVENT_NAMES} from '../../metrics/constants';
 import {
   checkParticipantNotInInteraction,
   getIsConferenceInProgress,
+  isCampaignPreviewReservation,
   isParticipantInMainInteraction,
   isPrimary,
   isSecondaryEpDnAgent,
@@ -81,7 +82,8 @@ export default class TaskManager extends EventEmitter {
 
   private handleIncomingWebCall = (call: ICall) => {
     const currentTask = Object.values(this.taskCollection).find(
-      (task) => task.data.interaction.mediaType === 'telephony'
+      (task) =>
+        task.data.interaction.mediaType === 'telephony' && !isCampaignPreviewReservation(task)
     );
 
     if (currentTask) {
@@ -249,8 +251,21 @@ export default class TaskManager extends EventEmitter {
             }
             break;
           case CC_EVENTS.AGENT_CONTACT_ASSIGNED:
-            task = this.updateTaskData(task, payload.data);
-            task.emit(TASK_EVENTS.TASK_ASSIGNED, task);
+            // When a campaign preview contact is accepted, the assigned event may arrive
+            // with a new interactionId while the task is stored under the original
+            // reservationInteractionId. Fall back to that key so the task is found.
+            if (!task && payload.data.reservationInteractionId) {
+              task = this.taskCollection[payload.data.reservationInteractionId];
+              if (task) {
+                // Re-key the task under the new interaction ID and remove the old entry
+                delete this.taskCollection[payload.data.reservationInteractionId];
+                this.taskCollection[payload.data.interactionId] = task;
+              }
+            }
+            if (task) {
+              task = this.updateTaskData(task, payload.data);
+              task.emit(TASK_EVENTS.TASK_ASSIGNED, task);
+            }
             break;
           case CC_EVENTS.AGENT_CONTACT_UNASSIGNED:
             task = this.updateTaskData(task, {
@@ -262,6 +277,14 @@ export default class TaskManager extends EventEmitter {
           case CC_EVENTS.AGENT_CONTACT_OFFER_RONA:
           case CC_EVENTS.AGENT_CONTACT_ASSIGN_FAILED:
           case CC_EVENTS.AGENT_INVITE_FAILED: {
+            LoggerProxy.warn(
+              `[DEBUG-CAMPAIGN-CLEAR] Task removal triggered by ${payload.data.type}, interactionId=${payload.data.interactionId}, taskType=${task?.data?.type}`,
+              {
+                module: TASK_MANAGER_FILE,
+                method: METHODS.REGISTER_TASK_LISTENERS,
+                interactionId: payload.data.interactionId,
+              }
+            );
             task = this.updateTaskData(task, payload.data);
 
             const eventTypeToMetricMap: Record<string, keyof typeof METRIC_EVENT_NAMES> = {
@@ -287,6 +310,14 @@ export default class TaskManager extends EventEmitter {
           case CC_EVENTS.CONTACT_ENDED:
             // Update task data
             if (task) {
+              LoggerProxy.warn(
+                `[DEBUG-CAMPAIGN-CLEAR] CONTACT_ENDED, interactionId=${payload.data.interactionId}, taskType=${task?.data?.type}, state=${task?.data?.interaction?.state}`,
+                {
+                  module: TASK_MANAGER_FILE,
+                  method: METHODS.REGISTER_TASK_LISTENERS,
+                  interactionId: payload.data.interactionId,
+                }
+              );
               task = this.updateTaskData(task, {
                 ...payload.data,
                 wrapUpRequired: payload.data.agentsPendingWrapUp?.includes(this.agentId) || false,
@@ -298,6 +329,14 @@ export default class TaskManager extends EventEmitter {
               task?.emit(TASK_EVENTS.TASK_END, task);
             }
             break;
+          case CC_EVENTS.CAMPAIGN_CONTACT_UPDATED:
+            // CampaignContactUpdated is a non-terminal event (intermediate update during accept).
+            // Only update the task data — do NOT remove the task or emit TASK_END.
+            // Task cleanup is handled by CONTACT_ENDED or other terminal events.
+            if (task) {
+              task = this.updateTaskData(task, payload.data);
+            }
+            break;
           case CC_EVENTS.CONTACT_MERGED:
             task = this.handleContactMerged(task, payload.data);
             break;
@@ -480,6 +519,39 @@ export default class TaskManager extends EventEmitter {
             task = this.updateTaskData(task, payload.data);
             task.emit(TASK_EVENTS.TASK_POST_CALL_ACTIVITY, task);
             break;
+          case CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION: {
+            // Campaign preview contact offered to agent
+            // Create a task in the collection so subsequent events (e.g. AGENT_CONTACT_ASSIGNED
+            // after acceptPreviewContact) can find and update it.
+            // Emit TASK_CAMPAIGN_PREVIEW_RESERVATION instead of TASK_INCOMING so the call
+            // does not ring out to the customer before the agent explicitly accepts the preview contact.
+            LoggerProxy.log('Campaign preview reservation received', {
+              module: TASK_MANAGER_FILE,
+              method: METHODS.REGISTER_TASK_LISTENERS,
+              interactionId: payload.data.interactionId,
+            });
+
+            if (!this.taskCollection[payload.data.interactionId]) {
+              task = new Task(
+                this.contact,
+                this.webCallingService,
+                {
+                  ...payload.data,
+                  wrapUpRequired: false,
+                  isConferenceInProgress: false,
+                  isAutoAnswering: false,
+                },
+                this.wrapupData,
+                this.agentId
+              );
+              this.taskCollection[payload.data.interactionId] = task;
+            } else {
+              task = this.updateTaskData(task, payload.data);
+            }
+
+            this.emit(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, task);
+            break;
+          }
           default:
             break;
         }

package/src/services/task/TaskUtils.ts

@@ -1,5 +1,6 @@
 /* eslint-disable import/prefer-default-export */
 import {Interaction, ITask, TaskData, MEDIA_CHANNEL} from './types';
+import {CC_EVENTS} from '../config/types';
 import {OUTDIAL_DIRECTION, OUTDIAL_MEDIA_TYPE, OUTBOUND_TYPE} from '../../constants';
 import {LoginOption} from '../../types';
 
@@ -219,3 +220,14 @@ export const shouldAutoAnswerTask = (
 
   return false;
 };
+
+/**
+ * Checks if a task is a campaign preview reservation that has not yet been accepted.
+ * Campaign preview tasks should not trigger incoming call handling until the agent
+ * explicitly accepts the preview contact.
+ * @param task - The task to check
+ * @returns true if the task is a pending campaign preview reservation, false otherwise
+ */
+export const isCampaignPreviewReservation = (task: ITask): boolean => {
+  return task?.data?.type === CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION;
+};

package/src/services/task/constants.ts

@@ -20,6 +20,10 @@ export const END = '/end';
 export const CONSULT_CONFERENCE = '/consult/conference';
 export const CONFERENCE_EXIT = '/conference/exit';
 export const CONFERENCE_TRANSFER = '/conference/transfer';
+export const DIALER_API = '/v1/dialer';
+export const CAMPAIGN_PREVIEW_ACCEPT = '/accept';
+/** 80-second timeout for accepting preview contact (outbound call setup takes longer than default 20s) */
+export const TIMEOUT_PREVIEW_ACCEPT = 80000;
 export const TASK_MANAGER_FILE = 'taskManager';
 export const TASK_FILE = 'task';
 

package/src/services/task/dialer.ts

@@ -1,7 +1,14 @@
 import {CC_EVENTS} from '../config/types';
 import {WCC_API_GATEWAY} from '../constants';
+import {HTTP_METHODS} from '../../types';
 import {createErrDetailsObject as err} from '../core/Utils';
-import {TASK_MESSAGE_TYPE, TASK_API} from './constants';
+import {
+  TASK_MESSAGE_TYPE,
+  TASK_API,
+  DIALER_API,
+  CAMPAIGN_PREVIEW_ACCEPT,
+  TIMEOUT_PREVIEW_ACCEPT,
+} from './constants';
 import * as Contact from './types';
 import AqmReqs from '../core/aqm-reqs';
 
@@ -48,5 +55,53 @@ export default function aqmDialer(aqm: AqmReqs) {
         errId: 'Service.aqm.dialer.startOutdial',
       },
     })),
+
+    /**
+     * Accepts a campaign preview contact, initiating the outbound call.
+     *
+     * @param {Object} p - Parameters object.
+     * @param {Contact.PreviewContactPayload} p.data - Payload containing interactionId and campaignId.
+     * @returns {Promise<Contact.AgentContact>} A promise that resolves with agent contact on success.
+     *
+     * Emits:
+     * - `CC_EVENTS.AGENT_CONTACT_ASSIGNED` on success
+     * - `CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED` on failure
+     * @ignore
+     */
+    acceptPreviewContact: aqm.req((p: {data: Contact.PreviewContactPayload}) => ({
+      url: `${DIALER_API}/campaign/${encodeURIComponent(p.data.campaignId)}/preview-task/${
+        p.data.interactionId
+      }${CAMPAIGN_PREVIEW_ACCEPT}`,
+      host: WCC_API_GATEWAY,
+      data: {},
+      method: HTTP_METHODS.POST,
+      timeout: TIMEOUT_PREVIEW_ACCEPT,
+      err,
+      notifSuccess: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {
+            type: [CC_EVENTS.AGENT_CONTACT_ASSIGNED, CC_EVENTS.CONTACT_ENDED],
+            __typeMap: {
+              typeField: 'type',
+              conditions: {
+                [CC_EVENTS.AGENT_CONTACT_ASSIGNED]: {
+                  reservationInteractionId: p.data.interactionId,
+                },
+                [CC_EVENTS.CONTACT_ENDED]: {interactionId: p.data.interactionId},
+              },
+            },
+          },
+        },
+        msg: {} as Contact.AgentContact,
+      },
+      notifFail: {
+        bind: {
+          type: TASK_MESSAGE_TYPE,
+          data: {type: CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED, campaignId: p.data.campaignId},
+        },
+        errId: 'Service.aqm.dialer.acceptPreviewContact',
+      },
+    })),
   };
 }

package/src/services/task/types.ts

@@ -542,6 +542,18 @@ export enum TASK_EVENTS {
    * ```
    */
   TASK_POST_CALL_ACTIVITY = 'task:postCallActivity',
+
+  /**
+   * Triggered when a campaign preview contact is offered to the agent
+   * @example
+   * ```typescript
+   * task.on(TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION, (data: AgentContact) => {
+   *   console.log('Campaign preview contact received:', data.interactionId);
+   *   // Handle campaign preview reservation
+   * });
+   * ```
+   */
+  TASK_CAMPAIGN_PREVIEW_RESERVATION = 'task:campaignPreviewReservation',
 }
 
 /**
@@ -1117,6 +1129,18 @@ export type DialerPayload = {
   origin: string;
 };
 
+/**
+ * Payload for campaign preview contact operations (accept, skip, remove)
+ * @public
+ */
+export type PreviewContactPayload = {
+  /** The interaction ID from the campaign reservation */
+  interactionId: string;
+  /** The campaign name (not a UUID). Available from the reservation event at
+   *  `task.data.interaction.callProcessingDetails.campaignId` or `task.data.campaignId`. */
+  campaignId: string;
+};
+
 /**
  * Data structure for cleaning up contact resources
  * @public

package/src/types.ts

@@ -541,7 +541,8 @@ export type RequestBody =
   | Contact.ConsultTransferPayLoad
   | Contact.cancelCtq
   | Contact.WrapupPayLoad
-  | Contact.DialerPayload;
+  | Contact.DialerPayload
+  | Contact.PreviewContactPayload;
 
 /**
  * Represents the options to fetch buddy agents for the logged in agent.

package/test/unit/spec/cc.ts

@@ -129,6 +129,7 @@ describe('webex.cc', () => {
 
       dialer: {
         startOutdial: jest.fn(),
+        acceptPreviewContact: jest.fn(),
       },
     };
 
@@ -2180,4 +2181,68 @@ describe('webex.cc', () => {
       );
     });
   });
+
+  describe('acceptPreviewContact', () => {
+    const previewPayload = {
+      interactionId: 'interaction-123',
+      campaignId: 'campaign-456',
+    };
+
+    it('should accept preview contact successfully', async () => {
+      const mockResponse = {trackingId: 'track-123'} as AgentContact;
+
+      const acceptPreviewContactMock = jest
+        .spyOn(webex.cc.services.dialer, 'acceptPreviewContact')
+        .mockResolvedValue(mockResponse);
+
+      const result = await webex.cc.acceptPreviewContact(previewPayload);
+
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Accepting campaign preview contact', {
+        module: CC_FILE,
+        method: 'acceptPreviewContact',
+      });
+      expect(LoggerProxy.log).toHaveBeenCalledWith(
+        'Campaign preview contact accepted successfully',
+        {
+          module: CC_FILE,
+          method: 'acceptPreviewContact',
+          trackingId: 'track-123',
+          interactionId: previewPayload.interactionId,
+        }
+      );
+
+      expect(acceptPreviewContactMock).toHaveBeenCalledWith({data: previewPayload});
+      expect(result).toEqual(mockResponse);
+    });
+
+    it('should handle error during acceptPreviewContact', async () => {
+      getErrorDetailsSpy.mockRestore();
+      getErrorDetailsSpy = jest.spyOn(Utils, 'getErrorDetails');
+
+      const error = {
+        details: {
+          trackingId: '1234',
+          data: {
+            reason: 'Error while performing acceptPreviewContact',
+          },
+        },
+      };
+
+      jest.spyOn(webex.cc.services.dialer, 'acceptPreviewContact').mockRejectedValue(error);
+
+      await expect(webex.cc.acceptPreviewContact(previewPayload)).rejects.toThrow(
+        error.details.data.reason
+      );
+
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Accepting campaign preview contact', {
+        module: CC_FILE,
+        method: 'acceptPreviewContact',
+      });
+      expect(LoggerProxy.error).toHaveBeenCalledWith(
+        `acceptPreviewContact failed with reason: ${error.details.data.reason}`,
+        {module: CC_FILE, method: 'acceptPreviewContact', trackingId: error.details.trackingId}
+      );
+      expect(getErrorDetailsSpy).toHaveBeenCalledWith(error, 'acceptPreviewContact', CC_FILE);
+    });
+  });
 });