सीक्वेलाइज़ और MySQL के साथ पासपोर्ट का उपयोग करना

Sequelize एक वादा-आधारित Node.js ORM है। इसका उपयोग PostgreSQL, MySQL, MariaDB, SQLite और MSSQL के साथ किया जा सकता है। इस ट्यूटोरियल में, हम एक वेब ऐप के उपयोगकर्ताओं के लिए प्रमाणीकरण लागू करेंगे। और हम उपयोगकर्ता पंजीकरण और लॉगिन को लागू करने के लिए पासपोर्ट, नोड के लिए लोकप्रिय प्रमाणीकरण मिडलवेयर, Sequelize और MySQL के साथ उपयोग करेंगे।

आरंभ करना

सुनिश्चित करें कि आपने अपनी मशीन पर निम्नलिखित स्थापित किया है:

• नोड
• MySQL

इस ट्यूटोरियल के लिए, हम एक्सप्रेस के साथ Node.js का उपयोग करेंगे, इसलिए हम आगे बढ़ते हैं और हमें जो चाहिए उसे इंस्टॉल करना शुरू करते हैं।

चरण 1:एक package.json फ़ाइल जेनरेट करें

अपने ऐप के लिए एक निर्देशिका बनाएं। इस निर्देशिका के अंदर, इसे अपने टर्मिनल या कमांड प्रॉम्प्ट से चलाएँ:

 npm init

यह npm डिपेंडेंसी मैनेजर को इनिशियलाइज़ करता है। यह संकेतों की एक श्रृंखला प्रस्तुत करेगा जिन पर हम शीघ्रता से अमल करेंगे।

• बिना स्पेस के अपने ऐप का नाम टाइप करें और 'नाम' के लिए एंटर दबाएं।
• 'संस्करण' के लिए एंटर दबाएं।
• 'विवरण' के लिए, इस ट्यूटोरियल में, हम विवरण के रूप में "Using Passport with Sequelize and MySQL" टाइप करेंगे और एंटर दबाएंगे। यह खाली भी हो सकता है।
• 'एंट्री पॉइंट (index.js)' के लिए, server.js टाइप करें और एंटर दबाएं।
• 'टेस्ट कमांड' के लिए एंटर दबाएं।
• 'गिट रिपोजिटरी' के लिए, यदि आपके पास एक है तो आप उस गिट रेपो में प्रवेश कर सकते हैं जहां आपका ऐप रहता है या इसे खाली छोड़ने के लिए केवल एंटर दबाएं।
• 'कीवर्ड' के लिए, एंटर दबाएं।
• 'author' के लिए, Enter दबाएं या ऐसा करने से पहले अपना नाम लिखें।
• 'लाइसेंस' के लिए, एंटर दबाएं।
• '(क्या यह ठीक है)' के लिए, यह आपको दिखाता है कि आपका package.json कैसा दिखेगा। हां टाइप करें और एंटर दबाएं।

चरण 2:निर्भरता स्थापित करें

इस ट्यूटोरियल के लिए प्रमुख निर्भरताएँ हैं:

• एक्सप्रेस
• अनुक्रमित करें
• MySQL
• पासपोर्ट
• पासपोर्ट स्थानीय रणनीति
• बॉडी पार्सर
• एक्सप्रेस सत्र
• Bcrypt Nodejs
• देखने के लिए एक्सप्रेस हैंडलबार 

उन्हें स्थापित करने के लिए, अपने टर्मिनल या कमांड प्रॉम्प्ट से, निम्नलिखित को एक के बाद एक चलाएँ।

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

यदि आप इस प्रोजेक्ट के लिए Git का उपयोग कर रहे हैं:

अपने प्रोजेक्ट फोल्डर में एक .gitignore फाइल बनाएं।

इस लाइन को .gitignore फ़ाइल में जोड़ें।

node_modules

चरण 3:ऐप सेट करें

अब, हम एक सर्वर फ़ाइल बनाते हैं। जब आप निम्नलिखित टाइप करेंगे तो यह मुख्य फाइल होगी जिसे कहा जाता है:

