Passport mit Sequelize und MySQL verwenden

() translation by (you can also view the original English article)

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

Einstieg

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

Node
MySQL

Für dieses Tutorial verwenden wir Node.js zusammen mit Express, also beginnen wir mit der Installation, was wir brauchen.

Schritt 1: Generieren Sie eine package.json-Datei

Erstellen Sie ein Verzeichnis für Ihre App. Führen Sie dies in diesem Verzeichnis von Ihrem Terminal oder Ihrer Eingabeaufforderung aus:

 npm init

Dadurch wird der npm-Abhängigkeitsmanager initialisiert. Dies wird eine Reihe von Eingabeaufforderungen präsentieren, die wir schnell durchgehen werden.

Geben Sie den Namen Ihrer App ohne Leerzeichen ein und drücken Sie die Eingabetaste für "name".
Drücken Sie die Eingabetaste für die 'version'.
Für "description" geben wir in diesem Tutorial "Using Passport with Sequelize and MySQL" als Beschreibung ein und drücken die Eingabetaste. Dies kann auch leer sein.
Geben Sie für 'entry point (index.js)' server.js ein und drücken Sie die Eingabetaste.
Drücken Sie für 'test command' die Eingabetaste.
Für 'git repository' können Sie das Git-Repository eingeben, in dem sich Ihre App befindet, falls Sie eines haben, oder einfach die Eingabetaste drücken, um dieses Feld leer zu lassen.
Drücken Sie für 'Keywords' die Eingabetaste.
Drücken Sie für 'author' die Eingabetaste oder geben Sie Ihren Namen ein, bevor Sie dies tun.
Drücken Sie für 'license' die Eingabetaste.
Für '(Is this okay)' zeigt Ihnen dies, wie Ihre package.json aussehen wird. Geben Sie Ja ein und drücken Sie die Eingabetaste.

Schritt 2: Abhängigkeiten installieren

Die wichtigsten Abhängigkeiten für dieses Tutorial sind:

Express
Sequelize
MySQL
Passport
Passport Local Strategy
Body Parser
Express Session
Bcrypt Nodejs
Express Handlebars für die Ansichten

Um sie zu installieren, führen Sie von Ihrem Terminal oder Ihrer Eingabeaufforderung die folgenden Schritte nacheinander aus.

npm install express --save

npm install sequelize --save

npm install mysql --save

npm install passport --save

npm install passport-local --save

npm install body-parser --save

npm install express-session --save

npm install bcrypt-nodejs --save

npm install express-handlebars --save

Wenn Sie Git für dieses Projekt verwenden:

Erstellen Sie in Ihrem Projektordner eine .gitignore-Datei.

Fügen Sie diese Zeile der .gitignore-Datei hinzu.

node_modules

Schritt 3: Einrichten der App

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

npm start

Dadurch wird die App ausgeführt. Sie können die App auch ausführen, indem Sie node server.js eingeben.

1	node server.js

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

In die Datei server.js fü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 einer Variablen express zu. Wir initialisieren dann express und nennen es eine Variable: app.

Dann lassen wir die App auf Port 5000 lauschen. Sie können eine beliebige freie Portnummer auf Ihrem Computer wählen.

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

Um auf Ihrem Computer zu testen, führen Sie dies in Ihrem Projektordner aus:

1	node server.js

Wenn Sie beim Besuch von http://localhost:5000/ den Text "Welcome to Passport with Sequelize" sehen, dann herzlichen Glückwunsch! Überprüfen Sie andernfalls, ob Sie alles genau so gemacht haben, wie es oben beschrieben wurde.

Als nächstes importieren wir einige Module, die wir benötigen, wie Passport, Express-Session und Body-Parser.

Nach var app = express() fügen wir die folgenden Zeilen hinzu:

1	var passport = require('passport')
2	var session = require('express-session')
3	var bodyParser = require('body-parser')

