@webex/plugin-meetings 3.0.0-beta.7 → 3.0.0-beta.71

package/dist/breakouts/index.js

@@ -0,0 +1,843 @@
+"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", {
+  value: true
+});
+exports.default = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _forEach2 = _interopRequireDefault(require("lodash/forEach"));
+var _debounce2 = _interopRequireDefault(require("lodash/debounce"));
+var _webexCore = require("@webex/webex-core");
+var _loggerProxy = _interopRequireDefault(require("../common/logs/logger-proxy"));
+var _constants = require("../constants");
+var _breakout = _interopRequireDefault(require("./breakout"));
+var _collection = _interopRequireDefault(require("./collection"));
+var _request = _interopRequireDefault(require("./request"));
+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
+  },
+  props: {
+    allowBackToMain: 'boolean',
+    // only present when in a breakout session
+    delayCloseTime: 'number',
+    // 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',
+    // only present when in a breakout session
+    sessionId: 'string',
+    // appears from the moment you enable breakouts
+    sessionType: 'string',
+    // appears from the moment you enable breakouts
+    startTime: 'string',
+    // appears once breakouts start
+    status: 'string',
+    // only present when in a breakout session
+    url: 'string',
+    // appears from the moment you enable breakouts
+    locusUrl: 'string',
+    // the current locus url
+    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
+    editLock: 'object',
+    // appears when getBreakout info editlock = true
+    intervalID: 'number',
+    meetingId: 'string'
+  },
+  children: {
+    currentBreakoutSession: _breakout.default
+  },
+  derived: {
+    isInMainSession: {
+      deps: ['sessionType'],
+      /**
+       * Returns true if the user is in the main session
+       * @returns {boolean}
+       */
+      fn: function fn() {
+        return this.sessionType === _constants.BREAKOUTS.SESSION_TYPES.MAIN;
+      }
+    },
+    isActiveBreakout: {
+      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: {
+      deps: ['groups'],
+      /**
+       * Returns the actived group id
+       * @returns {boolean}
+       */
+      fn: function fn() {
+        var _this$groups;
+        if ((_this$groups = this.groups) !== null && _this$groups !== void 0 && _this$groups.length) {
+          return this.groups[0].id;
+        }
+        return '';
+      }
+    }
+  },
+  /**
+   * initialize for the breakouts
+   * @returns {void}
+   */
+  initialize: function initialize() {
+    var _this = this;
+    this.listenTo(this, 'change:status', function () {
+      if (_this.status === _constants.BREAKOUTS.STATUS.CLOSING) {
+        _this.trigger(_constants.BREAKOUTS.EVENTS.BREAKOUTS_CLOSING);
+      }
+    });
+    this.debouncedQueryRosters = (0, _debounce2.default)(this.queryRosters, 10, {
+      leading: true,
+      trailing: false
+    });
+    this.listenTo(this.breakouts, 'add', function () {
+      _this.debouncedQueryRosters();
+    });
+    this.listenToBroadcastMessages();
+    this.listenToBreakoutRosters();
+    // @ts-ignore
+    this.breakoutRequest = new _request.default({
+      webex: this.webex
+    });
+  },
+  /**
+   * Calls this to clean up listeners
+   * @returns {void}
+   */
+  cleanUp: function cleanUp() {
+    this.stopListening();
+  },
+  /**
+   * Update the current locus url of the meeting
+   * @param {string} locusUrl // locus url
+   * @returns {void}
+   */
+  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 resource url
+   * @param {string} breakoutServiceUrl
+   * @returns {void}
+   */
+  breakoutServiceUrlUpdate: function breakoutServiceUrlUpdate(breakoutServiceUrl) {
+    this.set('breakoutServiceUrl', "".concat(breakoutServiceUrl, "/breakout/"));
+  },
+  /**
+   * The initial roster lists need to be queried because you don't
+   * get a breakout.roster event when you join the meeting
+   * @returns {void}
+   */
+  queryRosters: function queryRosters() {
+    var _this2 = this;
+    this.webex.request({
+      uri: "".concat(this.url, "/roster"),
+      qs: {
+        locusUrl: btoa(this.locusUrl)
+      }
+    }).then(function (result) {
+      var rosters = result.body.rosters;
+      rosters === null || rosters === void 0 ? void 0 : rosters.forEach(function (_ref) {
+        var locus = _ref.locus;
+        _this2.handleRosterUpdate(locus);
+      });
+      _this2.trigger(_constants.BREAKOUTS.EVENTS.MEMBERS_UPDATE);
+    }).catch(function (error) {
+      _loggerProxy.default.logger.error('Meeting:breakouts#queryRosters failed', error);
+    });
+  },
+  /**
+   *
+   * @param {Object} locus // locus object
+   * @returns {void}
+   */
+  handleRosterUpdate: function handleRosterUpdate(locus) {
+    var _locus$controls, _locus$controls$break;
+    var sessionId = (_locus$controls = locus.controls) === null || _locus$controls === void 0 ? void 0 : (_locus$controls$break = _locus$controls.breakout) === null || _locus$controls$break === void 0 ? void 0 : _locus$controls$break.sessionId;
+    var session = this.breakouts.get(sessionId);
+    if (!session) {
+      return;
+    }
+    session.parseRoster(locus);
+  },
+  /**
+   * Sets up listener for broadcast messages sent to the breakout session
+   * @returns {void}
+   */
+  listenToBroadcastMessages: function listenToBroadcastMessages() {
+    var _this3 = 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, {
+        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
+      });
+    });
+  },
+  /**
+   * Sets up a listener for roster messags from mecury
+   * @returns {void}
+   */
+  listenToBreakoutRosters: function listenToBreakoutRosters() {
+    var _this4 = this;
+    this.listenTo(this.webex.internal.mercury, 'event:breakout.roster', function (event) {
+      _this4.handleRosterUpdate(event.data.locus);
+      _this4.trigger(_constants.BREAKOUTS.EVENTS.MEMBERS_UPDATE);
+    });
+  },
+  /**
+   * Updates the information about the current breakout
+   * @param {Object} params
+   * @returns {void}
+   */
+  updateBreakout: function updateBreakout(params) {
+    var _this$set;
+    var preEnableBreakoutSession = this.get('enableBreakoutSession');
+    this.set(params);
+    this.set('groups', params.groups);
+    this.set('currentBreakoutSession', (_this$set = {
+      sessionId: params.sessionId,
+      groupId: params.groupId,
+      name: params.name,
+      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));
+
+    // We need to call queryPreAssignments when enableBreakoutSession become true
+    if (params.enableBreakoutSession && params.hasBreakoutPreAssignments && preEnableBreakoutSession !== params.enableBreakoutSession) {
+      this.queryPreAssignments();
+    }
+  },
+  /**
+   * Updates the information about available breakouts
+   * @param {Object} payload
+   * @returns {void}
+   */
+  updateBreakoutSessions: function updateBreakoutSessions(payload) {
+    var _this5 = this;
+    var breakouts = {};
+    if (payload.breakoutSessions) {
+      (0, _forEach2.default)(_constants.BREAKOUTS.SESSION_STATES, function (state) {
+        (0, _forEach2.default)(payload.breakoutSessions[state], function (breakout) {
+          var sessionId = breakout.sessionId;
+          if (!breakouts[sessionId]) {
+            breakouts[sessionId] = breakout;
+            breakouts[sessionId][_constants.BREAKOUTS.SESSION_STATES.ACTIVE] = false;
+            breakouts[sessionId][_constants.BREAKOUTS.SESSION_STATES.ASSIGNED] = false;
+            breakouts[sessionId][_constants.BREAKOUTS.SESSION_STATES.ALLOWED] = false;
+            breakouts[sessionId][_constants.BREAKOUTS.SESSION_STATES.ASSIGNED_CURRENT] = false;
+            breakouts[sessionId][_constants.BREAKOUTS.SESSION_STATES.REQUESTED] = false;
+          }
+          breakouts[sessionId][state] = true;
+        });
+      });
+    }
+    (0, _forEach2.default)(breakouts, function (breakout) {
+      // eslint-disable-next-line no-param-reassign
+      breakout.url = _this5.url;
+    });
+    this.breakouts.set((0, _values.default)(breakouts));
+  },
+  /**
+   * 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}
+   */
+  enableBreakouts: function enableBreakouts() {
+    if (this.breakoutServiceUrl) {
+      // @ts-ignore
+      return this.webex.request({
+        method: _constants.HTTP_VERBS.POST,
+        uri: this.breakoutServiceUrl,
+        body: {
+          locusUrl: this.locusUrl
+        }
+      }).catch(function (err) {
+        _loggerProxy.default.logger.error("Meeting:request#touchBreakout --> Error provisioning error ".concat(err));
+        throw err;
+      });
+    }
+    return _promise.default.reject(new Error("enableBreakouts: the breakoutServiceUrl is empty"));
+  },
+  /**
+   * Make the meeting enable or disable breakout session
+   * @param {boolean} enable
+   * @returns {Promise}
+   */
+  toggleBreakout: function toggleBreakout(enable) {
+    var _this6 = 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)) {
+              _context.next = 10;
+              break;
+            }
+            _context.next = 3;
+            return _this6.enableBreakouts();
+          case 3:
+            info = _context.sent;
+            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);
+          case 8:
+            _context.next = 12;
+            break;
+          case 10:
+            _context.next = 12;
+            return _this6.doToggleBreakout(enable);
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }))();
+  },
+  /**
+   * do toggle meeting breakout session enable or disable
+   * @param {boolean} enable
+   * @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: body
+    });
+  },
+  /**
+   * Create new breakout sessions
+   * @param {object} sessions -- breakout session group
+   * @returns {Promise}
+   */
+  create: function create(sessions) {
+    var _this7 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var _breakInfo$body;
+      var body, breakInfo;
+      return _regenerator.default.wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            body = _objectSpread(_objectSpread({}, _this7.editLock && !!_this7.editLock.token ? {
+              editlock: {
+                token: _this7.editLock.token
+              }
+            } : {}), {
+              groups: [{
+                sessions: sessions
+              }]
+            }); // @ts-ignore
+            _context2.next = 3;
+            return _this7.webex.request({
+              method: _constants.HTTP_VERBS.PUT,
+              uri: _this7.url,
+              body: body
+            }).catch(function (error) {
+              return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#create'));
+            });
+          case 3:
+            breakInfo = _context2.sent;
+            if ((_breakInfo$body = breakInfo.body) !== null && _breakInfo$body !== void 0 && _breakInfo$body.groups) {
+              _this7.set('groups', breakInfo.body.groups);
+            }
+
+            // clear edit lock info after save breakout session info
+            _this7._clearEditLockInfo();
+            return _context2.abrupt("return", _promise.default.resolve(breakInfo));
+          case 7:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }))();
+  },
+  /**
+   * Delete all breakout sessions
+   * @returns {Promise}
+   */
+  clearSessions: function clearSessions() {
+    var _this8 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+      var _breakInfo$body2;
+      var body, breakInfo;
+      return _regenerator.default.wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            body = _objectSpread(_objectSpread({}, _this8.editLock && !!_this8.editLock.token ? {
+              editlock: {
+                token: _this8.editLock.token
+              }
+            } : {}), {
+              groups: [{
+                action: _constants.BREAKOUTS.ACTION.DELETE
+              }]
+            }); // @ts-ignore
+            _context3.next = 3;
+            return _this8.webex.request({
+              method: _constants.HTTP_VERBS.PUT,
+              uri: _this8.url,
+              body: body
+            }).catch(function (error) {
+              return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#clearSessions'));
+            });
+          case 3:
+            breakInfo = _context3.sent;
+            if ((_breakInfo$body2 = breakInfo.body) !== null && _breakInfo$body2 !== void 0 && _breakInfo$body2.groups) {
+              _this8.set('groups', breakInfo.body.groups);
+            }
+            _this8.shouldFetchPreassignments = false;
+            return _context3.abrupt("return", _promise.default.resolve(breakInfo));
+          case 7:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    }))();
+  },
+  /**
+   * Host or cohost starts breakout sessions
+   * @param {object} params
+   * @returns {Promise}
+   */
+  start: function start() {
+    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var action = _constants.BREAKOUTS.ACTION.START;
+    var payload = _objectSpread({
+      id: this.breakoutGroupId,
+      action: action,
+      allowBackToMain: false,
+      allowToJoinLater: false,
+      duration: _constants.BREAKOUTS.DEFAULT_DURATION
+    }, params);
+    var body = _objectSpread(_objectSpread({}, this.editLock && !!this.editLock.token ? {
+      editlock: {
+        token: this.editLock.token,
+        refresh: true
+      }
+    } : {}), {
+      groups: [payload]
+    });
+    return this.request({
+      method: _constants.HTTP_VERBS.PUT,
+      uri: this.url,
+      body: body
+    }).catch(function (error) {
+      return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#start'));
+    });
+  },
+  /**
+   * Host or cohost ends breakout sessions
+   * @param {object} params
+   * @returns {Promise}
+   */
+  end: function end() {
+    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var delayCloseTime = this.delayCloseTime,
+      id = this.breakoutGroupId;
+    var action = _constants.BREAKOUTS.ACTION.CLOSE;
+    var payload = _objectSpread({
+      id: id,
+      action: action,
+      delayCloseTime: delayCloseTime
+    }, params);
+    var body = _objectSpread(_objectSpread({}, this.editLock && !!this.editLock.token ? {
+      editlock: {
+        token: this.editLock.token,
+        refresh: true
+      }
+    } : {}), {
+      groups: [payload]
+    });
+    return this.request({
+      method: _constants.HTTP_VERBS.PUT,
+      uri: this.url,
+      body: body
+    }).catch(function (error) {
+      return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#end'));
+    });
+  },
+  /**
+   * Host or cohost update breakout sessions
+   * @param {Object} params
+   * @param {String} params.id
+   * @returns {Promise}
+   */
+  update: function update(params) {
+    var _this$editLock;
+    if (!params.id) {
+      return _promise.default.reject(new Error('Missing breakout group id'));
+    }
+    var payload = _objectSpread({}, params);
+    var body = _objectSpread(_objectSpread({}, (_this$editLock = this.editLock) !== null && _this$editLock !== void 0 && _this$editLock.token ? {
+      editlock: {
+        token: this.editLock.token,
+        refresh: true
+      }
+    } : {}), {
+      groups: [payload]
+    });
+    return this.request({
+      method: _constants.HTTP_VERBS.PUT,
+      uri: this.url,
+      body: body
+    }).catch(function (error) {
+      return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#update'));
+    });
+  },
+  /**
+   * get existed breakout sessions
+   * @param {boolean} editlock -- lock operations of the breakout sessions
+   * @returns {Promise}
+   */
+  getBreakout: function getBreakout(editlock) {
+    var _this9 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var _breakout$body, _breakout$body2, _breakout$body2$editl;
+      var breakout;
+      return _regenerator.default.wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.next = 2;
+            return _this9.request({
+              method: _constants.HTTP_VERBS.GET,
+              uri: _this9.url + (editlock ? "?editlock=".concat(editlock) : '')
+            });
+          case 2:
+            breakout = _context4.sent;
+            if ((_breakout$body = breakout.body) !== null && _breakout$body !== void 0 && _breakout$body.groups) {
+              _this9.set('groups', breakout.body.groups);
+            }
+            if (editlock && (_breakout$body2 = breakout.body) !== null && _breakout$body2 !== void 0 && (_breakout$body2$editl = _breakout$body2.editlock) !== null && _breakout$body2$editl !== void 0 && _breakout$body2$editl.token) {
+              _this9.set('editLock', breakout.body.editlock);
+              _this9.keepEditLockAlive();
+            }
+            return _context4.abrupt("return", breakout);
+          case 6:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    }))();
+  },
+  /**
+   * enable and edit lock breakout
+   * @returns {void}
+   */
+  enableAndLockBreakout: function enableAndLockBreakout() {
+    var _this10 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      var info;
+      return _regenerator.default.wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            if (!_this10.enableBreakoutSession) {
+              _context5.next = 4;
+              break;
+            }
+            _this10.lockBreakout();
+            _context5.next = 8;
+            break;
+          case 4:
+            _context5.next = 6;
+            return _this10.enableBreakouts();
+          case 6:
+            info = _context5.sent;
+            if (info.body) {
+              _this10.lockBreakout();
+            }
+          case 8:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    }))();
+  },
+  /**
+   * send breakout edit lock
+   * @returns {void}
+   */
+  lockBreakout: function lockBreakout() {
+    var _this11 = this;
+    return (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
+      var _breakout$body3, breakout;
+      return _regenerator.default.wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            if (!(_this11.editLock && !!_this11.editLock.token)) {
+              _context6.next = 8;
+              break;
+            }
+            if (!(_this11.editLock.state === _constants.BREAKOUTS.EDIT_LOCK_STATUS.LOCKED)) {
+              _context6.next = 5;
+              break;
+            }
+            throw new Error('Breakout already locked');
+          case 5:
+            _this11.keepEditLockAlive();
+          case 6:
+            _context6.next = 12;
+            break;
+          case 8:
+            _context6.next = 10;
+            return _this11.getBreakout(true);
+          case 10:
+            breakout = _context6.sent;
+            if ((_breakout$body3 = breakout.body) !== null && _breakout$body3 !== void 0 && _breakout$body3.editlock) {
+              _this11.keepEditLockAlive();
+            }
+          case 12:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    }))();
+  },
+  /**
+   * keep edit lock alive
+   * @returns {void}
+   */
+  keepEditLockAlive: function keepEditLockAlive() {
+    var _this12 = 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 () {
+        _this12.request({
+          method: _constants.HTTP_VERBS.PUT,
+          uri: "".concat(_this12.url, "/editlock/").concat(_this12.editLock.token)
+        }).catch(function (error) {
+          _this12._clearEditLockInfo();
+          return _promise.default.reject((0, _utils.boServiceErrorHandler)(error, 'Breakouts#keepEditLockAlive'));
+        });
+      }, ttl / 2 * 1000);
+    }
+  },
+  /**
+   * unlock edit breakout
+   * @returns {void}
+   */
+  unLockEditBreakout: function unLockEditBreakout() {
+    var _this13 = 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 () {
+        _this13._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
+      };
+    });
+    return this.request({
+      method: _constants.HTTP_VERBS.PUT,
+      uri: this.url,
+      body: {
+        groups: [{
+          id: this.breakoutGroupId,
+          sessions: internalSessions
+        }]
+      }
+    });
+  },
+  /**
+   * The pre-assignments need to be queried when "hasBreakoutPreAssignments" is true
+   * @returns {void}
+   */
+  queryPreAssignments: function queryPreAssignments() {
+    var _this14 = this;
+    if (!this.shouldFetchPreassignments) {
+      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) {
+          _this14.set('groups', result.body.groups);
+        }
+      }).catch(function (error) {
+        _loggerProxy.default.logger.error('Meeting:breakouts#queryPreAssignments failed', error);
+      });
+      this.shouldFetchPreassignments = true;
+    }
+  },
+  /**
+   * 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
+    });
+  },
+  version: "3.0.0-beta.71"
+});
+var _default = Breakouts;
+exports.default = _default;
+//# sourceMappingURL=index.js.map