@webex/contact-center 3.12.0-llmrefactor.1 → 3.12.0-llmrefactor.11

package/src/services/AnswerCallOnWebexService.ts

@@ -0,0 +1,239 @@
+import LoggerProxy from '../logger-proxy';
+import {CC_FILE, METHODS} from '../constants';
+import {HTTP_METHODS, IHttpResponse, WebexSDK} from '../types';
+import {getErrorDetails} from './core/Utils';
+import {isWxAppCallNotFoundError} from './wxAppTelephonyUtils';
+
+const ANSWER_CALL_ON_WEBEX_FILE = 'AnswerCallOnWebexService';
+
+export type WxAppTelephonyError = Error & {
+  isWxAppTelephonyError: true;
+  trackingId?: string;
+  status?: number | string;
+};
+
+const extractWxAppTrackingId = (source: unknown): string | undefined => {
+  const sourceObj = source as {details?: {trackingId?: string}; trackingId?: string};
+
+  return sourceObj?.details?.trackingId || sourceObj?.trackingId;
+};
+
+const extractWxAppHttpStatus = (source: unknown): number | string | undefined => {
+  const obj = source as {
+    statusCode?: number;
+    status?: number | string;
+    details?: {status?: number | string};
+  };
+
+  return obj?.statusCode ?? obj?.status ?? obj?.details?.status;
+};
+
+const markWxAppTelephonyError = (error: Error, source: unknown): WxAppTelephonyError => {
+  const marked = error as WxAppTelephonyError;
+  marked.isWxAppTelephonyError = true;
+  const trackingId = extractWxAppTrackingId(source);
+  if (trackingId) {
+    marked.trackingId = trackingId;
+  }
+  const status = extractWxAppHttpStatus(source);
+  if (status !== undefined) {
+    marked.status = status;
+  }
+
+  return marked;
+};
+
+export type AnswerCallParams = {
+  callId: string;
+  endpointId: string;
+  lineOwnerId?: string;
+};
+
+export type CallIdParams = {
+  callId: string;
+  lineOwnerId?: string;
+};
+
+export type TransmitDtmfParams = CallIdParams & {
+  dtmf: string;
+};
+
+export type CallDetailsResponse = {
+  muted?: boolean;
+};
+
+/**
+ * REST telephony client for wxApp thick-client answer (WXCC-6026).
+ * Separate from WebCallingService (WebRTC/Mobius).
+ */
+export default class AnswerCallOnWebexService {
+  private webex: WebexSDK;
+
+  constructor(webex: WebexSDK) {
+    this.webex = webex;
+  }
+
+  private getTelephonyBaseUrl(): string {
+    const services = this.webex.internal.services;
+    const hydraUrl = services._serviceUrls?.hydra || services.get('hydra');
+
+    if (!hydraUrl) {
+      throw new Error('Telephony base URL is unavailable');
+    }
+
+    return `${hydraUrl.replace(/\/$/, '')}/telephony/calls`;
+  }
+
+  private extractTrackingId(source: unknown): string | undefined {
+    return extractWxAppTrackingId(source);
+  }
+
+  private async telephonyRequest(
+    resource: string,
+    method: HTTP_METHODS,
+    body: Record<string, unknown>,
+    logMethod: string
+  ): Promise<IHttpResponse> {
+    try {
+      const uri = `${this.getTelephonyBaseUrl()}${resource}`;
+
+      LoggerProxy.info(`AnswerCallOnWebexService.${logMethod} request`, {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: logMethod,
+        data: {uri, bodyKeys: Object.keys(body)},
+      });
+
+      const response = (await this.webex.request({
+        uri,
+        method,
+        body,
+        addAuthHeader: true,
+      })) as IHttpResponse;
+
+      LoggerProxy.info(`AnswerCallOnWebexService.${logMethod} success`, {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: logMethod,
+        data: {statusCode: response.statusCode},
+      });
+
+      return response;
+    } catch (error) {
+      const trackingId = this.extractTrackingId(error);
+      LoggerProxy.error(`AnswerCallOnWebexService.${logMethod} failed: ${error}`, {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: logMethod,
+        data: {
+          trackingId,
+          status: extractWxAppHttpStatus(error),
+        },
+      });
+      const {error: detailedError} = getErrorDetails(error, logMethod, CC_FILE);
+      throw markWxAppTelephonyError(detailedError, error);
+    }
+  }
+
+  public answerCall(params: AnswerCallParams): Promise<IHttpResponse> {
+    const {callId, endpointId, lineOwnerId} = params;
+
+    return this.telephonyRequest(
+      '/answer',
+      HTTP_METHODS.POST,
+      {
+        callId,
+        endpointId,
+        ...(lineOwnerId ? {lineOwnerId} : {}),
+      },
+      METHODS.ACCEPT
+    );
+  }
+
+  public rejectCall(params: CallIdParams): Promise<IHttpResponse> {
+    const {callId, lineOwnerId} = params;
+
+    return this.telephonyRequest(
+      '/reject',
+      HTTP_METHODS.POST,
+      {callId, ...(lineOwnerId ? {lineOwnerId} : {})},
+      METHODS.REJECT
+    );
+  }
+
+  public muteCall(params: CallIdParams): Promise<IHttpResponse> {
+    const {callId, lineOwnerId} = params;
+
+    return this.telephonyRequest(
+      '/mute',
+      HTTP_METHODS.POST,
+      {callId, ...(lineOwnerId ? {lineOwnerId} : {})},
+      METHODS.TOGGLE_MUTE
+    );
+  }
+
+  public unmuteCall(params: CallIdParams): Promise<IHttpResponse> {
+    const {callId, lineOwnerId} = params;
+
+    return this.telephonyRequest(
+      '/unmute',
+      HTTP_METHODS.POST,
+      {callId, ...(lineOwnerId ? {lineOwnerId} : {})},
+      METHODS.TOGGLE_MUTE
+    );
+  }
+
+  public transmitDtmf(params: TransmitDtmfParams): Promise<IHttpResponse> {
+    const {callId, dtmf, lineOwnerId} = params;
+
+    return this.telephonyRequest(
+      '/transmitDtmf',
+      HTTP_METHODS.POST,
+      {callId, dtmf, ...(lineOwnerId ? {lineOwnerId} : {})},
+      METHODS.TRANSMIT_DTMF
+    );
+  }
+
+  public async getCallDetails(params: CallIdParams): Promise<CallDetailsResponse> {
+    const {callId, lineOwnerId} = params;
+    const lineOwnerIdQuery = lineOwnerId ? `?lineOwnerId=${encodeURIComponent(lineOwnerId)}` : '';
+    const uri = `${this.getTelephonyBaseUrl()}/${callId}${lineOwnerIdQuery}`;
+
+    try {
+      LoggerProxy.info('AnswerCallOnWebexService.getCallDetails request', {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: METHODS.GET_CALL_DETAILS_ON_WEBEX,
+        data: {callId},
+      });
+
+      const response = (await this.webex.request({
+        uri,
+        method: HTTP_METHODS.GET,
+        addAuthHeader: true,
+      })) as IHttpResponse;
+
+      return (response.body ?? {}) as CallDetailsResponse;
+    } catch (error) {
+      if (isWxAppCallNotFoundError(error)) {
+        const err =
+          error instanceof Error
+            ? error
+            : new Error(String((error as {message?: string})?.message ?? error));
+        throw markWxAppTelephonyError(err, error);
+      }
+
+      const trackingId = this.extractTrackingId(error);
+      LoggerProxy.error(`AnswerCallOnWebexService.getCallDetails failed: ${error}`, {
+        module: ANSWER_CALL_ON_WEBEX_FILE,
+        method: METHODS.GET_CALL_DETAILS_ON_WEBEX,
+        data: {
+          trackingId,
+          status: extractWxAppHttpStatus(error),
+        },
+      });
+      const {error: detailedError} = getErrorDetails(
+        error,
+        METHODS.GET_CALL_DETAILS_ON_WEBEX,
+        CC_FILE
+      );
+      throw markWxAppTelephonyError(detailedError, error);
+    }
+  }
+}

