Sequelize es un ORM de Node.js basado en promesas. Se puede usar con PostgreSQL, MySQL, MariaDB, SQLite y MSSQL. En este tutorial, implementaremos la autenticación para los usuarios de una aplicación web. Y usaremos Passport, el popular middleware de autenticación para Node, junto con Sequelize y MySQL para implementar el registro de usuarios y el inicio de sesión.
Cómo empezar
Asegúrese de tener instalado lo siguiente en su máquina:
- Nodo
- MySQL
Para este tutorial, usaremos Node.js junto con Express, así que continuamos y comenzamos a instalar lo que necesitamos.
Paso 1:Genere un archivo package.json
Cree un directorio para su aplicación. Dentro de este directorio, ejecute esto desde su terminal o símbolo del sistema:
npm init
Esto inicializa el administrador de dependencias de npm. Esto presentará una serie de indicaciones que revisaremos rápidamente.
- Escriba el nombre de su aplicación sin espacios y presione Entrar para 'nombre'.
- Presione Enter para la 'versión'.
- Para 'descripción', en este tutorial, escribiremos "Uso de Passport con Sequelize y MySQL" como descripción y presionaremos Intro. Esto también puede estar en blanco.
- Para 'punto de entrada (index.js)', escriba server.js y presione Entrar.
- Para 'comando de prueba', presione Entrar.
- Para 'repositorio de git', puede ingresar el repositorio de git donde reside su aplicación si tiene uno o simplemente presione Entrar para dejarlo en blanco.
- Para 'Palabras clave', presione Entrar.
- Para 'autor', presione Entrar o escriba su nombre antes de hacerlo.
- Para 'licencia', presione Entrar.
- Para '(Is this okay )', esto le muestra cómo se verá su paquete.json. Escriba Sí y presione Entrar.
Paso 2:Instalar dependencias
Las principales dependencias de este tutorial son:
- Expreso
- Secuela
- MySQL
- Pasaporte
- Estrategia local de pasaporte
- Analizador de cuerpo
- Sesión exprés
- Bcrypt Nodejs
- Express Handlebars para las vistas
Para instalarlos, desde su terminal o símbolo del sistema, ejecute uno tras otro.
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
Si está utilizando Git para este proyecto:
En la carpeta de su proyecto, cree un archivo .gitignore.
Agregue esta línea al archivo .gitignore.
node_modules
Paso 3:configurar la aplicación
Ahora, creamos un archivo de servidor. Este será el archivo principal llamado cuando escriba lo siguiente:
npm start
Esto ejecuta la aplicación. También puede ejecutar la aplicación escribiendo node server.js.
node server.js
Luego, en nuestra carpeta de proyecto, creamos un nuevo archivo y lo llamamos server.js .
Dentro de server.js archivo, pegamos lo siguiente:
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 primera línea asigna el módulo express a una variable express. Luego inicializamos express y lo nombramos una variable:app.
Luego hacemos que la aplicación escuche en el puerto 5000 . Puede elegir cualquier número de puerto libre en su computadora.
A continuación, llamamos a app.get() función de enrutamiento express para responder con "Bienvenido a Passport con Sequelize" cuando se realiza una solicitud GET a "/".
Para probar en su computadora, ejecute esto desde dentro de la carpeta de su proyecto:
node server.js
Si ve el texto "Bienvenido a Passport con Sequelize" cuando visita http://localhost:5000/, ¡felicidades! De lo contrario, verifique que haya hecho todo exactamente como está escrito arriba.
A continuación, importamos algunos módulos que necesitamos, como passport, express-session y body-parser.
Después de var app = express() añadimos las siguientes líneas:
var passport = require('passport')
var session = require('express-session')
var bodyParser = require('body-parser') En las dos primeras líneas, importamos el módulo de pasaporte y la sesión rápida, los cuales necesitamos para gestionar la autenticación.
Luego, importamos el módulo analizador de cuerpo. Esto extrae la parte del cuerpo completo de una solicitud entrante y la expone en un formato con el que es más fácil trabajar. En este caso, utilizaremos el formato JSON.
Para permitir que nuestra aplicación use el analizador de cuerpo, agregamos estas líneas algunos espacios debajo de las líneas de importación:
//For BodyParser
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json()); A continuación, inicializamos el pasaporte, la sesión exprés y la sesión del pasaporte y los agregamos como middleware. Hacemos esto agregando estas líneas algunos espacios después de la línea de importación de 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 Comenzaremos a trabajar en la autenticación real ahora.
Haremos esto en cuatro pasos:
- Configure Sequelize con MySQL.
- Cree el modelo de usuario.
- Configurar vistas.
- Escribe una estrategia de pasaporte.
1. Configurar Sequelize con MySQL
Primero, creamos una base de datos en MySQL. Dale tu nombre preferido. Por el bien de este tutorial, vamos a crear una base de datos llamada sequelize_passport en MySQL.
Luego configuramos la configuración para manejar los detalles de la base de datos.
Primero, importemos el módulo dot-env para manejar las variables de entorno.
Ejecute esto en la carpeta de su proyecto raíz:
npm install --save dotenv
Luego lo importamos en el archivo del servidor principal, server.js, justo debajo de las otras importaciones.
var env = require('dotenv').load(); A continuación, creamos un archivo en nuestra carpeta de proyecto y lo llamamos .env.
El próximo paso a seguir es opcional si no estás usando Git:
Agregaremos el archivo .env a su archivo .gitignore.
Su archivo .gitignore debería verse así:
node_modules .env
Después de esto, agregamos nuestro entorno al archivo .env agregando esta línea:
NODE_ENV='development'
Luego creamos un archivo config.json que será utilizado por Sequelize para administrar diferentes entornos.
Lo primero que debe hacer es crear una carpeta llamada config en nuestra carpeta de proyectos. Dentro de esta carpeta, creamos un config. json expediente. Este archivo debe ignorarse si está enviando a un repositorio. Para hacer esto, agregue el siguiente código a su .gitignore:
config/config.json
Luego, pegamos el siguiente código en nuestro archivo 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"
}
} Recuerde reemplazar los valores en el bloque de desarrollo anterior con los detalles de autenticación de su base de datos.
A continuación, instalamos Sequelize con npm. Para hacer esto, ejecute el siguiente comando en la carpeta raíz del proyecto:
npm install --save sequelize
Ahora es el momento de crear los modelos carpeta.
Primero, creamos un directorio llamado app en nuestra carpeta de proyectos.
Dentro de la aplicación carpeta, creamos una nueva carpeta llamada models y crea un nuevo archivo llamado index.js en los modelos carpeta.
Dentro del archivo index.js, pegamos el código a continuación.
"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; Este archivo se usa para importar todos los modelos que colocamos en los modelos carpeta y exportarlos.
Para probar que todo está bien, agregamos esto en nuestro archivo 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!")
}); Aquí, estamos importando los modelos y luego llamando a la función de sincronización Sequelize.
Ejecute esto para ver si todo está bien:
node server.js
Si recibe el mensaje "El sitio está activo. ¡Bien! La base de datos se ve bien", entonces ha configurado Sequelize correctamente.
De lo contrario, siga cuidadosamente los pasos anteriores e intente solucionar el problema con ayuda.
2. Crear el modelo de usuario
Lo siguiente que vamos a hacer es crear el modelo de usuario, que es básicamente la tabla de usuarios. Esto contendrá información básica del usuario.
En nuestros modelos carpeta, creamos un archivo y lo llamamos user.js . La ruta completa de este archivo debe ser app/models/user.js.
Abra el archivo user.js y agregue el siguiente código:
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;
} Ahora ejecuta:
node server.js
Debería ver el mensaje familiar "El sitio está activo. ¡Genial! Base de datos se ve bien. " mensaje. Esto significa que nuestros modelos de Sequelize se han sincronizado con éxito, y si revisa su base de datos, debería ver una tabla de usuarios con las columnas especificadas presentes.
3:Configurar vistas
Primero, creemos la vista para el registro y conéctela.
Lo primero que debe hacer es importar el módulo de manillar express que usamos para las vistas en este tutorial.
Agregue esta línea al archivo de inicio principal, server.js.
var exphbs = require('express-handlebars')
Su bloque de importación debería verse así en este 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') A continuación, agregamos las siguientes líneas en nuestro archivo server.js.
//For Handlebars
app.set('views', './app/views')
app.engine('hbs', exphbs({
extname: '.hbs'
}));
app.set('view engine', '.hbs'); Ahora, en nuestra carpeta de aplicaciones, creamos tres carpetas llamadas views, controladores, y rutas .
En la carpeta de vistas, creamos un archivo llamado registro. hb y pegue el código de abajo en él.
<!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> Luego en nuestros controladores carpeta, creamos un nuevo archivo y lo llamamos authcontroller.js.
En este archivo, pegamos el siguiente controlador para la ruta de registro que crearemos en un momento.
var exports = module.exports = {}
exports.signup = function(req, res) {
res.render('signup');
} A continuación, creamos una ruta para registrarse. En la carpeta de rutas, creamos un nuevo archivo llamado auth.js y luego, en este archivo, importamos el controlador de autenticación y definimos la ruta de registro.
var authController = require('../controllers/authcontroller.js');
module.exports = function(app) {
app.get('/signup', authController.signup);
} Ahora, importaremos esta ruta en nuestro servidor.js y pasaremos la aplicación como argumento.
En el servidor, después de importar los modelos, agregue estas líneas:
//Routes
var authRoute = require('./app/routes/auth.js')(app); Ejecuta esto:
node server.js
Ahora, visite http://localhost:5000/signup y verá el formulario de registro.
Repitamos los pasos para el formulario de inicio de sesión. Como antes, crearemos un archivo llamado signin.hbs en nuestra carpeta de vistas y pegue el siguiente código HTML en ella:
<!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> Luego, agregue un controlador para el inicio de sesión en app/controllers/authcontroller.js.
exports.signin = function(req, res) {
res.render('signin');
} Luego en app/routes/auth.js , agregamos una ruta para iniciar sesión como esta:
app.get('/signin', authController.signin);
Ahora cuando ejecutas:
node server.js
y visite http://localhost:5000/signin/, debería ver el formulario de inicio de sesión.
El paso final y más importante es escribir nuestras estrategias de pasaporte.
4. Escribe una estrategia de pasaporte
En aplicación/config , creamos una nueva carpeta llamada pasaporte.
Luego, en nuestra nueva carpeta app/config/passport, creamos un nuevo archivo y lo llamamos passport.js . Este archivo contendrá nuestras estrategias de pasaporte.
En pasaporte.js , utilizaremos el modelo de usuario y pasaporte.
Primero, importamos bcrypt que necesitamos para proteger las contraseñas.
var bCrypt = require('bcrypt-nodejs');
Luego, agregamos un bloque module.exports como este:
module.exports = function(passport, user) {
} Dentro de este bloque, inicializamos la estrategia de pasaporte local y el modelo de usuario, que se pasará como argumento. Así es como hacemos esto:
module.exports = function(passport, user) {
var User = user;
var LocalStrategy = require('passport-local').Strategy;
} Luego definimos nuestra estrategia personalizada con nuestra instancia de LocalStrategy así:
passport.use('local-signup', new LocalStrategy(
{
usernameField: 'email',
passwordField: 'password',
passReqToCallback: true // allows us to pass back the entire request to the callback
},
)); Ahora hemos declarado qué solicitud (req ) son nuestros campos de nombre de usuario y campo de contraseña (variables de pasaporte).
La última variable passReqToCallback nos permite pasar la solicitud completa a la devolución de llamada, lo que es particularmente útil para registrarse.
Después de la última coma, agregamos esta función de devolución de llamada.
function(req, email, password, done) {
} En esta función, nos encargaremos de almacenar los detalles de un usuario.
Primero, agregamos nuestra función de generación de contraseña hash dentro de la función de devolución de llamada.
var generateHash = function(password) {
return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null);
}; Luego, usando el modelo de usuario de Sequelize que inicializamos anteriormente como Usuario , verificamos si el usuario ya existe, y si no lo agregamos.
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() es un método Sequelize para agregar nuevas entradas a la base de datos. Observe que los valores en los datos los objetos se obtienen del req.body objeto que contiene la entrada de nuestro formulario de registro.
Su pasaporte.js debería verse así:
//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);
}
});
}
});
}
));
} Ahora importaremos la estrategia en server.js.
Para ello, añadimos estas líneas debajo de la importación de rutas en server.js.
//load passport strategies
require('./app/config/passport/passport.js')(passport, models.user); Su server.js debería verse así en este 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)
}); Ahora aplicaremos la estrategia a nuestro /signup ruta.
Así es como lo hacemos:
Primero, vamos a app/routes/auth.js y agregue una ruta para publicar para registrarse de esta manera.
app.post('/signup', passport.authenticate('local-signup', {
successRedirect: '/dashboard',
failureRedirect: '/signup'
}
)); Como necesitamos el pasaporte, debemos pasarlo a este método. Podemos importar el pasaporte en este script o pasarlo desde server.js. Hagamos lo último.
Modifique la función exportada en este archivo app/routes/auth.js tener pasaporte como parámetro. El código en app/routes/auth.js debería verse así después de su modificación.
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'
}
));
} Luego en server.js , modificamos la importación de rutas y agregamos pasaporte como un argumento como este:
var authRoute = require('./app/routes/auth.js')(app,passport);
Ahora, vaya a la URL de registro http://localhost:5000/signup/ e intente registrarse.
Cuando intente registrarse, obtendrá un error "Error al serializar al usuario en la sesión ". Esto se debe a que Passport tiene que guardar una identificación de usuario en la sesión y la usa para administrar la recuperación de los detalles del usuario cuando es necesario.
Para resolver esto, vamos a implementar las funciones de serialización y deserializacion de pasaporte en nuestra app/config/passport/passport.js archivo.
Primero agregamos la función de serialización. En esta función, estaremos guardando la identificación de usuario a la sesión.
Para ello, añadimos las siguientes líneas debajo de la inicialización de la estrategia local.
//serialize
passport.serializeUser(function(user, done) {
done(null, user.id);
}); A continuación, implementamos la función de deserialización. Agregue la función justo debajo de la función de serialización.
// deserialize user
passport.deserializeUser(function(id, done) {
User.findById(id).then(function(user) {
if (user) {
done(null, user.get());
} else {
done(user.errors, null);
}
});
});
En la función de deserializar anterior, usamos Sequelize findById promete obtener al usuario y, si tiene éxito, se devuelve una instancia del modelo Sequelize. Para obtener el objeto Usuario de esta instancia, usamos la función captadora Sequelize como esta:user.get() .
Ahora ejecuta de nuevo:
node server.js
E intenta registrarte. ¡Hurra si tienes el mensaje "Cannot GET /dashboard"! Significa que nuestra autenticación fue exitosa. Recuerde que redirigimos a /dashboard en nuestro método de autenticación de pasaporte en routes/auth.js .
Ahora sigamos adelante y agreguemos esa ruta. Luego, agregue un middleware para asegurarse de que solo se pueda acceder a la página cuando un usuario haya iniciado sesión.
En nuestra aplicación/vistas carpeta, creamos un nuevo archivo llamado dashboard.hbs y agregue el siguiente código HTML en él.
<!DOCTYPE html>
<html>
<head>
<title>Passport with Sequelize</title>
</head>
<body>
<h2>Dashboard</h2>
<h5>Hurray! you are logged in.</h5>
</body>
</html> En rutas/auth.js , añadimos esta línea dentro de module.exports bloque:
app.get('/dashboard',authController.dashboard);
A continuación, vamos a app/controllers/authController.js y agregue el controlador del tablero.
exports.dashboard = function(req, res) {
res.render('dashboard');
} Tu AuthController.js debería verse así:
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');
} Ahora, ejecute la aplicación nuevamente e intente registrarse con una dirección de correo electrónico diferente a la que usó anteriormente. Se le redirigirá correctamente al /panel de control ruta.
Pero /panel no es una ruta protegida, lo que significa que incluso si un usuario no ha iniciado sesión, puede verla. No queremos esto, así que agregaremos un /logout route para cerrar la sesión del usuario y luego proteger la ruta y probar lo que hemos hecho.
Hagamos esto:
En rutas/auth.js agregamos esta línea:
app.get('/logout',authController.logout);
Luego agregamos el controlador en app/controllers/authController.js.
exports.logout = function(req, res) {
req.session.destroy(function(err) {
res.redirect('/');
});
} Ahora ejecute la aplicación nuevamente y regístrese con una dirección de correo electrónico diferente.
Después de eso, visite http://localhost:5000/logout para cerrar la sesión del usuario. Ahora visite http://localhost:5000/dashboard.
Notarás que es bastante accesible. Agreguemos un middleware personalizado para proteger esa ruta.
Para hacer esto, abrimos app/routes/auth.js y agregue esta función en module.exports bloque, debajo de todas las demás líneas de código.
function isLoggedIn(req, res, next) {
if (req.isAuthenticated())
return next();
res.redirect('/signin');
} Luego modificamos el controlador de ruta del tablero para que se vea así:
app.get('/dashboard',isLoggedIn, authController.dashboard);
Ahora, cuando vuelva a ejecutar la aplicación e intente visitar la página del panel y no haya iniciado sesión, debería ser redirigido a la página de inicio de sesión.
¡Uf! Es hora de implementar la parte final:el inicio de sesión.
Primero, agregaremos una nueva estrategia local para iniciar sesión en 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'
});
});
}
));
En esta estrategia, el isValidPassword La función compara la contraseña ingresada con el método de comparación bCrypt ya que almacenamos nuestra contraseña con bcrypt .
Si los detalles son correctos, nuestro usuario iniciará sesión.
Ahora ve a routes/auth.js y agregue la ruta para publicar en / iniciar sesión.
app.post('/signin', passport.authenticate('local-signin', {
successRedirect: '/dashboard',
failureRedirect: '/signin'
}
)); Tus rutas/auth.js deberían verse así cuando hayas terminado.
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');
}
} Ahora ejecute la aplicación e intente iniciar sesión. Debería poder iniciar sesión con cualquiera de los detalles que usó al registrarse, y será dirigido a http ://localhost:5000/panel/.
¡Felicitaciones si llegaste al final de este tutorial! Hemos utilizado con éxito Sequelize y Passport con una base de datos MySQL.
El código completo de este tutorial se puede encontrar en GitHub.
