Merge branch 'postgresql'

1 files changed, 200 insertions, 0 deletions

diff --git a/server/models/pod.js b/server/models/pod.js
new file mode 100644
index 000000000..b3c6db8e8
--- /dev/null
+++ b/server/models/pod.js
@@ -0,0 +1,200 @@
+'use strict'
+
+const map = require('lodash/map')
+
+const constants = require('../initializers/constants')
+const customPodsValidators = require('../helpers/custom-validators').pods
+
+// ---------------------------------------------------------------------------
+
+module.exports = function (sequelize, DataTypes) {
+  const Pod = sequelize.define('Pod',
+    {
+      host: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        validate: {
+          isHost: function (value) {
+            const res = customPodsValidators.isHostValid(value)
+            if (res === false) throw new Error('Host not valid.')
+          }
+        }
+      },
+      publicKey: {
+        type: DataTypes.STRING(5000),
+        allowNull: false
+      },
+      score: {
+        type: DataTypes.INTEGER,
+        defaultValue: constants.FRIEND_SCORE.BASE,
+        allowNull: false,
+        validate: {
+          isInt: true,
+          max: constants.FRIEND_SCORE.MAX
+        }
+      }
+    },
+    {
+      indexes: [
+        {
+          fields: [ 'host' ]
+        },
+        {
+          fields: [ 'score' ]
+        }
+      ],
+      classMethods: {
+        associate,
+
+        countAll,
+        incrementScores,
+        list,
+        listAllIds,
+        listRandomPodIdsWithRequest,
+        listBadPods,
+        load,
+        loadByHost,
+        removeAll
+      },
+      instanceMethods: {
+        toFormatedJSON
+      }
+    }
+  )
+
+  return Pod
+}
+
+// ------------------------------ METHODS ------------------------------
+
+function toFormatedJSON () {
+  const json = {
+    id: this.id,
+    host: this.host,
+    score: this.score,
+    createdAt: this.createdAt
+  }
+
+  return json
+}
+
+// ------------------------------ Statics ------------------------------
+
+function associate (models) {
+  this.belongsToMany(models.Request, {
+    foreignKey: 'podId',
+    through: models.RequestToPod,
+    onDelete: 'cascade'
+  })
+}
+
+function countAll (callback) {
+  return this.count().asCallback(callback)
+}
+
+function incrementScores (ids, value, callback) {
+  if (!callback) callback = function () {}
+
+  const update = {
+    score: this.sequelize.literal('score +' + value)
+  }
+
+  const options = {
+    where: {
+      id: {
+        $in: ids
+      }
+    },
+    // In this case score is a literal and not an integer so we do not validate it
+    validate: false
+  }
+
+  return this.update(update, options).asCallback(callback)
+}
+
+function list (callback) {
+  return this.findAll().asCallback(callback)
+}
+
+function listAllIds (transaction, callback) {
+  if (!callback) {
+    callback = transaction
+    transaction = null
+  }
+
+  const query = {
+    attributes: [ 'id' ]
+  }
+
+  if (transaction) query.transaction = transaction
+
+  return this.findAll(query).asCallback(function (err, pods) {
+    if (err) return callback(err)
+
+    return callback(null, map(pods, 'id'))
+  })
+}
+
+function listRandomPodIdsWithRequest (limit, callback) {
+  const self = this
+
+  self.count().asCallback(function (err, count) {
+    if (err) return callback(err)
+
+    // Optimization...
+    if (count === 0) return callback(null, [])
+
+    let start = Math.floor(Math.random() * count) - limit
+    if (start < 0) start = 0
+
+    const query = {
+      attributes: [ 'id' ],
+      order: [
+        [ 'id', 'ASC' ]
+      ],
+      offset: start,
+      limit: limit,
+      where: {
+        id: {
+          $in: [
+            this.sequelize.literal('SELECT "podId" FROM "RequestToPods"')
+          ]
+        }
+      }
+    }
+
+    return this.findAll(query).asCallback(function (err, pods) {
+      if (err) return callback(err)
+
+      return callback(null, map(pods, 'id'))
+    })
+  })
+}
+
+function listBadPods (callback) {
+  const query = {
+    where: {
+      score: { $lte: 0 }
+    }
+  }
+
+  return this.findAll(query).asCallback(callback)
+}
+
+function load (id, callback) {
+  return this.findById(id).asCallback(callback)
+}
+
+function loadByHost (host, callback) {
+  const query = {
+    where: {
+      host: host
+    }
+  }
+
+  return this.findOne(query).asCallback(callback)
+}
+
+function removeAll (callback) {
+  return this.destroy().asCallback(callback)
+}