Node.js
पासपोर्ट एकीकरण

टिप्पणियों

शुरू करना

पासपोर्ट का उपयोग करके passport.initialize() आरंभ किया जाना चाहिए। लॉगिन सत्रों का उपयोग करने के लिए, passport.session() मिडलवेयर की आवश्यकता होती है।

ध्यान दें कि passport.serialize() और passport.deserializeUser() विधियों को परिभाषित किया जाना चाहिए। सत्र से पासपोर्ट उपयोगकर्ता क्रम को क्रमबद्ध और डिस्क्रिअलाइज़ करेगा

const express = require('express');
const session = require('express-session');
const passport = require('passport');
const cookieParser = require('cookie-parser');
const app = express();

// Required to read cookies
app.use(cookieParser());

passport.serializeUser(function(user, next) {
    // Serialize the user in the session
    next(null, user);
});

passport.deserializeUser(function(user, next) {
    // Use the previously serialized user
        next(null, user);
});

// Configuring express-session middleware
app.use(session({
    secret: 'The cake is a lie',
    resave: true,
    saveUninitialized: true
}));

// Initializing passport
app.use(passport.initialize());
app.use(passport.session());

// Starting express server on port 3000
app.listen(3000);

स्थानीय प्रमाणीकरण

पासपोर्ट-स्थानीय मॉड्यूल का उपयोग स्थानीय प्रमाणीकरण को लागू करने के लिए किया जाता है।

यह मॉड्यूल आपको अपने Node.js अनुप्रयोगों में उपयोगकर्ता नाम और पासवर्ड का उपयोग करके प्रमाणित करने देता है।

उपयोगकर्ता का पंजीकरण:

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

