sequelize.js validateur personnalisé, contrôler l'unicité du nom d'utilisateur / mot de passe

Imaginer j'ai défini le suivant validateur personnalisé fonction:

isUnique: function () { //This works as expected
  throw new Error({error:[{message:'Email address already in use!'}]});
}

Cependant, lorsque je tente d'interroger la DB je rencontre des problèmes:

isUnique: function (email) { //This doesn't work
  var User = seqeulize.import('/path/to/user/model');

  User.find({where:{email: email}})
    .success(function () { //This gets called
      throw new Error({error:[{message:'Email address already in use!'}]});  //But this isn't triggering a validation error.
    });
}

Comment puis-je interroger l'ORM dans un validateur personnalisé et de déclencher une erreur de validation basée sur la réponse de l'ORM?

bien que ne fonctionne pas, vous pouvez essayer de course simple .find() et dans le rappel de manipuler le résultat de la requête et de l'appel response.render ou quoi que ce soit d'autre pour envoyer un message à l'utilisateur.
Sérieusement!? Je suis en train de programme pour la Sequelize interface plutôt qu'une mise en œuvre solide. Pourquoi ne pas le travail ci-dessus? Je peux seulement imaginer que .trouver est la capture de l'erreur quelque part?
Juste pour clarifier, de l'Utilisateur.find({où:{email: email}}).success() fonctionne parfaitement (comme spécifié dans le Sequelize docs). Le problème est que Sequelize n'est pas la capture de l'Erreur, ou l'erreur est d'être pris ailleurs.
autant que je sache User.find() renvoie à un événement, il provoquera une erreur lors de l'événement est émis, de sorte que l'appel de la isUnique("[email protected]"), et même essayer de try..catch ne le fera pas.
Ok, on dirait que j'ai beaucoup de travail à faire pour obtenir Sequelize en forme. C'est loin d'être aussi robuste que j'avais été amené à croire...

OriginalL'auteur Matt Richards | 2013-05-03

19

Vous pouvez vérifier si l'email existe déjà comme ça:
```
email: {
  type: Sequelize.STRING,
  allowNull: false,
  validate: {
    isEmail:true
  },
  unique: {
      args: true,
      msg: 'Email address already in use!'
  }
}
```
Ce! Je ne comprends pas pourquoi les autres ont besoin pour exécuter un user.find avant de l'insérer.
oui, vous pouvez le faire & évidemment, de son mieux, mais si vous avez d'auto incrémentation de la valeur dans la table, alors si votre requête d'insertion échoue en raison de l'unique violation puis aussi votre auto incrément id va augmenter, oui, c'est la façon dont tout le SQL fonctionne.
Je suis confus, vous semblez utiliser unique propriété de la colonne email (c'est à dire non pas comme une propriété de votre validate objet). La doc dire que attributes.column.unique peut avoir valeur de String | Boolean ; mais que votre valeur est un (pas de String ou Boolean) dont la valeur est : ` { args: true, msg : '...' }` . Cette valeur ressemble à comment vous pouvez l'utiliser unique si vous l'avez ajouté à la validate objet; mais vous avez unique directement sur la email (alias de colonne) de l'objet...
Le unique paramètre accepte un objet si il ont args comme une 'Chaîne' ou un 'Boolean' valeur. Le msg attribut est utilisé comme un message de validation.
J'ai changé cela pour la accepté de répondre. Il a été répondu à presque 4 ans après l'original de la question et je viens de remarquer que c'.

OriginalL'auteur alvaropaco

Voici un échantillons simplifiée du fonctionnement d'un isUnique validation de rappel (fonctionne aussi de SequelizeJS v2.0.0). J'ai ajouté des commentaires pour expliquer les choses importantes:

var UserModel = sequelize.define('User', {

    id: {
        type: Sequelize.INTEGER(11).UNSIGNED,
        autoIncrement: true,
        primaryKey: true
    },
    email: {
        type: Sequelize.STRING,
        validate: {
            isUnique: function(value, next) {

                UserModel.find({
                    where: {email: value},
                    attributes: ['id']
                })
                    .done(function(error, user) {

                        if (error)
                            //Some unexpected error occured with the find method.
                            return next(error);

                        if (user)
                            //We found a user with this email address.
                            //Pass the error to the next method.
                            return next('Email address already in use!');

                        //If we got this far, the email address hasn't been used yet.
                        //Call next with no arguments when validation is successful.
                        next();

                    });

            }
        }
    }

});

module.exports = UserModel;

OriginalL'auteur c.hill

Avec Sequelize 2.0, vous devez attraper les Erreurs de Validation.

Tout d'abord, définissons le Modèle de l'Utilisateur avec un validateur personnalisé:

var User = sequelize.define('User',
    {
        email: {
            type: Sequelize.STRING,
            allowNull: false,
            unique: true,
            validate: {
                isUnique: function (value, next) {
                    var self = this;
                    User.find({where: {email: value}})
                        .then(function (user) {
                            //reject if a different user wants to use the same email
                            if (user && self.id !== user.id) {
                                return next('Email already in use!');
                            }
                            return next();
                        })
                        .catch(function (err) {
                            return next(err);
                        });
                }
            }
        },
        other_field: Sequelize.STRING
    });

module.exports = User;

Puis, dans le contrôleur, la capture des Erreurs de Validation:

var Sequelize = require('sequelize'),
    _ = require('lodash'),
    User = require('./path/to/User.model');

exports.create = function (req, res) {
    var allowedKeys = ['email', 'other_field'];
    var attributes = _.pick(req.body, allowedKeys);
    User.create(attributes)
        .then(function (user) {
            res.json(user);
        })
        .catch(Sequelize.ValidationError, function (err) {
            //respond with validation errors
            return res.status(422).send(err.errors);
        })
        .catch(function (err) {
            //every other error
            return res.status(400).send({
                message: err.message
            });
        });

OriginalL'auteur Jon Saw

4

Succès de rappel, même si aucun utilisateur n'est trouvé. Vous devez vérifier si la fonction réussit un utilisateur comme un argument:
```
isUnique: function (email) { //This doesn't work
  var User = seqeulize.import('/path/to/user/model');

  User.find({where:{email: email}})
    .success(function (u) { //This gets called
      if(u){
        throw new Error({error:[{message:'Email address already in use!'}]});  //But this isn't triggering a validation error.
      }
    });
}
```
Je suis troublé par le fait que le code de la accepté de répondre inclut un commentaire qui dit "ceci ne fonctionne pas". Surtout depuis que le code semble reposer sur la chose, qui, vraisemblablement, ne fonctionne pas.
C'est parce que je viens de copier le code dans la question et a ajouté l'instruction si donc il serait de travailler

OriginalL'auteur Alejo

Vous devez vous connecter pour publier un commentaire.