var through = require('through2');
var routes = require('../mock/routes').routes;
var server = new Hapi.Server();
var file = require('./help/file');
var sass = require('gulp-sass');
var PORT = '9095';
var mockServerPort = '8007';
var WebpackDevServer = require("webpack-dev-server");
var ip = require('ip');
var webpack = require('webpack');
var config = require('./config/webpack');
var PROJECT_PATH = 'tianxiao-virgo-frontend/';
var swig = require('swig');
swig.setDefaults({
cache: false,
varControls: ['${', '}$']
});
server.register(Inert, function () {});
gulp.task('server:start', function () {
for (var item in config.entry) {
config.entry[item].unshift('webpack-dev-server/client?http://0.0.0.0:' + PORT, 'webpack/hot/dev-server')
}
config.plugins.push(new webpack.HotModuleReplacementPlugin());
var proxy = [
{
path: '*.json',
target: 'http://localhost:' + mockServerPort,
var express = require('express.io'),
swig = require('swig'),
passport = require('passport');
var LevelStore = require('connect-level')(express);
var db = require('./lib/db');
var server = express();
// View engine
swig.setDefaults({
root: './app/views',
cache : false
});
server.engine('html', swig.renderFile);
server.set('view engine', 'html');
server.set('views', __dirname + '/app/views');
server.set('view cache', false);
server.use(express.static('./public'));
if (process.env.NODE_ENV === 'production') {
server.use(express.logger());
}else{
server.use(express.logger('dev'));
}
// Server config
server.configure(function() {
server.use(express.cookieParser());
server.use(express.json());
// Q.longStackSupport = true;
/**
* Represents a MavensMate project
*
* @constructor
* @param {Object} [opts] - Options used in deployment
* @param {String} [opts.projectName] - For new projects, sets the name of the project
* @param {String} [opts.subscription] - (optional) Specifies list of Metadata types that the project should subscribe to
* @param {String} [opts.workspace] - (optional) For new projects, sets the workspace
* @param {String} [opts.path] - (optional) Explicitly sets path of the project (defaults to current working directory)
* @param {Array} [opts.packages] - List of packages
*/
function Project(opts) {
util.applyProperties(this, opts);
swig.setDefaults({ runInVm: true, loader: swig.loaders.fs(path.join(__dirname,'templates')) });
}
function api(url, accessToken, opt_cb) {
if (!opt_cb) {
opt_cb = function () {};
}
return request.get({
url: API_URL + url,
headers: {
Authorization: 'Bearer ' + accessToken
},
json: true
}, opt_cb);
}
swig.setDefaults({
// Swig's caching
cache: false
});
var app = express();
app.engine('html', swig.renderFile);
app.set('view engine', 'html');
app.set('views', __dirname + '/views');
//app.set('view options', { layout: false });
// Express' own caching
app.set('view cache', false);
app.use(express.logger());
app.use(express.static(__dirname + '/public'));
gutil = require('gulp-util'),
coffee = require('gulp-coffee'),
uglify = require('gulp-uglify'),
concat = require('gulp-concat'),
path = require('path'),
swig = require('swig'),
through = require('through2'),
browsersync = require('browser-sync').create(),
site = require('./site.json'),
deploy = require('gulp-gh-pages'),
repostname = /(\d{4})-(\d{1,2})-(\d{1,2})-(.*)/;
site.time = new Date();
swig.setDefaults({
loader: swig.loaders.fs(__dirname + '/dev/templates'),
cache: false
});
function collectPosts() {
var posts = [];
var tags = [];
return through.obj(function (file, enc, cb) {
posts.push(file.page);
posts[posts.length - 1].content = file.contents.toString();
if (file.page.tags) {
file.page.tags.forEach(function (tag) {
if (tags.indexOf(tag) == -1) {
tags.push(tag);
}
});
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'));
// Swig templating engine settings
if (env === 'development' || env === 'test') {
swig.setDefaults({
cache: false
});
}
// set views path, template engine and default layout
app.engine('html', swig.renderFile);
app.set('views', config.root + '/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();
});
// bodyParser should be above methodOverride
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: true}));
app.use(multer());
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: 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));
// adds CSRF support
if (process.env.NODE_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();
});
}
};
var serve = require('koa-static')
var session = require('koa-session')
var views = require('co-views')
var parse = require('co-body')
var koa = require('koa')
var swig = require('swig')
var https = require('https')
var http = require('http')
var request = require('request');
var fs = require('fs')
var app = koa()
var gameWorld =require("./lib/gameWorld")
//REMOVE IN PRODUCTION??
swig.setDefaults(config.templateOptions)
//ROUTES
app.keys = [config.sessionSecret]
app.use(session())
app.use(jsonResp())
app.use(router(app))
//PAGE ROUTES
app.get('/', defaultPageLoad('index'))
app.get('/public/*', serve('.'))
//PAGE HANDLERS
function defaultPageLoad(pageName, requiresLogin) {
return function *(){
var Hashids = require('hashids');
var swig = require('swig');
var mkdirp = require('mkdirp');
var app = require('commander');
var defv = {
database: 'HashidsTsql',
schema: 'hashids',
salt: makeSalt(),
minHashLength: 0,
alphabet: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890',
seps: 'cfhistuCFHISTU',
fileExt: 'sql'
};
swig.setDefaults({ allowCR: true });
app
.version(pkg.version)
.usage('[options] [file or directory/ path]')
.option('-d, --database [name]', 'Database name. [' + defv.database + ']', defv.database)
.option('-m, --schema [name]', 'Database schema. [' + defv.schema + ']', defv.schema)
.option('-a, --ascii', 'Generate ASCII/varchar compatible function(s).')
.option('-b, --bigint', 'Generate BIGINT compatible function(s).')
.option('-e, --encodeOnly', 'Generate encode function(s) only.')
.option('-s, --salt [value]', 'Salt. [random]', defv.salt)
.option('-n, --minHashLength [n]', 'Minimum hash length. [' + defv.minHashLength.toString() + ']', defv.minHashLength)
.option('-l, --alphabet [value]', 'Alphabet. [a-z,A-Z,1-9,0]', defv.alphabet)
.option('-x, --fileExt [value]', 'Extension for output files. [' + defv.fileExt + ']', defv.fileExt)
.option('-t, --test', 'Generate test procedureds and tables.')
.parse(process.argv);
variables: dirs.content + '/variables.yaml'
};
winston.remove(winston.transports.Console);
winston.add(winston.transports.Console, {colorize: true});
winston.add(winston.transports.File, {
filename: path.join(dirs.dist, '.build_errors'),
json: false
});
// turn off caching swig templates - so changes will propagate if re-run by a
// watch task
swig.setDefaults({
cache: false,
loader: swig.loaders.fs(__dirname + '/templates'),
locals: {
validateLink: validateLink
}
});
swig.setFilter('find', function (collection, key) {
return _.find(collection, key);
});
// patch swig groupBy filter so it doesn't mutate lists - this is a temporary
// workaround until patch makes its way into a swig release.
// See: https://github.com/paularmstrong/swig/pull/524
swig.setFilter('groupBy', function (input, key) {
if (!_.isArray(input)) {
return input;
}
module.exports = function(app, passport) {
// Add basic auth for staging
if (env === "staging") {
app.use(express.basicAuth(function(user, pass) {
return "username" === user & "password" === pass;
}));
app.use(function (req, res, next) {
if (req.remoteUser && req.user && !req.user._id) {
delete req.user;
}
next();
});
}
var CDN = require("express-cdn")(app, {
publicDir: rootPath + "/public",
viewsDir: rootPath + "/app/views",
extensions: [".swig"],
domain: process.env.S3_STATIC_BUCKET,
bucket: process.env.S3_STATIC_BUCKET,
key: process.env.S3_KEY,
secret: process.env.S3_SECRET,
ssl: false,
production: env === "production"
});
app.set("showStackError", true);
// use express favicon
app.use(express.favicon());
app.use(express.static(rootPath + "/public"));
app.use(express.logger("dev"));
app.engine("swig", swig.renderFile)
// views config
app.set("views", rootPath + "/app/views");
app.set("view engine", "swig");
app.set("view cache", false);
swig.setDefaults({ cache: false });
app.configure(function () {
// bodyParser should be above methodOverride
app.use(express.bodyParser());
app.use(express.methodOverride());
// cookieParser should be above session
app.use(express.cookieParser());
app.use(express.session({
secret: pkg.name,
store: new mongoStore({
url: process.env.MONGODB_URL,
collection : "sessions"
})
}));
// Passport session
app.use(passport.initialize());
app.use(passport.session());
// Flash messages
app.use(flash());
// expose pkg and node env to views
app.use(function (req, res, next) {
res.locals.pkg = pkg
res.locals.env = env
next();
});
// View helpers
app.use(helpers(pkg.name));
// adds CSRF support
if (process.env.NODE_ENV !== "test") {
app.use(express.csrf());
app.use(function(req, res, next) {
res.locals.csrf_token = req.csrfToken();
next();
});
}
// Supported locales
app.locales = ["en", "ja"];
i18n.expressBind(app, {
locales: app.locales,
subdomain: true,
query: env === "development"
});
// Generate a URL given a path and a locale
app.genURL = function(locale, path) {
var base = locale === "en" || !locale || env === "development" ?
app.baseURL() :
app.baseURL().replace(/:\/\//, "://" + locale + ".");
// Only use a query string in dev mode and if we're
// on a non-default locale
if (env === "development" && locale !== app.locales[0]) {
path += (/\?/.test(path) ? "&" : "?") + "lang=" + locale;
}
return base + path;
};
// The base URL for all pages
app.baseURL = function() {
return process.env.BASE_URL ||
"http://localhost:" + process.env.PORT;
};
// The base URL for storage
app.baseDataURL = function() {
return process.env.BASE_DATA_URL ||
"http://localhost:" + process.env.PORT;
};
// Generate a data URL
app.dataURL = function(source, type) {
return app.baseDataURL() + source + "/" + (type || "");
};
app.use(function(req, res, next) {
res.locals.CDN = CDN(req, res);
var otherLocale = function(req) {
return req.i18n.getLocale() === "en" ? "ja" : "en";
};
res.locals.getSiteCategory = function() {
if (req.path.indexOf("/source") === 0) {
return "sources";
} else if (req.path.indexOf("/artist") === 0) {
return "artists";
} else if (req.path.indexOf("/about") === 0) {
return "about";
} else if (!req.path || req.path === "/") {
return "home";
}
return "search";
};
res.locals.getOtherURL = function() {
return app.genURL(otherLocale(req), req.path);
};
res.locals.curLocale = function() {
return req.i18n.getLocale();
};
res.locals.URL = function(path) {
return path.getURL ?
path.getURL(req.i18n.getLocale()) :
app.genURL(req.i18n.getLocale(), path);
};
res.locals.fullName = function(item) {
var locale = req.i18n.getLocale();
return item.getFullName ?
item.getFullName(locale) :
locale === "ja" && item.kanji || item.name || item;
};
res.locals.shortName = function(item) {
return item.getShortName(req.i18n.getLocale());
};
res.locals.getTitle = function(item) {
return item.getTitle(req.i18n.getLocale());
};
res.locals.getDate = function(item) {
return item.dateCreated ?
res.locals.getDate(item.dateCreated) :
(item.circa ? "ca. " : "") +
item.start + (item.end && item.end !== item.start ?
"-" + item.end : "");
};
// Format a number using commas
// TODO: Handle locale here, as well
res.locals.stringNum = function(num) {
return (num || "").toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
};
next();
});
// routes should be at the last
app.use(app.router);
// custom error handler
app.use(function (err, req, res, next) {
if (err.message
&& (~err.message.indexOf("not found")
|| (~err.message.indexOf("Cast to ObjectId failed")))) {
return next();
}
console.error(err.stack);
res.status(500).render("500");
})
app.use(function (req, res, next) {
res.status(404).render("404", { url: req.originalUrl });
});
})
// development specific stuff
app.configure("development", function () {
app.locals.pretty = true;
});
// staging specific stuff
app.configure("staging", function () {
app.locals.pretty = true;
});
};
gulp.task('content', ['iconfont'], function() {
swig.setDefaults({ autoescape: false });
var markdownFilter = Filter('**/*.md');
return gulp.src(['src/content/**/*.{html,md}'])
// Extract YAML-formatted front-matter
// -----------------------------------
// Markdown files : Keep front-matter (for Pandoc to consume later.)
// All other files : Remove front-matter.
.pipe(gulpif( //if
/\.md$/, // then:
frontmatter({
property: 'meta',
remove: false
}), // else:
frontmatter({
property: 'meta',
remove: true
})
))
// Pretty URLs, Part 1 of 2
// ------------------------
// Rename /blah.html -> /blah/index.html,
// only if noprettyurl is NOT set in the front-matter.
.pipe(gulpif( //if
function(file){
return !file.meta.noprettyurl;
}, // then:
rename(function(path) {
if (path.basename !== 'index') {
path.dirname += '/'+path.basename;
path.basename = 'index';
}
})
))
// Site Tree
// ---------
// For building sitemap?
// For building navigation?
// For building index pages?
.pipe(vartree({
prop: 'meta',
root: sharedSiteData.tree,
childsProp: 'children',
pathProp: 'dirname',
nameProp: 'basename',
extProp: 'origext',
hrefProp: 'href',
folderProp: 'directory',
index: 'index'
}))
// Pretty URLs, Part 2 of 2
// ------------------------
.pipe(tap(function(file, t){
if (file.meta.href) {
file.meta.extname = '.html'
file.meta.href = file.meta.href.replace(/\/index\.(md|html)$/, '/');
file.meta.href = file.meta.href.replace(/\.md$/, '.html');
}
return t;
}))
// Templating
// ----------
// *Before* Markdown is processed.
.pipe(consolidate(
'swig',
function(file) {
return {
site: sharedSiteData,
page: file.meta
};
},
{
useContents: true
}
))
// Markdown (Pandoc)
// -----------------
// Process Markdown files through Pandoc.
.pipe(markdownFilter)
.pipe(spawn({
cmd: '/usr/bin/pandoc',
args: [
'-f', 'markdown',
'-t', 'html5',
'--smart'
]
}))
.pipe(markdownFilter.restore())
// Rename -> .html
// ---------------
.pipe(rename({
extname: ".html"
}))
// Layout Templating
// -----------------
// *After* Markdown is processed.
.pipe(tap(function(file, t){
if (typeof file.meta.layout != 'undefined') {
var template = process.cwd() + '/src/layouts/' + file.meta.layout + '.html';
file.contents = new Buffer(swig.renderFile(template, {
site: sharedSiteData,
page: file.meta,
content: file.contents.toString('utf-8')
}));
}
}))
// Output .html Files
// ------------------
.pipe(gulp.dest('build'))
// Output Site Tree
// ----------------
.on('end', function() {
console.log(JSON.stringify(sharedSiteData, null, 2));
})
;
});
function Catalogue(mongooseInstance, options) {
// Setup options
options = options || {};
options = extend({}, defaults, options);
if ( ! mongooseInstance ) {
throw new Error('You must provide catalogue with a mongoose instance');
}
// Create an express app
var app = this.app = express();
// View configuration
app.engine('html', swig.renderFile);
app.set('view engine', 'html');
app.set('views', __dirname);
if( DEV ) {
swig.setDefaults({ cache: false });
}
// Static Assets
app.use('/plugins', express.static(__dirname + '/plugins'), staticOptions);
app.use('/assets/images', express.static(__dirname + '/assets/images'), staticOptions);
app.use('/css', express.static(staticPath + '/css'), staticOptions);
app.use('/build/js', express.static(staticPath + '/js'), staticOptions);
app.use(express.json());
app.use(express.urlencoded());
app.use(express.methodOverride());
// Ensure responses are not cached
app.use(function(req, res, next) {
res.header('Cache-Control', noCacheHeader);
next();
});
// Expose the mongoose connection instance to the routes
app.set('db', mongooseInstance);
app.use(function(req, res, next) {
req.db = app.get('db');
next();
});
app.use(express.favicon());
app.use(app.router);
// Error Handling
app.use(function(err, req, res, next) {
console.error(err.stack);
res.send(500, err.message);
});
// Start Listening
app.listen(options.port, function() {
console.log('Catalogue Ready on Port ' + options.port);
});
// API Routes
var api = require('./server/api');
app.get('/api/models', api.models);
app.get('/api/model/:model/documents', api.getDocs);
app.get('/api/model/:model/document/:id', api.getDoc);
app.post('/api/model/:model/document', api.addDoc);
app.put('/api/model/:model/document/:id', api.updateDoc);
app.delete('/api/model/:model/document/:id', api.deleteDoc);
// Web App Routes
app.get('*', function(req, res, next) {
if( ! req.xhr ) return res.render( 'index' );
else next();
});
return this;
}
module.exports = function (app, io) {
// Compression middleware (should be placed before express.static)
app.use(compression({
threshold: 512
}));
// Static files middleware
app.use(favicon(path.resolve(__dirname + '/../public/images/favicon.ico')));
app.use(serveStatic(config.root + '/public'));
// Use winston on production
var log;
if (env !== 'development') {
log = {
stream: {
write: function (message, encoding) {
winston.info(message);
}
}
};
} else {
log = { format: 'dev' };
}
// Don't log during tests
// Logging middleware
// if (env !== 'test') app.use(morgan(log));
app.set('trust proxy', 'loopback');
app.use(cors());
app.use(slashes());
// Swig templating engine settings
if (env === 'development' || env === 'test') {
swig.setDefaults({
cache: false
});
}
// set views path, template engine and default layout
// app.engine('html', swig.renderFile);
app.set('views', config.root + '/app/views');
app.set('view engine', 'jade');
app.use(function (req, res, next) {
req.io = io;
next();
});
var baseUrl = config.baseURL;
var static_url = baseUrl;
if(config.url) {
static_url = 'http://' + config.url + baseUrl;
}
// cookieParser should be above session
app.use(cookieParser());
// bodyParser should be above methodOverride
app.use(bodyParser.json({limit: '50mb'}));
app.use(bodyParser.urlencoded({ extended: true, limit: '50mb' }));
var getRequestStaticUrl = function(req) {
if(req.query.host) {
return req.query.host;
}
if(req.headers.host) {
return ((req.secure) ? 'https' : 'http') + '://' + req.headers.host + baseUrl;
}
return static_url + baseUrl;
};
// expose package.json to views
app.use(function (req, res, next) {
var staticUrl = getRequestStaticUrl(req);
if(staticUrl.slice(-1) !== '/') {
staticUrl += '/';
}
res.locals.pkg = pkg;
res.locals.env = env;
res.locals.moment = moment;
res.locals._ = require('lodash');
res.locals.marked = require('marked');
res.locals.STATIC_URL = staticUrl;
res.locals.BASE_URL = baseUrl;
next();
});
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;
}
}));
// express/mongo session storage
app.use(session({
secret: pkg.name,
// store: new mongoStore({
// url: config.db,
// collection : 'sessions'
// }),
cookie: {
maxAge: 1000*60*60
}
}));
// use passport session
// app.use(passport.initialize());
// app.use(passport.session());
// connect flash for flash messages - should be declared after sessions
app.use(flash());
// should be declared after session and flash
app.use(helpers(pkg.name));
// adds CSRF support
if (process.env.NODE_ENV !== 'test') {
// app.use(csrf());
// // This could be moved to view-helpers :-)
// app.use(function(req, res, next){
// res.locals.csrf_token = req.csrfToken();
// next();
// });
}
};
this.enableProduction = function() {
productionFlag = true;
swig.setDefaults({ cache: 'memory' });
}
scope: scopes
});
//Init and configure Express
var app = express();
app.set('port', config.port);
// Set views path and view engine
app.engine('html', swig.renderFile);
app.set('view engine', 'html');
app.set('views', config.rootPath);
// Swig template engine configurations
app.set('view cache', false);
swig.setDefaults({
cache: false,
varControls: ['<%=', '%>']
});
// Setting static folder to serve
app.use(express.static(path.join(config.rootPath, '/public')));
//Return the index page and include the redirect url for google
app.get('/', function (req, res) {
res.render('index', {
authenticationURL: 'Documentation Search'
});
});
//Handle the callback from google which will contain the code needed to obtain the tokens.
//NOTE: The refresh token will be returned only on the first authentication. If you wish to to obtain it again
//got ot the account revoke the current authentication and authenticate again.
var apis = [];
for (var i in items) {
apis.push(items[i].name);
}
return apis;
}
/**
* Disable auto-escaping its output
* @type {Boolean}
*/
buildurl.safe = true;
swig.setFilter('buildurl', buildurl);
swig.setFilter('getAPIs', getAPIs);
swig.setFilter('oneLine', oneLine);
swig.setDefaults({ loader: swig.loaders.fs(__dirname + '/../templates')});
/**
* Handle error object with callback
* @param {Error} err Error object to return in callback
* @param {Function=} callback Optional callback function
*/
function handleError(err, callback) {
if (callback && typeof callback === 'function') {
callback(err, null);
}
}
/**
* Generator for generating API endpoints
* @param {object} options Options for generation
}
});
return pathParams;
}
/**
* Disable auto-escaping its output
* @type {Boolean}
*/
buildurl.safe = true;
swig.setFilter('buildurl', buildurl);
swig.setFilter('getAPIs', getAPIs);
swig.setFilter('oneLine', oneLine);
swig.setFilter('cleanComments', cleanComments);
swig.setFilter('getPathParams', getPathParams);
swig.setDefaults({ loader: swig.loaders.fs(path.join(__dirname, '..', 'templates'))});
/**
* Handle error object with callback
* @param {Error} err Error object to return in callback
* @param {Function=} callback Optional callback function
*/
function handleError(err, callback) {
if (callback && typeof callback === 'function') {
callback(err, null);
}
}
/**
* Generator for generating API endpoints
* @param {object} options Options for generation
return function (request, response, next) {
var viewsPath = options.views || response.getVariable('views');
swig.setDefaults({ autoescape: response.variables['view autoescape'] });
swig.setDefaultTZOffset(response.variables['view timezone']);
var res = extend({cook: response.cook}, response);
if (request.options) {
extend(request.options, options);
} else {
extend(request, {options: extend({}, options)});
}
res.render = function (view, data, cabView, obj) {
if (arguments.length === 1) {
data = view;
view = false;
}
if ( typeof view === 'object' && typeof data === 'string') {
var swith = view;
view = data; data = swith;
}
if (view) {
if (view.indexOf('.html') === -1) { // файл в viewsPath
view = viewsPath + '/' + view + '.html';
}
if (!swigCache[view]) {
swigCache[view] = swig.compileFile(view);
}
var d = extend(extend({}, request.options), typeof data === 'object' ? data : {data: data});
data = swigCache[view](d);
}
response.status(res.statusCode);
response.render( cabView || 'index', extend(extend({data: data}, request.options), obj || {}));
};
res.json = function (data) {
response.status(res.statusCode);
response.type('json').send(JSON.stringify(data, '\t', 4));
};
res.mark = function (data) {
var hash = exports.md5(data);
if (!markCache[hash]) {
markCache[hash] = marked(data, true);
setTimeout(function () {
if (markCache[hash]) {
delete markCache[hash];
}
}, 10000);
}
res.render('<div class="markdown">' + markCache[hash] + '</div>');
};
res.dump = function (data) {
res.mark('```\n' + JSON.stringify(data, '\t', 4) + '\n```');
};
callback(request, res, next);
};
}
const app = express();
app.use(morgan('common'));
app.use(express.static('public'));
app.use(bodyParser.urlencoded({extended: false}));
const csrfProtection = csurf();
app.engine('html', swig.renderFile);
app.set('view engine', 'html');
app.set('views', __dirname + '/views');
const isProduction = config.NODE_ENV === 'production';
swig.setDefaults({cache: isProduction});
if (!isProduction) {
app.disable('etag');
}
mongoose.connect(config.MONGODB_URL);
app.use(session({
secret: config.SESSION_SECRET,
store: new MongoStore({mongooseConnection: mongoose.connection}),
resave: false,
saveUninitialized: false
}));
app.use(passport.initialize());
identifier = loader.resolve(identifier);
if (cb) {
fs.readFile(identifier, encoding, cb);
return;
}
return fs.readFileSync(identifier, encoding);
},
};
return loader;
};
swig.setDefaults({
loader: swig_loader(path.join(__dirname, "..", "dynamic")),
cache: false,
});
exports.app = null;
const setup_express = function (app) {
app.use(express_body_parser.json());
app.use(express_cookie_parser());
app.use(express_body_parser());
app.use(express_session({
secret: settings.d.secrets.session,
resave: false,
saveUninitialized: true,
store: new express_session_file_store({
path: settings.d.folders.sessions,
exports.init = (conf) => {
if(conf.mode !== 'productive') {
app.set('view cache', false);
swig.setDefaults({ cache: false });
}
app.engine('html', swig.renderFile);
app.set('view engine', 'html');
app.set('views', __dirname+'/views');
app.use(session({
secret: Math.random().toString(36).substring(2),
resave: false,
saveUninitialized: true
}));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
function serveSession(req) {
return {
system: { name: conf.name },
user: req.session.pub
}
}
// **Requests Routings:**
// Redirect the views that will be loaded by the swig templating engine
app.get('/', (req, res) => res.render('index', serveSession(req)));
// - ** _"/"_:** Static redirect to the _"webpages/public"_ directory
app.use('/', express.static(path.resolve(__dirname, '..', 'webapp')));
app.get('/views/*', (req, res) => {
if(req.session.pub || req.params[0]==='login') {
if(req.params[0]==='admin' && !req.session.pub.isAdmin)
res.render('401_admin', serveSession(req));
else
res.render(req.params[0], serveSession(req));
}
else res.render('401');
});
app.use('/service/*', (req, res, next) => {
if(req.session.pub || req.params[0]==='session/login') next();
else res.status(401).send('Not logged in!');
});
// Dynamically load all services from the services folder
log.info('LOADING WEB SERVICES: ');
let arrServices = fs.readdirSync(path.resolve(__dirname, 'services'))
.filter((d) => d.substring(d.length-3) === '.js');
for(let i = 0; i < arrServices.length; i++) {
let fileName = arrServices[i];
log.info(' -> '+fileName);
let servicePath = fileName.substring(0, fileName.length-3);
let modService = require(path.resolve(__dirname, 'services', fileName));
app.use('/service/'+servicePath, modService);
}
// If the routing is getting down here, then we didn't find anything to do and
// tell the user that he ran into a 404, Not found
app.get('*', (req, res, next) => {
let err = new Error('Request from "'+req.ip+'" produced error making '+req.method+' request: '+req.originalUrl);
err.status = 404;
next(err);
});
// Handle errors
app.use((err, req, res, next) => {
if(req.method === 'GET') {
res.status(404);
res.render('404', serveSession(req));
} else {
log.error(err);
res.status(500).send('There was an error while processing your request!');
}
});
let server = app.listen(conf.httpport);
log.info('HL | Started listening on port '+conf.httpport);
server.on('listening', () => {
let port = server.address().port;
if(port !== conf.httpport) {
log.error(addr.port, conf.httpport);
log.error('HL | OPENED HTTP-PORT IS NOT WHAT WE WANTED!!! Shutting down!');
process.exit();
}
});
server.on('error', (err) => {
// Error handling of the express port listener requires special attention,
// thus we have to catch the error, which is issued if the port is already in use.
switch(err.errno) {
case 'EADDRINUSE':
log.error(err, 'HL | HTTP-PORT ALREADY IN USE!!! Shutting down!');
break;
case 'EACCES':
log.error(err, 'HL | HTTP-PORT NOT ACCSESSIBLE!!! Shutting down!');
break;
default:
log.error(err, 'HL | UNHANDLED SERVER ERROR!!! Shutting down!');
}
process.exit();
});
}
grunt.registerMultiTask('swig', 'Grunt plugin for the Swig JavaScript Template Engine.', function() {
// Merge task-specific and/or target-specific options with these defaults.
var options = this.options({
locals: {},
tags: {},
filters: {}
});
// Setup swig default configuration
swig.setDefaults({
// Get optional template path from options, setting root folder of where Swig looks for templates
loader: options.templatePath ? swig.loaders.fs(options.templatePath) : swig.loaders.fs(),
// Cache templates
cache: options.cache === true ? true : false
});
// Register all filters
for (var filter in options.filters) {
swig.setFilter( filter, options.filters[filter] );
}
// Register all tags
for (var tag in options.tags) {
swig.setTag( tag, options.tags[tag].parse, options.tags[tag].compile, options.tags[tag].ends, options.tags[tag].blockLevel );
if ( options.tags[tag].ext ) {
swig.setExtension( tag, options.tags[tag].ext );
}
}
// Iterate over all specified file groups.
this.files.forEach(function(f) {
// Concat specified files.
var output = f.src.filter(function(filepath) {
// Warn on and remove invalid source files (if nonull was set).
if (!grunt.file.exists(filepath)) {
grunt.log.warn('Source file "' + filepath + '" not found.');
return false;
} else {
return true;
}
}).map(function(filepath) {
// Read file source.
return {
source: grunt.file.read(filepath),
path: filepath
};
}); //.join(grunt.util.normalizelf(''));
output.forEach(function(item) {
var src = swig.render(item.source, {
filename: item.path,
locals: options.data
});
// Write the destination file.
grunt.file.write(f.dest, src);
// Print a success message.
grunt.log.writeln('File "' + f.dest + '" created.');
});
});
});
// CONSTANTES
var PORT = 3434;
var ENV = 'development';
// CONFIGURATION
app.engine('html', swig.renderFile);
app.set('port', process.env.PORT || PORT);
app.set('view engine', 'html');
app.set('view cache', false);
app.set('views', __dirname + '/views');
app.set('env', process.env.ENV || ENV);
app.use(morgan('dev'));
app.use(express.static(__dirname + '/assets'));
swig.setDefaults({
cache: false,
varControls: ['{(', ')}']
});
// ROUTES
require('./routes/index')(app);
app.get('*', function(req, res) {
res.status(404).render('pages/404');
});
// SERVER
if (ENV == 'development') {
app.use(errorhandler());
}
app.listen(app.get('port'), function() {
function init(options, cb) {
rootFolder = options.root || rootFolder;
swig.setDefaults(options);
if (options.filters) {
Object.keys(options.filters).forEach(function (filterName) {
swig.setFilter(filterName, options.filters[filterName]);
});
}
cb(null, render);
function render(templateName, context, urlRewriteFn, cb) {
if (!cb) {
cb = urlRewriteFn;
urlRewriteFn = null;
}
// compile file into swig template
compileTemplate(templateName, function (err, template) {
if (err) return cb(err);
// render template with context
renderTemplate(template, context, function (err, html) {
if (err) return cb(err);
createJsDomInstance(html, function (err, document) {
if (err) return cb(err);
if (urlRewriteFn) rewriteUrls(document, urlRewriteFn);
var slashes = os.platform() === 'win32' ? '\\\\' : '//';
var fileUrl = "file:" + slashes + path.resolve(process.cwd(), path.join(options.root, templateName));
options.juice = options.juice || {};
options.juice.url = fileUrl;
juiceDocument(document, options.juice, function (err) {
if (err) {
// free the associated memory
// with lazily created parentWindow
tryCleanup();
cb(err);
} else {
var inner = '<html>' + document.documentElement.innerHTML + '</html>';
tryCleanup();
generateText(options, context, inner, function (err, text) {
if (err) return cb(err);
cb(null, inner, text);
});
}
function tryCleanup() {
try {
document.parentWindow.close();
} catch (cleanupErr) {}
try {
document.close();
} catch (cleanupErr) {}
}
});
});
});
});
}
}
password = process.env.PASSWORD,
env = process.env.NODE_ENV || 'development';
// Application settings
app.engine('html', swig.renderFile);
app.set('view engine', 'html');
app.set('views', __dirname + '/app/views');
// Template engine settings
// Swig will cache templates for you, but you can disable
// that and use Express's caching instead, if you like:
app.set('view cache', false);
// To disable Swig's cache, do the following:
swig.setDefaults({ cache: false });
// NOTE: You should always cache templates in a production environment.
// Don't leave both of these to `false` in production!
// Set base directory for Swig templates and includes
swig.setDefaults({ loader: swig.loaders.fs(__dirname + '/app/views' )});
// Set up markdown
swig_extras.useTag(swig, 'markdown');
// Middleware to serve static assets
app.use('/public', express.static(__dirname + '/public'));
app.use('/public', express.static(__dirname + '/app/assets_govuk_legacy'));
app.use('/public', express.static(__dirname + '/nhsalpha_modules/nhsalpha_frontend_toolkit'));
module.exports.init = function(app) {
var env = app.get('env');
var root = app.get('root');
/**
* Configure view engine
*/
app.engine('html', swig.renderFile);
app.set('views', root + '/app/views');
app.set('view engine', 'html');
if (config.swig.cache) {
swig.setDefaults({ cache: 'memory' });
} else {
swig.setDefaults({ cache: false });
}
if (config.proxy.trust) {
app.enable('trust proxy');
}
/**
* Common express configs
*/
app.use(expressValidator());
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
app.use(methodOverride());
app.disable('x-powered-by');
var sessionOpts = {
secret: config.session.secret,
key: 'skey.sid',
resave: false,
saveUninitialized: false
};
switch(env) {
case 'production':
sessionOpts.store = new MongoStore({
url: config.mongodb.uri
});
case 'staging':
case 'test':
case 'development':
default:
app.use(session(sessionOpts));
}
/**
* Use passport session
*/
app.use(passport.initialize());
app.use(passport.session());
app.use(function(req, res, next) {
// a simple object that holds resources for each request
req.resources = req.resources || {};
res.locals.app = config.app;
res.locals.currentUser = req.user;
// mock i18n funciton
res.locals._t = function (value) { return value; };
res.locals._s = function (obj) { return JSON.stringify(obj); };
next();
});
if (config.serveStatic) {
app.use(serveStatic(path.join(root, 'public')));
}
};
// Static assets
app.use(express.static('./public'));
// Template engine
var swigHelpers = require('./views/helpers');
swigHelpers(swig);
app.engine('html', swig.renderFile);
app.set('view engine', 'html');
app.set('views', __dirname + '/views');
app.set('view cache', false);
// Swig cache for production
if (conf.env === 'production') {
console.log('Adding cache to templates', conf.env);
swig.setDefaults({ cache: 'memory' });
} else {
swig.setDefaults({ cache: false });
}
// Add session to the app
var RedisStore = require('connect-redis')(express);
app.configure(function () {
app.use(express.logger());
app.use(express.cookieParser());
app.use(express.json());
app.use(express.urlencoded());
app.use(express.session({
store: new RedisStore(conf.redis.options),
secret: conf.redis.secret
var async = require('async'),
fs = require('graceful-fs'),
path = require('path'),
moment = require('moment'),
swig = require('swig'),
util = require('../util'),
file = util.file2,
yfm = util.yfm,
escape = util.escape;
swig.setDefaults({
autoescape: false
});
var _getFilename = function(data, replace, callback){
var sourceDir = hexo.source_dir,
layout = data.layout,
date = data.date,
slug = data.slug,
target = '';
if (layout === 'page'){
if (data.path){
target = path.join(sourceDir, data.path);
} else {
target = path.join(sourceDir, slug, 'index.md');
}
} else {
var postDir = path.join(sourceDir, layout === 'draft' ? '_drafts' : '_posts'),
filename = '';
var express = require('express');
var server = express();
var models = require('./models');
var wiki = require('./routes/wiki');
var swig = require('swig');
var morgan = require('morgan');
var bodyParser = require('body-parser');
var path = require('path');
server.set('views', path.join(__dirname, '/views'));
server.set('view engine', 'html');
server.engine('html', swig.renderFile);
swig.setDefaults({ cache: false });
server.use(express.static('./public'));
server.use(morgan('dev'));
server.use(bodyParser.urlencoded({ extended: true }));
server.use(bodyParser.json());
server.use('/wiki', wiki.router);
models.User.sync().then(function() {
return models.Page.sync();
}).then(function() {
server.listen(3000, function() {
console.log('We are listneing on Port 3000!');
});
}).catch(console.error);
// set up our express application
app.use(morgan('dev')); // log every request to the console
app.use(cookieParser()); // read cookies (needed for auth)
app.use(bodyParser()); // get information from html forms
// View engine setup
// utilisation du moteur de swig pour les .html
app.engine('html', swig.renderFile);
// utiliser le moteur de template pour les .html
app.set('view engine', 'html');
// dossier des vues
app.set('views', __dirname + '/views');
// view cache
app.set('view cache', false); // désactivation du cache express
swig.setDefaults({ cache: false }); // désactivation du cache swig
// required for passport
app.use(session({ secret: 'ilovepandas' })); // session secret
app.use(passport.initialize());
app.use(passport.session()); // persistent login sessions
app.use(flash()); // use connect-flash for flash messages stored in session
/*app.use('/static', express.static('public'));*/
// routes ======================================================================
require('./app/routes.js')(app, passport, ctrl); // load our routes and pass in our app and fully configured passport
// launch ======================================================================
app.listen(port);
console.log('The magic happens on port ' + port);