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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "3.0.0-beta.29",
+  "version": "3.0.0-beta.290",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "contributors": [
@@ -32,31 +32,33 @@
     "build": "yarn run -T tsc --declaration true --declarationDir ./dist/types"
   },
   "devDependencies": {
-    "@webex/plugin-meetings": "3.0.0-beta.29",
-    "@webex/test-helper-chai": "3.0.0-beta.29",
-    "@webex/test-helper-mocha": "3.0.0-beta.29",
-    "@webex/test-helper-mock-webex": "3.0.0-beta.29",
-    "@webex/test-helper-retry": "3.0.0-beta.29",
-    "@webex/test-helper-test-users": "3.0.0-beta.29",
+    "@webex/plugin-meetings": "3.0.0-beta.290",
+    "@webex/test-helper-chai": "3.0.0-beta.290",
+    "@webex/test-helper-mocha": "3.0.0-beta.290",
+    "@webex/test-helper-mock-webex": "3.0.0-beta.290",
+    "@webex/test-helper-retry": "3.0.0-beta.290",
+    "@webex/test-helper-test-users": "3.0.0-beta.290",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "jsdom-global": "3.0.2",
     "sinon": "^9.2.4",
-    "typed-emitter": "^2.1.0"
+    "typed-emitter": "^2.1.0",
+    "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@webex/common": "3.0.0-beta.29",
-    "@webex/internal-media-core": "1.33.2",
-    "@webex/internal-plugin-conversation": "3.0.0-beta.29",
-    "@webex/internal-plugin-device": "3.0.0-beta.29",
-    "@webex/internal-plugin-llm": "3.0.0-beta.29",
-    "@webex/internal-plugin-mercury": "3.0.0-beta.29",
-    "@webex/internal-plugin-metrics": "3.0.0-beta.29",
-    "@webex/internal-plugin-support": "3.0.0-beta.29",
-    "@webex/internal-plugin-user": "3.0.0-beta.29",
-    "@webex/plugin-people": "3.0.0-beta.29",
-    "@webex/plugin-rooms": "3.0.0-beta.29",
-    "@webex/webex-core": "3.0.0-beta.29",
+    "@webex/common": "3.0.0-beta.290",
+    "@webex/internal-media-core": "2.1.0",
+    "@webex/internal-plugin-conversation": "3.0.0-beta.290",
+    "@webex/internal-plugin-device": "3.0.0-beta.290",
+    "@webex/internal-plugin-llm": "3.0.0-beta.290",
+    "@webex/internal-plugin-mercury": "3.0.0-beta.290",
+    "@webex/internal-plugin-metrics": "3.0.0-beta.290",
+    "@webex/internal-plugin-support": "3.0.0-beta.290",
+    "@webex/internal-plugin-user": "3.0.0-beta.290",
+    "@webex/media-helpers": "3.0.0-beta.290",
+    "@webex/plugin-people": "3.0.0-beta.290",
+    "@webex/plugin-rooms": "3.0.0-beta.290",
+    "@webex/webex-core": "3.0.0-beta.290",
     "ampersand-collection": "^2.0.2",
     "bowser": "^2.11.0",
     "btoa": "^1.2.1",
@@ -64,6 +66,7 @@
     "global": "^4.4.0",
     "ip-anonymize": "^0.1.0",
     "javascript-state-machine": "^3.1.0",
+    "jsonwebtoken": "^8.5.1",
     "lodash": "^4.17.21",
     "sdp-transform": "^2.12.0",
     "uuid": "^3.3.2",

package/src/annotation/annotation.types.ts

@@ -0,0 +1,50 @@
+import {ANNOTATION_POLICY} from './constants';
+
+/**
+ * Type for an StrokeData Object
+ */
+type StrokeData = {
+  deviceId: string;
+  toUserId: string;
+  requesterId: string;
+  content: string;
+  shareInstanceId: string;
+  encryptionKeyUrl: string;
+  version: string;
+};
+
+type RequestData = {
+  toUserId: string;
+  toDeviceUrl: string;
+  shareInstanceId: string;
+};
+
+type CommandRequestBody = {
+  actionType: string;
+  resourceType: string;
+  shareInstanceId: string;
+  receivers?: any[];
+};
+/**
+ * Type for an annotation Object include annotation version and privilege
+ */
+type AnnotationInfo = {
+  version: string;
+  policy: ANNOTATION_POLICY;
+};
+
+interface IAnnotationChannel {
+  // === below is for presenter
+  acceptRequest: (approval) => undefined | Promise<void>;
+  declineRequest: (approval) => undefined | Promise<void>;
+  closeAnnotation: (requestData: RequestData) => undefined | Promise<void>;
+  // === below is for attendee
+  approveAnnotation: (requestData: RequestData) => undefined | Promise<void>;
+  cancelApproveAnnotation: (requestData: RequestData, approval) => undefined | Promise<void>;
+  sendStrokeData: (strokeData: StrokeData) => void;
+  // =====
+  approvalUrlUpdate: (approvalUrl: string) => void;
+  locusUrlUpdate: (locusUrl: string) => void;
+}
+
+export type {StrokeData, RequestData, CommandRequestBody, IAnnotationChannel, AnnotationInfo};

package/src/annotation/constants.ts

@@ -0,0 +1,36 @@
+export const EVENT_TRIGGERS = {
+  ANNOTATION_STROKE_DATA: 'annotation:strokeData',
+  ANNOTATION_COMMAND: 'annotation:command',
+};
+export const ANNOTATION_RESOURCE_TYPE = 'AnnotationOnShare';
+export const ANNOTATION_RELAY_TYPES = {
+  ANNOTATION_CLIENT: 'annotation.client',
+};
+
+export const ANNOTATION_STATUS = {
+  NO_ANNOTATION: 'NO_ANNOTATION',
+  RUNNING_ANNOTATION: 'RUNNING_ANNOTATION',
+};
+
+export enum ANNOTATION_POLICY {
+  ANYONE_CAN_ANNOTATE = 'AnyoneCanAnnotate',
+  APPROVAL = 'Approval',
+  ANNOTATION_NOT_ALLOWED = 'AnnotationNotAllowed',
+}
+
+export const ANNOTATION_REQUEST_TYPE = {
+  ANNOTATION_MESSAGE: 'annotation_message',
+};
+
+export const enum ANNOTATION_ACTION_TYPE {
+  REQUESTED = 'REQUESTED',
+  ACCEPTED = 'ACCEPTED',
+  DECLINED = 'DECLINED',
+  OFFERED = 'OFFERED',
+  CANCELED = 'CANCELED',
+  EXPIRED = 'EXPIRED',
+  REVOKED = 'REVOKED',
+  CLOSED = 'CLOSED',
+}
+
+export const ANNOTATION = 'annotation';

package/src/annotation/index.ts

@@ -0,0 +1,328 @@
+import uuid from 'uuid';
+// eslint-disable-next-line import/no-extraneous-dependencies
+import {WebexPlugin, config} from '@webex/webex-core';
+import TriggerProxy from '../common/events/trigger-proxy';
+
+import {
+  EVENT_TRIGGERS,
+  ANNOTATION_RELAY_TYPES,
+  ANNOTATION,
+  ANNOTATION_REQUEST_TYPE,
+  ANNOTATION_ACTION_TYPE,
+  ANNOTATION_RESOURCE_TYPE,
+} from './constants';
+
+import {StrokeData, RequestData, IAnnotationChannel, CommandRequestBody} from './annotation.types';
+import {HTTP_VERBS} from '../constants';
+
+/**
+ * @description Annotation to handle LLM and Mercury message and locus API
+ * @class
+ */
+class AnnotationChannel extends WebexPlugin implements IAnnotationChannel {
+  namespace = ANNOTATION;
+
+  private seqNum: number;
+
+  hasSubscribedToEvents: boolean;
+
+  approvalUrl: string;
+  locusUrl: string;
+  deviceUrl: string;
+
+  /**
+   * Initializes annotation module
+   */
+  constructor(...args) {
+    super(...args);
+    this.seqNum = 1;
+  }
+
+  /**
+   * Process Stroke Data
+   * @param {object}  data
+   * @returns {void}
+   */
+  private processStrokeMessage(data) {
+    const {request} = data;
+    this.decryptContent(request.value.encryptionKeyUrl, request.value.content).then(
+      (decryptedContent) => {
+        request.value.content = decryptedContent;
+        TriggerProxy.trigger(
+          this,
+          {
+            file: 'annotation',
+            function: 'processStrokeMessage',
+          },
+          EVENT_TRIGGERS.ANNOTATION_STROKE_DATA,
+          {
+            payload: data,
+          }
+        );
+      }
+    );
+  }
+
+  /** bind all events from mercury
+   * @param {Object} e
+   * @returns {undefined}
+   */
+  private eventCommandProcessor(e) {
+    if (
+      e?.data?.eventType === 'locus.approval_request' &&
+      e?.data?.approval?.resourceType === ANNOTATION_RESOURCE_TYPE &&
+      e?.data?.approval?.actionType
+    ) {
+      TriggerProxy.trigger(
+        this,
+        {
+          file: 'annotation',
+          function: 'approval_request',
+        },
+        EVENT_TRIGGERS.ANNOTATION_COMMAND,
+        {
+          type: e.data.approval.actionType,
+          payload: e.data.approval,
+        }
+      );
+    }
+  }
+
+  /** bind all events from llm
+   * @param {Object} e
+   * @returns {undefined}
+   */
+  private eventDataProcessor(e) {
+    switch (e?.data?.relayType) {
+      case ANNOTATION_RELAY_TYPES.ANNOTATION_CLIENT:
+        this.processStrokeMessage(e.data);
+        break;
+      default:
+        break;
+    }
+  }
+
+  /**
+   * Listen to websocket messages
+   * @returns {undefined}
+   */
+  private listenToEvents() {
+    if (!this.hasSubscribedToEvents) {
+      // @ts-ignore
+      this.webex.internal.mercury.on(
+        'event:locus.approval_request',
+        this.eventCommandProcessor,
+        this
+      );
+      // @ts-ignore
+      this.webex.internal.llm.on('event:relay.event', this.eventDataProcessor, this);
+      this.hasSubscribedToEvents = true;
+    }
+  }
+
+  /**
+   * set locusUrl
+   * @param {string} locusUrl
+   * @returns {void}
+   */
+  public locusUrlUpdate(locusUrl: string) {
+    this.locusUrl = locusUrl;
+    this.listenToEvents();
+  }
+
+  /**
+   * set approved url
+   * @param {string} approvalUrl
+   * @returns {void}
+   */
+  public approvalUrlUpdate(approvalUrl: string) {
+    this.approvalUrl = approvalUrl;
+  }
+
+  /**
+   * accept request
+   * @param {object} approval
+   * @returns {Promise}
+   */
+  public acceptRequest(approval) {
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      url: approval.url,
+      body: {
+        resourceType: ANNOTATION_RESOURCE_TYPE,
+        actionType: ANNOTATION_ACTION_TYPE.ACCEPTED,
+      },
+    });
+  }
+
+  /**
+   * presenter declined request annotation
+   * @param {approval} approval
+   * @returns {Promise}
+   */
+  public declineRequest(approval) {
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      url: approval.url,
+      body: {
+        resourceType: ANNOTATION_RESOURCE_TYPE,
+        actionType: ANNOTATION_ACTION_TYPE.DECLINED,
+      },
+    });
+  }
+
+  /**
+   * request approved annotation
+   * @param {RequestData} requestData
+   * @returns {Promise}
+   */
+  public approveAnnotation(requestData: RequestData) {
+    return this.sendAnnotationAction(ANNOTATION_ACTION_TYPE.REQUESTED, requestData);
+  }
+
+  /**
+   * cancel approved annotation
+   * @param {object} requestData
+   * @param {object} approval
+   * @returns {Promise}
+   */
+  public cancelApproveAnnotation(requestData: RequestData, approval) {
+    const body: CommandRequestBody = {
+      actionType: ANNOTATION_ACTION_TYPE.CANCELED,
+      resourceType: 'AnnotationOnShare',
+      shareInstanceId: requestData.shareInstanceId,
+    };
+
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      url: `${approval.url}`,
+      body,
+    });
+  }
+
+  /**
+   * close annotation
+   * @param {object} requestData
+   * @returns {Promise}
+   */
+  public closeAnnotation(requestData: RequestData) {
+    return this.sendAnnotationAction(ANNOTATION_ACTION_TYPE.CLOSED, requestData);
+  }
+
+  /**
+   * send annotation command
+   * @param {ANNOTATION_ACTION_TYPE} actionType
+   * @param {RequestData} requestData
+   * @returns {Promise}
+   */
+  private sendAnnotationAction = async (
+    actionType: ANNOTATION_ACTION_TYPE,
+    requestData: RequestData
+  ): Promise<void> => {
+    const body: CommandRequestBody = {
+      actionType,
+      resourceType: 'AnnotationOnShare',
+      shareInstanceId: requestData.shareInstanceId,
+    };
+    if (requestData?.toUserId) {
+      body.receivers = [{participantId: requestData.toUserId, deviceUrl: requestData.toDeviceUrl}];
+    }
+
+    // @ts-ignore
+    return this.request({
+      method: HTTP_VERBS.POST,
+      url: `${this.approvalUrl}`,
+      body,
+    });
+  };
+
+  /**
+   * decrypt data
+   * @param {string} encryptionKeyUrl
+   * @param {string} content encrypted content
+   * @returns {string} decrypted content
+   */
+  private decryptContent = (encryptionKeyUrl: string, content: string): Promise<any> => {
+    // @ts-ignore
+    return this.webex.internal.encryption.decryptText(encryptionKeyUrl, content).then((res) => {
+      return res;
+    });
+  };
+
+  /**
+   * encrypt data
+   * @param {string} encryptionKeyUrl
+   * @param {string} content original content
+   * @returns {string} encrypted content
+   */
+  private encryptContent = (encryptionKeyUrl: string, content: string): Promise<any> => {
+    // @ts-ignore
+    return this.webex.internal.encryption.encryptText(encryptionKeyUrl, content).then((res) => {
+      return res;
+    });
+  };
+
+  /**
+   * Sends stroke data to presenter
+   * @param {StrokeData} strokeData
+   * @returns {void}
+   */
+  public sendStrokeData = (strokeData: StrokeData): void => {
+    // @ts-ignore
+    if (!this.webex.internal.llm.isConnected()) return;
+    this.encryptContent(strokeData.encryptionKeyUrl, strokeData.content).then(
+      (encryptedContent) => {
+        this.publishEncrypted(encryptedContent, strokeData);
+      }
+    );
+  };
+
+  /**
+   * private encrypted the strokes data
+   * @param {string} encryptedContent
+   * @param {StrokeData} strokeData
+   * @returns {void}
+   */
+  private publishEncrypted(encryptedContent: string, strokeData: StrokeData) {
+    const data = {
+      id: `${this.seqNum}`,
+      type: 'publishRequest',
+      recipients: {
+        // @ts-ignore
+        route: this.webex.internal.llm.getBinding(),
+      },
+      headers: {
+        to: strokeData.toUserId,
+      },
+      data: {
+        eventType: 'relay.event',
+        relayType: ANNOTATION_RELAY_TYPES.ANNOTATION_CLIENT,
+        request: {
+          value: {
+            type: ANNOTATION_REQUEST_TYPE.ANNOTATION_MESSAGE,
+            content: encryptedContent,
+            deviceId: strokeData.deviceId,
+            seq: this.seqNum,
+            requesterId: strokeData.requesterId,
+            version: strokeData.version,
+            shareInstanceId: strokeData.shareInstanceId,
+            encryptionKeyUrl: strokeData.encryptionKeyUrl,
+          },
+        },
+      },
+      trackingId: `${config.trackingIdPrefix}_${uuid.v4().toString()}`,
+      timestamp: new Date().getTime(),
+      sequenceNumber: this.seqNum,
+      filterMessage: false,
+    };
+
+    // @ts-ignore
+    this.webex.internal.llm.socket.send(data);
+    this.seqNum += 1;
+  }
+}
+
+export default AnnotationChannel;

