@webex/calling 0.0.1-next.5 → 0.0.1-next.7

package/dist/module/CallHistory/CallHistory.js

@@ -4,7 +4,7 @@ import log from '../Logger';
 import { serviceErrorCodeHandler } from '../common/Utils';
 import { CALL_HISTORY_FILE, FROM_DATE, HISTORY, LIMIT, NUMBER_OF_DAYS } from './constants';
 import { STATUS_CODE, SUCCESS_MESSAGE, USER_SESSIONS } from '../common/constants';
-import { EVENT_KEYS, MOBIUS_EVENT_KEYS, } from '../Events/types';
+import { COMMON_EVENT_KEYS, MOBIUS_EVENT_KEYS, } from '../Events/types';
 import { Eventing } from '../Events/impl';
 export class CallHistory extends Eventing {
     sdkConnector;
@@ -76,7 +76,7 @@ export class CallHistory extends Eventing {
     registerSessionsListener() {
         this.sdkConnector.registerListener(MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_INCLUSIVE, async (event) => {
             if (event && event.data.userSessions.userSessions) {
-                this.emit(EVENT_KEYS.CALL_HISTORY_USER_SESSION_INFO, event);
+                this.emit(COMMON_EVENT_KEYS.CALL_HISTORY_USER_SESSION_INFO, event);
             }
         });
     }

package/dist/module/CallingClient/CallingClient.js

@@ -1,16 +1,14 @@
 import * as Media from '@webex/internal-media-core';
 import { Mutex } from 'async-mutex';
 import { filterMobiusUris, handleCallingClientErrors, validateServiceData } from '../common/Utils';
-import { ERROR_TYPE } from '../Errors/types';
 import { LOGGER } from '../Logger/types';
 import SDKConnector from '../SDKConnector';
 import { Eventing } from '../Events/impl';
-import { EVENT_KEYS, MOBIUS_EVENT_KEYS, SessionType, } from '../Events/types';
-import { MobiusStatus, CallDirection, ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, } from '../common/types';
+import { MOBIUS_EVENT_KEYS, SessionType, CALLING_CLIENT_EVENT_KEYS, } from '../Events/types';
+import { ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, } from '../common/types';
 import log from '../Logger';
 import { getCallManager } from './calling/callManager';
-import { CALLING_CLIENT_FILE, VALID_PHONE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, IP_ENDPOINT, SPARK_USER_AGENT, URL_ENDPOINT, NETWORK_FLAP_TIMEOUT, } from './constants';
-import { CallingClientError } from '../Errors';
+import { CALLING_CLIENT_FILE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, IP_ENDPOINT, SPARK_USER_AGENT, URL_ENDPOINT, NETWORK_FLAP_TIMEOUT, } from './constants';
 import Line from './line';
 import { LINE_EVENTS, LineStatus } from './line/types';
 import { METRIC_EVENT, REG_ACTION, METRIC_TYPE } from '../Metrics/types';
@@ -47,7 +45,6 @@ export class CallingClient extends Eventing {
         this.backupMobiusUris = [];
         this.registerSessionsListener();
         log.setLogger(logLevel, CALLING_CLIENT_FILE);
-        this.incomingCallListener();
         this.registerCallsClearedListener();
     }
     async init() {
@@ -55,16 +52,6 @@ export class CallingClient extends Eventing {
         await this.createLine();
         this.detectNetworkChange();
     }
-    incomingCallListener() {
-        const logContext = {
-            file: CALLING_CLIENT_FILE,
-            method: this.incomingCallListener.name,
-        };
-        log.log('Listening for incoming calls... ', logContext);
-        this.callManager.on(EVENT_KEYS.INCOMING_CALL, (callObj) => {
-            this.emit(EVENT_KEYS.INCOMING_CALL, callObj);
-        });
-    }
     async detectNetworkChange() {
         let retry = false;
         const line = Object.values(this.lineDict)[0];
@@ -113,7 +100,7 @@ export class CallingClient extends Eventing {
         catch (err) {
             handleCallingClientErrors(err, (clientError) => {
                 this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
-                this.emit(EVENT_KEYS.ERROR, clientError);
+                this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
             }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
             regionInfo.clientRegion = '';
             regionInfo.countryCode = '';
@@ -163,7 +150,7 @@ export class CallingClient extends Eventing {
             catch (err) {
                 handleCallingClientErrors(err, (clientError) => {
                     this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
-                    this.emit(EVENT_KEYS.ERROR, clientError);
+                    this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
                 }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
                 useDefault = true;
             }
@@ -184,7 +171,7 @@ export class CallingClient extends Eventing {
             method: this.registerCallsClearedListener.name,
         };
         log.log('Registering listener for all calls cleared event', logContext);
-        this.callManager.on(EVENT_KEYS.ALL_CALLS_CLEARED, this.callsClearedHandler);
+        this.callManager.on(CALLING_CLIENT_EVENT_KEYS.ALL_CALLS_CLEARED, this.callsClearedHandler);
     }
     callsClearedHandler = async () => {
         const { registration } = Object.values(this.lineDict)[0];
@@ -203,35 +190,6 @@ export class CallingClient extends Eventing {
     getLoggingLevel() {
         return log.getLogLevel();
     }
-    getCall = (correlationId) => {
-        return this.callManager.getCall(correlationId);
-    };
-    makeCall = (dest) => {
-        let call;
-        const { registration } = Object.values(this.lineDict)[0];
-        if (dest) {
-            const match = dest.address.match(VALID_PHONE);
-            if (match && match[0].length === dest.address.length) {
-                const sanitizedNumber = dest.address
-                    .replace(/[^[*+]\d#]/gi, '')
-                    .replace(/\s+/gi, '')
-                    .replace(/-/gi, '');
-                const formattedDest = {
-                    type: dest.type,
-                    address: `tel:${sanitizedNumber}`,
-                };
-                call = this.callManager.createCall(formattedDest, CallDirection.OUTBOUND, registration.getDeviceInfo().device?.deviceId);
-                log.log(`New call created, callId: ${call.getCallId()}`, {});
-            }
-            else {
-                log.warn('Invalid phone number detected', {});
-                const err = new CallingClientError('An invalid phone number was detected. Check the number and try again.', {}, ERROR_TYPE.CALL_ERROR, MobiusStatus.ACTIVE);
-                this.emit(EVENT_KEYS.ERROR, err);
-            }
-            return call;
-        }
-        return undefined;
-    };
     getSDKConnector() {
         return this.sdkConnector;
     }
@@ -249,7 +207,7 @@ export class CallingClient extends Eventing {
                         sessionArr.splice(i, 1);
                     }
                 }
-                this.emit(EVENT_KEYS.USER_SESSION_INFO, event);
+                this.emit(CALLING_CLIENT_EVENT_KEYS.USER_SESSION_INFO, event);
             }
         });
     }
@@ -260,6 +218,28 @@ export class CallingClient extends Eventing {
     getLines() {
         return this.lineDict;
     }
+    getActiveCalls() {
+        const activeCalls = {};
+        const calls = this.callManager.getActiveCalls();
+        Object.keys(calls).forEach((correlationId) => {
+            const call = calls[correlationId];
+            if (!activeCalls[call.lineId]) {
+                activeCalls[call.lineId] = [];
+            }
+            activeCalls[call.lineId].push(call);
+        });
+        return activeCalls;
+    }
+    getConnectedCall() {
+        let connectCall;
+        const calls = this.callManager.getActiveCalls();
+        Object.keys(calls).forEach((correlationId) => {
+            if (calls[correlationId].isConnected() && !calls[correlationId].isHeld()) {
+                connectCall = calls[correlationId];
+            }
+        });
+        return connectCall;
+    }
 }
 export const createClient = async (webex, config) => {
     const callingClientInstance = new CallingClient(webex, config);

package/dist/module/CallingClient/calling/call.js

@@ -8,7 +8,7 @@ import { createCallError } from '../../Errors/catalog/CallError';
 import { CALL_ENDPOINT_RESOURCE, CALL_FILE, CALL_HOLD_SERVICE, CALL_STATUS_RESOURCE, CALL_TRANSFER_SERVICE, CALLING_USER_AGENT, CALLS_ENDPOINT_RESOURCE, CISCO_DEVICE_URL, DEFAULT_LOCAL_CALL_ID, DEFAULT_SESSION_TIMER, DEVICES_ENDPOINT_RESOURCE, HOLD_ENDPOINT, INITIAL_SEQ_NUMBER, MEDIA_ENDPOINT_RESOURCE, RESUME_ENDPOINT, SPARK_USER_AGENT, SUPPLEMENTARY_SERVICES_TIMEOUT, TRANSFER_ENDPOINT, } from '../constants';
 import SDKConnector from '../../SDKConnector';
 import { Eventing } from '../../Events/impl';
-import { EVENT_KEYS, MEDIA_CONNECTION_EVENT_KEYS, MOBIUS_MIDCALL_STATE, SUPPLEMENTARY_SERVICES, } from '../../Events/types';
+import { CALL_EVENT_KEYS, MEDIA_CONNECTION_EVENT_KEYS, MOBIUS_MIDCALL_STATE, SUPPLEMENTARY_SERVICES, } from '../../Events/types';
 import { DisconnectCause, DisconnectCode, MidCallEventType, MobiusCallState, RoapScenario, TransferType, } from './types';
 import log from '../../Logger';
 import { createCallerId } from './CallerId';
@@ -23,6 +23,7 @@ export class Call extends Eventing {
     callId;
     correlationId;
     deviceId;
+    lineId;
     disconnectReason;
     callStateMachine;
     mediaStateMachine;
@@ -54,13 +55,14 @@ export class Call extends Eventing {
     isHeld() {
         return this.held;
     }
-    constructor(activeUrl, webex, destination, direction, deviceId, deleteCb, indicator) {
+    constructor(activeUrl, webex, destination, direction, deviceId, lineId, deleteCb, indicator) {
         super();
         this.destination = destination;
         this.direction = direction;
         this.sdkConnector = SDKConnector;
         this.deviceId = deviceId;
         this.serviceIndicator = indicator;
+        this.lineId = lineId;
         if (!this.sdkConnector.getWebex()) {
             SDKConnector.setWebex(webex);
         }
@@ -88,7 +90,7 @@ export class Call extends Eventing {
                 correlationId: this.correlationId,
                 callerId: this.callerInfo,
             };
-            this.emit(EVENT_KEYS.CALLER_ID, emitObj);
+            this.emit(CALL_EVENT_KEYS.CALLER_ID, emitObj);
         });
         this.remoteRoapMessage = null;
         this.disconnectReason = { code: DisconnectCode.NORMAL, cause: DisconnectCause.NORMAL };
@@ -581,7 +583,7 @@ export class Call extends Eventing {
             });
             const errData = e;
             handleCallErrors((error) => {
-                this.emit(EVENT_KEYS.CALL_ERROR, error);
+                this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, CALL_FILE);
@@ -606,7 +608,7 @@ export class Call extends Eventing {
                         method: this.handleCallHold.name,
                     });
                     const callError = createCallError('An error occurred while placing the call on hold. Wait a moment and try again.', errorContext, ERROR_TYPE.TIMEOUT, this.getCorrelationId(), ERROR_LAYER.CALL_CONTROL);
-                    this.emit(EVENT_KEYS.HOLD_ERROR, callError);
+                    this.emit(CALL_EVENT_KEYS.HOLD_ERROR, callError);
                     this.submitCallErrorMetric(callError);
                 }, SUPPLEMENTARY_SERVICES_TIMEOUT);
             }
@@ -618,7 +620,7 @@ export class Call extends Eventing {
             });
             const errData = e;
             handleCallErrors((error) => {
-                this.emit(EVENT_KEYS.HOLD_ERROR, error);
+                this.emit(CALL_EVENT_KEYS.HOLD_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, CALL_FILE);
@@ -643,7 +645,7 @@ export class Call extends Eventing {
                         method: this.handleCallResume.name,
                     });
                     const callError = createCallError('An error occurred while resuming the call. Wait a moment and try again.', errorContext, ERROR_TYPE.TIMEOUT, this.getCorrelationId(), ERROR_LAYER.CALL_CONTROL);
-                    this.emit(EVENT_KEYS.RESUME_ERROR, callError);
+                    this.emit(CALL_EVENT_KEYS.RESUME_ERROR, callError);
                     this.submitCallErrorMetric(callError);
                 }, SUPPLEMENTARY_SERVICES_TIMEOUT);
             }
@@ -655,7 +657,7 @@ export class Call extends Eventing {
             });
             const errData = e;
             handleCallErrors((error) => {
-                this.emit(EVENT_KEYS.RESUME_ERROR, error);
+                this.emit(CALL_EVENT_KEYS.RESUME_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, CALL_FILE);
@@ -687,7 +689,7 @@ export class Call extends Eventing {
             });
             this.startCallerIdResolution(data.callerId);
         }
-        this.emit(EVENT_KEYS.PROGRESS, this.correlationId);
+        this.emit(CALL_EVENT_KEYS.PROGRESS, this.correlationId);
     }
     handleIncomingRoapOfferRequest(context, event) {
         log.info(`handleIncomingRoapOfferRequest: ${this.getCorrelationId()}  `, {
@@ -739,7 +741,7 @@ export class Call extends Eventing {
             });
             const errData = err;
             handleCallErrors((error) => {
-                this.emit(EVENT_KEYS.CALL_ERROR, error);
+                this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallAlerting.name, CALL_FILE);
@@ -750,7 +752,7 @@ export class Call extends Eventing {
             file: CALL_FILE,
             method: this.handleIncomingCallConnect.name,
         });
-        this.emit(EVENT_KEYS.CONNECT, this.correlationId);
+        this.emit(CALL_EVENT_KEYS.CONNECT, this.correlationId);
         if (this.earlyMedia || this.mediaNegotiationCompleted) {
             this.mediaNegotiationCompleted = false;
             this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED' });
@@ -783,7 +785,7 @@ export class Call extends Eventing {
             });
             const errData = err;
             handleCallErrors((error) => {
-                this.emit(EVENT_KEYS.CALL_ERROR, error);
+                this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallConnect.name, CALL_FILE);
@@ -818,7 +820,7 @@ export class Call extends Eventing {
         }
         this.sendMediaStateMachineEvt({ type: 'E_ROAP_TEARDOWN' });
         this.sendCallStateMachineEvt({ type: 'E_CALL_CLEARED' });
-        this.emit(EVENT_KEYS.DISCONNECT, this.correlationId);
+        this.emit(CALL_EVENT_KEYS.DISCONNECT, this.correlationId);
     }
     async handleOutgoingCallDisconnect(event) {
         this.setDisconnectReason();
@@ -851,7 +853,7 @@ export class Call extends Eventing {
             file: CALL_FILE,
             method: this.handleCallEstablished.name,
         });
-        this.emit(EVENT_KEYS.ESTABLISHED, this.correlationId);
+        this.emit(CALL_EVENT_KEYS.ESTABLISHED, this.correlationId);
         this.earlyMedia = false;
         this.connected = true;
         if (this.sessionTimer) {
@@ -875,7 +877,7 @@ export class Call extends Eventing {
                     clearInterval(this.sessionTimer);
                 }
                 handleCallErrors((callError) => {
-                    this.emit(EVENT_KEYS.CALL_ERROR, callError);
+                    this.emit(CALL_EVENT_KEYS.CALL_ERROR, callError);
                     this.submitCallErrorMetric(callError);
                 }, ERROR_LAYER.CALL_CONTROL, (interval) => {
                     setTimeout(() => {
@@ -930,7 +932,7 @@ export class Call extends Eventing {
         return (error) => {
             switch (this.callStateMachine.state.value) {
                 case 'S_CALL_HOLD':
-                    this.emit(EVENT_KEYS.HOLD_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.HOLD_ERROR, error);
                     if (this.supplementaryServicesTimer) {
                         clearTimeout(this.supplementaryServicesTimer);
                         this.supplementaryServicesTimer = undefined;
@@ -939,12 +941,12 @@ export class Call extends Eventing {
                     this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED', data: errData });
                     return;
                 case 'S_CALL_RESUME':
-                    this.emit(EVENT_KEYS.RESUME_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.RESUME_ERROR, error);
                     this.submitCallErrorMetric(error);
                     this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED', data: errData });
                     return;
                 default:
-                    this.emit(EVENT_KEYS.CALL_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                     this.submitCallErrorMetric(error);
                     if (!this.connected) {
                         this.sendMediaStateMachineEvt({ type: 'E_ROAP_ERROR', data: errData });
@@ -1043,7 +1045,7 @@ export class Call extends Eventing {
                 });
                 const errData = err;
                 handleCallErrors((error) => {
-                    this.emit(EVENT_KEYS.CALL_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                     this.submitCallErrorMetric(error);
                 }, ERROR_LAYER.MEDIA, (interval) => undefined, this.getCorrelationId(), errData, this.handleRoapError.name, CALL_FILE);
             }
@@ -1382,7 +1384,7 @@ export class Call extends Eventing {
                 });
                 const errData = e;
                 handleCallErrors((error) => {
-                    this.emit(EVENT_KEYS.TRANSFER_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.TRANSFER_ERROR, error);
                     this.submitCallErrorMetric(error, TRANSFER_ACTION.BLIND);
                 }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.completeTransfer.name, CALL_FILE);
             }
@@ -1407,7 +1409,7 @@ export class Call extends Eventing {
                 });
                 const errData = e;
                 handleCallErrors((error) => {
-                    this.emit(EVENT_KEYS.TRANSFER_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.TRANSFER_ERROR, error);
                     this.submitCallErrorMetric(error, TRANSFER_ACTION.CONSULT);
                 }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.completeTransfer.name, CALL_FILE);
             }
@@ -1500,7 +1502,7 @@ export class Call extends Eventing {
     mediaTrackListener() {
         this.mediaConnection.on(Event.REMOTE_TRACK_ADDED, (e) => {
             if (e.type === MEDIA_CONNECTION_EVENT_KEYS.MEDIA_TYPE_AUDIO) {
-                this.emit(EVENT_KEYS.REMOTE_MEDIA, e.track);
+                this.emit(CALL_EVENT_KEYS.REMOTE_MEDIA, e.track);
             }
         });
     }
@@ -1558,7 +1560,7 @@ export class Call extends Eventing {
                             file: CALL_FILE,
                             method: 'handleMidCallEvent',
                         });
-                        this.emit(EVENT_KEYS.HELD, this.correlationId);
+                        this.emit(CALL_EVENT_KEYS.HELD, this.correlationId);
                         this.held = true;
                         if (this.supplementaryServicesTimer) {
                             clearTimeout(this.supplementaryServicesTimer);
@@ -1571,7 +1573,7 @@ export class Call extends Eventing {
                             file: CALL_FILE,
                             method: 'handleMidCallEvent',
                         });
-                        this.emit(EVENT_KEYS.RESUMED, this.correlationId);
+                        this.emit(CALL_EVENT_KEYS.RESUMED, this.correlationId);
                         this.held = false;
                         if (this.supplementaryServicesTimer) {
                             clearTimeout(this.supplementaryServicesTimer);
@@ -1646,4 +1648,4 @@ export class Call extends Eventing {
         return this.getCallStats();
     }
 }
-export const createCall = (activeUrl, webex, dest, dir, deviceId, deleteCb, indicator) => new Call(activeUrl, webex, dest, dir, deviceId, deleteCb, indicator);
+export const createCall = (activeUrl, webex, dest, dir, deviceId, lineId, deleteCb, indicator) => new Call(activeUrl, webex, dest, dir, deviceId, lineId, deleteCb, indicator);

package/dist/module/CallingClient/calling/callManager.js

@@ -1,5 +1,5 @@
 import { CALL_MANAGER_FILE } from '../constants';
-import { EVENT_KEYS } from '../../Events/types';
+import { CALLING_CLIENT_EVENT_KEYS, LINE_EVENT_KEYS } from '../../Events/types';
 import { Eventing } from '../../Events/impl';
 import SDKConnector from '../../SDKConnector';
 import { CallDirection } from '../../common/types';
@@ -13,6 +13,7 @@ export class CallManager extends Eventing {
     callCollection;
     activeMobiusUrl;
     serviceIndicator;
+    lineDict;
     constructor(webex, indicator) {
         super();
         this.sdkConnector = SDKConnector;
@@ -20,19 +21,20 @@ export class CallManager extends Eventing {
         if (!this.sdkConnector.getWebex()) {
             SDKConnector.setWebex(webex);
         }
+        this.lineDict = {};
         this.webex = this.sdkConnector.getWebex();
         this.callCollection = {};
         this.activeMobiusUrl = '';
         this.listenForWsEvents();
     }
-    createCall = (destination, direction, deviceId) => {
+    createCall = (destination, direction, deviceId, lineId) => {
         log.log('Creating call object', {});
-        const newCall = createCall(this.activeMobiusUrl, this.webex, destination, direction, deviceId, (correlationId) => {
+        const newCall = createCall(this.activeMobiusUrl, this.webex, destination, direction, deviceId, lineId, (correlationId) => {
             delete this.callCollection[correlationId];
             const activeCalls = Object.keys(this.getActiveCalls()).length;
             log.info(`DELETE:: Deleted corelationId: ${newCall.getCorrelationId()} from CallManager, Number of call records :- ${activeCalls}`, {});
             if (activeCalls === 0) {
-                this.emit(EVENT_KEYS.ALL_CALLS_CLEARED);
+                this.emit(CALLING_CLIENT_EVENT_KEYS.ALL_CALLS_CLEARED);
             }
         }, this.serviceIndicator);
         this.callCollection[newCall.getCorrelationId()] = newCall;
@@ -75,7 +77,8 @@ export class CallManager extends Eventing {
                 const newId = Object.keys(this.callCollection).find((id) => this.callCollection[id].getCallId() === callId);
                 let newCall;
                 if (!newId) {
-                    newCall = this.createCall({}, CallDirection.INBOUND, mobiusEvent.data.deviceId);
+                    const lineId = this.getLineId(mobiusEvent.data.deviceId);
+                    newCall = this.createCall({}, CallDirection.INBOUND, mobiusEvent.data.deviceId, lineId);
                     log.log(`New incoming call created with correlationId from Call Setup message: ${newCall.getCorrelationId()}`, {
                         file: CALL_MANAGER_FILE,
                         method: 'dequeueWsEvents',
@@ -103,7 +106,7 @@ export class CallManager extends Eventing {
                     });
                     newCall.startCallerIdResolution(mobiusEvent.data.callerId);
                 }
-                this.emit(EVENT_KEYS.INCOMING_CALL, newCall);
+                this.emit(LINE_EVENT_KEYS.INCOMING_CALL, newCall);
                 newCall.sendCallStateMachineEvt({ type: 'E_RECV_CALL_SETUP', data: mobiusEvent.data });
                 break;
             }
@@ -135,7 +138,8 @@ export class CallManager extends Eventing {
                         activeCall = this.getCall(newId);
                     }
                     else {
-                        activeCall = this.createCall({}, CallDirection.INBOUND, mobiusEvent.data.deviceId);
+                        const lineId = this.getLineId(mobiusEvent.data.deviceId);
+                        activeCall = this.createCall({}, CallDirection.INBOUND, mobiusEvent.data.deviceId, lineId);
                         log.log(`New incoming call created with correlationId from ROAP Message: ${activeCall.getCorrelationId()}`, {
                             file: CALL_MANAGER_FILE,
                             method: 'dequeueWsEvents',
@@ -265,6 +269,12 @@ export class CallManager extends Eventing {
     getActiveCalls = () => {
         return this.callCollection;
     };
+    updateLine(deviceId, line) {
+        this.lineDict[deviceId] = line;
+    }
+    getLineId(deviceId) {
+        return this.lineDict[deviceId].lineId;
+    }
 }
 export const getCallManager = (webex, indicator) => {
     if (!callManager) {

package/dist/module/CallingClient/line/index.js

@@ -1,12 +1,16 @@
 import { v4 as uuid } from 'uuid';
-import { MobiusStatus, ServiceIndicator } from '../../common/types';
-import { LINE_EVENTS } from './types';
-import { LINE_FILE } from '../constants';
+import { CallDirection, MobiusStatus, ServiceIndicator, } from '../../common/types';
+import { LINE_EVENTS, LineStatus } from './types';
+import { LINE_FILE, VALID_PHONE } from '../constants';
 import log from '../../Logger';
 import { createRegistration } from '../registration';
 import { Eventing } from '../../Events/impl';
+import { LineError } from '../../Errors/catalog/LineError';
 import { validateServiceData } from '../../common';
 import SDKConnector from '../../SDKConnector';
+import { LINE_EVENT_KEYS } from '../../Events/types';
+import { getCallManager } from '../calling/callManager';
+import { ERROR_TYPE } from '../../Errors/types';
 export default class Line extends Eventing {
     #webex;
     #mutex;
@@ -29,6 +33,7 @@ export default class Line extends Eventing {
     rehomingIntervalMax;
     voicePortalNumber;
     voicePortalExtension;
+    callManager;
     #primaryMobiusUris;
     #backupMobiusUris;
     constructor(userId, clientDeviceUri, status, mutex, primaryMobiusUris, backupMobiusUris, logLevel, serviceDataConfig, phoneNumber, extension, voicemail) {
@@ -52,6 +57,8 @@ export default class Line extends Eventing {
         this.registration = createRegistration(this.#webex, serviceData, this.#mutex, this.lineEmitter, logLevel);
         this.registration.setStatus(MobiusStatus.DEFAULT);
         log.setLogger(logLevel, LINE_FILE);
+        this.callManager = getCallManager(this.#webex, serviceData.indicator);
+        this.incomingCallListener();
     }
     async register() {
         await this.#mutex.runExclusive(async () => {
@@ -60,6 +67,9 @@ export default class Line extends Eventing {
             this.registration.setMobiusServers(this.#primaryMobiusUris, this.#backupMobiusUris);
             await this.registration.triggerRegistration();
         });
+        if (this.mobiusDeviceId) {
+            this.callManager.updateLine(this.mobiusDeviceId, this);
+        }
     }
     async deregister() {
         this.registration.deregister();
@@ -107,4 +117,42 @@ export default class Line extends Eventing {
     }
     getRegistrationStatus = () => this.registration.getStatus();
     getDeviceId = () => this.registration.getDeviceInfo().device?.deviceId;
+    makeCall = (dest) => {
+        let call;
+        if (dest) {
+            const match = dest.address.match(VALID_PHONE);
+            if (match && match[0].length === dest.address.length) {
+                const sanitizedNumber = dest.address
+                    .replace(/[^[*+]\d#]/gi, '')
+                    .replace(/\s+/gi, '')
+                    .replace(/-/gi, '');
+                const formattedDest = {
+                    type: dest.type,
+                    address: `tel:${sanitizedNumber}`,
+                };
+                call = this.callManager.createCall(formattedDest, CallDirection.OUTBOUND, this.registration.getDeviceInfo().device?.deviceId, this.lineId);
+                log.log(`New call created, callId: ${call.getCallId()}`, {});
+            }
+            else {
+                log.warn('Invalid phone number detected', {});
+                const err = new LineError('An invalid phone number was detected. Check the number and try again.', {}, ERROR_TYPE.CALL_ERROR, LineStatus.ACTIVE);
+                this.emit(LINE_EVENTS.ERROR, err);
+            }
+            return call;
+        }
+        return undefined;
+    };
+    incomingCallListener() {
+        const logContext = {
+            file: LINE_FILE,
+            method: this.incomingCallListener.name,
+        };
+        log.log('Listening for incoming calls... ', logContext);
+        this.callManager.on(LINE_EVENT_KEYS.INCOMING_CALL, (callObj) => {
+            this.emit(LINE_EVENTS.INCOMING_CALL, callObj);
+        });
+    }
+    getCall = (correlationId) => {
+        return this.callManager.getCall(correlationId);
+    };
 }

package/dist/module/CallingClient/line/types.js

@@ -11,4 +11,5 @@ export var LINE_EVENTS;
     LINE_EVENTS["RECONNECTING"] = "reconnecting";
     LINE_EVENTS["REGISTERED"] = "registered";
     LINE_EVENTS["UNREGISTERED"] = "unregistered";
+    LINE_EVENTS["INCOMING_CALL"] = "line:incoming_call";
 })(LINE_EVENTS || (LINE_EVENTS = {}));

package/dist/module/Events/types.js

@@ -1,26 +1,35 @@
-export var EVENT_KEYS;
-(function (EVENT_KEYS) {
-    EVENT_KEYS["ALERTING"] = "call:alerting";
-    EVENT_KEYS["CALL_ERROR"] = "call:error";
-    EVENT_KEYS["CALLER_ID"] = "call:caller_id";
-    EVENT_KEYS["CONNECT"] = "call:connect";
-    EVENT_KEYS["DISCONNECT"] = "call:disconnect";
-    EVENT_KEYS["ERROR"] = "callingClient:error";
-    EVENT_KEYS["ESTABLISHED"] = "call:established";
-    EVENT_KEYS["HELD"] = "call:held";
-    EVENT_KEYS["HOLD_ERROR"] = "call:hold_error";
-    EVENT_KEYS["INCOMING_CALL"] = "callingClient:incoming_call";
-    EVENT_KEYS["OUTGOING_CALL"] = "callingClient:outgoing_call";
-    EVENT_KEYS["PROGRESS"] = "call:progress";
-    EVENT_KEYS["REMOTE_MEDIA"] = "call:remote_media";
-    EVENT_KEYS["RESUME_ERROR"] = "call:resume_error";
-    EVENT_KEYS["RESUMED"] = "call:resumed";
-    EVENT_KEYS["TRANSFER_ERROR"] = "call:transfer_error";
-    EVENT_KEYS["USER_SESSION_INFO"] = "callingClient:user_recent_sessions";
-    EVENT_KEYS["CB_VOICEMESSAGE_CONTENT_GET"] = "call_back_voicemail_content_get";
-    EVENT_KEYS["CALL_HISTORY_USER_SESSION_INFO"] = "callHistory:user_recent_sessions";
-    EVENT_KEYS["ALL_CALLS_CLEARED"] = "callingClient:all_calls_cleared";
-})(EVENT_KEYS || (EVENT_KEYS = {}));
+export var COMMON_EVENT_KEYS;
+(function (COMMON_EVENT_KEYS) {
+    COMMON_EVENT_KEYS["CB_VOICEMESSAGE_CONTENT_GET"] = "call_back_voicemail_content_get";
+    COMMON_EVENT_KEYS["CALL_HISTORY_USER_SESSION_INFO"] = "callHistory:user_recent_sessions";
+})(COMMON_EVENT_KEYS || (COMMON_EVENT_KEYS = {}));
+export var LINE_EVENT_KEYS;
+(function (LINE_EVENT_KEYS) {
+    LINE_EVENT_KEYS["INCOMING_CALL"] = "incoming_call";
+})(LINE_EVENT_KEYS || (LINE_EVENT_KEYS = {}));
+export var CALLING_CLIENT_EVENT_KEYS;
+(function (CALLING_CLIENT_EVENT_KEYS) {
+    CALLING_CLIENT_EVENT_KEYS["ERROR"] = "callingClient:error";
+    CALLING_CLIENT_EVENT_KEYS["OUTGOING_CALL"] = "callingClient:outgoing_call";
+    CALLING_CLIENT_EVENT_KEYS["USER_SESSION_INFO"] = "callingClient:user_recent_sessions";
+    CALLING_CLIENT_EVENT_KEYS["ALL_CALLS_CLEARED"] = "callingClient:all_calls_cleared";
+})(CALLING_CLIENT_EVENT_KEYS || (CALLING_CLIENT_EVENT_KEYS = {}));
+export var CALL_EVENT_KEYS;
+(function (CALL_EVENT_KEYS) {
+    CALL_EVENT_KEYS["ALERTING"] = "alerting";
+    CALL_EVENT_KEYS["CALL_ERROR"] = "call_error";
+    CALL_EVENT_KEYS["CALLER_ID"] = "caller_id";
+    CALL_EVENT_KEYS["CONNECT"] = "connect";
+    CALL_EVENT_KEYS["DISCONNECT"] = "disconnect";
+    CALL_EVENT_KEYS["ESTABLISHED"] = "established";
+    CALL_EVENT_KEYS["HELD"] = "held";
+    CALL_EVENT_KEYS["HOLD_ERROR"] = "hold_error";
+    CALL_EVENT_KEYS["PROGRESS"] = "progress";
+    CALL_EVENT_KEYS["REMOTE_MEDIA"] = "remote_media";
+    CALL_EVENT_KEYS["RESUME_ERROR"] = "resume_error";
+    CALL_EVENT_KEYS["RESUMED"] = "resumed";
+    CALL_EVENT_KEYS["TRANSFER_ERROR"] = "transfer_error";
+})(CALL_EVENT_KEYS || (CALL_EVENT_KEYS = {}));
 export var SUPPLEMENTARY_SERVICES;
 (function (SUPPLEMENTARY_SERVICES) {
     SUPPLEMENTARY_SERVICES["HOLD"] = "hold";

package/dist/module/Voicemail/BroadworksBackendConnector.js

@@ -273,7 +273,9 @@ export class BroadworksBackendConnector {
             return responseDetails;
         }
         catch (err) {
-            const errorInfo = err;
+            const errorInfo = {
+                statusCode: err instanceof Error ? Number(err.message) : '',
+            };
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
             return errorStatus;
         }

package/dist/module/Voicemail/UcmBackendConnector.js

@@ -1,7 +1,7 @@
 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 { SUCCESS_MESSAGE, USERS, CONTENT, UCM_CONNECTOR_FILE, FAILURE_MESSAGE, } from '../common/constants';
 import log from '../Logger';
 import { API_V1, LIMIT, OFFSET, SORT_ORDER, VMGATEWAY, VOICEMAILS } from './constants';
 export class UcmBackendConnector {
@@ -85,7 +85,7 @@ export class UcmBackendConnector {
                 messageinfoArray.push(message);
             });
             const responseDetails = {
-                statusCode: response.statusCode,
+                statusCode: Number(response.statusCode),
                 data: {
                     voicemailList: messageinfoArray,
                 },
@@ -163,10 +163,11 @@ export class UcmBackendConnector {
         });
         const contentInfo = response?.body;
         const respHeaders = response.headers;
+        const statusCode = response.statusCode;
         const mediaType = respHeaders?.mediatype;
         const mediaContent = contentInfo;
         const responseDetails = {
-            statusCode: response.statusCode,
+            statusCode: Number(statusCode),
             data: {
                 voicemailContent: {
                     type: mediaType,
@@ -175,6 +176,9 @@ export class UcmBackendConnector {
             },
             message: SUCCESS_MESSAGE,
         };
+        if (statusCode !== 200 && statusCode !== 202) {
+            responseDetails.message = FAILURE_MESSAGE;
+        }
         return responseDetails;
     }
     async voicemailMarkAsRead(messageId) {
@@ -195,7 +199,7 @@ export class UcmBackendConnector {
                 },
             });
             const responseDetails = {
-                statusCode: response.statusCode,
+                statusCode: Number(response.statusCode),
                 data: {},
                 message: SUCCESS_MESSAGE,
             };
@@ -225,7 +229,7 @@ export class UcmBackendConnector {
                 },
             });
             const responseDetails = {
-                statusCode: response.statusCode,
+                statusCode: Number(response.statusCode),
                 data: {},
                 message: SUCCESS_MESSAGE,
             };
@@ -252,7 +256,7 @@ export class UcmBackendConnector {
                 },
             });
             const responseDetails = {
-                statusCode: response.statusCode,
+                statusCode: Number(response.statusCode),
                 data: {},
                 message: SUCCESS_MESSAGE,
             };

package/dist/module/Voicemail/WxCallBackendConnector.js

@@ -114,7 +114,7 @@ export class WxCallBackendConnector {
             const mediaContent = mediaDetails.childNodes[2]?.textContent;
             log.info(`Media type is  ${mediaType}`, loggerContext);
             const responseDetails = {
-                statusCode: response.statusCode,
+                statusCode: Number(response.statusCode),
                 data: {
                     voicemailContent: {
                         type: mediaType,
@@ -183,7 +183,7 @@ export class WxCallBackendConnector {
                 method: HTTP_METHODS.PUT,
             });
             const responseDetails = {
-                statusCode: response.statusCode,
+                statusCode: Number(response.statusCode),
                 data: {},
                 message: SUCCESS_MESSAGE,
             };
@@ -207,7 +207,7 @@ export class WxCallBackendConnector {
                 method: HTTP_METHODS.PUT,
             });
             const responseDetails = {
-                statusCode: response.statusCode,
+                statusCode: Number(response.statusCode),
                 data: {},
                 message: SUCCESS_MESSAGE,
             };
@@ -231,7 +231,7 @@ export class WxCallBackendConnector {
                 method: HTTP_METHODS.DELETE,
             });
             const responseDetails = {
-                statusCode: response.statusCode,
+                statusCode: Number(response.statusCode),
                 data: {},
                 message: SUCCESS_MESSAGE,
             };
@@ -259,7 +259,7 @@ export class WxCallBackendConnector {
             const status = xmlDOM.getElementsByTagName(TRANSCRIPT_STATUS)[0];
             const transcript = xmlDOM.getElementsByTagName(TRANSCRIPT_CONTENT)[0];
             const responseDetails = {
-                statusCode: response.statusCode,
+                statusCode: Number(response.statusCode),
                 data: {
                     voicemailTranscript: transcript?.textContent,
                 },

package/dist/module/Voicemail/voicemailFixture.js

@@ -1,3 +1,4 @@
+import { FAILURE_MESSAGE, UNPROCESSABLE_CONTENT_CODE } from '../common/constants';
 export const bwToken = 'bwtoken';
 export const broadworksTokenType = {
     body: {
@@ -259,6 +260,38 @@ const MOCK_VOICEMAIL_FIFTH_MESSAGE = {
         $: `${braodworksUserMessageInfo}/aa237e9e-211a-4a0a-bb58-2a931eca061d`,
     },
 };
+export const getEmptyVoicemailListJsonBWRKS = {
+    statusCode: 200,
+    VoiceMessagingMessages: {
+        messageInfoList: {},
+    },
+};
+export const getInvalidVoicemailListJsonBWRKS = {
+    statusCode: 200,
+    VoiceMessagingMessages: {
+        messageInfoList: {
+            messageInfo: {},
+        },
+    },
+};
+export const getEmptyVoicemailListJsonWxC = {
+    statusCode: 200,
+    body: {
+        VoiceMessagingMessages: {
+            messageInfoList: {},
+        },
+    },
+};
+export const getInvalidVoicemailListJsonWxC = {
+    statusCode: 200,
+    body: {
+        VoiceMessagingMessages: {
+            messageInfoList: {
+                messageInfo: {},
+            },
+        },
+    },
+};
 export const getVoicemailListJsonBWRKS = {
     statusCode: 200,
     VoiceMessagingMessages: {
@@ -381,6 +414,20 @@ export const mockUCMVoicemailBody = {
         items: [MOCK_UCM_VOICEMAIL_FIRST_MESSAGE],
     },
 };
+export const mockVoicemailContentResponse = {
+    statusCode: 200,
+    headers: {
+        mediatype: 'audio/wav',
+    },
+    body: voicemailContent,
+};
+export const voicemailEventProcessingPayload = {
+    data: {
+        messageId: '1234567890',
+        eventType: 'processing',
+        status: 'waiting',
+    },
+};
 export const getVoiceMailListJsonUCM = {
     statusCode: 200,
     body: {
@@ -407,6 +454,20 @@ export const getDescVoiceMailListJsonUCM = {
         },
     },
 };
+export const responseDetails422 = {
+    data: { error: '422 Exception has occurred' },
+    message: FAILURE_MESSAGE,
+    statusCode: UNPROCESSABLE_CONTENT_CODE,
+};
+export const responseDetails204 = {
+    data: { error: '204 Exception has occurred' },
+    message: FAILURE_MESSAGE,
+    statusCode: 204,
+};
+export const resolveContactArgs = {
+    name: { $: 'test' },
+    address: { $: 'test address' },
+};
 export const mockVoicemailTranscriptResponse = {
     body: '<?xml version="1.0" encoding="UTF-8"?>\n<VoiceMessageTranscript xmlns="http://schema.broadsoft.com/xsi"><status>READY</status><content lang="EN">Hi, uh, testing, voice mail script, so dropping this message to be able to fetch it later.</content></VoiceMessageTranscript>',
     statusCode: 200,

package/dist/module/common/Utils.js

@@ -79,7 +79,7 @@ export function emitFinalFailure(emitterCb, loggerContext) {
 }
 export async function handleRegistrationErrors(err, emitterCb, loggerContext, restoreRegCb) {
     const lineError = createLineError('', {}, ERROR_TYPE.DEFAULT, LineStatus.INACTIVE);
-    const errorCode = err.statusCode;
+    const errorCode = Number(err.statusCode);
     let finalError = false;
     log.warn(`Status code: -> ${errorCode}`, loggerContext);
     switch (errorCode) {
@@ -111,7 +111,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
                 emitterCb(lineError, finalError);
                 return finalError;
             }
-            const code = errorBody.errorCode;
+            const code = Number(errorBody.errorCode);
             log.warn(`Error code found : ${code}`, loggerContext);
             switch (code) {
                 case DEVICE_ERROR_CODE.DEVICE_LIMIT_EXCEEDED: {
@@ -164,7 +164,7 @@ export async function handleRegistrationErrors(err, emitterCb, loggerContext, re
 }
 export async function handleCallingClientErrors(err, emitterCb, loggerContext) {
     const clientError = createClientError('', {}, ERROR_TYPE.DEFAULT, MobiusStatus.DEFAULT);
-    const errorCode = err.statusCode;
+    const errorCode = Number(err.statusCode);
     const finalError = false;
     log.warn(`Status code: -> ${errorCode}`, loggerContext);
     switch (errorCode) {
@@ -188,7 +188,7 @@ export async function handleCallErrors(emitterCb, errorLayer, retryCb, correlati
         method: caller,
     };
     const callError = createCallError('', loggerContext, ERROR_TYPE.DEFAULT, '', errorLayer);
-    const errorCode = err.statusCode;
+    const errorCode = Number(err.statusCode);
     log.warn(`Status code: ->${errorCode}`, loggerContext);
     switch (errorCode) {
         case ERROR_CODE.UNAUTHORIZED: {
@@ -209,12 +209,12 @@ export async function handleCallErrors(emitterCb, errorLayer, retryCb, correlati
                 return;
             }
             if (err.headers && 'retry-after' in err.headers && retryCb) {
-                const retryInterval = err.headers['retry-after'];
+                const retryInterval = Number(err.headers['retry-after']);
                 log.warn(`Retry Interval received: ${retryInterval}`, loggerContext);
                 retryCb(retryInterval);
                 return;
             }
-            const code = errorBody.errorCode;
+            const code = Number(errorBody.errorCode);
             let message;
             switch (code) {
                 case CALL_ERROR_CODE.INVALID_STATUS_UPDATE: {
@@ -286,7 +286,7 @@ export async function handleCallErrors(emitterCb, errorLayer, retryCb, correlati
     }
 }
 export async function serviceErrorCodeHandler(err, loggerContext) {
-    const errorCode = err.statusCode;
+    const errorCode = Number(err.statusCode);
     const failureMessage = 'FAILURE';
     switch (errorCode) {
         case ERROR_CODE.BAD_REQUEST: {
@@ -378,11 +378,11 @@ export async function serviceErrorCodeHandler(err, loggerContext) {
             return errorDetails;
         }
         default: {
-            log.warn(`422 Exception has occurred`, loggerContext);
+            log.warn(`${errorCode || 422} Exception has occurred`, loggerContext);
             const errorDetails = {
-                statusCode: 422,
+                statusCode: errorCode || 422,
                 data: {
-                    error: '422 Exception has occurred',
+                    error: `${errorCode || 422} Exception has occurred`,
                 },
                 message: failureMessage,
             };

package/dist/module/common/constants.js

@@ -16,6 +16,7 @@ export const SETTINGS = 'settings';
 export const STATUS_CODE = 'statusCode';
 export const SUCCESS_MESSAGE = 'SUCCESS';
 export const SUCCESS_STATUS_CODE = 200;
+export const UNPROCESSABLE_CONTENT_CODE = 422;
 export const TIME = 'time';
 export const TOKEN = 'token';
 export const TRANSCRIPT = 'transcript';

package/package.json

@@ -129,5 +129,5 @@
     "staticpath": "docs",
     "noprompt": true
   },
-  "version": "0.0.1-next.5"
+  "version": "0.0.1-next.7"
 }