@webex/plugin-meetings 3.0.0-beta.36 → 3.0.0-beta.360

package/src/interpretation/index.ts

@@ -0,0 +1,332 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+import {WebexPlugin} from '@webex/webex-core';
+import LoggerProxy from '../common/logs/logger-proxy';
+import {HTTP_VERBS, INTERPRETATION, MEETINGS} from '../constants';
+
+import SILanguageCollection from './collection';
+
+/**
+ * @class SimultaneousInterpretation
+ */
+const SimultaneousInterpretation = WebexPlugin.extend({
+  namespace: MEETINGS,
+  collections: {
+    siLanguages: SILanguageCollection,
+  },
+
+  props: {
+    locusUrl: 'string', // appears current meeting's locus url
+    approvalUrl: 'string', // appears current meeting's approval url for handoff between interpreters
+    originalLanguage: 'string', // appears current meeting's original language
+    sourceLanguage: 'string', // appears self interpreter's source language
+    targetLanguage: 'string', // appears self interpreter's target language
+    receiveLanguage: 'string', // appears self's receive language
+    order: 'number', // appears the order of self as interpreter
+    isActive: 'boolean', // appears self is interpreter and is active
+    selfParticipantId: 'string', // appears the self participant id
+    canManageInterpreters: 'boolean', // appears the ability to manage interpreters
+    supportLanguages: 'array', // appears the support languages
+    meetingSIEnabled: 'boolean', // appears the meeting support SI feature
+    hostSIEnabled: 'boolean', // appears the meeting host/interpreter feature of SI enabled
+    selfIsInterpreter: 'boolean', // current user is interpreter or not
+  },
+  derived: {
+    shouldQuerySupportLanguages: {
+      cache: false,
+      deps: ['canManageInterpreters', 'hostSIEnabled'],
+      /**
+       * Returns should query support languages or not
+       * @returns {boolean}
+       */
+      fn() {
+        return !!(this.canManageInterpreters && this.hostSIEnabled);
+      },
+    },
+  },
+  /**
+   * initialize for interpretation
+   * @returns {void}
+   */
+  initialize() {
+    this.listenTo(this, 'change:shouldQuerySupportLanguages', () => {
+      if (this.canManageInterpreters && !this.supportLanguages) {
+        this.querySupportLanguages();
+      }
+    });
+    this.listenToHandoffRequests();
+  },
+
+  /**
+   * Calls this to clean up listeners
+   * @returns {void}
+   */
+  cleanUp() {
+    this.stopListening();
+  },
+  /**
+   * Update the current locus url of the meeting
+   * @param {string} locusUrl // locus url
+   * @returns {void}
+   */
+  locusUrlUpdate(locusUrl) {
+    this.set('locusUrl', locusUrl);
+  },
+  /**
+   * Update the approval url for handoff
+   * @param {string} approvalUrl // approval url
+   * @returns {void}
+   */
+  approvalUrlUpdate(approvalUrl) {
+    this.set('approvalUrl', approvalUrl);
+  },
+  /**
+   * Update whether self has capability to manage interpreters (only host can manage it)
+   * @param {boolean} canManageInterpreters
+   * @returns {void}
+   */
+  updateCanManageInterpreters(canManageInterpreters) {
+    this.set('canManageInterpreters', canManageInterpreters);
+  },
+  /**
+   * Update whether the meeting's host si is enabled or not
+   * @param {boolean} hostSIEnabled
+   * @returns {void}
+   */
+  updateHostSIEnabled(hostSIEnabled) {
+    this.set('hostSIEnabled', hostSIEnabled);
+  },
+
+  /**
+   * Update whether the meeting support SI feature or not from meeting info
+   * @param {boolean} meetingSIEnabled
+   * @param {boolean} selfIsInterpreter
+   * @returns {void}
+   */
+  updateMeetingSIEnabled(meetingSIEnabled: boolean, selfIsInterpreter): void {
+    this.set('meetingSIEnabled', meetingSIEnabled);
+    this.set('selfIsInterpreter', selfIsInterpreter);
+  },
+
+  /**
+   * Update the interpretation languages channels which user can choose to subscribe
+   * @param {Object} interpretation
+   * @returns {void}
+   */
+  updateInterpretation(interpretation) {
+    this.siLanguages.set(interpretation?.siLanguages || []);
+  },
+  /**
+   * Update self's interpretation information (self is interpreter)
+   * @param {Object} interpretation
+   * @param {String} selfParticipantId
+   * @returns {void}
+   */
+  updateSelfInterpretation({interpretation, selfParticipantId}) {
+    const {originalLanguage, sourceLanguage, order, isActive, targetLanguage, receiveLanguage} =
+      interpretation || {};
+    this.set({originalLanguage, sourceLanguage, order, isActive, targetLanguage, receiveLanguage});
+    this.set('selfParticipantId', selfParticipantId);
+  },
+  /**
+   * query interpretation languages
+   * @returns {Promise}
+   */
+  querySupportLanguages() {
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: `${this.locusUrl}/languages/interpretation`,
+    })
+      .then((result) => {
+        this.set('supportLanguages', result.body?.siLanguages);
+        this.trigger(INTERPRETATION.EVENTS.SUPPORT_LANGUAGES_UPDATE);
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error('Meeting:interpretation#querySupportLanguages failed', error);
+        throw error;
+      });
+  },
+  /**
+   * get interpreters of the meeting
+   * @returns {Promise}
+   */
+  getInterpreters() {
+    return this.request({
+      method: HTTP_VERBS.GET,
+      uri: `${this.locusUrl}/interpretation/interpreters`,
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:interpretation#getInterpreters failed', error);
+      throw error;
+    });
+  },
+  /**
+   * update interpreters of the meeting
+   * @param {Array} interpreters
+   * @returns {Promise}
+   */
+  updateInterpreters(interpreters) {
+    return this.request({
+      method: HTTP_VERBS.PATCH,
+      uri: `${this.locusUrl}/controls`,
+      body: {
+        interpretation: {
+          interpreters,
+        },
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:interpretation#updateInterpreters failed', error);
+      throw error;
+    });
+  },
+  /**
+   * Change direction of interpretation for an interpreter participant
+   * @returns {Promise}
+   */
+  changeDirection() {
+    if (!this.sourceLanguage || !this.targetLanguage) {
+      return Promise.reject(new Error('Missing sourceLanguage or targetLanguage'));
+    }
+
+    if (!this.selfParticipantId) {
+      return Promise.reject(new Error('Missing self participant id'));
+    }
+
+    return this.request({
+      method: HTTP_VERBS.PATCH,
+      uri: `${this.locusUrl}/participant/${this.selfParticipantId}/controls`,
+      body: {
+        interpretation: {
+          sourceLanguage: this.targetLanguage,
+          targetLanguage: this.sourceLanguage,
+          isActive: this.isActive,
+          order: this.order,
+        },
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:interpretation#changeDirection failed', error);
+      throw error;
+    });
+  },
+  /**
+   * Sets up a listener for handoff requests from mercury
+   * @returns {void}
+   */
+  listenToHandoffRequests() {
+    this.listenTo(this.webex.internal.mercury, 'event:locus.approval_request', (event) => {
+      if (event?.data?.approval?.resourceType === INTERPRETATION.RESOURCE_TYPE) {
+        const {receivers, initiator, actionType, url} = event.data.approval;
+        const receiverId = receivers?.[0]?.participantId;
+        const isReceiver = !!receiverId && receiverId === this.selfParticipantId;
+        const senderId = initiator?.participantId;
+        const isSender = !!senderId && senderId === this.selfParticipantId;
+        if (!isReceiver && !isSender) {
+          return;
+        }
+        this.trigger(INTERPRETATION.EVENTS.HANDOFF_REQUESTS_ARRIVED, {
+          actionType,
+          isReceiver,
+          isSender,
+          senderId,
+          receiverId,
+          url,
+        });
+      }
+    });
+  },
+  /**
+   * handoff the active interpreter role to another interpreter in same group, only the interpreter is allowed to call this api
+   * @param {string} participantId the participant id you want to hand off
+   * @returns {Promise}
+   */
+  handoffInterpreter(participantId) {
+    if (!participantId) {
+      return Promise.reject(new Error('Missing target participant id'));
+    }
+    if (!this.approvalUrl) {
+      return Promise.reject(new Error('Missing approval url'));
+    }
+
+    return this.request({
+      method: HTTP_VERBS.POST,
+      uri: this.approvalUrl,
+      body: {
+        actionType: INTERPRETATION.ACTION_TYPE.OFFERED,
+        resourceType: INTERPRETATION.RESOURCE_TYPE,
+        receivers: [
+          {
+            participantId,
+          },
+        ],
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:interpretation#handoffInterpreter failed', error);
+      throw error;
+    });
+  },
+  /**
+   * the in-active interpreter request to hand off the active role to self
+   * @returns {Promise}
+   */
+  requestHandoff() {
+    if (!this.approvalUrl) {
+      return Promise.reject(new Error('Missing approval url'));
+    }
+
+    return this.request({
+      method: HTTP_VERBS.POST,
+      uri: this.approvalUrl,
+      body: {
+        actionType: INTERPRETATION.ACTION_TYPE.REQUESTED,
+        resourceType: INTERPRETATION.RESOURCE_TYPE,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:interpretation#requestHandoff failed', error);
+      throw error;
+    });
+  },
+  /**
+   * accept the request of handoff
+   * @param {String} url the url get from last approval event
+   * @returns {Promise}
+   */
+  acceptRequest(url) {
+    if (!url) {
+      return Promise.reject(new Error('Missing the url to accept'));
+    }
+
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: url,
+      body: {
+        actionType: INTERPRETATION.ACTION_TYPE.ACCEPTED,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:interpretation#acceptRequest failed', error);
+      throw error;
+    });
+  },
+  /**
+   * decline the request of handoff
+   * @param {String} url the url get from last approval event
+   * @returns {Promise}
+   */
+  declineRequest(url) {
+    if (!url) {
+      return Promise.reject(new Error('Missing the url to decline'));
+    }
+
+    return this.request({
+      method: HTTP_VERBS.PUT,
+      uri: url,
+      body: {
+        actionType: INTERPRETATION.ACTION_TYPE.DECLINED,
+      },
+    }).catch((error) => {
+      LoggerProxy.logger.error('Meeting:interpretation#declineRequest failed', error);
+      throw error;
+    });
+  },
+});
+
+export default SimultaneousInterpretation;

package/src/interpretation/siLanguage.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {WebexPlugin} from '@webex/webex-core';
+import {MEETINGS} from '../constants';
+
+const SILanguage = WebexPlugin.extend({
+  idAttribute: 'languageName',
+
+  namespace: MEETINGS,
+  props: {
+    languageCode: 'number',
+    languageName: 'string',
+  },
+});
+
+export default SILanguage;

package/src/locus-info/controlsUtils.ts

@@ -1,4 +1,5 @@
 import {isEqual} from 'lodash';
+import {BREAKOUTS} from '../constants';
 
 const ControlsUtils: any = {};
 
@@ -48,6 +49,41 @@ ControlsUtils.parse = (controls: any) => {
       : null;
   }
 
+  if (controls && controls.video) {
+    parsedControls.videoEnabled = controls.video.enabled;
+  }
+
+  if (controls?.muteOnEntry) {
+    parsedControls.muteOnEntry = {enabled: controls.muteOnEntry.enabled};
+  }
+
+  if (controls?.shareControl) {
+    parsedControls.shareControl = {control: controls.shareControl.control};
+  }
+
+  if (controls?.disallowUnmute) {
+    parsedControls.disallowUnmute = {enabled: controls.disallowUnmute.enabled};
+  }
+
+  if (controls?.reactions) {
+    parsedControls.reactions = {
+      enabled: controls.reactions.enabled,
+      showDisplayNameWithReactions: controls.reactions.showDisplayNameWithReactions,
+    };
+  }
+
+  if (controls?.viewTheParticipantList) {
+    parsedControls.viewTheParticipantList = {enabled: controls.viewTheParticipantList.enabled};
+  }
+
+  if (controls?.raiseHand) {
+    parsedControls.raiseHand = {enabled: controls.raiseHand.enabled};
+  }
+
+  if (controls?.video) {
+    parsedControls.video = {enabled: controls.video.enabled};
+  }
+
   return parsedControls;
 };
 
