@webex/plugin-meetings 3.0.0-beta.28 → 3.0.0-beta.280

package/dist/breakouts/index.js

@@ -1,5 +1,10 @@
 "use strict";
 
+var _Object$keys = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
+var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
 var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
 var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
 _Object$defineProperty(exports, "__esModule", {
@@ -18,15 +23,17 @@ var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy")
 var _constants = require("../constants");
 var _breakout = _interopRequireDefault(require("./breakout"));
 var _collection = _interopRequireDefault(require("./collection"));
-/*!
- * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
- */
-
+var _request = _interopRequireDefault(require("./request"));
+var _events = _interopRequireDefault(require("./events"));
+var _utils = require("./utils");
+function ownKeys(object, enumerableOnly) { var keys = _Object$keys(object); if (_Object$getOwnPropertySymbols) { var symbols = _Object$getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return _Object$getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(target, _Object$getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { _Object$defineProperty(target, key, _Object$getOwnPropertyDescriptor(source, key)); }); } return target; }
 /**
  * @class Breakouts
  */
 var Breakouts = _webexCore.WebexPlugin.extend({
   namespace: _constants.MEETINGS,
+  breakoutRequest: _request.default,
   collections: {
     breakouts: _collection.default
   },
@@ -37,6 +44,8 @@ var Breakouts = _webexCore.WebexPlugin.extend({
     // appears once breakouts start
     enableBreakoutSession: 'boolean',
     // appears from the moment you enable breakouts
+    hasBreakoutPreAssignments: 'boolean',
+    // appears from the moment you enable breakouts
     groupId: 'string',
     // appears from the moment you enable breakouts
     name: 'string',
@@ -53,7 +62,21 @@ var Breakouts = _webexCore.WebexPlugin.extend({
     // appears from the moment you enable breakouts
     locusUrl: 'string',
     // the current locus url
-    breakoutServiceUrl: 'string' // the current breakout resouce url
+    breakoutServiceUrl: 'string',
+    // the current breakout resource url
+    mainLocusUrl: 'string',
+    // the locus url of the main session
+    groups: 'array',
+    // appears when create breakouts
+    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: {
@@ -61,6 +84,7 @@ var Breakouts = _webexCore.WebexPlugin.extend({
   },
   derived: {
     isInMainSession: {
+      cache: false,
       deps: ['sessionType'],
       /**
        * Returns true if the user is in the main session
@@ -69,6 +93,56 @@ var Breakouts = _webexCore.WebexPlugin.extend({
       fn: function fn() {
         return this.sessionType === _constants.BREAKOUTS.SESSION_TYPES.MAIN;
       }
+    },
+    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
+       * @returns {boolean}
+       */
+      fn: function fn() {
+        return this.sessionType === _constants.BREAKOUTS.SESSION_TYPES.BREAKOUT && (this.status === _constants.BREAKOUTS.STATUS.OPEN || this.status === _constants.BREAKOUTS.STATUS.CLOSING);
+      }
+    },
+    breakoutGroupId: {
+      cache: false,
+      deps: ['manageGroups'],
+      /**
+       * Returns the active group id
+       * @returns {boolean}
+       */
+      fn: function fn() {
+        var _this$manageGroups;
+        if ((_this$manageGroups = this.manageGroups) !== null && _this$manageGroups !== void 0 && _this$manageGroups.length) {
+          return this.manageGroups[0].status !== _constants.BREAKOUTS.STATUS.CLOSED ? this.manageGroups[0].id : '';
+        }
+        return '';
+      }
+    },
+    breakoutStatus: {
+      cache: true,
+      deps: ['isInMainSession', 'status', 'groups'],
+      /**
+       * Returns the breakout status
+       * @returns {boolean}
+       */
+      fn: function fn() {
+        var _this$groups, _this$groups$;
+        return this.isInMainSession ? (_this$groups = this.groups) === null || _this$groups === void 0 ? void 0 : (_this$groups$ = _this$groups[0]) === null || _this$groups$ === void 0 ? void 0 : _this$groups$.status : this.status;
+      }
+    },
+    shouldQueryPreAssignments: {
+      cache: false,
+      deps: ['canManageBreakouts', 'enableBreakoutSession', 'hasBreakoutPreAssignments'],
+      /**
+       * Returns should query preAssignments or not
+       * @returns {boolean}
+       */
+      fn: function fn() {
+        return !!(this.canManageBreakouts && this.enableBreakoutSession && this.hasBreakoutPreAssignments);
+      }
     }
   },
   /**
@@ -77,20 +151,35 @@ var Breakouts = _webexCore.WebexPlugin.extend({
    */
   initialize: function initialize() {
     var _this = this;
-    this.listenTo(this, 'change:status', function () {
-      if (_this.status === _constants.BREAKOUTS.STATUS.CLOSING) {
+    this.listenTo(this, 'change:breakoutStatus', function () {
+      if (_this.breakoutStatus === _constants.BREAKOUTS.STATUS.CLOSING) {
         _this.trigger(_constants.BREAKOUTS.EVENTS.BREAKOUTS_CLOSING);
       }
     });
+    this.listenTo(this, 'change:shouldQueryPreAssignments', function () {
+      if (_this.shouldQueryPreAssignments && !_this.preAssignments) {
+        _this.queryPreAssignments();
+      }
+    });
     this.debouncedQueryRosters = (0, _debounce2.default)(this.queryRosters, 10, {
       leading: true,
       trailing: false
     });
-    this.listenTo(this.breakouts, 'add', function () {
+    this.listenTo(this.breakouts, 'add', function (breakout) {
       _this.debouncedQueryRosters();
+      _this.triggerReturnToMainEvent(breakout);
     });
+    this.listenTo(this.breakouts, 'change:requestedLastModifiedTime', function (breakout) {
+      _this.triggerReturnToMainEvent(breakout);
+    });
+    this.listenToCurrentSessionTypeChange();
     this.listenToBroadcastMessages();
     this.listenToBreakoutRosters();
+    this.listenToBreakoutHelp();
+    // @ts-ignore
+    this.breakoutRequest = new _request.default({
+      webex: this.webex
+    });
   },
   /**
    * Calls this to clean up listeners
@@ -106,9 +195,22 @@ var Breakouts = _webexCore.WebexPlugin.extend({
    */
   locusUrlUpdate: function locusUrlUpdate(locusUrl) {
     this.set('locusUrl', locusUrl);
+    var isInMainSession = this.isInMainSession,
+      mainLocusUrl = this.mainLocusUrl;
+    if (isInMainSession || !mainLocusUrl) {
+      this.set('mainLocusUrl', locusUrl);
+    }
   },
   /**
-   * Update the current breakout resouce url
+   * Update whether self is moderator/cohost or not
+   * @param {boolean} canManageBreakouts
+   * @returns {void}
+   */
+  updateCanManageBreakouts: function updateCanManageBreakouts(canManageBreakouts) {
+    this.set('canManageBreakouts', canManageBreakouts);
+  },
+  /**
+   * Update the current breakout resource url
    * @param {string} breakoutServiceUrl
    * @returns {void}
    */
@@ -129,7 +231,7 @@ var Breakouts = _webexCore.WebexPlugin.extend({
       }
     }).then(function (result) {
       var rosters = result.body.rosters;
-      rosters.forEach(function (_ref) {
+      rosters === null || rosters === void 0 ? void 0 : rosters.forEach(function (_ref) {
         var locus = _ref.locus;
         _this2.handleRosterUpdate(locus);
       });
@@ -152,25 +254,37 @@ var Breakouts = _webexCore.WebexPlugin.extend({
     }
     session.parseRoster(locus);
   },
+  /**
+   *Sets up listener for currentBreakoutSession sessionType changed
+   * @returns {void}
+   */
+  listenToCurrentSessionTypeChange: function listenToCurrentSessionTypeChange() {
+    var _this3 = this;
+    this.listenTo(this.currentBreakoutSession, 'change:sessionType', function (currentBreakoutSession, sessionType) {
+      if ((0, _utils.isSessionTypeChangedFromSessionToMain)(currentBreakoutSession, sessionType)) {
+        _this3.trigger(_constants.BREAKOUTS.EVENTS.LEAVE_BREAKOUT);
+      }
+    });
+  },
   /**
    * Sets up listener for broadcast messages sent to the breakout session
    * @returns {void}
    */
   listenToBroadcastMessages: function listenToBroadcastMessages() {
-    var _this3 = this;
+    var _this4 = this;
     this.listenTo(this.webex.internal.llm, 'event:breakout.message', function (event) {
       var _event$data = event.data,
         senderUserId = _event$data.senderUserId,
         sentTime = _event$data.sentTime,
         message = _event$data.message;
-      _this3.trigger(_constants.BREAKOUTS.EVENTS.MESSAGE, {
+      _this4.trigger(_constants.BREAKOUTS.EVENTS.MESSAGE, {
         senderUserId: senderUserId,
         sentTime: sentTime,
         message: message,
         // FIXME: This is only the current sessionId
         // We'd need to check that the dataChannelUrl is still the same
         // to guarantee that this message was sent to this session
-        sessionId: _this3.currentBreakoutSession.sessionId
+        sessionId: _this4.currentBreakoutSession.sessionId
       });
     });
   },
@@ -179,12 +293,45 @@ var Breakouts = _webexCore.WebexPlugin.extend({
    * @returns {void}
    */
   listenToBreakoutRosters: function listenToBreakoutRosters() {
-    var _this4 = this;
+    var _this5 = this;
     this.listenTo(this.webex.internal.mercury, 'event:breakout.roster', function (event) {
-      _this4.handleRosterUpdate(event.data.locus);
-      _this4.trigger(_constants.BREAKOUTS.EVENTS.MEMBERS_UPDATE);
+      _this5.handleRosterUpdate(event.data.locus);
+      _this5.trigger(_constants.BREAKOUTS.EVENTS.MEMBERS_UPDATE);
+    });
+  },
+  /**
+   * Sets up a listener for ask help notify from mecury
+   * @returns {void}
+   */
+  listenToBreakoutHelp: function listenToBreakoutHelp() {
+    var _this6 = this;
+    this.listenTo(this.webex.internal.mercury, 'event:breakout.help', function (event) {
+      var _event$data2 = event.data,
+        participant = _event$data2.participant,
+        sessionId = _event$data2.sessionId;
+      _this6.trigger(_constants.BREAKOUTS.EVENTS.ASK_FOR_HELP, {
+        participant: participant,
+        sessionId: sessionId
+      });
     });
   },
+  /**
+   * get current breakout is in progress or not
+   * @returns {boolean}
+   */
+  isBreakoutInProgress: function isBreakoutInProgress() {
+    var _this$groups2, _this$groups2$;
+    var currentStatus = ((_this$groups2 = this.groups) === null || _this$groups2 === void 0 ? void 0 : (_this$groups2$ = _this$groups2[0]) === null || _this$groups2$ === void 0 ? void 0 : _this$groups2$.status) || this.status;
+    return currentStatus === _constants.BREAKOUTS.STATUS.OPEN || currentStatus === _constants.BREAKOUTS.STATUS.CLOSING;
+  },
+  /**
+   * get current breakout is in closing or not
+   * @returns {boolean}
+   */
+  isBreakoutIClosing: function isBreakoutIClosing() {
+    var _this$groups3, _this$groups3$;
+    return (((_this$groups3 = this.groups) === null || _this$groups3 === void 0 ? void 0 : (_this$groups3$ = _this$groups3[0]) === null || _this$groups3$ === void 0 ? void 0 : _this$groups3$.status) || this.status) === _constants.BREAKOUTS.STATUS.CLOSING;
+  },
   /**
    * Updates the information about the current breakout
    * @param {Object} params
@@ -193,6 +340,10 @@ var Breakouts = _webexCore.WebexPlugin.extend({
   updateBreakout: function updateBreakout(params) {
     var _this$set;
     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', (_this$set = {
       sessionId: params.sessionId,
       groupId: params.groupId,
@@ -200,8 +351,21 @@ var Breakouts = _webexCore.WebexPlugin.extend({
       current: true,
       sessionType: params.sessionType,
       url: params.url
-    }, (0, _defineProperty2.default)(_this$set, _constants.BREAKOUTS.SESSION_STATES.ACTIVE, false), (0, _defineProperty2.default)(_this$set, _constants.BREAKOUTS.SESSION_STATES.ALLOWED, false), (0, _defineProperty2.default)(_this$set, _constants.BREAKOUTS.SESSION_STATES.ALLOWED, false), (0, _defineProperty2.default)(_this$set, _constants.BREAKOUTS.SESSION_STATES.ASSIGNED_CURRENT, false), (0, _defineProperty2.default)(_this$set, _constants.BREAKOUTS.SESSION_STATES.REQUESTED, false), _this$set));
-    this.set('enableBreakoutSession', params.enableBreakoutSession);
+    }, (0, _defineProperty2.default)(_this$set, _constants.BREAKOUTS.SESSION_STATES.ACTIVE, false), (0, _defineProperty2.default)(_this$set, _constants.BREAKOUTS.SESSION_STATES.ALLOWED, false), (0, _defineProperty2.default)(_this$set, _constants.BREAKOUTS.SESSION_STATES.ASSIGNED, false), (0, _defineProperty2.default)(_this$set, _constants.BREAKOUTS.SESSION_STATES.ASSIGNED_CURRENT, false), (0, _defineProperty2.default)(_this$set, _constants.BREAKOUTS.SESSION_STATES.REQUESTED, false), _this$set));
+    if (!this.isBreakoutInProgress()) {
+      this.clearBreakouts();
+    }
+    if (this.currentBreakoutSession.previous('sessionId') !== this.currentBreakoutSession.sessionId || this.currentBreakoutSession.previous('groupId') !== this.currentBreakoutSession.groupId) {
+      // should report joined session changed
+      var meeting = this.webex.meetings.getMeetingByType(_constants._ID_, this.meetingId);
+      _events.default.onBreakoutJoinResponse({
+        currentSession: this.currentBreakoutSession,
+        meeting: meeting,
+        breakoutMoveId: params.breakoutMoveId
+      },
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent.bind(this.webex.internal.newMetrics));
+    }
   },
   /**
    * Updates the information about available breakouts
@@ -209,8 +373,14 @@ var Breakouts = _webexCore.WebexPlugin.extend({
    * @returns {void}
    */
   updateBreakoutSessions: function updateBreakoutSessions(payload) {
-    var _this5 = this;
+    var _this7 = this;
     var 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) {
       (0, _forEach2.default)(_constants.BREAKOUTS.SESSION_STATES, function (state) {
         (0, _forEach2.default)(payload.breakoutSessions[state], function (breakout) {
@@ -224,15 +394,76 @@ var Breakouts = _webexCore.WebexPlugin.extend({
             breakouts[sessionId][_constants.BREAKOUTS.SESSION_STATES.REQUESTED] = false;
           }
           breakouts[sessionId][state] = true;
+          if (state === _constants.BREAKOUTS.SESSION_STATES.REQUESTED) {
+            breakouts[sessionId].requestedLastModifiedTime = breakout.modifiedAt;
+          }
         });
       });
     }
     (0, _forEach2.default)(breakouts, function (breakout) {
       // eslint-disable-next-line no-param-reassign
-      breakout.url = _this5.url;
+      breakout.url = _this7.url;
     });
     this.breakouts.set((0, _values.default)(breakouts));
   },
+  /**
+   * clear breakouts collection
+   * @returns {void}
+   */
+  clearBreakouts: function clearBreakouts() {
+    if (this.breakouts.length > 0) {
+      this.breakouts.reset();
+    }
+  },
+  /**
+   * get main session
+   * @returns {Breakout}
+   */
+  getMainSession: function getMainSession() {
+    if (this.isInMainSession) {
+      return this.currentBreakoutSession;
+    }
+    var mainSession = this.breakouts.filter(function (breakout) {
+      return breakout.isMain;
+    })[0];
+    if (!mainSession) {
+      throw new Error('no main session found');
+    }
+    return mainSession;
+  },
+  /**
+   * Host/CoHost ask all participants return to main session
+   * @returns {Promise}
+   */
+  askAllToReturn: function askAllToReturn() {
+    var mainSession = this.getMainSession();
+    return this.webex.request({
+      method: _constants.HTTP_VERBS.POST,
+      uri: "".concat(this.url, "/requestMove"),
+      body: {
+        groupId: mainSession.groupId,
+        sessionId: mainSession.sessionId
+      }
+    });
+  },
+  /**
+   * Broadcast message to all breakout session's participants
+   * @param {String} message
+   * @param {Object} options
+   * @returns {Promise}
+   */
+  broadcast: function broadcast(message, options) {
+    var breakoutGroupId = this.breakoutGroupId;
+    if (!breakoutGroupId) {
+      throw new Error('Cannot broadcast, no breakout session found');
+    }
+    return this.breakoutRequest.broadcast({
+      url: this.url,
+      message: message,
+      options: options,
+      groupId: breakoutGroupId
+    });
+  },
   /**
    * Make enable breakout resource
    * @returns {Promise}
@@ -254,39 +485,39 @@ var Breakouts = _webexCore.WebexPlugin.extend({
     return _promise.default.reject(new Error("enableBreakouts: the breakoutServiceUrl is empty"));
   },
   /**
-   * Make the meeting enbale or disable breakout session
+   * Make the meeting enable or disable breakout session
    * @param {boolean} enable
    * @returns {Promise}
    */
   toggleBreakout: function toggleBreakout(enable) {
-    var _this6 = this;
+    var _this8 = this;
     return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee() {
       var info;
       return _regenerator.default.wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            if (!(_this6.enableBreakoutSession === undefined)) {
+            if (!(_this8.enableBreakoutSession === undefined)) {
               _context.next = 10;
               break;
             }
             _context.next = 3;
-            return _this6.enableBreakouts();
+            return _this8.enableBreakouts();
           case 3:
             info = _context.sent;
+            // first time enable, set the initial data
+            _this8.updateBreakout(info === null || info === void 0 ? void 0 : info.body);
             if (enable) {
               _context.next = 8;
               break;
             }
-            // if enable is false, updateBreakout set the param then set enableBreakoutSession as false
-            _this6.updateBreakout(info.body);
             _context.next = 8;
-            return _this6.doToggleBreakout(enable);
+            return _this8.doToggleBreakout(enable);
           case 8:
             _context.next = 12;
             break;
           case 10:
             _context.next = 12;
-            return _this6.doToggleBreakout(enable);
+            return _this8.doToggleBreakout(enable);
           case 12:
           case "end":
             return _context.stop();
@@ -300,16 +531,517 @@ var Breakouts = _webexCore.WebexPlugin.extend({
    * @returns {Promise}
    */
   doToggleBreakout: function doToggleBreakout(enable) {
+    var body = _objectSpread(_objectSpread({}, this.editLock && !!this.editLock.token ? {
+      editlock: {
+        token: this.editLock.token
+      }
+    } : {}), {
+      enableBreakoutSession: enable
+    });
+
     // @ts-ignore
     return this.webex.request({
       method: _constants.HTTP_VERBS.PUT,
       uri: this.url,
-      body: {
-        enableBreakoutSession: enable
+      body: body
+    });
+  },
+  /**
+   * set groups to manageGroups prop
+   * @param {Object} breakoutInfo -- breakout groups
+   * @returns {void}
+   */
+  _setManageGroups: function _setManageGroups(breakoutInfo) {
+    var _breakoutInfo$body;
+    if (breakoutInfo !== null && breakoutInfo !== void 0 && (_breakoutInfo$body = breakoutInfo.body) !== null && _breakoutInfo$body !== void 0 && _breakoutInfo$body.groups) {
+      this.set('manageGroups', breakoutInfo.body.groups);
+    }
+  },
+  /**
+   * Create new breakout sessions
+   * @param {object} params -- breakout session group
+   * @returns {Promise}
+   */
+  create: function create(params) {
+    var _this9 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var payload, body, breakoutInfo;
+      return _regenerator.default.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            payload = _objectSpread({}, params);
+            body = _objectSpread(_objectSpread({}, _this9.editLock && !!_this9.editLock.token ? {
+              editlock: {
+                token: _this9.editLock.token
+              }
+            } : {}), {
+              groups: [payload]
+            }); // @ts-ignore
+            _context2.next = 4;
+            return _this9.webex.request({
+              method: _constants.HTTP_VERBS.PUT,
+              uri: _this9.url,
+              body: body
+            }).catch(function (error) {
+              return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#create'));
+            });
+          case 4:
+            breakoutInfo = _context2.sent;
+            _this9._setManageGroups(breakoutInfo);
+
+            // clear edit lock info after save breakout session info
+            _this9._clearEditLockInfo();
+            return _context2.abrupt("return", breakoutInfo);
+          case 8:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }))();
+  },
+  /**
+   * Delete all breakout sessions
+   * @returns {Promise}
+   */
+  clearSessions: function clearSessions() {
+    var _this10 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+      var body, breakoutInfo;
+      return _regenerator.default.wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            body = _objectSpread(_objectSpread({}, _this10.editLock && !!_this10.editLock.token ? {
+              editlock: {
+                token: _this10.editLock.token
+              }
+            } : {}), {
+              groups: [{
+                action: _constants.BREAKOUTS.ACTION.DELETE
+              }]
+            }); // @ts-ignore
+            _context3.next = 3;
+            return _this10.webex.request({
+              method: _constants.HTTP_VERBS.PUT,
+              uri: _this10.url,
+              body: body
+            }).catch(function (error) {
+              return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#clearSessions'));
+            });
+          case 3:
+            breakoutInfo = _context3.sent;
+            _this10._setManageGroups(breakoutInfo);
+            return _context3.abrupt("return", breakoutInfo);
+          case 6:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }))();
+  },
+  /**
+   * Host or cohost starts breakout sessions
+   * @param {object} params
+   * @returns {Promise}
+   */
+  start: function start() {
+    var _arguments = arguments,
+      _this11 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var params, action, payload, body, breakoutInfo;
+      return _regenerator.default.wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            params = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : {};
+            action = _constants.BREAKOUTS.ACTION.START;
+            payload = _objectSpread({
+              id: _this11.breakoutGroupId,
+              action: action,
+              allowBackToMain: false,
+              allowToJoinLater: false
+            }, params);
+            body = _objectSpread(_objectSpread({}, _this11.editLock && !!_this11.editLock.token ? {
+              editlock: {
+                token: _this11.editLock.token,
+                refresh: true
+              }
+            } : {}), {
+              groups: [payload]
+            });
+            _context4.next = 6;
+            return _this11.request({
+              method: _constants.HTTP_VERBS.PUT,
+              uri: _this11.url,
+              body: body
+            }).catch(function (error) {
+              return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#start'));
+            });
+          case 6:
+            breakoutInfo = _context4.sent;
+            _this11._setManageGroups(breakoutInfo);
+            return _context4.abrupt("return", breakoutInfo);
+          case 9:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }))();
+  },
+  /**
+   * Host or cohost ends breakout sessions
+   * @param {object} params
+   * @returns {Promise}
+   */
+  end: function end() {
+    var _arguments2 = arguments,
+      _this12 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      var params, delayCloseTime, id, action, payload, body, breakoutInfo;
+      return _regenerator.default.wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            params = _arguments2.length > 0 && _arguments2[0] !== undefined ? _arguments2[0] : {};
+            delayCloseTime = _this12.delayCloseTime, id = _this12.breakoutGroupId;
+            action = _constants.BREAKOUTS.ACTION.CLOSE;
+            payload = _objectSpread({
+              id: id,
+              action: action,
+              delayCloseTime: delayCloseTime
+            }, params);
+            body = _objectSpread(_objectSpread({}, _this12.editLock && !!_this12.editLock.token ? {
+              editlock: {
+                token: _this12.editLock.token,
+                refresh: true
+              }
+            } : {}), {
+              groups: [payload]
+            });
+            _context5.next = 7;
+            return _this12.request({
+              method: _constants.HTTP_VERBS.PUT,
+              uri: _this12.url,
+              body: body
+            }).catch(function (error) {
+              return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#end'));
+            });
+          case 7:
+            breakoutInfo = _context5.sent;
+            _this12._setManageGroups(breakoutInfo);
+            return _context5.abrupt("return", breakoutInfo);
+          case 10:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    }))();
+  },
+  /**
+   * Host or cohost update breakout sessions
+   * @param {Object} params
+   * @param {String} params.id
+   * @param {Boolean} unlockEdit
+   * @returns {Promise}
+   */
+  update: function update(params, unlockEdit) {
+    var _this13 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
+      var _this13$editLock;
+      var payload, body, breakoutInfo;
+      return _regenerator.default.wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            if (params.id) {
+              _context6.next = 2;
+              break;
+            }
+            return _context6.abrupt("return", _promise.default.reject(new Error('Missing breakout group id')));
+          case 2:
+            payload = _objectSpread({}, params);
+            body = _objectSpread(_objectSpread({}, (_this13$editLock = _this13.editLock) !== null && _this13$editLock !== void 0 && _this13$editLock.token ? {
+              editlock: {
+                token: _this13.editLock.token,
+                refresh: !unlockEdit
+              }
+            } : {}), {
+              groups: [payload]
+            });
+            _context6.next = 6;
+            return _this13.request({
+              method: _constants.HTTP_VERBS.PUT,
+              uri: _this13.url,
+              body: body
+            }).catch(function (error) {
+              return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#update'));
+            });
+          case 6:
+            breakoutInfo = _context6.sent;
+            if (unlockEdit) {
+              _this13._clearEditLockInfo();
+            }
+            _this13._setManageGroups(breakoutInfo);
+            return _context6.abrupt("return", breakoutInfo);
+          case 10:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    }))();
+  },
+  /**
+   * get existed breakout sessions
+   * @param {boolean} editlock -- lock operations of the breakout sessions
+   * @returns {Promise}
+   */
+  getBreakout: function getBreakout(editlock) {
+    var _this14 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
+      var _breakout$body, _breakout$body$editlo;
+      var breakout;
+      return _regenerator.default.wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            _context7.next = 2;
+            return _this14.request({
+              method: _constants.HTTP_VERBS.GET,
+              uri: _this14.url + (editlock ? "?editlock=".concat(editlock) : '')
+            });
+          case 2:
+            breakout = _context7.sent;
+            _this14._setManageGroups(breakout);
+            if (editlock && (_breakout$body = breakout.body) !== null && _breakout$body !== void 0 && (_breakout$body$editlo = _breakout$body.editlock) !== null && _breakout$body$editlo !== void 0 && _breakout$body$editlo.token) {
+              _this14.set('editLock', breakout.body.editlock);
+              _this14.keepEditLockAlive();
+            }
+            return _context7.abrupt("return", breakout);
+          case 6:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7);
+    }))();
+  },
+  /**
+   * enable and edit lock breakout
+   * @returns {void}
+   */
+  enableAndLockBreakout: function enableAndLockBreakout() {
+    var _this15 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
+      var info;
+      return _regenerator.default.wrap(function _callee8$(_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            if (!_this15.enableBreakoutSession) {
+              _context8.next = 4;
+              break;
+            }
+            _this15.lockBreakout();
+            _context8.next = 8;
+            break;
+          case 4:
+            _context8.next = 6;
+            return _this15.enableBreakouts();
+          case 6:
+            info = _context8.sent;
+            if (info.body) {
+              _this15.lockBreakout();
+            }
+          case 8:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8);
+    }))();
+  },
+  /**
+   * breakout edit locked by yourself or not
+   * @returns {boolean}
+   */
+  hasBreakoutLocked: function hasBreakoutLocked() {
+    return this.editLock && this.editLock.token && this.editLock.state === _constants.BREAKOUTS.EDIT_LOCK_STATUS.LOCKED;
+  },
+  /**
+   * send breakout edit lock
+   * @returns {void}
+   */
+  lockBreakout: function lockBreakout() {
+    var _this16 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9() {
+      var _breakout$body2, breakout;
+      return _regenerator.default.wrap(function _callee9$(_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            if (!(_this16.editLock && !!_this16.editLock.token)) {
+              _context9.next = 8;
+              break;
+            }
+            if (!(_this16.editLock.state === _constants.BREAKOUTS.EDIT_LOCK_STATUS.LOCKED)) {
+              _context9.next = 5;
+              break;
+            }
+            throw new Error('Breakout already locked');
+          case 5:
+            _this16.keepEditLockAlive();
+          case 6:
+            _context9.next = 12;
+            break;
+          case 8:
+            _context9.next = 10;
+            return _this16.getBreakout(true);
+          case 10:
+            breakout = _context9.sent;
+            if ((_breakout$body2 = breakout.body) !== null && _breakout$body2 !== void 0 && _breakout$body2.editlock) {
+              _this16.keepEditLockAlive();
+            }
+          case 12:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    }))();
+  },
+  /**
+   * keep edit lock alive
+   * @returns {void}
+   */
+  keepEditLockAlive: function keepEditLockAlive() {
+    var _this17 = this;
+    if (this.editLock && !!this.editLock.token) {
+      var ttl = this.editLock.ttl < 30 ? _constants.BREAKOUTS.DEFAULT_TTL : this.editLock.ttl;
+      if (this.intervalID) {
+        window.clearInterval(this.intervalID);
+      }
+      this.intervalID = window.setInterval(function () {
+        _this17.request({
+          method: _constants.HTTP_VERBS.PUT,
+          uri: "".concat(_this17.url, "/editlock/").concat(_this17.editLock.token)
+        }).catch(function (error) {
+          _this17._clearEditLockInfo();
+          return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#keepEditLockAlive'));
+        });
+      }, ttl / 2 * 1000);
+    }
+  },
+  /**
+   * unlock edit breakout
+   * @returns {void}
+   */
+  unLockEditBreakout: function unLockEditBreakout() {
+    var _this18 = this;
+    if (this.editLock && !!this.editLock.token) {
+      this.request({
+        method: _constants.HTTP_VERBS.DELETE,
+        uri: "".concat(this.url, "/editlock/").concat(this.editLock.token)
+      }).then(function () {
+        _this18._clearEditLockInfo();
+      }).catch(function (error) {
+        return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#unLockEditBreakout'));
+      });
+    }
+  },
+  /**
+   * clear interval and edit lock info
+   * @private
+   * @returns {void}
+   */
+  _clearEditLockInfo: function _clearEditLockInfo() {
+    if (this.intervalID) {
+      clearInterval(this.intervalID);
+    }
+    this.set('editLock', {});
+  },
+  /**
+   * assign participants to breakout session
+   * @param {Array} sessions
+   * @returns {void}
+   */
+  assign: function assign(sessions) {
+    var internalSessions = sessions.map(function (item) {
+      return {
+        id: item.id,
+        assigned: item.memberIds,
+        assignedEmails: item.emails,
+        anyoneCanJoin: !!item.anyone
+      };
+    });
+    var body = _objectSpread(_objectSpread({}, this.editLock && !!this.editLock.token ? {
+      editlock: {
+        token: this.editLock.token,
+        refresh: true
+      }
+    } : {}), {
+      groups: [{
+        id: this.breakoutGroupId,
+        sessions: internalSessions
+      }]
+    });
+    return this.request({
+      method: _constants.HTTP_VERBS.PUT,
+      uri: this.url,
+      body: body
+    });
+  },
+  /**
+   * query preAssignments
+   * @returns {void}
+   */
+  queryPreAssignments: function queryPreAssignments() {
+    var _this19 = this;
+    this.webex.request({
+      uri: "".concat(this.url, "/preassignments"),
+      qs: {
+        locusUrl: btoa(this.locusUrl)
+      }
+    }).then(function (result) {
+      var _result$body;
+      if ((_result$body = result.body) !== null && _result$body !== void 0 && _result$body.groups) {
+        _this19.set('preAssignments', result.body.groups);
+        _this19.trigger(_constants.BREAKOUTS.EVENTS.PRE_ASSIGNMENTS_UPDATE);
       }
+    }).catch(function (error) {
+      _loggerProxy.default.logger.error('Meeting:breakouts#queryPreAssignments failed', error);
+    });
+  },
+  /**
+   * assign participants dynamically after breakout sessions started,
+   * but currently it only used for admitting participants from lobby into breakout directly
+   * @param {Array} sessions
+   * @returns {void}
+   */
+  dynamicAssign: function dynamicAssign(sessions) {
+    var updatedSessions = sessions.map(function (item) {
+      return {
+        id: item.id,
+        participants: item.participants,
+        targetState: item.targetState
+      };
     });
+    var body = {
+      groups: [{
+        id: this.breakoutGroupId,
+        sessions: updatedSessions
+      }],
+      editlock: null
+    };
+    if (this.editLock && this.editLock.token) {
+      body.editlock = this.editLock;
+    }
+    return this.request({
+      method: _constants.HTTP_VERBS.PUT,
+      uri: "".concat(this.url, "/dynamicAssign"),
+      body: body
+    });
+  },
+  /**
+   * trigger ASK_RETURN_TO_MAIN event when main session requested
+   * @param {Object} breakout
+   * @returns {void}
+   */
+  triggerReturnToMainEvent: function triggerReturnToMainEvent(breakout) {
+    if (breakout.isMain && breakout.requested) {
+      this.trigger(_constants.BREAKOUTS.EVENTS.ASK_RETURN_TO_MAIN);
+    }
   },
-  version: "3.0.0-beta.28"
+  version: "3.0.0-beta.280"
 });
 var _default = Breakouts;
 exports.default = _default;