@webex/plugin-meetings 3.0.0-beta.27 → 3.0.0-beta.29

package/src/breakouts/request.ts

@@ -0,0 +1,55 @@
+import {StatelessWebexPlugin} from '@webex/webex-core';
+import LoggerProxy from '../common/logs/logger-proxy';
+import {getBroadcastRoles} from './utils';
+import {HTTP_VERBS} from '../constants';
+
+/**
+ * @class BreakoutRequest
+ */
+export default class BreakoutRequest extends StatelessWebexPlugin {
+  /**
+   * Broadcast message to all breakout session's participants
+   * @param {String} url
+   * @param {String} message
+   * @param {Object} options
+   * @param {string} groupId
+   * @param {string} sessionId
+   * @returns {Promise}
+   */
+  broadcast({
+    url,
+    message,
+    options,
+    groupId,
+    sessionId,
+  }: {
+    url: string;
+    message: string;
+    options?: object;
+    groupId: string;
+    sessionId?: string;
+  }) {
+    const roles = getBroadcastRoles(options);
+    const params = {
+      id: groupId,
+      recipientRoles: roles.length ? roles : undefined,
+      sessions: sessionId ? [{id: sessionId}] : undefined,
+    };
+
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.POST,
+      uri: `${url}/message`,
+      body: {
+        message,
+        groups: [params],
+      },
+    }).catch((error) => {
+      if (error.body && error.body.errorCode === 201409036 && error.statusCode === 409) {
+        LoggerProxy.logger.info(`Breakouts#broadcast --> no joined participants`);
+      } else {
+        throw error;
+      }
+    });
+  }
+}

package/src/breakouts/utils.ts

@@ -0,0 +1,15 @@
+// eslint-disable-next-line import/prefer-default-export
+export const getBroadcastRoles = (options): string[] => {
+  const recipientRoles = [];
+  if (!options || (!options.cohosts && !options.presenters)) {
+    return recipientRoles;
+  }
+  if (options.cohosts) {
+    recipientRoles.push('COHOST');
+  }
+  if (options.presenters) {
+    recipientRoles.push('PRESENTER');
+  }
+
+  return recipientRoles;
+};

package/src/members/index.ts

