@webex/contact-center 3.12.0-task-refactor.12 → 3.12.0-webex-services-ready.1

package/src/services/UserPreference.ts

@@ -0,0 +1,509 @@
+import {HTTP_METHODS, WebexSDK} from '../types';
+import type {
+  UserPreference as UserPreferenceResponse,
+  CreateUserPreferenceRequest,
+  UpdateUserPreferenceRequest,
+  GetUserPreferenceParams,
+} from './config/types';
+import LoggerProxy from '../logger-proxy';
+import WebexRequest from './core/WebexRequest';
+import MetricsManager from '../metrics/MetricsManager';
+import {WCC_API_GATEWAY} from './constants';
+import {endPointMap} from './config/constants';
+import {METRIC_EVENT_NAMES} from '../metrics/constants';
+
+/**
+ * UserPreference API class for managing Webex Contact Center user preferences.
+ * Provides functionality to get, create, update, and delete user preferences.
+ *
+ * @class UserPreference
+ * @public
+ * @example
+ * ```typescript
+ * import Webex from 'webex';
+ *
+ * const webex = new Webex({ credentials: 'YOUR_ACCESS_TOKEN' });
+ * const cc = webex.cc;
+ *
+ * // Register and login first
+ * await cc.register();
+ * await cc.stationLogin({ teamId: 'team123', loginOption: 'BROWSER' });
+ *
+ * // Get UserPreference API instance from ContactCenter
+ * const userPreferenceAPI = cc.userPreference;
+ *
+ * // Get user preferences for the current user
+ * const preferences = await userPreferenceAPI.getUserPreference();
+ *
+ * // Create new user preferences
+ * const newPreferences = await userPreferenceAPI.createUserPreference({
+ *   userId: 'user123',
+ *   preferences: { e911Reminder: true }
+ * });
+ *
+ * // Update user preferences
+ * const updatedPreferences = await userPreferenceAPI.updateUserPreference('user123', {
+ *   preferences: { e911Reminder: false }
+ * });
+ *
+ * // Delete user preferences
+ * await userPreferenceAPI.deleteUserPreference('user123');
+ * ```
+ */
+export class UserPreference {
+  private webexRequest: WebexRequest;
+  private webex: WebexSDK;
+  private getUserId: () => string;
+  private metricsManager: MetricsManager;
+
+  /**
+   * Creates an instance of UserPreference
+   * @param {WebexSDK} webex - The Webex SDK instance
+   * @param {() => string} getUserId - Function to get the current user's CI user ID
+   * @public
+   */
+  constructor(webex: WebexSDK, getUserId: () => string) {
+    this.webex = webex;
+    this.webexRequest = WebexRequest.getInstance({webex});
+    this.getUserId = getUserId;
+    this.metricsManager = MetricsManager.getInstance({webex});
+  }
+
+  /**
+   * Fetches user preferences for a specific user
+   * @param {GetUserPreferenceParams} [params] - Optional parameters for fetching preferences
+   * @param {string} [params.userId] - User ID to fetch preferences for. Defaults to current user's CI user ID.
+   * @param {number} [params.page=0] - Page number (0-indexed). Default: 0
+   * @param {number} [params.pageSize=100] - Number of items per page. Default: 100
+   * @returns {Promise<UserPreferenceResponse>} Promise resolving to user preferences
+   * @throws {Error} If the API call fails
+   * @public
+   * @example
+   * ```typescript
+   * // Get preferences for current user
+   * const preferences = await userPreferenceAPI.getUserPreference();
+   *
+   * // Get preferences for a specific user
+   * const preferences = await userPreferenceAPI.getUserPreference({ userId: 'user123' });
+   *
+   * // Get preferences with pagination
+   * const preferences = await userPreferenceAPI.getUserPreference({ page: 0, pageSize: 50 });
+   * ```
+   */
+  public async getUserPreference(
+    params?: GetUserPreferenceParams
+  ): Promise<UserPreferenceResponse> {
+    const {userId, page, pageSize} = params || {};
+    const targetUserId = userId || this.getUserId();
+    const orgId = this.webex.credentials.getOrgId();
+
+    LoggerProxy.info('Fetching user preferences', {
+      module: 'UserPreference',
+      method: 'getUserPreference',
+      data: {
+        orgId,
+        userId: targetUserId,
+        page,
+        pageSize,
+      },
+    });
+
+    if (!targetUserId) {
+      LoggerProxy.error('getUserPreference called without a valid userId', {
+        module: 'UserPreference',
+        method: 'getUserPreference',
+        data: {
+          orgId,
+          userId: targetUserId,
+          error: 'Missing userId. Ensure user is logged in or provide a userId.',
+        },
+      });
+
+      throw new Error('UserPreference: userId is not available.');
+    }
+
+    try {
+      let resource = endPointMap.userPreference(orgId, targetUserId);
+
+      // Build query parameters if provided
+      const queryParams: string[] = [];
+      if (page !== undefined) queryParams.push(`page=${page}`);
+      if (pageSize !== undefined) queryParams.push(`pageSize=${pageSize}`);
+      if (queryParams.length > 0) {
+        resource = `${resource}?${queryParams.join('&')}`;
+      }
+
+      LoggerProxy.info('Making API request to fetch user preferences', {
+        module: 'UserPreference',
+        method: 'getUserPreference',
+        data: {
+          resource,
+          service: WCC_API_GATEWAY,
+        },
+      });
+
+      this.metricsManager.timeEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_GET_SUCCESS);
+      this.metricsManager.timeEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_GET_FAILED);
+
+      const response = await this.webexRequest.request({
+        service: WCC_API_GATEWAY,
+        resource,
+        method: HTTP_METHODS.GET,
+      });
+
+      LoggerProxy.info('Successfully retrieved user preferences', {
+        module: 'UserPreference',
+        method: 'getUserPreference',
+        data: {
+          statusCode: response.statusCode,
+          userId: targetUserId,
+        },
+      });
+
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_GET_SUCCESS,
+        {
+          orgId,
+          userId: targetUserId,
+          statusCode: response.statusCode,
+        },
+        ['behavioral', 'operational']
+      );
+
+      return response.body;
+    } catch (error) {
+      const errorData = {
+        orgId,
+        userId: targetUserId,
+        error: error instanceof Error ? error.message : String(error),
+      };
+
+      LoggerProxy.error('Failed to fetch user preferences', {
+        module: 'UserPreference',
+        method: 'getUserPreference',
+        data: errorData,
+        error,
+      });
+
+      this.metricsManager.trackEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_GET_FAILED, errorData, [
+        'behavioral',
+        'operational',
+      ]);
+
+      throw error;
+    }
+  }
+
+  /**
+   * Creates new user preferences
+   * @param {CreateUserPreferenceRequest} data - The user preference data to create
+   * @returns {Promise<UserPreference>} Promise resolving to created user preferences
+   * @throws {Error} If the API call fails
+   * @public
+   * @example
+   * ```typescript
+   * const newPreferences = await userPreferenceAPI.createUserPreference({
+   *   userId: 'user123',
+   *   preferences: { e911Reminder: true, notificationSettings: { email: true } }
+   * });
+   * ```
+   */
+  public async createUserPreference(
+    data: CreateUserPreferenceRequest
+  ): Promise<UserPreferenceResponse> {
+    const orgId = this.webex.credentials.getOrgId();
+
+    LoggerProxy.info('Creating user preferences', {
+      module: 'UserPreference',
+      method: 'createUserPreference',
+      data: {
+        orgId,
+        userId: data.userId,
+      },
+    });
+
+    if (!data.userId) {
+      LoggerProxy.error('createUserPreference called without a valid userId', {
+        module: 'UserPreference',
+        method: 'createUserPreference',
+        data: {
+          orgId,
+          error: 'Missing userId in request data.',
+        },
+      });
+
+      throw new Error('UserPreference: userId is required to create user preferences.');
+    }
+
+    try {
+      const resource = endPointMap.userPreferenceCreate(orgId);
+
+      LoggerProxy.info('Making API request to create user preferences', {
+        module: 'UserPreference',
+        method: 'createUserPreference',
+        data: {
+          resource,
+          service: WCC_API_GATEWAY,
+        },
+      });
+
+      this.metricsManager.timeEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_CREATE_SUCCESS);
+      this.metricsManager.timeEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_CREATE_FAILED);
+
+      const response = await this.webexRequest.request({
+        service: WCC_API_GATEWAY,
+        resource,
+        method: HTTP_METHODS.POST,
+        body: data,
+      });
+
+      LoggerProxy.info('Successfully created user preferences', {
+        module: 'UserPreference',
+        method: 'createUserPreference',
+        data: {
+          statusCode: response.statusCode,
+          userId: data.userId,
+        },
+      });
+
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_CREATE_SUCCESS,
+        {
+          orgId,
+          userId: data.userId,
+          statusCode: response.statusCode,
+        },
+        ['behavioral', 'operational']
+      );
+
+      return response.body;
+    } catch (error) {
+      const errorData = {
+        orgId,
+        userId: data.userId,
+        error: error instanceof Error ? error.message : String(error),
+      };
+
+      LoggerProxy.error('Failed to create user preferences', {
+        module: 'UserPreference',
+        method: 'createUserPreference',
+        data: errorData,
+        error,
+      });
+
+      this.metricsManager.trackEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_CREATE_FAILED, errorData, [
+        'behavioral',
+        'operational',
+      ]);
+
+      throw error;
+    }
+  }
+
+  /**
+   * Updates existing user preferences
+   * @param {string} userId - User ID to update preferences for
+   * @param {UpdateUserPreferenceRequest} data - The user preference data to update
+   * @returns {Promise<UserPreference>} Promise resolving to updated user preferences
+   * @throws {Error} If the API call fails
+   * @public
+   * @example
+   * ```typescript
+   * const updatedPreferences = await userPreferenceAPI.updateUserPreference('user123', {
+   *   preferences: { e911Reminder: false }
+   * });
+   * ```
+   */
+  public async updateUserPreference(
+    userId: string,
+    data: UpdateUserPreferenceRequest
+  ): Promise<UserPreferenceResponse> {
+    const orgId = this.webex.credentials.getOrgId();
+
+    LoggerProxy.info('Updating user preferences', {
+      module: 'UserPreference',
+      method: 'updateUserPreference',
+      data: {
+        orgId,
+        userId,
+      },
+    });
+
+    if (!userId) {
+      LoggerProxy.error('updateUserPreference called without a valid userId', {
+        module: 'UserPreference',
+        method: 'updateUserPreference',
+        data: {
+          orgId,
+          error: 'Missing userId parameter.',
+        },
+      });
+
+      throw new Error('UserPreference: userId is required to update user preferences.');
+    }
+
+    try {
+      const resource = endPointMap.userPreference(orgId, userId);
+
+      LoggerProxy.info('Making API request to update user preferences', {
+        module: 'UserPreference',
+        method: 'updateUserPreference',
+        data: {
+          resource,
+          service: WCC_API_GATEWAY,
+        },
+      });
+
+      this.metricsManager.timeEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_UPDATE_SUCCESS);
+      this.metricsManager.timeEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_UPDATE_FAILED);
+
+      const response = await this.webexRequest.request({
+        service: WCC_API_GATEWAY,
+        resource,
+        method: HTTP_METHODS.PUT,
+        body: data,
+      });
+
+      LoggerProxy.info('Successfully updated user preferences', {
+        module: 'UserPreference',
+        method: 'updateUserPreference',
+        data: {
+          statusCode: response.statusCode,
+          userId,
+        },
+      });
+
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_UPDATE_SUCCESS,
+        {
+          orgId,
+          userId,
+          statusCode: response.statusCode,
+        },
+        ['behavioral', 'operational']
+      );
+
+      return response.body;
+    } catch (error) {
+      const errorData = {
+        orgId,
+        userId,
+        error: error instanceof Error ? error.message : String(error),
+      };
+
+      LoggerProxy.error('Failed to update user preferences', {
+        module: 'UserPreference',
+        method: 'updateUserPreference',
+        data: errorData,
+        error,
+      });
+
+      this.metricsManager.trackEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_UPDATE_FAILED, errorData, [
+        'behavioral',
+        'operational',
+      ]);
+
+      throw error;
+    }
+  }
+
+  /**
+   * Deletes user preferences for a specific user
+   * @param {string} userId - User ID to delete preferences for
+   * @returns {Promise<void>} Promise resolving when deletion is complete
+   * @throws {Error} If the API call fails
+   * @public
+   * @example
+   * ```typescript
+   * await userPreferenceAPI.deleteUserPreference('user123');
+   * ```
+   */
+  public async deleteUserPreference(userId: string): Promise<void> {
+    const orgId = this.webex.credentials.getOrgId();
+
+    LoggerProxy.info('Deleting user preferences', {
+      module: 'UserPreference',
+      method: 'deleteUserPreference',
+      data: {
+        orgId,
+        userId,
+      },
+    });
+
+    if (!userId) {
+      LoggerProxy.error('deleteUserPreference called without a valid userId', {
+        module: 'UserPreference',
+        method: 'deleteUserPreference',
+        data: {
+          orgId,
+          error: 'Missing userId parameter.',
+        },
+      });
+
+      throw new Error('UserPreference: userId is required to delete user preferences.');
+    }
+
+    try {
+      const resource = endPointMap.userPreference(orgId, userId);
+
+      LoggerProxy.info('Making API request to delete user preferences', {
+        module: 'UserPreference',
+        method: 'deleteUserPreference',
+        data: {
+          resource,
+          service: WCC_API_GATEWAY,
+        },
+      });
+
+      this.metricsManager.timeEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_DELETE_SUCCESS);
+      this.metricsManager.timeEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_DELETE_FAILED);
+
+      const response = await this.webexRequest.request({
+        service: WCC_API_GATEWAY,
+        resource,
+        method: HTTP_METHODS.DELETE,
+      });
+
+      LoggerProxy.info('Successfully deleted user preferences', {
+        module: 'UserPreference',
+        method: 'deleteUserPreference',
+        data: {
+          statusCode: response.statusCode,
+          userId,
+        },
+      });
+
+      this.metricsManager.trackEvent(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_DELETE_SUCCESS,
+        {
+          orgId,
+          userId,
+          statusCode: response.statusCode,
+        },
+        ['behavioral', 'operational']
+      );
+    } catch (error) {
+      const errorData = {
+        orgId,
+        userId,
+        error: error instanceof Error ? error.message : String(error),
+      };
+
+      LoggerProxy.error('Failed to delete user preferences', {
+        module: 'UserPreference',
+        method: 'deleteUserPreference',
+        data: errorData,
+        error,
+      });
+
+      this.metricsManager.trackEvent(METRIC_EVENT_NAMES.USER_PREFERENCE_DELETE_FAILED, errorData, [
+        'behavioral',
+        'operational',
+      ]);
+
+      throw error;
+    }
+  }
+}
+
+export default UserPreference;

