@webex/plugin-meetings 3.12.0-next.4 → 3.12.0-next.41

package/src/meetings/util.ts

@@ -18,6 +18,7 @@ import Trigger from '../common/events/trigger-proxy';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import Metrics from '../metrics';
 import {MEETING_KEY} from './meetings.types';
+import {EndMeetingReason, LocusFullState} from '../locus-info/types';
 
 /**
  * Meetings Media Codec Missing Event
@@ -266,6 +267,35 @@ MeetingsUtil.getThisDevice = (newLocus: any, deviceUrl: string) => {
   return null;
 };
 
+/**
+ * Checks if the fullState indicates the meeting has fully ended (not just a breakout move).
+ * @param {Object} fullState locus fullState data
+ * @returns {boolean}
+ */
+MeetingsUtil.isWholeMeetingEnded = (fullState: LocusFullState): boolean => {
+  return (
+    fullState.state === LOCUS.STATE.INACTIVE &&
+    fullState.endMeetingReason !== EndMeetingReason.breakoutEnded
+  );
+};
+
+/**
+ * Checks if the self state in a locus indicates a breakout move or breakout end.
+ * Returns true when:
+ * - self state is LEFT with reason MOVED (regular breakout move), OR
+ * - fullState is INACTIVE with endMeetingReason BREAKOUT_ENDED (breakout session ended)
+ * @param {Object} locus locus data
+ * @returns {boolean}
+ */
+MeetingsUtil.isSelfMovedOrBreakoutEnded = (locus: any): boolean => {
+  const isSelfLeftMoved = locus?.self?.state === _LEFT_ && locus?.self?.reason === _MOVED_;
+  const isBreakoutEnded =
+    locus?.fullState?.state === LOCUS.STATE.INACTIVE &&
+    locus?.fullState?.endMeetingReason === EndMeetingReason.breakoutEnded;
+
+  return isSelfLeftMoved || isBreakoutEnded;
+};
+
 /**
  * get self device joined status from locus data
  * @param {Object} meeting current meeting data
@@ -294,7 +324,10 @@ MeetingsUtil.joinedOnThisDevice = (meeting: any, newLocus: any, deviceUrl: strin
  * @private
  */
 MeetingsUtil.isBreakoutLocusDTO = (newLocus: any) => {
-  return newLocus?.controls?.breakout?.sessionType === BREAKOUTS.SESSION_TYPES.BREAKOUT;
+  return (
+    newLocus?.controls?.breakout?.sessionType === BREAKOUTS.SESSION_TYPES.BREAKOUT ||
+    !!newLocus?.info?.isBreakout
+  );
 };
 
 /**
@@ -310,4 +343,26 @@ MeetingsUtil.isValidBreakoutLocus = (locus: any) => {
 
   return isLocusAsBreakout && !inActiveStatus && selfJoined;
 };
+/**
+ * check if the breakout locus is associated with the main locus by comparing the breakout control url or the replaces info in self device
+ * @param {Object} mainLocus main locus data
+ * @param {Object} breakoutLocus breakout locus data
+ * @returns {boolean}
+ * @private
+ */
+MeetingsUtil.isMainAssociatedWithBreakout = (mainLocus: any, breakoutLocus: any) => {
+  if (
+    mainLocus.controls?.breakout?.url &&
+    mainLocus.controls?.breakout?.url === breakoutLocus.controls?.breakout?.url
+  ) {
+    return true;
+  }
+  const deviceUrl = breakoutLocus?.self?.deviceUrl;
+  const replaceInfo = MeetingsUtil.getThisDevice(breakoutLocus, deviceUrl)?.replaces?.[0];
+  if (replaceInfo?.locusUrl && replaceInfo.locusUrl === mainLocus.url) {
+    return true;
+  }
+
+  return false;
+};
 export default MeetingsUtil;

package/src/member/index.ts

