@webex/plugin-meetings 2.37.2 → 2.38.1

package/src/meetings/index.ts

@@ -221,6 +221,7 @@ export default class Meetings extends WebexPlugin {
       // @ts-ignore
       this.meetingCollection.getByKey(
         CORRELATION_ID,
+        // @ts-ignore
         MeetingsUtil.checkForCorrelationId(this.webex.internal.device.url, data.locus)
       ) ||
       this.meetingCollection.getByKey(
@@ -440,11 +441,14 @@ export default class Meetings extends WebexPlugin {
        */
       // @ts-ignore
       this.meetingInfo = this.config.experimental.enableUnifiedMeetings
-        ? new MeetingInfoV2(this.webex)
-        : new MeetingInfo(this.webex);
+        ? // @ts-ignore
+          new MeetingInfoV2(this.webex)
+        : // @ts-ignore
+          new MeetingInfo(this.webex);
       // @ts-ignore
       this.personalMeetingRoom = new PersonalMeetingRoom(
         {meetingInfo: this.meetingInfo},
+        // @ts-ignore
         {parent: this.webex}
       );
 
@@ -554,6 +558,7 @@ export default class Meetings extends WebexPlugin {
         // @ts-ignore
         .then(() =>
           LoggerProxy.logger.info(
+            // @ts-ignore
             `Meetings:index#register --> INFO, Device registered ${this.webex.internal.device.url}`
           )
         )
@@ -607,8 +612,8 @@ export default class Meetings extends WebexPlugin {
 
     this.stopListeningForEvents();
 
-    // @ts-ignore
     return (
+      // @ts-ignore
       this.webex.internal.mercury
         .disconnect()
         // @ts-ignore

package/src/meetings/request.ts

@@ -53,9 +53,9 @@ export default class MeetingRequest extends StatelessWebexPlugin {
    */
   determineRedirections(responseBody: any) {
     if (responseBody.remoteLocusClusterUrls && responseBody.remoteLocusClusterUrls.length) {
-      // @ts-ignore
       return Promise.all(
         responseBody.remoteLocusClusterUrls.map((url) =>
+          // @ts-ignore
           this.request({
             method: HTTP_VERBS.GET,
             url,

package/src/member/util.ts

@@ -72,7 +72,7 @@ MemberUtil.isAssociatedSame = (participant: any, id: string) =>
  * @param {String} status
  * @returns {Boolean}
  */
-MemberUtil.isNotAdmitted = (participant: any, isGuest: boolean, status: string) =>
+MemberUtil.isNotAdmitted = (participant: any, isGuest: boolean, status: string): boolean =>
   participant &&
   participant.guest &&
   ((participant.devices &&
@@ -82,6 +82,7 @@ MemberUtil.isNotAdmitted = (participant: any, isGuest: boolean, status: string)
     // @ts-ignore
     isGuest &&
     status === _IN_LOBBY_) ||
+    // @ts-ignore
     !status === _IN_MEETING_);
 
 /**

package/src/members/request.ts

@@ -140,6 +140,7 @@ export default class MembersRequest extends StatelessWebexPlugin {
       !options.locusUrl ||
       !options.memberId ||
       !options.url ||
+      // @ts-ignore
       (!options.tones && options.tones !== 0)
     ) {
       throw new ParameterError(

package/src/reachability/index.ts

@@ -261,6 +261,7 @@ export default class Reachability {
 
         // @ts-ignore
         LoggerProxy.logger.log(
+          // @ts-ignore
           `Reachability:index#onIceGatheringStateChange --> Successfully pinged ${peerConnection.key}:`,
           elapsed
         );
@@ -284,8 +285,8 @@ export default class Reachability {
       if (e.candidate && String(e.candidate.type).toLowerCase() === SERVER_REFLEXIVE) {
         const elapsed = this.getElapsedTime(peerConnection);
 
-        // @ts-ignore
         LoggerProxy.logger.log(
+          // @ts-ignore
           `Reachability:index#onIceCandidate --> Successfully pinged ${peerConnection.key}:`,
           elapsed
         );

package/src/reactions/reactions.type.ts

@@ -5,7 +5,8 @@ export type EmoticonData = {
 };
 
 export type SkinTone = EmoticonData;
-export type Reaction = ReactionData & {
+// @ts-ignore
+export type Reaction = EmoticonData & {
   tone?: SkinTone;
 };
 

package/src/recording-controller/enums.ts

@@ -0,0 +1,8 @@
+enum RecordingAction {
+  Start = 'Start',
+  Stop = 'Stop',
+  Pause = 'Pause',
+  Resume = 'Resume',
+}
+
+export default RecordingAction;

package/src/recording-controller/index.ts

@@ -0,0 +1,315 @@
+import PermissionError from '../common/errors/permission';
+import {CONTROLS, HTTP_VERBS} from '../constants';
+import MeetingRequest from '../meeting/request';
+import RecordingAction from './enums';
+import Util from './util';
+import LoggerProxy from '../common/logs/logger-proxy';
+
+/**
+ * @description Recording manages the recording functionality of the meeting object, there should only be one instantation of recording per meeting
+ * @export
+ * @private
+ * @class Recording
+ */
+export default class RecordingController {
+  /**
+   * @instance
+   * @type {MeetingRequest}
+   * @private
+   * @memberof RecordingController
+   */
+  private request: MeetingRequest;
+
+  /**
+   * @instance
+   * @type {Array}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private displayHints: Array<string> = [];
+
+  /**
+   * @instance
+   * @type {string}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private serviceUrl: string;
+
+  /**
+   * @instance
+   * @type {string}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private sessionId: string;
+
+  /**
+   * @instance
+   * @type {string}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private locusUrl: string;
+
+  /**
+   * @instance
+   * @type {string}
+   * @private
+   * @memberof RecordingInfo
+   */
+  private locusId: string;
+
+  /**
+   * @param {MeetingRequest} request
+   * @param {Object} options
+   * @constructor
+   * @memberof RecordingController
+   */
+  constructor(
+    request: MeetingRequest,
+    options?: {
+      serviceUrl?: string;
+      sessionId: string;
+      locusUrl: string;
+      displayHints?: Array<string>;
+    }
+  ) {
+    this.initialize(request);
+    this.set(options);
+  }
+
+  /**
+   * @param {MeetingRequest} request
+   * @param {LocusInfo} info
+   * @returns {void}
+   * @private
+   * @memberof RecordingController
+   */
+  private initialize(request: MeetingRequest) {
+    this.request = request;
+  }
+
+  /**
+   * @param {Object} options
+   * @returns {void}
+   * @public
+   * @memberof RecordingController
+   */
+  public set(options?: {
+    serviceUrl?: string;
+    sessionId: string;
+    locusUrl: string;
+    displayHints?: Array<string>;
+  }) {
+    this.extract(options);
+  }
+
+  /**
+   * @param {string} url
+   * @returns {void}
+   * @public
+   * @memberof RecordingController
+   */
+  public setLocusUrl(url: string) {
+    this.locusUrl = url;
+    this.locusId = Util.extractLocusId(this.locusUrl);
+  }
+
+  /**
+   * @param {Array} hints
+   * @returns {void}
+   * @public
+   * @memberof RecordingController
+   */
+  public setDisplayHints(hints: Array<string>) {
+    this.displayHints = hints;
+  }
+
+  /**
+   * @param {string} id
+   * @returns {void}
+   * @public
+   * @memberof RecordingController
+   */
+  public setSessionId(id: string) {
+    this.sessionId = id;
+  }
+
+  /**
+   * @param {string} url
+   * @returns {void}
+   * @public
+   * @memberof RecordingController
+   */
+  public setServiceUrl(url: string) {
+    this.serviceUrl = url;
+  }
+
+  /**
+   * @returns {string}
+   * @public
+   * @memberof RecordingController
+   */
+  public getLocusUrl() {
+    return this.locusUrl;
+  }
+
+  /**
+   * @returns {string}
+   * @public
+   * @memberof RecordingController
+   */
+  public getLocusId() {
+    return this.locusId;
+  }
+
+  /**
+   * @returns {string}
+   * @public
+   * @memberof RecordingController
+   */
+  public getSessionId() {
+    return this.sessionId;
+  }
+
+  /**
+   * @returns {string}
+   * @public
+   * @memberof RecordingController
+   */
+  public getServiceUrl() {
+    return this.serviceUrl;
+  }
+
+  /**
+   * @returns {Array}
+   * @public
+   * @memberof RecordingController
+   */
+  public getDisplayHints() {
+    return this.displayHints;
+  }
+
+  /**
+   * @param {Object} options
+   * @returns {void}
+   * @private
+   * @memberof RecordingController
+   */
+  private extract(options?: {
+    serviceUrl?: string;
+    sessionId: string;
+    locusUrl: string;
+    displayHints?: Array<string>;
+  }) {
+    this.setServiceUrl(options?.serviceUrl);
+    this.setSessionId(options?.sessionId);
+    this.setDisplayHints(options?.displayHints);
+    this.setLocusUrl(options?.locusUrl);
+  }
+
+  /**
+   * @param {RecordingAction} action
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  private recordingService(action: RecordingAction): Promise<any> {
+    // @ts-ignore
+    return this.request.request({
+      body: {
+        meetingInfo: {
+          locusSessionId: this.sessionId,
+        },
+        recording: {
+          action: action.toLowerCase(),
+        },
+      },
+      uri: `${this.serviceUrl}/loci/${this.locusId}/recording`,
+      method: HTTP_VERBS.PUT,
+    });
+  }
+
+  /**
+   * @param {RecordingAction} action
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  private recordingControls(action: RecordingAction): Promise<any> {
+    const record = Util.deriveRecordingStates(action);
+
+    LoggerProxy.logger.log(`RecordingController:index#recordingControls --> ${record}`);
+
+    // @ts-ignore
+    return this.request.request({
+      uri: `${this.locusUrl}/${CONTROLS}`,
+      body: {
+        record,
+      },
+      method: HTTP_VERBS.PATCH,
+    });
+  }
+
+  /**
+   * @param {RecordingAction} action
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  private recordingFacade(action: RecordingAction): Promise<any> {
+    LoggerProxy.logger.log(
+      `RecordingController:index#recordingFacade --> recording action [${action}]`
+    );
+
+    // assumes action is proper cased (i.e., Example)
+    if (Util?.[`canUser${action}`](this.displayHints)) {
+      if (this.serviceUrl) {
+        return this.recordingService(action);
+      }
+
+      return this.recordingControls(action);
+    }
+
+    return Promise.reject(
+      new PermissionError(`${action} recording not allowed, due to moderator property.`)
+    );
+  }
+
+  /**
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  public startRecording(): Promise<any> {
+    return this.recordingFacade(RecordingAction.Start);
+  }
+
+  /**
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  public stopRecording(): Promise<any> {
+    return this.recordingFacade(RecordingAction.Stop);
+  }
+
+  /**
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  public pauseRecording(): Promise<any> {
+    return this.recordingFacade(RecordingAction.Pause);
+  }
+
+  /**
+   * @private
+   * @memberof RecordingController
+   * @returns {Promise}
+   */
+  public resumeRecording(): Promise<any> {
+    return this.recordingFacade(RecordingAction.Resume);
+  }
+}

package/src/recording-controller/util.ts

@@ -0,0 +1,58 @@
+import {DISPLAY_HINTS} from '../constants';
+import RecordingAction from './enums';
+
+const canUserStart = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START);
+
+const canUserPause = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE);
+
+const canUserResume = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME);
+
+const canUserStop = (displayHints: Array<string>): boolean =>
+  displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP);
+
+const extractLocusId = (url: string) => {
+  return url?.split('/').pop();
+};
+
+const deriveRecordingStates = (action: RecordingAction): {recording: boolean; paused: boolean} => {
+  let recording;
+  let paused;
+
+  switch (action) {
+    case RecordingAction.Start:
+      recording = true;
+      paused = false;
+      break;
+    case RecordingAction.Stop:
+      recording = false;
+      paused = false;
+      break;
+    case RecordingAction.Resume:
+      recording = true;
+      paused = false;
+      break;
+    case RecordingAction.Pause:
+      recording = true;
+      paused = true;
+      break;
+    default:
+      throw new Error(`Recording state cannot be derived from invalid action: ${action}`);
+  }
+
+  return {
+    recording,
+    paused,
+  };
+};
+
+export default {
+  canUserStart,
+  canUserPause,
+  canUserResume,
+  canUserStop,
+  deriveRecordingStates,
+  extractLocusId,
+};

package/src/roap/index.ts

@@ -170,8 +170,8 @@ export default class Roap extends StatelessWebexPlugin {
           locusSelfUrl: meeting.selfUrl,
           mediaId: options.mediaId,
           correlationId: options.correlationId,
-          audioMuted: meeting.isAudioMuted(),
-          videoMuted: meeting.isVideoMuted(),
+          audioMuted: meeting.audio?.isLocallyMuted(),
+          videoMuted: meeting.video?.isLocallyMuted(),
           meetingId: meeting.id,
         })
         .then(() => {
@@ -222,8 +222,8 @@ export default class Roap extends StatelessWebexPlugin {
         locusSelfUrl: meeting.selfUrl,
         mediaId: options.mediaId,
         correlationId: options.correlationId,
-        audioMuted: options.audioMuted,
-        videoMuted: options.videoMuted,
+        audioMuted: meeting.audio?.isLocallyMuted(),
+        videoMuted: meeting.video?.isLocallyMuted(),
         meetingId: meeting.id,
       })
       .then(() => {
@@ -295,8 +295,8 @@ export default class Roap extends StatelessWebexPlugin {
         correlationId: meeting.correlationId,
         locusSelfUrl: meeting.selfUrl,
         mediaId: sendEmptyMediaId ? '' : meeting.mediaId,
-        audioMuted: meeting.isAudioMuted(),
-        videoMuted: meeting.isVideoMuted(),
+        audioMuted: meeting.audio?.isLocallyMuted(),
+        videoMuted: meeting.video?.isLocallyMuted(),
         meetingId: meeting.id,
       })
       .then(({locus, mediaConnections}) => {
@@ -353,8 +353,8 @@ export default class Roap extends StatelessWebexPlugin {
               roapMessage,
               // eslint-disable-next-line no-warning-comments
               // TODO: check whats the need for video and audiomute
-              audioMuted: !!meeting.isAudioMuted(),
-              videoMuted: !!meeting.isVideoMuted(),
+              audioMuted: meeting.audio?.isLocallyMuted(),
+              videoMuted: meeting.video?.isLocallyMuted(),
             })
           ),
           // mediaId: meeting.mediaId

package/src/roap/turnDiscovery.ts

@@ -177,8 +177,8 @@ export default class TurnDiscovery {
         locusSelfUrl: meeting.selfUrl,
         // @ts-ignore - Fix missing type
         mediaId: isReconnecting ? '' : meeting.mediaId,
-        audioMuted: meeting.isAudioMuted(),
-        videoMuted: meeting.isVideoMuted(),
+        audioMuted: meeting.audio?.isLocallyMuted(),
+        videoMuted: meeting.video?.isLocallyMuted(),
         meetingId: meeting.id,
       })
       .then(({mediaConnections}) => {
@@ -211,8 +211,8 @@ export default class TurnDiscovery {
       // @ts-ignore - fix type
       mediaId: meeting.mediaId,
       correlationId: meeting.correlationId,
-      audioMuted: meeting.isAudioMuted(),
-      videoMuted: meeting.isVideoMuted(),
+      audioMuted: meeting.audio?.isLocallyMuted(),
+      videoMuted: meeting.video?.isLocallyMuted(),
       meetingId: meeting.id,
     });
   }
@@ -230,7 +230,7 @@ export default class TurnDiscovery {
    *                                 media connection just after a reconnection
    * @returns {Promise}
    */
-  doTurnDiscovery(meeting: Meeting, isReconnecting: boolean) {
+  doTurnDiscovery(meeting: Meeting, isReconnecting?: boolean) {
     // @ts-ignore - fix type
     const isAnyClusterReachable = meeting.webex.meetings.reachability.isAnyClusterReachable();
 

package/src/statsAnalyzer/mqaUtil.ts

@@ -26,6 +26,7 @@ export const getAudioReceiverMqa = ({audioReceiver, statsResults, lastMqaDataSen
 
   // @ts-ignore
   audioReceiver.streams[0].common.maxRtpJitter =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRtpJitter) * 1000 || 0;
   audioReceiver.streams[0].common.meanRtpJitter =
     mean(statsResults[mediaType][sendrecvType].meanRtpJitter) * 1000 || 0;
@@ -72,6 +73,7 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent})
 
   // @ts-ignore
   audioSender.common.maxRemoteJitter =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
   audioSender.common.meanRemoteJitter =
     mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
@@ -96,6 +98,7 @@ export const getAudioSenderMqa = ({audioSender, statsResults, lastMqaDataSent})
 
   // @ts-ignore
   audioSender.common.maxRoundTripTime =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
   audioSender.common.meanRoundTripTime =
     mean(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
@@ -152,6 +155,7 @@ export const getVideoReceiverMqa = ({
 
   // @ts-ignore
   videoReceiver.common.maxRemoteJitter =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
   videoReceiver.common.meanRemoteJitter =
     mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
@@ -217,6 +221,7 @@ export const getVideoSenderMqa = ({
 
   // @ts-ignore
   videoSender.common.maxRemoteJitter =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
   videoSender.common.meanRemoteJitter =
     mean(statsResults[mediaType][sendrecvType].meanRemoteJitter) * 1000 || 0;
@@ -239,6 +244,7 @@ export const getVideoSenderMqa = ({
 
   // @ts-ignore
   videoSender.common.maxRoundTripTime =
+    // @ts-ignore
     max(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;
   videoSender.common.meanRoundTripTime =
     mean(statsResults[mediaType][sendrecvType].meanRoundTripTime) * 1000 || 0;

package/test/integration/spec/journey.js

@@ -5,7 +5,7 @@ import {assert} from '@webex/test-helper-chai';
 import {skipInNode} from '@webex/test-helper-mocha';
 import sinon from 'sinon';
 
-import BrowserDetection from '@webex/plugin-meetings/src/common/browser-detection';
+import BrowserDetection from '@webex/plugin-meetings/dist/common/browser-detection';
 
 import DEFAULT_RESOLUTIONS from '../../../src/config';
 import testUtils from '../../utils/testUtils';

package/test/integration/spec/space-meeting.js

@@ -2,7 +2,7 @@
 import {assert} from '@webex/test-helper-chai';
 import {skipInNode, jenkinsOnly} from '@webex/test-helper-mocha';
 import {patterns} from '@webex/common';
-import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/utilv2';
+import MeetingInfoUtil from '@webex/plugin-meetings/dist/meeting-info/utilv2';
 
 import CMR from '../../utils/cmr';
 import testUtils from '../../utils/testUtils';

package/test/integration/spec/transcription.js

@@ -1,4 +1,4 @@
-import Transcription from '@webex/plugin-meetings/src/transcription';
+import Transcription from '@webex/plugin-meetings/dist/transcription';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';