@webex/plugin-meetings 1.144.2 → 1.146.1

package/src/members/request.js

@@ -73,4 +73,39 @@ export default class MembersRequest extends StatelessWebexPlugin {
 
     return this.request(requestParams);
   }
+
+  /**
+   * Sends a request to the DTMF endpoint to send tones
+   * @param {Object} options
+   * @param {String} options.locusUrl
+   * @param {String} options.url device url SIP user
+   * @param {String} options.tones a string of one or more DTMF tones to send
+   * @param {String} options.memberId ID of PSTN user
+   * @returns {Promise}
+   */
+  sendDialPadKey(options) {
+    if (!options || !options.locusUrl || !options.memberId || !options.url || !options.tones && options.tones !== 0) {
+      throw new ParameterError('memberId must be defined, the associated locus url, the device url and DTMF tones for this meeting object must be defined.');
+    }
+
+    const requestParams = MembersUtil.generateSendDTMFRequestParams(options);
+
+    return this.request(requestParams);
+  }
+
+  /**
+   * @param {Object} options with format of {invitee: string, locusUrl: string}
+   * @returns {Promise}
+   * @throws {Error} if the options are not valid and complete, must have invitee with emailAddress OR email AND locusUrl
+   * @memberof MembersRequest
+   */
+  cancelPhoneInvite(options) {
+    if (!(options?.invitee?.phoneNumber || options?.locusUrl)) {
+      throw new ParameterError('invitee must be passed and the associated locus url for this meeting object must be defined.');
+    }
+
+    const requestParams = MembersUtil.generateCancelInviteRequestParams(options);
+
+    return this.request(requestParams);
+  }
 }

package/src/members/util.js

@@ -1,3 +1,5 @@
+import uuid from 'uuid';
+
 import {
   HTTP_VERBS,
   CONTROLS,
@@ -5,7 +7,9 @@ import {
   LEAVE,
   PARTICIPANT,
   VALID_EMAIL_ADDRESS,
-  DIALER_REGEX
+  DIALER_REGEX,
+  SEND_DTMF_ENDPOINT,
+  _REMOVE_
 } from '../constants';
 
 const MembersUtil = {};
@@ -156,4 +160,57 @@ MembersUtil.getTransferHostToMemberRequestParams = (options) => {
   };
 };
 
+MembersUtil.genderateSendDTMFOptions = (url, tones, memberId, locusUrl) => ({
+  url,
+  tones,
+  memberId,
+  locusUrl
+});
+
+MembersUtil.generateSendDTMFRequestParams = ({
+  url, tones, memberId, locusUrl
+}) => {
+  const body = {
+    device: {
+      url
+    },
+    memberId,
+    dtmf: {
+      correlationId: uuid.v4(),
+      tones,
+      direction: 'transmit'
+    }
+  };
+  const uri = `${locusUrl}/${PARTICIPANT}/${memberId}/${SEND_DTMF_ENDPOINT}`;
+
+  return {
+    method: HTTP_VERBS.POST,
+    uri,
+    body
+  };
+};
+
+MembersUtil.cancelPhoneInviteOptions = (invitee, locusUrl) => ({
+  invitee,
+  locusUrl
+});
+
+MembersUtil.generateCancelInviteRequestParams = (options) => {
+  const body = {
+    actionType: _REMOVE_,
+    invitees: [
+      {
+        address: options.invitee.phoneNumber
+      }
+    ]
+  };
+  const requestParams = {
+    method: HTTP_VERBS.PUT,
+    uri: options.locusUrl,
+    body
+  };
+
+  return requestParams;
+};
+
 export default MembersUtil;

package/src/metrics/index.js

