@webex/plugin-meetings 3.8.0-next.5 → 3.8.0-next.51

package/src/meeting/locusMediaRequest.ts

@@ -1,10 +1,12 @@
 /* eslint-disable valid-jsdoc */
 import {defer} from 'lodash';
-import {Defer} from '@webex/common';
+import {Defer, transferEvents} from '@webex/common';
+import {EventEmitter} from 'events';
 import {WebexPlugin} from '@webex/webex-core';
 import {MEDIA, HTTP_VERBS, ROAP} from '../constants';
 import LoggerProxy from '../common/logs/logger-proxy';
 import {ClientMediaPreferences} from '../reachability/reachability.types';
+import MeetingUtil from './util';
 
 export type MediaRequestType = 'RoapMessage' | 'LocalMute';
 export type RequestResult = any;
@@ -220,14 +222,6 @@ export class LocusMediaRequest extends WebexPlugin {
         localMedias.roapMessage = request.roapMessage;
         localMedias.reachability = request.reachability;
         body.clientMediaPreferences = request.clientMediaPreferences;
-
-        // @ts-ignore
-        this.webex.internal.newMetrics.submitClientEvent({
-          name: 'client.locus.media.request',
-          options: {
-            meetingId: this.config.meetingId,
-          },
-        });
         break;
     }
 
@@ -250,30 +244,29 @@ export class LocusMediaRequest extends WebexPlugin {
       this.confluenceState = 'creation in progress';
     }
 
-    // @ts-ignore
-    return this.request({
+    const upload = new EventEmitter();
+    const download = new EventEmitter();
+
+    const options = {
       method: HTTP_VERBS.PUT,
       uri,
       body,
-    })
+      upload,
+      download,
+    };
+
+    // @ts-ignore
+    const promise = this.request(options)
       .then((result) => {
         if (isRequestAffectingConfluenceState(request)) {
           this.confluenceState = 'created';
         }
 
-        if (request.type === 'RoapMessage') {
-          // @ts-ignore
-          this.webex.internal.newMetrics.submitClientEvent({
-            name: 'client.locus.media.response',
-            options: {
-              meetingId: this.config.meetingId,
-            },
-          });
-        }
-
         return result;
       })
