@webex/calling 0.0.1-next.0

package/dist/module/Voicemail/UcmBackendConnector.js

@@ -0,0 +1,275 @@
+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 } from '../common/constants';
+import log from '../Logger';
+import { API_V1, LIMIT, OFFSET, SORT_ORDER, VMGATEWAY, VOICEMAILS } from './constants';
+export class UcmBackendConnector {
+    vgEndpoint;
+    userId;
+    orgId;
+    sdkConnector;
+    webex;
+    vgVoiceMessageURI;
+    constructor(webex, logger) {
+        this.sdkConnector = SDKConnector;
+        if (!this.sdkConnector.getWebex()) {
+            SDKConnector.setWebex(webex);
+        }
+        this.webex = this.sdkConnector.getWebex();
+        this.userId = this.webex.internal.device.userId;
+        this.orgId = this.webex.internal.device.orgId;
+        log.setLogger(logger.level, UCM_CONNECTOR_FILE);
+    }
+    init() {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: 'init',
+        };
+        log.info('Initializing UCM calling voicemail connector', loggerContext);
+        const response = this.setUcmVoiceMessageBaseURI();
+        return response;
+    }
+    getSDKConnector() {
+        return this.sdkConnector;
+    }
+    setUcmVoiceMessageBaseURI() {
+        this.vgEndpoint = getVgActionEndpoint(this.webex, CALLING_BACKEND.UCM);
+        this.vgVoiceMessageURI = `${this.vgEndpoint}/${VMGATEWAY}/${API_V1}/${USERS}/${this.userId}/`;
+        return this.vgVoiceMessageURI;
+    }
+    async getVoicemailList(offset, offsetLimit, sort) {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: 'getVoicemailList',
+        };
+        log.info(`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({
+                uri: `${urlVg}`,
+                method: HTTP_METHODS.GET,
+                headers: {
+                    orgId: this.orgId,
+                },
+            });
+            const msgInfo = response.body;
+            const messageinfoArray = [];
+            const ucmVmMsgInfo = msgInfo.Message;
+            ucmVmMsgInfo.forEach((msgInfoObj) => {
+                const message = {};
+                let stringObj = {};
+                const numberObj = {};
+                stringObj.$ = msgInfoObj.Duration;
+                message.duration = stringObj;
+                numberObj.$ = Number(msgInfoObj.ArrivalTime);
+                message.time = numberObj;
+                stringObj = { $: '' };
+                stringObj.$ = msgInfoObj.MsgId;
+                message.messageId = stringObj;
+                if (msgInfoObj.Read === 'true') {
+                    message.read = {};
+                }
+                const callerIdObj = msgInfoObj.CallerId;
+                const callingParty = {};
+                stringObj = { $: '' };
+                stringObj.$ = callerIdObj.CallerName;
+                callingParty.name = stringObj;
+                stringObj = { $: '' };
+                stringObj.$ = this.userId;
+                callingParty.userId = stringObj;
+                stringObj = { $: '' };
+                stringObj.$ = callerIdObj.CallerNumber;
+                callingParty.address = stringObj;
+                message.callingPartyInfo = callingParty;
+                messageinfoArray.push(message);
+            });
+            const responseDetails = {
+                statusCode: response.statusCode,
+                data: {
+                    voicemailList: messageinfoArray,
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async getVoicemailContent(messageId) {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: 'getVoicemailContent',
+        };
+        try {
+            const response = (await this.getVoicemailContentUcm(messageId));
+            return response;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.info(`Voice mail content error is ${errorStatus}`, loggerContext);
+            return errorStatus;
+        }
+    }
+    async getVoicemailSummary() {
+        return Promise.resolve(null);
+    }
+    async getVoicemailContentUcm(messageId) {
+        return new Promise((resolve, reject) => {
+            const voicemailContentUrl = `${this.vgVoiceMessageURI}${VOICEMAILS}/${messageId}/${CONTENT}`;
+            const mercuryApi = `${this.webex.internal.services._serviceUrls.mercuryApi}`;
+            this.returnUcmPromise(voicemailContentUrl, mercuryApi)
+                .then((response) => {
+                if (response.statusCode === 200) {
+                    resolve(response);
+                }
+                else if (response.statusCode === 202) {
+                    this.sdkConnector.registerListener('event:ucm.voicemail_download_complete', async (event) => {
+                        const responseEvent = event;
+                        const voicemailContentUrl = `${this.vgVoiceMessageURI}${VOICEMAILS}/${responseEvent?.data?.messageId}/${CONTENT}`;
+                        const response = await this.returnUcmPromise(voicemailContentUrl, mercuryApi);
+                        if (response.statusCode === 200) {
+                            this.sdkConnector.unregisterListener('event:ucm.voicemail_download_complete');
+                            resolve(response);
+                        }
+                        else {
+                            this.sdkConnector.unregisterListener('event:ucm.voicemail_download_complete');
+                            reject(response);
+                        }
+                    });
+                }
+                else {
+                    reject(response);
+                }
+            })
+                .catch((err) => {
+                reject(err);
+            });
+        });
+    }
+    async returnUcmPromise(voicemailContentUrl, mercuryApi) {
+        const response = await this.webex.request({
+            uri: `${voicemailContentUrl}`,
+            method: HTTP_METHODS.GET,
+            headers: {
+                orgId: this.orgId,
+                deviceUrl: this.webex.internal.device.url,
+                mercuryHostname: mercuryApi,
+            },
+        });
+        const contentInfo = response?.body;
+        const respHeaders = response.headers;
+        const mediaType = respHeaders?.mediatype;
+        const mediaContent = contentInfo;
+        const responseDetails = {
+            statusCode: response.statusCode,
+            data: {
+                voicemailContent: {
+                    type: mediaType,
+                    content: mediaContent,
+                },
+            },
+            message: SUCCESS_MESSAGE,
+        };
+        return responseDetails;
+    }
+    async voicemailMarkAsRead(messageId) {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: 'voicemailMarkAsRead',
+        };
+        try {
+            const voicemailContentUrl = `${this.vgVoiceMessageURI}${VOICEMAILS}/${messageId}`;
+            const response = await this.webex.request({
+                uri: voicemailContentUrl,
+                method: HTTP_METHODS.PUT,
+                headers: {
+                    orgId: this.orgId,
+                },
+                body: {
+                    read: 'true',
+                },
+            });
+            const responseDetails = {
+                statusCode: response.statusCode,
+                data: {},
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async voicemailMarkAsUnread(messageId) {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: 'voicemailMarkAsUnread',
+        };
+        try {
+            const voicemailContentUrl = `${this.vgVoiceMessageURI}${VOICEMAILS}/${messageId}`;
+            const response = await this.webex.request({
+                uri: voicemailContentUrl,
+                method: HTTP_METHODS.PUT,
+                headers: {
+                    orgId: this.orgId,
+                },
+                body: {
+                    read: 'false',
+                },
+            });
+            const responseDetails = {
+                statusCode: response.statusCode,
+                data: {},
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async deleteVoicemail(messageId) {
+        const loggerContext = {
+            file: UCM_CONNECTOR_FILE,
+            method: 'deleteVoicemail',
+        };
+        try {
+            const voicemailContentUrl = `${this.vgVoiceMessageURI}${VOICEMAILS}/${messageId}`;
+            const response = await this.webex.request({
+                uri: voicemailContentUrl,
+                method: HTTP_METHODS.DELETE,
+                headers: {
+                    orgId: this.orgId,
+                },
+            });
+            const responseDetails = {
+                statusCode: response.statusCode,
+                data: {},
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async getVMTranscript(messageId) {
+        log.info(`Message Id: ${messageId}`, {});
+        return Promise.resolve(null);
+    }
+    resolveContact(callingPartyInfo) {
+        log.info(`Calling Party Info: ${callingPartyInfo}`, {});
+        return Promise.resolve(null);
+    }
+}

package/dist/module/Voicemail/Voicemail.js

@@ -0,0 +1,110 @@
+import SDKConnector from '../SDKConnector';
+import { CALLING_BACKEND } from '../common/types';
+import log from '../Logger';
+import { getCallingBackEnd } 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';
+export class Voicemail extends Eventing {
+    logger;
+    sdkConnector;
+    webex;
+    callingBackend;
+    backendConnector;
+    metricManager;
+    constructor(webex, logger) {
+        super();
+        this.logger = logger;
+        this.sdkConnector = SDKConnector;
+        if (!this.sdkConnector.getWebex()) {
+            SDKConnector.setWebex(webex);
+        }
+        this.webex = this.sdkConnector.getWebex();
+        this.metricManager = getMetricManager(this.webex, undefined);
+        this.callingBackend = getCallingBackEnd(this.webex);
+        this.initializeBackendConnector();
+        log.setLogger(logger.level, VOICEMAIL_FILE);
+    }
+    init() {
+        const response = this.backendConnector.init();
+        return response;
+    }
+    initializeBackendConnector() {
+        switch (this.callingBackend) {
+            case CALLING_BACKEND.WXC: {
+                this.backendConnector = new WxCallBackendConnector(this.webex, this.logger);
+                break;
+            }
+            case CALLING_BACKEND.BWRKS: {
+                this.backendConnector = new BroadworksBackendConnector(this.webex, this.logger);
+                break;
+            }
+            case CALLING_BACKEND.UCM: {
+                this.backendConnector = new UcmBackendConnector(this.webex, this.logger);
+                break;
+            }
+            default: {
+                throw new Error('Calling backend is not identified, exiting....');
+            }
+        }
+    }
+    submitMetric(response, metricAction, messageId) {
+        const { statusCode, data: { error: errorMessage }, } = response;
+        if (statusCode >= 200 && statusCode < 300) {
+            this.metricManager.submitVoicemailMetric(METRIC_EVENT.VOICEMAIL, metricAction, METRIC_TYPE.BEHAVIORAL, messageId);
+        }
+        else {
+            this.metricManager.submitVoicemailMetric(METRIC_EVENT.VOICEMAIL_ERROR, metricAction, METRIC_TYPE.BEHAVIORAL, messageId, errorMessage, statusCode);
+        }
+    }
+    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;
+    }
+    async getVoicemailContent(messageId) {
+        const response = await this.backendConnector.getVoicemailContent(messageId);
+        this.submitMetric(response, VOICEMAIL_ACTION.GET_VOICEMAIL_CONTENT, messageId);
+        return response;
+    }
+    async getVoicemailSummary() {
+        const response = await this.backendConnector.getVoicemailSummary();
+        if (response !== null) {
+            this.submitMetric(response, VOICEMAIL_ACTION.GET_VOICEMAIL_SUMMARY);
+        }
+        return response;
+    }
+    async voicemailMarkAsRead(messageId) {
+        const response = await this.backendConnector.voicemailMarkAsRead(messageId);
+        this.submitMetric(response, VOICEMAIL_ACTION.MARK_READ, messageId);
+        return response;
+    }
+    async voicemailMarkAsUnread(messageId) {
+        const response = await this.backendConnector.voicemailMarkAsUnread(messageId);
+        this.submitMetric(response, VOICEMAIL_ACTION.MARK_UNREAD, messageId);
+        return response;
+    }
+    async deleteVoicemail(messageId) {
+        const response = await this.backendConnector.deleteVoicemail(messageId);
+        this.submitMetric(response, VOICEMAIL_ACTION.DELETE, messageId);
+        return response;
+    }
+    async getVMTranscript(messageId) {
+        const response = await this.backendConnector.getVMTranscript(messageId);
+        if (response !== null) {
+            this.submitMetric(response, VOICEMAIL_ACTION.TRANSCRIPT, messageId);
+        }
+        return response;
+    }
+    resolveContact(callingPartyInfo) {
+        return this.backendConnector.resolveContact(callingPartyInfo);
+    }
+    getSDKConnector() {
+        return this.sdkConnector;
+    }
+}
+export const createVoicemailClient = (webex, logger) => new Voicemail(webex, logger);

package/dist/module/Voicemail/WxCallBackendConnector.js

@@ -0,0 +1,279 @@
+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 { 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';
+export class WxCallBackendConnector {
+    xsiEndpoint;
+    userId;
+    context;
+    sdkConnector;
+    xsiVoiceMessageURI;
+    webex;
+    constructor(webex, logger) {
+        this.sdkConnector = SDKConnector;
+        if (!this.sdkConnector.getWebex()) {
+            SDKConnector.setWebex(webex);
+        }
+        this.context = Math.random().toString(RADIX_RAND).substring(PREFIX);
+        this.webex = this.sdkConnector.getWebex();
+        this.userId = this.webex.internal.device.userId;
+        log.setLogger(logger.level, WEBEX_CALLING_CONNECTOR_FILE);
+    }
+    init() {
+        const loggerContext = {
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: 'init',
+        };
+        log.info('Initializing Webex calling voicemail connector', loggerContext);
+        const response = this.setXsiVoiceMessageURI();
+        return response;
+    }
+    getSDKConnector() {
+        return this.sdkConnector;
+    }
+    async setXsiVoiceMessageURI() {
+        let responseDetails;
+        const loggerContext = {
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: 'setXsiVoiceMessageURI',
+        };
+        this.xsiEndpoint = await getXsiActionEndpoint(this.webex, loggerContext, CALLING_BACKEND.WXC);
+        log.info(`XsiEndpoint is ${this.xsiEndpoint}`, loggerContext);
+        if (this.userId) {
+            this.xsiVoiceMessageURI = `${this.xsiEndpoint}/${BW_XSI_ENDPOINT_VERSION}/${USER}/${this.userId}/${VOICE_MESSAGING_MESSAGES}`;
+            responseDetails = {
+                statusCode: SUCCESS_STATUS_CODE,
+                data: {},
+                message: SUCCESS_MESSAGE,
+            };
+        }
+        return responseDetails;
+    }
+    async getVoicemailList(offset, offsetLimit, sort, refresh) {
+        const loggerContext = {
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: 'getVoicemailList',
+        };
+        log.info(`Offset: ${offset} Offset limit: ${offsetLimit} Sort type:${sort}`, loggerContext);
+        let messageinfo;
+        if (refresh) {
+            const urlXsi = `${this.xsiVoiceMessageURI}${JSON_FORMAT}`;
+            const sortParam = Object.values(SORT).includes(sort) ? sort : SORT.DEFAULT;
+            try {
+                const response = await this.webex.request({
+                    uri: `${urlXsi}`,
+                    method: HTTP_METHODS.GET,
+                });
+                const voicemailListResponse = response.body;
+                if (Object.keys(voicemailListResponse?.VoiceMessagingMessages?.messageInfoList).length === 0) {
+                    messageinfo = [];
+                }
+                else if (!Array.isArray(voicemailListResponse?.VoiceMessagingMessages?.messageInfoList?.messageInfo)) {
+                    messageinfo = Array(voicemailListResponse?.VoiceMessagingMessages?.messageInfoList?.messageInfo);
+                }
+                else {
+                    messageinfo = voicemailListResponse?.VoiceMessagingMessages?.messageInfoList
+                        ?.messageInfo;
+                    messageinfo = getSortedVoicemailList(messageinfo, sortParam);
+                }
+                storeVoicemailList(this.context, messageinfo);
+            }
+            catch (err) {
+                const errorInfo = err;
+                const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+                return errorStatus;
+            }
+        }
+        const { messages, moreVMAvailable } = fetchVoicemailList(this.context, offset, offsetLimit, loggerContext);
+        const responseDetails = {
+            statusCode: moreVMAvailable ? SUCCESS_STATUS_CODE : NO_VOICEMAIL_STATUS_CODE,
+            data: {
+                voicemailList: messages,
+            },
+            message: moreVMAvailable ? SUCCESS_MESSAGE : NO_VOICEMAIL_MSG,
+        };
+        return responseDetails;
+    }
+    async getVoicemailContent(messageId) {
+        const loggerContext = {
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: 'getVoicemailContent',
+        };
+        try {
+            const voicemailContentUrl = `${this.xsiEndpoint}${messageId}`;
+            const response = await this.webex.request({
+                uri: `${voicemailContentUrl}`,
+                method: HTTP_METHODS.GET,
+            });
+            const parser = new DOMParser();
+            const xmlDOM = parser.parseFromString(response[RAW_REQUEST].response, XML_TYPE);
+            const mediaDetails = xmlDOM.getElementsByTagName(MESSAGE_MEDIA_CONTENT)[0];
+            const mediaType = mediaDetails.childNodes[1]?.textContent;
+            const mediaContent = mediaDetails.childNodes[2]?.textContent;
+            log.info(`Media type is  ${mediaType}`, loggerContext);
+            const responseDetails = {
+                statusCode: response.statusCode,
+                data: {
+                    voicemailContent: {
+                        type: mediaType,
+                        content: mediaContent,
+                    },
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            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',
+        };
+        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,
+            });
+            const parser = new DOMParser();
+            const xmlDOM = parser.parseFromString(response[RAW_REQUEST].response, XML_TYPE);
+            const voicemailSummary = xmlDOM.getElementsByTagName(SUMMARY)[0];
+            const newMessages = voicemailSummary.getElementsByTagName(NEW_MESSAGES)[0];
+            const newUrgentMessages = voicemailSummary.getElementsByTagName(NEW_URGENT_MESSAGES)[0];
+            const oldMessages = voicemailSummary.getElementsByTagName(OLD_MESSAGES)[0];
+            const oldUrgentMessages = voicemailSummary.getElementsByTagName(OLD_URGENT_MESSAGES)[0];
+            const responseDetails = {
+                statusCode: Number(response.statusCode),
+                data: {
+                    voicemailSummary: {
+                        newMessages: newMessages ? Number(newMessages.textContent) : 0,
+                        newUrgentMessages: newUrgentMessages ? Number(newUrgentMessages.textContent) : 0,
+                        oldMessages: oldMessages ? Number(oldMessages.textContent) : 0,
+                        oldUrgentMessages: oldUrgentMessages ? Number(oldUrgentMessages.textContent) : 0,
+                    },
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            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',
+        };
+        try {
+            const voicemailContentUrl = `${this.xsiEndpoint}${messageId}/${MARK_AS_READ}`;
+            const response = await this.webex.request({
+                uri: voicemailContentUrl,
+                method: HTTP_METHODS.PUT,
+            });
+            const responseDetails = {
+                statusCode: response.statusCode,
+                data: {},
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async voicemailMarkAsUnread(messageId) {
+        const loggerContext = {
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: 'voicemailMarkAsUnread',
+        };
+        try {
+            const voicemailContentUrl = `${this.xsiEndpoint}${messageId}/${MARK_AS_UNREAD}`;
+            const response = await this.webex.request({
+                uri: voicemailContentUrl,
+                method: HTTP_METHODS.PUT,
+            });
+            const responseDetails = {
+                statusCode: response.statusCode,
+                data: {},
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async deleteVoicemail(messageId) {
+        const loggerContext = {
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: 'deleteVoicemail',
+        };
+        try {
+            const voicemailContentUrl = `${this.xsiEndpoint}${messageId}`;
+            const response = await this.webex.request({
+                uri: voicemailContentUrl,
+                method: HTTP_METHODS.DELETE,
+            });
+            const responseDetails = {
+                statusCode: response.statusCode,
+                data: {},
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async getVMTranscript(messageId) {
+        const loggerContext = {
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: 'getVMTranscript',
+        };
+        try {
+            const voicemailContentUrl = `${this.xsiEndpoint}${messageId}/${TRANSCRIPT}`;
+            const response = await this.webex.request({
+                uri: voicemailContentUrl,
+                method: HTTP_METHODS.GET,
+            });
+            const parser = new DOMParser();
+            const xmlDOM = parser.parseFromString(response[RAW_REQUEST].response, XML_TYPE);
+            const status = xmlDOM.getElementsByTagName(TRANSCRIPT_STATUS)[0];
+            const transcript = xmlDOM.getElementsByTagName(TRANSCRIPT_CONTENT)[0];
+            const responseDetails = {
+                statusCode: response.statusCode,
+                data: {
+                    voicemailTranscript: transcript?.textContent,
+                },
+                message: status.textContent,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    resolveContact(callingPartyInfo) {
+        return resolveContact(callingPartyInfo);
+    }
+}

package/dist/module/Voicemail/constants.js

@@ -0,0 +1,29 @@
+export const API_V1 = 'api/v1';
+export const VOICEMAIL_FILE = 'VoicemailClient';
+export const BROADWORKS_VOICEMAIL_FILE = 'BroadworksBackendConnector';
+export const CALLS = 'calls';
+export const BW_TOKEN_FETCH_ENDPOINT = '/idp/bwtoken/fetch';
+export const JSON_FORMAT = '?format=json';
+export const LIMIT = '&limit';
+export const MARK_AS_READ = 'MarkAsRead';
+export const MARK_AS_UNREAD = 'MarkAsUnread';
+export const MESSAGE_MEDIA_CONTENT = 'messageMediaContent';
+export const MESSAGE_SUMMARY = 'MessageSummary';
+export const NO_VOICEMAIL_MSG = 'No additional voicemails';
+export const NO_VOICEMAIL_STATUS_CODE = 204;
+export const OFFSET = '?offset';
+export const OFFSET_INDEX = 0;
+export const OFFSET_LIMIT = 100;
+export const PREFIX = 2;
+export const RADIX_RAND = 36;
+export const SORT_ORDER = '&sortOrder';
+export const TRANSCRIPT_STATUS = 'status';
+export const SUMMARY = 'summary';
+export const TRANSCRIPT_CONTENT = 'content';
+export const VMGATEWAY = 'vmgateway';
+export const VOICEMAILS = 'voicemails';
+export const VOICE_MESSAGING_MESSAGES = 'VoiceMessagingMessages';
+export const NEW_MESSAGES = 'newMessages';
+export const OLD_MESSAGES = 'oldMessages';
+export const NEW_URGENT_MESSAGES = 'newUrgentMessages';
+export const OLD_URGENT_MESSAGES = 'oldUrgentMessages';

package/dist/module/Voicemail/types.js

@@ -0,0 +1 @@
+export {};