@inspire-platform/sails-hook-auth/dist/api/controllers/PasswordResetTokenController.js

Passport-based User Authentication system for sails.js applications.

'use strict';

var _ = require('lodash');

module.exports = {

  find: function find(req, res) {
    return res.status(403).send();
  },

  findOne: function findOne(req, res) {
    return PasswordResetToken.findOne({ id: req.param('id') }).then(function (token) {
      if (token) {
        if (false === tokenIsExpired(token)) {
          return res.status(200).send();
        } else {
          return res.status(403).send({
            message: 'Token is expired.'
          });
        }
      } else {
        return res.status(400).send();
      }
    }).catch(function (err) {
      sails.log.error(err);
      return res.status(500).send();
    });
  },

  create: function create(req, res) {

    // email is required
    if (false === _.has(req.body, 'email')) {
      return res.status('400').send({
        message: 'The email property is required.'
      });
    }

    var email = req.body.email;

    return User.findOne({ email: email }).populate('passwordResetToken').then(function (user) {
      if (user) {
        return createToken(user).then(function (token) {
          return PasswordResetToken.NotifyTokenCreated(user, token);
        }).then(function () {
          return res.status(200).send();
        });
      } else {
        return res.status(403).send({
          message: 'No user with matching email address was found.'
        });
      }
    }).catch(function (cause) {
      sails.log.error(cause);
      return res.status(500).send();
    });
  },

  update: function update(req, res) {

    // password is required
    if (false === _.has(req.body, 'password')) {
      return res.status('400').send({
        message: 'The password property is required.'
      });
    }

    var tokenId = req.params.id;
    var password = req.body.password;

    return PasswordResetToken.findOne({ id: tokenId }).populate('user').then(function (token) {

      if (token) {
        if (false === tokenIsExpired(token)) {
          return updatePassword(token, password).then(function (user) {
            return PasswordResetToken.NotifyPasswordChanged(user);
          }).then(function () {
            return res.status(200).send();
          });
        } else {
          return res.status(403).send({
            message: 'Token is expired.'
          });
        }
      } else {
        return res.status(403).send({
          message: 'Token not found.'
        });
      }
    }).catch(function (cause) {
      sails.log.error(cause);
      var status = cause.status || 500;
      if (status === 400) {
        return res.badRequest(cause);
      }
      return res.status(status).send();
    });
  },

  destroy: function destroy(req, res) {
    return res.status(403).send();
  }

};

function createToken(user) {
  return new Promise(function (resolve, reject) {
    if (user.passwordResetToken.length) {
      // remove old one
      return PasswordResetToken.destroy({ id: user.passwordResetToken.map(function (prt) {
          return prt.id;
        }) }).then(resolve, reject);
    } else {
      // nothing to do
      return resolve();
    }
  }).then(function () {
    // create new token
    return PasswordResetToken.create({ user: user.id }).fetch();
  });
}

function updatePassword(token, password) {

  return new Promise(function (resolve, reject) {
    // try to update user password
    return sails.services.passport.protocols.local.update({
      id: token.user.id,
      password: password
    }, function (err, user) {
      // error?
      if (err) {
        return reject(err);
      } else {
        // password updated, destroy token
        return PasswordResetToken.destroy({ id: token.id }).then(function () {
          return resolve(user);
        }).catch(reject);
      }
    });
  });
}

function tokenIsExpired(token) {
  var now = new Date();
  var expires = new Date(token.expiresAt);

  return now >= expires;
}