Pass: Ermöglicht anmelden mit name und E-Mail-Adresse? (Lokale Strategie)

Hier ist was für mich gearbeitet, die Lösung basiert auf einem Mungo basiert odm, der erste Teil ist die passport-bezogenen Teil, den ich auch an den Benutzer als Teil von odm, um zu zeigen, wie sich die Verschlüsselung des Passworts erfolgt.

Wenn ich deine Frage verstanden, du willst den Benutzer zur Eingabe entweder seine E-Mail oder Passwort. In diesem Fall ändern Sie die Suche, um zu versuchen beide, das ist, übereinstimmung der bereitgestellten Benutzer-id (in Ihrem Aufruf von findOne(...) entweder mit dem Benutzernamen oder Passwort.

Hinweis, dass ich bcrypt zu vermeiden, speichern Passwörter löschen, das ist, warum es ist eine angepasste compare-Methode für das testen von Passwörtern. Beachten Sie auch 'Tipps' mit google auth als auch, Mein system aktiviert, wenn es relevant ist, bitte laß mich wissen, und ich kann hinzufügen, den erforderlichen code.

------------ Auth-Teil (nur relevante snippets) -----------

var passport = require('passport'),
LocalStrategy = require('passport-local').Strategy;

passport.serializeUser(function(user, done) {
    //the values returned here will be used to deserializeUser
    //this can be use for further logins
    done(null, {username: user.username, _id: user.id, role: user.role});
});

passport.deserializeUser(function(user, done) {
    done(null, user);
});


passport.use(new LocalStrategy(function(username, password, done){
    odm.User.findOne({username: username, authType: 'direct'}, function(err, user){
        if(err){
            return done(err, false);
        }
        if(!user){
            return done(null, false);
        }
        if(user.role === 'new'){
            console.log('can not use new user!');
            return done('user not activated yet, please contact admin', false);
        }
        user.comparePassword(password,function(err, isMatch){
            if(err){
                return done(err, false);
            }
            if(isMatch){
                return done(null, user);//{username: username});
            }
            return done(null, false);
        });
    });
}));
app.post('/login',  function(req, res, next){
        passport.authenticate('local', {
            failureRedirect: '/logout?status=login failed'
        }, function(err, user, info){
                if(err){
                    return next(err);
                }
                if(!user){
                    return res.redirect('/login');
                }
                req.logIn(user, function(err){
                    if (req.body.rememberme) {
                        req.session.cookie.maxAge = 30*24*60*60*1000 ;//Rememeber 'me' for 30 days
                    } else {
                        req.session.cookie.expires = false;
                    }
                    var redirect = req.param('redirect') || '/index';
                    res.redirect(redirect);
                });
            }
        )(req, res, next);
    }
);

app.post('/register',function(req, res){
    var user = new odm.User({username: req.body.username, password: req.body.password, email: req.body.email, authType: 'direct'});
    user.save(function(err, user){
        if(err){
            console.log('registration err: ' , err);
        } else {
            res.redirect('/list');
        }
    });
});

--- Benutzer - /odm-relevanten Teile ----------------

var bcrypt = require('bcrypt-nodejs');

//--------------------- User ------------------------------------------ //
var userSchema = new Schema({
    name: String,
    email: String,
    username: {type: String, required: true, unique: true},
    password: String,
    role: {type: String, required: true, enum: ['new', 'admin', 'user'], default: 'new'},
    authType: {type: String, enum: ['google', 'direct'], required: true}
});

userSchema.pre('save', function (next) {
    var user = this;
    if (!user.isModified('password')) return next();

    console.log('making hash...........');
    bcrypt.genSalt(SALT_WORK_FACTOR, function (err, salt) {
        if (err) return next(err);

        bcrypt.hash(user.password, salt, null, function (err, hash) {
            if (err) return next(err);
            user.password = hash;
            next();
        });
    });
});

userSchema.methods.comparePassword = function (candidatePassword, cb) {
    bcrypt.compare(candidatePassword, this.password, function (err, isMatch) {
        if (err) return cb(err);
        cb(null, isMatch);
    });
};

Das hat nichts zu tun mit passport und ist ziemlich einfach, vorausgesetzt, Sie verwenden body-parser. Stellen Sie sicher, Sie haben eine input field im Formular mit dem Attribut name="name" wo Sie registrieren den Namen des Benutzers wie:

<div class="form-group">
    <label for="signup-name">Name</label>
    <input type="text" placeholder="Name" name="name">
</div> 

In Ihre routing, können Sie auf dieses Feld mit req.body.name:

passport.use('local-signup', new LocalStrategy({
    usernameField: 'email',
    passwordField: 'password',
    //are there other options?
    //emailField did not seem to do anything
    passReqToCallback: true
},
function(req, email, password, done) {
    //check if email not already in database
    //create new user using "email" and "password"
    //I want an additional parameter here "name"

    user.email = email;
    user.password = password; //Do some hashing before storing

    user.name = req.body.name;

}));

So können Sie hinzufügen, wie viele Formular-Eingabe-Felder, wie Sie möchten, auf Sie zugreifen, indem Sie den Wert des name-Attributs. Ein Zweites Beispiel wäre:

<input type="text" placeholder="City" name="city">
<input type="text" placeholder="Country" name="country">

//Access them by
user.city = req.body.city;
user.country = req.body.country;