Sequelize is een op beloften gebaseerde Node.js ORM. Het kan worden gebruikt met PostgreSQL, MySQL, MariaDB, SQLite en MSSQL. In deze zelfstudie implementeren we authenticatie voor gebruikers van een web-app. En we zullen Passport, de populaire authenticatie-middleware voor Node, samen met Sequelize en MySQL gebruiken om gebruikersregistratie en login te implementeren.
Aan de slag
Zorg ervoor dat u het volgende op uw computer hebt geïnstalleerd:
- Knooppunt
- MijnSQL
Voor deze zelfstudie gebruiken we Node.js samen met Express, dus we gaan door en beginnen te installeren wat we nodig hebben.
Stap 1:Genereer een package.json-bestand
Maak een map voor uw app. Voer dit in deze map uit vanaf uw terminal of opdrachtprompt:
npm init
Hiermee wordt de npm Dependency Manager geïnitialiseerd. Dit zal een reeks prompts weergeven die we snel zullen doornemen.
- Typ de naam van je app zonder spaties en druk op Enter voor 'naam'.
- Druk op Enter voor de 'versie'.
- Voor 'beschrijving' typen we in deze zelfstudie 'Paspoort gebruiken met Sequelize en MySQL' als beschrijving en drukken we op Enter. Dit kan ook leeg zijn.
- Voor 'entry point (index.js)' typt u server.js en drukt u op Enter.
- Druk voor 'testopdracht' op Enter.
- Voor 'git repository' kun je de git repository invoeren waar je app zich bevindt als je er een hebt of druk gewoon op Enter om dit leeg te laten.
- Druk voor 'Trefwoorden' op Enter.
- Druk voor 'auteur' op Enter of typ uw naam voordat u dat doet.
- Druk voor 'licentie' op Enter.
- Voor '(Is this okay )' laat dit zien hoe je package.json eruit zal zien. Typ Ja en druk op Enter.
Stap 2:Installeer afhankelijkheden
De belangrijkste afhankelijkheden voor deze tutorial zijn:
- Express
- Vervolg
- MijnSQL
- Paspoort
- Lokale strategie paspoort
- Body-parser
- Express-sessie
- Bcrypt Nodejs
- Express Handlebars voor de weergaven
Om ze te installeren vanaf uw terminal of opdrachtprompt, voert u de volgende een voor een uit.
npm install express --save npm install sequelize --save npm install mysql --save npm install passport --save npm install passport-local --save npm install body-parser --save npm install express-session --save npm install bcrypt-nodejs --save npm install express-handlebars --save
Als je Git voor dit project gebruikt:
Maak in je projectmap een .gitignore-bestand aan.
Voeg deze regel toe aan het .gitignore-bestand.
node_modules
Stap 3:de app instellen
Nu maken we een serverbestand aan. Dit wordt het hoofdbestand dat wordt aangeroepen als u het volgende typt:
npm start
Hiermee wordt de app uitgevoerd. U kunt de app ook uitvoeren door node server.js te typen.
node server.js
Vervolgens maken we in onze projectmap een nieuw bestand en noemen we dit bestand server.js .
Binnen de server.js bestand, plakken we het volgende:
var express = require('express');
var app = express();
app.get('/', function(req, res) {
res.send('Welcome to Passport with Sequelize');
});
app.listen(5000, function(err) {
if (!err)
console.log("Site is live");
else console.log(err)
}); De eerste regel wijst de expresmodule toe aan een variabele express. We initialiseren dan express en noemen het een variabele:app.
Dan laten we de app luisteren op poort 5000 . U kunt elk vrij poortnummer op uw computer kiezen.
Vervolgens noemen we de app.get() express-routeringsfunctie om te reageren met "Welcome to Passport with Sequelize" wanneer een GET-verzoek wordt gedaan aan "/".
Om op uw computer te testen, voert u dit uit vanuit uw projectmap:
node server.js
Als u de tekst "Welcome to Passport with Sequelize" ziet wanneer u http://localhost:5000/ bezoekt, gefeliciteerd! Controleer anders of u alles precies hebt gedaan zoals hierboven beschreven.
Vervolgens importeren we enkele modules die we nodig hebben, zoals paspoort, express-sessie en body-parser.
Na var app = express() we voegen de volgende regels toe:
var passport = require('passport')
var session = require('express-session')
var bodyParser = require('body-parser') In de eerste twee regels importeren we de paspoortmodule en de express-sessie, die we allebei nodig hebben voor authenticatie.
Vervolgens importeren we de body-parser-module. Dit extraheert het volledige lichaamsdeel van een binnenkomend verzoek en geeft het weer in een formaat dat gemakkelijker is om mee te werken. In dit geval gebruiken we het JSON-formaat.
Om onze app de body-parser te laten gebruiken, voegen we deze regels enkele spaties toe onder de importregels:
//For BodyParser
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json()); Vervolgens initialiseren we het paspoort en de expressessie en de paspoortsessie en voegen ze beide toe als middleware. We doen dit door deze regels enkele spaties toe te voegen na de bodyParser-importregel.
// For Passport
app.use(session({ secret: 'keyboard cat',resave: true, saveUninitialized:true})); // session secret
app.use(passport.initialize());
app.use(passport.session()); // persistent login sessions We gaan nu aan de daadwerkelijke authenticatie werken.
We doen dit in vier stappen:
- Stel Sequelize in met MySQL.
- Maak het gebruikersmodel.
- Weergaven instellen.
- Schrijf een paspoortstrategie.
1. Sequelize instellen met MySQL
Eerst maken we een database in MySQL. Geef het je favoriete naam. Laten we omwille van deze tutorial een database maken met de naam sequelize_passport in MySQL.
Vervolgens stellen we de configuratie in om DB-details te verwerken.
Laten we eerst de dot-env-module importeren om omgevingsvariabelen te verwerken.
Voer dit uit in uw hoofdprojectmap:
npm install --save dotenv
Vervolgens importeren we het in het hoofdserverbestand, server.js, net onder de andere importen.
var env = require('dotenv').load(); Vervolgens maken we een bestand aan in onze projectmap en noemen het .env.
Deze volgende stap is optioneel als je Git niet gebruikt:
We voegen het .env-bestand toe aan je .gitignore-bestand.
Uw .gitignore-bestand zou er als volgt uit moeten zien:
node_modules .env
Hierna voegen we onze omgeving toe aan het .env-bestand door deze regel toe te voegen:
NODE_ENV='development'
Vervolgens maken we een config.json-bestand dat door Sequelize zal worden gebruikt om verschillende omgevingen te beheren.
Het eerste dat u moet doen, is een map maken met de naam config in onze projectmap. In deze map maken we een config. json het dossier. Dit bestand moet worden genegeerd als u naar een repository pusht. Om dit te doen, voeg je de volgende code toe aan je .gitignore:
config/config.json
Vervolgens plakken we de volgende code in ons bestand config.json.
{
"development": {
"username": "root",
"password": null,
"database": "sequelize_passport",
"host": "127.0.0.1",
"dialect": "mysql"
},
"test": {
"username": "",
"password": null,
"database": "",
"host": "",
"dialect": "mysql"
},
"production": {
"username": "",
"password": null,
"database": "",
"host": "127.0.0.1",
"dialect": "mysql"
}
} Vergeet niet om de waarden in het ontwikkelingsblok hierboven te vervangen door uw database-authenticatiegegevens.
Vervolgens installeren we sequelize met npm. Voer hiervoor de volgende opdracht uit in de hoofdmap van het project:
npm install --save sequelize
Nu is het tijd om de modellen te maken map.
Eerst maken we een directory met de naam app in onze projectmap.
In de app map maken we een nieuwe map met de naammodellen en maak een nieuw bestand aan met de naam index.js in de modellen map.
In het index.js-bestand plakken we de onderstaande code.
"use strict";
var fs = require("fs");
var path = require("path");
var Sequelize = require("sequelize");
var env = process.env.NODE_ENV || "development";
var config = require(path.join(__dirname, '..', 'config', 'config.json'))[env];
var sequelize = new Sequelize(config.database, config.username, config.password, config);
var db = {};
fs
.readdirSync(__dirname)
.filter(function(file) {
return (file.indexOf(".") !== 0) && (file !== "index.js");
})
.forEach(function(file) {
var model = sequelize.import(path.join(__dirname, file));
db[model.name] = model;
});
Object.keys(db).forEach(function(modelName) {
if ("associate" in db[modelName]) {
db[modelName].associate(db);
}
});
db.sequelize = sequelize;
db.Sequelize = Sequelize;
module.exports = db; Dit bestand wordt gebruikt om alle modellen te importeren die we in de modellen plaatsen map en exporteer ze.
Om te testen of alles goed is, voegen we dit toe aan ons server.js-bestand.
//Models
var models = require("./app/models");
//Sync Database
models.sequelize.sync().then(function() {
console.log('Nice! Database looks fine')
}).catch(function(err) {
console.log(err, "Something went wrong with the Database Update!")
}); Hier importeren we de modellen en roepen we vervolgens de Sequelize-synchronisatiefunctie op.
Voer dit uit om te zien of alles in orde is:
node server.js
Als je de melding "Site is live Nice! Database ziet er goed uit" krijgt, dan heb je Sequelize succesvol ingesteld.
Als dit niet het geval is, neem dan de bovenstaande stappen zorgvuldig door en probeer het probleem met hulp op te lossen.
2. Maak het gebruikersmodel
Het volgende dat we gaan doen, is het gebruikersmodel maken, dat in feite de gebruikerstabel is. Dit bevat basisgebruikersinformatie.
In onze modellen map, maken we een bestand en noemen het user.js . Het volledige pad voor dit bestand moet app/models/user.js zijn.
Open het bestand user.js en voeg de volgende code toe:
module.exports = function(sequelize, Sequelize) {
var User = sequelize.define('user', {
id: {
autoIncrement: true,
primaryKey: true,
type: Sequelize.INTEGER
},
firstname: {
type: Sequelize.STRING,
notEmpty: true
},
lastname: {
type: Sequelize.STRING,
notEmpty: true
},
username: {
type: Sequelize.TEXT
},
about: {
type: Sequelize.TEXT
},
email: {
type: Sequelize.STRING,
validate: {
isEmail: true
}
},
password: {
type: Sequelize.STRING,
allowNull: false
},
last_login: {
type: Sequelize.DATE
},
status: {
type: Sequelize.ENUM('active', 'inactive'),
defaultValue: 'active'
}
});
return User;
} Voer nu uit:
node server.js
U zou de bekende "Site is live. Leuk! . moeten zien Database ziet er goed uit. " bericht. Dit betekent dat onze Sequelize-modellen met succes zijn gesynchroniseerd en als u uw database controleert, ziet u een gebruikerstabel met de opgegeven kolommen.
3:weergaven instellen
Laten we eerst de weergave voor aanmelding maken en verbinden.
Het eerste dat u moet doen, is de module voor express stuur importeren die we gebruiken voor weergaven in deze zelfstudie.
Voeg deze regel toe aan het hoofdstartbestand, server.js.
var exphbs = require('express-handlebars')
Je importblok zou er nu zo uit moeten zien.
var express = require('express')
var app = express()
var passport = require('passport')
var session = require('express-session')
var bodyParser = require('body-parser')
var env = require('dotenv').load()
var exphbs = require('express-handlebars') Vervolgens voegen we de volgende regels toe aan ons server.js-bestand.
//For Handlebars
app.set('views', './app/views')
app.engine('hbs', exphbs({
extname: '.hbs'
}));
app.set('view engine', '.hbs'); Nu maken we in onze app-map drie mappen met de naam views, controllers, en routes .
In de map views maken we een bestand aan met de naam signup. hbs en plak de onderstaande code erin.
<!DOCTYPE html>
<html>
<head>
<title></title>
</head>
<body>
<form id="signup" name="signup" method="post" action="/signup">
<label for="email">Email Address</label>
<input class="text" name="email" type="email" />
<label for="firstname">Firstname</label>
<input name="firstname" type="text" />
<label for="lastname">Lastname</label>
<input name="lastname" type="text" />
<label for="password">Password</label>
<input name="password" type="password" />
<input class="btn" type="submit" value="Sign Up" />
</form>
</body>
</html> Dan in onze controllers map, maken we een nieuw bestand aan en noemen het authcontroller.js.
In dit bestand plakken we de volgende controller voor de aanmeldingsroute die we zo zullen maken.
var exports = module.exports = {}
exports.signup = function(req, res) {
res.render('signup');
} Vervolgens maken we een route voor aanmelding. In de routesmap maken we een nieuw bestand met de naam auth.js en vervolgens importeren we in dit bestand de auth-controller en definiëren we de aanmeldingsroute.
var authController = require('../controllers/authcontroller.js');
module.exports = function(app) {
app.get('/signup', authController.signup);
} Nu importeren we deze route in onze server.js en geven de app door als argument.
Voeg in de server, na het importeren van de modellen, deze regels toe:
//Routes
var authRoute = require('./app/routes/auth.js')(app); Voer dit uit:
node server.js
Ga nu naar http://localhost:5000/signup en u ziet het aanmeldingsformulier.
Laten we de stappen voor het aanmeldingsformulier herhalen. Net als voorheen maken we een bestand met de naam signin.hbs in onze map views en plak de volgende HTML-code erin:
<!DOCTYPE html>
<html>
<head>
<title></title>
</head>
<body>
<form id="signin" name="signin" method="post" action="signin">
<label for="email">Email Address</label>
<input class="text" name="email" type="text" />
<label for="password">Password</label>
<input name="password" type="password" />
<input class="btn" type="submit" value="Sign In" />
</form>
</body>
</html> Voeg vervolgens een controller toe voor het inloggen in app/controllers/authcontroller.js.
exports.signin = function(req, res) {
res.render('signin');
} Dan in app/routes/auth.js , voegen we een route toe om als volgt in te loggen:
app.get('/signin', authController.signin);
Als je nu rent:
node server.js
en bezoek http://localhost:5000/signin/, u zou het aanmeldingsformulier moeten zien.
De laatste en belangrijkste stap is het schrijven van onze paspoortstrategieën.
4. Schrijf een paspoortstrategie
In app/config , maken we een nieuwe map met de naam paspoort.
Vervolgens maken we in onze nieuwe map app/config/passport een nieuw bestand en noemen het passport.js . Dit bestand bevat onze paspoortstrategieën.
In passport.js , we zullen het gebruikersmodel en paspoort gebruiken.
Eerst importeren we bcrypt die we nodig hebben om wachtwoorden te beveiligen.
var bCrypt = require('bcrypt-nodejs');
Vervolgens voegen we een module.exports-blok toe zoals dit:
module.exports = function(passport, user) {
} Binnen dit blok initialiseren we de paspoort-lokale strategie en het gebruikersmodel, dat als argument wordt doorgegeven. Hier is hoe we dit doen:
module.exports = function(passport, user) {
var User = user;
var LocalStrategy = require('passport-local').Strategy;
} Vervolgens definiëren we onze aangepaste strategie met onze instantie van de LocalStrategy als volgt:
passport.use('local-signup', new LocalStrategy(
{
usernameField: 'email',
passwordField: 'password',
passReqToCallback: true // allows us to pass back the entire request to the callback
},
)); Nu hebben we aangegeven welk verzoek (req ) velden onze usernameField en passwordField (paspoortvariabelen) zijn.
Met de laatste variabele passReqToCallback kunnen we het hele verzoek doorgeven aan de callback, wat vooral handig is bij het aanmelden.
Na de laatste komma voegen we deze terugbelfunctie toe.
function(req, email, password, done) {
} In deze functie zullen we de gegevens van een gebruiker opslaan.
Eerst voegen we onze hash-functie voor het genereren van wachtwoorden toe aan de callback-functie.
var generateHash = function(password) {
return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null);
}; Vervolgens gebruiken we het gebruikersmodel Sequelize dat we eerder hebben geïnitialiseerd als Gebruiker , we controleren of de gebruiker al bestaat, en zo niet, dan voegen we ze toe.
User.findOne({
where: {
email: email
}
}).then(function(user) {
if (user)
{
return done(null, false, {
message: 'That email is already taken'
});
} else
{
var userPassword = generateHash(password);
var data =
{
email: email,
password: userPassword,
firstname: req.body.firstname,
lastname: req.body.lastname
};
User.create(data).then(function(newUser, created) {
if (!newUser) {
return done(null, false);
}
if (newUser) {
return done(null, newUser);
}
});
}
});
User.create() is een Sequelize-methode voor het toevoegen van nieuwe items aan de database. Merk op dat de waarden in de data object zijn verkregen van de req.body object dat de invoer van ons aanmeldingsformulier bevat.
Uw passport.js zou er als volgt uit moeten zien:
//load bcrypt
var bCrypt = require('bcrypt-nodejs');
module.exports = function(passport, user) {
var User = user;
var LocalStrategy = require('passport-local').Strategy;
passport.use('local-signup', new LocalStrategy(
{
usernameField: 'email',
passwordField: 'password',
passReqToCallback: true // allows us to pass back the entire request to the callback
},
function(req, email, password, done) {
var generateHash = function(password) {
return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null);
};
User.findOne({
where: {
email: email
}
}).then(function(user) {
if (user)
{
return done(null, false, {
message: 'That email is already taken'
});
} else
{
var userPassword = generateHash(password);
var data =
{
email: email,
password: userPassword,
firstname: req.body.firstname,
lastname: req.body.lastname
};
User.create(data).then(function(newUser, created) {
if (!newUser) {
return done(null, false);
}
if (newUser) {
return done(null, newUser);
}
});
}
});
}
));
} Nu gaan we de strategie importeren in server.js.
Om dit te doen, voegen we deze regels toe onder de import van routes in server.js.
//load passport strategies
require('./app/config/passport/passport.js')(passport, models.user); Uw server.js zou er op dit moment zo uit moeten zien:
var express = require('express')
var app = express()
var passport = require('passport')
var session = require('express-session')
var bodyParser = require('body-parser')
var env = require('dotenv').load()
var exphbs = require('express-handlebars')
//For BodyParser
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(bodyParser.json());
// For Passport
app.use(session({
secret: 'keyboard cat',
resave: true,
saveUninitialized: true
})); // session secret
app.use(passport.initialize());
app.use(passport.session()); // persistent login sessions
//For Handlebars
app.set('views', './app/views')
app.engine('hbs', exphbs({
extname: '.hbs'
}));
app.set('view engine', '.hbs');
app.get('/', function(req, res) {
res.send('Welcome to Passport with Sequelize');
});
//Models
var models = require("./app/models");
//Routes
var authRoute = require('./app/routes/auth.js')(app);
//load passport strategies
require('./app/config/passport/passport.js')(passport, models.user);
//Sync Database
models.sequelize.sync().then(function() {
console.log('Nice! Database looks fine')
}).catch(function(err) {
console.log(err, "Something went wrong with the Database Update!")
});
app.listen(5000, function(err) {
if (!err)
console.log("Site is live");
else console.log(err)
}); Nu gaan we de strategie daadwerkelijk toepassen op onze /signup route.
Zo doen we dat:
Eerst gaan we naar app/routes/auth.js , en voeg een route toe om te posten om je op deze manier aan te melden.
app.post('/signup', passport.authenticate('local-signup', {
successRedirect: '/dashboard',
failureRedirect: '/signup'
}
)); Omdat we een paspoort nodig hebben, moeten we het aan deze methode doorgeven. We kunnen paspoort importeren in dit script of het doorgeven van server.js. Laten we het laatste doen.
Wijzig de functie die in dit bestand is geëxporteerd app/routes/auth.js paspoort als parameter hebben. De code in app/routes/auth.js zou er na uw wijziging zo uit moeten zien.
var authController = require('../controllers/authcontroller.js');
module.exports = function(app, passport) {
app.get('/signup', authController.signup);
app.get('/signin', authController.signin);
app.post('/signup', passport.authenticate('local-signup', {
successRedirect: '/dashboard',
failureRedirect: '/signup'
}
));
} Dan in server.js , we wijzigen de import van routes en voegen paspoort toe als een argument zoals dit:
var authRoute = require('./app/routes/auth.js')(app,passport);
Ga nu naar de aanmeldings-URL http://localhost:5000/signup/ en probeer u aan te melden.
Wanneer u zich probeert aan te melden, krijgt u de foutmelding "Kan gebruiker niet naar sessie serialiseren ". Dit komt omdat het paspoort een gebruikers-ID in de sessie moet opslaan en dit gebruikt om het ophalen van de gebruikersgegevens te beheren wanneer dat nodig is.
Om dit op te lossen, gaan we zowel de serialisatie- als deserialize-functies van het paspoort implementeren in onze app/config/passport/passport.js bestand.
Eerst voegen we de serialisatiefunctie toe. In deze functie bewaren we de gebruikers-ID naar de sessie.
Om dit te doen, voegen we de volgende regels toe onder de initialisatie van de lokale strategie.
//serialize
passport.serializeUser(function(user, done) {
done(null, user.id);
}); Vervolgens implementeren we de deserialize-functie. Voeg de functie toe net onder de serialize-functie.
// deserialize user
passport.deserializeUser(function(id, done) {
User.findById(id).then(function(user) {
if (user) {
done(null, user.get());
} else {
done(user.errors, null);
}
});
});
In de deserialize-functie hierboven gebruiken we de Sequelize findById beloven om de gebruiker te krijgen, en indien succesvol, wordt een exemplaar van het Sequelize-model geretourneerd. Om het User-object uit deze instantie te halen, gebruiken we de Getter-functie Sequelize als volgt:user.get() .
Ren nu opnieuw:
node server.js
En probeer je aan te melden. Hoera als je de "Cannot GET /dashboard" hebt! Het betekent dat onze authenticatie succesvol was. Onthoud dat we zijn omgeleid naar /dashboard in onze paspoort.authenticate-methode in routes/auth.js .
Laten we nu doorgaan en die route toevoegen. Voeg vervolgens een middleware toe om ervoor te zorgen dat de pagina alleen toegankelijk is wanneer een gebruiker is aangemeld bij de sessie.
In onze app/weergaven map maken we een nieuw bestand met de naam dashboard.hbs en voeg de volgende HTML-code erin toe.
<!DOCTYPE html>
<html>
<head>
<title>Passport with Sequelize</title>
</head>
<body>
<h2>Dashboard</h2>
<h5>Hurray! you are logged in.</h5>
</body>
</html> In routes/auth.js , voegen we deze regel toe aan de module.exports blok:
app.get('/dashboard',authController.dashboard);
Vervolgens gaan we naar app/controllers/authController.js en voeg de dashboardcontroller toe.
exports.dashboard = function(req, res) {
res.render('dashboard');
} Uw AuthController.js zou er als volgt uit moeten zien:
var exports = module.exports = {}
exports.signup = function(req, res) {
res.render('signup');
}
exports.signin = function(req, res) {
res.render('signin');
}
exports.dashboard = function(req, res) {
res.render('dashboard');
} Voer de app nu opnieuw uit en probeer u aan te melden met een ander e-mailadres dan u eerder hebt gebruikt. U wordt op de juiste manier doorgestuurd naar het /dashboard route.
Maar /dashboard is geen beveiligde route, wat betekent dat zelfs als een gebruiker niet is ingelogd, deze deze kan zien. We willen dit niet, dus we voegen een /logout . toe route om de gebruiker uit te loggen en vervolgens de route te beveiligen en te testen wat we hebben gedaan.
Laten we dit doen:
In routes/auth.js we voegen deze regel toe:
app.get('/logout',authController.logout);
Vervolgens voegen we de controller toe in app/controllers/authController.js.
exports.logout = function(req, res) {
req.session.destroy(function(err) {
res.redirect('/');
});
} Start de app nu opnieuw en meld u aan met een ander e-mailadres.
Ga daarna naar http://localhost:5000/logout om de gebruiker uit te loggen. Ga nu naar http://localhost:5000/dashboard.
Je zult merken dat het vrij toegankelijk is. Laten we een aangepaste middleware toevoegen om die route te beschermen.
Hiervoor openen we app/routes/auth.js en voeg deze functie toe aan de module.exports blok, onder alle andere regels code.
function isLoggedIn(req, res, next) {
if (req.isAuthenticated())
return next();
res.redirect('/signin');
} Vervolgens passen we de route-handler van het dashboard aan om er als volgt uit te zien:
app.get('/dashboard',isLoggedIn, authController.dashboard);
Wanneer u nu de app opnieuw uitvoert en probeert de dashboardpagina te bezoeken en u bent niet ingelogd, zou u moeten worden doorgestuurd naar de aanmeldingspagina.
Wauw! Het is tijd om het laatste deel te implementeren:het inloggen.
Eerst voegen we een nieuwe lokale strategie toe voor inloggen in app/config/passport/passport.js .
//LOCAL SIGNIN
passport.use('local-signin', new LocalStrategy(
{
// by default, local strategy uses username and password, we will override with email
usernameField: 'email',
passwordField: 'password',
passReqToCallback: true // allows us to pass back the entire request to the callback
},
function(req, email, password, done) {
var User = user;
var isValidPassword = function(userpass, password) {
return bCrypt.compareSync(password, userpass);
}
User.findOne({
where: {
email: email
}
}).then(function(user) {
if (!user) {
return done(null, false, {
message: 'Email does not exist'
});
}
if (!isValidPassword(user.password, password)) {
return done(null, false, {
message: 'Incorrect password.'
});
}
var userinfo = user.get();
return done(null, userinfo);
}).catch(function(err) {
console.log("Error:", err);
return done(null, false, {
message: 'Something went wrong with your Signin'
});
});
}
));
In deze strategie, de isValidPassword functie vergelijkt het ingevoerde wachtwoord met de bCrypt-vergelijkingsmethode aangezien we ons wachtwoord hebben opgeslagen met bcrypt .
Als de gegevens correct zijn, wordt onze gebruiker aangemeld.
Ga nu naar routes/auth.js en voeg de route voor het posten toe aan / aanmelden.
app.post('/signin', passport.authenticate('local-signin', {
successRedirect: '/dashboard',
failureRedirect: '/signin'
}
)); Je routes/auth.js zouden er zo uit moeten zien als je klaar bent.
var authController = require('../controllers/authcontroller.js');
module.exports = function(app, passport) {
app.get('/signup', authController.signup);
app.get('/signin', authController.signin);
app.post('/signup', passport.authenticate('local-signup', {
successRedirect: '/dashboard',
failureRedirect: '/signup'
}
));
app.get('/dashboard', isLoggedIn, authController.dashboard);
app.get('/logout', authController.logout);
app.post('/signin', passport.authenticate('local-signin', {
successRedirect: '/dashboard',
failureRedirect: '/signin'
}
));
function isLoggedIn(req, res, next) {
if (req.isAuthenticated())
return next();
res.redirect('/signin');
}
} Voer nu de app uit en probeer in te loggen. U zou moeten kunnen inloggen met alle gegevens die u heeft gebruikt tijdens het aanmelden, en u wordt doorverwezen naar http ://localhost:5000/dashboard/.
Gefeliciteerd als je het einde van deze tutorial hebt gehaald! We hebben Sequelize en Passport met succes gebruikt met een MySQL-database.
De volledige code voor deze tutorial is te vinden op GitHub.