getMiddleware: function() {
return connect()
.use('/get', connect.query())
.use('/get/collection', this.getCollection.bind(this))
.use('/get/collectionAndDaresAndInstances', this.getCollectionAndDaresAndInstances.bind(this))
.use('/get/dare', this.getDare.bind(this))
.use('/get/dareAndInstance', this.getDareAndInstance.bind(this))
.use('/get/dareEdit', this.getDareEdit.bind(this))
.use('/get/checkUsername', this.getCheckUsername.bind(this))
.use('/get/checkEmail', this.getCheckEmail.bind(this))
.use('/get/loginData', this.getLoginData.bind(this))
.use('/get/daresAndInstancesAll', this.getDaresAndInstancesAll.bind(this))
.use('/get/daresAndInstancesNewest', this.getDaresAndInstancesNewest.bind(this))
.use('/get/daresAndInstancesByUserId', this.getDaresAndInstancesByUserId.bind(this))
.use('/get/daresAndInstancesPlayed', this.getDaresAndInstancesPlayed.bind(this))
.use('/get/userByUsername', this.getUserByUsername.bind(this))
.use('/get/usersAll', this.getUsersAll.bind(this))
.use('/post', connect.json())
.use('/post/program', this.postProgram.bind(this))
.use('/post/instance', this.postInstance.bind(this))
.use('/post/dareCreate', this.postDareCreate.bind(this))
.use('/post/dareEdit', this.postDareEdit.bind(this))
.use('/post/register', this.postRegister.bind(this))
.use('/post/login', this.postLogin.bind(this))
.use('/post/logout', this.postLogout.bind(this));
},
module.exports = function(app) {
app.engine('handlebars', exphbs.create({
defaultLayout: 'main',
layoutsDir: app.get('views') + '/layouts',
partialsDir: [app.get('views') + '/partials'],
helpers: {
timeago: function(timestamp) {
console.log(timestamp);
return moment(timestamp).startOf('minute').fromNow();
}
}
}).engine);
app.set('view engine', 'handlebars');
app.use(connect.logger('dev'));
app.use(connect.bodyParser({
uploadDir:path.join(__dirname, '../public/upload/temp')
}));
app.use(connect.json());
app.use(connect.urlencoded());
app.use(connect.methodOverride());
app.use(connect.cookieParser('some-secret-value-here'));
app.use(app.router);
app.use('/public/', connect.static(path.join(__dirname, '../public')));
if ('development' === app.get('env')) {
app.use(connect.errorHandler());
}
routes.initialize(app);
return app;
};
/**
* Sets up the correct connect middleware and setup a requesthandler to handle incoming request.
*
* @param context
* @param port
*/
function start(context, port) {
var logger = log4js.getLogger('manuras');
logger.info('Starting HTTP Server on Worker');
var app = connect();
logger.debug('Setting up middleware');
app.use(connect.static(context.settings.paths.public))
.use(connect.query())
.use(connect.cookieParser())
.use(connect.urlencoded())
.use(connect.json())
.use(requestHandler.handler(context))
.use(errorHandler.handle());
logger.debug('Creating Server');
var server = http.createServer(app);
logger.debug('Set Server for requestHandler. Start server.');
requestHandler.setServer(server, function() {
server.listen(port);
});
}
app.configure(function () {
app.set('port', process.env.PORT || 1337);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'hbs');
app.set('layout', 'layout');
app.use(express.favicon());
app.use(express.static(path.join(__dirname, 'config', 'logo')));
app.use(connect.json());
app.use(connect.urlencoded());
app.use(express.methodOverride());
app.use(app.router);
app.use(function (req, res, next) {
res.status(404);
res.render('errors/404', { url: req.url });
});
// error-handling middleware
app.use(function (err, req, res, next) {
// we may use properties of the error object
// here and next(err) appropriately, or if
// we possibly recovered from the error, simply next().
res.status(err.status || 500);
res.render('errors/500', { error: err });
});
});
module.exports = function (port) {
"use strict";
var scheduler = new Scheduler();
var app = connect()
.use(connect.query())
.use(connect.urlencoded())
.use(connect.json())
.use(middleware.matchApi('/v1', scheduler.api(), { verbose: false }))
.use(middleware.basicAuth())
.use(middleware.apiCall());
var server = http.createServer(app).listen(port);
var connections = [];
console.log('=> Scheduler running at: http://localhost:' + port + '/v1');
server.on('close', function () {
console.log('');
});
process.on('SIGINT', function () {
server.close();
scheduler.stop();
});
scheduler.start();
return server;
};
this.start = function(callback){
// logging status
_status = 'starting';
// check settings and middle-wares
this.get('favicon') && this.use(connect.favicon(this.get('favicon')));
this.get('logger') && this.use(connect.logger(this.get('logger')));
if (this.get('session')){
this.use(connect.cookieParser());
this.use(connect.cookieSession(this.get('session')));
}
this.use(connect.json());
this.use(connect.urlencoded());
for (var ext in engines) this.engine(ext, engines[ext]);
this.use(connect.static(_root));
// initialize database
if (this.get('dbpath')) this.db = new DB(path.resolve(process.cwd(), this.get('dbpath')));
// start listening
_server.listen(_port, function(){
_status = 'started';
if ('function' === typeof callback) callback();
});
};
db.connect(function(err, adapters) {
// Create an app instance
app = recess();
// Card Catalog Options
app.set('connection', adapters.mongo);
app.set('namespace', 'categories');
app.set('adapters', adapters);
// Middleware
app.before(cors_middleware);
app.before(hmac_middleware(adapters.mongo));
app.before(connect.json());
app.before(connect.urlencoded());
// API Card
app.card(api_v1_card);
app.on('ready', function() {
app.listen(process.env.PORT || 3000);
console.log('Listening on port ' + (process.env.PORT || 3000));
});
bootstrap(adapters.mongo, function(err) {
if(err) throw error(err);
// Create the card catalog
app.create();
});
});
module.exports = function(options) {
var app = connect(),
emitter = new events.EventEmitter();
// optional parameters
options = options || {};
options.emitter = emitter;
// proxy cross-origin requests
app.use(proxy(options));
// support POST JSON-encoded and URL-encoded queries
app.use(connect.json());
app.use(connect.urlencoded());
// no-cache header
app.use(nocache(options));
// sessions require the cookie parser
app.use(connect.cookieParser());
// register requires session support
app.use(connect.session({ secret: 'phonegap' }));
// watch file system for changes and notify client
app.use(autoreload(options));
// handle /register requests
app.use(register(options));
// handle /zip requests
app.use(zip(options));
// inject JavaScript to refresh app or navigate home
app.use(inject(options));
// serve static assets
app.use(mstatic(options));
// serve cordova js if 404'd out from previous static server
app.use(cordova(options));
// serve cordova_plugin js if 404'd out from previous static server
app.use(cordova_plugins(options));
// serve plugins if 404'd out from previous static server
app.use(plugins(options));
// create request listener and attach event emitter interface
var requestListener = function(req, res, next) {
app.handle(req, res, next);
};
for(var property in emitter) {
requestListener[property] = emitter[property];
}
return requestListener;
};
app.configure(function() {
app.use(connect.json());
app.use(express.logger('dev'));
app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
app.use("/click", express.static(path.join(__dirname, 'app-click')));
app.use("/", express.static(path.join(__dirname, 'app-command')));
});
function createStaticServer(rootname) {
var app
, server
, failed = false
, somereq
;
function useUserReq(req, res, next) {
try {
somereq(req, res, next);
} catch(e) {
if (!failed) {
console.error("required '" + rootname + "', but couldn't use it as a connect module");
console.error(e);
failed = true;
}
next();
}
}
app = connect();
try {
somereq = require(rootname);
if ('function' === typeof somereq) {
app.use(useUserReq);
} else {
app.use(somereq);
}
console.log(rootname, "is a loadable module. I'm gonna load it!");
} catch(e) {
console.log(rootname, "is not a loadable module and that's okay.");
// ignore
}
app
.use(connect.static(rootname))
.use(connect.directory(rootname))
.use(createFileReceiver(rootname))
.use('/version', function (req, res, next) {
res.end(version);
})
.use(connect.json())
.use(connect.urlencoded())
.use(connect.multipart())
.use(function (req, res) {
console.log(req.body);
res.end();
})
;
return app;
}
start : function(){
process.title = 'goofyd';
var connect = require('connect');
var app = connect();
app.use(connect.logger('dev'))
app.use(connect.query());
app.use(connect.json());
app.use(function(req, res, next){
res.json = function(result){
this.setHeader('Connection', 'keep-alive');
this.setHeader('Transfer-Encoding', 'chunked');
this.setHeader('Content-Type', 'application/json');
this.end(JSON.stringify(Utils.simplify(result)));
},
res.success = function(result){
this.json({
status: 'success',
result: result
})
}
res.error = function(result){
var error = result;
if(error instanceof Error){
var err = {
message :error.message,
code :error.code
};
for(var i in error){
if(i=='stack'){
err.stack = error.stack.split('\n');
}else
if(typeof(error[i])!='function'){
err[i] = Utils.simplify(error[i]);
}
}
error = err;
}
this.json({
status: 'error',
result: error
})
}
next()
});
for(var handler in Server.instance){
if(handler!='constructor' && typeof(Server.instance[handler])==='function'){
app.use('/'+handler,Server.instance[handler].bind(Server.instance));
}
}
app.use(connect.static(__dirname+'/../../web'));
app.listen(CONFIG.GOOFY_PORT);
}
exports.setup = function(app) {
app.get('/subscribed',
session.provider,
getUserSubscriptions);
app.post('/subscribed',
connect.json(),
session.provider,
changeUserSubscriptions);
app.get('/:channel/subscribers/:node',
session.provider,
getNodeSubscriptions);
};
topic: function () {
union.createServer({
buffer: false,
before: [
connect.urlencoded(),
connect.json(),
function (req, res) {
res.end(JSON.stringify(req.body, true, 2));
}
]
}).listen(8082, this.callback);
},
function init(app) {
// list
app.get("/drawings", allDrawings);
// details
app.get("/drawings/:id", showDrawing);
app.get("/drawings/:id/json", showDrawingJSON);
// edit
app.get("/drawings/:id/edit", editDrawing);
app.post("/drawings/:id/edit", editDrawingSave);
app.post("/drawings/:id/edit/saveImage", [connect.json()], editDrawingSaveImage);
}
function serve (dirs, port, log) {
var app = connect();
app.use(connect.json());
app.use(watcher({ paths: dirs, log: log}));
dirs.forEach(function (dir) {
app.use(connect.static(dir));
});
app.use(connect.errorHandler());
app.listen(port || PORT);
}
module.exports = function(app, options) {
options = options || {};
var personaOpts = {};
Object.keys(defaultOptions).forEach(function(key) {
if (typeof options[key] === typeof defaultOptions[key]) {
personaOpts[key] = options[key];
} else {
personaOpts[key] = defaultOptions[key];
}
});
var verify = browseridVerify({
url: personaOpts.verifierURI
});
app.post(personaOpts.verifyPath, connect.json(), connect.urlencoded(), personaOpts.middleware, function(req, res) {
// If the body can't be parsed then we can't get the assertion
if (!req.body) {
personaOpts.verifyResponse("Server-side exception", req, res);
return;
}
verify(req.body.assertion, personaOpts.audience, function(err, email, response) {
if (err) {
if (err instanceof Error) {
err = err.message;
}
return personaOpts.verifyResponse(err, req, res);
}
if (response && response.status !== "okay") {
return personaOpts.verifyResponse(response.reason, req, res, email);
}
if (req.session) {
req.session[personaOpts.sessionKey] = email;
}
personaOpts.verifyResponse(null, req, res, email);
});
});
app.post(personaOpts.logoutPath, personaOpts.middleware, function(req, res) {
if (req.session) {
req.session[personaOpts.sessionKey] = null;
}
personaOpts.logoutResponse(null, req, res);
});
};
Service.initializeHttpServer = function () {
var self = this;
this.httpServer = connect();
this.httpServer.use(connect.cookieParser('keyboard cat'));
this.httpServer.use(connect.session({ cookie: { maxAge: 60000 }}));
this.httpServer.use(connect.json());
this.httpServer.use(connect.urlencoded());
this.httpServer.use(connect.multipart());
this.httpServer.use(function (req, resp) {
var requestHandler = Core.HttpEngine.createRequestHandler();
requestHandler.handle(self, req, resp);
});
};
bender.server.create = function() {
var app = connect(),
server = http.createServer( app );
// enable connect's middleware
app.use( connect.json() );
app.use( connect.urlencoded() );
// create middleware instances
bender.middlewares.forEach( function( middleware ) {
app.use( middleware( bender ) );
} );
// serve static files, e.g. client scripts and styles
app.use( connect.static( path.resolve( __dirname, '../static/' ) ) );
// serve 404 for unhandled requests
app.use( function( req, res ) {
res.writeHead( 404 );
res.end( http.STATUS_CODES[ '404' ] );
} );
return server;
};
/* Copyright (c) 2010-2014 Richard Rodger, MIT License */
'use strict'
var Connect = require('connect')
var Seneca = require('../..')
var si = Seneca()
si.use('echo')
Connect()
.use(Connect.logger())
.use(Connect.json())
.use(si.export('web'))
.listen(3000)
// curl -H "Content-Type:application/json" -d '{"a":1}' http://localhost:3000/echo
var connect = require('connect');
var login = require('./login');
var app = connect();
app.use(connect.json()); // Parse JSON request body into `request.body`
app.use(connect.urlencoded()); // Parse form in request body into `request.body`
app.use(connect.cookieParser()); // Parse cookies in the request headers into `request.cookies`
app.use(connect.query()); // Parse query string into `request.query`
app.use('/', main);
function main(request, response, next) {
switch (request.method) {
case 'GET': get(request, response); break;
case 'POST': post(request, response); break;
case 'DELETE': del(request, response); break;
case 'PUT': put(request, response); break;
}
};
function get(request, response) {
var cookies = request.cookies;
console.log(cookies);
if ('session_id' in cookies) {
var sid = cookies['session_id'];
if ( login.isLoggedIn(sid) ) {
response.setHeader('Set-Cookie', 'session_id=' + sid);
response.end(login.hello(sid));
} else {
response.end("Invalid session_id! Please login again\n");
var app = connect();
// Use the logger if environment config allows
//
if (config.log) {
app.use(connect.logger('dev'));
}
// Append connect middleware
//
app.use(connect.query());
app.use(connect.json());
// Defines support for res.json in controller
// actions
//
// @req {Object} The http request object
// @res {Object} The http response object
// @next {Function} The function to execute once finished
//
app.use(function (req,res, next) {
res.json = function (statusCodeOrBody, body) {
var status = 200;
if (typeof statusCodeOrBody === 'number') {
status = statusCodeOrBody;
that.run = function (basePath, databases, start) {
var port = 5000;
var fileServer = new stat.Server(__dirname);
app.use(connect.json());
basePath = basePath || '';
if (basePath !== '' && basePath.indexOf('/') !== 0) {
basePath = '/' + basePath;
}
if (!databases) {
databases = [ '/tmp/redis.sock' ];
}
bind(databases);
if (start) {
start(that);
}
app.get('/durableVisual.js', function (request, response) {
request.addListener('end',function () {
fileServer.serveFile('/durableVisual.js', 200, {}, request, response);
}).resume();
});
app.get(basePath + '/:rules/:sid/admin.html', function (request, response) {
request.addListener('end',function () {
fileServer.serveFile('/admin.html', 200, {}, request, response);
}).resume();
});
app.get(basePath + '/:rules/:sid', function (request, response) {
response.contentType = 'application/json; charset=utf-8';
getState(request.params.rules,
request.params.sid,
function (err, result) {
if (err) {
response.send({ error: err }, 500);
}
else {
response.send(result);
}
});
});
app.post(basePath + "/:rules/:sid", function (request, response) {
response.contentType = "application/json; charset=utf-8";
var message = request.body;
var rules = request.params.rules;
message.sid = request.params.sid;
that.post(rules, message, function (err) {
if (err)
response.send({ error: err }, 500);
else
response.send();
});
});
app.patch(basePath + '/:rules/:sid', function (request, response) {
response.contentType = 'application/json; charset=utf-8';
var document = request.body;
var rules = request.params.rules;
document.id = request.params.sid;
patchSession(rules, document, function (err) {
if (err) {
response.send({ error: err }, 500);
} else {
response.send();
}
});
});
app.get(basePath + '/:rules', function (request, response) {
response.contentType = 'application/json; charset=utf-8';
var rules = request.params.rules;
getRuleset(rules, function (err, result) {
if (err) {
response.send({ error: err }, 500);
}
else {
response.send(result);
}
});
});
setTimeout(dispatchRules, 100, 1);
setTimeout(dispatchTimers, 100, 1);
app.listen(port, function () {
console.log('Listening on ' + port);
});
};
module.exports = function(options) {
var workspaceRoot = options.root;
var fileRoot = options.fileRoot;
var workspaceDir = options.workspaceDir;
if (!workspaceRoot) { throw 'options.root path required'; }
var workspaceId = 'orionode';
var workspaceName = 'Orionode Workspace';
return connect()
.use(connect.json())
.use(resource(workspaceRoot, {
GET: function(req, res, next, rest) {
if (rest === '') {
// http://wiki.eclipse.org/Orion/Server_API/Workspace_API#Getting_the_list_of_available_workspaces
fileUtil.withStats(workspaceDir, function(err, stats) {
if (err) {
throw err;
}
var ws = JSON.stringify({
Id: 'anonymous',
Name: 'anonymous',
UserName: '******',
Workspaces: [{
Id: workspaceId,
LastModified: stats.mtime.getTime(),
Location: api.join(workspaceRoot, workspaceId),
Name: workspaceName
}]
});
res.setHeader('Content-Type', 'application/json');
res.setHeader('Content-Length', ws.length);
res.end(ws);
});
} else if (rest === workspaceId) {
// http://wiki.eclipse.org/Orion/Server_API/Workspace_API#Getting_workspace_metadata
var parentFileLocation = fileRoot;
fileUtil.getChildren(workspaceDir, parentFileLocation, function(children) {
// TODO this is basically a File object with 1 more field. Should unify the JSON between workspace.js and file.js
var ws = JSON.stringify({
Directory: true,
Id: workspaceId,
Name: workspaceName,
Location: api.join(workspaceRoot, workspaceId),
ChildrenLocation: api.join(workspaceRoot, workspaceId), // ?? // api.join(fileRoot, workspaceId, '?depth=1'),
Children: children
// Projects: [
// // TODO projects -- does anything care about these?
// ]
});
res.setHeader('Content-Type', 'application/json');
res.setHeader('Content-Length', ws.length);
res.end(ws);
});
} else {
res.statusCode = 400;
res.end(util.format('workspace not found: %s', rest));
}
},
POST: function(req, res, next, rest) {
var err;
if (rest === '') {
// Create workspace. unsupported
err = {Message: 'Unsupported operation: create workspace'};
res.statusCode = 403;
res.end(JSON.stringify(err));
} else if (rest === workspaceId) {
// Create project
var projectName = req.headers.slug || (req.body && req.body.Name);
if (!projectName) {
err = {Message: 'Missing "Slug" header or "Name" parameter'};
res.statusCode = 400;
res.setHeader('Content-Type', 'application/json');
res.end(JSON.stringify(err));
} else {
fs.mkdir(fileUtil.safeFilePath(workspaceDir, projectName), parseInt('0755', 8), function(error) {
if (error) {
err = {Message: error};
res.statusCode = 400;
res.end(JSON.stringify(error));
} else {
var newProject = JSON.stringify({
ContentLocation: api.join(fileRoot, projectName), // Important
Id: projectName,
Location: api.join(workspaceRoot, 'project', projectName) // not important
});
res.statusCode = 201;
res.setHeader('Content-Type', 'application/json');
res.setHeader('Content-Length', newProject.length);
res.end(newProject);
}
});
}
}
},
PUT: function(req, res, next, rest) {
// Would 501 be more appropriate?
writeError(403, res);
},
DELETE: function(req, res, next, rest) {
// Would 501 be more appropriate?
writeError(403, res);
}
}));
};
module.exports = function(options) {
var fileRoot = options.root;
var workspaceDir = options.workspaceDir;
if (!fileRoot) { throw 'options.root is required'; }
if (!workspaceDir) { throw 'options.workspaceDir is required'; }
var writeFileMetadata = function(req /*, args.. */) {
var args = Array.prototype.slice.call(arguments, 1);
var originalFileUrl = fileUtil.getContextPath(req) + fileRoot;
return fileUtil.writeFileMetadata.apply(null, [originalFileUrl].concat(args));
};
var getSafeFilePath = fileUtil.safeFilePath.bind(null, workspaceDir);
function writeFileContents(res, rest, filepath, stats, etag) {
if (stats.isDirectory()) {
//shouldn't happen
writeError(500, res, "Expected a file not a directory");
} else {
var stream = fs.createReadStream(filepath);
res.setHeader('Content-Length', stats.size);
res.setHeader('ETag', etag);
res.setHeader('Accept-Patch', 'application/json-patch; charset=UTF-8');
stream.pipe(res);
stream.on('error', function(e) {
res.writeHead(500, e.toString());
res.end();
});
stream.on('end', function() {
res.statusCode = 200;
res.end();
});
}
}
function handleDiff(req, res, rest, body) {
try {
body = typeof body === "string" ? JSON.parse(body) : body;
} catch (e) {
writeError(500, res, e.toString());
}
var diffs = body.diff || [];
var contents = body.contents;
var patchPath = getSafeFilePath(rest);
fs.exists(patchPath, function(destExists) {
if (destExists) {
fs.readFile(patchPath,function (error, data) {
if (error) {
writeError(500, res, error);
return;
}
var newContents = data.toString();
var buffer = {
_text: [newContents],
replaceText: function (text, start, end) {
var offset = 0, chunk = 0, length;
while (chunk<this._text.length) {
length = this._text[chunk].length;
if (start <= offset + length) { break; }
offset += length;
chunk++;
}
var firstOffset = offset;
var firstChunk = chunk;
while (chunk<this._text.length) {
length = this._text[chunk].length;
if (end <= offset + length) { break; }
offset += length;
chunk++;
}
var lastOffset = offset;
var lastChunk = chunk;
var firstText = this._text[firstChunk];
var lastText = this._text[lastChunk];
var beforeText = firstText.substring(0, start - firstOffset);
var afterText = lastText.substring(end - lastOffset);
var params = [firstChunk, lastChunk - firstChunk + 1];
if (beforeText) { params.push(beforeText); }
if (text) { params.push(text); }
if (afterText) { params.push(afterText); }
Array.prototype.splice.apply(this._text, params);
if (this._text.length === 0) { this._text = [""]; }
},
getText: function() {
return this._text.join("");
}
};
for (var i=0; i<diffs.length; i++) {
var change = diffs[i];
buffer.replaceText(change.text, change.start, change.end);
}
newContents = buffer.getText();
var failed = false;
if (contents) {
if (newContents !== contents) {
failed = true;
newContents = contents;
}
}
fs.writeFile(patchPath, newContents, function(err) {
if (err) {
writeError(500, res, error);
return;
}
if (failed) {
write(406, res, 'Bad file diffs. Please paste this content in a bug report: \u00A0\u00A0 \t' + JSON.stringify(body));
return;
}
fs.stat(patchPath, function(error, stats) {
if (err) {
writeError(500, res, error);
return;
}
var etag = new ETag(newContents);
writeFileMetadata(req, res, rest, patchPath, stats, etag.getValue() /*the new ETag*/);
});
});
});
} else {
writeError(500, res, 'Destination does not exist.');
}
});
}
function writeDiffContents(req, res, next, rest) {
var requestBody = new Buffer(0);
req.on('error', function(e) {
writeError(500, res, e.toString());
});
// Tolerate both json and text/plain here for compatibility with Java server and client code
if (req.headers['content-type'] === "application/json" && req.body) {
handleDiff(req, res, rest, req.body);
return;
}
// Buffer it
req.on('data', function(data) {
requestBody = Buffer.concat([requestBody,data]);
});
req.on('end', function(event) {
handleDiff(req, res, rest, requestBody.toString());
});
}
/*
* Handler begins here
*/
return connect()
.use(connect.json())
.use(resource(fileRoot, {
GET: function(req, res, next, rest) {
if (writeEmptyFilePathError(res, rest)) {
return;
}
var filepath = getSafeFilePath(rest);
fileUtil.withStatsAndETag(filepath, function(error, stats, etag) {
if (error && error.code === 'ENOENT') {
writeError(404, res, 'File not found: ' + rest);
} else if (error) {
writeError(500, res, error);
} else if (stats.isFile() && getParam(req, 'parts') !== 'meta') {
// GET file contents
writeFileContents(res, rest, filepath, stats, etag);
} else {
// TODO handle depth > 1 for directories
var includeChildren = (stats.isDirectory() && getParam(req, 'depth') === '1');
writeFileMetadata(req, res, rest, filepath, stats, etag, includeChildren);
}
});
},
PUT: function(req, res, next, rest) {
if (writeEmptyFilePathError(res, rest)) {
return;
}
var filepath = getSafeFilePath(rest);
if (getParam(req, 'parts') === 'meta') {
// TODO implement put of file attributes
res.statusCode = 501;
return;
} else {
// The ETag for filepath's current contents is computed asynchronously -- so buffer the request body
// to memory, then write it into the real file once ETag is available.
var requestBody = new Buffer(0);
var requestBodyETag = new ETag(req);
req.on('data', function(data) {
requestBody = Buffer.concat([requestBody, data]);
});
req.on('error', function(e) {
console.warn(e);
});
req.on('end', function(e) {
var ifMatchHeader = req.headers['if-match'];
if(!ifMatchHeader){//If etag is not defined, we are writing blob. In this case the file does not exist yet so we need create it.
fs.writeFile(filepath, requestBody, function(error) {
if (error) {
writeError(500, res, error);
return;
}
fs.stat(filepath, function(error, stats) {
writeFileMetadata(req, res, rest, filepath, stats, requestBodyETag.getValue() /*the new ETag*/);
});
});
} else {
fileUtil.withStatsAndETag(filepath, function(error, stats, etag) {
if (error && error.code === 'ENOENT') {
res.statusCode = 404;
res.end();
} else if (ifMatchHeader && ifMatchHeader !== etag) {
res.statusCode = 412;
res.end();
} else {
// write buffer into file
fs.writeFile(filepath, requestBody, function(error) {
if (error) {
writeError(500, res, error);
return;
}
writeFileMetadata(req, res, rest, filepath, stats, requestBodyETag.getValue() /*the new ETag*/);
});
}
});
}
});
}
},
POST: function(req, res, next, rest) {
if (writeEmptyFilePathError(res, rest)) {
return;
}
var diffPatch = req.headers['x-http-method-override'];
if (diffPatch === "PATCH") {
writeDiffContents(req, res, next, rest);
return;
}
var name = req.headers.slug || (req.body && req.body.Name);
if (!name) {
write(400, res, 'Missing Slug header or Name property');
return;
}
var wwwpath = api.join(rest, encodeURIComponent(name)),
filepath = getSafeFilePath(path.join(rest, name));
fileUtil.handleFilePOST(workspaceDir, fileRoot, req, res, wwwpath, filepath);
},
DELETE: function(req, res, next, rest) {
if (writeEmptyFilePathError(res, rest)) {
return;
}
var filepath = getSafeFilePath(rest);
fileUtil.withStatsAndETag(filepath, function(error, stats, etag) {
var ifMatchHeader = req.headers['if-match'];
if (error && error.code === 'ENOENT') {
res.statusCode = 204;
res.end();
} else if (ifMatchHeader && ifMatchHeader !== etag) {
write(412, res);
} else {
var callback = function(error) {
if (error) {
writeError(500, res, error);
return;
}
res.statusCode = 204;
res.end();
};
if (stats.isDirectory()) {
fileUtil.rumRuff(filepath, callback);
} else {
fs.unlink(filepath, callback);
}
}
});
}
}));
};
app.configure(function() {
app.use(connect.json())
});
"use strict";
var express = require('express');
var path = require('path');
var connect = require('connect');
var init = express();
init.use(connect.json());
init.use(connect.urlencoded());
//init.use(cors({ origin: "*" }));
//CORS middleware
var allowCrossDomain = function (req, res, next) {
res.header('Access-Control-Allow-Origin', 'null');
res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE');
res.header('Access-Control-Allow-Headers', 'Content-Type');
res.header('Access-Control-Allow-Credentials', true);
next();
}
init.use(allowCrossDomain);
//init.use(express.cookieParser());
// Set routing handler to serve all static files
// Set the directory public to serve static files
init.use(express.static(path.join(__dirname, 'client')));
(function () {
'use strict';
var connect = require('connect')
, path = require('path')
, passport = require('passport')
, User = require('./user')
, ExampleStrategy = require('./passport-example').Strategy
, app = connect()
, server
, port = process.argv[2] || 3002
, oauthConfig = require('./oauth-config')
, pConf = oauthConfig.provider
, lConf = oauthConfig.consumer
// for Ward Steward
, opts = require('./oauth-consumer-config')
;
if (!connect.router) {
connect.router = require('connect_router');
}
// Passport session setup.
// To support persistent login sessions, Passport needs to be able to
// serialize users into and deserialize users out of the session. Typically,
// this will be as simple as storing the user ID when serializing, and finding
// the user by ID when deserializing. However, since this example does not
// have a database of user records, the complete Facebook profile is serialized
// and deserialized.
passport.serializeUser(function(user, done) {
//Users.create(user);
done(null, user);
});
passport.deserializeUser(function(obj, done) {
var user = obj // Users.read(obj)
;
done(null, user);
});
passport.use(new ExampleStrategy({
// see https://github.com/jaredhanson/oauth2orize/blob/master/examples/all-grants/db/clients.js
clientID: opts.clientId
, clientSecret: opts.clientSecret
, callbackURL: lConf.protocol + "://" + lConf.host + "/auth/example-oauth2orize/callback"
}
, function (accessToken, refreshToken, profile, done) {
User.findOrCreate({ profile: profile }, function (err, user) {
user.accessToken = accessToken;
return done(err, user);
});
}
));
function route(rest) {
rest.get('/externalapi/account', function (req, res, next) {
console.log('[using accessToken]', req.user.accessToken);
if (false) { next(); }
var request = require('request')
, options = {
url: pConf.protocol + '://' + pConf.host + '/api/exampleauth/me'
, headers: {
'Authorization': 'Bearer ' + req.user.accessToken
}
}
;
function callback(error, response, body) {
if (!error && response.statusCode === 200) {
res.end(body);
} else {
res.end('error: \n' + body);
}
}
request(options, callback);
});
/*
*/
rest.get('/auth/example-oauth2orize', passport.authenticate('exampleauth', { scope: ['email'] }));
rest.get('/auth/example-oauth2orize/callback'
//passport.authenticate('facebook', { successRedirect: '/close.html?accessToken=blar',
// failureRedirect: '/close.html?error=foo' }));
, passport.authenticate('exampleauth', { failureRedirect: '/close.html?error=foo' })
);
rest.get('/auth/example-oauth2orize/callback'
, function (req, res) {
console.log('req.session');
console.log(req.session);
var url = '/success.html' // + '?type=fb'
/*
+ '&accessToken=' + req.session.passport.user.accessToken
+ '&email=' + req.session.passport.user.profile.email
+ '&link=' + req.session.passport.user.profile.profileUrl
*/
;
console.log(url);
res.statusCode = 302;
res.setHeader('Location', url);
res.end('hello');
// This will pass through to the static module
//req.url = url;
//next();
}
);
rest.post('/auth/example-oauth2orize/callback', function (req, res/*, next*/) {
console.log('req.user', req.user);
res.end('thanks for playing');
});
}
app
.use(connect.query())
.use(connect.json())
.use(connect.urlencoded())
.use(connect.compress())
.use(connect.cookieParser())
.use(connect.session({ secret: 'keyboard mouse' }))
.use(passport.initialize())
.use(passport.session())
.use(connect.router(route))
.use(connect.static(path.join(__dirname, 'public')))
;
module.exports = app;
if (require.main === module) {
server = app.listen(port, function () {
console.log('Listening on', server.address());
});
}
}());
var app = connect();
app.use('/public', connect.static(PUBLIC_DIR));
app.use(function (req, res, next) {
res.req = req;
next();
});
//parse http get params
app.use(connect.query());
//parse http post body
app.use(connect.urlencoded());
app.use(connect.json({
strict: true
}));
//parse cookie
app.use(connect.cookieParser());
//session
app.use(connect.session({
key: config.sessionCookie,
secret: config.sessionSecret,
cookie: {
path: '/',
httpOnly: true
},
}));
module.exports = function(options) {
var app = connect(),
emitter = new events.EventEmitter();
// optional parameters
options = options || {};
options.emitter = emitter;
// global array to contain files to update for delta updates
options.filesToUpdate = [];
// proxy cross-origin requests
app.use(proxy(options));
// support POST JSON-encoded and URL-encoded queries
app.use(connect.json());
app.use(connect.urlencoded());
// no-cache header
app.use(nocache(options));
// sessions require the cookie parser
app.use(connect.cookieParser());
// register requires session support
app.use(connect.session({ secret: 'phonegap' }));
// watch file system for changes and notify client
app.use(autoreload(options));
// handle delta updates for content sync
app.use(update(options));
// handle /register requests
app.use(register(options));
// handle /zip requests
app.use(zip(options));
// inject JavaScript to refresh app or navigate home
app.use(inject(options));
// support desktop browser
if (options.browser)
app.use(browser(options));
// serve static assets
app.use(mstatic(options));
// serve cordova js if 404'd out from previous static server
app.use(cordova(options));
// serve cordova_plugin js if 404'd out from previous static server
app.use(cordova_plugins(options));
// serve plugins if 404'd out from previous static server
app.use(plugins(options));
// allow client to specify custom middleware
if (options.customMiddleware) {
if (typeof options.customMiddleware === "function") {
app.use(options.customMiddleware(options));
} else if (Array.isArray(options.customMiddleware)) {
options.customMiddleware.forEach(function(custom) {
if (typeof custom === "function") {
app.use(custom(options));
}
});
}
}
// create request listener and attach event emitter interface
var requestListener = function(req, res, next) {
app.handle(req, res, next);
};
for(var property in emitter) {
requestListener[property] = emitter[property];
}
return requestListener;
};
var app = process.app = module.exports = express();
app.log = require('./lib/log');
app.config = require('./lib/config');
app.datastore = require('./lib/storage');
app.redisSession = redisSession;
app.log('info', 'configuring server');
app.SERVER_VERSION = version;
app.use(connect.urlencoded());
app.use(connect.json({
limit: '20mb'
}));
app.use(cors({
credentials: true,
origin: function (origin, callback) {
callback(null, true);
}
}));
if (app.config.securityHeaders) {
try {
var luscaObj = app.config.securityHeaders;
// A naive validation check:
if ((typeof luscaObj.csp == 'object') && (typeof luscaObj.xframe == "string")
&& (typeof luscaObj.csrf == 'boolean')) {