@webex/internal-plugin-conversation 3.7.0 → 3.8.0

package/dist/share-activity.js

@@ -391,7 +391,7 @@ var ShareActivity = _webexCore.WebexPlugin.extend({
       return res.body.spaceUrl;
     });
   },
-  version: "3.7.0"
+  version: "3.8.0"
 });
 
 /**

package/package.json

@@ -19,12 +19,12 @@
     ]
   },
   "dependencies": {
-    "@webex/common": "3.7.0",
-    "@webex/helper-html": "3.7.0",
-    "@webex/helper-image": "3.7.0",
-    "@webex/internal-plugin-encryption": "3.7.0",
-    "@webex/internal-plugin-user": "3.7.0",
-    "@webex/webex-core": "3.7.0",
+    "@webex/common": "3.8.0",
+    "@webex/helper-html": "3.8.0",
+    "@webex/helper-image": "3.8.0",
+    "@webex/internal-plugin-encryption": "3.8.0",
+    "@webex/internal-plugin-user": "3.8.0",
+    "@webex/webex-core": "3.8.0",
     "crypto-js": "^4.1.1",
     "lodash": "^4.17.21",
     "node-scr": "^0.3.0",
@@ -36,13 +36,13 @@
     "@webex/eslint-config-legacy": "0.0.0",
     "@webex/jest-config-legacy": "0.0.0",
     "@webex/legacy-tools": "0.0.0",
-    "@webex/test-helper-chai": "3.7.0",
-    "@webex/test-helper-file": "3.7.0",
-    "@webex/test-helper-make-local-url": "3.7.0",
-    "@webex/test-helper-mocha": "3.7.0",
-    "@webex/test-helper-mock-webex": "3.7.0",
-    "@webex/test-helper-retry": "3.7.0",
-    "@webex/test-helper-test-users": "3.7.0",
+    "@webex/test-helper-chai": "3.8.0",
+    "@webex/test-helper-file": "3.8.0",
+    "@webex/test-helper-make-local-url": "3.8.0",
+    "@webex/test-helper-mocha": "3.8.0",
+    "@webex/test-helper-mock-webex": "3.8.0",
+    "@webex/test-helper-retry": "3.8.0",
+    "@webex/test-helper-test-users": "3.8.0",
     "eslint": "^8.24.0",
     "prettier": "^2.7.1",
     "sinon": "^9.2.4"
@@ -56,5 +56,5 @@
     "test:style": "eslint ./src/**/*.*",
     "test:unit": "webex-legacy-tools test --unit --runner jest"
   },
-  "version": "3.7.0"
+  "version": "3.8.0"
 }

package/src/conversation.js

