@webex/plugin-meetings 3.0.0-beta.2 → 3.0.0-beta.200

package/src/members/request.ts

@@ -0,0 +1,255 @@
+// @ts-ignore
+import {StatelessWebexPlugin} from '@webex/webex-core';
+
+import {MEETINGS} from '../constants';
+import ParameterError from '../common/errors/parameter';
+
+import MembersUtil from './util';
+import MeetingUtil from '../meeting/util';
+
+/**
+ * @class MembersRequest
+ */
+export default class MembersRequest extends StatelessWebexPlugin {
+  namespace = MEETINGS;
+  locusDeltaRequest: (options: object) => Promise<any>;
+
+  /**
+   * Constructor
+   * @param {Object} attrs
+   * @param {Object} options
+   */
+  constructor(attrs: {meeting: any}, options: object) {
+    const {meeting, ...otherAttrs} = attrs;
+    super(otherAttrs, options);
+
+    this.locusDeltaRequest = MeetingUtil.generateLocusDeltaRequest(meeting);
+  }
+
+  /**
+   *
+   * @param {Object} options with format of {invitee: string, locusUrl: string}
+   * @returns {Promise}
+   * @throws {Error} if the options are not valid and complete, must have invitee with emailAddress OR email AND locusUrl
+   * @memberof MembersRequest
+   */
+  addMembers(options: any) {
+    if (
+      !(
+        !options ||
+        !options.invitee ||
+        !options.invitee.emailAddress ||
+        !options.invitee.email ||
+        !options.invitee.phoneNumber ||
+        !options.locusUrl
+      )
+    ) {
+      throw new ParameterError(
+        'invitee must be passed and the associated locus url for this meeting object must be defined.'
+      );
+    }
+    const requestParams = MembersUtil.getAddMemberRequestParams(options);
+
+    return this.locusDeltaRequest(requestParams);
+  }
+
+  /**
+   *
+   * @param {Object} options
+   * @returns {Promise}
+   * @throws {Error} if the options are not valid and complete, must have memberIds AND locusUrl
+   * @memberof MembersRequest
+   */
+  admitMember(options: any) {
+    if (!options || !options.locusUrl || !options.memberIds) {
+      throw new ParameterError(
+        'memberIds must be an array passed and the associated locus url for this meeting object must be defined.'
+      );
+    }
+    const requestParams = MembersUtil.getAdmitMemberRequestParams(options);
+
+    return this.locusDeltaRequest(requestParams);
+  }
+
+  /**
+   * Sends a request to remove a member
+   * @param {Object} options
+   * @param {String} options.locusUrl
+   * @param {String} options.memberId ID of member
+   * @returns {Promise}
+   */
+  removeMember(options) {
+    if (!options || !options.locusUrl || !options.memberId) {
+      throw new ParameterError(
+        'memberId must be defined, and the associated locus url for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.getRemoveMemberRequestParams(options);
+
+    return this.locusDeltaRequest(requestParams);
+  }
+
+  /**
+   * Sends a request to mute a member
+   * @param {Object} options
+   * @param {String} options.locusUrl
+   * @param {String} options.memberId ID of member
+   * @returns {Promise}
+   */
+  muteMember(options) {
+    if (!options || !options.locusUrl || !options.memberId) {
+      throw new ParameterError(
+        'memberId must be defined, and the associated locus url for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.getMuteMemberRequestParams(options);
+
+    // @ts-ignore
+    return this.locusDeltaRequest(requestParams);
+  }
+
+  /**
+   * Sends a request to the DTMF endpoint to send tones
+   * @param {Object} options
+   * @param {String} options.locusUrl
+   * @param {String} options.memberId ID of PSTN user
+   * @returns {Promise}
+   */
+  assignRolesMember(options: any) {
+    if (!options || !options.locusUrl || !options.memberId) {
+      throw new ParameterError(
+        'memberId must be defined, and the associated locus url for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.getRoleAssignmentMemberRequestParams(options);
+
+    return this.locusDeltaRequest(requestParams);
+  }
+
+  /**
+   * Sends a request to raise or lower a member's hand
+   * @param {Object} options
+   * @param {String} options.locusUrl
+   * @param {String} options.memberId ID of member
+   * @returns {Promise}
+   */
+  raiseOrLowerHandMember(options) {
+    if (!options || !options.locusUrl || !options.memberId) {
+      throw new ParameterError(
+        'memberId must be defined, and the associated locus url for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.getRaiseHandMemberRequestParams(options);
+
+    return this.locusDeltaRequest(requestParams);
+  }
+
+  /**
+   * Sends a request to lower all hands
+   * @param {Object} options
+   * @param {String} options.locusUrl
+   * @param {String} options.requestingParticipantId ID of requesting participant
+   * @returns {Promise}
+   */
+  lowerAllHandsMember(options) {
+    if (!options || !options.locusUrl || !options.requestingParticipantId) {
+      throw new ParameterError(
+        'requestingParticipantId must be defined, and the associated locus url for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.getLowerAllHandsMemberRequestParams(options);
+
+    return this.locusDeltaRequest(requestParams);
+  }
+
+  /**
+   *
+   * @param {Object} options with format of {locusUrl: string, requestingParticipantId: string}
+   * @returns {Promise}
+   * @throws {Error} if the options are not valid and complete, must have requestingParticipantId AND locusUrl
+   * @memberof MembersRequest
+   */
+  editDisplayNameMember(options: {locusUrl: string; requestingParticipantId: string}) {
+    if (!options || !options.locusUrl || !options.requestingParticipantId) {
+      throw new ParameterError(
+        'requestingParticipantId must be defined, and the associated locus url for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.editDisplayNameMemberRequestParams(options);
+
+    return this.locusDeltaRequest(requestParams);
+  }
+
+  /**
+   * Sends a request to raise or lower a member's hand
+   * @param {Object} options
+   * @param {String} options.locusUrl
+   * @param {String} options.memberId ID of member
+   * @param {String} options.moderator ID of moderator
+   * @returns {Promise}
+   */
+  transferHostToMember(options) {
+    if (!options || !options.locusUrl || !options.memberId || !options.moderator) {
+      throw new ParameterError(
+        'memberId must be defined, the associated locus url, and the moderator for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.getTransferHostToMemberRequestParams(options);
+
+    return this.locusDeltaRequest(requestParams);
+  }
+
+  /**
+   * Sends a request to the DTMF endpoint to send tones
+   * @param {Object} options
+   * @param {String} options.locusUrl
+   * @param {String} options.url device url SIP user
+   * @param {String} options.tones a string of one or more DTMF tones to send
+   * @param {String} options.memberId ID of PSTN user
+   * @returns {Promise}
+   */
+  sendDialPadKey(options: {locusUrl: string; url: string; tones: string; memberId: string}) {
+    // @ts-ignore
+    if (
+      !options ||
+      !options.locusUrl ||
+      !options.memberId ||
+      !options.url ||
+      // @ts-ignore
+      (!options.tones && options.tones !== 0)
+    ) {
+      throw new ParameterError(
+        'memberId must be defined, the associated locus url, the device url and DTMF tones for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.generateSendDTMFRequestParams(options);
+
+    return this.locusDeltaRequest(requestParams);
+  }
+
+  /**
+   * @param {Object} options with format of {invitee: string, locusUrl: string}
+   * @returns {Promise}
+   * @throws {Error} if the options are not valid and complete, must have invitee with emailAddress OR email AND locusUrl
+   * @memberof MembersRequest
+   */
+  cancelPhoneInvite(options: any) {
+    if (!(options?.invitee?.phoneNumber || options?.locusUrl)) {
+      throw new ParameterError(
+        'invitee must be passed and the associated locus url for this meeting object must be defined.'
+      );
+    }
+
+    const requestParams = MembersUtil.generateCancelInviteRequestParams(options);
+
+    return this.locusDeltaRequest(requestParams);
+  }
+}

package/src/members/types.ts

@@ -0,0 +1,28 @@
+export enum ServerRoles {
+  Cohost = 'COHOST',
+  Moderator = 'MODERATOR',
+  Presenter = 'PRESENTER',
+}
+
+export type ServerRoleShape = {
+  type: ServerRoles;
+  hasRole: boolean;
+};
+
+export type RoleAssignmentOptions = {
+  roles: Array<ServerRoleShape>;
+  locusUrl: string;
+  memberId: string;
+};
+
+export type RoleAssignmentBody = {
+  role: {
+    roles: Array<ServerRoleShape>;
+  };
+};
+
+export type RoleAssignmentRequest = {
+  method: string;
+  uri: string;
+  body: RoleAssignmentBody;
+};

package/src/members/util.ts

@@ -0,0 +1,339 @@
+import uuid from 'uuid';
+import {
+  HTTP_VERBS,
+  CONTROLS,
+  _FORCED_,
+  LEAVE,
+  PARTICIPANT,
+  VALID_EMAIL_ADDRESS,
+  DIALER_REGEX,
+  SEND_DTMF_ENDPOINT,
+  _REMOVE_,
+  ALIAS,
+} from '../constants';
+
+import {RoleAssignmentOptions, RoleAssignmentRequest, ServerRoleShape} from './types';
+
+const MembersUtil = {
+  /**
+   * @param {Object} invitee with emailAddress, email or phoneNumber
+   * @param {String} locusUrl
+   * @param {Boolean} alertIfActive
+   * @returns {Object} the format object
+   */
+  generateAddMemberOptions: (invitee: object, locusUrl: string, alertIfActive: boolean) => ({
+    invitee,
+    locusUrl,
+    alertIfActive,
+  }),
+
+  /**
+   * @param {Array} memberIds
+   * @param {String} locusUrl
+   * @returns {Object} the format object
+   */
+  generateAdmitMemberOptions: (memberIds: Array<any>, locusUrl: string) => ({
+    locusUrl,
+    memberIds,
+  }),
+
+  /**
+   * @param {Object} options with {invitee: {emailAddress, email, phoneNumber}, alertIfActive}
+   * @returns {Object} with {invitees: [{address}], alertIfActive}
+   */
+  getAddMemberBody: (options: any) => ({
+    invitees: [
+      {
+        address:
+          options.invitee.emailAddress || options.invitee.email || options.invitee.phoneNumber,
+      },
+    ],
+    alertIfActive: options.alertIfActive,
+  }),
+
+  /**
+   * @param {Object} options with {memberIds, authorizingLocusUrl}
+   * @returns {Object} admit with {memberIds}
+   */
+  getAdmitMemberRequestBody: (options: any) => {
+    const {memberIds, sessionLocusUrls} = options;
+    const body: any = {admit: {participantIds: memberIds}};
+    if (sessionLocusUrls) {
+      const {authorizingLocusUrl} = sessionLocusUrls;
+
+      return {authorizingLocusUrl, ...body};
+    }
+
+    return body;
+  },
+
+  /**
+   * @param {Object} format with {memberIds, locusUrl, sessionLocusUrls}
+   * @returns {Object} the request parameters (method, uri, body) needed to make a admitMember request
+   * if a host/cohost is in a breakout session, the locus url should be the main session locus url
+   */
+  getAdmitMemberRequestParams: (format: any) => {
+    const body = MembersUtil.getAdmitMemberRequestBody(format);
+    const {locusUrl, sessionLocusUrls} = format;
+    const baseUrl = sessionLocusUrls?.mainLocusUrl || locusUrl;
+    const uri = `${baseUrl}/${CONTROLS}`;
+
+    return {
+      method: HTTP_VERBS.PUT,
+      uri,
+      body,
+    };
+  },
+
+  /**
+   * @param {Object} format with {invitee {emailAddress, email, phoneNumber}, locusUrl, alertIfActive}
+   * @returns {Object} the request parameters (method, uri, body) needed to make a addMember request
+   */
+  getAddMemberRequestParams: (format: any) => {
+    const body = MembersUtil.getAddMemberBody(format);
+    const requestParams = {
+      method: HTTP_VERBS.PUT,
+      uri: format.locusUrl,
+      body,
+    };
+
+    return requestParams;
+  },
+
+  isInvalidInvitee: (invitee) => {
+    if (!(invitee && (invitee.email || invitee.emailAddress || invitee.phoneNumber))) {
+      return true;
+    }
+
+    if (invitee.phoneNumber) {
+      return !DIALER_REGEX.E164_FORMAT.test(invitee.phoneNumber);
+    }
+
+    return !VALID_EMAIL_ADDRESS.test(invitee.email || invitee.emailAddress);
+  },
+
+  getRemoveMemberRequestParams: (options) => {
+    const body = {
+      reason: options.reason,
+    };
+    const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${LEAVE}`;
+
+    return {
+      method: HTTP_VERBS.PUT,
+      uri,
+      body,
+    };
+  },
+
+  generateTransferHostMemberOptions: (transfer, moderator, locusUrl) => ({
+    moderator,
+    locusUrl,
+    memberId: transfer,
+  }),
+
+  generateRemoveMemberOptions: (removal, locusUrl) => ({
+    reason: _FORCED_,
+    memberId: removal,
+    locusUrl,
+  }),
+
+  generateMuteMemberOptions: (memberId, status, locusUrl, isAudio) => ({
+    memberId,
+    muted: status,
+    locusUrl,
+    isAudio,
+  }),
+
+  generateRaiseHandMemberOptions: (memberId, status, locusUrl) => ({
+    memberId,
+    raised: status,
+    locusUrl,
+  }),
+
+  /**
+   * @param {String} memberId
+   * @param {[ServerRoleShape]} roles
+   * @param {String} locusUrl
+   * @returns {RoleAssignmentOptions}
+   */
+  generateRoleAssignmentMemberOptions: (
+    memberId: string,
+    roles: Array<ServerRoleShape>,
+    locusUrl: string
+  ): RoleAssignmentOptions => ({
+    memberId,
+    roles,
+    locusUrl,
+  }),
+
+  generateLowerAllHandsMemberOptions: (requestingParticipantId, locusUrl) => ({
+    requestingParticipantId,
+    locusUrl,
+  }),
+
+  /**
+   * @param {String} memberId id of the participant who is receiving request
+   * @param {String} requestingParticipantId id of the participant who is sending request (optional)
+   * @param {String} alias alias name
+   * @param {String} locusUrl url
+   * @returns {Object} consists of {memberID: string, requestingParticipantId: string, alias: string, locusUrl: string}
+   */
+  generateEditDisplayNameMemberOptions: (memberId, requestingParticipantId, alias, locusUrl) => ({
+    memberId,
+    requestingParticipantId,
+    alias,
+    locusUrl,
+  }),
+
+  getMuteMemberRequestParams: (options) => {
+    const property = options.isAudio === false ? 'video' : 'audio';
+    const body = {
+      [property]: {
+        muted: options.muted,
+      },
+    };
+    const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
+
+    return {
+      method: HTTP_VERBS.PATCH,
+      uri,
+      body,
+    };
+  },
+
+  /**
+   * @param {RoleAssignmentOptions} options
+   * @returns {RoleAssignmentRequest} the request parameters (method, uri, body) needed to make a addMember request
+   */
+  getRoleAssignmentMemberRequestParams: (options: RoleAssignmentOptions): RoleAssignmentRequest => {
+    const body = {role: {roles: []}};
+    options.roles.forEach((role) => {
+      body.role.roles.push({type: role.type, hasRole: role.hasRole});
+    });
+
+    const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
+
+    return {
+      method: HTTP_VERBS.PATCH,
+      uri,
+      body,
+    };
+  },
+
+  getRaiseHandMemberRequestParams: (options) => {
+    const body = {
+      hand: {
+        raised: options.raised,
+      },
+    };
+    const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
+
+    return {
+      method: HTTP_VERBS.PATCH,
+      uri,
+      body,
+    };
+  },
+
+  getLowerAllHandsMemberRequestParams: (options) => {
+    const body = {
+      hand: {
+        raised: false,
+      },
+      requestingParticipantId: options.requestingParticipantId,
+    };
+    const uri = `${options.locusUrl}/${CONTROLS}`;
+
+    return {
+      method: HTTP_VERBS.PATCH,
+      uri,
+      body,
+    };
+  },
+
+  /**
+   * @param {Object} options with format of {locusUrl: string, requestingParticipantId: string}
+   * @returns {Object} request parameters (method, uri, body) needed to make a editDisplayName request
+   */
+  editDisplayNameMemberRequestParams: (options) => {
+    const body = {
+      aliasValue: options.alias,
+      requestingParticipantId: options.requestingParticipantId,
+    };
+    const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${ALIAS}`;
+
+    return {
+      method: HTTP_VERBS.POST,
+      uri,
+      body,
+    };
+  },
+
+  getTransferHostToMemberRequestParams: (options) => {
+    const body = {
+      role: {
+        moderator: options.moderator,
+      },
+    };
+    const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
+
+    return {
+      method: HTTP_VERBS.PATCH,
+      uri,
+      body,
+    };
+  },
+
+  genderateSendDTMFOptions: (url, tones, memberId, locusUrl) => ({
+    url,
+    tones,
+    memberId,
+    locusUrl,
+  }),
+
+  generateSendDTMFRequestParams: ({url, tones, memberId, locusUrl}) => {
+    const body = {
+      device: {
+        url,
+      },
+      memberId,
+      dtmf: {
+        correlationId: uuid.v4(),
+        tones,
+        direction: 'transmit',
+      },
+    };
+    const uri = `${locusUrl}/${PARTICIPANT}/${memberId}/${SEND_DTMF_ENDPOINT}`;
+
+    return {
+      method: HTTP_VERBS.POST,
+      uri,
+      body,
+    };
+  },
+
+  cancelPhoneInviteOptions: (invitee, locusUrl) => ({
+    invitee,
+    locusUrl,
+  }),
+
+  generateCancelInviteRequestParams: (options) => {
+    const body = {
+      actionType: _REMOVE_,
+      invitees: [
+        {
+          address: options.invitee.phoneNumber,
+        },
+      ],
+    };
+    const requestParams = {
+      method: HTTP_VERBS.PUT,
+      uri: options.locusUrl,
+      body,
+    };
+
+    return requestParams;
+  },
+};
+
+export default MembersUtil;

package/src/metrics/{constants.js → constants.ts}

@@ -1,4 +1,3 @@
-
 // Metrics constants ----------------------------------------------------------
 
 const BEHAVIORAL_METRICS = {
@@ -10,6 +9,7 @@ const BEHAVIORAL_METRICS = {
   JOIN_FAILURE: 'js_sdk_join_failures',
   ADD_MEDIA_SUCCESS: 'js_sdk_add_media_success',
   ADD_MEDIA_FAILURE: 'js_sdk_add_media_failures',
+  ROAP_MERCURY_EVENT_RECEIVED: 'js_sdk_roap_mercury_received',
   CONNECTION_SUCCESS: 'js_sdk_connection_success',
   CONNECTION_FAILURE: 'js_sdk_connection_failures',
   MEETING_LEAVE_FAILURE: 'js_sdk_meeting_leave_failure',
@@ -41,10 +41,6 @@ const BEHAVIORAL_METRICS = {
   INVALID_ICE_CANDIDATE: 'js_sdk_invalid_ice_candidate',
   UPLOAD_LOGS_FAILURE: 'js_sdk_upload_logs_failure',
   RECEIVE_TRANSCRIPTION_FAILURE: 'js_sdk_receive_transcription_failure',
-  ENABLE_BNR_SUCCESS: 'js_sdk_enable_bnr_success',
-  ENABLE_BNR_FAILURE: 'js_sdk_enable_bnr_failure',
-  DISABLE_BNR_SUCCESS: 'js_sdk_disable_bnr_success',
-  DISABLE_BNR_FAILURE: 'js_sdk_disable_bnr_failure',
   FETCH_MEETING_INFO_V1_SUCCESS: 'js_sdk_fetch_meeting_info_v1_success',
   FETCH_MEETING_INFO_V1_FAILURE: 'js_sdk_fetch_meeting_info_v1_failure',
   ADHOC_MEETING_SUCCESS: 'js_sdk_adhoc_meeting_success',
@@ -57,7 +53,7 @@ const BEHAVIORAL_METRICS = {
   MOVE_FROM_SUCCESS: 'js_sdk_move_from_success',
   MOVE_FROM_FAILURE: 'js_sdk_move_from_failure',
   TURN_DISCOVERY_FAILURE: 'js_sdk_turn_discovery_failure',
+  MEETING_INFO_POLICY_ERROR: 'js_sdk_meeting_info_policy_error',
 };
 
-
 export {BEHAVIORAL_METRICS as default};