app.use(session({
secret: config.login.sessionSecret,
resave: false,
saveUninitialized: false,
store: new NedbStore({filename: path.resolve(__dirname, '../../db/sessions.db')}),
cookie: {
path: '/',
httpOnly: true,
secure: config.ssl && config.ssl.enabled
}
}));
app.use(passport.initialize());
app.use(passport.session());
app.use('/login', express.static(path.join(__dirname, 'public')));
app.set('views', __dirname);
app.get('/login', (req, res) => {
res.render('public/login.jade', {
user: req.user,
config
});
});
app.get('/authError', (req, res) => {
res.render('public/authError.jade', {
message: req.query.message,
code: req.query.code,
viewUrl: req.query.viewUrl
});
var fs = require('fs');
var path = require('path');
var express = require('express');
var bodyParser = require('body-parser');
var app = express();
app.set('port', (process.env.PORT || 4000));
app.use('/', express.static(__dirname));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: true}));
app.get('/comments.json', function(req, res) {
fs.readFile('comments.json', function(err, data) {
res.setHeader('Cache-Control', 'no-cache');
res.json(JSON.parse(data));
});
});
app.post('/comments.json', function(req, res) {
fs.readFile('comments.json', function(err, data) {
var comments = JSON.parse(data);
comments.push(req.body);
fs.writeFile('comments.json', JSON.stringify(comments, null, 4), function(err) {
res.setHeader('Cache-Control', 'no-cache');
res.json(comments);
});
});
});
var user = require('./routes/user');
var http = require('http');
var path = require('path');
var app = express();
// 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.bodyParser());
app.use(express.methodOverride());
app.use(app.router);
app.use(express.static(path.join(__dirname, 'public')));
// development only
if ('development' == app.get('env')) {
app.use(express.errorHandler());
}
app.get('/', routes.index);
app.get('/users', user.list);
app.post('/contato', routes.adicionaContato);
app.get('/contatos', routes.listaContatos);
http.createServer(app).listen(app.get('port'), function(){
console.log('Express server listening on port ' + app.get('port'));
});
// required libraries
var express = require('express');
var path = require('path');
var moduleOne = require('./public/modules/moduleOne');
var moduleTwo = require('./public/modules/moduleTwo');
var moduleThree = require('./public/modules/moduleThree');
console.log(moduleOne);
console.log(moduleTwo);
console.log(moduleThree);
// varables for the server
var app = express();
var port = 3000;
app.use(express.static('public'));
app.get('/', function(request,respond){
response.sendFile(path.join(__dirname, 'public/views/index.html'));
});
app.get('/balance', function(request, response){
response.body = moduleThree;
});
app.listen(port, function listening (){
console.log("BankBot Engaged!",port);
});
/**
* Module dependencies.
*/
var express = require('express'),
ejs = require('ejs');
var route = require('./routes/index');
var app = module.exports = express();
var port = 3000;
app.set('views', __dirname + '/views');
app.set('view engine', 'html');
app.engine('.html', ejs.__express);
app.use('/styles', express.static(__dirname + '/public/styles'));
app.use('/images', express.static(__dirname + '/public/images'));
app.use('/js', express.static(__dirname + '/public/js'));
// 模板路由
app.get('/', route.index);
app.get('/index', route.index);
app.get('/about', route.about);
app.get('/blog', route.blog);
app.get('/contact', route.contact);
app.get('/element', route.element);
var express = require('express'),
path = require('path'),
logger = require('morgan'),
config = require('./config'),
routes = require('./routes'),
_ = require('lodash'),
csurf = require('csurf'),
Loader = require('loader'),
session = require('express-session'),
app = express(),
staticDir = path.join(__dirname, 'public');
// 静态目录
app.use('/public', express.static(staticDir));
// 模版配置
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
app.engine('ejs', require('ejs-mate'));
app.locals._layoutFile = 'layout.ejs';
app.use(Loader.less(__dirname));
// cookie session配置
app.use(require('cookie-parser')(config.session_secret));
app.use(session({
secret: config.session_secret,
key: 'sid',
resave: true,
saveUninitialized: true
}));
if (!config.debug) {
app.use(csurf());
var express = require('express');
var fs = require('fs');
var app = express.createServer(express.logger());
var buffer = new Buffer(fs.readFileSync("index.html"));
app.use(express.static(__dirname));
app.get('/', function(request, response) {
response.send(buffer.toString("utf-8"));
});
var port = process.env.PORT || 8080;
app.listen(port, function() {
console.log("Listening on " + port);
});
module.exports = function (app, passport) {
// Compression middleware (should be placed before express.static)
app.use(compression({
threshold: 512
}));
// Static files middleware
app.use(express.static(config.root + '/public'));
// Use winston on production
let log = 'dev';
if (env !== 'development') {
log = {
stream: {
write: message => winston.info(message)
}
};
}
// Don't log during tests
// Logging middleware
if (env !== 'test') app.use(morgan(log));
// Swig template engine settings
if (env === 'development' || env === 'test') {
swig.setDefaults({
cache: false
});
}
// set views path, template engine and default layout
app.engine('html', swig.renderFile);
app.set('views', config.root + '/views');
app.set('view engine', 'html');
// expose package.json and environment to views (why ?!)
app.use(function (req, res, next) {
res.locals.pkg = pkg;
res.locals.env = env;
next();
});
// bodyParser should be above methodOverride
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(multer().array('image', 1));
app.use(methodOverride(function (req) {
if (req.body && typeof req.body === 'object' && '_method' in req.body) {
// look in urlencoded POST bodies and delete it
var method = req.body._method;
delete req.body._method;
return method;
}
}));
// CookieParser should be above session
app.use(cookieParser());
app.use(cookieSession({ secret: 'secret' }));
app.use(session({
resave: true,
saveUninitialized: true,
secret: pkg.name,
store: new mongoStore({
url: config.db,
collection : 'sessions'
})
}));
// use passport session
app.use(passport.initialize());
app.use(passport.session());
// connect flash for flash messages - should be declared after sessions
app.use(flash());
// should be declared after session and flash
app.use(helpers(pkg.name));
if (env !== 'test') {
app.use(csrf());
// This could be moved to view-helpers :-)
app.use(function (req, res, next) {
res.locals.csrf_token = req.csrfToken();
next();
});
}
};
router.use(favicon(__dirname + '/favicon.ico'));
router.use(bodyParser.urlencoded({ extended: true }));
router.use(bodyParser.json());
router.use(logger('dev'));
app.use('/self_service/', router);
console.log('About to crank up node');
console.log('PORT=' + port);
console.log('NODE_ENV=' + environment);
switch (environment) {
case 'build':
console.log('** BUILD **');
app.use(express.static('./build/'));
// Any invalid calls for templateUrls are under app/* and should return 404
app.use('/app/*', function(req, res) {
four0four.send404(req, res);
});
// Any deep link calls should return index.html
app.use('/*', express.static('./public/index.html'));
break;
default:
console.log('** DEV **');
router.use(express.static('./client/'));
app.use(express.static('./client/assets'));
app.use(express.static('./'));
app.use(express.static('./tmp'));
// Any invalid calls for templateUrls are under app/* and should return 404
router.use('/app/*', function(req, res) {
var express = require('express'),
morgan = require('morgan'),
path = require('path'),
mongoose = require('mongoose'),
app = express(),
apiAsteroidRouter = require('./server/routes/api/asteroids.js');
mongoose.connect( process.env.MONGODB_URI || "mongodb://localhost/spacerocks" );
app.set('views', path.join(__dirname, 'client/views'));
app.use(morgan('dev'));
// Set static file root folders
app.use(express.static('client'));
app.use(express.static('bower_components'));
app.get('/', function(req, res){
res.sendFile(__dirname + '/client/views/index.html');
});
app.use('/api/asteroids', apiAsteroidRouter);
app.get("/data/:file", function(req, res){
console.log("Sending " + req.params.file );
res.sendFile( path.resolve( __dirname + "/data/" + req.params.file ) );
});
/**
* @param {{dir: string,
host: string,
port: number}} _config
**/
export default function server(_config) {
const cwd = process.cwd();
const root = getNodeProjectRoot(cwd);
const config = _.merge(getRc(root), _config);
// consts
const exdir = config.dir || '';
const host = config.host || 'http://localhost';
const port = config.port || 3001;
const isGroup = config.group || null;
/* eslint-disable global-require */
const pkg = require(path.join(root, 'package.json'));
const app = express();
var tpldir = path.join(root, exdir);
var itemList = getItems(isGroup);
var entries = {};
if (isGroup) {
const files = glob.sync(root + '/homepage/**')
.filter(f => /\.(js|jsx)$/.test(f))
.forEach(f => {
if (filename(f)[0] !== '_') {
var name = path.relative(root, f).replace(/(.js|.jsx)$/, '');
entries[name] = f;
}
});
}
devserver.getMiddlewares({
rtconfig: config,
tpldir: tpldir,
port,
root,
pkg,
entries,
items: itemList,
}).forEach(x => app.use(x));
function filename(p) {
return p.replace(/\.[^/.]+$/, '').replace(/^.*\//, '');
}
function getExamples() {
const files = glob.sync(tpldir + '/**')
.filter(f => /\.(js|jsx)$/.test(f));
return files;
}
function getComponents(itemList) {
var components = itemList.map(x => ({
name: x.name,
examples: x.examples
}));
return components;
}
function getItems(isGroup) {
let items = [];
if (isGroup) {
const paths = glob.sync(tpldir + '/*/package.json');
for (let p of paths) {
let pkg = require(p),
examples = [],
files = [];
if (pkg['mt-group']) {
const item_path = p.substr(0, p.indexOf('package.json'));
glob
.sync(item_path + '/examples/**')
.filter(f => /\.(js|jsx)$/.test(f))
.forEach(f => {
examples.push(filename(f));
files.push(f);
});
items.push({
name: pkg['name'],
path: p.substr(0, p.indexOf('package.json') - 1),
examples: examples,
files: files
});
}
}
} else {
const paths = glob.sync(tpldir + '/**').filter(f => /\.(js|jsx)$/.test(f));
let examples = [],
files = [];
paths.forEach(f => {examples.push(filename(f)), files.push(f)});
items.push({
name: pkg['name'],
path: root,
examples: examples,
files: files,
});
}
return items;
}
/* eslint-disable new-cap */
const router = express.Router();
app.use(express.static(path.join(__dirname, '../../vendor')));
router.get('/', (req, res) => {
if (isGroup) {
var components = getComponents(itemList);
res.send(htmlFunc.group({
components: components,
title: pkg['name']
}));
} else {
const files = getExamples();
const fns = files.map(filename);
res.send(list({
examples: fns,
title: 'examples',
}));
}
});
router.get('/examples/', (req, res) => {
const itemName = req.query.component;
const exampleName = req.query.name;
if (!exampleName) {
res.send(`<h1 style="color:#cc1122"> example's name can not null!</h1>`);
return;
}
let fp, contentHTML, tfp, jsPath, pkgInfo = pkg;
if (isGroup) {
const item = itemList.find(x => x.name === itemName)
if (!itemName || !item) {
res.send(`<h1 style="color:#cc1122"> component not found!</h1>`);
return;
}
tfp = path.join(item.path, 'examples', exampleName);
pkgInfo = require(item.path + '/package.json');
} else {
tfp = path.join(tpldir, exampleName);
}
if (fs.existsSync(tfp + '.js')) fp = `${tfp}.js`;
if (fs.existsSync(tfp + '.jsx')) fp = `${tfp}.jsx`;
if (!fp) {
res.send(`<h1 style="color:#cc1122"> ${exampleName} not found!</h1>`);
return;
}
jsPath = devserver.getURL(fp);
/* eslint-disable no-unused-vars, no-return-assign */
safe(__ => contentHTML = fs.readFileSync(`${tfp}.html`, 'utf-8'));
const content = fs.readFileSync(fp, 'utf-8');
res.send(example({
pkg: pkgInfo,
contentHTML,
pagename: exampleName,
styles: [
'/hljs.css',
],
scripts: [
{ src: '/browser-polyfill.js' },
{ src: jsPath },
],
title: pkgInfo.name + '-' + exampleName,
// @TODO delete
pkgjson: JSON.stringify({
name: `${pkgInfo.name}-${exampleName}-test`,
dependencies: {
[pkgInfo.name]: pkgInfo.version,
},
}, null, 2),
sourcecode: hljs.highlight('javascript', content).value,
}));
return;
});
router.get('/components/', (req, res) => {
const itemName = req.query.name;
const item = itemList.find(x => x.name === itemName)
if (!item) {
res.send(`<h1 style="color:#cc1122"> ${itemName} not found!</h1>`);
return;
}
res.send(list({
examples: item.examples,
title: 'examples',
component: itemName,
}));
return;
});
router.get(['/homepage/:name', '/homepage'], (req, res) => {
let fp, contentHTML, tfp, cfp, scripts = [], pkgInfo = pkg;
let name = req.params.name == null? 'index' : req.params.name;
name = name.replace(/\.html$/, '');
tfp = path.join(root, 'homepage', name);
pkgInfo = require( path.join(root, '/package.json'));
scripts.push({ src: '/browser-polyfill.js' });
if (fs.existsSync(tfp + '.js')) fp = `${tfp}.js`;
if (fs.existsSync(tfp + '.jsx')) fp = `${tfp}.jsx`;
if (fp != null) {
const jsPath = devserver.getURL(fp).replace('\/..\/', '\/');
scripts.push({ src: jsPath});
}
if (fs.existsSync(`${tfp}.html`)) {
/* eslint-disable no-unused-vars, no-return-assign */
safe(__ => contentHTML = fs.readFileSync(`${tfp}.html`, 'utf-8'));
} else {
/* eslint-disable no-unused-vars, no-return-assign */
safe(__ => contentHTML = `<div id="container-wrap"></div>`, 'utf-8');
}
const indexcss = fs.existsSync(`${tfp}.css`) ? fs.readFileSync(`${tfp}.css`, 'utf-8') : '';
res.send(htmlFunc.page({
pkg: pkgInfo,
contentHTML,
pagename: '',
styles: [
'/hljs.css',
indexcss
],
scripts: scripts,
title: pkgInfo.name
}));
return;
});
app.use(router);
app.listen(port, () => {
setTimeout(() => {
/* eslint-disable no-console */
console.log(
`
-----------------------------------------------------------------------------------
app server listening on ${port}, visit ${host}:${port} to check awesome!
-----------------------------------------------------------------------------------
`
);
}, 1000);
});
}
const Express = require('express');
const PORT = 3002;
var app = new Express();
app
.use(Express.static(`${__dirname}/../.tmp`))
.get('/', (req, res) => {
res.render('../app/index.ejs',{});
}).listen(PORT, (err) => {
if (err) {
throw err;
}
console.log(`Listen on ${PORT}`);
});
var express = require('express');
var ejs = require('ejs');
var bodyParser = require('body-parser');
var _ = require('underscore');
var db = require('./db.js');
var bcrypt = require('bcrypt');
var middleware = require('./middleware.js')(db);
var app = express();
var port = process.env.PORT || 3000;
app.use(bodyParser.json());
app.set('view engine', 'ejs');
app.set('views', __dirname + '/client');
app.use('/assets', express.static(__dirname + '/client'));
app.get('/', function (req, res) {
res.render('index.ejs');
});
var minderRoutes = require('./routes/minder.js');
var userRoutes = require('./routes/user.js');
minderRoutes(app);
userRoutes(app);
db.sequelize.sync({force: true}).then(function () {
app.listen(port, function () {
console.log(colors.info('Express is listening on ' + port));
});
var express = require('express');
var path = require('path');
var RED = require("node-red");
var http = require('https');
var fs = require('fs');
// Create a server
var app = express();
// Add a simple route for static content served from 'public'
app.use("/",express.static("public"));
// Create the settings object - see default settings.js file for other options
var settings = {
verbose: true,
httpAdminRoot:"/red",
httpNodeRoot: "/api",
httpStatic: path.join(__dirname, 'public'),
userDir: path.join(__dirname, 'node-config'),
nodesDir: path.join(__dirname, 'node-config'),
functionGlobalContext: { } // enables global context
};
var options = {
cert: fs.readFileSync('ssl-cert-snakeoil.pem'),
key: fs.readFileSync('ssl-cert-snakeoil.key')
};
var server = http.createServer(options,app);
RED.init(server,settings);
const port = 1337;
var chatUsersHandling = require('./chatUsersHandling');
var express = require('express');
var app = express();
var http = require('http').Server(app);
var io = require('socket.io')(http);
var userlist = new Array();
app.use(express.static(__dirname + '/../public'));
app.get('/statistics', function (req, res) {
res.send(printStatistics());
});
function printStatistics() {
var statistics = "Here you can see our statistics"
+ "<br />" +
"Number of active users: " + userlist.length;
for (i = 0; i < userlist.length; i++) {
statistics += "<br />" + userlist[i];
}
return statistics;
}
chatUsersHandling.emitConnectionMessages(io, userlist);
var server = http.listen(port, function () {
console.log('Listening on port %d', server.address().port);
});
var express = require('express');
var compression = require('compression')
var path = require("path");
var app = express();
app.use(compression())
app.use('/public', express.static('public'));
app.set('port', (process.env.PORT || 5000));
app.get('/', function(request, response) {
response.sendFile(path.join(__dirname+'/index.html'));
});
app.listen(app.get('port'), function() {
console.log("Node app is running at localhost:" + app.get('port'))
})
Gateway.prototype.startWeb = function()
{
var self = this;
app.set('views', __dirname + '/views');
app.set('view engine', 'jade');
//是Connect內建的middleware，设置此处可以将client提交过来的post请求放入request.body中
app.use(express.bodyParser());
//是Connect內建的，可以协助处理POST请求伪装PUT、DELETE和其他HTTP methods
app.use(express.methodOverride());
//cookie
app.use(express.cookieParser());
//route requests
app.use(app.router);
//public文件夹下面的文件，都暴露出来，客户端访问的时候，不需要使用public路径
app.use(express.static(__dirname + '/public'));
app.use(express.static('/data/app/node_kissy/public'));
app.configure('development', function(){
app.use(express.errorHandler({dumpExceptions: true, showStack: true}));
});
app.configure('production', function(){
app.use(express.errorHandler());
});
app.get('/', function(req, res){
res.render('index', {
title: 'Express',
youAreUsingJade:true
});
});
app.post("/mcp-filter/main/interface.htm", function(req, res){
var message = req.body.message;
self.handle(message, function(backMsgNode){
res.json(backMsgNode);
log.info(backMsgNode);
});
});
app.post("/main/notify.htm", function(req, res){
var message = req.body.message;
log.info(message);
res.json({});
});
app.get("/mcp-filter/main/interface.htm", function(req, res){
var message = req.query.message;
self.handle(message, function(backMsgNode){
res.json(backMsgNode);
log.info(backMsgNode);
});
});
app.get('/download/:name', function(req, res){
var path = req.params.name.match(/^([a-zA-Z0-9_]+)(\.html)$/);
log.info(path);
if(path){
var downLoadPath = path[1].split("_");
var headNode = {cmd:downLoadPath};
headNode.userId = req.cookies.userId;
headNode.userType = req.cookies.userType;
headNode.key = req.cookies.st;
pageCtl.handle(headNode, req.query, function(err, filePath){
if(err)
{
res.render("sys/error", err);
}
else
{
var name = "明细导出.xlsx";
res.setHeader('Content-Type', 'application/vnd.openxmlformats');
res.setHeader("Content-Disposition", "attachment; filename=" + encodeURIComponent(name));
excelUtil.download(filePath, req, res, true);
}
});
}
});
app.get('/:name', function(req, res, next){
var path = req.params.name.match(/^([a-zA-Z0-9_]+)(\.html)$/);
if(path)
{
var jadePathArray = path[1].split("_");
var jadePath = jadePathArray.join("/");
var headNode = {cmd:jadePathArray};
headNode.userId = req.cookies.userId;
headNode.userType = req.cookies.userType;
headNode.key = req.cookies.st;
pageCtl.handle(headNode, req.query, function(err, data){
if(err)
{
res.render("sys/error", err);
}
else
{
res.render(jadePath, data);
}
});
}
else
{
next();
}
});
httpServer.listen(9988);
};
app.configure(function(){
app.use('/', express.static(__dirname + '/'));
app.use('/bggapi', BGGProxy);
});
module.exports = function (app, speechToText, textToSpeech) {
// Configure Express
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
// Setup static public directory
app.use(express.static(__dirname + '/../public'));
app.use(express.static(__dirname + '/../bower_components'));
// Add error handling in dev
if (!process.env.VCAP_SERVICES) app.use(errorhandler());
// Route For text 2 speech
app.get('/synthesizeMale', function(req, res) {
var synthReq = {
accept: "audio/ogg; codecs=opus",
voice: "VoiceEnUsMichael",
text: req.query.text
};
var transcript = textToSpeech.synthesize(synthReq);
transcript.on('response', function(response) {
console.log(response.headers);
if (req.query.download) {
response.headers['content-disposition'] = 'attachment; filename=transcript.ogg';
}
});
transcript.pipe(res);
});
// Route For text 2 speech
app.get('/synthesizeMale', function(req, res) {
var synthReq = {
accept: "audio/ogg; codecs=opus",
voice: "VoiceEnUsMichael",
text: req.query.text
};
var transcript = textToSpeech.synthesize(synthReq);
transcript.on('response', function(response) {
console.log(response.headers);
if (req.query.download) {
response.headers['content-disposition'] = 'attachment; filename=transcript.ogg';
}
});
transcript.pipe(res);
});
app.get('/synthesizeFemale', function(req, res) {
var synthReq = {
accept: "audio/ogg; codecs=opus",
voice: "VoiceEnUsLisa",
text: req.query.text
};
var transcript = textToSpeech.synthesize(synthReq);
transcript.on('response', function(response) {
console.log(response.headers);
if (req.query.download) {
response.headers['content-disposition'] = 'attachment; filename=transcript.ogg';
}
});
transcript.pipe(res);
});
// For speech 2 text
app.post('/', function(req, res) {
var audio;
if(req.body.url && req.body.url.indexOf('audio/') === 0) {
// sample audio
audio = fs.createReadStream(__dirname + '/../public/' + req.body.url);
} else { // malformed url
return res.status(500).json({ error: 'Malformed URL' });
}
speechToText.recognize({audio: audio, content_type: 'audio/l16; rate=44100'}, function(err, transcript){
if (err) return res.status(500).json({ error: err });
else return res.json(transcript);
});
});
};
});
});
});
var UserSchema = new mongoose.Schema({
name: String
});
var User = mongoose.model('User', UserSchema);
var app = express();
app.set('view engine', 'jade');
app.use(express.static(__dirname + "/client"));
app.use(bodyParser.json());
var paths = ['/', '/users', '/feed'];
paths.forEach(function(path) {
app.get(path, function(req, res) {
res.render('index');
});
});
app.get('/api/users', function(req, res) {
User.find({}, function(err, _users) {
res.send(_users);
});
var express = require('express');
var path = require('path');
var bodyParser = require('body-parser');
var logger = require('morgan');
var routes = require('./routes');
var api = require('./routes/api');
var app = express();
global.appPublic=path.join(__dirname, 'public');
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
app.use(express.static(global.appPublic));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.use('/api', api);
app.use('/', routes);
module.exports = app;
const express = require('express');
const app = express();
const path = require('path');
const httpProxy = require('http-proxy');
const isProduction = process.env.NODE_ENV === 'production';
const port = isProduction ? process.env.PORT || 4000 : 3000;
const publicPath = isProduction ? path.resolve(__dirname, 'build') : path.resolve(__dirname, 'src');
app.set("view options", {layout: false});
app.use(express.static(publicPath));
// We only want to run the workflow when not in production
if (!isProduction) {
const Webpack = require('webpack');
const WebpackDevServer = require('webpack-dev-server');
const webpackConfig = require('./webpack.config.js');
const proxy = httpProxy.createProxyServer();
// First we fire up Webpack an pass in the configuration we
// created
var bundleStart = null;
const compiler = Webpack(webpackConfig);
// We give notice in the terminal when it starts bundling and
// set the time it started
compiler.plugin('compile', function() {
console.log('Bundling...');
bundleStart = Date.now();
});
// Set up Express
const app = module.exports = express();
// Use domains to capture the errors at the request scope, and not crash the server
app.use((req, res, next) => {
const d = domain.create();
d.add(req);
d.add(res);
d.on('error', next);
d.run(next);
});
app.use(cors());
app.use(busboy());
// if images are stored locally in the public directory
app.use(express.static(path.join(__dirname, '../public'), { maxAge: ((cfg.imgCache) ? cfg.imgCache : 0) }));
// if images are mounted (to a dir named storage) - usueful if we run thumby inside a docker container and need persistant storage
app.use(express.static(path.join(__dirname, '../storage'), { maxAge: ((cfg.imgCache) ? cfg.imgCache : 0) }));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
// Load clients into the app
router.connect(app);
// exception handling middleware
app.use((err, req, res, next) => {
const globalErrorHandler = require('./utils/globalErrorHandler');
globalErrorHandler.log(err, req, res, next);
// TODO: Add all routes from ./routes.js
// TODO: Add the express config
// See code below
const express = require('express');
const path = require('path');
const logger = require('./logger');
const config = require('./config/environment');
const app = express();
require('./config/express')(app);
require('./routes')(app);
app.use('/public', express.static(path.resolve(__dirname, '../public'), {fallthrough: false}));
app.use('/api/*', function(req, resp){ return resp.status(404).send('Not Found'); });
app.get('*', function response(req, res) {
res.sendFile(path.resolve(__dirname, '../public/index.html'));
});
app.listen(config.PORT, '0.0.0.0', function onStart(err) {
if (err) {
logger.error('listen', err);
}
logger.info("STARTING_APP");
logger.info('listening on port:', config.PORT);
});
var express = require('express');
var app = express();
var server = require('http').createServer(app);
app.use(express.static(__dirname + '/'));
app.get('/', function(request, response){
console.log(request);
console.log(response);
response.sendFile(path.join(__dirname, './', './index.html'));
});
server.listen(3000, function(){
console.log('The server is running on 3000');
});
module.exports = server;
var express = require('express')
, ejs = require('ejs')
, config = require('./config')
, todo = require('./controllers/todo')
, csrf = require('./lib/csrf');
var app = express.createServer();
app.use(express.static(__dirname + '/public', {maxAge: 3600000 * 24 * 30}));
app.use(express.cookieParser());
app.use(express.bodyParser());
app.use(express.session({
secret: config.session_secret
}));
/**
* Fixed CSRF
* add '<input type="hidden" name="csrf" value="<%- it.csrf %>" />' to form
*/
app.use(csrf.check());
app.dynamicHelpers({
csrf: csrf.token
});
app.helpers({
config: config
});
/**
* Views settings
*/
app.set("view engine", "html");
app.set("views", __dirname + '/views');
var async = require('async'),
mcping = require('mc-ping-updated'),
_ = require('underscore'),
express = require('express'),
app = express();
app.set('view engine', 'jade');
app.use('/public', express.static(__dirname + '/public'));
app.get('/', function(req, res) {
var ports = _.range(25561, 25580);
var address = 'wheee.org';
var servers = _.map(ports, function(port) { return address + ':' + port; });
var serverResponses = [];
async.each(ports, function(port, callback) {
mcping(address, port, function(err, res) {
if (err) {
// skip getting any information from the response, probably the server was down or there never was one available on this port
callback();
} else {
if (typeof res.description != 'string') {
res.description = res.description.text;
}
res.description = res.description.replace(/§.{1}/g, '');
serverResponses.push({port: port, info: res});
callback();
}
});
}, function(err) {
var express = require('express');
var app = express();
var http = require('http').Server(app);
var io = require('socket.io')(http);
var yarp = require('../yarp');
app.use(express.static('js'));
app.get('/', function(req, res){
res.sendFile('stream_audio.html',{ root : __dirname});
});
var port = new yarp.Port('sound');
port.open('/yarpjs/mic:o');
io.on('connection', function(socket){
socket.on('stream-audio', function (data) {
var sound = port.prepare();
sound.fromBinary(data.buffer);
var React = require('react');
var ReactDOM = require('react-dom/server');
var Router = require('react-router');
var routes = require('./app/routes');
var express = require('express');
var path = require('path');
var logger = require('morgan');
var bodyParser = require('body-parser');
var app = express();
app.set('port', process.env.PORT || 3000);
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(express.static(path.join(__dirname, 'assets'))); // typically the 'public' folder
// routing
app.use(function(req, res) {
Router.match({ routes: routes.default, location: req.url }, function(err, redirectLocation, renderProps) {
if (err) {
res.status(500).send(err.message)
} else if (redirectLocation) {
res.status(302).redirect(redirectLocation.pathname + redirectLocation.search)
} else if (renderProps) {
var html = ReactDOM.renderToString(React.createElement(Router.RoutingContext, renderProps));
var page = swig.renderFile('views/index.html', { html: html });
res.status(200).send(page);
} else {
res.status(404).send('Page Not Found')
}
models = require('./models'),
Vimeo = require('vimeo-api').Vimeo;
var app = express();
require('dotenv').load();
// Vimeo suggested syntax for instantiating module
var lib = new Vimeo(process.env.VIMEO_CLIENT_ID, process.env.VIMEO_CLIENT_SECRET, process.env.VIMEO_TOKEN);
var User = models.users;
var Keyword = models.keywords;
// Server Configuration
app.use(logger('dev'));
app.use( bodyParser() );
app.use( express.static( path.join( application_root, 'public' )))
app.use( express.static( path.join( application_root, 'browser' )))
// Routes
// Export app as module
module.exports = app;
// USER ROUTES
// Request 50 videos with query req.params.category
app.get('/categories/:category/videos', function(req, res) {
lib.request({
method: 'GET',
path: '/categories/' + req.params.category + '/videos', //vimeo.api/categories/{category}/videos
query: {
page: req.query.page,