@@ -303,15 +303,16 @@ const Conversation = WebexPlugin.extend({
   },
 
   /**
-   * delete a reaction
-   * @param {Object} conversation
-   * @param {Object} reactionId,
-   * @param {String} recipientId,
+   * create a reaction
+   * @param {Object} conversation the conversation in which the reaction will be added
+   * @param {Object} reactionId reaction activity to be deleted
+   * @param {Object} actorId id of person object who is reacting
+   * @param {String} recipientId used when reacting to direct IMC messages
    * @returns {Promise<Activity>}
    */
-  deleteReaction(conversation, reactionId, recipientId) {
+  deleteReaction(conversation, reactionId, actorId, recipientId) {
     const deleteReactionPayload = {
-      actor: {objectType: 'person', id: this.webex.internal.device.userId},
+      actor: {objectType: 'person', id: actorId ?? this.webex.internal.device.userId},
       object: {
         id: reactionId,
         objectType: 'activity',
@@ -334,39 +335,43 @@ const Conversation = WebexPlugin.extend({
 
   /**
    * create a reaction
-   * @param {Object} conversation
+   * @param {Object} conversation the conversation in which the reaction will be added
    * @param {Object} displayName must be 'celebrate', 'heart', 'thumbsup', 'smiley', 'haha', 'confused', 'sad'
-   * @param {Object} activity activity object from convo we are reacting to
-   * @param {String} recipientId,
+   * @param {Object} parentActivity activity object from that we are reacting to
+   * @param {Object} actorId id of person object who is reacting
+   * @param {String} recipientId used when reacting to direct IMC messages
    * @returns {Promise<Activity>}
    */
-  addReaction(conversation, displayName, activity, recipientId) {
-    return this.createReactionHmac(displayName, activity).then((hmac) => {
-      const addReactionPayload = {
-        actor: {objectType: 'person', id: this.webex.internal.device.userId},
-        target: {
-          id: conversation.id,
-          objectType: 'conversation',
-        },
-        verb: 'add',
-        objectType: 'activity',
-        parent: {
-          type: 'reaction',
-          id: activity.id,
-        },
-        object: {
-          objectType: 'reaction2',
-          displayName,
-          hmac,
-        },
-      };
+  async addReaction(conversation, displayName, parentActivity, actorId, recipientId) {
+    let hmac;
+    if (this.config.includeEncryptionTransforms) {
+      hmac = await this.createReactionHmac(displayName, parentActivity);
+    }
 
-      if (recipientId) {
-        addReactionPayload.recipients = {items: [{id: recipientId, objectType: 'person'}]};
-      }
+    const addReactionPayload = {
+      actor: {objectType: 'person', id: actorId ?? this.webex.internal.device.userId},
+      target: {
+        id: conversation.id,
+        objectType: 'conversation',
+      },
+      verb: 'add',
+      objectType: 'activity',
+      parent: {
+        type: 'reaction',
+        id: parentActivity.id,
+      },
+      object: {
+        objectType: 'reaction2',
+        displayName,
+        hmac,
+      },
+    };
 
-      return this.sendReaction(conversation, addReactionPayload);
-    });
+    if (recipientId) {
+      addReactionPayload.recipients = {items: [{id: recipientId, objectType: 'person'}]};
+    }
+
+    return this.sendReaction(conversation, addReactionPayload);
   },
 
   /**

package/test/unit/spec/conversation.js

@@ -37,67 +37,78 @@ describe('plugin-conversation', () => {
     });
 
     describe('addReaction()', () => {
-      it('should add recipients to the payload if provided', () => {
-        const {conversation} = webex.internal;
-        const recipientId = 'example-recipient-id';
-        const expected = {items: [{id: recipientId, objectType: 'person'}]};
+      let conversation;
+      let recipientId;
+      let expectedRecipients;
+      let actorId;
+
+      beforeEach(() => {
+        conversation = webex.internal.conversation;
+        recipientId = 'example-recipient-id';
+        actorId = 'actorId-123';
+        expectedRecipients = {items: [{id: recipientId, objectType: 'person'}]};
         conversation.sendReaction = sinon.stub().returns(Promise.resolve());
         conversation.createReactionHmac = sinon.stub().returns(Promise.resolve('hmac'));
+      });
+      it('should add recipients to the payload if provided', async () => {
+        conversation.config.includeEncryptionTransforms = true;
 
-        return conversation.addReaction({}, 'example-display-name', {}, recipientId).then(() => {
-          assert.deepEqual(conversation.sendReaction.args[0][1].recipients, expected);
-        });
+        await conversation.addReaction({}, 'example-display-name', {}, actorId, recipientId);
+        assert.called(conversation.createReactionHmac);
+        assert.deepEqual(conversation.sendReaction.args[0][1].recipients, expectedRecipients);
       });
-    });
 
-    describe('deleteReaction()', () => {
-      it('should add recipients to the payload if provided', () => {
-        const {conversation} = webex.internal;
-        const recipientId = 'example-recipient-id';
-        const expected = {items: [{id: recipientId, objectType: 'person'}]};
-        conversation.sendReaction = sinon.stub().returns(Promise.resolve());
+      it('will not call createReactionHmac if config prohibits', async () => {
+        conversation.config.includeEncryptionTransforms = false;
 
-        return conversation.deleteReaction({}, 'example-reaction-id', recipientId).then(() => {
-          assert.deepEqual(conversation.sendReaction.args[0][1].recipients, expected);
-        });
+        await conversation.addReaction({}, 'example-display-name', {}, actorId, recipientId);
+        assert.deepEqual(conversation.sendReaction.args[0][1].recipients, expectedRecipients);
+        assert.notCalled(conversation.createReactionHmac);
       });
-    });
 
-    describe('prepare()', () => {
-      it('should ammend activity recipients to the returned object', () => {
-        const {conversation} = webex.internal;
-        const activity = {recipients: 'example-recipients'};
+      it('should use actorId if provided', async () => {
+        await conversation.addReaction({}, 'example-display-name', {}, actorId, recipientId);
+        assert.equal(conversation.sendReaction.args[0][1].actor.id, actorId);
+      });
 
-        return conversation.prepare(activity).then((results) => {
-          assert.deepEqual(results.recipients, activity.recipients);
-        });
+      it('should use fallback device.userId if no actorId provided', async () => {
+        const defaultUserId = 'fallback-id';
+        webex.internal.device.userId = defaultUserId;
+        await conversation.addReaction({}, 'example-display-name', {}, undefined, recipientId);
+        assert.equal(conversation.sendReaction.args[0][1].actor.id, defaultUserId);
       });
     });
 
-    describe('addReaction()', () => {
-      it('should add recipients to the payload if provided', () => {
-        const {conversation} = webex.internal;
-        const recipientId = 'example-recipient-id';
-        const expected = {items: [{id: recipientId, objectType: 'person'}]};
+    describe('deleteReaction()', () => {
+      let conversation;
+      let recipientId;
+      let expectedRecipients;
+      let actorId;
+
+      beforeEach(() => {
+        conversation = webex.internal.conversation;
+        recipientId = 'example-recipient-id';
+        actorId = 'actorId-123';
+        expectedRecipients = {items: [{id: recipientId, objectType: 'person'}]};
         conversation.sendReaction = sinon.stub().returns(Promise.resolve());
         conversation.createReactionHmac = sinon.stub().returns(Promise.resolve('hmac'));
+      });
 
-        return conversation.addReaction({}, 'example-display-name', {}, recipientId).then(() => {
-          assert.deepEqual(conversation.sendReaction.args[0][1].recipients, expected);
-        });
+      it('should add recipients to the payload if provided', async () => {
+        await conversation.deleteReaction({}, 'example-reaction-id', actorId, recipientId);
+        assert.deepEqual(conversation.sendReaction.args[0][1].recipients, expectedRecipients);
       });
-    });
 
-    describe('deleteReaction()', () => {
-      it('should add recipients to the payload if provided', () => {
-        const {conversation} = webex.internal;
-        const recipientId = 'example-recipient-id';
-        const expected = {items: [{id: recipientId, objectType: 'person'}]};
-        conversation.sendReaction = sinon.stub().returns(Promise.resolve());
+      it('should use actorId if provided', async () => {
+        await conversation.deleteReaction({}, 'example-reaction-id', actorId, recipientId);
+        assert.equal(conversation.sendReaction.args[0][1].actor.id, actorId);
+      });
 
-        return conversation.deleteReaction({}, 'example-reaction-id', recipientId).then(() => {
-          assert.deepEqual(conversation.sendReaction.args[0][1].recipients, expected);
-        });
+      it('should use fallback device.userId if no actorId provided', async () => {
+        const defaultUserId = 'fallback-id';
+        webex.internal.device.userId = defaultUserId;
+        await conversation.deleteReaction({}, 'example-reaction-id', undefined, recipientId);
+        assert.equal(conversation.sendReaction.args[0][1].actor.id, defaultUserId);
       });
     });