@@ -27,6 +27,7 @@ export default class Member {
   isModerator: any;
   isModeratorAssignmentProhibited: any;
   isPresenterAssignmentProhibited: any;
+  isAttendeeAssignmentProhibited: any;
   isMutable: any;
   isNotAdmitted: any;
   isRecording: any;
@@ -292,6 +293,14 @@ export default class Member {
      */
     this.isPresenterAssignmentProhibited = null;
 
+    /**
+     * @instance
+     * @type {Boolean}
+     * @public
+     * @memberof Member
+     */
+    this.isAttendeeAssignmentProhibited = null;
+
     /**
      * @instance
      * @type {Boolean}
@@ -369,6 +378,7 @@ export default class Member {
         MemberUtil.isModeratorAssignmentProhibited(participant);
       this.isPresenterAssignmentProhibited =
         MemberUtil.isPresenterAssignmentProhibited(participant);
+      this.isAttendeeAssignmentProhibited = MemberUtil.isAttendeeAssignmentProhibited(participant);
       this.canApproveAIEnablement = MemberUtil.canApproveAIEnablement(participant);
       this.processStatus(participant);
       this.processRoles(participant);

package/src/member/types.ts

@@ -103,6 +103,7 @@ export interface Participant {
   moderator: boolean; // Locus docs say this is deprecated and role control should be used instead
   moderatorAssignmentNotAllowed: boolean;
   presenterAssignmentNotAllowed: boolean;
+  attendeeAssignmentNotAllowed?: boolean;
   person: ParticipantPerson;
   resourceGuest: boolean;
   state: string; // probably one of MEETING_STATE.STATES

package/src/member/util.ts

@@ -140,6 +140,9 @@ const MemberUtil = {
   isPresenterAssignmentProhibited: (participant: Participant) =>
     participant && participant.presenterAssignmentNotAllowed,
 
+  isAttendeeAssignmentProhibited: (participant: Participant) =>
+    !!(participant && participant.attendeeAssignmentNotAllowed),
+
   /**
    * checks to see if the participant id is the same as the passed id
    * there are multiple ids that can be used

package/src/webinar/index.ts

@@ -154,12 +154,63 @@ const Webinar = WebexPlugin.extend({
     );
   },
 
+  /**
+   * Ensures practice-session token exists before registering the practice LLM channel.
+   * @param {object} meeting
+   * @returns {Promise<string|undefined>}
+   */
+  async ensurePracticeSessionDatachannelToken(meeting) {
+    // @ts-ignore
+    const isDataChannelTokenEnabled = await this.webex.internal.llm.isDataChannelTokenEnabled();
+
+    if (!isDataChannelTokenEnabled) {
+      return undefined;
+    }
+
+    // @ts-ignore
+    const cachedToken = this.webex.internal.llm.getDatachannelToken(
+      DataChannelTokenType.PracticeSession
+    );
+
+    if (cachedToken) {
+      return cachedToken;
+    }
+
+    try {
+      const refreshResponse = await meeting.refreshDataChannelToken();
+      const {datachannelToken, dataChannelTokenType} = refreshResponse?.body ?? {};
+
+      if (!datachannelToken) {
+        return undefined;
+      }
+
+      // @ts-ignore
+      this.webex.internal.llm.setDatachannelToken(
+        datachannelToken,
+        dataChannelTokenType || DataChannelTokenType.PracticeSession
+      );
+
+      return datachannelToken;
+    } catch (error) {
+      LoggerProxy.logger.warn(
+        `Webinar:index#ensurePracticeSessionDatachannelToken --> failed to proactively refresh practice-session token: ${
+          error?.message || String(error)
+        }`
+      );
+
+      return undefined;
+    }
+  },
+
   /**
    * Connects to low latency mercury and reconnects if the address has changed
    * It will also disconnect if called when the meeting has ended
    * @returns {Promise}
    */
   async updatePSDataChannel() {
+    this._updatePSDataChannelSequence = (this._updatePSDataChannelSequence || 0) + 1;
+    const invocationSequence = this._updatePSDataChannelSequence;
+
     const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
     const isPracticeSession = meeting?.isJoined() && this.isJoinPracticeSessionDataChannel();
 
@@ -174,7 +225,7 @@ const Webinar = WebexPlugin.extend({
       meeting?.locusInfo || {};
 
     // @ts-ignore
-    const practiceSessionDatachannelToken = this.webex.internal.llm.getDatachannelToken(
+    let practiceSessionDatachannelToken = this.webex.internal.llm.getDatachannelToken(
       DataChannelTokenType.PracticeSession
     );
 
@@ -229,6 +280,29 @@ const Webinar = WebexPlugin.extend({
       this._pendingOnlineListener = null;
     }
 
+    const refreshedPracticeSessionToken = await this.ensurePracticeSessionDatachannelToken(meeting);
+
+    const latestPracticeSessionDatachannelUrl = get(
+      meeting,
+      'locusInfo.info.practiceSessionDatachannelUrl'
+    );
+    const isStillPracticeSession = meeting?.isJoined() && this.isJoinPracticeSessionDataChannel();
+
+    // Skip stale invocations after async refresh to avoid reconnecting a session
+    // that was already updated/cleaned by a newer state transition.
+    if (
+      invocationSequence !== this._updatePSDataChannelSequence ||
+      !isStillPracticeSession ||
+      !latestPracticeSessionDatachannelUrl ||
+      latestPracticeSessionDatachannelUrl !== practiceSessionDatachannelUrl
+    ) {
+      return undefined;
+    }
+
+    if (refreshedPracticeSessionToken) {
+      practiceSessionDatachannelToken = refreshedPracticeSessionToken;
+    }
+
     // @ts-ignore - Fix type
     return this.webex.internal.llm
       .registerAndConnect(

package/test/unit/spec/aiEnableRequest/index.ts

@@ -55,6 +55,27 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#locusUrlUpdate', () => {
+      it('should update the locusUrl property', () => {
+        const testLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id';
+
+        aiEnableRequest.locusUrlUpdate(testLocusUrl);
+
+        assert.equal(aiEnableRequest.locusUrl, testLocusUrl);
+      });
+
+      it('should handle updating locusUrl multiple times', () => {
+        const firstUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id-1';
+        const secondUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id-2';
+
+        aiEnableRequest.locusUrlUpdate(firstUrl);
+        assert.equal(aiEnableRequest.locusUrl, firstUrl);
+
+        aiEnableRequest.locusUrlUpdate(secondUrl);
+        assert.equal(aiEnableRequest.locusUrl, secondUrl);
+      });
+    });
+
     describe('#selfParticipantIdUpdate', () => {
       it('should update the selfParticipantId property', () => {
         const testSelfParticipantId = 'participant-123';
@@ -254,6 +275,71 @@ describe('plugin-meetings', () => {
         sinon.assert.notCalled(triggerSpy);
       });
 
+      it('should not trigger event when locusUrl does not match', () => {
+        const testLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id';
+        const differentLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/different-id';
+
+        aiEnableRequest.locusUrl = testLocusUrl;
+
+        // Reset the spy after setting locusUrl to avoid counting property change events
+        triggerSpy.resetHistory();
+
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            locusUrl: differentLocusUrl,
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testSelfParticipantId}],
+              initiator: {participantId: testInitiatorId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.notCalled(triggerSpy);
+      });
+
+      it('should trigger event when locusUrl matches', () => {
+        const testLocusUrl = 'https://locus-a.wbx2.com/locus/api/v1/loci/test-id';
+
+        aiEnableRequest.locusUrl = testLocusUrl;
+
+        // Reset the spy after setting locusUrl to avoid counting property change events
+        triggerSpy.resetHistory();
+
+        aiEnableRequest.listenToApprovalRequests();
+
+        const event = {
+          data: {
+            locusUrl: testLocusUrl,
+            approval: {
+              resourceType: AI_ENABLE_REQUEST.RESOURCE_TYPE,
+              receivers: [{participantId: testSelfParticipantId}],
+              initiator: {participantId: testInitiatorId},
+              actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+              url: testUrl,
+            },
+          },
+        };
+
+        webex.internal.mercury.emit(`event:${LOCUSEVENT.APPROVAL_REQUEST}`, event);
+
+        sinon.assert.calledOnce(triggerSpy);
+        sinon.assert.calledWith(triggerSpy, AI_ENABLE_REQUEST.EVENTS.APPROVAL_REQUEST_ARRIVED, {
+          actionType: AI_ENABLE_REQUEST.ACTION_TYPE.REQUESTED,
+          isApprover: true,
+          isInitiator: false,
+          initiatorId: testInitiatorId,
+          approverId: testSelfParticipantId,
+          url: testUrl,
+        });
+      });
+
       it('should handle events with different action types', () => {
         aiEnableRequest.listenToApprovalRequests();
 

package/test/unit/spec/breakouts/breakout.ts

@@ -217,10 +217,14 @@ describe('plugin-meetings', () => {
           locusParticipantsUpdate: sinon.stub(),
         };
 
-        const locusData = {some: 'data'};
+        const locusData = {participants: [{id: 'participant-1'}], sequence: {entries: [123]}};
         const result = breakout.parseRoster(locusData);
 
-        assert.calledOnceWithExactly(breakout.members.locusParticipantsUpdate, locusData);
+        assert.calledOnceWithExactly(breakout.members.locusParticipantsUpdate, {
+          participants: [{id: 'participant-1'}],
+          isReplace: true,
+        });
+        assert.equal(breakout.breakoutRosterLocus, locusData);
         assert.equal(result, undefined);
       });
       it('not call locusParticipantsUpdate if sequence is expired', () => {
@@ -228,7 +232,7 @@ describe('plugin-meetings', () => {
           locusParticipantsUpdate: sinon.stub(),
         };
         breakout.isNeedHandleRoster = sinon.stub().returns(false);
-        const locusData = {some: 'data'};
+        const locusData = {participants: [{id: 'participant-1'}], sequence: {entries: [123]}};
         breakout.parseRoster(locusData);
 
         assert.notCalled(breakout.members.locusParticipantsUpdate);

package/test/unit/spec/controls-options-manager/index.js

@@ -1,5 +1,6 @@
 import ControlsOptionsManager from '@webex/plugin-meetings/src/controls-options-manager';
 import Util from '@webex/plugin-meetings/src/controls-options-manager/util';
+import ParameterError from '@webex/plugin-meetings/src/common/errors/parameter';
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import { HTTP_VERBS } from '@webex/plugin-meetings/src/constants';
@@ -76,6 +77,19 @@ describe('plugin-meetings', () => {
 
                       assert.deepEqual(result, request.request.firstCall.returnValue);
                     });
+
+                    it('should send setMuteOnEntry to locusUrl without authorizingLocusUrl when in breakout', () => {
+                      manager.setDisplayHints(['ENABLE_MUTE_ON_ENTRY']);
+                      manager.mainLocusUrl = 'test/main';
+
+                      const result = manager.setMuteOnEntry(true);
+
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { muteOnEntry: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
                   });
 
                   describe('setDisallowUnmute', () => {
@@ -118,6 +132,19 @@ describe('plugin-meetings', () => {
 
                       assert.deepEqual(result, request.request.firstCall.returnValue);
                     });
+
+                    it('should send setDisallowUnmute to locusUrl without authorizingLocusUrl when in breakout', () => {
+                      manager.setDisplayHints(['ENABLE_HARD_MUTE']);
+                      manager.mainLocusUrl = 'test/main';
+
+                      const result = manager.setDisallowUnmute(true);
+
+                      assert.calledWith(request.request, {  uri: 'test/id/controls',
+                      body: { disallowUnmute: { enabled: true } },
+                      method: HTTP_VERBS.PATCH});
+
+                      assert.deepEqual(result, request.request.firstCall.returnValue);
+                    });
                   });
             });
 
@@ -138,6 +165,18 @@ describe('plugin-meetings', () => {
                 });
               });
 
+              it('should reject with ParameterError when locusUrl is not set', () => {
+                const noLocusManager = new ControlsOptionsManager(request);
+
+                const result = noLocusManager.update({scope: 'audio', properties: {muted: true}});
+
+                assert.notCalled(request.request);
+                return assert.isRejected(result).then((err) => {
+                  assert.instanceOf(err, ParameterError);
+                  assert.match(err.message, /locusUrl.*must be defined/);
+                });
+              });
+
               it('should throw an error if the scope is not supported', () => {
                 const scope = 'invalid';
 
@@ -203,7 +242,7 @@ describe('plugin-meetings', () => {
                   });
               });
 
-              it('should call request with mainLocusUrl and locusUrl as authorizingLocusUrl if mainLocusUrl is exist and not same with locusUrl', () => {
+              it('should send audio controls to locusUrl without authorizingLocusUrl and non-audio to mainLocusUrl with authorizingLocusUrl when in breakout', () => {
                 const restorable = Util.canUpdate;
                 Util.canUpdate = sinon.stub().returns(true);
                 manager.mainLocusUrl = 'test/main';
@@ -213,15 +252,16 @@ describe('plugin-meetings', () => {
 
                 return manager.update(audio, reactions)
                   .then(() => {
+                    // Audio controls go directly to current locusUrl (no cross-locus authorization)
                     assert.calledWith(request.request, {
-                      uri: 'test/main/controls',
+                      uri: 'test/id/controls',
                       body: {
                         audio: audio.properties,
-                        authorizingLocusUrl: 'test/id'
                       },
                       method: HTTP_VERBS.PATCH,
                     });
 
+                    // Non-audio controls go to mainLocusUrl with authorizingLocusUrl
                     assert.calledWith(request.request, {
                       uri: 'test/main/controls',
                       body: {
@@ -234,6 +274,49 @@ describe('plugin-meetings', () => {
                     Util.canUpdate = restorable;
                   });
               });
+
+              it('should send audio controls to locusUrl without authorizingLocusUrl when in breakout', () => {
+                const restorable = Util.canUpdate;
+                Util.canUpdate = sinon.stub().returns(true);
+                manager.mainLocusUrl = 'test/main';
+
+                const audio = {scope: 'audio', properties: {muted: true, disallowUnmute: false}};
+
+                return manager.update(audio)
+                  .then(() => {
+                    assert.calledWith(request.request, {
+                      uri: 'test/id/controls',
+                      body: {
+                        audio: audio.properties,
+                      },
+                      method: HTTP_VERBS.PATCH,
+                    });
+
+                    Util.canUpdate = restorable;
+                  });
+              });
+
+              it('should send non-audio controls to mainLocusUrl with authorizingLocusUrl when in breakout', () => {
+                const restorable = Util.canUpdate;
+                Util.canUpdate = sinon.stub().returns(true);
+                manager.mainLocusUrl = 'test/main';
+
+                const reactions = {scope: 'reactions', properties: {enabled: true}};
+
+                return manager.update(reactions)
+                  .then(() => {
+                    assert.calledWith(request.request, {
+                      uri: 'test/main/controls',
+                      body: {
+                        reactions: reactions.properties,
+                        authorizingLocusUrl: 'test/id',
+                      },
+                      method: HTTP_VERBS.PATCH,
+                    });
+
+                    Util.canUpdate = restorable;
+                  });
+              });
             });
 
             describe('Mute/Unmute All', () => {
@@ -252,6 +335,18 @@ describe('plugin-meetings', () => {
                 })
               });
 
+              it('should reject with ParameterError when locusUrl is not set', () => {
+                const noLocusManager = new ControlsOptionsManager(request);
+
+                const result = noLocusManager.setMuteAll(true, true, true);
+
+                assert.notCalled(request.request);
+                return assert.isRejected(result).then((err) => {
+                  assert.instanceOf(err, ParameterError);
+                  assert.match(err.message, /locusUrl.*must be defined/);
+                });
+              });
+
               it('rejects when correct display hint is not present mutedEnabled=false', () => {
                 const result = manager.setMuteAll(false, false, false);
 
@@ -340,14 +435,27 @@ describe('plugin-meetings', () => {
                 assert.deepEqual(result, request.request.firstCall.returnValue);
               });
 
-              it('request with mainLocusUrl and make locusUrl as authorizingLocusUrl if mainLocusUrl is exist and not same with locusUrl', () => {
+              it('should send setMuteAll to locusUrl without authorizingLocusUrl when in breakout', () => {
                 manager.setDisplayHints(['MUTE_ALL', 'DISABLE_HARD_MUTE', 'DISABLE_MUTE_ON_ENTRY']);
                 manager.mainLocusUrl = `test/main`;
 
                 const result = manager.setMuteAll(true, true, true, ['attendee']);
 
-                assert.calledWith(request.request, {  uri: 'test/main/controls',
-                  body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true, roles: ['attendee'] }, authorizingLocusUrl: 'test/id' },
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                  body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true, roles: ['attendee'] } },
+                  method: HTTP_VERBS.PATCH});
+
+                assert.deepEqual(result, request.request.firstCall.returnValue);
+              });
+
+              it('should send setMuteAll with PANELIST role to locusUrl without authorizingLocusUrl when in breakout', () => {
+                manager.setDisplayHints(['MUTE_ALL', 'ENABLE_HARD_MUTE', 'ENABLE_MUTE_ON_ENTRY']);
+                manager.mainLocusUrl = `test/main`;
+
+                const result = manager.setMuteAll(true, true, true, ['PANELIST']);
+
+                assert.calledWith(request.request, {  uri: 'test/id/controls',
+                  body: { audio: { muted: true, disallowUnmute: true, muteOnEntry: true, roles: ['PANELIST'] } },
                   method: HTTP_VERBS.PATCH});
 
                 assert.deepEqual(result, request.request.firstCall.returnValue);