npm start

यह ऐप चलाता है। आप नोड सर्वर.जेएस टाइप करके भी ऐप चला सकते हैं।

node server.js

फिर, अपने प्रोजेक्ट फ़ोल्डर में, हम एक नई फ़ाइल बनाते हैं और इस फ़ाइल को नाम देते हैं server.js ।

server.js . के अंदर फ़ाइल, हम निम्नलिखित पेस्ट करते हैं:

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)

});

पहली पंक्ति एक वेरिएबल एक्सप्रेस को एक्सप्रेस मॉड्यूल असाइन करती है। फिर हम एक्सप्रेस को इनिशियलाइज़ करते हैं और इसे एक वेरिएबल नाम देते हैं:app.

फिर हम पोर्ट पर ऐप सुनते हैं 5000 . आप अपने कंप्यूटर पर कोई भी मुफ्त पोर्ट नंबर चुन सकते हैं।

इसके बाद, हम app.get() . को कॉल करते हैं जब "/" के लिए GET अनुरोध किया जाता है, तो "सीक्वेलाइज़ के साथ पासपोर्ट में आपका स्वागत है" के साथ प्रतिक्रिया देने के लिए एक्सप्रेस रूटिंग फ़ंक्शन।

अपने कंप्यूटर पर परीक्षण करने के लिए, इसे अपने प्रोजेक्ट फ़ोल्डर के अंदर से चलाएँ:

node server.js

यदि आप http://localhost:5000/ पर जाते समय "वेलकम टू पासपोर्ट विद सीक्वेलाइज़" टेक्स्ट देखते हैं तो बधाई हो! अन्यथा, जांच लें कि आपने सब कुछ ठीक वैसा ही किया है जैसा ऊपर लिखा है।

इसके बाद, हम कुछ मॉड्यूल आयात करते हैं जिनकी हमें आवश्यकता होती है, जैसे पासपोर्ट, एक्सप्रेस-सेशन और बॉडी-पार्सर।

var app = express() . के बाद हम निम्नलिखित पंक्तियाँ जोड़ते हैं:

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

पहली दो पंक्तियों में, हम पासपोर्ट मॉड्यूल और एक्सप्रेस-सत्र आयात करते हैं, दोनों को हमें प्रमाणीकरण को संभालने की आवश्यकता होती है।

फिर, हम बॉडी-पार्सर मॉड्यूल आयात करते हैं। यह आने वाले अनुरोध के पूरे शरीर के हिस्से को निकालता है और इसे एक ऐसे प्रारूप में उजागर करता है जिसके साथ काम करना आसान हो। इस मामले में, हम JSON प्रारूप का उपयोग करेंगे।

हमारे ऐप को बॉडी पार्सर का उपयोग करने देने के लिए, हम इन पंक्तियों को आयात लाइनों के नीचे कुछ स्थान जोड़ते हैं:

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

इसके बाद, हम पासपोर्ट और एक्सप्रेस सत्र और पासपोर्ट सत्र को इनिशियलाइज़ करते हैं और दोनों को मिडलवेयर के रूप में जोड़ते हैं। हम इन पंक्तियों को 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

हम अब वास्तविक प्रमाणीकरण पर काम करना शुरू करेंगे।

हम इसे चार चरणों में करेंगे:

• MySQL के साथ सीक्वेलाइज़ सेट करें।
• उपयोगकर्ता मॉडल बनाएं।
• दृश्य सेट करें।
• पासपोर्ट रणनीति लिखें।

सबसे पहले, हम MySQL में एक डेटाबेस बनाते हैं। इसे अपना पसंदीदा नाम दें। इस ट्यूटोरियल के लिए, चलिए sequelize_passport . नाम का एक डेटाबेस बनाते हैं MySQL में।

फिर हम डीबी विवरण को संभालने के लिए कॉन्फ़िगरेशन सेट करते हैं।

