@webex/plugin-meetings 3.0.0-beta.50 → 3.0.0-beta.52

package/src/breakouts/index.ts

@@ -34,9 +34,11 @@ const Breakouts = WebexPlugin.extend({
     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 resouce url
+    breakoutServiceUrl: 'string', // the current breakout resource url
     mainLocusUrl: 'string', // the locus url of the main session
     groups: 'array', // appears when create breakouts
+    editLock: 'object', // appears when getBreakout info editlock = true
+    intervalID: 'number',
   },
 
   children: {
@@ -115,7 +117,7 @@ const Breakouts = WebexPlugin.extend({
   },
 
   /**
-   * Update the current breakout resouce url
+   * Update the current breakout resource url
    * @param {string} breakoutServiceUrl
    * @returns {void}
    */
@@ -336,7 +338,7 @@ const Breakouts = WebexPlugin.extend({
   },
 
   /**
-   * Make the meeting enbale or disable breakout session
+   * Make the meeting enable or disable breakout session
    * @param {boolean} enable
    * @returns {Promise}
    */
@@ -376,17 +378,30 @@ const Breakouts = WebexPlugin.extend({
    */
   async create(sessions) {
     // @ts-ignore
+    const bodyInfo =
+      this.editLock && !!this.editLock.token
+        ? {
+            groups: [
+              {
+                sessions,
+              },
+            ],
+            editlock: {
+              token: this.editLock.token,
+            },
+          }
+        : {
+            groups: [
+              {
+                sessions,
+              },
+            ],
+          };
     const breakInfo = await this.webex
       .request({
         method: HTTP_VERBS.PUT,
         uri: this.url,
-        body: {
-          groups: [
-            {
-              sessions,
-            },
-          ],
-        },
+        body: bodyInfo,
       })
       .catch((error) => {
         return Promise.reject(
@@ -398,6 +413,9 @@ const Breakouts = WebexPlugin.extend({
       this.set('groups', breakInfo.body.groups);
     }
 
+    // clear edit lock info after save breakout session info
+    this._clearEditLockInfo();
+
     return Promise.resolve(breakInfo);
   },
 
@@ -407,17 +425,30 @@ const Breakouts = WebexPlugin.extend({
    */
   async clearSessions() {
     // @ts-ignore
+    const bodyInfo =
+      this.editLock && !!this.editLock.token
+        ? {
+            groups: [
+              {
+                action: BREAKOUTS.ACTION.DELETE,
+              },
+            ],
+            editlock: {
+              token: this.editLock.token,
+            },
+          }
+        : {
+            groups: [
+              {
+                action: BREAKOUTS.ACTION.DELETE,
+              },
+            ],
+          };
     const breakInfo = await this.webex
       .request({
         method: HTTP_VERBS.PUT,
         uri: this.url,
-        body: {
-          groups: [
-            {
-              action: BREAKOUTS.ACTION.DELETE,
-            },
-          ],
-        },
+        body: bodyInfo,
       })
       .catch((error) => {
         return Promise.reject(
@@ -503,9 +534,125 @@ const Breakouts = WebexPlugin.extend({
     if (breakout.body?.groups) {
       this.set('groups', breakout.body.groups);
     }
+    if (breakout.body?.editlock && editlock) {
+      this.set('editLock', breakout.body.editlock);
+    }
 
     return breakout;
   },
+
+  /**
+   * enable and edit lock breakout
+   * @returns {void}
+   */
+  async enableAndLockBreakout() {
+    if (this.enableBreakoutSession) {
+      this.lockBreakout();
+    } else {
+      const info = await this.enableBreakouts();
+
+      if (info.body) {
+        this.lockBreakout();
+      }
+    }
+  },
+
+  /**
+   * send breakout edit lock
+   * @returns {void}
+   */
+  async lockBreakout() {
+    if (this.editLock && !!this.editLock.token) {
+      if (this.editLock.state === BREAKOUTS.EDIT_LOCK_STATUS.LOCKED) {
+        throw new Error('Breakout already locked');
+      } else {
+        this.keepEditLockAlive();
+      }
+    } else {
+      const breakout = await this.getBreakout(true);
+      if (breakout.body?.editlock) {
+        this.keepEditLockAlive();
+      }
+    }
+  },
+
+  /**
+   * keep edit lock alive
+   * @returns {void}
+   */
+  keepEditLockAlive() {
+    if (this.editLock && !!this.editLock.token) {
+      const ttl = this.editLock.ttl < 30 ? BREAKOUTS.DEFAULT_TTL : this.editLock.ttl;
+
+      this.intervalID = window.setInterval(() => {
+        this.request({
+          method: HTTP_VERBS.PUT,
+          uri: `${this.url}/editlock/${this.editLock.token}`,
+        }).catch((error) => {
+          this._clearEditLockInfo();
+
+          return Promise.reject(boServiceErrorHandler(error, 'Breakouts#keepEditLockAlive'));
+        });
+      }, (ttl / 2) * 1000);
+    }
+  },
+
+  /**
+   * unlock edit breakout
+   * @returns {void}
+   */
+  unLockEditBreakout() {
+    this.request({
+      method: HTTP_VERBS.DELETE,
+      uri: `${this.url}/editlock/${this.editLock.token}`,
+    })
+      .then(() => {
+        this._clearEditLockInfo();
+      })
+      .catch((error) => {
+        return Promise.reject(boServiceErrorHandler(error, 'Breakouts#unLockEditBreakout'));
+      });
+  },
+
+  /**
+   * clear interval and edit lock info
+   * @private
+   * @returns {void}
+   */
+  _clearEditLockInfo() {
+    if (this.intervalID) {
+      clearInterval(this.intervalID);
+    }
+    this.set('editLock', {});
+  },
+
+  /**
+   * assign participants to breakout session
+   * @param {Array} sessions
+   * @returns {void}
+   */
+  assign(sessions: any[]) {
+    const internalSessions = sessions.map((item) => {
+      return {
+        id: item.id,
+        assigned: item.memberIds,
+        assignedEmails: item.emails,
+      };
+    });
+
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: this.url,
+      body: {
+        groups: [
+          {
+            id: this.breakoutGroupId,
+            sessions: internalSessions,
+          },
+        ],
+      },
+    });
+  },
 });
 
 export default Breakouts;

package/src/breakouts/utils.ts

@@ -26,13 +26,13 @@ export const getBroadcastRoles = (options): string[] => {
  */
 export const boServiceErrorHandler = (error: any, message: string): any => {
   const errorCode = error?.body?.errorCode;
-  const {EDIT_LOCK_TOKEN_MISMATCH} = BREAKOUTS.ERROR_CODE;
+  const {EDIT_LOCK_TOKEN_MISMATCH, EDIT_NOT_AUTHORIZED} = BREAKOUTS.ERROR_CODE;
+  LoggerProxy.logger.info(message);
   switch (errorCode) {
     case EDIT_LOCK_TOKEN_MISMATCH:
-      LoggerProxy.logger.info(message);
-
       return new BreakoutEditLockedError('Edit lock token mismatch', error);
-
+    case EDIT_NOT_AUTHORIZED:
+      return new BreakoutEditLockedError('Not authorized to interact with edit lock', error);
     default:
       return error;
   }

package/src/constants.ts

@@ -480,6 +480,7 @@ export const HTTP_VERBS = {
   POST: 'POST',
   GET: 'GET',
   PATCH: 'PATCH',
+  DELETE: 'DELETE',
 };
 
 // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/iceGatheringState
@@ -556,8 +557,15 @@ export const BREAKOUTS = {
   },
   ERROR_CODE: {
     EDIT_LOCK_TOKEN_MISMATCH: 201409024,
+    EDIT_NOT_AUTHORIZED: 201403007,
   },
   DEFAULT_DURATION: 60000,
+  EDIT_LOCK_STATUS: {
+    LOCKED: 'LOCKED',
+    NOT_LOCKED: 'NOT_LOCKED',
+    UNKNOWN: 'UNKNOWN',
+  },
+  DEFAULT_TTL: 30,
 };
 
 export const LOCUSINFO = {

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

@@ -3,12 +3,10 @@ import Breakout from '@webex/plugin-meetings/src/breakouts/breakout';
 import Breakouts from '@webex/plugin-meetings/src/breakouts';
 import Members from '@webex/plugin-meetings/src/members';
 import MockWebex from '@webex/test-helper-mock-webex';
-import sinon from "sinon";
-
+import sinon from 'sinon';
 
 describe('plugin-meetings', () => {
   describe('breakout', () => {
-
     let webex;
     let breakout;
     let breakouts;
@@ -29,34 +27,33 @@ describe('plugin-meetings', () => {
     describe('initialize', () => {
       it('creates the object correctly', () => {
         assert.instanceOf(breakout.members, Members);
-      })
+      });
     });
 
     describe('#join', () => {
       it('makes the request as expected', async () => {
-        const result = await breakout.join()
+        const result = await breakout.join();
 
         assert.calledOnceWithExactly(webex.request, {
           method: 'POST',
           uri: 'url/move',
           body: {
             groupId: 'groupId',
-            sessionId: 'sessionId'
-          }
+            sessionId: 'sessionId',
+          },
         });
 
-        assert.equal(result, 'REQUEST_RETURN_VALUE')
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
       });
     });
 
     describe('#leave', () => {
       it('throws error if in main sesson', async () => {
-
         breakout.set('sessionType', 'MAIN');
 
         const fn = () => {
           breakout.leave();
-        }
+        };
 
         expect(fn).to.throw(/Cannot leave the main session/);
       });
@@ -64,14 +61,14 @@ describe('plugin-meetings', () => {
       it('throws error if there is no main session', async () => {
         const fn = () => {
           breakout.leave();
-        }
+        };
 
         expect(fn).to.throw(/Cannot leave, no main session found/);
       });
 
       it('joins the main session if in a breakout', async () => {
         breakout.parent.breakouts.add({
-          sessionType: 'MAIN'
+          sessionType: 'MAIN',
         });
 
         const mainSession = breakouts.breakouts.models[0];
@@ -82,58 +79,60 @@ describe('plugin-meetings', () => {
 
         assert.calledOnceWithExactly(mainSession.join);
         assert.equal(result, 'JOIN_RETURN_VALUE');
-      })
+      });
     });
 
     describe('#askForHelp', () => {
       it('makes the request as expected', async () => {
-        const result = await breakout.askForHelp()
+        const result = await breakout.askForHelp();
 
         assert.calledOnceWithExactly(webex.request, {
           method: 'POST',
           uri: 'url/help',
           body: {
             groupId: 'groupId',
-            sessionId: 'sessionId'
-          }
+            sessionId: 'sessionId',
+          },
         });
 
-        assert.equal(result, 'REQUEST_RETURN_VALUE')
+        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')
+        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'
+          sessionId: 'sessionId',
         });
 
-        assert.equal(result, 'REQUEST_RETURN_VALUE')
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
 
-        result = await breakout.broadcast('hello', {presenters: true, cohosts: true})
+        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'
+          sessionId: 'sessionId',
         });
 
-        assert.equal(result, 'REQUEST_RETURN_VALUE')
+        assert.equal(result, 'REQUEST_RETURN_VALUE');
       });
     });
 
     describe('#parseRoster', () => {
       it('calls locusParticipantsUpdate', () => {
         breakout.members = {
-          locusParticipantsUpdate: sinon.stub()
+          locusParticipantsUpdate: sinon.stub(),
         };
 
         const locusData = {some: 'data'};
@@ -141,7 +140,7 @@ describe('plugin-meetings', () => {
 
         assert.calledOnceWithExactly(breakout.members.locusParticipantsUpdate, locusData);
         assert.equal(result, undefined);
-      })
-    })
+      });
+    });
   });
 });