@webex/plugin-meetings 3.0.0-beta.2 → 3.0.0-beta.200

package/src/meeting-info/index.ts

@@ -0,0 +1,183 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {_MEETING_LINK_, _SIP_URI_, _PERSONAL_ROOM_} from '../constants';
+import LoggerProxy from '../common/logs/logger-proxy';
+
+import MeetingInfoCollection from './collection';
+import MeetingInfoRequest from './request';
+import MeetingInfoUtil from './util';
+
+/**
+ * @class MeetingInfo
+ */
+export default class MeetingInfo {
+  meetingInfoCollection: any;
+  meetingInfoRequest: any;
+  webex: any;
+
+  /**
+   *
+   * @param {WebexSDK} webex
+   */
+  constructor(webex: any) {
+    this.webex = webex;
+
+    /**
+     * The meeting info request server interface
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof MeetingInfo
+     */
+    this.meetingInfoRequest = new MeetingInfoRequest(this.webex);
+    /**
+     * The meeting information collection interface
+     * @instance
+     * @type {Object}
+     * @private
+     * @memberof MeetingInfo
+     */
+    this.meetingInfoCollection = new MeetingInfoCollection();
+  }
+
+  /**
+   * @param {string} id
+   * @returns {object}
+   * @public
+   * @memberof MeetingInfo
+   */
+  public getMeetingInfo(id: string) {
+    return this.meetingInfoCollection.get(id);
+  }
+
+  /**
+   * @param {string} id
+   * @param {object} info
+   * @returns {null}
+   * @public
+   * @memberof MeetingInfo
+   */
+  public setMeetingInfo(id: string, info: object) {
+    this.meetingInfoCollection.set(id, info);
+  }
+
+  /**
+   * Helper to make the actual MeetingInfo request and set the meetingInfo if successful, else reject
+   * @param {Object} options
+   * @returns {Promise}
+   * @private
+   * @memberof MeetingInfo
+   */
+  private requestFetchInfo(options: any) {
+    const {meetingId} = options;
+    if (meetingId) {
+      this.webex.internal.newMetrics.submitInternalEvent({
+        name: 'internal.client.meetinginfo.request',
+      });
+    }
+
+    return this.meetingInfoRequest
+      .fetchMeetingInfo(options)
+      .then((info) => {
+        if (meetingId) {
+          this.webex.internal.newMetrics.submitInternalEvent({
+            name: 'internal.client.meetinginfo.response',
+          });
+        }
+        if (info && info.body) {
+          this.setMeetingInfo(info.body.sipMeetingUri || info.body.meetingLink, info.body);
+        }
+
+        return info;
+      })
+      .catch((error) => {
+        LoggerProxy.logger.error(
+          `Meeting-info:index#requestFetchInfo -->  ${error} fetch meetingInfo`
+        );
+        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);
+      });
+  }
+
+  /**
+   * Helper to generate the options for the MeetingInfo request
+   * @param {String} destination
+   * @param {String} type
+   * @returns {Promise}
+   * @private
+   * @memberof MeetingInfo
+   */
+  private fetchInfoOptions(destination: string, type: string) {
+    return MeetingInfoUtil.generateOptions({
+      destination,
+      type,
+      webex: this.webex,
+    });
+  }
+
+  // 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
+   * @returns {Promise} returns a meeting info object
+   * @public
+   * @memberof MeetingInfo
+   */
+  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} = {}
+  ) {
+    if (type === _PERSONAL_ROOM_ && !destination) {
+      destination = this.webex.internal.device.userId;
+    }
+
+    return this.fetchInfoOptions(MeetingInfoUtil.extractDestination(destination, type), type).then(
+      (infoOptions) =>
+        // fetch meeting info
+        this.requestFetchInfo({...infoOptions, meetingId: options.meetingId}).catch((error) => {
+          // if it failed the first time as 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_),
+              meetingId: options.meetingId,
+            });
+          }
+
+          return Promise.reject(error);
+        })
+    );
+  }
+}

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

