पासपोर्ट: नाम और ईमेल पते के साथ साइन अप करने की अनुमति दें? (स्थानीय रणनीति)

Question

क्या कोई उपयोगकर्ता स्थानीय पासवर्ड पर अपने पासवर्ड, ईमेल और नाम के साथ पंजीकरण करने की अनुमति देने का कोई तरीका है?
प्रत्येक उदाहरण जो मुझे ऑनलाइन मिल सकता है केवल नाम/पासवर्ड या ईमेल/पासवर्ड का उपयोग करें।

मैंने पूरे पासपोर्ट दस्तावेज के माध्यम से भी खोज की, लेकिन वह दस्तावेज बिल्कुल सहायक नहीं है। यह सिर्फ उदाहरणों से भरा एक फूला हुआ साइट है।
मुझे केवल कार्यों, कक्षाओं और चर के पासपोर्ट की एक सूची की आवश्यकता है, जो स्पष्टीकरण के साथ उपयोग करता है कि वे और उनके प्रत्येक पैरामीटर क्या करते हैं। प्रत्येक अच्छी लाइब्रेरी में ऐसा कुछ है, मैं इसे पासपोर्ट के लिए क्यों नहीं ढूंढ सकता?

यहाँ मेरी कोड के मुख्य भागों हैं:

passport.use('local-signup', new LocalStrategy({ 
    usernameField: 'email', 
    passwordField: 'password', 
    //are there other options? 
    //emailField did not seem to do anything 
    passReqToCallback: true // allows us to pass in the req from our route (lets us check if a user is logged in or not) 
}, 
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" 
})); 

तो पासपोर्ट वास्तव में है कि सीमित है? ऐसा करने का एक तरीका होना चाहिए, है ना?

Answer 1

आप थोड़ा उलझन में हो सकते हैं लेकिन पासपोर्ट साइनअप विधियों को लागू नहीं करता है। यह सिर्फ प्राधिकरण पुस्तकालय है। तो आपको उस उपयोग-मामले को अपने आप संभालना होगा।

सबसे पहले, मार्ग कि साइन-अप और अपने चेक के लिए जिम्मेदार होगा बनाने के लिए:

signup: function (req, res) { 
    User 
    .findOne({ 
     or: [{username: req.param('username')}, {email: req.param('email')}] 
    }) 
    .then(function(user) { 
     if (user) return {message: 'User already exists'};   
     return User.create(req.allParams()); 
    }) 
    .then(res.ok) 
    .catch(res.negotiate); 
} 

उपरोक्त उदाहरण पाल ढांचे पर आधारित है, लेकिन आप अपने खुद के मामले में कोई समस्या नहीं के साथ फिट कर सकते हैं ।

अगला चरण पासपोर्ट स्थानीय रणनीति शामिल है।

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

var LOCAL_STRATEGY_CONFIG = { 
    usernameField: 'email', 
    passwordField: 'password', 
    session: false, 
    passReqToCallback: true 
}; 

function _onLocalStrategyAuth(req, email, password, next) { 
    User 
    .findOne(or: [{email: email}, {username: email}]) 
    .then(function (user) { 
     if (!user) return next(null, null, { 
     code: 'E_USER_NOT_FOUND', 
     message: email + ' is not found', 
     status: 401 
     }); 

     if (!HashService.bcrypt.compareSync(password, user.password)) return next(null, null, { 
     code: 'E_WRONG_PASSWORD', 
     message: 'Password is wrong', 
     status: 401 
     }); 

     return next(null, user, {}); 
    }) 
    .catch(next); 
} 

passport.use(new LocalStrategy(LOCAL_STRATEGY_CONFIG), _onLocalStrategyAuth)); 

हमारे पास अभी केवल साइनइन कार्य है। यह आसान है।

signin: function(req, res) { 
    passport.authenticate('local', function(error, user, info) { 
    if (error || !user) return res.negotiate(Object.assign(error, info)); 
    return res.ok(user); 
    })(req, res); 
} 

इस तरह पासपोर्ट के लिए अधिक उपयुक्त है और मेरे लिए बहुत अच्छा काम करता है।

Answer 2

यहां मेरे लिए क्या काम किया गया है, यह समाधान एक मोंगोस आधारित ओडीएम पर आधारित है, पहला भाग पासपोर्ट से संबंधित हिस्सा है, मैंने उपयोगकर्ता को ओडीएम से भी जोड़ा है, जिससे पासवर्ड की एन्क्रिप्शन कैसे की जाती है।

यदि मैं आपका प्रश्न समझ गया, तो आप चाहते हैं कि उपयोगकर्ता या तो उसका ईमेल या पासवर्ड टाइप करें। इस मामले में, दोनों उपयोगकर्ता को खोजने के लिए खोज को संशोधित करें, यानी उपयोगकर्ता नाम या पासवर्ड के साथ खोजने के लिए अपने कॉल में (0)।

ध्यान दें कि मैं स्पष्ट पासवर्ड संग्रहीत करने से बचने के लिए bcrypt का उपयोग करता हूं , यही कारण है कि पासवर्ड का परीक्षण करने के लिए एक अनुकूलित तुलना विधि भी है। Google ऑथ का उपयोग करने के 'संकेत' को भी ध्यान दें, मेरा सिस्टम दोनों सक्षम है, यदि यह प्रासंगिक है, तो कृपया मुझे पता करें और मैं आवश्यक कोड जोड़ सकता हूं।

------------ प्रमाणीकरण हिस्सा (सिर्फ प्रासंगिक स्निपेट) -----------

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'); 
     } 
    }); 
}); 

--- उपयोगकर्ता/ODM, प्रासंगिक भागों ---- ------------

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); 
    }); 
}; 

Answer 3

var localStrategy = require('passport-local').Strategy; 
var User = require('../public/models/user'); 

module.exports = function(passport){ 

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

    passport.deserializeUser(function(id, done){ 
     User.findById(id, function(err, user){ 
      done(err, user); 
     }); 
    }); 

    passport.use('local-signup', new localStrategy({ 
     usernameField: 'email', 
     passwordField: 'password', 
     passReqToCallback: true 
    }, 
    function(req, email, password, done){ 
     process.nextTick(function(){ 
      User.findOne({'local.enroll': email}, function(err, user){ 
       if(err) 
        return done(err); 
       if(user){ 
        return done(null, false, req.flash('signupmessage', 'The email already taken')); 
       } else{ 
        var newUser = new User(); 
        newUser.local.enroll = email; 
        newUser.local.password = newUser.generateHash(password);      
        newUser.save(function(err){ 
         if(err) 
          throw err 
         return done(null, newUser); 
        }); 
       } 

      }); 
     }); 
    })); 

    passport.use('local-login', new localStrategy({ 
     usernameField: 'email', 
     passwordField: 'password', 
     passReqToCallback: true 
    }, 
    function(req, email, password, done){ 
     process.nextTick(function(){ 
      User.findOne({'local.enroll': email}, function(err, user){ 
       if(err) 
        return done(err); 
       if(!user){ 
        return done(null, false, req.flash('loginmessage', 'No user found')); 
       } 
       if(!user.validPassword(password)){ 
        return done(null, false, req.flash('loginmessage', 'Invalid password')); 
       } 
       return done(null, user); 
      }); 
     }); 
    }));  
} 

Answer 4

UserModel.find({email: req.body.email}, function(err, user){            
    if(err){                 
     res.redirect('/your sign up page');                   
    } else {                 
     if(user.length > 0){              
     res.redirect('/again your sign up page');                  
     } else{                
     //YOUR REGISTRATION CODES HERE                  
     }                   
    }                   
})