@webex/internal-plugin-calendar 2.48.0 → 2.50.0

package/src/calendar.js

@@ -41,8 +41,8 @@
  * @instance
  * @memberof Calendar
  */
-
-import btoa from 'btoa';
+import {isArray} from 'lodash';
+import {base64} from '@webex/common';
 import {WebexPlugin} from '@webex/webex-core';
 
 import CalendarCollection from './collection';
@@ -54,6 +54,9 @@ import {
   CALENDAR_UPDATED,
 } from './constants';
 
+import EncryptHelper from './calendar.encrypt.helper';
+import DecryptHelper from './calendar.decrypt.helper';
+
 const Calendar = WebexPlugin.extend({
   namespace: 'Calendar',
 
@@ -65,6 +68,43 @@ const Calendar = WebexPlugin.extend({
    */
   registered: false,
 
+  /**
+   * Cache all rpc event request locally
+   * */
+  rpcEventRequests: [],
+
+  /**
+   * Cache KMS encryptionKeyUrl
+   * */
+  encryptionKeyUrl: null,
+
+  /**
+   * WebexPlugin initialize method. This triggers once Webex has completed its
+   * initialization workflow.
+   *
+   * If the plugin is meant to perform startup actions, place them in this
+   * `initialize()` method instead of the `constructor()` method.
+   * @returns {void}
+   */
+  initialize() {
+    // Used to perform actions after webex is fully qualified and ready for
+    // operation.
+    this.listenToOnce(this.webex, 'ready', () => {
+      // Pre-fetch a KMS encryption key url to improve performance
+      this.webex.internal.encryption.kms.createUnboundKeys({count: 1}).then((keys) => {
+        const key = isArray(keys) ? keys[0] : keys;
+        this.encryptionKeyUrl = key ? key.uri : null;
+        this.logger.info('calendar->bind a KMS encryption key url');
+        this.webex.internal.encryption
+          .getKey(this.encryptionKeyUrl, {onBehalfOf: null})
+          .then((retrievedKey) => {
+            this.encryptionKeyUrl = retrievedKey ? retrievedKey.uri : null;
+            this.logger.info('calendar->retrieve the KMS encryption key url and cache it');
+          });
+      });
+    });
+  },
+
   /**
    * Explicitly sets up the calendar plugin by registering
    * the device, connecting to mercury, and listening for calendar events.
@@ -148,6 +188,9 @@ const Calendar = WebexPlugin.extend({
     this.webex.internal.mercury.on('event:calendar.meeting.delete', (envelope) => {
       this._handleDelete(envelope.data);
     });
+    this.webex.internal.mercury.on('event:calendar.free_busy', (envelope) => {
+      this._handleFreeBusy(envelope.data);
+    });
   },
 
   /**
@@ -161,6 +204,7 @@ const Calendar = WebexPlugin.extend({
     this.webex.internal.mercury.off('event:calendar.meeting.update');
     this.webex.internal.mercury.off('event:calendar.meeting.update.minimal');
     this.webex.internal.mercury.off('event:calendar.meeting.delete');
+    this.webex.internal.mercury.off('event:calendar.free_busy');
   },
 
   /**
@@ -199,6 +243,32 @@ const Calendar = WebexPlugin.extend({
     this.trigger(CALENDAR_DELETE, item);
   },
 
+  /**
+   * handles free_busy events
+   * @param {Object} data
+   * @returns {undefined}
+   * @private
+   */
+  _handleFreeBusy(data) {
+    DecryptHelper.decryptFreeBusyResponse(this, data).then(() => {
+      let response = {};
+      if (data && data.calendarFreeBusyScheduleResponse) {
+        response = data.calendarFreeBusyScheduleResponse;
+      }
+      if (response && response.requestId && response.requestId in this.rpcEventRequests) {
+        this.logger.log(
+          `webex.internal.calendar - receive requests, requestId: ${response.requestId}`
+        );
+        delete response.encryptionKeyUrl;
+        const {resolve} = this.rpcEventRequests[response.requestId];
+        resolve(response);
+        delete this.rpcEventRequests[response.requestId];
+      } else {
+        this.logger.log('webex.internal.calendar - receive other requests.');
+      }
+    });
+  },
+
   /**
    * Retrieves a collection of calendars based on the request parameters
    * Defaults to 1 day before and 7 days ahead
@@ -253,7 +323,7 @@ const Calendar = WebexPlugin.extend({
     return this.request({
       method: 'GET',
       service: 'calendar',
-      resource: `calendarEvents/${btoa(id)}/participants`,
+      resource: `calendarEvents/${base64.encode(id)}/participants`,
     });
   },
 
@@ -266,7 +336,7 @@ const Calendar = WebexPlugin.extend({
     return this.request({
       method: 'GET',
       service: 'calendar',
-      resource: `calendarEvents/${btoa(id)}/notes`,
+      resource: `calendarEvents/${base64.encode(id)}/notes`,
     });
   },
 
@@ -312,6 +382,114 @@ const Calendar = WebexPlugin.extend({
         return Promise.all(promises).then(() => meetingObjects);
       });
   },
+
+  /**
+   * Create calendar event
+   * @param {object} [data] meeting payload data
+   * @returns {Promise} Resolves with creating calendar event response
+   * */
+  createCalendarEvent(data) {
+    return EncryptHelper.encryptCalendarEventRequest(this, data).then(() =>
+      this.request({
+        method: 'POST',
+        service: 'calendar',
+        body: data,
+        resource: 'calendarEvents/sync',
+      })
+    );
+  },
+
+  /**
+   * Update calendar event
+   * @param {string} [id] calendar event id
+   * @param {object} [data] meeting payload data
+   * @param {object} [query] the query parameters for specific usage
+   * @returns {Promise} Resolves with updating calendar event response
+   * */
+  updateCalendarEvent(id, data, query) {
+    return EncryptHelper.encryptCalendarEventRequest(this, data).then(() =>
+      this.request({
+        method: 'PATCH',
+        service: 'calendar',
+        body: data,
+        resource: `calendarEvents/${base64.encode(id)}/sync`,
+        qs: query || {},
+      })
+    );
+  },
+
+  /**
+   * Delete calendar event
+   * @param {string} [id] calendar event id
+   * @returns {Promise} Resolves with deleting calendar event response
+   * */
+  deleteCalendarEvent(id) {
+    return this.request({
+      method: 'DELETE',
+      service: 'calendar',
+      resource: `calendarEvents/${base64.encode(id)}/sync`,
+    });
+  },
+
+  /**
+   * @typedef QuerySchedulerDataOptions
+   * @param {string} [siteName] it is site full url, must have. Example: ccctest.dmz.webex.com
+   * @param {string} [id] it is seriesOrOccurrenceId. If present, the series/occurrence meeting ID to fetch data for. It should be base64 encoded.
+   *                      Example: 040000008200E00074C5B7101A82E008000000004A99F11A0841D9010000000000000000100000009EE499D4A71C1A46B51494C70EC7BFE5
+   * @param {string} [clientMeetingId] If present, the client meeting UUID to fetch data for. It should be base64 encoded.
+   *                      Example: 7f318aa9-887c-6e94-802a-8dc8e6eb1a0a
+   * @param {string} [scheduleTemplateId] it template id.
+   * @param {string} [sessionTypeId] it session type id.
+   * @param {string} [organizerCIUserId] required in schedule-on-behalf case. It is the organizer's CI UUID.
+   * @param {boolean} [usmPreference]
+   * @param {string} [webexMeetingId] webex side meeting UUID
+   * @param {string} [eventId] event ID.
+   * @param {string} [icalUid] icalendar UUID.
+   * @param {string} [thirdPartyType] third part type, such as: Microsoft
+   */
+  /**
+   * Get scheduler data from calendar service
+   * @param {QuerySchedulerDataOptions} [query] the command parameters for fetching scheduler data.
+   * @returns {Promise} Resolves with a decrypted scheduler data
+   * */
+  getSchedulerData(query) {
+    return this.request({
+      method: 'GET',
+      service: 'calendar',
+      resource: 'schedulerData',
+      qs: query || {},
+    }).then((response) => {
+      return DecryptHelper.decryptSchedulerDataResponse(this, response.body).then(() => response);
+    });
+  },
+
+  /**
+   * Get free busy status from calendar service
+   * @param {Object} [data] the command parameters for fetching free busy status.
+   * @returns {Promise} Resolves with a decrypted response
+   * */
+  getFreeBusy(data) {
+    return new Promise((resolve, reject) => {
+      EncryptHelper.encryptFreeBusyRequest(this, data)
+        .then(() => {
+          this.request({
+            method: 'POST',
+            service: 'calendar',
+            body: data,
+            resource: 'freebusy',
+          })
+            .then(() => {
+              this.rpcEventRequests[data.requestId] = {resolve, reject};
+            })
+            .catch((error) => {
+              reject(error);
+            });
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    });
+  },
 });
 
 export default Calendar;

package/src/index.js

@@ -20,7 +20,15 @@ registerInternalPlugin('calendar', Calendar, {
         name: 'transformMeetingNotes',
         direction: 'inbound',
         test(ctx, response) {
-          return Promise.resolve(has(response, 'body.encryptedNotes'));
+          return Promise.resolve(
+            has(response, 'body.encryptedNotes') &&
+              !(
+                response.options &&
+                response.options.service === 'calendar' &&
+                response.options.method === 'GET' &&
+                response.options.resource === 'schedulerData'
+              )
+          );
         },
         extract(response) {
           return Promise.resolve(response.body);
@@ -30,7 +38,15 @@ registerInternalPlugin('calendar', Calendar, {
         name: 'transformMeetingParticipants',
         direction: 'inbound',
         test(ctx, response) {
-          return Promise.resolve(has(response, 'body.encryptedParticipants'));
+          return Promise.resolve(
+            has(response, 'body.encryptedParticipants') &&
+              !(
+                response.options &&
+                response.options.service === 'calendar' &&
+                response.options.method === 'GET' &&
+                response.options.resource === 'schedulerData'
+              )
+          );
         },
         extract(response) {
           return Promise.resolve(response.body);
@@ -50,7 +66,15 @@ registerInternalPlugin('calendar', Calendar, {
         name: 'transformMeeting',
         direction: 'inbound',
         test(ctx, response) {
-          return Promise.resolve(has(response, 'body.seriesId'));
+          return Promise.resolve(
+            has(response, 'body.seriesId') &&
+              !(
+                response.options &&
+                response.options.service === 'calendar' &&
+                response.options.method === 'GET' &&
+                response.options.resource === 'schedulerData'
+              )
+          );
         },
         extract(response) {
           return Promise.resolve(response.body);

package/test/unit/spec/calendar.js

@@ -2,10 +2,10 @@
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
 
-import {assert} from '@webex/test-helper-chai';
+import { assert, expect } from "@webex/test-helper-chai";
 import Calendar from '@webex/internal-plugin-calendar';
 import MockWebex from '@webex/test-helper-mock-webex';
-import btoa from 'btoa';
+import { base64 } from "@webex/common";
 import sinon from 'sinon';
 
 import {
@@ -48,6 +48,14 @@ describe('internal-plugin-calendar', () => {
         }),
         off: sinon.spy(),
       };
+      webex.internal.encryption = {
+        kms: {
+          createUnboundKeys: sinon.stub().resolves([{
+            uri: "kms://kms-us-int.wbx2.com/keys/xxxx-xxxx-xxxx-xxxx"
+          }])
+        },
+        encryptText: sinon.stub().resolves("encryptedText")
+      };
     });
 
     describe('Public Api Contract', () => {
@@ -55,7 +63,7 @@ describe('internal-plugin-calendar', () => {
         it('on calendar register call mercury registration', async () => {
           await webex.internal.calendar.register();
           assert.calledOnce(webex.internal.device.register);
-          assert.callCount(webex.internal.mercury.on, 5);
+          assert.callCount(webex.internal.mercury.on, 6);
           assert.equal(webex.internal.calendar.registered, true);
         });
         it('should trigger `calendar:register` event', async () => {
@@ -97,7 +105,7 @@ describe('internal-plugin-calendar', () => {
         it('should call `mercury.unregister` and `device.unregister`', async () => {
           await webex.internal.calendar.register();
           await webex.internal.calendar.unregister();
-          assert.callCount(webex.internal.mercury.off, 5);
+          assert.callCount(webex.internal.mercury.off, 6);
           assert.calledOnce(webex.internal.mercury.disconnect);
           assert.calledOnce(webex.internal.device.unregister);
         });
@@ -208,7 +216,7 @@ describe('internal-plugin-calendar', () => {
             .withArgs({
               method: 'GET',
               service: 'calendar',
-              resource: `calendarEvents/${btoa('calendar1')}/notes`,
+              resource: `calendarEvents/${base64.encode('calendar1')}/notes`,
             })
             .returns(
               Promise.resolve({
@@ -235,7 +243,7 @@ describe('internal-plugin-calendar', () => {
           assert.calledWith(webex.request, {
             method: 'GET',
             service: 'calendar',
-            resource: `calendarEvents/${btoa('calendar1')}/notes`,
+            resource: `calendarEvents/${base64.encode('calendar1')}/notes`,
           });
         });
 
@@ -269,7 +277,7 @@ describe('internal-plugin-calendar', () => {
             .withArgs({
               method: 'GET',
               service: 'calendar',
-              resource: `calendarEvents/${btoa('calendar1')}/notes`,
+              resource: `calendarEvents/${base64.encode('calendar1')}/notes`,
             })
             .returns(
               Promise.resolve({
@@ -298,7 +306,7 @@ describe('internal-plugin-calendar', () => {
           assert.calledWith(webex.request, {
             method: 'GET',
             service: 'calendar',
-            resource: `calendarEvents/${btoa('calendar1')}/notes`,
+            resource: `calendarEvents/${base64.encode('calendar1')}/notes`,
           });
         });
       });
@@ -321,7 +329,7 @@ describe('internal-plugin-calendar', () => {
           assert.calledWith(webex.request, {
             method: 'GET',
             service: 'calendar',
-            resource: `calendarEvents/${btoa(id)}/notes`,
+            resource: `calendarEvents/${base64.encode(id)}/notes`,
           });
         });
       });
@@ -344,7 +352,124 @@ describe('internal-plugin-calendar', () => {
           assert.calledWith(webex.request, {
             method: 'GET',
             service: 'calendar',
-            resource: `calendarEvents/${btoa(id)}/participants`,
+            resource: `calendarEvents/${base64.encode(id)}/participants`,
+          });
+        });
+      });
+
+      describe("#getSchedulerData()", () => {
+        it("should fetch meeting calendar data", async () => {
+          const query = {
+            siteName: "scheduler01.dmz.webex.com",
+            clientMeetingId: "YWJjZGFiY2QtYWJjZC1hYmNkLWFiY2QtMDAwMDAwMDA"
+          };
+
+          webex.request = sinon.stub().resolves({
+            body: {
+              encryptedSubject: "My Meeting 1",
+              schedulerPreferences: {
+                uiControlAttributes: {
+                  displayHostSaveMeetingTemplate: true
+                },
+                webexOptions: {
+                  sessionTypeId: 3
+                }
+              }
+            }
+          });
+
+          const res = await webex.internal.calendar.getSchedulerData(query);
+
+          expect(res.body.encryptedSubject).to.equal("My Meeting 1");
+          expect(res.body.schedulerPreferences.uiControlAttributes.displayHostSaveMeetingTemplate).to.be.true;
+          expect(res.body.schedulerPreferences.webexOptions.sessionTypeId).to.equal(3);
+          assert.calledWith(webex.request, {
+            method: "GET",
+            service: "calendar",
+            resource: "schedulerData",
+            qs: {
+              siteName: query.siteName,
+              clientMeetingId: query.clientMeetingId
+            }
+          });
+        });
+      });
+
+      describe("#createCalendarEvent()", () => {
+        it("should create an calendar event", async () => {
+          const data = {
+            encryptionKeyUrl: "kms://kms-us-int.wbx2.com/keys/d1c14fc5-be10-4389-ae83-9521f92fbfd3",
+            notes: "This is Agenda",
+            subject: "My Meeting 1",
+            webexOptions: "{}"
+          };
+
+          webex.request = sinon.stub().resolves({
+            body: {
+              meetingId: "abcdabcd-abcd-abcd-abcd-00000000",
+              globalMeetingId: "xxxx-xxxx-xxxx-xxxx"
+            }
+          });
+
+          const res = await webex.internal.calendar.createCalendarEvent(data);
+
+          expect(res.body.meetingId).to.equal("abcdabcd-abcd-abcd-abcd-00000000");
+          expect(res.body.globalMeetingId).to.equal("xxxx-xxxx-xxxx-xxxx");
+          assert.calledWith(webex.request, {
+            method: "POST",
+            service: "calendar",
+            body: data,
+            resource: "calendarEvents/sync"
+          });
+        });
+      });
+
+      describe("#updateCalendarEvent()", () => {
+        it("should update a calendar event", async () => {
+          const id = "abcdabcd-abcd-abcd-abcd-00000000";
+          const data = {
+            encryptionKeyUrl: "kms://kms-us-int.wbx2.com/keys/d1c14fc5-be10-4389-ae83-9521f92fbfd3",
+            notes: "This is Agenda",
+            subject: "My Meeting 1",
+            webexOptions: "{}"
+          };
+          const query = {};
+
+          webex.request = sinon.stub().resolves({
+            body: {
+              meetingId: "abcdabcd-abcd-abcd-abcd-00000000",
+              globalMeetingId: "xxxx-xxxx-xxxx-xxxx"
+            }
+          });
+
+          const res = await webex.internal.calendar.updateCalendarEvent(id, data);
+
+          expect(res.body.meetingId).to.equal("abcdabcd-abcd-abcd-abcd-00000000");
+          expect(res.body.globalMeetingId).to.equal("xxxx-xxxx-xxxx-xxxx");
+          assert.calledWith(webex.request, {
+            method: "PATCH",
+            service: "calendar",
+            body: data,
+            resource: `calendarEvents/${base64.encode(id)}/sync`,
+            qs: query
+          });
+        });
+      });
+
+      describe("#deleteCalendarEvent()", () => {
+        it("should delete a calendar event", async () => {
+          const id = "abcdabcd-abcd-abcd-abcd-00000000";
+
+          webex.request = sinon.stub().resolves({
+            body: {}
+          });
+
+          await webex.internal.calendar.deleteCalendarEvent(id);
+
+          assert.calledWith(webex.request, {
+            method: "DELETE",
+            service: "calendar",
+            resource: `calendarEvents/${base64.encode(id)}/sync`
           });
         });
       });