@webex/plugin-meetings 3.0.0-beta.67 → 3.0.0-beta.69

package/src/locus-info/selfUtils.ts

@@ -14,6 +14,7 @@ import {
   AUDIO,
   VIDEO,
   MediaContent,
+  SELF_ROLES,
 } from '../constants';
 import ParameterError from '../common/errors/parameter';
 
@@ -105,6 +106,7 @@ SelfUtils.getSelves = (oldSelf, newSelf, deviceId) => {
     current
   );
   updates.moderatorChanged = SelfUtils.moderatorChanged(previous, current);
+  updates.isUpgradeToModeratorOrCohost = SelfUtils.isUpgradeToModeratorOrCohost(previous, current);
   updates.isMediaInactiveOrReleased = SelfUtils.wasMediaInactiveOrReleased(previous, current);
   updates.isUserObserving = SelfUtils.isDeviceObserving(previous, current);
   updates.layoutChanged = SelfUtils.layoutChanged(previous, current);
@@ -334,6 +336,31 @@ SelfUtils.moderatorChanged = (oldSelf, changedSelf) => {
   return oldSelf.moderator !== changedSelf.moderator;
 };
 
+/**
+ * @param {Object} oldSelf
+ * @param {Object} changedSelf
+ * @returns {Boolean}
+ * @throws {Error} if changed self was undefined
+ */
+SelfUtils.isUpgradeToModeratorOrCohost = (oldSelf, changedSelf) => {
+  if (!oldSelf) {
+    return false;
+  }
+  if (!changedSelf) {
+    throw new ParameterError(
+      'New self must be defined to determine if self transitioned moderator or cohost status.'
+    );
+  }
+  const isAttendeeOnly =
+    oldSelf.roles.includes(SELF_ROLES.ATTENDEE) &&
+    !oldSelf.roles.includes(SELF_ROLES.COHOST) &&
+    !oldSelf.roles.includes(SELF_ROLES.MODERATOR);
+  const isCohost = changedSelf.roles.includes(SELF_ROLES.COHOST);
+  const isModerator = changedSelf.roles.includes(SELF_ROLES.MODERATOR);
+
+  return isAttendeeOnly && (isCohost || isModerator);
+};
+
 /**
  * @param {Object} oldSelf
  * @param {Object} changedSelf

package/src/meeting/index.ts

@@ -553,7 +553,7 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     this.id = uuid.v4();
     /**
-     * Correlation ID used for network tracking of meeting join
+     * Correlation ID used for network tracking of meeting
      * @instance
      * @type {String}
      * @readonly
@@ -610,7 +610,7 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     // @ts-ignore
-    this.breakouts = new Breakouts({}, {parent: this.webex});
+    this.breakouts = new Breakouts({meetingId: this.id}, {parent: this.webex});
     /**
      * helper class for managing receive slots (for multistream media connections)
      */
@@ -2581,6 +2581,12 @@ export default class Meeting extends StatelessWebexPlugin {
       );
     });
 
