@webex/internal-plugin-task 0.0.0-next.1

package/src/helpers/decrypt.helper.js

@@ -0,0 +1,58 @@
+/**
+ * Decrypt text property - Note: this is backup solution for decryption, the better solution is to use interceptors and needs migration later
+ * @param {object} [ctx] context
+ * @param {string} [name] property name
+ * @param {string|object} [key] encryption key or key uri
+ * @param {object} [object] object which contains the property
+ * @returns {Promise} Resolves when decryption is complete
+ */
+const _decryptTextProp = (ctx, name, key, object) => {
+  if (!object[name]) {
+    return Promise.resolve();
+  }
+
+  return ctx.webex.internal.encryption
+    .decryptText(key.uri || key, object[name])
+    .then((plaintext) => {
+      object[name] = plaintext;
+    });
+};
+
+const _decryptTaskFields = (ctx, item) => {
+  if (!item || !item.encryptionKeyUrl) {
+    return Promise.resolve();
+  }
+
+  return Promise.all([
+    _decryptTextProp(ctx, 'title', item.encryptionKeyUrl, item),
+    _decryptTextProp(ctx, 'notes', item.encryptionKeyUrl, item),
+  ]);
+};
+
+const DecryptHelper = {
+  /**
+   * Decrypt task response
+   * @param {object} [ctx] context
+   * @param {object} [data] task response
+   * @returns {Promise} Resolves with decrypted response
+   * */
+  decryptTaskResponse: (ctx, data) => {
+    return _decryptTaskFields(ctx, data);
+  },
+
+  /**
+   * Decrypt tasks response
+   * @param {object} [ctx] context
+   * @param {object} [data] tasks response
+   * @returns {Promise} Resolves with decrypted response
+   * */
+  decryptTasksResponse: (ctx, data) => {
+    if (!data || !data.items || data.items.length === 0) {
+      return Promise.resolve();
+    }
+
+    return Promise.all(data.items.map((task) => _decryptTaskFields(ctx, task)));
+  },
+};
+
+export default DecryptHelper;

package/src/helpers/encrypt.helper.js

@@ -0,0 +1,50 @@
+import {isArray} from 'lodash';
+/**
+ * Encrypt text property of an object - Note: this is backup solution for encryption, the better solution is to use interceptors and needs migration later
+ * @param {object} [ctx] context
+ * @param {string} [name] property name
+ * @param {string|object} [key] encryption key or key uri
+ * @param {object} [object] object which contains the property
+ * @returns {Promise} Resolves when encryption is complete
+ */
+const _encryptTextProp = (ctx, name, key, object) => {
+  if (!object[name]) {
+    return Promise.resolve();
+  }
+
+  return ctx.webex.internal.encryption
+    .encryptText(key.uri || key, object[name])
+    .then((ciphertext) => {
+      object[name] = ciphertext;
+    });
+};
+
+const EncryptHelper = {
+  /**
+   * Encrypt create / update task event request payload
+   * @param {object} [ctx] context
+   * @param {object} [data] task payload data
+   * @returns {Promise} Resolves with encrypted request payload
+   * */
+  encryptTaskRequest: (ctx, data) => {
+    if (data.encryptionKeyUrl) {
+      return Promise.all([
+        _encryptTextProp(ctx, 'title', data.encryptionKeyUrl, data),
+        _encryptTextProp(ctx, 'notes', data.encryptionKeyUrl, data),
+      ]);
+    }
+
+    return ctx.webex.internal.encryption.kms.createUnboundKeys({count: 1}).then((keys) => {
+      const key = isArray(keys) ? keys[0] : keys;
+      const encryptionKeyUrl = key.uri;
+      Object.assign(data, {encryptionKeyUrl});
+
+      return Promise.all([
+        _encryptTextProp(ctx, 'title', encryptionKeyUrl, data),
+        _encryptTextProp(ctx, 'notes', encryptionKeyUrl, data),
+      ]);
+    });
+  },
+};
+
+export default EncryptHelper;

package/src/index.js

@@ -0,0 +1,22 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import '@webex/internal-plugin-device';
+import '@webex/internal-plugin-encryption';
+import '@webex/internal-plugin-conversation';
+
+import {registerInternalPlugin} from '@webex/webex-core';
+
+import Task from './task';
+import config from './config';
+
+registerInternalPlugin('task', Task, {
+  config,
+  payloadTransformer: {
+    predicates: [],
+    transforms: [],
+  },
+});
+
+export {default} from './task';

