hulawho/src/User.js

hulawho api

var async = require('async')
var mongoose = require('mongoose')
var UserModel = require('./models/schema').User
var ResetModel = require('./models/schema').Reset
var Leaderboard = require('./Leaderboard')
var crypto = require('./modules/crypto_primitives')

function User(profile) {
  var self = this

  if(profile) {
    self.auth = profile.auth
    if (self.auth == 'password') {
      self.password = profile.password
    }
    self.name = profile.name
    self.nick = profile.nick
    self.email = profile.email
  }
}

User.prototype.register = function(callback) {
  var self = this

  if(self.auth == 'password') {
    async.series([
      function(callback) {
        self.passwordRegister(callback)
      },
      function(callback) {
        self.populateLeaderboard(callback)
      }
    ], function(err, res) {
      if(err) {
        callback(err)
        return
      }

      callback(null, {status: 200, message: 'USER REGISTRATION AND INITIALIZATION OK'})
    })
  }
}

User.prototype.authenticate = function(authData, callback) {
  var self = this
  self.authData = authData

  if (self.authData.auth == 'password') {
    self.passwordAuthenticate(callback)
  }
}

User.prototype.passwordAuthenticate = function(callback) {
  var self = this

  UserModel.findOne({email: self.authData.email}, function(err, candidate) {
    if (err) {
      callback(err)
      return
    }

    if(!candidate) {
      callback({status: 404, message: 'ACCOUNT NOT FOUND'})
      return
    }

    crypto.verifyKdf(candidate.kdf, self.authData.password, function(err, res) {
      if(err) {
        callback(err)
        return
      }

      if(res != true) {
        callback({status: 423, message: 'USER AUTHENTICATION FAILURE'})
        return
      }

      var resObject = {}

      self.id = resObject.id = candidate._id
      self.name = resObject.name = candidate.name
      self.nick = resObject.nick = candidate.nick
      self.email = resObject.email = candidate.email
      self.verified = resObject.verified = candidate.verified

      callback(null, {status: 200, message: 'USER AUTHENTICATION OK', data: resObject})
    })
  })
}

User.prototype.passwordRegister = function(callback) {
  var self = this

  UserModel.findOne({ $or: [ { email: self.email }, { nick: self.nick } ] }, function(err, res) {
    if(err) {
      callback(err)
      return
    }

    if(res) {
      callback({status: 401, message: 'EMAIL OR NICK ALREADY REGISTERED'})
      return
    }

    var entry = {auth: self.auth, name: self.name, nick: self.nick, email: self.email}

    crypto.generateKdf(self.password, function(err, res) {
      if(err) {
        callback(err)
        return
      }

      entry.kdf = res

      var user = new UserModel(entry)
      user.save(function(err, res) {
        if(err) {
          callback(err)
          return
        }

        self.id = res.id
        self.verified = res.verified

        callback(null, {status: 200, message: 'USER REGISTRATION OK'})
      })
    })
  })
}

User.prototype.populateLeaderboard = function(callback) {
  var self = this
  var leaderboard = new Leaderboard()

  leaderboard.addUser(self.id, function(err, res) {
    if(err) {
      callback(err)
      return
    }

    callback(null, {status: 200, message: 'LEADERBOARD POPULATION OK'})
  })
}

User.prototype.pushLeague = function(user, league, callback) {
  var self = this
  self.id = user

  UserModel.findOneAndUpdate({_id: self.id}, {$push: {leagues: league}}, function(err, res) {
    if(err) {
      callback(err)
      return
    }

    if(!res) {
      callback({status: 428, message: 'USER NOT FOUND'})
      return
    }

    callback(null, {status: 200, message: 'USER LEAGUE PUSH OK'})
  })
}

module.exports = User