सबसे पहले, पर्यावरण चर को संभालने के लिए dot-env मॉड्यूल को आयात करते हैं।

इसे अपने रूट प्रोजेक्ट फ़ोल्डर में चलाएँ:

npm install --save dotenv

फिर हम इसे अन्य आयातों के ठीक नीचे मुख्य सर्वर फ़ाइल, server.js में आयात करते हैं।

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

इसके बाद, हम अपने प्रोजेक्ट फ़ोल्डर में एक फाइल बनाते हैं और इसे .env नाम देते हैं।

यदि आप Git का उपयोग नहीं कर रहे हैं, तो यह अगला चरण वैकल्पिक है:

हम .env फ़ाइल को आपकी .gitignore फ़ाइल में जोड़ देंगे।

आपकी .gitignore फ़ाइल इस तरह दिखनी चाहिए:

node_modules
.env

इसके बाद, हम इस लाइन को जोड़कर .env फाइल में अपना एनवायरनमेंट जोड़ते हैं:

NODE_ENV='development'

फिर हम एक config.json फ़ाइल बनाते हैं जिसका उपयोग Sequelize द्वारा विभिन्न वातावरणों को प्रबंधित करने के लिए किया जाएगा।

सबसे पहले आपको config . नाम का फोल्डर बनाना है हमारे प्रोजेक्ट फ़ोल्डर में। इस फ़ोल्डर के अंदर, हम एक कॉन्फ़िगरेशन। बनाते हैं जेसन फ़ाइल। यदि आप किसी रिपॉजिटरी पर जोर दे रहे हैं तो इस फाइल को नजरअंदाज कर देना चाहिए। ऐसा करने के लिए, निम्नलिखित कोड को अपने .gitignore में जोड़ें:

config/config.json

फिर, हम निम्न कोड को हमारी 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"

    }

}

अपने डेटाबेस प्रमाणीकरण विवरण के साथ उपरोक्त विकास खंड में मानों को प्रतिस्थापित करना याद रखें।

अगला, हम npm के साथ सीक्वेलाइज़ स्थापित करते हैं। ऐसा करने के लिए, प्रोजेक्ट के रूट फ़ोल्डर में निम्न कमांड चलाएँ:

npm install --save sequelize

अब मॉडल बनाने का समय आ गया है फ़ोल्डर।

सबसे पहले, हम एक निर्देशिका बनाते हैं जिसका नाम app . है हमारे प्रोजेक्ट फ़ोल्डर में।

ऐप्लिकेशन  . के अंदर फ़ोल्डर, हम नाम का एक नया फ़ोल्डर बनाते हैं मॉडल और index.js . नाम की एक नई फ़ाइल बनाएं मॉडल . में फ़ोल्डर।

index.js फ़ाइल के अंदर, हम नीचे कोड पेस्ट करते हैं।

"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;

इस फ़ाइल का उपयोग हमारे द्वारा मॉडल . में रखे गए सभी मॉडलों को आयात करने के लिए किया जाता है फ़ोल्डर, और उन्हें निर्यात करें।

यह जांचने के लिए कि सब कुछ ठीक है, हम इसे अपनी सर्वर.जेएस फ़ाइल में जोड़ते हैं।

//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!")

});

यहां, हम मॉडल आयात कर रहे हैं, और फिर सीक्वेलाइज़ सिंक फ़ंक्शन को कॉल कर रहे हैं।

सब कुछ ठीक है या नहीं यह देखने के लिए इसे चलाएं:

node server.js

अगर आपको "साइट लाइव है नाइस! डेटाबेस ठीक दिखता है" संदेश मिलता है, तो आपने सीक्वेलाइज़ को सफलतापूर्वक सेट कर लिया है।

यदि नहीं, तो कृपया ऊपर दिए गए चरणों को ध्यान से देखें और सहायता से समस्या को डीबग करने का प्रयास करें।

अगली चीज़ जो हम करने जा रहे हैं वह उपयोगकर्ता मॉडल बनाना है, जो मूल रूप से उपयोगकर्ता तालिका है। इसमें बुनियादी उपयोगकर्ता जानकारी होगी।

