@webex/calling 0.0.1-next.0

package/dist/module/Metrics/index.js

@@ -0,0 +1,232 @@
+import { METRIC_FILE, VERSION } from '../CallingClient/constants';
+import { METRIC_EVENT } from './types';
+import log from '../Logger';
+let metricManager;
+class MetricManager {
+    webex;
+    deviceInfo;
+    serviceIndicator;
+    constructor(webex, indicator) {
+        log.info('Initializing metric manager...', { file: METRIC_FILE });
+        this.webex = webex;
+        this.serviceIndicator = indicator;
+    }
+    setDeviceInfo(deviceInfo) {
+        this.deviceInfo = deviceInfo;
+    }
+    submitRegistrationMetric(name, metricAction, type, clientError) {
+        let data;
+        switch (name) {
+            case METRIC_EVENT.REGISTRATION: {
+                data = {
+                    tags: {
+                        action: metricAction,
+                        device_id: this.deviceInfo?.device?.deviceId,
+                        service_indicator: this.serviceIndicator,
+                    },
+                    fields: {
+                        device_url: this.deviceInfo?.device?.clientDeviceUri,
+                        mobius_url: this.deviceInfo?.device?.uri,
+                        calling_sdk_version: VERSION,
+                    },
+                    type,
+                };
+                break;
+            }
+            case METRIC_EVENT.REGISTRATION_ERROR: {
+                if (clientError) {
+                    data = {
+                        tags: {
+                            action: metricAction,
+                            device_id: this.deviceInfo?.device?.deviceId,
+                            service_indicator: this.serviceIndicator,
+                        },
+                        fields: {
+                            device_url: this.deviceInfo?.device?.clientDeviceUri,
+                            mobius_url: this.deviceInfo?.device?.uri,
+                            calling_sdk_version: VERSION,
+                            error: clientError.getError().message,
+                            error_type: clientError.getError().type,
+                        },
+                        type,
+                    };
+                }
+                break;
+            }
+            default:
+                log.warn('Invalid metric name received. Rejecting request to submit metric.', {
+                    file: METRIC_FILE,
+                    method: this.submitRegistrationMetric.name,
+                });
+                break;
+        }
+        if (data) {
+            this.webex.internal.metrics.submitClientMetrics(name, data);
+        }
+    }
+    submitCallMetric(name, metricAction, type, callId, correlationId, callError) {
+        let data;
+        switch (name) {
+            case METRIC_EVENT.CALL: {
+                data = {
+                    tags: {
+                        action: metricAction,
+                        device_id: this.deviceInfo?.device?.deviceId,
+                        service_indicator: this.serviceIndicator,
+                    },
+                    fields: {
+                        device_url: this.deviceInfo?.device?.clientDeviceUri,
+                        mobius_url: this.deviceInfo?.device?.uri,
+                        calling_sdk_version: VERSION,
+                        call_id: callId,
+                        correlation_id: correlationId,
+                    },
+                    type,
+                };
+                break;
+            }
+            case METRIC_EVENT.CALL_ERROR: {
+                if (callError) {
+                    data = {
+                        tags: {
+                            action: metricAction,
+                            device_id: this.deviceInfo?.device?.deviceId,
+                            service_indicator: this.serviceIndicator,
+                        },
+                        fields: {
+                            device_url: this.deviceInfo?.device?.clientDeviceUri,
+                            mobius_url: this.deviceInfo?.device?.uri,
+                            calling_sdk_version: VERSION,
+                            call_id: callId,
+                            correlation_id: correlationId,
+                            error: callError.getCallError().message,
+                            error_type: callError.getCallError().type,
+                        },
+                        type,
+                    };
+                }
+                break;
+            }
+            default:
+                log.warn('Invalid metric name received. Rejecting request to submit metric.', {
+                    file: METRIC_FILE,
+                    method: this.submitCallMetric.name,
+                });
+                break;
+        }
+        if (data) {
+            this.webex.internal.metrics.submitClientMetrics(name, data);
+        }
+    }
+    submitMediaMetric(name, metricAction, type, callId, correlationId, localSdp, remoteSdp, callError) {
+        let data;
+        switch (name) {
+            case METRIC_EVENT.MEDIA: {
+                data = {
+                    tags: {
+                        action: metricAction,
+                        device_id: this.deviceInfo?.device?.deviceId,
+                        service_indicator: this.serviceIndicator,
+                    },
+                    fields: {
+                        device_url: this.deviceInfo?.device?.clientDeviceUri,
+                        mobius_url: this.deviceInfo?.device?.uri,
+                        calling_sdk_version: VERSION,
+                        call_id: callId,
+                        correlation_id: correlationId,
+                        local_media_details: localSdp,
+                        remote_media_details: remoteSdp,
+                    },
+                    type,
+                };
+                break;
+            }
+            case METRIC_EVENT.MEDIA_ERROR: {
+                if (callError) {
+                    data = {
+                        tags: {
+                            action: metricAction,
+                            device_id: this.deviceInfo?.device?.deviceId,
+                            service_indicator: this.serviceIndicator,
+                        },
+                        fields: {
+                            device_url: this.deviceInfo?.device?.clientDeviceUri,
+                            mobius_url: this.deviceInfo?.device?.uri,
+                            calling_sdk_version: VERSION,
+                            call_id: callId,
+                            correlation_id: correlationId,
+                            local_media_details: localSdp,
+                            remote_media_details: remoteSdp,
+                            error: callError.getCallError().message,
+                            error_type: callError.getCallError().type,
+                        },
+                        type,
+                    };
+                }
+                break;
+            }
+            default:
+                log.warn('Invalid metric name received. Rejecting request to submit metric.', {
+                    file: METRIC_FILE,
+                    method: this.submitMediaMetric.name,
+                });
+                break;
+        }
+        if (data) {
+            this.webex.internal.metrics.submitClientMetrics(name, data);
+        }
+    }
+    submitVoicemailMetric(name, metricAction, type, messageId, voicemailError, statusCode) {
+        let data;
+        switch (name) {
+            case METRIC_EVENT.VOICEMAIL: {
+                data = {
+                    tags: {
+                        action: metricAction,
+                        device_id: this.deviceInfo?.device?.deviceId,
+                        message_id: messageId,
+                    },
+                    fields: {
+                        device_url: this.deviceInfo?.device?.clientDeviceUri,
+                        calling_sdk_version: VERSION,
+                    },
+                    type,
+                };
+                break;
+            }
+            case METRIC_EVENT.VOICEMAIL_ERROR: {
+                data = {
+                    tags: {
+                        action: metricAction,
+                        device_id: this.deviceInfo?.device?.deviceId,
+                        message_id: messageId,
+                        error: voicemailError,
+                        status_code: statusCode,
+                    },
+                    fields: {
+                        device_url: this.deviceInfo?.device?.clientDeviceUri,
+                        calling_sdk_version: VERSION,
+                    },
+                    type,
+                };
+                break;
+            }
+            default:
+                log.warn('Invalid metric name received. Rejecting request to submit metric.', {
+                    file: METRIC_FILE,
+                    method: this.submitVoicemailMetric.name,
+                });
+                break;
+        }
+        if (data) {
+            this.webex.internal.metrics.submitClientMetrics(name, data);
+        }
+    }
+}
+export const getMetricManager = (webex, indicator) => {
+    if (!metricManager) {
+        metricManager = new MetricManager(webex, indicator);
+    }
+    return metricManager;
+};
+export default getMetricManager;