package/src/services/config/constants.ts

@@ -298,4 +298,28 @@ export const endPointMap = {
     `organization/${orgId}/v2/outdial-ani/${outdialANI}/entry${
       queryParams ? `?${queryParams}` : ''
     }`,
+
+  /**
+   * Gets the endpoint for user preference by user ID.
+   * @param orgId - Organization ID.
+   * @param userId - User ID.
+   * @returns The endpoint URL string.
+   * @public
+   * @example
+   * const url = endPointMap.userPreference('org123', 'user456');
+   * @ignore
+   */
+  userPreference: (orgId: string, userId: string) =>
+    `organization/${orgId}/user-preference/${userId}`,
+
+  /**
+   * Gets the endpoint for creating user preference.
+   * @param orgId - Organization ID.
+   * @returns The endpoint URL string.
+   * @public
+   * @example
+   * const url = endPointMap.userPreferenceCreate('org123');
+   * @ignore
+   */
+  userPreferenceCreate: (orgId: string) => `organization/${orgId}/user-preference`,
 };

package/src/services/config/types.ts

@@ -1294,3 +1294,55 @@ export type OutdialAniParams = {
   /** Comma-separated list of attributes to include in response (optional) */
   attributes?: string;
 };
+
+/**
+ * User preference data structure
+ * @public
+ */
+export type UserPreference = {
+  /** Unique identifier for the user preference */
+  id: string;
+  /** Organization ID */
+  organizationId: string;
+  /** User ID (CI user ID) */
+  userId: string;
+  /** User preference data as key-value pairs */
+  preferences: Record<string, unknown>;
+  /** Timestamp when this preference was created (Unix timestamp in milliseconds) */
+  createdTime?: number;
+  /** Timestamp when this preference was last updated (Unix timestamp in milliseconds) */
+  lastUpdatedTime?: number;
+};
+
+/**
+ * Request payload for creating user preferences
+ * @public
+ */
+export type CreateUserPreferenceRequest = {
+  /** User ID (CI user ID) */
+  userId: string;
+  /** Desktop preference data as a JSON string (required) */
+  desktopPreference: string;
+};
+
+/**
+ * Request payload for updating user preferences
+ * @public
+ */
+export type UpdateUserPreferenceRequest = {
+  /** Desktop preference data as a JSON string (required) */
+  desktopPreference: string;
+};
+
+/**
+ * Query parameters for fetching user preferences
+ * @public
+ */
+export type GetUserPreferenceParams = {
+  /** User ID to fetch preferences for. Defaults to current user's CI user ID. */
+  userId?: string;
+  /** Page number (0-indexed). Default: 0 */
+  page?: number;
+  /** Number of items per page. Default: 100 */
+  pageSize?: number;
+};

