@webex/plugin-meetings 2.10.0 → 2.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/plugin-meetings",
-  "version": "2.10.0",
+  "version": "2.12.0",
   "description": "",
   "license": "MIT",
   "contributors": [
@@ -24,19 +24,19 @@
   },
   "dependencies": {
     "@babel/runtime-corejs2": "^7.14.8",
-    "@webex/webex-core": "2.10.0",
-    "@webex/internal-plugin-mercury": "2.10.0",
-    "@webex/internal-plugin-conversation": "2.10.0",
+    "@webex/webex-core": "2.12.0",
+    "@webex/internal-plugin-mercury": "2.12.0",
+    "@webex/internal-plugin-conversation": "2.12.0",
     "webrtc-adapter": "^7.7.0",
     "lodash": "^4.17.21",
     "uuid": "^3.3.2",
     "global": "^4.4.0",
     "ip-anonymize": "^0.1.0",
-    "@webex/common": "2.10.0",
+    "@webex/common": "2.12.0",
     "bowser": "^2.11.0",
     "sdp-transform": "^2.12.0",
     "readable-stream": "^3.6.0",
-    "@webex/common-timers": "2.10.0",
+    "@webex/common-timers": "2.12.0",
     "btoa": "^1.2.1",
     "@webex/internal-media-core": "^0.0.4-beta",
     "javascript-state-machine": "^3.1.0",

package/src/meeting/index.js

@@ -1023,7 +1023,13 @@ export default class Meeting extends StatelessWebexPlugin {
     return this.fetchMeetingInfo({
       password, captchaCode
     })
-      .then(() => ({isPasswordValid: true, requiredCaptcha: null, failureReason: MEETING_INFO_FAILURE_REASON.NONE}))
+      .then(() => {
+        Metrics.sendBehavioralMetric(
+          BEHAVIORAL_METRICS.VERIFY_PASSWORD_SUCCESS
+        );
+
+        return {isPasswordValid: true, requiredCaptcha: null, failureReason: MEETING_INFO_FAILURE_REASON.NONE};
+      })
       .catch((error) => {
         if (error instanceof PasswordError || error instanceof CaptchaError) {
           return {

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

@@ -1,5 +1,7 @@
 
 import {HTTP_VERBS, _CONVERSATION_URL_} from '../constants';
+import Metrics from '../metrics';
+import BEHAVIORAL_METRICS from '../metrics/constants';
 
 import MeetingInfoUtil from './utilv2';
 
@@ -141,6 +143,10 @@ export default class MeetingInfoV2 {
         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,
@@ -149,6 +155,16 @@ export default class MeetingInfoV2 {
           .catch((err) => {
             throw new MeetingInfoV2AdhocMeetingError(err.body?.code, err.body?.message);
           });
+      })
+      .catch((err) => {
+        Metrics.sendBehavioralMetric(
+          BEHAVIORAL_METRICS.ADHOC_MEETING_FAILURE,
+          {
+            reason: err.message,
+            stack: err.stack
+          }
+        );
+        throw new MeetingInfoV2AdhocMeetingError(err.body?.code, err.body?.message);
       });
   }
 
@@ -189,11 +205,32 @@ export default class MeetingInfoV2 {
     if (directURI) options.directURI = directURI;
 
     return this.webex.request(options)
+      .then(() => {
+        Metrics.sendBehavioralMetric(
+          BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_SUCCESS
+        );
+      })
       .catch((err) => {
         if (err?.statusCode === 403) {
+          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,
@@ -201,6 +238,14 @@ export default class MeetingInfoV2 {
             refreshURL: err.body.refreshURL
           });
         }
+
+        Metrics.sendBehavioralMetric(
+          BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_FAILURE,
+          {
+            reason: err.message,
+            stack: err.stack
+          }
+        );
         throw err;
       });
   }

package/src/members/index.js

@@ -756,9 +756,29 @@ export default class Members extends StatelessWebexPlugin {
     }
     const options = MembersUtil.generateRaiseHandMemberOptions(memberId, raise, this.locusUrl);
 
-    return this.membersRequest.raiseLowerHandMember(options);
+    return this.membersRequest.raiseOrLowerHandMember(options);
   }
 
+  /**
+   * Lower all hands of members in a meeting
+   * @param {String} requestingMemberId - id of the participant which requested the lower all hands
+   * @returns {Promise}
+   * @public
+   * @memberof Members
+   */
+  lowerAllHands(requestingMemberId) {
+    if (!this.locusUrl) {
+      return Promise.reject(new ParameterError('The associated locus url for this meetings members object must be defined.'));
+    }
+    if (!requestingMemberId) {
+      return Promise.reject(new ParameterError('The requestingMemberId must be defined to lower all hands in a meeting.'));
+    }
+    const options = MembersUtil.generateLowerAllHandsMemberOptions(requestingMemberId, this.locusUrl);
+
+    return this.membersRequest.lowerAllHandsMember(options);
+  }
+
+
   /**
    * Transfers the host to another member
    * @param {String} memberId

package/src/members/request.js

@@ -74,6 +74,16 @@ export default class MembersRequest extends StatelessWebexPlugin {
     return this.request(requestParams);
   }
 
+  lowerAllHandsMember(options) {
+    if (!options || !options.locusUrl || !options.requestingParticipantId) {
+      throw new ParameterError('requestingParticipantId must be defined, and the associated locus url for this meeting object must be defined.');
+    }
+
+    const requestParams = MembersUtil.getLowerAllHandsMemberRequestParams(options);
+
+    return this.request(requestParams);
+  }
+
   transferHostToMember(options) {
     if (!options || !options.locusUrl || !options.memberId || !options.moderator) {
       throw new ParameterError('memberId must be defined, the associated locus url, and the moderator for this meeting object must be defined.');

package/src/members/util.js

@@ -136,6 +136,11 @@ MembersUtil.generateRaiseHandMemberOptions = (memberId, status, locusUrl) => ({
   locusUrl
 });
 
+MembersUtil.generateLowerAllHandsMemberOptions = (requestingParticipantId, locusUrl) => ({
+  requestingParticipantId,
+  locusUrl
+});
+
 MembersUtil.getMuteMemberRequestParams = (options) => {
   const body = {
     audio: {
@@ -166,6 +171,22 @@ MembersUtil.getRaiseHandMemberRequestParams = (options) => {
   };
 };
 
+MembersUtil.getLowerAllHandsMemberRequestParams = (options) => {
+  const body = {
+    hand: {
+      raised: false
+    },
+    requestingParticipantId: options.requestingParticipantId
+  };
+  const uri = `${options.locusUrl}/${CONTROLS}`;
+
+  return {
+    method: HTTP_VERBS.PATCH,
+    uri,
+    body
+  };
+};
+
 MembersUtil.getTransferHostToMemberRequestParams = (options) => {
   const body = {
     role: {

package/src/metrics/constants.js

@@ -44,7 +44,14 @@ const BEHAVIORAL_METRICS = {
   ENABLE_BNR_SUCCESS: 'js_sdk_enable_bnr_success',
   ENABLE_BNR_FAILURE: 'js_sdk_enable_bnr_failure',
   DISABLE_BNR_SUCCESS: 'js_sdk_disable_bnr_success',
-  DISABLE_BNR_FAILURE: 'js_sdk_disable_bnr_failure'
+  DISABLE_BNR_FAILURE: 'js_sdk_disable_bnr_failure',
+  FETCH_MEETING_INFO_V1_SUCCESS: 'js_sdk_fetch_meeting_info_v1_success',
+  FETCH_MEETING_INFO_V1_FAILURE: 'js_sdk_fetch_meeting_info_v1_failure',
+  ADHOC_MEETING_SUCCESS: 'js_sdk_adhoc_meeting_success',
+  ADHOC_MEETING_FAILURE: 'js_sdk_adhoc_meeting_failure',
+  VERIFY_PASSWORD_SUCCESS: 'js_sdk_verify_password_success',
+  VERIFY_PASSWORD_ERROR: 'js_sdk_verify_password_error',
+  VERIFY_CAPTCHA_ERROR: 'js_sdk_verify_captcha_error'
 };
 
 

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

@@ -2366,6 +2366,11 @@ describe('plugin-meetings', () => {
           assert.equal(meeting.requiredCaptcha, null);
           assert.calledTwice(TriggerProxy.trigger);
           assert.calledWith(TriggerProxy.trigger, meeting, {file: 'meetings', function: 'fetchMeetingInfo'}, 'meeting:meetingInfoAvailable');
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.VERIFY_PASSWORD_SUCCESS,
+          );
         });
 
         it('calls meetingInfoProvider with all the right parameters and parses the result when random delay is applied', async () => {
@@ -2437,6 +2442,11 @@ describe('plugin-meetings', () => {
 
           assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, null, null);
 
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.VERIFY_PASSWORD_ERROR,
+          );
           assert.deepEqual(meeting.meetingInfo, FAKE_MEETING_INFO);
           assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
           assert.equal(meeting.requiredCaptcha, null);
@@ -2457,6 +2467,11 @@ describe('plugin-meetings', () => {
 
           assert.calledWith(meeting.attrs.meetingInfoProvider.fetchMeetingInfo, FAKE_DESTINATION, FAKE_TYPE, 'aaa', null);
 
+          assert(Metrics.sendBehavioralMetric.calledOnce);
+          assert.calledWith(
+            Metrics.sendBehavioralMetric,
+            BEHAVIORAL_METRICS.VERIFY_CAPTCHA_ERROR,
+          );
           assert.deepEqual(meeting.meetingInfo, {});
           assert.equal(meeting.meetingInfoFailureReason, MEETING_INFO_FAILURE_REASON.WRONG_PASSWORD);
           assert.equal(meeting.passwordStatus, PASSWORD_STATUS.REQUIRED);

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

@@ -16,6 +16,8 @@ import {
 } from '@webex/plugin-meetings/src/constants';
 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';
+import Metrics from '@webex/plugin-meetings/src/metrics';
+import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 
 describe('plugin-meetings', () => {
   const conversation = {
@@ -42,6 +44,13 @@ describe('plugin-meetings', () => {
   let webex;
   let meetingInfo = null;
 
+  beforeEach(() => {
+    sinon.stub(Metrics, 'sendBehavioralMetric');
+  });
+  afterEach(() => {
+    sinon.restore();
+  });
+
   describe('Meeting Info V2', () => {
     beforeEach(() => {
       webex = new MockWebex({
@@ -125,6 +134,11 @@ describe('plugin-meetings', () => {
             captchaVerifyCode: 'aabbcc11'
           }
         });
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.FETCH_MEETING_INFO_V1_SUCCESS,
+        );
       });
 
       it('create adhoc meeting when conversationUrl passed with enableAdhocMeetings toggle', async () => {
@@ -254,6 +268,11 @@ describe('plugin-meetings', () => {
             invitees: invitee
           }
         });
+        assert(Metrics.sendBehavioralMetric.calledOnce);
+        assert.calledWith(
+          Metrics.sendBehavioralMetric,
+          BEHAVIORAL_METRICS.ADHOC_MEETING_SUCCESS,
+        );
       });
     });
   });

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

@@ -10,8 +10,9 @@ import chaiAsPromised from 'chai-as-promised';
 import {Credentials} from '@webex/webex-core';
 import Support from '@webex/internal-plugin-support';
 import MockWebex from '@webex/test-helper-mock-webex';
-import Meetings from '@webex/plugin-meetings';
 
+import Meetings from '@webex/plugin-meetings';
+import ParameterError from '@webex/plugin-meetings/src/common/errors/parameter';
 import Members from '@webex/plugin-meetings/src/members';
 import MembersUtil from '@webex/plugin-meetings/src/members/util';
 
@@ -191,25 +192,123 @@ describe('plugin-meetings', () => {
       });
     });
 
-    describe('#raiseHand', () => {
-      it('should fire spies correctly when raiseOrLowerHand is called with valid params', async () => {
-        const members = createMembers({url: url1});
+    describe('#raiseOrLowerHand', () => {
+      const setup = (locusUrl) => {
+        const members = createMembers({url: locusUrl});
 
-        const {membersRequest} = members;
+        const spies = {
+          generateRaiseHandMemberOptions: sandbox.spy(MembersUtil, 'generateRaiseHandMemberOptions'),
+          raiseOrLowerHandMember: sandbox.spy(members.membersRequest, 'raiseOrLowerHandMember'),
+        };
+
+        return {members, spies};
+      };
 
-        const generateOptionsSpy = sandbox.spy(MembersUtil, 'generateRaiseHandMemberOptions');
-        const raiseOrLowerHandMemberSpy = sandbox.spy(membersRequest, 'raiseOrLowerHandMember');
+      const checkInvalid = async (resultPromise, expectedMessage, spies) => {
+        await assert.isRejected(resultPromise, ParameterError, expectedMessage);
+        assert.notCalled(spies.generateRaiseHandMemberOptions);
+        assert.notCalled(spies.raiseOrLowerHandMember);
+      };
 
-        await members.raiseOrLowerHand('test1', true);
+      const checkValid = async (resultPromise, spies, expectedMemberId, expectedRaise, expectedLocusUrl) => {
+        await assert.isFulfilled(resultPromise);
+        assert.calledOnceWithExactly(spies.generateRaiseHandMemberOptions, expectedMemberId, expectedRaise, expectedLocusUrl);
+        assert.calledOnceWithExactly(spies.raiseOrLowerHandMember, {memberId: expectedMemberId, raised: expectedRaise, locusUrl: expectedLocusUrl});
+        assert.strictEqual(resultPromise, spies.raiseOrLowerHandMember.getCall(0).returnValue);
+      };
 
-        assert.calledOnce(generateOptionsSpy);
-        assert.calledOnce(raiseOrLowerHandMemberSpy);
+      it('should not make a request if there is no member id', async () => {
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.raiseOrLowerHand();
+
+        await checkInvalid(resultPromise, 'The member id must be defined to raise/lower the hand of the member.', spies);
       });
 
-      it('should throw a rejection if there is no locus url', async () => {
-        const members = createMembers({url: false});
+      it('should not make a request if there is no locus url', async () => {
+        const {members, spies} = setup();
+
+        const resultPromise = members.raiseOrLowerHand(uuid.v4());
+
+        await checkInvalid(resultPromise, 'The associated locus url for this meetings members object must be defined.', spies);
+      });
+
+      it('should make the correct request when called with raise as true', async () => {
+        const memberId = uuid.v4();
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.raiseOrLowerHand(memberId, true);
+
+        await checkValid(resultPromise, spies, memberId, true, url1);
+      });
+
+      it('should make the correct request when called with raise as false', async () => {
+        const memberId = uuid.v4();
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.raiseOrLowerHand(memberId, false);
+
+        await checkValid(resultPromise, spies, memberId, false, url1);
+      });
+
+      it('should make the correct request when called with raise as default', async () => {
+        const memberId = uuid.v4();
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.raiseOrLowerHand(memberId);
+
+        await checkValid(resultPromise, spies, memberId, true, url1);
+      });
+    });
+
+    describe('#lowerAllHands', () => {
+      const setup = (locusUrl) => {
+        const members = createMembers({url: locusUrl});
+
+        const spies = {
+          generateLowerAllHandsMemberOptions: sandbox.spy(MembersUtil, 'generateLowerAllHandsMemberOptions'),
+          lowerAllHandsMember: sandbox.spy(members.membersRequest, 'lowerAllHandsMember'),
+        };
+
+        return {members, spies};
+      };
+
+      const checkInvalid = async (resultPromise, expectedMessage, spies) => {
+        await assert.isRejected(resultPromise, ParameterError, expectedMessage);
+        assert.notCalled(spies.generateLowerAllHandsMemberOptions);
+        assert.notCalled(spies.lowerAllHandsMember);
+      };
+
+      const checkValid = async (resultPromise, spies, expectedRequestingMemberId, expectedLocusUrl) => {
+        await assert.isFulfilled(resultPromise);
+        assert.calledOnceWithExactly(spies.generateLowerAllHandsMemberOptions, expectedRequestingMemberId, expectedLocusUrl);
+        assert.calledOnceWithExactly(spies.lowerAllHandsMember, {requestingParticipantId: expectedRequestingMemberId, locusUrl: expectedLocusUrl});
+        assert.strictEqual(resultPromise, spies.lowerAllHandsMember.getCall(0).returnValue);
+      };
+
+      it('should not make a request if there is no requestingMemberId', async () => {
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.lowerAllHands();
+
+        await checkInvalid(resultPromise, 'The requestingMemberId must be defined to lower all hands in a meeting.', spies);
+      });
+
+      it('should not make a request if there is no locus url', async () => {
+        const {members, spies} = setup();
+
+        const resultPromise = members.lowerAllHands(uuid.v4());
+
+        await checkInvalid(resultPromise, 'The associated locus url for this meetings members object must be defined.', spies);
+      });
+
+      it('should make the correct request when called with requestingMemberId', async () => {
+        const requestingMemberId = uuid.v4();
+        const {members, spies} = setup(url1);
+
+        const resultPromise = members.lowerAllHands(requestingMemberId);
 
-        assert.isRejected(members.raiseOrLowerHand('test1', true));
+        await checkValid(resultPromise, spies, requestingMemberId, url1);
       });
     });
   });

package/test/unit/spec/members/request.js

@@ -3,9 +3,11 @@ import chai from 'chai';
 import uuid from 'uuid';
 import chaiAsPromised from 'chai-as-promised';
 import MockWebex from '@webex/test-helper-mock-webex';
-import Meetings from '@webex/plugin-meetings';
 
+import Meetings from '@webex/plugin-meetings';
 import MembersRequest from '@webex/plugin-meetings/src/members/request';
+import membersUtil from '@webex/plugin-meetings/src/members/util';
+import ParameterError from '@webex/plugin-meetings/src/common/errors/parameter';
 
 const {assert} = chai;
 
@@ -118,5 +120,72 @@ describe('plugin-meetings', () => {
         assert.equal(requestParams.body.hand.raised, true);
       });
     });
+
+    describe('#lowerAllHands', () => {
+      const parameterErrorMessage = 'requestingParticipantId must be defined, and the associated locus url for this meeting object must be defined.';
+
+      const checkInvalid = async (functionParams) => {
+        assert.throws(() => membersRequest.lowerAllHandsMember(functionParams), ParameterError, parameterErrorMessage);
+        assert(membersRequest.request.notCalled);
+        assert(membersUtil.getLowerAllHandsMemberRequestParams.notCalled);
+      };
+
+      it('rejects if no options are passed in', async () => {
+        checkInvalid();
+      });
+
+      it('rejects if no locusUrl are passed in', async () => {
+        checkInvalid({requestingParticipantId: 'test'});
+      });
+
+      it('rejects if no requestingParticipantId are passed in', async () => {
+        checkInvalid({locusUrl: 'test'});
+      });
+
+      it('returns a promise', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+
+        const options = {
+          requestingParticipantId: memberId,
+          locusUrl,
+        };
+
+        assert.strictEqual(membersRequest.lowerAllHandsMember(options), membersRequest.request.getCall(0).returnValue);
+      });
+
+      it('sends a PATCH to the locus endpoint', async () => {
+        const locusUrl = url1;
+        const memberId = 'test1';
+
+        const options = {
+          requestingParticipantId: memberId,
+          locusUrl,
+        };
+
+
+        const getRequestParamsSpy = sandbox.spy(membersUtil, 'getLowerAllHandsMemberRequestParams');
+
+        await membersRequest.lowerAllHandsMember(options);
+
+        assert.calledOnceWithExactly(getRequestParamsSpy, {
+          requestingParticipantId: memberId,
+          locusUrl: url1
+        });
+
+        const requestParams = membersRequest.request.getCall(0).args[0];
+
+        assert.deepEqual(requestParams, {
+          method: 'PATCH',
+          uri: `${locusUrl}/controls`,
+          body: {
+            hand: {
+              raised: false
+            },
+            requestingParticipantId: memberId
+          }
+        });
+      });
+    });
   });
 });

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

@@ -0,0 +1,39 @@
+import sinon from 'sinon';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+
+import MembersUtil from '@webex/plugin-meetings/src/members/util';
+
+const {assert} = chai;
+
+chai.use(chaiAsPromised);
+sinon.assert.expose(chai.assert, {prefix: ''});
+
+describe('plugin-meetings', () => {
+  describe('members utils library', () => {
+    describe('#generateRaiseHandMemberOptions', () => {
+      it('returns the correct options', () => {
+        const memberId = 'test';
+        const status = true;
+        const locusUrl = 'urlTest1';
+
+        assert.deepEqual(MembersUtil.generateRaiseHandMemberOptions(memberId, status, locusUrl), {
+          memberId,
+          raised: status,
+          locusUrl
+        });
+      });
+    });
+    describe('#generateLowerAllHandsMemberOptions', () => {
+      it('returns the correct options', () => {
+        const requestingParticipantId = 'test';
+        const locusUrl = 'urlTest1';
+
+        assert.deepEqual(MembersUtil.generateLowerAllHandsMemberOptions(requestingParticipantId, locusUrl), {
+          requestingParticipantId,
+          locusUrl
+        });
+      });
+    });
+  });
+});