package/dist/module/Metrics/types.js

@@ -0,0 +1,37 @@
+export var METRIC_TYPE;
+(function (METRIC_TYPE) {
+    METRIC_TYPE["OPERATIONAL"] = "operational";
+    METRIC_TYPE["BEHAVIORAL"] = "behavioral";
+})(METRIC_TYPE || (METRIC_TYPE = {}));
+export var METRIC_EVENT;
+(function (METRIC_EVENT) {
+    METRIC_EVENT["CALL"] = "web-calling-sdk-callcontrol";
+    METRIC_EVENT["CALL_ERROR"] = "web-calling-sdk-callcontrol-error";
+    METRIC_EVENT["MEDIA"] = "web-calling-sdk-media";
+    METRIC_EVENT["MEDIA_ERROR"] = "web-calling-sdk-media-error";
+    METRIC_EVENT["REGISTRATION"] = "web-calling-sdk-registration";
+    METRIC_EVENT["REGISTRATION_ERROR"] = "web-calling-sdk-registration-error";
+    METRIC_EVENT["VOICEMAIL"] = "web-calling-sdk-voicemail";
+    METRIC_EVENT["VOICEMAIL_ERROR"] = "web-calling-sdk-voicemail-error";
+})(METRIC_EVENT || (METRIC_EVENT = {}));
+export var REG_ACTION;
+(function (REG_ACTION) {
+    REG_ACTION["REGISTER"] = "register";
+    REG_ACTION["DEREGISTER"] = "deregister";
+    REG_ACTION["KEEPALIVE_FAILURE"] = "keepaliveFailure";
+})(REG_ACTION || (REG_ACTION = {}));
+export var TRANSFER_ACTION;
+(function (TRANSFER_ACTION) {
+    TRANSFER_ACTION["BLIND"] = "TRANSFER_BLIND";
+    TRANSFER_ACTION["CONSULT"] = "TRANSFER_CONSULT";
+})(TRANSFER_ACTION || (TRANSFER_ACTION = {}));
+export var VOICEMAIL_ACTION;
+(function (VOICEMAIL_ACTION) {
+    VOICEMAIL_ACTION["GET_VOICEMAILS"] = "get_voicemails";
+    VOICEMAIL_ACTION["GET_VOICEMAIL_CONTENT"] = "get_voicemail_content";
+    VOICEMAIL_ACTION["GET_VOICEMAIL_SUMMARY"] = "get_voicemail_summary";
+    VOICEMAIL_ACTION["MARK_READ"] = "mark_read";
+    VOICEMAIL_ACTION["MARK_UNREAD"] = "mark_unread";
+    VOICEMAIL_ACTION["DELETE"] = "delete";
+    VOICEMAIL_ACTION["TRANSCRIPT"] = "transcript";
+})(VOICEMAIL_ACTION || (VOICEMAIL_ACTION = {}));

