Verwenden von Passport mit Sequelize und MySQL

Sequelize ist ein Promise-basiertes Node.js-ORM. Es kann mit PostgreSQL, MySQL, MariaDB, SQLite und MSSQL verwendet werden. In diesem Tutorial implementieren wir die Authentifizierung für Benutzer einer Web-App. Und wir werden Passport, die beliebte Authentifizierungs-Middleware für Node, zusammen mit Sequelize und MySQL verwenden, um die Benutzerregistrierung und -anmeldung zu implementieren.

Erste Schritte

Stellen Sie sicher, dass Folgendes auf Ihrem Computer installiert ist:

Knoten
MySQL

Für dieses Tutorial werden wir Node.js zusammen mit Express verwenden, also fahren wir fort und installieren, was wir brauchen.

Schritt 1:Generieren Sie eine package.json-Datei

Erstellen Sie ein Verzeichnis für Ihre App. Führen Sie in diesem Verzeichnis dies von Ihrem Terminal oder Ihrer Eingabeaufforderung aus:

npm-init

Dadurch wird der npm Dependency Manager initialisiert. Dies wird eine Reihe von Eingabeaufforderungen präsentieren, die wir schnell durchgehen werden.

Geben Sie den Namen Ihrer App ohne Leerzeichen ein und drücken Sie die Eingabetaste für „Name“.
Drücken Sie die Eingabetaste für die 'Version'.
Für „Beschreibung“ geben wir in diesem Tutorial „Using Passport with Sequelize and MySQL“ als Beschreibung ein und drücken die Eingabetaste. Dies kann auch leer sein.
Geben Sie für „Einstiegspunkt (index.js)“ server.js ein und drücken Sie die Eingabetaste.
Drücken Sie für „Befehl testen“ die Eingabetaste.
Für „Git-Repository“ können Sie das Git-Repository eingeben, in dem sich Ihre App befindet, falls Sie eines haben, oder einfach die Eingabetaste drücken, um dieses Feld leer zu lassen.
Drücken Sie für "Keywords" die Eingabetaste.
Drücken Sie für „Autor“ die Eingabetaste oder geben Sie vorher Ihren Namen ein.
Drücken Sie für „Lizenz“ die Eingabetaste.
Für „(Ist das in Ordnung)“ zeigt Ihnen dies, wie Ihre package.json aussehen wird. Geben Sie Ja ein und drücken Sie die Eingabetaste.

Schritt 2:Abhängigkeiten installieren

Die wichtigsten Abhängigkeiten für dieses Tutorial sind:

Express
Sequelisieren
MySQL
Reisepass
Lokale Passport-Strategie
Body-Parser
Express-Sitzung
Bcrypt-Nodejs
Express-Handlebars für die Ansichten

Um sie zu installieren, führen Sie von Ihrem Terminal oder Ihrer Eingabeaufforderung nacheinander Folgendes aus.

npm install express --savenpm install sequelize --savenpm install mysql --savenpm install password --savenpm install password-local --savenpm install body-parser --savenpm install express-session --savenpm install bcrypt-nodejs - -savenpm 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 zur .gitignore-Datei hinzu.

node_modules

Schritt 3:Richten Sie die App ein

Jetzt erstellen wir eine Serverdatei. Dies ist die Hauptdatei, die aufgerufen wird, wenn Sie Folgendes eingeben:

npm starten

Damit läuft die App. Sie können die App auch ausführen, indem Sie node server.js.

eingeben

Knotenserver.js

Dann erstellen wir in unserem Projektordner eine neue Datei und nennen diese Datei server.js .

Innerhalb der server.js Datei, fügen wir Folgendes ein:

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)});

Die erste Zeile weist das Express-Modul einem Variablen-Express zu. Dann initialisieren wir express und nennen es eine Variable:app.

Dann lassen wir die App auf Port 5000 lauschen . Sie können eine beliebige freie Portnummer auf Ihrem Computer auswählen.

Als nächstes rufen wir app.get() auf Express-Routing-Funktion, um mit "Welcome to Passport with Sequelize" zu antworten, wenn eine GET-Anfrage an "/".

gestellt wird

Führen Sie zum Testen auf Ihrem Computer Folgendes aus Ihrem Projektordner aus:

Knotenserver.js

