merge master

services/karma.js

@@ -0,0 +1,155 @@
+const debug = require('debug')('talk:trust');
+const UserModel = require('../models/user');
+
+/**
+ * This will create an object with the property name of the action type as the
+ * key and an object as it's value. This will contain a RELIABLE, and UNRELIABLE
+ * property with the number of karma points associated with their particular
+ * state.
+ * 
+ * If only the RELIABLE variable is provided, then it will also be used as the
+ * UNRELIABLE variable.
+ * 
+ * The form of the environment variable is:
+ * 
+ *  <name>:<RELIABLE>,<UNRELIABLE>;<name>:<RELIABLE>,<UNRELIABLE>;...
+ * 
+ * The default used is:
+ * 
+ *  comment:1,1;flag:-1,-1
+ */
+const parseThresholds = (thresholds) => thresholds
+  .split(';')
+  .filter((threshold) => threshold && threshold.length > 0)
+  .reduce((acc, threshold) => {
+    const thresholds = threshold.split(':');
+    if (thresholds.length < 2) {
+      return acc;
+    }
+
+    let [name, values] = thresholds;
+    let [RELIABLE, UNRELIABLE] = values.split(',').map((value) => parseInt(value));
+
+    if (!(name in acc)) {
+      acc[name] = {};
+    }
+
+    if (isNaN(UNRELIABLE) && !isNaN(RELIABLE)) {
+      acc[name].RELIABLE = RELIABLE;
+      acc[name].UNRELIABLE = RELIABLE;
+    } else {
+      if (!isNaN(UNRELIABLE)) {
+        acc[name].UNRELIABLE = UNRELIABLE;
+      }
+
+      if (!isNaN(RELIABLE)) {
+        acc[name].RELIABLE = RELIABLE;
+      }
+    }
+
+    return acc;
+  }, {
+    comment: {
+      RELIABLE: -1,
+      UNRELIABLE: -1
+    },
+    flag: {
+      RELIABLE: -1,
+      UNRELIABLE: -1
+    }
+  });
+
+const THRESHOLDS = parseThresholds(process.env.TRUST_THRESHOLDS || '');
+
+debug('using thresholds: ', THRESHOLDS);
+
+/**
+ * KarmaModel represents the checkable properties of a user and wrapps the
+ * KarmaService function `isReliable` to work flexibly with the graph.
+ */
+class KarmaModel {
+  constructor(model) {
+    this.model = model;
+  }
+
+  get flagger() {
+    return KarmaService.isReliable('flag', this.model);
+  }
+
+  get commenter() {
+    return KarmaService.isReliable('comment', this.model);
+  }
+}
+
+/**
+ * KarmaService provides interfaces for editing a user's karma.
+ */
+class KarmaService {
+
+  /**
+   * Model returns a KarmaModel based on the passed in user.
+   */
+  static model(user) {
+    if (user === null || !user.metadata || !user.metadata.trust) {
+      return new KarmaModel({});
+    }
+
+    return new KarmaModel(user.metadata.trust);
+  }
+
+  /**
+   * Inspects the reliability of a property and returns it if known.
+   * @param {String} name - name of the property
+   * @param {Object} trust - object possibly containing the propertys
+   */
+  static isReliable(name, trust) {
+    if (trust && trust[name]) {
+      if (trust[name].karma > THRESHOLDS[name].RELIABLE) {
+        return true;
+      } else if (trust[name].karma < THRESHOLDS[name].UNRELIABLE) {
+        return false;
+      }
+    } else if (THRESHOLDS[name].RELIABLE < 0) {
+      return true;
+    } else if (THRESHOLDS[name].UNRELIABLE > 0) {
+      return false;
+    }
+
+    return null;
+  }
+
+  /**
+   * modifyUserKarma updates the user to adjust their karma, for either the `type`
+   * of 'comment' or 'flag'. If `multi` is true, then it assumes that `id` is an
+   * array of id's.
+   */
+  static async modifyUser(id, direction = 1, type = 'comment', multi = false) {
+    const key = `metadata.trust.${type}.karma`;
+
+    let update = {
+      $inc: {
+        [key]: direction
+      }
+    };
+
+    if (multi) {
+
+      // If it was in multi-mode but there was no user's to adjust, bail.
+      if (id.length <= 0) {
+        return;
+      }
+
+      return UserModel.update({
+        id: {
+          $in: id
+        }
+      }, update, {
+        multi: true
+      });
+    }
+
+    return UserModel.update({id}, update);
+  }
+}
+
+module.exports = KarmaService;