@webex/plugin-meetings 3.0.0-beta.31 → 3.0.0-beta.310

package/dist/webinar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Webinar","WebexPlugin","extend","namespace","MEETINGS","collections","webinar","WebinarCollection","props","locusUrl","webcastUrl","webinarAttendeesSearchingUrl","canManageWebcast","locusUrlUpdate","set","webcastUrlUpdate","webinarAttendeesSearchingUrlUpdate","updateCanManageWebcast"],"sources":["index.ts"],"sourcesContent":["/*!\n * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.\n */\nimport {WebexPlugin} from '@webex/webex-core';\nimport {MEETINGS} from '../constants';\n\nimport WebinarCollection from './collection';\n\n/**\n * @class Webinar\n */\nconst Webinar = WebexPlugin.extend({\n  namespace: MEETINGS,\n  collections: {\n    webinar: WebinarCollection,\n  },\n\n  props: {\n    locusUrl: 'string', // appears current webinar's locus url\n    webcastUrl: 'string', // current webinar's webcast url\n    webinarAttendeesSearchingUrl: 'string', // current webinarAttendeesSearching url\n    canManageWebcast: 'boolean', // appears the ability to manage webcast\n  },\n\n  /**\n   * Update the current locus url of the webinar\n   * @param {string} locusUrl // locus url\n   * @returns {void}\n   */\n  locusUrlUpdate(locusUrl) {\n    this.set('locusUrl', locusUrl);\n  },\n\n  /**\n   * Update the current webcast url of the meeting\n   * @param {string} webcastUrl // webcast url\n   * @returns {void}\n   */\n  webcastUrlUpdate(webcastUrl) {\n    this.set('webcastUrl', webcastUrl);\n  },\n\n  /**\n   * Update the current webinarAttendeesSearching url of the meeting\n   * @param {string} webinarAttendeesSearchingUrl // webinarAttendeesSearching url\n   * @returns {void}\n   */\n  webinarAttendeesSearchingUrlUpdate(webinarAttendeesSearchingUrl) {\n    this.set('webinarAttendeesSearchingUrl', webinarAttendeesSearchingUrl);\n  },\n\n  /**\n   * Update whether self has capability to manage start/stop webcast (only host can manage it)\n   * @param {boolean} canManageWebcast\n   * @returns {void}\n   */\n  updateCanManageWebcast(canManageWebcast) {\n    this.set('canManageWebcast', canManageWebcast);\n  },\n});\n\nexport default Webinar;\n"],"mappings":";;;;;;;;AAGA;AACA;AAEA;AANA;AACA;AACA;;AAMA;AACA;AACA;AACA,IAAMA,OAAO,GAAGC,sBAAW,CAACC,MAAM,CAAC;EACjCC,SAAS,EAAEC,mBAAQ;EACnBC,WAAW,EAAE;IACXC,OAAO,EAAEC;EACX,CAAC;EAEDC,KAAK,EAAE;IACLC,QAAQ,EAAE,QAAQ;IAAE;IACpBC,UAAU,EAAE,QAAQ;IAAE;IACtBC,4BAA4B,EAAE,QAAQ;IAAE;IACxCC,gBAAgB,EAAE,SAAS,CAAE;EAC/B,CAAC;EAED;AACF;AACA;AACA;AACA;EACEC,cAAc,0BAACJ,QAAQ,EAAE;IACvB,IAAI,CAACK,GAAG,CAAC,UAAU,EAAEL,QAAQ,CAAC;EAChC,CAAC;EAED;AACF;AACA;AACA;AACA;EACEM,gBAAgB,4BAACL,UAAU,EAAE;IAC3B,IAAI,CAACI,GAAG,CAAC,YAAY,EAAEJ,UAAU,CAAC;EACpC,CAAC;EAED;AACF;AACA;AACA;AACA;EACEM,kCAAkC,8CAACL,4BAA4B,EAAE;IAC/D,IAAI,CAACG,GAAG,CAAC,8BAA8B,EAAEH,4BAA4B,CAAC;EACxE,CAAC;EAED;AACF;AACA;AACA;AACA;EACEM,sBAAsB,kCAACL,gBAAgB,EAAE;IACvC,IAAI,CAACE,GAAG,CAAC,kBAAkB,EAAEF,gBAAgB,CAAC;EAChD,CAAC;EAAA;AACH,CAAC,CAAC;AAAC,eAEYZ,OAAO;AAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "3.0.0-beta.31",
+  "version": "3.0.0-beta.310",
   "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.31",
-    "@webex/test-helper-chai": "3.0.0-beta.31",
-    "@webex/test-helper-mocha": "3.0.0-beta.31",
-    "@webex/test-helper-mock-webex": "3.0.0-beta.31",
-    "@webex/test-helper-retry": "3.0.0-beta.31",
-    "@webex/test-helper-test-users": "3.0.0-beta.31",
+    "@webex/plugin-meetings": "3.0.0-beta.310",
+    "@webex/test-helper-chai": "3.0.0-beta.310",
+    "@webex/test-helper-mocha": "3.0.0-beta.310",
+    "@webex/test-helper-mock-webex": "3.0.0-beta.310",
+    "@webex/test-helper-retry": "3.0.0-beta.310",
+    "@webex/test-helper-test-users": "3.0.0-beta.310",
     "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.31",
-    "@webex/internal-media-core": "1.35.0",
-    "@webex/internal-plugin-conversation": "3.0.0-beta.31",
-    "@webex/internal-plugin-device": "3.0.0-beta.31",
-    "@webex/internal-plugin-llm": "3.0.0-beta.31",
-    "@webex/internal-plugin-mercury": "3.0.0-beta.31",
-    "@webex/internal-plugin-metrics": "3.0.0-beta.31",
-    "@webex/internal-plugin-support": "3.0.0-beta.31",
-    "@webex/internal-plugin-user": "3.0.0-beta.31",
-    "@webex/plugin-people": "3.0.0-beta.31",
-    "@webex/plugin-rooms": "3.0.0-beta.31",
-    "@webex/webex-core": "3.0.0-beta.31",
+    "@webex/common": "3.0.0-beta.310",
+    "@webex/internal-media-core": "2.2.1",
+    "@webex/internal-plugin-conversation": "3.0.0-beta.310",
+    "@webex/internal-plugin-device": "3.0.0-beta.310",
+    "@webex/internal-plugin-llm": "3.0.0-beta.310",
+    "@webex/internal-plugin-mercury": "3.0.0-beta.310",
+    "@webex/internal-plugin-metrics": "3.0.0-beta.310",
+    "@webex/internal-plugin-support": "3.0.0-beta.310",
+    "@webex/internal-plugin-user": "3.0.0-beta.310",
+    "@webex/media-helpers": "3.0.0-beta.310",
+    "@webex/plugin-people": "3.0.0-beta.310",
+    "@webex/plugin-rooms": "3.0.0-beta.310",
+    "@webex/webex-core": "3.0.0-beta.310",
     "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()