@webex/plugin-meetings 2.59.8-next.2 → 2.60.0-next.1

package/src/meeting-info/index.ts

@@ -70,10 +70,41 @@ export default class MeetingInfo {
    * @private
    * @memberof MeetingInfo
    */
-  private requestFetchInfo(options: object) {
+  private requestFetchInfo(options: any) {
+    const {meetingId, sendCAevents} = options;
+    if (meetingId && sendCAevents) {
+      this.webex.internal.newMetrics.submitInternalEvent({
+        name: 'internal.client.meetinginfo.request',
+      });
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.meetinginfo.request',
+        options: {
+          meetingId,
+        },
+      });
+    }
+
     return this.meetingInfoRequest
       .fetchMeetingInfo(options)
       .then((info) => {
+        if (meetingId && sendCAevents) {
+          this.webex.internal.newMetrics.submitInternalEvent({
+            name: 'internal.client.meetinginfo.response',
+          });
+          this.webex.internal.newMetrics.submitClientEvent({
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: info?.url,
+              },
+            },
+            options: {
+              meetingId,
+              webexConferenceIdStr: info?.body?.confIdStr || info?.body?.confID,
+              globalMeetingId: info?.body?.meetingId,
+            },
+          });
+        }
         if (info && info.body) {
           this.setMeetingInfo(info.body.sipMeetingUri || info.body.meetingLink, info.body);
         }
@@ -84,6 +115,23 @@ export default class MeetingInfo {
         LoggerProxy.logger.error(
           `Meeting-info:index#requestFetchInfo -->  ${error} fetch meetingInfo`
         );
+        if (meetingId && sendCAevents) {
+          this.webex.internal.newMetrics.submitInternalEvent({
+            name: 'internal.client.meetinginfo.response',
+          });
+          this.webex.internal.newMetrics.submitClientEvent({
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: error?.url,
+              },
+            },
+            options: {
+              meetingId,
+              rawError: error,
+            },
+          });
+        }
 
         return Promise.reject(error);
       });
@@ -105,29 +153,54 @@ export default class MeetingInfo {
     });
   }
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * Fetches meeting info from the server
    * @param {String} destination one of many different types of destinations to look up info for
    * @param {String} [type] to match up with the destination value
+   * @param {String} [password] meeting password
+   * @param {Object} [captchaInfo] captcha code and id
+   * @param {String} [installedOrgID]
+   * @param {String} [locusId]
+   * @param {Object} [extraParams]
+   * @param {Boolean} [options] meeting Id and whether Call Analyzer events should be sent
    * @returns {Promise} returns a meeting info object
    * @public
    * @memberof MeetingInfo
    */
