8
मैं कुछ नोड.जेएस ढांचे के पीछे कुछ सिद्धांतों और सम्मेलनों के साथ संघर्ष कर रहा हूं। मैं नोड.जे.एस. के लिए नया हूँ मैं एक परिदृश्य स्थापित करने की कोशिश कर रहा हूं जहां मेरे पास एक एमवीसी फ्रेमवर्क है जहां मैं नियंत्रकों का एक सेट परिभाषित करता हूं जो बुनियादी आराम कार्यक्षमता करते हैं, और मेरे कुछ नियंत्रक मार्गों को प्रमाणीकरण की आवश्यकता होती है। अगर आपको प्रमाणित नहीं किया गया है, तो आपको इसे लॉगिन पेज पर भेजना चाहिए, लेकिन लॉगिन करने के बाद, यह आपको उस पृष्ठ पर वापस भेजता है जिसे आपने पहले अनुरोध किया था। मैंने ट्यूटोरियल्स का एक गुच्छा देखा है, और मैंने स्टैक ओवरफ्लो पर कुछ प्रश्नों को देखा है, लेकिन मुझे लगता है कि समस्या यह है कि कुछ क्लिक नहीं कर रहा है। मुझे उम्मीद है कि आप में से एक मुझे कुछ समझने के पीछे बता सकता है कि क्या हो रहा है, और शायद मुझे मेरी समस्या के लिए सही दिशा में इंगित करें। मेरा कोड नीचे है। मेरी असली समस्या यह है कि मैं वास्तव में इस अगले() प्रतिमान को समझ नहीं पा रहा हूं। हो सकता है कि मैं यह सब गलत भी कर रहा हूं और गलत तरीके से सोच रहा हूं। शायद आप मुझे कुछ अच्छे विचारों में भी दे सकते हैं।नोड.जेएस सिद्धांत - नोड.जेएस, एक्सप्रेस.जेएस, पासपोर्ट.जेएस
संपादित करें:
======
मैं एक समाधान मिल गया। मैं बाद में किसी अन्य व्यक्ति के लिए अपने प्रश्न का उत्तर दूंगा जो कुछ जानकारी प्राप्त करने और इस समस्या को हल करने के लिए भी देख सकता है।
- Server.js
/**
* Clancy server implementation (using Express)
*/
require('console-trace')({
always: true,
right: true,
colors: true
})
/**
* Include our server's needed objects.
**/
var express = require('express');
var _ = require('underscore');
var cons = require('consolidate');
passport = require('passport'),
LocalStrategy = require('passport-local').Strategy;
var db = require('./lib/db');
var colors = require('colors');
var Users = db.users;
var People = require('./controllers/People');
var Login = require('./controllers/Login');
/**
* This provides our MVC context object
**/
var app = express();
/**
* This is our router definition for the server
**/
app.engine('html', cons.underscore);
// set .html as the default extension
app.set('view engine', 'html');
app.set('views', __dirname + '/views');
/**
* Set up the server to allow static content, cookies, session, and
* parsing the server. Also, we initialize authentication and our
* routing mechanism.
*
*/
app.configure(function() {
app.use('/static', express.static(__dirname + "/webapp"));
app.use(express.cookieParser());
app.use(express.bodyParser());
app.use(express.session({
secret: 'keyboard cat'
}));
app.use(passport.initialize());
app.use(passport.session());
app.use(app.router);
});
/**
* This lets authentication know how it should store
* and grab users from a request to pass to a mapping
* function.
*/
passport.serializeUser(function (user, done) {
done(null, user._id);
});
passport.deserializeUser(function (id, done) {
Users.findOne({
_id: db.bson.ObjectID(id)
}, function (err, user) {
done(err, user);
});
});
/**
* This sets up which authentication strategies we support.
* as of right now, LocalStrategy (our own username/password)
* is all we support.
*
*/
passport.use(new LocalStrategy(
function (username, password, done) {
Users.findOne({
username: username
}, function (err, user) {
if (err) {
return done(err);
}
if (!user) {
return done(null, false, {
message: 'Incorrect username.'
});
}
if (!(user.password == password)) {
return done(null, false, {
message: 'Incorrect password.'
});
}
console.info(user.password + " " + password.yellow);
console.info(!(user.password == password).yellow);
console.info(user._id);
return done(null, user);
});
}));
/**
* Path mapping
*/
// Index mapping
app.get('/', function (req, resp) {
resp.render('index', {
title: "Welcome!"
});
});
// Allow login, and set up the dependency for passport.
Login.setPassport(passport);
app.get("/login", Login.loginForm);
app.get("/login/error", Login.loginForm);
app.post('/login', passport.authenticate('local', function (req, res, next) {
passport.authenticate('local', function (err, user, info) {
// This is the default destination upon successful login.
var redirectUrl = '/people';
if (err) {
return next(err);
}
if (!user) {
return res.redirect('/');
}
// If we have previously stored a redirectUrl, use that,
// otherwise, use the default.
if (req.session.redirectUrl) {
redirectUrl = req.session.redirectUrl;
req.session.redirectUrl = null;
}
req.logIn(user, function (err) {
if (err) {
return next(err);
}
});
res.redirect(redirectUrl);
})(req, res, next);
}));
app.get('/logout', Login.logout);
// People Controller has a dependency on the Passport library
People.setPassport(passport);
// These are our definitions for paths the People Controller can handle.
app.get("/people", People.list);
app.get("/people/:id", People.get);
// These are the error handler mappings.
app.use(function (req, res, next) {
// the status option, or res.statusCode = 404
// are equivalent, however with the option we
// get the "status" local available as well
res.render('404', {
status: 404,
url: req.url
});
});
app.use(function (err, req, res, next) {
// we may use properties of the error object
// here and next(err) appropriately, or if
// we possibly recovered from the error, simply next().
console.error(("ERROR: " + err.toString()).red);
res.render('500', {
status: err.status || 500,
error: err
});
});
app.listen(3000);
console.info('The Clancy server is listening on port: 3000'.green);
- लोग नियंत्रक
/**
* People Controller
*/
var db = require('../lib/db');
var auth = require('../lib/authUtils');
/**
* People constructor.
* ===================
* The people constructor has dependencies on the database,
* and on the Passport middleware. The db object doesn't
* care about maintaining state, so we can just include that
* here, however the Passport plugin needs to have all of the
* stuff the server defines. So, it's passed in.
*/
function People(){
var passport;
}
People.prototype = {
list: function(req, resp){
auth.ensureAuth(req, resp);
console.info("user info: " + user._id);
resp.render('index', {
title: "User",
users: [1,2,3]
});
},
get: function(req, resp){
console.log('> get person' + req.params.id);
db.users.find({_id: db.bson.ObjectID(id)}, function(err, users){
if(err || !users) console.log("No user found");
resp.send(users);
});
},
setPassport: function(pass){
this.passport = pass;
},
getPassport: function(){
return this.passport;
}
}
module.exports = new People();
- लॉगिन नियंत्रक
/**
* People Controller
*/
/**
* Login constructor.
* ===================
* The Login constructor has dependencies on the Passport middleware.
* The db object doesn't care about maintaining state, so we can just
* include that here, however the Passport plugin needs to have all
* of the stuff the server defines. So, it's passed in.
*/
function Login(){
var passport;
}
var l = Login.prototype;
Login.prototype = {
loginForm: function(req, resp){
var url = require('url').parse(req.url, true);
console.info('url string: ' + url.pathname.yellow);
if(url.pathname === '/login/error')
{
resp.render('login', {
title: "Login to FormPickle.com",
message: "Your username or password was incorrect."
});
}
console.info('Trying to login'.yellow);
resp.render('login', {
title: "Login to FormPickle.com",
message: ""
});
},
setPassport: function(pass){
l.passport = pass;
},
getPassport: function(){
return l.passport;
},
logout: function(req, resp){
req.logout();
resp.render('logout');
}
}
module.exports = new Login();
- डीबी मिडिलवेयर
/**
* DB
*/
var databaseURI = "localhost:27017/clancy";
var collections = ["users", "forms"];
var db = require("mongojs").connect(databaseURI, collections);
module.exports = db;
- AuthUtils.js
/***
* Define a middleware function for authenticated routes to store the original URL
*
*/
function Auth(){
};
Auth.prototype = {
ensureAuth: ensureAuthenticated(req, resp, next)
}
var ensureAuthenticated = function (req, res, next) {
if (req.isAuthenticated()) { return next(); }
// If the user is not authenticated, then we will start the authentication
// process. Before we do, let's store this originally requested URL in the
// session so we know where to return the user later.
req.session.redirectUrl = req.url;
// Resume normal authentication...
logger.info('User is not authenticated.');
req.flash("warn", "You must be logged-in to do that.");
res.redirect('/login');
}
module.exports = new Auth();
अग्रिम में तुम लोगों को धन्यवाद। मैं StackOverflow पर समुदाय से प्यार करता हूँ। प्रौद्योगिकी के एक नए टुकड़े सीखते समय आप हमेशा बहुत ही भयानक होते हैं।
केवल एक टिप्पणी, यदि स्थिर फाइलों को प्रस्तुत करने के लिए एक्सप्रेस कॉन्फ़िगर किया जा सकता है तो इसका मतलब यह नहीं है कि यह सबसे अच्छा समाधान है, आप आमतौर पर nginx का उपयोग करते हैं यह उद्देश्य –
समझा। यह सिर्फ एक प्रारंभिक पास सेट है। मैं बाद में स्थैतिक सामग्री के लिए एक HTTP सर्वर में परिवर्तित कर दूंगा। –
टीजे होलोवाचुक में [उदाहरण]] (https://github.com/visionmedia/express/tree/master/examples/mvc) एक्सप्रेस का उपयोग कर एमवीसी के कार्यान्वयन के – verybadalloc