@webex/calling 3.8.0 → 3.8.1-next.10

package/dist/module/Voicemail/UcmBackendConnector.js

@@ -1,9 +1,9 @@
 import SDKConnector from '../SDKConnector';
 import { HTTP_METHODS, CALLING_BACKEND, } from '../common/types';
-import { getVgActionEndpoint, serviceErrorCodeHandler } from '../common/Utils';
-import { SUCCESS_MESSAGE, USERS, CONTENT, UCM_CONNECTOR_FILE, FAILURE_MESSAGE, } from '../common/constants';
+import { getVgActionEndpoint, serviceErrorCodeHandler, uploadLogs } from '../common/Utils';
+import { SUCCESS_MESSAGE, USERS, CONTENT, UCM_CONNECTOR_FILE, FAILURE_MESSAGE, METHOD_START_MESSAGE, } from '../common/constants';
 import log from '../Logger';
-import { API_V1, LIMIT, OFFSET, SORT_ORDER, VMGATEWAY, VOICEMAILS } from './constants';
+import { API_V1, LIMIT, METHODS, OFFSET, SORT_ORDER, VMGATEWAY, VOICEMAILS } from './constants';
 export class UcmBackendConnector {
     vgEndpoint;
     userId;
@@ -24,16 +24,22 @@ export class UcmBackendConnector {
     init() {
         const loggerContext = {
             file: UCM_CONNECTOR_FILE,
-            method: 'init',
+            method: METHODS.INIT,
         };
-        log.info('Initializing UCM calling voicemail connector', loggerContext);
+        log.info(METHOD_START_MESSAGE, loggerContext);
         const response = this.setUcmVoiceMessageBaseURI();
+        log.log('UCM calling voicemail connector initialized successfully', loggerContext);
         return response;
     }
     getSDKConnector() {
         return this.sdkConnector;
     }
     setUcmVoiceMessageBaseURI() {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: METHODS.SET_UCM_VOICE_MESSAGE_BASE_URI,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         this.vgEndpoint = getVgActionEndpoint(this.webex, CALLING_BACKEND.UCM);
         this.vgVoiceMessageURI = `${this.vgEndpoint}/${VMGATEWAY}/${API_V1}/${USERS}/${this.userId}/`;
         return this.vgVoiceMessageURI;
@@ -41,9 +47,9 @@ export class UcmBackendConnector {
     async getVoicemailList(offset, offsetLimit, sort) {
         const loggerContext = {
             file: UCM_CONNECTOR_FILE,
-            method: 'getVoicemailList',
+            method: METHODS.GET_VOICEMAIL_LIST,
         };
-        log.info(`Offset: ${offset} Offset limit: ${offsetLimit} Sort type:${sort}`, loggerContext);
+        log.info(`${METHOD_START_MESSAGE} with Offset: ${offset} Offset limit: ${offsetLimit} Sort type:${sort}`, loggerContext);
         const urlVg = `${this.vgVoiceMessageURI}${VOICEMAILS}/${OFFSET}=${offset}${LIMIT}=${offsetLimit}${SORT_ORDER}=${sort}`;
         try {
             const response = await this.webex.request({
@@ -91,9 +97,13 @@ export class UcmBackendConnector {
                 },
                 message: SUCCESS_MESSAGE,
             };
+            log.log('Successfully retrieved voicemail list', loggerContext);
             return responseDetails;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to get voicemail list: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
@@ -102,13 +112,18 @@ export class UcmBackendConnector {
     async getVoicemailContent(messageId) {
         const loggerContext = {
             file: UCM_CONNECTOR_FILE,
-            method: 'getVoicemailContent',
+            method: METHODS.GET_VOICEMAIL_CONTENT,
         };
+        log.info(`${METHOD_START_MESSAGE} with Message ID: ${messageId}`, loggerContext);
         try {
             const response = (await this.getVoicemailContentUcm(messageId));
+            log.log(`Successfully retrieved voicemail content with  Message ID: ${messageId}`, loggerContext);
             return response;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to get voicemail content: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             log.info(`Voice mail content error is ${errorStatus}`, loggerContext);
@@ -119,6 +134,11 @@ export class UcmBackendConnector {
         return Promise.resolve(null);
     }
     async getVoicemailContentUcm(messageId) {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: METHODS.GET_VOICEMAIL_CONTENT_UCM,
+        };
+        log.info(`${METHOD_START_MESSAGE} with Message ID: ${messageId}`, loggerContext);
         return new Promise((resolve, reject) => {
             const voicemailContentUrl = `${this.vgVoiceMessageURI}${VOICEMAILS}/${messageId}/${CONTENT}`;
             const mercuryApi = `${this.webex.internal.services._serviceUrls.mercuryApi}`;
@@ -152,6 +172,11 @@ export class UcmBackendConnector {
         });
     }
     async returnUcmPromise(voicemailContentUrl, mercuryApi) {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: METHODS.RETURN_UCM_PROMISE,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         const response = await this.webex.request({
             uri: `${voicemailContentUrl}`,
             method: HTTP_METHODS.GET,
@@ -184,8 +209,9 @@ export class UcmBackendConnector {
     async voicemailMarkAsRead(messageId) {
         const loggerContext = {
             file: UCM_CONNECTOR_FILE,
-            method: 'voicemailMarkAsRead',
+            method: METHODS.VOICEMAIL_MARK_AS_READ,
         };
+        log.info(`${METHOD_START_MESSAGE} with Message ID: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.vgVoiceMessageURI}${VOICEMAILS}/${messageId}`;
             const response = await this.webex.request({
@@ -203,9 +229,13 @@ export class UcmBackendConnector {
                 data: {},
                 message: SUCCESS_MESSAGE,
             };
+            log.log('Successfully marked voicemail as read', loggerContext);
             return responseDetails;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to mark voicemail as read: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
@@ -214,8 +244,9 @@ export class UcmBackendConnector {
     async voicemailMarkAsUnread(messageId) {
         const loggerContext = {
             file: UCM_CONNECTOR_FILE,
-            method: 'voicemailMarkAsUnread',
+            method: METHODS.VOICEMAIL_MARK_AS_UNREAD,
         };
+        log.info(`${METHOD_START_MESSAGE} with Message ID: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.vgVoiceMessageURI}${VOICEMAILS}/${messageId}`;
             const response = await this.webex.request({
@@ -233,9 +264,13 @@ export class UcmBackendConnector {
                 data: {},
                 message: SUCCESS_MESSAGE,
             };
+            log.log('Successfully marked voicemail as unread', loggerContext);
             return responseDetails;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to mark voicemail as unread: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
@@ -244,8 +279,9 @@ export class UcmBackendConnector {
     async deleteVoicemail(messageId) {
         const loggerContext = {
             file: UCM_CONNECTOR_FILE,
-            method: 'deleteVoicemail',
+            method: METHODS.DELETE_VOICEMAIL,
         };
+        log.info(`${METHOD_START_MESSAGE} with Message ID: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.vgVoiceMessageURI}${VOICEMAILS}/${messageId}`;
             const response = await this.webex.request({
@@ -260,9 +296,13 @@ export class UcmBackendConnector {
                 data: {},
                 message: SUCCESS_MESSAGE,
             };
+            log.log('Successfully deleted voicemail', loggerContext);
             return responseDetails;
         }
         catch (err) {
+            const extendedError = new Error(`Failed to delete voicemail: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;

package/dist/module/Voicemail/Voicemail.js

@@ -1,14 +1,15 @@
+import { METHOD_START_MESSAGE } from '../common/constants';
 import SDKConnector from '../SDKConnector';
 import { CALLING_BACKEND } from '../common/types';
 import log from '../Logger';
-import { getCallingBackEnd } from '../common/Utils';
+import { getCallingBackEnd, uploadLogs } from '../common/Utils';
 import { WxCallBackendConnector } from './WxCallBackendConnector';
 import { BroadworksBackendConnector } from './BroadworksBackendConnector';
 import { Eventing } from '../Events/impl';
 import { UcmBackendConnector } from './UcmBackendConnector';
 import { METRIC_EVENT, METRIC_TYPE, VOICEMAIL_ACTION } from '../Metrics/types';
 import { getMetricManager } from '../Metrics';
-import { VOICEMAIL_FILE } from './constants';
+import { VOICEMAIL_FILE, METHODS } from './constants';
 export class Voicemail extends Eventing {
     logger;
     sdkConnector;
@@ -29,11 +30,34 @@ export class Voicemail extends Eventing {
         this.initializeBackendConnector();
         log.setLogger(logger.level, VOICEMAIL_FILE);
     }
-    init() {
-        const response = this.backendConnector.init();
-        return response;
+    async init() {
+        try {
+            log.info(METHOD_START_MESSAGE, {
+                file: VOICEMAIL_FILE,
+                method: METHODS.INIT,
+            });
+            const response = this.backendConnector.init();
+            log.log('Voicemail connector initialized successfully', {
+                file: VOICEMAIL_FILE,
+                method: METHODS.INIT,
+            });
+            return response;
+        }
+        catch (err) {
+            const extendedError = new Error(`Failed to initialize voicemail: ${err}`);
+            log.error(extendedError, {
+                file: VOICEMAIL_FILE,
+                method: METHODS.INIT,
+            });
+            await uploadLogs();
+            throw err;
+        }
     }
     initializeBackendConnector() {
+        log.info(METHOD_START_MESSAGE, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.INITIALIZE_BACKEND_CONNECTOR,
+        });
         switch (this.callingBackend) {
             case CALLING_BACKEND.WXC: {
                 this.backendConnector = new WxCallBackendConnector(this.webex, this.logger);
@@ -62,46 +86,122 @@ export class Voicemail extends Eventing {
         }
     }
     async getVoicemailList(offset, offsetLimit, sort, refresh) {
-        const response = await this.backendConnector.getVoicemailList(offset, offsetLimit, sort, refresh);
-        this.submitMetric(response, VOICEMAIL_ACTION.GET_VOICEMAILS);
-        return response;
+        try {
+            log.info(`${METHOD_START_MESSAGE} with: offset=${offset}, limit=${offsetLimit}, sort=${sort}, refresh=${refresh}`, {
+                file: VOICEMAIL_FILE,
+                method: METHODS.GET_VOICEMAIL_LIST,
+            });
+            const response = await this.backendConnector.getVoicemailList(offset, offsetLimit, sort, refresh);
+            this.submitMetric(response, VOICEMAIL_ACTION.GET_VOICEMAILS);
+            log.log(`Successfully retrieved voicemail list: statusCode=${response.statusCode}`, {
+                file: VOICEMAIL_FILE,
+                method: METHODS.GET_VOICEMAIL_LIST,
+            });
+            return response;
+        }
+        catch (err) {
+            const extendedError = new Error(`Failed to get voicemail list: ${err}`);
+            log.error(extendedError, {
+                file: VOICEMAIL_FILE,
+                method: METHODS.GET_VOICEMAIL_LIST,
+            });
+            await uploadLogs();
+            throw err;
+        }
     }
     async getVoicemailContent(messageId) {
+        log.info(`${METHOD_START_MESSAGE} with: messageId=${messageId}`, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.GET_VOICEMAIL_CONTENT,
+        });
         const response = await this.backendConnector.getVoicemailContent(messageId);
         this.submitMetric(response, VOICEMAIL_ACTION.GET_VOICEMAIL_CONTENT, messageId);
+        log.log(`Successfully retrieved voicemail content for messageId=${messageId}, statusCode=${response.statusCode}`, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.GET_VOICEMAIL_CONTENT,
+        });
         return response;
     }
     async getVoicemailSummary() {
+        log.info(METHOD_START_MESSAGE, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.GET_VOICEMAIL_SUMMARY,
+        });
         const response = await this.backendConnector.getVoicemailSummary();
         if (response !== null) {
             this.submitMetric(response, VOICEMAIL_ACTION.GET_VOICEMAIL_SUMMARY);
+            log.log(`Successfully retrieved voicemail summary: statusCode=${response.statusCode}`, {
+                file: VOICEMAIL_FILE,
+                method: METHODS.GET_VOICEMAIL_SUMMARY,
+            });
         }
         return response;
     }
     async voicemailMarkAsRead(messageId) {
+        log.info(`${METHOD_START_MESSAGE} with: messageId=${messageId}`, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.VOICEMAIL_MARK_AS_READ,
+        });
         const response = await this.backendConnector.voicemailMarkAsRead(messageId);
         this.submitMetric(response, VOICEMAIL_ACTION.MARK_READ, messageId);
+        log.log(`Successfully marked voicemail as read: messageId=${messageId}, statusCode=${response.statusCode}`, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.VOICEMAIL_MARK_AS_READ,
+        });
         return response;
     }
     async voicemailMarkAsUnread(messageId) {
+        log.info(`${METHOD_START_MESSAGE} with: messageId=${messageId}`, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.VOICEMAIL_MARK_AS_UNREAD,
+        });
         const response = await this.backendConnector.voicemailMarkAsUnread(messageId);
         this.submitMetric(response, VOICEMAIL_ACTION.MARK_UNREAD, messageId);
+        log.log(`Successfully marked voicemail as unread: messageId=${messageId}, statusCode=${response.statusCode}`, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.VOICEMAIL_MARK_AS_UNREAD,
+        });
         return response;
     }
     async deleteVoicemail(messageId) {
+        log.info(`${METHOD_START_MESSAGE} with: messageId=${messageId}`, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.DELETE_VOICEMAIL,
+        });
         const response = await this.backendConnector.deleteVoicemail(messageId);
         this.submitMetric(response, VOICEMAIL_ACTION.DELETE, messageId);
+        log.log(`Successfully deleted voicemail: messageId=${messageId}, statusCode=${response.statusCode}`, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.DELETE_VOICEMAIL,
+        });
         return response;
     }
     async getVMTranscript(messageId) {
+        log.info(`${METHOD_START_MESSAGE} with: messageId=${messageId}`, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.GET_VM_TRANSCRIPT,
+        });
         const response = await this.backendConnector.getVMTranscript(messageId);
         if (response !== null) {
             this.submitMetric(response, VOICEMAIL_ACTION.TRANSCRIPT, messageId);
+            log.log(`Successfully retrieved voicemail transcript: messageId=${messageId}, statusCode=${response.statusCode}`, {
+                file: VOICEMAIL_FILE,
+                method: METHODS.GET_VM_TRANSCRIPT,
+            });
         }
         return response;
     }
     resolveContact(callingPartyInfo) {
-        return this.backendConnector.resolveContact(callingPartyInfo);
+        log.info(METHOD_START_MESSAGE, {
+            file: VOICEMAIL_FILE,
+            method: METHODS.RESOLVE_CONTACT,
+        });
+        const response = this.backendConnector.resolveContact(callingPartyInfo);
+        log.log('Contact resolution completed successfully', {
+            file: VOICEMAIL_FILE,
+            method: METHODS.RESOLVE_CONTACT,
+        });
+        return response;
     }
     getSDKConnector() {
         return this.sdkConnector;

package/dist/module/Voicemail/WxCallBackendConnector.js

@@ -1,9 +1,9 @@
 import SDKConnector from '../SDKConnector';
-import { RAW_REQUEST, SUCCESS_MESSAGE, SUCCESS_STATUS_CODE, TRANSCRIPT, USER, XML_TYPE, BW_XSI_ENDPOINT_VERSION, WEBEX_CALLING_CONNECTOR_FILE, } from '../common/constants';
-import { serviceErrorCodeHandler, getXsiActionEndpoint, getSortedVoicemailList, resolveContact, storeVoicemailList, fetchVoicemailList, } from '../common/Utils';
+import { RAW_REQUEST, SUCCESS_MESSAGE, SUCCESS_STATUS_CODE, TRANSCRIPT, USER, XML_TYPE, BW_XSI_ENDPOINT_VERSION, WEBEX_CALLING_CONNECTOR_FILE, METHOD_START_MESSAGE, } from '../common/constants';
+import { serviceErrorCodeHandler, getXsiActionEndpoint, getSortedVoicemailList, resolveContact, storeVoicemailList, fetchVoicemailList, uploadLogs, } from '../common/Utils';
 import { CALLING_BACKEND, HTTP_METHODS, SORT, } from '../common/types';
 import log from '../Logger';
-import { JSON_FORMAT, MARK_AS_READ, MARK_AS_UNREAD, MESSAGE_MEDIA_CONTENT, TRANSCRIPT_CONTENT, VOICE_MESSAGING_MESSAGES, NO_VOICEMAIL_MSG, NO_VOICEMAIL_STATUS_CODE, RADIX_RAND, PREFIX, TRANSCRIPT_STATUS, MESSAGE_SUMMARY, CALLS, SUMMARY, NEW_MESSAGES, NEW_URGENT_MESSAGES, OLD_URGENT_MESSAGES, OLD_MESSAGES, } from './constants';
+import { JSON_FORMAT, MARK_AS_READ, MARK_AS_UNREAD, MESSAGE_MEDIA_CONTENT, TRANSCRIPT_CONTENT, VOICE_MESSAGING_MESSAGES, NO_VOICEMAIL_MSG, NO_VOICEMAIL_STATUS_CODE, RADIX_RAND, PREFIX, TRANSCRIPT_STATUS, MESSAGE_SUMMARY, CALLS, SUMMARY, NEW_MESSAGES, NEW_URGENT_MESSAGES, OLD_URGENT_MESSAGES, OLD_MESSAGES, METHODS, } from './constants';
 export class WxCallBackendConnector {
     xsiEndpoint;
     userId;
@@ -11,6 +11,7 @@ export class WxCallBackendConnector {
     sdkConnector;
     xsiVoiceMessageURI;
     webex;
+    authHeaders = null;
     constructor(webex, logger) {
         this.sdkConnector = SDKConnector;
         if (!this.sdkConnector.getWebex()) {
@@ -21,12 +22,13 @@ export class WxCallBackendConnector {
         this.userId = this.webex.internal.device.userId;
         log.setLogger(logger.level, WEBEX_CALLING_CONNECTOR_FILE);
     }
-    init() {
+    async init() {
+        this.authHeaders = await this.getAuthHeaders();
         const loggerContext = {
             file: WEBEX_CALLING_CONNECTOR_FILE,
-            method: 'init',
+            method: METHODS.INIT,
         };
-        log.info('Initializing Webex calling voicemail connector', loggerContext);
+        log.info(METHOD_START_MESSAGE, loggerContext);
         const response = this.setXsiVoiceMessageURI();
         return response;
     }
@@ -37,10 +39,11 @@ export class WxCallBackendConnector {
         let responseDetails;
         const loggerContext = {
             file: WEBEX_CALLING_CONNECTOR_FILE,
-            method: 'setXsiVoiceMessageURI',
+            method: METHODS.SET_XSI_VOICE_MESSAGE_URI,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         this.xsiEndpoint = await getXsiActionEndpoint(this.webex, loggerContext, CALLING_BACKEND.WXC);
-        log.info(`XsiEndpoint is ${this.xsiEndpoint}`, loggerContext);
+        log.log(`XsiEndpoint is ${this.xsiEndpoint}`, loggerContext);
         if (this.userId) {
             this.xsiVoiceMessageURI = `${this.xsiEndpoint}/${BW_XSI_ENDPOINT_VERSION}/${USER}/${this.userId}/${VOICE_MESSAGING_MESSAGES}`;
             responseDetails = {
@@ -54,9 +57,9 @@ export class WxCallBackendConnector {
     async getVoicemailList(offset, offsetLimit, sort, refresh) {
         const loggerContext = {
             file: WEBEX_CALLING_CONNECTOR_FILE,
-            method: 'getVoicemailList',
+            method: METHODS.GET_VOICEMAIL_LIST,
         };
-        log.info(`Offset: ${offset} Offset limit: ${offsetLimit} Sort type:${sort}`, loggerContext);
+        log.info(`${METHOD_START_MESSAGE} with Offset: ${offset} Offset limit: ${offsetLimit} Sort type:${sort}`, loggerContext);
         let messageinfo;
         if (refresh) {
             const urlXsi = `${this.xsiVoiceMessageURI}${JSON_FORMAT}`;
@@ -65,6 +68,7 @@ export class WxCallBackendConnector {
                 const response = await this.webex.request({
                     uri: `${urlXsi}`,
                     method: HTTP_METHODS.GET,
+                    headers: { ...this.authHeaders },
                 });
                 const voicemailListResponse = response.body;
                 if (Object.keys(voicemailListResponse?.VoiceMessagingMessages?.messageInfoList).length === 0) {
@@ -82,6 +86,9 @@ export class WxCallBackendConnector {
             }
             catch (err) {
                 const errorInfo = err;
+                const extendedError = new Error(`Failed to get voicemail list: ${err}`);
+                log.error(extendedError, loggerContext);
+                await uploadLogs();
                 const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
                 return errorStatus;
             }
@@ -94,18 +101,21 @@ export class WxCallBackendConnector {
             },
             message: moreVMAvailable ? SUCCESS_MESSAGE : NO_VOICEMAIL_MSG,
         };
+        log.log('Successfully fetched voicemail list', loggerContext);
         return responseDetails;
     }
     async getVoicemailContent(messageId) {
         const loggerContext = {
             file: WEBEX_CALLING_CONNECTOR_FILE,
-            method: 'getVoicemailContent',
+            method: METHODS.GET_VOICEMAIL_CONTENT,
         };
+        log.info(`${METHOD_START_MESSAGE} with messageId: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.xsiEndpoint}${messageId}`;
             const response = await this.webex.request({
                 uri: `${voicemailContentUrl}`,
                 method: HTTP_METHODS.GET,
+                headers: { ...this.authHeaders },
             });
             const parser = new DOMParser();
             const xmlDOM = parser.parseFromString(response[RAW_REQUEST].response, XML_TYPE);
@@ -123,25 +133,30 @@ export class WxCallBackendConnector {
                 },
                 message: SUCCESS_MESSAGE,
             };
+            log.log('Successfully fetched voicemail content', loggerContext);
             return responseDetails;
         }
         catch (err) {
             const errorInfo = err;
+            const extendedError = new Error(`Failed to get voicemail content: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
-            log.info(`Voice mail content error is ${errorStatus}`, loggerContext);
             return errorStatus;
         }
     }
     async getVoicemailSummary() {
         const loggerContext = {
             file: WEBEX_CALLING_CONNECTOR_FILE,
-            method: 'getVoicemailSummary',
+            method: METHODS.GET_VOICEMAIL_SUMMARY,
         };
+        log.info(METHOD_START_MESSAGE, loggerContext);
         try {
             const voicemailSummaryUrl = `${this.xsiEndpoint}/${BW_XSI_ENDPOINT_VERSION}/${USER}/${this.userId}/${CALLS}/${MESSAGE_SUMMARY}`;
             const response = await this.webex.request({
                 uri: `${voicemailSummaryUrl}`,
                 method: HTTP_METHODS.GET,
+                headers: { ...this.authHeaders },
             });
             const parser = new DOMParser();
             const xmlDOM = parser.parseFromString(response[RAW_REQUEST].response, XML_TYPE);
@@ -162,35 +177,44 @@ export class WxCallBackendConnector {
                 },
                 message: SUCCESS_MESSAGE,
             };
+            log.log('Successfully fetched voicemail summary', loggerContext);
             return responseDetails;
         }
         catch (err) {
             const errorInfo = err;
+            const extendedError = new Error(`Failed to get voicemail summary: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
-            log.error(new Error(`Voicemail summary error is ${errorStatus}`), loggerContext);
             return errorStatus;
         }
     }
     async voicemailMarkAsRead(messageId) {
         const loggerContext = {
             file: WEBEX_CALLING_CONNECTOR_FILE,
-            method: 'voicemailMarkAsRead',
+            method: METHODS.VOICEMAIL_MARK_AS_READ,
         };
+        log.info(`${METHOD_START_MESSAGE} with messageId: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.xsiEndpoint}${messageId}/${MARK_AS_READ}`;
             const response = await this.webex.request({
                 uri: voicemailContentUrl,
                 method: HTTP_METHODS.PUT,
+                headers: { ...this.authHeaders },
             });
             const responseDetails = {
                 statusCode: Number(response.statusCode),
                 data: {},
                 message: SUCCESS_MESSAGE,
             };
+            log.log('Successfully marked voicemail as read', loggerContext);
             return responseDetails;
         }
         catch (err) {
             const errorInfo = err;
+            const extendedError = new Error(`Failed to mark voicemail as read: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
         }
@@ -198,23 +222,29 @@ export class WxCallBackendConnector {
     async voicemailMarkAsUnread(messageId) {
         const loggerContext = {
             file: WEBEX_CALLING_CONNECTOR_FILE,
-            method: 'voicemailMarkAsUnread',
+            method: METHODS.VOICEMAIL_MARK_AS_UNREAD,
         };
+        log.info(`${METHOD_START_MESSAGE} with messageId: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.xsiEndpoint}${messageId}/${MARK_AS_UNREAD}`;
             const response = await this.webex.request({
                 uri: voicemailContentUrl,
                 method: HTTP_METHODS.PUT,
+                headers: { ...this.authHeaders },
             });
             const responseDetails = {
                 statusCode: Number(response.statusCode),
                 data: {},
                 message: SUCCESS_MESSAGE,
             };
+            log.log('Successfully marked voicemail as unread', loggerContext);
             return responseDetails;
         }
         catch (err) {
             const errorInfo = err;
+            const extendedError = new Error(`Failed to mark voicemail as unread: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
         }
@@ -222,23 +252,29 @@ export class WxCallBackendConnector {
     async deleteVoicemail(messageId) {
         const loggerContext = {
             file: WEBEX_CALLING_CONNECTOR_FILE,
-            method: 'deleteVoicemail',
+            method: METHODS.DELETE_VOICEMAIL,
         };
+        log.info(`${METHOD_START_MESSAGE} with messageId: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.xsiEndpoint}${messageId}`;
             const response = await this.webex.request({
                 uri: voicemailContentUrl,
                 method: HTTP_METHODS.DELETE,
+                headers: { ...this.authHeaders },
             });
             const responseDetails = {
                 statusCode: Number(response.statusCode),
                 data: {},
                 message: SUCCESS_MESSAGE,
             };
+            log.log('Successfully deleted voicemail', loggerContext);
             return responseDetails;
         }
         catch (err) {
             const errorInfo = err;
+            const extendedError = new Error(`Failed to delete voicemail: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
         }
@@ -246,13 +282,15 @@ export class WxCallBackendConnector {
     async getVMTranscript(messageId) {
         const loggerContext = {
             file: WEBEX_CALLING_CONNECTOR_FILE,
-            method: 'getVMTranscript',
+            method: METHODS.GET_VM_TRANSCRIPT,
         };
+        log.info(`${METHOD_START_MESSAGE} with messageId: ${messageId}`, loggerContext);
         try {
             const voicemailContentUrl = `${this.xsiEndpoint}${messageId}/${TRANSCRIPT}`;
             const response = await this.webex.request({
                 uri: voicemailContentUrl,
                 method: HTTP_METHODS.GET,
+                headers: { ...this.authHeaders },
             });
             const parser = new DOMParser();
             const xmlDOM = parser.parseFromString(response[RAW_REQUEST].response, XML_TYPE);
@@ -265,10 +303,14 @@ export class WxCallBackendConnector {
                 },
                 message: status.textContent,
             };
+            log.log('Successfully fetched voicemail transcript', loggerContext);
             return responseDetails;
         }
         catch (err) {
             const errorInfo = err;
+            const extendedError = new Error(`Failed to get voicemail transcript: ${err}`);
+            log.error(extendedError, loggerContext);
+            await uploadLogs();
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
         }
@@ -276,4 +318,11 @@ export class WxCallBackendConnector {
     resolveContact(callingPartyInfo) {
         return resolveContact(callingPartyInfo);
     }
+    async getAuthHeaders() {
+        const headers = {};
+        if (this.webex?.config?.fedramp) {
+            headers.Authorization = await this.webex.credentials.getUserToken();
+        }
+        return headers;
+    }
 }

package/dist/module/Voicemail/constants.js

@@ -27,3 +27,24 @@ export const NEW_MESSAGES = 'newMessages';
 export const OLD_MESSAGES = 'oldMessages';
 export const NEW_URGENT_MESSAGES = 'newUrgentMessages';
 export const OLD_URGENT_MESSAGES = 'oldUrgentMessages';
+export const METHODS = {
+    INIT: 'init',
+    GET_SDK_CONNECTOR: 'getSDKConnector',
+    GET_USER_ID: 'getUserId',
+    GET_BW_TOKEN: 'getBwToken',
+    SET_XSI_VOICE_MESSAGE_URI: 'setXsiVoiceMessageURI',
+    GET_VOICEMAIL_LIST: 'getVoicemailList',
+    GET_VOICEMAIL_CONTENT: 'getVoicemailContent',
+    GET_VOICEMAIL_SUMMARY: 'getVoicemailSummary',
+    VOICEMAIL_MARK_AS_READ: 'voicemailMarkAsRead',
+    VOICEMAIL_MARK_AS_UNREAD: 'voicemailMarkAsUnread',
+    DELETE_VOICEMAIL: 'deleteVoicemail',
+    GET_VM_TRANSCRIPT: 'getVMTranscript',
+    RESOLVE_CONTACT: 'resolveContact',
+    GET_VOICEMAIL_CONTENT_UCM: 'getVoicemailContentUcm',
+    RETURN_UCM_PROMISE: 'returnUcmPromise',
+    INITIALIZE_BACKEND_CONNECTOR: 'initializeBackendConnector',
+    SUBMIT_METRIC: 'submitMetric',
+    GET_AUTH_HEADERS: 'getAuthHeaders',
+    SET_UCM_VOICE_MESSAGE_BASE_URI: 'setUcmVoiceMessageBaseURI',
+};