@webex/plugin-meetings 1.158.0 → 1.159.0

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.
@@ -407,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.
@@ -430,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}`);
@@ -604,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/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
+          }
+        });
+      });
+    });
   });
 });

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

@@ -28,7 +28,6 @@ import {
   ROAP
 } from '../../../../src/constants';
 
-
 describe('plugin-meetings', () => {
   const logger = {
     log: () => {},
@@ -74,6 +73,11 @@ describe('plugin-meetings', () => {
         }
       });
 
+
+      Object.assign(webex, {
+        logging: logger
+      });
+
       Object.assign(webex.meetings.config, {
         bandwidth: {
           // please note, these are the maximum bandwidth values
@@ -86,7 +90,7 @@ describe('plugin-meetings', () => {
           enableUnifiedMeetings: true
         },
         logging: {
-          enable: false,
+          enable: true,
           verboseEvents: true
         }
       });
@@ -95,6 +99,10 @@ describe('plugin-meetings', () => {
         logger
       });
 
+      Object.assign(webex.meetings, {
+        startReachability: sinon.stub().returns(Promise.resolve())
+      });
+
       Object.assign(webex.internal, {
         device: {
           deviceType: 'FAKE_DEVICE',
@@ -162,17 +170,36 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#_toggleAdhocMeetings', () => {
+      it('should have toggleAdhocMeetings', () => {
+        assert.equal(typeof webex.meetings._toggleAdhocMeetings, 'function');
+      });
+
+      describe('success', () => {
+        it('should update meetings to start  adhoc meeting', () => {
+          webex.meetings._toggleAdhocMeetings(false);
+          assert.equal(webex.meetings.config.experimental.enableAdhocMeetings, false);
+        });
+      });
+
+      describe('failure', () => {
+        it('should not accept non boolean input', () => {
+          const currentEnableAdhocMeetings = webex.meetings.config.experimental.enableAdhocMeetings;
+
+          webex.meetings._toggleAdhocMeetings('test');
+          assert.equal(webex.meetings.config.experimental.enableAdhocMeetings, currentEnableAdhocMeetings);
+        });
+      });
+    });
+
+
     describe('Public API Contracts', () => {
       describe('#register', () => {
-        it('emits an event and resolves when register succeeds', (done) => {
+        it('emits an event and resolves when register succeeds', async () => {
           webex.canAuthorize = true;
-          webex.meetings.register().then(() => {
-            assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {
-              file: 'meetings', function: 'register'
-            }, 'meetings:registered');
-            assert.isTrue(webex.meetings.registered);
-            done();
-          });
+          await webex.meetings.register();
+          assert.calledWith(TriggerProxy.trigger, sinon.match.instanceOf(Meetings), {file: 'meetings', function: 'register'}, 'meetings:registered');
+          assert.isTrue(webex.meetings.registered);
         });
 
         it('rejects when SDK canAuthorize is false', () => {
@@ -192,15 +219,24 @@ describe('plugin-meetings', () => {
           assert.isRejected(webex.meetings.register());
         });
 
-        it('resolves immediately if already registered', (done) => {
+        it('resolves immediately if already registered', async () => {
           webex.canAuthorize = true;
           webex.meetings.registered = true;
-          webex.meetings.register().then(() => {
-            assert.notCalled(webex.internal.device.register);
-            assert.notCalled(webex.internal.mercury.connect);
-            assert.isTrue(webex.meetings.registered);
-            done();
-          });
+          await webex.meetings.register();
+          assert.notCalled(webex.internal.device.register);
+          assert.notCalled(webex.internal.mercury.connect);
+          assert.isTrue(webex.meetings.registered);
+        });
+
+        it('on register makes sure following functions are called ', async () => {
+          webex.canAuthorize = true;
+          webex.meetings.registered = false;
+          await webex.meetings.register();
+          assert.called(webex.internal.device.register);
+          assert.called(webex.internal.services.fetchLoginUserInformation);
+          assert.called(webex.internal.services.fetchClientRegionInfo);
+          assert.called(webex.internal.mercury.connect);
+          assert.isTrue(webex.meetings.registered);
         });
       });
 
@@ -768,6 +804,15 @@ describe('plugin-meetings', () => {
           assert.calledWith(TriggerProxy.trigger, webex.internal.mercury, SCOPE, EVENT);
         });
       });
+
+      describe('#fetchUserPreferredWebexSite', () => {
+        it('should call request.fetchLoginUserInformation to get the preferred webex site ', async () => {
+          assert.isDefined(webex.meetings.preferredWebexSite);
+          await webex.meetings.fetchUserPreferredWebexSite();
+
+          assert.equal(webex.meetings.preferredWebexSite, 'go.webex.com');
+        });
+      });
     });
   });
 });

package/test/unit/spec/meetings/utils.js

@@ -0,0 +1,18 @@
+import {assert} from '@webex/test-helper-chai';
+import MeetingsUtil from '@webex/plugin-meetings/src/meetings/util';
+
+describe('plugin-meetings', () => {
+  describe('Meetings utils function', () => {
+    describe('#parseUserPreferences', () => {
+      it('parsed the prefered webesite from userPreferences', async () => {
+        const res = MeetingsUtil.parseUserPreferences([
+          'SparkTOSAccept',
+          '"preferredWebExSite":"go.webex.com"'
+        ]);
+
+        assert.equal(res, 'go.webex.com');
+      });
+    });
+  });
+});
+