@wazo/sdk 0.38.5 → 0.38.8

package/src/api/confd.js

@@ -1,10 +1,13 @@
 /* @flow */
 import ApiRequester from '../utils/api-requester';
 import type { UUID, ListConfdUsersResponse, ListApplicationsResponse } from '../domain/types';
+import type { MeetingCreateArguments, MeetingUpdateArguments } from '../domain/Meeting';
 import Profile from '../domain/Profile';
 import SipLine from '../domain/SipLine';
 import ExternalApp from '../domain/ExternalApp';
 import Meeting from '../domain/Meeting';
+import MeetingAuthorization from '../domain/MeetingAuthorization';
+import { convertKeysFromCamelToUnderscore } from '../utils/object';
 
 export default (client: ApiRequester, baseUrl: string) => ({
   listUsers: (): Promise<ListConfdUsersResponse> => client.get(`${baseUrl}/users`, null),
@@ -72,8 +75,18 @@ export default (client: ApiRequester, baseUrl: string) => ({
   getMyMeetings: (): Promise<Meeting> =>
     client.get(`${baseUrl}/users/me/meetings`).then(response => Meeting.parseMany(response.items)),
 
-  createMyMeeting: (name: string, persistent: boolean): Promise<Meeting> =>
-    client.post(`${baseUrl}/users/me/meetings`, { name, persistent }).then(Meeting.parse),
+  createMyMeeting: (args: MeetingCreateArguments): Promise<Meeting> =>
+    client
+      .post(`${baseUrl}/users/me/meetings`, convertKeysFromCamelToUnderscore(args))
+      .then(Meeting.parse),
+
+  updateMyMeeting: (meetingUuid: string, data: MeetingUpdateArguments): Promise<Boolean> =>
+    client.put(
+      `${baseUrl}/users/me/meetings/${meetingUuid}`,
+      convertKeysFromCamelToUnderscore(data),
+      null,
+      ApiRequester.successResponseParser,
+    ),
 
   deleteMyMeeting: (meetingUuid: string): Promise<Meeting> =>
     client.delete(`${baseUrl}/users/me/meetings/${meetingUuid}`, null),
@@ -81,6 +94,34 @@ export default (client: ApiRequester, baseUrl: string) => ({
   getMeeting: (meetingUuid: string): Promise<Meeting> =>
     client.get(`${baseUrl}/meetings/${meetingUuid}`, null).then(Meeting.parse),
 
+  meetingAuthorizations: (meetingUuid: string): Promise<Array<MeetingAuthorization>> =>
+    client.get(`${baseUrl}/users/me/meetings/${meetingUuid}/authorizations`, null).then(MeetingAuthorization.parseMany),
+
+  meetingAuthorizationReject: (meetingUuid: string, authorizationUuid: string): Promise<Boolean> =>
+    client.put(
+      `${baseUrl}/users/me/meetings/${meetingUuid}/authorizations/${authorizationUuid}/reject`,
+      {},
+      null,
+      ApiRequester.successResponseParser,
+    ),
+
+  meetingAuthorizationAccept: (meetingUuid: string, authorizationUuid: string): Promise<Boolean> =>
+    client.put(
+      `${baseUrl}/users/me/meetings/${meetingUuid}/authorizations/${authorizationUuid}/accept`,
+      {},
+      null,
+      ApiRequester.successResponseParser,
+    ),
+
   guestGetMeeting: (meetingUuid: string): Promise<Meeting> =>
     client.get(`${baseUrl}/guests/me/meetings/${meetingUuid}`, null).then(Meeting.parse),
+
+  guestAuthorizationRequest: (userUuid: string, meetingUuid: string, username: string): Promise<> =>
+    client
+      .post(`${baseUrl}/guests/${userUuid}/meetings/${meetingUuid}/authorizations`, { guest_name: username })
+      .then(MeetingAuthorization.parse),
+
+  guestAuthorizationCheck: (userUuid: string, meetingUuid: string, authorizationUuid: string): Promise<> =>
+    client.get(`${baseUrl}/guests/${userUuid}/meetings/${meetingUuid}/authorizations/${authorizationUuid}`, null),
+
 });

package/src/domain/Call.js

@@ -15,6 +15,7 @@ type CallResponse = {
   dialed_extension: string,
   status: string,
   is_caller: boolean,
+  is_video?: boolean,
   line_id: ?number,
   creation_time: string,
   on_hold: boolean,
@@ -27,6 +28,7 @@ type CallArguments = {
   id: string,
   sipCallId: string,
   isCaller: boolean,
+  isVideo?: boolean,
   callerName: string,
   callerNumber: string,
   calleeName: string,
@@ -53,6 +55,7 @@ export default class Call {
   dialedExtension: string;
   lineId: ?number;
   isCaller: boolean;
+  isVideo: boolean;
   onHold: boolean;
   muted: boolean;
   status: string;
@@ -77,6 +80,7 @@ export default class Call {
       calleeNumber: plain.peer_caller_id_number,
       dialedExtension: plain.dialed_extension,
       isCaller: plain.is_caller,
+      isVideo: plain.is_video,
       muted: plain.muted,
       onHold: plain.on_hold,
       status: plain.status,
@@ -100,6 +104,7 @@ export default class Call {
     calleeNumber,
     dialedExtension,
     isCaller,
+    isVideo,
     lineId,
     muted,
     onHold,
@@ -123,6 +128,7 @@ export default class Call {
     this.startingTime = startingTime;
     this.talkingToIds = talkingToIds || [];
     this.recording = recording;
+    this.isVideo = !!isVideo;
 
     // Useful to compare instead of instanceof with minified code
     this.type = 'Call';

package/src/domain/CallSession.js

@@ -390,7 +390,7 @@ export default class CallSession {
       ringing: call.isRinging(),
       answered: call.isUp(),
       answeredBySystem: call.isUp() && call.talkingToIds.length === 0,
-      cameraEnabled: false,
+      cameraEnabled: call.isVideo,
       dialedExtension: call.dialedExtension,
       call,
       conference: false, // @FIXME?

package/src/domain/Meeting.js

@@ -3,6 +3,19 @@ import moment from 'moment';
 
 import newFrom from '../utils/new-from';
 
+import MeetingAuthorization from './MeetingAuthorization';
+
+export type MeetingCreateArguments = {
+  name: string,
+  requireAuthorization: boolean,
+  persistent: boolean,
+}
+
+export type MeetingUpdateArguments = {
+  name?: string,
+  requireAuthorization?: boolean,
+}
+
 export type MeetingCreationResponse = {
   guest_sip_authorization: string,
   ingress_http_uri: string,
@@ -13,6 +26,7 @@ export type MeetingCreationResponse = {
   exten: string,
   persistent: boolean,
   creation_time: string,
+  require_authorization: boolean,
 }
 
 export default class Meeting {
@@ -27,6 +41,8 @@ export default class Meeting {
   persistent: boolean;
   ownerUuids: Array<string>;
   creationTime: Date;
+  pendingAuthorizations: Array<MeetingAuthorization>
+  requireAuthorization: boolean;
 
   static parse(plain: MeetingCreationResponse): Meeting {
     return new Meeting({
@@ -39,6 +55,7 @@ export default class Meeting {
       extension: plain.exten,
       persistent: plain.persistent,
       creationTime: moment(plain.creation_time).toDate(),
+      requireAuthorization: plain.require_authorization,
     });
   }
 
@@ -63,6 +80,7 @@ export default class Meeting {
     extension,
     persistent,
     creationTime,
+    requireAuthorization,
   }: Object = {}) {
     this.guestSipAuthorization = guestSipAuthorization;
     this.uri = uri;
@@ -73,6 +91,7 @@ export default class Meeting {
     this.extension = extension;
     this.persistent = persistent;
     this.creationTime = creationTime;
+    this.requireAuthorization = requireAuthorization;
 
     // Useful to compare instead of instanceof with minified code
     this.type = 'Meeting';
@@ -83,4 +102,5 @@ export default class Meeting {
     const [username, secret] = atob(this.guestSipAuthorization).split(':');
     return { username, secret };
   }
+
 }

package/src/domain/MeetingAuthorization.js

@@ -0,0 +1,67 @@
+// @flow
+
+export type RawMeetingAuthorization = {
+  created_at: string,
+  meeting_uuid: string,
+  uuid: string,
+  guest_uuid: string,
+  guest_name: string,
+}
+
+export const PENDING = 'pending';
+export const ACCEPTED = 'accepted';
+export const REJECTED = 'rejected';
+export const POST_PROCESSING = 'post_processing';
+export const POST_PROCESSED_SUCCESS = 'post_processed_success';
+export const POST_PROCESSED_ERROR = 'post_processed_error';
+
+export default class MeetingAuthorization {
+  meetingUuid: string;
+  uuid: string;
+  userUuid: string;
+  userName: string;
+  status: string;
+
+  constructor({
+    meetingUuid,
+    uuid,
+    userUuid,
+    userName,
+  }: Object = {}) {
+    this.meetingUuid = meetingUuid;
+    this.uuid = uuid;
+    this.userUuid = userUuid;
+    this.userName = userName;
+  }
+
+  setStatus(status: string) {
+    this.status = status;
+  }
+
+  getStatus() {
+    return this.status;
+  }
+
+  static parse(plain: RawMeetingAuthorization) {
+    const {
+      meeting_uuid: meetingUuid,
+      uuid,
+      guest_uuid: userUuid,
+      guest_name: userName,
+    } = plain;
+
+    return new MeetingAuthorization({
+      meetingUuid,
+      uuid,
+      userUuid,
+      userName,
+    });
+  }
+
+  static parseMany(items: RawMeetingAuthorization[]): Array<MeetingAuthorization> {
+    if (!items) {
+      return [];
+    }
+    return items.map(MeetingAuthorization.parse);
+  }
+}

package/src/domain/Phone/WebRTCPhone.js

@@ -668,10 +668,10 @@ export default class WebRTCPhone extends Emitter implements Phone {
     this.audioRingVolume = volume;
   }
 
-  changeAudioInputDevice(id: string) {
+  changeAudioInputDevice(id: string, force: ?boolean) {
     logger.info('WebRTC phone - changeAudio input device', { deviceId: id });
 
-    return this.client.changeAudioInputDevice(id, this.currentSipSession);
+    return this.client.changeAudioInputDevice(id, this.currentSipSession, force);
   }
 
   changeVideoInputDevice(id: ?string) {

package/src/domain/__tests__/Meeting.test.js

@@ -1,9 +1,76 @@
 // @flow
 /* global btoa */
 
+import moment from 'moment';
 import Meeting from '../Meeting';
 
+const rawCreationTime = '2021-12-21T15:56:42.880Z';
+
 describe('Meeting domain', () => {
+  it('should retain its values when parsed', () => {
+    const args = {
+      guest_sip_authorization: 'some-guest-sip-authorization',
+      ingress_http_uri: 'some-uri',
+      name: 'some-name',
+      owner_uuids: ['some-owner-uuid'],
+      port: 'some-port',
+      uuid: 'some-uuid',
+      exten: 'some-exten',
+      persistent: true,
+      creation_time: rawCreationTime,
+      require_authorization: true,
+    };
+
+    const meeting = Meeting.parse(args);
+    const {
+      uri,
+      uuid,
+      name,
+      port,
+      extension,
+      persistent,
+      ownerUuids,
+      creationTime,
+      requireAuthorization,
+    } = meeting;
+
+    expect(uri).toEqual(args.ingress_http_uri);
+    expect(uuid).toEqual(args.uuid);
+    expect(name).toEqual(args.name);
+    expect(port).toEqual(args.port);
+    expect(extension).toEqual(args.exten);
+    expect(persistent).toEqual(args.persistent);
+    expect(ownerUuids).toEqual(args.owner_uuids);
+    expect(creationTime).toEqual(moment(rawCreationTime).toDate());
+    expect(requireAuthorization).toEqual(args.require_authorization);
+  });
+
+  it('should retain its values when instantiated', () => {
+    const keys = [
+      'uuid',
+      'name',
+      'guestSipAuthorization',
+      'ownerUuids',
+      'port',
+      'uri',
+      'extension',
+      'persistent',
+      'creationTime',
+      'requireAuthorization',
+    ];
+
+    const args = keys.reduce((acc, key) => {
+      acc[key] = `some-${key}`;
+      return acc;
+    }, {});
+
+    const meeting = new Meeting(args);
+
+    keys.forEach(key =>
+      // $FlowFixMe
+      expect(meeting[key]).toEqual(`some-${key}`));
+  });
+
   it('can return username and secret from an base64 encrypted string', () => {
     const USERNAME = 'username';
     const SECRET = 'secret';
@@ -18,6 +85,7 @@ describe('Meeting domain', () => {
       uuid: '',
       exten: '',
       persistent: false,
+      require_authorization: false,
     };
 
     const meeting = Meeting.parse(args);
@@ -30,7 +98,7 @@ describe('Meeting domain', () => {
 
   it('should return a date from a string', () => {
     const args = {
-      creation_time: '2021-12-21T15:56:42.880Z',
+      creation_time: rawCreationTime,
       guest_sip_authorization: '',
       ingress_http_uri: '',
       name: '',
@@ -39,6 +107,7 @@ describe('Meeting domain', () => {
       uuid: '',
       exten: '',
       persistent: false,
+      require_authorization: false,
     };
 
     const { creationTime } = Meeting.parse(args);

package/src/domain/__tests__/MeetingAuthorization.test.js

@@ -0,0 +1,58 @@
+import MeetingAuthorization from '../MeetingAuthorization';
+
+describe('MeetingAuthorization', () => {
+  describe('parse', () => {
+    it('should parse a raw input', () => {
+      const rawAuthorization = {
+        created_at: 'today',
+        meeting_uuid: 'meeting_uuid',
+        uuid: 'uuid',
+        guest_uuid: 'guest_uuid',
+        guest_name: 'guest_name',
+      };
+
+      const authorization = {
+        meetingUuid: rawAuthorization.meeting_uuid,
+        uuid: rawAuthorization.uuid,
+        userUuid: rawAuthorization.guest_uuid,
+        userName: rawAuthorization.guest_name,
+        status: undefined,
+      };
+
+      const response = MeetingAuthorization.parse(rawAuthorization);
+      expect(response).toEqual(authorization);
+    });
+  });
+
+  describe('parseMany', () => {
+    it('should parse multiple raw inputs', () => {
+      const rawAuthorizations = [
+        {
+          created_at: 'today1',
+          meeting_uuid: 'meeting_uuid1',
+          uuid: 'uuid1',
+          guest_uuid: 'guest_uuid1',
+          guest_name: 'guest_name1',
+        },
+        {
+          created_at: 'today2',
+          meeting_uuid: 'meeting_uuid2',
+          uuid: 'uuid2',
+          guest_uuid: 'guest_uuid2',
+          guest_name: 'guest_name2',
+        },
+      ];
+
+      const authorizations = rawAuthorizations.map(rawAuthorization => ({
+        meetingUuid: rawAuthorization.meeting_uuid,
+        uuid: rawAuthorization.uuid,
+        userUuid: rawAuthorization.guest_uuid,
+        userName: rawAuthorization.guest_name,
+        status: undefined,
+      }));
+
+      const response = MeetingAuthorization.parseMany(rawAuthorizations);
+      expect(response).toEqual(authorizations);
+    });
+  });
+});

package/src/lib/WazoSessionDescriptionHandler.js

@@ -12,7 +12,7 @@ import { SessionDescriptionHandler }
 import { SessionDescriptionHandlerOptions }
   from 'sip.js/lib/platform/web/session-description-handler/session-description-handler-options';
 import IssueReporter from '../service/IssueReporter';
-import { fixSdp, parseCandidate } from '../utils/sdp';
+import { addIcesInAllBundles, fixSdp, parseCandidate } from '../utils/sdp';
 
 const wazoLogger = IssueReporter ? IssueReporter.loggerFor('webrtc-sdh') : console;
 
@@ -141,7 +141,10 @@ class WazoSessionDescriptionHandler extends SessionDescriptionHandler {
 
         // Check if we got ICEs
         if (sdp.indexOf('a=candidate') !== -1) {
-          return description;
+          return {
+            type: description.type,
+            sdp: addIcesInAllBundles(sdp),
+          };
         }
 
         wazoLogger.info('No ICE candidates found in SDP, fixing it with gathered ices', this.gatheredCandidates);

package/src/simple/room/Participant.js

@@ -4,6 +4,7 @@ import IssueReporter from '../../service/IssueReporter';
 
 import Room, { SIGNAL_TYPE_PARTICIPANT_UPDATE } from './Room';
 import Contact from '../../domain/Contact';
+import getApiClient from '../../service/getApiClient';
 
 const logger = IssueReporter.loggerFor('room');
 
@@ -20,6 +21,7 @@ class Participant extends Emitter {
   videoMuted: boolean;
   screensharing: boolean;
   isOnHold: boolean;
+  banned: boolean;
   extra: Object;
 
   ON_UPDATED: string;
@@ -37,6 +39,7 @@ class Participant extends Emitter {
   ON_EXTRA_CHANGE: string;
   ON_HOLD: string;
   ON_RESUME: string;
+  ON_BAN: string;
 
   /**
    * @param room Room The room where the participant is
@@ -60,6 +63,7 @@ class Participant extends Emitter {
     this.screensharing = false;
     this.isOnHold = false;
     this.extra = extra;
+    this.banned = false;
 
     this.ON_UPDATED = 'participant/ON_UPDATED';
     this.ON_START_TALKING = 'participant/ON_START_TALKING';
@@ -76,6 +80,7 @@ class Participant extends Emitter {
     this.ON_EXTRA_CHANGE = 'participant/ON_EXTRA_CHANGE';
     this.ON_HOLD = 'participant/ON_HOLD';
     this.ON_RESUME = 'participant/ON_RESUME';
+    this.ON_BAN = 'participant/ON_BAN';
   }
 
   triggerEvent(name: string, ...args: any[]) {
@@ -116,6 +121,10 @@ class Participant extends Emitter {
         status.extra = this.extra;
         break;
       }
+      case this.ON_BAN: {
+        status.banned = true;
+        break;
+      }
       default:
         break;
     }
@@ -220,6 +229,11 @@ class Participant extends Emitter {
     this.triggerUpdate(this.ON_RESUME, broadcast);
   }
 
+  onBan(broadcast: boolean = true) {
+    this.banned = true;
+    this.triggerUpdate(this.ON_BAN, broadcast);
+  }
+
   getStatus() {
     return {
       callId: this.callId,
@@ -266,6 +280,10 @@ class Participant extends Emitter {
       }
     }
 
+    if (status.banned) {
+      this.onBan(false);
+    }
+
     // Poor man's object comparison
     if (typeof status.extra !== 'undefined' && JSON.stringify(this.extra) !== JSON.stringify(status.extra)) {
       this.extra = { ...this.extra, ...status.extra };
@@ -293,6 +311,28 @@ class Participant extends Emitter {
     this.streams = streams;
     this.videoStreams = streams;
   }
+
+  async ban(apiRequestDelay: ?number = null) {
+    const { meetingUuid } = this.room;
+    if (!meetingUuid) {
+      throw new Error('Attempting to ban a participant without a `meetingUuid`');
+    }
+
+    // this notifies all that someone is being banned
+    this.onBan(true);
+
+    // this allows to delay the actual ban, in order for the banned participant as well as others to react to the situation
+    if (apiRequestDelay) {
+      await this.delay(apiRequestDelay);
+    }
+
+    // proceed with the actual kick
+    return getApiClient().calld.banMeetingParticipant(meetingUuid, this.callId);
+  }
+
+  async delay(ms: number) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
 }
 
 export default Participant;

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;