In den ersten beiden Zeilen importieren wir das Passport-Modul und die Express-Session, die wir beide für die Authentifizierung benötigen.

Dann importieren wir das Body-Parser-Modul. Dadurch wird der gesamte Textteil einer eingehenden Anforderung extrahiert und in einem Format bereitgestellt, mit dem die Arbeit einfacher ist. In diesem Fall verwenden wir das JSON-Format.

Damit unsere App den Body-Parser verwenden kann, fügen wir diese Zeilen einige Leerzeichen unter den Importzeilen hinzu:

1	//For BodyParser
2	app.use(bodyParser.urlencoded({ extended: true }));
3	app.use(bodyParser.json());

Als nächstes initialisieren wir Passport und die Express- und Passport-Sitzung und fügen beide als Middleware hinzu. Dazu fügen wir diese Zeilen einige Leerzeichen nach der bodyParser-Importzeile hinzu.

// For Passport

app.use(session({ secret: 'keyboard cat',resave: true, saveUninitialized:true})); // session secret

app.use(passport.initialize());

app.use(passport.session()); // persistent login sessions

Wir werden jetzt mit der eigentlichen Authentifizierung beginnen.

Wir machen das 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. Lassen Sie uns für dieses Tutorial eine Datenbank mit dem Namen sequelize_passport in MySQL erstellen.

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

Lassen Sie uns zunächst das dot-env-Modul importieren, um Umgebungsvariablen zu verarbeiten.

Führen Sie dies in Ihrem Stammprojektordner aus:

1	npm install --save dotenv

Dann importieren wir es in die Hauptserverdatei server.js, direkt unter den anderen Importen.

1	var env = require('dotenv').load();

Als nächstes erstellen wir eine Datei in unserem Projektordner und nennen sie .env.

Dieser nächste Schritt ist optional, wenn Sie Git nicht verwenden:

Wir fügen die .env-Datei zu Ihrer .gitignore-Datei hinzu.

Ihre .gitignore-Datei sollte so aussehen:

1	node_modules
2	.env

Danach fügen wir unsere Umgebung der .env-Datei hinzu, indem wir diese Zeile hinzufügen:

NODE_ENV='development'

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

Als erstes erstellen Sie einen Ordner namens config in unserem Projektordner. In diesem Ordner erstellen wir eine config.json-Datei. Diese Datei sollte ignoriert werden, wenn Sie auf ein Repository pushen. Fügen Sie dazu Ihrer .gitignore-Datei den folgenden Code hinzu:

config/config.json

Dann fügen wir den folgenden Code in unsere Datei config.json 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 Datenbankauthentifizierungsdetails zu ersetzen.

Als nächstes installieren wir Sequelize mit npm. Führen Sie dazu den folgenden Befehl im Stammordner des Projekts aus:

1	npm install --save sequelize

Jetzt ist es an der Zeit, den models-Ordner zu erstellen.

Zuerst erstellen wir ein Verzeichnis namens app in unserem Projektordner.

Innerhalb des app-Ordners erstellen wir einen neuen Ordner namens models und erstellen eine neue Datei namens index.js im Ordner models.

In die Datei index.js fü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 || "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;

Diese Datei wird verwendet, um alle Modelle, die wir im models-Ordner platzieren, zu importieren und zu exportieren.

Um zu testen, ob alles in Ordnung ist, fügen wir dies in unsere Datei server.js ein.

//Models
var models = require("./app/models");

//Sync Database
models.sequelize.sync().then(function() {

    console.log('Nice! Database looks fine')

}).catch(function(err) {

    console.log(err, "Something went wrong with the Database Update!")

});

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

Führen Sie dies aus, um zu sehen, ob alles in Ordnung ist:

1	node server.js

Wenn Sie die Meldung "Site is live Nice! Database sieht in Ordnung" erhalten, haben Sie Sequelize erfolgreich eingerichtet.

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

2. Erstellen Sie das Benutzermodell

