passportjs kullanıcı nesnesi, parolayı karşılaştırmak için parola döndürmez

Question

Kullanıcının saklanan nesnenin, model/user.js içinde validatePassword işlevinde neden parola döndürmediğine dair bir fikre sahip olmam konusunda bir sorunum var. Pasaport resmi belgelerinde açıklanan tüm adımları takip ettim.

İmza için pasaportların yerlilerini kullandım. E-postayı karşılaştırdığımda, her zaman karşılaştırırdım, ancak şifreyi doğrulamak için çalıştım ve bu.password'ı veya argüman olarak kullanmaya çalıştığımda her zaman boş kalır ve bu yüzden şifrem karşılaştırılmaz.

Tüm kullanıcı şema bilgileri aldım ancak kullanıcı nesnesinde parola alamıyorum, böylece karşılaştırılamıyorum.

Bu sorundan nasıl çıkabileceğimi bilen var mı?

Konsol Log

root@wk11:/var/www/html/mytripmean/trunk# nodejs server.js 
    Mytrip is listening on port 1000 
    MongoDB connection successful 
    ---- User Information ---- 
    myemail@gmail.com 
    Password@@123 
    { message: 'Incorrect password.' } 
    not user: 
    false 
    [Error: Illegal arguments: string, undefined] 

    /var/www/html/mytripmean/trunk/app/data/models/user.js:105 
       throw err; 
        ^
    Error: Illegal arguments: string, undefined 
     at Error (<anonymous>) 
     at Object.bcrypt.compare (/var/www/html/mytripmean/trunk/node_modules/bcryptjs/dist/bcrypt.js:250:42) 
     at model.userSchema.methods.validPassword (/var/www/html/mytripmean/trunk/app/data/models/user.js:102:12) 
     at Query.<anonymous> (/var/www/html/mytripmean/trunk/app/data/routes/user.js:222:27) 
     at /var/www/html/mytripmean/trunk/node_modules/kareem/index.js:177:19 
     at /var/www/html/mytripmean/trunk/node_modules/kareem/index.js:109:16 
     at process._tickCallback (node.js:448:13) 

modeller/

var mongoose = require('mongoose') 
      , Schema = mongoose.Schema 
      , ObjectId = Schema.ObjectId 
      , randtoken = require('rand-token') 
      , bcrypt = require("bcryptjs"); 

    var userSchema = new Schema({ 
    // _Id: objectId, 
     social_id: { 
      type: String, //(Social id of facebook/twitter) 
      required: false, 
      unique: false 
     }, 
     social_media: { 
      type: String, //(facebook/twitter) 
      required: false, 
      unique: false 
     }, 
     link_id: { 
      type: String, //will be dispalying as user reference in url 
      required: true, 
      unique: true 
     }, 
     nick_name: { 
      type: String, // Unique Nickname for signup 
      required: true, 
      unique: true 
     }, 
     email: { 
      type: String, // Unqiue Email for signup 
      required: true, 
      unique: true 
     }, 
     password: { 
      type: String, // Password 
      required: true, 
      select: false 
     }, 
     user_type: { 
      type: Number, // 1: SuperAdmin, 2: Admin, 3: SiteUser, 4: Restaurant 
      required: true 
     }, //reason_to_close: String, // Close Account 
     is_active: { 
      type: Number, // -1: pending to activation, 0: inactive, 1: active, 
      required: true 
     }, 
     is_close: { 
      type: Number, // -1: pending to close/Undecided, 0: closed , 1: open/ not close, 
      required: true 
     }, 
     is_online: { 
      type: Number, // 0: Offline, 1: Online 
      required: true 
     }, 
     created_at: { 
      type: Date, 
      default: Date.now 
     }, // Registration date 
     updated_at: { 
      type: Date, // Registration activation date/user update date 
      default: Date.now 
     } 
    }, {collection: 'user'}); 

    // Password verification 
    userSchema.methods.validPassword = function (candidatePassword, callback) { 
     bcrypt.compare(candidatePassword, this.password, function (err, isMatch) { 
      console.log(err); 
      if (err) { 
       throw err; 
      } 
      callback(null, isMatch); 
     }); 
    }; 

    var User = module.exports = mongoose.model("User", userSchema); 

    module.exports.checkEmail = function (callback) { 
     return this.model('User').count({email: this.email}, callback); 
    }; 

    module.exports.validateEmailOrNickname = function (username, callback) { 
     var orCondition = [{nick_name: username}, {email: username}]; 
     //return this.model("user").findOne().or(orCondition); 
     return this.model("User").find({$or: orCondition}, callback); 
    }; 

    module.exports.getUserById = function (id) { 
     User.findById(id, callback); 
    }; 

    module.exports.createUser = function (user, callback) { 
     bcrypt.genSalt(10, function (err, salt) { 
      bcrypt.hash(user.password, salt, function (err, hash) { 
       user.password = hash; 
       user.save(callback); 
      }); 
     }); 
    }; 

yolları/user.js

user.js