package/src/task.js

@@ -0,0 +1,224 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+import {WebexPlugin} from '@webex/webex-core';
+
+import {TASK_REGISTERED, TASK_UNREGISTERED} from './constants';
+
+import EncryptHelper from './helpers/encrypt.helper';
+import DecryptHelper from './helpers/decrypt.helper';
+
+const Task = WebexPlugin.extend({
+  namespace: 'Task',
+
+  /**
+   * registered value indicating events registration is successful
+   * @instance
+   * @type {Boolean}
+   * @memberof Task
+   */
+  registered: false,
+
+  /**
+   * 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.
+  },
+
+  /**
+   * Explicitly sets up the Task plugin by registering
+   * the device, connecting to mercury, and listening for events.
+   * @returns {Promise}
+   * @public
+   * @memberof Task
+   */
+  register() {
+    if (!this.webex.canAuthorize) {
+      this.logger.error('Task->register#ERROR, Unable to register, SDK cannot authorize');
+
+      return Promise.reject(new Error('SDK cannot authorize'));
+    }
+
+    if (this.registered) {
+      this.logger.info('Task->register#INFO, task plugin already registered');
+
+      return Promise.resolve();
+    }
+
+    return this.webex.internal.device
+      .register()
+      .then(() => this.webex.internal.mercury.connect())
+      .then(() => {
+        this.listenForEvents();
+        this.trigger(TASK_REGISTERED);
+        this.registered = true;
+      })
+      .catch((error) => {
+        this.logger.error(`Task->register#ERROR, Unable to register, ${error.message}`);
+
+        return Promise.reject(error);
+      });
+  },
+
+  /**
+   * Explicitly tears down the task plugin by stops listening to task events
+   *
+   * @returns {Promise}
+   * @public
+   * @memberof Task
+   */
+  unregister() {
+    if (!this.registered) {
+      this.logger.info('Task->unregister#INFO, task plugin already unregistered');
+
+      return Promise.resolve();
+    }
+
+    this.stopListeningForEvents();
+    this.trigger(TASK_UNREGISTERED);
+    this.registered = false;
+
+    return Promise.resolve();
+  },
+
+  /**
+   * registers for task events through mercury
+   * @returns {undefined}
+   * @private
+   */
+  listenForEvents() {},
+
+  /**
+   * unregisteres all the task events from mercury
+   * @returns {undefined}
+   * @private
+   */
+  stopListeningForEvents() {},
+
+  /**
+   * Retrieves a collection of tasks based on the request parameters
+   * @param {Object} options
+   * @param {String} options.orderBy
+   * @param {Number} options.offset
+   * @param {Number} options.limit
+   * @returns {Promise} Resolves with an array of tasks
+   */
+  listMyTasks(options) {
+    options = options || {};
+
+    return this.webex
+      .request({
+        method: 'GET',
+        service: 'raindrop',
+        resource: 'tasks',
+        qs: options || {},
+      })
+      .then((response) => {
+        return DecryptHelper.decryptTasksResponse(this, response.body).then(() => response);
+      });
+  },
+
+  /**
+   * Retrieves a task based on the request parameters
+   * @param {String} id Task ID
+   * @returns {Promise} Resolves with an array of tasks
+   */
+  getTask(id) {
+    return this.request({
+      method: 'GET',
+      service: 'raindrop',
+      resource: `tasks/${id}`,
+    }).then((response) => {
+      return DecryptHelper.decryptTaskResponse(this, response.body).then(() => response);
+    });
+  },
+
+  /**
+   * Create task
+   * @param {object} [data] task payload data
+   * @returns {Promise} Resolves with creating task response
+   * */
+  createTask(data) {
+    return EncryptHelper.encryptTaskRequest(this, data).then(() =>
+      this.request({
+        method: 'POST',
+        service: 'raindrop',
+        body: data,
+        resource: 'tasks',
+      }).then((response) => {
+        return DecryptHelper.decryptTaskResponse(this, response.body).then(() => response);
+      })
+    );
+  },
+
+  /**
+   * Update task
+   * @param {string} [id] task id
+   * @param {object} [data] task payload data
+   * @returns {Promise} Resolves with updating task response
+   * */
+  updateTask(id, data) {
+    return EncryptHelper.encryptTaskRequest(this, data).then(() =>
+      this.request({
+        method: 'PATCH',
+        service: 'raindrop',
+        body: data,
+        resource: `tasks/${id}`,
+      }).then((response) => {
+        return DecryptHelper.decryptTaskResponse(this, response.body).then(() => response);
+      })
+    );
+  },
+
+  /**
+   * Delete task
+   * @param {string} [id] task id
+   * @returns {Promise} Resolves with deleting task response
+   * */
+  deleteTask(id) {
+    return this.request({
+      method: 'DELETE',
+      service: 'raindrop',
+      resource: `tasks/${id}`,
+    });
+  },
+
+  /**
+   * Accept task
+   * @param {string} [id] task id
+   * @returns {Promise} Resolves with accepting task response
+   * */
+  acceptTask(id) {
+    return this.request({
+      method: 'POST',
+      service: 'raindrop',
+      resource: `tasks/${id}/accept`,
+    }).then((response) => {
+      return DecryptHelper.decryptTaskResponse(this, response.body).then(() => response);
+    });
+  },
+
+  /**
+   * Reject task
+   * @param {string} [id] task id
+   * @returns {Promise} Resolves with rejecting task response
+   * */
+  rejectTask(id) {
+    return this.request({
+      method: 'POST',
+      service: 'raindrop',
+      resource: `tasks/${id}/reject`,
+    }).then((response) => {
+      return DecryptHelper.decryptTaskResponse(this, response.body).then(() => response);
+    });
+  },
+});
+
+export default Task;