@@ -175,7 +175,6 @@ class Metrics {
       eventId: uuid.v4(),
       version: 1,
       origin: {
-        buildType: 'prod',
         name: 'endpoint',
         networkType: 'unknown',
         userAgent: this.userAgentToString(),
@@ -264,7 +263,6 @@ class Metrics {
       origin: {
         audioSetupDelay,
         videoSetupDelay,
-        buildType: 'prod',
         name: 'endpoint',
         networkType: options.networkType || UNKNOWN,
         userAgent: this.userAgentToString(),

package/src/roap/handler.js

@@ -192,8 +192,10 @@ export default class RoapHandler extends StatelessWebexPlugin {
   handleAction(session, action, meeting, correlationId) {
     let signal;
 
+
     switch (action.type) {
       case ROAP.RECEIVE_ROAP_MSG:
+        LoggerProxy.logger.log(`Roap:handler#handleAction --> RECEIVE_ROAP_MSG event captured, reciving a roap message : ${JSON.stringify(action)}`);
         if (compareWithLastRoapMessage(this.lastRoapMessage, action)) {
           LoggerProxy.logger.warn(`Roap:handler#handleAction --> duplicate roap offer from server: ${action.msg.seq}`);
         }
@@ -204,18 +206,15 @@ export default class RoapHandler extends StatelessWebexPlugin {
         }
         break;
       case ROAP.SEND_ROAP_MSG:
+        LoggerProxy.logger.log(`Roap:handler#handleAction --> SEND_ROAP_MSG event captured, sending roap message ${JSON.stringify(action)}`);
+
         action.local = true;
         this.execute(signal, session, action, meeting, ROAP.TX_);
         break;
       case ROAP.SEND_ROAP_MSG_SUCCESS:
-        // This means we got and answer and waiting for 200 ok for /participants
-        if (RoapCollection.getSessionSequence(correlationId, action.seq).ANSWER) {
-          signal = ROAP.ROAP_SIGNAL.RX_ANSWER;
-          // NOTE: When server send back an answer via mercury the
-          // remote SDP is already saved sent and ok message is sent back
-          // We dont have to indicate the roapHandler about the RX_ANSWER via SEND_ROAP_MSG_SUCCESS
-          // RoapHandler.transition(signal, session, meeting);
-        }
+        // NOTE: When server send back an answer via mercury the
+        // remote SDP is already saved sent and ok message is sent back
+        // We dont have to indicate the roapHandler about the RX_ANSWER via SEND_ROAP_MSG_SUCCESS
         break;
       case ROAP.RECEIVE_CALL_LEAVE:
         RoapCollection.deleteSession(correlationId);

package/src/roap/index.js

@@ -174,6 +174,12 @@ export default class Roap extends StatelessWebexPlugin {
       seq: options.seq
     };
 
+    this.roapHandler.submit({
+      type: ROAP.SEND_ROAP_MSG,
+      msg: roapMessage,
+      correlationId: options.correlationId
+    });
+
     return this.roapRequest
       .sendRoap({
         roapMessage,
@@ -186,10 +192,11 @@ export default class Roap extends StatelessWebexPlugin {
       })
       .then(() => {
         meeting.setRoapSeq(options.seq);
+
         this.roapHandler.submit({
-          type: ROAP.SEND_ROAP_MSG,
-          msg: roapMessage,
-          correlationId: options.correlationId
+          type: ROAP.SEND_ROAP_MSG_SUCCESS,
+          seq: roapMessage.seq,
+          correlationId: meeting.correlationId
         });
       });
   }

package/src/roap/state.js

@@ -25,6 +25,8 @@ const shouldStep = (roap, meeting) => {
 };
 
 const handleTransition = (value, signal, meeting) => {
+  LoggerProxy.logger.log(`Roap:state#handleTransition --> current ${value} to ${signal}`);
+
   switch (value) {
     case ROAP.ROAP_STATE.INIT:
       if (signal === ROAP.ROAP_SIGNAL.RX_OFFER) {

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

@@ -186,6 +186,22 @@ describe('plugin-meetings', () => {
           assert.calledWith(meeting.members.addMember, uuid1, false);
         });
       });
+      describe('#cancelPhoneInvite', () => {
+        it('should have #invite', () => {
+          assert.exists(meeting.cancelPhoneInvite);
+        });
+        beforeEach(() => {
+          meeting.members.cancelPhoneInvite = sinon.stub().returns(Promise.resolve(test1));
+        });
+        it('should proxy members #cancelPhoneInvite and return a promise', async () => {
+          const cancel = meeting.cancelPhoneInvite(uuid1);
+
+          assert.exists(cancel.then);
+          await cancel;
+          assert.calledOnce(meeting.members.cancelPhoneInvite);
+          assert.calledWith(meeting.members.cancelPhoneInvite, uuid1);
+        });
+      });
       describe('#admit', () => {
         it('should have #admit', () => {
           assert.exists(meeting.admit);

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

@@ -0,0 +1,192 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import sinon from 'sinon';
+import uuid from 'uuid';
+import chai from 'chai';
+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 Members from '@webex/plugin-meetings/src/members';
+import MembersUtil from '@webex/plugin-meetings/src/members/util';
+
+const {assert} = chai;
+
+chai.use(chaiAsPromised);
+sinon.assert.expose(chai.assert, {prefix: ''});
+
+
+describe('plugin-meetings', () => {
+  let webex;
+  let url1;
+  const fakeMembersCollection = {
+    test1: {
+      namespace: 'Meetings',
+      participant: {
+        state: 'JOINED',
+        type: 'USER',
+        person: {
+          id: '6eb08f8b-bf69-3251-a126-b161bead2d21',
+          phoneNumber: '+18578675309',
+          isExternal: true,
+          primaryDisplayString: '+18578675309'
+        },
+        devices: [
+          {
+            url: 'https://fakeURL.com',
+            deviceType: 'SIP',
+            state: 'JOINED',
+            intents: [
+              null
+            ],
+            correlationId: '1234',
+            provisionalUrl: 'dialout:///fake',
+            isSparkPstn: true
+          },
+          {
+            url: 'dialout:///fakeagain',
+            deviceType: 'PROVISIONAL',
+            state: 'JOINED',
+            intents: [
+              null
+            ],
+            correlationId: '4321',
+            isVideoCallback: false,
+            clientUrl: 'https://fakeURL',
+            provisionalType: 'DIAL_OUT_ONLY',
+            dialingStatus: 'SUCCESS'
+          }
+        ],
+        status: {
+          audioStatus: 'SENDRECV',
+          videoStatus: 'INACTIVE'
+        },
+        id: 'abc-123-abc-123',
+        guest: true,
+        resourceGuest: false,
+        moderator: false,
+        panelist: false,
+        moveToLobbyNotAllowed: true,
+        deviceUrl: 'https://fakeDeviceurl'
+      },
+      id: 'abc-123-abc-123',
+      status: 'IN_MEETING',
+      type: 'MEETING',
+      isModerator: false
+    }
+  };
+
+
+  describe('members', () => {
+    const sandbox = sinon.createSandbox();
+    let createMembers;
+
+    beforeEach(() => {
+      webex = new MockWebex({
+        children: {
+          meetings: Meetings,
+          credentials: Credentials,
+          support: Support
+        },
+        config: {
+          credentials: {
+            client_id: 'mock-client-id'
+          },
+          meetings: {
+            reconnection: {
+              enabled: false
+            },
+            mediaSettings: {},
+            metrics: {},
+            stats: {}
+          }
+        }
+      });
+
+      url1 = `https://example.com/${uuid.v4()}`;
+
+      createMembers = (options) => new Members({locusUrl: options.url}, {parent: webex});
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    describe('#addMembers', () => {
+      it('should invoke isInvalidInvitee and generateAddMemberOptions from MembersUtil when addMember is called with valid params', async () => {
+        sandbox.spy(MembersUtil, 'isInvalidInvitee');
+        sandbox.spy(MembersUtil, 'generateAddMemberOptions');
+
+        const members = createMembers({url: url1});
+
+        await members.addMember({phoneNumber: '+18578675309'});
+        assert.calledOnce(MembersUtil.isInvalidInvitee);
+        assert.calledOnce(MembersUtil.generateAddMemberOptions);
+      });
+
+      it('should throw a rejection if there is no locus url', async () => {
+        const members = createMembers({url: false});
+
+        assert.isRejected(members.addMember({email: 'test@cisco.com'}));
+      });
+    });
+
+    describe('#sendDialPadKey', () => {
+      it('should throw a rejection when calling sendDialPadKey with no tones', async () => {
+        const members = createMembers({url: url1});
+
+        assert.isRejected(members.sendDialPadKey());
+      });
+
+      it('should throw a rejection when calling sendDialPadKey with no member is found', async () => {
+        const members = createMembers({url: url1});
+
+        assert.isRejected(members.sendDialPadKey('1', '1234'));
+      });
+
+      it('should call genderateSendDTMFOptions with proper options on Members util if we the member is valid', async () => {
+        sandbox.spy(MembersUtil, 'genderateSendDTMFOptions');
+        const members = createMembers({url: url1});
+
+        members.membersCollection.setAll(fakeMembersCollection);
+        await members.sendDialPadKey('1', 'test1');
+        assert.calledWith(MembersUtil.genderateSendDTMFOptions, 'https://fakeURL.com', '1', 'test1', url1);
+      });
+
+      it('should call the sendDialPadKey method on membersRequest if the member is valid', async () => {
+        const members = createMembers({url: url1});
+
+        const {membersRequest} = members;
+
+        assert.exists(membersRequest);
+        const sendDialPadKeyspy = sandbox.spy(membersRequest, 'sendDialPadKey');
+
+        members.membersCollection.setAll(fakeMembersCollection);
+        await members.sendDialPadKey('1', 'test1');
+        assert.calledOnce(sendDialPadKeyspy);
+      });
+    });
+
+    describe('#cancelPhoneInvite', () => {
+      it('should invoke isInvalidInvitee and generateAddMemberOptions from MembersUtil when addMember is called with valid params', async () => {
+        sandbox.spy(MembersUtil, 'isInvalidInvitee');
+        sandbox.spy(MembersUtil, 'cancelPhoneInviteOptions');
+
+        const members = createMembers({url: url1});
+
+        await members.cancelPhoneInvite({phoneNumber: '+18578675309'});
+        assert.calledOnce(MembersUtil.isInvalidInvitee);
+        assert.calledOnce(MembersUtil.cancelPhoneInviteOptions);
+      });
+
+      it('should throw a rejection if there is no locus url', async () => {
+        const members = createMembers({url: false});
+
+        assert.isRejected(members.cancelPhoneInvite({phoneNumber: '+18578675309'}));
+      });
+    });
+  });
+});

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

@@ -0,0 +1,101 @@
+import sinon from 'sinon';
+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 MembersRequest from '@webex/plugin-meetings/src/members/request';
+
+const {assert} = chai;
+
+chai.use(chaiAsPromised);
+sinon.assert.expose(chai.assert, {prefix: ''});
+
+describe('plugin-meetings', () => {
+  let membersRequest;
+  let url1;
+  let sandbox;
+
+  beforeEach(() => {
+    const webex = new MockWebex({
+      children: {
+        meetings: Meetings
+      }
+    });
+
+    sandbox = sinon.createSandbox();
+
+    url1 = `https://example.com/${uuid.v4()}`;
+
+    membersRequest = new MembersRequest({}, {
+      parent: webex
+    });
+    membersRequest.request = sinon.mock().returns(Promise.resolve({}));
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+
+  describe('members request library', () => {
+    describe('#sendDialPadKey', () => {
+      it('sends a POST to the sendDtmf locus endpoint', async () => {
+        const locusUrl = url1;
+        const url = 'https://fakedeviceurl.com';
+        const tones = '1';
+        const memberId = 'test1';
+
+        await membersRequest.sendDialPadKey({
+          url,
+          tones,
+          memberId,
+          locusUrl
+        });
+        const requestParams = membersRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'POST');
+        assert.equal(requestParams.uri, `${locusUrl}/participant/${memberId}/sendDtmf`);
+        assert.equal(requestParams.body.dtmf.tones, tones);
+        assert.equal(requestParams.body.device.url, url);
+      });
+    });
+
+    describe('#addMembers', () => {
+      it('sends a PUT to the locus endpoint', async () => {
+        const options = {
+          invitee: {
+            phoneNumber: '+18578675309'
+          },
+          locusUrl: url1
+        };
+
+        await membersRequest.addMembers(options);
+        const requestParams = membersRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'PUT');
+        assert.equal(requestParams.uri, url1);
+        assert.equal(requestParams.body.invitees[0].address, '+18578675309');
+      });
+    });
+
+    describe('#cancelPhoneInvite', () => {
+      it('sends a PUT to the locus endpoint', async () => {
+        const options = {
+          invitee: {
+            phoneNumber: '+18578675309'
+          },
+          locusUrl: url1
+        };
+
+        await membersRequest.cancelPhoneInvite(options);
+        const requestParams = membersRequest.request.getCall(0).args[0];
+
+        assert.equal(requestParams.method, 'PUT');
+        assert.equal(requestParams.uri, url1);
+        assert.equal(requestParams.body.invitees[0].address, '+18578675309');
+        assert.equal(requestParams.body.actionType, 'REMOVE');
+      });
+    });
+  });
+});