var express = require('express'); 
    var router = express.Router(); 
    var bcrypt = require("bcryptjs") 
    var User = require('../models/user'); 
    var UserProfile = require('../models/userProfile'); 
    var UserSignupToken = require('../models/userSignupToken.js'); 
    var IpLogger = require('../models/ipLogger.js'); 
    var passport = require("passport"); 
    var localStrategy = require("passport-local"), Startegy; 

    router 
      .route('/api/user/register') 
      .post(
        function (req, res, next) { 

         var user_, userData_; 
         userData_ = { 
          link_id: req.body.manLinkId, 
          nick_name: req.body.txtNickname, 
          email: req.body.txtEmail, 
          password: req.body.manPassword, 
          user_type: req.body.manUserType, 
          is_active: req.body.manIsActive, 
          is_close: req.body.manIsClose, 
          is_online: req.body.manIsOnline 
         }; 

         user_ = new User(userData_); 

         user_.validate(function (err) { 
          if (err) { 

          } else { 
           //check recaptch is validate or not 
           var request = require('request'); 
           request 
             .post({ 
              url: 'http://www.google.com/recaptcha/api/verify', 
              form: { 
               privatekey: process.env.RECAPTCHA_PRIVATE_KEY, 
               remoteip: req.connection.remoteAddress, 
               challenge: req.body.captcha.challenge, 
               response: req.body.captcha.response 
              } 
             }, function (err, httpResponse, body) { 
              if (body.match(/false/) === null) { 
               //Recaptcha validated 
               User.createUser(user_, function (err, data) { 
                if (err) { 
                 console.log("stpe 1:"); 
                 console.log(err); 
                 res.json({status: 0, message: 'User having an error on stage 1'}); 
                } else { 
                 res.locals.user = data; 
                 //res.json({error:1, message: 'User saved'}); 
                 next(); 
                } 
               }); 
               //res.json({ "captchaError": true }); 
              } else { 
               res.json({"captchaError": false}); 
              } 
             }); 
          } 
         }); 
        }, 
        function (req, res, next) { 
         var userProfileData_, userProfile_; 
         userProfileData_ = { 
          user_id: res.locals.user.id, 
          link_id: res.locals.user.link_id, 
          full_name: req.body.txtFullname, 
          is_active: -1 
         }; 
         userProfile_ = new UserProfile(userProfileData_); 
         userProfile_.save(function (err, data) { 
          if (err) { 
           console.log("stpe 2:"); 
           console.log(err); 
           res.json({status: 0, message: 'User having an error on stage 2'}); 
          } else { 
           //res.json({error:1, message: 'User profile generated'}); 
           next(); 
          } 
         }); 
        }, 
        function (req, res, next) { 
         var userSignupTokenData_, userSignupToken_; 
         userSignupTokenData_ = { 
          user_id: res.locals.user.id, 
          link_id: res.locals.user.link_id, 
          is_active: -1 
         }; 
         userSignupToken_ = new UserSignupToken(userSignupTokenData_); 
         userSignupToken_.save(function (err, data) { 
          if (err) { 
           console.log("stpe 3:"); 
           console.log(err); 
           res.json({status: 0, message: 'User having an error on stage 3'}); 
          } else { 
           //res.json({error:1, message: 'User signup token generated'}); 
           next(); 
          } 
         }); 
        }, 
        function (req, res, next) { 
         var ipLoggerData_, ipLogger_, client_IP; 
         ipLoggerData_ = { 
          user_id: res.locals.user.id, 
          link_id: res.locals.user.link_id, 
          client_ip: req.ip, 
          activity: "signup" 
         }; 
         ipLogger_ = new IpLogger(ipLoggerData_); 
         ipLogger_.save(function (err, data) { 
          if (err) { 
           console.log("stpe 4:"); 
           console.log(err); 
           res.json({status: 0, message: 'User having an error on stage 4'}); 
          } else { 
           res.json({status: 1, message: 'user saved'}); 
          } 
         }); 
        } 
      ); 
    //Check unique validation 
    router 
      .route('/api/user/authenticate') 
      .post(
        function (req, res, next) { 
         console.log("---- User Information ----"); 
         console.log(req.body.txtSigninEmail); 
         console.log(req.body.txtSigninPassword); 

         passport.authenticate('local', function (err, user, info) { 
          console.log(info); 
          if (err) { 
           console.log(err); 
           return next(err); 
          } 
          if (!user) { 
           console.log("not user:"); 
           console.log(user); 
           return res.status(401).json({ 
            err: info 
           }); 
          } 
          req.login(user, function (err) { 
           if (err) { 
            return res.status(500).json({ 
             err: 'could not login user' 
            }); 
           } 
           res.status(200).json({ 
            status: 'login successful' 
           }); 
          }); 
         })(req, res, next); 
        }); 
    router 
      .route('/api/user/checkEmail') 
      .post(
        function (req, res) { 
         User.count({email: req.body.txtSigninPassword}, function (err, user) { 
          if (err) { 
           // console.log("error false"); 
           res.json(false); 
          } else { 
           // console.log("data"); 
           // console.log(user); 
           res.json({"status": user > 0 ? false : true}); 
          } 
         }); 
        }); 


    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', new localStrategy(
      { 
       usernameField: 'txtSigninEmail', 
       passwordField: 'txtSigninPassword' 
      }, 
      function (username, password, done) { 
       User.findOne({email: username}, function (err, user) { 
        if (err) { 
         return done(err); 
        } 
        if (!user) { 
         return done(null, false, {message: 'Incorrect username.'}); 
        } 
        if (!user.validPassword(password)) { 
         return done(null, false, {message: 'Incorrect password.'}); 
        } 
        return done(null, user); 
       }); 
      } 
    )); 
    module.exports = router; 

Answer 1

2 saatlik çalışmadan sonra sorumu yanıtladım. Kullanıcı modeli şifre alanımda "select: false" özelliğini ayarladım, çünkü her zaman boş olarak bir parola alıyorum.

Yaşlı: iyi çalışıyor doğrudur:

var userSchema = new Schema({ 
     password: { 
      type: String, // Password 
      required: true, 
      select: false 
     }, 
} 

seçme yeniden ayarladıktan sonra. Güncelleme

: Eğer bcrypt.compare geçmek this.password() tanımsız gibi

var userSchema = new Schema({ 
     password: { 
      type: String, // Password 
      required: true, 
      select: true 
     }, 
}