package/src/breakouts/README.md

@@ -41,6 +41,12 @@ The following are methods available to attendees of a meeting:
 ```javascript
 // Join a breakout
 // This can be used when the participant is in the main session or in a different breakout session
+// when call join function, should send message to metrics
+/* Breakout Sessions created during meetings allow participants to move into smaller breakout sessions and then 
+   return to the main meeting at a later time. These moves can be initiated by the user or by the meeting 
+   host/co-host.  The goal of this metric is to track these moves in production by instrumenting them for 
+   analysis from the end user's experience perspective.
+*/
 breakout.join();
 
 // Leave a breakout
@@ -107,10 +113,6 @@ note: None of these are currently implemented
 // Move a participant to breakout
 breakout.move(participant)
 
-// Assign a particpant to a breakout
-// Not sure whether there is any difference from move
-breakout.assign(participant)
-
 // Remove someone from a breakout session
 // This returns them to the main session
 breakout.remove(participant)
@@ -119,21 +121,49 @@ breakout.remove(participant)
 // This can only be done when breakouts are inactive
 breakout.delete()
 
-// Create a breakout session
-breakouts.create(sessionName)
+/*
+Create breakout sessions, Type is array
+Format: [{'name':'session1', "anyoneCanJoin" : true}]
+*/
+breakouts.create(sessions)
+
+// Delete all breakout sessions
+breakouts.clearSessions()
+
+// update breakout session with params
+// if unlockEdit is true, will release lock editing after update finish
+breakout.update(params, unlockEdit)
+
+// Start breakout sessions with necessary params
+breakouts.start(params)
 
-// Rename an existing breakout session
-breakout.rename(newSessionName)
+// Assign a particpant/participants to breakouts/a breakout
+// sessions should be like: [{id:'xx',memberIds:['111'],emails:['111@ss.com',anyone: true]},...]
+breakouts.assign(sessions)
 
-// Start breakout sessions
-breakouts.start()
+// Dynammic assign a particpant/participants to breakouts/main (not used by now)
+// Admit lobby waiting participants to a breakout directly
+// sessions should be like: [{id:'xx',participants:['111'],targetState:'JOINED'},...]
+breakouts.dynamicAssign(sessions)
 
-// End breakout sessions
-breakouts.end()
+// End breakout sessions with necessary params
+breakouts.end(params)
+
+// get breakout sessions with/without param editlock
+breakouts.getBreakout(editlock?)
 
 // Enable breakout sessions
 breakouts.enable()
 
+// Enable and lock breakout 
+breakouts.enableAndLockBreakout()
+
+// Lock breakout
+breakouts.lockBreakout()
+
+// Unlock breakout
+breakouts.unLockEditBreakout()
+
 // Disable breakout sessions
 breakouts.disable()
 

package/src/breakouts/breakout.ts

@@ -4,11 +4,11 @@
 
 import {WebexPlugin} from '@webex/webex-core';
 
-import {HTTP_VERBS, MEETINGS} from '../constants';
-import LocusInfo from '../locus-info';
+import uuid from 'uuid';
+import {_ID_, HTTP_VERBS, MEETINGS} from '../constants';
 import Members from '../members';
 import BreakoutRequest from './request';
-
+import breakoutEvent from './events';
 /**
  * @class
  */
@@ -30,10 +30,12 @@ const Breakout = WebexPlugin.extend({
     sessionType: 'string',
     groupId: 'string',
     url: 'string', // where to send requests to
+    requestedLastModifiedTime: 'string',
   },
 
   derived: {
     isMain: {
+      cache: false, // fix issue: sometimes the derived will not change even if the deps changed
       deps: ['sessionType'],
       /**
        * If the breakout has no name, assume it is the main session
@@ -44,26 +46,47 @@ const Breakout = WebexPlugin.extend({
       },
     },
   },
-
+  /**
+   * initializer for the Breakout class
+   * @returns {void}
+   */
   initialize() {
-    this.members = new Members({}, {parent: this.webex});
     // @ts-ignore
     this.breakoutRequest = new BreakoutRequest({webex: this.webex});
+    this.breakoutRosterLocus = null;
   },
 
   /**
    * Joins the breakout session
    * @returns {Promise}
    */
-  join() {
-    return this.request({
+  async join() {
+    const breakoutMoveId = uuid.v4();
+    const deviceUrl = this.webex.internal.device.url;
+    const {meetingId} = this.collection.parent;
+    const meeting = this.webex.meetings.getMeetingByType(_ID_, meetingId);
+    breakoutEvent.onBreakoutMoveRequest(
+      {currentSession: this, meeting, breakoutMoveId},
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent.bind(this.webex.internal.newMetrics)
+    );
+    const result = await this.request({
       method: HTTP_VERBS.POST,
       uri: `${this.url}/move`,
       body: {
+        breakoutMoveId,
+        deviceUrl,
         groupId: this.groupId,
         sessionId: this.sessionId,
       },
     });
+    breakoutEvent.onBreakoutMoveResponse(
+      {currentSession: this, meeting, breakoutMoveId},
+      // @ts-ignore
+      this.webex.internal.newMetrics.submitClientEvent.bind(this.webex.internal.newMetrics)
+    );
+
+    return result;
   },
 
   /**
@@ -101,12 +124,47 @@ const Breakout = WebexPlugin.extend({
   },
 
   /**
-   * Parses the participants from the locus object
-   * @param locus Locus object
+   * inits the members object
    * @returns {void}
    */
+  initMembers() {
+    const {meetingId} = this.collection.parent;
+    const meeting = this.webex.meetings.getMeetingByType(_ID_, meetingId);
+    this.members = new Members(
+      {
+        meeting,
+      },
+      {parent: this.webex}
+    );
+  },
 
+  /**
+   * check sequence and determine whether to update the new roster or not
+   * @param {Object} locus Locus object
+   * @returns {Boolean}
+   */
+  isNeedHandleRoster(locus: any) {
+    if (!this.breakoutRosterLocus?.sequence?.entries?.length || !locus?.sequence?.entries?.length) {
+      return true;
+    }
+    const prevSequence = this.breakoutRosterLocus.sequence.entries[0];
+    const currentSequence = locus.sequence.entries[0];
+
+    return currentSequence > prevSequence;
+  },
+  /**
+   * Parses the participants from the locus object
+   * @param {Object} locus Locus object
+   * @returns {void}
+   */
   parseRoster(locus) {
+    if (!this.members) {
+      this.initMembers();
+    }
+    if (!this.isNeedHandleRoster(locus)) {
+      return;
+    }
+    this.breakoutRosterLocus = locus;
     this.members.locusParticipantsUpdate(locus);
   },