// Copyright IBM Corp. 2015. All Rights Reserved.
// Node module: smartprofiling-example-app
// US Government Users Restricted Rights - Use, duplication or disclosure
// restricted by GSA ADP Schedule Contract with IBM Corp.
var loopback = require('loopback');
var boot = require('loopback-boot');
var app = module.exports = loopback();
boot(app);
});
};
boot(app, __dirname, function(err) {
if (err) {
throw err;
}
if (require.main === module) {
var io = require('socket.io')(app.start());
io.on('connection', function(socket) {
onConnection(socket);
socket.on('add-chat-user', function(user) {
addChatUserForSocket(user, socket);
});
socket.on('message', function(message) {
onMessage(socket, message)
});
socket.on('disconnect', function() {
onClose(socket)
});
});
}
});
var User = function(name, id) {
this.name = name;
var app = module.exports = loopback();
app.start = function() {
// start the web server
return app.listen(function() {
app.emit('started');
var baseUrl = app.get('url').replace(/\/$/, '');
console.log('Web server listening at: %s', baseUrl);
if (app.get('loopback-component-explorer')) {
var explorerPath = app.get('loopback-component-explorer').mountPath;
console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function(err) {
if (err) throw err;
// start the server if `$ node server.js`
if (require.main === module)
app.io = require('socket.io')(app.start());
app.io.on('connection',function(){
console.log('conectado');
app.io.emit('test','asd');
});
app.io.on('chat',function(){ console.log('chatt');});
//app.start();
});
console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function(err) {
if (err) throw err;
// start the server if `$ node server.js`
if (require.main === module)
app.io = require('socket.io')(app.start());
app.io.on('connection', function(socket){
socket.on('msg', function(msg){
try {
ioMiddleware.processRequest(app, msg, socket);
} catch(e) {
console.log(e)
}
});
socket.on('disconnect', function() {
try {
socketEvents.disconnect(app, socket);
} catch(e) {
console.log(e)
}
})
});
});
boot(app, __dirname, function(err) {
if (err) throw err;
// start the server if `$ node server.js`
if (require.main === module) {
app.io = require('socket.io')(app.start());
app.io.on('connection', function(socket){
console.log('connected');
socket.on('disconnect', function(){
console.log('disconnected');
});
});
setInterval(function() {
app.models.Sensor.findById(1, function(err, sensor) {
if (sensor.status == "Not connected") {
return;
}
var sensorDisconnected = false;
if (sensor.lastHeartbeatAt == null) {
sensorDisconnected = true;
}
else {
var now = new Date();
var diff = now - sensor.lastHeartbeatAt;
// set disconnected if we haven't received
// a heartbeat for over 90 seconds
if (diff > 90000) {
sensorDisconnected = true;
}
}
if (sensorDisconnected) {
console.log("[%s] Sensor disconnected", now.toISOString());
sensor.status = "Not connected";
sensor.save();
}
});
}, 10000);
var gateway = process.env.KANBANLIVE_GATEWAY || false;
if (gateway) {
console.log('Configured as gateway');
var p = process.env.KANBANLIVE_SERIALPORT;
if (!p) {
p = "/dev/ttyAMA0";
}
console.log("Opening serial port: %s", p);
var serialPort = require('serialport');
var SerialPort = serialPort.SerialPort;
var sp = new SerialPort(p, {
baudrate: 9600,
parser: serialPort.parsers.readline("-")
});
var ts = new Date();
var lastTime = ts.getTime();
var message = "";
var lastMessage = message;
sp.on('data', function(data) {
ts = new Date();
message = data.toString();
if ((message.length != 10) && (message.length != 11)) {
console.log("[%s] ignoring message: %s", ts.toISOString(), message);
return;
}
var currentTime = ts.getTime();
var diff = Math.abs(currentTime - lastTime);
if ((diff < 500) && (message == lastMessage)) {
return;
}
lastTime = currentTime;
lastMessage = message;
console.log("[%s] rx: %s", ts.toISOString(), message);
var batteryLevel = null;
if (message.length == 11) {
batteryLevel = parseInt(message.substring(3, 7), 16) / 1000;
}
val = parseInt(message.substring(message.length - 4), 16);
console.log("[%s] batttery level: %dV, value: %s", ts.toISOString(), batteryLevel, val);
app.models.Sensor.findById(1, function(err, sensor) {
sensor.status = "Connected";
sensor.batteryLevel = batteryLevel;
sensor.lastHeartbeatAt = new Date();
sensor.save();
});
if ((val == 0x001A) || (val == 0x001B)) {
key = message.substring(1);
app.models.Bin.find({where: {key: key}, limit: 1}, function(err, bins) {
var i;
for (i in bins) {
bin = bins[i];
if (bin.status == 'has-stock') {
bin.status = 'requires-stock';
}
else if (bin.status == 'requires-stock') {
bin.status = 'empty';
}
else if (bin.status == 'empty') {
bin.status = 'has-stock';
}
else {
bin.status = 'has-stock';
}
bin.updated_at = currentTime;
bin.save();
}
});
}
else {
app.models.Bin.find(function(err, bins) {
var i;
for (i in bins) {
bin = bins[i];
if ((bin.key == 'AA000001A') || (bin.key == 'AA000001B')) {
continue;
}
var status = val & bin.port_mask;
if (status == 0) {
new_status = 'has-stock';
}
else {
new_status = 'requires-stock';
}
// else if (status == 2) {
// bin.status = 'empty';
// }
// else {
// bin.status = 'has-stock';
// }
if (bin.status != new_status) {
bin.status = new_status;
bin.updated_at = currentTime;
bin.save();
}
}
});
}
});
}
else {
console.log('Configured as server');
}
}
});
console.log('Web server listening at: %s', baseUrl);
if (app.get('loopback-component-explorer')) {
var explorerPath = app.get('loopback-component-explorer').mountPath;
console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function(err) {
if (err) throw err;
// start the server if `$ node server.js`
if (require.main === module){
//app.start();
app.io = require('socket.io')(app.start());
app.io.on('connection', function(socket){
console.log('a user connected');
socket.on('subscribe', function(room) {
console.log('joining room', room);
socket.join(room);
});
socket.on('disconnect', function(){
console.log('user disconnected');
});
});
}
});
var loopback = require('loopback');
var boot = require('loopback-boot');
var server = module.exports = loopback();
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(server, __dirname);
server.start = function() {
// start the web server
return server.listen(function() {
server.emit('started');
console.log('Web server listening at: %s', server.get('url'));
});
};
// start the server if `$ node server.js`
if (require.main === module) {
server.io = require('socket.io')(server.start());
server.io.on('connection', function(socket){
console.log('a user connected');
socket.emit('launch', 'from server');
socket.on('disconnect', function(){
console.log('user disconnected');
});
});
'use strict';
var loopback = require('loopback');
var boot = require('loopback-boot');
var client = module.exports = loopback();
boot(client);
if (app.get("loopback-component-explorer")) {
var explorerPath = app.get("loopback-component-explorer").mountPath;
winston.info("Browse your REST API at %s%s", baseUrl, explorerPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function (err) {
if (err) {
throw err;
}
// notify that the app has booted, ready to be started
app.booted = true;
app.emit("booted");
// start the server if `$ node server.js`
if (require.main === module) {
app.start();
}
});
//------------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
const loopback = require('loopback');
const boot = require('loopback-boot');
const app = module.exports = loopback();
app.start = () =>
// start the web server
app.listen(() => {
app.emit('started');
const baseUrl = app.get('url').replace(/\/$/, '');
console.log('Web server listening at: %s', baseUrl);
if (app.get('loopback-component-explorer')) {
const explorerPath = app.get('loopback-component-explorer').mountPath;
console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
}
})
;
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, (err) => {
if (err) {
throw err;
}
// start the server if `$ node server.js`
if (require.main === module || require.main.filename.indexOf('server.js') !== -1) {
app.start();
}
});
// app.post('/**', passport.authenticate('mca-backend-strategy', {session: false}));
// app.put('/**', passport.authenticate('mca-backend-strategy', {session: false}));
// app.delete('/**', passport.authenticate('mca-backend-strategy', {session: false}));
// Protect /protected endpoint which is used in Getting Started with Bluemix Mobile Services tutorials
// app.get('/protected', passport.authenticate('mca-backend-strategy', {session: false}), function(req, res){
// res.send("Hello, this is a protected resouce of the mobile backend application!");
// });
// ------------ Protecting backend APIs with Mobile Client Access end -----------------
app.start = function () {
// start the web server
return app.listen(function () {
app.emit('started');
var baseUrl = app.get('url').replace(/\/$/, '');
console.log('Web server listening at: %s', baseUrl);
var componentExplorer = app.get('loopback-component-explorer');
if (componentExplorer) {
console.log('Browse your REST API at %s%s', baseUrl, componentExplorer.mountPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function (err) {
if (err) throw err;
if (require.main === module)
app.start();
});
var app = module.exports = loopback();
app.start = function() {
// start the web server
return app.listen(function() {
app.emit('started');
var baseUrl = app.get('url').replace(/\/$/, '');
console.log('Web server listening at: %s', baseUrl);
if (app.get('loopback-component-explorer')) {
var explorerPath = app.get('loopback-component-explorer').mountPath;
console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function(err) {
if (err) throw err;
// Can add routes right inside server.js also.
app.use('/express-status', function(req, res, next) {
res.json({ running: true });
});
// start the server if `$ node server.js`
if (require.main === module)
app.start();
});
// start the web server
return app.listen(function() {
app.emit('started');
var baseUrl = app.get('url').replace(/\/$/, '');
console.log('Web server listening at: %s', baseUrl);
if (app.get('loopback-component-explorer')) {
var explorerPath = app.get('loopback-component-explorer').mountPath;
console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function(err) {
if (err) throw err;
// start the server if `$ node server.js`
if (require.main === module)
app.start();
//
// var order = loopback.findModel('Order');
// var msg = {msg:"பீட்ரூட் காகிலோ,బంగాళాదుంప అర కేజి\nCabbage 1 no", vno: "9880405637", cno: "8095101060"};
// order.new(msg , function(err, data) {
// console.log(data);
// });
});
path = require('path'),
setupPassport = require('./component-passport');
var app = loopback();
var isBeta = !!process.env.BETA;
expressState.extend(app);
app.set('state namespace', '__fcc__');
app.set('port', process.env.PORT || 3000);
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
app.use(loopback.token());
app.disable('x-powered-by');
boot(app, {
appRootDir: __dirname,
dev: process.env.NODE_ENV
});
setupPassport(app);
app.start = _.once(function() {
app.listen(app.get('port'), function() {
app.emit('started');
console.log(
'FreeCodeCamp server listening on port %d in %s',
app.get('port'),
app.get('env')
);
if (isBeta) {
console.log('Free Code Camp is in beta mode');
}
logger.info('Web server listening at: %s', baseUrl);
if (app.get('loopback-component-explorer')) {
var explorerPath = app.get('loopback-component-explorer').mountPath;
logger.info('Browse your REST API at %s%s', baseUrl, explorerPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function(err) {
if (err) { throw err; }
// start the server if `$ node server.js`
if (require.main === module) {
// Start the server
var expressApp = app.start();
// Start CantyCTI
cantyCti(expressApp);
}
});
function cantyCti(expressApp) {
/**
* Keys for Socket.io events.
*/
const EVENT_KEY_INCOMING_CALL = 'incoming call';
const EVENT_KEY_CALL_REQUEST = 'call request';
const io = require('socket.io')(expressApp);
// var logger = require('loopback-component-logger')(rootLogger);
var app = module.exports = loopback();
require('loopback-ds-calculated-mixin')(app);
app.start = function() {
// start the web server
return app.listen(function() {
app.emit('started');
var baseUrl = app.get('url').replace(/\/$/, '');
console.log('Web server listening at: %s', baseUrl);
if (app.get('loopback-component-explorer')) {
var explorerPath = app.get('loopback-component-explorer').mountPath;
console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function(err) {
if (err) throw err;
console.log("====== automigrate models for TodosDSMysql ====================");
app.datasources['TodosDSMysql'].automigrate(['User', 'AccessToken', 'ACL','RoleMapping','Role','Todo'], function(err) {
console.log(err);
});
// start the server if `$ node server.js`
if (require.main === module)
app.start();
});
/**
* Factory method that returns a loopback server object. This object can be used
* as express middleware.
*
* @param {ServiceManager} serviceManager
* @param {Minkelite} minkelite instance for tracing
* @param {object} options Options object
*/
function server(serviceManager, minkelite, options) {
var app = loopback();
app.serviceManager = serviceManager;
options = options || {};
var duration1Day = 24 * 60 * 60 * 1000;
options['ExpressUsageRecord.deleteWindow'] =
options['ExpressUsageRecord.deleteWindow'] || String(duration1Day);
for (var k in options) {
if (!options.hasOwnProperty(k)) continue;
app.set(k, options[k]);
}
var config;
app.minkelite = minkelite;
if (options.db) {
app.dataSource('db', options.db);
} else if (process.env.STRONGLOOP_MESH_DB) {
// For backward compatibility with old way of specifying connection info
// via environment variable.
var dbUrl = url.parse(process.env.STRONGLOOP_MESH_DB || 'memory://');
debug('Datasource URI: %j', dbUrl);
config = {
name: 'db',
host: dbUrl.hostname,
port: dbUrl.port,
connector: dbUrl.protocol.slice(0, -1),
};
if (dbUrl.path) config.file = dbUrl.path;
debug('Datasource config: %j', config);
app.dataSource('db', config);
} else {
config = {connector: 'memory'};
if (options.dbFilePath) config.file = options.dbFilePath;
app.dataSource('db', config);
}
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname);
app.start = function(callback) {
app.dataSources.db.autoupdate(function(err) {
if (err) return callback(err);
// start the web server
app._server = app.listen(function() {
var addr = this.address();
app.emit('started', addr.port);
console.log('Web server listening at port: %s', addr.port);
if (callback) return callback(null, addr.port);
});
});
};
app.stop = function(callback) {
if (this.minkelite)
this.minkelite.shutdown();
if (!this._server) {
return cb();
}
this._server.close(cb);
function cb() {
app.emit('stopped');
if (callback) callback();
}
};
app.useDbWatcher = function(dbWatcher, callback) {
var ServerService = app.models.ServerService;
var ServiceInstance = app.models.ServiceInstance;
var Executor = app.models.Executor;
var Gateway = app.models.Gateway;
async.parallel([
ServerService.useDbWatcher.bind(null, dbWatcher),
ServiceInstance.useDbWatcher.bind(null, dbWatcher),
Executor.useDbWatcher.bind(null, dbWatcher),
Gateway.useDbWatcher.bind(null, dbWatcher),
], callback);
};
app.handleModelUpdate = function(instanceId, uInfo, callback) {
// These are all currently notifications, so callback is optional and unused
// However, the unit tests need to know when models have been updated, so
// take care to not callback until any actions are complete.
if (!callback) {
callback = assert.ifError;
}
var AgentTrace = app.models.AgentTrace;
var ExpressUsageRecord = app.models.ExpressUsageRecord;
var ProfileData = app.models.ProfileData;
var ServiceInstance = app.models.ServiceInstance;
var ServiceMetric = app.models.ServiceMetric;
var ServiceProcess = app.models.ServiceProcess;
switch (uInfo.cmd) {
case 'started':
// Note carefully that strong-pm doesn't actually pass the started cmd
// directly, it first annotates it with a bunch of extra information.
ServiceInstance.recordInstanceInfo(instanceId, uInfo, function(err) {
if (err) return callback(err);
ServiceProcess.recordFork(instanceId, uInfo, callback);
});
break;
case 'fork':
ServiceProcess.recordFork(instanceId, uInfo, callback);
break;
case 'exit':
ServiceProcess.recordExit(instanceId, uInfo, callback);
break;
case 'listening':
ServiceProcess.recordListeningEndpoint(instanceId, uInfo, callback);
break;
case 'object-tracking':
case 'cpu-profiling':
case 'heap-snapshot':
ServiceProcess.recordProfilingState(instanceId, uInfo, callback);
break;
case 'status':
ServiceInstance.recordStatusUpdate(instanceId, uInfo, callback);
break;
case 'metrics':
ServiceMetric.recordMetrics(instanceId, uInfo, callback);
break;
case 'agent:trace':
AgentTrace.recordTrace(instanceId, uInfo, callback);
break;
case 'trace:object':
if (!app.minkelite)
return callback();
var record = JSON.parse(uInfo.record);
app.minkelite.postRawPieces(record.version,
record.packet.metadata.account_key,
record.packet,
callback);
break;
case 'express:usage-record':
ExpressUsageRecord.recordUsage(instanceId, uInfo, callback);
break;
case 'cpu:profile-data':
ProfileData.recordProfileData(instanceId, uInfo, callback);
break;
case 'status:wd':
ServiceProcess.recordStatusWdUpdate(instanceId, uInfo, function(err) {
if (err) return callback(err);
// Work around for versions of supervisor which dont include appName
// in status:wd message
if (!uInfo.appName) {
return process.nextTick(callback);
}
ServiceInstance.recordStatusWdUpdate(instanceId, uInfo, callback);
});
break;
case 'debugger-status':
ServiceProcess.recordDebuggerStatusUpdate(instanceId, uInfo, callback);
break;
default:
debug('Unknown request: %j', uInfo);
callback();
break;
}
};
app.setServiceCommit = function(serviceId, commit, callback) {
var ServerService = app.models.ServerService;
ServerService.setServiceCommit(serviceId, commit, callback);
};
return app;
}
boot(app, __dirname, function (error) {
if (error) {
throw error;
}
// start the server if `$ node server.js`
if (require.main === module) {
app.io = require('socket.io')(app.start());
var Authenticate = function (socket, data, callback) {
// console.log(data);
//
// if ((data.username || data.email) && data.password) {
// var credentials = {
// password : data.password
// };
// if (data.username) {
// credentials.username = data.username;
// }
//
// app.models.user.login(credentials, 'user', function (error, token) {
// if (error) {
// log.error(error);
// }
// console.log(token);
// });
// }
//
// callback(null, true);
app.models.AccessToken.find({
where : {
and : [{userId : data.userId}, {id : data.id}]
}
}, function (error, tokenDetail) {
if (error) {
throw error;
}
if (tokenDetail.length) {
callback(null, true);
} else {
callback(null, false);
}
});
};
require('socketio-auth')(app.io, {authenticate : Authenticate});
app.io.on('connection', function (socket) {
log.info('a user connected');
socket.on('disconnect', function () {
log.info('user disconnected');
});
});
}
});
var loopback = require('loopback');
var boot = require('loopback-boot');
var app = module.exports = loopback();
app.start = function() {
// start the web server
return app.listen(function() {
app.emit('started');
var baseUrl = app.get('url').replace(/\/$/, '');
console.log('Web server listening at: %s', baseUrl);
if (app.get('loopback-component-explorer')) {
var explorerPath = app.get('loopback-component-explorer').mountPath;
console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
if (require.main === module) {
boot(app, __dirname, function(err) {
if (err)
throw err;
app.start();
});
}
boot(app, __dirname, function (err) {
if (err) throw err;
// start the server if `$ node server.js`
if (require.main === module) {
app.io = require('socket.io')(app.start());
app.io.on('connection', function (socket) {
console.log("connect"+socket.client.request._query.id);
app.models.player.findById(socket.client.request._query.id, function(error, findResult){
if(findResult !=null){
findResult.status = "online";
findResult.save();
}
});
player(app.models.player,socket);
game(app.models.game, socket,app.io);
socket.on('disconnect', function (data) {
console.log("disconnect:"+socket.client.request._query.id);
app.models.player.findById(socket.client.request._query.id, function(error, findResult){
if(findResult !=null){
findResult.status = "offline";
findResult.save();
}
});
});
})
}
});
var loopback = require('loopback');
var boot = require('loopback-boot');
var client = module.exports = loopback();
console.log(__dirname);
boot(client, __dirname,function(err){
if(err){
console.log(err);
throw err;
}
});
return new Promise((resolve, reject) => {
boot(app, options, (err) => {
if (err) reject(err);
resolve();
});
});
var rewriteModule = require('http-rewrite-middleware');
app.use(rewriteModule.getMiddleware([
// hairdresser-favorites -> business-member-favorites
{from: '^/api/users/([a-z0-9]+)/favorite-hairdressers$', to: '/api/users/$1/favorite-business-members'},
{from: '^/api/users/([a-z0-9]+)/favorite-hairdressers/([a-z0-9]+)$', to: '/api/users/$1/favorite-business-members/$2'},
// hairdressers -> business members
{from: '^/api/hairdressers$', to: '/api/businessMembers'},
{from: '^/api/hairdressers/([a-z0-9]+)$', to: '/api/businessMembers/$1'},
], {silent: true}));
// boot scripts mount components like REST API
boot(app, {
appRootDir: __dirname,
config: require('./config'),
dataSources: require('./datasources')
});
// setup passport
var passport = passportConfigurator.init();
passportConfigurator.setupModels({
userModel: app.models.user,
userCredentialModel: app.models.userCredential,
userIdentityModel: app.models.userIdentity,
});
for (var s in passportConfig) {
var c = passportConfig[s];
c.session = c.session !== false;
c.profileToUser = app.models.User.profileToUser;
passportConfigurator.configureProvider(s, c);
}
//
// - - - - - THIRD PARTY AUTH INIT - - - - - -
//
// authorisation providers initialisation is required before booting
var PassportConfigurator = loopbackPassport.PassportConfigurator;
var passportConfigurator = new PassportConfigurator(app);
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function(err) {
if (err) throw err;
// start the server if `$ node server.js`
if (require.main === module)
app.start();
});
//
// - - - - - THIRD PARTY AUTH CONFIG - - - - - -
//
// authorisation providers configuration
// this section informs loopback of available providers via the
// providers.json file at the backend root
// var PassportConfigurator = loopbackPassport.PassportConfigurator;
// var passportConfigurator = new PassportConfigurator(app);
// Build the providers/passport config
// var config = {};
app.set("ms_name", 'image');
app.set("awsAccessKey", process.env.AWS_ACCESS_KEY);
app.set("awsSecretKey", process.env.AWS_SECRET_KEY)
boot(app, __dirname, (err) => {
if (err) throw err;
app.start = function () {
const httpServer = http.createServer(app).listen(http_port, () => {
app.emit('started');
app.close = function (done) {
app.removeAllListeners('started');
app.removeAllListeners('loaded');
if (app.registry) {
debug('Leave etcd ...');
app.registry.leave(app.get('ms_name'));
}
if (app.rabbit) {
debug('Close rabbit...');
app.rabbit.closeAll();
}
httpServer.close(done);
};
process.on('SIGINT', app.close);
});
};
if (require.main === module)
app.start();
app.loaded = true;
app.emit('loaded');
});
try {
config = require('../providers.json');
} catch (err) {
console.trace(err);
process.exit(1); // fatal
}
// -- Add your pre-processing middleware here --
// Setup the view engine (jade)
var path = require('path');
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
// boot scripts mount components like REST API
boot(app, __dirname);
// to support JSON-encoded bodies
app.middleware('parse', bodyParser.json());
// to support URL-encoded bodies
app.middleware('parse', bodyParser.urlencoded({
extended: true
}));
// The access token is only available after boot
app.middleware('auth', loopback.token({
model: app.models.accessToken
}));
app.middleware('session:before', loopback.cookieParser(app.get('cookieSecret')));
app.middleware('session', loopback.session({
boot(app, __dirname, function(err) {
if (err) throw err;
app.set('view engine', 'ejs');
app.set('views', path.join(__dirname, 'views'));
// Set up login/logout forms
app.get('/login', site.loginForm);
app.oauth2 = app._oauth2Handlers; // For testing
var isMain = require.main === module;
app.start = function() {
var port = app.get('port');
var host = app.get('host');
var httpServer = http.createServer(app).listen(port, host, function() {
if (isMain)
printServerListeningMsg('http', host, port);
var httpsPort = app.get('https-port');
var httpsServer = https.createServer(httpsOptions, app).listen(httpsPort,
host, function() {
if (isMain)
printServerListeningMsg('https', host, httpsPort);
app.emit('started');
app.close = function(cb) {
app.removeAllListeners('started');
app.removeAllListeners('loaded');
httpServer.close(function() {
httpsServer.close(cb);
});
};
});
});
};
if (isMain)
app.start();
app.loaded = true;
app.emit('loaded');
});
app.use(loopback.token({ model: app.models.accessToken, currentUserLiteral: 'me' }));
app.start = function start() {
// start the web server
return app.listen(() => {
app.emit('started');
const baseUrl = app.get('url').replace(/\/$/, '');
debug('Web server listening at: %s', baseUrl);
if (app.get('loopback-component-explorer')) {
const explorerPath = app.get('loopback-component-explorer').mountPath;
debug('Browse your REST API at %s%s', baseUrl, explorerPath);
}
if (app.get('loopback-component-model-diagram')) {
const modelDiagramPath = app.get('loopback-component-model-diagram').mountPath;
debug('Browse your entity relation diagram at %s%s', baseUrl, modelDiagramPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, (err) => {
if (err) throw err;
// start the server if `$ node server.js`
if (require.main === module) {
app.start();
}
});
let explorerPath = app.get('loopback-component-explorer').mountPath;
console.log('Browse your REST API at %s%s', baseUrl, explorerPath);
}
});
};
// Bootstrap the application, configure models, datasources and middleware.
// Sub-apps like REST API are mounted via boot scripts.
boot(app, __dirname, function(err) {
if (err) throw err;
// start the server if `$ node server.js`
if (require.main === module) {
// if WORKER_SCRIPT present, start it instead of api.
// 'worker' can be anything: websocket server, another http server, etc.
let scriptPath = process.env.WORKER_SCRIPT;
if (scriptPath) {
return startWorker(scriptPath, app);
} else {
app.start();
}
}
});
function startWorker(scriptPath, app) {
let worker;
scriptPath = path.join(__dirname, scriptPath);
console.log('Attempting to start worker|server at %s...', scriptPath);
try {
worker = require(scriptPath);
boot(app, __dirname, function(err) {
if (err) throw err;
//
// I would prefer that this code was somewhere else (../boot/passport.js ?)
// I think it could be important that the code is "after" boot, or at a specific point in boot.
// "work in progress" I follow the yellow brick road from googling...
//
// Passport configurators..
var loopbackPassport = require('loopback-component-passport');
var PassportConfigurator = loopbackPassport.PassportConfigurator;
var passportConfigurator = new PassportConfigurator(app);
/*
* body-parser is a piece of express middleware that
* reads a form's input and stores it as a javascript
* object accessible through `req.body`
*
*/
var bodyParser = require('body-parser');
/**
* Flash messages for passport
*
* Setting the failureFlash option to true instructs Passport to flash an
* error message using the message given by the strategy's verify callback,
* if any. This is often the best approach, because the verify callback
* can make the most accurate determination of why authentication failed.
*/
var flash = require('express-flash');
// attempt to build the providers/passport config
var config = {};
try {
config = require('../providers.json');
} catch (err) {
console.trace(err);
process.exit(1); // fatal
}
// Set up the /favicon.ico
app.use(loopback.favicon());
// request pre-processing middleware
app.use(loopback.compress());
// -- Add your pre-processing middleware here --
// Setup the view engine (jade)
var path = require('path');
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');
// boot scripts mount components like REST API
boot(app, __dirname);
// to support JSON-encoded bodies
app.use(bodyParser.json());
// to support URL-encoded bodies
app.use(bodyParser.urlencoded({
extended: true
}));
// The access token is only available after boot
app.use(loopback.token({
model: app.models.accessToken
}));
app.use(loopback.cookieParser(app.get('cookieSecret')));
app.use(loopback.session({
secret: 'kitty',
saveUninitialized: true,
resave: true
}));
passportConfigurator.init();
// We need flash messages to see passport errors
app.use(flash());
//console.log("NO setupModels at the moment");
passportConfigurator.setupModels({
userModel: app.models.user,
userIdentityModel: app.models.userIdentity,
userCredentialModel: app.models.userCredential
});
for (var s in config) {
var c = config[s];
c.session = c.session !== false;
passportConfigurator.configureProvider(s, c);
}
var ensureLoggedIn = require('connect-ensure-login').ensureLoggedIn;
app.get('/', function (req, res, next) {
res.render('pages/index', {user:
req.user,
url: req.url
});
});
app.get('/auth/account', ensureLoggedIn('/login.html'), function (req, res, next) {
res.render('pages/loginProfiles', {
user: req.user,
url: req.url
});
});
app.get('/link/account', ensureLoggedIn('/login.html'), function (req, res, next) {
res.render('pages/linkedAccounts', {
user: req.user,
url: req.url
});
});
app.get('/local', function (req, res, next){
res.render('pages/local', {
user: req.user,
url: req.url
});
});
app.get('/signup', function (req, res, next){
res.render('pages/signup', {
user: req.user,
url: req.url
});
});
app.post('/signup', function (req, res, next) {
var User = app.models.user;
var newUser = {};
newUser.email = req.body.email.toLowerCase();
newUser.username = req.body.username.trim();
newUser.password = req.body.password;
User.create(newUser, function (err, user) {
if (err) {
req.flash('error', err.message);
return res.redirect('back');
} else {
// Passport exposes a login() function on req (also aliased as logIn())
// that can be used to establish a login session. This function is
// primarily used when users sign up, during which req.login() can
// be invoked to log in the newly registered user.
req.login(user, function (err) {
if (err) {
req.flash('error', err.message);
return res.redirect('back');
}
return res.redirect('/auth/account');
});
}
});
});
app.get('/login', function (req, res, next){
res.render('pages/login', {
user: req.user,
url: req.url
});
});
app.get('/link', function (req, res, next){
res.render('pages/link', {
user: req.user,
url: req.url
});
});
app.get('/auth/logout', function (req, res, next) {
req.logout();
res.redirect('/');
});
// -- Mount static files here--
// All static middleware should be registered at the end, as all requests
// passing the static middleware are hitting the file system
// Example:
var path = require('path');
app.use(loopback.static(path.resolve(__dirname, '../client/public')));
// Requests that get this far won't be handled
// by any middleware. Convert them into a 404 error
// that will be handled later down the chain.
app.use(loopback.urlNotFound());
// The ultimate error handler.
app.use(loopback.errorHandler());
// start the server if `$ node server.js`
if (require.main === module)
app.start();
});