हमारे मॉडल . में फ़ोल्डर, हम एक फ़ाइल बनाते हैं और उसे नाम देते हैं user.js . इस फ़ाइल का पूरा पथ होना चाहिए app/models/user.js.

user.js फ़ाइल खोलें और निम्न कोड जोड़ें:

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;

}

अब दौड़ें:

node server.js

आपको परिचित देखना चाहिए "साइट लाइव है। अच्छा है! डेटाबेस ठीक लग रहा है। " संदेश। इसका मतलब है कि हमारे Sequelize मॉडल सफलतापूर्वक समन्वयित हो गए हैं, और यदि आप अपने डेटाबेस की जांच करते हैं तो आपको निर्दिष्ट कॉलम के साथ एक उपयोगकर्ता तालिका देखनी चाहिए।

3:दृश्य सेट करें

सबसे पहले, साइनअप के लिए व्यू बनाते हैं और इसे वायर अप करते हैं।

पहली बात यह है कि एक्सप्रेस हैंडलबार मॉड्यूल आयात करें जिसका उपयोग हम इस ट्यूटोरियल में विचारों के लिए करते हैं।

इस लाइन को मुख्य प्रारंभ फ़ाइल server.js. . में जोड़ें

var exphbs = require('express-handlebars')

इस समय आपका इम्पोर्ट ब्लॉक कुछ इस तरह दिखना चाहिए।

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 Handlebars
app.set('views', './app/views')
app.engine('hbs', exphbs({
    extname: '.hbs'
}));
app.set('view engine', '.hbs');

अब, हमारे ऐप फोल्डर में, हम views, . नाम के तीन फोल्डर बनाते हैं नियंत्रक, और मार्ग ।

दृश्य फ़ोल्डर में, हम साइनअप. . नाम की एक फ़ाइल बनाते हैं एचबीएस और उसमें नीचे दिए गए कोड को पेस्ट करें।

<!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>

फिर हमारे नियंत्रकों . में फ़ोल्डर, हम एक नई फ़ाइल बनाते हैं और उसका नाम authcontroller.js. . रखते हैं

इस फ़ाइल में, हम साइनअप रूट के लिए निम्न नियंत्रक पेस्ट करते हैं जिसे हम एक पल में बना देंगे।

var exports = module.exports = {}

exports.signup = function(req, res) {

    res.render('signup');

}

अगला, हम साइनअप के लिए एक मार्ग बनाते हैं। मार्ग फ़ोल्डर में, हम auth.js  . नामक एक नई फ़ाइल बनाते हैं और फिर, इस फ़ाइल में, हम प्रमाणीकरण नियंत्रक को आयात करते हैं और साइनअप मार्ग को परिभाषित करते हैं।

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

module.exports = function(app) {

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

}

अब, हम इस मार्ग को अपने सर्वर.जेएस में आयात करेंगे और ऐप को तर्क के रूप में पास करेंगे।

सर्वर में, मॉडल आयात करने के बाद, इन पंक्तियों को जोड़ें:

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

इसे चलाएँ: 

node server.js

अब, http://localhost:5000/signup पर जाएं और आपको साइनअप फॉर्म दिखाई देगा।

आइए साइन-इन फॉर्म के चरणों को दोहराएं। पहले की तरह, हम signin.hbs . नाम की एक फ़ाइल बनाएंगे हमारे विचार फ़ोल्डर में और उसमें निम्नलिखित 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>

फिर, app/controllers/authcontroller.js. में साइन-इन के लिए एक कंट्रोलर जोड़ें।

exports.signin = function(req, res) {

    res.render('signin');

}

फिर ऐप/मार्ग/auth.js . में , हम इस तरह साइन-इन के लिए एक मार्ग जोड़ते हैं:

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

अब जब आप दौड़ें:

 node server.js 

और http://localhost:5000/signin/ पर जाएं, आपको साइन-इन फॉर्म देखना चाहिए।

