@wazo/sdk 0.38.7 → 0.38.10

package/src/simple/room/Room.js

@@ -143,7 +143,7 @@ class Room extends Emitter {
     logger.info('connecting to room', { extension, audioOnly, room: !!room });
 
     if (!room) {
-      await Wazo.Phone.connect();
+      await Wazo.Phone.connect({ media: constraints });
 
       const withCamera = constraints && !!constraints.video;
 
@@ -590,7 +590,7 @@ class Room extends Emitter {
         const participant: ?Participant = this._getParticipantFromCallId(status.callId);
 
         if (participant) {
-          // we're received, so no need to broadcast, hence the input false arg
+          // we're receiving, so no need to broadcast
           participant.updateStatus(status, false);
         }
         break;

package/src/simple/room/SipRoom.js

@@ -13,7 +13,7 @@ class SipRoom extends Room {
     logger.info('connecting to sip room', { extension, audioOnly, room: !!room });
 
     if (!room) {
-      await Wazo.Phone.connect();
+      await Wazo.Phone.connect({ media: constraints });
 
       const withCamera = constraints && !!constraints.video;
 

package/src/simple/room/__tests__/Participant.test.js

@@ -0,0 +1,81 @@
+// Using directly Wazo to avoid issues with require cycle
+import getApiClient from '../../../service/getApiClient';
+import Wazo from '../../index';
+import Room from '../Room';
+
+jest.mock('../../../service/getApiClient');
+
+describe('Participant', () => {
+  describe('ban', () => {
+    it('should throw an error when there is no meeting', async () => {
+      const room = new Room();
+      const participant = new Wazo.RemoteParticipant(room, {
+        call_id: 'id',
+        caller_id_name: 'Alice',
+        caller_id_number: 'number',
+      });
+
+      await expect(async () => participant.ban())
+        .rejects.toThrow('Attempting to ban a participant without a `meetingUuid`');
+    });
+
+    it('should call the api', async () => {
+      const number = '1234';
+      const meetingUuid = 'some-meeting-uuid';
+      const callId = 'some-call-id';
+      const room = new Room();
+      room.setMeetingUuid(meetingUuid);
+
+      const banMeetingParticipant = jest.fn();
+
+      getApiClient.mockImplementation(() => ({
+        calld: {
+          banMeetingParticipant,
+        },
+      }));
+
+      const participant = new Wazo.RemoteParticipant(room, {
+        call_id: callId,
+        caller_id_name: 'Alice',
+        caller_id_number: number,
+      });
+
+      participant.onBan = jest.fn();
+
+      await participant.ban();
+      expect(banMeetingParticipant).toHaveBeenCalledWith(meetingUuid, callId);
+      expect(participant.onBan).toHaveBeenCalledWith(true);
+    });
+
+    it('should call the api with a delay', async () => {
+      const number = '1234';
+      const meetingUuid = 'some-meeting-uuid';
+      const callId = 'some-call-id';
+      const someDelay = 2;
+      const room = new Room();
+      room.setMeetingUuid(meetingUuid);
+
+      const banMeetingParticipant = jest.fn();
+
+      getApiClient.mockImplementation(() => ({
+        calld: {
+          banMeetingParticipant,
+        },
+      }));
+
+      const participant = new Wazo.RemoteParticipant(room, {
+        call_id: callId,
+        caller_id_name: 'Alice',
+        caller_id_number: number,
+      });
+
+      participant.delay = jest.fn();
+      participant.onBan = jest.fn();
+
+      await participant.ban(someDelay);
+      expect(banMeetingParticipant).toHaveBeenCalledWith(meetingUuid, callId);
+      expect(participant.delay).toHaveBeenCalledWith(someDelay);
+      expect(participant.onBan).toHaveBeenCalledWith(true);
+    });
+  });
+});

package/src/types/WebSocketMessage.js

@@ -8,6 +8,7 @@ import type {
 import type { ChatMessageResponse } from '../domain/ChatMessage';
 import ChatRoom from '../domain/ChatRoom';
 import Meeting from '../domain/Meeting';
+import type MeetingAuthorization from '../domain/MeetingAuthorization';
 
 type WebSocketBaseMessage = {
   op: string,
@@ -189,6 +190,10 @@ type AgentPaused = WebSocketBaseMessage & { data: any, name: 'agent_paused' };
 type AgentUnpaused = WebSocketBaseMessage & { data: any, name: 'agent_unpaused' };
 
 type MeetingUserProgress = WebSocketBaseMessage & { data: Meeting, name: 'meeting_user_progress' };
+type MeetingAuthorizationPending = WebSocketBaseMessage & {
+  data: MeetingAuthorization,
+  name: 'meeting_authorization_pending'
+};
 
 export type WebSocketMessage =
   | CallCreated
@@ -223,4 +228,5 @@ export type WebSocketMessage =
   | AgentStatusUpdate
   | AgentPaused
   | AgentUnpaused
-  | MeetingUserProgress;
+  | MeetingUserProgress
+  | MeetingAuthorizationPending;

package/src/utils/__tests__/object.test.js

@@ -0,0 +1,35 @@
+// @flow
+import { convertKeysFromCamelToUnderscore } from '../object';
+
+describe('object utils', () => {
+  describe('convertKeysFromCamelToUnderscore', () => {
+    it('should throw an error when input is not an object', () => {
+      const msg = 'Input is not an object';
+      expect(() => convertKeysFromCamelToUnderscore(true)).toThrow(msg);
+      expect(() => convertKeysFromCamelToUnderscore(null)).toThrow(msg);
+      expect(() => convertKeysFromCamelToUnderscore(undefined)).toThrow(msg);
+      expect(() => convertKeysFromCamelToUnderscore([])).toThrow(msg);
+      expect(() => convertKeysFromCamelToUnderscore('some-string')).toThrow(msg);
+    });
+
+    it('should convert camel-cased keys to underscore', () => {
+      let value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({ LoremIpsum: value })).toEqual({ lorem_ipsum: value });
+      value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({ loremIpsum: value })).toEqual({ lorem_ipsum: value });
+      value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({ 'lorem-ipsum': value })).toEqual({ 'lorem-ipsum': value });
+      value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({ L123: value })).toEqual({ l123: value });
+    });
+
+    it('should handle multi-leveled object', () => {
+      const value = Math.random();
+      expect(convertKeysFromCamelToUnderscore({ LoremIpsum: { DoloreSit: { Amet: value }, regular: 'reg' } }))
+        .toEqual({ lorem_ipsum: { dolore_sit: { amet: value }, regular: 'reg' } });
+
+      expect(convertKeysFromCamelToUnderscore({ LoremIpsum: { DoloreSit: { Amet: [value] }, regular: ['something'] } }))
+        .toEqual({ lorem_ipsum: { dolore_sit: { amet: [value] }, regular: ['something'] } });
+    });
+  });
+});

package/src/utils/__tests__/string.test.js

@@ -0,0 +1,23 @@
+import { camelToUnderscore } from '../string';
+
+describe('string utils', () => {
+  describe('camelToUnderscore', () => {
+    it('', () => {
+      expect(() => camelToUnderscore(null)).toThrow('Input is not a string');
+      expect(() => camelToUnderscore(undefined)).toThrow('Input is not a string');
+      expect(() => camelToUnderscore({})).toThrow('Input is not a string');
+      expect(() => camelToUnderscore([])).toThrow('Input is not a string');
+    });
+
+    it('should convert camel-cased string to underscore', () => {
+      expect(camelToUnderscore('loremIpsum')).toEqual('lorem_ipsum');
+      expect(camelToUnderscore('lorem-ipsum')).toEqual('lorem-ipsum');
+      expect(camelToUnderscore('')).toEqual('');
+    });
+
+    it('should not prefix string with an underscore', () => {
+      expect(camelToUnderscore('LoremIpsum')).toEqual('lorem_ipsum');
+      expect(camelToUnderscore('L123')).toEqual('l123');
+    });
+  });
+});

package/src/utils/object.js

@@ -0,0 +1,15 @@
+// @flow
+
+import { camelToUnderscore } from './string';
+
+export const convertKeysFromCamelToUnderscore = (args: Object) => {
+  if (!args || typeof args !== 'object' || Array.isArray(args)) {
+    throw new Error('Input is not an object');
+  }
+
+  return Object.keys(args).reduce((acc, key) => {
+    acc[camelToUnderscore(key)] = typeof args[key] === 'object' && !Array.isArray(args[key])
+      ? convertKeysFromCamelToUnderscore(args[key]) : args[key];
+    return acc;
+  }, {});
+};

package/src/utils/string.js

@@ -0,0 +1,8 @@
+// @flow
+
+export const camelToUnderscore = (key: string) => {
+  if (typeof key !== 'string') {
+    throw new Error('Input is not a string');
+  }
+  return key.charAt(0).toLowerCase() + key.substring(1).replace(/([A-Z])/g, '_$1').toLowerCase();
+};

package/src/web-rtc-client.js

@@ -1070,7 +1070,7 @@ export default class WebRTCClient extends Emitter {
     });
   }
 
-  changeAudioInputDevice(id: string, session: ?Inviter, force: ?boolean) {
+  async changeAudioInputDevice(id: string, session: ?Inviter, force: ?boolean) {
     const currentId = this.getAudioDeviceId();
     logger.info('setting audio input device', { id, currentId, session: !!session });
 
@@ -1078,33 +1078,50 @@ export default class WebRTCClient extends Emitter {
       return null;
     }
 
+    // in order to handle an audio track change for default devices
+    // we need the actual id of the device (not 'default')
+    let deviceId = id;
+    if (id === 'default' && navigator.mediaDevices) {
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      const defaultDevice = devices.find(device => device.deviceId === 'default');
+      if (defaultDevice) {
+        const deviceLabel = defaultDevice.label.replace('Default - ', '');
+        const targetDevice = devices.find(device => device.label === deviceLabel);
+        if (targetDevice) {
+          deviceId = targetDevice.deviceId;
+          if (!force && deviceId === currentId) {
+            return null;
+          }
+        }
+      }
+    }
+
     // let's update the local audio value
     if (this.audio) {
       this.audio = {
         deviceId: {
-          exact: id,
+          exact: deviceId,
         },
       };
     }
 
-    if (session) {
+    if (session && navigator.mediaDevices) {
       const sdh = session.sessionDescriptionHandler;
       const pc = sdh.peerConnection;
 
-      // $FlowFixMe
-      return navigator.mediaDevices.getUserMedia({ audio: { deviceId: { exact: id } } }).then(async stream => {
-        const audioTrack = stream.getAudioTracks()[0];
-        const sender = pc && pc.getSenders().find(s => audioTrack && s && s.track && s.track.kind === audioTrack.kind);
+      const constraints = { audio: { deviceId: { exact: deviceId } } };
+      const stream = await navigator.mediaDevices.getUserMedia(constraints);
+      const audioTrack = stream.getAudioTracks()[0];
+      const sender = pc && pc.getSenders().find(s => audioTrack && s && s.track && s.track.kind === audioTrack.kind);
 
-        if (sender) {
-          if (sender.track) {
-            audioTrack.enabled = sender.track.enabled;
-          }
-          sender.replaceTrack(audioTrack);
+      if (sender) {
+        if (sender.track) {
+          audioTrack.enabled = sender.track.enabled;
         }
+        sender.replaceTrack(audioTrack);
+      }
 
-        return stream;
-      });
+      return stream;
     }
   }
 
@@ -1124,14 +1141,14 @@ export default class WebRTCClient extends Emitter {
       return null;
     }
 
-    // let's update the local video value
-    if (this.video) {
-      this.video = {
-        deviceId: {
-          exact: id,
-        },
-      };
-    }
+    // let's make sure we don't lose other video constraints settings -- width, height, frameRate...
+    const videoObject = typeof this.video === 'object' ? this.video : {};
+    this.video = {
+      ...videoObject,
+      deviceId: {
+        exact: id,
+      },
+    };
   }
 
   changeSessionVideoInputDevice(id: ?string, session: Inviter) {

package/src/websocket-client.js

@@ -94,6 +94,7 @@ export const AGENT_UNPAUSED = 'agent_unpaused';
 export const CONFERENCE_ADHOC_PARTICIPANT_LEFT = 'conference_adhoc_participant_left';
 export const CONFERENCE_ADHOC_DELETED = 'conference_adhoc_deleted';
 export const MEETING_USER_PROGRESS = 'meeting_user_progress';
+export const MEETING_USER_GUEST_AUTHORIZATION_CREATED = 'meeting_user_guest_authorization_created';
 
 const BLACKLIST_EVENTS = [
   CHAT_MESSAGE_SENT,
@@ -448,6 +449,7 @@ WebSocketClient.eventLists = [
   CONFERENCE_ADHOC_PARTICIPANT_LEFT,
   CONFERENCE_ADHOC_DELETED,
   MEETING_USER_PROGRESS,
+  MEETING_USER_GUEST_AUTHORIZATION_CREATED,
 ];
 
 export default WebSocketClient;