Als nächstes erstellen wir das Benutzermodell, das im Grunde die Benutzertabelle ist. Diese enthält grundlegende Benutzerinformationen.

In unserem models-Ordner erstellen wir eine Datei und nennen sie user.js. Der vollständige Pfad für diese Datei sollte app/models/user.js lauten.

Öffnen Sie die Datei user.js und fü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
        },

        lastname: {
            type: Sequelize.STRING,
            notEmpty: true
        },

        username: {
            type: Sequelize.TEXT
        },

        about: {
            type: Sequelize.TEXT
        },

        email: {
            type: Sequelize.STRING,
            validate: {
                isEmail: true
            }
        },

        password: {
            type: Sequelize.STRING,
            allowNull: false
        },

        last_login: {
            type: Sequelize.DATE
        },

        status: {
            type: Sequelize.ENUM('active', 'inactive'),
            defaultValue: 'active'
        }


    });

    return User;

}

Führen Sie nun aus:

1	node server.js

Sie sollten das bekannte "Site is live. Nice! Database sieht in Ordnung" sehen. Botschaft. Dies bedeutet, dass unsere Sequelize-Modelle erfolgreich synchronisiert wurden, und wenn Sie Ihre Datenbank überprüfen, sollten Sie eine Benutzertabelle mit den angegebenen Spalten sehen.

3: Ansichten einrichten

Zuerst erstellen wir die Ansicht für die Anmeldung und verbinden sie.

Als erstes müssen Sie das Express-Lenkermodul importieren, das wir in diesem Tutorial für Ansichten verwenden.

Fügen Sie diese Zeile der Hauptstartdatei server.js hinzu.

var exphbs = require('express-handlebars')

Ihr Importblock sollte jetzt so aussehen.

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')

Als nächstes fügen wir die folgenden Zeilen in unsere Datei server.js ein.

//For 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 den Namen Ansichten, Controller und Routen.

Im Ordner "views" erstellen wir eine Datei namens signup.hbs und fügen den folgenden Code darin ein.

<!DOCTYPE html>
<html>

<head>
    <title></title>
</head>

<body>
    <form id="signup" name="signup" method="post" action="/signup">
        <label for="email">Email Address</label>
        <input class="text" name="email" type="email" />
        <label for="firstname">Firstname</label>
        <input name="firstname" type="text" />
        <label for="lastname">Lastname</label>
        <input name="lastname" type="text" />
        <label for="password">Password</label>
        <input name="password" type="password" />
        <input class="btn" type="submit" value="Sign Up" />
    </form>

</body>

</html>

Dann erstellen wir in unserem controllers-Ordner eine neue Datei und nennen sie authcontroller.js.

In diese Datei fügen wir den folgenden Controller für die Anmelderoute ein, die wir gleich erstellen werden.

var exports = module.exports = {}

exports.signup = function(req, res) {

    res.render('signup');

}

Als nächstes erstellen wir eine Route für die Anmeldung. Im Routenordner erstellen wir eine neue Datei namens auth.js und importieren dann in dieser Datei den Auth-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 übergeben app als Argument.

Fügen Sie im Server nach dem Import der Modelle die folgenden Zeilen hinzu:

1	//Routes
2	var authRoute = require('./app/routes/auth.js')(app);

Führen Sie dies aus:

1	node server.js

Besuchen Sie jetzt http://localhost:5000/signup und Sie sehen das Anmeldeformular.

Wiederholen Sie die Schritte für das Anmeldeformular. Wie zuvor erstellen wir eine Datei namens signin.hbs in unserem Ansichtenordner und fügen den folgenden HTML-Code darin ein:

<!DOCTYPE html>
<html>

<head>
    <title></title>
</head>

<body>
    <form id="signin" name="signin" method="post" action="signin">
        <label for="email">Email Address</label>
        <input class="text" name="email" type="text" />
        <label for="password">Password</label>
        <input name="password" type="password" />
        <input class="btn" type="submit" value="Sign In" />
    </form>