// A named strategy is used since two local strategy are used :
// one for the registration and the other to sign-in
passport.use('localSignup', new LocalStrategy({
    // Overriding defaults expected parameters,
    // which are 'username' and 'password'
    usernameField: 'email',
    passwordField: 'password',
    passReqToCallback: true // allows us to pass back the entire request to the callback    .
},
function(req, email, password, next) {
    // Check in database if user is already registered
    findUserByEmail(email, function(user) {
        // If email already exists, abort registration process and
        // pass 'false' to the callback
        if (user) return next(null, false);
        // Else, we create the user
        else {
            // Password must be hashed !
            let newUser = createUser(email, password);

            newUser.save(function() {
                // Pass the user to the callback
                return next(null, newUser);
            });
        }
    });
});

उपयोगकर्ता में प्रवेश करना:

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

passport.use('localSignin', new LocalStrategy({
    usernameField : 'email',
    passwordField : 'password',
},
function(email, password, next) {
    // Find the user
    findUserByEmail(email, function(user) {
        // If user is not found, abort signing in process
        // Custom messages can be provided in the verify callback
        // to give the user more details concerning the failed authentication
        if (!user) 
            return next(null, false, {message: 'This e-mail address is not associated with any account.'});
        // Else, we check if password is valid
        else {
            // If password is not correct, abort signing in process
            if (!isPasswordValid(password)) return next(null, false);
            // Else, pass the user to callback
            else return next(null, user);
        }
    });
});

मार्ग बनाना:

// ...
app.use(passport.initialize());
app.use(passport.session());

// Sign-in route
// Passport strategies are middlewares
app.post('/login', passport.authenticate('localSignin', {
    successRedirect: '/me',
    failureRedirect: '/login'
});

// Sign-up route
app.post('/register', passport.authenticate('localSignup', {
    successRedirect: '/',
    failureRedirect: '/signup'
});

// Call req.logout() to log out
app.get('/logout', function(req, res) {
    req.logout();
    res.redirect('/');
});

app.listen(3000);

फेसबुक प्रमाणीकरण

फेसबुक प्रमाणीकरण को लागू करने के लिए पासपोर्ट-फेसबुक मॉड्यूल का उपयोग किया जाता है। इस उदाहरण में, यदि उपयोगकर्ता साइन-इन पर मौजूद नहीं है, तो वह बनाया जाता है।

कार्यान्वयन की रणनीति:

const passport = require('passport');
const FacebookStrategy = require('passport-facebook').Strategy;

// Strategy is named 'facebook' by default
passport.use({
    clientID: 'yourclientid',
    clientSecret: 'yourclientsecret',
    callbackURL: '/auth/facebook/callback'
},
// Facebook will send a token and user's profile
function(token, refreshToken, profile, next) {
    // Check in database if user is already registered
    findUserByFacebookId(profile.id, function(user) {
        // If user exists, returns his data to callback
        if (user) return next(null, user);
        // Else, we create the user
        else {
            let newUser = createUserFromFacebook(profile, token);

            newUser.save(function() {
                // Pass the user to the callback
                return next(null, newUser);
            });
        }
    });
});

मार्ग बनाना:

// ...
app.use(passport.initialize());
app.use(passport.session());

// Authentication route
app.get('/auth/facebook', passport.authenticate('facebook', {
    // Ask Facebook for more permissions
    scope : 'email'
}));

// Called after Facebook has authenticated the user
app.get('/auth/facebook/callback',
    passport.authenticate('facebook', {
        successRedirect : '/me',
        failureRedirect : '/'
}));


//...

app.listen(3000);

सरल उपयोगकर्ता नाम-पासवर्ड प्रमाणीकरण

अपने मार्गों / index.js में

यहाँ user userSchema के लिए मॉडल है

router.post('/login', function(req, res, next) {
    if (!req.body.username || !req.body.password) {
        return res.status(400).json({
            message: 'Please fill out all fields'
        });
    }
    
    passport.authenticate('local', function(err, user, info) {
        if (err) {
            console.log("ERROR : " + err);
            return next(err);
        }

        if(user) (
            console.log("User Exists!")
            //All the data of the user can be accessed by user.x
            res.json({"success" : true});
            return;
        } else {
            res.json({"success" : false});
            console.log("Error" + errorResponse());
            return;
        }
    })(req, res, next);
});

Google पासपोर्ट प्रमाणीकरण

हमारे पास सरल मॉड्यूल npm में उपलब्ध है गॉगल ऑटेथेनेशन नाम पासपोर्ट-google-oauth20 के लिए

इस उदाहरण पर विचार करें। इस उदाहरण में रूट डायरेक्टरी में पासपोर्ट.जेएस और google.js फाइल होने वाले नाम से एक फ़ोल्डर बनाया गया है। अपने app.js में निम्नलिखित शामिल हैं

var express = require('express');
var session = require('express-session');
var passport = require('./config/passport'); // path where the passport file placed  
var app = express();
passport(app);

// अन्य कोड सर्वर, त्रुटि संभाल initailize

कॉन्फ़िगरेशन फ़ोल्डर में passport.js फ़ाइल में निम्न कोड शामिल हैं

var passport = require  ('passport'),
google = require('./google'),
User = require('./../model/user'); // User is the  mongoose model

module.exports = function(app){
  app.use(passport.initialize());
  app.use(passport.session());
  passport.serializeUser(function(user, done){
      done(null, user);
  });
  passport.deserializeUser(function (user, done) {
     done(null, user);
  });
  google();
};

Google.js फ़ाइल में समान कॉन्फ़िगरेशन फ़ोल्डर में निम्नलिखित शामिल हैं

var passport = require('passport'),
GoogleStrategy = require('passport-google-oauth20').Strategy,
User = require('./../model/user');
module.exports = function () {
passport.use(new GoogleStrategy({
        clientID: 'CLIENT ID',
        clientSecret: 'CLIENT SECRET',
        callbackURL: "http://localhost:3000/auth/google/callback"
    },
    function(accessToken, refreshToken, profile, cb) {
        User.findOne({ googleId : profile.id }, function (err, user) {
            if(err){
                return cb(err, false, {message : err});
            }else {
                if (user != '' && user != null) {
                    return cb(null, user, {message : "User "});
                } else {
                    var username  = profile.displayName.split(' ');
                    var userData = new User({
                        name : profile.displayName,
                        username : username[0],
                        password : username[0],
                        facebookId : '',
                        googleId : profile.id,
                    });
                    // send email to user just in case required to send the newly created
                    // credentails to user for future login without using google login
                    userData.save(function (err, newuser) {
                        if (err) {
                            return cb(null, false, {message : err + " !!! Please try again"});
                        }else{
                            return cb(null, newuser);
                        }
                    });
                }
            }
        });
      }
  ));
};

इस उदाहरण में, यदि उपयोगकर्ता DB में नहीं है, तो उपयोगकर्ता मॉडल में फ़ील्ड नाम googleId का उपयोग करके स्थानीय संदर्भ के लिए DB में एक नया उपयोगकर्ता बना रहा है।