@webex/plugin-meetings 1.157.0 → 1.159.0

package/src/config.js

@@ -89,7 +89,8 @@ export default {
     enableExtmap: false,
     experimental: {
       enableMediaNegotiatedEvent: false,
-      enableUnifiedMeetings: false
+      enableUnifiedMeetings: false,
+      enableAdhocMeetings: false
     }
   }
 };

package/src/index.js

@@ -10,5 +10,4 @@ registerPlugin('meetings', Meetings, {
 
 export default Meetings;
 
-// eslint-disable-next-line object-curly-spacing
 export * as CONSTANTS from './constants';

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

@@ -1,10 +1,11 @@
 
-import {HTTP_VERBS} from '../constants';
+import {HTTP_VERBS, _CONVERSATION_URL_} from '../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 ';
 
 /**
  * Error to indicate that wbxappapi requires a password
@@ -28,7 +29,27 @@ export class MeetingInfoV2PasswordError extends Error {
 }
 
 /**
-   * Error to indicate that wbxappapi requires a captcha
+ * Error generating a adhoc space meeting
+ */
+export class MeetingInfoV2AdhocMeetingError extends Error {
+  /**
+    *
+    * @constructor
+    * @param {Number} [wbxAppApiErrorCode]
+    * @param {String} [message]
+    */
+  constructor(wbxAppApiErrorCode, message = ADHOC_MEETING_DEFAULT_ERROR) {
+    super(`${message}, code=${wbxAppApiErrorCode}`);
+    this.name = 'MeetingInfoV2AdhocMeetingError';
+    this.sdkMessage = message;
+    this.stack = (new Error()).stack;
+    this.wbxAppApiCode = wbxAppApiErrorCode;
+  }
+}
+
+
+/**
+   * Error to indicate that preferred webex site not present to start adhoc meeting
    */
 export class MeetingInfoV2CaptchaError extends Error {
   /**
@@ -65,7 +86,7 @@ export default class MeetingInfoV2 {
      * 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} returns destination and type
+     * @returns {Promise} destination and type
      * @public
      * @memberof MeetingInfo
      */
@@ -77,6 +98,59 @@ export default class MeetingInfoV2 {
     });
   }
 
+  /**
+     * Creates adhoc space meetings for a space by fetching the conversation infomation
+     * @param {String} conversationUrl conversationUrl to start adhoc meeting on
+     * @returns {Promise} returns a meeting info object
+     * @public
+     * @memberof MeetingInfo
+     */
+  async createAdhocSpaceMeeting(conversationUrl) {
+    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: conversation.displayName,
+          spaceUrl: conversation.url,
+          keyUrl: conversation.encryptionKeyUrl,
+          kroUrl: conversation.kmsResourceObjectUrl,
+          invitees: getInvitees(conversation.participants?.items)
+        };
+
+        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
+        })
+          .catch((err) => {
+            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
@@ -95,14 +169,25 @@ export default class MeetingInfoV2 {
       type,
       webex: this.webex
     });
+
+    if (destinationType.type === _CONVERSATION_URL_ && this.webex.config.meetings.experimental.enableAdhocMeetings) {
+      return this.createAdhocSpaceMeeting(destinationType.destination);
+    }
+
     const body = await MeetingInfoUtil.getRequestBody({...destinationType, password, captchaInfo});
 
-    return this.webex.request({
+    const options = {
       method: HTTP_VERBS.POST,
       service: 'webex-appapi-service',
       resource: 'meetingInfo',
       body
-    })
+    };
+
+    const directURI = await MeetingInfoUtil.getDirectMeetingInfoURI(destinationType);
+
+    if (directURI) options.directURI = directURI;
+
+    return this.webex.request(options)
       .catch((err) => {
         if (err?.statusCode === 403) {
           throw new MeetingInfoV2PasswordError(err.body?.code, err.body?.data?.meetingInfo);

package/src/meeting-info/utilv2.js

@@ -264,4 +264,43 @@ MeetingInfoUtil.getRequestBody = (options) => {
   return body;
 };
 
+/**
+ * Helper function to parse the webex site/host from a URI string.
+ * @param {String} uri string (e.g. '10019857020@convergedats.webex.com')
+ * @returns {String} the site/host part of the URI string (e.g. 'convergedats.webex.com')
+ */
+MeetingInfoUtil.getWebexSite = (uri) => {
+  const exceptedDomains = ['meet.webex.com', 'meetup.webex.com', 'ciscospark.com'];
+  const site = uri?.match(/.+@(.+\..+\.*.)$/)?.[1];
+
+  return exceptedDomains.includes(site) ? null : site;
+};
+
+/**
+ * Helper function to return the direct URI for fetching meeting info (to avoid a redirect).
+ * @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 {Object} options.destination ?? value.value
+ * @returns {String} returns a URI string or null of there is no direct URI
+ */
+MeetingInfoUtil.getDirectMeetingInfoURI = (options) => {
+  const {
+    type, destination
+  } = options;
+
+  let preferredWebexSite = null;
+
+  switch (type) {
+    case _SIP_URI_:
+      preferredWebexSite = MeetingInfoUtil.getWebexSite(destination);
+      break;
+    case _LOCUS_ID_:
+      preferredWebexSite = destination.info?.webExSite;
+      break;
+    default:
+  }
+
+  return preferredWebexSite ? `https://${preferredWebexSite}/wbxappapi/v1/meetingInfo` : null;
+};
+
 export default MeetingInfoUtil;

package/src/meetings/index.js

@@ -3,6 +3,7 @@
 */
 
 import '@webex/internal-plugin-mercury';
+import '@webex/internal-plugin-conversation';
 import {WebexPlugin} from '@webex/webex-core';
 
 import 'webrtc-adapter';
@@ -163,6 +164,15 @@ export default class Meetings extends WebexPlugin {
        */
       this.registered = false;
 
+      /**
+       * This values indicates the preferred webex site the user will start there meeting, getsits value from {@link Meetings#register}
+       * @instance
+       * @type {String}
+       * @private
+       * @memberof Meetings
+       */
+      this.preferredWebexSite = '';
+
       /**
        * The public interface for the internal Media util files. These are helpful to expose outside the context
        * of a meeting so that a user can access media without creating a meeting instance.
@@ -176,8 +186,6 @@ export default class Meetings extends WebexPlugin {
         getSupportedDevice: Media.getSupportedDevice
       };
 
-      LoggerProxy.set(this.webex.logger);
-
       this.onReady();
       MeetingsUtil.checkH264Support({disableNotifications: true});
       Metrics.initialSetup(this.meetingCollection, this.webex);
@@ -368,6 +376,7 @@ export default class Meetings extends WebexPlugin {
     onReady() {
       this.webex.once(READY, () => {
         StaticConfig.set(this.config);
+        LoggerProxy.set(this.webex.logger);
         LoggerConfig.set(this.config.logging);
 
         /**
@@ -408,6 +417,22 @@ export default class Meetings extends WebexPlugin {
       }
     }
 
+    /**
+     * API to toggle starting adhoc meeting
+     * @param {Boolean} changeState
+     * @private
+     * @memberof Meetings
+     * @returns {undefined}
+    */
+    _toggleAdhocMeetings(changeState) {
+      if (typeof changeState !== 'boolean') {
+        return;
+      }
+      if (this.config?.experimental?.enableAdhocMeetings !== changeState) {
+        this.config.experimental.enableAdhocMeetings = changeState;
+      }
+    }
+
     /**
      * Explicitly sets up the meetings plugin by registering
      * the device, connecting to mercury, and listening for locus events.
@@ -431,6 +456,7 @@ export default class Meetings extends WebexPlugin {
       }
 
       return Promise.all([
+        this.fetchUserPreferredWebexSite(),
         this.getGeoHint(),
         this.startReachability().catch((error) => {
           LoggerProxy.logger.error(`Meetings:index#register --> GDM error, ${error.message}`);
@@ -605,12 +631,28 @@ export default class Meetings extends WebexPlugin {
       });
     }
 
+    /**
+     * Fetch user preferred webex site information
+     * This also has other infomation about the user
+     * @returns {Promise}
+     * @private
+     * @memberof Meetings
+     */
+    fetchUserPreferredWebexSite() {
+      return this.request.fetchLoginUserInformation().then((res) => {
+        this.preferredWebexSite = MeetingsUtil.parseUserPreferences(res.userPreferences);
+        console.error(this.preferredWebexSite);
+      });
+    }
+
+
     /**
      * gets the personal meeting room instance, for saved PMR values for this user
      * @returns {PersonalMeetingRoom}
      * @public
      * @memberof Meetings
      */
+
     getPersonalMeetingRoom() {
       return this.personalMeetingRoom;
     }

package/src/meetings/request.js

@@ -12,9 +12,9 @@ import {
  */
 export default class MeetingRequest extends StatelessWebexPlugin {
   /**
-     *  get all the active meetings for the user
-     * @returns {Array} return locus array
-    */
+   *  get all the active meetings for the user
+   * @returns {Array} return locus array
+  */
   getActiveMeetings() {
     return this.request({
       api: API.LOCUS,
@@ -27,13 +27,22 @@ export default class MeetingRequest extends StatelessWebexPlugin {
   }
 
   /**
-     *  fetch geoHit for the user
-     * @returns {Promise<object>} geoHintInfo
-    */
+   *  fetch geoHit for the user
+   * @returns {Promise<object>} geoHintInfo
+   */
   fetchGeoHint() {
     return this.webex.internal.services.fetchClientRegionInfo();
   }
 
+  /**
+   *  fetch login user information
+   * @returns {Promise<object>} loginUserInformation
+  */
+  fetchLoginUserInformation() {
+    return this.webex.internal.services.fetchLoginUserInformation();
+  }
+
+
   // locus federation, determines and populate locus if the responseBody has remote URLs to fetch locus details
 
   /**

package/src/meetings/util.js

@@ -64,6 +64,25 @@ MeetingsUtil.checkForCorrelationId = (deviceUrl, locus) => {
   return false;
 };
 
+MeetingsUtil.parseUserPreferences = (userPreferences) => {
+  let webexSite = null;
+
+  userPreferences.find((item) => {
+    // eslint-disable-next-line no-useless-escape
+    const regex = /"preferredWebExSite\":\"(\S+)\"/;
+    const preferredSite = item.match(regex);
+
+    if (preferredSite) {
+      webexSite = preferredSite[1];
+
+      return true;
+    }
+
+    return false;
+  });
+
+  return webexSite;
+};
 
 /**
  * Will check to see if the H.264 media codec is supported.

package/test/{unit/spec/transcription/index.js → integration/spec/transcription.js}

@@ -1,6 +1,6 @@
+import Transcription from '@webex/plugin-meetings/src/transcription';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import Transcription from '@webex/plugin-meetings/src/transcription';
 
 describe('transcription index', () => {
   let webSocketUrl, members, sessionId, token, transcription;

package/test/unit/spec/common/browser-detection.js

@@ -1,3 +1,4 @@
+import 'jsdom-global/register';
 import {assert} from '@webex/test-helper-chai';
 import BrowserDetection from
   '@webex/plugin-meetings/src/common/browser-detection';

package/test/unit/spec/locus-info/index.js

@@ -1,3 +1,4 @@
+import 'jsdom-global/register';
 import sinon from 'sinon';
 import {cloneDeep} from 'lodash';
 import {assert} from '@webex/test-helper-chai';
@@ -16,7 +17,6 @@ import {
 
 import {self, selfWithInactivity} from './selfConstant';
 
-
 describe('plugin-meetings', () => {
   describe('LocusInfo index', () => {
     const updateMeeting = () => {};

package/test/unit/spec/meeting/index.js

@@ -1,6 +1,7 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
+import 'jsdom-global/register';
 import {cloneDeep, isEqual} from 'lodash';
 import sinon from 'sinon';
 import StateMachine from 'javascript-state-machine';
@@ -37,7 +38,7 @@ import {
   EVENT_TRIGGERS,
   _SIP_URI_
 } from '@webex/plugin-meetings/src/constants';
-import {BEHAVIORAL_METRICS} from '@webex/plugin-meetings/src/metrics/constants';
+import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 
 import {
   UserNotJoinedError,
@@ -72,6 +73,43 @@ describe('plugin-meetings', () => {
   };
 
   before(() => {
+    const MediaStream = {
+      getVideoTracks: () => [{
+        applyConstraints: () => { }
+      }]
+    };
+
+    Object.defineProperty(global.window.navigator, 'mediaDevices', {
+      writable: true,
+      value: {
+        getDisplayMedia: sinon.stub().returns(Promise.resolve(MediaStream)),
+        enumerateDevices: sinon.stub().returns(Promise.resolve([
+          {
+            deviceId: '',
+            kind: 'audioinput',
+            label: '',
+            groupId: '29d9339cc77bffdd24cb69ee80f6d3200481099bcd0f29267558672de0430777',
+          },
+          {
+            deviceId: '',
+            kind: 'videoinput',
+            label: '',
+            groupId: '08d4f8200e7e4a3425ecf75b7edea9ae4acd934019f2a52217554bcc8e46604d',
+          },
+          {
+            deviceId: '',
+            kind: 'audiooutput',
+            label: '',
+            groupId: '29d9339cc77bffdd24cb69ee80f6d3200481099bcd0f29267558672de0430777',
+          }
+        ])),
+      },
+    });
+
+    Object.defineProperty(global.window, 'MediaStream', {
+      writable: true,
+      value: MediaStream
+    });
     LoggerConfig.set({verboseEvents: true, enable: false});
     LoggerProxy.set(logger);
   });
@@ -108,6 +146,9 @@ describe('plugin-meetings', () => {
           metrics: {},
           stats: {},
           experimental: {enableUnifiedMeetings: true}
+        },
+        metrics: {
+          type: ['behavioral']
         }
       }
     });
@@ -122,6 +163,7 @@ describe('plugin-meetings', () => {
     Metrics.postEvent = sinon.stub();
     Metrics.initialSetup(null, webex);
     MediaUtil.createPeerConnection = sinon.stub().returns({});
+    MediaUtil.createMediaStream = sinon.stub().returns(true);
 
     uuid1 = uuid.v4();
     uuid2 = uuid.v4();
@@ -2530,7 +2572,6 @@ describe('plugin-meetings', () => {
           sandbox.stub(MeetingUtil, 'getTrack').returns({audioTrack: null, videoTrack: fakeTrack});
           sandbox.stub(meeting.mediaProperties, 'setMediaSettings');
           sandbox.stub(meeting.mediaProperties, 'setVideoDeviceId');
-          sandbox.stub(MediaUtil, 'createMediaStream').returns(true);
 
           meeting.setLocalTracks(fakeStream);
 
@@ -2571,7 +2612,6 @@ describe('plugin-meetings', () => {
       });
       describe('#setRemoteStream', () => {
         beforeEach(() => {
-          MediaUtil.createMediaStream = sinon.stub().returns(true);
           meeting.statsAnalyzer = {startAnalyzer: sinon.stub()};
         });
         it('should trigger a media:ready event when remote stream track ontrack is fired', () => {

package/test/unit/spec/meeting-info/meetinginfov2.js

@@ -10,12 +10,34 @@ import Mercury from '@webex/internal-plugin-mercury';
 import Meetings from '@webex/plugin-meetings/src/meetings';
 import {
   _MEETING_ID_,
-  _PERSONAL_ROOM_
+  _PERSONAL_ROOM_,
+  _CONVERSATION_URL_
 } from '@webex/plugin-meetings/src/constants';
-import MeetingInfo, {MeetingInfoV2PasswordError, MeetingInfoV2CaptchaError} from '@webex/plugin-meetings/src/meeting-info/meeting-info-v2';
+import MeetingInfo, {MeetingInfoV2PasswordError, MeetingInfoV2CaptchaError, MeetingInfoV2AdhocMeetingError} from '@webex/plugin-meetings/src/meeting-info/meeting-info-v2';
 import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/utilv2';
 
 describe('plugin-meetings', () => {
+  const conversation = {
+    displayName: 'displayName',
+    url: 'conversationUrl',
+    encryptionKeyUrl: 'encryptionKeyUrl',
+    kmsResourceObjectUrl: 'kmsResourceObjectUrl',
+    participants: {
+      items: [
+        {
+          id: '344ea183-9d5d-4e77-aed',
+          emailAddress: 'testUser1@cisco.com',
+          entryUUID: '344ea183-9d5d-4e77-'
+
+        },
+        {
+          id: '40b446fe-175c-4628-8a9d',
+          emailAddress: 'testUser2@cisco.com',
+          entryUUID: '40b446fe-175c-4628'
+        }
+      ]
+    }
+  };
   let webex;
   let meetingInfo = null;
 
@@ -29,6 +51,9 @@ describe('plugin-meetings', () => {
         }
       });
 
+      webex.meetings.preferredWebexSite = 'go.webex.com';
+      webex.config.meetings = {experimental: {enableUnifiedMeetings: true, enableAdhocMeetings: true}};
+
       Object.assign(webex.internal, {
         device: {
           deviceType: 'FAKE_DEVICE',
@@ -41,6 +66,9 @@ describe('plugin-meetings', () => {
           disconnect: sinon.stub().returns(Promise.resolve()),
           on: () => {},
           off: () => {}
+        },
+        conversation: {
+          get: sinon.stub().returns(Promise.resolve(conversation))
         }
       });
 
@@ -98,6 +126,40 @@ describe('plugin-meetings', () => {
         });
       });
 
+      it('create adhoc meeting when conversationUrl passed with enableAdhocMeetings toggle', async () => {
+        sinon.stub(meetingInfo, 'createAdhocSpaceMeeting').returns(Promise.resolve());
+        await meetingInfo.fetchMeetingInfo('conversationUrl', _CONVERSATION_URL_);
+
+        assert.calledWith(meetingInfo.createAdhocSpaceMeeting, 'conversationUrl');
+        assert.notCalled(webex.request);
+        meetingInfo.createAdhocSpaceMeeting.restore();
+      });
+
+      it('should not call createAdhocSpaceMeeting if enableAdhocMeetings toggle is off', async () => {
+        webex.config.meetings.experimental.enableAdhocMeetings = false;
+        sinon.stub(meetingInfo, 'createAdhocSpaceMeeting').returns(Promise.resolve());
+
+        await meetingInfo.fetchMeetingInfo('conversationUrl', _CONVERSATION_URL_);
+
+        assert.notCalled(meetingInfo.createAdhocSpaceMeeting);
+        assert.called(webex.request);
+        meetingInfo.createAdhocSpaceMeeting.restore();
+      });
+
+      it('should throw an error MeetingInfoV2AdhocMeetingError if not able to start adhoc meeting for a conversation', async () => {
+        webex.config.meetings.experimental.enableAdhocMeetings = true;
+
+        webex.request = sinon.stub().rejects({statusCode: 403, body: {code: 400000, message: 'Input is invalid'}});
+        try {
+          await meetingInfo.createAdhocSpaceMeeting('conversationUrl');
+        }
+        catch (err) {
+          assert.instanceOf(err, MeetingInfoV2AdhocMeetingError);
+          assert.deepEqual(err.message, 'Input is invalid, code=400000');
+          assert.equal(err.wbxAppApiCode, 400000);
+        }
+      });
+
       it('should throw MeetingInfoV2PasswordError for 403 response', async () => {
         const FAKE_MEETING_INFO = {blablabla: 'some_fake_meeting_info'};
 
@@ -154,5 +216,40 @@ describe('plugin-meetings', () => {
         });
       });
     });
+
+
+    describe('createAdhocSpaceMeeting', () => {
+      it('Make a request to /instantSpace when conversationUrl', async () => {
+        const conversationUrl = 'https://conversationUrl/xxx';
+        const invitee = [];
+
+        invitee.push({
+          email: conversation.participants.items[0].emailAddress,
+          ciUserUuid: conversation.participants.items[0].entryUUID
+        });
+
+        invitee.push({
+          email: conversation.participants.items[1].emailAddress,
+          ciUserUuid: conversation.participants.items[1].entryUUID
+        });
+
+        await meetingInfo.createAdhocSpaceMeeting(conversationUrl);
+
+        assert.calledWith(webex.internal.conversation.get, {url: conversationUrl},
+          {includeParticipants: true, disableTransform: true});
+
+        assert.calledWith(webex.request, {
+          method: 'POST',
+          uri: 'https://go.webex.com/wbxappapi/v2/meetings/spaceInstant',
+          body: {
+            title: conversation.displayName,
+            spaceUrl: conversation.url,
+            keyUrl: conversation.encryptionKeyUrl,
+            kroUrl: conversation.kmsResourceObjectUrl,
+            invitees: invitee
+          }
+        });
+      });
+    });
   });
 });