Sequelize to oparty na obietnicach ORM Node.js. Może być używany z PostgreSQL, MySQL, MariaDB, SQLite i MSSQL. W tym samouczku zaimplementujemy uwierzytelnianie dla użytkowników aplikacji internetowej. Użyjemy Passport, popularnego oprogramowania pośredniczącego do uwierzytelniania dla Node, wraz z Sequelize i MySQL, aby zaimplementować rejestrację i logowanie użytkownika.
Rozpoczęcie pracy
Upewnij się, że masz zainstalowane na swoim komputerze następujące elementy:
- Węzeł
- MySQL
W tym samouczku będziemy używać Node.js razem z Express, więc zaczynamy instalować to, czego potrzebujemy.
Krok 1:Wygeneruj plik package.json
Utwórz katalog dla swojej aplikacji. W tym katalogu uruchom to z terminala lub wiersza poleceń:
npm init
To inicjuje menedżera zależności npm. Spowoduje to wyświetlenie serii podpowiedzi, przez które szybko przejdziemy.
- Wpisz nazwę swojej aplikacji bez spacji i naciśnij Enter, aby wyświetlić „nazwę”.
- Naciśnij Enter, aby wyświetlić „wersję”.
- W przypadku „opisu” w tym samouczku wpiszemy „Korzystanie z usługi Passport z Sequelize i MySQL” jako opis i naciśnij klawisz Enter. To też może być puste.
- Dla „punktu wejścia (index.js)” wpisz server.js i naciśnij Enter.
- W przypadku „polecenia testowego” naciśnij klawisz Enter.
- W przypadku „repozytorium git” możesz wpisać repozytorium git, w którym znajduje się Twoja aplikacja, jeśli takie posiadasz, lub po prostu naciśnij Enter, aby pozostawić to puste.
- W przypadku „Słowa kluczowe” naciśnij Enter.
- W przypadku „autora” naciśnij Enter lub wpisz swoje imię i nazwisko, zanim to zrobisz.
- W przypadku „licencja” naciśnij Enter.
- Dla „(Czy to w porządku )” pokazuje, jak będzie wyglądał Twój plik package.json. Wpisz Tak i naciśnij Enter.
Krok 2:Zainstaluj zależności
Główne zależności tego samouczka to:
- Ekspres
- Sequelizuj
- MySQL
- Paszport
- Paszportowa strategia lokalna
- Parser ciała
- Sesja ekspresowa
- Bcrypt Nodejs
- Ekspresowe uchwyty do widoków
Aby je zainstalować, z terminala lub wiersza poleceń uruchom następujące po sobie.
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
Jeśli używasz Git w tym projekcie:
W folderze projektu utwórz plik .gitignore.
Dodaj tę linię do pliku .gitignore.
node_modules
Krok 3:skonfiguruj aplikację
Teraz tworzymy plik serwera. Będzie to główny plik wywoływany, gdy wpiszesz:
npm start
To uruchamia aplikację. Możesz również uruchomić aplikację, wpisując node server.js.
node server.js
Następnie w naszym folderze projektu tworzymy nowy plik i nazywamy go server.js .
Wewnątrz pliku server.js plik, wklejamy następujące:
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)
}); Pierwszy wiersz przypisuje moduł express do zmiennej express. Następnie inicjujemy express i nazywamy ją zmienną:app.
Następnie sprawiamy, że aplikacja nasłuchuje na porcie 5000 . Możesz wybrać dowolny wolny numer portu na swoim komputerze.
Następnie wywołujemy app.get() ekspresowa funkcja routingu, która odpowiada komunikatem „Welcome to Passport with Sequelize”, gdy żądanie GET zostanie wysłane do „/”.
Aby przetestować na swoim komputerze, uruchom to z poziomu folderu projektu:
node server.js
Jeśli zobaczysz tekst „Welcome to Passport with Sequelize” podczas odwiedzania http://localhost:5000/, to gratulacje! W przeciwnym razie sprawdź, czy zrobiłeś wszystko dokładnie tak, jak opisano powyżej.
Następnie importujemy niektóre potrzebne nam moduły, takie jak paszport, sesja ekspresowa i parser ciała.
Po var app = express() dodajemy następujące wiersze:
var passport = require('passport')
var session = require('express-session')
var bodyParser = require('body-parser') W pierwszych dwóch wierszach importujemy moduł paszportu i sesję ekspresową, które są potrzebne do obsługi uwierzytelniania.
Następnie importujemy moduł body-parser. To wyodrębnia całą część treści przychodzącego żądania i udostępnia ją w formacie, z którym łatwiej się pracuje. W takim przypadku użyjemy formatu JSON.
Aby nasza aplikacja mogła korzystać z parsera treści, dodajemy te wiersze kilka spacji poniżej wierszy importu:
//For BodyParser
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json()); Następnie inicjujemy sesję paszportową i ekspresową oraz sesję paszportową i dodajemy je jako oprogramowanie pośredniczące. Robimy to, dodając te linie kilka spacji po linii importu bodyParser.
// 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 Rozpoczniemy teraz pracę nad rzeczywistym uwierzytelnianiem.
Zrobimy to w czterech krokach:
- Skonfiguruj Sequelize z MySQL.
- Utwórz model użytkownika.
- Skonfiguruj widoki.
- Napisz strategię paszportową.
1. Skonfiguruj sekwencjonowanie za pomocą MySQL
Najpierw tworzymy bazę danych w MySQL. Nadaj mu swoje preferowane imię. Na potrzeby tego samouczka utwórzmy bazę danych o nazwie sequelize_passport w MySQL.
Następnie ustawiamy konfigurację do obsługi szczegółów DB.
Najpierw zaimportujmy moduł dot-env do obsługi zmiennych środowiskowych.
Uruchom to w głównym folderze projektu :
npm install --save dotenv
Następnie importujemy go do głównego pliku serwera, server.js, tuż pod innymi importami.
var env = require('dotenv').load(); Następnie tworzymy plik w naszym folderze projektu i nazywamy go .env.
Następny krok do wykonania jest opcjonalny, jeśli nie używasz Git:
Dodamy plik .env do Twojego pliku .gitignore.
Twój plik .gitignore powinien wyglądać tak:
node_modules .env
Następnie dodajemy nasze środowisko do pliku .env, dodając następującą linię:
NODE_ENV='development'
Następnie tworzymy plik config.json, który będzie używany przez Sequelize do zarządzania różnymi środowiskami.
Pierwszą rzeczą do zrobienia jest utworzenie folderu o nazwie config w naszym folderze projektu. Wewnątrz tego folderu tworzymy config. json plik. Ten plik powinien zostać zignorowany, jeśli wysyłasz do repozytorium. Aby to zrobić, dodaj następujący kod do swojego .gitignore:
config/config.json
Następnie wklejamy następujący kod do naszego pliku config.json.
{
"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"
}
} Pamiętaj, aby zastąpić wartości w powyższym bloku programistycznym danymi uwierzytelniającymi bazę danych.
Następnie instalujemy sequelize z npm. Aby to zrobić, uruchom następujące polecenie w folderze głównym projektu:
npm install --save sequelize
Teraz czas na stworzenie modeli teczka.
Najpierw tworzymy katalog o nazwie app w naszym folderze projektu.
Wewnątrz aplikacji folder, tworzymy nowy folder o nazwie modele i utwórz nowy plik o nazwie index.js w modelach folder.
Wewnątrz pliku index.js wklejamy poniższy kod.
"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; Ten plik służy do importowania wszystkich modeli, które umieszczamy w modelach folderu i wyeksportuj je.
Aby sprawdzić, czy wszystko jest w porządku, dodajemy to do naszego pliku server.js.
//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!")
}); Tutaj importujemy modele, a następnie wywołujemy funkcję synchronizacji Sequelize.
Uruchom to, aby sprawdzić, czy wszystko jest w porządku:
node server.js
Jeśli pojawi się komunikat „Strona jest aktywna, ładnie! Baza danych wygląda dobrze”, oznacza to, że pomyślnie skonfigurowałeś Sequelize.
Jeśli nie, dokładnie wykonaj powyższe kroki i spróbuj rozwiązać problem z pomocą.
2. Utwórz model użytkownika
Następną rzeczą, jaką zamierzamy zrobić, jest stworzenie modelu użytkownika, który w zasadzie jest tabelą użytkowników. Zawiera podstawowe informacje o użytkowniku.
W naszych modelach folderu, tworzymy plik i nazywamy go user.js . Pełna ścieżka do tego pliku powinna wyglądać tak:app/models/user.js.
Otwórz plik user.js i dodaj następujący kod:
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;
} Teraz uruchom:
node server.js
Powinieneś zobaczyć znajomy komunikat „Witryna jest aktywna. Świetnie! Baza danych wygląda dobrze. " wiadomość. Oznacza to, że nasze modele Sequelize zostały pomyślnie zsynchronizowane, a jeśli sprawdzisz bazę danych, powinieneś zobaczyć tabelę użytkowników z określonymi kolumnami.
3:Skonfiguruj widoki
Najpierw utwórzmy widok do rejestracji i podłączmy go.
Pierwszą rzeczą do zrobienia jest zaimportowanie modułu ekspresowych kierownic, którego używamy do widoków w tym samouczku.
Dodaj ten wiersz do głównego pliku startowego server.js.
var exphbs = require('express-handlebars')
Twój blok importu powinien teraz wyglądać tak.
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') Następnie dodajemy następujące wiersze w naszym pliku server.js.
//For Handlebars
app.set('views', './app/views')
app.engine('hbs', exphbs({
extname: '.hbs'
}));
app.set('view engine', '.hbs'); Teraz w naszym folderze aplikacji utworzymy trzy foldery o nazwie widoki, kontrolery, i trasy .
W folderze widoków tworzymy plik o nazwie signup. hbs i wklej w nim poniższy kod.
<!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> Następnie w naszych kontrolerach folderu, tworzymy nowy plik i nazywamy go authcontroller.js.
W tym pliku wklejamy następujący kontroler dla ścieżki rejestracji, którą za chwilę utworzymy.
var exports = module.exports = {}
exports.signup = function(req, res) {
res.render('signup');
} Następnie tworzymy trasę do rejestracji. W folderze Routes tworzymy nowy plik o nazwie auth.js a następnie w tym pliku importujemy kontroler uwierzytelniania i definiujemy trasę rejestracji.
var authController = require('../controllers/authcontroller.js');
module.exports = function(app) {
app.get('/signup', authController.signup);
} Teraz zaimportujemy tę trasę do naszego server.js i przekażemy aplikację jako argument.
Na serwerze, po zaimportowaniu modeli, dodaj te linie:
//Routes
var authRoute = require('./app/routes/auth.js')(app); Uruchom to:
node server.js
Teraz wejdź na http://localhost:5000/signup, a zobaczysz formularz rejestracji.
Powtórzmy kroki dla formularza logowania. Tak jak poprzednio, utworzymy plik o nazwie signin.hbs w naszym folderze widoków i wklej w nim następujący kod HTML:
<!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> Następnie dodaj kontroler do logowania w app/controllers/authcontroller.js.
exports.signin = function(req, res) {
res.render('signin');
} Następnie w app/routes/auth.js , dodajemy trasę do logowania w następujący sposób:
app.get('/signin', authController.signin);
Teraz, gdy biegasz:
node server.js
i odwiedź http://localhost:5000/signin/, powinieneś zobaczyć formularz logowania.
Ostatnim i głównym krokiem jest napisanie naszych strategii paszportowych.
4. Napisz strategię paszportową
W aplikacji/konfiguracji , tworzymy nowy folder o nazwie paszport.
Następnie w naszym nowym folderze app/config/passport tworzymy nowy plik i nazywamy go passport.js . Ten plik będzie zawierał nasze strategie paszportowe.
W paszport.js , użyjemy modelu użytkownika i paszportu.
Najpierw importujemy bcrypt których potrzebujemy do zabezpieczenia haseł.
var bCrypt = require('bcrypt-nodejs');
Następnie dodajemy blok module.exports w następujący sposób:
module.exports = function(passport, user) {
} Wewnątrz tego bloku inicjujemy strategię paszport-lokalną oraz model użytkownika, który zostanie przekazany jako argument. Oto jak to robimy:
module.exports = function(passport, user) {
var User = user;
var LocalStrategy = require('passport-local').Strategy;
} Następnie definiujemy naszą niestandardową strategię za pomocą naszej instancji LocalStrategy w następujący sposób:
passport.use('local-signup', new LocalStrategy(
{
usernameField: 'email',
passwordField: 'password',
passReqToCallback: true // allows us to pass back the entire request to the callback
},
)); Teraz zadeklarowaliśmy, jakie żądanie (req ) pola należą do naszych usernameField i passwordField (zmienne paszportu).
Ostatnia zmienna passReqToCallback pozwala nam przekazać całe żądanie do wywołania zwrotnego, co jest szczególnie przydatne podczas rejestracji.
Po ostatnim przecinku dodajemy tę funkcję zwrotną.
function(req, email, password, done) {
} W tej funkcji zajmiemy się przechowywaniem danych użytkownika.
Najpierw dodajemy naszą funkcję generowania haszowanych haseł w funkcji zwrotnej.
var generateHash = function(password) {
return bCrypt.hashSync(password, bCrypt.genSaltSync(8), null);
}; Następnie, korzystając z modelu użytkownika Sequelize, który zainicjowaliśmy wcześniej jako Użytkownik , sprawdzamy, czy użytkownik już istnieje, a jeśli nie, dodajemy go.
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() to metoda Sequelize służąca do dodawania nowych wpisów do bazy danych. Zwróć uwagę, że wartości w danych obiekt są pobierane z req.body obiekt, który zawiera dane wejściowe z naszego formularza rejestracyjnego.
Twój paszport.js powinien wyglądać tak:
//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);
}
});
}
});
}
));
} Teraz zaimportujemy strategię w server.js.
Aby to zrobić, dodajemy te wiersze poniżej importu tras w server.js.
//load passport strategies
require('./app/config/passport/passport.js')(passport, models.user); Twój server.js powinien teraz wyglądać tak:
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)
}); Teraz faktycznie zastosujemy tę strategię do naszego /signup trasa.
Oto jak to robimy:
Najpierw przechodzimy do app/routes/auth.js i dodaj trasę do publikowania, aby się zarejestrować w ten sposób.
app.post('/signup', passport.authenticate('local-signup', {
successRedirect: '/dashboard',
failureRedirect: '/signup'
}
)); Ponieważ potrzebujemy paszportu, musimy go przekazać do tej metody. Paszport możemy zaimportować w tym skrypcie lub przekazać go z server.js. Zróbmy to drugie.
Zmodyfikuj funkcję wyeksportowaną w tym pliku app/routes/auth.js mieć paszport jako parametr. Kod w app/routes/auth.js powinien wyglądać tak po Twojej modyfikacji.
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'
}
));
} Następnie w server.js , modyfikujemy import tras i dodajemy paszport jako argument w następujący sposób:
var authRoute = require('./app/routes/auth.js')(app,passport);
Teraz przejdź do adresu URL rejestracji http://localhost:5000/signup/ i spróbuj się zarejestrować.
Podczas próby rejestracji pojawi się błąd „Nie udało się zserializować użytkownika do sesji „. Dzieje się tak, ponieważ paszport musi zapisać identyfikator użytkownika w sesji i używa go do zarządzania pobieraniem danych użytkownika w razie potrzeby.
Aby rozwiązać ten problem, zaimplementujemy zarówno funkcje serializacji, jak i deserializacji paszportu w naszym app/config/passport/passport.js plik.
Najpierw dodajemy funkcję serializacji. W tej funkcji zapiszemy identyfikator użytkownika do sesji.
Aby to zrobić, dodajemy następujące wiersze poniżej inicjalizacji strategii lokalnej.
//serialize
passport.serializeUser(function(user, done) {
done(null, user.id);
}); Następnie implementujemy funkcję deserializacji. Dodaj funkcję tuż pod funkcją serializacji.
// deserialize user
passport.deserializeUser(function(id, done) {
User.findById(id).then(function(user) {
if (user) {
done(null, user.get());
} else {
done(user.errors, null);
}
});
});
W powyższej funkcji deserializacji używamy Sequelize findById obiecuję zdobyć użytkownika, a jeśli się powiedzie, zwracana jest instancja modelu Sequelize. Aby pobrać obiekt User z tej instancji, używamy funkcji pobierającej Sequelize w następujący sposób:user.get() .
Teraz uruchom ponownie:
node server.js
I spróbuj się zarejestrować. Hurra, jeśli otrzymałeś komunikat „Nie można uzyskać / pulpitu nawigacyjnego”! Oznacza to, że nasze uwierzytelnienie zakończyło się sukcesem. Pamiętaj, że przekierowaliśmy do /dashboard w naszej metodzie paszport.authenticate w routes/auth.js .
Teraz przejdźmy dalej i dodajmy tę trasę. Następnie dodaj oprogramowanie pośredniczące, aby mieć pewność, że dostęp do strony będzie możliwy tylko wtedy, gdy użytkownik jest zalogowany do sesji.
W naszej aplikacji/widokach folderu, tworzymy nowy plik o nazwie dashboard.hbs i dodaj w nim następujący kod HTML.
<!DOCTYPE html>
<html>
<head>
<title>Passport with Sequelize</title>
</head>
<body>
<h2>Dashboard</h2>
<h5>Hurray! you are logged in.</h5>
</body>
</html> W routes/auth.js , dodajemy ten wiersz w module.exports blok:
app.get('/dashboard',authController.dashboard);
Następnie przechodzimy do app/controllers/authController.js i dodaj kontroler deski rozdzielczej.
exports.dashboard = function(req, res) {
res.render('dashboard');
} Twój AuthController.js powinien wyglądać tak:
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');
} Teraz ponownie uruchom aplikację i spróbuj zarejestrować się przy użyciu innego adresu e-mail niż ten, którego używałeś wcześniej. Zostaniesz odpowiednio przekierowany do /dashboard trasa.
Ale /panel nie jest chronioną trasą, co oznacza, że nawet jeśli użytkownik nie jest zalogowany, może ją zobaczyć. Nie chcemy tego, więc dodamy /logout trasa, aby wylogować użytkownika, a następnie zabezpieczyć trasę i przetestować to, co zrobiliśmy.
Zróbmy to:
W routes/auth.js dodajemy ten wiersz:
app.get('/logout',authController.logout);
Następnie dodajemy kontroler w app/controllers/authController.js.
exports.logout = function(req, res) {
req.session.destroy(function(err) {
res.redirect('/');
});
} Teraz ponownie uruchom aplikację i zarejestruj się przy użyciu innego adresu e-mail.
Następnie odwiedź http://localhost:5000/logout, aby wylogować użytkownika. Teraz odwiedź http://localhost:5000/dashboard.
Zauważysz, że jest całkiem dostępny. Dodajmy niestandardowe oprogramowanie pośredniczące, aby chronić tę trasę.
W tym celu otwieramy app/routes/auth.js i dodaj tę funkcję w module.exports bloku, pod wszystkimi innymi liniami kodu.
function isLoggedIn(req, res, next) {
if (req.isAuthenticated())
return next();
res.redirect('/signin');
} Następnie modyfikujemy obsługę trasy na desce rozdzielczej, aby wyglądała tak:
app.get('/dashboard',isLoggedIn, authController.dashboard);
Teraz, gdy ponownie uruchomisz aplikację i spróbujesz odwiedzić stronę pulpitu nawigacyjnego, a nie jesteś zalogowany, powinieneś zostać przekierowany na stronę logowania.
Uff! Czas na wdrożenie ostatniej części:logowania.
Najpierw dodamy nową lokalną strategię logowania w app/config/passport/passport.js .
//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'
});
});
}
));
W tej strategii isValidPassword funkcja porównuje hasło wprowadzone z metodą porównania bCrypt, ponieważ zapisaliśmy nasze hasło w bcrypt .
Jeśli dane są poprawne, nasz użytkownik zostanie zalogowany.
Teraz przejdź do routes/auth.js i dodaj trasę do publikowania w / logowanie.
app.post('/signin', passport.authenticate('local-signin', {
successRedirect: '/dashboard',
failureRedirect: '/signin'
}
)); Kiedy skończysz, Twoje route/auth.js powinny wyglądać tak.
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');
}
} Teraz uruchom aplikację i spróbuj się zalogować. Powinno być możliwe zalogowanie się przy użyciu dowolnych danych użytych podczas rejestracji, a nastąpi przekierowanie na stronę http ://localhost:5000/panel/.
Gratulacje, jeśli dotarłeś do końca tego samouczka! Z powodzeniem wykorzystaliśmy Sequelize i Passport z bazą danych MySQL.
Pełny kod tego samouczka można znaleźć na GitHub.