package/dist/module/SDKConnector/index.js

@@ -0,0 +1,39 @@
+import { validateWebex } from './utils';
+let instance;
+let webex;
+class SDKConnector {
+    setWebex(webexInstance) {
+        if (instance) {
+            throw new Error('You cannot set the SDKConnector instance more than once');
+        }
+        const { error, success } = validateWebex(webexInstance);
+        if (error) {
+            throw error;
+        }
+        else if (success) {
+            webex = webexInstance;
+        }
+        else {
+            throw new Error('An unknown error occurred setting up the webex instance.');
+        }
+        instance = this;
+    }
+    get() {
+        return instance;
+    }
+    getWebex() {
+        return webex;
+    }
+    request(request) {
+        return instance.getWebex().request(request);
+    }
+    registerListener(event, cb) {
+        instance.getWebex().internal.mercury.on(event, (data) => {
+            cb(data);
+        });
+    }
+    unregisterListener(event) {
+        instance.getWebex().internal.mercury.off(event);
+    }
+}
+export default Object.freeze(new SDKConnector());

package/dist/module/SDKConnector/types.js

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

package/dist/module/SDKConnector/utils.js

@@ -0,0 +1,12 @@
+export const validateWebex = (webexInstance) => {
+    if (webexInstance.canAuthorize) {
+        if (webexInstance.ready) {
+            if (webexInstance.internal.mercury) {
+                return { error: undefined, success: true };
+            }
+            return { error: new Error('webex.internal.mercury is not available'), success: false };
+        }
+        return { error: new Error('webex.ready is not true'), success: false };
+    }
+    return { error: new Error('webex.canAuthorize is not true'), success: false };
+};

package/dist/module/Voicemail/BroadworksBackendConnector.js

