@webex/plugin-meetings 3.0.0-bnr.5 → 3.0.0-stream-classes.2

package/src/breakouts/index.ts

@@ -5,12 +5,13 @@ import {WebexPlugin} from '@webex/webex-core';
 import {debounce, forEach} from 'lodash';
 import LoggerProxy from '../common/logs/logger-proxy';
 
-import {BREAKOUTS, MEETINGS, HTTP_VERBS} from '../constants';
+import {BREAKOUTS, MEETINGS, HTTP_VERBS, _ID_} from '../constants';
 
 import Breakout from './breakout';
 import BreakoutCollection from './collection';
 import BreakoutRequest from './request';
-import {boServiceErrorHandler} from './utils';
+import breakoutEvent from './events';
+import {boServiceErrorHandler, isSessionTypeChangedFromSessionToMain} from './utils';
 
 /**
  * @class Breakouts
@@ -38,10 +39,12 @@ const Breakouts = WebexPlugin.extend({
     breakoutServiceUrl: 'string', // the current breakout resource url
     mainLocusUrl: 'string', // the locus url of the main session
     groups: 'array', // appears when create breakouts
-    shouldFetchPreassignments: 'boolean', // Controlling the lifecycle of the pre-assign API
+    manageGroups: 'array', // appears when manage breakouts
+    preAssignments: 'array', // appears when getPreAssignments info hasBreakoutPreAssignments = true
     editLock: 'object', // appears when getBreakout info editlock = true
     intervalID: 'number',
     meetingId: 'string',
+    canManageBreakouts: 'boolean', // appear the ability to manage breakouts
   },
   children: {
     currentBreakoutSession: Breakout,
@@ -49,6 +52,7 @@ const Breakouts = WebexPlugin.extend({
 
   derived: {
     isInMainSession: {
+      cache: false,
       deps: ['sessionType'],
       /**
        * Returns true if the user is in the main session
@@ -59,6 +63,7 @@ const Breakouts = WebexPlugin.extend({
       },
     },
     isActiveBreakout: {
+      cache: false, // fix issue: sometimes the derived will not change even if the deps changed
       deps: ['sessionType', 'status'],
       /**
        * Returns true if the breakout status is active
@@ -72,19 +77,48 @@ const Breakouts = WebexPlugin.extend({
       },
     },
     breakoutGroupId: {
-      deps: ['groups'],
+      cache: false,
+      deps: ['manageGroups'],
       /**
-       * Returns the actived group id
+       * Returns the active group id
        * @returns {boolean}
        */
       fn() {
-        if (this.groups?.length) {
-          return this.groups[0].id;
+        if (this.manageGroups?.length) {
+          return this.manageGroups[0].status !== BREAKOUTS.STATUS.CLOSED
+            ? this.manageGroups[0].id
+            : '';
         }
 
         return '';
       },
     },