-  public fetchMeetingInfo(destination: string, type: string = null) {
+  public fetchMeetingInfo(
+    destination: string,
+    type: string = null,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    password: string = null,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    captchaInfo: {
+      code: string;
+      id: string;
+    } = null,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    installedOrgID = null,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    locusId = null,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    extraParams: object = {},
+    options: {meetingId?: string; sendCAevents?: boolean} = {}
+  ) {
     if (type === _PERSONAL_ROOM_ && !destination) {
       destination = this.webex.internal.device.userId;
     }
 
     return this.fetchInfoOptions(MeetingInfoUtil.extractDestination(destination, type), type).then(
-      (options) =>
+      (infoOptions) =>
         // fetch meeting info
-        this.requestFetchInfo(options).catch((error) => {
+        this.requestFetchInfo({...infoOptions, ...options}).catch((error) => {
           // if it failed the first time as meeting link
-          if (options.type === _MEETING_LINK_) {
+          if (infoOptions.type === _MEETING_LINK_) {
             // convert the meeting link to sip URI and retry
-            return this.requestFetchInfo(
-              this.fetchInfoOptions(MeetingInfoUtil.convertLinkToSip(destination), _SIP_URI_)
-            );
+            return this.requestFetchInfo({
+              ...this.fetchInfoOptions(MeetingInfoUtil.convertLinkToSip(destination), _SIP_URI_),
+              ...options,
+            });
           }
 
           return Promise.reject(error);

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

@@ -1,4 +1,10 @@
-import {HTTP_VERBS, _CONVERSATION_URL_, WBXAPPAPI_SERVICE} from '../constants';
+import lodash from 'lodash';
+import {
+  HTTP_VERBS,
+  _CONVERSATION_URL_,
+  WBXAPPAPI_SERVICE,
+  DEFAULT_MEETING_INFO_REQUEST_BODY,
+} from '../constants';
 import Metrics from '../metrics';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 
@@ -11,7 +17,7 @@ const CAPTCHA_ERROR_DEFAULT_MESSAGE =
 const ADHOC_MEETING_DEFAULT_ERROR =
   'Failed starting the adhoc meeting, Please contact support team ';
 const CAPTCHA_ERROR_REQUIRES_PASSWORD_CODES = [423005, 423006];
-
+const POLICY_ERROR_CODES = [403049, 403104, 403103, 403048, 403102, 403101];
 /**
  * Error to indicate that wbxappapi requires a password
  */
@@ -63,6 +69,30 @@ export class MeetingInfoV2AdhocMeetingError extends Error {
   }
 }
 
+/**
+ * Error preventing join because of a meeting policy
+ */
+export class MeetingInfoV2PolicyError extends Error {
+  meetingInfo: object;
+  sdkMessage: string;
+  wbxAppApiCode: number;
+  /**
+   *
+   * @constructor
+   * @param {Number} [wbxAppApiErrorCode]
+   * @param {Object} [meetingInfo]
+   * @param {String} [message]
+   */
+  constructor(wbxAppApiErrorCode?: number, meetingInfo?: object, message?: string) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2AdhocMeetingError';
+    this.sdkMessage = message;
+    this.stack = new Error().stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+    this.meetingInfo = meetingInfo;
+  }
+}
+
 /**
  * Error to indicate that preferred webex site not present to start adhoc meeting
  */
@@ -124,14 +154,38 @@ export default class MeetingInfoV2 {
     });
   }
 
+  /**
+   * Raises a MeetingInfoV2PolicyError for policy error codes
+   * @param {any} err the error from the request
+   * @returns {void}
+   */
+  handlePolicyError = (err) => {
+    if (!err.body) {
+      return;
+    }
+
+    if (POLICY_ERROR_CODES.includes(err.body?.code)) {
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.MEETING_INFO_POLICY_ERROR, {
+        code: err.body?.code,
+      });
+
+      throw new MeetingInfoV2PolicyError(
+        err.body?.code,
+        err.body?.data?.meetingInfo,
+        err.body?.message
+      );
+    }
+  };
+
   /**
    * 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) {
+  async createAdhocSpaceMeeting(conversationUrl: string, installedOrgID?: string) {
     if (!this.webex.meetings.preferredWebexSite) {
       throw Error('No preferred webex site found');
     }
@@ -159,21 +213,27 @@ export default class MeetingInfoV2 {
           keyUrl: conversation.encryptionKeyUrl,
           kroUrl: conversation.kmsResourceObjectUrl,
           invitees: getInvitees(conversation.participants?.items),
+          installedOrgID,
         };
 
         const uri = this.webex.meetings.preferredWebexSite
           ? `https://${this.webex.meetings.preferredWebexSite}/wbxappapi/v2/meetings/spaceInstant`
           : '';
 
-        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADHOC_MEETING_SUCCESS);
-
         return this.webex.request({
           method: HTTP_VERBS.POST,
           uri,
           body,
         });
       })
+      .then((requestResult) => {
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADHOC_MEETING_SUCCESS);
+
+        return requestResult;
+      })
       .catch((err) => {
+        this.handlePolicyError(err);
+
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.ADHOC_MEETING_FAILURE, {
           reason: err.message,
           stack: err.stack,
@@ -190,6 +250,10 @@ export default class MeetingInfoV2 {
    * @param {Object} captchaInfo
    * @param {String} captchaInfo.code
    * @param {String} captchaInfo.id
+   * @param {String} installedOrgID org ID of user's machine
+   * @param {String} locusId
+   * @param {Object} extraParams
+   * @param {Object} options
    * @returns {Promise} returns a meeting info object
    * @public
    * @memberof MeetingInfo
@@ -201,8 +265,14 @@ export default class MeetingInfoV2 {
     captchaInfo: {
       code: string;
       id: string;
-    } = null
+    } = null,
+    installedOrgID = null,
+    locusId = null,
+    extraParams: object = {},
+    options: {meetingId?: string; sendCAevents?: boolean} = {}
   ) {
+    const {meetingId, sendCAevents} = options;
+
     const destinationType = await MeetingInfoUtil.getDestinationType({
       destination,
       type,
@@ -214,12 +284,35 @@ export default class MeetingInfoV2 {
       this.webex.config.meetings.experimental.enableAdhocMeetings &&
       this.webex.meetings.preferredWebexSite
     ) {
-      return this.createAdhocSpaceMeeting(destinationType.destination);
+      return this.createAdhocSpaceMeeting(destinationType.destination, installedOrgID);
     }
 
-    const body = await MeetingInfoUtil.getRequestBody({...destinationType, password, captchaInfo});
+    const body = await MeetingInfoUtil.getRequestBody({
+      ...destinationType,
+      password,
+      captchaInfo,
+      installedOrgID,
+      locusId,
+      extraParams,
+    });
+
+    // If the body only contains the default properties, we don't have enough to
+    // fetch the meeting info so don't bother trying.
+    if (
+      !lodash.difference(Object.keys(body), Object.keys(DEFAULT_MEETING_INFO_REQUEST_BODY)).length
+    ) {
+      const err = new Error('Not enough information to fetch meeting info');
+      Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_FAILURE, {
+        reason: err.message,
+        destinationType: destinationType?.type,
+        webExMeetingId: destinationType?.info?.webExMeetingId,
+        sipUri: destinationType?.info?.sipUri,
+      });
 
-    const options: any = {
+      throw err;
+    }
+
+    const requestOptions: any = {
       method: HTTP_VERBS.POST,
       body,
     };
@@ -227,21 +320,74 @@ export default class MeetingInfoV2 {
     const directURI = await MeetingInfoUtil.getDirectMeetingInfoURI(destinationType);
 
     if (directURI) {
-      options.uri = directURI;
+      requestOptions.uri = directURI;
     } else {
-      options.service = WBXAPPAPI_SERVICE;
-      options.resource = 'meetingInfo';
+      requestOptions.service = WBXAPPAPI_SERVICE;
+      requestOptions.resource = 'meetingInfo';
+    }
+
+    if (meetingId && sendCAevents) {
+      this.webex.internal.newMetrics.submitInternalEvent({
+        name: 'internal.client.meetinginfo.request',
+      });
+
+      this.webex.internal.newMetrics.submitClientEvent({
+        name: 'client.meetinginfo.request',
+        options: {
+          meetingId,
+        },
+      });
     }
 
     return this.webex
-      .request(options)
+      .request(requestOptions)
       .then((response) => {
+        if (meetingId && sendCAevents) {
+          this.webex.internal.newMetrics.submitInternalEvent({
+            name: 'internal.client.meetinginfo.response',
+          });
+
+          this.webex.internal.newMetrics.submitClientEvent({
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: response?.url,
+              },
+            },
+            options: {
+              meetingId,
+              webexConferenceIdStr: response?.body?.confIdStr || response?.body?.confID,
+              globalMeetingId: response?.body?.meetingId,
+            },
+          });
+        }
         Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_SUCCESS);
 
         return response;
       })
       .catch((err) => {
+        if (meetingId && sendCAevents) {
+          this.webex.internal.newMetrics.submitInternalEvent({
+            name: 'internal.client.meetinginfo.response',
+          });
+
+          this.webex.internal.newMetrics.submitClientEvent({
+            name: 'client.meetinginfo.response',
+            payload: {
+              identifiers: {
+                meetingLookupUrl: err?.url,
+              },
+            },
+            options: {
+              meetingId,
+              rawError: err,
+            },
+          });
+        }
+
         if (err?.statusCode === 403) {
+          this.handlePolicyError(err);
+
           Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.VERIFY_PASSWORD_ERROR, {
             reason: err.message,
             stack: err.stack,

package/src/meeting-info/util.ts

@@ -236,7 +236,7 @@ MeetingInfoUtil.generateOptions = async (from) => {
     }
   } else {
     throw new ParameterError(
-      'MeetingInfo is fetched with meeting link, sip uri, phone number, hydra room id, hydra people id, or a conversation url.'
+      'MeetingInfo is fetched with the meeting link, SIP URI, phone number, Hydra people ID, or a conversation URL.'
     );
   }
 

package/src/meeting-info/utilv2.ts

@@ -19,14 +19,20 @@ import {
   JOIN,
   MEET,
   MEET_M,
+  MEET_CISCO,
+  MEET_CO,
   HTTPS_PROTOCOL,
   UUID_REG,
   VALID_EMAIL_ADDRESS,
+  DEFAULT_MEETING_INFO_REQUEST_BODY,
 } from '../constants';
 import ParameterError from '../common/errors/parameter';
 import LoggerProxy from '../common/logs/logger-proxy';
+import {SpaceIDDeprecatedError} from '../common/errors/webex-errors';
 
 const MeetingInfoUtil: any = {};
+const meetingInfoError =
+  'MeetingInfo is fetched with the meeting link, SIP URI, phone number, Hydra people ID, or a conversation URL.';
 
 MeetingInfoUtil.getParsedUrl = (link) => {
   try {
@@ -62,6 +68,8 @@ MeetingInfoUtil.isMeetingLink = (value: string) => {
     parsedUrl.pathname &&
     (parsedUrl.pathname.includes(`/${MEET}`) ||
       parsedUrl.pathname.includes(`/${MEET_M}`) ||
+      parsedUrl.pathname.includes(`/${MEET_CISCO}`) ||
+      parsedUrl.pathname.includes(`/${MEET_CO}`) ||
       parsedUrl.pathname.includes(`/${JOIN}`));
 
   return hostNameBool && pathNameBool;
@@ -215,12 +223,8 @@ MeetingInfoUtil.getDestinationType = async (from) => {
       throw e;
     }
   } else {
-    LoggerProxy.logger.warn(
-      "Meeting-info:util#getDestinationType --> ('MeetingInfo is fetched with meeting link, sip uri, phone number, hydra room id, hydra people id, or a conversation url."
-    );
-    throw new ParameterError(
-      'MeetingInfo is fetched with meeting link, sip uri, phone number, hydra room id, hydra people id, or a conversation url.'
-    );
+    LoggerProxy.logger.warn(`Meeting-info:util#getDestinationType --> ${meetingInfoError}`);
+    throw new ParameterError(`${meetingInfoError}`);
   }
 
   return Promise.resolve(options);
@@ -230,14 +234,15 @@ MeetingInfoUtil.getDestinationType = async (from) => {
  * Helper function to build up a correct locus url depending on the value passed
  * @param {Object} options type and value to fetch meeting info
  * @param {String} options.type One of [SIP_URI, PERSONAL_ROOM, MEETING_ID, CONVERSATION_URL, LOCUS_ID, MEETING_LINK]
+ * @param {String} options.installedOrgID org ID of user's machine
  * @param {Object} options.destination ?? value.value
  * @returns {Object} returns an object with {resource, method}
  */
 MeetingInfoUtil.getRequestBody = (options: {type: string; destination: object} | any) => {
-  const {type, destination, password, captchaInfo} = options;
+  const {type, destination, password, captchaInfo, installedOrgID, locusId, extraParams} = options;
   const body: any = {
-    supportHostKey: true,
-    supportCountryList: true,
+    ...DEFAULT_MEETING_INFO_REQUEST_BODY,
+    ...extraParams,
   };
 
   switch (type) {
@@ -281,6 +286,14 @@ MeetingInfoUtil.getRequestBody = (options: {type: string; destination: object} |
     body.captchaVerifyCode = captchaInfo.code;
   }
 
+  if (installedOrgID) {
+    body.installedOrgID = installedOrgID;
+  }
+
+  if (locusId) {
+    body.locusId = locusId;
+  }
+
   return body;
 };
 

package/src/meetings/collection.ts

@@ -40,4 +40,24 @@ export default class MeetingCollection extends Collection {
 
     return null;
   }
+
+  /**
+   * get a specific meeting searching for key
+   * @param {String} breakoutUrl
+   * @returns {Meeting} if found, else returns null
+   * @public
+   * @memberof MeetingCollection
+   */
+  public getActiveBreakoutLocus(breakoutUrl: string) {
+    if (breakoutUrl) {
+      // @ts-ignore
+      return find(
+        // @ts-ignore
+        this.meetings,
+        (meeting) => meeting.breakouts?.url === breakoutUrl && meeting.breakouts?.isActiveBreakout
+      );
+    }
+
+    return null;
+  }
 }