@webex/contact-center 3.12.0-task-refactor.11 → 3.12.0-task-refactor.13

package/src/metrics/behavioral-events.ts

@@ -463,6 +463,48 @@ const eventTaxonomyMap: Record<string, BehavioralEventTaxonomy> = {
     target: 'outdial_ani_ep_fetch',
     verb: 'fail',
   },
+
+  // Campaign Preview API Events
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_accept',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_ACCEPT_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_accept',
+    verb: 'fail',
+  },
+
+  // Campaign Preview Skip API Events
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_skip',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_SKIP_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_skip',
+    verb: 'fail',
+  },
+
+  // Campaign Preview Remove API Events
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_SUCCESS]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_remove',
+    verb: 'complete',
+  },
+  [METRIC_EVENT_NAMES.CAMPAIGN_PREVIEW_REMOVE_FAILED]: {
+    product,
+    agent: 'user',
+    target: 'campaign_preview_remove',
+    verb: 'fail',
+  },
 };
 
 /**

package/src/metrics/constants.ts

@@ -163,7 +163,15 @@ export const METRIC_EVENT_NAMES = {
   OUTDIAL_ANI_EP_FETCH_SUCCESS: 'Outdial ANI Entries Fetch Success',
   OUTDIAL_ANI_EP_FETCH_FAILED: 'Outdial ANI Entries Fetch Failed',
 
-  // AI Assistant events
+  // Campaign Preview API Events
+  CAMPAIGN_PREVIEW_ACCEPT_SUCCESS: 'Campaign Preview Accept Success',
+  CAMPAIGN_PREVIEW_ACCEPT_FAILED: 'Campaign Preview Accept Failed',
+  CAMPAIGN_PREVIEW_SKIP_SUCCESS: 'Campaign Preview Skip Success',
+  CAMPAIGN_PREVIEW_SKIP_FAILED: 'Campaign Preview Skip Failed',
+  CAMPAIGN_PREVIEW_REMOVE_SUCCESS: 'Campaign Preview Remove Success',
+  CAMPAIGN_PREVIEW_REMOVE_FAILED: 'Campaign Preview Remove Failed',
+
+  // AI Assistant Transcript events
   AI_ASSISTANT_SEND_EVENT_SUCCESS: 'AI Assistant Send Event Success',
   AI_ASSISTANT_SEND_EVENT_FAILED: 'AI Assistant Send Event Failed',
   AI_ASSISTANT_GET_SUGGESTED_RESPONSE_SUCCESS: 'AI Assistant Get Suggested Response Success',

package/src/services/ApiAiAssistant.ts

@@ -302,6 +302,9 @@ export class ApiAIAssistant {
         ['operational']
       );
 
+      if (error instanceof Error) {
+        throw error;
+      }
       const {error: detailedError} = getErrorDetails(
         error,
         METHODS.FETCH_HISTORIC_TRANSCRIPTS,

package/src/services/config/Util.ts

@@ -189,7 +189,7 @@ function parseAgentConfigs(profileData: {
 
   const finalData = {
     teams: teamData,
-    defaultDn: userData.defaultDialledNumber,
+    defaultDn: userData.deafultDialledNumber,
     forceDefaultDn: tenantData.forceDefaultDn,
     forceDefaultDnForAgent: getDefaultAgentDN(agentProfileData.agentDNValidation),
     regexUS: tenantData.dnDefaultRegex,

package/src/services/config/types.ts

@@ -119,6 +119,16 @@ export const CC_TASK_EVENTS = {
   AGENT_CONTACT_UNASSIGNED: 'AgentContactUnassigned',
   /** Event emitted when inviting agent fails */
   AGENT_INVITE_FAILED: 'AgentInviteFailed',