@@ -0,0 +1,289 @@
+import { ERROR_CODE } from '../Errors/types';
+import SDKConnector from '../SDKConnector';
+import { BASE64, BEARER, BINARY, SUCCESS_MESSAGE, SUCCESS_STATUS_CODE, OBJECT, TOKEN, USER, XML_TYPE, BW_XSI_ENDPOINT_VERSION, } from '../common/constants';
+import { serviceErrorCodeHandler, getXsiActionEndpoint, getSortedVoicemailList, storeVoicemailList, fetchVoicemailList, } from '../common/Utils';
+import { CALLING_BACKEND, HTTP_METHODS, SORT, } from '../common/types';
+import log from '../Logger';
+import { BROADWORKS_VOICEMAIL_FILE, BW_TOKEN_FETCH_ENDPOINT, JSON_FORMAT, MARK_AS_READ, MARK_AS_UNREAD, MESSAGE_MEDIA_CONTENT, VOICE_MESSAGING_MESSAGES, NO_VOICEMAIL_MSG, NO_VOICEMAIL_STATUS_CODE, RADIX_RAND, PREFIX, } from './constants';
+export class BroadworksBackendConnector {
+    bwtoken;
+    userId;
+    xsiAccessToken;
+    xsiEndpoint;
+    context;
+    sdkConnector;
+    webex;
+    xsiVoiceMessageURI;
+    constructor(webex, logger) {
+        this.sdkConnector = SDKConnector;
+        if (!this.sdkConnector.getWebex()) {
+            SDKConnector.setWebex(webex);
+        }
+        this.webex = this.sdkConnector.getWebex();
+        this.context = Math.random().toString(RADIX_RAND).substring(PREFIX);
+        log.setLogger(logger.level, BROADWORKS_VOICEMAIL_FILE);
+    }
+    init() {
+        const loggerContext = {
+            file: BROADWORKS_VOICEMAIL_FILE,
+            method: 'init',
+        };
+        log.info('Initializing Broadworks voicemail connector', loggerContext);
+        const response = this.setXsiVoiceMessageURI();
+        return response;
+    }
+    getSDKConnector() {
+        return this.sdkConnector;
+    }
+    async getUserId() {
+        const loggerContext = {
+            file: BROADWORKS_VOICEMAIL_FILE,
+            method: 'getUserId',
+        };
+        try {
+            await this.getBwToken();
+            if (this.bwtoken && this.bwtoken.split('.').length > 1) {
+                const decodedString = Buffer.from(this.bwtoken.split('.')[1], BASE64).toString(BINARY);
+                this.userId = JSON.parse(decodedString).sub;
+                return this.userId;
+            }
+            const error = ERROR_CODE.UNAUTHORIZED;
+            throw new Error(`${error}`);
+        }
+        catch (err) {
+            const errorInfo = {
+                statusCode: err instanceof Error ? Number(err.message) : '',
+            };
+            return serviceErrorCodeHandler(errorInfo, loggerContext);
+        }
+    }
+    async getBwToken() {
+        try {
+            const bwTokenResponse = await this.webex.request({
+                uri: `${this.webex.internal.services._serviceUrls.broadworksIdpProxy}${BW_TOKEN_FETCH_ENDPOINT}`,
+                method: HTTP_METHODS.GET,
+            });
+            const response = bwTokenResponse.body;
+            this.bwtoken = response[TOKEN][BEARER];
+        }
+        catch (err) {
+            log.info(`Broadworks token exception ${err}`, {});
+        }
+    }
+    async setXsiVoiceMessageURI() {
+        const loggerContext = {
+            file: BROADWORKS_VOICEMAIL_FILE,
+            method: 'setXsiVoiceMessageURI',
+        };
+        let userIdResponse = await this.getUserId();
+        this.xsiEndpoint = await getXsiActionEndpoint(this.webex, loggerContext, CALLING_BACKEND.BWRKS);
+        this.xsiAccessToken = `${BEARER} ${this.bwtoken}`;
+        log.info(`XsiEndpoint is ${this.xsiEndpoint}`, loggerContext);
+        if (userIdResponse && typeof userIdResponse !== OBJECT) {
+            this.xsiVoiceMessageURI = `${this.xsiEndpoint}/${BW_XSI_ENDPOINT_VERSION}/${USER}/${userIdResponse}/${VOICE_MESSAGING_MESSAGES}`;
+            userIdResponse = {
+                statusCode: SUCCESS_STATUS_CODE,
+                data: {},
+                message: SUCCESS_MESSAGE,
+            };
+        }
+        return userIdResponse;
+    }
+    async getVoicemailList(offset, offsetLimit, sort, refresh) {
+        const loggerContext = {
+            file: BROADWORKS_VOICEMAIL_FILE,
+            method: 'getVoicemailList',
+        };
+        log.info(`Offset: ${offset} Offset limit: ${offsetLimit} Sort type:${sort}`, loggerContext);
+        const urlXsi = `${this.xsiVoiceMessageURI}${JSON_FORMAT}`;
+        let messageinfo;
+        const sortParam = Object.values(SORT).includes(sort) ? sort : SORT.DEFAULT;
+        if (refresh) {
+            try {
+                const response = await fetch(`${urlXsi}`, {
+                    method: HTTP_METHODS.GET,
+                    headers: {
+                        Authorization: this.xsiAccessToken,
+                    },
+                });
+                if (!response.ok) {
+                    throw new Error(`${response.status}`);
+                }
+                const voicemailListResponse = (await response.json());
+                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 = {
+                    statusCode: err instanceof Error ? Number(err.message) : '',
+                };
+                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: BROADWORKS_VOICEMAIL_FILE,
+            method: 'getVoicemailContent',
+        };
+        try {
+            const voicemailContentUrl = `${this.xsiEndpoint}${messageId}`;
+            const response = await fetch(`${voicemailContentUrl}`, {
+                method: 'GET',
+                headers: {
+                    Authorization: this.xsiAccessToken,
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`${response.status}`);
+            }
+            const xmlData = await response.text();
+            const parser = new DOMParser();
+            const xmlDOM = parser.parseFromString(xmlData, 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?.status,
+                data: {
+                    voicemailContent: {
+                        type: mediaType,
+                        content: mediaContent,
+                    },
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = {
+                statusCode: err instanceof Error ? Number(err.message) : '',
+            };
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async getVoicemailSummary() {
+        return Promise.resolve(null);
+    }
+    async voicemailMarkAsRead(messageId) {
+        const loggerContext = {
+            file: BROADWORKS_VOICEMAIL_FILE,
+            method: 'voicemailMarkAsRead',
+        };
+        try {
+            const voicemailContentUrl = `${this.xsiEndpoint}${messageId}/${MARK_AS_READ}`;
+            const response = await fetch(voicemailContentUrl, {
+                method: HTTP_METHODS.PUT,
+                headers: {
+                    Authorization: this.xsiAccessToken,
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`${response.status}`);
+            }
+            const responseDetails = {
+                statusCode: response.status,
+                data: {},
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = {
+                statusCode: err instanceof Error ? Number(err.message) : '',
+            };
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async voicemailMarkAsUnread(messageId) {
+        const loggerContext = {
+            file: BROADWORKS_VOICEMAIL_FILE,
+            method: 'voicemailMarkAsUnread',
+        };
+        try {
+            const voicemailContentUrl = `${this.xsiEndpoint}${messageId}/${MARK_AS_UNREAD}`;
+            const response = await fetch(voicemailContentUrl, {
+                method: HTTP_METHODS.PUT,
+                headers: {
+                    Authorization: this.xsiAccessToken,
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`${response.status}`);
+            }
+            const responseDetails = {
+                statusCode: response.status,
+                data: {},
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = {
+                statusCode: err instanceof Error ? Number(err.message) : '',
+            };
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async deleteVoicemail(messageId) {
+        const loggerContext = {
+            file: BROADWORKS_VOICEMAIL_FILE,
+            method: 'deleteVoicemail',
+        };
+        try {
+            const voicemailContentUrl = `${this.xsiEndpoint}${messageId}`;
+            const response = await fetch(voicemailContentUrl, {
+                method: HTTP_METHODS.DELETE,
+                headers: {
+                    Authorization: this.xsiAccessToken,
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`${response.status}`);
+            }
+            const responseDetails = {
+                statusCode: response.status,
+                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);
+    }
+}