@wazo/sdk 0.39.0-beta.9 → 0.39.1

package/esm/__tests__/api-client.test.js

@@ -1,8 +1,10 @@
+import { AbortController } from 'node-abort-controller';
 import { Base64 } from 'js-base64';
 import WazoApiClient from '../api-client';
 import ServerError from '../domain/ServerError';
 import BadResponse from '../domain/BadResponse';
 import Session from '../domain/Session';
+const controller = new AbortController();
 const mockedResponse = {
     data: {
         token: 1,
@@ -65,7 +67,7 @@ const server = 'localhost';
 const authVersion = '0.1';
 const username = 'wazo';
 const password = 'zowa';
-jest.mock('node-fetch/lib/index', () => { });
+jest.mock('node-fetch/src/index', () => { });
 const token = '1234';
 const client = new WazoApiClient({
     server,
@@ -98,6 +100,7 @@ describe('With correct API results', () => {
             expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token`, {
                 method: 'post',
                 body: JSON.stringify(data),
+                signal: controller.signal,
                 headers,
                 agent: null,
             });
@@ -111,6 +114,7 @@ describe('With correct API results', () => {
             expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token/${oldToken}`, {
                 method: 'delete',
                 body: null,
+                signal: controller.signal,
                 headers: {},
                 agent: null,
             });
@@ -131,6 +135,7 @@ describe('With unAuthorized API results', () => {
             expect(global.fetch).toBeCalledWith(`https://${server}/api/auth/${authVersion}/token/${tokenToCheck}`, {
                 method: 'head',
                 body: null,
+                signal: controller.signal,
                 headers: {},
                 agent: null,
             });
@@ -159,6 +164,7 @@ describe('With not found API results', () => {
             expect(global.fetch).toBeCalledWith(`https://${server}/api/calld/1.0/users/me/voicemails`, {
                 method: 'get',
                 body: null,
+                signal: controller.signal,
                 headers: {
                     'X-Auth-Token': token,
                     'Content-Type': 'application/json',

package/esm/__tests__/web-rtc-client.test.js

@@ -1,5 +1,15 @@
 import WebRTCClient from '../web-rtc-client';
 jest.mock('sip.js/lib/platform/web/transport');
+jest.mock('sip.js/lib/api/user-agent', () => ({
+    start: () => { },
+    UserAgent: class UserAgent {
+        // @ts-ignore
+        static makeURI = () => { };
+        // @ts-ignore
+        start = () => { };
+        transport = {};
+    },
+}));
 // @ts-expect-error
 const client = new WebRTCClient({});
 describe('WebRTC client', () => {

package/esm/api/dird.js

@@ -15,9 +15,9 @@ const getContactPayload = (contact) => ({
     note: contact.note ? contact.note : '',
 });
 export default ((client, baseUrl) => ({
-    search: (context, term) => client.get(`${baseUrl}/directories/lookup/${context}`, {
+    search: (context, term, offset = 0, limit = null) => client.get(`${baseUrl}/directories/lookup/${context}`, {
         term,
-    }).then(Contact.parseMany),
+    }).then((response) => Contact.parseMany(response, offset, limit)),
     listPersonalContacts: (queryParams = null) => client.get(`${baseUrl}/personal`, queryParams).then((response) => Contact.parseManyPersonal(response.items)),
     fetchPersonalContact: (contactUuid) => client.get(`${baseUrl}/personal/${contactUuid}`).then(Contact.parsePersonal),
     addContact: (contact) => client.post(`${baseUrl}/personal`, getContactPayload(contact)).then(Contact.parsePersonal),

package/esm/api-client.js

@@ -116,6 +116,7 @@ export default class ApiClient {
                 this.onRefreshTokenError(error);
             }
         }
+        return null;
     }
     setToken(token) {
         this.client.setToken(token);
@@ -126,6 +127,9 @@ export default class ApiClient {
     setRefreshToken(refreshToken) {
         this.refreshToken = refreshToken;
     }
+    setRequestTimeout(requestTimeout) {
+        this.client.setRequestTimeout(requestTimeout);
+    }
     setClientId(clientId) {
         this.client.clientId = clientId;
     }

package/esm/checker/checks/ice-ipv4.js

@@ -12,7 +12,8 @@ export default {
     name: 'Non IP v4 ice',
     check: (server, session, externalAppConfig) => new Promise((resolve, reject) => {
         if (typeof MediaStream === 'undefined') {
-            return resolve('Skipped on node');
+            resolve('Skipped on node');
+            return;
         }
         const mobile = isMobile();
         const offerOptions = {

package/esm/domain/Contact.js

@@ -55,11 +55,12 @@ export default class Contact {
         }
         return aLastName.localeCompare(bLastName);
     }
-    static parseMany(response) {
-        if (!response || !response.results) {
+    static parseMany(response, offset = 0, limit = null) {
+        if (!response || !response.results || limit === 0) {
             return [];
         }
-        return response.results.map(r => Contact.parse(r, response.column_types));
+        const results = limit !== null && limit > 0 ? response.results.slice(offset, limit) : offset > 0 ? response.results.slice(offset) : response.results;
+        return results.map(r => Contact.parse(r, response.column_types));
     }
     static manyGraphQlWithNumbersParser(numbers) {
         return (response) => {
@@ -160,13 +161,19 @@ export default class Contact {
             const postalAddress = plain.postalAddresses[0];
             address = `${postalAddress.street} ${postalAddress.city} ${postalAddress.postCode} ${postalAddress.country}`;
         }
+        const firstName = plain.givenName || '';
+        const lastName = plain.familyName || '';
+        const companyName = plain.company || '';
+        const isCompanyAccount = !firstName && !lastName;
+        const name = isCompanyAccount ? companyName : `${firstName} ${lastName}`;
         return new Contact({
-            name: `${plain.givenName || ''} ${plain.familyName || ''}`,
+            name,
             number: plain.phoneNumbers.length ? plain.phoneNumbers[0].number : '',
-            numbers: plain.phoneNumbers.length ? [{
-                    label: 'primary',
-                    number: plain.phoneNumbers[0].number,
-                }] : [],
+            // Make numbers unique
+            numbers: [...new Map(plain.phoneNumbers.map(item => [item.number, item])).values()].map((item, idx) => ({
+                label: idx === 0 ? 'primary' : 'secondary',
+                number: item.number,
+            })),
             email: plain.emailAddresses.length ? plain.emailAddresses[0].email : '',
             emails: plain.emailAddresses.length ? [{
                     label: 'primary',

package/esm/domain/Phone/WebRTCPhone.js

@@ -303,9 +303,6 @@ export default class WebRTCPhone extends Emitter {
                 this.eventEmitter.emit(ON_CALL_CANCELED, callSession, elsewhere);
             };
         }
-        else if (sipSession instanceof Invitation) {
-            console.warn('sipSession._onCancel not found, please update the wazo SDK accordingly');
-        }
         sipSession.stateChange.addListener((newState) => {
             switch (newState) {
                 case SessionState.Establishing:
@@ -359,10 +356,6 @@ export default class WebRTCPhone extends Emitter {
             if (kind === 'audio') {
                 return this.eventEmitter.emit(ON_AUDIO_STREAM, stream);
             }
-            // not sure this does anything
-            if (kind === 'video') {
-                event.track.enabled = false;
-            }
             return this.eventEmitter.emit(ON_VIDEO_STREAM, stream, event.track.id, event, sipSession);
         };
         peerConnection.onremovestream = (event) => {
@@ -411,10 +404,12 @@ export default class WebRTCPhone extends Emitter {
         logger.info('WebRTC phone - stop screen sharing', {
             restoreLocalStream,
         });
-        let reinvited;
+        let reinvited = null;
         try {
             if (this.currentScreenShare.stream) {
-                this.currentScreenShare.stream.getTracks().forEach((track) => track.stop());
+                this.currentScreenShare.stream.getTracks()
+                    .filter((track) => track.enabled)
+                    .forEach((track) => track.stop());
             }
             if (restoreLocalStream) {
                 const targetCallSession = callSession || this.currentCallSession;
@@ -1098,12 +1093,15 @@ export default class WebRTCPhone extends Emitter {
     async close(force = false) {
         logger.info('WebRTC close');
         try {
-            await Promise.race([this.unregister(), new Promise((resolve, reject) => setTimeout(() => reject(new Error('Unregister, timed out')), 3000))]);
+            await Promise.race([
+                this.unregister(),
+                new Promise((resolve, reject) => setTimeout(() => reject(new Error('Unregister, timed out')), 3000)),
+            ]);
         }
         catch (e) {
             logger.error('WebRTC close, unregister error', e);
         }
-        this.client.close(force);
+        await this.client.close(force);
         this.unbind();
         this.incomingSessions = [];
         this.currentSipSession = undefined;

package/esm/domain/Session.js

@@ -1,6 +1,7 @@
 /* eslint-disable no-nested-ternary */
 import { KEYUTIL, KJUR, b64utoutf8 } from 'jsrsasign';
 import swarmPublicKey from '../pubkey';
+import Contact from './Contact';
 import newFrom from '../utils/new-from';
 import compareVersions from '../utils/compare-version';
 const { jws } = KJUR;
@@ -8,6 +9,7 @@ const swarmKey = (KEYUTIL.getKey(swarmPublicKey));
 const MINIMUM_WAZO_ENGINE_VERSION_FOR_DEFAULT_CONTEXT = '19.08';
 export default class Session {
     acl;
+    contact;
     token;
     refreshToken;
     uuid;
@@ -95,6 +97,28 @@ export default class Session {
     primaryCtiLine() {
         return this.profile && (this.profile.sipLines || []).find(sipLine => sipLine && !sipLine.isWebRtc());
     }
+    getContact() {
+        if (this.contact) {
+            return this.contact;
+        }
+        const { email, firstName, lastName, mobileNumber, state, status } = this.profile || {};
+        const number = this.primaryNumber() || '';
+        const numbers = [{ label: 'primary', number }];
+        if (mobileNumber) {
+            numbers.push({ label: 'mobile', number: mobileNumber });
+        }
+        return new Contact({
+            uuid: this.uuid || '',
+            email,
+            name: `${firstName} ${lastName}`,
+            number,
+            numbers,
+            state: state || '',
+            status,
+            backend: 'wazo',
+            source: 'default',
+        });
+    }
     primaryContext() {
         if (this.engineVersion) {
             if (this.hasEngineVersionGte(MINIMUM_WAZO_ENGINE_VERSION_FOR_DEFAULT_CONTEXT)) {

package/esm/domain/__tests__/Contact.test.js

@@ -1,4 +1,132 @@
 import Contact from '../Contact';
+const genericContactResponse = {
+    column_types: [
+        'name',
+        'number',
+        'callable',
+        'voicemail',
+        'favorite',
+        'email',
+        'personal',
+    ],
+    term: 'a',
+    column_headers: [
+        'Nom',
+        'Num\u00e9ro',
+        'Mobile',
+        'Bo\u00eete vocale',
+        'Favoris',
+        'E-mail',
+        'Personnel',
+    ],
+    results: [],
+};
+const contact1 = {
+    source: 'internal',
+    column_values: [
+        'Jonathan Lessard',
+        '8020',
+        '06800880',
+        null,
+        false,
+        'jonathan@example.com',
+        false,
+    ],
+    backend: 'wazo',
+    relations: {
+        user_id: 8,
+        xivo_id: '6cd695d2-cdb9-4444-8b2d-27425ab85fa8',
+        agent_id: null,
+        endpoint_id: 8,
+        user_uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
+        source_entry_id: '8',
+    },
+};
+const contact2 = {
+    source: 'internal',
+    column_values: [
+        'John Doe',
+        '8021',
+        '06800881',
+        null,
+        false,
+        'john@example.com',
+        false,
+    ],
+    backend: 'wazo',
+    relations: {
+        user_id: 9,
+        xivo_id: '6cd695d2-cdb9-4444-8b2d-27425ab85fa9',
+        agent_id: null,
+        endpoint_id: 9,
+        user_uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b55',
+        source_entry_id: '9',
+    },
+};
+const parsedContact1 = new Contact({
+    name: 'Jonathan Lessard',
+    number: '8020',
+    numbers: [
+        {
+            label: 'primary',
+            number: '8020',
+        },
+        {
+            label: 'secondary',
+            number: '06800880',
+        },
+    ],
+    favorited: false,
+    email: 'jonathan@example.com',
+    emails: [
+        {
+            label: 'primary',
+            email: 'jonathan@example.com',
+        },
+    ],
+    address: '',
+    entreprise: '',
+    birthday: '',
+    note: '',
+    endpointId: 8,
+    personal: false,
+    source: 'internal',
+    sourceId: '8',
+    uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
+    backend: 'wazo',
+});
+const parsedContact2 = new Contact({
+    name: 'John Doe',
+    number: '8021',
+    numbers: [
+        {
+            label: 'primary',
+            number: '8021',
+        },
+        {
+            label: 'secondary',
+            number: '06800881',
+        },
+    ],
+    favorited: false,
+    email: 'john@example.com',
+    emails: [
+        {
+            label: 'primary',
+            email: 'john@example.com',
+        },
+    ],
+    address: '',
+    entreprise: '',
+    birthday: '',
+    note: '',
+    endpointId: 9,
+    personal: false,
+    source: 'internal',
+    sourceId: '9',
+    uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b55',
+    backend: 'wazo',
+});
 describe('Contact domain', () => {
     it('is extern when given no uuid', () => {
         const boba = new Contact({});
@@ -131,7 +259,7 @@ describe('Contact domain', () => {
         const contact = new Contact({
             name: 'John Smith',
         });
-        const { firstName, lastName, } = contact.separateName();
+        const { firstName, lastName } = contact.separateName();
         expect(firstName).toBe('John');
         expect(lastName).toBe('Smith');
     });
@@ -139,7 +267,7 @@ describe('Contact domain', () => {
         const contact = new Contact({
             name: 'John  Smith',
         });
-        const { firstName, lastName, } = contact.separateName();
+        const { firstName, lastName } = contact.separateName();
         expect(firstName).toBe('John');
         expect(lastName).toBe('Smith');
     });
@@ -165,67 +293,91 @@ describe('Contact domain', () => {
     });
     it('can parse a plain contact to domain', () => {
         const response = {
-            column_types: ['name', 'number', 'callable', 'voicemail', 'favorite', 'email', 'personal'],
-            term: 'a',
-            column_headers: ['Nom', 'Num\u00e9ro', 'Mobile', 'Bo\u00eete vocale', 'Favoris', 'E-mail', 'Personnel'],
-            results: [{
-                    source: 'internal',
-                    column_values: ['Jonathan Lessard', '8020', '06800880', null, false, 'contact@nexapp.ca', false],
-                    backend: 'wazo',
-                    relations: {
-                        user_id: 8,
-                        xivo_id: '6cd695d2-cdb9-4444-8b2d-27425ab85fa8',
-                        agent_id: null,
-                        endpoint_id: 8,
-                        user_uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
-                        source_entry_id: '8',
-                    },
-                }],
+            ...genericContactResponse,
+            results: [contact1],
         };
         const contact = Contact.parse(response.results[0], response.column_types);
-        expect(contact).toEqual(new Contact({
-            name: 'Jonathan Lessard',
-            number: '8020',
-            numbers: [{
-                    label: 'primary',
-                    number: '8020',
-                }, {
-                    label: 'secondary',
-                    number: '06800880',
-                }],
-            favorited: false,
-            email: 'contact@nexapp.ca',
-            emails: [{
-                    label: 'primary',
-                    email: 'contact@nexapp.ca',
-                }],
-            address: '',
-            entreprise: '',
-            birthday: '',
-            note: '',
-            endpointId: 8,
-            personal: false,
-            source: 'internal',
-            sourceId: '8',
-            uuid: 'a14dd6d6-547c-434d-bd5c-e882b5b83b54',
-            backend: 'wazo',
-        }));
+        expect(contact).toEqual(parsedContact1);
     });
     it('should merge 2 contact', () => {
-        const contact = new Contact({
+        const noBirthdayContact = new Contact({
             uuid: 'uuid-12345',
             lastActivity: 'yesterday',
             // @ts-expect-error
             birthday: null,
         });
-        const contact2 = new Contact({
+        const noLastActivityContact = new Contact({
             uuid: 'uuid-12345',
             // @ts-expect-error
             lastActivity: null,
             birthday: 'tomorrow',
         });
-        const result = contact.merge(contact2);
+        const result = noBirthdayContact.merge(noLastActivityContact);
         expect(result.lastActivity).toBe('yesterday');
         expect(result.birthday).toBe('tomorrow');
     });
+    it('returns all contacts when parsing many contacts with no limit', () => {
+        const response = {
+            ...genericContactResponse,
+            results: [contact1, contact2],
+        };
+        const contacts = Contact.parseMany(response);
+        expect(contacts).toEqual([parsedContact1, parsedContact2]);
+    });
+    it('returns all contacts when parsing many contacts with a higher limit than number of results', () => {
+        const response = {
+            ...genericContactResponse,
+            results: [contact1, contact2],
+        };
+        const contacts = Contact.parseMany(response, 0, 1000);
+        expect(contacts).toEqual([parsedContact1, parsedContact2]);
+    });
+    it('returns limited contacts when parsing many contacts with a smaller limit than number of results', () => {
+        const response = {
+            ...genericContactResponse,
+            results: [contact1],
+        };
+        const contacts = Contact.parseMany(response, 0, 1);
+        expect(contacts).toEqual([parsedContact1]);
+    });
+    it('returns all contacts when parsing many contacts with same limit than number of results', () => {
+        const response = {
+            ...genericContactResponse,
+            results: [contact1, contact2],
+        };
+        const contacts = Contact.parseMany(response, 0, 2);
+        expect(contacts).toEqual([parsedContact1, parsedContact2]);
+    });
+    it('returns an empty array when parsing many contact with limit of 0', () => {
+        const response = {
+            ...genericContactResponse,
+            results: [contact1, contact2],
+        };
+        const contacts = Contact.parseMany(response, 0, 0);
+        expect(contacts).toEqual([]);
+    });
+    it('returns all contacts when parsing many contacts with a negative limit', () => {
+        const response = {
+            ...genericContactResponse,
+            results: [contact1, contact2],
+        };
+        const contacts = Contact.parseMany(response, 0, -1);
+        expect(contacts).toEqual([parsedContact1, parsedContact2]);
+    });
+    it('returns all contacts when parsing many contacts with a null limit', () => {
+        const response = {
+            ...genericContactResponse,
+            results: [contact1, contact2],
+        };
+        const contacts = Contact.parseMany(response, 0, null);
+        expect(contacts).toEqual([parsedContact1, parsedContact2]);
+    });
+    it('returns all contacts after the first one when parsing many contacts with an offset of 1', () => {
+        const response = {
+            ...genericContactResponse,
+            results: [contact1, contact2],
+        };
+        const contacts = Contact.parseMany(response, 1, null);
+        expect(contacts).toEqual([parsedContact2]);
+    });
 });

package/esm/lib/WazoSessionDescriptionHandler.js

@@ -170,20 +170,23 @@ class WazoSessionDescriptionHandler extends SessionDescriptionHandler {
         if (this._peerConnection === undefined) {
             return;
         }
-        // Closing senders via getLocalStreams
+        // Closing senders via getLocalStreams, `getLocalStreams` is deprecated, we have to check if it exists.
         // @ts-ignore
-        this.peerConnection?.getLocalStreams().forEach(stream => {
-            stream.getTracks().forEach((track) => {
-                track.stop();
+        if (this.peerConnection?.getLocalStreams) {
+            // @ts-ignore
+            this.peerConnection?.getLocalStreams().forEach(stream => {
+                stream.getTracks()
+                    .filter((track) => track.enabled)
+                    .forEach((track) => track.stop());
             });
-        });
-        // Closing receivers via getRemoteStreams
-        // @ts-ignore
-        this.peerConnection?.getRemoteStreams().forEach(stream => {
-            stream.getTracks().forEach((track) => {
-                track.stop();
+            // Closing receivers via getRemoteStreams
+            // @ts-ignore
+            this.peerConnection?.getRemoteStreams().forEach(stream => {
+                stream.getTracks()
+                    .filter((track) => track.enabled)
+                    .forEach((track) => track.stop());
             });
-        });
+        }
         if (this._dataChannel) {
             this._dataChannel.close();
         }

package/esm/service/IssueReporter.js

@@ -12,7 +12,7 @@ const ERROR = 'error';
 const CONSOLE_METHODS = [INFO, LOG, WARN, ERROR];
 const LOG_LEVELS = [TRACE, DEBUG, INFO, LOG, WARN, ERROR];
 const CATEGORY_PREFIX = 'logger-category=';
-const MAX_REMOTE_RETRY = 100;
+const MAX_REMOTE_RETRY = 10;
 const addLevelsTo = (instance, withMethods = false) => {
     instance.TRACE = TRACE;
     instance.DEBUG = DEBUG;
@@ -265,6 +265,14 @@ class IssueReporter {
             this.bufferTimeout = null;
         }
     }
+    _computeRetryDelay(attempt, initial = 1000, maxWait = 50000) {
+        // min wait is initial(attempt = 0)
+        // later retries are randomly distributed between initial wait and exponential
+        const base = 1.5;
+        const wait = Math.min(initial * base ** attempt, maxWait);
+        const jitterWait = Math.max(initial, Math.random() * wait);
+        return jitterWait;
+    }
     _sendDebugToGrafana(payload, retry = 0) {
         if (!this.remoteClientConfiguration || retry >= MAX_REMOTE_RETRY) {
             return;
@@ -284,6 +292,8 @@ class IssueReporter {
             // @ts-ignore
             e.skipSendToRemote = true;
             this.log('error', this._makeCategory('grafana'), 'Sending log to grafana, error', e);
+            // wait at least 1 second, at most 50 seconds
+            const wait = this._computeRetryDelay(retry, 1000, 50000);
             setTimeout(() => {
                 if (Array.isArray(payload)) {
                     payload = payload.map(message => this._writeRetryCount(message, retry + 1));
@@ -292,7 +302,7 @@ class IssueReporter {
                     payload = this._writeRetryCount(payload, retry + 1);
                 }
                 this._sendDebugToGrafana(payload, retry + 1);
-            }, 5000 + retry * 1000);
+            }, wait);
         });
     }
     _writeRetryCount(message, count) {

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

@@ -97,4 +97,16 @@ describe('IssueReporter', () => {
             _retry: 1,
         });
     });
+    it('retry delay', () => {
+        expect(IssueReporter._computeRetryDelay(0, 1000, 50000)).toBe(1000);
+        expect(IssueReporter._computeRetryDelay(1, 1000, 50000)).toBeGreaterThanOrEqual(1000);
+        const samples = [];
+        for (let i = 0; i <= 10; i++) {
+            samples.push(IssueReporter._computeRetryDelay(i, 1000, 50000));
+        }
+        const min = Math.min(...samples);
+        expect(min).toBe(1000);
+        const max = Math.max(...samples);
+        expect(max).toBeLessThanOrEqual(50000);
+    });
 });

package/esm/service/getApiClient.js

@@ -14,6 +14,7 @@ global.wazoOnRefreshTokenError = global.wazoOnRefreshTokenError || {};
 global.wazoRefreshExpiration = global.wazoRefreshExpiration || {};
 global.wazoRefreshBackend = global.wazoRefreshBackend || {};
 global.wazoIsMobile = global.wazoIsMobile || {};
+global.wazoRequestApiTimeout = global.wazoRequestApiTimeout || {};
 global.wazoFetchOptions = global.wazoFetchOptions || {};
 export const setApiClientId = (clientId, forServer = null) => {
     global.wazoClientId[String(forServer)] = clientId;
@@ -49,12 +50,17 @@ export const setRefreshBackend = (refreshBackend, forServer = null) => {
 export const setIsMobile = (isMobile, forServer = null) => {
     global.wazoIsMobile[String(forServer)] = isMobile;
 };
+export const setRequestTimeout = (requestTimeout, forServer = null) => {
+    global.wazoRequestApiTimeout[String(forServer)] = requestTimeout;
+};
 export const setFetchOptions = (fetchOptions, forServer = null) => {
     global.wazoFetchOptions[String(forServer)] = fetchOptions;
 };
+export const getFetchOptions = (forServer = null) => (forServer ? global.wazoFetchOptions[forServer] : global.wazoFetchOptions.null) || global.wazoFetchOptions.null;
 const fillClient = (apiClient) => {
     const { server, token, clientId, } = apiClient.client;
     const tenantId = global.wazoRefreshTenantId[server] || global.wazoRefreshTenantId.null || apiClient.refreshTenantId;
+    const requestTimeout = global.wazoRequestApiTimeout[server] || global.wazoRequestApiTimeout.null;
     //  try with null server when dealing with non-related server info
     apiClient.setToken(global.wazoClientToken[server] || global.wazoClientToken.null || token);
     apiClient.setClientId(global.wazoClientId[server] || global.wazoClientId.null || clientId);
@@ -69,6 +75,9 @@ const fillClient = (apiClient) => {
     apiClient.setRefreshExpiration(global.wazoRefreshExpiration[server] || global.wazoRefreshExpiration.null || apiClient.refreshExpiration);
     apiClient.setRefreshBackend(global.wazoRefreshBackend[server] || global.wazoRefreshBackend.null || apiClient.refreshBackend);
     apiClient.setIsMobile(global.wazoIsMobile[server] || global.wazoIsMobile.null || apiClient.isMobile);
+    if (requestTimeout) {
+        apiClient.setRequestTimeout(requestTimeout);
+    }
     return apiClient;
 };
 export default ((forServer = null) => {