</body>

</html>

Fügen Sie dann einen Controller für die Anmeldung in app/controllers/authcontroller.js hinzu.

exports.signin = function(req, res) {

    res.render('signin');

}

Dann fügen wir in app/routes/auth.js eine Route für die Anmeldung wie folgt hinzu:

app.get('/signin', authController.signin);

Wenn Sie jetzt laufen:

1	node 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 enthält unsere Passstrategien.

In passport.js verwenden wir das Benutzermodell und den Passport.

Zuerst importieren wir bcrypt, das wir zum Sichern von Passwörtern benötigen.

var bCrypt = require('bcrypt-nodejs');

Dann fügen wir einen module.exports-Block wie folgt hinzu:

1	module.exports = function(passport, user) {
2
3	}

In diesem Block initialisieren wir die Passport-Local-Strategie und das Benutzermodell, das als Argument ü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 // allows us to pass back the entire request to the callback

    },

));

Jetzt haben wir deklariert, welche Anfragefelder (req) unser usernameField und passwordField (Passport-Variablen) sind.

Die letzte Variable passReqToCallback ermöglicht es uns, die gesamte Anfrage an den Callback zu übergeben, was besonders für die Anmeldung nützlich ist.

Nach dem letzten Komma fügen wir diese Callback-Funktion hinzu.

1	function(req, email, password, done) {
2
3	}

In dieser Funktion übernehmen wir die Speicherung von Benutzerdaten.

Zuerst fügen wir unsere Funktion zum Generieren von Hash-Passwörtern in die Callback-Funktion ein.

 var generateHash = function(password) {

     return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null);

 };

Dann überprüfen wir mit dem Sequelize-Benutzermodell, das wir zuvor als User initialisiert haben, ob der Benutzer bereits existiert, und fügen ihn gegebenenfalls hinzu.

User.findOne({
    where: {
        email: email
    }
}).then(function(user) {

    if (user)

    {

        return done(null, false, {
            message: 'That email is already taken'
        });

    } else

    {

        var userPassword = generateHash(password);

        var data =

            {
                email: email,

                password: userPassword,

                firstname: req.body.firstname,

                lastname: req.body.lastname

            };


        User.create(data).then(function(newUser, created) {

            if (!newUser) {

                return done(null, false);

            }

            if (newUser) {

                return done(null, newUser);

            }

        });

    }

});

User.create() ist eine Sequelize-Methode zum Hinzufügen neuer Einträge zur Datenbank. Beachten Sie, dass die Werte im data-Objekt aus dem req.body-Objekt stammen, das die Eingabe aus unserem Anmeldeformular enthält.

Ihre passport.js sollte so aussehen:

//load bcrypt
var bCrypt = require('bcrypt-nodejs');


module.exports = function(passport, user) {


    var User = user;

    var LocalStrategy = require('passport-local').Strategy;


    passport.use('local-signup', new LocalStrategy(

        {

            usernameField: 'email',

            passwordField: 'password',

            passReqToCallback: true // allows us to pass back the entire request to the callback

        },



        function(req, email, password, done) {

            var generateHash = function(password) {

                return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null);

            };



            User.findOne({
                where: {
                    email: email
                }
            }).then(function(user) {

                if (user)

                {

                    return done(null, false, {
                        message: 'That email is already taken'
                    });

                } else

                {

                    var userPassword = generateHash(password);

                    var data =

                        {
                            email: email,

                            password: userPassword,

                            firstname: req.body.firstname,

                            lastname: req.body.lastname

                        };

                    User.create(data).then(function(newUser, created) {

                        if (!newUser) {

                            return done(null, false);

                        }

                        if (newUser) {

                            return done(null, newUser);

                        }

                    });

                }

            });

        }

    ));

}

Jetzt importieren wir die Strategie in server.js.