@@ -65,6 +101,26 @@ ControlsUtils.getControls = (oldControls: any, newControls: any) => {
     previous,
     current,
     updates: {
+      hasMuteOnEntryChanged: current?.muteOnEntry?.enabled !== previous?.muteOnEntry?.enabled,
+
+      hasShareControlChanged: current?.shareControl?.control !== previous?.shareControl?.control,
+
+      hasDisallowUnmuteChanged:
+        current?.disallowUnmute?.enabled !== previous?.disallowUnmute?.enabled,
+
+      hasReactionsChanged: current?.reactions?.enabled !== previous?.reactions?.enabled,
+
+      hasReactionDisplayNamesChanged:
+        current?.reactions?.showDisplayNameWithReactions !==
+        previous?.reactions?.showDisplayNameWithReactions,
+
+      hasViewTheParticipantListChanged:
+        current?.viewTheParticipantList?.enabled !== previous?.viewTheParticipantList?.enabled,
+
+      hasRaiseHandChanged: current?.raiseHand?.enabled !== previous?.raiseHand?.enabled,
+
+      hasVideoChanged: current?.video?.enabled !== previous?.video?.enabled,
+
       hasRecordingPausedChanged:
         current?.record &&
         !isEqual(previous?.record?.paused, current.record.paused) &&
@@ -94,6 +150,12 @@ ControlsUtils.getControls = (oldControls: any, newControls: any) => {
       ),
 
       hasBreakoutChanged: !isEqual(previous?.breakout, current?.breakout),
+
+      hasInterpretationChanged: !isEqual(previous?.interpretation, current?.interpretation),
+
+      hasVideoEnabledChanged:
+        newControls.video?.enabled !== undefined &&
+        !isEqual(previous?.videoEnabled, current?.videoEnabled),
     },
   };
 };