@@ -0,0 +1,407 @@
+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';
+
+import MeetingInfoUtil from './utilv2';
+
+const PASSWORD_ERROR_DEFAULT_MESSAGE =
+  'Password required. Call fetchMeetingInfo() with password argument';
+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 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
+ */
+export class MeetingInfoV2PasswordError extends Error {
+  meetingInfo: any;
+  sdkMessage: any;
+  wbxAppApiCode: any;
+  body: any;
+
+  /**
+   *
+   * @constructor
+   * @param {Number} [wbxAppApiErrorCode]
+   * @param {Object} [meetingInfo]
+   * @param {String} [message]
+   */
+  constructor(
+    wbxAppApiErrorCode?: number,
+    meetingInfo?: object,
+    message: string = PASSWORD_ERROR_DEFAULT_MESSAGE
+  ) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2PasswordError';
+    this.sdkMessage = message;
+    this.stack = new Error().stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+    this.meetingInfo = meetingInfo;
+  }
+}
+
+/**
+ * Error generating a adhoc space meeting
+ */
+export class MeetingInfoV2AdhocMeetingError extends Error {
+  sdkMessage: any;
+  wbxAppApiCode: any;
+  /**
+   *
+   * @constructor
+   * @param {Number} [wbxAppApiErrorCode]
+   * @param {String} [message]
+   */
+  constructor(wbxAppApiErrorCode?: number, message: string = ADHOC_MEETING_DEFAULT_ERROR) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2AdhocMeetingError';
+    this.sdkMessage = message;
+    this.stack = new Error().stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+  }
+}
+
+/**
+ * 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
+ */
+export class MeetingInfoV2CaptchaError extends Error {
+  captchaInfo: any;
+  isPasswordRequired: any;
+  sdkMessage: any;
+  wbxAppApiCode: any;
+  body: any;
+  /**
+   *
+   * @constructor
+   * @param {Number} [wbxAppApiErrorCode]
+   * @param {Object} [captchaInfo]
+   * @param {String} [message]
+   */
+  constructor(
+    wbxAppApiErrorCode?: number,
+    captchaInfo?: object,
+    message: string = CAPTCHA_ERROR_DEFAULT_MESSAGE
+  ) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2PasswordError';
+    this.sdkMessage = message;
+    this.stack = new Error().stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+    this.isPasswordRequired = CAPTCHA_ERROR_REQUIRES_PASSWORD_CODES.includes(wbxAppApiErrorCode);
+    this.captchaInfo = captchaInfo;
+  }
+}
+
+/**
+ * @class MeetingInfo
+ */
+export default class MeetingInfoV2 {
+  webex: any;
+
+  /**
+   *
+   * @param {WebexSDK} webex
+   */
+  constructor(webex) {
+    this.webex = webex;
+  }
+
+  /**
+   * converts hydra id into conversation url and persons Id
+   * @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
+   * @returns {Promise} destination and type
+   * @public
+   * @memberof MeetingInfo
+   */
+  fetchInfoOptions(destination: string, type: string = null) {
+    return MeetingInfoUtil.getDestinationType({
+      destination,
+      type,
+      webex: this.webex,
+    });
+  }
+
+  /**
+   * 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, installedOrgID?: string) {
+    if (!this.webex.meetings.preferredWebexSite) {
+      throw Error('No preferred webex site found');
+    }
+    const getInvitees = (particpants = []) => {
+      const invitees = [];
+
+      if (particpants) {
+        particpants.forEach((participant) => {
+          invitees.push({
+            email: participant.emailAddress,
+            ciUserUuid: participant.entryUUID,
+          });
+        });
+      }
+
+      return invitees;
+    };
+
+    return this.webex.internal.conversation
+      .get({url: conversationUrl}, {includeParticipants: true, disableTransform: true})
+      .then((conversation) => {
+        const body: {
+          title: string;
+          spaceUrl: string;
+          keyUrl: string;
+          kroUrl: string;
+          invitees: any[];
+          installedOrgID?: string;
+        } = {
+          title: conversation.displayName,
+          spaceUrl: conversation.url,
+          keyUrl: conversation.encryptionKeyUrl,
+          kroUrl: conversation.kmsResourceObjectUrl,
+          invitees: getInvitees(conversation.participants?.items),
+        };
+
+        if (installedOrgID) {
+          body.installedOrgID = installedOrgID;
+        }
+
+        const uri = this.webex.meetings.preferredWebexSite
+          ? `https://${this.webex.meetings.preferredWebexSite}/wbxappapi/v2/meetings/spaceInstant`
+          : '';
+
+        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,
+        });
+        throw new MeetingInfoV2AdhocMeetingError(err.body?.code, err.body?.message);
+      });
+  }
+
+  /**
+   * 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
+   * @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
+   */
+  async fetchMeetingInfo(
+    destination: string,
+    type: string = null,
+    password: string = null,
+    captchaInfo: {
+      code: string;
+      id: string;
+    } = null,
+    installedOrgID = null,
+    locusId = null,
+    extraParams: object = {},
+    options: {meetingId?: string} = {}
+  ) {
+    const {meetingId} = options;
+
+    const destinationType = await MeetingInfoUtil.getDestinationType({
+      destination,
+      type,
+      webex: this.webex,
+    });
+
+    if (
+      destinationType.type === _CONVERSATION_URL_ &&
+      this.webex.config.meetings.experimental.enableAdhocMeetings &&
+      this.webex.meetings.preferredWebexSite
+    ) {
+      return this.createAdhocSpaceMeeting(destinationType.destination, installedOrgID);
+    }
+
+    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,
+      });
+
+      throw err;
+    }
+
+    const requestOptions: any = {
+      method: HTTP_VERBS.POST,
+      body,
+    };
+
+    const directURI = await MeetingInfoUtil.getDirectMeetingInfoURI(destinationType);
+
+    if (directURI) {
+      requestOptions.uri = directURI;
+    } else {
+      requestOptions.service = WBXAPPAPI_SERVICE;
+      requestOptions.resource = 'meetingInfo';
+    }
+
+    if (meetingId) {
+      this.webex.internal.newMetrics.submitInternalEvent({
+        name: 'internal.client.meetinginfo.request',
+      });
+    }
+
+    return this.webex
+      .request(requestOptions)
+      .then((response) => {
+        if (meetingId) {
+          this.webex.internal.newMetrics.submitInternalEvent({
+            name: 'internal.client.meetinginfo.response',
+          });
+        }
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_SUCCESS);
+
+        return response;
+      })
+      .catch((err) => {
+        if (meetingId) {
+          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,
+          });
+
+          throw new MeetingInfoV2PasswordError(err.body?.code, err.body?.data?.meetingInfo);
+        }
+        if (err?.statusCode === 423) {
+          Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.VERIFY_CAPTCHA_ERROR, {
+            reason: err.message,
+            stack: err.stack,
+          });
+
+          throw new MeetingInfoV2CaptchaError(err.body?.code, {
+            captchaId: err.body.captchaID,
+            verificationImageURL: err.body.verificationImageURL,
+            verificationAudioURL: err.body.verificationAudioURL,
+            refreshURL: err.body.refreshURL,
+          });
+        }
+
+        Metrics.sendBehavioralMetric(BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_FAILURE, {
+          reason: err.message,
+          stack: err.stack,
+        });
+        throw err;
+      });
+  }
+}

