module.exports= function(app,passport){
app.use(bodyParser());
app.use(busboy());
//Ruta para verificar si esta autenticado
app.get('/loggedin', function(req, res) {
//Si esta autenticado devuelve el usuario
res.send(req.isAuthenticated() ? req.user : '******');
});
//Cierra la sesion actual del usuario
app.get('/logout', function (req, res){
req.logout();
res.redirect('/');
});
//
app.post('/signup',function(req,res,next){
console.log(req.body.username);
console.log(req.body.password);
passport.authenticate('local-signup',function(err, user, info) {
console.log(user);
res.json(user);
})(req, res, next);
});
app.post('/login',function(req,res,next){
passport.authenticate('local-login',function(err, user, info) {
if(user != false){
req.login(user,function(err){
if (err) { return next(err); }
});
console.log(user.local.role);
res.json(user);
}else{
console.log(info);
res.json(info);
}
})(req, res, next);
});
app.post('/uploadxml', function (req, res){
var fstream;
req.pipe(req.busboy);
req.busboy.on('file',function (fieldname,file,filename){
console.log('Uploading: ' + filename);
fstream = fs.createWriteStream('./xmls/'+filename);
file.pipe(fstream);
fstream.on('close',function(){
console.log(filename);
rxml.readXml(filename,function (doneXml){
res.json(doneXml);
console.log('ok' + doneXml);
});
});
});
});
app.get('/getXml',function (req,res){
var rfc = "zzxcasd";
var builder = new xml2js.Builder();
var stream = fs.createWriteStream("./xmls/my_file.xml");
stream.on('open', function(fd) {
console.log("hola")
stream.write('<?xml version="1.0" encoding="utf-8"?>\n');
stream.write('<cfdi:comprobante rfc="'+ rfc + '" >\n');
stream.end();
});
});
app.get('*', function(req, res) {
res.sendfile('./public/index.html');
});
};
_.extend(app.locals, {
config: config,
Loader: Loader,
assets: assets
});
app.use(errorPageMiddleware.errorPage);
_.extend(app.locals, require('./common/render_helper'));
app.use(function(req, res, next) {
res.locals.csrf = req.csrfToken ? req.csrfToken() : '';
next();
});
app.use(busboy({
limits: {
fileSize: bytes(config.file_limit)
}
}));
// routes
app.use('/api/v1', function(req, res, next) {
if (req.headers.origin) {
res.setHeader("Access-Control-Allow-Origin", req.headers.origin);
res.setHeader('Access-Control-Allow-Credentials', 'true');
}
next();
}, apiRouterV1);
app.use('/', webRouter);
// error handler
});
*/
/* put above
http.createServer(app).listen(app.get('port'), function() {
console.log('Express db server listening on port '+ app.get('port'));
});
*/
//app.listen(port);
//console.log("listening to port");
app.use(function(req,res,next){
req.db=db;
next();
});
//app.locals.db = db;
app.use(busboy());
app.get('/api/v1/recipes', recipesModel.getRecipes);
app.get('/api/v1/recipesAll', recipesModel.getAllRecipes);
app.get('/', serveFirstPage);
//app.post('/upload',multipartMiddleware,uploadFile);
app.post('/upload',uploadFilebus);
//app.post('/upload',uploadFile);
//app.post('/upload',upStub);
//app.post('/upload',upFile);
app.get('/randomRecipe', serveRandomRecipe);
/*app.get('/listdb',function(req,res){
db.driver.admin.listDatabases(function(e,dbs){
config.allowCORS);
return true;
}
var server = restify.createServer();
server.use(restify.gzipResponse());
// Increase the form field size limit from the 2M default.
server.use(restify.queryParser());
//server.use(restify.bodyParser());
// form parsing
server.use(busboy({
immediate: true,
// Increase the form field size limit from the 1M default.
limits: { fieldSize: 15 * 1024 * 1024 }
}));
server.use(function (req, res, next) {
req.body = req.body || {};
if ( !req.busboy ) {
return next();
}
req.busboy.on('field', function ( field, val ) {
req.body[field] = val;
});
req.busboy.on('end', function () {
next();
});
});
for(var i=0; i<objects.length; i++){
objs['obj_'+obj_count] = {id:'obj_'+obj_count,type:'char',img:'/images/chars/'+objects[i]+'.png',
x:Math.floor(Math.random()*xBound),y:Math.floor(Math.random()*yBound)};
obj_count++;
}
app.set('views', __dirname + '/tpl');
app.set('view engine', "jade");
app.engine('jade', require('jade').__express);
app.get("/", function(req, res){
res.render("page");
res.end();
});
app.use(busboy({limits: {fileSize: 1000000}}));
app.use(express.static(__dirname + '/public'));
/*app.post("/uploadschool", function(req, res){
var file_name = new Date().getTime();
var fstream;
req.pipe(req.busboy);
req.busboy.on('file', function (fieldname, file, filename) {
console.log("Uploading: " + filename);
fstream = fs.createWriteStream(uploadPath + '/full/' + file_name + '.jpg');
file.pipe(fstream);
fstream.on('close', function () {
im.resize({
srcPath: uploadPath + '/full/' + file_name + '.jpg',
dstPath: uploadPath + '/preview/' + file_name + '.jpg' ,
width:150,
*/ !function(e,o){"object"==typeof exports?module.exports=o():"function"==typeof define&&define.amd?define(o):e.NodeUploadExample=o()}(this,function(){var e=require("express"),o=require("fstream"),n=require("fs"),t=require("connect-busboy"),i=e.Router();return i.use(t()),i.post("/",function(e,t){"undefined"!=typeof e.busboy?(e.busboy.on("file",function(e,i,s,p,r){i.pipe(o.Writer({path:"example.dat"})),n.writeFile("example.mime",r),t.json("ok")}),e.pipe(e.busboy)):t.json("req.busboy undefined")}),i.get("/",function(e,o){n.existsSync("example.dat")&&n.existsSync("example.mime")?o.sendFile("example.dat",{root:process.cwd(),headers:{"Content-Type":n.readFileSync("example.mime")}}):o.json("example.dat || example.mime do not exist")}),i});
var fs = require('fs');
var path = require('path');
var child_process = require('child_process');
var express = require('express');
var _ = require('underscore');
var busboy = require('connect-busboy');
var async = require('async');
var config = require('./config');
var srcDir = path.join(config.document_directory, 'src');
var renderedDir = path.join(config.document_directory, 'rendered');
var app = express();
app.use('/', express.static('public'));
app.use('/document', busboy({ immediate: true }));
app.get('/document', function (req, res) {
fs.readdir(renderedDir, function (err, files) {
if (err) return res.send(500, err.message);
var result = {
documents: _.filter(files, function (fileName) { return fileName !== '.empty';})
};
res.send(result);
})
});
app.get('/document/:document_name.adoc', function (req, res) {
res.sendfile(req.params.document_name, { root: srcDir });
var express = require('express');
var router = express.Router();
var app = express();
var fs = require('fs');
var busboy = require('connect-busboy');
router.use(busboy());
// Upload file and response back.
router.post('/uploadPhotos', function(req, res) {
var fstream;
req.pipe(req.busboy);
req.busboy.on('file', function (fieldname, file, filename) {
console.log("Upload data: " + JSON.stringify(file));
filename = "test" + fileAuto() + filename.substr(filename.lastIndexOf("."));
var path = __dirname.substr(0, __dirname.length - 15) + "/public/images/" + filename;
console.log("path= " + path + " ; __dirname= " + __dirname);
fstream = fs.createWriteStream(path);
file.pipe(fstream);
fstream.on('close', function () {
res.send("http://127.0.0.1:8081/images/" + filename);
});
});
});
var auto = 1;
function fileAuto () {
return auto ++;
const app = express();
const port = process.env.PORT || 8000;
if (process.env.NODE_ENV !== "production") {
const logger = require("morgan");
app.use(logger("dev"));
}
const FileManipulator = require("./services/FileManipulator");
FileManipulator.cleanTmp();
app.use(compression());
app.use(busboy({
limits: {
fileSize: 50 * 1024 * 1024 // 50 MB
}
}));
app.use(bodyParser.urlencoded({
extended: true,
}));
app.use(bodyParser.json());
app.use(cors());
app.use("", require("./config/routes"));
const SocketIOServer = require("./services/SocketIOServer");
if (!module.parent) {
app.listen(port, (err) => {
if (err) {
var q = require("q");
var lodash = require('lodash');
var busboy = require('connect-busboy');
var app = express();
var router = express.Router();
var env = process.env.NODE_ENV || 'development';
app.locals.ENV = env;
app.locals.ENV_DEVELOPMENT = env == 'development';
app.use(logger('dev'));
app.use(busboy()); //use for file uploading
app.use(bodyParser.json({
limit: '50mb'
}));
app.use(bodyParser.urlencoded({
extended: true,
limit: '50mb'
}));
app.use(cookieParser());
app.use('/', router);
app.use(function(req, res, next) {
res.header("Access-Control-Allow-Origin", "*");
res.header("Access-Control-Allow-Methods", "GET, PUT, POST, DELETE");
res.header("Access-Control-Allow-Credentials", "true");//false
module.exports = function (app) {
// Compression middleware (should be placed before express.static)
app.use(compression({
threshold: 512
}));
app.use( express.static( nconf.get('root') + '/public') );
// Logging middleware
app.use(expressWinston.logger({
winstonInstance: winston,
meta: false, // optional: control whether you want to log the meta data about the request (default to true)
//msg: "HTTP {{res.statusCode}} {{req.method}} {{res.responseTime}}ms {{req.url}}", // optional: customize the default logging message. E.g. "{{res.statusCode}} {{req.method}} {{res.responseTime}}ms {{req.url}}"
expressFormat: true, // Use the default Express/morgan request formatting, with the same colors. Enabling this will override any msg and colorStatus if true. Will only output colors on transports with colorize set to true
colorStatus: true, // Color the status code, using the Express/morgan color palette (default green, 3XX cyan, 4XX yellow, 5XX red). Will not be recognized if expressFormat is true
ignoreRoute: function (req, res) {
// skip web page requests
skip = true;
if( req.url.match(/^\/api/)!==null ) skip = false;
return skip;
}
}));
// set views path, template engine and default layout
//app.engine('html', swig.renderFile);
//app.set('views', config.root + '/app/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();
});
app.use( cors() );
// bodyParser should be above methodOverride
app.use( bodyParser.json() );
app.use( busboy({
limits: {
fileSize: 10 * 1024 * 1024
}
})
);
app.use( bodyParser.urlencoded({ extended: false }) );
app.use(methodOverride(function (req, res) {
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: nconf.get('db'),
collection : 'sessions'
})
}));
// adds CSRF support when production mode
if ( process.env.NODE_ENV === 'production') {
// Add CSRF support only for production mode app
app.use(csrf());
// This could be moved to view-helpers :-)
app.use(function(req, res, next){
res.locals.csrf_token = req.csrfToken();
console.log( res.locals.csrf_token )
next();
});
}
/*
app.on('mount', function (parent) {
console.log(parent); // refers to the parent app
});*/
}
module.exports = function () {
"use strict";
var express = require("express");
var app = express();
var serveStatic = require("serve-static");
var path = require("path");
var logger = require("morgan");
var cookieParser = require("cookie-parser");
var bodyParser = require("body-parser");
var Q = require("q");
var busboy = require('connect-busboy'); //middleware for form/file upload
var routes = require(path.join(__dirname, ".", "routes", "index"))(express);
var models = require(path.join(__dirname, ".", "models"))();
app.models = models;
app.use(logger("dev"));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: false}));
app.use(cookieParser());
app.use(busboy());
var orderService = require(path.join(__dirname, ".","services","order"))(models, Q);
var userService = require(path.join(__dirname, ".","services","user"))(models, Q);
var userLocationService = require(path.join(__dirname, ".","services","userlocation"))(models, Q);
var groupService = require(path.join(__dirname, ".","services","group"))(models, Q);
var customerService = require(path.join(__dirname, ".","services","customer"))(models, Q);
var itemDictService = require(path.join(__dirname, ".","services","itemdict"))(models, Q);
var orderRoute = require(path.join(__dirname, ".", "routes","order"))(express, orderService);
var userRoute = require(path.join(__dirname, ".", "routes","user"))(express, userService);
var userLocationRoute = require(path.join(__dirname, ".", "routes","userlocation"))(express, userLocationService);
var groupRoute = require(path.join(__dirname, ".", "routes","group"))(express, groupService);
var customerRoute = require(path.join(__dirname, ".", "routes","customer"))(express, customerService);
var itemDictRoute = require(path.join(__dirname, ".", "routes","itemdict"))(express, itemDictService);
var surveyRoute = require(path.join(__dirname, ".", "routes","survey"))(express);
var syncRoute = require(path.join(__dirname, ".", "routes","sync"))(express);
var env = process.env.NODE_ENV || "development";
var config = require(path.join(__dirname, "config", "config.json"))[env];
// view engine setup
app.set("views", path.join(__dirname, "views"));
app.set("view engine", "jade");
// init routes
app.use("/", serveStatic(path.join(__dirname, "public"), {"index": ["index.html"]}));
app.use("/uploads", serveStatic(path.join(__dirname, "uploads")));
app.use("/api-docs-ui", serveStatic(path.join(__dirname, "swaggerui"), {"index": ["index.html"]}));
app.use("/", routes);
app.use(config.apiUrl + "/order", orderRoute);
app.use(config.apiUrl + "/user", userRoute);
app.use(config.apiUrl + "/userlocation", userLocationRoute)
app.use(config.apiUrl + "/group", groupRoute);
app.use(config.apiUrl + "/customer", customerRoute);
app.use(config.apiUrl + "/itemdict", itemDictRoute);
app.use(config.apiUrl + "/survey", surveyRoute);
app.use(config.apiUrl + "/sync", syncRoute);
return app;
};
var path = require('path'); //used for file path
var fs = require('fs-extra');
var partials = require('express-partials');
// var sessionController = require('./routes/session_controller.js');
// var postController = require('./routes/post_controller');
// var userController = require('./routes/user_controller.js');
var app = express();
var bodyParser = require('body-parser')
var mituboController = require('./routes/mitubo_controller.js');
// parse application/x-www-form-urlencoded
app.use(bodyParser.urlencoded({ extended: false }))
app.use(Busboy());
// parse application/json
app.use(bodyParser.json())
// all environments
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
app.use(express.favicon());
app.use(express.logger('dev'));
app.use(express.json());
app.use(express.urlencoded());
app.use(express.methodOverride());
app.use(express.cookieParser('--Core Blog 2014--'));
app.use(express.session());
app.use(passport.initialize());
});
client.on('disconnect', function() {
//Remove user's name from user array
//Broadcast new uster list to clients
});
});
/* Set up routes */
app.get('/', function(req, res) {
res.sendFile(__dirname + '/views/index.html');
});
app.use(busboy({
limits : {
fileSize : config.max_filesize * 1024 * 1024
}
}));
app.post('/upload', function(req, res) {
req.busboy.on('file', function(fieldname, file, filename, encoding, mimetype) {
var path = __dirname + '/uploads/';
var fstream = fs.createWriteStream(path + filename);
file.pipe(fstream);
fstream.on('close', function() {
res.redirect('back');
io.sockets.emit('upload', {
url : '/uploads/' + filename,
filename : filename
});
});
var fs = require('fs');
var busboy = require('connect-busboy'); // for file upload
// include the routes
var routes = require("./routes").routes;
// set the view engine to ejs
app.set('view engine', 'ejs');
var bodyParser = require('body-parser')
app.use( bodyParser.json() ); // to support JSON-encoded bodies
app.use(bodyParser.urlencoded({ // to support URL-encoded bodies
extended: true
}));
app.use(busboy()) // to support file uploads
// include all folders
app.use(express.static(__dirname + '/public'));
app.use(express.static(__dirname + '/public/css'));
app.use(express.static(__dirname + '/public/js'));
//set port
app.set('port', (process.env.PORT || 8000));
app.get(routes.root, function(req, res) {
// get all the crontabs
crontab.crontabs( function(docs){
res.render('index', {
routes : JSON.stringify(routes),
crontabs : JSON.stringify(docs),
module.exports = function(app,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({
filter: function(req, res) {
return (/json|text|javascript|css/).test(res.getHeader('Content-Type'));
},
// 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(logger('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');
// Set views path, template engine and default layout
//app.set('views', config.root + '/app/views');
// Enable jsonp
app.enable('jsonp callback');
//------ MIDDLEWARE
// Request body parsing middleware should be above methodOverride
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended : true}));
app.use(bodyParser.raw());
app.use(bodyParser.text());
app.use(busboy());
app.use(methodOverride());
// Dynamic helpers
app.use(helpers(config.app.name));
// Connect flash for flash messages
app.use(flash());
// Cross Domains Allowed
app.use(cors({
allowedOrigins : config.allowedOrigins,
headers : ['X-Requested-With', 'Content-Type', 'Authorization']
}));
};
app.set('trust proxy', 1); // trust first proxy
//express cookie Session
app.use(session({
name: 'racepacesession',
secret: 'wordSecret1forRacePace'
}));
app.use(sessionData({}));
//Busboy
app.use(
bb({
limits: {
fields: 10, //10 Fields per submit. This is very low, but shouldn't get reached
files: 1, //1 File at a time
fileSize: 2 * 1024 * 1024 //2MB file Limit
}
})
);
for(var urlName in urls.uses)
{
if(urls.uses[urlName].url)
{
app.use(urls.uses[urlName].url, urls.uses[urlName].func);
}
else
{
app.use(urls.uses[urlName].func);
}
export default (app, server) =>{
app.use(busboy());
var io = new SocketIo(server, {path: '/api/chat'});
// Accept file uploads.
app.post('/upload', function(req, res) {
var fstream;
req.pipe(req.busboy);
req.busboy.on('file', function(fieldname, file, filename) {
var uploadWithExtension = function(extension) {
return path.resolve(__dirname,'..','build','client','uploads',uuid.v4() + extension);
};
var extension = path.extname(filename);
var uploadPath = uploadWithExtension(extension);
var fstream = fs.createWriteStream(uploadPath);
file.pipe(fstream);
fstream.on('close', function() {
var completion = function(title, filename, cleanup) {
// N.B. We explicitly specify the URL here (inc. 'index.html') to ensure this URL is different
// to the top-level URL of the application itself. For some reason, when the two paths match,
// Firefox will not load the contents of the iframes.
// Doubtless there is 'correct' solution to this, but time is short.
state.items.push({
uuid: uuid.v4(),
title: title,
url: "/uploads/" + path.basename(filename),
cleanup: cleanup
});
broadcastState();
};
if (extension == '.jpg' || extension == '.jpeg' || extension == '.png' || extension == '.gif') {
var imagePath = uploadPath;
gm(uploadPath).autoOrient().write(uploadPath, function() {
completion(path.basename(filename, extension), uploadPath, function() {
fs.unlink(imagePath, function(error) {
if (error) {
console.log("Error occured on gm");
console.log(error);
}
});
});
res.sendStatus(200);
});
} else if (extension == '.pdf') {
var thumbnailPath = uploadWithExtension('.jpg');
var command = Util.format(
'gs -dBATCH -dNOPAUSE -sDEVICE=jpeg -r200 -sOutputFile=%s %s',
thumbnailPath, uploadPath);
exec(command, function(error) {
if (error) {
console.log("Encountered an error generating PDF preview.");
console.log(error);
res.sendStatus(500);
return;
}
completion(path.basename(filename, extension), thumbnailPath, function() {
fs.unlink(uploadPath, function(error) {
if (error) {
console.log(error);
}
});
fs.unlink(thumbnailPath, function(error) {
if (error) {
console.log(error);
}
});
});
res.sendStatus(200);
});
} else {
console.log(Util.format("Unsupported file with extension '%s'", extension));
fs.unlink(uploadPath, function(error) {
if (error) {
console.log(error);
}
});
}
})
})
});
var offerSocket = undefined;
function broadcastState() {
var clientState = Update(state, {
users: {$set: values(state.users)}
});
io.emit('server-set-state', JSON.stringify(clientState));
}
io.on('connection', function(socket) {
socket.uuid = uuid.v4(),
state.users[socket.uuid] = {
uuid: socket.uuid,
name: 'Jason Morley',
email: '*****@*****.**',
avatar: Gravatar.imageUrl('*****@*****.**', { "size": "128" })
};
broadcastState();
//avatar: {$set: gravatar.imageUrl(user.email, { "size": "128" })},
//avatar: {$set: gravatar.profile_url(user.email, { "size": "128" })},
socket.on('disconnect', function() {
delete state.users[socket.uuid];
if (offerSocket == socket) {
state.offer = undefined;
state.answer = undefined;
}
broadcastState();
}).on('client-set-user', parse_message(function(user) {
state.users[socket].name = user.name;
state.users[socket].email = user.email;
broadcastState();
})).on('client-add-item', parse_message(function(item) {
item.uuid = uuid.v4();
state.items.push(item);
broadcastState();
})).on('client-remove-item', parse_message(function(message) {
var item = state.items[message.index];
if (item.cleanup) {
item.cleanup();
}
state.items.splice(message.index, 1);
if (state.selection == item.uuid) {
state.selection = false;
}
broadcastState();
})).on('client-set-selection', parse_message(function(message) {
state.selection = message.uuid;
broadcastState();
})).on('client-clear-selection', parse_message(function(message) {
state.selection = false;
broadcastState();
})).on('client-call-add-ice-candidate', function(candidate) {
socket.broadcast.emit('server-call-add-ice-candidate', candidate);
}).on('client-call-set-offer', parse_message(function(offer) {
state.offer = offer;
offerSocket = socket;
broadcastState();
})).on('client-call-set-answer', parse_message(function(answer) {
state.answer = answer;
broadcastState();
}));
});
}
var HFTServer = function(options, startedCallback) {
var self = this;
var g = {
port: config.getSettings().settings.port,
extraPorts: [80, 8080],
screenshotCount: 0,
baseDir: 'public',
cwd: process.cwd(),
};
languages.init(options);
var relayServer;
var appleCaptivePortalHandler;
Object.keys(options).forEach(function(prop) {
g[prop] = options[prop];
});
var getBaseUrl;
var updateIpAddresses = function(addresses) {
if (relayServer) {
relayServer.setOptions({baseUrl: getBaseUrl()});
}
hftSite.setup({addresses: addresses});
hftSite.inform();
if (appleCaptivePortalHandler) {
appleCaptivePortalHandler.setOptions({address: addresses[0]});
}
};
var getAddress = (function() {
var oldAddressesAsStr;
return function() {
var addresses = g.address ? [g.address] : iputils.getIpAddresses();
if (addresses.length === 0) {
addresses = ['127.0.0.1'];
}
var addressesAsStr = addresses.join(',');
if (addressesAsStr !== oldAddressesAsStr) {
oldAddressesAsStr = addressesAsStr;
console.log('using ip address: ' + addresses[0] + (addresses.length > 1 ? '. use --address=<ip> to pick one' : ''));
updateIpAddresses(addresses);
}
return addresses[0];
};
}());
var ipIntervalId = setInterval(getAddress, 15 * 1000);
getBaseUrl = function() {
return 'http://' + getAddress() + ':' + g.port;
};
g.gameDB = g.gameDB || new AvailableGames();
var eventEmitter = new events.EventEmitter();
var gameFiles = new GameFiles();
var nonRequire = new NonRequire({fileSystem: gameFiles.fileSystem});
var es6Support = new ES6Support({fileSystem: nonRequire.fileSystem});
var fileCache = new Cache({fileSystem: es6Support.fileSystem});
// var fileCache = new Cache({fileSystem: nonRequire.fileSystem});
// var fileCache = new Cache();
var rCompile = new RCompile({fileSystem: fileCache, optimize: "uglify2"});
//var rCompile = new RCompile({fileSystem: fileCache, optimize: "none"});
var app = express();
hftSite.setup({
address: getAddress(),
port: g.port,
privateServer: g.privateServer,
});
g.cwd = path.normalize(path.join(__dirname, '..'));
var send404 = function(res, msg) {
msg = msg || '';
res.writeHead(404);
res.write('404<br/>' + res.url + "<br/>" + msg);
res.end();
};
var bodyParser = function(req, res, next) {
var query = { };
var content = [];
req.addListener('data', function(chunk) {
content.push(chunk);
});
req.addListener('end', function() {
try {
query = JSON.parse(content.join(""));
} catch (e) {
query = {};
}
req.body = query;
next();
});
};
//function saveScreenshotFromDataURL(dataURL) {
// var EXPECTED_HEADER = 'data:image/png;base64,';
// if (strings.startsWith(dataURL, EXPECTED_HEADER)) {
// var filename = 'screenshot-' + (g.screenshotCount++) + '.png';
// fs.writeFile(
// filename,
// dataURL.substr(
// EXPECTED_HEADER.length,
// dataURL.length - EXPECTED_HEADER.length),
// 'base64');
// console.log('Saved Screenshot: ' + filename + '\n');
// }
//}
var handleTimeRequest = function(query, res) {
res.json({ time: highResClock.getTime() });
};
// var handleScreenshotRequest = function(query, res) {
// saveScreenshotFromDataURL(query.dataURL);
// sendJSONResponse(res, { ok: true });
// };
var handleListRunningGamesRequest = function(query, res) {
if (!relayServer) {
send404(res);
return;
}
var games = relayServer.getGames();
res.json(games);
};
var handleListAvailableGamesRequest = function(query, res) {
res.json(g.gameDB.getGames());
};
var handleHappyFunTimesPingRequest = function(query, res) {
var games = relayServer.getGames();
var game = (games.length > 0) ? (': ' + games[0].runtimeInfo.originalGameId) : '';
res.set({'Access-Control-Allow-Origin': '*'}).json({
version: '0.0.0',
id: 'HappyFunTimes',
serverName: (options.systemName || computerName.get()) + game,
});
};
var handleOPTIONS = function(req, res) {
res.removeHeader('Content-Type');
res.writeHead(200, {
'Access-Control-Allow-Origin': '*',
'Access-Control-Allow-Methods': 'GET,POST,OPTIONS',
'Access-Control-Allow-Headers': 'X-Requested-With, X-HTTP-Method-Override, Content-Type, Accept',
'Access-Control-Allow-Credentials': false,
'Access-Control-Max-Age': 86400,
});
res.end('{}');
};
var isFolder = (function() {
// Keep a cache of all paths because fs.statSync is sync
// this should never be that big because we're only serving
// a few files and are not online.... hopefully.
var fileDB = { };
return function(filepath) {
var dir = fileDB[filepath];
if (dir === undefined) {
var stats;
try {
stats = fs.statSync(filepath);
dir = stats.isDirectory();
} catch (e) {
dir = false;
}
fileDB[path] = dir;
}
return dir;
};
}());
var sendStringResponse = function(res, data, opt_mimeType) {
res.writeHead(200, {
'Content-Type': opt_mimeType || 'text/html',
'Content-Length': data.length,
'Cache-Control': 'no-cache, no-store, must-revalidate', // HTTP 1.1.
'Pragma': 'no-cache', // HTTP 1.0.
'Expires': '0', // Proxies.
});
res.write(data);
res.end();
};
var getRequestIpAddress = function(req) {
var ip = req.headers['x-forwarded-for'];
if (!ip && req.connection) {
ip = req.connection.remoteAddress;
}
if (!ip && req.socket) {
ip = req.socket.remoteAddress;
}
if (!ip && req.connection && req.connection.socket) {
ip = req.connection.socket.remoteAddress;
}
if (ip && ip.indexOf(',')) {
ip = ip.split(',')[0];
}
return ip;
};
var sendFileResponse = function(req, res, fullPath, opt_prepFn, runtimeInfo) {
debug('path: ' + fullPath);
var mimeType = mime.lookup(fullPath);
if (mimeType) {
// This is scary. If there's any async between here and
// the actual read we could get the wrong enable.
es6Support.enable(runtimeInfo ? runtimeInfo.features.es6 : true);
fileCache.readFile(fullPath, function(err, data){
if (err) {
console.error('' + err + ': ' + fullPath);
console.error('ip: ' + getRequestIpAddress(req));
console.error(JSON.stringify(req.headers, undefined, ' '));
return send404(res);
}
if (opt_prepFn) {
data = opt_prepFn(data.toString());
}
if (strings.startsWith(mimeType, 'text')) {
res.writeHead(200, {
'Content-Type': mimeType + '; charset=utf-8',
'Cache-Control': 'no-cache, no-store, must-revalidate', // HTTP 1.1.
'Pragma': 'no-cache', // HTTP 1.0.
'Expires': '0', // Proxies.
});
res.write(data, 'utf8');
res.end();
} else {
sendStringResponse(res, data, mimeType);
}
});
} else {
send404(res);
}
};
appleCaptivePortalHandler = new AppleCaptivePortalHandler({
baseDir: path.join(g.cwd, g.baseDir),
address: getAddress(),
port: g.port,
sendFileFn: sendFileResponse,
});
if (!options.askName) {
appleCaptivePortalHandler.setFirstPath('/index.html');
}
// Blargs! What a mess. This needs to be cleaned up
var sendRequestedFileFullPath = function(req, res, fullPath, runtimeInfo, reqOptions) {
reqOptions = reqOptions || {};
var parsedUrl = url.parse(req.url);
var filePath = parsedUrl.pathname;
debug("sendRequestedFileFullPath:", filePath);
var isTemplate = (runtimeInfo && runtimeInfo.templateUrls[filePath]) || reqOptions.params;
var isQuery = parsedUrl.query !== null;
var isAnchor = parsedUrl.hash !== null;
if (runtimeInfo && runtimeInfo.features.es6 && es6Support.isES6(fullPath)) {
var mapFile = parsedUrl.pathname + '.map';
res.setHeader('X-SourceMap', mapFile);
}
if (!isQuery && !isAnchor) {
// Add '/' if it's a folder.
if (!strings.endsWith(filePath, '/') && isFolder(fullPath)) {
filePath += '/';
res.writeHead(302, {
'Location': filePath,
});
res.end();
return;
}
// Add index.html if ends with '/'
if (strings.endsWith(fullPath, '/') || strings.endsWith(fullPath, '\\')) {
fullPath += 'index.html';
}
}
var prepFn = isTemplate ? (function() {
var params = [
{ localhost: getAddress(), },
];
if (runtimeInfo) {
params.push(runtimeInfo);
}
if (reqOptions.params) {
if (reqOptions.params.length) {
params = params.concat(reqOptions.params);
} else {
params.push(reqOptions.params);
}
}
return function(str) {
return strings.replaceParams(str, params);
};
}()) : undefined;
sendFileResponse(req, res, fullPath, prepFn, runtimeInfo);
};
var gamePrefix = "/games/";
var gamePrefixLength = gamePrefix.length + 1; // + the slash after the id
var pathToGamePath = function(gameId, runtimeInfo, filePath) {
return path.normalize(path.join(runtimeInfo.htmlPath, filePath.substr(gamePrefixLength + gameId.length)));
};
// Send a file from a game.
var sendGameRequestedFile = function(req, res) {
var gameId = req.params[0];
var runtimeInfo = g.gameDB.getGameById(gameId);
if (!runtimeInfo || !runtimeInfo.htmlPath) {
return send404(res, 'unknown gameId: ' + gameId);
}
var parsedUrl = url.parse(req.url);
var filePath = parsedUrl.pathname;
var fullPath = pathToGamePath(gameId, runtimeInfo, filePath);
sendRequestedFileFullPath(req, res, fullPath, runtimeInfo);
};
var sendRequestedFile = function(req, res, reqOptions) {
var parsedUrl = url.parse(req.url);
var filePath = parsedUrl.pathname;
var fullPath = path.normalize(path.join(g.cwd, g.baseDir, filePath));
sendRequestedFileFullPath(req, res, fullPath, undefined, reqOptions);
};
// Send a file from the HFT system
var sendSystemRequestedFile = function(req, res) {
if (appleCaptivePortalHandler.check(req, res)) {
return;
}
sendRequestedFile(req, res);
};
// Send Templated File
var sendTemplatedFile = function(req, res) {
sendRequestedFile(req, res, {
params: {
'enterNameScript': (options.askName ? 'scripts/enter-name.js' : 'scripts/go-to-index.js'),
},
});
};
var addTemplateInsertedPath = function(theApp, pathRegex, templateName, contentPath) {
theApp.get(pathRegex, function(req, res) {
var gameId = req.params[0];
var filename = req.params[1] || templateName;
var runtimeInfo = g.gameDB.getGameById(gameId);
if (!runtimeInfo) {
var msg = [
'url:' + req.url,
'unknown gameId: ' + gameId,
'have you run `hft add` for the game in ' + path.dirname(contentPath),
].join('\n');
console.error(msg);
return send404(res, msg);
}
if (!templateName) {
contentPath = filename + ".html";
var urlRuntimeInfo = runtimeInfo.templateFileOptions[contentPath];
if (urlRuntimeInfo && urlRuntimeInfo.urlInfo) {
templateName = urlRuntimeInfo.urlInfo.template;
}
}
if (!runtimeInfo.useTemplate[templateName]) {
return sendGameRequestedFile(req, res);
}
var templatePath = runtimeInfo.versionSettings.templates[templateName];
templatePath = path.normalize(path.join(g.cwd, templatePath));
var contentFullPath = path.normalize(path.join(runtimeInfo.htmlPath, contentPath));
fileCache.readFile(templatePath, function(err, templateData) {
if (err) {
console.error('' + err + ': ' + templatePath);
return send404(res);
}
sendFileResponse(req, res, contentFullPath, function(str) {
debug("doing substitutions for:", contentPath);
var scriptParams = {
filename: filename,
};
var result = strings.replaceParams(templateData.toString(), [
{
filename: filename,
pages: {
game: {
beforeScripts: strings.replaceParams(runtimeInfo.pages.game.beforeScripts, scriptParams),
afterScripts: strings.replaceParams(runtimeInfo.pages.game.afterScripts, scriptParams),
},
controller: {
beforeScripts: strings.replaceParams(runtimeInfo.pages.controller.beforeScripts, scriptParams),
afterScripts: strings.replaceParams(runtimeInfo.pages.controller.afterScripts, scriptParams),
},
},
},
runtimeInfo,
{
content: str,
hftSettings: 'window.hftSettings = ' + JSON.stringify({
menu: g.menu,
apiVersion: runtimeInfo.info.happyFunTimes.apiVersion,
}),
},
]);
return result;
});
});
});
};
var minifyControllerJS = function() {
var gameIndexRE = /\/games\/(.*?)\/index.html$/;
return function(req, res, next) {
var referer = req.get("Referer");
var match = gameIndexRE.exec(referer);
if (!match) {
return next();
}
var gameId = match[1];
var runtimeInfo = g.gameDB.getGameById(gameId);
if (!runtimeInfo) {
return next();
}
var controllerPath = runtimeInfo.htmlPath + "/scripts/controller.js";
rCompile.compile(controllerPath, function(err, content) {
if (err) {
console.warn(err);
return next();
}
sendStringResponse(res, content, "application/json");
});
};
}();
app.get(/^\/hft\/0.x.x\/scripts\/runtime\/live-settings\.js$/, function(req, res) {
var data = {
system: {
checkForApp: options.checkForApp,
},
};
var src = "define([], function() { return " + JSON.stringify(data) + "; })\n";
sendStringResponse(res, src, "application/javascript");
});
addTemplateInsertedPath(app, /^\/games\/(.*?)\/index\.html$/, 'controller', 'controller.html');
addTemplateInsertedPath(app, /^\/games\/(.*?)\/gameview\.html$/, 'game', 'game.html');
addTemplateInsertedPath(app, /^\/games\/(.*?)\/(.*?)\.html$/);
app.get(/^\/games\/(.*?)\/runtime-scripts\/traceur-runtime.js$/, function(req, res) {
//var gameId = req.params[0];
var fullPath = path.join(__dirname, '..', 'node_modules', 'traceur', 'bin', 'traceur-runtime.js');
sendRequestedFileFullPath(req, res, fullPath);
});
var nonPath = path.join(__dirname, '..', 'templates', '0.x.x', 'non-require-v1.3.0.js');
nonRequire.addPath(nonPath);
app.get(/^\/games\/(.*?)\/runtime-scripts\/hft-min.js$/, function(req, res) {
//var gameId = req.params[0];
sendRequestedFileFullPath(req, res, nonPath);
});
if (options.optimizeController) {
app.get(/^\/3rdparty\/require\.js$/, minifyControllerJS);
}
if (options.allowMinify) {
app.get(/^\/games\/(.*?)\/scripts\/(.*?)-minify\.js$/, function(req, res) {
var gamePrefixLength = 8; // '/games/' + the slash after the id
var gameId = req.params[0];
var runtimeInfo = g.gameDB.getGameById(gameId);
if (!runtimeInfo || !runtimeInfo.htmlPath) {
return send404(res, 'unknown gameId: ' + gameId);
}
var parsedUrl = url.parse(req.url);
var filePath = parsedUrl.pathname;
var fullPath = path.normalize(path.join(runtimeInfo.htmlPath, filePath.substr(gamePrefixLength + gameId.length)));
nonRequire.addPath(fullPath);
sendGameRequestedFile(req, res);
});
}
var addUploadedFile = function(req, res) {
debug("addUploadedFile");
var bad = false;
var files = {};
var fields = {};
req.pipe(req.busboy);
req.busboy.on('field', function(fieldname, val) {
fields[fieldname] = val;
});
req.busboy.on('file', function (fieldname, file, filename) {
//debug("receiving: " + filename);
var buffers = [];
file.on('data', function(data) {
//debug("got chunk " + buffers.length + ": " + data.length);
buffers.push(data);
});
file.on('end', function() {
files[filename] = Buffer.concat(buffers);
//debug("total data: " + files[filename]);
});
file.on('error', function(e) {
console.error(e);
bad = true; // not really sure how to handle errors
});
});
req.busboy.on('finish', function() {
try {
if (bad) {
throw "trouble receiving file";
}
var gameId = fields.gameId;
if (!gameId) {
throw "bad gameId";
}
self.addFilesForGame(gameId, files);
res.json({
success: true,
msg: "Added " + Object.keys(files).length + " files",
});
} catch (e) {
debug("failed to add: " + Object.keys(files).join(", ") + "\n" + e);
var eStr = e ? e.toString() : "";
res.json({
sucesss: false,
msg: "Failed to add: " + Object.keys(files).join(", ") + "\n" + eStr,
});
}
});
};
var installUploadedFile = function(req, res) {
debug("installUploadedFile");
var fileInfo;
req.pipe(req.busboy);
req.busboy.on('file', function (fieldname, file, filename) {
debug("receiving: " + filename);
var safeishName = filename.replace(/[^a-zA-Z0-9-_. ]/g, '_').substring(0, 64);
msgbox.prompt({
msg: "Install '" + safeishName + "'?",
title: "HappyFunTimes",
}, function(err, result) {
if (err) {
result = msgbox.Result.NO;
}
switch (result) {
case msgbox.Result.YES: {
utils.getTempTempFilename({postfix: ".zip"})
.then(function(_fileInfo) {
fileInfo = _fileInfo;
debug("streamfile: " + filename);
return new Promise(function(resolve, reject) {
var fstream = fs.createWriteStream(fileInfo.filename);
file.pipe(fstream);
fstream.on('close', function() {
resolve(fileInfo);
});
fstream.on('error', function(e) {
reject(e);
});
});
})
.then(function() {
debug("installing: " + filename);
return install.install(fileInfo.filename, undefined, { overwrite: true });
})
.then(function() {
debug("installed: " + filename);
fileInfo.cleanup();
res.json({
success: true,
msg: "Installed",
});
})
.catch(function(e) {
debug("failed to install: " + filename);
e = e ? e.toString() : "";
fileInfo.cleanup();
res.json({
sucesss: false,
msg: "Failed to install: " + e.replace(fileInfo.filename, filename),
});
});
}
break;
case msgbox.Result.NO:
default: {
res.json({
success: true,
msg: "Installation Cancelled",
});
}
break;
}
});
});
};
// if we're in DNS mode we'll get messages from games trying to
// inform happyfuntimes.net
function fakeHFTSitePing(req, res) {
res.json({
ip: "0.0.0.0",
});
}
app.get(/^\/games\/(.*?)\//, sendGameRequestedFile);
app.get(/^\/enter-name.html/, sendTemplatedFile);
app.use(/^\/api\/v0\/install\//, busboy());
app.post(/^\/api\/v0\/install\//, installUploadedFile);
app.use(/^\/api\/inform2/, busboy());
app.post(/^\/api\/inform2/, fakeHFTSitePing);
app.use(/^\/api\/v0\/uploadFile\//, busboy());
app.post(/^\/api\/v0\/uploadFile\//, addUploadedFile);
app.get(/.*/, sendSystemRequestedFile);
app.post(/.*/, bodyParser);
var postCmdHandlers = {
time: handleTimeRequest,
//screenshot: handleScreenshotRequest,
listRunningGames: handleListRunningGamesRequest,
listAvailableGames: handleListAvailableGamesRequest,
happyFunTimesPing: handleHappyFunTimesPingRequest,
};
app.post(/.*/, function(req, res){
if (!req.body.cmd){
return send404(res);
}
var handler = postCmdHandlers[req.body.cmd];
if (!handler){
return send404(res);
}
handler(req.body, res);
});
app.options(/.*/, handleOPTIONS);
var ports = [g.port];
g.extraPorts.forEach(function(p) {
if (g.port.toString() !== p) {
ports.push(p);
}
});
var numResponsesNeeded = ports.length;
var servers = [];
var goodPorts = [];
var tryStartRelayServer = function() {
--numResponsesNeeded;
if (numResponsesNeeded < 0) {
throw 'numReponsese is negative';
}
if (numResponsesNeeded === 0) {
if (goodPorts.length === 0) {
startedCallback(new Error('NO PORTS available. Tried port(s) ' + ports.join(', ')));
return;
}
var RelayServer = require('./relayserver.js');
relayServer = options.relayServer || new RelayServer(servers, {
baseUrl: getBaseUrl(),
noMessageTimout: options.inactivityTimeout,
gameDB: g.gameDB,
hftServer: this,
languages: languages,
instructions: options.instructions,
instructionsPosition: options.instructionsPosition,
});
console.log('Listening on port(s): ' + goodPorts.join(', ') + '\n');
eventEmitter.emit('ports', goodPorts);
// Add management game
var hftGame = new HFTGame({
gameDB: g.gameDB,
relayServer: relayServer,
});
relayServer.assignAsClientForGame({gameId: '__hft__', showInList: false}, hftGame.getClientForGame());
relayServer.on('gameStarted', function(e) {
if (options.kiosk && !options.askName) {
var runtimeInfo = g.gameDB.getGameById(e.gameId);
if (runtimeInfo) {
appleCaptivePortalHandler.setFirstPath('/games/' + e.gameId + '/index.html');
}
}
});
startedCallback();
}
}.bind(this);
var makeServerErrorHandler = function(portnum) {
return function(err) {
console.warn('WARNING!!!: ' + err.code + ': could NOT connect to port: ' + portnum);
tryStartRelayServer();
};
};
var makeServerListeningHandler = function(theServer, portnum) {
return function() {
servers.push(theServer);
goodPorts.push(portnum);
tryStartRelayServer();
};
};
ports.forEach(function(port) {
var server = options.httpServer || http.createServer(app);
server.once('error', makeServerErrorHandler(port));
server.once('listening', makeServerListeningHandler(server, port));
server.listen(port);
});
/**
* Close the HFTServer
* @todo make it no-op after it's closed?
*/
this.close = function() {
if (relayServer) {
relayServer.close();
}
servers.forEach(function(server) {
server.close();
});
if (ipIntervalId) {
clearInterval(ipIntervalId);
ipIntervalId = undefined;
}
};
this.getSettings = function() {
return g;
};
this.on = function() {
eventEmitter.on.apply(eventEmitter, arguments);
};
this.addListener = function() {
eventEmitter.addListener.apply(eventEmitter, arguments);
};
this.removeListener = function() {
eventEmitter.removeListener.apply(eventEmitter, arguments);
};
this.handleRequest = function(req, res) {
app(req, res);
};
this.addFilesForGame = function(gameId, files) {
var runtimeInfo = g.gameDB.getGameById(gameId);
if (!runtimeInfo) {
console.error("can not get runtimeInfo for gameId: " + gameId);
return;
}
if (!runtimeInfo.features.filesFromGame) {
console.error("files from game requires API version 1.11.0 or greater. Update your package.json");
return;
}
var mappedFiles = {};
Object.keys(files).forEach(function(filePath) {
var content = files[filePath];
debug("added: " + filePath + " size: " + content.length + " gameId:" + gameId);
filePath = filePath.replace(/\\/g, '/');
filePath = gamePrefix + gameId + '/' + filePath;
filePath = pathToGamePath(gameId, runtimeInfo, filePath);
mappedFiles[filePath] = content;
});
gameFiles.addFiles(mappedFiles);
};
};
function run(configuration) {
var config = configuration || {};
var projectFolder = (config.hasOwnProperty('fileStorage') ? config.fileStorage.projectFiles || __dirname + '/static/translations' : __dirname + '/static/translations'),
projectJSON = (config.hasOwnProperty('fileStorage') ? config.fileStorage.projectJSON || projectFolder + '/project.json' : projectFolder + '/project.json'),
uploadFolder = (config.hasOwnProperty('fileStorage') ? config.fileStorage.images || __dirname + '/dist/upload' : __dirname + '/dist/upload'),
mkdir = require('./lib/server/mkdir-p');
// create required folders:
mkdir('/', uploadFolder);
mkdir('/', projectFolder);
var packageJSON = require('./package.json'),
express = require('express'),
shoe = require('shoe'),
dnode = require('dnode'),
dao = require('./lib/server/dao.js')({projectFolder, uploadFolder, projectJSON}),
fileManager = require('./lib/server/legacy/fileManager.js')(projectFolder),
serverPort = config.port || (packageJSON.config.port || 3000),
enableAuth = packageJSON.config.enableAuth,
pug = require('pug'),
cookieParser = require('cookie-parser'),
bodyParser = require('body-parser'),
changesNotifier = require('./lib/server/changesNotifier.js')(),
busboy = require('connect-busboy'),
operations = require('./lib/server/operations.js')(dao, changesNotifier, config.auth);
var app = express();
// initialize the dao object - it's required to do this asynchronous because of the projectHandler
dao.init()
.catch(err => console.log(err))
enableAuth = config.hasOwnProperty('auth');
// use bodyParser middleware for handling request bodies (express does *not* provide that feature out-of-the-box).
// since we only have one case of that (POST to /login where username, password are in the body) and that one is url-encoded,
// we only need that flavor of bodyParser. about the "extended" property, see https://github.com/expressjs/body-parser#bodyparserurlencodedoptions
app.use(bodyParser.urlencoded({
extended: false
}));
// same for parsing cookie
app.use(cookieParser());
app.use(busboy());
// activate the LDAP auth
if (enableAuth) {
app.use(require('./lib/server/auth')(app, config.auth))
app.use(require('./lib/server/middleware/touchSession'))
}
app.use(function (req, res, next) {
console.log(req.method, req.url, req.query, req.user ? req.user.name : '-');
next();
});
// configure routes for static content
if (config.translatronUi) {
app.use('/js',
express.static(__dirname + '/node_modules/@eightyfour84/translatron-ui/dist/js'));
app.use('/css',
express.static(__dirname + '/node_modules/@eightyfour84/translatron-ui/dist/css'));
app.use('/img',
express.static(__dirname + '/node_modules/@eightyfour84/translatron-ui/dist/img'));
} else {
app.use('/dist',
express.static(__dirname + '/dist'));
}
app.use('/images',
express.static(uploadFolder));
app.use('/bower_components',
express.static(__dirname + '/bower_components'));
app.use(require('./lib/server/middleware-importer/upload')(uploadFolder, function (folder, key, fName) {
operations.addImage(folder, key, fName);
}));
app.use(require('./lib/server/middleware-importer/uploadJMBF')(operations.saveBundle));
app.use(require('./lib/server/middleware-importer/importJSON')(operations.importJSON));
/*
The main router handles all URLs for viewing/editing projects/directories and the export routes
*/
var mainRouter = express.Router();
mainRouter.use(require('./lib/server/middleware/usersOnline'));
// TODO add middleware to mainRouter which will check if a project or directory with that id exists
mainRouter.use(require('./lib/server/middleware-exporter/jpmbfExporter')(dao));
mainRouter.use(require('./lib/server/middleware-exporter/jsonExporter')(dao));
mainRouter.get('*', (req, res) => {
if (config.translatronUi) {
res.header('version', packageJSON.version)
res.sendFile(__dirname + '/node_modules/@eightyfour84/translatron-ui/dist/index.html')
} else {
res.send(pug.compileFile(__dirname + '/lib/client/pug/index.pug')({
version: packageJSON.version
}));
}
});
var toLoginIfUnauthenticated = function (req, res, next) {
if (!/\.json/.test(req.path) && !/\.properties/.test(req.path) && enableAuth && !req.user) {
// TODO sending the login page only makes sense for browser requests. if anybody is e.g. using curl to
// retrieve message bundles, we should only return a 401 but no content
res.status(401).send(pug.compileFile(__dirname + '/lib/client/pug/login.pug')());
} else {
next();
}
};
app.get(/\/(?:\w\/)*(?:\w+\.\w+)?/, toLoginIfUnauthenticated, mainRouter);
// catch-all route + handler if no route matched, just return 404
app.all('*', (req, res) => {
res.status(404).send('Not found');
});
var server = app.listen(serverPort);
var websocketServer = shoe(function (stream) {
"use strict";
var d = dnode(operations);
// handle errors from processing commands from clients: at least log them
// if we didn't have this error handler, errors would propagate up the stack and effectively close down the
// application
d.on('error', (err) => {
console.error(err.message, err.stack);
});
d.on('end', () => {
operations.detachClientCallbacks();
});
d.pipe(stream).pipe(d);
});
// "/trade" identifies the websocket connection
websocketServer.install(server, '/trade');
console.log("start server ", serverPort);
}
replset: {socketOptions: {keepAlive: 300000, connectTimeoutMS: 30000}}
};
mongoose.connect(config.database, options);
var conn = mongoose.connection;
// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json({limit: '50mb'}));
app.use(bodyParser.urlencoded({limit: '50mb', extended: true, parameterLimit: 50000}));
app.use(cookieParser());
app.use(busboy({
highWaterMark: 2 * 1024 * 1024,
limits: {
fileSize: 10 * 1024 * 1024
}
}));
app.use('/images', express.static(__dirname + '/public/uploads'));
app.use(express.static(__dirname + '/public'));
app.use('/', routes);
app.use('/upload', upload);
app.use('/deals', deals);
app.use('/users', users);
app.use('/lists', lists);
app.use('/merchants', merchants);
app.use('/init', init);
app.use('/services', services);
app.use('/categories', categories);
app.use('/macrocategories', macrocategories);
/**
* @file Provides a file upload field for entity forms
*/
/**
* @namespace filefield
*/
iris.registerModule("filefield",__dirname);
var busboy = require('connect-busboy');
iris.app.use(busboy());
var fs = require('fs');
iris.route.post('/admin/file/fileFieldUpload/:filename/:form/:parameters', function (req, res) {
// Make temp file directory and files directory if they don't exist
var mkdirSync = function (path) {
try {
fs.mkdirSync(path);
} catch (e) {
if (e.code != 'EEXIST') throw e;
}
};
mkdirSync(iris.sitePath + "/" + "temp");
mkdirSync(iris.sitePath + "/" + "files");
app.use(favicon(__dirname + '/public/img/icon.png'));
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(session({
store : new MongoStore({ url: config.db , ttl: 4 * 60 * 60}), //4 hour
secret: 'action',
name : 'action',
resave:true,
saveUninitialized:true,
}));
app.use(busboy({
// immediate: true,
limits: {
fileSize: 10 * 1024 * 1024
},
}));
app.use('/', routes);
app.use('/users', users);
app.use('/action',require('./routes/action'));
app.use('/search',require('./routes/search'));
app.use('/type',require('./routes/type'));
app.use('/notification',require('./routes/notif'));
app.use('/web',web);
// catch 404 and forward to error handler
app.use(function(req, res, next) {
var err = new Error('Not Found');
err.status = 404;
next(err);
function initExpress() {
app.set('json spaces', 4);
app.set('views', './views');
app.set('view engine', 'ejs');
app.use(busboy());
}
'Access-Control-Allow-Headers': 'Origin, X-Requested-With, Content-Range, Content-Disposition, Content-Type, X-Foo, X-Rnd',
'Access-Control-Allow-Credentials': 'true'
});
}
next();
});
var uploadPath = '/upload';
app.options(uploadPath, function (req, res) {
res.end();
});
app.post(
uploadPath,
busboy({immediate: true}), // parse post data
fileApi(), // prepare req.body, req.files and req.images
function (req, res) {
var jsonp = req.query.callback || null;
res[jsonp ? 'jsonp' : 'json']({
status: 200,
statusText: 'OK',
images: req.images,
data: {
HEADERS: req.headers,
_REQUEST: req.body,
_FILES: req.files
}
});
}
if (success) res.locals.message = '<div class="alert alert-success">' + success + '</div>';
// expose "messages" local variable
res.locals.messages = msgs;
// expose "hasMessages"
res.locals.hasMessages = !! msgs.length;
next();
// empty or "flush" the messages so they
// don't build up
req.session.messages = [];
});
// File Handling
app.use(busboy({ immediate: true }));
// Context processors for templates - Must come after session - before controllers
app.use(context_processors());
// load controllers
require('./lib/boot')(app, { verbose: !module.parent });
// Additional Routes
var login = require('./lib/auth');
app.get('/login', login.load_login);
app.post('/login', login.authenticate);
app.get('/logout', login.logout);
var photo_ajax = require('./controllers/photo/ajax/index');
app.get('/photo_ajax/:id', photo_ajax.get_photo);
res.locals.csrf = req.csrfToken ? req.csrfToken() : '';
next();
});
// github oauth
passport.serializeUser(function (user, done) {
done(null, user);
});
passport.deserializeUser(function (user, done) {
done(null, user);
});
passport.use(new GitHubStrategy(config.GITHUB_OAUTH, githubStrategyMiddleware));
app.use(busboy({
limits: {
fileSize: 10 * 1024 * 1024 // 10MB
}
}));
// routes
app.use('/', webRouter);
app.use('/api/v1', cors(), apiRouterV1);
// error handler
if (config.debug) {
app.use(errorhandler());
} else {
app.use(function (err, req, res, next) {
return res.status(500).send('500 status');
});
}
var gameServer = null;
var app = express();
// view engine setup
app.setMaster = function (configs) {
gameServer = configs;
};
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'hbs');
// uncomment after placing your favicon in /public
//app.use(favicon(__dirname + '/public_html/favicon.ico'));
//app.use(logger('dev'));
app.use(busboy({limits: {fileSize: 512 * 1024}}));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: false}));
app.use(cookieParser());
app.use('/', routes);
app.use(express.static(path.join(__dirname, 'public_html')));
// 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
return JSON.stringify(input);
});
env.addFilter('time', function(input, format){
if(!input){
return "";
}
return moment(input).format(format || "YYYY-MM-DD HH:mm:ss");
});
nunjucks.precompile(path.normalize(__dirname +'/views'), { env: env, include:[/./] });
env.express(app);
//middleware
app
.use(bodyParser.json())
.use(bodyParser.urlencoded({extended:true}))
.use(busboy())
.use(cookieParser())
.use(session({secret:'weishop'}))
.use(flash())
.use(operation())
.use(function(err, req, res, next) {
res.json(err);
console.error('[%s][%s] Express handle exception: [%s]', new Date(), process.pid, err);
});
//wechat
wechat(app);
//routes
routes(app);
exports.extend = function(app, options) {
if (app[key]) { return app; }
Object.defineProperty(app, key, { value: exports });
options = options || {};
options.immediate = false; //Remove if the user sets it
options.path = options.path || path.join(os.tmpdir(), 'express-busboy');
const restrictMultiple = options.restrictMultiple;
const mimeTypeLimit = options.mimeTypeLimit ? !Array.isArray(options.mimeTypeLimit) ? [options.mimeTypeLimit] : options.mimeTypeLimit : null;
delete options.restrictMultiple;
delete options.mimeTypeLimit;
app.use(busboy(options));
app.use((req, res, next) => {
var allowUpload = true;
req.body = req.body || {};
req.files = req.files || {};
if (req.is('json') && req.readable) {
jsonBody(req, res, options, (err, body) => {
req.body = body || {};
next();
});
return;
}
if (!req.busboy) { //Nothing to parse..
return next();
}
if (options.allowedPath) {
allowUpload = false;
/*istanbul ignore else - else case is the default case*/
if (options.allowedPath === req.url) {
allowUpload = true;
} else if (typeof options.allowedPath === 'function') {
allowUpload = !!options.allowedPath(req.url);
} else if (typeof options.allowedPath.test === 'function') {
allowUpload = !!options.allowedPath.test(req.url);
}
}
let bbDone = false;
const finish = () => {
/*istanbul ignore next*/
if (!bbDone) {
return; //bail busboy is still running
}
//Busboy is done, check the files
let complete = true;
Object.keys(req.files).forEach((name) => {
let file = req.files[name];
if (!Array.isArray(file)) {
file = [file];
}
file.forEach((f) => {
if (!f.done) { //file is not done writing
complete = false;
}
});
});
if (complete) { //all files are done writing..
next();
}
};
if (options.upload && allowUpload) {
req.busboy.on('file', (name, file, filename, encoding, mimetype) => {
const fileUuid = uuid.v4();
const out = path.join(options.path, '/', fileUuid, '/', name, filename);
if (mimeTypeLimit && !mimeTypeLimit.some(type => { return type === mimetype; })) {
return file.resume();
}
/*istanbul ignore next*/
if (!filename || filename === '') {
return file.on('data', () => { });
}
const data = {
uuid: fileUuid,
field: name,
file: out,
filename: filename,
encoding: encoding,
mimetype: mimetype,
truncated: false,
done: false
};
mkdirp.sync(path.dirname(out));
const writer = fs.createWriteStream(out);
writer.on('finish', () => {
data.done = true;
finish();
});
file.pipe(writer);
// Indicate whether the file was truncated
/*istanbul ignore next*/
file.on('limit', () => {
data.truncated = true;
});
convertParams(req.files, name, data);
});
}
req.busboy.on('field', (name, data) => {
convertParams(req.body, name, data);
});
req.busboy.on('finish', () => {
req.body = qs.parse(qs.stringify(req.body), { arrayLimit: options.arrayLimit });
if (restrictMultiple) {
[req.body, req.files].forEach(fixDups);
}
bbDone = true;
finish();
});
req.pipe(req.busboy);
});
return app;
};