@webex/plugin-meetings 3.0.0-beta.17 → 3.0.0-beta.170

package/src/interpretation/collection.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import AmpCollection from 'ampersand-collection';
+
+import {MEETINGS} from '../constants';
+
+import SILanguage from './siLanguage';
+
+const SILanguageCollection = AmpCollection.extend({
+  model: SILanguage,
+
+  namespace: MEETINGS,
+
+  mainIndex: 'languageName',
+});
+
+export default SILanguageCollection;

package/src/interpretation/index.ts

@@ -0,0 +1,182 @@
+/*!
+ * 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
+    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
+    siEnabled: 'boolean', // appears the meeting enabled SI
+  },
+  derived: {
+    shouldQuerySupportLanguages: {
+      cache: false,
+      deps: ['canManageInterpreters', 'siEnabled'],
+      /**
+       * Returns should query support languages or not
+       * @returns {boolean}
+       */
+      fn() {
+        return !!(this.canManageInterpreters && this.siEnabled);
+      },
+    },
+  },
+  /**
+   * initialize for interpretation
+   * @returns {void}
+   */
+  initialize() {
+    this.listenTo(this, 'change:shouldQuerySupportLanguages', () => {
+      if (this.canManageInterpreters && !this.supportLanguages) {
+        this.querySupportLanguages();
+      }
+    });
+  },
+
+  /**
+   * 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 whether self has capability to manage interpreters (only host can manage it)
+   * @param {boolean} canManageInterpreters
+   * @returns {void}
+   */
+  updateCanManageInterpreters(canManageInterpreters) {
+    this.set('canManageInterpreters', canManageInterpreters);
+  },
+  /**
+   * Update the interpretation languages channels which user can choose to subscribe
+   * @param {Object} interpretation
+   * @returns {void}
+   */
+  updateInterpretation(interpretation) {
+    this.set('siEnabled', !!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;
+    });
+  },
+});
+
+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) &&
@@ -92,6 +148,14 @@ ControlsUtils.getControls = (oldControls: any, newControls: any) => {
         !isEqual(previous?.entryExitTone, current?.entryExitTone) &&
         (previous?.entryExitTone || current?.entryExitTone)
       ),
+
+      hasBreakoutChanged: !isEqual(previous?.breakout, current?.breakout),
+
+      hasInterpretationChanged: !isEqual(previous?.interpretation, current?.interpretation),
+
+      hasVideoEnabledChanged:
+        newControls.video?.enabled !== undefined &&
+        !isEqual(previous?.videoEnabled, current?.videoEnabled),
     },
   };
 };
@@ -109,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;