Prüfen, ob ein Benutzer mit mongodb und pass.js existiert?

Question

Ich benutze Mungo und Pass-local für meine Strategie. Mit Redux erstelle ich eine Aktion, um einen Benutzer zu registrieren, und es funktioniert gut. Nach der Registrierung möchte ich die gleichen Anmeldeinformationen verwenden, um den Benutzer einzuloggen.

Ich habe Login mit JWT arbeiten, aber es trifft kein Backend, nur ein Benutzerobjekt. Ich frage mich, wie ich den Pass verwenden kann, um mich mit meinem Mongo-Backend zu authentifizieren, eine Erfolgsantwort zu geben, und dann kann ich weiterhin mein aktuelles Setup verwenden, um das JWT auszustellen. Ich weiß, dass ich das möglicherweise überarbeiten kann, um sauberer zu sein, und nur Pass zu verwenden, aber ich habe das so weit arbeiten lassen, und ich möchte es nur mit einer echten Datenbank verbinden, die registerUser erfolgreich verwendet.

./server/models/account.js

var mongoose = require('mongoose'); 
var Schema = mongoose.Schema; 
var passportLocalMongoose = require('passport-local-mongoose'); 

var Account = new Schema({ 
    username: String, 
    password: String 
}); 

Account.plugin(passportLocalMongoose); 

module.exports = mongoose.model('Account', Account); 

./index.js (server Einspeisepunkt)

var bodyParser = require('body-parser') 

// db 
var db   = require('./server/db'); // just db url 
var mongoose  = require('mongoose'); 
var passport  = require('passport'); 
var LocalStrategy = require('passport-local').Strategy; 
var Account  = require('./server/models/account'); 

var app = new (require('express'))() 
var port = 3000 

// webpack stuff went here 

app.use(bodyParser.urlencoded({ extended: true })); 
app.use(bodyParser.json()); 

app.use(passport.initialize()); 

app.get("/", function(req, res) { 
    res.sendFile(__dirname + '/client/index.html') 
}) 

passport.use(new LocalStrategy(Account.authenticate())); 
mongoose.connect(db.url); 

app.use(require('./server/routes')); <------------------------------ file below 

app.listen etc 

./server/routes.js

var express = require('express'), 
    _  = require('lodash'), 
    config = require('./config'), 
    jwt  = require('jsonwebtoken'); 

var app = module.exports = express.Router(); 

// XXX: This should be a database of users :). 
var users = [{     <----------------------------dummy account 
    id: 1, 
    username: 'test', 
    password: 'test' 
}]; 
function createToken(user) { 
    return jwt.sign(_.omit(user, 'password'), config.secret, { expiresIn: 60*60*5 }); 
} 
function getUserScheme(req) { 
    var username; 
    var type; 
    var userSearch = {}; 
    -- error stuff -- 
    return { 
    username: username, 
    type: type, 
    userSearch: userSearch 
    } 
} 

app.post('/sessions/create', function(req, res) { 
    var userScheme = getUserScheme(req); 
    -- error stuff -- 
    res.status(201).send({ 
    id_token: createToken(user) 
    }); 
}); 

./client/actions/index.js - Aktionen, die zur Registrierung/Anmeldung aufgerufen (registrieren Arbeiten mit Mongo, Login funktioniert nur mit einem Dummy-Objekt)

export function registerUser(creds) { 
    let config = { 
    method: 'POST', 
    headers: { 'Content-Type':'application/x-www-form-urlencoded' }, 
    body: `username=${creds.username}&password=${creds.password}` 
    } 
    return dispatch => { 
    // dispatch(requestLogin(creds)) 
    return fetch('http://localhost:3000/register', config) 
     .then((response) => { 
     if (!response.ok) { console.log("err"); } 
     else { dispatch(loginUser(creds)) } 
     }).catch(err => console.log("Error: ", err)) 
    } 
} 
// Calls the API to get a token and 
// dispatches actions along the way 
export function loginUser(creds) { 
    let config = { 
    method: 'POST', 
    headers: { 'Content-Type':'application/x-www-form-urlencoded' }, 
    body: `username=${creds.username}&password=${creds.password}` 
    } 
    return dispatch => { 
    // We dispatch requestLogin to kickoff the call to the API 
    // console.log(creds) 
    dispatch(requestLogin(creds)) 
    return fetch('http://localhost:3000/sessions/create', config) 
     .then(response => 
     response.json() 
      .then(user => ({ user, response })) 
    ) 
     .then(({ user, response }) => { 
     if (!response.ok) { 
      // If there was a problem, we want to 
      // dispatch the error condition 
      dispatch(loginError(user.message)) 
      return Promise.reject(user) 
     } 
     else { 
      // If login was successful, set the token in local storage 
      localStorage.setItem('id_token', user.id_token) 
      // Dispatch the success action 
      dispatch(receiveLogin(user)) 
     } 
     }).catch(err => console.log("Error: ", err)) 
    } 
} 

Answer 1

ich Sie etwas brauchen erraten wie:

export const passportJWT = function (passport) { 
    passport.use(new JwtStrategy({ 
    jwtFromRequest: ExtractJwt.fromAuthHeader(), 
    secretOrKey: config.JwtSecret, 
    }, (jwtPayload, done) => { 
    Account.findOne({ username: jwtPayload.username}, (err, account) => { 
    if (err) return done(err, false); 
    if (user) { 
     return done(null, account); 
    } 
    return done(null, false); 
    }); 
})); 
}; 

und

export const JWTAuthentication = (req, res, next) => { 
    passport.authenticate('jwt', { session: false })(req, res, next); 
}; 

dann diese Middleware für die Routen verwenden, die JWT-Authentifizierung benötigt. wie:

yourRouter.get('/login', JWTAuthentication, (req, res) => { 
    //if jwt authentication passed 
    //you can access user object as req.user 
});