+  /** Event emitted when a campaign preview contact is offered to the agent */
+  AGENT_OFFER_CAMPAIGN_RESERVATION: 'AgentOfferCampaignReservation',
+  /** Event emitted when campaign contact is updated */
+  CAMPAIGN_CONTACT_UPDATED: 'CampaignContactUpdated',
+  /** Event emitted when accepting a campaign preview contact fails */
+  CAMPAIGN_PREVIEW_ACCEPT_FAILED: 'CampaignPreviewAcceptFailed',
+  /** Event emitted when skipping a campaign preview contact fails */
+  CAMPAIGN_PREVIEW_SKIP_FAILED: 'CampaignPreviewSkipFailed',
+  /** Event emitted when removing a campaign preview contact fails */
+  CAMPAIGN_PREVIEW_REMOVE_FAILED: 'CampaignPreviewRemoveFailed',
   /** Event emitted when a real-time transcript chunk is received */
   REAL_TIME_TRANSCRIPTION: 'REAL_TIME_TRANSCRIPTION',
   /** Event emitted when an AI assistant suggested response is available */
@@ -294,8 +304,9 @@ export type AgentResponse = {
 
   /**
    * The default dialed number of the agent.
+   * Note: The API returns this field as "deafultDialledNumber" (with typo).
    */
-  defaultDialledNumber?: string;
+  deafultDialledNumber?: string;
 };
 
 /**

package/src/services/constants.ts

@@ -58,6 +58,7 @@ export const AGENT = 'agent';
  * @ignore
  */
 export const SUBSCRIBE_API = 'v1/notification/subscribe';
+
 /**
  * API path for realtime transcription subscription.
  * @type {string}

package/src/services/core/Err.ts

@@ -38,6 +38,9 @@ export type TaskErrorIds =
   | {'Service.aqm.task.pauseRecording': Failure}
   | {'Service.aqm.task.resumeRecording': Failure}
   | {'Service.aqm.dialer.startOutdial': Failure}
+  | {'Service.aqm.dialer.acceptPreviewContact': Failure}
+  | {'Service.aqm.dialer.skipPreviewContact': Failure}
+  | {'Service.aqm.dialer.removePreviewContact': Failure}
   | {'Service.reqs.generic.failure': {trackingId: string}};
 
 export type ReqError =

package/src/services/core/Utils.ts

@@ -14,6 +14,7 @@ import {
   InteractionParticipant,
 } from '../task/types';
 import {PARTICIPANT_TYPES, STATE_CONSULT} from './constants';
+import {DialPlan} from '../config/types';
 
 /**
  * Extracts common error details from a Webex request payload.
@@ -30,11 +31,72 @@ const getCommonErrorDetails = (errObj: WebexRequestPayload) => {
   };
 };
 
-export const isValidDialNumber = (input: string): boolean => {
-  // This regex checks for a valid dial number format for only few countries such as US, Canada.
-  const regexForDn = /1[0-9]{3}[2-9][0-9]{6}([,]{1,10}[0-9]+){0,1}/;
+/**
+ * Strips characters defined in the dial plan entry from the input string.
+ *
+ * @param input - The dial number to sanitize
+ * @param strippedChars - String of characters to remove from the input
+ * @returns The sanitized input with specified characters removed
+ */
+export const stripDialPlanChars = (input: string, strippedChars: string): string => {
+  if (!strippedChars) {
+    return input;
+  }
+
+  const charsToStrip = new Set(strippedChars.split(''));
 
-  return regexForDn.test(input);
+  return input
+    .split('')
+    .filter((c) => !charsToStrip.has(c))
+    .join('');
+};
+
+/**
+ * Validates a dial number against the provided dial plan regex patterns.
+ * A number is valid if it matches at least one regex pattern in the dial plans.
+ * Skips validation when no dial plan entries are configured, deferring to the server.
+ *
+ * @param input - The dial number to validate
+ * @param dialPlanEntries - Array of dial plan entries containing regex patterns
+ * @returns true if the input matches at least one dial plan regex pattern or no entries are configured, false otherwise
+ */
+export const isValidDialNumber = (
+  input: string,
+  dialPlanEntries: DialPlan['dialPlanEntity']
+): boolean => {
+  if (!input) {
+    LoggerProxy.warn('Dial number is empty or undefined.', {
+      module: 'Utils',
+      method: 'isValidDialNumber',
+    });
+
+    return false;
+  }
+
+  if (!dialPlanEntries || dialPlanEntries.length === 0) {
+    LoggerProxy.log(
+      'No dial plan entries found. Skipping client-side validation, deferring to server.',
+      {module: 'Utils', method: 'isValidDialNumber'}
+    );
+
+    return true;
+  }
+
+  return dialPlanEntries.some((entry) => {
+    try {
+      const sanitizedInput = stripDialPlanChars(input, entry.strippedChars);
+      const regex = new RegExp(entry.regex);
+
+      return regex.test(sanitizedInput);
+    } catch (e) {
+      LoggerProxy.warn(`Failed to validate dial number against entry "${entry.name}": ${e}`, {
+        module: 'Utils',
+        method: 'isValidDialNumber',
+      });
+
+      return false;
+    }
+  });
 };
 
 export const getStationLoginErrorData = (failure: Failure, loginOption: LoginOption) => {
@@ -56,7 +118,7 @@ export const getStationLoginErrorData = (failure: Failure, loginOption: LoginOpt
     },
     INVALID_DIAL_NUMBER: {
       message:
-        'Enter a valid US dial number. For help, reach out to your administrator or support team.',
+        'Enter a valid dial number. For help, reach out to your administrator or support team.',
       fieldName: loginOption,
     },
   };