package/src/services/EntryPoint.ts

@@ -2,12 +2,40 @@ import {HTTP_METHODS, WebexSDK} from '../types';
 import type {EntryPointRecord, EntryPointListResponse, EntryPointSearchParams} from '../types';
 import LoggerProxy from '../logger-proxy';
 import WebexRequest from './core/WebexRequest';
-import PageCache, {PAGINATION_DEFAULTS} from '../utils/PageCache';
+import {PAGINATION_DEFAULTS} from '../utils/PageCache';
 import MetricsManager from '../metrics/MetricsManager';
 import {WCC_API_GATEWAY} from './constants';
 import {endPointMap} from './config/constants';
 import {METRIC_EVENT_NAMES} from '../metrics/constants';
 
+const DEFAULT_ENTRY_POINT_ATTRIBUTES = 'id,dialledNumber,entryPointId,entryPointName';
+const DEFAULT_ENTRY_POINT_SORT_FIELD = 'entryPointName';
+
+type DialNumberEntryPointRecord = {
+  id: string;
+  dialledNumber?: string;
+  entryPointId: string;
+  entryPointName: string;
+};
+
+const mergeEntryPointAttributes = (attributes?: string): string => {
+  const mergedAttributes = new Set(DEFAULT_ENTRY_POINT_ATTRIBUTES.split(','));
+
+  attributes
+    ?.split(',')
+    .map((attribute) => attribute.trim())
+    .filter(Boolean)
+    .forEach((attribute) => mergedAttributes.add(attribute));
+
+  return Array.from(mergedAttributes).join(',');
+};
+
+const mapDialNumberEntryPoint = (item: DialNumberEntryPointRecord): EntryPointRecord => ({
+  id: item.entryPointId,
+  name: item.entryPointName,
+  ...(item.dialledNumber ? {number: item.dialledNumber} : {}),
+});
+
 /**
  * EntryPoint class for managing Webex Contact Center entry points.
  * Provides functionality to fetch, search, and paginate through entry points.
@@ -35,7 +63,7 @@ import {METRIC_EVENT_NAMES} from '../metrics/constants';
  * });
  *
  * // Search for specific entry points
- * const searchResults = await entryPointAPI.searchEntryPoints({
+ * const searchResults = await entryPointAPI.getEntryPoints({
  *   search: 'support',
  *   filter: 'type=="voice"'
  * });
@@ -46,9 +74,6 @@ export class EntryPoint {
   private webex: WebexSDK;
   private metricsManager: MetricsManager;
 
-  // Page cache using the common utility
-  private pageCache: PageCache<EntryPointRecord>;
-
   /**
    * Creates an instance of EntryPoint
    * @param {WebexSDK} webex - The Webex SDK instance
@@ -57,19 +82,21 @@ export class EntryPoint {
   constructor(webex: WebexSDK) {
     this.webex = webex;
     this.webexRequest = WebexRequest.getInstance({webex});
-    this.pageCache = new PageCache<EntryPointRecord>('EntryPoint');
     this.metricsManager = MetricsManager.getInstance({webex});
   }
 
   /**
-   * Fetches entry points for the organization with pagination support
-   * @param {EntryPointSearchParams} [params] - Search and pagination parameters
+   * Fetches entry-point dial-number mappings for the organization with pagination support. By
+   * default, returns the agent's desktop-profile-filtered mappings in backend entry-point-name order.
+   * Search, filter, attribute, and sort parameters can customize the request while desktop-profile
+   * scoping and required mapping fields remain SDK-owned.
+   * @param {EntryPointSearchParams} [params] - Search, pagination, and compatible override parameters.
    * @returns {Promise<EntryPointListResponse>} Promise resolving to paginated entry points
    * @throws {Error} If the API call fails
    * @public
    * @example
    * ```typescript
-   * // Get first page of entry points
+   * // Get the first page using the default entry-point policy
    * const response = await entryPointAPI.getEntryPoints();
    *
    * // Get specific page with custom page size
@@ -89,12 +116,14 @@ export class EntryPoint {
       search,
       filter,
       attributes,
-      sortBy,
+      sortBy = 'name',
       sortOrder = 'asc',
     } = params;
 
     const orgId = this.webex.credentials.getOrgId();
-    const isSearchRequest = !!(search || filter || attributes || sortBy);
+    const hasCustomSort = sortBy !== 'name' || sortOrder !== 'asc';
+    const isSearchRequest = !!(search || filter || attributes || hasCustomSort);
+    const effectiveSortBy = sortBy === 'name' ? DEFAULT_ENTRY_POINT_SORT_FIELD : sortBy;
 
     LoggerProxy.info(
       `Fetching entry points - orgId: ${orgId}, page: ${page}, pageSize: ${pageSize}, isSearchRequest: ${isSearchRequest}`,
@@ -104,51 +133,24 @@ export class EntryPoint {
       }
     );
 
-    // Check if we can use cache for simple pagination (no search/filter/attributes/sort)
-    if (this.pageCache.canUseCache({search, filter, attributes, sortBy})) {
-      const cacheKey = this.pageCache.buildCacheKey(orgId, page, pageSize);
-      const cachedPage = this.pageCache.getCachedPage(cacheKey);
-
-      if (cachedPage) {
-        const duration = Date.now() - startTime;
-
-        LoggerProxy.log(
-          `Returning page ${page} from cache - cacheHit: true, duration: ${duration}ms, recordCount: ${cachedPage.data.length}, pageSize: ${pageSize}`,
-          {
-            module: 'EntryPoint',
-            method: 'getEntryPoints',
-          }
-        );
-
-        return {
-          data: cachedPage.data,
-          meta: {
-            page,
-            pageSize,
-            totalPages: cachedPage.totalMeta?.totalPages,
-            totalRecords: cachedPage.totalMeta?.totalRecords,
-          },
-        };
-      }
-    }
-
-    // Start timing only for actual API calls (not cache hits)
     this.metricsManager.timeEvent(METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_SUCCESS);
 
     try {
-      // Build query parameters
       const queryParams = new URLSearchParams({
         page: page.toString(),
         pageSize: pageSize.toString(),
-        sortOrder,
+        attributes: mergeEntryPointAttributes(attributes),
       });
 
       if (search) queryParams.append('search', search);
       if (filter) queryParams.append('filter', filter);
-      if (attributes) queryParams.append('attributes', attributes);
-      if (sortBy) queryParams.append('sortBy', sortBy);
+      if (effectiveSortBy) {
+        queryParams.append('sort', `${effectiveSortBy},${sortOrder.toUpperCase()}`);
+      }
+      queryParams.append('desktopProfileFilter', 'true');
+      queryParams.append('includeEntryPointName', 'true');
 
-      const resource = endPointMap.entryPointList(orgId, queryParams.toString());
+      const resource = endPointMap.entryPointDialNumberList(orgId, queryParams.toString());
 
       LoggerProxy.log(
         `Making API request to fetch entry points - resource: ${resource}, service: ${WCC_API_GATEWAY}`,
@@ -162,12 +164,21 @@ export class EntryPoint {
         service: WCC_API_GATEWAY,
         resource,
         method: HTTP_METHODS.GET,
+        headers: {
+          'X-ORGANIZATION-ID': orgId,
+          'x-ignore-internal-data': 'false',
+        },
       });
 
+      const responseBody: EntryPointListResponse = {
+        ...response.body,
+        data: (response.body?.data ?? []).map(mapDialNumberEntryPoint),
+      };
+
       const duration = Date.now() - startTime;
 
-      const recordCount = response.body?.data?.length || 0;
-      const totalRecords = response.body?.meta?.totalRecords;
+      const recordCount = responseBody.data.length;
+      const totalRecords = responseBody.meta?.totalRecords;
 
       LoggerProxy.log(`Successfully retrieved ${recordCount} entry points`, {
         module: 'EntryPoint',
@@ -199,19 +210,7 @@ export class EntryPoint {
         );
       }
 
-      // Cache the page data for simple pagination (no search/filter/attributes/sort)
-      if (this.pageCache.canUseCache({search, filter, attributes, sortBy}) && response.body?.data) {
-        const cacheKey = this.pageCache.buildCacheKey(orgId, page, pageSize);
-        this.pageCache.cachePage(cacheKey, response.body.data, response.body.meta);
-
-        LoggerProxy.log('Cached entry points data for future requests', {
-          module: 'EntryPoint',
-          method: 'getEntryPoints',
-          data: {cacheKey, recordCount},
-        });
-      }
-
-      return response.body;
+      return responseBody;
     } catch (error) {
       const errorData = {
         orgId,

package/src/services/Queue.ts

@@ -70,14 +70,16 @@ export class Queue {
   }
 
   /**
-   * Fetches contact service queues for the organization
-   * @param {ContactServiceQueueSearchParams} [params] - Search and pagination parameters
+   * Fetches contact service queues for the organization. By default, returns active inbound
+   * telephony queues in backend name-ascending order using the agent's desktop profile views.
+   * Existing filter, sort, and desktop-profile parameters override those defaults.
+   * @param {ContactServiceQueueSearchParams} [params] - Search, pagination, and override parameters
    * @returns {Promise<ContactServiceQueuesResponse>} Promise resolving to contact service queues
    * @throws {Error} If the API call fails
    * @public
    * @example
    * ```typescript
-   * // Get all queues with default pagination
+   * // Get queues using the default list policy and pagination
    * const response = await queueAPI.getQueues();
    *
    * // Get queues with specific pagination
@@ -101,17 +103,29 @@ export class Queue {
       page = PAGINATION_DEFAULTS.PAGE,
       pageSize = PAGINATION_DEFAULTS.PAGE_SIZE,
       search,
-      filter,
+      filter = 'queueType==INBOUND;channelType==TELEPHONY;active==true',
       attributes,
-      sortBy,
-      sortOrder,
-      desktopProfileFilter,
+      sortBy = 'name',
+      sortOrder = 'asc',
+      desktopProfileFilter = true,
       provisioningView,
       singleObjectResponse,
     } = params;
+    const agentView = desktopProfileFilter;
+    const firstLevelView = desktopProfileFilter;
 
     const orgId = this.webex.credentials.getOrgId();
-    const isSearchRequest = !!(search || filter || attributes || sortBy);
+    const effectiveSortBy = sortBy ?? (sortOrder ? 'name' : undefined);
+    const isSearchRequest = !!(search || filter || attributes || effectiveSortBy);
+    const canUseCache = this.pageCache.canUseCache({
+      search,
+      filter,
+      attributes,
+      sortBy: effectiveSortBy,
+      desktopProfileFilter,
+      provisioningView,
+      singleObjectResponse,
+    });
 
     LoggerProxy.info('Fetching contact service queues', {
       module: 'Queue',
@@ -125,7 +139,7 @@ export class Queue {
     });
 
     // Check if we can use cache for simple pagination (no search/filter/attributes/sort)
-    if (this.pageCache.canUseCache({search, filter, attributes, sortBy})) {
+    if (canUseCache) {
       const cacheKey = this.pageCache.buildCacheKey(orgId, page, pageSize);
       const cachedPage = this.pageCache.getCachedPage(cacheKey);
 
@@ -170,14 +184,17 @@ export class Queue {
       if (filter) queryParams.append('filter', filter);
       if (attributes) queryParams.append('attributes', attributes);
       if (search) queryParams.append('search', search);
-      if (sortBy) queryParams.append('sortBy', sortBy);
-      if (sortOrder) queryParams.append('sortOrder', sortOrder);
+      if (effectiveSortBy)
+        queryParams.append('sort', `${effectiveSortBy},${(sortOrder ?? 'asc').toUpperCase()}`);
       if (desktopProfileFilter !== undefined)
         queryParams.append('desktopProfileFilter', desktopProfileFilter.toString());
       if (provisioningView !== undefined)
         queryParams.append('provisioningView', provisioningView.toString());
       if (singleObjectResponse !== undefined)
         queryParams.append('singleObjectResponse', singleObjectResponse.toString());
+      if (agentView !== undefined) queryParams.append('agentView', agentView.toString());
+      if (firstLevelView !== undefined)
+        queryParams.append('firstLevelView', firstLevelView.toString());
 
       const resource = endPointMap.queueList(orgId, queryParams.toString());
 
@@ -232,7 +249,7 @@ export class Queue {
       }
 
       // Cache the page data for simple pagination (no search/filter/attributes/sort)
-      if (this.pageCache.canUseCache({search, filter, attributes, sortBy}) && response.body?.data) {
+      if (canUseCache && response.body?.data) {
         const cacheKey = this.pageCache.buildCacheKey(orgId, page, pageSize);
         this.pageCache.cachePage(cacheKey, response.body.data, response.body.meta);