@wazo/sdk 0.37.41 → 0.38.0

package/src/api-client.js

@@ -53,6 +53,7 @@ export default class ApiClient {
 
   refreshToken: ?string;
   onRefreshToken: ?Function;
+  onRefreshTokenError: ?Function;
   refreshExpiration: ?number;
   refreshBackend: ?string;
   refreshTenantId: ?string;
@@ -105,23 +106,31 @@ export default class ApiClient {
       return null;
     }
 
-    const session = await this.auth.refreshToken(
-      this.refreshToken,
-      this.refreshBackend,
-      this.refreshExpiration,
-      this.isMobile,
-      this.refreshTenantId,
-    );
+    try {
+      const session = await this.auth.refreshToken(
+        this.refreshToken,
+        this.refreshBackend,
+        this.refreshExpiration,
+        this.isMobile,
+        this.refreshTenantId,
+      );
 
-    logger.info('token refreshed', { token: session.token });
+      logger.info('token refreshed', { token: session.token });
 
-    if (this.onRefreshToken) {
-      this.onRefreshToken(session.token, session);
-    }
+      if (this.onRefreshToken) {
+        this.onRefreshToken(session.token, session);
+      }
+
+      this.setToken(session.token);
 
-    this.setToken(session.token);
+      return session.token;
+    } catch (error) {
+      logger.error('token refresh, error', error);
 
-    return session.token;
+      if (this.onRefreshTokenError) {
+        this.onRefreshTokenError(error);
+      }
+    }
   }
 
   setToken(token: string) {
@@ -144,6 +153,10 @@ export default class ApiClient {
     this.onRefreshToken = onRefreshToken;
   }
 
+  setOnRefreshTokenError(callback: Function) {
+    this.onRefreshTokenError = callback;
+  }
+
   setRefreshExpiration(refreshExpiration: number) {
     this.refreshExpiration = refreshExpiration;
   }

package/src/service/IssueReporter.js

@@ -330,13 +330,9 @@ class IssueReporter {
 
       setTimeout(() => {
         if (isArray) {
-          payload = payload.map(message => {
-            message._retry = retry + 1;
-            return message;
-          });
-        } else {
-          // $FlowFixMe
-          payload._retry = retry + 1;
+          payload = payload.map(message => this._writeRetryCount(message, retry + 1));
+        } else if (payload && typeof payload === 'object') {
+          payload = this._writeRetryCount(payload, retry + 1);
         }
 
         this._sendDebugToGrafana(payload, retry + 1);
@@ -344,6 +340,15 @@ class IssueReporter {
     });
   }
 
+  _writeRetryCount(message: string | Object, count: number): string | Object {
+    if (message && typeof message === 'object') {
+      // $FlowFixMe
+      message._retry = count;
+    }
+
+    return message;
+  }
+
   _isLevelAbove(level1: string, level2: string) {
     const index1 = LOG_LEVELS.indexOf(level1);
     const index2 = LOG_LEVELS.indexOf(level2);

package/src/service/__tests__/IssueReporter.test.js

@@ -100,4 +100,10 @@ describe('IssueReporter', () => {
     expect(IssueReporter.removeSlashes('\"')).toBe("'");
     expect(IssueReporter.removeSlashes('\\\"')).toBe("'");
   });
+
+  it('Add retry count', () => {
+    expect(IssueReporter._writeRetryCount('', 1)).toBe('');
+    expect(IssueReporter._writeRetryCount('{}', 1)).toBe('{}');
+    expect(IssueReporter._writeRetryCount({}, 1)).toEqual({ _retry: 1 });
+  });
 });

package/src/service/getApiClient.js

@@ -10,7 +10,9 @@ global.wazoClients = global.wazoClients || {};
 global.wazoClientId = global.wazoClientId || {};
 global.wazoClientToken = global.wazoClientToken || {};
 global.wazoRefreshToken = global.wazoRefreshToken || {};
+global.wazoRefreshTenantId = global.wazoRefreshTenantId || {};
 global.wazoOnRefreshToken = global.wazoOnRefreshToken || {};
+global.wazoOnRefreshTokenError = global.wazoOnRefreshTokenError || {};
 global.wazoRefreshExpiration = global.wazoRefreshExpiration || {};
 global.wazoRefreshBackend = global.wazoRefreshBackend || {};
 global.wazoIsMobile = global.wazoIsMobile || {};
@@ -32,10 +34,18 @@ export const setRefreshToken = (newRefreshToken: ?string, forServer: ?string = n
   global.wazoRefreshToken[forServer] = newRefreshToken;
 };
 
+export const setRefreshTenantId = (refreshTenantId: ?string, forServer: ?string = null) => {
+  global.wazoRefreshTenantId[forServer] = refreshTenantId;
+};
+
 export const setOnRefreshToken = (onRefreshToken: Function, forServer: ?string = null) => {
   global.wazoOnRefreshToken[forServer] = onRefreshToken;
 };
 
+export const setOnRefreshTokenError = (callback: Function, forServer: ?string = null) => {
+  global.wazoOnRefreshTokenError[forServer] = callback;
+};
+
 export const setRefreshExpiration = (refreshExpiration: number, forServer: ?string = null) => {
   global.wazoRefreshExpiration[forServer] = refreshExpiration;
 };
@@ -62,12 +72,20 @@ const fillClient = (apiClient: WazoApiClient) => {
 
   apiClient.setRefreshToken(global.wazoRefreshToken[server] || global.wazoRefreshToken[null] || apiClient.refreshToken);
 
+  apiClient.setRefreshTenantId(
+    global.wazoRefreshTenantId[server] || global.wazoRefreshTenantId[null] || apiClient.refreshTenantId,
+  );
+
   apiClient.setFetchOptions(global.wazoFetchOptions[server] || global.wazoFetchOptions[null] || apiClient.fetchOptions);
 
   apiClient.setOnRefreshToken(
     global.wazoOnRefreshToken[server] || global.wazoOnRefreshToken[null] || apiClient.onRefreshToken,
   );
 
+  apiClient.setOnRefreshTokenError(
+    global.wazoOnRefreshTokenError[server] || global.wazoOnRefreshTokenError[null] || apiClient.onRefreshTokenError,
+  );
+
   apiClient.setRefreshExpiration(
     global.wazoRefreshExpiration[server] || global.wazoRefreshExpiration[null] || apiClient.refreshExpiration,
   );
@@ -81,7 +99,7 @@ const fillClient = (apiClient: WazoApiClient) => {
   return apiClient;
 };
 
-export default (forServer: ?string): WazoApiClient => {
+export default (forServer: ?string = null): WazoApiClient => {
   const server: string = forServer || global.wazoCurrentServer || '';
   if (server in global.wazoClients) {
     return fillClient(global.wazoClients[server]);

package/src/simple/Auth.js

@@ -10,6 +10,8 @@ import getApiClient, {
   setRefreshExpiration,
   setOnRefreshToken,
   setFetchOptions,
+  setRefreshTenantId,
+  setOnRefreshTokenError,
 } from '../service/getApiClient';
 import IssueReporter from '../service/IssueReporter';
 
@@ -29,6 +31,7 @@ class Auth {
   host: ?string;
   session: ?Session;
   onRefreshTokenCallback: ?Function;
+  onRefreshTokenCallbackError: ?Function;
   authenticated: boolean;
   mobile: boolean;
   BACKEND_WAZO: string;
@@ -66,6 +69,14 @@ class Auth {
         this.onRefreshTokenCallback(token, session);
       }
     });
+
+    setOnRefreshTokenError(error => {
+      logger.error('on refresh token error', error);
+
+      if (this.onRefreshTokenCallbackError) {
+        this.onRefreshTokenCallbackError(error);
+      }
+    });
   }
 
   setFetchOptions(options: Object) {
@@ -154,6 +165,10 @@ class Auth {
     this.onRefreshTokenCallback = callback;
   }
 
+  setOnRefreshTokenError(callback: Function) {
+    this.onRefreshTokenCallbackError = callback;
+  }
+
   checkAuthorizations(session: Session, authorizationName: ?string) {
     if (!authorizationName) {
       return;
@@ -186,6 +201,12 @@ class Auth {
     setRefreshToken(refreshToken);
   }
 
+  setRefreshTenantId(refreshTenantId: string) {
+    setRefreshTenantId(refreshTenantId);
+
+    getApiClient().setRefreshTenantId(refreshTenantId);
+  }
+
   forceRefreshToken() {
     getApiClient().forceRefreshToken();
   }

package/src/simple/Softphone.js

@@ -0,0 +1,148 @@
+// @flow
+/* eslint-disable no-unused-vars */
+/* global window, document */
+const SDK_CLICK_TO_CALL = 'sdk/CLICK_TO_CALL';
+const SDK_ON_CALL_MADE = 'sdk/SDK_ON_CALL_MADE';
+const SDK_CALL_ENDED = 'sdk/ON_CALL_ENDED';
+const SDK_CALL_INCOMING = 'sdk/SDK_CALL_INCOMING';
+const SDK_AUTHENTICATED = 'sdk/SDK_AUTHENTICATED';
+
+class Softphone {
+  url: string = 'https://softphone.wazo.io';
+  width: number = 500;
+  height: number = 600;
+  displayed: boolean = false;
+  iframe: ?Object = null;
+
+  onLinkEnabled(link: Object) {}
+
+  onCallMade(call: Object) {}
+  onCallIncoming(call: Object) {}
+  onCallEnded(call: Object, card: Object, direction: string, fromExtension: string) {}
+  onAuthenticated(session: Object) {}
+
+  init(url: string, width: number, height: number) {
+    if (url) {
+      this.url = url;
+    }
+    if (width) {
+      this.width = width;
+    }
+    if (height) {
+      this.height = height;
+    }
+
+    window.addEventListener('message', this._onMessage.bind(this), false);
+
+    this._createIframe();
+  }
+
+  parseLinks() {
+    const links = this._getLinks();
+
+    links.forEach(link => {
+      link.setAttribute('data-wazo-parsed', true);
+      link.addEventListener('click', this._onLinkClick.bind(this));
+      this.onLinkEnabled(link);
+    });
+  }
+
+  makeCall(number: string) {
+    this.displaySoftphone();
+
+    if (this.iframe) {
+      this.iframe.contentWindow.postMessage({ type: SDK_CLICK_TO_CALL, number }, '*');
+    }
+  }
+
+  toggleSoftphoneDisplay() {
+    if (this.displayed) {
+      this.hideSoftphone();
+    } else {
+      this.displaySoftphone();
+    }
+
+    this.displayed = !this.displayed;
+  }
+
+  displaySoftphone() {
+    if (!this.iframe) {
+      this._createIframe();
+    }
+
+    if (this.iframe) {
+      this.iframe.style.display = 'block';
+    }
+  }
+
+  hideSoftphone() {
+    if (this.iframe) {
+      this.iframe.style.display = 'none';
+    }
+  }
+
+  _createIframe() {
+    this.iframe = document.createElement('iframe');
+    // $FlowFixMe
+    this.iframe.width = this.width;
+    // $FlowFixMe
+    this.iframe.height = this.height;
+    // $FlowFixMe
+    this.iframe.allow = 'camera *; microphone *; autoplay *; display-capture *';
+    this.iframe.style.position = 'absolute';
+    this.iframe.style.left = '0';
+    this.iframe.style.bottom = '0';
+    this.iframe.style.border = '1px solid #aaa';
+    this.iframe.src = this.url;
+    this.iframe.style.display = 'none';
+    this.iframe.id = 'wazo-softphone';
+
+    // $FlowFixMe
+    document.body.appendChild(this.iframe);
+  }
+
+  _getLinks() {
+    return [].slice.call(document.querySelectorAll('a:not([data-wazo-parsed])'), 0)
+      .filter(link => link.href.indexOf('tel:') === 0 || link.href.indexOf('callto:') === 0);
+  }
+
+  _onLinkClick(e: Object) {
+    e.preventDefault();
+    const number = e.target.href.split(':')[1];
+
+    this.makeCall(number);
+  }
+
+  _onAuthenticated() {
+    this.parseLinks();
+  }
+
+  _onMessage(event: Object) {
+    if (!event.data) {
+      return;
+    }
+
+    switch (event.data.type) {
+      case SDK_ON_CALL_MADE:
+        this.onCallMade(event.data.callSession);
+        break;
+      case SDK_CALL_ENDED: {
+        const { callSession, content, direction, userExtension } = event.data;
+        this.onCallEnded(callSession, content, direction, userExtension);
+        break;
+      }
+      case SDK_CALL_INCOMING:
+        this.onCallIncoming(event.data.callSession);
+        break;
+      case SDK_AUTHENTICATED:
+        // $FlowFixMe
+        this._onAuthenticated(event.data.session);
+        this.onAuthenticated(event.data.session);
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+export default new Softphone();

package/src/simple/index.js

@@ -39,6 +39,7 @@ import IssueReporter from '../service/IssueReporter';
 import Features from '../domain/Features';
 import Meeting from '../domain/Meeting';
 import Checker from '../checker/Checker';
+import Softphone from './Softphone';
 
 const Wazo = {
   Auth,
@@ -58,6 +59,7 @@ const Wazo = {
   loggerFor: IssueReporter.loggerFor.bind(IssueReporter),
   Features,
   Checker,
+  Softphone,
 
   // Domain
   domain: {

package/src/web-rtc-client.js

@@ -771,8 +771,10 @@ export default class WebRTCClient extends Emitter {
       conference: isConference,
     };
 
-    // Avoid sdh to created a new stream
-    session.sessionDescriptionHandler.localMediaStreamConstraints = options.constraints;
+    // Avoid sdh to create a new stream
+    if (session.sessionDescriptionHandler) {
+      session.sessionDescriptionHandler.localMediaStreamConstraints = options.constraints;
+    }
 
     // Send re-INVITE
     return session.invite(options);

package/src/websocket-client.js

@@ -356,7 +356,7 @@ class WebSocketClient extends Emitter {
       this.close();
     }
     const url = `wss://${this.host || ''}/api/websocketd/?token=${this.token || ''}&version=${this.version}`;
-    logger.log('Wazo WS url computed to reconnect', { url });
+    logger.info('Wazo WS url computed to reconnect', { url });
 
     return url;
   }