Wenn Sie den Text „Welcome to Passport with Sequelize“ sehen, wenn Sie http://localhost:5000/ besuchen, dann herzlichen Glückwunsch! Überprüfen Sie andernfalls, ob Sie alles genau so gemacht haben, wie es oben beschrieben ist.

Als Nächstes importieren wir einige Module, die wir benötigen, wie Passport, Express-Session und Body-Parser.

Nach var app = express() wir fügen die folgenden Zeilen hinzu:

var password =require('passport')var session =require('express-session')var bodyParser =require('body-parser')

In den ersten beiden Zeilen importieren wir das Passport-Modul und die Express-Session, die wir beide für die Authentifizierung benötigen.

Dann importieren wir das Body-Parser-Modul. Dadurch wird der gesamte Textteil einer eingehenden Anfrage extrahiert und in einem Format bereitgestellt, mit dem einfacher gearbeitet werden kann. In diesem Fall verwenden wir das JSON-Format.

Damit unsere App den Body-Parser verwenden kann, fügen wir diese Zeilen einige Leerzeichen unterhalb der Importzeilen hinzu:

//For BodyParserapp.use(bodyParser.urlencoded({ extended:true }));app.use(bodyParser.json());

Als Nächstes initialisieren wir Passport, die Express-Sitzung und die Passport-Sitzung und fügen beide als Middleware hinzu. Dazu fügen wir diese Zeilen einige Leerzeichen nach der bodyParser-Importzeile ein.

// For Passportapp.use(session({ secret:'keyboard cat', resave:true, saveUninitialized:true})); // Sitzungsgeheimnisapp.use(passport.initialize());app.use(passport.session()); // dauerhafte Anmeldesitzungen

Wir werden jetzt mit der Arbeit an der eigentlichen Authentifizierung beginnen.

Wir tun dies in vier Schritten:

Sequelize mit MySQL einrichten.
Erstellen Sie das Benutzermodell.
Ansichten einrichten.
Schreiben Sie eine Passstrategie.

1. Sequelize mit MySQL einrichten

Zuerst erstellen wir eine Datenbank in MySQL. Geben Sie ihm Ihren bevorzugten Namen. Für dieses Tutorial erstellen wir eine Datenbank mit dem Namen sequelize_passport in MySQL.

Dann richten wir die Konfiguration ein, um DB-Details zu verarbeiten.

Lassen Sie uns zuerst das Modul dot-env importieren, um Umgebungsvariablen zu handhaben.

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 =require('dotenv').load();

Als nächstes erstellen wir eine Datei in unserem Projektordner und nennen sie .env.

Dieser 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 der .env-Datei hinzu, indem wir diese Zeile hinzufügen:

NODE_ENV='development'

Dann erstellen wir eine config.json-Datei, die von Sequelize verwendet wird, um verschiedene Umgebungen zu verwalten.

Als erstes müssen Sie einen Ordner mit dem Namen config erstellen in unserer Projektmappe. In diesem Ordner erstellen wir eine config. json Datei. Diese Datei sollte ignoriert werden, wenn Sie in ein Repository pushen. Fügen Sie dazu Ihrer .gitignore-Datei den folgenden Code 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":{ "username":"", "password":null, "database":"", "host":"", "dialect":"mysql" }, "production":{ "username":"", "password":null, "database":"", "host":"127.0.0.1", "dialect":"mysql" }}

Denken Sie daran, die Werte im obigen Entwicklungsblock durch Ihre Datenbank-Authentifizierungsdetails 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, die Modelle zu erstellen Mappe.

Zuerst erstellen wir ein Verzeichnis mit dem Namen app in unserem Projektordner.

In der App erstellen wir einen neuen Ordner mit dem Namen models und erstellen Sie eine neue Datei mit dem Namen index.js in den Modellen Ordner.

In die index.js-Datei fügen wir den folgenden Code ein.

"use strict";var fs =require("fs");var path =require("path");var Sequelize =require("sequelize");var env =process.env.NODE_ENV || "Entwicklung";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;

Diese Datei wird verwendet, um alle Modelle zu importieren, die wir in den Modellen platzieren Ordner und exportieren Sie sie.

Um zu testen, ob alles in Ordnung ist, fügen wir dies in unsere server.js-Datei ein.