@@ -296,6 +296,8 @@ export default class Members extends StatelessWebexPlugin {
       const delta = this.handleLocusInfoUpdatedParticipants(payload);
       const full = this.handleMembersUpdate(delta); // SDK should propagate the full list for both delta and non delta updates
 
+      this.receiveSlotManager.updateMemberIds();
+
       Trigger.trigger(
         this,
         {

package/src/multistream/receiveSlot.ts

@@ -91,7 +91,7 @@ export class ReceiveSlot extends EventsScope {
   /**
    * registers event handlers with the underlying ReceiveSlot
    */
-  setupEventListeners() {
+  private setupEventListeners() {
     const scope = {
       file: 'meeting/receiveSlot',
       function: 'setupEventListeners',
@@ -116,6 +116,13 @@ export class ReceiveSlot extends EventsScope {
     );
   }
 
+  /** Tries to find the member id for this receive slot if it hasn't got one */
+  public findMemberId() {
+    if (this.#memberId === undefined && this.#csi) {
+      this.#memberId = this.findMemberIdCallback(this.#csi);
+    }
+  }
+
   /**
    * The MediaStream object associated with this slot.
    *

package/src/multistream/receiveSlotManager.ts

@@ -141,4 +141,16 @@ export class ReceiveSlotManager {
       numFreeSlots,
     };
   }
+
+  /**
+   * Tries to find the member id on all allocated receive slots
+   * This function should be called when new members are added to the meeting.
+   */
+  updateMemberIds() {
+    Object.keys(this.allocatedSlots).forEach((key) => {
+      this.allocatedSlots[key].forEach((slot: ReceiveSlot) => {
+        slot.findMemberId();
+      });
+    });
+  }
 }

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

@@ -35,7 +35,7 @@ describe('plugin-meetings', () => {
     describe('#join', () => {
       it('makes the request as expected', async () => {
         const result = await breakout.join()
-  
+
         assert.calledOnceWithExactly(webex.request, {
           method: 'POST',
           uri: 'url/move',
@@ -44,7 +44,7 @@ describe('plugin-meetings', () => {
             sessionId: 'sessionId'
           }
         });
-  
+
         assert.equal(result, 'REQUEST_RETURN_VALUE')
       });
     });
@@ -88,7 +88,7 @@ describe('plugin-meetings', () => {
     describe('#askForHelp', () => {
       it('makes the request as expected', async () => {
         const result = await breakout.askForHelp()
-  
+
         assert.calledOnceWithExactly(webex.request, {
           method: 'POST',
           uri: 'url/help',
@@ -97,7 +97,35 @@ describe('plugin-meetings', () => {
             sessionId: 'sessionId'
           }
         });
-  
+
+        assert.equal(result, 'REQUEST_RETURN_VALUE')
+      });
+    });
+
+    describe('#broadcast', () => {
+      it('makes the request as expected', async () => {
+        breakout.breakoutRequest.broadcast = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+        let result = await breakout.broadcast('hello')
+        assert.calledWithExactly(breakout.breakoutRequest.broadcast, {
+          url: 'url',
+          message: 'hello',
+          options: undefined,
+          groupId: 'groupId',
+          sessionId: 'sessionId'
+        });
+
+        assert.equal(result, 'REQUEST_RETURN_VALUE')
+
+        result = await breakout.broadcast('hello', {presenters: true, cohosts: true})
+
+        assert.calledWithExactly(breakout.breakoutRequest.broadcast, {
+          url: 'url',
+          message: 'hello',
+          options: {presenters: true, cohosts: true},
+          groupId: 'groupId',
+          sessionId: 'sessionId'
+        });
+
         assert.equal(result, 'REQUEST_RETURN_VALUE')
       });
     });

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

@@ -1,4 +1,4 @@
-import {assert} from '@webex/test-helper-chai';
+import {assert, expect} from '@webex/test-helper-chai';
 import Breakout from '@webex/plugin-meetings/src/breakouts/breakout';
 import Breakouts from '@webex/plugin-meetings/src/breakouts';
 import BreakoutCollection from '@webex/plugin-meetings/src/breakouts/collection';
@@ -20,9 +20,11 @@ describe('plugin-meetings', () => {
       webex.internal.llm.on = sinon.stub();
       webex.internal.mercury.on = sinon.stub();
       breakouts = new Breakouts({}, {parent: webex});
+      breakouts.groupId = 'groupId';
+      breakouts.sessionId = 'sessionId';
+      breakouts.url = 'url';
       breakouts.locusUrl = 'locusUrl';
       breakouts.breakoutServiceUrl = 'breakoutServiceUrl';
-      breakouts.url = 'url';
       webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
     });
 
@@ -31,7 +33,7 @@ describe('plugin-meetings', () => {
         assert.equal(breakouts.namespace, 'Meetings');
       });
 
-      it('emits BREAKOUTS_CLOSING event when the status is CLOSING', () => {  
+      it('emits BREAKOUTS_CLOSING event when the status is CLOSING', () => {
         let called = false;
         breakouts.listenTo(breakouts, BREAKOUTS.EVENTS.BREAKOUTS_CLOSING, () => {
           called = true;
@@ -58,7 +60,7 @@ describe('plugin-meetings', () => {
       it('triggers message event when a message received', () => {
         const call = webex.internal.llm.on.getCall(0);
         const callback = call.args[1];
-        
+
         assert.equal(call.args[0], 'event:breakout.message');
 
         let message;
@@ -90,7 +92,7 @@ describe('plugin-meetings', () => {
       it('triggers member update event when a roster received', () => {
         const call = webex.internal.mercury.on.getCall(0);
         const callback = call.args[1];
-        
+
         assert.equal(call.args[0], 'event:breakout.roster');
 
         let called = false;
@@ -204,9 +206,9 @@ describe('plugin-meetings', () => {
     describe('#cleanUp', () => {
       it('stops listening', () => {
         breakouts.stopListening = sinon.stub();
-  
+
         breakouts.cleanUp();
-  
+
         assert.calledOnceWithExactly(breakouts.stopListening);
       });
     });
@@ -230,7 +232,7 @@ describe('plugin-meetings', () => {
     });
 
     describe('#queryRosters', () => {
-      
+
       it('makes the expected query', async () => {
 
         webex.request.returns(Promise.resolve({
@@ -249,7 +251,7 @@ describe('plugin-meetings', () => {
         breakouts.handleRosterUpdate = sinon.stub();
 
         const result = await breakouts.queryRosters();
-  
+
         assert.calledOnceWithExactly(webex.request, {
           uri: 'url/roster',
           qs: { locusUrl: 'dGVzdA==' }
@@ -293,6 +295,67 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#getMainSession', () => {
+      it('returns main session as expect', () => {
+        breakouts.updateBreakout({
+          sessionId: 'sessionId',
+          groupId: 'groupId',
+          sessionType: 'sessionType',
+          url: 'url',
+          name: 'name',
+          allowBackToMain: true,
+          delayCloseTime: 10,
+          enableBreakoutSession: true,
+          startTime: 'startTime',
+          status: 'active',
+          locusUrl: 'locusUrl'
+        });
+        const payload = {
+          breakoutSessions: {
+            active: [{sessionId: 'sessionId1'}],
+          }
+        }
+        breakouts.updateBreakoutSessions(payload);
+
+        breakouts.set('sessionType', BREAKOUTS.SESSION_TYPES.MAIN);
+        let result = breakouts.getMainSession();
+        assert.equal(result.sessionId, 'sessionId');
+
+        const payload2 = {
+          breakoutSessions: {
+            active: [{sessionId: 'sessionId1', sessionType: BREAKOUTS.SESSION_TYPES.MAIN}],
+          }
+        }
+        breakouts.updateBreakoutSessions(payload2);
+        breakouts.set('sessionType', 'BREAKOUT');
+        result = breakouts.getMainSession();
+        assert.equal(result.sessionId, 'sessionId1');
+      });
+      it('throw error if cannot find main session', () => {
+        const fn = () => {
+          breakouts.getMainSession();
+        }
+        expect(fn).to.throw(/no main session found/);
+      });
+    });
+
+    describe('#askAllToReturn',  () => {
+      it('makes the request as expected', async () => {
+        breakouts.set('sessionType', BREAKOUTS.SESSION_TYPES.MAIN);
+        breakouts.currentBreakoutSession.sessionId = 'sessionId';
+        breakouts.currentBreakoutSession.groupId = 'groupId';
+        const result = await breakouts.askAllToReturn();
+        assert.calledOnceWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'url/requestMove',
+          body: {
+            groupId: 'groupId',
+            sessionId: 'sessionId'
+          }
+        });
+      });
+    });
+
     describe('#breakoutServiceUrlUpdate', () => {
       it('sets the breakoutService url', () => {
         breakouts.breakoutServiceUrlUpdate('newBreakoutServiceUrl');
@@ -313,7 +376,7 @@ describe('plugin-meetings', () => {
         }}))
         breakouts.updateBreakout = sinon.stub().resolves();
         breakouts.doToggleBreakout = sinon.stub().resolves();
-        
+
         await breakouts.toggleBreakout(false);
         assert.calledOnceWithExactly(breakouts.enableBreakouts);
         assert.calledOnceWithExactly(breakouts.updateBreakout, {
@@ -351,6 +414,38 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#broadcast',  () => {
+      it('makes the request as expected', async () => {
+        breakouts.breakoutRequest.broadcast = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+        let result = await breakouts.broadcast('hello');
+        assert.calledWithExactly(breakouts.breakoutRequest.broadcast, {
+          url: 'url',
+          message: 'hello',
+          options: undefined,
+          groupId: 'groupId'
+        });
+
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+
+        result = await breakouts.broadcast('hello', {presenters: true, cohosts: true});
+        assert.calledWithExactly(breakouts.breakoutRequest.broadcast, {
+          url: 'url',
+          groupId: 'groupId',
+          message: 'hello',
+          options: {presenters: true, cohosts: true}
+        });
+        assert.equal(result, 'REQUEST_RETURN_VALUE')
+      });
+
+      it('throw error if no breakout group id found', () => {
+        breakouts.set('sessionType', BREAKOUTS.SESSION_TYPES.MAIN);
+        const fn = () => {
+          breakouts.broadcast('hello');
+        }
+        expect(fn).to.throw(/no breakout session found/);
+      });
+    });
+
     describe('doToggleBreakout', () => {
       it('makes the request as expected', async () => {
         const result = await breakouts.doToggleBreakout(true);

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

@@ -0,0 +1,104 @@
+import sinon from 'sinon';
+import {assert, expect} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import BreakoutRequest from "@webex/plugin-meetings/src/breakouts/request";
+import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
+
+describe('plugin-meetings', () => {
+  describe('BreakoutRequest', () => {
+    let webex;
+    let breakoutRequest;
+    beforeEach(() => {
+      // @ts-ignore
+      webex = new MockWebex({});
+      // @ts-ignore
+      breakoutRequest = new BreakoutRequest({webex});
+      webex.request = sinon.stub().returns(Promise.resolve('REQUEST_RETURN_VALUE'));
+    });
+
+    describe('#broadcast', () => {
+      it('makes request as expected', async () => {
+        let result = await breakoutRequest.broadcast({url: 'url', message: 'hello', groupId: 'groupId'});
+        assert.calledWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'url/message',
+          body: {
+            message: 'hello',
+            groups: [{
+              id: 'groupId',
+              recipientRoles: undefined,
+              sessions: undefined
+            }],
+          }
+        });
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+
+        result = await breakoutRequest.broadcast({
+          url: 'url',
+          message: 'hello',
+          groupId: 'groupId',
+          options: {
+            presenters: true,
+            cohosts: true
+          }
+        });
+        assert.calledWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'url/message',
+          body: {
+            message: 'hello',
+            groups: [{
+              id: 'groupId',
+              recipientRoles: ['COHOST', 'PRESENTER'],
+              sessions: undefined
+            }]
+          }
+        });
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+
+        result = await breakoutRequest.broadcast({
+          url: 'url',
+          message: 'hello',
+          groupId: 'groupId',
+          options: {
+            presenters: true,
+            cohosts: true
+          },
+          sessionId: 'sessionId'
+        });
+
+        assert.calledWithExactly(webex.request, {
+          method: 'POST',
+          uri: 'url/message',
+          body: {
+            message: 'hello',
+            groups: [{
+              id: 'groupId',
+              recipientRoles: ['COHOST', 'PRESENTER'],
+              sessions: [{id: 'sessionId'}]
+            }]
+          }
+        });
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
+      });
+
+      it('catch 409 error and log', async () => {
+        const error = {statusCode: 409, body: {errorCode: 201409036}};
+        webex.request.rejects(error);
+        LoggerProxy.logger.info = sinon.stub();
+        await breakoutRequest.broadcast({url: 'url', message: 'hello', groupId: 'groupId'});
+        assert.calledOnceWithExactly(
+          LoggerProxy.logger.info,
+          'Breakouts#broadcast --> no joined participants'
+        );
+
+        const otherError = new Error('something wrong');
+        webex.request.rejects(otherError);
+        LoggerProxy.logger.error = sinon.stub();
+        await breakoutRequest.broadcast({url: 'url', message: 'hello', groupId: 'groupId'}).catch((error) => {
+          assert.equal(error.toString(), 'Error: something wrong');
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,21 @@
+import {assert} from '@webex/test-helper-chai';
+import {getBroadcastRoles} from '@webex/plugin-meetings/src/breakouts/utils'
+describe('plugin-meetings', () => {
+  describe('Breakouts utils', () => {
+    describe('#getBroadcastRoles', () => {
+      it('return expect roles', () => {
+        let roles = getBroadcastRoles();
+        assert.deepEqual(roles, []);
+
+        roles = getBroadcastRoles({cohosts: true});
+        assert.deepEqual(roles, ['COHOST']);
+
+        roles = getBroadcastRoles({presenters: true});
+        assert.deepEqual(roles, ['PRESENTER']);
+
+        roles = getBroadcastRoles({presenters: true, cohosts: true});
+        assert.deepEqual(roles, ['COHOST', 'PRESENTER']);
+      });
+    });
+  });
+});

package/test/unit/spec/multistream/receiveSlot.ts

@@ -101,4 +101,40 @@ describe('ReceiveSlot', () => {
     assert.strictEqual(receiveSlot.csi, undefined);
     assert.strictEqual(receiveSlot.sourceState, 'no source');
   });
+
+  describe('findMemberId()', () => {
+    it('doesn\'t do anything if csi is not set', () => {
+      // by default the receiveSlot does not have any csi or member id
+      receiveSlot.findMemberId();
+
+      assert.notCalled(findMemberIdCallbackStub);
+    });
+
+    it('finds a member id if member id is undefined and CSI is known', () => {
+      // setup receiveSlot to have a csi without a member id
+      const csi = 12345;
+      fakeWcmeSlot.emit(WcmeReceiveSlotEvents.SourceUpdate, 'live', csi);
+      findMemberIdCallbackStub.reset();
+
+      receiveSlot.findMemberId();
+
+      assert.calledOnce(findMemberIdCallbackStub);
+      assert.calledWith(findMemberIdCallbackStub, csi);
+    });
+
+    it('doesn\'t do anything if member id already set', () => {
+      // setup receiveSlot to have a csi and a member id
+      const csi = 12345;
+      const memberId = '12345678-1234-5678-9012-345678901234';
+
+      findMemberIdCallbackStub.returns(memberId);
+
+      fakeWcmeSlot.emit(WcmeReceiveSlotEvents.SourceUpdate, 'live', csi);
+      findMemberIdCallbackStub.reset();
+
+      receiveSlot.findMemberId();
+
+      assert.notCalled(findMemberIdCallbackStub);
+    });
+  });
 });

package/test/unit/spec/multistream/receiveSlotManager.ts

@@ -1,6 +1,7 @@
 import sinon from 'sinon';
 import {assert} from '@webex/test-helper-chai';
 import {MediaType} from '@webex/internal-media-core';
+import {ReceiveSlot} from '@webex/plugin-meetings/src/multistream/receiveSlot';
 import {ReceiveSlotManager} from '@webex/plugin-meetings/src/multistream/receiveSlotManager';
 import * as ReceiveSlotModule from '@webex/plugin-meetings/src/multistream/receiveSlot';
 
@@ -30,6 +31,7 @@ describe('ReceiveSlotManager', () => {
       const fakeReceiveSlot = {
         id: `fake sdk receive slot ${fakeReceiveSlots.length + 1}`,
         mediaType,
+        findMemberId: sinon.stub(),
       };
 
       fakeReceiveSlots.push(fakeReceiveSlot);
@@ -170,4 +172,30 @@ describe('ReceiveSlotManager', () => {
       numFreeSlots: {'VIDEO-MAIN': 1},
     });
   });
+
+  describe('updateMemberIds', () => {
+
+    it('calls findMemberId() on all allocated receive slots', async () => {
+      const audioSlots: ReceiveSlot[] = [];
+      const videoSlots: ReceiveSlot[] = [];
+
+      // allocate a bunch of receive slots
+      audioSlots.push(await receiveSlotManager.allocateSlot(MediaType.AudioMain));
+      audioSlots.push(await receiveSlotManager.allocateSlot(MediaType.AudioMain));
+      videoSlots.push(await receiveSlotManager.allocateSlot(MediaType.VideoMain));
+      videoSlots.push(await receiveSlotManager.allocateSlot(MediaType.VideoMain));
+      videoSlots.push(await receiveSlotManager.allocateSlot(MediaType.VideoMain));
+
+      receiveSlotManager.updateMemberIds();
+
+      assert.strictEqual(audioSlots.length, 2);
+      assert.strictEqual(videoSlots.length, 3);
+
+      assert.strictEqual(fakeReceiveSlots.length, audioSlots.length + videoSlots.length);
+
+      fakeReceiveSlots.forEach(slot => {
+        assert.calledOnce(slot.findMemberId);
+      });
+    });
+  });
 });