const map = require('lodash/map')
const constants = require('../initializers/constants')
+const customPodsValidators = require('../helpers/custom-validators').pods
// ---------------------------------------------------------------------------
const Pod = sequelize.define('Pod',
{
host: {
- type: DataTypes.STRING
+ 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)
+ type: DataTypes.STRING(5000),
+ allowNull: false
},
score: {
type: DataTypes.INTEGER,
- defaultValue: constants.FRIEND_SCORE.BASE
+ defaultValue: constants.FRIEND_SCORE.BASE,
+ allowNull: false,
+ validate: {
+ isInt: true,
+ max: constants.FRIEND_SCORE.MAX
+ }
}
- // Check createdAt
},
{
+ indexes: [
+ {
+ fields: [ 'host' ]
+ },
+ {
+ fields: [ 'score' ]
+ }
+ ],
classMethods: {
associate,
incrementScores,
list,
listAllIds,
+ listRandomPodIdsWithRequest,
listBadPods,
load,
loadByHost,
return Pod
}
-// TODO: max score -> constants.FRIENDS_SCORE.MAX
-// TODO: validation
-// PodSchema.path('host').validate(validator.isURL)
-// PodSchema.path('publicKey').required(true)
-// PodSchema.path('score').validate(function (value) { return !isNaN(value) })
-
// ------------------------------ METHODS ------------------------------
function toFormatedJSON () {
this.belongsToMany(models.Request, {
foreignKey: 'podId',
through: models.RequestToPod,
- onDelete: 'CASCADE'
+ onDelete: 'cascade'
})
}
score: this.sequelize.literal('score +' + value)
}
- const query = {
+ 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, query).asCallback(callback)
+ return this.update(update, options).asCallback(callback)
}
function list (callback) {
return this.findAll().asCallback(callback)
}
-function listAllIds (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)
})
}
+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: {