@wazo/sdk 0.37.1 → 0.37.2

package/esm/simple/room/Participant.js

@@ -128,7 +128,7 @@ const isMobile = () => typeof navigator !== 'undefined' && navigator.product ===
 
 const methods = ['head', 'get', 'post', 'put', 'delete'];
 
-const logger$a = IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
+const logger$b = IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
 
 // Use a function here to be able to mock it in tests
 const realFetch = () => {
@@ -267,7 +267,7 @@ class ApiRequester {
     };
 
     if (this.refreshTokenPromise) {
-      logger$a.info('A token is already refreshing, waiting ...', { url });
+      logger$b.info('A token is already refreshing, waiting ...', { url });
       await this.refreshTokenPromise;
     }
 
@@ -287,7 +287,7 @@ class ApiRequester {
         return promise.then(async (err        ) => {
           // Check if the token is still valid
           if (firstCall && this._checkTokenExpired(response, err)) {
-            logger$a.warn('token expired', { error: err.reason });
+            logger$b.warn('token expired', { error: err.reason });
             // Replay the call after refreshing the token
             return this._replayWithNewToken(err, path, method, body, headers, parse);
           }
@@ -297,7 +297,7 @@ class ApiRequester {
             : exceptionClass.fromResponse(err, response.status);
 
           if (this.shouldLogErrors) {
-            logger$a.error('API error', error);
+            logger$b.error('API error', error);
           }
 
           throw error;
@@ -307,7 +307,7 @@ class ApiRequester {
       return newParse(response, isJson);
     }).catch(error => {
       if (this.shouldLogErrors) {
-        logger$a.error('Fetch failed', { url, options, message: error.message, stack: error.stack });
+        logger$b.error('Fetch failed', { url, options, message: error.message, stack: error.stack });
       }
 
       throw error;
@@ -335,13 +335,13 @@ class ApiRequester {
   ) {
     const isTokenNotFound = this._isTokenNotFound(err);
     let newPath = path;
-    logger$a.info('refreshing token', { inProgress: !!this.refreshTokenPromise });
+    logger$b.info('refreshing token', { inProgress: !!this.refreshTokenPromise });
 
     this.refreshTokenPromise = this.refreshTokenPromise || this.refreshTokenCallback();
 
     return this.refreshTokenPromise.then(() => {
       this.refreshTokenPromise = null;
-      logger$a.info('token refreshed', { isTokenNotFound });
+      logger$b.info('token refreshed', { isTokenNotFound });
       if (isTokenNotFound) {
         const pathParts = path.split('/');
         pathParts.pop();
@@ -619,7 +619,13 @@ class IssueReporter {
   }
 
   _isLevelAbove(level1        , level2        ) {
-    return LOG_LEVELS.indexOf(level1) > LOG_LEVELS.indexOf(level2);
+    const index1 = LOG_LEVELS.indexOf(level1);
+    const index2 = LOG_LEVELS.indexOf(level2);
+    if (index1 === -1 || index2 === -1) {
+      return false;
+    }
+
+    return index1 > index2;
   }
 
   _makeCategory(category        ) {
@@ -3726,11 +3732,414 @@ class IndirectTransfer {
 }
 
 //      
+
+class CallApi {
+  static async fetchCallLogs(offset        , limit        )                  {
+    return getApiClient().callLogd.listCallLogs(offset, limit);
+  }
+
+  static async fetchDistinctCallLogs(offset        , limit        , distinct         = 'peer_exten')                  {
+    return getApiClient().callLogd.listDistinctCallLogs(offset, limit, distinct);
+  }
+
+  static async fetchActiveCalls()                  {
+    return getApiClient().calld.listCalls();
+  }
+
+  static async fetchCallLogsFromDate(from      , number        )                     {
+    return getApiClient().callLogd.listCallLogsFromDate(from, number);
+  }
+
+  static async search(query        , limit        )                     {
+    return getApiClient().callLogd.search(query, limit);
+  }
+
+  static async searchBy(field        , value        , limit        )                     {
+    return getApiClient().callLogd.searchBy(field, value, limit);
+  }
+
+  static async fetchSIP(session         , line       )               {
+    const lineToUse = line || session.primaryLine();
+    return getApiClient().confd.getUserLineSip(session.uuid, lineToUse ? lineToUse.id : null);
+  }
+
+  static async cancelCall(callSession             )                {
+    return getApiClient().calld.cancelCall(callSession.callId);
+  }
+
+  static async makeCall(callFromLine      , extension        , isMobile          = false,
+    callbackAllLines          = false)                 {
+    const lineId = callFromLine ? callFromLine.id : null;
+
+    const response = await getApiClient().calld.makeCall(extension, isMobile, lineId, callbackAllLines);
+    return Call.parse(response);
+  }
+
+  static async relocateCall(callId        , line        , contactIdentifier         )                      {
+    return getApiClient().calld.relocateCall(callId, 'line', line, contactIdentifier);
+  }
+
+  static async hold(callId        )                {
+    return getApiClient().calld.hold(callId);
+  }
+
+  static async resume(callId        )                {
+    return getApiClient().calld.resume(callId);
+  }
+
+  static async mute(callId        )                {
+    return getApiClient().calld.mute(callId);
+  }
+
+  static async sendDTMF(callId        , digits        )                {
+    return getApiClient().calld.sendDTMF(callId, digits);
+  }
+
+  static async unmute(callId        )                {
+    return getApiClient().calld.unmute(callId);
+  }
+
+  static async transferCall(callId        , number        , flow        )                    {
+    return getApiClient().calld.transferCall(callId, number, flow);
+  }
+
+  static async cancelCallTransfer(transferId        )                    {
+    return getApiClient().calld.cancelCallTransfer(transferId);
+  }
+
+  static async confirmCallTransfer(transferId        )                    {
+    return getApiClient().calld.confirmCallTransfer(transferId);
+  }
+}
+
+//      
+
+const TRANSFER_FLOW_ATTENDED = 'attended';
 const TRANSFER_FLOW_BLIND = 'blind';
 
 // const MINIMUM_WAZO_ENGINE_VERSION_FOR_CTI_HOLD = '20.11';
 
-IssueReporter$1 ? IssueReporter$1.loggerFor('cti-phone') : console;
+const logger$a = IssueReporter$1 ? IssueReporter$1.loggerFor('cti-phone') : console;
+
+class CTIPhone extends Emitter                  {
+                   
+
+                    
+
+                            
+
+                     
+
+  constructor(session         , isMobile          = false, callbackAllLines          = false) {
+    super();
+    logger$a.info('CTI Phone created');
+    this.session = session;
+    this.isMobile = isMobile;
+    this.callbackAllLines = callbackAllLines;
+  }
+
+  getOptions()                        {
+    // @FIXME: temporarily disabling this option
+    // const hold = this.session.hasEngineVersionGte(MINIMUM_WAZO_ENGINE_VERSION_FOR_CTI_HOLD);
+
+    return {
+      accept: false,
+      decline: true,
+      mute: true,
+      hold: false,
+      transfer: true,
+      sendKey: true,
+      addParticipant: false,
+      record: true,
+      merge: false,
+    };
+  }
+
+  hasAnActiveCall() {
+    return !!this.currentCall;
+  }
+
+  callCount() {
+    return this.currentCall ? 1 : 0;
+  }
+
+  isWebRTC() {
+    return false;
+  }
+
+  getUserAgent() {
+    return 'cti-phone';
+  }
+
+  startHeartbeat() {
+  }
+
+  setOnHeartbeatTimeout() {
+  }
+
+  setOnHeartbeatCallback() {
+  }
+
+  stopHeartbeat() {
+  }
+
+  bindClientEvents() {
+  }
+
+  onConnect() {
+  }
+
+  onDisconnect() {
+  }
+
+  async makeCall(number        , line      )                        {
+    logger$a.info('make CTI call', { number });
+
+    if (!number) {
+      return null;
+    }
+    try {
+      this.currentCall = await CallApi.makeCall(line, number, this.isMobile, this.callbackAllLines);
+    } catch (_) {
+      // We have to deal with error like `User has no mobile phone number` error in the UI.
+    }
+    if (!this.currentCall) {
+      return null;
+    }
+    const callSession = CallSession.parseCall(this.currentCall);
+    this.eventEmitter.emit('onCallOutgoing', callSession);
+
+    return callSession;
+  }
+
+  accept(callSession             )                         {
+    if (!callSession) {
+      return Promise.resolve(null);
+    }
+    logger$a.info('accept CTI call', { callId: callSession.getId(), number: callSession.number });
+
+    if (!this.currentCall) {
+      this.currentCall = callSession.call;
+    }
+
+    return Promise.resolve(callSession.getId());
+  }
+
+  endCurrentCall(callSession             )       {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('end current CTI call', { callId: callSession.getId(), number: callSession.number });
+
+    this.currentCall = undefined;
+    this.eventEmitter.emit('onCallEnded', callSession);
+  }
+
+  async hangup(callSession             )                   {
+    if (!callSession) {
+      return Promise.resolve(false);
+    }
+    logger$a.info('hangup CTI call', { callId: callSession.getId(), number: callSession.number });
+
+    try {
+      await CallApi.cancelCall(callSession);
+      if (this.currentCall && callSession.callId === this.currentCall.id) {
+        this.endCurrentCall(callSession);
+      }
+
+      this.eventEmitter.emit('onCallEnded', callSession);
+      return true;
+    } catch (e) {
+      logger$a.error('hangup CTI call, error', e);
+
+      this.eventEmitter.emit('onCallFailed', callSession);
+      return false;
+    }
+  }
+
+  ignore() {}
+
+  async reject(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('reject CTI call', { callId: callSession.getId(), number: callSession.number });
+
+    await CallApi.cancelCall(callSession);
+    this.eventEmitter.emit('onCallEnded', callSession);
+  }
+
+  async transfer(callSession             , number        )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('transfer CTI call', { callId: callSession.getId(), number: callSession.number, to: number });
+
+    await CallApi.transferCall(callSession.callId, number, TRANSFER_FLOW_BLIND);
+  }
+
+  indirectTransfer() {}
+
+  async initiateCTIIndirectTransfer(callSession             , number        )               {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('indirect CTI transfer', { callId: callSession.getId(), number: callSession.number, to: number });
+
+    return CallApi.transferCall(callSession.callId, number, TRANSFER_FLOW_ATTENDED);
+  }
+
+  async cancelCTIIndirectTransfer(transferId        )               {
+    logger$a.info('cancel CTI transfer', { transferId });
+
+    return CallApi.cancelCallTransfer(transferId);
+  }
+
+  async confirmCTIIndirectTransfer(transferId        )               {
+    logger$a.info('confirm CTI transfer', { transferId });
+
+    return CallApi.confirmCallTransfer(transferId);
+  }
+
+  sendKey(callSession             , digits        ) {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('send CTI key', { callId: callSession.getId(), number: callSession.number, digits });
+
+    return CallApi.sendDTMF(callSession.callId, digits);
+  }
+
+  onConnectionMade() {
+    logger$a.info('on CTI connection made');
+
+    this.eventEmitter.emit('onCallAccepted');
+  }
+
+  async close() {
+    logger$a.info('CTI close');
+
+    return Promise.resolve();
+  }
+
+  async hold(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('CTI hold', { callId: callSession.getId(), number: callSession.number });
+
+    return CallApi.hold(callSession.callId);
+  }
+
+  async resume(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('CTI resume', { callId: callSession.getId(), number: callSession.number });
+
+    return CallApi.resume(callSession.callId);
+  }
+
+  async mute(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('CTI mute', { callId: callSession.getId(), number: callSession.number });
+
+    return CallApi.mute(callSession.callId);
+  }
+
+  async unmute(callSession             )                {
+    if (!callSession) {
+      return;
+    }
+    logger$a.info('CTI unmute', { callId: callSession.getId(), number: callSession.number });
+
+    return CallApi.unmute(callSession.callId);
+  }
+
+  putOnSpeaker() {}
+
+  putOffSpeaker() {}
+
+  turnCameraOff() {}
+
+  turnCameraOn() {}
+
+  changeAudioInputDevice() {}
+
+  changeVideoInputDevice() {}
+
+  changeAudioDevice() {}
+
+  changeRingDevice() {}
+
+  changeAudioVolume() {}
+
+  changeRingVolume() {}
+
+  hasVideo()          {
+    return false;
+  }
+
+  getLocalStreamForCall()               {
+    return null;
+  }
+
+  getRemoteStreamForCall()               {
+    return null;
+  }
+
+  getLocalVideoStream()               {
+    return null;
+  }
+
+  setActiveSipSession() {}
+
+  isRegistered()          {
+    return true;
+  }
+
+  hasIncomingCallSession()          {
+    return true;
+  }
+
+  hasActiveRemoteVideoStream()          {
+    return false;
+  }
+
+  getCurrentCallSession()               {
+    return this.currentCall ? CallSession.parseCall(this.currentCall) : null;
+  }
+
+  enableRinging() {}
+
+  sendMessage() {}
+
+  disableRinging() {}
+
+  getLocalStream() {
+    return null;
+  }
+
+  getRemoteStream() {
+    return null;
+  }
+
+  getRemoteVideoStream() {
+    return null;
+  }
+
+  getRemoteAudioStream() {
+    return null;
+  }
+
+  hasLocalVideo() {
+    return false;
+  }
+
+  useLocalVideoElement() {}
+}
 
 /*       */
 
@@ -6534,6 +6943,9 @@ class WebRTCClient extends Emitter {
     if (!this._isWeb()) {
       options.sessionDescriptionHandlerModifiers = [holdModifier];
     }
+    options.sessionDescriptionHandlerOptions = {
+      constraints: options.constraints,
+    };
 
     // Send re-INVITE
     return session.invite(options);
@@ -6573,6 +6985,9 @@ class WebRTCClient extends Emitter {
       // (eg: holdModifier)
       options.sessionDescriptionHandlerModifiers = [];
     }
+    options.sessionDescriptionHandlerOptions = {
+      constraints: options.constraints,
+    };
 
     // Send re-INVITE
     return session.invite(options);
@@ -11150,6 +11565,7 @@ const Wazo = {
     ServerError,
     Call,
     CallLog,
+    CTIPhone,
     Recording,
     ChatMessage,
     ChatRoom,
@@ -11165,6 +11581,7 @@ const Wazo = {
     CallSession,
     IndirectTransfer,
     SwitchboardCall,
+    WebRTCPhone,
   },
 
   // Api