//Modelsvar models =require(./app/models");//Sync Databasemodels.sequelize.sync().then(function() { console.log('Schön! Datenbank sieht gut aus')}) .catch(function(err) { console.log(err, „Beim Datenbank-Update ist etwas schief gelaufen!“)});

Hier importieren wir die Modelle und rufen dann die Sequelize-Sync-Funktion auf.

Führen Sie dies aus, um zu sehen, ob alles in Ordnung ist:

Knotenserver.js

Wenn Sie die Meldung „Site is live Nice! Database does fine“ erhalten, haben Sie Sequelize erfolgreich eingerichtet.

Wenn nicht, gehen Sie die obigen Schritte bitte sorgfältig durch und versuchen Sie, das Problem mit der Hilfe zu beheben.

2. Erstellen Sie das Benutzermodell

Als Nächstes erstellen wir das Benutzermodell, das im Grunde die Benutzertabelle ist. Diese enthält grundlegende Benutzerinformationen.

In unseren Modellen erstellen wir eine Datei und nennen sie user.js . Der vollständige Pfad für diese Datei sollte app/models/user.js. lauten

Ö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, type:Sequelize.INTEGER }, firstname:{ type:Sequelize .STRING, notEmpty:true }, Nachname:{ Typ:Sequelize.STRING, notEmpty:true }, Benutzername:{ Typ:Sequelize.TEXT }, Info:{ Typ:Sequelize.TEXT }, E-Mail:{ Typ:Sequelize.STRING , validieren:{ isEmail:true } }, Passwort:{ type:Sequelize.STRING, allowNull:false }, last_login:{ type:Sequelize.DATE }, status:{ type:Sequelize.ENUM('active', 'inactive' ), defaultValue:'aktiv' } }); Benutzer zurückgeben;

Führen Sie nun Folgendes aus:

Knotenserver.js

Sie sollten das bekannte „Site is live. Nice! “ sehen Datenbank sieht gut aus. " Nachricht. Dies bedeutet, dass unsere Sequelize-Modelle erfolgreich synchronisiert wurden, und wenn Sie Ihre Datenbank überprüfen, sollten Sie eine Benutzertabelle mit den angegebenen Spalten sehen.

3:Ansichten einrichten

Lassen Sie uns zuerst die Ansicht für die Anmeldung erstellen und verbinden.

Als erstes müssen Sie das Express-Handlebars-Modul importieren, das wir in diesem Tutorial für Ansichten verwenden.

Fügen Sie diese Zeile zur Hauptstartdatei server.js. hinzu

var exphbs = require('express-handlebars')

Ihr Importblock sollte jetzt so aussehen.

var express =require('express')var app =express()var passwort =require('passport')var session =require('express-session')var bodyParser =require('body-parser')var env =require('dotenv').load()var exphbs =require('express-handlebars')

Als nächstes fügen wir die folgenden Zeilen in unsere server.js-Datei ein.

//For Handlebarsapp.set('views', './app/views')app.engine('hbs', exphbs({ extname:'.hbs'}));app.set('view engine ', '.hbs');

Jetzt erstellen wir in unserem App-Ordner drei Ordner namens views, Controller, und Routen .