अंतिम और प्रमुख चरण हमारी पासपोर्ट रणनीतियाँ लिख रहा है।

ऐप/कॉन्फ़िगरेशन . में , हम पासपोर्ट . नामक एक नया फ़ोल्डर बनाते हैं

फिर हमारे नए फोल्डर ऐप/कॉन्फिग/पासपोर्ट में, हम एक नई फाइल बनाते हैं और इसे passport.js नाम देते हैं। . इस फ़ाइल में हमारी पासपोर्ट रणनीतियाँ होंगी।

पासपोर्ट.जेएस . में , हम उपयोगकर्ता मॉडल और पासपोर्ट का उपयोग करेंगे।

सबसे पहले, हम bcrypt आयात करते हैं जिसे हमें पासवर्ड सुरक्षित करने की आवश्यकता है।

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

फिर, हम इस तरह एक मॉड्यूल.एक्सपोर्ट ब्लॉक जोड़ते हैं:

module.exports = function(passport, user) {

}

इस ब्लॉक के अंदर, हम पासपोर्ट-स्थानीय रणनीति और उपयोगकर्ता मॉडल को इनिशियलाइज़ करते हैं, जिसे एक तर्क के रूप में पारित किया जाएगा। यहां बताया गया है कि हम यह कैसे करते हैं:

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

    },

));

अब हमने किस अनुरोध की घोषणा की है (req ) फ़ील्ड हमारे यूज़रनेमफ़ील्ड और पासवर्डफ़ील्ड (पासपोर्ट वैरिएबल) हैं।

अंतिम चर passReqToCallback हमें पूरे अनुरोध को कॉलबैक में पास करने की अनुमति देता है, जो विशेष रूप से साइन अप करने के लिए उपयोगी है।

अंतिम अल्पविराम के बाद, हम इस कॉलबैक फ़ंक्शन को जोड़ते हैं।

  function(req, email, password, done) {

  }

इस फ़ंक्शन में, हम उपयोगकर्ता के विवरण संग्रहीत करने का काम संभालेंगे।

सबसे पहले, हम अपने हैशेड पासवर्ड जनरेटिंग फ़ंक्शन को कॉलबैक फ़ंक्शन के अंदर जोड़ते हैं।

 var generateHash = function(password) {

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

 };

फिर, Sequelize उपयोगकर्ता मॉडल का उपयोग करके हमने पहले उपयोगकर्ता . के रूप में प्रारंभ किया था , हम यह देखने के लिए जांच करते हैं कि क्या उपयोगकर्ता पहले से मौजूद है, और यदि नहीं तो हम उन्हें जोड़ते हैं।

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() डेटाबेस में नई प्रविष्टियाँ जोड़ने के लिए एक Sequelize विधि है। ध्यान दें कि डेटा . में मान ऑब्जेक्ट req.body . से प्राप्त किए गए हैं ऑब्जेक्ट जिसमें हमारे साइनअप फॉर्म से इनपुट होता है।

आपका पासपोर्ट.js इस तरह दिखना चाहिए:

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

                        }

                    });

                }

            });

        }

    ));

}

अब हम server.js. . में रणनीति आयात करेंगे

ऐसा करने के लिए, हम इन पंक्तियों को server.js. . में आयात किए गए मार्गों के नीचे जोड़ते हैं

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

इस समय आपका सर्वर.जेएस इस तरह दिखना चाहिए:

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)

});

अब हम वास्तव में अपने /साइनअप . पर रणनीति लागू करेंगे मार्ग।

यहां बताया गया है कि हम यह कैसे करते हैं:

सबसे पहले, हम app/routes/auth.js . पर जाते हैं , और इस तरह साइनअप करने के लिए पोस्टिंग के लिए एक मार्ग जोड़ें।

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

        failureRedirect: '/signup'
    }

));