@@ -111,4 +173,50 @@ ControlsUtils.getId = (controls: any) => {
   return null;
 };
 
+/**
+ * check whether to replace the meeting's members or not.
+ * For case joined breakout session, need replace meeting's members
+ * @param {LocusControls} oldControls
+ * @param {LocusControls} controls
+ * @returns {Boolean}
+ */
+ControlsUtils.isNeedReplaceMembers = (oldControls: any, controls: any) => {
+  // no breakout case
+  if (!oldControls?.breakout || !controls?.breakout) {
+    return false;
+  }
+
+  return (
+    oldControls.breakout.groupId !== controls.breakout.groupId ||
+    oldControls.breakout.sessionId !== controls.breakout.sessionId
+  );
+};
+
+/**
+ * determine the switch status between breakout session and main session.
+ * @param {LocusControls} oldControls
+ * @param {LocusControls} controls
+ * @returns {Object}
+ */
+ControlsUtils.getSessionSwitchStatus = (oldControls: any, controls: any) => {
+  const status = {isReturnToMain: false, isJoinToBreakout: false};
+  // no breakout case
+  if (!oldControls?.breakout || !controls?.breakout) {
+    return status;
+  }
+
+  status.isReturnToMain =
+    oldControls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.BREAKOUT &&
+    controls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.MAIN;
+  status.isJoinToBreakout =
+    oldControls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.MAIN &&
+    controls.breakout.sessionType === BREAKOUTS.SESSION_TYPES.BREAKOUT;
+
+  return status;
+};
+
+ControlsUtils.isMainSessionDTO = (locus: any) => {
+  return locus?.controls?.breakout?.sessionType !== BREAKOUTS.SESSION_TYPES.BREAKOUT;
+};
+
 export default ControlsUtils;