@webex/plugin-meetings 3.8.0-next.6 → 3.8.0-next.60

package/src/meeting/locusMediaRequest.ts

@@ -221,14 +221,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;
     }
 
@@ -269,16 +261,6 @@ export class LocusMediaRequest extends WebexPlugin {
           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) => {

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,17 @@ 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],
+
+  canMoveToLobby: (displayHints) => displayHints.includes(DISPLAY_HINTS.MOVE_TO_LOBBY),
 
   /**
    * Adds the current locus sequence information to a request body

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

@@ -807,6 +807,26 @@ export default class Meetings extends WebexPlugin {
     }
   }
 
+  /**
+   * API to toggle usage of audio main DTX, needs to be called before webex.meetings.register()
+   *
+   * @param {Boolean} newValue
+   * @private
+   * @memberof Meetings
+   * @returns {undefined}
+   */
+  private _toggleDisableAudioMainDtx(newValue: boolean) {
+    if (typeof newValue !== 'boolean') {
+      return;
+    }
+
+    // @ts-ignore
+    if (this.config.experimental.disableAudioMainDtx !== newValue) {
+      // @ts-ignore
+      this.config.experimental.disableAudioMainDtx = newValue;
+    }
+  }
+
   /**
    * Executes a registration step and updates the registration status.
    * @param {Function} step - The registration step to execute.
@@ -854,7 +874,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 +955,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 +1252,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 +1427,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 = [];
 

package/src/member/index.ts

@@ -23,6 +23,7 @@ export default class Member {
   isInMeeting: any;
   isModerator: any;
   isModeratorAssignmentProhibited: any;
+  isPresenterAssignmentProhibited: any;
   isMutable: any;
   isNotAdmitted: any;
   isRecording: any;
@@ -257,6 +258,14 @@ export default class Member {
      */
     this.isModeratorAssignmentProhibited = null;
 
+    /**
+     * @instance
+     * @type {Boolean}
+     * @public
+     * @memberof Member
+     */
+    this.isPresenterAssignmentProhibited = null;
+
     /**
      * @instance
      * @type {IExternalRoles}
@@ -309,6 +318,8 @@ export default class Member {
       this.isModerator = MemberUtil.isModerator(participant);
       this.isModeratorAssignmentProhibited =
         MemberUtil.isModeratorAssignmentProhibited(participant);
+      this.isPresenterAssignmentProhibited =
+        MemberUtil.isPresenterAssignmentProhibited(participant);
       this.processStatus(participant);
       this.processRoles(participant as ParticipantWithRoles);
       // must be done last

package/src/member/util.ts

@@ -127,6 +127,9 @@ MemberUtil.isDevice = (participant: any) => participant && participant.type ===
 MemberUtil.isModeratorAssignmentProhibited = (participant) =>
   participant && participant.moderatorAssignmentNotAllowed;
 
+MemberUtil.isPresenterAssignmentProhibited = (participant) =>
+  participant && participant.presenterAssignmentNotAllowed;
+
 /**
  * checks to see if the participant id is the same as the passed id
  * there are multiple ids that can be used

package/src/members/index.ts

@@ -886,6 +886,31 @@ export default class Members extends StatelessWebexPlugin {
     });
   }
 
+  /**
+   * Moves a meeting member into the lobby.
+   * @param {String} memberId -- The ID of the member to move.
+   * @returns {Promise} -- Resolves with the lobby‐move response.
+   * @public
+   * @memberof Members
+   */
+  public moveToLobby(memberId: string) {
+    if (!this.locusUrl) {
+      return Promise.reject(
+        new ParameterError(
+          'The associated locus url for this meetings members object must be defined.'
+        )
+      );
+    }
+    if (!memberId) {
+      return Promise.reject(
+        new ParameterError('The member id must be defined to move the member to lobby.')
+      );
+    }
+    const body = MembersUtil.getMoveMemberToLobbyRequestBody(memberId);
+
+    return this.membersRequest.moveToLobbyMember({locusUrl: this.locusUrl, memberId}, body);
+  }
+
   /**
    * Raise or lower the hand of a member in a meeting
    * @param {String} memberId