@webex/plugin-meetings 2.60.1-next.9 → 2.60.2

package/src/interpretation/index.ts

@@ -1,332 +0,0 @@
-/*!
- * 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

@@ -1,18 +0,0 @@
-/*!
- * 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/meeting/locusMediaRequest.ts

@@ -1,313 +0,0 @@
-/* eslint-disable valid-jsdoc */
-import {defer} from 'lodash';
-import {Defer} from '@webex/common';
-import {WebexPlugin} from '@webex/webex-core';
-import {MEDIA, HTTP_VERBS, ROAP, IP_VERSION} from '../constants';
-import LoggerProxy from '../common/logs/logger-proxy';
-
-export type MediaRequestType = 'RoapMessage' | 'LocalMute';
-export type RequestResult = any;
-
-export type RoapRequest = {
-  type: 'RoapMessage';
-  selfUrl: string;
-  mediaId: string;
-  roapMessage: any;
-  reachability: any;
-  sequence?: any;
-  joinCookie: any; // any, because this is opaque to the client, we pass whatever object we got from one backend component (Orpheus) to the other (Locus)
-  ipVersion?: IP_VERSION;
-};
-
-export type LocalMuteRequest = {
-  type: 'LocalMute';
-  selfUrl: string;
-  mediaId: string;
-  sequence?: any;
-  muteOptions: {
-    audioMuted?: boolean;
-    videoMuted?: boolean;
-  };
-};
-
-export type Request = RoapRequest | LocalMuteRequest;
-
-/** Class representing a single /media request being sent to Locus */
-class InternalRequestInfo {
-  public readonly request: Request;
-  private pendingPromises: Defer[];
-  private sendRequestFn: (request: Request) => Promise<RequestResult>;
-
-  /** Constructor */
-  constructor(
-    request: Request,
-    pendingPromise: Defer,
-    sendRequestFn: (request: Request) => Promise<RequestResult>
-  ) {
-    this.request = request;
-    this.pendingPromises = [pendingPromise];
-    this.sendRequestFn = sendRequestFn;
-  }
-
-  /**
-   * Returns the list of pending promises associated with this request
-   */
-  public getPendingPromises() {
-    return this.pendingPromises;
-  }
-
-  /**
-   * Adds promises to the list of pending promises associated with this request
-   */
-  public addPendingPromises(pendingPromises: Defer[]) {
-    this.pendingPromises.push(...pendingPromises);
-  }
-
-  /**
-   * Executes the request. Returned promise is resolved once the request
-   * is completed (no matter if it succeeded or failed).
-   */
-  public execute(): Promise<void> {
-    return this.sendRequestFn(this.request)
-      .then((result) => {
-        // resolve all the pending promises associated with this request
-        this.pendingPromises.forEach((d) => d.resolve(result));
-      })
-      .catch((e) => {
-        // reject all the pending promises associated with this request
-        this.pendingPromises.forEach((d) => d.reject(e));
-      });
-  }
-}
-
-export type Config = {
-  device: {
-    url: string;
-    deviceType: string;
-    countryCode?: string;
-    regionCode?: string;
-  };
-  correlationId: string;
-  preferTranscoding: boolean;
-};
-
-/**
- * Returns true if the request is triggering confluence creation in the server
- */
-function isRequestAffectingConfluenceState(request: Request): boolean {
-  return (
-    request.type === 'RoapMessage' && request.roapMessage.messageType === ROAP.ROAP_TYPES.OFFER
-  );
-}
-
-/**
- * This class manages all /media API requests to Locus. Every call to that
- * Locus API has to go through this class.
- */
-export class LocusMediaRequest extends WebexPlugin {
-  private config: Config;
-  private latestAudioMuted?: boolean;
-  private latestVideoMuted?: boolean;
-  private isRequestInProgress: boolean;
-  private queuedRequests: InternalRequestInfo[];
-  private confluenceState: 'not created' | 'creation in progress' | 'created';
-  /**
-   * Constructor
-   */
-  constructor(config: Config, options: any) {
-    super({}, options);
-    this.isRequestInProgress = false;
-    this.queuedRequests = [];
-    this.config = config;
-    this.confluenceState = 'not created';
-  }
-
-  /**
-   * Add a request to the internal queue.
-   */
-  private addToQueue(info: InternalRequestInfo) {
-    if (info.request.type === 'LocalMute' && this.queuedRequests.length > 0) {
-      // We don't need additional local mute requests in the queue.
-      // We only need at most 1 local mute or 1 roap request, because
-      // roap requests also include mute state, so whatever request
-      // is sent out, it will send the latest local mute state.
-      // We only need to store the pendingPromises so that they get resolved
-      // when the roap request is sent out.
-      this.queuedRequests[0].addPendingPromises(info.getPendingPromises());
-
-      return;
-    }
-
-    if (info.request.type === 'RoapMessage' && this.queuedRequests.length > 0) {
-      // remove any LocalMute requests from the queue, because this Roap message
-      // will also update the mute status in Locus, so they are redundant
-      this.queuedRequests = this.queuedRequests.filter((r) => {
-        if (r.request.type === 'LocalMute') {
-          // we need to keep the pending promises from the local mute request
-          // that we're removing from the queue
-          info.addPendingPromises(r.getPendingPromises());
-
-          return false;
-        }
-
-        return true;
-      });
-    }
-
-    this.queuedRequests.push(info);
-  }
-
-  /**
-   * Takes the next request from the queue and executes it. Once that
-   * request is completed, the next one will be taken from the queue
-   * and executed and this is repeated until the queue is empty.
-   */
-  private executeNextQueuedRequest(): void {
-    if (this.isRequestInProgress) {
-      return;
-    }
-
-    const nextRequest = this.queuedRequests.shift();
-
-    if (nextRequest) {
-      this.isRequestInProgress = true;
-      nextRequest.execute().then(() => {
-        this.isRequestInProgress = false;
-        this.executeNextQueuedRequest();
-      });
-    }
-  }
-
-  /**
-   * Returns latest requested audio and video mute values. If they have never been
-   * requested, we assume audio/video to be muted.
-   */
-  private getLatestMuteState() {
-    const audioMuted = this.latestAudioMuted !== undefined ? this.latestAudioMuted : true;
-    const videoMuted = this.latestVideoMuted !== undefined ? this.latestVideoMuted : true;
-
-    return {audioMuted, videoMuted};
-  }
-
-  /**
-   * Prepares the uri and body for the media request to be sent to Locus
-   */
-  private sendHttpRequest(request: Request) {
-    const uri = `${request.selfUrl}/${MEDIA}`;
-
-    const {audioMuted, videoMuted} = this.getLatestMuteState();
-
-    // first setup things common to all requests
-    const body: any = {
-      device: this.config.device,
-      correlationId: this.config.correlationId,
-      clientMediaPreferences: {
-        preferTranscoding: this.config.preferTranscoding,
-        ipver: request.type === 'RoapMessage' ? request.ipVersion : undefined,
-      },
-    };
-
-    const localMedias: any = {
-      audioMuted,
-      videoMuted,
-    };
-
-    // now add things specific to request type
-    switch (request.type) {
-      case 'LocalMute':
-        body.respOnlySdp = true;
-        body.usingResource = null;
-        break;
-
-      case 'RoapMessage':
-        localMedias.roapMessage = request.roapMessage;
-        localMedias.reachability = request.reachability;
-        body.clientMediaPreferences.joinCookie = request.joinCookie;
-        break;
-    }
-
-    if (request.sequence) {
-      body.sequence = request.sequence;
-    }
-
-    body.localMedias = [
-      {
-        localSdp: JSON.stringify(localMedias), // this part must be JSON stringified, Locus requires this
-        mediaId: request.mediaId,
-      },
-    ];
-
-    LoggerProxy.logger.info(
-      `Meeting:LocusMediaRequest#sendHttpRequest --> ${request.type} audioMuted=${audioMuted} videoMuted=${videoMuted}`
-    );
-
-    if (isRequestAffectingConfluenceState(request) && this.confluenceState === 'not created') {
-      this.confluenceState = 'creation in progress';
-    }
-
-    // @ts-ignore
-    return this.request({
-      method: HTTP_VERBS.PUT,
-      uri,
-      body,
-    })
-      .then((result) => {
-        if (isRequestAffectingConfluenceState(request)) {
-          this.confluenceState = 'created';
-        }
-
-        return result;
-      })
-      .catch((e) => {
-        if (
-          isRequestAffectingConfluenceState(request) &&
-          this.confluenceState === 'creation in progress'
-        ) {
-          this.confluenceState = 'not created';
-        }
-        throw e;
-      });
-  }
-
-  /**
-   * Sends a media request to Locus
-   */
-  public send(request: Request): Promise<RequestResult> {
-    if (request.type === 'LocalMute') {
-      const {audioMuted, videoMuted} = request.muteOptions;
-
-      if (audioMuted !== undefined) {
-        this.latestAudioMuted = audioMuted;
-      }
-      if (videoMuted !== undefined) {
-        this.latestVideoMuted = videoMuted;
-      }
-
-      if (this.confluenceState === 'not created') {
-        // if there is no confluence, there is no point sending out local mute request
-        // as it will fail so we just store the latest audio/video muted values
-        // and resolve immediately, so that higher layer (MuteState class) doesn't get blocked
-        // and can call us again if user mutes/unmutes again before confluence is created
-        LoggerProxy.logger.info(
-          'Meeting:LocusMediaRequest#send --> called with LocalMute request before confluence creation'
-        );
-
-        return Promise.resolve({});
-      }
-    }
-
-    const pendingPromise = new Defer();
-
-    const newRequest = new InternalRequestInfo(
-      request,
-      pendingPromise,
-      this.sendHttpRequest.bind(this)
-    );
-
-    this.addToQueue(newRequest);
-
-    defer(() => this.executeNextQueuedRequest());
-
-    return pendingPromise.promise;
-  }
-}

package/src/meeting/request.type.ts

@@ -1,13 +0,0 @@
-import {Reaction} from '../reactions/reactions.type';
-
-export type SendReactionOptions = {
-  reactionChannelUrl: string;
-  reaction: Reaction;
-  participantId: string;
-};
-
-export type ToggleReactionsOptions = {
-  enable: boolean;
-  locusUrl: string;
-  requestingParticipantId: string;
-};