package/src/types.ts

@@ -6,7 +6,12 @@ import {
 } from '@webex/internal-plugin-metrics/src/metrics.types';
 import * as Agent from './services/agent/types';
 import * as Contact from './services/task/types';
-import {AIFeatureFlags, Profile} from './services/config/types';
+import {
+  AIFeatureFlags,
+  Profile,
+  CreateUserPreferenceRequest,
+  UpdateUserPreferenceRequest,
+} from './services/config/types';
 import {PaginatedResponse, BaseSearchParams} from './utils/PageCache';
 
 /**
@@ -544,7 +549,9 @@ export type RequestBody =
   | Contact.cancelCtq
   | Contact.WrapupPayLoad
   | Contact.DialerPayload
-  | Contact.PreviewContactPayload;
+  | Contact.PreviewContactPayload
+  | CreateUserPreferenceRequest
+  | UpdateUserPreferenceRequest;
 
 /**
  * Represents the options to fetch buddy agents for the logged in agent.

package/test/unit/spec/cc.ts

@@ -403,12 +403,7 @@ describe('webex.cc', () => {
         isEndConsultEnabled: mockAgentProfile.isEndConsultEnabled,
         webRtcEnabled: mockAgentProfile.webRtcEnabled,
         autoWrapup: mockAgentProfile.wrapUpData.wrapUpProps.autoWrapup ?? false,
-      });
-      expect(mockTaskManager.setConfigFlags).toHaveBeenCalledWith({
-        isEndTaskEnabled: mockAgentProfile.isEndTaskEnabled,
-        isEndConsultEnabled: mockAgentProfile.isEndConsultEnabled,
-        webRtcEnabled: mockAgentProfile.webRtcEnabled,
-        autoWrapup: mockAgentProfile.wrapUpData.wrapUpProps.autoWrapup ?? false,
+        aiFeature: mockAgentProfile.aiFeature,
       });
       expect(reloadSpy).toHaveBeenCalled();
       expect(result).toEqual(mockAgentProfile);