Im Views-Ordner erstellen wir eine Datei namens signup. hbs und fügen Sie den unten stehenden Code ein.

   E-Mail-Adresse  Vorname  Nachname  Passwort   
 
 Dann in unseren Controllern erstellen wir eine neue Datei und nennen sie authcontroller.js. 
 
 In diese Datei fügen wir den folgenden Controller für die Anmelderoute ein, die wir gleich 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  und dann importieren wir in diese Datei den Authentifizierungs-Controller und definieren die Anmelderoute.
 var authController =require('../controllers/authcontroller.js');module.exports =function(app) { app.get('/signup', authController.signup);}
 
 Jetzt importieren wir diese Route in unsere server.js und übergeben app als Argument.
 
 Fügen Sie im Server nach dem Import der Modelle diese Zeilen hinzu:
 //Routesvar authRoute =require('./app/routes/auth.js')(app);
 
 Führen Sie Folgendes aus: 
 Knotenserver.js
 
 Besuchen Sie jetzt http://localhost:5000/signup und Sie sehen das Anmeldeformular.
 
 Wiederholen wir die Schritte für das Anmeldeformular. Wie zuvor erstellen wir eine Datei namens signin.hbs in unserem Ansichtenordner und fügen Sie den folgenden HTML-Code ein:
    E-Mail-Adresse  Password   
 
 Fügen Sie dann einen Controller für die Anmeldung in app/controllers/authcontroller.js. hinzu 
 exports.signin =function(req, res) { res.render('signin');}
 
 Dann in app/routes/auth.js , fügen wir eine Route für die Anmeldung wie folgt hinzu:
 
 app.get('/signin', authController.signin); 
 
 Wenn Sie jetzt laufen:
  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.
 4. Schreiben Sie eine Pass-Strategie
 
 In app/config , erstellen wir einen neuen Ordner namens passport. 
 
 Dann erstellen wir in unserem neuen Ordner app/config/passport eine neue Datei und nennen sie passport.js . Diese Datei enthält unsere Passstrategien.
 
 In passport.js verwenden wir das Benutzermodell und den Passport.
 
 Zuerst importieren wir bcrypt die wir zum Sichern von Passwörtern benötigen.
 
 var bCrypt = require('bcrypt-nodejs'); 
 
 Dann fügen wir einen module.exports-Block wie diesen hinzu:
 module.exports =function(passport, user) {}
 
 Innerhalb dieses Blocks initialisieren wir die Passport-Local-Strategie und das Benutzermodell, das als Argument übergeben wird. So machen wir das:
 module.exports =function(passport, user) { var User =user; var LocalStrategy =require('passport-local').Strategy;}
 
 Dann definieren wir unsere benutzerdefinierte Strategie mit unserer Instanz der LocalStrategy wie folgt:
 passport.use('local-signup', new LocalStrategy( { usernameField:'email', passwordField:'password', passReqToCallback:true // erlaubt uns, die gesamte Anfrage an den Callback zurückzugeben },)); 
 
 Nun haben wir deklariert, welche Anfrage (req ) Felder sind unser usernameField und passwordField (Passport-Variablen). 
 
 Die letzte Variable passReqToCallback ermöglicht es uns, die gesamte Anfrage an den Callback zu übergeben, was besonders für die Anmeldung nützlich ist.
 
 Nach dem letzten Komma fügen wir diese Callback-Funktion hinzu.
  function(req, email, password, done) { }
 
 In dieser Funktion kümmern wir uns um das Speichern von Benutzerdaten.
 
 Zuerst fügen wir unsere Hash-Passwort-Erzeugungsfunktion in die Callback-Funktion ein.
  var generateHash =function(password) { return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null); };
 
 Verwenden Sie dann das Sequelize-Benutzermodell, das wir zuvor als Benutzer initialisiert haben , prüfen wir, ob der Benutzer bereits existiert, und wenn nicht, fügen wir ihn hinzu.
 User.findOne({ where:{ email:email }}).then(function(user) { if (user) { return done(null, false, { message:'Diese E-Mail ist bereits vergeben' }); } 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, erstellt) { if (!newUser) { return done(null, false); } 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 den data Objekt werden aus req.body geholt -Objekt, das die Eingabe aus unserem Anmeldeformular enthält. 
 
 
 Ihre passport.js sollte so aussehen:
 //bcryptvar laden 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 // ermöglicht es uns, die gesamte Anfrage an den Callback zurückzugeben }, function(req, email, Passwort, fertig) { 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:'Diese E-Mail ist bereits vergeben' }); } else { var userPassword =generateHash(password); var data ={ email:email, password:Benutzer-Passwort, vorname:req.body.vorname, nachname:req.body.lastname }; User.create(data).then(function(newUser, created) { if (!newUser) { return done(null, false); } if (newUser) { return done(null, newUser); } }); } }); } ));}
 
 Jetzt importieren wir die Strategie in server.js. 
 
 Dazu fügen wir diese Zeilen unterhalb des Routenimports in server.js. ein 
 //Passport-Strategien ladenrequire('./app/config/passport/passport.js')(passport, models.user);
 
 Ihre server.js sollte zu diesem Zeitpunkt so aussehen:
 var express =require('express')var app =express()var passwort =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( )); // For Passportapp.use(session({ secret:'keyboard cat', resave:true, saveUninitialized:true})); // Sitzungsgeheimnisapp.use(passport.initialize());app.use(passport.session()); // dauerhafte Anmeldesitzungen//For Handlebarsapp.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');});//Modelsvar models =require(". /app/models");//Routesvar authRoute =require('./app/routes/auth.js')(app);//Passportstrategien ladenrequire('./app/config/passport/passport.js') (passport, models.user);//Sync Databasemodels.sequelize.sync().then(function() { console.log('Schön! Datenbank sieht gut aus')}).catch(function(err) { console.log (err, „Beim Datenbank-Update ist etwas schief gelaufen!“)});app.listen(5000, function(err) { if (!err) console.log(“Site is live“); else console.log(err )});
 
 Jetzt werden wir die Strategie tatsächlich auf unser /signup anwenden Strecke.
 
 So machen wir das:
 
 Zuerst gehen wir zu app/routes/auth.js , und fügen Sie eine Route zum Posten hinzu, um sich wie folgt anzumelden.
 app.post('/signup', Passport.authenticate('local-signup', { successRedirect:'/dashboard', failureRedirect:'/signup' }));
 
 Da wir einen Reisepass benötigen, müssen wir ihn an diese Methode weitergeben. Wir können Passport in dieses Skript importieren oder von server.js übergeben. Machen wir letzteres.
 
 Ä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 Ihrer Änderung so aussehen.
 var authController =require('../controllers/authcontroller.js');module.exports =function(app, password) { 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 , ändern wir den Routenimport und fügen Passport als Argument wie folgt hinzu:
 
 var authRoute = require('./app/routes/auth.js')(app,passport); 
 
 Gehen Sie jetzt zur Anmelde-URL http://localhost:5000/signup/ und versuchen Sie, sich anzumelden.
 
 Wenn Sie versuchen, sich anzumelden, erhalten Sie die Fehlermeldung „Failed to serialize user into session ". Dies liegt daran, dass Passport eine Benutzer-ID in der Sitzung speichern muss und diese verwendet, um das Abrufen der Benutzerdetails bei Bedarf zu verwalten.
 
 Um dies zu lösen, werden wir sowohl die Serialisierungs- als auch die Deserialisierungsfunktion von Passport in unserer app/config/passport/passport.js implementieren Datei.
 
 Zuerst fügen wir die Serialize-Funktion hinzu. In dieser Funktion speichern wir die Benutzer-ID zur Sitzung.
 
 Dazu fügen wir die folgenden Zeilen unterhalb der Initialisierung der lokalen Strategie ein.
 //serializepassport.serializeUser(function(user, done) { done(null, user.id);});
 
 Als nächstes implementieren wir die Deserialisierungsfunktion. Fügen Sie die Funktion direkt unter der Serialize-Funktion hinzu.
 // Benutzer deserialisieren password.deserializeUser(function(id, done) { User.findById(id).then(function(user) { if (user) { done(null, user.get()); } else { done(user.errors, null); } });});
 
 In der obigen Deserialisierungsfunktion verwenden wir die Sequelize findById Versprechen, den Benutzer zu erhalten, und wenn erfolgreich, wird eine Instanz des Sequelize-Modells zurückgegeben. Um das User-Objekt von dieser Instanz zu erhalten, verwenden wir die Sequelize-Getter-Funktion wie folgt:user.get() .
 
 Jetzt erneut ausführen:
 Knotenserver.js
 
 Und versuchen Sie, sich anzumelden. Hurra, wenn Sie die Meldung "Cannot GET /dashboard" erhalten haben! Dies bedeutet, dass unsere Authentifizierung erfolgreich war. Denken Sie daran, dass wir in unserer Methode "password.authenticate" in routes/auth.js zu /dashboard umgeleitet haben .
 
 Lassen Sie uns jetzt fortfahren und diese Route hinzufügen. Fügen Sie dann eine Middleware hinzu, um sicherzustellen, dass auf die Seite nur zugegriffen werden kann, wenn ein Benutzer bei der Sitzung angemeldet ist.
 
 In unserer App/Ansichten erstellen wir eine neue Datei mit dem Namen dashboard.hbs und fügen Sie den folgenden HTML-Code hinzu.
  Reisepass mit Sequelize Dashboard
 Hurra! Sie sind eingeloggt.
 
 In routes/auth.js , fügen wir diese Zeile in module.exports ein blockieren:
 
 app.get('/dashboard',authController.dashboard); 
 
 Als nächstes gehen wir zu app/controllers/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 die App jetzt erneut aus und versuchen Sie, sich mit einer anderen E-Mail-Adresse als der zuvor verwendeten anzumelden. Sie werden entsprechend zum /Dashboard  weitergeleitet Route. 
 
 Aber /dashboard ist keine geschützte Route, was bedeutet, dass ein Benutzer sie auch sehen kann, wenn er nicht angemeldet ist. Wir wollen das nicht, also fügen wir ein /logout hinzu route, um den Benutzer abzumelden, und dann die Route zu schützen und zu testen, was wir getan haben.
 
 Gehen wir so vor:
 
 In routes/auth.js wir fügen diese Zeile hinzu:
 
 app.get('/logout',authController.logout); 
 
 Dann fügen wir den Controller in app/controllers/authController.js hinzu.
  exports.logout =function(req, res) { req.session.destroy(function(err) { res.redirect('/'); }); }
 
 Führen Sie die App jetzt erneut aus und melden Sie sich mit einer anderen E-Mail-Adresse an.
 
 Besuchen Sie danach http://localhost:5000/logout, um den Benutzer abzumelden. Besuchen Sie jetzt http://localhost:5000/dashboard.
 
 Sie werden feststellen, dass es ziemlich zugänglich ist. Lassen Sie uns eine benutzerdefinierte Middleware hinzufügen, um diese Route zu schützen.
 
 Dazu öffnen wir app/routes/auth.js und  fügen Sie diese Funktion in module.exports hinzu Block, unter allen anderen Codezeilen.
 Funktion isLoggedIn(req, res, next) { if (req.isAuthenticated()) return next(); res.redirect('/signin');}
 
 Dann ändern wir den Route-Handler des Dashboards so, dass er folgendermaßen aussieht:
 
 app.get('/dashboard',isLoggedIn, authController.dashboard); 
 
 Wenn Sie jetzt die App erneut ausführen und versuchen, die Dashboard-Seite aufzurufen, ohne angemeldet zu sein, 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 in app/config/passport/passport.js hinzu . 
 //LOCAL SIGNINpassport.use('local-signin', new LocalStrategy( { // Standardmäßig verwendet die lokale Strategie Benutzername und Passwort, wir überschreiben mit E-Mail usernameField:'email', passwordField:'password', passReqToCallback :true // erlaubt uns, die gesamte Anfrage an den Callback zurückzugeben }, 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:'Falsches Passwort.' }); } var userinfo =user. werden(); return done(null, userinfo); }).catch(function(err) { console.log("Error:", err); return done(null, false, { message:'Etwas ist mit Ihrer Anmeldung schief gelaufen' }); }); }));
 
 Bei dieser Strategie ist die  isValidPassword   Funktion vergleicht das eingegebene Passwort mit der bCrypt-Vergleichsmethode, da wir unser Passwort mit bcrypt gespeichert haben . 
 
 
 Wenn die Angaben korrekt sind, wird unser Benutzer angemeldet.
 
 Gehen Sie nun zu routes/auth.js und fügen Sie die Route zum Posten zu / hinzu anmelden. 
 app.post('/signin', Passport.authenticate('local-signin', { successRedirect:'/dashboard', failureRedirect:'/signin' }));
 
 Ihre "routes/auth.js" sollte so aussehen, wenn Sie fertig sind.
 var authController =require('../controllers/authcontroller.js');module.exports =function(app, password) { app.get('/signup', authController.signup); app.get('/signin', authController.signin); app.post('/signup', password.authenticate('local-signup', { successRedirect:'/dashboard', failureRedirect:'/signup' } )); app.get('/dashboard', isLoggedIn, authController.dashboard); app.get('/logout', authController.logout); app.post('/signin', password.authenticate('local-signin', { successRedirect:'/dashboard', failureRedirect:'/signin' } )); Funktion isLoggedIn(req, res, next) { if (req.isAuthenticated()) return next(); res.redirect('/signin'); }}
 
 Führen Sie jetzt die App aus und versuchen Sie, sich anzumelden. Sie sollten sich mit allen Details anmelden können, die Sie bei der Registrierung verwendet haben, und Sie werden zu http weitergeleitet ://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.