db.on('error',function(err){
console.log('DB error : ', err);
});
//view setting
app.set("view engine", 'ejs');
//set middlewares
app.use(express.static(path.join(__dirname, 'public')));
app.use(badyParser.json());
app.use(badyParser.urlencoded({extended:true}));
app.use(methodOverride("_method"));
app.use(flash());
app.use(session({secret:'MySecret'}));
//passport
var passport = require('./config/passport');
app.use(passport.initialize());
app.use(passport.session());
// routes
app.use('/', require('./routes/home'));
app.use('/users', require('./routes/users'));
app.use('/posts', require('./routes/posts'));
//start server
var express = require('express');
var bodyParser = require('body-parser');
var session = require('express-session');
var app = express();
app.use(session({secret: 'something awesome'}));
app.use(bodyParser.urlencoded({ extended:false }));
var isAuthenticated = function(req, res, next) {
if(req.session.logged_in === true) {
return next();
}
else {
return res.redirect('/login');
}
};
app.post('/login', function(req, res) {
if(req.body.username == 'cahlan' && req.body.password == 'test') {
req.session.logged_in = true;
return res.redirect('/');
}
else {
return res.redirect('/login?error=bad_password');
}
});
app.get('/', isAuthenticated, function(req, res) {
res.sendFile(__dirname+'/public/index.html');
});
var io = require('socket.io').listen(server);
// other config
app.use(express.static(__dirname + '/public'));
app.use(morgan('dev'));
app.use(methodOverride());
app.use(bodyParser.urlencoded({'extended':'true'}));
app.use(bodyParser.json());
app.use(bodyParser.json({ type: 'application/vnd.api+json' }));
app.use(cookieParser());
app.use(session({
secret: process.env.SESSION_SECRET,
maxAge: new Date(253402300000000), // don't expire any time soon
store: new RedisStore({client: redisClient}),
resave: false,
saveUninitialized: false
}));
app.use(passport.initialize());
app.use(passport.session());
// passport config
var User = require('./app/models/user')(io);
passport.use(new LocalStrategy(User.authenticate()));
passport.serializeUser(User.serializeUser());
passport.deserializeUser(User.deserializeUser());
var express = require('express'); //installed
var session = require('express-session');
var nodemailer = require("nodemailer"); // installed
var bodyParser = require('body-parser'); //installed
var passport = require('passport'); //installed
var LocalStrategy = require('passport-local').LocalStrategy //installed
var mongoose = require('mongoose'); //installed
mongoose.connect('mongodb://localhost/PreSchool');
var app = express();
app.use(express.static(__dirname + '/public'));
app.use(bodyParser.json());
app.use(session({
secret: 'MissKatiePreSchool2015', saveUninitialized: true, resave: true
}));
app.use(passport.initialize());
app.use(passport.session());
app.listen(9898, function(){
console.log("Express Started on Port 9898");
});
},
function(accessToken, refreshToken, profile, done) {
console.log(profile);
}
));
var app = express();
app.set('views', __dirname + '/views');
app.set('view engine', 'jade');
//app.use(express.logger());
app.use(cookieParser());
app.use(bodyParser());
app.use(methodOverride());
app.use(session({ secret: '__QwerTy.bone;-__' }));
//app.use(passport.initialize());
//app.use(passport.session());
app.use(express.static(__dirname + '/public'));
app.get('/', routes.index);
['facebook']
.forEach(function(social) {
app.get(
'/auth/' + social,
passport.authenticate(social),
function(req, res) {}
);
app.get(
'/auth/' + social + '/callback',
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
app.use(compress());
app.use(connectAssets({
paths: [path.join(__dirname, 'public/css'), path.join(__dirname, 'public/js')]
}));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(expressValidator());
app.use(methodOverride());
app.use(cookieParser());
app.use(session({
resave: true,
saveUninitialized: true,
secret: secrets.sessionSecret,
store: new MongoStore({ url: secrets.db, auto_reconnect: true })
}));
app.use(passport.initialize());
app.use(passport.session());
app.use(flash());
app.use(function(req, res, next) {
// CSRF protection.
if (_.contains(csrfExclude, req.path)) return next();
csrf(req, res, next);
});
app.use(function(req, res, next) {
// Make user object available in templates.
res.locals.user = req.user;
next();
});
sessStore.on('connect', function() {
app.use(cookieParser());
app.use(session({
secret: secret,
saveUninitialized: true,
resave: true,
store: sessStore
}));
app.use(function(req, res, next) {
var uid = req.session.id;
if (req.session.uid == null) {
req.session.uid = uid;
console.log('Anonymous user connected. Assigned uid: %s', uid);
userStates[uid] = userStateFactory(uid).init();
}
next();
});
app.use(express.static(__dirname + '/public'));
var userSockets = {};
io.on('connection', function(socket) {
cookieParser(secret, {})(socket.handshake, {}, function (parseErr) {
var uid = socket.handshake.signedCookies['connect.sid'];
var s = userStates[uid];
userSockets[uid] = socket;
var sock = function() { return userSockets[uid]; };
if (s != null) {
var scanProgress = s.progress('progress:scan');
var scanListener = function(value) {
sock().emit('scan', value);
if (value.progress >= 100) {
scanProgress.setValue(0, function() {
s.scan(function(err, results) {
sock().emit('scanResults', results);
});
});
}
};
scanProgress.on('update', scanListener);
var accountListener = function(value) {
sock().emit('account', value);
};
s.on('account', accountListener);
sock().on('itJobs', function(amount) { s.payForItJob(amount); });
sock().on('scan', function() {
scanProgress.start();
});
sock().on('startHacking', function(ip) {
s.startHacking(ip);
});
sock().on('stopHacking', function(ip) {
s.stopHacking(ip);
});
var hackingListener = function(evt) {
sock().emit('hacking', evt);
};
s.on('hacking', hackingListener);
sock().on('moveToHacking', function(ip) {
s.moveToHacking(ip, function() {
sock().emit('movedToHacking', ip);
});
});
sock().on('removeFromHacking', function(ip) {
s.removeFromHacking(ip, function() {
socket.emit('removedFromHacking', ip);
});
});
sock().on('disconnect', function() {
// scanProgress.removeListener('update', scanListener);
s.removeListener('account', accountListener)
.removeListener('hacking', hackingListener)
.destroy();
delete userSockets[uid];
});
s.getMainState(function(err, state) {
sock().emit('mainState', state);
});
}
});
});
http.listen(httpPort, function() {
console.log('listening on *:%d', httpPort);
});
});
var dburl = 'mongodb://localhost/movie';
mongoose.connect(dburl);
app.set('views','./app/views/pages');
app.set('view engine','jade');
// parse application/x-www-form-urlencoded
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ 'extended': true }));
// session
app.use(cookieParser());
app.use(session({
secret : 'movie',
store : new mongoStore({
url : dburl,
collection: 'sessions'
})
}));
if('development' === app.get('env')){
app.set('showStackError',true);
app.use(morgan('dev'));
app.locals.pretty = true;
mongoose.set('debug',true);
}
require('./config/routes')(app);
app.use(express.static(path.join(__dirname,'public')))
app.locals.moment = require('moment');
var User = require('./app/models/user');
var Links = require('./app/collections/links');
var Link = require('./app/models/link');
var Click = require('./app/models/click');
var app = express();
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');
app.use(partials());
app.use(cookieParser());
app.use(expressSession({
key: "mysite.sid.uid.whatever",
secret: 'secret',
cookie: {
maxAge: 2678400000 // 31 days
},
}));
// Parse JSON (uniform resource locators)
app.use(bodyParser.json());
// Parse forms (signup/login)
app.use(bodyParser.urlencoded({ extended: true }));
app.use(express.static(__dirname + '/public'));
app.get('/', checkUser,
function(req, res) {
res.render('index');
});
init: function (attr) {
/* attrs:
app - express app
config - application config data
*/
var app = attr.app
, config = attr.config
;
// express session configuration
// ----------------------------------------------------
app.use(cookieParser(config.COOKIE_SECRET));
// redis-based session
if (config.SESSION_STORE == 'RedisStore') {
console.log('Auth.express_config: using RedisStore for sessions.');
var RedisStore = require('connect-redis')(session);
app.use(session({
resave: true,
saveUninitialized: true,
secret: config.SESSION_SECRET,
name: config.SESSION_NAME,
cookie: { maxAge: 86400 * 365 * 10 * 1000, path: '/' },
store: new RedisStore({
port: config.REDIS_SESSION_PORT,
host: config.REDIS_SESSION_HOST,
auth_pass: config.REDIS_SESSION_AUTH
}),
}));
// mongodb-based session
} else if (config.SESSION_STORE == 'MongoStore'){
console.log('Auth.express_config: using connect-mongo for sessions.');
var MongoStore = require('connect-mongo')(session);
app.use(session({
resave: true,
saveUninitialized: true,
secret: config.SESSION_SECRET,
name: config.SESSION_NAME,
cookie: { maxAge: 86400 * 365 * 10 * 1000, path: '/' },
store: new MongoStore({
url: config.MONGODB_SESSION_URL,
autoReconnect: true
})
}));
}
// passport authorization configuration
// ----------------------------------------------------
app.use(passport.initialize());
app.use(passport.session());
// anon strategy
//passport.use(new AnonStrategy());
// google strategy
passport.use(new GoogleStrategy({
clientID: config.GOOGLE_CLIENT_ID,
clientSecret: config.GOOGLE_CLIENT_SECRET,
callbackURL: config.GOOGLE_REDIRECT_URL
},
function(accessToken, refreshToken, profile, cb) {
console.log('Auth.express_config: google login with id=' + profile.id);
//return cb(null, { googleId: profile.id });
// find or create
UserModel.findOne({ 'googleId': profile.id }, 'googleId', function (err, user) {
// current user
if (user) {
return cb(err, user);
// new user
} else {
// create a user
var newUser = new UserModel({
googleId: profile.id,
name: profile.displayName,
image_url: (profile.photos && profile.photos[0] ? profile.photos[0].value : undefined)
});
newUser.save(function (err, user) {
if (err) { console.error(err); }
return cb(err, user);
});
}
}); // END find User
}
)); // END google strategy
// local strategy
passport.use(new LocalStrategy(
function(username, password, cb) {
console.log('Auth.express_config: local login with username ' + username);
// find or create
UserModel.findOne({ 'localId': username }, 'localId', function (err, user) {
// current user
if (user) {
return cb(err, user);
// new user
} else {
// create a user
var newUser = new UserModel({
localId: username,
name: username,
password: Math.floor(100000000 + Math.random() * 900000000) // 9 digit random number
});
newUser.save(function (err, user) {
if (err) { console.error(err); }
return cb(err, user);
});
}
}); // END find User
User.findOne({ username: username }, function (err, user) {
if (err) { return cb(err); }
if (!user) { return cb(null, false); }
if (!user.verifyPassword(password)) { return cb(null, false); }
return cb(null, user);
});
}
));
passport.serializeUser(function(user, done) {
done(null, user);
});
passport.deserializeUser(function(user, done) {
done(null, user);
});
}
mdb.initialize(function (err) {
// Store session data in the mongo database; this is needed if we're
// going to have multiple web servers sharing a single db
var MongoStore = require('connect-mongo')(session);
var theSession = session({
secret: cookieSecret,
resave: false,
saveUninitialized: false,
store: new MongoStore({ mongooseConnection: mdb.mongoose.connection })
});
app.use(theSession);
console.log( "Session setup." );
passport.use(login.localStrategy(rootUrl));
passport.use(login.googleStrategy(rootUrl));
passport.use(login.twitterStrategy(rootUrl));
passport.use(login.courseraStrategy(rootUrl));
passport.use(login.ltiStrategy(rootUrl));
passport.use(login.githubStrategy(rootUrl));
// Only store the user _id in the session
passport.serializeUser(function(user, done) {
done(null, user._id);
});
passport.deserializeUser(function(id, done) {
mdb.User.findOne({_id: new mongo.ObjectID(id)}, function(err,document) {
done(err, document);
});
});
// Middleware for all environments
function addDatabaseMiddleware(req, res, next) {
//req.db = db;
if ('user' in req)
res.locals.user = req.user;
else {
res.locals.user = req.user = {};
}
next();
}
app.version = require('./package.json').version;
//app.use(versionator.middleware);
app.use('/public', express.static(path.join(__dirname, 'public')));
app.use('/node_modules', express.static(path.join(__dirname, 'node_modules')));
//app.locals.versionPath = versionator.versionPath;
//console.log( versionator.versionPath('/template/test') );
app.use(api.authenticateViaHMAC);
app.use(passport.initialize());
app.use(passport.session());
//app.get('/xake', api.authenticateViaHMAC);
//app.get('/api/xake', api.xake);
//app.put( '/activity/:commit/:path(*)', api.authenticateViaHMAC);
app.put( '/activity/:commit/:path(*.png)', api.putFile );
app.put( '/activity/:commit/:path(*.css)', api.putFile );
app.put( '/activity/:commit/:path(*.js)', api.putFile );
app.put( '/activity/:commit/:path(*.tex)', api.putFile );
app.put( '/activity/:commit/:path(*.jpg)', api.putFile );
app.put( '/activity/:commit/:path(*.pdf)', api.putFile );
app.put( '/activity/:commit/:path(*.svg)', api.putFile );
app.put( '/activity/:commit/:path(*)', api.putActivity );
app.put( '/course/:commit/:path(*)', api.putXourse );
app.put( '/repos/:owner/:repo/git/commits/:sha', api.verifyCollaborator );
app.put( '/repos/:owner/:repo/git/commits/:sha', api.putCommit );
app.put( '/commits/:sha', api.putBareCommit );
//app.put( '/activity/:commit/:path(*.tex)', api.authenticateViaHMAC);
//app.put( '/activity/:commit/:path(*.tex)', api.putTex );
app.use(login.guestUserMiddleware);
app.use(addDatabaseMiddleware);
// Middleware for development only
if ('development' == app.get('env')) {
app.use(errorHandler());
}
// Setup routes.
// TODO: Move to separate file.
app.get('/users/xarma', score.getXarma);
app.get('/users/xudos', score.getXudos);
app.post('/users/xarma', score.postXarma);
app.post('/users/xudos', score.postXudos);
// Requires the rawBody middleware above
github.secret = process.env.GITHUB_WEBHOOK_SECRET;
app.post('/github', github.github);
app.get('/', routes.index);
app.get('/users/me', user.getCurrent);
//app.get('/users/profile', user.currentProfile);
//app.get('/users/:id/profile', user.profile);
app.get('/users/:id', user.get);
app.get('/users/:id/edit', user.edit);
app.post('/users/:id', user.update);
app.get('/users/', user.index);
app.get('/users/page/:page', user.index); // pagination in Mongo is fairly slow
app.delete('/users/:id/google', function( req, res ) { user.deleteLinkedAccount( req, res, 'google' ); } );
app.delete('/users/:id/coursera', function( req, res ) { user.deleteLinkedAccount( req, res, 'coursera' ); } );
app.delete('/users/:id/github', function( req, res ) { user.deleteLinkedAccount( req, res, 'github' ); } );
app.delete('/users/:id/twitter', function( req, res ) { user.deleteLinkedAccount( req, res, 'twitter' ); } );
app.put('/users/:id/secret', function( req, res ) { user.putSecret( req, res ); } );
// BADBAD: this should probably be a PUT since it changes state
app.get('/users/:id/courses/:owner/:repo', function( req, res ) { user.courses( req, res ); } );
app.get( '/course/calculus-one/', function( req, res ) { res.redirect('/about/plans'); });
app.get( '/course/calculus-one', function( req, res ) { res.redirect('/about/plans'); });
app.get( '/course/calculus-two/', function( req, res ) { res.redirect('/about/plans'); });
app.get( '/course/calculus-two', function( req, res ) { res.redirect('/about/plans'); });
app.get( '/course/multivariable/', function( req, res ) { res.redirect('/about/m2o2c2'); });
app.get( '/course/multivariable', function( req, res ) { res.redirect('/about/m2o2c2'); });
//app.get('/course/', course.index );
app.get( '/course', function( req, res ) { res.redirect(req.url + '/'); });
app.get( '/courses', function( req, res ) { res.redirect('/course/'); });
app.get( '/courses/', function( req, res ) { res.redirect('/course/'); });
app.get( '/course/:commit([0-9a-fA-F]+)/', course.xourseFromCommit, course.tableOfContents );
app.get( '/course/:username/:repository/', course.xourseFromUserAndRepo, course.tableOfContents );
app.get( '/course/:username/:repository/:branch/', course.xourseFromUserAndRepo, course.tableOfContents );
var appXimera = function( regexp, callback ) {
app.get( '/:noun(course|activity)/:commit([0-9a-fA-F]+)/:path(' + regexp + ')', course.objectFromCommit, callback );
app.get( '/:noun(course|activity)/:username/:repository/:path(' + regexp + ')', course.objectFromUserAndRepo, callback );
app.get( '/:noun(course|activity)/:username/:repository/:branch/:path(' + regexp + ')', course.objectFromUserAndRepo, callback );
};
appXimera( '*.tex', course.source );
// SVG files will only be rendered if they are sent with content type image/svg+xml
appXimera( '*.svg', course.file('image/svg+xml') );
appXimera( '*.png', course.file('image/png') );
appXimera( '*.pdf', course.file('image/pdf') );
appXimera( '*.jpg', course.file('image/jpeg') );
appXimera( '*.js', course.file('text/javascript') );
appXimera( '*.css', course.file('text/css') );
appXimera( '*', course.activity );
app.get( '/course/:commit([0-9a-fA-F]+)$' ,function( req, res ) { res.redirect(req.url + '/'); });
app.get( '/course/:username/:repository', function( req, res ) { res.redirect(req.url + '/'); });
app.get( '/course/:username/:repository/:branch', function( req, res ) { res.redirect(req.url + '/'); });
app.get( '/statistics/:commit/:hash/answers', course.answers );
app.get( '/statistics/:commit/:hash/successes', course.successes );
//app.head( '/activity/:commit/:path(*.png)', course.imageHead );
//app.head( '/activity/:commit/:path(*.jpg)', course.imageHead );
//app.head( '/activity/:commit/:path(*.pdf)', course.imageHead );
//app.head( '/activity/:commit/:path(*.svg)', course.imageHead );
app.head( '/activity/:commit/:path(*)', course.activityByHashHead );
// TinCan (aka Experience) API
app.post('/xAPI/statements', tincan.postStatements);
// Instructor paths
app.get(/^\/instructor\/course\/(.+)\/activity\/(.+)\/$/, instructor.instructorActivity );
app.get('/instructor/activity-analytics/:id', instructor.activityAnalytics);
// Coursera login.
app.get('/auth/coursera',
passport.authenticate('oauth'));
app.get('/auth/coursera/callback',
passport.authenticate('oauth', { successRedirect: '/just-logged-in',
failureRedirect: '/auth/coursera'}));
// Google login.
app.get('/auth/google', passport.authenticate('google-openidconnect'));
app.get('/auth/google/callback',
passport.authenticate('google-openidconnect', { successRedirect: '/just-logged-in',
failureRedirect: '/auth/google'}));
// Permit local logins when on a test machine
if (app.locals.deployment != 'production') {
app.post('/auth/local',
passport.authenticate('local', { failureRedirect: '/' }),
function(req, res) {
res.redirect('/');
});
}
// Twitter login.
app.get('/auth/twitter', passport.authenticate('twitter'));
app.get('/auth/twitter/callback',
passport.authenticate('twitter', { successRedirect: '/just-logged-in',
failureRedirect: '/auth/twitter'}));
// GitHub login.
app.get('/auth/github', passport.authenticate('oauth2'));
app.get('/auth/github/callback',
passport.authenticate('oauth2', { successRedirect: '/just-logged-in',
failureRedirect: '/',
failureFlash: true}));
// LTI login
app.post('/lti', passport.authenticate('lti', { successRedirect: '/just-logged-in',
failureRedirect: '/'}));
app.get('/logout', function (req, res) {
req.logout();
res.redirect('/');
});
app.get('/just-logged-in', function (req, res) {
if (req.user.course) {
console.log( "course = ", req.user.course);
res.redirect( req.user.course );
} else {
if (req.user.lastUrlVisited && (req.user.lastUrlVisited != "/") && (!(req.user.lastUrlVisited.match(/\.svg$/)))) {
console.log( "lastUrlVisited = ", req.user.lastUrlVisited);
res.redirect(req.user.lastUrlVisited);
} else
res.redirect('/');
}
});
app.get('/mailing-list', function( req, res ) {
fs.appendFile( 'emails.txt', req.query['email'] + "\n", function(err) { return; });
res.send(200);
});
app.get('/about', about.index);
app.get('/about/team', about.team);
app.get('/about/workshop', about.workshop);
app.get('/about/contact', about.contact);
app.get('/about/faq', about.faq);
app.get('/about/who', about.who);
app.get('/about/plans', about.plans);
app.get('/about/xarma', about.xarma);
app.get('/about/xudos', about.xudos);
app.get('/about/m2o2c2', about.m2o2c2);
app.get('/about/supporters', function( req, res ) { res.redirect('/about/support'); });
app.get('/about/support', about.support);
//app.get('/template/:templateFile', template.renderTemplate);
//app.get('/template/forum/:templateFile', template.renderForumTemplate);
var state = require('./routes/state.js')(null);
app.get('/state/:activityHash', state.get);
app.put('/state/:activityHash', state.put);
app.delete('/state/:activityHash', state.remove);
app.put('/completion/:activityHash', state.completion);
app.get('/users/:id/completions', state.getCompletions);
app.get('/commits/:hash/activities', course.getActivitiesFromCommit );
app.get('/image/:hash', mongoImage.get);
app.locals.moment = require('moment');
app.locals._ = require('underscore');
app.locals.deployment = process.env.DEPLOYMENT;
// Setup blogs
var Poet = require('poet')
var poet = Poet(app, {
posts: './blog/', // Directory of posts
postsPerPage: 5, // Posts per page in pagination
readMoreLink: function (post) {
// readMoreLink is a function that
// takes the post object and formats an anchor
// to be used to append to a post's preview blurb
// and returns the anchor text string
return '<a href="' + post.url + '">Read More »</a>';
},
readMoreTag: '<!--more-->', // tag used to generate the preview. More in 'preview' section
routes: {
'/blog/post/:post': 'blog/post',
'/blog/page/:page': 'blog/page',
'/blog/tag/:tag': 'blog/tag',
'/blog/category/:category': 'blog/category'
}
});
app.get( '/blog', function ( req, res ) { res.render( 'blog/index' ); });
poet.init().then( function() {
// Start HTTP server for fully configured express App.
var server = http.createServer(app);
var ios = require('socket.io-express-session');
var io = require('socket.io')(server);
io.use(ios(theSession, cookieParser(cookieSecret)));
// Setup forum rooms
/*
var forum = require('./routes/forum.js')(socket);
app.post('/forum/upvote/:post', forum.upvote);
app.post('/forum/flag/:post', forum.flag);
app.get(/\/forum\/(.+)/, forum.get);
app.post(/\/forum\/(.+)/, forum.post);
app.put('/forum/:post', forum.put);
app.delete('/forum/:post', forum.delete);
*/
if(!module.parent){
server.listen(app.get('port'), function(stream){
console.log('Express server listening on port ' + app.get('port'));
});
}
io.on('connection', function (socket) {
// join to room and save the room name
socket.on('join room', function (room) {
socket.join(room);
});
socket.on('send', function (data) {
socket.sockets.emit('message', data);
});
socket.on('activity', function (activityHash) {
var userId = socket.handshake.session.guestUserId;
if (socket.handshake.session.passport) {
userId = socket.handshake.session.passport.userId || userId;
}
socket.join(activityHash + '/' + userId);
});
/*
socket.on('persistent-data', function (data) {
var userId = socket.handshake.session.guestUserId;
if (socket.handshake.session.passport) {
userId = socket.handshake.session.passport.userId || userId;
}
if (socket.handshake.session.userdata)
socket.handshake.session.userdata = socket.handshake.session.userdata + 1;
else
socket.handshake.session.userdata = 0;
socket.to(data.activityHash + '/' + userId).emit('persistent-data', data);
});
*/
});
// If nothing else matches, it is a 404
app.use(function(req, res, next){
res.render('404', { status: 404, url: req.url });
});
});
});
module.exports = function(app) {
var env = app.get('env');
app.set('views', config.root + '/server/views');
app.engine('html', require('ejs').renderFile);
app.set('view engine', 'html');
app.use(compression());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.use(methodOverride());
app.use(cookieParser());
// Persist sessions with mongoStore / sequelizeStore
// We need to enable sessions for passport-twitter because it's an
// oauth 1.0 strategy, and Lusca depends on sessions
app.use(session({
secret: config.secrets.session,
saveUninitialized: true,
resave: false,
store: new mongoStore({
mongooseConnection: mongoose.connection,
db: 'easy-stock'
})
}));
/**
* Lusca - express server security
* https://github.com/krakenjs/lusca
*
if ('test' !== env) {
app.use(lusca({
csrf: {
angular: true
},
xframe: 'SAMEORIGIN',
hsts: {
maxAge: 31536000, //1 year, in seconds
includeSubDomains: true,
preload: true
},
xssProtection: true
}));
}
*/
app.set('appPath', path.join(config.root, 'client'));
if ('production' === env) {
app.use(favicon(path.join(config.root, 'client', 'favicon.ico')));
app.use(express.static(app.get('appPath')));
app.use(morgan('dev'));
}
if ('development' === env) {
app.use(require('connect-livereload')());
}
if ('development' === env || 'test' === env) {
app.use(express.static(path.join(config.root, '.tmp')));
app.use(express.static(app.get('appPath')));
app.use(morgan('dev'));
app.use(errorHandler()); // Error handler - has to be last
}
};
app.use(sass({
src: path.join(__dirname, 'public'),
dest: path.join(__dirname, 'public'),
sourceMap: true
}))
app.use(logger('dev'))
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({ extended: true }))
app.use(expressValidator())
app.use(methodOverride())
app.use(cookieParser())
app.use(session({
resave: true,
saveUninitialized: true,
secret: process.env.SESSION_SECRET,
store: new MongoStore({
url: process.env.MONGODB || process.env.MONGOLAB_URI,
autoReconnect: true
})
}))
app.use(passport.initialize())
app.use(passport.session())
app.use(flash())
app.use(function (req, res, next) {
if (req.path === '/api/upload') {
next()
} else {
lusca.csrf()(req, res, next)
}
})
app.use(lusca.xframe('SAMEORIGIN'))
rootRequire('config/environments')(app);
app.set('io', require('socket.io').listen(httpServer));
var conString = process.env.DATABASE_URL || "postgres://postgres@localhost/forum";
var Sequelize = require('sequelize');
var sequelize = new Sequelize(conString);
app.use(compression());
app.use(cookieParser());
app.use(session({
store: new pgSession({
pg: pg,
conString: conString,
tableName: 'session'
}),
secret: app.get('sessionSecret') || 'w!** *1*h',
cookie: { maxAge: 365 * 24 * 60 * 60 * 1000 }, // 1 year
resave: false,
saveUninitialized: false
}));
rootRequire('lib/authentication');
app.use(passport.initialize());
app.use(passport.session());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: true}));
app.use(multer());
rootRequire('config/routes')(app, passport);
module.exports = function( app ) {
//Compresses the document
app.use ( compression({
threshold :512
}));
/* // Static files middleware
app.use(express.static(config.root + '/public'));
*/
// bodyParser should be above methodOverride
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(cookieParser(config.sessionSecret));
app.use(cookieSession({secret : config.sessionSecret, cookie :{maxAge :1}}));
app.use(session({
secret : config.sessionSecret,
proxy : true,
resave : true,
saveUninitialized : true,
cookie: {
maxAge : 360*5//10800 * 1000//3 Hour
// expires : new Date(Date.now() + 300000) //1 Hour
}
}));
// use passport session
app.use(passport.initialize());
app.use(passport.session());
utilities.walk('./routes/').forEach(function(routePath) {
require(path.resolve(routePath))(app);
});
//For error Handling, always keep in the end
/**
* Error handling
*/
// app.use(function (err, req, res, next) {
// // treat as 404
// if (err.message
// && (~err.message.indexOf('not found')
// || (~err.message.indexOf('Cast to ObjectId failed')))) {
// return next();
// }
// console.error(err.stack);
// // error page
// res.status(500);
// res.send({
// "status" : "error",
// "result" : err.message
// });
// });
//
// // assume 404 since no middleware responded
// app.use(function (req, res, next) {
// res.status(404).send({
// "status" : "error",
// "result" : "404"
// });
// });
};
// Enable logging requests to console in development mode only
if (app.get('env') == 'development')
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(expressValidator());
app.use(methodOverride());
app.use(cookieParser());
app.use(session({
resave: true,
saveUninitialized: true,
secret: config.secrets.sessionSecret,
store: new MongoStore({
url: config.secrets.db,
auto_reconnect: true
}),
cookie: {
maxAge: 4 * week
}
}));
app.use(passport.initialize());
app.use(passport.session());
app.use(flash());
app.use(function(req, res, next) {
// CSRF protection
// Skip CSRF protection for white listed URLs
if (_.contains(csrfExclude, req.path)) return next();
// Skip CSRF protection for calls to the API (valid API Key required instead)
if ((/^\/api/).test(req.path)) {
res.locals._csrf = "undefined";
helpers:{
section:function(name,options){
if(!this._sections) this._sections={};
this._sections[name]=options.fn(this);
return null;
}
}
});
app.engine('handlebars',handlebars.engine);
//app.use(cookieParser());
app.use(session({
genid:function(req){
return uuid.v1();
},
secret:'keyboard cat',
resave:false,
saveUnitialized:true,
cookie:{secure:true, maxAge:60000}
}));
app.use(compression());
app.use(express.static(__dirname+'/public',{maxAge:86400000}));
app.set('view engine','handlebars');
app.set('port',process.env.PORT || 3000);
app.disable('x-powered-by');
app.set('etag',function(body,encoding){
return require('crypto').createHash('md5').update(body).digest('hex');
});
app.use(function (req,res,next) {
privateKey: "2fe365ec06cdba5e0b5933c5ccb4989a"
});
var mongoUri = process.env.MONGOLAB_URI || 'mongodb://localhost/thesortclub';
mongoose.connect(mongoUri);
require('./config/passport')(passport);
app.get("/client_token", function (req, res) {
gateway.clientToken.generate({}, function (err, response) {
res.send(response.clientToken);
});
});
app.use(cookieParser('keyboard cat'));
app.use(session({ cookie: { maxAge: 60000 }}));
app.use(flash());
app.set('view engine', ejs)
app.use(function(req, res, next) {
res.locals.messages = req.flash();
next();
});
app.use(methodOverride(function(req, res){
if (req.body && typeof req.body === 'object' && '_method' in req.body) {
var method = req.body._method
delete req.body._method
return method
}
at: 'finished',
status: res.statusCode,
method: req.method,
url: req.originalUrl,
})
})
next()
})
app.use(cookieParser(process.env.COOKIE_SECRET))
app.use(session({
secret: process.env.COOKIE_SECRET,
cookie: {
secure: useSSL,
},
store: KnexSessionStore,
resave: false,
saveUninitialized: false,
}))
app.use(passport.initialize())
app.use(passport.session())
passport.use(new EveOnlineStrategy({
clientID: process.env.EVE_OAUTH_CLIENT_ID,
clientSecret: process.env.EVE_OAUTH_SECRET_KEY,
callbackURL: process.env.CANONICAL_URL + process.env.EVE_OAUTH_CALLBACK,
},
function(characterInformation, done) {
debug('eve:auth', characterInformation)
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'hbs');
// uncomment after placing your favicon in /public
//app.use(favicon(__dirname + '/public/favicon.ico'));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser(setting.cookie_secret));
app.use(express.static(path.join(__dirname, 'public')));
// session setup
app.use(session({
secret: setting.session_secret,
resave: false,
saveUninitialized: false,
cookie: { maxAge: 60*60*1000 }
}));
//middleware to catch all the request
app.use(function (req, res, next) {
console.log('**********Time: %d**********', Date.now());
next();
});
app.use(auth.authUser);
app.use('/', routes);
// catch 404 and forward to error handler
app.use(function(req, res, next) {
models.USERS = db.models.USERS;
models.HOMEWORKS = db.models.HOMEWORKS;
models.HOMEWORK_PROBLEMS = db.models.HOMEWORK_PROBLEMS;
models.HOMEWORK_HISTORIES = db.models.HOMEWORK_HISTORIES;
models.HOMEWORK_FILES = db.models.HOMEWORK_FILES;
db.sync(function (err) {
if (err) console.log(err);
next();
});
});
}
}));
app.use(session({
secret: 'NodejsAtSigma',
resave: false,
saveUninitialized: false
}));
app.use(passport.initialize());
app.use(passport.session());
app.use(express.static(path.join(__dirname, 'public')));
app.use('/', routes);
app.use('/users', users);
// passport config
passport.use(new LocalStrategy({ passReqToCallback: true }, function (req, username, password, done) {
console.log("hey!");
req.models.USERS.find({ USER_ID: username }, function (err, users) {
console.log(password);
var hash = crypto.createHash('sha256');
// [START requests]
app.use(logging.requestLogger);
// [END requests]
// Configure the session and session storage.
const sessionConfig = {
resave: false,
saveUninitialized: false,
secret: config.get('SECRET'),
signed: true,
store: new DatastoreStore({
dataset: new Datastore({kind: 'express-sessions'}),
}),
};
app.use(session(sessionConfig));
// OAuth2
app.use(passport.initialize());
app.use(passport.session());
app.use(require('./lib/oauth2').router);
// Books
app.use('/books', require('./books/crud'));
app.use('/api/books', require('./books/api'));
// Redirect root to /books
app.get('/', (req, res) => {
res.redirect('/books');
});
mongoose.Promise = Promise;
const MongoStore = connectMongo(session);
app.use('/public', express.static(path.resolve('public')));
app.use('/doc', express.static(path.resolve('doc')));
app.use(cookieParser());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(session({
secret: 'myUserSuperSecret',
cookie: {
maxAge: 2628000000
},
store: new MongoStore({ mongooseConnection: mongoose.connection })
}));
app.use(passport.initialize());
app.use(passport.session());
app.use(fileUpload());
passportConfig(passport);
app.use('/api', api);
app.get('favicon.ico', (req, res) => {
res.sendFile(path.resolve('public/favicon.ico'));
app.engine('html', require('ejs').renderFile);
var options = {
host: '120.27.5.9',
port: 3306,
user: '******',
password: '******',
database: 'dataChart'
};
var sessionStore = new MySQLStore(options);
app.use(session({
secret: 'kkChart',
key:'kkChart',
cookie: {maxAge: 1000 * 60 * 60 * 1},////设定 cookie 1 天
resave:true,
saveUninitialized: true,
store: sessionStore
}));
app.use(flash());
// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));
app.use(function(req,res,next){
res.locals.openId = req.session.openId;
app.use(globalCSP);
var csrfProtection = csrf({ cookie: true });
var parseForm = bodyParser.urlencoded({ extended: false });
app.use(cookieParser());
var pool = anyDB.createPool(config.dbURI, {
min: 2, max: 10
});
app.use(session({
// store:new RedisStore({
// host:'127.0.0.1',
// port:'6379'
// }),
name: 'login',
secret: '04n4MY7jLXKlz3y17YdoSOR9o71gvH3R',
resave: false,
saveUninitialized: false,
cookie: { path: '/admin', maxAge: 1000*60*60*24*3, httpOnly: true }
})
);
// URL expected: http://hostname/admin
//app.get('/', csrfProtection, function (req, res) {
app.get('/', csrfProtection, function (req, res, next) {
/*
var schema = req.headers['x-forwarded-proto'];
if (schema === 'https') {// Redirect to https.
res.redirect('https://' + req.headers.host + req.url);
}
const router = function (config) {
// appRouter configuration
const appRouter = express.Router();
const mongo = db(config);
if (config.useBasicAuth) {
appRouter.use(basicAuth(config.basicAuth.username, config.basicAuth.password));
}
appRouter.use(favicon(__dirname + '/../public/images/favicon.ico'));
appRouter.use(logger('dev', config.options.logger));
appRouter.use('/public', express.static(__dirname + '/../build/'));
// Set request size limit
appRouter.use(bodyParser.urlencoded({
extended: true,
limit: config.site.requestSizeLimit,
}));
appRouter.use(cookieParser(config.site.cookieSecret));
appRouter.use(session({
key: config.site.cookieKeyName,
resave: true,
saveUninitialized: true,
secret: config.site.sessionSecret,
}));
appRouter.use(methodOverride(function (req) {
if (req.body && typeof req.body === 'object' && '_method' in req.body) {
// look in urlencoded POST bodies and delete it
const method = req.body._method;
delete req.body._method;
return method;
}
}));
if (process.env.NODE_ENV === 'development') {
appRouter.use(errorHandler());
}
const addTrailingSlash = function (s) {
return s + (s[s.length - 1] === '/' ? '' : '/');
};
const buildBaseHref = function (originalUrl, reqUrl) {
if (reqUrl === '/') {
return addTrailingSlash(originalUrl);
}
const idx = originalUrl.lastIndexOf(reqUrl);
const rootPath = originalUrl.substring(0, idx);
return addTrailingSlash(rootPath);
};
// View helper, sets local variables used in templates
appRouter.all('*', function (req, res, next) {
res.locals.baseHref = buildBaseHref(req.originalUrl, req.url);
res.locals.databases = mongo.databases;
res.locals.collections = mongo.collections;
res.locals.gridFSBuckets = utils.colsToGrid(mongo.collections);
// Flash messages
if (req.session.success) {
res.locals.messageSuccess = req.session.success;
delete req.session.success;
}
if (req.session.error) {
res.locals.messageError = req.session.error;
delete req.session.error;
}
//user in admin databases normally have the read and write access to all databases
if (config.mongodb.admin !== true && mongo.databases[0] !== 'admin') return next();
mongo.updateDatabases(mongo.adminDb, function (databases) {
mongo.databases = databases;
res.locals.databases = mongo.databases;
return next();
});
});
// route param pre-conditions
appRouter.param('database', function (req, res, next, id) {
//Make sure database exists
if (!_.includes(mongo.databases, id)) {
req.session.error = 'Database not found!';
return res.redirect(res.locals.baseHref);
}
req.dbName = id;
res.locals.dbName = id;
res.locals.dbUrl = utils.buildDatabaseURL(res.locals.baseHref, id);
if (mongo.connections[id] !== undefined) {
req.db = mongo.connections[id];
} else {
mongo.connections[id] = mongo.mainConn.db(id);
req.db = mongo.connections[id];
}
next();
});
// :collection param MUST be preceded by a :database param
appRouter.param('collection', function (req, res, next, id) {
//Make sure collection exists
if (!_.includes(mongo.collections[req.dbName], id)) {
req.session.error = 'Collection not found!';
return res.redirect(res.locals.baseHref + 'db/' + req.dbName);
}
req.collectionName = id;
res.locals.collectionName = id;
res.locals.collectionUrl = utils.buildCollectionURL(res.locals.baseHref, res.locals.dbName, id);
res.locals.collections = mongo.collections[req.dbName];
res.locals.gridFSBuckets = utils.colsToGrid(mongo.collections[req.dbName]);
mongo.connections[req.dbName].collection(id, function (err, coll) {
if (err || coll === null) {
req.session.error = 'Collection not found!';
return res.redirect(res.locals.baseHref + 'db/' + req.dbName);
}
req.collection = coll;
next();
});
});
// :document param MUST be preceded by a :collection param
appRouter.param('document', function (req, res, next, id) {
if (id === 'undefined' || id === undefined) {
req.session.error = 'Document lacks an _id!';
return res.redirect(res.locals.baseHref + 'db/' + req.dbName + '/' + req.collectionName);
}
id = JSON.parse(decodeURIComponent(id));
let obj_id;
// Attempt to create ObjectID from passed 'id'
try {
obj_id = new mongodb.ObjectID.createFromHexString(id);
} catch (err) {
try {
// Is it a GUID?
obj_id = new mongodb.Binary(new Buffer(id, 'base64'), 3);
} catch (err) {
// Silence GUID error as well
}
// Silence the error
}
// If an ObjectID was correctly created from passed id param, try getting the ObjID first else falling back to try getting the string id
// If not valid ObjectID created, try getting string id
if (obj_id) {
// passed id has successfully been turned into a valid ObjectID
req.collection.findOne({ _id: obj_id }, function (err, doc) {
if (err) {
req.session.error = 'Error: ' + err;
return res.redirect(res.locals.baseHref + 'db/' + req.dbName + '/' + req.collectionName);
}
if (doc === null) {
// No document found with obj_id, try again with straight id
req.collection.findOne({ _id: id }, function (err, doc) {
if (err) {
req.session.error = 'Error: ' + err;
return res.redirect(res.locals.baseHref + 'db/' + req.dbName + '/' + req.collectionName);
}
if (doc === null) {
req.session.error = 'Document not found!';
return res.redirect(res.locals.baseHref + 'db/' + req.dbName + '/' + req.collectionName);
}
// Document found - send it back
req.document = doc;
res.locals.document = doc;
next();
});
} else {
// Document found - send it back
req.document = doc;
res.locals.document = doc;
next();
}
});
} else {
// Passed id was NOT a valid ObjectID
req.collection.findOne({ _id: id }, function (err, doc) {
if (err) {
req.session.error = 'Error: ' + err;
return res.redirect(res.locals.baseHref + 'db/' + req.dbName + '/' + req.collectionName);
}
if (doc === null) {
req.session.error = 'Document not found!';
return res.redirect(res.locals.baseHref + 'db/' + req.dbName + '/' + req.collectionName);
}
req.document = doc;
res.locals.document = doc;
next();
});
}
});
// get individual property - for async loading of big documents
// (db)/(collection)/(document)/(prop)
appRouter.param('prop', function (req, res, next, prop) {
req.prop = req.document[prop];
next();
});
// GridFS (db)/gridFS/(bucket)
appRouter.param('bucket', function (req, res, next, id) {
req.bucketName = id;
res.locals.bucketName = id;
mongo.connections[req.dbName].collection(id + '.files', function (err, filesConn) {
if (err || filesConn === null) {
req.session.error = id + '.files collection not found! Err:' + err;
return res.redirect(res.locals.baseHref + 'db/' + req.dbName);
}
req.filesConn = filesConn;
filesConn.find({}).toArray(function (err, files) {
if (err || files === null) {
req.session.error = id + '.files collection not found! Error:' + err;
return res.redirect(res.locals.baseHref + 'db/' + req.dbName);
}
req.files = files;
next();
});
});
});
// GridFS files
appRouter.param('file', function (req, res, next, id) {
req.fileID = JSON.parse(decodeURIComponent(id));
next();
});
// mongodb mongoMiddleware
const mongoMiddleware = function (req, res, next) {
req.mainConn = mongo.mainConn;
req.adminDb = mongo.adminDb;
req.databases = mongo.databases; //List of database names
req.collections = mongo.collections; //List of collection names in all databases
req.gridFSBuckets = utils.colsToGrid(mongo.collections);
//Allow page handlers to request an update for collection list
req.updateCollections = mongo.updateCollections;
next();
};
// routes
const configuredRoutes = routes(config);
appRouter.get('/', mongoMiddleware, configuredRoutes.index);
appRouter.post('/', mongoMiddleware, configuredRoutes.addDatabase);
appRouter.delete('/:database', mongoMiddleware, configuredRoutes.deleteDatabase);
appRouter.get('/db/:database', mongoMiddleware, configuredRoutes.viewDatabase);
appRouter.post('/checkValid', mongoMiddleware, configuredRoutes.checkValid);
// Collection level routes
appRouter.post('/db/:database/import/:collection', mongoMiddleware, configuredRoutes.importCollection);
appRouter.get('/db/:database/compact/:collection', mongoMiddleware, configuredRoutes.compactCollection);
appRouter.get('/db/:database/expArr/:collection', mongoMiddleware, configuredRoutes.exportColArray);
appRouter.get('/db/:database/expCsv/:collection', mongoMiddleware, configuredRoutes.exportCsv);
appRouter.get('/db/:database/reIndex/:collection', mongoMiddleware, configuredRoutes.reIndex);
appRouter.post('/db/:database/addIndex/:collection', mongoMiddleware, configuredRoutes.addIndex);
appRouter.get('/db/:database/export/:collection', mongoMiddleware, configuredRoutes.exportCollection);
appRouter.get('/db/:database/dropIndex/:collection', mongoMiddleware, configuredRoutes.dropIndex);
appRouter.get('/db/:database/updateCollections', mongoMiddleware, configuredRoutes.updateCollections);
// GridFS
appRouter.post('/db/:database/gridFS', mongoMiddleware, configuredRoutes.addBucket);
appRouter.delete('/db/:database/gridFS/:bucket', mongoMiddleware, configuredRoutes.deleteBucket);
appRouter.get('/db/:database/gridFS/:bucket', mongoMiddleware, configuredRoutes.viewBucket);
appRouter.post('/db/:database/gridFS/:bucket', mongoMiddleware, configuredRoutes.addFile);
appRouter.get('/db/:database/gridFS/:bucket/:file', mongoMiddleware, configuredRoutes.getFile);
appRouter.delete('/db/:database/gridFS/:bucket/:file', mongoMiddleware, configuredRoutes.deleteFile);
appRouter.get('/db/:database/:collection', mongoMiddleware, configuredRoutes.viewCollection);
appRouter.put('/db/:database/:collection', mongoMiddleware, configuredRoutes.renameCollection);
appRouter.delete('/db/:database/:collection', mongoMiddleware, configuredRoutes.deleteCollection);
appRouter.post('/db/:database', mongoMiddleware, configuredRoutes.addCollection);
// Document routes
appRouter.post('/db/:database/:collection', mongoMiddleware, configuredRoutes.addDocument);
appRouter.get('/db/:database/:collection/:document', mongoMiddleware, configuredRoutes.viewDocument);
appRouter.put('/db/:database/:collection/:document', mongoMiddleware, configuredRoutes.updateDocument);
appRouter.delete('/db/:database/:collection/:document', mongoMiddleware, configuredRoutes.deleteDocument);
// Property routes
appRouter.get('/db/:database/:collection/:document/:prop', mongoMiddleware, configuredRoutes.getProperty);
return appRouter;
};
var cors = function(req, res, next) {
res.setHeader('Access-Control-Allow-Origin', '*');
next();
};
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
// uncomment after placing your favicon in /public
//app.use(favicon(__dirname + '/public/favicon.ico'));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser('Avatar Voting Secret'));
app.use(session({secret: 'Avatar Voting Secret'}));
app.use(express.static(path.join(__dirname, 'public')));
app.use('/', index);
app.use('/users', users.router);
app.use('/suggestions', auth.filter, cors, suggestions);
// catch 404 and forward to error handler
app.use(function(req, res, next) {
var err = new Error('Not Found');
err.status = 404;
next(err);
});
// error handlers
var express = require('express')
var session = require('express-session')
var Grant = require('grant-express')
var config = {
server: {
protocol: 'http',
host: 'dummy.com:3000'
},
facebook: {
key: '[APP_ID]',
secret: '[APP_SECRET]',
callback: '/handle_callback'
}
}
var app = express()
app.use(session({secret: 'very secret'}))
app.use(new Grant(config))
app.get('/handle_callback', function (req, res) {
console.log(req.query)
res.end(JSON.stringify(req.query, null, 2))
})
app.listen(3000, function () {
console.log('Express server listening on port ' + 3000)
})
var app = express();
var server = http.createServer(app);
server.listen(4000);
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
app.use(favicon());
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded());
app.use(cookieParser());
app.use(expressSession({secret: '1234567890QWERTY',maxAge : new Date(Date.now() + 36000000),expires : new Date(Date.now() + 3600000)}));
app.use('/img',express.static(path.join(__dirname, 'public/images')));
app.use('/js',express.static(path.join(__dirname, 'public/javascripts')));
app.use('/css',express.static(path.join(__dirname, 'public/stylesheets')));
app.use('/', routes);
/// catch 404 and forward to error handler
app.use(function(req, res, next) {
var err = new Error('Not Found');
err.status = 404;
next(err);
});
}
var methodOverride = require('method-override');
var app = express();
app.use(methodOverride('_method'));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.use(session({
store: new pgSession({
pg : pg,
conString : connectionString,
tableName : 'session'
}),
secret: 'sooosecrett', // something we maybe want to save with dotenv *hint hint*
resave: false,
saveUninitialized: true,
cookie: { maxAge: 30 * 24 * 60 * 60 * 1000 } // 30 days
}))
app.get('/', function(req, res) {
// console.log(req.session.user);
res.render('home.html.ejs', { user: req.session.user});
});
app.post('/', db.createUser, function(req, res) {
res.redirect(301,'/');
});