Sequelize je ORM Node.js založený na slibech. Lze jej použít s PostgreSQL, MySQL, MariaDB, SQLite a MSSQL. V tomto tutoriálu budeme implementovat ověřování pro uživatele webové aplikace. A k implementaci registrace a přihlašování uživatelů použijeme Passport, oblíbený ověřovací middleware pro Node, spolu se Sequelize a MySQL.
Začínáme
Ujistěte se, že máte na svém počítači nainstalováno následující:
- Uzel
- MySQL
V tomto tutoriálu budeme používat Node.js společně s Express, takže můžeme pokračovat a začít instalovat, co potřebujeme.
Krok 1:Vygenerujte soubor package.json
Vytvořte adresář pro svou aplikaci. V tomto adresáři spusťte toto z terminálu nebo příkazového řádku:
npm init
Tím se inicializuje Správce závislostí npm. Zobrazí se řada výzev, kterými rychle projdeme.
- Zadejte název aplikace bez mezer a stisknutím klávesy Enter zadejte název.
- Stisknutím klávesy Enter zobrazíte 'verzi'.
- Pro „popis“ v tomto tutoriálu napíšeme jako popis „Using Passport with Sequelize and MySQL“ a stiskneme Enter. Toto může být také prázdné.
- Pro „vstupní bod (index.js)“ zadejte server.js a stiskněte Enter.
- Pro testovací příkaz stiskněte Enter.
- Pro „git repository“ můžete zadat git repo, kde se vaše aplikace nachází, pokud nějaké máte, nebo stačí stisknout Enter a nechat toto prázdné.
- V části Klíčová slova stiskněte klávesu Enter.
- Chcete-li zadat 'autor', stiskněte Enter nebo předtím, než to uděláte, zadejte své jméno.
- Pro „licenci“ stiskněte Enter.
- Pro „(Je to v pořádku)“ toto ukazuje, jak bude váš package.json vypadat. Napište Yes a stiskněte Enter.
Krok 2:Instalace závislostí
Hlavní závislosti tohoto kurzu jsou:
- Expresní
- Sequelizovat
- MySQL
- Pas
- Místní strategie pasu
- Analyzátor těla
- Expresní relace
- Bcrypt Nodejs
- Řídítka Express pro zobrazení
Chcete-li je nainstalovat, z terminálu nebo příkazového řádku spusťte následující postup po sobě.
npm install express --savenpm install sequelize --savenpm install mysql --savenpm install passport --savenpm install passport-local --savenpm install body-parser --savenpm install express-session --savenpm install bcrypt-nodejs - -savenpm nainstalovat expresní řídítka --save
Pokud pro tento projekt používáte Git:
Ve složce projektu vytvořte soubor .gitignore.
Přidejte tento řádek do souboru .gitignore.
node_modules
Krok 3:Nastavení aplikace
Nyní vytvoříme soubor serveru. Toto bude hlavní soubor nazvaný, když zadáte následující:
spuštění npm
Tím se aplikace spustí. Aplikaci můžete také spustit zadáním node server.js.
node server.js
Poté v naší složce projektu vytvoříme nový soubor a pojmenujeme jej server.js .
Uvnitř server.js soubor, vložíme následující:
var express =require('express');var app =express();app.get('/', function(req, res) { res.send('Vítejte ve službě Passport with Sequelize');});app.listen(5000, function(err) { if (!err) console.log("Stránka je aktivní"); else console.log(err)}); První řádek přiřadí expresní modul k proměnné express. Poté inicializujeme express a pojmenujeme ji jako proměnnou:app.
Poté aplikaci necháme naslouchat na portu 5000 . Můžete si vybrat libovolné volné číslo portu na vašem počítači.
Dále zavoláme app.get() expresní směrovací funkce, která odpovídá „Vítejte v Passport with Sequelize“, když je na „/“ odeslán požadavek GET.
Chcete-li otestovat na svém počítači, spusťte toto ze složky projektu:
node server.js
Pokud při návštěvě http://localhost:5000/ uvidíte text „Welcome to Passport with Sequelize“, gratulujeme! V opačném případě zkontrolujte, zda jste udělali vše přesně tak, jak je psáno výše.
Dále importujeme některé potřebné moduly, jako je pas, expresní relace a analyzátor těla.
Za var app = express() přidáme následující řádky:
var passport =require('passport')var session =require('express-session')var bodyParser =require('body-parser') V prvních dvou řádcích importujeme modul passport a express-session, přičemž oba potřebujeme k ověření.
Poté importujeme modul analýzy těla. Tím se extrahuje celá část těla příchozího požadavku a zobrazí se ve formátu, se kterým se snáze pracuje. V tomto případě použijeme formát JSON.
Aby naše aplikace mohla používat analyzátor těla, přidáme tyto řádky několik mezer pod řádky importu:
//For BodyParserapp.use(bodyParser.urlencoded({ extended:true }));app.use(bodyParser.json()); Dále inicializujeme pas a expresní relaci a pasovou relaci a přidáme je jako middleware. To provedeme přidáním těchto řádků za řádek importu bodyParser.
// Pro Passportapp.use(session({ secret:'keyboard cat',save:true, saveUninitialized:true})); // session secretapp.use(passport.initialize());app.use(passport.session()); // trvalé relace přihlášení Nyní začneme pracovat na skutečné autentizaci.
Provedeme to ve čtyřech krocích:
- Nastavte Sequelize pomocí MySQL.
- Vytvořte uživatelský model.
- Nastavte zobrazení.
- Napište pasovou strategii.
1. Nastavení Sequelize pomocí MySQL
Nejprve vytvoříme databázi v MySQL. Dejte tomu svůj preferovaný název. Pro účely tohoto tutoriálu vytvořte databázi s názvem sequelize_passport v MySQL.
Poté nastavíme konfiguraci pro zpracování podrobností DB.
Nejprve importujme modul dot-env pro práci s proměnnými prostředí.
Spusťte to v kořenové složce projektu:
instalace npm --save dotenv
Poté jej importujeme do hlavního souboru serveru, server.js, hned pod ostatními importy.
var env =require('dotenv').load(); Dále vytvoříme soubor v naší složce projektu a pojmenujeme ho .env.
Tento další krok je volitelný, pokud nepoužíváte Git:
Přidáme soubor .env do vašeho souboru .gitignore.
Váš soubor .gitignore by měl vypadat takto:
node_modules.env
Poté přidáme naše prostředí do souboru .env přidáním tohoto řádku:
NODE_ENV='development'
Poté vytvoříme soubor config.json, který bude Sequelize používat ke správě různých prostředí.
První věc, kterou musíte udělat, je vytvořit složku s názvem config v naší složce projektu. Uvnitř této složky vytvoříme config. json soubor. Tento soubor by měl být ignorován, pokud posíláte do úložiště. Chcete-li to provést, přidejte do souboru .gitignore následující kód:
config/config.json
Poté vložíme následující kód do našeho souboru config.json.
{ "development":{ "username":"root", "password":null, "database":"sequelize_passport", "host":"127.0.0.1", "dialect":"mysql" }, "test":{ "username":"", "password":null, "database":"", "host":"", "dialekt":"mysql" }, "production":{ "username":"", "heslo":null, "database":"", "hostitel":"127.0.0.1", "dialekt":"mysql" }} Nezapomeňte nahradit hodnoty ve vývojovém bloku výše podrobnostmi ověření vaší databáze.
Dále nainstalujeme sequelize s npm. Chcete-li to provést, spusťte v kořenové složce projektu následující příkaz:
instalace npm --save sequelize
Nyní je čas vytvořit modely složka.
Nejprve vytvoříme adresář s názvem app v naší složce projektu.
Uvnitř aplikace vytvoříme novou složku s názvemmodely a vytvořte nový soubor s názvem index.js v modelech složka.
Do souboru index.js vložíme níže uvedený kód.
"use strict";var fs =require("fs");var path =required("cesta");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) &&(soubor !=="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; Tento soubor se používá k importu všech modelů, které umísťujeme do modelů složku a exportovat je.
Abychom otestovali, že je vše v pořádku, přidáme to do našeho souboru server.js.
//Modelsvar models =require("./app/models");//Sync Databasemodels.sequelize.sync().then(function() { console.log('Pěkné! Databáze vypadá dobře')}) .catch(function(err) { console.log(err, "Něco se pokazilo s aktualizací databáze!")}); Zde importujeme modely a poté zavoláme funkci synchronizace Sequelize.
Spusťte toto a zjistěte, zda je vše v pořádku:
node server.js
Pokud se zobrazí zpráva "Stránka je aktivní Pěkná! Databáze vypadá dobře", pak jste úspěšně nastavili Sequelize.
Pokud ne, projděte si prosím pečlivě výše uvedené kroky a pokuste se problém vyřešit pomocí nápovědy.
2. Vytvořte uživatelský model
Další věcí, kterou uděláme, je vytvoření uživatelského modelu, což je v podstatě uživatelská tabulka. To bude obsahovat základní informace o uživateli.
V našich modelech složku, vytvoříme soubor a pojmenujeme jej user.js . Úplná cesta k tomuto souboru by měla být app/models/user.js.
Otevřete soubor user.js a přidejte následující kód:
module.exports =function(sequelize, Sequelize) { var User =sequelize.define('user', { id:{ autoIncrement:true, primaryKey:true, type:Sequelize.INTEGER }, jméno:{ type:Sequelize .STRING, notEmpty:true }, příjmení:{ type:Sequelize.STRING, notEmpty:true }, uživatelské jméno:{ type:Sequelize.TEXT }, o:{ type:Sequelize.TEXT }, e-mail:{ type:Sequelize.STRING , validate:{ isEmail:true } }, heslo:{ type:Sequelize.STRING, allowNull:false }, last_login:{ type:Sequelize.DATE }, status:{ type:Sequelize.ENUM('active', 'inactive' ), defaultValue:'aktivní' } }); vrátit uživatele;} Nyní spusťte:
node server.js
Měli byste vidět známé „Web je aktivní. Skvělé! Databáze vypadá dobře. To znamená, že naše modely Sequelize byly úspěšně synchronizovány, a pokud zkontrolujete svou databázi, měli byste vidět tabulku uživatelů se zadanými sloupci.
3:Nastavení zobrazení
Nejprve vytvoříme zobrazení pro registraci a zapojíme jej.
První věc, kterou musíte udělat, je importovat modul expresních řídítek, který používáme pro zobrazení v tomto tutoriálu.
Přidejte tento řádek do hlavního počátečního souboru server.js.
var exphbs = require('express-handlebars')
Váš importní blok by měl v tomto okamžiku vypadat takto.
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') Dále přidáme následující řádky do našeho souboru server.js.
//For Handlebarsapp.set('views', './app/views')app.engine('hbs', exphbs({ extname:'.hbs'}));app.set('view engine ', '.hbs'); Nyní v naší složce aplikace vytvoříme tři složky s názvem views, ovladače a trasy .
Ve složce zobrazení vytvoříme soubor s názvem signup. hbs a vložte do něj níže uvedený kód.
Poté v našich ovladačích vytvoříme nový soubor a pojmenujeme ho authcontroller.js.
Do tohoto souboru vložíme následující ovladač pro trasu registrace, kterou za chvíli vytvoříme.
var exports =module.exports ={}exports.signup =function(req, res) { res.render('signup');} Dále vytvoříme trasu pro přihlášení. Ve složce tras vytvoříme nový soubor s názvem auth.js a poté v tomto souboru importujeme ověřovací řadič a definujeme cestu registrace.
var authController =require('../controllers/authcontroller.js');module.exports =function(app) { app.get('/signup', authController.signup);} Nyní tuto trasu naimportujeme do našeho server.js a předáme aplikaci jako argument.
Na serveru po importu modelů přidejte tyto řádky:
//Routesvar authRoute =require('./app/routes/auth.js')(app); Spusťte toto:
node server.js
Nyní navštivte http://localhost:5000/signup a uvidíte registrační formulář.
Zopakujeme kroky pro přihlašovací formulář. Stejně jako předtím vytvoříme soubor s názvem signin.hbs v naší složce zobrazení a vložte do ní následující kód HTML:
Poté přidejte ovladač pro přihlášení do app/controllers/authcontroller.js.
exports.signin =function(req, res) { res.render('signin');} Poté v app/routes/auth.js , přidáme trasu pro přihlášení takto:
app.get('/signin', authController.signin);
Nyní, když spustíte:
node server.js
a navštivte http://localhost:5000/signin/, měli byste vidět přihlašovací formulář.
Posledním a hlavním krokem je sepsání našich pasových strategií.
4. Napište strategii pasu
V app/config vytvoříme novou složku s názvem passport.
Poté v naší nové složce app/config/passport vytvoříme nový soubor a pojmenujeme ho passport.js . Tento soubor bude obsahovat naše pasové strategie.
V passport.js , budeme používat uživatelský model a pas.
Nejprve importujeme bcrypt které potřebujeme k zabezpečení hesel.
var bCrypt = require('bcrypt-nodejs');
Poté přidáme blok module.exports takto:
module.exports =function(passport, user) {} Uvnitř tohoto bloku inicializujeme passport-local strategii a uživatelský model, který bude předán jako argument. Zde je návod, jak to udělat:
module.exports =function(passport, user) { var User =user; var LocalStrategy =require('passport-local').Strategy;} Potom definujeme naši vlastní strategii pomocí naší instance LocalStrategy takto:
passport.use('local-signup', new LocalStrategy( { usernameField:'email', passwordField:'password', passReqToCallback:true // nám umožňuje předat zpět celý požadavek zpětnému volání },)); Nyní jsme uvedli, jaký požadavek (req ) jsou pole našeho uživatelského jménaField a passwordField (proměnné pasu).
Poslední proměnná passReqToCallback nám umožňuje předat celý požadavek zpětnému volání, což je užitečné zejména při registraci.
Za poslední čárku přidáme tuto funkci zpětného volání.
Funkce (požadavek, e-mail, heslo, hotovo) { } V této funkci se postaráme o uložení údajů o uživateli.
Nejprve do funkce zpětného volání přidáme naši funkci generování hashovaného hesla.
var createHash =function(heslo) { return bCrypt.hashSync(heslo, bCrypt.genSaltSync(8), null); }; Poté pomocí uživatelského modelu Sequelize, který jsme dříve inicializovali jako Uživatel , zkontrolujeme, zda uživatel již existuje, a pokud ne, přidáme ho.
User.findOne({ kde:{ email:email }}).then(function(user) { if (user) { return done(null, false, { message:'Tento email je již přijat' }); } else { var userPassword =vygenerovatHash(heslo); var data ={ email:email, heslo:userPassword, jméno: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() je metoda Sequelize pro přidávání nových položek do databáze. Všimněte si, že hodnoty v data objekt se získá z req.body objekt, který obsahuje vstup z našeho registračního formuláře.
Váš passport.js by měl vypadat takto:
//načíst bcryptvar 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 // nám umožňuje předat zpět celý požadavek zpětnému volání }, function(req, email, heslo, hotovo) { var vygenerovatHash =function(heslo) { return bCrypt.hashSync(heslo, bCrypt.genSaltSync(8), null); }; User.findOne({ kde:{ email:email } }).then(funkce (user) { if (user) { return done(null, false, { message:'Tento email je již přijat' }); } else { var userPassword =generationHash(password); var data ={ email:email, password:uživatelské heslo, jméno: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); } }); } }); } ));} Nyní naimportujeme strategii do server.js.
Za tímto účelem přidáme tyto řádky pod import tras v server.js.
//load passport strategysrequire('./app/config/passport/passport.js')(passport, models.user); Váš server.js by měl v tuto chvíli vypadat takto:
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 BodyParserapp.use(bodyParser.urlencoded({ extend:true}));app.use(bodyParser.json( ));// For Passportapp.use(session({ secret:'keyboard cat', resave:true, saveUninitialized:true})); // session secretapp.use(passport.initialize());app.use(passport.session()); // trvalé relace přihlášení//For Handlebarsapp.set('views', './app/views')app.engine('hbs', exphbs({ extname:'.hbs'}));app.set(' view engine', '.hbs');app.get('/', function(req, res) { res.send('Vítejte v Passport with Sequelize');});//Modelsvar models =require(". /app/models");//Routesvar authRoute =require('./app/routes/auth.js')(app);//načíst strategie pasu ('./app/config/passport/passport.js') (passport, models.user);//Sync Databasemodels.sequelize.sync().then(function() { console.log('Pěkné! Databáze vypadá dobře')}).catch(function(err) { console.log (err, "Něco se pokazilo s aktualizací databáze!")});app.listen(5000, function(err) { if (!err) console.log("Stránka je aktivní"); else console.log(err )}); Nyní skutečně použijeme strategii na naše /signup trasa.
Děláme to takto:
Nejprve přejdeme na app/routes/auth.js a přidejte trasu pro zveřejňování, abyste se mohli zaregistrovat takto.
app.post('/signup', passport.authenticate('local-signup', { successRedirect:'/dashboard', failureRedirect:'/signup' })); Protože potřebujeme pas, musíme ho předat této metodě. Můžeme importovat pas v tomto skriptu nebo jej předat ze server.js. Udělejme to druhé.
Upravte funkci exportovanou v tomto souboru app/routes/auth.js mít pas jako parametr. Kód v app/routes/auth.js by měl po vaší úpravě vypadat takto.
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' } ));} Poté v server.js , upravíme import tras a přidáme pas jako argument takto:
var authRoute = require('./app/routes/auth.js')(app,passport);
Nyní přejděte na přihlašovací adresu URL http://localhost:5000/signup/ a zkuste se zaregistrovat.
Když se pokusíte zaregistrovat, zobrazí se chyba „Nepodařilo se serializovat uživatele do relace Je to proto, že passport musí v relaci uložit ID uživatele a používá to ke správě získávání údajů o uživateli, když je to potřeba.
Abychom to vyřešili, budeme implementovat funkce serializace i deserializace pasu v našem app/config/passport/passport.js soubor.
Nejprve přidáme funkci serializace. V této funkci uložíme ID uživatele na relaci.
Za tímto účelem přidáváme následující řádky pod inicializaci místní strategie.
//serializepassport.serializeUser(function(user, done) { done(null, user.id);}); Dále implementujeme funkci deserializace. Přidejte funkci těsně pod funkci serializace.
// deserializovat uživatele passport.deserializeUser(function(id, done) { User.findById(id).then(function(user) { if (user) { done(null, user.get()); } else { done(user.errors, null); } });});
Ve výše uvedené funkci deserializace používáme Sequelize findById slib, že uživatele získá, a pokud bude úspěšný, vrátí se instance modelu Sequelize. K získání objektu User z této instance používáme funkci Sequelize getter takto:user.get() .
Nyní spusťte znovu:
node server.js
A zkuste se přihlásit. Hurá, pokud máte "Cannot GET /dashboard"! Znamená to, že naše ověření bylo úspěšné. Nezapomeňte, že jsme v naší metodě passport.authenticate v routes/auth.js přesměrovali na /dashboard .
Nyní pojďme do toho a přidejte tuto trasu. Poté přidejte middleware, abyste zajistili, že stránka bude přístupná pouze tehdy, když je uživatel přihlášen do relace.
V naší aplikaci/zobrazení vytvoříme nový soubor s názvem dashboard.hbs a přidejte do něj následující kód HTML.
Pas s funkcí Sequelize Dashboard
Hurá! jste přihlášeni.
V routes/auth.js , přidáme tento řádek do module.exports blokovat:
app.get('/dashboard',authController.dashboard);
Dále přejdeme na app/controllers/authController.js a přidejte ovladač na palubní desce.
exports.dashboard =function(req, res) { res.render('dashboard');} Váš AuthController.js by měl vypadat takto:
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');} Nyní spusťte aplikaci znovu a zkuste se zaregistrovat pomocí jiné e-mailové adresy, než kterou jste používali dříve. Budete náležitě přesměrováni na /dashboard trasa.
Ale /dashboard není chráněnou cestou, což znamená, že i když uživatel není přihlášen, může ji vidět. Toto nechceme, proto přidáme /logout route k odhlášení uživatele a poté k ochraně trasy a testování toho, co jsme udělali.
Pojďme na to:
V routes/auth.js přidáme tento řádek:
app.get('/logout',authController.logout);
Poté přidáme ovladač do souboru app/controllers/authController.js.
exports.logout =function(req, res) { req.session.destroy(function(err) { res.redirect('/'); }); } Nyní spusťte aplikaci znovu a zaregistrujte se pomocí jiné e-mailové adresy.
Poté navštivte http://localhost:5000/logout a odhlaste uživatele. Nyní navštivte http://localhost:5000/dashboard.
Všimnete si, že je docela přístupný. Pojďme přidat vlastní middleware pro ochranu této trasy.
Za tímto účelem otevřeme app/routes/auth.js a přidejte tuto funkci do module.exports bloku, pod všemi ostatními řádky kódu.
funkce isLoggedIn(req, res, next) { if (req.isAuthenticated()) return next(); res.redirect('/signin');} Poté upravíme obslužnou rutinu trasy řídicího panelu tak, aby vypadala takto:
app.get('/dashboard',isLoggedIn, authController.dashboard);
Když nyní aplikaci znovu spustíte a pokusíte se navštívit stránku řídicího panelu a nejste přihlášeni, měli byste být přesměrováni na přihlašovací stránku.
Páni! Je čas implementovat poslední část:přihlášení.
Nejprve přidáme novou místní strategii pro přihlašování do app/config/passport/passport.js .
//LOCAL SIGNINpassport.use('local-signin', new LocalStrategy( { // ve výchozím nastavení používá místní strategie uživatelské jméno a heslo, přepíšeme e-mailem usernameField:'email', passwordField:'password', passReqToCallback :true // nám umožňuje předat zpět celý požadavek zpětnému volání }, function(req, email, password, done) { var User =user; var isValidPassword =function(userpass, password) { return bCrypt.compareSync(heslo, userpass); } User.findOne({ kde:{ email:email } }).then(function(user) { if (!user) { return done(null, false, { message:'E-mail neexistuje' }); } if (!isValidPassword(uživatel.heslo, heslo)) { return done(null, false, { zpráva:'Nesprávné heslo.' }); } var userinfo =uživatel. dostat(); return done(null, userinfo); }).catch(function(err) { console.log("Error:", err); return done(null, false, { message:'Něco se pokazilo s vaším přihlášením' }); }); }));
V této strategii isValidPassword funkce porovnává zadané heslo s metodou porovnání bCrypt, protože jsme heslo uložili pomocí bcrypt .
Pokud jsou údaje správné, náš uživatel bude přihlášen.
Nyní přejděte na routes/auth.js a přidejte trasu pro odeslání do / přihlášení.
app.post('/signin', passport.authenticate('local-signin', { successRedirect:'/dashboard', failureRedirect:'/signin' })); Vaše routes/auth.js by po dokončení měly vypadat takto.
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'); }} Nyní spusťte aplikaci a zkuste se přihlásit. Měli byste být schopni se přihlásit pomocí jakýchkoli údajů, které jste použili při registraci, a budete přesměrováni na http ://localhost:5000/dashboard/.
Gratulujeme, pokud jste se dostali až na konec tohoto tutoriálu! Úspěšně jsme použili Sequelize a Passport s databází MySQL.
Úplný kód pro tento tutoriál najdete na GitHubu.