Share
Sequelize est un ORM Node.js à base de promesses. Il peut être utilisé avec PostgreSQL, MySQL, MariaDB, SQLite et MSSQL. Dans ce tutoriel, nous allons implémenter l'authentification pour les utilisateurs d'une application Web. Et nous utiliserons Passport, le middleware d’authentification populaire pour Node, ainsi que Sequelize et MySQL pour implémenter l’enregistrement et la connexion des utilisateurs..
Assurez-vous que les éléments suivants sont installés sur votre ordinateur:
Pour ce tutoriel, nous utiliserons Node.js avec Express. Nous allons donc commencer à installer ce dont nous avons besoin..
Créez un répertoire pour votre application. Dans ce répertoire, lancez ceci depuis votre terminal ou votre invite de commande:
npm init
Ceci initialise le gestionnaire de dépendances npm. Cela présentera une série d’invites que nous allons parcourir rapidement..
Les principales dépendances de ce tutoriel sont:
Pour les installer, à partir de votre terminal ou de votre invite de commande, exécutez les opérations suivantes, l'une après l'autre..
npm install express --save npm install sequelize --save npm installer mysql --save npm installer passport --save npm installer passport-local --save npm installer body-parser --save npm installer express-session --save npm installer bcrypt-nodejs --save npm installer express-handlebars --save
Si vous utilisez Git pour ce projet:
Dans votre dossier de projet, créez un fichier .gitignore..
Ajouter cette ligne au fichier .gitignore.
node_modules
Maintenant, nous créons un fichier serveur. Ce sera le fichier principal appelé lorsque vous tapez ce qui suit:
npm start
Cela lance l'application. Vous pouvez également exécuter l'application en tapant le noeud server.js..
noeud serveur.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:
Accentsconagua
var express = require ('express'); var app = express (); app.get ('/', fonction (req, res) res.send ('Welcome to Passport with Sequelize');); app.listen (5000, function (err) if (! err) console.log ("Le site est actif"); sinon console.log (err));La première ligne assigne le module express à une variable express. Nous initialisons ensuite express et appelons cela une variable: app.
Ensuite, nous faisons en sorte que l'application écoute 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 "Welcome to Passport with Sequelize" lorsqu'une requête GET est adressée à "/".
Pour tester sur votre ordinateur, lancez ceci depuis l'intérieur du dossier de votre projet:
noeud serveur.js
Si vous voyez le texte «Bienvenue dans Passport with Sequelize» lors de votre visite à 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, tels que passeport, session express et analyseur de corps..
Après var app = express () nous ajoutons les lignes suivantes:
var passport = require ('passeport') 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, tous deux nécessaires pour gérer l'authentification..
Ensuite, nous importons le module analyseur de corps. Cela extrait la totalité 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 des espaces sous les lignes d'importation:
// Pour BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ());
Ensuite, nous initialisons le passeport, la session express et la session de passeport et les ajoutons tous deux en tant que middleware. Nous faisons cela en ajoutant ces lignes quelques espaces après la ligne d'importation bodyParser.
// Pour Passport app.use (session (secret: 'cat du clavier', reserver: true, saveUninitialized: true)); // session secrète app.use (passport.initialize ()); app.use (passport.session ()); // sessions de connexion persistantes
Nous allons commencer à travailler sur l'authentification réelle maintenant.
Nous allons procéder en quatre étapes:
Tout d'abord, nous créons une base de données en MySQL. Donnez-lui votre nom préféré. Dans l’intérêt de ce tutoriel, créons une base de données nommée sequelize_passport en MySQL.
Ensuite, nous avons configuré la configuration pour gérer les détails de la base de données.
D'abord, importons le module point-env pour gérer les variables d'environnement.
Exécutez ceci dans votre dossier de projet racine:
npm installer --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 allons ajouter 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 = 'développement'
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 fichier. Ce fichier doit être ignoré si vous poussez dans un référentiel. Pour ce faire, ajoutez le code suivant à votre fichier .gitignore:
config / config.json
Ensuite, nous collons le code suivant dans notre fichier config.json.
"développement": "nom d'utilisateur": "racine", "mot de passe": null, "base de données": "sequelize_passport", "hôte": "127.0.0.1", "dialecte": "mysql", "test" : "nom d'utilisateur": "", "mot de passe": null, "base de données": "", "hôte": "", "dialecte": "mysql", "production": "nom d'utilisateur": "", "mot de passe": null, "base de données": "", "hôte": "127.0.0.1", "dialecte": "mysql"
N'oubliez pas de remplacer les valeurs du bloc de développement ci-dessus par les informations 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
Maintenant il est temps de créer le des modèles dossier.
Tout d'abord, nous créons un répertoire nommé app dans notre dossier de projet.
À l'intérieur de app dossier, nous créons un nouveau dossier nommé des modèles et créez un nouveau fichier nommé index.js dans le des modèles dossier.
Dans le fichier index.js, nous collons le code ci-dessous.
"use strict"; var fs = require ("fs"); var path = require ("chemin"); var Sequelize = require ("sequelize"); var env = process.env.NODE_ENV || "développement"; 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 (fonction (fichier) return (fichier.indexOf (".")! == 0) && (fichier! == "index.js");) .forEach (fonction (fichier ) var model = sequelize.import (path.join (__ nomrépertoire, fichier)); db [modèle.nom] = modèle;); Object.keys (db) .forEach (function (modelName) if ("associate" dans 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 des modèles dossier, et les exporter.
Pour vérifier que tout va bien, nous ajoutons ceci dans notre fichier server.js.
// Modèles var modèles = require ("./ app / models"); // Sync Database models.sequelize.sync (). Then (function () console.log ('Nice! La base de données est belle')). Catch (function (err) console.log (err, "Une erreur s'est produite avec la mise à jour de la base de données! "));Ici, nous importons les modèles, puis appelons la fonction de synchronisation Sequelize..
Exécutez ceci pour voir si tout va bien:
noeud serveur.js
Si vous obtenez le message "Le site est en direct, Nice! La base de données est en bon état", alors vous avez configuré Sequelize avec succès.
Sinon, veuillez suivre attentivement les étapes ci-dessus et essayez de résoudre le problème avec de l'aide..
La prochaine chose que nous allons faire est de créer le modèle utilisateur, qui est essentiellement la table utilisateur. Cela contiendra des informations utilisateur de base.
Dans notre des 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 = fonction (sequelize, Sequelize) var Utilisateur = sequelize.define ('utilisateur', id: autoIncrement: true, primaryKey: true, type: Sequelize.INTEGER, prénom: type: Sequelize.STRING, notEmpty: true, nom: type: Sequelize.STRING, notEmpty: true, nom d'utilisateur: type: Sequelize.TEXT, about: type: Sequelize.TEXT, email: type: Sequelize.STRING, validate: isEmail: true, mot de passe: type: Sequelize.STRING, allowNull: false, last_login: type: Sequelize.DATE, statut: type: Sequelize.ENUM ('actif', 'inactif'), defaultValue : 'actif' ); utilisateur de retour; Maintenant, lancez:
noeud serveur.js
Vous devriez voir le familier "Le site est en direct. Agréable! Base de données semble bien."message. Cela signifie que nos modèles Sequelize ont été synchronisés avec succès. Si vous vérifiez votre base de données, vous devriez voir une table des utilisateurs avec les colonnes spécifiées présentes..
Tout d'abord, créons la vue pour l'inscription et connectez-la.
La première chose à faire est d’importer le module de guidon express que nous utilisons pour les vues de ce tutoriel..
Ajouter cette ligne au fichier de démarrage principal, server.js.
var exphbs = require ('express-guidon')
Votre bloc d'importation devrait ressembler à ceci à ce stade.
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-guidon')Ensuite, nous ajoutons les lignes suivantes dans notre fichier server.js.
// Pour le guidon app.set ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('moteur de visualisation', '.hbs');Maintenant, dans notre dossier d'applications, nous créons trois dossiers nommés vues, contrôleurs, et itinéraires.
Dans le dossier des vues, nous créons un fichier nommé s'inscrire.hbs et collez le code ci-dessous dedans.
Puis dans notre 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 = fonction (req, res) res.render ('signup'); Ensuite, nous créons un itinéraire pour vous inscrire. Dans le dossier des routes, nous créons un nouveau fichier nommé auth.js puis, dans ce fichier, nous importons le contrôleur auth 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 l'application en argument.
Sur le serveur, après l’importation des modèles, ajoutez ces lignes:
// Routes var authRoute = require ('./ app / routes / auth.js') (app);Lance ça:
noeud serveur.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 auparavant, nous allons créer un fichier nommé connexion.hbs dans notre dossier de vues et collez-y le code HTML suivant:
Ensuite, ajoutez un contrôleur pour la connexion app / controllers / authcontroller.js.
exports.signin = fonction (req, res) res.render ('identifiant'); Puis dans app / routes / auth.js, nous ajoutons un itinéraire pour vous connecter comme ceci:
app.get ('/ signin', authController.signin);
Maintenant quand tu cours:
noeud serveur.js
et visitez http: // localhost: 5000 / signin /, vous devriez voir le formulaire de connexion.
La dernière et majeure étape est la rédaction de nos stratégies de passeport.
Dans app / config, nous créons un nouveau dossier nommé passeport.
Ensuite, dans notre nouveau dossier app / config / passport, nous créons un nouveau fichier et le nommons. passeport.js. Ce fichier contiendra nos stratégies de passeport.
Dans passeport.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)
À l'intérieur de ce bloc, nous initialisons la stratégie de passeport local et le modèle d'utilisateur, qui seront transmis en tant qu'argument. Voici comment nous faisons cela:
module.exports = fonction (passeport, utilisateur) var Utilisateur = utilisateur; var LocalStrategy = require ('passport-local'). Stratégie; 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 // permet de renvoyer l'intégralité de la demande au rappel,));Maintenant nous avons déclaré quelle requête (req) Les champs usernameField et passwordField (variables de passeport) sont.
La dernière variable passReqToCallback permet de transmettre l'intégralité de la demande au rappel, ce qui est particulièrement utile pour l'inscription..
Après la dernière virgule, nous ajoutons cette fonction de rappel.
fonction (req, email, mot de passe, done)
Dans cette fonction, nous allons gérer le stockage des détails d'un utilisateur.
Tout d'abord, nous ajoutons notre fonction de génération de mot de passe haché à l'intérieur de la fonction de rappel.
var generateHash = fonction (mot de passe) return bCrypt.hashSync (mot de passe, bCrypt.genSaltSync (8), null); ;
Ensuite, en utilisant le modèle utilisateur Sequelize que nous avons initialisé plus tôt Utilisateur, on vérifie si l'utilisateur existe déjà, et sinon on les ajoute.
User.findOne (où: email: email). Then (fonction (utilisateur) if (utilisateur) return done (null, false, message: 'Cet email est déjà utilisé'); autre var userPassword = generateHash (mot de passe); var data = email: email, mot de passe: userPassword, prénom: req.body.firstname, dernier nom: req.body.lastname; User.create (data) .then (fonction (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 le Les données objet sont obtenus à partir de la req.body objet qui contient l'entrée de notre formulaire d'inscription.
Votre passeport.js devrait ressembler à ceci:
// charge bcrypt var bCrypt = require ('bcrypt-nodejs'); module.exports = fonction (passeport, utilisateur) var Utilisateur = utilisateur; var LocalStrategy = require ('passport-local'). Stratégie; passport.use ('local-signup', new LocalStrategy (usernameField: 'email', PasswordField: 'password', passReqToCallback: true // nous permet de renvoyer l'intégralité de la demande au rappel, fonction (req, email, password, done) var generateHash = function (mot de passe) return bCrypt.hashSync (mot de passe, bCrypt.genSaltSync (8), null);; User.findOne (où: email: email). (utilisateur) if (utilisateur) return done (null, false, message: 'Cet email est déjà pris'); else var userPassword = generateHash (mot de passe); var data = email: email, mot de passe: userPassword, prénom: req.body.firstname, nom de famille: req.body.lastname; utilisateur.create (données) .then (fonction (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 ci-dessous les routes importées dans server.js.
// stratégies de chargement de passeport exigent ('./ app / config / passport / passport.js') (passport, models.user);Votre server.js devrait ressembler à ceci à ce moment:
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') // Pour BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ()); // Pour Passport app.use (session (secret: 'cat du clavier', reserver: true, saveUninitialized: true)); // session secrète app.use (passport.initialize ()); app.use (passport.session ()); // sessions de connexion persistantes // pour le guidon app.set ('vues', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('moteur de visualisation', '.hbs'); app.get ('/', fonction (req, res) res.send ('Welcome to Passport with Sequelize');); // Modèles var modèles = require ("./ app / models"); // Routes var authRoute = require ('./ app / routes / auth.js') (app); // stratégies de chargement de passeport exigent ('./ app / config / passport / passport.js') (passport, models.user); // Sync Database models.sequelize.sync (). Then (function () console.log ('Nice! La base de données est belle')). Catch (function (err) console.log (err, "Une erreur s'est produite avec la mise à jour de la base de données! ")); app.listen (5000, function (err) if (! err) console.log ("Le site est actif"); sinon console.log (err));Maintenant, nous allons effectivement appliquer la stratégie à notre /s'inscrire route.
Voici comment nous faisons cela:
Tout d'abord, nous allons à app / routes / auth.js, et ajouter un itinéraire pour poster à l'inscription comme ça.
app.post ('/ signup', passport.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 passer de server.js. Faisons le dernier.
Modifier la fonction exportée dans ce fichier app / routes / auth.js avoir un passeport comme paramètre. Le code en app / routes / auth.js devrait ressembler à ceci après votre modification.
var authController = require ('… /controllers/authcontroller.js'); module.exports = fonction (application, passeport) app.get ('/ signup', authController.signup); app.get ('/ signin', authController.signin); app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', failureRedirect: '/ signup')); Puis dans server.js, nous modifions les routes importées et ajoutons passeport comme argument:
var authRoute = require ('./ app / routes / auth.js') (app, passeport);
Maintenant, allez à 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 la sérialisation de l'utilisateur en session". C'est parce que passe doit enregistrer un ID utilisateur dans la session et qu'il l'utilise pour gérer l'extraction 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 du passeport dans notre app / config / passport / passport.js fichier.
Tout d'abord, nous ajoutons la fonction sérialiser. Dans cette fonction, nous allons sauver le identifiant d'utilisateur à la session.
Pour ce faire, nous ajoutons les lignes suivantes sous l’initialisation de la stratégie locale.
// sérialiser passport.serializeUser (function (user, done) done (null, user.id););
Ensuite, nous implémentons la fonction de désérialisation. Ajouter la fonction juste en dessous de la fonction sérialiser.
// désérialise l'utilisateur passport.deserializeUser (function (id, done) User.findById (id) .then (function (user) if (utilisateur) done (null, user.get ()); else done ( user.errors, null);););
Dans la fonction de désérialisation ci-dessus, nous utilisons le séquençage 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 de cette instance, nous utilisons la fonction d'accesseur Sequelize comme suit: user.get ().
Maintenant, lancez à nouveau:
noeud serveur.js
Et essayez de vous inscrire. Hourra si vous avez le "ne peut pas obtenir / tableau de bord"! Cela signifie que notre authentification a réussi. N'oubliez pas que nous avons redirigé vers / dashboard dans notre méthode passport.authenticate in routes / auth.js.
Maintenant, allons-y et ajoutons cette route. Ajoutez ensuite un middleware pour vous assurer que la page n'est accessible que lorsqu'un utilisateur est connecté à la session..
Dans notre app / 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 authentifié.
Dans routes / auth.js, nous ajoutons cette ligne à l'intérieur du module.exports bloc:
app.get ('/ dashboard', authController.dashboard);
Ensuite, nous allons à app / controllers / authController.js et ajoutez le contrôleur de tableau de bord.
exports.dashboard = fonction (req, res) res.render ('tableau de bord'); Votre AuthController.js devrait ressembler à ceci:
var exports = module.exports = exports.signup = fonction (req, res) res.render ('signup'); exports.signin = fonction (req, res) res.render ('connexion'); exports.dashboard = fonction (req, res) res.render ('tableau de bord'); Lancez à nouveau l'application et essayez de vous inscrire avec une adresse de messagerie différente de celle que vous avez utilisée précédemment. Vous serez redirigé de manière appropriée vers le /tableau de bord route.
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 /Connectez - Out route pour déconnecter l'utilisateur, puis protéger la route et tester ce que nous avons fait.
Faisons cela:
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, relancez l'application et inscrivez-vous avec une adresse email différente.
Après cela, visitez http: // localhost: 5000 / logout pour déconnecter l’utilisateur. Maintenant, visitez http: // localhost: 5000 / dashboard.
Vous remarquerez que c'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 block, 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. app / config / passport / passport.js.
// SIGNAL LOCAL passport.use ('local-signin', new LocalStrategy (// par défaut, la stratégie locale utilise un nom d'utilisateur et un mot de passe, nous remplacerons par e-mail usernameField: 'email', mot_passe: 'mot_passe', passReqToCallback: true // nous permet de renvoyer l'intégralité de la demande au rappel, function (req, email, mot de passe, done) var User = utilisateur; var isValidPassword = fonction (userpass, mot de passe) return bCrypt.compareSync (mot de passe, userpass) ; User.findOne (où: email: email). Then (fonction (utilisateur) if (! Utilisateur) return done (null, false, message: 'Email n'existe pas); if (! isValidPassword (user.password, password)) return done (null, false, message: 'Mot de passe incorrect.'); var userinfo = user.get (); return done (null, userinfo); ) .catch (function (err) console.log ("Erreur:", err); return done (null, false, message: 'Une erreur s'est produite avec votre identifiant'););));Dans cette stratégie, leisValidPasswordLa fonction compare le mot de passe entré 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é.
Maintenant, allez à routes / auth.js et ajoutez l'itinéraire pour poster à /se connecter.
app.post ('/ identifiant', passport.authenticate ('identifiant local', successRedirect: '/ dashboard', failureRedirect: '/ identifiant'));Vos routes / auth.js devraient ressembler à ceci lorsque vous avez terminé.
var authController = require ('… /controllers/authcontroller.js'); module.exports = fonction (application, passeport) 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 ('/ identifiant', passport.authenticate ('identifiant local', successRedirect: '/ dashboard', failureRedirect: '/ identifiant')); 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 n'importe lequel des détails que vous avez utilisés lors de votre inscription, et vous serez redirigé vers http: // localhost: 5000 / dashboard /.
Félicitations si vous avez atteint 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.
Ceci conclut notre tutoriel sur l’utilisation de Passport pour l’authentification des utilisateurs avec Sequelize et MySQL. Sequelize est un ORM vraiment utile pour gérer MySQL avec Node. Je l’ai personnellement trouvé très utile, et vous devriez certainement envisager de l’utiliser dans votre prochaine application Node-MySQL.
