Sequelize est un ORM Node.js basé sur des promesses. Il peut être utilisé avec PostgreSQL, MySQL, MariaDB, SQLite et MSSQL. Dans ce didacticiel, nous allons implémenter l'authentification pour les utilisateurs d'une application Web. Et nous utiliserons Passport, le middleware d'authentification populaire pour Node, avec Sequelize et MySQL pour implémenter l'enregistrement et la connexion des utilisateurs.
Mise en route
Assurez-vous que les éléments suivants sont installés sur votre ordinateur :
- Nœud
- MySQL
Pour ce didacticiel, nous utiliserons Node.js avec Express, nous allons donc de l'avant et commençons à installer ce dont nous avons besoin.
Étape 1 :Générer un fichier package.json
Créez un répertoire pour votre application. Dans ce répertoire, exécutez-le depuis votre terminal ou l'invite de commande :
npm init
Cela initialise le gestionnaire de dépendances npm. Cela présentera une série d'invites que nous allons parcourir rapidement.
- Tapez le nom de votre application sans espaces et appuyez sur Entrée pour "nom".
- Appuyez sur Entrée pour la 'version'.
- Pour 'description', dans ce didacticiel, nous allons saisir "Utilisation de Passport avec Sequelize et MySQL" comme description et appuyer sur Entrée. Cela peut aussi être vide.
- Pour "point d'entrée (index.js)", saisissez server.js et appuyez sur Entrée.
- Pour 'test command', appuyez sur Entrée.
- Pour 'git repository', vous pouvez entrer le dépôt git où réside votre application si vous en avez un ou simplement appuyer sur Entrée pour laisser ce champ vide.
- Pour "Mots clés", appuyez sur Entrée.
- Pour "auteur", appuyez sur Entrée ou saisissez votre nom avant de le faire.
- Pour "licence", appuyez sur Entrée.
- Pour '(Is this okay )', cela vous montre à quoi ressemblera votre package.json. Tapez Oui et appuyez sur Entrée.
Étape 2 :Installer les dépendances
Les principales dépendances de ce didacticiel sont :
- Express
- Séqueliser
- MySQL
- Passeport
- Stratégie locale de passeport
- Analyseur de corps
- Séance express
- Bcrypt Nodejs
- Express Handlebars pour les vues
Pour les installer, depuis votre terminal ou invite de commande, lancez les suivants les uns après les autres.
npm installer express --savenpm installer sequelize --savenpm installer mysql --savenpm installer passeport --savenpm installer passeport-local --savenpm installer body-parser --savenpm installer express-session --savenpm installer bcrypt-nodejs - -savenpm install express-handlebars --save
Si vous utilisez Git pour ce projet :
Dans votre dossier de projet, créez un fichier .gitignore.
Ajoutez cette ligne au fichier .gitignore.
node_modules
Étape 3 :Configurer l'application
Maintenant, nous créons un fichier serveur. Ce sera le fichier principal appelé lorsque vous tapez ce qui suit :
début npm
Cela exécute l'application. Vous pouvez également exécuter l'application en tapant node server.js.
node server.js
Ensuite, dans notre dossier de projet, nous créons un nouveau fichier et nommons ce fichier server.js .
À l'intérieur de server.js fichier, nous collons ce qui suit :
var express =require('express');var app =express();app.get('/', function(req, res) { res.send('Bienvenue dans Passport avec Sequelize');});app.listen(5000, function(err) { if (!err) console.log("Site is live"); else console.log(err)}); La première ligne attribue le module express à une variable express. Nous initialisons ensuite express et lui nommons une variable :app.
Ensuite, nous faisons écouter l'application sur le port 5000 . Vous pouvez choisir n'importe quel numéro de port libre sur votre ordinateur.
Ensuite, nous appelons le app.get() fonction de routage express pour répondre par "Bienvenue dans Passport avec Sequelize" lorsqu'une requête GET est faite à "/".
Pour tester sur votre ordinateur, exécutez ceci depuis le dossier de votre projet :
node server.js
Si vous voyez le texte "Bienvenue dans Passport avec Sequelize" lorsque vous visitez http://localhost:5000/ alors félicitations ! Sinon, vérifiez que vous avez tout fait exactement comme il est écrit ci-dessus.
Ensuite, nous importons certains modules dont nous avons besoin, comme passport, express-session et body-parser.
Après var app = express() nous ajoutons les lignes suivantes :
var passeport =require('passport')var session =require('express-session')var bodyParser =require('body-parser') Dans les deux premières lignes, nous importons le module de passeport et la session express, dont nous avons besoin pour gérer l'authentification.
Ensuite, nous importons le module body-parser. Cela extrait toute la partie du corps d'une demande entrante et l'expose dans un format plus facile à utiliser. Dans ce cas, nous utiliserons le format JSON.
Pour permettre à notre application d'utiliser l'analyseur de corps, nous ajoutons ces lignes quelques espaces sous les lignes d'importation :
//Pour BodyParserapp.use(bodyParser.urlencoded({ extended :true }));app.use(bodyParser.json()); Ensuite, nous initialisons le passeport et la session express et la session de passeport et les ajoutons tous les deux en tant que middleware. Nous faisons cela en ajoutant ces lignes quelques espaces après la ligne d'importation bodyParser.
// For Passportapp.use(session({ secret :'keyboard cat',resave :true, saveUninitialized:true})); // session secretapp.use(passport.initialize());app.use(passport.session()); // sessions de connexion persistantes Nous allons commencer à travailler sur l'authentification proprement dite maintenant.
Nous procéderons en quatre étapes :
- Configurer Sequelize avec MySQL.
- Créez le modèle utilisateur.
- Configurer les vues.
- Rédiger une stratégie de passeport.
1. Configurer Sequelize avec MySQL
Tout d'abord, nous créons une base de données dans MySQL. Donnez-lui votre nom préféré. Pour les besoins de ce tutoriel, créons une base de données nommée sequelize_passport dans MySQL.
Ensuite, nous configurons la configuration pour gérer les détails de la base de données.
Tout d'abord, importons le module dot-env pour gérer les variables d'environnement.
Exécutez ceci dans votre dossier de projet racine :
npm install --save dotenv
Ensuite, nous l'importons dans le fichier du serveur principal, server.js, juste en dessous des autres importations.
var env =require('dotenv').load(); Ensuite, nous créons un fichier dans notre dossier de projet et le nommons .env.
Cette prochaine étape à suivre est facultative si vous n'utilisez pas Git :
Nous ajouterons le fichier .env à votre fichier .gitignore.
Votre fichier .gitignore devrait ressembler à ceci :
node_modules.env
Après cela, nous ajoutons notre environnement au fichier .env en ajoutant cette ligne :
NODE_ENV='development'
Ensuite, nous créons un fichier config.json qui sera utilisé par Sequelize pour gérer différents environnements.
La première chose à faire est de créer un dossier nommé config dans notre dossier de projet. Dans ce dossier, nous créons un config. json dossier. Ce fichier doit être ignoré si vous poussez vers un référentiel. Pour cela, ajoutez le code suivant à votre .gitignore :
config/config.json
Ensuite, nous collons le code suivant dans notre fichier 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" }} N'oubliez pas de remplacer les valeurs dans le bloc de développement ci-dessus par les détails d'authentification de votre base de données.
Ensuite, nous installons sequelize avec npm. Pour ce faire, exécutez la commande suivante dans le dossier racine du projet :
npm install --save sequelize
Il est maintenant temps de créer les modèles dossier.
Tout d'abord, nous créons un répertoire nommé app dans notre dossier de projet.
Dans l'application dossier, nous créons un nouveau dossier nommé modèles et créez un nouveau fichier nommé index.js dans les modèles dossier.
Dans le fichier index.js, nous collons le code ci-dessous.
"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; Ce fichier est utilisé pour importer tous les modèles que nous plaçons dans les modèles dossier et exportez-les.
Pour tester que tout va bien, nous ajoutons ceci dans notre fichier server.js.
//Modelsvar models =require("./app/models");//Sync Databasemodels.sequelize.sync().then(function() { console.log('Nice ! La base de données a l'air bien')}) .catch(function(err) { console.log(err, "Quelque chose s'est mal passé avec la mise à jour de la base de données!")}); Ici, nous importons les modèles, puis appelons la fonction Sequelize sync.
Exécutez ceci pour voir si tout va bien :
node server.js
Si vous obtenez le message "Site is live Nice! Database looks fine", alors vous avez configuré Sequelize avec succès.
Si ce n'est pas le cas, veuillez suivre attentivement les étapes ci-dessus et essayez de déboguer le problème avec de l'aide.
2. Créer le modèle utilisateur
La prochaine chose que nous allons faire est de créer le modèle utilisateur, qui est essentiellement la table utilisateur. Celui-ci contiendra des informations utilisateur de base.
Dans nos modèles dossier, nous créons un fichier et le nommons user.js . Le chemin complet de ce fichier doit être app/models/user.js.
Ouvrez le fichier user.js et ajoutez le code suivant :
module.exports =function(sequelize, Sequelize) { var User =sequelize.define('user', { id :{ autoIncrement :true, primaryKey :true, type :Sequelize.INTEGER }, firstname :{ type :Sequelize .STRING, notEmpty :vrai }, nom :{ type :Sequelize.STRING, notEmpty :vrai }, nom d'utilisateur :{ type :Sequelize.TEXT }, à propos de :{ type :Sequelize.TEXT }, e-mail :{ type :Sequelize.STRING , valider :{ isEmail :true } }, mot de passe :{ type :Sequelize.STRING, allowNull :false }, last_login :{ type :Sequelize.DATE }, statut :{ type :Sequelize.ENUM('actif', 'inactif' ), valeur par défaut :'active' } }); renvoyer l'utilisateur ; } Exécutez maintenant :
node server.js
Vous devriez voir le familier "Le site est en ligne. Sympa ! Base de données a l'air bien. ". Cela signifie que nos modèles Sequelize ont été synchronisés avec succès, et si vous vérifiez votre base de données, vous devriez voir une table d'utilisateurs avec les colonnes spécifiées présentes.
3 :Configurer les vues
Tout d'abord, créons la vue pour l'inscription et connectons-la.
La première chose à faire est d'importer le module express handlebars que nous utilisons pour les vues dans ce tutoriel.
Ajoutez cette ligne au fichier de démarrage principal, server.js.
var exphbs = require('express-handlebars')
Votre bloc d'importation devrait ressembler à ceci à ce stade.
var express =require('express')var app =express()var passeport =require('passport')var session =require('express-session')var bodyParser =require('body-parser')var env =require('dotenv').load()var exphbs =require('express-handlebars') Ensuite, nous ajoutons les lignes suivantes dans notre fichier server.js.
//Pour le guidonapp.set('views', './app/views')app.engine('hbs', exphbs({ extname :'.hbs'}));app.set('view engine ', '.hbs'); Maintenant, dans notre dossier d'application, nous créons trois dossiers nommés views, contrôleurs, et itinéraires .
Dans le dossier des vues, nous créons un fichier nommé signup. hbs et collez-y le code ci-dessous.
Puis dans nos contrôleurs dossier, nous créons un nouveau fichier et le nommons authcontroller.js.
Dans ce fichier, nous collons le contrôleur suivant pour la route d'inscription que nous allons créer dans un instant.
var exports =module.exports ={}exports.signup =function(req, res) { res.render('signup');} Ensuite, nous créons une route pour l'inscription. Dans le dossier routes, nous créons un nouveau fichier nommé auth.js puis, dans ce fichier, nous importons le contrôleur d'authentification et définissons la route d'inscription.
var authController =require('../controllers/authcontroller.js');module.exports =function(app) { app.get('/signup', authController.signup);} Maintenant, nous allons importer cette route dans notre server.js et passer app comme argument.
Dans le serveur, après l'importation des modèles, ajoutez ces lignes :
//Routesvar authRoute =require('./app/routes/auth.js')(app); Exécutez ceci :
node server.js
Maintenant, visitez http://localhost:5000/signup et vous verrez le formulaire d'inscription.
Répétons les étapes pour le formulaire de connexion. Comme précédemment, nous allons créer un fichier nommé signin.hbs dans notre dossier de vues et collez-y le code HTML suivant :
Ensuite, ajoutez un contrôleur pour la connexion dans app/controllers/authcontroller.js.
exports.signin =function(req, res) { res.render('signin');} Puis dans app/routes/auth.js , nous ajoutons une route pour la connexion comme celle-ci :
app.get('/signin', authController.signin);
Maintenant, lorsque vous exécutez :
nœud serveur.js
et visitez http://localhost:5000/signin/, vous devriez voir le formulaire de connexion.
L'étape finale et majeure consiste à rédiger nos stratégies de passeport.
4. Rédiger une stratégie de passeport
Dans app/config , nous créons un nouveau dossier nommé passport.
Ensuite, dans notre nouveau dossier app/config/passport, nous créons un nouveau fichier et le nommons passport.js . Ce fichier contiendra nos stratégies de passeport.
Dans passport.js , nous utiliserons le modèle d'utilisateur et le passeport.
Tout d'abord, nous importons bcrypt dont nous avons besoin pour sécuriser les mots de passe.
var bCrypt = require('bcrypt-nodejs');
Ensuite, nous ajoutons un bloc module.exports comme ceci :
module.exports =fonction(passeport, utilisateur) {} A l'intérieur de ce bloc, nous initialisons la stratégie passeport-local, et le modèle utilisateur, qui sera passé en argument. Voici comment procéder :
module.exports =function(passport, user) { var User =user ; var LocalStrategy =require('passport-local').Strategy;} Ensuite, nous définissons notre stratégie personnalisée avec notre instance de LocalStrategy comme ceci :
passport.use('local-signup', new LocalStrategy( { usernameField:'email', passwordField:'password', passReqToCallback:true // nous permet de renvoyer l'intégralité de la requête au rappel },)); Nous avons maintenant déclaré quelle requête (req ) nos champs usernameField et passwordField (variables de passeport).
La dernière variable passReqToCallback permet de passer l'intégralité de la requête au callback, ce qui est particulièrement utile pour s'inscrire.
Après la dernière virgule, nous ajoutons cette fonction de rappel.
function(req, email, password, done) { } Dans cette fonction, nous gérerons le stockage des détails d'un utilisateur.
Tout d'abord, nous ajoutons notre fonction de génération de mot de passe haché dans la fonction de rappel.
var generateHash =function(password) { return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null); } ; Ensuite, en utilisant le modèle utilisateur Sequelize que nous avons initialisé plus tôt en tant que User , nous vérifions si l'utilisateur existe déjà, et si ce n'est pas le cas, nous l'ajoutons.
User.findOne({ where:{ email:email }}).then(function(user) { if (user) { return done(null, false, { message:'Cet email est déjà pris' }); } 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() est une méthode Sequelize pour ajouter de nouvelles entrées à la base de données. Notez que les valeurs dans les données objet sont obtenus à partir de req.body objet qui contient l'entrée de notre formulaire d'inscription.
Votre passport.js devrait ressembler à ceci :
//load bcryptvar bCrypt =require('bcrypt-nodejs');module.exports =function(passport, user) { var User =user; var LocalStrategy =require('passport-local').Strategy; passeport.use('local-signup', new LocalStrategy( { usernameField:'email', passwordField:'password', passReqToCallback:true // nous permet de retransmettre l'intégralité de la requête au rappel }, 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:'Cet email est déjà pris' }); } else { var userPassword =generateHash(password); var data ={ email:email, password:mot de passe de l'utilisateur, prénom :req.body.firstname, nom :req.body.lastname } ; User.create(data).then(function(newUser, created) { if (!newUser) { return done(null, false); } if (newUser) { return done(null, newUser); } }); } }); } ));} Nous allons maintenant importer la stratégie dans server.js.
Pour ce faire, nous ajoutons ces lignes sous les routes importées dans server.js.
//charger les stratégies de passeportrequire('./app/config/passport/passport.js')(passport, models.user); Votre server.js devrait ressembler à ceci pour le moment :
var express =require('express')var app =express()var passeport =require('passport')var session =require('express-session')var bodyParser =require('body-parser')var env =require('dotenv').load()var exphbs =require('express-handlebars')//For BodyParserapp.use(bodyParser.urlencoded({ extended:true}));app.use(bodyParser.json( ));// Pour Passportapp.use(session({ secret :'keyboard cat', resave :true, saveUninitialized :true})); // session secretapp.use(passport.initialize());app.use(passport.session()); // sessions de connexion persistantes // Pour Handlebarsapp.set('views', './app/views')app.engine('hbs', exphbs({ extname:'.hbs'}));app.set(' view engine', '.hbs');app.get('/', function(req, res) { res.send('Bienvenue dans Passport with Sequelize');});//Modelsvar models =require(". /app/models");//Routesvar authRoute =require('./app/routes/auth.js')(app);//charger les stratégies de passeportrequire('./app/config/passport/passport.js') (passport, models.user);//Sync Databasemodels.sequelize.sync().then(function() { console.log('Nice! La base de données a l'air bien')}).catch(function(err) { console.log (err, "Quelque chose s'est mal passé avec la mise à jour de la base de données!")});app.listen(5000, function(err) { if (!err) console.log("Site is live"); else console.log(err )}); Nous allons maintenant appliquer la stratégie à notre /signup itinéraire.
Voici comment nous procédons :
Tout d'abord, nous allons à app/routes/auth.js , et ajoutez un itinéraire de publication pour vous inscrire comme ceci.
app.post('/signup', passeport.authenticate('local-signup', { successRedirect :'/dashboard', failureRedirect :'/signup' })); Puisque nous avons besoin d'un passeport, nous devons le transmettre à cette méthode. Nous pouvons importer un passeport dans ce script ou le transmettre depuis server.js. Faisons ce dernier.
Modifier la fonction exportée dans ce fichier app/routes/auth.js d'avoir le passeport comme paramètre. Le code dans app/routes/auth.js devrait ressembler à ceci après votre modification.
var authController =require('../controllers/authcontroller.js');module.exports =function(app, passeport) { app.get('/signup', authController.signup); app.get('/signin', authController.signin); app.post('/signup', passeport.authenticate('local-signup', { successRedirect :'/dashboard', failureRedirect :'/signup' } ));} Puis dans server.js , nous modifions l'importation des routes et ajoutons passeport comme argument comme ceci :
var authRoute = require('./app/routes/auth.js')(app,passport);
Maintenant, accédez à l'URL d'inscription http://localhost:5000/signup/ et essayez de vous inscrire.
Lorsque vous essayez de vous inscrire, vous obtenez une erreur "Échec de sérialisation de l'utilisateur dans la session ". En effet, le passeport doit enregistrer un identifiant d'utilisateur dans la session, et il l'utilise pour gérer la récupération des détails de l'utilisateur en cas de besoin.
Pour résoudre ce problème, nous allons implémenter les fonctions de sérialisation et de désérialisation de passeport dans notre app/config/passport/passport.js fichier.
Nous ajoutons d'abord la fonction de sérialisation. Dans cette fonction, nous enregistrerons l'identifiant d'utilisateur à la séance.
Pour ce faire, nous ajoutons les lignes suivantes en dessous de l'initialisation de la stratégie locale.
//serializepassport.serializeUser(function(user, done) { done(null, user.id);}); Ensuite, nous implémentons la fonction de désérialisation. Ajoutez la fonction juste en dessous de la fonction de sérialisation.
// désérialiser l'utilisateur passeport.deserializeUser(function(id, done) { User.findById(id).then(function(user) { if (user) { done(null, user.get()); } else { done(user.errors, null); } });});
Dans la fonction de désérialisation ci-dessus, nous utilisons Sequelize findById promettent d'obtenir l'utilisateur et, en cas de succès, une instance du modèle Sequelize est renvoyée. Pour obtenir l'objet User à partir de cette instance, nous utilisons la fonction getter Sequelize comme ceci :user.get() .
Exécutez à nouveau :
node server.js
Et essayez de vous inscrire. Hourra si vous avez le "Cannot GET /dashboard" ! Cela signifie que notre authentification a réussi. N'oubliez pas que nous avons redirigé vers /dashboard dans notre méthode passeport.authenticate dans routes/auth.js .
Maintenant, allons-y et ajoutons cette route. Ensuite, ajoutez un middleware pour vous assurer que la page n'est accessible que lorsqu'un utilisateur est connecté à la session.
Dans notre application/vues dossier, nous créons un nouveau fichier nommé dashboard.hbs et ajoutez-y le code HTML suivant.
Passeport avec Sequelize Tableau de bord
Hourra ! vous êtes connecté.
Dans routes/auth.js , nous ajoutons cette ligne dans le module.exports bloquer :
app.get('/dashboard',authController.dashboard);
Ensuite, nous allons à app/controllers/authController.js et ajoutez le contrôleur de tableau de bord.
exports.dashboard =function(req, res) { res.render('dashboard');} Votre AuthController.js devrait ressembler à ceci :
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');} Maintenant, exécutez à nouveau l'application et essayez de vous inscrire avec une adresse e-mail différente de celle que vous avez utilisée précédemment. Vous serez correctement redirigé vers le /dashboard itinéraire.
Mais /tableau de bord n'est pas un itinéraire protégé, ce qui signifie que même si un utilisateur n'est pas connecté, il peut le voir. Nous ne voulons pas cela, nous allons donc ajouter un /logout route pour déconnecter l'utilisateur, puis protégez la route et testez ce que nous avons fait.
Faisons ceci :
Dans routes/auth.js nous ajoutons cette ligne :
app.get('/logout',authController.logout);
Ensuite, nous ajoutons le contrôleur dans app/controllers/authController.js.
exports.logout =function(req, res) { req.session.destroy(function(err) { res.redirect('/'); }); }
Maintenant, exécutez à nouveau l'application et inscrivez-vous avec une adresse e-mail différente.
Après cela, visitez http://localhost:5000/logout pour déconnecter l'utilisateur. Visitez maintenant http://localhost:5000/dashboard.
Vous remarquerez qu'il est assez accessible. Ajoutons un middleware personnalisé pour protéger cette route.
Pour ce faire, nous ouvrons app/routes/auth.js et ajouter cette fonction dans le module.exports bloc, en dessous de toutes les autres lignes de code.
function isLoggedIn(req, res, next) { if (req.isAuthenticated()) return next(); res.redirect('/signin');}
Ensuite, nous modifions le gestionnaire d'itinéraire du tableau de bord pour qu'il ressemble à ceci :
app.get('/dashboard',isLoggedIn, authController.dashboard);
Maintenant, lorsque vous exécutez à nouveau l'application et essayez de visiter la page du tableau de bord et que vous n'êtes pas connecté, vous devriez être redirigé vers la page de connexion.
Ouf! Il est temps de mettre en œuvre la dernière partie :la connexion.
Tout d'abord, nous allons ajouter une nouvelle stratégie locale pour la connexion dans app/config/passport/passport.js .
//LOCAL SIGNINpassport.use('local-signin', new LocalStrategy( { // par défaut, la stratégie locale utilise le nom d'utilisateur et le mot de passe, nous remplacerons par l'email usernameField :'email', passwordField :'password', passReqToCallback :true // nous permet de renvoyer l'intégralité de la requête au 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:'L'email n'existe pas' }); } if (!isValidPassword(user.password, password)) { return done(null, false, { message :'Incorrect password.' }); } var userinfo =user. avoir(); return done(null, userinfo); }).catch(function(err) { console.log("Error:", err); return done(null, false, { message:'Quelque chose s'est mal passé avec votre connexion' }); }); }));
Dans cette stratégie, le isValidPassword la fonction compare le mot de passe saisi avec la méthode de comparaison bCrypt puisque nous avons stocké notre mot de passe avec bcrypt .
Si les détails sont corrects, notre utilisateur sera connecté.
Allez maintenant dans routes/auth.js et ajoutez la route pour la publication sur / se connecter.
app.post('/signin', passeport.authenticate('local-signin', { successRedirect :'/dashboard', failureRedirect :'/signin' }));
Vos routes/auth.js devraient ressembler à ceci lorsque vous avez terminé.
var authController =require('../controllers/authcontroller.js');module.exports =function(app, passeport) { app.get('/signup', authController.signup); app.get('/signin', authController.signin); app.post('/signup', passeport.authenticate('local-signup', { successRedirect :'/dashboard', failureRedirect :'/signup' } )); app.get('/dashboard', isLoggedIn, authController.dashboard); app.get('/logout', authController.logout); app.post('/signin', passeport.authenticate('local-signin', { successRedirect :'/dashboard', failureRedirect :'/signin' } )); function isLoggedIn(req, res, next) { if (req.isAuthenticated()) return next(); res.redirect('/signin'); }}
Maintenant, lancez l'application et essayez de vous connecter. Vous devriez pouvoir vous connecter avec tous les détails que vous avez utilisés lors de votre inscription, et vous serez redirigé vers http ://localhost:5000/dashboard/.
Félicitations si vous êtes arrivé à la fin de ce tutoriel ! Nous avons utilisé avec succès Sequelize et Passport avec une base de données MySQL.
Le code complet de ce tutoriel est disponible sur GitHub.