Dazu fügen wir diese Zeilen unterhalb des Routenimports in server.js hinzu.

1	//load passport strategies
2	require('./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 passport = require('passport')
var session = require('express-session')
var bodyParser = require('body-parser')
var env = require('dotenv').load()
var exphbs = require('express-handlebars')


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


// For Passport
app.use(session({
    secret: 'keyboard cat',
    resave: true,
    saveUninitialized: true
})); // session secret
app.use(passport.initialize());
app.use(passport.session()); // persistent login sessions


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



app.get('/', function(req, res) {

    res.send('Welcome to Passport with Sequelize');

});

//Models
var models = require("./app/models");

//Routes

var authRoute = require('./app/routes/auth.js')(app);


//load passport strategies

require('./app/config/passport/passport.js')(passport, models.user);


//Sync Database

models.sequelize.sync().then(function() {

    console.log('Nice! Database looks fine')


}).catch(function(err) {

    console.log(err, "Something went wrong with the Database Update!")

});


app.listen(5000, function(err) {

    if (!err)

        console.log("Site is live");
        
    else console.log(err)

});

Jetzt werden wir die Strategie tatsächlich auf unsere /signup-Route anwenden.

So machen wir das:

Zuerst gehen wir zu app/routes/auth.js und fügen 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 benötigen, müssen wir ihn an diese Methode übergeben. Wir können den Passport in dieses Skript importieren oder von server.js übergeben. Machen wir letzteres.

Ändern Sie die exportierte Funktion in dieser Datei app/routes/auth.js so, dass sie Passport als Parameter hat. Der Code in app/routes/auth.js sollte nach Ihrer Änderung so aussehen.

var authController = require('../controllers/authcontroller.js');


module.exports = function(app, passport) {

    app.get('/signup', authController.signup);


    app.get('/signin', authController.signin);


    app.post('/signup', passport.authenticate('local-signup', {
            successRedirect: '/dashboard',

            failureRedirect: '/signup'
        }

    ));



}

Dann ändern wir in server.js den Routenimport und fügen den Passport wie folgt als Argument hinzu:

var authRoute = require('./app/routes/auth.js')(app,passport);

Gehen Sie nun zur Anmelde-URL http://localhost:5000/signup/ und versuchen Sie, sich anzumelden.

Wenn Sie versuchen, sich anzumelden, erhalten Sie eine Fehlermeldung "Fehler beim Serialisieren des Benutzers in die Sitzung". 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 lösen, implementieren wir die Serialisierungs- und Deserialisierungsfunktionen von Passport in unserer Datei app/config/passport/passport.js.

Zuerst fügen wir die Serialisierungsfunktion hinzu. In dieser Funktion speichern wir die user id in der Sitzung.

Dazu fügen wir die folgenden Zeilen unterhalb der Initialisierung der lokalen Strategie ein.

//serialize
passport.serializeUser(function(user, done) {

    done(null, user.id);

});

Als nächstes implementieren wir die Deserialize-Funktion. Fügen Sie die Funktion direkt unter der Serialisierungsfunktion hinzu.

// deserialize user 
passport.deserializeUser(function(id, done) {

    User.findById(id).then(function(user) {

        if (user) {

            done(null, user.get());

        } else {

            done(user.errors, null);

        }

    });

});

In der obigen Deserialize-Funktion verwenden wir das Sequelize findById-Versprechen, um den Benutzer abzurufen, und bei Erfolg wird eine Instanz des Sequelize-Modells zurückgegeben. Um das User-Objekt von dieser Instanz abzurufen, verwenden wir die Sequelize-Getter-Funktion wie folgt: user.get().

Jetzt noch einmal ausführen:

1	node server.js

Und versuchen Sie sich anzumelden. Hurra, wenn Sie das "Cannot GET /dashboard" bekommen haben! Dies bedeutet, dass unsere Authentifizierung erfolgreich war. Denken Sie daran, dass wir in unserer Methode Passport.authenticate in routes/auth.js auf /dashboard umgeleitet haben.

Lassen Sie uns nun fortfahren und diese Route hinzufügen. Fügen Sie dann eine Middleware hinzu, um sicherzustellen, dass die Seite nur aufgerufen werden kann, wenn ein Benutzer bei der Sitzung angemeldet ist.

In unserem app/views-Ordner erstellen wir eine neue Datei namens dashboard.hbs und fügen den folgenden HTML-Code hinzu.

<!DOCTYPE html>
<html>

<head>
    <title>Passport with Sequelize</title>
</head>

<body>
    <h2>Dashboard</h2>
    <h5>Hurray! you are logged in.</h5>

</body>

</html>

In routes/auth.js fügen wir diese Zeile innerhalb des module.exports-Blocks hinzu:

app.get('/dashboard',authController.dashboard);

Als nächstes gehen wir zu app/controllers/authController.js und fügen 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');

}