+    // We need to reinitialize  when user upgrades to host or cohost
+    this.locusInfo.on(LOCUSINFO.EVENTS.SELF_MODERATOR_OR_COHOST_UPGRADE, (payload) => {
+      this.breakouts.queryPreAssignments(payload);
+      // ...
+    });
+
     this.locusInfo.on(LOCUSINFO.EVENTS.SELF_IS_SHARING_BLOCKED_CHANGE, (payload) => {
       Trigger.trigger(
         this,

package/src/metrics/config.ts

@@ -140,6 +140,8 @@ export const eventType = {
   PSTN_AUDIO_ATTEMPT_START: 'client.pstnaudio.attempt.start',
   PSTN_AUDIO_ATTEMPT_FINISH: 'client.pstnaudio.attempt.finish',
   PSTN_AUDIO_ATTEMPT_SKIP: 'client.pstnaudio.attempt.skip',
+  MOVE_TO_BREAKOUT: 'client.breakout-session.move.request',
+  JOIN_BREAKOUT_RESPONSE: 'client.breakout-session.join.response',
 };
 
 export const error = {

package/src/metrics/index.ts

@@ -241,6 +241,11 @@ class Metrics {
       if (options.isRoapCallEnabled) {
         payload.event.isRoapCallEnabled = options.isRoapCallEnabled;
       }
+      ['breakoutMoveId', 'breakoutSessionId', 'breakoutGroupId'].forEach((item) => {
+        if (options[item]) {
+          payload.event.identifiers[item] = options[item];
+        }
+      });
     }
 
     return payload;

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

@@ -3,8 +3,10 @@ import Breakout from '@webex/plugin-meetings/src/breakouts/breakout';
 import Breakouts from '@webex/plugin-meetings/src/breakouts';
 import Members from '@webex/plugin-meetings/src/members';
 import MockWebex from '@webex/test-helper-mock-webex';
+import Metrics from '@webex/plugin-meetings/src/metrics';
 import sinon from 'sinon';
-
+import {eventType} from '../../../../src/metrics/config';
+import uuid from 'uuid';
 describe('plugin-meetings', () => {
   describe('breakout', () => {
     let webex;
@@ -22,6 +24,11 @@ describe('plugin-meetings', () => {
       breakout.sessionId = 'sessionId';
       breakout.sessionType = 'BREAKOUT';
       breakout.url = 'url';
+      breakout.collection = {
+        parent: {
+          meetingId: 'activeMeetingId',
+        },
+      };
       webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
     });
 
@@ -33,8 +40,8 @@ describe('plugin-meetings', () => {
 
     describe('#join', () => {
       it('makes the request as expected', async () => {
+        Metrics.postEvent = sinon.stub();
         const result = await breakout.join();
-
         assert.calledOnceWithExactly(webex.request, {
           method: 'POST',
           uri: 'url/move',
@@ -46,6 +53,30 @@ describe('plugin-meetings', () => {
 
         assert.equal(result, 'REQUEST_RETURN_VALUE');
       });
+      it('send metrics as expected', async () => {
+        Metrics.postEvent = sinon.stub();
+        uuid.v4 = sinon.stub().returns('breakoutMoveId');
+        await breakout.join();
+        assert.calledTwice(Metrics.postEvent);
+        assert.calledWithMatch(Metrics.postEvent, {
+          event: eventType.MOVE_TO_BREAKOUT,
+          meetingId: 'activeMeetingId',
+          data: {
+            breakoutMoveId: 'breakoutMoveId',
+            breakoutSessionId: 'sessionId',
+            breakoutGroupId: 'groupId',
+          },
+        });
+        assert.calledWithMatch((Metrics.postEvent as any).secondCall, {
+          event: eventType.JOIN_BREAKOUT_RESPONSE,
+          meetingId: 'activeMeetingId',
+          data: {
+            breakoutMoveId: 'breakoutMoveId',
+            breakoutSessionId: 'sessionId',
+            breakoutGroupId: 'groupId',
+          },
+        });
+      });
     });
 
     describe('#leave', () => {

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

@@ -1007,6 +1007,85 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('queryPreAssignments', () => {
+      it('makes the expected query', async () => {
+        webex.request.returns(
+          Promise.resolve({
+            body: {
+              "groups": [
+                {
+                  "sessions": [
+                    {
+                      "name": "Breakout session 1",
+                      "assignedEmails": [
+                        "a@a.com",
+                        "b@b.com",
+                        "jial2@cisco.com"
+                      ],
+                      "anyoneCanJoin": false
+                    },
+                    {
+                      "name": "Breakout session 2",
+                      "anyoneCanJoin": false
+                    },
+                    {
+                      "name": "Breakout session 3",
+                      "assignedEmails": [
+                        "c@c.com"
+                      ],
+                      "anyoneCanJoin": false
+                    }
+                  ],
+                  "unassignedInvitees": {
+                    "emails": [
+                      "d@d.com"
+                    ]
+                  },
+                  "type": "BREAKOUT"
+                }
+              ]
+            }
+          })
+        );
+        breakouts.shouldFetchPreassignments = false;
+        const result = await breakouts.queryPreAssignments();
+        const arg = webex.request.getCall(0).args[0];
+        assert.equal(arg.uri, 'url/preassignments');
+        assert.equal(breakouts.groups[0].unassignedInvitees.emails[0],'d@d.com');
+        assert.equal(breakouts.groups[0].sessions[0].name,'Breakout session 1');
+        assert.equal(breakouts.groups[0].sessions[0].anyoneCanJoin,false);
+        assert.equal(breakouts.groups[0].sessions[0].assignedEmails.toString(), ["a@a.com", "b@b.com", "jial2@cisco.com"].toString());
+        assert.equal(breakouts.groups[0].sessions[1].name,'Breakout session 2');
+        assert.equal(breakouts.groups[0].sessions[1].anyoneCanJoin,false);
+        assert.equal(breakouts.groups[0].sessions[1].assignedEmails, undefined);
+        assert.equal(breakouts.groups[0].sessions[2].name,'Breakout session 3');
+        assert.equal(breakouts.groups[0].sessions[2].anyoneCanJoin,false);
+        assert.equal(breakouts.groups[0].sessions[2].assignedEmails[0], 'c@c.com');
+        assert.equal(breakouts.groups[0].unassignedInvitees.emails[0],'d@d.com');
+        assert.equal(breakouts.groups[0].type,'BREAKOUT');
+        assert.equal(breakouts.shouldFetchPreassignments, true);
+      });
+
+      it('rejects when no pre-assignments created for this meeting', async () => {
+        const response = {
+          statusCode: 404,
+          body: {
+            errorCode: 201404004,
+            message: 'No pre-assignments created for this meeting'
+          },
+        };
+        webex.request.rejects(response);
+        LoggerProxy.logger.error = sinon.stub();
+        const result = await breakouts.queryPreAssignments();
+        await testUtils.flushPromises();
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.error,
+          'Meeting:breakouts#queryPreAssignments failed',
+          response
+        );
+     });
+  });
+
     describe('#dynamicAssign', () => {
       it('should make a PUT request with correct body and return the result', async () => {
         breakouts.dynamicAssign = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));

package/test/unit/spec/locus-info/index.js

@@ -871,6 +871,27 @@ describe('plugin-meetings', () => {
         );
       });
 
+      it('should trigger upgradeToModeratorOrCohost for breakouts', () => {
+
+        locusInfo.self = self;
+        const upgradeToModeratorOrCohost = cloneDeep(self);
+        upgradeToModeratorOrCohost.roles = ['ATTENDEE','COHOST'];
+
+        locusInfo.webex.internal.device.url = self.deviceUrl;
+        locusInfo.emitScoped = sinon.stub();
+        locusInfo.updateSelf(upgradeToModeratorOrCohost, []);
+
+        assert.neverCalledWith(
+          locusInfo.emitScoped,
+          {
+            file: 'locus-info',
+            function: 'updateSelf',
+          },
+          LOCUSINFO.EVENTS.SELF_MODERATOR_OR_COHOST_UPGRADE,
+          self
+        );
+      });
+
       it('should trigger SELF_REMOTE_MUTE_STATUS_UPDATED if muted and disallowUnmute changed', () => {
         locusInfo.self = self;
         const selfWithMutedByOthersAndDissalowUnmute = cloneDeep(self);

package/test/unit/spec/locus-info/selfUtils.js

@@ -289,4 +289,41 @@ describe('plugin-meetings', () => {
       );
     });
   });
+
+  describe('isUpgradeToModeratorOrCohost', () => {
+    it('returns true if changed', () => {
+      assert.equal(
+        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE']}, {roles: ['ATTENDEE','MODERATOR']}),
+        true
+      );
+    });
+
+    it('returns true if changed', () => {
+      assert.equal(
+        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE']}, {roles: ['ATTENDEE','COHOST']}),
+        true
+      );
+    });
+
+    it('returns false if changed', () => {
+      assert.equal(
+        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE','MODERATOR']}, {roles: ['ATTENDEE']}),
+        false
+      );
+    });
+
+    it('returns false if changed', () => {
+      assert.equal(
+        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE','COHOST']}, {roles: ['ATTENDEE']}),
+        false
+      );
+    });
+
+    it('returns false if changed', () => {
+      assert.equal(
+        SelfUtils.isUpgradeToModeratorOrCohost({roles: ['ATTENDEE','HOST','MODERATOR']}, {roles: ['ATTENDEE']}),
+        false
+      );
+    });
+  });
 });

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

@@ -4518,6 +4518,19 @@ describe('plugin-meetings', () => {
         });
       });
 
+      describe('#setUpBreakoutsPreAssignmentsListener', () => {
+        it('listens to the self moderator or cohost upgrade event', () => {
+          meeting.breakouts.queryPreAssignments = sinon.stub();
+          const payload = 'payload';
+          meeting.locusInfo.emit(
+            {function: 'test', file: 'test'},
+            'SELF_MODERATOR_OR_COHOST_UPGRADE',
+            payload,
+          );
+          assert.calledOnceWithExactly(meeting.breakouts.queryPreAssignments, payload);
+        });
+      });
+
       describe('#setUpBreakoutsListener', () => {
         it('listens to the closing event from breakouts and triggers the closing event', () => {
           TriggerProxy.trigger.reset();