@@ -199,6 +261,7 @@ export const createErrDetailsObject = (errObj: WebexRequestPayload) => {
 };
 
 /*
+/**
  * Gets the consulted agent ID from the media object by finding the agent
  * in the consult media participants (excluding the current agent).
  *

package/src/services/core/aqm-reqs.ts

@@ -20,18 +20,40 @@ export default class AqmReqs {
     this.webSocketManager.on('message', this.onMessage.bind(this));
   }
 
+  /**
+   * Creates a request function for an API call with parameters
+   * @param c - The configuration for the request
+   * @returns A function that makes the API request
+   */
   req<TRes, TErr, TReq>(c: Conf<TRes, TErr, TReq>): Res<TRes, TReq> {
     return (p: TReq, cbRes?: CbRes<TRes>) => this.makeAPIRequest(c(p), cbRes);
   }
 
+  /**
+   * Creates a request function for an API call with no parameters
+   * @param c - The configuration for the request
+   * @returns A function that makes the API request
+   */
   reqEmpty<TRes, TErr>(c: ConfEmpty<TRes, TErr>): ResEmpty<TRes> {
     return (cbRes?: CbRes<TRes>) => this.makeAPIRequest(c(), cbRes);
   }
 
+  /**
+   * Makes an API request
+   * @param c - The request configuration
+   * @param cbRes - The callback for the response
+   * @returns A promise that resolves with the response or rejects with an error
+   */
   private async makeAPIRequest<TRes, TErr>(c: Req<TRes, TErr>, cbRes?: CbRes<TRes>): Promise<TRes> {
     return this.createPromise(c, cbRes);
   }
 