चूंकि हमें पासपोर्ट की जरूरत है, इसलिए हमें इसे इस तरीके से पास करना होगा। हम इस स्क्रिप्ट में पासपोर्ट आयात कर सकते हैं या इसे server.js से पास कर सकते हैं। चलो बाद करते हैं।

इस फ़ाइल में निर्यात किए गए फ़ंक्शन को संशोधित करें app/routes/auth.js एक पैरामीटर के रूप में पासपोर्ट होना। ऐप/मार्ग/auth.js . में कोड आपके संशोधन के बाद ऐसा दिखना चाहिए।

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

    ));



}

फिर server.js . में , हम रूट आयात को संशोधित करते हैं और पासपोर्ट को इस तरह तर्क के रूप में जोड़ते हैं:

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

अब, साइनअप URL http://localhost:5000/signup/ पर जाएं और साइन अप करने का प्रयास करें।

जब आप साइन अप करने का प्रयास करते हैं, तो आपको एक त्रुटि मिलेगी "उपयोगकर्ता को सत्र में क्रमबद्ध करने में विफल ". ऐसा इसलिए है क्योंकि पासपोर्ट को सत्र में एक उपयोगकर्ता आईडी सहेजनी होती है, और यह इसका उपयोग जरूरत पड़ने पर उपयोगकर्ता विवरण प्राप्त करने के प्रबंधन के लिए करता है।

इसे हल करने के लिए, हम अपने app/config/passport/passport.js में पासपोर्ट के क्रमबद्ध और अक्रमांकन दोनों कार्यों को लागू करने जा रहे हैं। फ़ाइल।

सबसे पहले हम serialize फंक्शन जोड़ते हैं। इस फ़ंक्शन में, हम उपयोगकर्ता आईडी . सहेजेंगे सत्र के लिए।

ऐसा करने के लिए, हम स्थानीय रणनीति के आरंभीकरण के नीचे निम्नलिखित पंक्तियाँ जोड़ते हैं।

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

    done(null, user.id);

});

अगला, हम deserialize फ़ंक्शन को लागू करते हैं। सीरियलाइज़ फंक्शन के ठीक नीचे फंक्शन जोड़ें।

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

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

        if (user) {

            done(null, user.get());

        } else {

            done(user.errors, null);

        }

    });

});

उपरोक्त deserialize फ़ंक्शन में, हम Sequelize findById . का उपयोग करते हैं उपयोगकर्ता प्राप्त करने का वादा करता है, और यदि सफल होता है, तो Sequelize मॉडल का एक उदाहरण वापस कर दिया जाता है। इस उदाहरण से उपयोगकर्ता ऑब्जेक्ट प्राप्त करने के लिए, हम इस तरह सीक्वेलाइज़ गेटर फ़ंक्शन का उपयोग करते हैं:user.get() ।

अब फिर से दौड़ें:

node server.js

और साइन अप करने का प्रयास करें। हुर्रे अगर आपको "गेट /डैशबोर्ड नहीं मिल रहा है"! इसका मतलब है कि हमारा प्रमाणीकरण सफल रहा। याद रखें कि हमने मार्गों/auth.js में अपने पासपोर्ट.प्रमाणीकरण विधि में /डैशबोर्ड पर पुनर्निर्देशित किया है ।

अब आगे बढ़ते हैं और उस मार्ग को जोड़ते हैं। फिर, यह सुनिश्चित करने के लिए एक मिडलवेयर जोड़ें कि पृष्ठ पर केवल तभी पहुँचा जा सकता है जब कोई उपयोगकर्ता सत्र में लॉग इन हो।

हमारे ऐप्लिकेशन/दृश्यों . में फ़ोल्डर, हम dashboard.hbs . नामक एक नई फ़ाइल बनाते हैं और इसमें निम्न HTML कोड जोड़ें।

<!DOCTYPE html>
<html>

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

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

</body>

</html>

मार्गों/auth.js . में , हम इस पंक्ति को module.exports . के अंदर जोड़ते हैं ब्लॉक करें:

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

इसके बाद, हम app/controllers/authController.js . पर जाते हैं और डैशबोर्ड नियंत्रक जोड़ें।

