@webex/plugin-meetings 3.7.0-next.1 → 3.7.0-next.11

package/src/meeting/util.ts

@@ -197,6 +197,7 @@ const MeetingUtil = {
 
   cleanUp: (meeting) => {
     meeting.getWebexObject().internal.device.meetingEnded();
+    meeting.stopPeriodicLogUpload();
 
     meeting.breakouts.cleanUp();
     meeting.simultaneousInterpretation.cleanUp();

package/src/meetings/index.ts

@@ -155,6 +155,9 @@ export type BasicMeetingInformation = {
   };
   meetingInfo: any;
   sessionCorrelationId: string;
+  roles: string[];
+  getCurUserType: () => string | null;
+  callStateForMetrics: CallStateForMetrics;
 };
 
 /**
@@ -1143,6 +1146,9 @@ export default class Meetings extends WebexPlugin {
           sessionId: meeting.locusInfo?.fullState?.sessionId,
         },
       },
+      roles: meeting.roles,
+      callStateForMetrics: meeting.callStateForMetrics,
+      getCurUserType: meeting.getCurUserType,
     });
     this.meetingCollection.delete(meeting.id);
     Trigger.trigger(

package/src/members/util.ts

@@ -46,6 +46,7 @@ const MembersUtil = {
       {
         address:
           options.invitee.emailAddress || options.invitee.email || options.invitee.phoneNumber,
+        ...(options.invitee.roles ? {roles: options.invitee.roles} : {}),
       },
     ],
     alertIfActive: options.alertIfActive,

package/src/metrics/constants.ts

@@ -71,6 +71,8 @@ const BEHAVIORAL_METRICS = {
   TURN_DISCOVERY_REQUIRES_OK: 'js_sdk_turn_discovery_requires_ok',
   REACHABILITY_COMPLETED: 'js_sdk_reachability_completed',
   WEBINAR_REGISTRATION_ERROR: 'js_sdk_webinar_registration_error',
+  GUEST_ENTERED_LOBBY: 'js_sdk_guest_entered_lobby',
+  GUEST_EXITED_LOBBY: 'js_sdk_guest_exited_lobby',
 };
 
 export {BEHAVIORAL_METRICS as default};

package/src/reachability/clusterReachability.ts

@@ -357,11 +357,14 @@ export class ClusterReachability extends EventsScope {
 
       this.startTimestamp = performance.now();
 
+      // Set up the state change listeners before triggering the ICE gathering
+      const gatherIceCandidatePromise = this.gatherIceCandidates();
+
       // not awaiting the next call on purpose, because we're not sending the offer anywhere and there won't be any answer
       // we just need to make this call to trigger the ICE gathering process
       this.pc.setLocalDescription(offer);
 
-      await this.gatherIceCandidates();
+      await gatherIceCandidatePromise;
     } catch (error) {
       LoggerProxy.logger.warn(`Reachability:ClusterReachability#start --> Error: `, error);
     }

package/src/recording-controller/enums.ts

@@ -1,8 +1,11 @@
-enum RecordingAction {
+export enum RecordingAction {
   Start = 'Start',
   Stop = 'Stop',
   Pause = 'Pause',
   Resume = 'Resume',
 }
 
-export default RecordingAction;
+export enum RecordingType {
+  Premise = 'premise',
+  Cloud = 'cloud',
+}

package/src/recording-controller/index.ts

@@ -1,9 +1,9 @@
 import PermissionError from '../common/errors/permission';
+import LoggerProxy from '../common/logs/logger-proxy';
 import {CONTROLS, HTTP_VERBS, SELF_POLICY} from '../constants';
 import MeetingRequest from '../meeting/request';
-import RecordingAction from './enums';
+import {RecordingAction, RecordingType} from './enums';
 import Util from './util';
-import LoggerProxy from '../common/logs/logger-proxy';
 
 /**
  * @description Recording manages the recording functionality of the meeting object, there should only be one instantation of recording per meeting
@@ -228,11 +228,12 @@ export default class RecordingController {
 
   /**
    * @param {RecordingAction} action
+   * @param {RecordingType} recordingType
    * @private
    * @memberof RecordingController
    * @returns {Promise}
    */
-  private recordingService(action: RecordingAction): Promise<any> {
+  private recordingService(action: RecordingAction, recordingType: RecordingType): Promise<any> {
     // @ts-ignore
     return this.request.request({
       body: {
@@ -242,6 +243,7 @@ export default class RecordingController {
         recording: {
           action: action.toLowerCase(),
         },
+        recordingType,
       },
       uri: `${this.serviceUrl}/loci/${this.locusId}/recording`,
       method: HTTP_VERBS.PUT,
@@ -276,14 +278,25 @@ export default class RecordingController {
    * @returns {Promise}
    */
   private recordingFacade(action: RecordingAction): Promise<any> {
+    const isPremiseRecordingEnabled = Util.isPremiseRecordingEnabled(
+      this.displayHints,
+      this.selfUserPolicies
+    );
     LoggerProxy.logger.log(
       `RecordingController:index#recordingFacade --> recording action [${action}]`
     );
 
+    let recordingType: RecordingType;
+    if (isPremiseRecordingEnabled) {
+      recordingType = RecordingType.Premise;
+    } else {
+      recordingType = RecordingType.Cloud;
+    }
+
     // assumes action is proper cased (i.e., Example)
     if (Util?.[`canUser${action}`](this.displayHints, this.selfUserPolicies)) {
       if (this.serviceUrl) {
-        return this.recordingService(action);
+        return this.recordingService(action, recordingType);
       }
 
       return this.recordingControls(action);

package/src/recording-controller/util.ts

@@ -1,33 +1,47 @@
 import {DISPLAY_HINTS, SELF_POLICY} from '../constants';
-import RecordingAction from './enums';
+import {RecordingAction} from './enums';
 import MeetingUtil from '../meeting/util';
 
 const canUserStart = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserPause = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserResume = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const canUserStop = (
   displayHints: Array<string>,
   userPolicies: Record<SELF_POLICY, boolean>
 ): boolean =>
-  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) &&
+  (displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP)) &&
+  MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
+
+const isPremiseRecordingEnabled = (
+  displayHints: Array<string>,
+  userPolicies: Record<SELF_POLICY, boolean>
+): boolean =>
+  (displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_START) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_PAUSE) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_STOP) ||
+    displayHints.includes(DISPLAY_HINTS.PREMISE_RECORDING_CONTROL_RESUME)) &&
   MeetingUtil.selfSupportsFeature(SELF_POLICY.SUPPORT_NETWORK_BASED_RECORD, userPolicies);
 
 const extractLocusId = (url: string) => {
@@ -70,6 +84,7 @@ export default {
   canUserPause,
   canUserResume,
   canUserStop,
+  isPremiseRecordingEnabled,
   deriveRecordingStates,
   extractLocusId,
 };

package/src/webinar/index.ts

@@ -3,9 +3,10 @@
  */
 import {WebexPlugin} from '@webex/webex-core';
 import {get} from 'lodash';
-import {MEETINGS, SELF_ROLES} from '../constants';
+import {HTTP_VERBS, MEETINGS, SELF_ROLES} from '../constants';
 
 import WebinarCollection from './collection';
+import LoggerProxy from '../common/logs/logger-proxy';
 
 /**
  * @class Webinar
@@ -22,6 +23,7 @@ const Webinar = WebexPlugin.extend({
     canManageWebcast: 'boolean', // appears the ability to manage webcast
     selfIsPanelist: 'boolean', // self is panelist
     selfIsAttendee: 'boolean', // self is attendee
+    practiceSessionEnabled: 'boolean', // practice session enabled
   },
 
   /**
@@ -59,18 +61,48 @@ const Webinar = WebexPlugin.extend({
    * @returns {{isPromoted: boolean, isDemoted: boolean}} Role transition states
    */
   updateRoleChanged(payload) {
+    const oldRoles = get(payload, 'oldRoles', []);
+    const newRoles = get(payload, 'newRoles', []);
+
     const isPromoted =
-      get(payload, 'oldRoles', []).includes(SELF_ROLES.ATTENDEE) &&
-      get(payload, 'newRoles', []).includes(SELF_ROLES.PANELIST);
+      oldRoles.includes(SELF_ROLES.ATTENDEE) && newRoles.includes(SELF_ROLES.PANELIST);
     const isDemoted =
-      get(payload, 'oldRoles', []).includes(SELF_ROLES.PANELIST) &&
-      get(payload, 'newRoles', []).includes(SELF_ROLES.ATTENDEE);
-    this.set('selfIsPanelist', get(payload, 'newRoles', []).includes(SELF_ROLES.PANELIST));
-    this.set('selfIsAttendee', get(payload, 'newRoles', []).includes(SELF_ROLES.ATTENDEE));
-    this.updateCanManageWebcast(get(payload, 'newRoles', []).includes(SELF_ROLES.MODERATOR));
+      oldRoles.includes(SELF_ROLES.PANELIST) && newRoles.includes(SELF_ROLES.ATTENDEE);
+    this.set('selfIsPanelist', newRoles.includes(SELF_ROLES.PANELIST));
+    this.set('selfIsAttendee', newRoles.includes(SELF_ROLES.ATTENDEE));
+    this.updateCanManageWebcast(newRoles.includes(SELF_ROLES.MODERATOR));
 
     return {isPromoted, isDemoted};
   },
+
+  /**
+   * start or stop practice session for webinar
+   * @param {boolean} enabled
+   * @returns {Promise}
+   */
+  setPracticeSessionState(enabled) {
+    return this.request({
+      method: HTTP_VERBS.PATCH,
+      uri: `${this.locusUrl}/controls`,
+      body: {
+        practiceSession: {
+          enabled,
+        },
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:webinar#setPracticeSessionState failed', error);
+      throw error;
+    });
+  },
+
+  /**
+   * update practice session status
+   * @param {object} payload
+   * @returns {void}
+   */
+  updatePracticeSessionStatus(payload) {
+    this.set('practiceSessionEnabled', payload.enabled);
+  },
 });
 
 export default Webinar;

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

@@ -33,6 +33,7 @@ describe('plugin-meetings', () => {
         canStartManualCaption: null,
         canStopManualCaption: null,
         isManualCaptionActive: null,
+        isPremiseRecordingEnabled: null,
         isSaveTranscriptsEnabled: null,
         isWebexAssistantActive: null,
         canViewCaptionPanel: null,
@@ -88,6 +89,11 @@ describe('plugin-meetings', () => {
         canShowStageView: null,
         canEnableStageView: null,
         canDisableStageView: null,
+        isPracticeSessionOn : null,
+        isPracticeSessionOff : null,
+        canStartPracticeSession: null,
+        canStopPracticeSession: null,
+
         ...expected,
       };
 
@@ -126,6 +132,7 @@ describe('plugin-meetings', () => {
       'canStartManualCaption',
       'canStopManualCaption',
       'isManualCaptionActive',
+      'isPremiseRecordingEnabled',
       'isSaveTranscriptsEnabled',
       'isWebexAssistantActive',
       'canViewCaptionPanel',
@@ -181,7 +188,12 @@ describe('plugin-meetings', () => {
       'canShowStageView',
       'canEnableStageView',
       'canDisableStageView',
-    ].forEach((key) => {
+      'isPracticeSessionOn',
+      'isPracticeSessionOff',
+      'canStartPracticeSession',
+      'canStopPracticeSession',
+
+  ].forEach((key) => {
       it(`get and set for ${key} work as expected`, () => {
         const inMeetingActions = new InMeetingActions();
 

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

@@ -2465,6 +2465,61 @@ describe('plugin-meetings', () => {
           checkWorking();
         });
 
+        it('should upload logs periodically', async () => {
+          const clock = sinon.useFakeTimers();
+
+          meeting.roap.doTurnDiscovery = sinon
+            .stub()
+            .resolves({turnServerInfo: undefined, turnDiscoverySkippedReason: undefined});
+
+          let logUploadCounter = 0;
+
+          TriggerProxy.trigger.callsFake((meetingObject, options, event) => {
+            if (
+              meetingObject === meeting &&
+              options.file === 'meeting/index' &&
+              options.function === 'uploadLogs' &&
+              event === 'REQUEST_UPLOAD_LOGS'
+            ) {
+              logUploadCounter += 1;
+            }
+          });
+
+          meeting.config.logUploadIntervalMultiplicationFactor = 1;
+          meeting.meetingState = 'ACTIVE';
+
+          await meeting.addMedia({
+            mediaSettings: {},
+          });
+
+          const checkLogCounter = (delayInMinutes, expectedCounter) => {
+            const delayInMilliseconds = delayInMinutes * 60 * 1000;
+
+            // first check that the counter is not increased just before the delay
+            clock.tick(delayInMilliseconds - 50);
+            assert.equal(logUploadCounter, expectedCounter - 1);
+
+            // and now check that it has reached expected value after the delay
+            clock.tick(50);
+            assert.equal(logUploadCounter, expectedCounter);
+          };
+
+          checkLogCounter(0.1, 1);
+          checkLogCounter(15, 2);
+          checkLogCounter(30, 3);
+          checkLogCounter(60, 4);
+          checkLogCounter(60, 5);
+
+          // simulate media connection being removed -> 1 more upload should happen, but nothing more afterwards
+          meeting.mediaProperties.webrtcMediaConnection = undefined;
+          checkLogCounter(60, 6);
+
+          clock.tick(120*1000*60);
+          assert.equal(logUploadCounter, 6);
+
+          clock.restore();
+        });
+
         it('should attach the media and return promise when in the lobby if allowMediaInLobby is set', async () => {
           meeting.roap.doTurnDiscovery = sinon
             .stub()
@@ -8620,6 +8675,13 @@ describe('plugin-meetings', () => {
             {payload: test1}
           );
           assert.calledOnce(meeting.updateLLMConnection);
+          assert.calledOnceWithExactly(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.GUEST_ENTERED_LOBBY,
+            {
+              correlation_id: meeting.correlationId,
+            }
+          );
           done();
         });
         it('listens to the self admitted guest event', (done) => {
@@ -8641,6 +8703,13 @@ describe('plugin-meetings', () => {
           assert.calledOnce(meeting.updateLLMConnection);
           assert.calledOnceWithExactly(meeting.rtcMetrics.sendNextMetrics);
 
+          assert.calledOnceWithExactly(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.GUEST_EXITED_LOBBY,
+            {
+              correlation_id: meeting.correlationId,
+            }
+          );
           done();
         });
 
@@ -8973,6 +9042,8 @@ describe('plugin-meetings', () => {
         });
 
         it('listens to MEETING_CONTROLS_PRACTICE_SESSION_STATUS_UPDATED', async () => {
+          meeting.webinar.updatePracticeSessionStatus = sinon.stub();
+
           const state = {example: 'value'};
 
           await meeting.locusInfo.emitScoped(
@@ -8981,6 +9052,7 @@ describe('plugin-meetings', () => {
             {state}
           );
 
+          assert.calledOnceWithExactly( meeting.webinar.updatePracticeSessionStatus, state);
           assert.calledWith(
             TriggerProxy.trigger,
             meeting,

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

@@ -45,6 +45,7 @@ describe('plugin-meetings', () => {
       meeting.cleanupLocalStreams = sinon.stub().returns(Promise.resolve());
       meeting.closeRemoteStreams = sinon.stub().returns(Promise.resolve());
       meeting.closePeerConnections = sinon.stub().returns(Promise.resolve());
+      meeting.stopPeriodicLogUpload = sinon.stub();
 
       meeting.unsetRemoteStreams = sinon.stub();
       meeting.unsetPeerConnections = sinon.stub();
@@ -70,6 +71,7 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.cleanupLocalStreams);
         assert.calledOnce(meeting.closeRemoteStreams);
         assert.calledOnce(meeting.closePeerConnections);
+        assert.calledOnce(meeting.stopPeriodicLogUpload);
 
         assert.calledOnce(meeting.unsetRemoteStreams);
         assert.calledOnce(meeting.unsetPeerConnections);

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

@@ -131,9 +131,9 @@ describe('plugin-meetings', () => {
         logger,
         people: {
           _getMe: sinon.stub().resolves({
-            type: 'validuser', 
+            type: 'validuser',
           }),
-        }
+        },
       });
 
       startReachabilityStub = sinon.stub(webex.meetings, 'startReachability').resolves();
@@ -1985,6 +1985,8 @@ describe('plugin-meetings', () => {
             const meetingIds = {
               meetingId: meeting.id,
               correlationId: meeting.correlationId,
+              roles: meeting.roles,
+              callStateForMetrics: meeting.callStateForMetrics,
             };
 
             webex.meetings.destroy(meeting, test1);
@@ -2021,6 +2023,8 @@ describe('plugin-meetings', () => {
 
             assert.equal(deletedMeetingInfo.id, meetingIds.meetingId);
             assert.equal(deletedMeetingInfo.correlationId, meetingIds.correlationId);
+            assert.equal(deletedMeetingInfo.roles, meetingIds.roles);
+            assert.equal(deletedMeetingInfo.callStateForMetrics, meetingIds.callStateForMetrics);
           });
         });
 
@@ -2092,7 +2096,7 @@ describe('plugin-meetings', () => {
           );
         });
 
-        const setup = ({me = { type: 'validuser'}, user} = {}) => {
+        const setup = ({me = {type: 'validuser'}, user} = {}) => {
           loggerProxySpy = sinon.spy(LoggerProxy.logger, 'error');
           assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), []);
 
@@ -2113,9 +2117,9 @@ describe('plugin-meetings', () => {
 
         it('should not call request.getMeetingPreferences if user is a guest', async () => {
           setup({me: {type: 'appuser'}});
-      
+
           await webex.meetings.fetchUserPreferredWebexSite();
-      
+
           assert.equal(webex.meetings.preferredWebexSite, '');
           assert.deepEqual(webex.internal.services._getCatalog().getAllowedDomains(), []);
           assert.notCalled(webex.internal.services.getMeetingPreferences);

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

@@ -262,5 +262,100 @@ describe('plugin-meetings', () => {
         testParams(false);
       });
     });
+
+    describe('#getAddMemberBody', () => {
+      it('returns the correct body with email address and roles', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+            roles: ['role1', 'role2'],
+          },
+          alertIfActive: true,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+              roles: ['role1', 'role2'],
+            },
+          ],
+          alertIfActive: true,
+        });
+      });
+
+      it('returns the correct body with phone number and no roles', () => {
+        const options = {
+          invitee: {
+            phoneNumber: '1234567890',
+          },
+          alertIfActive: false,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: '1234567890',
+            },
+          ],
+          alertIfActive: false,
+        });
+      });
+
+      it('returns the correct body with fallback to email', () => {
+        const options = {
+          invitee: {
+            email: 'fallback@example.com',
+          },
+          alertIfActive: true,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'fallback@example.com',
+            },
+          ],
+          alertIfActive: true,
+        });
+      });
+
+      it('handles missing `alertIfActive` gracefully', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+            roles: ['role1'],
+          },
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+              roles: ['role1'],
+            },
+          ],
+          alertIfActive: undefined,
+        });
+      });
+
+      it('ignores roles if not provided', () => {
+        const options = {
+          invitee: {
+            emailAddress: 'test@example.com',
+          },
+          alertIfActive: false,
+        };
+
+        assert.deepEqual(MembersUtil.getAddMemberBody(options), {
+          invitees: [
+            {
+              address: 'test@example.com',
+            },
+          ],
+          alertIfActive: false,
+        });
+      });
+    });
   });
 });

package/test/unit/spec/reachability/clusterReachability.ts

@@ -15,6 +15,7 @@ describe('ClusterReachability', () => {
   let previousRTCPeerConnection;
   let clusterReachability;
   let fakePeerConnection;
+  let gatherIceCandidatesSpy;
 
   const emittedEvents: Record<Events, (ResultEventData | ClientMediaIpsUpdatedEventData)[]> = {
     [Events.resultReady]: [],
@@ -44,6 +45,8 @@ describe('ClusterReachability', () => {
       xtls: ['stun:xtls1.webex.com', 'stun:xtls2.webex.com:443'],
     });
 
+    gatherIceCandidatesSpy = sinon.spy(clusterReachability, 'gatherIceCandidates');
+
     resetEmittedEvents();
 
     clusterReachability.on(Events.resultReady, (data: ResultEventData) => {
@@ -151,6 +154,10 @@ describe('ClusterReachability', () => {
       assert.calledOnceWithExactly(fakePeerConnection.createOffer, {offerToReceiveAudio: true});
       assert.calledOnce(fakePeerConnection.setLocalDescription);
 
+      // Make sure that gatherIceCandidates is called before setLocalDescription
+      // as setLocalDescription triggers the ICE gathering process
+      assert.isTrue(gatherIceCandidatesSpy.calledBefore(fakePeerConnection.setLocalDescription));
+
       clusterReachability.abort();
       await promise;