package/test/integration/spec/task.js

@@ -0,0 +1,87 @@
+import {assert} from '@webex/test-helper-chai';
+
+// mock testUsers
+const testUsers = {
+  create: () => Promise.resolve([
+    {
+      token: 'fake-token',
+      webex: null
+    }
+  ])
+};
+
+// mock WebexCore
+class MockTask {
+  constructor() {
+    this.tasks = [];
+    this.id = 1;
+  }
+  createTask({title, notes}) {
+    const task = {id: String(this.id++), title, notes};
+    this.tasks.push(task);
+    return Promise.resolve({body: task});
+  }
+  getTask(id) {
+    const task = this.tasks.find(t => t.id === id);
+    return Promise.resolve(task);
+  }
+  listMyTasks() {
+    return Promise.resolve({body: {items: this.tasks}});
+  }
+  deleteTask(id) {
+    this.tasks = this.tasks.filter(t => t.id !== id);
+    return Promise.resolve();
+  }
+}
+
+class WebexCore {
+  constructor() {
+    this.internal = {
+      device: {},
+      encryption: {
+        kms: {
+          setDeviceInfo: () => {},
+          createUnboundKeys: async () => [{uri: 'kms://mock-key', jwk: {}}]
+        }
+      },
+      task: new MockTask()
+    };
+  }
+}
+
+describe('plugin-task', function () {
+  // this.timeout(60000);
+  describe('Task', () => {
+    let createdTask, spock;
+
+    beforeEach('create users', async () => {
+      [spock] = await testUsers.create({count: 1});
+      spock.webex = new WebexCore();
+    });
+
+    beforeEach('populate data', async () => {
+      const t = await spock.webex.internal.task.createTask({
+        title: 'Task Title',
+        notes: 'Task Notes',
+      });
+      createdTask = t.body;
+    });
+
+    afterEach(async () => {
+      const res = await spock.webex.internal.task.listMyTasks();
+      await Promise.all(
+        res.body.items.map((task) =>
+          spock.webex.internal.task.deleteTask(task.id).catch((reason) => console.warn(reason))
+        )
+      );
+    });
+
+    describe('#getTask()', () => {
+      it('fetch the task', async () => {
+        const task = await spock.webex.internal.task.getTask(createdTask.id);
+        assert.isObject(task);
+        assert.equal(task.id, createdTask.id);
+      });
+    });
+  });
+});

package/test/unit/spec/helpers/decrypt.helper.js