Führen Sie nun die App erneut aus und versuchen Sie, sich mit einer anderen E-Mail-Adresse als der zuvor verwendeten anzumelden. Sie werden entsprechend zur /dashboard-Route weitergeleitet.

Aber /dashboard ist keine geschützte Route, das heißt, auch wenn ein Benutzer nicht angemeldet ist, kann er ihn sehen. Wir wollen dies nicht, also fügen wir eine /logout-Route hinzu, um den Benutzer abzumelden, und schützen dann die Route und testen, was wir getan haben.

Lass uns das machen:

In routes/auth.js fügen wir diese Zeile hinzu:

app.get('/logout',authController.logout);

Dann fügen wir den Controller in app/controllers/authController.js hinzu.

 exports.logout = function(req, res) {

     req.session.destroy(function(err) {

         res.redirect('/');

     });

 }

Führen Sie nun die App erneut aus und melden Sie sich mit einer anderen E-Mail-Adresse an.

Rufen Sie danach http://localhost:5000/logout auf, um den Benutzer abzumelden. Besuchen Sie jetzt http://localhost:5000/dashboard.

Sie werden feststellen, dass es gut zugänglich ist. Fügen wir eine benutzerdefinierte Middleware hinzu, um diese Route zu schützen.

Dazu öffnen wir app/routes/auth.js und fügen diese Funktion im module.exports-Block unter allen anderen Codezeilen hinzu.

function isLoggedIn(req, res, next) {

    if (req.isAuthenticated())
    
        return next();
        
    res.redirect('/signin');

}

Dann ändern wir den Routen-Handler des Dashboards so, dass er wie folgt aussieht:

app.get('/dashboard',isLoggedIn, authController.dashboard);

Wenn Sie nun die App erneut ausführen und versuchen, die Dashboard-Seite zu besuchen und nicht angemeldet sind, sollten Sie zur Anmeldeseite weitergeleitet werden.

Wütend! Es ist Zeit, den letzten Teil zu implementieren: die Anmeldung.

Zuerst fügen wir eine neue lokale Strategie für die Anmeldung in app/config/passport/passport.js hinzu.

//LOCAL SIGNIN
passport.use('local-signin', new LocalStrategy(

    {

        // by default, local strategy uses username and password, we will override with email

        usernameField: 'email',

        passwordField: 'password',

        passReqToCallback: true // allows us to pass back the entire request to the callback

    },


    function(req, email, password, done) {

        var User = user;

        var isValidPassword = function(userpass, password) {

            return bCrypt.compareSync(password, userpass);

        }

        User.findOne({
            where: {
                email: email
            }
        }).then(function(user) {

            if (!user) {

                return done(null, false, {
                    message: 'Email does not exist'
                });

            }

            if (!isValidPassword(user.password, password)) {

                return done(null, false, {
                    message: 'Incorrect password.'
                });

            }


            var userinfo = user.get();
            return done(null, userinfo);


        }).catch(function(err) {

            console.log("Error:", err);

            return done(null, false, {
                message: 'Something went wrong with your Signin'
            });

        });


    }

));

