@webex/plugin-meetings 3.0.0-beta.57 → 3.0.0-beta.59

package/src/meeting/in-meeting-actions.ts

@@ -20,6 +20,8 @@ interface IInMeetingActions {
   canSetMuted?: boolean;
   canUnsetMuted?: boolean;
   canAssignHost?: boolean;
+  canSetPresenter?: boolean;
+  canUnsetPresenter?: boolean;
   canStartRecording?: boolean;
   canPauseRecording?: boolean;
   canResumeRecording?: boolean;
@@ -32,6 +34,7 @@ interface IInMeetingActions {
   canStartTranscribing?: boolean;
   canStopTranscribing?: boolean;
   isClosedCaptionActive?: boolean;
+  isSaveTranscriptsEnabled?: boolean;
   isWebexAssistantActive?: boolean;
   canViewCaptionPanel?: boolean;
   isRealTimeTranslationEnabled?: boolean;
@@ -71,6 +74,10 @@ export default class InMeetingActions implements IInMeetingActions {
 
   canSetMuteOnEntry = null;
 
+  canSetPresenter = null;
+
+  canUnsetPresenter = null;
+
   canUnsetMuteOnEntry = null;
 
   canSetDisallowUnmute = null;
@@ -97,6 +104,8 @@ export default class InMeetingActions implements IInMeetingActions {
 
   isClosedCaptionActive = null;
 
+  isSaveTranscriptsEnabled = null;
+
   isWebexAssistantActive = null;
 
   canViewCaptionPanel = null;
@@ -134,6 +143,8 @@ export default class InMeetingActions implements IInMeetingActions {
     canSetDisallowUnmute: this.canSetDisallowUnmute,
     canSetMuted: this.canSetMuted,
     canUnsetMuted: this.canUnsetMuted,
+    canSetPresenter: this.canSetPresenter,
+    canUnsetPresenter: this.canUnsetPresenter,
     canUnsetDisallowUnmute: this.canUnsetDisallowUnmute,
     canStartRecording: this.canStartRecording,
     canPauseRecording: this.canPauseRecording,
@@ -147,6 +158,7 @@ export default class InMeetingActions implements IInMeetingActions {
     canStartTranscribing: this.canStartTranscribing,
     canStopTranscribing: this.canStopTranscribing,
     isClosedCaptionActive: this.isClosedCaptionActive,
+    isSaveTranscriptsEnabled: this.isSaveTranscriptsEnabled,
     isWebexAssistantActive: this.isWebexAssistantActive,
     canViewCaptionPanel: this.canViewCaptionPanel,
     isRealTimeTranslationEnabled: this.isRealTimeTranslationEnabled,

package/src/meeting/index.ts

@@ -2307,6 +2307,9 @@ export default class Meeting extends StatelessWebexPlugin {
           canStartTranscribing: MeetingUtil.canStartTranscribing(payload.info.userDisplayHints),
           canStopTranscribing: MeetingUtil.canStopTranscribing(payload.info.userDisplayHints),
           isClosedCaptionActive: MeetingUtil.isClosedCaptionActive(payload.info.userDisplayHints),
+          isSaveTranscriptsEnabled: MeetingUtil.isSaveTranscriptsEnabled(
+            payload.info.userDisplayHints
+          ),
           isWebexAssistantActive: MeetingUtil.isWebexAssistantActive(payload.info.userDisplayHints),
           canViewCaptionPanel: MeetingUtil.canViewCaptionPanel(payload.info.userDisplayHints),
           isRealTimeTranslationEnabled: MeetingUtil.isRealTimeTranslationEnabled(

package/src/meeting/util.ts

@@ -470,6 +470,9 @@ MeetingUtil.endMeetingForAll = (meeting) => {
 MeetingUtil.canEnableClosedCaption = (displayHints) =>
   displayHints.includes(DISPLAY_HINTS.CAPTION_START);
 
+MeetingUtil.isSaveTranscriptsEnabled = (displayHints) =>
+  displayHints.includes(DISPLAY_HINTS.SAVE_TRANSCRIPTS_ENABLED);
+
 MeetingUtil.canStartTranscribing = (displayHints) =>
   displayHints.includes(DISPLAY_HINTS.TRANSCRIPTION_CONTROL_START);
 

package/src/meetings/index.ts

@@ -1108,33 +1108,41 @@ export default class Meetings extends WebexPlugin {
    * @memberof Meetings
    */
   public syncMeetings() {
-    return this.request.getActiveMeetings().then((locusArray) => {
-      const activeLocusUrl = [];
-
-      if (locusArray?.loci && locusArray.loci.length > 0) {
-        locusArray.loci.forEach((locus) => {
-          activeLocusUrl.push(locus.url);
-          this.handleLocusEvent({
-            locus,
-            locusUrl: locus.url,
+    return this.request
+      .getActiveMeetings()
+      .then((locusArray) => {
+        const activeLocusUrl = [];
+
+        if (locusArray?.loci && locusArray.loci.length > 0) {
+          locusArray.loci.forEach((locus) => {
+            activeLocusUrl.push(locus.url);
+            this.handleLocusEvent({
+              locus,
+              locusUrl: locus.url,
+            });
           });
-        });
-      }
-      const meetingsCollection = this.meetingCollection.getAll();
-
-      if (Object.keys(meetingsCollection).length > 0) {
-        // Some time the mercury event is missed after mercury reconnect
-        // if sync returns no locus then clear all the meetings
-        for (const meeting of Object.values(meetingsCollection)) {
-          // @ts-ignore
-          if (!activeLocusUrl.includes(meeting.locusUrl)) {
-            // destroy function also uploads logs
+        }
+        const meetingsCollection = this.meetingCollection.getAll();
+
+        if (Object.keys(meetingsCollection).length > 0) {
+          // Some time the mercury event is missed after mercury reconnect
+          // if sync returns no locus then clear all the meetings
+          for (const meeting of Object.values(meetingsCollection)) {
             // @ts-ignore
-            this.destroy(meeting, MEETING_REMOVED_REASON.NO_MEETINGS_TO_SYNC);
+            if (!activeLocusUrl.includes(meeting.locusUrl)) {
+              // destroy function also uploads logs
+              // @ts-ignore
+              this.destroy(meeting, MEETING_REMOVED_REASON.NO_MEETINGS_TO_SYNC);
+            }
           }
         }
-      }
-    });
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error(
+          `Meetings:index#syncMeetings --> failed to sync meetings, ${error}`
+        );
+        throw new Error(error);
+      });
   }
 
   /**

package/src/meetings/request.ts

@@ -23,6 +23,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         LoggerProxy.logger.error(
           `Meetings:request#getActiveMeetings --> failed to get locus details, ${error}`
         );
+        throw new Error(error);
       });
   }
 
@@ -71,6 +72,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
               LoggerProxy.logger.error(
                 `Meetings:request#determineRedirections --> failed to get locus details from url: ${url}, reason: ${error}`
               );
+              throw new Error(error);
             })
         )
       ).then(() => Promise.resolve(responseBody));

package/src/member/index.ts

@@ -2,6 +2,7 @@
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 import {MEETINGS, _IN_LOBBY_, _NOT_IN_MEETING_, _IN_MEETING_} from '../constants';
+import {IExternalRoles, ParticipantWithRoles} from './types';
 
 import MemberUtil from './util';
 
@@ -28,6 +29,7 @@ export default class Member {
   isSelf: any;
   isUser: any;
   isVideoMuted: any;
+  roles: IExternalRoles;
   name: any;
   participant: any;
   status: any;
@@ -228,6 +230,14 @@ export default class Member {
      * @memberof Member
      */
     this.isModeratorAssignmentProhibited = null;
+
+    /**
+     * @instance
+     * @type {IExternalRoles}
+     * @public
+     * @memberof Member
+     */
+    this.roles = null;
     // TODO: more participant types
     // such as native client, web client, is a device, what type of phone, etc
     this.processParticipant(participant);
@@ -258,6 +268,7 @@ export default class Member {
       this.isModeratorAssignmentProhibited =
         MemberUtil.isModeratorAssignmentProhibited(participant);
       this.processStatus(participant);
+      this.processRoles(participant as ParticipantWithRoles);
       // must be done last
       this.isNotAdmitted = MemberUtil.isNotAdmitted(participant, this.isGuest, this.status);
     }
@@ -427,6 +438,17 @@ export default class Member {
     }
   }
 
+  /**
+   * process the roles that have been applied to this member
+   * @param {Object} participant
+   * @returns {undefined}
+   * @private
+   * @memberof Member
+   */
+  private processRoles(participant: ParticipantWithRoles) {
+    this.roles = MemberUtil.extractControlRoles(participant);
+  }
+
   /**
    * set the type for the member, could be MEETING or CALL
    * @param {String} type

package/src/member/types.ts

@@ -0,0 +1,24 @@
+export interface IExternalRoles {
+  cohost: boolean;
+  moderator: boolean;
+  presenter: boolean;
+}
+
+export enum ServerRoles {
+  Cohost = 'COHOST',
+  Moderator = 'MODERATOR',
+  Presenter = 'PRESENTER',
+}
+
+export type ServerRoleShape = {
+  type: ServerRoles;
+  hasRole: boolean;
+};
+
+export type ParticipantWithRoles = {
+  controls: {
+    role: {
+      roles: Array<ServerRoleShape>;
+    };
+  };
+};

package/src/member/util.ts

@@ -1,3 +1,4 @@
+import {IExternalRoles, ParticipantWithRoles, ServerRoles, ServerRoleShape} from './types';
 import {
   _USER_,
   _RESOURCE_ROOM_,
@@ -19,6 +20,58 @@ import ParameterError from '../common/errors/parameter';
 
 const MemberUtil: any = {};
 
+/**
+ * @param {Object} participant the locus participant
+ * @returns {[ServerRoleShape]}
+ */
+MemberUtil.getControlsRoles = (participant: ParticipantWithRoles): Array<ServerRoleShape> =>
+  participant?.controls?.role?.roles;
+
+/**
+ * @param {Object} participant the locus participant
+ * @param {ServerRoles} controlRole the search role
+ * @returns {Boolean}
+ */
+MemberUtil.hasRole = (participant: any, controlRole: ServerRoles): boolean =>
+  MemberUtil.getControlsRoles(participant)?.some(
+    (role) => role.type === controlRole && role.hasRole
+  );
+
+/**
+ * @param {Object} participant the locus participant
+ * @returns {Boolean}
+ */
+MemberUtil.hasCohost = (participant: ParticipantWithRoles): boolean =>
+  MemberUtil.hasRole(participant, ServerRoles.Cohost) || false;
+
+/**
+ * @param {Object} participant the locus participant
+ * @returns {Boolean}
+ */
+MemberUtil.hasModerator = (participant: ParticipantWithRoles): boolean =>
+  MemberUtil.hasRole(participant, ServerRoles.Moderator) || false;
+
+/**
+ * @param {Object} participant the locus participant
+ * @returns {Boolean}
+ */
+MemberUtil.hasPresenter = (participant: ParticipantWithRoles): boolean =>
+  MemberUtil.hasRole(participant, ServerRoles.Presenter) || false;
+
+/**
+ * @param {Object} participant the locus participant
+ * @returns {IExternalRoles}
+ */
+MemberUtil.extractControlRoles = (participant: ParticipantWithRoles): IExternalRoles => {
+  const roles = {
+    cohost: MemberUtil.hasCohost(participant),
+    moderator: MemberUtil.hasModerator(participant),
+    presenter: MemberUtil.hasPresenter(participant),
+  };
+
+  return roles;
+};
+
 /**
  * @param {Object} participant the locus participant
  * @returns {Boolean}

package/src/members/index.ts

@@ -16,6 +16,7 @@ import MembersRequest from './request';
 import MembersUtil from './util';
 import {ReceiveSlotManager} from '../multistream/receiveSlotManager';
 import {MediaRequestManager} from '../multistream/mediaRequestManager';
+import {ServerRoleShape} from './types';
 
 /**
  * Members Update Event
@@ -803,6 +804,32 @@ export default class Members extends StatelessWebexPlugin {
     return this.membersRequest.muteMember(options);
   }
 
+  /**
+   * Assign role(s) to a member in the meeting
+   * @param {String} memberId
+   * @param {[ServerRoleShape]} roles - to assign an array of roles
+   * @returns {Promise}
+   * @public
+   * @memberof Members
+   */
+  public assignRoles(memberId: string, roles: Array<ServerRoleShape>) {
+    if (!this.locusUrl) {
+      return Promise.reject(
+        new ParameterError(
+          'The associated locus url for this meetings members object must be defined.'
+        )
+      );
+    }
+    if (!memberId) {
+      return Promise.reject(
+        new ParameterError('The member id must be defined to assign the roles to a member.')
+      );
+    }
+    const options = MembersUtil.generateRoleAssignmentMemberOptions(memberId, roles, this.locusUrl);
+
+    return this.membersRequest.assignRolesMember(options);
+  }
+
   /**
    * Raise or lower the hand of a member in a meeting
    * @param {String} memberId

package/src/members/request.ts

@@ -85,6 +85,26 @@ export default class MembersRequest extends StatelessWebexPlugin {
     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(

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

@@ -1,5 +1,4 @@
 import uuid from 'uuid';
-
 import {
   HTTP_VERBS,
   CONTROLS,
@@ -12,6 +11,8 @@ import {
   _REMOVE_,
 } from '../constants';
 
+import {RoleAssignmentOptions, RoleAssignmentRequest, ServerRoleShape} from './types';
+
 const MembersUtil: any = {};
 
 /**
@@ -152,6 +153,22 @@ MembersUtil.generateRaiseHandMemberOptions = (memberId, 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,
@@ -173,6 +190,27 @@ MembersUtil.getMuteMemberRequestParams = (options) => {
   };
 };
 
+/**
+ * @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: {

package/src/reconnection-manager/index.ts

@@ -452,10 +452,10 @@ export default class ReconnectionManager {
     // So that on rejoin it known what parametrs it was using
     if (!this.meeting || !this.webex.meetings.getMeetingByType(_ID_, this.meeting.id)) {
       LoggerProxy.logger.info(
-        'ReconnectionManager:index#executeReconnection --> Meeting got deleted due to inactivity or ended remotely '
+        'ReconnectionManager:index#executeReconnection --> Meeting got deleted due to inactivity or ended remotely.'
       );
 
-      throw new Error('Unable to rejoin a meeting already ended or inactive .');
+      throw new Error('Unable to rejoin a meeting already ended or inactive.');
     }
 
     LoggerProxy.logger.info(

package/test/unit/spec/meeting/in-meeting-actions.ts

@@ -10,6 +10,8 @@ describe('plugin-meetings', () => {
         canLock: null,
         canUnlock: null,
         canAssignHost: null,
+        canSetPresenter: null,
+        canUnsetPresenter: null,
         canStartRecording: null,
         canPauseRecording: null,
         canResumeRecording: null,
@@ -28,6 +30,7 @@ describe('plugin-meetings', () => {
         canStartTranscribing: null,
         canStopTranscribing: null,
         isClosedCaptionActive: null,
+        isSaveTranscriptsEnabled: null,
         isWebexAssistantActive: null,
         canViewCaptionPanel: null,
         isRealTimeTranslationEnabled: null,
@@ -57,6 +60,8 @@ describe('plugin-meetings', () => {
       'canLock',
       'canUnlock',
       'canAssignHost',
+      'canSetPresenter',
+      'canUnsetPresenter',
       'canStartRecording',
       'canPauseRecording',
       'canResumeRecording',
@@ -72,6 +77,7 @@ describe('plugin-meetings', () => {
       'canEnableClosedCaption',
       'canStopTranscribing',
       'isClosedCaptionActive',
+      'isSaveTranscriptsEnabled',
       'isWebexAssistantActive',
       'canViewCaptionPanel',
       'isRealTimeTranslationEnabled',

package/test/unit/spec/meeting/utils.js

@@ -389,6 +389,7 @@ describe('plugin-meetings', () => {
     });
 
     [
+      {functionName: 'isSaveTranscriptsEnabled', displayHint: 'SAVE_TRANSCRIPTS_ENABLED'},
       {functionName: 'canEnableClosedCaption', displayHint: 'CAPTION_START'},
       {functionName: 'canStartTranscribing', displayHint: 'TRANSCRIPTION_CONTROL_START'},
       {functionName: 'canStopTranscribing', displayHint: 'TRANSCRIPTION_CONTROL_STOP'},

package/test/unit/spec/member/index.js

@@ -19,4 +19,28 @@ describe('member', () => {
 
     assert.calledOnceWithExactly(MemberUtil.isHandRaised, participant);
   });
+
+  describe('roles', () => {
+    it('checks that processParticipant calls processRoles', () => {
+      const participant = {};
+
+      const member = new Member({});
+  
+      sinon.spy(member, 'processRoles');
+      member.processParticipant(participant);
+  
+      assert.calledOnceWithExactly(member.processRoles, participant);
+    });
+
+    it('checks that processRoles calls extractControlRoles', () => {
+      const participant = {};
+
+      const member = new Member({});
+  
+      sinon.spy(MemberUtil, 'extractControlRoles');
+      member.processParticipant(participant);
+  
+      assert.calledOnceWithExactly(MemberUtil.extractControlRoles, participant);
+    });
+  })
 });