package/src/meeting-info/{request.js → request.ts}

@@ -2,15 +2,18 @@ import {API} from '../constants';
 import ParameterError from '../common/errors/parameter';
 
 import MeetingInfoUtil from './util';
+
 /**
  * @class MeetingInfoRequest
  */
 export default class MeetingInfoRequest {
+  webex: any;
+
   /**
    * Meeting Info Request Constructor
    * @param {WebexSDK} webex
    */
-  constructor(webex) {
+  constructor(webex: any) {
     this.webex = webex;
   }
 
@@ -24,12 +27,19 @@ export default class MeetingInfoRequest {
    * @throws {Error} if the options are not valid and complete
    * @memberof MeetingInfoRequest
    */
-  fetchMeetingInfo(options) {
+  fetchMeetingInfo(options: any) {
     if (!options || !options.type || !options.destination) {
-      throw new ParameterError('MeetingInfo should be fetched with a type and destination specified, see list of valid types and their corresponding values in constants');
+      throw new ParameterError(
+        'MeetingInfo should be fetched with a type and destination specified, see list of valid types and their corresponding values in constants'
+      );
     }
     const resourceUrl = MeetingInfoUtil.getResourceUrl(options.type, options.destination);
-    const requestParams = MeetingInfoUtil.getRequestParams(resourceUrl, options.type, options.destination, API.LOCUS);
+    const requestParams = MeetingInfoUtil.getRequestParams(
+      resourceUrl,
+      options.type,
+      options.destination,
+      API.LOCUS
+    );
 
     return this.webex.request(requestParams);
   }