Bei dieser Strategie vergleicht die Funktion isValidPassword das eingegebene Passwort mit der Vergleichsmethode bCrypt, da wir unser Passwort bei bcrypt gespeichert haben.

Wenn die Angaben korrekt sind, wird unser Benutzer angemeldet.

Gehen Sie nun zu routes/auth.js und fügen Sie die Route zum Posten zu /signin hinzu.

app.post('/signin', passport.authenticate('local-signin', {
        successRedirect: '/dashboard',

        failureRedirect: '/signin'
    }

));

Ihre routes/auth.js sollten so aussehen, wenn Sie fertig sind.

var authController = require('../controllers/authcontroller.js');


module.exports = function(app, passport) {


    app.get('/signup', authController.signup);


    app.get('/signin', authController.signin);


    app.post('/signup', passport.authenticate('local-signup', {
            successRedirect: '/dashboard',

            failureRedirect: '/signup'
        }

    ));


    app.get('/dashboard', isLoggedIn, authController.dashboard);



    app.get('/logout', authController.logout);


    app.post('/signin', passport.authenticate('local-signin', {
            successRedirect: '/dashboard',

            failureRedirect: '/signin'
        }

    ));


    function isLoggedIn(req, res, next) {

        if (req.isAuthenticated())

            return next();

        res.redirect('/signin');

    }

}

Führen Sie nun die App aus und versuchen Sie, sich anzumelden. Sie sollten sich mit allen Details anmelden können, die Sie bei der Anmeldung verwendet haben, und Sie werden zu http://localhost:5000/dashboard/ weitergeleitet.

Herzlichen Glückwunsch, wenn Sie es bis zum Ende dieses Tutorials geschafft haben! Wir haben Sequelize und Passport erfolgreich mit einer MySQL-Datenbank verwendet.

Den vollständigen Code für dieses Tutorial finden Sie auf GitHub.

Abschluss

Damit ist unser Tutorial zur Verwendung von Passport zur Authentifizierung von Benutzern mit Sequelize und MySQL abgeschlossen. Sequelize ist ein wirklich nützliches ORM für den Umgang mit MySQL bei der Verwendung von Node. Ich persönlich fand es sehr nützlich, und Sie sollten auf jeden Fall in Betracht ziehen, es in Ihrer nächsten Node-MySQL-App zu verwenden.

1	{
2
3	"development": {
4
5	"username": "root",
6
7	"password": null,
8
9	"database": "sequelize_passport",
10
11	"host": "127.0.0.1",
12
13	"dialect": "mysql"
14
15	},
16
17	"test": {
18
19	"username": "",
20
21	"password": null,
22
23	"database": "",
24
25	"host": "",
26
27	"dialect": "mysql"
28
29	},
30
31	"production": {
32
33	"username": "",
34
35	"password": null,
36
37	"database": "",
38
39	"host": "127.0.0.1",
40
41	"dialect": "mysql"
42
43	}
44
45	}

1	module.exports = function(sequelize, Sequelize) {
2
3	var User = sequelize.define('user', {
4
5	id: {
6	autoIncrement: true,
7	primaryKey: true,
8	type: Sequelize.INTEGER
9	},
10
11	firstname: {
12	type: Sequelize.STRING,
13	notEmpty: true
14	},
15
16	lastname: {
17	type: Sequelize.STRING,
18	notEmpty: true
19	},
20
21	username: {
22	type: Sequelize.TEXT
23	},
24
25	about: {
26	type: Sequelize.TEXT
27	},
28
29	email: {
30	type: Sequelize.STRING,
31	validate: {
32	isEmail: true
33	}
34	},
35
36	password: {
37	type: Sequelize.STRING,
38	allowNull: false
39	},
40
41	last_login: {
42	type: Sequelize.DATE
43	},
44
45	status: {
46	type: Sequelize.ENUM('active', 'inactive'),
47	defaultValue: 'active'
48	}
49
50
51	});
52
53	return User;
54
55	}

