Webhook improvements (#7879)

* refactor: Move translate test utility to helpers directory

* Add kind property to webhooks

* feat: Add options to create webhook route

* refactor: Move webhook ops into single file

* refactor: Create webhook objects for specific webhook behavior

* chore(tests): Add default sleep helper value of 1 second

* feat(api): Add method for groups to send out webhook

* feat(api): Add taskCreated webhook task creation

* feat(api): Send chat webhooks after a chat is sent

* refactor: Move webhook routes to own controller

* lint: Correct linting errors

* fix(api): Correct taskCreated webhook method

* fix(api): Fix webhook logging to only log when there is an error

* fix: Update groupChatRecieved webhook creation

* chore: Add integration tests for webhooks

* fix: Set webhook creation response to 201

* fix: Correct how task scored webhook data is sent

* Revert group chat recieved webhook to only support one group

* Remove quest activity option for webhooks

* feat: Send webhook for each task created

* feat: Allow webhooks without a type to default to taskScored

* feat: Add logic for adding ids to webhook

* feat: optimize webhook url check by shortcircuiting if no url is passed

* refactor: Use full name for webhook variable

* feat: Add missing params to client webhook

* lint: Add missing semicolon

* chore(tests): Fix inccorect webhook tests

* chore: Add migration to update task scored webhooks

* feat: Allow default value of webhook add route to be enabled

* chore: Update webhook documentation

* chore: Remove special handling for v2

* refactor: adjust addComputedStatsToJSONObject to work for webhooks

* refactor: combine taskScored and taskActivity webhooks

* feat(api): Add task activity to task update and delete routes

* chore: Change references to taskScored to taskActivity

* fix: Correct stats object being passed in for transform

* chore: Remove extra line break

* fix: Pass in the language to use for the translations

* refactor(api): Move webhooks from user.preferences.webhooks to user.webhooks

* chore: Update migration to set webhook array

* lint: Correct brace spacing

* chore: convert webhook lib to use user.webhooks

* refactor(api): Consolidate filters

* chore: clarify migration instructions

* fix(test): Correct user creation in user anonymized tests

* chore: add test that webhooks cannot be updated via PUT /user

* refactor: Simplify default webhook id value

* refactor(client): Push newly created webhook instead of doing a sync

* chore(test): Add test file for webhook model

* refactor: Remove webhook validation

* refactor: Remove need for watch on webhooks

* refactor(client): Update webhooks object without syncing

* chore: update webhook documentation

* Fix migrations issues

* chore: remove v2 test helper

* fix(api): Provide webhook type in task scored webhook

* fix(client): Fix webhook deletion appearing to delete all webhooks

* feat(api): add optional label field for webhooks

* feat: provide empty string as default for webhook label

* chore: Update webhook migration

* chore: update webhook migration name

website/server/libs/webhook.js

@@ -1,9 +1,8 @@
-import { each } from 'lodash';
 import { post } from 'request';
 import { isURL } from 'validator';
 import logger from './logger';
 
-let _sendWebhook = (url, body) => {
+function sendWebhook (url, body) {
   post({
     url,
     body,
@@ -13,23 +12,100 @@ let _sendWebhook = (url, body) => {
       logger.error(err);
     }
   });
-};
+}
 
-let _isInvalidWebhook = (hook) => {
-  return !hook.enabled || !isURL(hook.url);
-};
+function isValidWebhook (hook) {
+  return hook.enabled && isURL(hook.url);
+}
 
-export function sendTaskWebhook (webhooks, data) {
-  each(webhooks, (hook) => {
-    if (_isInvalidWebhook(hook)) return;
+export class WebhookSender {
+  constructor (options = {}) {
+    this.type = options.type;
+    this.transformData = options.transformData || WebhookSender.defaultTransformData;
+    this.webhookFilter = options.webhookFilter || WebhookSender.defaultWebhookFilter;
+  }
 
-    let body = {
-      direction: data.task.direction,
-      task: data.task.details,
-      delta: data.task.delta,
-      user: data.user,
+  static defaultTransformData (data) {
+    return data;
+  }
+
+  static defaultWebhookFilter () {
+    return true;
+  }
+
+  send (webhooks, data) {
+    let hooks = webhooks.filter((hook) => {
+      return isValidWebhook(hook) &&
+        this.type === hook.type &&
+        this.webhookFilter(hook, data);
+    });
+
+    if (hooks.length < 1) {
+      return; // prevents running the body creation code if there are no webhooks to send
+    }
+
+    let body = this.transformData(data);
+
+    hooks.forEach((hook) => {
+      sendWebhook(hook.url, body);
+    });
+  }
+}
+
+export let taskScoredWebhook = new WebhookSender({
+  type: 'taskActivity',
+  webhookFilter (hook) {
+    let scored = hook.options && hook.options.scored;
+
+    return scored;
+  },
+  transformData (data) {
+    let { user, task, direction, delta } = data;
+
+    let extendedStats = user.addComputedStatsToJSONObj(user.stats.toJSON());
+
+    let userData = {
+      _id: user._id,
+      _tmp: user._tmp,
+      stats: extendedStats,
     };
 
-    _sendWebhook(hook.url, body);
-  });
-}
+    let dataToSend = {
+      type: 'scored',
+      direction,
+      delta,
+      task,
+      user: userData,
+    };
+
+    return dataToSend;
+  },
+});
+
+export let taskActivityWebhook = new WebhookSender({
+  type: 'taskActivity',
+  webhookFilter (hook, data) {
+    let { type } = data;
+    return hook.options[type];
+  },
+});
+
+export let groupChatReceivedWebhook = new WebhookSender({
+  type: 'groupChatReceived',
+  webhookFilter (hook, data) {
+    return hook.options.groupId === data.group.id;
+  },
+  transformData (data) {
+    let { group, chat } = data;
+
+    let dataToSend = {
+      group: {
+        id: group.id,
+        name: group.name,
+      },
+      chat,
+    };
+
+    return dataToSend;
+  },
+});