-      .catch((e) => {
+      .catch((error) => {
+        let e = error;
+
         if (
           isRequestAffectingConfluenceState(request) &&
           this.confluenceState === 'creation in progress'
@@ -282,6 +275,8 @@ export class LocusMediaRequest extends WebexPlugin {
         }
 
         if (request.type === 'RoapMessage') {
+          e = MeetingUtil.markErrorAsHandledBySdk(e);
+
           // @ts-ignore
           this.webex.internal.newMetrics.submitClientEvent({
             name: 'client.locus.media.response',
@@ -294,6 +289,21 @@ export class LocusMediaRequest extends WebexPlugin {
 
         throw e;
       });
+
+    if (request.type === 'RoapMessage') {
+      const setupProgressListener = (direction: string, eventEmitter: EventEmitter) => {
+        eventEmitter.on('progress', (progressEvent: ProgressEvent) => {
+          LoggerProxy.logger.info(
+            `${request.type}: ${direction} Progress, Timestamp: ${progressEvent.timeStamp}, Progress: ${progressEvent.loaded}/${progressEvent.total}`
+          );
+        });
+      };
+
+      setupProgressListener('Upload', options.upload);
+      setupProgressListener('Download', options.download);
+    }
+
+    return promise;
   }
 
   /**

package/src/meeting/muteState.ts

@@ -147,7 +147,6 @@ export class MuteState {
    * @public
    * @memberof MuteState
    * @param {Object} [meeting] the meeting object
-   * @param {Boolean} [mute] true for muting, false for unmuting request
    * @returns {void}
    */
   public handleLocalStreamMuteStateChange(meeting?: any) {
@@ -350,7 +349,6 @@ export class MuteState {
    * @param {Meeting} meeting
    * @returns {void}
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   private applyUnmuteAllowedToStream(meeting: any) {
     if (this.type === AUDIO) {
       meeting.mediaProperties.audioStream?.setUnmuteAllowed(this.state.server.unmuteAllowed);

package/src/meeting/request.ts

@@ -27,7 +27,12 @@ import {
   _SLIDES_,
   ANNOTATION,
 } from '../constants';
-import {SendReactionOptions, BrbOptions, ToggleReactionsOptions} from './request.type';
+import {
+  SendReactionOptions,
+  BrbOptions,
+  ToggleReactionsOptions,
+  PostMeetingDataConsentOptions,
+} from './request.type';
 import MeetingUtil from './util';
 import {AnnotationInfo} from '../annotation/annotation.types';
 import {ClientMediaPreferences} from '../reachability/reachability.types';
@@ -934,4 +939,34 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       },
     });
   }
+
+  /**
+   * Sends a request to set post meeting data consent.
+   *
+   * @param {Object} options - The options for post meeting data consent request.
+   * @param {boolean} options.consent - Whether accepted or declined.
+   * @param {string} options.locusUrl - The URL of the locus.
+   * @param {string} options.deviceUrl - The URL of the device.
+   * @param {string} options.selfId - The ID of the participant.
+   * @returns {Promise}
+   */
+  setPostMeetingDataConsent({
+    postMeetingDataConsent,
+    locusUrl,
+    deviceUrl,
+    selfId,
+  }: PostMeetingDataConsentOptions) {
+    const uri = `${locusUrl}/${PARTICIPANT}/${selfId}/${CONTROLS}`;
+
+    return this.locusDeltaRequest({
+      method: HTTP_VERBS.PATCH,
+      uri,
+      body: {
+        consent: {
+          postMeetingDataConsent,
+          deviceUrl,
+        },
+      },
+    });
+  }
 }

package/src/meeting/request.type.ts

@@ -18,3 +18,10 @@ export type BrbOptions = {
   deviceUrl: string;
   selfId: string;
 };
+
+export type PostMeetingDataConsentOptions = {
+  postMeetingDataConsent: boolean;
+  locusUrl: string;
+  deviceUrl: string;
+  selfId: string;
+};

package/src/meeting/util.ts

@@ -176,11 +176,12 @@ const MeetingUtil = {
         deviceCapabilities: options.deviceCapabilities,
         liveAnnotationSupported: options.liveAnnotationSupported,
         clientMediaPreferences,
+        alias: options.alias,
       })
       .then((res) => {
         const parsed = MeetingUtil.parseLocusJoin(res);
         meeting.setLocus(parsed);
-
+        meeting.isoLocalClientMeetingJoinTime = res?.headers?.date; // read from header if exist, else fall back to system clock : https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-555657
         webex.internal.newMetrics.submitClientEvent({
           name: 'client.locus.join.response',
           payload: {
@@ -572,9 +573,15 @@ const MeetingUtil = {
   canUserRenameSelfAndObserved: (displayHints) =>
     displayHints.includes(DISPLAY_HINTS.CAN_RENAME_SELF_AND_OBSERVED),
 
+  requiresPostMeetingDataConsentPrompt: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.SHOW_POST_MEETING_DATA_CONSENT_PROMPT),
+
   canUserRenameOthers: (displayHints) => displayHints.includes(DISPLAY_HINTS.CAN_RENAME_OTHERS),
 
-  canShareWhiteBoard: (displayHints) => displayHints.includes(DISPLAY_HINTS.SHARE_WHITEBOARD),
+  // Default empty value for policies if we get an undefined value (ie permissionToken is not available)
+  canShareWhiteBoard: (displayHints, policies = {}) =>
+    displayHints.includes(DISPLAY_HINTS.SHARE_WHITEBOARD) &&
+    !!policies[SELF_POLICY.SUPPORT_WHITEBOARD],
 
   /**
    * Adds the current locus sequence information to a request body
@@ -805,6 +812,24 @@ const MeetingUtil = {
       },
     ];
   },
+
+  /**
+   * Creates a proxy object to mark an error as handled by the SDK.
+   * @param {Error} error original error
+   * @returns {Proxy} proxy object with handledBySdk property
+   */
+  markErrorAsHandledBySdk: (error) => {
+    return new Proxy(error, {
+      // eslint-disable-next-line require-jsdoc
+      get(target, prop) {
+        if (prop === 'handledBySdk') {
+          return true;
+        }
+
+        return Reflect.get(target, prop);
+      },
+    });
+  },
 };
 
 export default MeetingUtil;

package/src/meeting-info/meeting-info-v2.ts

@@ -16,6 +16,9 @@ const CAPTCHA_ERROR_DEFAULT_MESSAGE =
   'Captcha required. Call fetchMeetingInfo() with captchaInfo argument';
 const ADHOC_MEETING_DEFAULT_ERROR =
   'Failed starting the adhoc meeting, Please contact support team ';
+const MEETING_IS_IN_PROGRESS_MESSAGE = 'Meeting is in progress';
+const STATIC_MEETING_LINK_ALREADY_EXISTS_MESSAGE = 'Static meeting link already exists';
+const FETCH_STATIC_MEETING_LINK = 'Meeting link does not exists for conversation';
 const CAPTCHA_ERROR_REQUIRES_PASSWORD_CODES = [423005, 423006];
 const CAPTCHA_ERROR_REQUIRES_REGISTRATION_ID_CODES = [423007];
 
@@ -193,6 +196,77 @@ export class MeetingInfoV2JoinForbiddenError extends Error {
   }
 }
 
+/**
+ * Error fetching static link for a conversation when it does not exist
+ */
+export class MeetingInfoV2StaticLinkDoesNotExistError extends Error {
+  sdkMessage: any;
+  wbxAppApiCode: any;
+  body: any;
+  /**
+   *
+   * @constructor
+   * @param {Number} [wbxAppApiErrorCode]
+   * @param {String} [message]
+   */
+  constructor(wbxAppApiErrorCode?: number, message: string = FETCH_STATIC_MEETING_LINK) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2StaticLinkDoesNotExistError';
+    this.sdkMessage = message;
+    this.stack = new Error().stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+  }
+}
+
+/**
+ * Error enabling/disabling static meeting link
+ */
+export class MeetingInfoV2MeetingIsInProgressError extends Error {
+  sdkMessage: any;
+  wbxAppApiCode: any;
+  body: any;
+  /**
+   *
+   * @constructor
+   * @param {Number} [wbxAppApiErrorCode]
+   * @param {String} [message]
+   * @param {Boolean} [enable]
+   */
+  constructor(
+    wbxAppApiErrorCode?: number,
+    message = MEETING_IS_IN_PROGRESS_MESSAGE,
+    enable = false
+  ) {
+    super(`${message}, code=${wbxAppApiErrorCode}, enable=${enable}`);
+    this.name = 'MeetingInfoV2MeetingIsInProgressError';
+    this.sdkMessage = message;
+    this.stack = new Error().stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+  }
+}
+
+/**
+ * Error enabling/disabling static meeting link
+ */
+export class MeetingInfoV2StaticMeetingLinkAlreadyExists extends Error {
+  sdkMessage: any;
+  wbxAppApiCode: any;
+  body: any;
+  /**
+   *
+   * @constructor
+   * @param {Number} [wbxAppApiErrorCode]
+   * @param {String} [message]
+   */
+  constructor(wbxAppApiErrorCode?: number, message = STATIC_MEETING_LINK_ALREADY_EXISTS_MESSAGE) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2StaticMeetingLinkAlreadyExists';
+    this.sdkMessage = message;
+    this.stack = new Error().stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+  }
+}
+
 /**
  * @class MeetingInfo
  */
@@ -293,17 +367,20 @@ export default class MeetingInfoV2 {
   };
 
   /**
-   * Creates adhoc space meetings for a space by fetching the conversation infomation
+   * helper function to either create an adhoc space meeting or enable static meeting link
    * @param {String} conversationUrl conversationUrl to start adhoc meeting on
    * @param {String} installedOrgID org ID of user's machine
+   * @param {Boolean} enableStaticMeetingLink whether or not to enable static meeting link
    * @returns {Promise} returns a meeting info object
    * @public
    * @memberof MeetingInfo
    */
-  async createAdhocSpaceMeeting(conversationUrl: string, installedOrgID?: string) {
-    if (!this.webex.meetings.preferredWebexSite) {
-      throw Error('No preferred webex site found');
-    }
+  async createAdhocSpaceMeetingOrEnableStaticMeetingLink(
+    conversationUrl: string,
+    installedOrgID?: string,
+    // setting this to true enables static meeting link
+    enableStaticMeetingLink = false
+  ) {
     const getInvitees = (particpants = []) => {
       const invitees = [];
 
@@ -329,6 +406,7 @@ export default class MeetingInfoV2 {
           kroUrl: conversation.kmsResourceObjectUrl,
           invitees: getInvitees(conversation.participants?.items),
           installedOrgID,
+          schedule: enableStaticMeetingLink,
         };
 
         if (installedOrgID) {
@@ -344,7 +422,23 @@ export default class MeetingInfoV2 {
           uri,
           body,
         });
-      })
+      });
+  }
+
+  /**
+   * Creates adhoc space meetings for a space by fetching the conversation infomation
+   * @param {String} conversationUrl conversationUrl to start adhoc meeting on
+   * @param {String} installedOrgID org ID of user's machine
+   * @returns {Promise} returns a meeting info object
+   * @public
+   * @memberof MeetingInfo
+   */
+  async createAdhocSpaceMeeting(conversationUrl: string, installedOrgID?: string) {
+    if (!this.webex.meetings.preferredWebexSite) {
+      throw Error('No preferred webex site found');
+    }
+
+    return this.createAdhocSpaceMeetingOrEnableStaticMeetingLink(conversationUrl, installedOrgID)
       .then((requestResult) => {
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADHOC_MEETING_SUCCESS);
 
@@ -363,6 +457,153 @@ export default class MeetingInfoV2 {
       });
   }
 
+  /**
+   * Fetches details for static meeting link
+   * @param {String} conversationUrl conversationUrl that's required to find static meeting link if it exists
+   * @returns {Promise} returns a Promise
+   * @public
+   * @memberof MeetingInfo
+   */
+  async fetchStaticMeetingLink(conversationUrl: string) {
+    if (!this.webex.meetings.preferredWebexSite) {
+      throw Error('No preferred webex site found');
+    }
+
+    const body = {
+      spaceUrl: conversationUrl,
+    };
+
+    const uri = this.webex.meetings.preferredWebexSite
+      ? `https://${this.webex.meetings.preferredWebexSite}/wbxappapi/v2/meetings/spaceInstant/query`
+      : '';
+
+    return this.webex
+      .request({
+        method: HTTP_VERBS.POST,
+        uri,
+        body,
+      })
+      .then((requestResult) => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.FETCH_STATIC_MEETING_LINK_SUCCESS);
+
+        return requestResult;
+      })
+      .catch((err) => {
+        if (err?.statusCode === 403) {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_LINK_DOES_NOT_EXIST_ERROR, {
+            reason: err.message,
+            stack: err.stack,
+          });
+
+          throw new MeetingInfoV2StaticLinkDoesNotExistError(err.body?.code, err.body?.message);
+        }
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.FETCH_STATIC_MEETING_LINK_FAILURE, {
+          reason: err.message,
+          stack: err.stack,
+        });
+
+        throw err;
+      });
+  }
+
+  /**
+   * Enables static meeting link
+   * @param {String} conversationUrl conversationUrl that's required to enable static meeting link
+   * @returns {Promise} returns a Promise
+   * @public
+   * @memberof MeetingInfo
+   */
+  async enableStaticMeetingLink(conversationUrl: string) {
+    if (!this.webex.meetings.preferredWebexSite) {
+      throw Error('No preferred webex site found');
+    }
+
+    return this.createAdhocSpaceMeetingOrEnableStaticMeetingLink(conversationUrl, undefined, true)
+      .then((requestResult) => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ENABLE_STATIC_METTING_LINK_SUCCESS);
+
+        return requestResult;
+      })
+      .catch((err) => {
+        if (err?.statusCode === 403) {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_IS_IN_PROGRESS_ERROR, {
+            reason: err.message,
+            stack: err.stack,
+          });
+
+          throw new MeetingInfoV2MeetingIsInProgressError(err.body?.code, err.body?.message, true);
+        }
+
+        if (err?.statusCode === 409) {
+          Metrics.sendBehavioralMetric(
+            BEHAVIORAL_METRICS.STATIC_MEETING_LINK_ALREADY_EXISTS_ERROR,
+            {
+              reason: err.message,
+              stack: err.stack,
+            }
+          );
+
+          throw new MeetingInfoV2StaticMeetingLinkAlreadyExists(err.body?.code, err.body?.message);
+        }
+
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ENABLE_STATIC_METTING_LINK_FAILURE, {
+          reason: err.message,
+          stack: err.stack,
+        });
+
+        throw err;
+      });
+  }
+
+  /**
+   * Disables static meeting link for given conversation url
+   * @param {String} conversationUrl conversationUrl that's required to disable static meeting link if it exists
+   * @returns {Promise} returns a Promise
+   * @public
+   * @memberof MeetingInfo
+   */
+  async disableStaticMeetingLink(conversationUrl: string) {
+    if (!this.webex.meetings.preferredWebexSite) {
+      throw Error('No preferred webex site found');
+    }
+
+    const body = {
+      spaceUrl: conversationUrl,
+    };
+
+    const uri = this.webex.meetings.preferredWebexSite
+      ? `https://${this.webex.meetings.preferredWebexSite}/wbxappapi/v2/meetings/spaceInstant/deletePersistentMeeting`
+      : '';
+
+    return this.webex
+      .request({
+        method: HTTP_VERBS.POST,
+        uri,
+        body,
+      })
+      .then((requestResult) => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DISABLE_STATIC_MEETING_LINK_SUCCESS);
+
+        return requestResult;
+      })
+      .catch((err) => {
+        if (err?.statusCode === 403) {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_IS_IN_PROGRESS_ERROR, {
+            reason: err.message,
+            stack: err.stack,
+          });
+
+          throw new MeetingInfoV2MeetingIsInProgressError(err.body?.code, err.body?.message);
+        }
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.DISABLE_STATIC_MEETING_LINK_FAILURE, {
+          reason: err.message,
+          stack: err.stack,
+        });
+
+        throw err;
+      });
+  }
+
   /**
    * Fetches meeting info from the server
    * @param {String} destination one of many different types of destinations to look up info for

package/src/meetings/index.ts

@@ -854,7 +854,7 @@ export default class Meetings extends WebexPlugin {
       this.executeRegistrationStep(
         () =>
           this.startReachability('registration').catch((error) => {
-            LoggerProxy.logger.error(`Meetings:index#register --> GDM error, ${error.message}`);
+            LoggerProxy.logger.warn(`Meetings:index#register --> startReachability failed:`, error);
           }),
         'startReachability'
       ),
@@ -935,6 +935,21 @@ export default class Meetings extends WebexPlugin {
         .disconnect()
         // @ts-ignore
         .then(() => this.webex.internal.device.unregister())
+        .catch((error) => {
+          // If error status code is 404, continue the chain
+          if (error.statusCode === 404) {
+            LoggerProxy.logger.info(
+              'Meetings:index#unregister --> 404 error during device unregister, proceeding normally'
+            );
+
+            return; // returning undefined allows the chain to continue
+          }
+          // For any other status code, break the chain by rethrowing
+          LoggerProxy.logger.error(
+            `Meetings:index#unregister --> Failed to unregister device: ${error.message}`
+          );
+          throw error; // rethrow to break the promise chain
+        })
         .then(() => {
           Trigger.trigger(
             this,
@@ -1217,6 +1232,29 @@ export default class Meetings extends WebexPlugin {
     );
   }
 
+  /**
+   * Fetch static meeting link for given conversation url.
+   *
+   * @param {string} conversationUrl - url for conversation
+   * @returns {Promise}
+   * @public
+   * @memberof Meetings
+   */
+  public fetchStaticMeetingLink(conversationUrl: string): Promise<any> {
+    return (
+      this.meetingInfo
+        .fetchStaticMeetingLink(conversationUrl)
+        // Catch a failure to fetch static meeting link.
+        .catch((error) => {
+          LoggerProxy.logger.error(
+            `Meetings:index#fetchStaticMeetingLink --> ERROR, unable to fetch persistent meeting link: ${error.message}`
+          );
+
+          return Promise.reject(error);
+        })
+    );
+  }
+
   /**
    * Create a meeting or return an existing meeting.
    *
@@ -1369,6 +1407,54 @@ export default class Meetings extends WebexPlugin {
     );
   }
 
+  /**
+   * Enable static meeting links for given conversation url.
+   *
+   *
+   * @param {string} conversationUrl - url for conversation
+   * @returns {Promise}
+   * @public
+   * @memberof Meetings
+   */
+  public enableStaticMeetingLink(conversationUrl: string): Promise<any> {
+    return (
+      this.meetingInfo
+        .enableStaticMeetingLink(conversationUrl)
+        // Catch a failure to enable static meeting link.
+        .catch((error) => {
+          LoggerProxy.logger.error(
+            `Meetings:index#enableStaticMeetingLink --> ERROR, unable to enable static meeting link: ${error.message}`
+          );
+
+          return Promise.reject(error);
+        })
+    );
+  }
+
+  /**
+   * Disable static meeting links for given conversation url.
+   *
+   *
+   * @param {string} conversationUrl - url for conversation
+   * @returns {Promise}
+   * @public
+   * @memberof Meetings
+   */
+  public disableStaticMeetingLink(conversationUrl: string): Promise<any> {
+    return (
+      this.meetingInfo
+        .disableStaticMeetingLink(conversationUrl)
+        // Catch a failure to disable static meeting link.
+        .catch((error) => {
+          LoggerProxy.logger.error(
+            `Meetings:index#disableStaticMeetingLink --> ERROR, unable to disable static meeting link: ${error.message}`
+          );
+
+          return Promise.reject(error);
+        })
+    );
+  }
+
   /**
    * Create meeting
    *

package/src/meetings/util.ts

@@ -99,6 +99,24 @@ MeetingsUtil.getMediaServer = (sdp) => {
   return mediaServer;
 };
 
+MeetingsUtil.getMediaServerIp = (sdp) => {
+  let mediaServerIp;
+
+  // Attempt to collect the media server from the roap message.
+  try {
+    mediaServerIp = sdp
+      .split('\r\n')
+      .find((line) => line.startsWith('o='))
+      .match(/o=\S+ \d+ \d+ IN IP4 ([\d.]+)/)?.[1]
+      .toLowerCase()
+      .trim();
+  } catch {
+    mediaServerIp = undefined;
+  }
+
+  return mediaServerIp;
+};
+
 MeetingsUtil.checkForCorrelationId = (deviceUrl, locus) => {
   let devices = [];