Sequelize è un ORM Node.js basato su promesse. Può essere utilizzato con PostgreSQL, MySQL, MariaDB, SQLite e MSSQL. In questo tutorial implementeremo l'autenticazione per gli utenti di un'app Web. E utilizzeremo Passport, il popolare middleware di autenticazione per Node, insieme a Sequelize e MySQL per implementare la registrazione e l'accesso degli utenti.
Per iniziare
Assicurati di avere installato quanto segue sul tuo computer:
- Nodo
- MySQL
Per questo tutorial utilizzeremo Node.js insieme a Express, quindi andiamo avanti e iniziamo a installare ciò di cui abbiamo bisogno.
Passaggio 1:genera un file package.json
Crea una directory per la tua app. All'interno di questa directory, eseguilo dal tuo terminale o dal prompt dei comandi:
npm init
Questo inizializza il npm Dependency Manager. Questo presenterà una serie di prompt che esamineremo rapidamente.
- Digita il nome della tua app senza spazi e premi Invio per 'nome'.
- Premi Invio per la 'versione'.
- Per "descrizione", in questo tutorial, digiteremo "Using Passport with Sequelize and MySQL" come descrizione e premiamo Invio. Anche questo può essere vuoto.
- Per 'punto di ingresso (index.js)', digita server.js e premi Invio.
- Per 'comando di prova', premere Invio.
- Per 'git repository', puoi inserire il repository git in cui risiede la tua app, se ne hai uno, o semplicemente premere Invio per lasciare vuoto.
- Per "Parole chiave", premi Invio.
- Per 'autore', premi Invio o digita il tuo nome prima di farlo.
- Per 'licenza', premi Invio.
- Per '(Va bene )', questo ti mostra come apparirà il tuo package.json. Digita Sì e premi Invio.
Passaggio 2:installa le dipendenze
Le principali dipendenze per questo tutorial sono:
- Espresso
- Sequenza
- MySQL
- Passaporto
- Strategia locale del passaporto
- Analizzatore del corpo
- Sessione rapida
- Bcrypt Nodejs
- Manubri Express per le viste
Per installarli, dal tuo terminale o dal prompt dei comandi, esegui uno dopo l'altro.
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
Se stai usando Git per questo progetto:
Nella cartella del tuo progetto crea un file .gitignore.
Aggiungi questa riga al file .gitignore.
node_modules
Fase 3:configura l'app
Ora creiamo un file del server. Questo sarà il file principale chiamato quando digiti quanto segue:
npm start
Questo esegue l'app. Puoi anche eseguire l'app digitando node server.js.
node server.js
Quindi, nella nostra cartella del progetto, creiamo un nuovo file e chiamiamo questo file server.js .
All'interno di server.js file, incolliamo quanto segue:
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)
}); La prima riga assegna il modulo Express a una variabile express. Quindi inizializziamo express e la denominiamo variabile:app.
Quindi facciamo ascoltare l'app sulla porta 5000 . Puoi scegliere qualsiasi numero di porta gratuita sul tuo computer.
Successivamente, chiamiamo app.get() funzione di instradamento espresso per rispondere con "Benvenuto in Passport con Sequelize" quando viene inviata una richiesta GET a "/".
Per testare sul tuo computer, eseguilo dalla cartella del tuo progetto:
node server.js
Se vedi il testo "Welcome to Passport with Sequelize" quando visiti http://localhost:5000/ allora congratulazioni! Altrimenti, controlla di aver fatto tutto esattamente come è scritto sopra.
Successivamente, importiamo alcuni moduli di cui abbiamo bisogno, come passport, express-session e body-parser.
Dopo var app = express() aggiungiamo le seguenti righe:
var passport = require('passport')
var session = require('express-session')
var bodyParser = require('body-parser') Nelle prime due righe importiamo il modulo passaporto e la sessione rapida, entrambi di cui abbiamo bisogno per gestire l'autenticazione.
Quindi, importiamo il modulo body-parser. Questo estrae l'intera parte del corpo di una richiesta in arrivo e la espone in un formato con cui è più facile lavorare. In questo caso, utilizzeremo il formato JSON.
Per consentire alla nostra app di utilizzare il body parser, aggiungiamo queste righe alcuni spazi sotto le righe di importazione:
//For BodyParser
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json()); Successivamente, inizializziamo il passaporto, la sessione rapida e la sessione del passaporto e li aggiungiamo entrambi come middleware. Lo facciamo aggiungendo a queste righe alcuni spazi dopo la riga di importazione bodyParser.
// 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 Inizieremo ora a lavorare sull'autenticazione vera e propria.
Lo faremo in quattro passaggi:
- Imposta Sequelize con MySQL.
- Crea il modello utente.
- Imposta visualizzazioni.
- Scrivi una strategia per i passaporti.
1. Imposta la sequenza con MySQL
Innanzitutto, creiamo un database in MySQL. Dagli il tuo nome preferito. Per il bene di questo tutorial, creiamo un database chiamato sequelize_passport in MySQL.
Quindi impostiamo la configurazione per gestire i dettagli del DB.
Per prima cosa, importiamo il modulo dot-env per gestire le variabili d'ambiente.
Eseguilo nella cartella principale del progetto:
npm install --save dotenv
Quindi lo importiamo nel file del server principale, server.js, appena sotto le altre importazioni.
var env = require('dotenv').load(); Successivamente, creiamo un file nella nostra cartella del progetto e lo chiamiamo .env.
Questo passaggio successivo da seguire è facoltativo se non stai utilizzando Git:
Aggiungeremo il file .env al tuo file .gitignore.
Il tuo file .gitignore dovrebbe assomigliare a questo:
node_modules .env
Successivamente, aggiungiamo il nostro ambiente al file .env aggiungendo questa riga:
NODE_ENV='development'
Quindi creiamo un file config.json che verrà utilizzato da Sequelize per gestire diversi ambienti.
La prima cosa da fare è creare una cartella denominata config nella nostra cartella del progetto. All'interno di questa cartella, creiamo un config. json file. Questo file dovrebbe essere ignorato se stai eseguendo il push in un repository. Per fare ciò, aggiungi il seguente codice al tuo .gitignore:
config/config.json
Quindi, incolliamo il codice seguente nel nostro file 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"
}
} Ricorda di sostituire i valori nel blocco di sviluppo sopra con i dettagli di autenticazione del database.
Successivamente, installiamo sequelize con npm. Per fare ciò, esegui il seguente comando nella cartella principale del progetto:
npm install --save sequelize
Ora è il momento di creare i modelli cartella.
Innanzitutto, creiamo una directory denominata app nella nostra cartella del progetto.
Dentro l'app cartella, creiamo una nuova cartella denominata models e crea un nuovo file chiamato index.js nei modelli cartella.
All'interno del file index.js, incolliamo il codice qui sotto.
"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; Questo file viene utilizzato per importare tutti i modelli che inseriamo nei models cartella ed esportarli.
Per verificare che tutto vada bene, lo aggiungiamo nel nostro file server.js.
//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!")
}); Qui importiamo i modelli e quindi chiamiamo la funzione di sincronizzazione Sequelize.
Esegui questo per vedere se tutto va bene:
node server.js
Se ricevi il messaggio "Il sito è attivo Bello! Il database sembra a posto", hai impostato Sequelize correttamente.
In caso contrario, segui attentamente i passaggi precedenti e prova a eseguire il debug del problema con l'aiuto.
2. Crea il modello utente
La prossima cosa che faremo è creare il modello utente, che è fondamentalmente la tabella utente. Questo conterrà informazioni di base sull'utente.
Nei nostri modelli cartella, creiamo un file e gli chiamiamo user.js . Il percorso completo di questo file dovrebbe essere app/models/user.js.
Apri il file user.js e aggiungi il seguente codice:
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;
} Ora esegui:
node server.js
Dovresti vedere il familiare "Il sito è attivo. Bello! Banca dati sembra a posto. " messaggio. Ciò significa che i nostri modelli Sequelize sono stati sincronizzati correttamente e se controlli il tuo database dovresti vedere una tabella utenti con le colonne specificate presenti.
3:Imposta viste
Per prima cosa, creiamo la vista per la registrazione e la colleghiamo.
La prima cosa da fare è importare il modulo manubrio espresso che utilizziamo per le visualizzazioni in questo tutorial.
Aggiungi questa riga al file di avvio principale, server.js.
var exphbs = require('express-handlebars')
Il tuo blocco di importazione dovrebbe essere simile a questo a questo punto.
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') Successivamente, aggiungiamo le seguenti righe nel nostro file server.js.
//For Handlebars
app.set('views', './app/views')
app.engine('hbs', exphbs({
extname: '.hbs'
}));
app.set('view engine', '.hbs'); Ora, nella nostra cartella dell'app, creiamo tre cartelle denominate viste, titolari del trattamento e percorsi .
Nella cartella delle visualizzazioni, creiamo un file chiamato registrazione. hbs e incollaci il codice qui sotto.
<!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> Poi nei nostri controller cartella, creiamo un nuovo file e lo chiamiamo authcontroller.js.
In questo file, incolliamo il seguente controller per il percorso di registrazione che creeremo tra poco.
var exports = module.exports = {}
exports.signup = function(req, res) {
res.render('signup');
} Successivamente, creiamo un percorso per la registrazione. Nella cartella dei percorsi, creiamo un nuovo file denominato auth.js e quindi, in questo file, importiamo il controller di autenticazione e definiamo il percorso di registrazione.
var authController = require('../controllers/authcontroller.js');
module.exports = function(app) {
app.get('/signup', authController.signup);
} Ora importeremo questo percorso nel nostro server.js e passeremo l'app come argomento.
Nel server, dopo l'importazione dei modelli, aggiungi queste righe:
//Routes
var authRoute = require('./app/routes/auth.js')(app); Esegui questo:
node server.js
Ora visita http://localhost:5000/signup e vedrai il modulo di registrazione.
Ripetiamo i passaggi per il modulo di accesso. Come prima, creeremo un file denominato signin.hbs nella nostra cartella delle visualizzazioni e incollarvi il seguente codice HTML:
<!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> Quindi, aggiungi un controller per l'accesso in app/controllers/authcontroller.js.
exports.signin = function(req, res) {
res.render('signin');
} Quindi in app/routes/auth.js , aggiungiamo un percorso per l'accesso come questo:
app.get('/signin', authController.signin);
Ora quando corri:
node server.js
e visita http://localhost:5000/signin/, dovresti vedere il modulo di accesso.
Il passo finale e importante è scrivere le nostre strategie per i passaporti.
4. Scrivi una strategia del passaporto
In app/config , creiamo una nuova cartella denominata passport.
Quindi nella nostra nuova cartella app/config/passport, creiamo un nuovo file e lo chiamiamo passport.js . Questo file conterrà le nostre strategie per i passaporti.
In passport.js , utilizzeremo il modello utente e il passaporto.
Per prima cosa importiamo bcrypt di cui abbiamo bisogno per proteggere le password.
var bCrypt = require('bcrypt-nodejs');
Quindi, aggiungiamo un blocco module.exports come questo:
module.exports = function(passport, user) {
} All'interno di questo blocco, inizializziamo la strategia passport-local e il modello utente, che verrà passato come argomento. Ecco come lo facciamo:
module.exports = function(passport, user) {
var User = user;
var LocalStrategy = require('passport-local').Strategy;
} Quindi definiamo la nostra strategia personalizzata con la nostra istanza di LocalStrategy in questo modo:
passport.use('local-signup', new LocalStrategy(
{
usernameField: 'email',
passwordField: 'password',
passReqToCallback: true // allows us to pass back the entire request to the callback
},
)); Ora abbiamo dichiarato quale richiesta (req ) i campi sono i nostri usernameField e passwordField (variabili del passaporto).
L'ultima variabile passReqToCallback ci permette di passare l'intera richiesta al callback, che è particolarmente utile per la registrazione.
Dopo l'ultima virgola, aggiungiamo questa funzione di callback.
function(req, email, password, done) {
} In questa funzione, ci occuperemo della memorizzazione dei dettagli di un utente.
Innanzitutto, aggiungiamo la nostra funzione di generazione della password con hash all'interno della funzione di callback.
var generateHash = function(password) {
return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null);
}; Quindi, utilizzando il modello utente Sequelize che abbiamo inizializzato in precedenza come Utente , controlliamo se l'utente esiste già e, in caso contrario, lo aggiungiamo.
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() è un metodo Sequelize per aggiungere nuove voci al database. Si noti che i valori nei dati oggetto sono ottenuti da req.body oggetto che contiene l'input dal nostro modulo di registrazione.
Il tuo passport.js dovrebbe assomigliare a questo:
//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);
}
});
}
});
}
));
} Ora importeremo la strategia in server.js.
Per fare ciò, aggiungiamo queste righe sotto l'importazione dei percorsi in server.js.
//load passport strategies
require('./app/config/passport/passport.js')(passport, models.user); Il tuo server.js dovrebbe apparire così in questo momento:
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)
}); Ora applicheremo effettivamente la strategia al nostro /registrazione percorso.
Ecco come lo facciamo:
Per prima cosa, andiamo su app/routes/auth.js e aggiungi un percorso per la pubblicazione per registrarti in questo modo.
app.post('/signup', passport.authenticate('local-signup', {
successRedirect: '/dashboard',
failureRedirect: '/signup'
}
)); Dal momento che abbiamo bisogno del passaporto, dobbiamo passarlo a questo metodo. Possiamo importare il passaporto in questo script o passarlo da server.js. Facciamo quest'ultimo.
Modifica la funzione esportata in questo file app/routes/auth.js avere il passaporto come parametro. Il codice in app/routes/auth.js dovrebbe apparire così dopo la modifica.
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'
}
));
} Quindi in server.js , modifichiamo le rotte import e aggiungiamo passport come argomento come questo:
var authRoute = require('./app/routes/auth.js')(app,passport);
Ora vai all'URL di registrazione http://localhost:5000/signup/ e prova a registrarti.
Quando provi a registrarti, riceverai un messaggio di errore "Impossibile serializzare l'utente nella sessione ". Questo perché il passaporto deve salvare un ID utente nella sessione e lo utilizza per gestire il recupero dei dettagli dell'utente quando necessario.
Per risolvere questo problema, implementeremo sia le funzioni di serializzazione che di deserializzazione di passport nel nostro app/config/passport/passport.js file.
Per prima cosa aggiungiamo la funzione serialize. In questa funzione, salveremo l'ID utente alla sessione.
Per fare ciò, aggiungiamo le seguenti righe sotto l'inizializzazione della strategia locale.
//serialize
passport.serializeUser(function(user, done) {
done(null, user.id);
}); Successivamente, implementiamo la funzione di deserializzazione. Aggiungi la funzione appena sotto la funzione serializza.
// deserialize user
passport.deserializeUser(function(id, done) {
User.findById(id).then(function(user) {
if (user) {
done(null, user.get());
} else {
done(user.errors, null);
}
});
});
Nella funzione deserialize sopra, usiamo il Sequelize findById promette di ottenere l'utente e, in caso di successo, viene restituita un'istanza del modello Sequelize. Per ottenere l'oggetto User da questa istanza, utilizziamo la funzione Sequelize getter in questo modo:user.get() .
Ora corri di nuovo:
node server.js
E prova a registrarti. Evviva se hai il "Cannot GET /dashboard"! Significa che la nostra autenticazione è riuscita. Ricorda che siamo stati reindirizzati a /dashboard nel nostro metodo passport.authenticate in routes/auth.js .
Ora andiamo avanti e aggiungiamo quel percorso. Quindi, aggiungi un middleware per assicurarti che sia possibile accedere alla pagina solo quando un utente ha effettuato l'accesso alla sessione.
Nella nostra app/viste cartella, creiamo un nuovo file chiamato dashboard.hbs e aggiungi il seguente codice HTML.
<!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 , aggiungiamo questa riga all'interno di module.exports blocco:
app.get('/dashboard',authController.dashboard);
Successivamente, andiamo su app/controllers/authController.js e aggiungi il controller dashboard.
exports.dashboard = function(req, res) {
res.render('dashboard');
} Il tuo AuthController.js dovrebbe assomigliare a questo:
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');
} Ora, esegui di nuovo l'app e prova a registrarti con un indirizzo email diverso da quello che hai utilizzato in precedenza. Verrai opportunamente reindirizzato alla /dashboard rotta.
Ma /dashboard non è un percorso protetto, il che significa che anche se un utente non ha effettuato l'accesso, può vederlo. Non lo vogliamo, quindi aggiungeremo un /logout percorso per disconnettere l'utente, quindi proteggere il percorso e verificare ciò che abbiamo fatto.
Facciamo così:
In routes/auth.js aggiungiamo questa riga:
app.get('/logout',authController.logout);
Quindi aggiungiamo il controller in app/controllers/authController.js.
exports.logout = function(req, res) {
req.session.destroy(function(err) {
res.redirect('/');
});
} Ora esegui di nuovo l'app e registrati con un indirizzo email diverso.
Successivamente, visita http://localhost:5000/logout per disconnettere l'utente. Ora visita http://localhost:5000/dashboard.
Noterai che è abbastanza accessibile. Aggiungiamo un middleware personalizzato per proteggere quel percorso.
Per fare ciò, apriamo app/routes/auth.js e aggiungi questa funzione in module.exports blocco, sotto tutte le altre righe di codice.
function isLoggedIn(req, res, next) {
if (req.isAuthenticated())
return next();
res.redirect('/signin');
} Quindi modifichiamo il gestore del percorso della dashboard in modo che assomigli a questo:
app.get('/dashboard',isLoggedIn, authController.dashboard);
Ora, quando esegui nuovamente l'app e provi a visitare la pagina del dashboard e non sei connesso, dovresti essere reindirizzato alla pagina di accesso.
Accidenti! È tempo di implementare la parte finale:l'accesso.
Innanzitutto, aggiungeremo una nuova strategia locale per l'accesso 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 questa strategia, il isValidPassword la funzione confronta la password inserita con il metodo di confronto bCrypt poiché abbiamo memorizzato la nostra password con bcrypt .
Se i dettagli sono corretti, il nostro utente verrà registrato.
Ora vai su routes/auth.js e aggiungi il percorso per la pubblicazione su / accesso.
app.post('/signin', passport.authenticate('local-signin', {
successRedirect: '/dashboard',
failureRedirect: '/signin'
}
)); Quando hai finito, i tuoi percorsi/auth.js dovrebbero avere questo aspetto.
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');
}
} Ora esegui l'app e prova ad accedere. Dovresti essere in grado di accedere con tutti i dettagli che hai utilizzato durante la registrazione e verrai indirizzato a http ://localhost:5000/dashboard/.
Congratulazioni se sei arrivato alla fine di questo tutorial! Abbiamo utilizzato con successo Sequelize e Passport con un database MySQL.
Il codice completo per questo tutorial è disponibile su GitHub.
