Share
Sequelize ist ein auf Versprechungen basierendes Node.js-ORM. Es kann mit PostgreSQL, MySQL, MariaDB, SQLite und MSSQL verwendet werden. In diesem Lernprogramm implementieren wir die Authentifizierung für Benutzer einer Web-App. Wir werden Passport, die beliebte Authentifizierungs-Middleware für Node, zusammen mit Sequelize und MySQL verwenden, um die Benutzerregistrierung und -anmeldung zu implementieren.
Stellen Sie sicher, dass Folgendes auf Ihrem Computer installiert ist:
In diesem Lernprogramm verwenden wir Node.js zusammen mit Express. Wir beginnen also mit der Installation, was wir brauchen.
Erstellen Sie ein Verzeichnis für Ihre App. Führen Sie in diesem Verzeichnis dies über Ihr Terminal oder die Eingabeaufforderung aus:
npm init
Dies initialisiert den npm Dependency Manager. Daraufhin werden eine Reihe von Aufforderungen angezeigt, die wir schnell durchgehen werden.
Die wichtigsten Abhängigkeiten für dieses Lernprogramm sind:
Um sie zu installieren, führen Sie an Ihrem Terminal oder der Eingabeaufforderung die folgenden Befehle nacheinander aus.
npm install express --save npm install sequelize --save npm install mysql --save npm install passport --save npm install passport-local --save npm installieren body-parser --save npm installieren express-session --save npm install bcrypt-nodejs --save npm install express-handlebars --save
Wenn Sie Git für dieses Projekt verwenden:
Erstellen Sie in Ihrem Projektordner eine .gitignore-Datei.
Fügen Sie diese Zeile der .gitignore-Datei hinzu.
Knotenmodule
Jetzt erstellen wir eine Server-Datei. Dies ist die Hauptdatei, die aufgerufen wird, wenn Sie Folgendes eingeben:
npm starten
Dadurch wird die App ausgeführt. Sie können die App auch ausführen, indem Sie node server.js eingeben.
Knoten server.js
Dann erstellen wir in unserem Projektordner eine neue Datei und benennen diese Datei server.js.
In der server.js Datei fügen wir folgendes ein:
Accentsconagua
var express = erfordern ('express'); var app = express (); app.get ('/', Funktion (req, res) res.send ('Willkommen bei Passport mit Sequelize');); app.listen (5000, function (err) if (! err) console.log ("Site ist live"); else console.log (err));Die erste Zeile weist das Express-Modul einer Variablen-Express zu. Wir initialisieren dann express und nennen es eine Variable: app.
Dann machen wir App auf Port hören 5000. Sie können eine beliebige freie Portnummer auf Ihrem Computer auswählen.
Als nächstes rufen wir die app.get () Express-Routing-Funktion, um mit "Welcome to Passport with Sequelize" zu antworten, wenn eine GET-Anforderung an "/" gestellt wird.
Um auf Ihrem Computer zu testen, führen Sie dies in Ihrem Projektordner aus:
Knoten server.js
Wenn Sie den Text "Willkommen bei Passport with Sequelize" sehen, wenn Sie http: // localhost: 5000 / besuchen, dann herzlichen Glückwunsch! Überprüfen Sie andernfalls, dass Sie alles genau so gemacht haben, wie es oben beschrieben ist.
Als Nächstes importieren wir einige benötigte Module wie Pass, Express-Session und Body-Parser.
Nach dem var app = express () Wir fügen folgende Zeilen hinzu:
var passport = required ('passport') var Sitzung = required ('express-session') var bodyParser = required ('body-parser')In den ersten beiden Zeilen importieren wir das Pass-Modul und die Express-Sitzung, die beide für die Authentifizierung erforderlich sind.
Dann importieren wir das Body-Parser-Modul. Dadurch wird der gesamte Hauptteil einer eingehenden Anforderung extrahiert und in einem Format dargestellt, mit dem einfacher zu arbeiten ist. In diesem Fall verwenden wir das JSON-Format.
Damit unsere App den Body-Parser verwenden kann, fügen Sie diese Zeilen einige Leerzeichen unterhalb der Importzeilen hinzu:
// Für BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ());
Als Nächstes initialisieren wir den Passport und die Expresssitzung und die Passportsitzung und fügen beide als Middleware hinzu. Wir tun dies, indem Sie diese Zeilen einige Leerzeichen nach der BodyParser-Importlinie hinzufügen.
// Für Passport app.use (Sitzung (geheim: 'keyboard cat', resave: true, saveUninitialized: true))); // Session Secret app.use (passport.initialize ()); app.use (passport.session ()); // ständige Anmeldesitzungen
Wir werden jetzt mit der eigentlichen Authentifizierung beginnen.
Wir machen das in vier Schritten:
Zuerst erstellen wir eine Datenbank in MySQL. Geben Sie Ihren bevorzugten Namen an. In diesem Tutorial erstellen wir eine Datenbank mit dem Namen sequelize_passport in MySQL.
Dann richten wir die Konfiguration ein, um DB-Details zu behandeln.
Zunächst importieren wir das dot-env-Modul, um Umgebungsvariablen zu verarbeiten.
Führen Sie dies in Ihrem Stammprojektordner aus:
npm install --save dotenv
Dann importieren wir es in die Hauptserverdatei server.js, direkt unter den anderen Importen.
var env = requir ('dotenv'). load (); Als Nächstes erstellen wir eine Datei in unserem Projektordner und nennen sie .env.
Der nächste Schritt ist optional, wenn Sie Git nicht verwenden:
Wir fügen die .env-Datei Ihrer .gitignore-Datei hinzu.
Ihre .gitignore-Datei sollte folgendermaßen aussehen:
node_modules .env
Danach fügen wir unsere Umgebung zur .env-Datei hinzu, indem Sie folgende Zeile hinzufügen:
NODE_ENV = 'Entwicklung'
Dann erstellen wir eine config.json-Datei, die von Sequelize zum Verwalten verschiedener Umgebungen verwendet wird.
Als Erstes erstellen Sie einen Ordner mit dem Namen Konfig in unserem Projektordner. In diesem Ordner erstellen wir eine Konfig.Json Datei. Diese Datei sollte ignoriert werden, wenn Sie in ein Repository wechseln. Fügen Sie dazu den folgenden Code zu Ihrem .gitignore hinzu:
config / config.json
Dann fügen wir den folgenden Code in unsere config.json-Datei ein.
"development": "username": "root", "password": null, "database": "sequelize_passport", "host": "127.0.0.1", "dialect": "mysql", "test" : "Benutzername": "", "Kennwort": Null, "Datenbank": "", "Host": "", "Dialekt": "Mysql", "Produktion": "Benutzername": "", "Kennwort": null, "Datenbank": "", "Host": "127.0.0.1", "Dialekt": "Mysql"
Denken Sie daran, die Werte im obigen Entwicklungsblock durch Ihre Datenbankauthentifizierungsdetails zu ersetzen.
Als Nächstes installieren wir sequelize mit npm. Führen Sie dazu den folgenden Befehl im Stammordner des Projekts aus:
npm install --save sequelize
Jetzt ist es an der Zeit, das zu erstellen Modelle Mappe.
Zuerst erstellen wir ein Verzeichnis mit dem Namen App in unserem Projektordner.
In der App Ordner erstellen wir einen neuen Ordner mit dem Namen Modelle und erstellen Sie eine neue Datei mit dem Namen index.js in dem Modelle Mappe.
In die Datei index.js fügen wir den folgenden Code ein.
"streng verwenden"; var fs = required ("fs"); var path = required ("Pfad"); var Sequelize = required ("sequelize"); var env = process.env.NODE_ENV || "Entwicklung"; var config = required (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 ) var model = sequelize.import (path.join (__ dirname, Datei)); db [model.name] = model;); Object.keys (db) .forEach (Funktion (modelName) if ("assoziieren" in db [modelName]) db [modelName] .associate (db);; db.sequelize = sequelize; db.Sequelize = Sequelize; module.exports = db;Diese Datei wird verwendet, um alle Modelle zu importieren, in denen wir platziert sind Modelle Ordner und exportieren Sie sie.
Um zu testen, ob alles in Ordnung ist, fügen wir dies in unsere server.js-Datei ein.
// Modelle var models = erfordern ("./ app / models"); // Datenbank synchronisieren models.sequelize.sync (). Dann (function () console.log ('Nice! Database sieht gut aus')). Catch (function (err) console.log (err, "Etwas ist schief gelaufen mit dem Datenbank-Update! "));Hier importieren wir die Modelle und rufen dann die Sequelize-Synchronisierungsfunktion auf.
Führen Sie das aus, um zu sehen, ob alles in Ordnung ist:
Knoten server.js
Wenn Sie die Meldung erhalten, "Site is live Nice! Datenbank sieht gut aus", haben Sie Sequelize erfolgreich eingerichtet.
Wenn nicht, gehen Sie bitte sorgfältig die oben genannten Schritte durch und versuchen Sie, das Problem mit Hilfe des Fehlers zu beheben.
Als nächstes erstellen wir das Benutzermodell, bei dem es sich im Wesentlichen um die Benutzertabelle handelt. Diese enthält grundlegende Benutzerinformationen.
In unserer Modelle Ordner erstellen wir eine Datei und benennen sie user.js. Der vollständige Pfad für diese Datei sollte sein app / models / user.js.
Öffnen Sie die Datei user.js und fügen Sie den folgenden Code hinzu:
module.exports = function (sequelize, Sequelize) var User = sequelize.define ('user', id: autoIncrement: true, primaryKey: true, Typ: Sequelize.INTEGER, Vorname: Typ: Sequelize.STRING, notEmpty: true, Nachname: Typ: Sequelize.STRING, NotEmpty: True, Benutzername: Typ: Sequelize.TEXT, ungefähr: Typ: Sequelize.TEXT, E-Mail: Typ: Sequelize.STRING, Validate: isEmail: true, Kennwort: Typ: Sequelize.STRING, allowNull: False, last_login: Typ: Sequelize.DATE, Status: Typ: Sequelize.ENUM ('aktiv', 'inaktiv'), defaultValue : "aktiv"); Benutzer zurückgeben; Jetzt ausführen:
Knoten server.js
Sie sollten das vertraute sehen "Site ist live. nett! Datenbank sieht gut aus.Dies bedeutet, dass unsere Sequelize-Modelle erfolgreich synchronisiert wurden. Wenn Sie Ihre Datenbank überprüfen, sollten Sie eine Benutzertabelle mit den angegebenen Spalten sehen.
Zuerst erstellen wir die Ansicht für die Anmeldung und verbinden sie.
Als erstes müssen Sie das Express-Lenker-Modul importieren, das in diesem Lernprogramm für Ansichten verwendet wird.
Fügen Sie diese Zeile der Hauptstartdatei hinzu, server.js.
var exphbs = required ('express-handlebars')
Ihr Importblock sollte jetzt so aussehen.
var express = required ('express') var app = express () var passport = required ('passport') var session = required ('express-session') var bodyParser = required ('body-parser') var env = required ('dotenv'). load () var exphbs = requir ('express-handlebars')Als nächstes fügen wir die folgenden Zeilen in unsere server.js-Datei ein.
// Für Handlebars app.set ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('view engine', '.hbs');Jetzt erstellen wir in unserem App-Ordner drei Ordner mit dem Namen Ansichten, Steuerungen, und Routen.
Im Ansichtenordner erstellen wir eine Datei mit dem Namen Anmelden.hbs und fügen Sie den Code unten ein.
Dann in unserem Steuerungen Ordner erstellen wir eine neue Datei und benennen sie authcontroller.js.
In diese Datei fügen wir den folgenden Controller für die Anmelderoute ein, die wir in Kürze erstellen werden.
var exports = module.exports = exports.signup = function (req, res) res.render ('signup'); Als Nächstes erstellen wir eine Route für die Anmeldung. Im Routenordner erstellen wir eine neue Datei mit dem Namen auth.js In dieser Datei importieren wir dann den Auth-Controller und definieren die Anmelderoute.
var authController = required ('… /controllers/authcontroller.js'); module.exports = function (app) app.get ('/ signup', authController.signup); Nun importieren wir diese Route in unsere server.js und übergeben die app als Argument.
Fügen Sie auf dem Server nach dem Import der Modelle folgende Zeilen hinzu:
// Routen var authRoute = required ('./ app / routes / auth.js') (app);Führen Sie das aus:
Knoten server.js
Besuchen Sie jetzt http: // localhost: 5000 / sign und Sie sehen das Anmeldeformular.
Wiederholen Sie die Schritte für das Anmeldeformular. Wie zuvor erstellen wir eine Datei mit dem Namen signin.hbs Fügen Sie in unserem Ansichtenordner den folgenden HTML-Code ein:
Fügen Sie dann einen Controller für die Anmeldung hinzu app / controller / authcontroller.js.
exports.signin = function (req, res) res.render ('signin'); Dann in app / routes / auth.js, Wir fügen eine Route für die Anmeldung wie folgt hinzu:
app.get ('/ signin', authController.signin);
Wenn du jetzt rennst:
Knoten server.js
und besuchen Sie http: // localhost: 5000 / signin /. Sie sollten das Anmeldeformular sehen.
Der letzte und wichtigste Schritt ist das Schreiben unserer Passstrategien.
Im app / config, Wir erstellen einen neuen Ordner mit dem Namen Reisepass.
Dann erstellen wir in unserem neuen Ordner app / config / passport eine neue Datei und benennen sie passport.js. Diese Datei enthält unsere Passstrategien.
Im passport.js, Wir werden das Benutzermodell und den Pass verwenden.
Zuerst importieren wir bcrypt die wir brauchen, um Passwörter zu sichern.
var bCrypt = required ('bcrypt-nodejs');
Dann fügen wir einen module.exports-Block wie folgt hinzu:
module.exports = Funktion (Pass, Benutzer)
Innerhalb dieses Blocks initialisieren wir die lokale Passport-Strategie und das Benutzermodell, das als Argument übergeben wird. So machen wir das:
module.exports = Funktion (Pass, Benutzer) var User = Benutzer; var LocalStrategy = required ('passport-local'). Strategie; Dann definieren wir unsere benutzerdefinierte Strategie mit unserer Instanz von LocalStrategy wie folgt:
passport.use ('local-signup', neue LocalStrategy (usernameField: 'email', passwordField: 'password', passReqToCallback: true // ermöglicht uns die Rückgabe der gesamten Anfrage an den Rückruf,));Nun haben wir erklärt, welche Anfrage (req) Felder sind usernameField und passwordField (Passvariablen).
Die letzte Variable passReqToCallback ermöglicht es uns, die gesamte Anforderung an den Rückruf weiterzuleiten, was besonders für die Anmeldung nützlich ist.
Nach dem letzten Komma fügen wir diese Rückruffunktion hinzu.
Funktion (Anfrage, E-Mail, Passwort, erledigt)
In dieser Funktion übernehmen wir das Speichern der Angaben eines Benutzers.
Zuerst fügen wir unsere Funktion zur Erzeugung von Hash-Kennwörtern in die Rückruffunktion hinzu.
var generateHash = Funktion (Kennwort) return bCrypt.hashSync (Kennwort, bCrypt.genSaltSync (8), null); ;
Anschließend haben wir das zuvor als initialisierte Benutzermodell Sequelize verwendet Nutzer, Wir prüfen, ob der Benutzer bereits existiert, und wenn nicht, fügen wir sie hinzu.
User.findOne (wo: email: email). Dann (Funktion (Benutzer) if (Benutzer) return done (null, falsch, Nachricht: 'Diese E-Mail ist bereits vergeben'); else var userPassword = generateHash (Kennwort); var data = email: E-Mail, Kennwort: userPassword, Vorname: req.body.firstname, Nachname: req.body.lastname; User.create (data) .then (function (newUser, erstellt) if (! newUser) return done (null, falsch); if (newUser) return done (null, newUser);;););
User.create () ist eine Sequelize-Methode zum Hinzufügen neuer Einträge zur Datenbank. Beachten Sie, dass die Werte in der Daten Objekt werden von der bekommen req.body Objekt, das die Eingabe aus unserem Anmeldeformular enthält.
Ihre passport.js sollte so aussehen:
// load bcrypt var bCrypt = requir ('bcrypt-nodejs'); module.exports = Funktion (Pass, Benutzer) var User = Benutzer; var LocalStrategy = required ('passport-local'). Strategie; passport.use ('local-signup', neue LocalStrategy (usernameField: 'email', passwordField: 'password', passReqToCallback: true // ermöglicht die Rückgabe der gesamten Anfrage an den Rückruf, Funktion (req, email, password, done) var generateHash = Funktion (Kennwort) Rückgabe von bCrypt.hashSync (Kennwort, bCrypt.genSaltSync (8), null);; User.findOne (wo: email: email) und dann (Funktion (Benutzer) if (Benutzer) return done (null, falsch, Nachricht: 'Diese E-Mail wurde bereits angenommen'); else var userPassword = generateHash (Kennwort); var data = email: E-Mail, Kennwort: userPassword, Vorname: req.body.firstname, lastname: req.body.lastname; User.create (data) .then (Funktion (newUser, erstellt) if (! newUser) return done (null, false); if (newUser) return done (null, neuer Benutzer);;););))); Nun importieren wir die Strategie in server.js.
Dazu fügen wir diese Zeilen unterhalb der Routen ein, die in importiert werden server.js.
// Passportstrategien werden benötigt ('./ app / config / passport / passport.js') (passport, models.user);Ihre server.js sollte zu diesem Zeitpunkt so aussehen:
var express = required ('express') var app = express () var passport = required ('passport') var session = required ('express-session') var bodyParser = required ('body-parser') var env = required ('dotenv'). load () var exphbs = required ('express-handlebars') // Für BodyParser app.use (bodyParser.urlencoded (extended: true)); app.use (bodyParser.json ()); // Für Passport app.use (Sitzung (geheim: 'keyboard cat', resave: true, saveUninitialized: true))); // Session Secret app.use (passport.initialize ()); app.use (passport.session ()); // ständige Anmeldesitzungen // Für Handlebars app.set ('views', './app/views') app.engine ('hbs', exphbs (extname: '.hbs')); app.set ('view engine', '.hbs'); app.get ('/', Funktion (req, res) res.send ('Willkommen bei Passport mit Sequelize');); // Modelle var models = erfordern ("./ app / models"); // Routen var authRoute = required ('./ app / routes / auth.js') (app); // Passportstrategien werden benötigt ('./ app / config / passport / passport.js') (passport, models.user); // Datenbank synchronisieren models.sequelize.sync (). Dann (function () console.log ('Nice! Database sieht gut aus')). Catch (function (err) console.log (err, "Etwas ist schief gelaufen mit dem Datenbank-Update! ")); app.listen (5000, function (err) if (! err) console.log ("Site ist live"); else console.log (err));Jetzt werden wir die Strategie tatsächlich auf unsere anwenden /Anmelden Route.
So machen wir das:
Zuerst gehen wir zu app / routes / auth.js, und fügen Sie eine Route für die Veröffentlichung hinzu, um sich so anzumelden.
app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', failureRedirect: '/ signup')));Da wir einen Pass benötigen, müssen wir ihn an diese Methode übergeben. Wir können den Passport in dieses Skript importieren oder von server.js aus übergeben. Lass uns das letztere tun.
Ändern Sie die in diese Datei exportierte Funktion app / routes / auth.js Pass als Parameter haben. Der Code in app / routes / auth.js sollte nach der Änderung so aussehen.
var authController = required ('… /controllers/authcontroller.js'); module.exports = Funktion (App, Passport) app.get ('/ signup', authController.signup); app.get ('/ signin', authController.signin); app.post ('/ signup', passport.authenticate ('local-signup', successRedirect: '/ dashboard', failureRedirect: '/ signup'))); Dann in server.js, Wir ändern den Routenimport und fügen Pass als Argument hinzu:
var authRoute = required ('./app/routen/auth.js') (app, passport);
Gehen Sie nun zur Anmelde-URL http: // localhost: 5000 / signup / und versuchen Sie, sich anzumelden.
Wenn Sie sich anmelden, erhalten Sie eine Fehlermeldung. "Fehler beim Serialisieren des Benutzers in Sitzung“. Dies liegt daran, Reisepass einen Benutzer-ID in der Sitzung speichern hat, und es verwendet diese die Benutzerdaten abrufen zu verwalten, wenn erforderlich.
Um dieses Problem zu lösen, implementieren wir sowohl die Serialisierungs- als auch die Deserialisierungsfunktionen von Passport in unserem app / config / passport / passport.js Datei.
Zuerst fügen wir die Serialisierungsfunktion hinzu. In dieser Funktion speichern wir die Benutzeridentifikation zur Sitzung.
Dazu fügen wir unter der Initialisierung der lokalen Strategie die folgenden Zeilen hinzu.
// serialize passport.serializeUser (function (user, done) done (null, user.id););
Als nächstes implementieren wir die Deserialisierungsfunktion. Fügen Sie die Funktion direkt unter der Serialisierungsfunktion hinzu.
// deserialize user passport.deserializeUser (Funktion (id, done) User.findById (id) .then (function (user) if (user) done (null, user.get ()); else done ( user.errors, null);););
In der oben genannten Deserialize-Funktion verwenden wir die Sequelize findById versprechen, den Benutzer zu erhalten, und bei Erfolg wird eine Instanz des Sequelize-Modells zurückgegeben. Um das Benutzerobjekt aus dieser Instanz abzurufen, verwenden wir die Get-Funktion Sequelize wie folgt: user.get ().
Jetzt wieder ausführen:
Knoten server.js
Und versuche dich anzumelden. Hurra, wenn Sie das "Kann nicht erhalten / Dashboard" bekommen haben! Dies bedeutet, dass unsere Authentifizierung erfolgreich war. Denken Sie daran, dass wir in unserer Methode passport.authenticate in / Dashboard umgeleitet wurden routen / auth.js.
Nun gehen wir weiter und fügen diese Route hinzu. Fügen Sie dann eine Middleware hinzu, um sicherzustellen, dass auf die Seite nur dann zugegriffen werden kann, wenn ein Benutzer an der Sitzung angemeldet ist.
In unserer App / Ansichten Ordner erstellen wir eine neue Datei mit dem Namen dashboard.hbs und fügen Sie den folgenden HTML-Code hinzu.
Reisepass mit Sequelize Instrumententafel
Hurra! Du bist eingeloggt.
Im routen / auth.js, wir fügen diese Zeile in das modul.exporte Block:
app.get ('/ dashboard', authController.dashboard);
Als nächstes gehen wir zu app / controller / authController.js und fügen Sie den Dashboard-Controller hinzu.
exports.dashboard = function (req, res) res.render ('Dashboard'); Ihre AuthController.js sollte so aussehen:
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'); Führen Sie nun die App erneut aus und versuchen Sie, sich mit einer anderen E-Mail-Adresse als der zuvor verwendeten zu registrieren. Sie werden in geeigneter Weise an die weitergeleitet /Instrumententafel Route.
Aber /Instrumententafel ist keine geschützte Route. Das heißt, auch wenn ein Benutzer nicht angemeldet ist, kann er sie sehen. Wir wollen das nicht, also fügen wir ein /Ausloggen Route, um den Benutzer abzumelden, und dann die Route zu schützen und zu testen, was wir getan haben.
Lass uns das machen:
Im routen / auth.js Wir fügen diese Zeile hinzu:
app.get ('/ logout', authController.logout);
Dann fügen wir den Controller in app / controller / authController.js hinzu.
exports.logout = function (req, res) req.session.destroy (function (err) res.redirect ('/');); Starten Sie nun die App erneut und melden Sie sich mit einer anderen E-Mail-Adresse an.
Besuchen Sie anschließend http: // localhost: 5000 / logout, um den Benutzer abzumelden. Besuchen Sie jetzt http: // localhost: 5000 / Dashboard.
Sie werden feststellen, dass es gut zugänglich ist. Fügen Sie eine benutzerdefinierte Middleware hinzu, um diese Route zu schützen.
Dazu öffnen wir uns app / routes / auth.js und fügen Sie diese Funktion in die modul.exporte Block unter allen anderen Codezeilen.
function isLoggedIn (req, res, next) if (req.isAuthenticated ()) return next (); res.redirect ('/ signin'); Dann ändern wir den Dashboard-Routenhandler so, dass er wie folgt aussieht:
app.get ('/ dashboard', isLoggedIn, authController.dashboard);
Wenn Sie nun die App erneut ausführen und versuchen, die Dashboard-Seite aufzurufen, und Sie nicht angemeldet sind, sollten Sie zur Anmeldeseite weitergeleitet werden.
Wütend! Es ist an der Zeit, den letzten Teil zu implementieren: die Anmeldung.
Zuerst fügen wir eine neue lokale Strategie für die Anmeldung hinzu app / config / passport / passport.js.
// LOCAL SIGNIN passport.use ('local-signin', neue LocalStrategy (// Standardmäßig verwendet lokale Strategie Benutzername und Passwort, wir überschreiben sie mit E-Mail-BenutzernameFeld: 'email', passwordField: 'password', passReqToCallback: true // ermöglicht die Rückgabe der gesamten Anforderung an den Rückruf, function (req, email, password, done) var User = user; var isValidPassword = function (userpass, password) return bCrypt.compareSync (password, userpass) ; User.findOne (wo: email: email). Dann (Funktion (Benutzer) if (! Benutzer) return done (null, falsch, Nachricht: 'E-Mail existiert nicht'); if (! isValidPassword (user.password, password)) return done (null, falsch, message: 'Falsches Passwort'); var userinfo = user.get (); return done (null, userinfo); ) .catch (function (err) console.log ("Error:", err); return done (null, false, message: 'Etwas ist mit Ihrer Anmeldung fehlgeschlagen););));In dieser Strategie wird derisValidPasswordDie Funktion vergleicht das mit der bCrypt-Vergleichsmethode eingegebene Passwort, seit wir unser Passwort gespeichert haben bcrypt.
Wenn die Angaben korrekt sind, wird unser Benutzer angemeldet.
Gehen Sie jetzt zu routen / auth.js und fügen Sie die Route für die Veröffentlichung in hinzu /Einloggen.
app.post ('/ signin', passport.authenticate ('local-signin', successRedirect: '/ dashboard', failureRedirect: '/ signin)));Ihre Routen / auth.js sollten so aussehen, wenn Sie fertig sind.
var authController = required ('… /controllers/authcontroller.js'); module.exports = Funktion (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'); Führen Sie nun die App aus und versuchen Sie, sich anzumelden. Sie sollten sich mit allen Details anmelden können, die Sie bei der Anmeldung verwendet haben, und Sie werden weitergeleitet http: // localhost: 5000 / Dashboard /.
Herzlichen Glückwunsch, wenn Sie es bis zum Ende dieses Tutorials geschafft haben! Wir haben Sequelize und Passport erfolgreich mit einer MySQL-Datenbank verwendet.
Den vollständigen Code für dieses Tutorial finden Sie auf GitHub.
Damit ist unser Tutorial zur Verwendung von Passport für die Authentifizierung von Benutzern mit Sequelize und MySQL abgeschlossen. Sequelize ist ein wirklich nützliches ORM für den Umgang mit MySQL bei Verwendung von Node. Ich persönlich fand es sehr nützlich, und Sie sollten es definitiv in Ihrer nächsten Node-MySQL-App in Betracht ziehen.
