function (err) {
if (err) {
return console.log('Error: failed initialization while authing/selecting a redis DB ', err);
}
nohm.setClient(nohm_redis_client);
nohm.setPrefix(config.nohm.prefix);
cb();
}
io.sockets.on('connection', function(socket) {
console.log('Socket ' + socket.id + ' connected.');
nohm.setPrefix('bugio:io:');
nohm.setClient(client);
socket.on('message', function(message) { // receive and save a message
if(!socket.userid)
return socket.send(false, message, 'Login required.');
message.sender = socket.userid;
message.recipients = message.recipients.filter(function(r) { return !!r; });
message.ccs = (message.ccs || []).join('').split('');
var msg = nohm.factory('Message');
msg.p(message);
msg.save(function(err) {
if(err == 'invalid')
socket.emit('validation_failed', msg.errors);
else if(err)
socket.emit('validation_failed', err);
else {
var deliveries = message.recipients.concat(message.ccs);
deliveries.forEach(function(delivery) { // alert every recipient about the new message
if(parseInt(delivery) > 0)
socket.broadcast.to('user/' + delivery).emit('new_message', message);
});
socket.send(true, message); // inform myself about the new message
}
});
});
socket.on('login', function(data) {
var cookies = cookie.parse(socket.handshake.headers.cookie);
var sessid = cookies[cookie_id];
client.get('bugio:session:' + sessid, function(err, value) {
if(!value)
return socket.emit('login', false);
var storedCookie = JSON.parse(value);
socket.userid = storedCookie['warden.user.user.key'][0][0];
socket.join('user/' + socket.userid);
return socket.emit('login', true);
});
});
socket.on('disconnect', function(details) {
console.log('Socket ' + socket.id + ' disconnected: ' + details + '.');
});
});
return function (req, res, next){
var id = req.param(param_name);
var model = nohm.factory(model_name);
if ( ! req.loaded) {
req.loaded = {};
}
var _load = function (id) {
model.load(id, function (err) {
if (err) {
next(new loadModelError('not_found', 404));
} else {
req.loaded[model_name] = model;
next();
}
});
};
if (id && !do_string_search) {
_load(id);
} else if (id && do_string_search) {
model.find({name:id}, function (err, ids) {
if (err || ids.length === 0) {
next(new loadModelError('not_found', 404));
} else if (ids.length > 1) {
next(new loadModelError('multiple_matches', 400));
} else {
_load(ids[0]);
}
});
} else {
next(new loadModelError('needs_id_param', 400));
}
}
function(email, password, done) {
var user = Nohm.factory('User');
user.getByEmail(email, function(err, userRecord) {
if (err) return done(null, false, { message : err });
return done(null,userRecord);
});
}
redis.select(config.nohm.db || 0, function (err) {
if (err) {
console.log('problem selecting the redis db');
process.exit(1);
}
Nohm.purgeDb(callback);
});
post : function (req, res, next) {
var user = Nohm.factory('User');
user.p('email', req.param('email'));
user.p('password', req.param('password'));
user.save(function (err) {
if (err) {
//build an error parser for errors in user.errors for more granular errors
console.log('Error registering : %s', util.inspect(user.errors));
res.render('register', {
title : 'Register',
err : 'Looks like Your Form Data Was Invalid, Try Again'
});
} else {
//Authenticate the current session if registration succeeds
passport.authenticate('newUser', function(err, user, info) {
if (err) return next(err);
if (!user) return res.redirect('/login');
req.logIn(user, function(err) {
if (err) return next(err);
return res.redirect('/home');
});
})(req, res, next);
}
});
}
async.each(selection_items_ids, function(selection_item_id, callback) {
var BaseItem = models.BaseItem;
nohm.factory("BaseItem", selection_item_id, function() {
selection_items_data.push(this.allProperties());
callback();
});
}, function(err) {
async.each(selections_ids, function(selection_id, callback) {
var Selection = models.Selection;
nohm.factory("Selection", selection_id, function() {
selection_data.push(this);
callback();
});
}, function(err) {
function Sale() {
var order = nohm.factory('Order');
var now = new Date();
order.p({ orderDate: now });
order.link(offer4blue, 'offer');
order.save(function(err) { console.log("Saved blude order"); });
}
episodes.forEach(function (ep) {
ep = nodeToJson(ep);
if (seasons.indexOf(ep.SeasonNumber) === -1) {
seasons.push(ep.SeasonNumber);
}
if (ep.EpisodeNumber) {
var episode_model = nohm.factory('Episode');
episode_model.p({
tvdb_id: ep.id,
imdb_id: ep.IMDB_ID,
name: ep.EpisodeName,
number: ep.EpisodeNumber,
first_aired: ep.FirstAired,
plot: ep.Overview,
season: ep.SeasonNumber
});
show.link(episode_model, {
error: function (err, errors, episode) {
console.log('link_error', err, errors, episode.allProperties());
}
});
show.link(episode_model, {
name: 'season'+ep.SeasonNumber,
error: function (err, errors, episode) {
console.log('season link_error', err, errors, episode.allProperties());
}
});
}
});
socket.on('message', function(message) { // receive and save a message
if(!socket.userid)
return socket.send(false, message, 'Login required.');
message.sender = socket.userid;
message.recipients = message.recipients.filter(function(r) { return !!r; });
message.ccs = (message.ccs || []).join('').split('');
var msg = nohm.factory('Message');
msg.p(message);
msg.save(function(err) {
if(err == 'invalid')
socket.emit('validation_failed', msg.errors);
else if(err)
socket.emit('validation_failed', err);
else {
var deliveries = message.recipients.concat(message.ccs);
deliveries.forEach(function(delivery) { // alert every recipient about the new message
if(parseInt(delivery) > 0)
socket.broadcast.to('user/' + delivery).emit('new_message', message);
});
socket.send(true, message); // inform myself about the new message
}
});
});
passport.deserializeUser(function (id, done) {
var user = Nohm.factory('User');
user.load(id, function (err, properties) {
if (err) {
done (err,properties);
} else {
done(null, this.allProperties());
}
});
});
redis.on('ready', function () {
Nohm.setClient(redis);
redis.select(config.nohm.db || 0, function (err) {
if (err) {
console.log('problem selecting the redis db');
process.exit(1);
}
Nohm.purgeDb(callback);
});
});
async.filter(episode_ids, function (id, cb) {
nohm.factory('Episode').find({
tvdb_id: id
}, function (err, ids) {
if (err) {
throw err;
}
cb(ids.length !== 0);
});
}, function (ids) {
findById: function(id, callback) {
var foundUser = nohm.factory('User', id, function (err) {
if (err === 'not found') {
callback(err, null);
} else if (err) {
callback(err, null);
} else {
callback(null, foundUser.allProperties());
}
});
},
async.every(ids, function (id, next) {
if (id === self.id) {
next(true);
} else {
var episode = nohm.factory('Episode');
episode.id = id;
episode.getSeen(user, function (err, seen) {
next(!err && seen);
});
}
}, function (result) {
redisClient.on("connect", function () {
nohm.setClient(redisClient);
console.log("Nohm Connected to Redis Client");
//createUser();
// testSaveSameUser();
// testFindUser('tome2222');
// testFindAndLoad('tomsse2');
// testFindAndLoad('tome4');
//testSignIn();
testFindUserById(100);
});
module.exports.findUser = function(userId, callback) {
var foundUser = nohm.factory('User', userId, function (err) {
if (err === 'not found') {
console.log('no user with id ' + userId + ' found :-(');
} else if (err) {
console.log(err); // database or unknown error
}
callback(err, foundUser);
});
}
this.getAll('Show', 'defaultForeign', function (err, ids) {
if (err) {
callback(err);
} else {
var show = nohm.factory('Show', ids[0], function (err) {
if (err) {
callback(err);
} else {
callback(null, show);
}
});
}
});
return new Promise(function(resolve, reject) {
var rfid = Nohm.factory('Rfid', id, function (err) {
if (err) {
reject({
type: 'INTERNAL',
message: 'Failed to load Rfid with id: ' + id
});
}
else {
resolve(rfid);
}
})
});
importSeries: function (id, language, callback) {
var self = this;
var show = nohm.factory('Show');
if (typeof (language) === 'function') {
callback = language;
language = 'en';
}
id = parseInt(id, 10);
if (id > 0) {
show.find({
tvdb_id: ''+id
}, function (err, ids) {
if ( ! err && ids.length === 0) {
self._tvdbRequest('/series/'+id+'/all/'+language+'.zip', 'zip', function (err, documents) {
if (err) {
callback(err, show);
} else {
documents.forEach(function (doc) {
var name = doc.root().name();
switch (name) {
case 'Data':
fillShowFromDataXml(show, doc);
break;
case 'Banners':
getBannerFromDataXml(show, doc, id, language, self);
break;
}
});
show.save({
continue_on_link_error: true
}, function (err, linkage_error, link_name) {
if (err && linkage_error) {
console.log('TVDB Error: while importing the linking of an episode failed for this relation:', link_name);
}
callback(err, show);
});
}
});
} else if (err) {
callback(err, show);
} else {
show.load(ids[0], function (err) {
callback(err, show);
});
}
});
} else {
console.log('Called tvdbModel.importSeries with invalid id', arguments[0]);
return callback('invalid id');
}
},
pagesController.index = function() {
var self = this;
self.user = self.req.user;
Nohm.factory('Controller').read({}, function(err, controllers) {
if (err && err !== 'not found') {
self.res.status(400);
}
self.controllers = controllers;
self.render();
});
}
app.post('/User/', async function(req, res, next) {
try {
const data = {
name: req.body.name,
password: req.body.password,
email: req.body.email,
};
const user = await Nohm.factory('User'); // alternatively new UserModel(); like in put
await user.store(data);
res.json({ result: 'success', data: user.safeAllProperties() });
} catch (err) {
next(err);
}
});
store: function(props, done){
var code = nohm.factory('AccessToken');
code.p(props);
code.save(function (err) {
if (err === 'invalid') {
console.log('properties were invalid: ');
done(code.errors, null)
} else if (err) {
console.log(err);
done(err, null)
} else {
done(null, code);
}
});
}
authController.register = function() {
var self = this,
options = {},
model = Nohm.factory('User');
model.getCreateFields().forEach(function(field) {
options[field] = self.param(field);
});
model.create(options, function (err) {
var user = this;
self.req.logIn(user, function(err) {
self._callback(err, user.allProperties());
});
});
}
async.forEachLimit(documents[0].find('/Data/Series'), 10, function (node, cb) {
if ( ! checkTime(node)) {
cb();
} else {
nohm.factory('Show').find({
tvdb_id: ''+node.get('id').text()
}, function (err, ids) {
if (ids.length === 0) {
cb();
} else if (err) {
cb(err);
} else {
self.updateSeries(ids[0], episode_ids, cb);
}
});
}
}, done);
post : function (req, res, next) {
var user = Nohm.factory('User');
user.p('email', req.param('email'));
user.p('password', req.param('password'));
user.save(function (err) {
if (err) {
console.log('Error registering : %s', user.errors);
res.render('register', {
title : 'Register',
err : user.errors
});
} else {
res.redirect('/login');
}
});
}
server.use(function (req, res, next) {
res.ok = function (data, meta) {
data = data || {};
res.json({result: 'success', data: data, meta: meta});
};
//console.log(req.method, req.url);
req.loaded = {};
req.user = nohm.factory('User');
if ( req.session.userdata && ! isNaN(req.session.userdata.id)) {
req.user.load(req.session.userdata.id, function (err) {
if (err) {
req.session.logged_in = false;
req.session.userdata = undefined;
}
next();
});
} else {
next();
}
});
.then(function(rfidObj) {
if (rfidObj) {
reject({
type: 'EXIST',
message: 'Rfid ' + rfid + ' already exists'
});
} else {
var rfidModel = Nohm.factory('Rfid');
rfidModel.store({
rfid: rfid,
creationTime: new Date().toString()
}, function (err) {
if (err) {
reject({
type: 'INTERNAL',
message: 'Failed to create Rfid ' + rfid
});
} else {
resolve(rfidModel.allProperties());
}
});
}
})
var redis = require('redis').createClient();
// CONFIGURATION ///////////////////////////////////////////////////////////////
var TOPICS_AMOUNT = 100; // Amount of topics
var POSTS_AMOUNT = 1000; // Amount of posts per topic to create
var KWORDS_AMOUNT = 10; // Amount of keywords
var WORDS_AMOUNT = 200; // Amount of words in post body
// INIT ////////////////////////////////////////////////////////////////////////
nohm.setClient(redis);
// HELPER FUNCTIONS ////////////////////////////////////////////////////////////
var RND_COUNTER = Date.now();
var DOT_COUNTER = [0, 0];
function rnd() {
RND_COUNTER += 1;
return RND_COUNTER;
}