var init = exports.init = function (config) {
var mongodbUrl = config.db_uri;
console.log('Using MongoDB URL: %s', mongodbUrl);
mongoose.connect(mongodbUrl, function (error) {
if (error) {
console.error('Could not connect to DB: %s', error);
process.exit(1);
}
});
mongoose.connection.on('error', function (error) {
console.error('MongoDB connection error: %s', error);
});
session_store = new mongoStore({ mongooseConnection: mongoose.connection });
swig.init({
root: config.viewpath,
// allows errors to be thrown and caught by express instead of suppressed by Swig
allowErrors: true,
cache: false,
filters: require('./swig-filters'),
tags: require('./swig-tags').tags,
extensions: { plugin: pluginTemplates }
});
var app = express();
if (isDevelopment) {
app.use(morgan('dev'));
}
if (isTest) {
// awesome view testingness
require('./views-test')(app);
}
app.set('views', path.join(__dirname, 'views'));
app.engine('html', pluginTemplates.engine);
if (config.cors) {
app.use(cors(config.cors));
}
app.use(middleware.bodySetter);
// parse application/x-www-form-urlencoded
app.use(bodyParser.urlencoded({ extended: false, limit: config.body_parser_limit }))
// parse application/json
app.use(bodyParser.json({ limit: config.body_parser_limit }))
app.use(cookieParser());
app.use(compression());
app.use(methodOverride());
app.use(serveFavicon(path.join(__dirname, '..', 'public', 'favicon.ico'), { maxAge: 2592000000 }));
app.use(expressSession({
secret: config.session_secret, store: session_store,
cookie: {maxAge: MONTH_IN_MILLISECONDS},
resave: false,
saveUninitialized: true
}));
app.use(connectFlash());
app.use(function(req, res, next){
res.locals.models = models;
next();
})
auth.setup(app); // app.use(passport) is included
app.use('/vendor', express.static(path.join(__dirname, '..', 'vendor'), {maxAge: MONTH_IN_MILLISECONDS}));
app.use(express.static(path.join(__dirname, '..', 'dist'), {maxAge: MONTH_IN_MILLISECONDS}));
app.use(express.static(path.join(__dirname, '..', 'public'), {maxAge: MONTH_IN_MILLISECONDS}));
if (!config.smtp) {
console.warn('No SMTP creds - forgot password flow will not work');
}
// Routes
app.get('/', routes.index);
app.get('/about',function(req, res) {
res.render('about');
});
app.get('/status', routes.status);
app.post('/login', function (req, res, next) {
if (!req.user) {
return next();
}
res.redirect('/');
}, auth.authenticate);
app.get('/logout', auth.logout);
app.get('/forgot', function (req, res) {
res.render('forgot.html', {
user: req.user,
messages: req.flash('error')
});
});
app.post('/forgot', auth.forgot);
app.get('/reset/:token', auth.reset);
app.post('/reset/:token', auth.resetPost);
// Compiled plugin config assets
app.get('/scripts/plugin-config-compiled.js', api_config.server('config', 'js'))
app.get('/styles/plugin-config-compiled.css', api_config.server('config', 'css'))
app.get('/scripts/account-plugins-compiled.js', api_config.server('account', 'js'))
app.get('/styles/account-plugins-compiled.css', api_config.server('account', 'css'))
app.get('/scripts/plugin-status-compiled.js', api_config.server('status', 'js'))
app.get('/styles/plugin-status-compiled.css', api_config.server('status', 'css'))
app.get('/admin/projects', auth.requireAdminOr401, routes_admin.projects);
app.get('/admin/users', auth.requireAdminOr401, routes_admin.users);
app.get('/admin/jobs', auth.requireAdminOr401, function(req, res) {
res.render('admin/jobs.html', {
version: pjson.version
})
});
app.get('/admin/make_admin', auth.requireAdminOr401, routes_admin.make_admin);
app.post('/admin/remove_user', auth.requireAdminOr401, routes_admin.remove_user);
app.get('/admin/invites', auth.requireAdminOr401, routes_admin.invites);
app.get('/admin/:org/:repo/job/:job_id', auth.requireAdminOr401, routes_admin.job);
app.get('/admin/plugins', auth.requireAdminOr401, routes_admin.plugins.get);
app.put('/admin/plugins', auth.requireAdminOr401, routes_admin.plugins.put);
app.use('/account', auth.requireUser, require('./routes/account'));
app.use('/projects', auth.requireUser, require('./routes/projects'));
/* Requires at least read-only access to the repository in the path */
app.get('/:org/:repo/', middleware.project, routes_jobs.html);
app.put('/:org/:repo/', auth.requireUser, api_repo.create_project);
app.get('/:org/:repo/job/:job_id?', middleware.project, routes_jobs.multijob);
app.get('/:org/:repo/jobs/', middleware.project, routes_jobs.jobs);
app.post('/:org/:repo/start', auth.requireUser, middleware.project, auth.requireProjectAdmin, api_jobs.jobs_start);
app.delete('/:org/:repo/cache', auth.requireUser, middleware.project, auth.requireProjectAdmin, api_repo.clear_cache);
app.delete('/:org/:repo/', middleware.project, auth.requireProjectAdmin, api_repo.delete_project);
// provider
app.all('/:org/:repo/provider/',
auth.requireUserOr401,
middleware.project,
auth.requireProjectAdmin)
app.get('/:org/:repo/provider/', routes.getProviderConfig)
app.post('/:org/:repo/provider/', routes.setProviderConfig)
// collaborators
app.all('/:org/:repo/collaborators/',
auth.requireUserOr401,
middleware.project,
auth.requireProjectAdmin)
app.get('/:org/:repo/collaborators/', api_collaborators.get);
app.post('/:org/:repo/collaborators/', middleware.requireBody(['email']), api_collaborators.post);
app.delete('/:org/:repo/collaborators/', middleware.requireBody(['email']), api_collaborators.del);
// branches
app.use('/:org/:repo/branches/',
auth.requireUserOr401,
middleware.project,
auth.requireProjectAdmin,
api_branches
);
// keygen
app.post('/:org/:repo/keygen/', auth.requireUser, middleware.project, auth.requireProjectAdmin, api_config.keygen);
/* Requires admin access to the repository in the path */
if ('development' === app.get('env')) {
app.get('/:org/:repo/config(/*)', auth.requireUser, middleware.project, auth.requireProjectAdmin, routes.reloadConfig, routes.config);
} else {
app.get('/:org/:repo/config(/*)', auth.requireUser, middleware.project, auth.requireProjectAdmin, routes.config);
}
app.put('/:org/:repo/config', auth.requireUser, middleware.project, auth.requireProjectAdmin, routes.setConfig);
app.all(
'/:org/:repo/config/branch/runner(/*)',
auth.requireUser,
middleware.project,
auth.requireProjectAdmin
)
app.get('/:org/:repo/config/branch/runner', routes.getRunnerConfig);
app.put('/:org/:repo/config/branch/runner', routes.setRunnerConfig);
app.put('/:org/:repo/config/branch/runner/id', routes.setRunnerId);
app.all(
'/:org/:repo/config/branch/:plugin',
auth.requireUser,
middleware.project,
auth.requireProjectAdmin,
middleware.projectPlugin
)
app.get('/:org/:repo/config/branch/:plugin', routes.getPluginConfig);
app.put('/:org/:repo/config/branch/:plugin', routes.setPluginConfig);
app.put('/:org/:repo/config/branch/', auth.requireUser, middleware.project, auth.requireProjectAdmin, routes.configureBranch)
// app.get('/api/job/:id', api_jobs.raw);
app.use('/api', api);
app.get('/api/jobs', auth.requireUserOr401, api_jobs.jobs);
// app.get('/api/jobs/:org/:repo', middleware.project, api_jobs.repo_jobs);
app.get('/api/session', api_session.get);
app.post('/api/session', api_session.create);
app.use(function(req, res, next) {
var user_created_timestamp=0;
if (req.user !== undefined) {
user_created_timestamp = parseInt(req.user.id.substr(0,8),16);
}
res.locals.user_created_timestamp = user_created_timestamp;
next();
});
common.app = app;
common.session_store = session_store;
//
// ### Strider Webapp Event Emitter
//
// Strider has a Node.Js Event Emitter which emits many events. This can be
// used by extensions to add extremely flexible custom handling for just about
// anything.
//
common.emitter = new EventEmitter();
return app;
};
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));//是否使用默认的querystring来将字符串转成json
app.use(cookieParser());// req.cookies
//当使用session中间件之后，会在多一个 req.session
var config = require('./config');
app.use(session({
secret:'5',//加密cookie
resave:true,
saveUninitialized:true,
store:new MongoStore({
url:config.url
})
}));
var flash = require('connect-flash');
app.use(flash());//一闪而过 显示一次之后就被清除 req.flash()
app.use(function(req,res,next){
res.locals.user = req.session.user;//把session中的user取出来赋给模板变量对象
//把flash也就是session中的信息取出来赋给模板对象
res.locals.success = req.flash('success').toString();
res.locals.error = req.flash('error').toString();
next();
});
app.use(express.static(path.join(__dirname, 'public')));
app.use('/', routes);
app.use('/users', users);
app.use('/articles', articles);
// catch 404 and forward to error handler
// 捕获404错误并且转向错误处理中单件
app.mongoose.connect(configDB.url);
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', __dirname + '/views');
app.set('view engine', 'ejs');
app.use(express.favicon());
app.use(express.logger('dev'));
app.use(express.cookieParser());
app.use(express.bodyParser());
app.use(express.methodOverride());
app.use(express.session({
secret : 'SECRET'
}));
app.use(passport.initialize());
app.use(passport.session()); // persistent login sessions
app.use(flash()); // use connect-flash for flash messages stored in session
app.use(express.static(path.join(__dirname, 'public')));
app.use(express.static(path.join(__dirname, 'views/war')));
// development only
if ('development' === app.get('env')) {
app.use(express.errorHandler());
}
require('./routes.js')(app, passport);
require('./config/passport')(passport);
var server = http.createServer(app).listen(app.get('port'), function() {
console.log('Express server listening on port ' + app.get('port'));
});
var chess = require('./controllers/chessGameController.js');
var morgan = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var session = require('express-session');
// creates new express app
var app = express();
app.use(morgan('dev')); // log every request to the console
app.use(cookieParser()); // read cookies (needed for auth)
app.use(bodyParser()); // get information from html forms
app.use('/static', express.static('./public'));
// configures and connects to db
var configDB = require('./config/database.js');
mongoose.connect(configDB.url);
// required for passport
// require('./config/passport')(passport); // pass passport for configuration
app.use(session({ secret: 'ilovescotchscotchyscotchscotch' })); // session secret
app.use(passport.initialize());
app.use(passport.session()); // persists login sessions
app.use(flash()); // enables flash messages
// requires routes
require('./routes.js')(app, passport);
app.listen(3000, function(){
console.log("server running on local host 3000!")
});
module.exports = function (PORT, PATH, CALLBACK) {
if (isDebug) mongodb.enableDebug();
mongodb.connect(mongodb.PRODUCTION_URI, () => {
const lookup = require('./server/controllers/lookup.js');
lookup.getAll((err) => {
if (!err) console.log('Lookups cached');
});
});
if (config.aws_mysql.host) {
if (isDebug) db.enableDebug();
db.connect(db.MODE_PRODUCTION, config.aws_mysql, (err) => {
if (err) {
console.log('Unable to connect to MySQL.');
process.exit(1);
} else {
console.log('MySQL connection established');
}
});
} else if (config.mysql.host) {
db.connect(db.MODE_PRODUCTION, config.mysql, (err) => {
if (err) {
console.log('Unable to connect to MySQL.');
process.exit(1);
} else {
console.log('MySQL connection established');
}
});
} else {
db.fakeDB(() => {
console.log('Spoofed MySQL connection established');
});
}
const app = express();
// enables gzip
app.use(compression());
// view engine setup
// app.set('views', path.join(__dirname, 'views'));
// app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'server/views'));
app.set('view engine', 'pug');
// 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,
}));
// Configuring Passport
const passport = require('passport');
const expressSession = require('express-session');
app.use(expressSession({
secret: config.passport.secret,
resave: false,
saveUninitialized: false,
}));
app.use(passport.initialize());
app.use(passport.session());
// Using the flash middleware provided by connect-flash to store messages in session
// and displaying in templates
const flash = require('connect-flash');
app.use(flash());
// Initialize Passport
const initPassport = require('./server/passport/init');
initPassport(passport);
const routes = require('./server/routes/index')(passport);
app.use('/', routes);
app.use(express.static(path.join(__dirname, PATH)));
// catch 404 and forward to error handler
app.use((req, res, next) => {
const err = new Error('Not Found');
err.status = 404;
next(err);
});
// error handlers
// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
app.use((err, req, res, next) => {
res.status(err.status || 500);
res.render('pages/error.jade', {
message: err.message,
error: err,
});
});
}
// Force ssl on heroku if in production mode
const forceSsl = function forceSsl(req, res, next) {
if (req.headers['x-forwarded-proto'] !== 'https') {
return res.redirect(['https://', req.get('Host'), req.url].join(''));
}
return next();
};
if (app.get('env') === 'production') {
app.use(forceSsl);
}
// production error handler
// no stacktraces leaked to user
app.use((err, req, res) => {
res.status(err.status || 500);
res.render('pages/error.jade', {
message: err.message,
error: {},
});
});
/**
* Module dependencies.
*/
const debug = require('debug')('passport-mongo:server');
const http = require('http');
/**
* Get port from config or environment and store in Express.
*/
let port = PORT || config.server.port;
if (!port) port = process.env.PORT || '3000';
app.set('port', port);
/**
* Create HTTP server.
*/
const server = http.createServer(app);
/**
* Listen on provided port, on all network interfaces.
*/
server.listen(port);
server.on('error', onError);
server.on('listening', onListening);
/**
* Event listener for HTTP server "error" event.
*/
function onError(error) {
if (error.syscall !== 'listen') {
throw error;
}
const bind = typeof port === 'string' ? `Pipe ${port}` : `Port ${port}`;
// handle specific listen errors with friendly messages
switch (error.code) {
case 'EACCES':
console.error(`${bind} requires elevated privileges`);
process.exit(1);
break;
case 'EADDRINUSE':
console.error(`${bind} is already in use`);
process.exit(1);
break;
default:
throw error;
}
}
/**
* Event listener for HTTP server "listening" event.
*/
function onListening() {
CALLBACK();
const addr = server.address();
const bind = typeof addr === 'string' ?
`pipe ${addr}` :
`port ${addr.port}`;
debug(`Listening on ${bind}`);
}
};
module.exports = function (app, passport, db) {
app.set('showStackError', true);
// Prettify HTML
app.locals.pretty = true;
// cache=memory or swig dies in NODE_ENV=production
app.locals.cache = 'memory';
// Should be placed before express.static
// To ensure that all assets and data are compressed (utilize bandwidth)
app.use(compression({
// Levels are specified in a range of 0 to 9, where-as 0 is
// no compression and 9 is best compression, but slowest
level: 9
}));
// Only use logger for development environment
if (process.env.NODE_ENV === 'development') {
app.use(morgan('dev'));
}
// assign the template engine to .html files
app.engine('html', consolidate[config.templateEngine]);
// set .html as the default extension
app.set('view engine', 'html');
// The cookieParser should be above session
app.use(cookieParser());
// Request body parsing middleware should be above methodOverride
app.use(expressValidator());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(methodOverride());
// Import the assets file and add to locals
var assets = assetmanager.process({
assets: require('./assets.json'), debug: process.env.NODE_ENV !== 'production', webroot: /public\/|packages\//g
});
// Add assets to local variables
app.use(function (req, res, next) {
res.locals.assets = assets;
mean.aggregated('js', 'header', function (data) {
res.locals.headerJs = data;
next();
});
});
// Express/Mongo session storage
app.use(session({
secret: config.sessionSecret,
store: new mongoStore({
db: db.connection.db,
collection: config.sessionCollection
}), cookie: config.sessionCookie,
name: config.sessionName,
resave: true,
saveUninitialized: true
}));
// Dynamic helpers
app.use(helpers(config.app.name));
// Use passport session
app.use(passport.initialize());
app.use(passport.session());
//mean middleware from modules before routes
app.use(mean.chainware.before);
// Connect flash for flash messages
app.use(flash());
};
module.exports = function(app) {
// In our app.js configuration
if (app.get('env') === 'development') {
//console.log('development');
//if (process.env.NODE_ENV === 'name')
//app.use(require('connect-livereload')());
// Disable caching of scripts for easier testing
app.use(function noCache(req, res, next) {
if (req.url.indexOf('/scripts/') === 0) {
//res.header('Cache-Control', 'no-cache, no-store, must-revalidate');
res.header('Pragma', 'no-cache');
res.header('Expires', 0);
}
next();
});
//app.use(statick(path.join(config.root, '.tmp')));
app.use(statick(path.join(config.root, 'app')));
app.use(errorHandler());
app.set('views', config.root + '/app/views');
//app.use(logger);
};
app.set('trust proxy', true);
/*app.use('/', function(req, res, next) {
console.log('%s %s — %s and ip - %s', (new Date).toString(), req.method, req.url,req.ip);
return next();
});
*/
if (app.get('env') === 'production') {
console.log('production');
app.use(favicon(path.join(config.root, 'app', 'favicon.ico')));
app.use(statick(path.join(config.root, 'app')));
app.set('views', config.root + '/views');
};
//app.engine('pdf', require('ejs').renderFile);
app.set('view engine', 'jade');
app.use(bodyParser({limit: '50mb'}));
app.use(multer({ dest: './uploads/'}))
app.use(methodOverride());
app.use(cookieParser());
//app.use(useragent.express());
/*app.use(session({
//key: "mysite.sid.uid.whatever",
secret: 'mysite.sid.uid.whatever'
*//*cookie: {
maxAge: 26784000000 // 31 days
}*//*
}));*/
// Persist sessions with mongoStore
app.use(session({
secret: 'angular-fullstack secret',
store: new mongoStore({
url: config.mongo.uri,
collection: 'sessions'
})
}));
//use passport session
app.use(passport.initialize());
app.use(passport.session());
app.use(flash()); // use connect-flash for flash messages stored in session
// Router needs to be last
// app.use(app.router);
};
module.exports = function () {
var app = express();
var server = http.createServer(app);
var io = socketio.listen(server);
if(app.get('env') === 'production'){
app.use(compress());
}
app.use(bodyParser.urlencoded({extended: true}));
app.use(bodyParser.json());
app.use(methodOverride());
app.use(cookieParser());
var leanStore = new LeanStore();
app.use(session({
saveUninitialized: true,
resave: true,
secret: 'SessionSecret',
store: leanStore
}));
app.set('views', './app/views');
app.set('view engine', 'ejs');
app.use(express.static('./public'));
app.use(flash());
app.use(passport.initialize());
app.use(passport.session());
// 加载云代码方法
app.use(AV.Cloud);
// 使用 avos-express-cookie-session 记录登录信息到 cookie
//app.use(AV.Cloud.CookieSession({ secret: 'abcdefgh', maxAge: 3600000, fetchUser: false }));
require('../app/routes/index.server.routes.js')(app);
require('../app/routes/weixin.server.routes.js')(app);
require('../app/routes/users.server.routes.js')(app);
require('../app/routes/articles.server.routes.js')(app);
app.use(function(req, res, next) {
var err = new Error('Not Found');
err.status = 404;
next(err);
});
if (app.get('env') === 'development') {
app.use(function (err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: err
});
});
} else {
app.use(function (err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: {}
});
});
}
require('./socketio')(server, io, leanStore);
return server;
}
module.exports = function(mongooseConnection, redisClient) {
require('../config/passport.js')(passport);
var app = express();
// Middleware
// In production we use a CDN
if (!isProduction) {
app.use(stylusMiddleware());
}
app.use(slashes(false));
app.use(logger('dev'));
app.use(express.static(path.join(__dirname, '../public')));
app.engine('jsx', render);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jsx');
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(multer());
app.use(cookieParser());
app.use(session({
resave: false, // don't save session if unmodified
saveUninitialized: false, // don't create session until something stored
secret: 'bodhi',
store: new RedisStore({
client: redisClient,
ttl: 14 * 86400 // 14 days expiration
})
}));
app.use(passport.initialize());
app.use(passport.session());
// Always after sessions
app.use(flash());
// Don't need CSRF w/ access tokens
var csrfMiddleware = csrf();
app.use(function(req, res, next) {
var isAPI = req.originalUrl.slice(0, 4) === '/api';
var accessToken = req.query.access_token || req.body.access_token || null;
if (!isAPI || !accessToken) {
csrfMiddleware.apply(null, arguments);
} else {
next();
}
});
app.use(function(req, res, next) {
if (req.csrfToken)
res.locals.csrf_token = req.csrfToken();
next();
});
// Pretty print
if (app.get('env') === 'development') {
app.set('json spaces', 2);
// app.locals.pretty = true;
}
// Append the user to the locals for use in every view
app.use(function(req, res, next) {
res.locals.user = req.user;
next();
});
require('../config/routes.js')(app, passport);
app.listen(process.env.PORT || 8080);
};
module.exports = function () {
/*
* Express configuration
*/
// Create app
var app = express();
// view engine setup
app.set('views', './views');
app.set('view engine', 'jade');
// jade layouts disabled by default
app.set('view options', {
layout: false
});
// show pretty html
app.locals.pretty = true;
// Parse JSON
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({
extended: true
}));
// Use morgan for request logs
app.use(morgan(config.morgan, {
"stream": {
write: function (message, encoding) {
logger.info(message);
}
}
}));
// Passport references
app.use(session({
secret: config.sessionSecret,
resave: false,
saveUninitialized: true,
store: new redisStore({
url: config.redis.uri
})
}));
app.use(passport.initialize());
app.use(passport.session());
app.use(flash());
/*
* Routes
*/
// Enable cross-domain requests for all routes
app.use(cors());
// Static files (CSS, JS, etc...)
app.use(serveStatic('./public', {
index: false
}));
// Documentation - static
app.use('/docs', express.static('docs'));
// Static/generic routes
app.use('/', require('../routes/static'));
// Auth routes
app.use('/auth', require('../routes/auth'));
// Threads routes
app.use('/threads', require('../routes/threads'));
// Test services routes
app.use('/services', require('../routes/services'));
/*
* HTTP server setup
*/
var server = require('http').createServer(app);
server.listen(config.port);
console.log("Environment: " + config.mode);
console.log("HTTP server listening on port " + config.port);
// Return the express app
return app;
};
app.configure(function () {
// bodyParser should be above methodOverride
app.use(express.bodyParser());
app.use(express.methodOverride());
// cookieParser should be above session
app.use(express.cookieParser());
app.use(express.session({
secret: pkg.name,
store: new mongoStore({
url: config.db,
collection : "sessions"
})
}));
// Passport session
app.use(passport.initialize());
app.use(passport.session());
// Flash messages
app.use(flash());
// expose pkg and node env to views
app.use(function (req, res, next) {
res.locals.pkg = pkg
res.locals.env = env
next();
});
// View helpers
app.use(helpers(pkg.name));
// adds CSRF support
if (process.env.NODE_ENV !== "test") {
app.use(express.csrf());
app.use(function(req, res, next) {
res.locals.csrf_token = req.csrfToken();
next();
});
}
// Supported locales
app.locales = ["en", "ja"];
i18n.expressBind(app, {
locales: app.locales,
subdomain: true,
query: env === "development"
});
// Generate a URL given a path and a locale
app.genURL = function(locale, path) {
var base = locale === "en" || !locale || env === "development" ?
app.baseURL() :
app.baseURL().replace(/:\/\//, "://" + locale + ".");
// Only use a query string in dev mode and if we're
// on a non-default locale
if (env === "development" && locale !== app.locales[0]) {
path += (/\?/.test(path) ? "&" : "?") + "lang=" + locale;
}
return base + path;
};
// The base URL for all pages
app.baseURL = function() {
return process.env.BASE_URL ||
"http://localhost:" + process.env.PORT;
};
// The base URL for storage
app.baseDataURL = function() {
return process.env.BASE_DATA_URL ||
"http://localhost:" + process.env.PORT;
};
// Generate a data URL
app.dataURL = function(source, type) {
return app.baseDataURL() + source + "/" + (type || "");
};
app.use(function(req, res, next) {
res.locals.CDN = CDN(req, res);
var otherLocale = function(req) {
return req.i18n.getLocale() === "en" ? "ja" : "en";
};
res.locals.getSiteCategory = function() {
if (req.path.indexOf("/source") === 0) {
return "sources";
} else if (req.path.indexOf("/artist") === 0) {
return "artists";
} else if (req.path.indexOf("/about") === 0) {
return "about";
} else if (!req.path || req.path === "/") {
return "home";
}
return "search";
};
res.locals.getOtherURL = function() {
return app.genURL(otherLocale(req), req.path);
};
res.locals.curLocale = function() {
return req.i18n.getLocale();
};
res.locals.URL = function(path) {
return path.getURL ?
path.getURL(req.i18n.getLocale()) :
app.genURL(req.i18n.getLocale(), path);
};
res.locals.fullName = function(item) {
var locale = req.i18n.getLocale();
return item.getFullName ?
item.getFullName(locale) :
locale === "ja" && item.kanji || item.name || item;
};
res.locals.shortName = function(item) {
return item.getShortName(req.i18n.getLocale());
};
res.locals.getTitle = function(item) {
return item.getTitle(req.i18n.getLocale());
};
res.locals.getDate = function(item) {
return item.dateCreated ?
res.locals.getDate(item.dateCreated) :
(item.circa ? "ca. " : "") +
item.start + (item.end && item.end !== item.start ?
"-" + item.end : "");
};
next();
});
// routes should be at the last
app.use(app.router);
// custom error handler
app.use(function (err, req, res, next) {
if (err.message
&& (~err.message.indexOf("not found")
|| (~err.message.indexOf("Cast to ObjectId failed")))) {
return next();
}
console.error(err.stack);
res.status(500).render("500");
})
app.use(function (req, res, next) {
res.status(404).render("404", { url: req.originalUrl });
});
})
module.exports = function (app, config) {
// configuration of server here
app.use(express.static(config.root + '/public'));
app.use(multer({
dest: config.uploadPath
}));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(cookieParser('monty-python-and-the-holy-grail'));
app.use(session({secret: 'montypythonholygrail'}));
app.use(passport.initialize());
app.use(passport.session());
app.use(flash());
mongoose.connect(config.db);
var db = mongoose.connection;
db.on('error', function () {
throw new Error('Unable to connect to database at ' + config.db);
});
app.set('views', config.root + '/app/views');
app.engine('handlebars', exphbs.create({
defaultLayout: 'main',
layoutsDir: app.get('views') + '/layouts'
}).engine);
app.set('view engine', 'handlebars');
var models = glob.sync(config.root + '/app/models/*.js');
models.forEach(function (model) {
require(model);
});
// passport
require('./passport')(passport);
app.use(function (req, res, next) {
if (req.session && req.session.passport) {
res.locals.userID = req.session.passport.user;
}
next();
});
var controllers = glob.sync(config.root + '/app/controllers/*.js');
controllers.forEach(function (controller) {
require(controller)(app, passport);
});
app.use(function (req, res, next) {
var err = new Error('Not Found!');
err.status = 404;
next(err);
});
app.use(function (req, res, next) {
var err = new Error('Server Error!');
err.status = 500;
next(err);
});
app.use(function (err, req, res, next) {
res.status(err.status);
res.send(err.message || 'Something Broke!');
});
};
module.exports.initMiddleware = function(app) {
winston.info('Initializing Middleware...');
// Showing stack errors
app.set('showStackError', true);
// Enable jsonp
app.enable('jsonp callback');
// Should be placed before express.static
app.use(compress({
filter: function(req, res) {
return (/json|text|javascript|css|font|svg/).test(res.getHeader('Content-Type'));
},
level: 9
}));
// Initialize favicon middleware
app.use(favicon('./modules/core/client/img/brand/favicon.ico'));
// Environment dependent middleware
if (process.env.NODE_ENV === 'development') {
// Enable logger (morgan)
//app.use(morgan('dev'));
// Disable views cache
app.set('view cache', false);
} else if (process.env.NODE_ENV === 'production') {
app.locals.cache = 'memory';
}
// Request body parsing middleware should be above methodOverride
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(bodyParser.json());
app.use(methodOverride());
// Add the cookie parser and flash middleware
app.use(cookieParser());
app.use(flash());
// Add multipart handling middleware
var storage = multer.diskStorage({
destination: function(req, file, cb) {
cb(null, './public/uploads/users/profile');
},
filename: function(req, file, cb) {
var getFileExt = function(fileName) {
var fileExt = fileName.split(".");
if (fileExt.length === 1 || (fileExt[0] === "" && fileExt.length === 2)) {
return "";
}
return fileExt.pop();
};
cb(null, Date.now() + '.' + getFileExt(file.originalname));
}
});
app.use(multer({
storage: storage
}).single('file'));
};
app.configure(function() {
app.use(express.cookieParser('keyboard cat'));
app.use(express.session({ cookie: { maxAge: 60000 }}));
app.use(flash());
});
module.exports = function(app) {
var relativePath = nconf.get('relative_path');
middleware = require('./middleware')(app);
app.engine('tpl', templates.__express);
app.set('view engine', 'tpl');
app.set('views', nconf.get('views_dir'));
app.set('json spaces', process.env.NODE_ENV === 'development' ? 4 : 0);
app.use(flash());
app.enable('view cache');
app.use(compression());
setupFavicon(app);
app.use(relativePath + '/apple-touch-icon', middleware.routeTouchIcon);
app.use(bodyParser.urlencoded({extended: true}));
app.use(bodyParser.json());
app.use(cookieParser());
var cookie = {
maxAge: 1000 * 60 * 60 * 24 * parseInt(meta.config.loginDays || 14, 10)
};
if (meta.config.cookieDomain) {
cookie.domain = meta.config.cookieDomain;
}
if (nconf.get('secure')) {
cookie.secure = true;
}
app.use(session({
store: db.sessionStore,
secret: nconf.get('secret'),
key: 'express.sid',
cookie: cookie,
resave: true,
saveUninitialized: true
}));
app.use(function (req, res, next) {
res.setHeader('X-Powered-By', 'NodeBB');
if (meta.config['allow-from-uri']) {
res.setHeader('X-Frame-Options', 'ALLOW-FROM ' + meta.config['allow-from-uri']);
} else {
res.setHeader('X-Frame-Options', 'SAMEORIGIN');
}
next();
});
app.use(middleware.processRender);
auth.initialize(app, middleware);
return middleware;
};
exports.start = function(callback) {
var app = express();
app.map = function(a, route){
route = route || '';
for (var key in a) {
if (a.hasOwnProperty(key)) {
switch (typeof a[key]) {
case 'object':
// { '/path': { ... }}
app.map(a[key], route + key);
break;
case 'function':
// get: function(){ ... }
app[key](route, a[key]);
break;
}
}
}
};
app.use(express.static(path.resolve(__dirname + '/../client')));
app.use(express.urlencoded());
app.use(cookieSession({
name: process.env.SESSION_COOKIE_KEY,
keys: [process.env.SESSION_COOKIE_SECRET],
cookie: { maxAge: 14 * 24 * 60 * 60 * 1000 }
}));
app.use(flash());
app.use(passport.initialize());
app.set('view engine', 'html');
app.set('views', __dirname + '/views');
app.engine('html', require('hogan-express'));
var passportOptions = {
successRedirect: '/user/details',
failureRedirect: '/user/details',
failureFlash: true,
session: false // Not using passport for session management
};
app.get('/auth/facebook', passport.authenticate('facebook'));
app.get('/auth/facebook/callback', passport.authenticate('facebook', passportOptions));
app.get('/auth/twitter', passport.authenticate('twitter'));
app.get('/auth/twitter/callback',passport.authenticate('twitter', passportOptions));
app.get('/auth/google', passport.authenticate('google', { scope: ['openid'] }));
app.get('/auth/google/callback',passport.authenticate('google', passportOptions));
app.map(multiplayerRoute());
app.map(userRoute());
if (process.env.GOOGLE_ANALYTICS) {
app.get('/analytics/google.js', function (req, res) {
res.set('Content-Type', 'application/javascript');
res.send('(function(i,s,o,g,r,a,m){i[\'GoogleAnalyticsObject\']=r;i[r]=i[r]||function(){' +
'(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),' +
'm=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)' +
'})(window,document,\'script\',\'//www.google-analytics.com/analytics.js\',\'ga\');' +
'ga(\'create\', \'' + process.env.GOOGLE_ANALYTICS + '\', \'tineargames.com\');' +
'ga(\'send\', \'pageview\');');
});
}
var port = process.env.PORT || TEST_PORT;
console.log('starting server on port ' + port);
var server = app.listen(port, callback);
lobby(server);
};
app.configure(function() {
//cookieParser should be above session
app.use(express.cookieParser());
//bodyParser should be above methodOverride
app.use(express.bodyParser());
app.use(express.methodOverride());
var allowCrossDomain = function(req, res, next) {
res.header('Access-Control-Allow-Origin', config.allowedDomains);
res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE');
res.header('Access-Control-Allow-Headers', 'Content-Type');
next();
}
app.use(allowCrossDomain);
app.use(function(req, res, next) {
var oneof = false;
if(req.headers.origin) {
res.header('Access-Control-Allow-Origin', req.headers.origin);
oneof = true;
}
if(req.headers['access-control-request-method']) {
res.header('Access-Control-Allow-Methods', req.headers['access-control-request-method']);
oneof = true;
}
if(req.headers['access-control-request-headers']) {
res.header('Access-Control-Allow-Headers', req.headers['access-control-request-headers']);
oneof = true;
}
if(oneof) {
res.header('Access-Control-Max-Age', 60 * 60 * 24 * 365);
}
// intercept OPTIONS method
if (oneof && req.method == 'OPTIONS') {
res.send(200);
}
else {
next();
}
});
//express/mongo session storage
app.use(express.session({
secret: 'MEAN',
store: new mongoStore({
url: config.db,
collection: 'sessions'
})
}));
//connect flash for flash messages
app.use(flash());
//dynamic helpers
app.use(helpers(config.app.name));
//use passport session
app.use(passport.initialize());
app.use(passport.session());
app.use(jsonToken());
//routes should be at the last
app.use(app.router);
//Assume "not found" in the error msgs is a 404. this is somewhat silly, but valid, you can do whatever you like, set properties, use instanceof etc.
app.use(function(err, req, res, next) {
//Treat as 404
if (~err.message.indexOf('not found')) return next();
//Log it
console.error(err.stack);
//Error page
res.status(500).render('500', {
error: err.stack
});
});
//Assume 404 since no middleware responded
app.use(function(req, res, next) {
res.status(404).render('404', {
url: req.originalUrl,
error: 'Not found'
});
});
});
/**
* Database models.
*/
var User = require('../models/user');
/**
* Renders the home page.
*/
router.get('/', function(req, res) {
res.render('home');
});
/**
* Renders the registration page.
*/
router.get('/register', flash(), function(req, res) {
if (req.user) {
return res.redirect('/dashboard');
}
res.render('register', {
title: 'Create a new account',
duplicateUser: req.flash('duplicateUser')[0],
invalidUsername: req.flash('invalidUsername')[0],
invalidPassword: req.flash('invalidPassword')[0],
invalidPasswordConfirm: req.flash('invalidPasswordConfirm')[0]
});
});
/**
* Creates a new user and logs in.
*/
exports.configure = function(app, options) {
var ensureAuthenticated = function(req, res, next) {
console.log(req.session);
if (process.env.AUTHTYPE == "skip") {
req.user = {
username: "******"
};
return next();
}
if (req.isAuthenticated()) {
return next();
}
req.session.callbackUrl = req.path;
// console.log (req.url);
// res.redirect(settings.baseUrl + '/login');
res.locals({
title: settings.title,
customCss: settings.customCss,
loginUrl: settings.baseUrl+"/login",
flash: {
error: "Authentication Required"
}
});
res.status(401);
renderLogin(res);
};
app.use(passport.initialize());
app.use(passport.session());
app.use(flash());
app.use(require('express-partials')());
var extend = require("extend");
extend(settings, options);
//console.log(settings);
if (options.db) {
db = options.db;
}
ensureDbReady(function() {});
app.use("/authstarter", express.static(__dirname + '/static'));
if (!app.engines[".jshtml"]) {
app.engine('jshtml', require("jshtml-express"));
}
var renderLogin = function(res) {
var customviewpath = app.get("views");
var defaultviewpath = __dirname + "/views/";
var relative = path.relative(customviewpath, defaultviewpath);
var view = __dirname + '/views/login.jshtml';
var layout = __dirname + '/views/blanklayout.jshtml';
if (fs.existsSync(customviewpath + "/login.jshtml")) view = customviewpath + "/login.jshtml";
if (fs.existsSync(customviewpath + "/" + settings.layout + ".jshtml")) layout = customviewpath + "/" + settings.layout + ".jshtml";
res.render(view, {
layout: layout
});
};
app.get('/logout', function(req, res) {
req.logout();
res.redirect(settings.baseUrl + '/');
});
app.get('/login', function(req, res) {
res.locals({
title: settings.title,
customCss: settings.customCss,
flash: req.flash(),
loginUrl: settings.baseUrl+"/login",
originalUrl: req.session.callbackUrl
});
renderLogin(res);
});
var authInternal = function(req, res, next) {
// console.log("auth for " + req.body.originalUrl);
req.session.callbackUrl = req.body.originalUrl;
return passport.authenticate('local', {
successRedirect: settings.baseUrl + '/loginredirect',
failureRedirect: settings.baseUrl + '/login',
failureFlash: true
})(req, res, next);
};
app.post('/login', authInternal);
app.get("/loginredirect", function(req, res) {
// console.log("redirecting - original url is " + req.session.callbackUrl);
res.redirect(req.session.callbackUrl || (settings.baseUrl + "/"));
});
exports.ensureAuthenticated = ensureAuthenticated;
};
return new Promise((resolve, reject) => {
debug('in AppUi init() async');
// self.services = services;
self.app = feathers();
var optionsUi = {
key: fs.readFileSync(ca.masterUiPrivateKeyFile),
cert: fs.readFileSync(ca.masterUiCertFile),
ca: [
fs.readFileSync(ca.intCertFile)
/*
* root cert placed in /usr/share/ca-certificates/partout and updated
* /etc/ca-certificates.conf to point to it.
* run update-ca-certificates
* only include intermediate ca here, and import this into
* browsers cert stores
*/
],
requestCert: true,
rejectUnauthorized: false
};
self.app.opts = opts;
self.app.set('cfg', cfg);
/*
var store = new ArangoDBStore({
url: cfg.database_url,
dbName: cfg.database_name
});
store.on('error', function (err) {
if (err) {
throw new Error(err);
}
});
*/
self.app
.use(compression())
.use(cors())
.use(logger)
.use('/', staticServe('public')) // assets
.use('/dist', staticServe('dist'))
.use('/node_modules', staticServe('node_modules'))
.use(flash())
.configure(hooks())
.configure(rest())
.configure(socketio(function (io) {
io.on('connection', function (socket) {
debug('socket connection recvd');
socket.on('login', function(entity, info) {
debug('(Socket) User logged in', entity);
debug('(Socket) user:'******'logout', function(tokenPayload, info) {
debug('(Socket) User logged out', tokenPayload);
});
});
io.use(function (socket, next) {
//console.log('socket event:', socket);
next();
});
}))
.configure(services(function (err, orm) {
debug('services cb');
// Create issue reporter for collection into db/ui
const issues = new Issues(self.app);
self.report_issue = self.app.report_issue = issues.report_issue.bind(issues);
self.app
//.use(express.static('public')); // /assets, /css. etc
.use(bodyParser.json())
.use(bodyParser.urlencoded({ extended: true }))
.set('query parser', 'extended')
.use(cookieParser());
debug('after app configures');
self.app.use('/', routerUi);
require('./lib/ui/routes')(routerUi, cfg, serverMetrics, self.app, auth.hooks);
self.app.set('views', 'public/views');
self.app.set('view engine', 'ejs');
// Template variables
self.app.locals = {
banner: utils.getBanner(),
master_hostname: cfg.partout_master_hostname,
master_api_port: cfg.partout_api_port,
role: 'master'
};
self.app.engine('html', require('ejs').renderFile);
// self.app.use(function (req, res, next) {
// console.log('IN MY FUNC');
// next(new Error('TEST errorHandler'));
// });
self.app.use(errorHandler({
html: function (error, req, res, next) {
console.error('errorHandler html error:', error);
self.app.report_issue(error);
next();
}
}));
///////////////////////////////////////////
self.app.on('login', function(entity, info) {
debug('(Rest) User logged in', entity);
});
self.app.on('logout', function(tokenPayload, info) {
debug('(Rest) User logged out', tokenPayload);
});
var server = httpsUi.createServer(optionsUi, self.app)
.listen(cfg.partout_ui_port);
console.info('Master UI listening on port', cfg.partout_ui_port);
var io = require('socket.io').listen(server);
self.app.setup(server);
resolve();
}));
});
module.exports = function(db) {
// Initialize express app
var app = express();
// Globbing model files
config.getGlobbedFiles('./app/models/**/*.js').forEach(function(modelPath) {
require(path.resolve(modelPath));
});
// Setting application local variables
app.locals.title = config.app.title;
app.locals.description = config.app.description;
app.locals.keywords = config.app.keywords;
app.locals.facebookAppId = config.facebook.clientID;
app.locals.GAcode = config.GA.code;
app.locals.jsFiles = config.getJavaScriptAssets();
app.locals.cssFiles = config.getCSSAssets();
app.locals.languages = require('../public/modules/core/languages/languages.json');
app.locals.appSettings = config.app.settings;
app.locals.appSettings.time = new Date().toISOString();
app.locals.appSettings.https = config.https;
// Passing the request url to environment locals
app.use(function(req, res, next) {
res.locals.url = req.protocol + '://' + req.headers.host + '/';// + req.url;
next();
});
// Should be placed before express.static
app.use(compress({
filter: function(req, res) {
return (/json|text|javascript|css/).test(res.getHeader('Content-Type'));
},
level: 9
}));
// Showing stack errors
app.set('showStackError', true);
// Set swig as the template engine
app.engine('server.view.html', consolidate[config.templateEngine]);
// Set views path and view engine
app.set('view engine', 'server.view.html');
app.set('views', './app/views');
// Environment dependent middleware
if (process.env.NODE_ENV === 'development') {
// Enable logger (morgan)
app.use(morgan('dev'));
// Disable views cache
app.set('view cache', false);
} else if (process.env.NODE_ENV === 'production') {
app.locals.cache = 'memory';
}
// Request body parsing middleware should be above methodOverride
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(bodyParser.json());
app.use(methodOverride());
// CookieParser should be above session
app.use(cookieParser());
// Express MongoDB session storage
app.use(session({
saveUninitialized: true,
resave: true,
secret: config.sessionSecret,
store: new mongoStore({
db: db.connection.db,
collection: config.sessionCollection
})
}));
// use passport session
app.use(passport.initialize());
app.use(passport.session());
// connect flash for flash messages
app.use(flash());
// Use helmet to secure Express headers
app.use(helmet.xframe());
app.use(helmet.xssFilter());
app.use(helmet.nosniff());
app.use(helmet.ienoopen());
app.disable('x-powered-by');
// Setting the app router and static folder
app.use(express.static(path.resolve('./public')));
// Globbing routing files
config.getGlobbedFiles('./app/routes/**/*.js').forEach(function(routePath) {
require(path.resolve(routePath))(app);
});
// Assume 'not found' in the error msgs is a 404. this is somewhat silly, but valid, you can do whatever you like, set properties, use instanceof etc.
app.use(function(err, req, res, next) {
// If the error object doesn't exists
if (!err) return next();
// Log it
console.error(err.stack);
// Error page
res.status(500).render('500', {
error: err.stack
});
});
// Assume 404 since no middleware responded
app.use(function(req, res) {
res.status(404).render('404', {
url: req.originalUrl,
error: 'Not Found'
});
});
// Attach Socket.io
// @link: http://vexxhost.com/blog/mean-socket-io-integration-tutorial/
var server = http.createServer(app);
var io = socketio.listen(server);
app.set('socketio', io);
app.set('server', server);
return app;
};
exports = module.exports = function(IoC, settings, sessions, User, policies) {
var app = this;
// pass a secret to cookieParser() for signed cookies
app.all(policies.notApiRouteRegexp, cookieParser(settings.cookieParser));
// add req.session cookie support
settings.session.store = sessions;
app.all(policies.notApiRouteRegexp, session(settings.session));
// support live reload
// (note this must come after sessions)
// <http://stackoverflow.com/a/26740588>
if (settings.liveReload.enabled)
app.all(policies.notApiRouteRegexp, connectLiveReload(settings.liveReload.options));
// add support for authentication
app.use(passport.initialize());
app.all(policies.notApiRouteRegexp, passport.session());
// add flash message support
app.use(session(settings.session));
app.use(flash());
app.all(policies.notApiRouteRegexp, flash());
// add passport strategies
passport.use(User.createStrategy());
passport.serializeUser(User.serializeUser());
passport.deserializeUser(User.deserializeUser());
// ## Google Authentication
if (settings.google.enabled) {
// web-based
passport.use(new GoogleStrategy({
callbackURL: settings.url + '/auth/google/callback',
clientID: settings.google.clientID,
clientSecret: settings.google.clientSecret
}, providerAuthCallback));
// token-based
passport.use(new GoogleTokenStrategy({
clientID: settings.google.clientID,
clientSecret: settings.google.clientSecret
}, providerAuthCallback));
}
// ## Facebook Authentication
if (settings.facebook.enabled) {
// web-based
passport.use(new FacebookStrategy({
callbackURL: settings.url + '/auth/facebook/callback',
clientID: settings.facebook.appID,
clientSecret: settings.facebook.appSecret
}, providerAuthCallback));
// token-based
passport.use(new FacebookTokenStrategy({
clientID: settings.facebook.appID,
clientSecret: settings.facebook.appSecret
}, providerAuthCallback));
}
function providerAuthCallback(accessToken, refreshToken, profile, done) {
if (profile.emails.length === 0 || !_.isObject(profile.emails[0]) || !validator.isEmail(profile.emails[0].value)) {
return done(new Error('Your account did not have an email address associated with it'));
}
var $or = [
{
email: profile.emails[0].value
}
];
// normalize the auth callbacks by simply pushing to the
// $or query that will be executed with User.findOne below
// this allows us to simply have one auth callback for
// different providers like Facebook, Google, etc.
var provider = {};
provider[profile.provider + '_id'] = profile.id;
// note that we unshift instead of push, since we want findOne
// to return the user based off `profile.id` which takes
// precedence over the user's email address in `profile.emails`
$or.unshift(provider);
User.findOne({
$or: $or
}, function(err, user) {
if (err) return done(err);
if (user) {
if (!user[profile.provider + '_id']) {
user[profile.provider + '_id'] = profile.id;
}
if (accessToken)
user[profile.provider + '_access_token'] = accessToken;
if (refreshToken)
user[profile.provider + '_refresh_token'] = refreshToken;
return user.save(done);
}
user = {
email: profile.emails[0].value,
name: profile.name.givenName,
surname: profile.name.familyName
};
user[profile.provider + '_id'] = profile.id;
if (accessToken)
user[profile.provider + '_access_token'] = accessToken;
if (refreshToken)
user[profile.provider + '_refresh_token'] = refreshToken;
// if the user signed in with another service
// then create a random password for them
User.register(user, randomstring.token(), function(err, user) {
if (err) return done(err);
if (!user)
return done(new Error('An error has occured while registering, please try later'));
done(null, user);
user.sendWelcomeEmail();
});
});
}
};
app.disable('x-powered-by'); // remove powered by express
// views
app.set('views', path.join(__dirname, 'server/views'));
app.set('view engine', 'ejs');
// middlewares
app.use(morgan('dev'));
app.use(bodyParser.json()); // parses application/json
app.use(bodyParser.urlencoded({ extended: true })); // parses application/x-www-form-urlencoded
app.use(compression()); // compression middleware
app.use(methodOverride()); // HTTP verbs like PUT or DELETE
app.use(requestID); // request id for logger
app.use(helmet()); // implements 6 measures for security headers
app.use(log4js.connectLogger(log4js.getLogger("http"), { level: 'auto' }));
app.use(flash()); //use flash
app.use(require('serve-favicon')(__dirname + '/public/images/favicon.ico')); //serve favicon
app.use(require('serve-static')(path.join(__dirname, 'public'))); // server static files
// routes
require('./server/routes/index')(app);
//initialize
//require(__base + '/server/init/mongo'); //mongo using mongoose
//require(__base + '/server/init/rabbit'); rabbitmq using ampq-coffee
logger = require(__base + '/server/init/logger').main;
// start listening
var server = app.listen(app.get('port'), function() {
module.exports = function (app, passport) {
// Compression middleware (should be placed before express.static)
app.use(compression({
threshold: 512
}));
// Static files middleware
app.use(express.static(config.root + '/public'));
// Use winston on production
let log = 'dev';
if (env !== 'development') {
log = {
stream: {
write: message => winston.info(message)
}
};
}
// Don't log during tests
// Logging middleware
if (env !== 'test') app.use(morgan(log));
// Swig templating engine settings
if (env === 'development' || env === 'test') {
swig.setDefaults({
cache: false
});
}
// set views path, template engine and default layout
app.engine('html', swig.renderFile);
app.set('views', config.root + '/server/views');
app.set('view engine', 'html');
// expose package.json to views
app.use(function (req, res, next) {
res.locals.pkg = pkg;
res.locals.env = env;
next();
});
// bodyParser should be above methodOverride
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(multer().array('image', 1));
app.use(methodOverride(function (req) {
if (req.body && typeof req.body === 'object' && '_method' in req.body) {
// look in urlencoded POST bodies and delete it
var method = req.body._method;
delete req.body._method;
return method;
}
}));
// CookieParser should be above session
app.use(cookieParser());
app.use(cookieSession({ secret: 'secret' }));
app.use(session({
resave: true,
saveUninitialized: true,
secret: pkg.name,
store: new mongoStore({
url: config.db,
collection : 'sessions'
})
}));
// use passport session
app.use(passport.initialize());
app.use(passport.session());
// connect flash for flash messages - should be declared after sessions
app.use(flash());
// should be declared after session and flash
app.use(helpers(pkg.name));
if (env !== 'test') {
/*app.use(csrf());
// This could be moved to view-helpers :-)
app.use(function (req, res, next) {
res.locals.csrf_token = req.csrfToken();
next();
});*/
}
};
module.exports = function (app, config, passport) {
app.set('showStackError', true);
// should be placed before express.static
// app.use(express.compress({
// filter: function (req, res) {
// return /json|text|javascript|css/.test(res.getHeader('Content-Type'))
// },
// level: 9
// }))
app.use(favicon());
app.use(express.static(config.root + '/public'))
// Logging
if (env !== 'test') app.use(logger('dev'));
// set views path, template engine and default layout
app.set('views', config.root + '/views');
app.set('view engine', 'ejs');
// expose package.json to views
app.use(function (req, res, next) {
res.locals.pkg = pkg
next()
})
// cookieParser should be above session
app.use(cookieParser());
// bodyParser
app.use(bodyParser.json());
app.use(bodyParser.urlencoded());
app.use(multer({ dest: config.root + '/uploads' }));
// expresssession storage
app.use(session({
store: new mongoStore({
url: config.db,
collection : 'sessions'
}),
secret: pkg.name,
resave: true,
saveUninitialized: true
}));
// use passport session
app.use(passport.initialize());
app.use(passport.session());
// connect flash for flash messages - should be declared after sessions
app.use(flash());
// should be declared after session and flash
// app.use(helpers(pkg.name))
// adds CSRF support
// if (process.env.NODE_ENV !== 'test') {
// app.use(express.csrf())
// // This could be moved to view-helpers :-)
// app.use(function(req, res, next){
// res.locals.csrf_token = req.csrfToken()
// next()
// })
// }
// Add user to all renders
app.use(function(req, res, next){
res.locals.user = req.user;
// res.locals.message = [''];
res.locals.message = {
'info': req.flash('info'),
'error': req.flash('error')
};
next();
});
// Bootstrap routes
require('./routes')(app, passport);
/// 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
// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: err,
user: req.user
});
});
}
// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: {},
user: req.user
});
});
// // assume "not found" in the error msgs
// // is a 404. this is somewhat silly, but
// // valid, you can do whatever you like, set
// // properties, use instanceof etc.
// 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()
// }
// // log it
// // send emails if you want
// console.error(err.stack)
// // error page
// res.status(500).render('500', { error: err.stack })
// })
// // assume 404 since no middleware responded
// app.use(function(req, res, next){
// res.status(404).render('404', {
// url: req.originalUrl,
// error: 'Not found'
// })
// })
}
var app = express();
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
app.use(logger({
stream : accessLogfile
}));
app.use(favicon());
// app.use(logger('dev'));
app.use(bodyParser());
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'public')));
app.use(flash()); // used before session
app.use(session({
secret : settings.cookieSecret,
key : settings.db, // cookie name
cookie : {
maxAge : 1000 * 60 * 60 * 24 * 30,
}, // 30 days
store : new MongoStore({
db : settings.db
})
}));
// dynamicHelper
app.use(function(req, res, next) {
res.locals.user = req.session.user;
var namespace = param.split('.')
, root = namespace.shift()
, formParam = root;
while(namespace.length) {
formParam += '[' + namespace.shift() + ']';
}
return {
param : formParam,
msg : msg,
value : value
};
}
}));
app.use(connectFlash());
app.use(function (req, res, next) {
res.locals.messages = require('express-messages')(req, res);
next();
});
app.get('*', function(req, res, next){
res.locals.user = req.user || null;
next();
});
// Specify routing
app.use('/', routes);
app.use('/users', users);
// catch 404 and forward to error handler
module.exports = function(db) {
// Initialize express app
var app = express();
// Globbing model files
config.getGlobbedFiles('./app/models/**/*.js').forEach(function(modelPath) {
require(path.resolve(modelPath));
});
// Setting application local variables
app.locals.title = config.app.title;
app.locals.description = config.app.description;
app.locals.keywords = config.app.keywords;
app.locals.facebookAppId = config.facebook.clientID;
app.locals.jsFiles = config.getJavaScriptAssets();
app.locals.cssFiles = config.getCSSAssets();
// Passing the request url to environment locals
app.use(function(req, res, next) {
res.locals.url = req.protocol + '://' + req.headers.host + req.url;
next();
});
// Should be placed before express.static
app.use(compress({
filter: function(req, res) {
return (/json|text|javascript|css/).test(res.getHeader('Content-Type'));
},
level: 9
}));
// Showing stack errors
app.set('showStackError', true);
// Set swig as the template engine
app.engine('server.view.html', consolidate[config.templateEngine]);
// Set views path and view engine
app.set('view engine', 'server.view.html');
app.set('views', './app/views');
// Environment dependent middleware
if (process.env.NODE_ENV === 'development') {
// Enable logger (morgan)
app.use(morgan('dev'));
// Disable views cache
app.set('view cache', false);
} else if (process.env.NODE_ENV === 'production') {
app.locals.cache = 'memory';
}
// Request body parsing middleware should be above methodOverride
app.use(bodyParser.urlencoded({
extended: true
}));
app.use(bodyParser.json());
app.use(methodOverride());
// CookieParser should be above session
app.use(cookieParser());
// Express MongoDB session storage
app.use(session({
saveUninitialized: true,
resave: true,
secret: config.sessionSecret,
store: new mongoStore({
db: db.connection.db,
collection: config.sessionCollection
})
}));
// use passport session
app.use(passport.initialize());
app.use(passport.session());
// connect flash for flash messages
app.use(flash());
// Use helmet to secure Express headers
app.use(helmet.xframe());
app.use(helmet.xssFilter());
app.use(helmet.nosniff());
app.use(helmet.ienoopen());
app.disable('x-powered-by');
// Setting the app router and static folder
app.use(express.static(path.resolve('./public')));
// Globbing routing files
config.getGlobbedFiles('./app/routes/**/*.js').forEach(function(routePath) {
require(path.resolve(routePath))(app);
});
// Assume 'not found' in the error msgs is a 404. this is somewhat silly, but valid, you can do whatever you like, set properties, use instanceof etc.
app.use(function(err, req, res, next) {
// If the error object doesn't exists
if (!err) return next();
// Log it
console.error(err.stack);
// Error page
res.status(500).render('500', {
error: err.stack
});
});
// Assume 404 since no middleware responded
app.use(function(req, res) {
res.status(404).render('404', {
url: req.originalUrl,
error: 'Not Found'
});
});
if (process.env.NODE_ENV === 'secure') {
// Log SSL usage
console.log('Securely using https protocol');
// Load SSL key and certificate
var privateKey = fs.readFileSync('./config/sslcerts/key.pem', 'utf8');
var certificate = fs.readFileSync('./config/sslcerts/cert.pem', 'utf8');
// Create HTTPS Server
var httpsServer = https.createServer({
key: privateKey,
cert: certificate
}, app);
// Return HTTPS server instance
return httpsServer;
}
// Attach Socket.io
var server = http.createServer(app);
var io = socketio.listen(server);
app.set('socketio', io);
app.set('server', server);
//When recieve join event from items controller add user id to room. (used for only sending data to correct users)
io.on('connection', function (socket) {
console.log(socket.id);
socket.on('join',function(user){
socket.join(user);
});
});
// Return Express server instance
return app;
};
// Configure app
var app = express();
app.set('views', __dirname + '/views');
app.set('view engine', 'jade');
// Set up middleware
app.use(express.responseTime());
app.use(express.logger());
app.use(express.favicon());
app.use(express.cookieParser());
app.use(express.bodyParser());
app.use(express.session({store: new RedisSessionStore({ttl: 60 * 30}),
secret: "BadWolf"}));
app.use(passport.initialize());
app.use(passport.session());
app.use(flash());
app.use(app.router);
app.use(express.static(__dirname + '/public'));
// Start listening
var server = app.listen(8000);
console.log('Server listening at http://127.0.0.1:8000/');
// Connect socket.io
io = socketio.listen(server);
io.set('log level', 2);
io.sockets.on('connection', function (socket) {
console.log("SocketIO Connection");
socket.on('new point', function (data) {
console.log("New Point: " + data.trackid + ", Lon: " + data.lon + ", Lat: " + data.lat);
, app = express()
, morgan = require('morgan')
, favicon = require('serve-favicon')
, cookieParser = require('cookie-parser')
, methodOverride = require('method-override')
, session = require('express-session')
, errorHandler = require('errorhandler')
, bodyParser = require('body-parser')
, marked = require('marked').setOptions({ breaks: true })
, db = require('./app/model/index.js')
, env = (process.env.NODE_ENV || 'development');
// configuration ==============
// boilerplate
app.use(cookieParser()); app.use(methodOverride()); app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json()); app.use(errorHandler()); app.use(morgan('dev')); app.use(flash());
app.set('port', process.env.PORT || 8080);
app.use(favicon(__dirname + '/public/src/assets/favicon/favicon.ico'));
app.use('/public', express.static('public'));
app.use('/parser', express.static('parser'));
app.use('/bower', express.static('bower_components'));
// view template engine
app.set('view engine', 'jade');
app.set('views', __dirname + '/app/view');
// models
// app.set('models', require('./app/model'));
// MVC Definitions =============