@webex/plugin-meetings 3.0.0-beta.41 → 3.0.0-beta.410

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)
@@ -128,12 +130,22 @@ breakouts.create(sessions)
 // Delete all breakout sessions
 breakouts.clearSessions()
 
-// Rename an existing breakout session
-breakout.rename(newSessionName)
+// 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)
 
+// 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)
+
+// 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 with necessary params
 breakouts.end(params)
 
@@ -143,6 +155,15 @@ 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);
   },
 

package/src/breakouts/events.ts

@@ -0,0 +1,56 @@
+// eslint-disable-next-line import/prefer-default-export
+import {ClientEvent} from '@webex/internal-plugin-metrics';
+
+const breakoutEvent: {
+  onBreakoutMoveRequest: (eventInfo: any, submitClientEvent: any) => void;
+  onBreakoutMoveResponse: (eventInfo: any, submitClientEvent: any) => void;
+  onBreakoutJoinResponse: (eventInfo: any, submitClientEvent: any) => void;
+  postMoveCallAnalyzer: (
+    event: ClientEvent['name'],
+    eventInfo: any,
+    submitClientEvent: any
+  ) => void;
+} = {
+  onBreakoutMoveRequest: (eventInfo, submitClientEvent) => {
+    breakoutEvent.postMoveCallAnalyzer(
+      'client.breakout-session.move.request',
+      eventInfo,
+      submitClientEvent
+    );
+  },
+  onBreakoutMoveResponse: (eventInfo, submitClientEvent) => {
+    breakoutEvent.postMoveCallAnalyzer(
+      'client.breakout-session.move.response',
+      eventInfo,
+      submitClientEvent
+    );
+  },
+  onBreakoutJoinResponse: (eventInfo, submitClientEvent) => {
+    breakoutEvent.postMoveCallAnalyzer(
+      'client.breakout-session.join.response',
+      eventInfo,
+      submitClientEvent
+    );
+  },
+  postMoveCallAnalyzer: (event: ClientEvent['name'], eventInfo: any, submitClientEvent) => {
+    if (!eventInfo?.breakoutMoveId || !eventInfo?.meeting) {
+      return;
+    }
+    if (!eventInfo.meeting.meetingInfo?.enableConvergedArchitecture) {
+      return;
+    }
+    submitClientEvent({
+      name: event,
+      payload: {
+        identifiers: {
+          breakoutMoveId: eventInfo.breakoutMoveId,
+          breakoutSessionId: eventInfo?.currentSession?.sessionId,
+          breakoutGroupId: eventInfo?.currentSession?.groupId,
+        },
+      },
+      options: {meetingId: eventInfo.meeting.id},
+    });
+  },
+};
+
+export default breakoutEvent;