Reorganize model files

1 files changed, 274 insertions, 0 deletions

diff --git a/server/models/pod/pod.ts b/server/models/pod/pod.ts
new file mode 100644
index 000000000..4c6e63024
--- /dev/null
+++ b/server/models/pod/pod.ts
@@ -0,0 +1,274 @@
+import { each, waterfall } from 'async'
+import { map } from 'lodash'
+import * as Sequelize from 'sequelize'
+
+import { FRIEND_SCORE, PODS_SCORE } from '../../initializers'
+import { logger, isHostValid } from '../../helpers'
+
+import { addMethodsToModel } from '../utils'
+import {
+  PodClass,
+  PodInstance,
+  PodAttributes,
+
+  PodMethods
+} from './pod-interface'
+
+let Pod: Sequelize.Model<PodInstance, PodAttributes>
+let toFormatedJSON: PodMethods.ToFormatedJSON
+let countAll: PodMethods.CountAll
+let incrementScores: PodMethods.IncrementScores
+let list: PodMethods.List
+let listAllIds: PodMethods.ListAllIds
+let listRandomPodIdsWithRequest: PodMethods.ListRandomPodIdsWithRequest
+let listBadPods: PodMethods.ListBadPods
+let load: PodMethods.Load
+let loadByHost: PodMethods.LoadByHost
+let removeAll: PodMethods.RemoveAll
+let updatePodsScore: PodMethods.UpdatePodsScore
+
+export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
+  Pod = sequelize.define<PodInstance, PodAttributes>('Pod',
+    {
+      host: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        validate: {
+          isHost: function (value) {
+            const res = isHostValid(value)
+            if (res === false) throw new Error('Host not valid.')
+          }
+        }
+      },
+      publicKey: {
+        type: DataTypes.STRING(5000),
+        allowNull: false
+      },
+      score: {
+        type: DataTypes.INTEGER,
+        defaultValue: FRIEND_SCORE.BASE,
+        allowNull: false,
+        validate: {
+          isInt: true,
+          max: FRIEND_SCORE.MAX
+        }
+      },
+      email: {
+        type: DataTypes.STRING(400),
+        allowNull: false,
+        validate: {
+          isEmail: true
+        }
+      }
+    },
+    {
+      indexes: [
+        {
+          fields: [ 'host' ],
+          unique: true
+        },
+        {
+          fields: [ 'score' ]
+        }
+      ]
+    }
+  )
+
+  const classMethods = [
+    associate,
+
+    countAll,
+    incrementScores,
+    list,
+    listAllIds,
+    listRandomPodIdsWithRequest,
+    listBadPods,
+    load,
+    loadByHost,
+    updatePodsScore,
+    removeAll
+  ]
+  const instanceMethods = [ toFormatedJSON ]
+  addMethodsToModel(Pod, classMethods, instanceMethods)
+
+  return Pod
+}
+
+// ------------------------------ METHODS ------------------------------
+
+toFormatedJSON = function () {
+  const json = {
+    id: this.id,
+    host: this.host,
+    email: this.email,
+    score: this.score,
+    createdAt: this.createdAt
+  }
+
+  return json
+}
+
+// ------------------------------ Statics ------------------------------
+
+function associate (models) {
+  Pod.belongsToMany(models.Request, {
+    foreignKey: 'podId',
+    through: models.RequestToPod,
+    onDelete: 'cascade'
+  })
+}
+
+countAll = function (callback: PodMethods.CountAllCallback) {
+  return Pod.count().asCallback(callback)
+}
+
+incrementScores = function (ids: number[], value: number, callback?: PodMethods.IncrementScoresCallback) {
+  if (!callback) callback = function () { /* empty */ }
+
+  const update = {
+    score: 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 Pod.update(update, options).asCallback(callback)
+}
+
+list = function (callback: PodMethods.ListCallback) {
+  return Pod.findAll().asCallback(callback)
+}
+
+listAllIds = function (transaction: Sequelize.Transaction, callback: PodMethods.ListAllIdsCallback) {
+  const query: any = {
+    attributes: [ 'id' ]
+  }
+
+  if (transaction !== null) query.transaction = transaction
+
+  return Pod.findAll(query).asCallback(function (err: Error, pods) {
+    if (err) return callback(err)
+
+    return callback(null, map(pods, 'id'))
+  })
+}
+
+listRandomPodIdsWithRequest = function (limit: number, tableWithPods: string, tableWithPodsJoins: string, callback: PodMethods.ListRandomPodIdsWithRequestCallback) {
+  Pod.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: [
+            Sequelize.literal(`SELECT DISTINCT "${tableWithPods}"."podId" FROM "${tableWithPods}" ${tableWithPodsJoins}`)
+          ]
+        }
+      }
+    }
+
+    return Pod.findAll(query).asCallback(function (err, pods) {
+      if (err) return callback(err)
+
+      return callback(null, map(pods, 'id'))
+    })
+  })
+}
+
+listBadPods = function (callback: PodMethods.ListBadPodsCallback) {
+  const query = {
+    where: {
+      score: { $lte: 0 }
+    }
+  }
+
+  return Pod.findAll(query).asCallback(callback)
+}
+
+load = function (id: number, callback: PodMethods.LoadCallback) {
+  return Pod.findById(id).asCallback(callback)
+}
+
+loadByHost = function (host: string, callback: PodMethods.LoadByHostCallback) {
+  const query = {
+    where: {
+      host: host
+    }
+  }
+
+  return Pod.findOne(query).asCallback(callback)
+}
+
+removeAll = function (callback: PodMethods.RemoveAllCallback) {
+  return Pod.destroy().asCallback(callback)
+}
+
+updatePodsScore = function (goodPods: number[], badPods: number[]) {
+  logger.info('Updating %d good pods and %d bad pods scores.', goodPods.length, badPods.length)
+
+  if (goodPods.length !== 0) {
+    incrementScores(goodPods, PODS_SCORE.BONUS, function (err) {
+      if (err) logger.error('Cannot increment scores of good pods.', { error: err })
+    })
+  }
+
+  if (badPods.length !== 0) {
+    incrementScores(badPods, PODS_SCORE.MALUS, function (err) {
+      if (err) logger.error('Cannot decrement scores of bad pods.', { error: err })
+      removeBadPods()
+    })
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+// Remove pods with a score of 0 (too many requests where they were unreachable)
+function removeBadPods () {
+  waterfall([
+    function findBadPods (callback) {
+      listBadPods(function (err, pods) {
+        if (err) {
+          logger.error('Cannot find bad pods.', { error: err })
+          return callback(err)
+        }
+
+        return callback(null, pods)
+      })
+    },
+
+    function removeTheseBadPods (pods, callback) {
+      each(pods, function (pod: any, callbackEach) {
+        pod.destroy().asCallback(callbackEach)
+      }, function (err) {
+        return callback(err, pods.length)
+      })
+    }
+  ], function (err, numberOfPodsRemoved) {
+    if (err) {
+      logger.error('Cannot remove bad pods.', { error: err })
+    } else if (numberOfPodsRemoved) {
+      logger.info('Removed %d pods.', numberOfPodsRemoved)
+    } else {
+      logger.info('No need to remove bad pods.')
+    }
+  })
+}