exports.dashboard = function(req, res) {

    res.render('dashboard');

}

आपका AuthController.js इस तरह दिखना चाहिए:

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

}

अब, ऐप को फिर से चलाएँ, और आपके द्वारा पहले इस्तेमाल किए गए ईमेल पते से भिन्न ईमेल पते के साथ साइन अप करने का प्रयास करें। आपको उचित रूप से /डैशबोर्ड . पर रीडायरेक्ट कर दिया जाएगा रास्ता।

लेकिन /डैशबोर्ड एक संरक्षित मार्ग नहीं है, जिसका अर्थ है कि भले ही कोई उपयोगकर्ता लॉग इन न हो, वे इसे देख सकते हैं। हमें यह नहीं चाहिए, इसलिए हम एक /लॉगआउट जोड़ देंगे उपयोगकर्ता को लॉग आउट करने के लिए मार्ग, और फिर मार्ग की रक्षा करें और परीक्षण करें कि हमने क्या किया है।

आइए इसे करते हैं:

मार्गों/auth.js . में हम यह पंक्ति जोड़ते हैं:

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

फिर हम नियंत्रक को app/controllers/authController.js में जोड़ते हैं।

 exports.logout = function(req, res) {

     req.session.destroy(function(err) {

         res.redirect('/');

     });

 }

अब ऐप को फिर से चलाएँ और किसी भिन्न ईमेल पते से साइन अप करें।

उसके बाद, उपयोगकर्ता को लॉग आउट करने के लिए http://localhost:5000/logout पर जाएं। अब http://localhost:5000/डैशबोर्ड पर जाएं।

आप देखेंगे कि यह काफी सुलभ है। आइए उस मार्ग की सुरक्षा के लिए एक कस्टम मिडलवेयर जोड़ें।

ऐसा करने के लिए, हम app/routes/auth.js और . खोलते हैं इस फ़ंक्शन को module.exports . में जोड़ें कोड की अन्य सभी पंक्तियों के नीचे ब्लॉक करें।

function isLoggedIn(req, res, next) {

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

}

फिर हम इस तरह दिखने के लिए डैशबोर्ड रूट हैंडलर को संशोधित करते हैं:

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

अब जब आप ऐप को फिर से चलाते हैं और डैशबोर्ड पेज पर जाने का प्रयास करते हैं और आप लॉग इन नहीं हैं, तो आपको साइन-इन पेज पर रीडायरेक्ट किया जाना चाहिए।

वाह! यह अंतिम भाग को लागू करने का समय है:साइन-इन।

सबसे पहले, हम 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'
            });

        });


    }

));

इस रणनीति में, isValidPassword फ़ंक्शन bCrypt तुलना पद्धति के साथ दर्ज पासवर्ड की तुलना करता है क्योंकि हमने अपना पासवर्ड bcrypt के साथ संग्रहीत किया है .

यदि विवरण सही हैं, तो हमारे उपयोगकर्ता को साइन इन किया जाएगा।

अब मार्ग/auth.js . पर जाएं और / . पर पोस्ट करने का मार्ग जोड़ें प्रवेश करें.

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

        failureRedirect: '/signin'
    }

));

काम पूरा हो जाने पर आपके मार्ग/auth.js इस तरह दिखाई देने चाहिए।

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

    }

}

अब ऐप चलाएं और साइन इन करने का प्रयास करें। साइन अप करते समय आपके द्वारा उपयोग किए गए किसी भी विवरण के साथ आप साइन इन करने में सक्षम होना चाहिए, और आपको http पर निर्देशित किया जाएगा। ://लोकलहोस्ट:5000/डैशबोर्ड/.

बधाई हो अगर आपने इसे इस ट्यूटोरियल के अंत में बनाया है! हमने सफलतापूर्वक एक MySQL डेटाबेस के साथ Sequelize और Passport का उपयोग किया है।

इस ट्यूटोरियल का पूरा कोड GitHub पर पाया जा सकता है।