+    breakoutStatus: {
+      cache: true,
+      deps: ['isInMainSession', 'status', 'groups'],
+      /**
+       * Returns the breakout status
+       * @returns {boolean}
+       */
+      fn() {
+        return this.isInMainSession ? this.groups?.[0]?.status : this.status;
+      },
+    },
+    shouldQueryPreAssignments: {
+      cache: false,
+      deps: ['canManageBreakouts', 'enableBreakoutSession', 'hasBreakoutPreAssignments'],
+      /**
+       * Returns should query preAssignments or not
+       * @returns {boolean}
+       */
+      fn() {
+        return !!(
+          this.canManageBreakouts &&
+          this.enableBreakoutSession &&
+          this.hasBreakoutPreAssignments
+        );
+      },
+    },
   },
 
   /**
@@ -92,20 +126,31 @@ const Breakouts = WebexPlugin.extend({
    * @returns {void}
    */
   initialize() {
-    this.listenTo(this, 'change:status', () => {
-      if (this.status === BREAKOUTS.STATUS.CLOSING) {
+    this.listenTo(this, 'change:breakoutStatus', () => {
+      if (this.breakoutStatus === BREAKOUTS.STATUS.CLOSING) {
         this.trigger(BREAKOUTS.EVENTS.BREAKOUTS_CLOSING);
       }
     });
+    this.listenTo(this, 'change:shouldQueryPreAssignments', () => {
+      if (this.shouldQueryPreAssignments && !this.preAssignments) {
+        this.queryPreAssignments();
+      }
+    });
     this.debouncedQueryRosters = debounce(this.queryRosters, 10, {
       leading: true,
       trailing: false,
     });
-    this.listenTo(this.breakouts, 'add', () => {
+    this.listenTo(this.breakouts, 'add', (breakout) => {
       this.debouncedQueryRosters();
+      this.triggerReturnToMainEvent(breakout);
     });
+    this.listenTo(this.breakouts, 'change:requestedLastModifiedTime', (breakout) => {
+      this.triggerReturnToMainEvent(breakout);
+    });
+    this.listenToCurrentSessionTypeChange();
     this.listenToBroadcastMessages();
     this.listenToBreakoutRosters();
+    this.listenToBreakoutHelp();
     // @ts-ignore
     this.breakoutRequest = new BreakoutRequest({webex: this.webex});
   },
@@ -131,6 +176,15 @@ const Breakouts = WebexPlugin.extend({
     }
   },
 
+  /**
+   * Update whether self is moderator/cohost or not
+   * @param {boolean} canManageBreakouts
+   * @returns {void}
+   */
+  updateCanManageBreakouts(canManageBreakouts) {
+    this.set('canManageBreakouts', canManageBreakouts);
+  },
+
   /**
    * Update the current breakout resource url
    * @param {string} breakoutServiceUrl
@@ -180,6 +234,21 @@ const Breakouts = WebexPlugin.extend({
 
     session.parseRoster(locus);
   },
+  /**
+   *Sets up listener for currentBreakoutSession sessionType changed
+   * @returns {void}
+   */
+  listenToCurrentSessionTypeChange(): void {
+    this.listenTo(
+      this.currentBreakoutSession,
+      'change:sessionType',
+      (currentBreakoutSession, sessionType) => {
+        if (isSessionTypeChangedFromSessionToMain(currentBreakoutSession, sessionType)) {
+          this.trigger(BREAKOUTS.EVENTS.LEAVE_BREAKOUT);
+        }
+      }
+    );
+  },
 
   /**
    * Sets up listener for broadcast messages sent to the breakout session
@@ -214,15 +283,47 @@ const Breakouts = WebexPlugin.extend({
     });
   },
 
+  /**
+   * Sets up a listener for ask help notify from mecury
+   * @returns {void}
+   */
+  listenToBreakoutHelp() {
+    this.listenTo(this.webex.internal.mercury, 'event:breakout.help', (event) => {
+      const {
+        data: {participant, sessionId},
+      } = event;
+      this.trigger(BREAKOUTS.EVENTS.ASK_FOR_HELP, {participant, sessionId});
+    });
+  },
+
+  /**
+   * get current breakout is in progress or not
+   * @returns {boolean}
+   */
+  isBreakoutInProgress() {
+    const currentStatus = this.groups?.[0]?.status || this.status;
+
+    return currentStatus === BREAKOUTS.STATUS.OPEN || currentStatus === BREAKOUTS.STATUS.CLOSING;
+  },
+
+  /**
+   * get current breakout is in closing or not
+   * @returns {boolean}
+   */
+  isBreakoutIClosing() {
+    return (this.groups?.[0]?.status || this.status) === BREAKOUTS.STATUS.CLOSING;
+  },
   /**
    * Updates the information about the current breakout
    * @param {Object} params
    * @returns {void}
    */
   updateBreakout(params) {
-    const preEnableBreakoutSession = this.get('enableBreakoutSession');
     this.set(params);
+    // These values are set manually so they are unset when they are not included in params
     this.set('groups', params.groups);
+    this.set('startTime', params.startTime);
+    this.set('status', params.status);
 
     this.set('currentBreakoutSession', {
       sessionId: params.sessionId,
@@ -233,18 +334,30 @@ const Breakouts = WebexPlugin.extend({
       url: params.url,
       [BREAKOUTS.SESSION_STATES.ACTIVE]: false,
       [BREAKOUTS.SESSION_STATES.ALLOWED]: false,
-      [BREAKOUTS.SESSION_STATES.ALLOWED]: false,
+      [BREAKOUTS.SESSION_STATES.ASSIGNED]: false,
       [BREAKOUTS.SESSION_STATES.ASSIGNED_CURRENT]: false,
       [BREAKOUTS.SESSION_STATES.REQUESTED]: false,
     });
 
-    // We need to call queryPreAssignments when enableBreakoutSession become true
+    if (!this.isBreakoutInProgress()) {
+      this.clearBreakouts();
+    }
+
     if (
-      params.enableBreakoutSession &&
-      params.hasBreakoutPreAssignments &&
-      preEnableBreakoutSession !== params.enableBreakoutSession
+      this.currentBreakoutSession.previous('sessionId') !== this.currentBreakoutSession.sessionId ||
+      this.currentBreakoutSession.previous('groupId') !== this.currentBreakoutSession.groupId
     ) {
-      this.queryPreAssignments();
+      // should report joined session changed
+      const meeting = this.webex.meetings.getMeetingByType(_ID_, this.meetingId);
+      breakoutEvent.onBreakoutJoinResponse(
+        {
+          currentSession: this.currentBreakoutSession,
+          meeting,
+          breakoutMoveId: params.breakoutMoveId,
+        },
+        // @ts-ignore
+        this.webex.internal.newMetrics.submitClientEvent.bind(this.webex.internal.newMetrics)
+      );
     }
   },
 
@@ -255,7 +368,12 @@ const Breakouts = WebexPlugin.extend({
    */
   updateBreakoutSessions(payload) {
     const breakouts = {};
-
+    if (this.isBreakoutIClosing()) {
+      // fix issue: don't clear/update breakouts collection when in closing since locus DTO will send undefined or
+      // only the MAIN session info here, if just update it, will miss the breakout roster info during
+      // count down to end breakouts
+      return;
+    }
     if (payload.breakoutSessions) {
       forEach(BREAKOUTS.SESSION_STATES, (state) => {
         forEach(payload.breakoutSessions[state], (breakout) => {
@@ -271,10 +389,13 @@ const Breakouts = WebexPlugin.extend({
           }
 
           breakouts[sessionId][state] = true;
+
+          if (state === BREAKOUTS.SESSION_STATES.REQUESTED) {
+            breakouts[sessionId].requestedLastModifiedTime = breakout.modifiedAt;
+          }
         });
       });
     }
-
     forEach(breakouts, (breakout: typeof Breakout) => {
       // eslint-disable-next-line no-param-reassign
       breakout.url = this.url;
@@ -282,6 +403,15 @@ const Breakouts = WebexPlugin.extend({
 
     this.breakouts.set(Object.values(breakouts));
   },
+  /**
+   * clear breakouts collection
+   * @returns {void}
+   */
+  clearBreakouts() {
+    if (this.breakouts.length > 0) {
+      this.breakouts.reset();
+    }
+  },
   /**
    * get main session
    * @returns {Breakout}
@@ -368,9 +498,9 @@ const Breakouts = WebexPlugin.extend({
   async toggleBreakout(enable) {
     if (this.enableBreakoutSession === undefined) {
       const info = await this.enableBreakouts();
+      // first time enable, set the initial data
+      this.updateBreakout(info?.body);
       if (!enable) {
-        // if enable is false, updateBreakout set the param then set enableBreakoutSession as false
-        this.updateBreakout(info.body);
         await this.doToggleBreakout(enable);
       }
     } else {
@@ -397,18 +527,30 @@ const Breakouts = WebexPlugin.extend({
     });
   },
 
+  /**
+   * set groups to manageGroups prop
+   * @param {Object} breakoutInfo -- breakout groups
+   * @returns {void}
+   */
+  _setManageGroups(breakoutInfo) {
+    if (breakoutInfo?.body?.groups) {
+      this.set('manageGroups', breakoutInfo.body.groups);
+    }
+  },
+
   /**
    * Create new breakout sessions
-   * @param {object} sessions -- breakout session group
+   * @param {object} params -- breakout session group
    * @returns {Promise}
    */
-  async create(sessions) {
+  async create(params) {
+    const payload = {...params};
     const body = {
       ...(this.editLock && !!this.editLock.token ? {editlock: {token: this.editLock.token}} : {}),
-      ...{groups: [{sessions}]},
+      ...{groups: [payload]},
     };
     // @ts-ignore
-    const breakInfo = await this.webex
+    const breakoutInfo = await this.webex
       .request({
         method: HTTP_VERBS.PUT,
         uri: this.url,
@@ -418,14 +560,12 @@ const Breakouts = WebexPlugin.extend({
         return Promise.reject(boServiceErrorHandler(error, 'Breakouts#create'));
       });
 
-    if (breakInfo.body?.groups) {
-      this.set('groups', breakInfo.body.groups);
-    }
+    this._setManageGroups(breakoutInfo);
 
     // clear edit lock info after save breakout session info
     this._clearEditLockInfo();
 
-    return Promise.resolve(breakInfo);
+    return breakoutInfo;
   },
 
   /**
@@ -438,7 +578,7 @@ const Breakouts = WebexPlugin.extend({
       ...{groups: [{action: BREAKOUTS.ACTION.DELETE}]},
     };
     // @ts-ignore
-    const breakInfo = await this.webex
+    const breakoutInfo = await this.webex
       .request({
         method: HTTP_VERBS.PUT,
         uri: this.url,
@@ -448,12 +588,9 @@ const Breakouts = WebexPlugin.extend({
         return Promise.reject(boServiceErrorHandler(error, 'Breakouts#clearSessions'));
       });
 
-    if (breakInfo.body?.groups) {
-      this.set('groups', breakInfo.body.groups);
-    }
-    this.shouldFetchPreassignments = false;
+    this._setManageGroups(breakoutInfo);
 
-    return Promise.resolve(breakInfo);
+    return breakoutInfo;
   },
 
   /**
@@ -461,14 +598,13 @@ const Breakouts = WebexPlugin.extend({
    * @param {object} params
    * @returns {Promise}
    */
-  start(params = {}) {
+  async start(params = {}) {
     const action = BREAKOUTS.ACTION.START;
     const payload = {
       id: this.breakoutGroupId,
       action,
       allowBackToMain: false,
       allowToJoinLater: false,
-      duration: BREAKOUTS.DEFAULT_DURATION,
       ...params,
     };
 
@@ -479,13 +615,17 @@ const Breakouts = WebexPlugin.extend({
       ...{groups: [payload]},
     };
 
-    return this.request({
+    const breakoutInfo = await this.request({
       method: HTTP_VERBS.PUT,
       uri: this.url,
       body,
     }).catch((error) => {
       return Promise.reject(boServiceErrorHandler(error, 'Breakouts#start'));
     });
+
+    this._setManageGroups(breakoutInfo);
+
+    return breakoutInfo;
   },
 
   /**
@@ -493,7 +633,7 @@ const Breakouts = WebexPlugin.extend({
    * @param {object} params
    * @returns {Promise}
    */
-  end(params = {}) {
+  async end(params = {}) {
     const {delayCloseTime, breakoutGroupId: id} = this;
     const action = BREAKOUTS.ACTION.CLOSE;
     const payload = {
@@ -510,39 +650,54 @@ const Breakouts = WebexPlugin.extend({
       ...{groups: [payload]},
     };
 
-    return this.request({
+    const breakoutInfo = await this.request({
       method: HTTP_VERBS.PUT,
       uri: this.url,
       body,
     }).catch((error) => {
       return Promise.reject(boServiceErrorHandler(error, 'Breakouts#end'));
     });
+
+    this._setManageGroups(breakoutInfo);
+
+    return breakoutInfo;
   },
 
   /**
    * Host or cohost update breakout sessions
    * @param {Object} params
    * @param {String} params.id
+   * @param {Boolean} unlockEdit
    * @returns {Promise}
    */
-  update(params: {id: string}) {
+  async update(params: {id: string}, unlockEdit?: boolean) {
     if (!params.id) {
       return Promise.reject(new Error('Missing breakout group id'));
     }
     const payload = {...params};
 
     const body = {
-      ...(this.editLock?.token ? {editlock: {token: this.editLock.token, refresh: true}} : {}),
+      ...(this.editLock?.token
+        ? {editlock: {token: this.editLock.token, refresh: !unlockEdit}}
+        : {}),
       ...{groups: [payload]},
     };
 
-    return this.request({
+    const breakoutInfo = await this.request({
       method: HTTP_VERBS.PUT,
       uri: this.url,
       body,
     }).catch((error) => {
       return Promise.reject(boServiceErrorHandler(error, 'Breakouts#update'));
     });
+
+    if (unlockEdit) {
+      this._clearEditLockInfo();
+    }
+
+    this._setManageGroups(breakoutInfo);
+
+    return breakoutInfo;
   },
 
   /**
@@ -556,9 +711,7 @@ const Breakouts = WebexPlugin.extend({
       uri: this.url + (editlock ? `?editlock=${editlock}` : ''),
     });
 
-    if (breakout.body?.groups) {
-      this.set('groups', breakout.body.groups);
-    }
+    this._setManageGroups(breakout);
     if (editlock && breakout.body?.editlock?.token) {
       this.set('editLock', breakout.body.editlock);
       this.keepEditLockAlive();
@@ -583,6 +736,18 @@ const Breakouts = WebexPlugin.extend({
     }
   },
 
+  /**
+   * breakout edit locked by yourself or not
+   * @returns {boolean}
+   */
+  hasBreakoutLocked() {
+    return (
+      this.editLock &&
+      this.editLock.token &&
+      this.editLock.state === BREAKOUTS.EDIT_LOCK_STATUS.LOCKED
+    );
+  },
+
   /**
    * send breakout edit lock
    * @returns {void}
@@ -672,10 +837,11 @@ const Breakouts = WebexPlugin.extend({
       };
     });
 
-    return this.request({
-      method: HTTP_VERBS.PUT,
-      uri: this.url,
-      body: {
+    const body = {
+      ...(this.editLock && !!this.editLock.token
+        ? {editlock: {token: this.editLock.token, refresh: true}}
+        : {}),
+      ...{
         groups: [
           {
             id: this.breakoutGroupId,
@@ -683,27 +849,31 @@ const Breakouts = WebexPlugin.extend({
           },
         ],
       },
+    };
+
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: this.url,
+      body,
     });
   },
 
   /**
-   * The pre-assignments need to be queried when "hasBreakoutPreAssignments" is true
+   * query preAssignments
    * @returns {void}
    */
   queryPreAssignments() {
-    if (!this.shouldFetchPreassignments) {
-      this.webex
-        .request({uri: `${this.url}/preassignments`, qs: {locusUrl: btoa(this.locusUrl)}})
-        .then((result) => {
-          if (result.body?.groups) {
-            this.set('groups', result.body.groups);
-          }
-        })
-        .catch((error) => {
-          LoggerProxy.logger.error('Meeting:breakouts#queryPreAssignments failed', error);
-        });
-      this.shouldFetchPreassignments = true;
-    }
+    this.webex
+      .request({uri: `${this.url}/preassignments`, qs: {locusUrl: btoa(this.locusUrl)}})
+      .then((result) => {
+        if (result.body?.groups) {
+          this.set('preAssignments', result.body.groups);
+          this.trigger(BREAKOUTS.EVENTS.PRE_ASSIGNMENTS_UPDATE);
+        }
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error('Meeting:breakouts#queryPreAssignments failed', error);
+      });
   },
   /**
    * assign participants dynamically after breakout sessions started,
@@ -740,6 +910,16 @@ const Breakouts = WebexPlugin.extend({
       body,
     });
   },
+  /**
+   * trigger ASK_RETURN_TO_MAIN event when main session requested
+   * @param {Object} breakout
+   * @returns {void}
+   */
+  triggerReturnToMainEvent(breakout) {
+    if (breakout.isMain && breakout.requested) {
+      this.trigger(BREAKOUTS.EVENTS.ASK_RETURN_TO_MAIN);
+    }
+  },
 });
 
 export default Breakouts;

package/src/breakouts/utils.ts

@@ -42,3 +42,16 @@ export const boServiceErrorHandler = (error: any, position: string): any => {
 
   return throwError;
 };
+
+/**
+ *
+ * @param {object} breakout
+ * @param {string} newSessionType
+ * @returns {boolean}
+ */
+export const isSessionTypeChangedFromSessionToMain = (breakout, newSessionType) => {
+  return (
+    breakout.previous('sessionType') === BREAKOUTS.SESSION_TYPES.BREAKOUT &&
+    newSessionType === BREAKOUTS.SESSION_TYPES.MAIN
+  );
+};

package/src/common/errors/webex-errors.ts

@@ -72,13 +72,17 @@ WebExMeetingsErrors[UserNotJoinedError.CODE] = UserNotJoinedError;
  * @classdesc Raised whenever the user has not established media yet.
  * @extends WebexMeetingsError
  * @property {number} code - 30103
- * @property {string} message - 'User has not established media yet'
+ * @property {string} message - error message
  */
 class NoMediaEstablishedYetError extends WebexMeetingsError {
   static CODE = 30103;
 
+  // eslint-disable-next-line require-jsdoc
   constructor() {
-    super(NoMediaEstablishedYetError.CODE, 'User has not established media yet');
+    super(
+      NoMediaEstablishedYetError.CODE,
+      'Webrtc media connection is missing, call addMedia() first'
+    );
   }
 }
 

package/src/common/logs/logger-proxy.ts

@@ -1,4 +1,4 @@
-/* eslint-disable no-unused-vars */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import LoggerConfig from './logger-config';
 
 const LoggerProxy: any = {

package/src/common/queue.ts

@@ -1,13 +1,18 @@
 /**
- * Simple queue
+ * Simple queue in which the elements are always sorted
  */
-export default class SimpleQueue {
-  queue: any[];
+export default class SortedQueue<ItemType> {
+  queue: ItemType[];
+  // returns -1 if left < right, 0 if left === right, +1 if left > right
+  compareFunc: (left: ItemType, right: ItemType) => number;
+
   /**
-   * @constructs SimpleQueue
+   * @constructs SortedQueue
+   * @param {Function} compareFunc comparison function used for sorting the elements of the queue
    */
-  constructor() {
+  constructor(compareFunc: (left: ItemType, right: ItemType) => number) {
     this.queue = [];
+    this.compareFunc = compareFunc;
   }
 
   /**
@@ -23,8 +28,17 @@ export default class SimpleQueue {
    * @param {object} item
    * @returns {undefined}
    */
-  enqueue(item: object) {
-    this.queue.push(item);
+  enqueue(item: ItemType) {
+    // Find the index of the first item in the queue that's greater or equal to the new item.
+    // That's where we want to insert the new item.
+    const idx = this.queue.findIndex((existingItem) => {
+      return this.compareFunc(existingItem, item) >= 0;
+    });
+    if (idx >= 0) {
+      this.queue.splice(idx, 0, item);
+    } else {
+      this.queue.push(item);
+    }
   }
 
   /**
@@ -32,7 +46,7 @@ export default class SimpleQueue {
    * Returns null if the queue is empty.
    * @returns {(object|null)} Queue item or null.
    */
-  dequeue() {
+  dequeue(): ItemType {
     if (this.queue.length === 0) {
       return null;
     }