+  /**
+   * Creates a promise for an API request
+   * @param c - The request configuration
+   * @param cbRes - The callback for the response
+   * @returns A promise that resolves with the response or rejects with an error
+   */
   private createPromise<TRes, TErr>(c: Req<TRes, TErr>, cbRes?: CbRes<TRes>) {
     return new Promise<TRes>((resolve, reject) => {
       const keySuccess = this.bindPrint(c.notifSuccess.bind);
@@ -154,10 +176,13 @@ export default class AqmReqs {
             if (response?.headers) {
               response.headers.Authorization = '*';
             }
-            LoggerProxy.error(`Routing request timeout${keySuccess}${response!}${c.url}`, {
-              module: AQM_REQS_FILE,
-              method: METHODS.CREATE_PROMISE,
-            });
+            LoggerProxy.error(
+              `Routing request timeout${keySuccess}${JSON.stringify(response)}${c.url}`,
+              {
+                module: AQM_REQS_FILE,
+                method: METHODS.CREATE_PROMISE,
+              }
+            );
             reject(
               new Err.Details('Service.aqm.reqs.Timeout', {
                 key: keySuccess,
@@ -171,39 +196,60 @@ export default class AqmReqs {
     });
   }
 
-  private bindPrint(bind: any) {
+  /**
+   * Converts a bind object to a string representation
+   * @param bind - The bind object to convert
+   * @returns A string representation of the bind object
+   */
+  private bindPrint(bind: any): string {
     let result = '';
-    // eslint-disable-next-line no-restricted-syntax
-    for (const k in bind) {
-      if (Array.isArray(bind[k])) {
-        result += `${k}=[${bind[k].join(',')}],`;
-      } else if (typeof bind[k] === 'object' && bind[k] !== null) {
-        result += `${k}=(${this.bindPrint(bind[k])}),`;
+    for (const key of Object.keys(bind).filter((prop) => prop !== '__typeMap')) {
+      const value = bind[key];
+
+      if (Array.isArray(value)) {
+        result += `${key}=[${value.join(',')}],`;
+      } else if (typeof value === 'object' && value !== null) {
+        result += `${key}=(${this.bindPrint(value)}),`;
       } else {
-        result += `${k}=${bind[k]},`;
+        result += `${key}=${value},`;
       }
     }
 
     return result ? result.slice(0, -1) : result;
   }
 
-  private bindCheck(bind: any, msg: any) {
-    // eslint-disable-next-line no-restricted-syntax
-    for (const k in bind) {
-      if (Array.isArray(bind[k])) {
+  /**
+   * Checks if a message matches a bind object
+   * @param bind - The bind object to check against
+   * @param msg - The message to check
+   * @returns True if the message matches the bind object, false otherwise
+   */
+  private bindCheck(bind: any, msg: any): boolean {
+    // Handle type-dependent field matching if __typeMap is present
+    if (bind.__typeMap && typeof bind.__typeMap === 'object') {
+      if (!AqmReqs.typeMapCheck(bind.__typeMap, msg)) {
+        return false;
+      }
+    }
+
+    for (const key of Object.keys(bind).filter((prop) => prop !== '__typeMap')) {
+      const bindValue = bind[key];
+      const msgValue = msg[key];
+
+      if (Array.isArray(bindValue)) {
         // Check if the message value matches any of the values in the array
-        if (!bind[k].includes(msg[k])) {
+        if (!bindValue.includes(msgValue)) {
           return false;
         }
-      } else if (typeof bind[k] === 'object' && bind[k] !== null) {
-        if (typeof msg[k] === 'object' && msg[k] !== null) {
-          if (!this.bindCheck(bind[k], msg[k])) {
+      } else if (typeof bindValue === 'object' && bindValue !== null) {
+        if (typeof msgValue === 'object' && msgValue !== null) {
+          if (!this.bindCheck(bindValue, msgValue)) {
             return false;
           }
         } else {
           return false;
         }
-      } else if (!msg[k] || msg[k] !== bind[k]) {
+      } else if (!msgValue || msgValue !== bindValue) {
         return false;
       }
     }
@@ -211,7 +257,39 @@ export default class AqmReqs {
     return true;
   }
 
-  // must be lambda
+  /**
+   * Checks type-dependent field conditions defined in __typeMap.
+   * @param typeMap - The type map to check against
+   * @param msg - The message to check
+   * @returns True if the message matches the type map, false otherwise
+   * The typeMap has the shape:
+   *   { typeField: "type", conditions: { EventA: { field: value }, EventB: { field: value } } }
+   * It reads msg[typeField] to determine which condition set to apply,
+   * then verifies all fields in that condition match the message.
+   */
+  private static typeMapCheck(typeMap: any, msg: any): boolean {
+    const typeField = typeMap.typeField || 'type';
+    const msgType = msg[typeField];
+
+    if (typeMap.conditions && typeMap.conditions[msgType]) {
+      const condition = typeMap.conditions[msgType];
+      for (const field of Object.keys(condition)) {
+        if (!msg[field] || msg[field] !== condition[field]) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Handles incoming messages from the WebSocket (must be a lambda fn)
+   * @param msg - The message to handle
+   * @returns
+   */
   private readonly onMessage = (msg: any) => {
     const event = JSON.parse(msg);
     if (event.type === 'Welcome') {

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

@@ -48,8 +48,16 @@ export class WebSocketManager extends EventEmitter {
     body: SubscribeRequest;
     resource: string;
   }): Promise<WelcomeResponse> {
-    const {body, resource} = options;
-    await this.register(body, resource);
+    const {body: connectionConfig, resource} = options;
+    try {
+      await this.register(connectionConfig, resource);
+    } catch (error) {
+      LoggerProxy.error(`[WebSocketStatus] | Error in registering Websocket ${error}`, {
+        module: WEB_SOCKET_MANAGER_FILE,
+        method: METHODS.INIT_WEB_SOCKET,
+      });
+      throw error;
+    }
 
     return new Promise((resolve, reject) => {
       this.welcomePromiseResolve = resolve;
@@ -81,11 +89,23 @@ export class WebSocketManager extends EventEmitter {
 
   private async register(connectionConfig: SubscribeRequest, resource: string) {
     try {
+      // X-ORGANIZATION-ID header is only required for INT environments
+      const isIntEnv = this.webex.internal?.services?.isIntegrationEnvironment() || false;
+      const orgId = this.webex.credentials.getOrgId();
+
+      if (isIntEnv && orgId) {
+        LoggerProxy.log(`[WebSocketManager] Adding X-ORGANIZATION-ID header for INT environment`, {
+          module: WEB_SOCKET_MANAGER_FILE,
+          method: METHODS.REGISTER,
+        });
+      }
+
       const subscribeResponse: SubscribeResponse = await this.webex.request({
         service: WCC_API_GATEWAY,
         resource,
         method: HTTP_METHODS.POST,
         body: connectionConfig,
+        headers: isIntEnv && orgId ? {'X-ORGANIZATION-ID': orgId} : undefined,
       });
       this.url = subscribeResponse.body.webSocketUrl;
     } catch (e) {
@@ -93,6 +113,7 @@ export class WebSocketManager extends EventEmitter {
         `Register API Failed, Request to RoutingNotifs websocket registration API failed ${e}`,
         {module: WEB_SOCKET_MANAGER_FILE, method: METHODS.REGISTER}
       );
+      throw e;
     }
   }
 

package/src/services/index.ts

@@ -41,6 +41,7 @@ export default class Services {
   constructor(options: {webex: WebexSDK; connectionConfig: SubscribeRequest}) {
     const {webex, connectionConfig} = options;
     this.webSocketManager = new WebSocketManager({webex});
+    // TODO: Implement reconnection logic for this websocket in upcoming PR
     this.rtdWebSocketManager = new WebSocketManager({webex});
     const aqmReq = new AqmReqs(this.webSocketManager);
     this.config = new AgentConfigService();

package/src/services/task/Task.ts

@@ -414,6 +414,19 @@ export default abstract class Task extends EventEmitter implements ITask {
       emitTaskIncoming: this.createEmitSelfAction(TASK_EVENTS.TASK_INCOMING, {
         updateTaskData: true,
       }),
+      emitTaskCampaignPreviewReservation: this.createEmitSelfAction(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_RESERVATION,
+        {updateTaskData: true}
+      ),
+      emitTaskCampaignPreviewAcceptFailed: this.createEmitSelfAction(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_ACCEPT_FAILED
+      ),
+      emitTaskCampaignPreviewSkipFailed: this.createEmitSelfAction(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_SKIP_FAILED
+      ),
+      emitTaskCampaignPreviewRemoveFailed: this.createEmitSelfAction(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_REMOVE_FAILED
+      ),
       emitTaskHydrate: this.createEmitSelfAction(TASK_EVENTS.TASK_HYDRATE, {
         updateTaskData: true,
       }),