1	User.findOne({
2	where: {
3	email: email
4	}
5	}).then(function(user) {
6
7	if (user)
8
9	{
10
11	return done(null, false, {
12	message: 'That email is already taken'
13	});
14
15	} else
16
17	{
18
19	var userPassword = generateHash(password);
20
21	var data =
22
23	{
24	email: email,
25
26	password: userPassword,
27
28	firstname: req.body.firstname,
29
30	lastname: req.body.lastname
31
32	};
33
34
35	User.create(data).then(function(newUser, created) {
36
37	if (!newUser) {
38
39	return done(null, false);
40
41	}
42
43	if (newUser) {
44
45	return done(null, newUser);
46
47	}
48
49	});
50
51	}
52
53	});

1	//load bcrypt
2	var bCrypt = require('bcrypt-nodejs');
3
4
5	module.exports = function(passport, user) {
6
7
8	var User = user;
9
10	var LocalStrategy = require('passport-local').Strategy;
11
12
13	passport.use('local-signup', new LocalStrategy(
14
15	{
16
17	usernameField: 'email',
18
19	passwordField: 'password',
20
21	passReqToCallback: true // allows us to pass back the entire request to the callback
22
23	},
24
25
26
27	function(req, email, password, done) {
28
29	var generateHash = function(password) {
30
31	return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null);
32
33	};
34
35
36
37	User.findOne({
38	where: {
39	email: email
40	}
41	}).then(function(user) {
42
43	if (user)
44
45	{
46
47	return done(null, false, {
48	message: 'That email is already taken'
49	});
50
51	} else
52
53	{
54
55	var userPassword = generateHash(password);
56
57	var data =
58
59	{
60	email: email,
61
62	password: userPassword,
63
64	firstname: req.body.firstname,
65
66	lastname: req.body.lastname
67
68	};
69
70	User.create(data).then(function(newUser, created) {
71
72	if (!newUser) {
73
74	return done(null, false);
75
76	}
77
78	if (newUser) {
79
80	return done(null, newUser);
81
82	}
83
84	});
85
86	}
87
88	});
89
90	}
91
92	));
93
94	}

1	var express = require('express')
2	var app = express()
3	var passport = require('passport')
4	var session = require('express-session')
5	var bodyParser = require('body-parser')
6	var env = require('dotenv').load()
7	var exphbs = require('express-handlebars')
8
9
10	//For BodyParser
11	app.use(bodyParser.urlencoded({
12	extended: true
13	}));
14	app.use(bodyParser.json());
15
16
17	// For Passport
18	app.use(session({
19	secret: 'keyboard cat',
20	resave: true,
21	saveUninitialized: true
22	})); // session secret
23	app.use(passport.initialize());
24	app.use(passport.session()); // persistent login sessions
25
26
27	//For Handlebars
28	app.set('views', './app/views')
29	app.engine('hbs', exphbs({
30	extname: '.hbs'
31	}));
32	app.set('view engine', '.hbs');
33
34
35
36	app.get('/', function(req, res) {
37
38	res.send('Welcome to Passport with Sequelize');
39
40	});
41
42	//Models
43	var models = require("./app/models");
44
45	//Routes
46
47	var authRoute = require('./app/routes/auth.js')(app);
48
49
50	//load passport strategies
51
52	require('./app/config/passport/passport.js')(passport, models.user);
53
54
55	//Sync Database
56
57	models.sequelize.sync().then(function() {
58
59	console.log('Nice! Database looks fine')
60
61
62	}).catch(function(err) {
63
64	console.log(err, "Something went wrong with the Database Update!")
65
66	});
67
68
69	app.listen(5000, function(err) {
70
71	if (!err)
72
73	console.log("Site is live");
74
75	else console.log(err)
76
77	});