@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.104

package/src/members/request.ts

@@ -0,0 +1,215 @@
+// @ts-ignore
+import {StatelessWebexPlugin} from '@webex/webex-core';
+
+import {MEETINGS} from '../constants';
+import ParameterError from '../common/errors/parameter';
+
+import MembersUtil from './util';
+
+/**
+ * @class MembersRequest
+ */
+export default class MembersRequest extends StatelessWebexPlugin {
+  namespace = MEETINGS;
+
+  /**
+   *
+   * @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);
+
+    // @ts-ignore
+    return this.request(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);
+
+    // @ts-ignore
+    return this.request(requestParams);
+  }
+
+  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);
+
+    // @ts-ignore
+    return this.request(requestParams);
+  }
+
+  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.request(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);
+
+    // @ts-ignore
+    return this.request(requestParams);
+  }
+
+  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);
+
+    // @ts-ignore
+    return this.request(requestParams);
+  }
+
+  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);
+
+    // @ts-ignore
+    return this.request(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);
+
+    // @ts-ignore
+    return this.request(requestParams);
+  }
+
+  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);
+
+    // @ts-ignore
+    return this.request(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);
+
+    // @ts-ignore
+    return this.request(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);
+
+    // @ts-ignore
+    return this.request(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.js → util.ts}

@@ -1,5 +1,4 @@
 import uuid from 'uuid';
-
 import {
   HTTP_VERBS,
   CONTROLS,
@@ -9,10 +8,13 @@ import {
   VALID_EMAIL_ADDRESS,
   DIALER_REGEX,
   SEND_DTMF_ENDPOINT,
-  _REMOVE_
+  _REMOVE_,
+  ALIAS,
 } from '../constants';
 
-const MembersUtil = {};
+import {RoleAssignmentOptions, RoleAssignmentRequest, ServerRoleShape} from './types';
+
+const MembersUtil: any = {};
 
 /**
  * @param {Object} invitee with emailAddress, email or phoneNumber
@@ -20,10 +22,14 @@ const MembersUtil = {};
  * @param {Boolean} alertIfActive
  * @returns {Object} the format object
  */
-MembersUtil.generateAddMemberOptions = (invitee, locusUrl, alertIfActive) => ({
+MembersUtil.generateAddMemberOptions = (
+  invitee: object,
+  locusUrl: string,
+  alertIfActive: boolean
+) => ({
   invitee,
   locusUrl,
-  alertIfActive
+  alertIfActive,
 });
 
 /**
@@ -31,44 +37,55 @@ MembersUtil.generateAddMemberOptions = (invitee, locusUrl, alertIfActive) => ({
  * @param {String} locusUrl
  * @returns {Object} the format object
  */
-MembersUtil.generateAdmitMemberOptions = (memberIds, locusUrl) => ({
+MembersUtil.generateAdmitMemberOptions = (memberIds: Array<any>, locusUrl: string) => ({
   locusUrl,
-  memberIds
+  memberIds,
 });
 
 /**
  * @param {Object} options with {invitee: {emailAddress, email, phoneNumber}, alertIfActive}
  * @returns {Object} with {invitees: [{address}], alertIfActive}
  */
-MembersUtil.getAddMemberBody = (options) => ({
+MembersUtil.getAddMemberBody = (options: any) => ({
   invitees: [
     {
-      address: options.invitee.emailAddress || options.invitee.email || options.invitee.phoneNumber
-    }
+      address: options.invitee.emailAddress || options.invitee.email || options.invitee.phoneNumber,
+    },
   ],
-  alertIfActive: options.alertIfActive
+  alertIfActive: options.alertIfActive,
 });
 
 /**
- * @param {Object} options with {memberIds}
+ * @param {Object} options with {memberIds, authorizingLocusUrl}
  * @returns {Object} admit with {memberIds}
  */
-MembersUtil.getAdmitMemberRequestBody = (options) => ({
-  admit: {participantIds: options.memberIds}
-});
+MembersUtil.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}
+ * @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
  */
-MembersUtil.getAdmitMemberRequestParams = (format) => {
+MembersUtil.getAdmitMemberRequestParams = (format: any) => {
   const body = MembersUtil.getAdmitMemberRequestBody(format);
-  const uri = `${format.locusUrl}/${CONTROLS}`;
+  const {locusUrl, sessionLocusUrls} = format;
+  const baseUrl = sessionLocusUrls?.mainLocusUrl || locusUrl;
+  const uri = `${baseUrl}/${CONTROLS}`;
 
   return {
     method: HTTP_VERBS.PUT,
     uri,
-    body
+    body,
   };
 };
 
@@ -76,12 +93,12 @@ MembersUtil.getAdmitMemberRequestParams = (format) => {
  * @param {Object} format with {invitee {emailAddress, email, phoneNumber}, locusUrl, alertIfActive}
  * @returns {Object} the request parameters (method, uri, body) needed to make a addMember request
  */
-MembersUtil.getAddMemberRequestParams = (format) => {
+MembersUtil.getAddMemberRequestParams = (format: any) => {
   const body = MembersUtil.getAddMemberBody(format);
   const requestParams = {
     method: HTTP_VERBS.PUT,
     uri: format.locusUrl,
-    body
+    body,
   };
 
   return requestParams;
@@ -101,104 +118,180 @@ MembersUtil.isInvalidInvitee = (invitee) => {
 
 MembersUtil.getRemoveMemberRequestParams = (options) => {
   const body = {
-    reason: options.reason
+    reason: options.reason,
   };
   const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${LEAVE}`;
 
   return {
     method: HTTP_VERBS.PUT,
     uri,
-    body
+    body,
   };
 };
 
 MembersUtil.generateTransferHostMemberOptions = (transfer, moderator, locusUrl) => ({
   moderator,
   locusUrl,
-  memberId: transfer
+  memberId: transfer,
 });
 
 MembersUtil.generateRemoveMemberOptions = (removal, locusUrl) => ({
   reason: _FORCED_,
   memberId: removal,
-  locusUrl
+  locusUrl,
 });
 
-MembersUtil.generateMuteMemberOptions = (memberId, status, locusUrl) => ({
+MembersUtil.generateMuteMemberOptions = (memberId, status, locusUrl, isAudio) => ({
   memberId,
   muted: status,
-  locusUrl
+  locusUrl,
+  isAudio,
 });
 
 MembersUtil.generateRaiseHandMemberOptions = (memberId, status, locusUrl) => ({
   memberId,
   raised: status,
-  locusUrl
+  locusUrl,
+});
+
+/**
+ * @param {String} memberId
+ * @param {[ServerRoleShape]} roles
+ * @param {String} locusUrl
+ * @returns {RoleAssignmentOptions}
+ */
+MembersUtil.generateRoleAssignmentMemberOptions = (
+  memberId: string,
+  roles: Array<ServerRoleShape>,
+  locusUrl: string
+): RoleAssignmentOptions => ({
+  memberId,
+  roles,
+  locusUrl,
 });
 
 MembersUtil.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}
+ */
+MembersUtil.generateEditDisplayNameMemberOptions = (
+  memberId,
+  requestingParticipantId,
+  alias,
   locusUrl
+) => ({
+  memberId,
+  requestingParticipantId,
+  alias,
+  locusUrl,
 });
 
 MembersUtil.getMuteMemberRequestParams = (options) => {
+  const property = options.isAudio === false ? 'video' : 'audio';
   const body = {
-    audio: {
-      muted: options.muted
-    }
+    [property]: {
+      muted: options.muted,
+    },
   };
   const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
 
   return {
     method: HTTP_VERBS.PATCH,
     uri,
-    body
+    body,
+  };
+};
+
+/**
+ * @param {RoleAssignmentOptions} options
+ * @returns {RoleAssignmentRequest} the request parameters (method, uri, body) needed to make a addMember request
+ */
+MembersUtil.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,
   };
 };
 
 MembersUtil.getRaiseHandMemberRequestParams = (options) => {
   const body = {
     hand: {
-      raised: options.raised
-    }
+      raised: options.raised,
+    },
   };
   const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
 
   return {
     method: HTTP_VERBS.PATCH,
     uri,
-    body
+    body,
   };
 };
 
 MembersUtil.getLowerAllHandsMemberRequestParams = (options) => {
   const body = {
     hand: {
-      raised: false
+      raised: false,
     },
-    requestingParticipantId: options.requestingParticipantId
+    requestingParticipantId: options.requestingParticipantId,
   };
   const uri = `${options.locusUrl}/${CONTROLS}`;
 
   return {
     method: HTTP_VERBS.PATCH,
     uri,
-    body
+    body,
+  };
+};
+
+/**
+ * @param {Object} options with format of {locusUrl: string, requestingParticipantId: string}
+ * @returns {Object} request parameters (method, uri, body) needed to make a editDisplayName request
+ */
+MembersUtil.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,
   };
 };
 
 MembersUtil.getTransferHostToMemberRequestParams = (options) => {
   const body = {
     role: {
-      moderator: options.moderator
-    }
+      moderator: options.moderator,
+    },
   };
   const uri = `${options.locusUrl}/${PARTICIPANT}/${options.memberId}/${CONTROLS}`;
 
   return {
     method: HTTP_VERBS.PATCH,
     uri,
-    body
+    body,
   };
 };
 
@@ -206,35 +299,33 @@ MembersUtil.genderateSendDTMFOptions = (url, tones, memberId, locusUrl) => ({
   url,
   tones,
   memberId,
-  locusUrl
+  locusUrl,
 });
 
-MembersUtil.generateSendDTMFRequestParams = ({
-  url, tones, memberId, locusUrl
-}) => {
+MembersUtil.generateSendDTMFRequestParams = ({url, tones, memberId, locusUrl}) => {
   const body = {
     device: {
-      url
+      url,
     },
     memberId,
     dtmf: {
       correlationId: uuid.v4(),
       tones,
-      direction: 'transmit'
-    }
+      direction: 'transmit',
+    },
   };
   const uri = `${locusUrl}/${PARTICIPANT}/${memberId}/${SEND_DTMF_ENDPOINT}`;
 
   return {
     method: HTTP_VERBS.POST,
     uri,
-    body
+    body,
   };
 };
 
 MembersUtil.cancelPhoneInviteOptions = (invitee, locusUrl) => ({
   invitee,
-  locusUrl
+  locusUrl,
 });
 
 MembersUtil.generateCancelInviteRequestParams = (options) => {
@@ -242,14 +333,14 @@ MembersUtil.generateCancelInviteRequestParams = (options) => {
     actionType: _REMOVE_,
     invitees: [
       {
-        address: options.invitee.phoneNumber
-      }
-    ]
+        address: options.invitee.phoneNumber,
+      },
+    ],
   };
   const requestParams = {
     method: HTTP_VERBS.PUT,
     uri: options.locusUrl,
-    body
+    body,
   };
 
   return requestParams;