@@ -0,0 +1,93 @@
+import DecryptHelper from "@webex/internal-plugin-task/src/helpers/decrypt.helper";
+
+describe("internal-plugin-task", () => {
+  describe("DecryptHelper", () => {
+    let ctx;
+    let encryptedTaskData;
+    let encryptedTasksData;
+
+    beforeEach(() => {
+      ctx = {
+        webex: {
+          internal: {
+            encryption: {
+              decryptText: jest.fn()
+            }
+          }
+        }
+      };
+
+      encryptedTaskData = {
+        "id": "abcdabcd-abcd-abcd-abcd-00000000",
+        "title": "Encrypted Task Title",
+        "notes": "Encrypted Task Notes",
+        "encryptionKeyUrl": "/keys/e5d3f747-6adf-432d-999c-6578e33953e3",
+      };
+
+      encryptedTasksData = {
+        "offset": 0,
+        "limit": 100,
+        "hasMore": false,
+        "items": [
+          encryptedTaskData
+        ]
+      };
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it("#decryptTaskResponse - should resolve with undefined if data is undefined", async () => {
+      const decryptedData = await DecryptHelper.decryptTaskResponse(ctx, undefined);
+      expect(decryptedData).toBeUndefined();
+    });
+
+    it("#decryptTaskResponse - should resolve with undefined if data.encryptionKeyUrl is undefined", async () => {
+      encryptedTaskData.encryptionKeyUrl = undefined;
+      const decryptedData = await DecryptHelper.decryptTaskResponse(ctx, encryptedTaskData);
+      expect(decryptedData).toBeUndefined();
+    });
+
+    describe("#decryptTaskResponse - should replace encrypted data with decrypted data in response", () => {
+      it("should decrypt scheduler data response correctly", async () => {
+        const expectedCiphertext = "some decrypted text for testing";
+        ctx.webex.internal.encryption.decryptText.mockResolvedValue(expectedCiphertext);
+
+        await DecryptHelper.decryptTaskResponse(ctx, encryptedTaskData);
+
+        expect(encryptedTaskData.title).toBe(expectedCiphertext);
+        expect(encryptedTaskData.notes).toBe(expectedCiphertext);
+        expect(ctx.webex.internal.encryption.decryptText).toHaveBeenCalled();
+      });
+    });
+
+    it("#decryptTasksResponse - should resolve with undefined if data is undefined", async () => {
+      const decryptedData = await DecryptHelper.decryptTasksResponse(ctx, undefined);
+      expect(decryptedData).toBeUndefined();
+    });
+
+    it("#decryptTasksResponse - should resolve with undefined if data.items is undefined", async () => {
+      const decryptedData = await DecryptHelper.decryptTasksResponse(ctx, {});
+      expect(decryptedData).toBeUndefined();
+    });
+
+    it("#decryptTasksResponse - should resolve with undefined if data.items is empty", async () => {
+      const decryptedData = await DecryptHelper.decryptTasksResponse(ctx, { items: [] });
+      expect(decryptedData).toBeUndefined();
+    });
+
+    describe("#decryptTasksResponse - should replace encrypted data with decrypted data in response", () => {
+      it("should decrypt tasks data response correctly", async () => {
+        const expectedCiphertext = "some decrypted text for testing";
+        ctx.webex.internal.encryption.decryptText.mockResolvedValue(expectedCiphertext);
+
+        await DecryptHelper.decryptTasksResponse(ctx, encryptedTasksData);
+
+        expect(encryptedTasksData.items[0].title).toBe(expectedCiphertext);
+        expect(encryptedTasksData.items[0].notes).toBe(expectedCiphertext);
+        expect(ctx.webex.internal.encryption.decryptText).toHaveBeenCalled();
+      });
+    });
+  });
+});

package/test/unit/spec/helpers/encrypt.helper.js

@@ -0,0 +1,43 @@
+import EncryptHelper from '@webex/internal-plugin-task/src/helpers/encrypt.helper';
+
+describe('internal-plugin-task', () => {
+  describe('encryptHelper', () => {
+    let ctx;
+
+    beforeEach(() => {
+      ctx = {
+        webex: {
+          internal: {
+            encryption: {
+              encryptText: jest.fn(),
+              kms: {
+                createUnboundKeys: jest.fn().mockResolvedValue([{
+                  uri: 'kmsKeyUri',
+                }]),
+              }
+            },
+          },
+        },
+      };
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('#encryptTaskRequest with plain text fields', async () => {
+      const taskRequest = {
+        "title": "plain text title",
+        "notes": "plain text notes",
+      };
+      const expectedCiphertext = 'some encrpty data';
+      ctx.webex.internal.encryption.encryptText.mockResolvedValue(expectedCiphertext);
+
+      await EncryptHelper.encryptTaskRequest(ctx, taskRequest);
+
+      expect(taskRequest.title).toBe(expectedCiphertext);
+      expect(taskRequest.notes).toBe(expectedCiphertext);
+      expect(ctx.webex.internal.encryption.encryptText).toHaveBeenCalled();
+    });
+  });
+});