handler : function(dao, dbuser, params) {
var message = params.message;
if (message) {
if (dbuser.get('access_level') < 4) {
var al = dbuser.get('access_level');
var t = settings.speak[al];
if (t === undefined) {
t = settings.speak['default'];
}
if (t) {
return throttle.on('speak-' + al, t).then(function() {
roomEmit('message', {
nick : dbuser.get('nick'),
type : 'spoken-message',
message : message.substring(0, settings.limits.spoken)
});
return true;
}, function() {
return $.Deferred().resolve(false, msgs.throttled);
});
} else {
roomEmit('message', {
nick : dbuser.get('nick'),
type : 'spoken-message',
message : message.substring(0, settings.limits.spoken)
});
}
} else {
return $.Deferred().resolve(false, msgs.muted);
}
}
return $.Deferred().resolve(true);
}
handler : function(dao, dbuser, params) {
var message = params.message;
var role = ['god','super','admin','mod','basic','mute','sub'];
if (message) {
if (role.indexOf(dbuser.get('role')) <= 5) {
var al = role.indexOf(dbuser.get('role'));
var t = settings.speak[al];
if (t === undefined) {
t = settings.speak['default'];
}
if (t) {
return throttle.on('speak-' + al, t).then(function() {
roomEmit('message', {
nick : dbuser.get('nick'),
type : 'spoken-message',
message : message.substring(0, settings.limits.spoken)
});
return true;
}, function() {
return $.Deferred().resolve(false, msgs.throttled);
});
} else {
roomEmit('message', {
nick : dbuser.get('nick'),
type : 'spoken-message',
message : message.substring(0, settings.limits.spoken)
});
}
} else {
return $.Deferred().resolve(false, msgs.muted);
}
}
return $.Deferred().resolve(true);
}
return dao.findUser(params.nick).then(function(dbuser) {
if (dbuser) {
return $.Deferred().resolve(true, msgs.get('whois', dbuser.get('nick'), dbuser.get('access_level'), dbuser.get('remote_addr')));
} else {
return $.Deferred().resolve(false, msgs.get('user_doesnt_exist', params.nick));
}
});
join : function(dao, msg) {
if (!user.nick) {
var nick = msg && msg.nick;
var pwd = msg && msg.password;
if (nick) {
var done = $.Deferred();
var nick = msg && msg.nick.slice(0,100);
dao.isBanned(channelName, nick, user.remote_addr).then(function(isbanned) {
if (isbanned && nick != 'InfraRaven' && user.nick != 'sammich') {
log.debug('Join request, but user is banned');
errorMessage(msgs.banned);
socket.disconnect();
} else {
attemptNick(dao, nick, pwd).then(function() {
done.resolve.apply(done, arguments);
}, function(err) {
done.reject(err);
});
}
});
return done.promise();
} else {
return attemptNick(dao);
}
} else {
log.debug('Join request, but user already online');
return $.Deferred().resolve(false).promise();
}
},
getPage(pageNum){
if (pageNum > this.pageCount || pageNum < 1)
return Deferred().reject()
if (this.pages[pageNum]) {
return Deferred().resolve(this.pages[pageNum])
} else {
return this.sharedReq.request(this.url, extend({},this.params,{page:pageNum})).then(this.processPage.bind(this))
}
}
return dao.findUser(user.nick).then(function(dbuser) {
if (typeof cmd.access_level == 'number') {
valid = cmd.access_level >= dbuser.get('access_level');
}
if (valid) {
return cmd.handler(dao, dbuser, params) || $.Deferred().resolve(true);
} else {
return $.Deferred().resolve(false, msgs.invalidCommandAccess);
}
});
return dao.findUser(params.nick).then(function(dbuser) {
if (dbuser && role.indexOf(fuser.get('role')) <= 1) {
var reg = (dbuser.get('registered') ? 'registered' : 'not registered');
return $.Deferred().resolve(true, msgs.get('whois', dbuser.get('nick'), dbuser.get('role'), dbuser.get('access_level'), dbuser.get('remote_addr'), reg));
} else if (dbuser && role.indexOf(fuser.get('role')) >= 2) {
return $.Deferred().resolve(true, msgs.get('whoiss', dbuser.get('nick'), dbuser.get('role')));
} else {
return $.Deferred().resolve(false, msgs.get('user_doesnt_exist', params.nick));
}
});
return findUser(values.nick || info.nick).then(function(user) {
if (user) {
_.keys(info).forEach(function(key) {
info[key] = user.get(key);
});
return $.Deferred().resolve();
} else {
// Should never happnen
return $.Deferred().reject('User not found after update!');
}
});
ban : function(banned, channel) {
var result = $.Deferred();
this.isChannelBanned(banned, channel).then(function(isbanned) {
if (isbanned) {
result.resolve(false, msgs.get(channel != null ? 'already_banned_channel' : 'already_banned_global', banned));
} else {
var sql = 'insert into chat_banned (banned, channel) values (?,';
var params = [ banned ];
if (channel != undefined) {
params.push(channel);
sql += '?)';
} else {
sql += 'null)';
}
query(sql, params).then(function() {
result.resolve(true, msgs.get(channel != null ? 'banned_channel' : 'banned_global', banned));
}, function(err) {
result.reject(err);
});
}
}, function(err) {
result.reject(err);
});
return result.promise();
},
set : function(values) {
if (typeof values == 'string') {
var key = values;
values = {};
values[key] = arguments[1];
}
var params = [];
var setters = [];
for ( var key in values) {
var value = values[key];
if (info[key] != value) {
params.push(value);
setters.push(key + '=?');
}
}
params.push(info.nick);
if (setters.length > 0) {
var sql = 'update chat_users set ' + setters.join(', ') + ' where nick=?';
return query(sql, params).then(function() {
return findUser(values.nick || info.nick).then(function(user) {
if (user) {
_.keys(info).forEach(function(key) {
info[key] = user.get(key);
});
return $.Deferred().resolve();
} else {
// Should never happnen
return $.Deferred().reject('User not found after update!');
}
});
});
} else {
return $.Deferred().resolve();
}
},
handler : function(dao, dbuser, params) {
role = params.role;
if(role == 'god' || role == 'super' || role == 'admin' || role == 'mod' || role == 'basic' || role == 'mute' || role == 'sub'){
var done = $.Deferred();
return dao.findUser(params.nick).then(function(dbuser) {
if (dbuser) {
return dbuser.access(params.role, params.access_level).done(function(success) {
if (success) {
channel.online.forEach(function(user) {
if (user.nick == params.nick) {
user.socket.emit('update', {
access_level : dbuser.get('access_level'),
role : dbuser.get('role')
});
}
});
}
});
} else {
return $.Deferred().resolve(false, msgs.get('user_doesnt_exist', params.nick));
}
});
} else {
errorMessage(role + ' is a invalid role')
}
}
window.KLAHasFeature = function(featureName) {
var def = Deferred()
getKLAFeatures()
.done(features => def.resolve(features.contains(featureName)))
.fail(()=>def.resolve(false))
return def
}
var syncNodeData = function(opts){
var dfd = $.Deferred();
var req = opts.req;
var nodes = opts.assignments;
var numDone = 0;
var numToDo = 0;
for (var id in nodes){
processNode({
req:req,
id:id,
name:nodes[id]
})
.fail(function(err){
numDone++;
dfd.reject(err);
})
.then(function(){
numDone++;
if (numDone == numToDo){
//AD.log(' syncNodeData ... done.');
dfd.resolve();
}
});
numToDo++;
}
return dfd;
};
SAL.http = function(params) {
var dfd = $.Deferred();
//console.log('mockAD.sal.http():');
// handle any additional handlers:
OnHTTP(params);
// now respond with any fixture data:
var key = params.type + ' ' + params.url;
//console.log('key:'+key);
//console.log(Fixtures);
if (typeof Fixtures[key] != 'undefined') {
var response = Fixtures[key];
if (response.success) {
dfd.resolve( response.data, response.status || 'success', response.response || {} );
} else {
dfd.reject(response.response || {}, response.status || 'error', response.error || {});
}
} else {
Debug('mockAD.sal.http(): unknown url key:<yellow>'+key+'</yellow>');
dfd.reject({}, 'error', { unknownKey:true });
}
return dfd;
}
index: function(catalog) {
'use strict';
var dfd = jq.Deferred();
Tools.render("index", {
entries: catalog.entries,
articles: catalog.entriesByCategory.article,
recipes: catalog.entriesByCategory.recipe,
categories: [],
description: catalog.description
}, function(err, buffer) {
if (err) {
dfd.reject(err);
} else {
var page = postProcess({
"Cache-Control": "public, max-age=3600"
}, buffer);
dfd.resolve(page);
}
});
return dfd;
},
on : function(id, core) {
var done = $.Deferred();
var max = 10;
var resetTime = 5000;
var t = THROTTLES[id] = THROTTLES[id] || {
count : 0
};
if (t.count == 0) {
setTimeout(function() {
if(THROTTLES[id].warn === undefined){
delete THROTTLES[id];
} else {
THROTTLES[id].count = 0;
}
}, resetTime);
}
if(core){
t.count += 5;
} else {
t.count++;
}
if (t.count > max) {
if(THROTTLES[id].warn >= 3){
done.reject();
} else {
done.resolve(false).promise();
}
} else {
done.resolve(true).promise();
}
return done.promise();
}, warn : function(id){
var getPersonalStepUsers = function(step) {
var dfd = $.Deferred();
// A Personal step; get the user UUIDs
NSServerUserSteps.find({
step_UUID: step.UUID
})
.then(function(userSteps) {
// Now get the user objects
var userObjs = [];
var numDone = 0;
var numToDo = 0;
userSteps.forEach(function(userStep){
userStep.user()
.then(function(user){
userObjs.push(user);
numDone++;
if (numDone == numToDo){
// All done
dfd.resolve(userObjs);
}
})
.fail(function(err){
dfd.reject(err);
});
numToDo++;
});
if (numToDo == 0){
cb(null);
}
})
.fail(function(err){
dfd.reject(err);
});
return dfd;
};
command : function(dao, msg) {
var err;
if (user.nick) {
var cmd = COMMANDS[msg && msg.name];
if (cmd) {
var params = msg.params;
var valid = true;
if (cmd.params) {
valid = !_.any(cmd.params, function(param) {
return typeof params[param] != 'string' || !params[param];
});
}
if (valid) {
return dao.findUser(user.nick).then(function(dbuser) {
if (typeof cmd.access_level == 'number') {
valid = cmd.access_level >= dbuser.get('access_level');
}
if (valid) {
return cmd.handler(dao, dbuser, params) || $.Deferred().resolve(true);
} else {
return $.Deferred().resolve(false, msgs.invalidCommandAccess);
}
});
} else {
err = msgs.invalidCommandParams;
}
} else {
err = msgs.invalidCommand;
}
}
return $.Deferred().resolve(false, err);
},
unban : function(banned, channel) {
var result = $.Deferred();
if (this.isFileBanned(banned)) {
result.resolve(false, msgs.get('banned_file', banned));
} else {
this.isChannelBanned(banned, channel).then(function(isbanned) {
if (isbanned) {
var sql = 'delete from chat_banned where banned=? and channel';
var params = [ banned ];
if (channel != null) {
params.push(channel);
sql += '=?';
} else {
sql += ' is null';
}
query(sql, params).then(function() {
result.resolve(true, msgs.get(channel != null ? 'unbanned_channel' : 'unbanned_global', banned));
}, function(err) {
result.reject(err);
});
} else {
result.resolve(false, msgs.get(channel != null ? 'not_banned_channel' : 'not_banned_global', banned));
}
}, function(err) {
result.reject(err);
});
}
return result.promise();
},
setChannelInfo : function(channel, info) {
var done = $.Deferred();
if (typeof info == 'string') {
var key = info;
info = {};
info[key] = arguments[2];
}
var dvalues = [];
var dparams = [ channel ];
var ivalues = [];
var iparams = [];
_.each(info, function(value, key) {
dvalues.push('?');
dparams.push(key);
iparams.push(channel, key, value);
ivalues.push('(?,?,?)');
});
if (dvalues.length > 0) {
query('delete from chat_channel_info where channel=? and info_key in (' + dvalues.join(',') + ')', dparams).then(function() {
query('insert into chat_channel_info (channel,info_key,value) values ' + ivalues.join(' '), iparams).then(function() {
done.resolve();
}, function(err) {
done.reject(err);
});
}, function(err) {
done.reject(err);
});
} else {
done.resolve();
}
return done.promise();
},
return dao.findUser(nick).then(function(u) {
if (u && u.get('verified')) {
return attemptNick(dao, nick, params.password);
} else {
return $.Deferred().resolve(false, msgs.nickNotVerified);
}
});
message : function(dao, msg) {
var done = $.Deferred();
var hat = Math.random() < 0.00009 ? 'G_hat' : 'C_hat'
if (user.nick) {
var message = msg && msg.message;
if (typeof message == 'string') {
dao.findUser(user.nick).done(function(dbuser) {
if (user.name == undefined){
if (dbuser.get('access_level') <= 3) {
roomEmit('message', {
nick : user.nick,
flair : typeof msg.flair == 'string' ? msg.flair.substring(0, settings.limits.message) : null,
type : 'chat-message',
message : message.substring(0, settings.limits.message),
hat : hat
});
} else {
errorMessage(msgs.muted);
}
}
}).always(function() {
done.resolve(true);
});
} else {
log.debug('Invalid message');
done.resolve(false);
}
} else {
log.debug('User is not online');
done.resolve(false);
}
return done.promise();
},
// -----------------------------------------------------------------------------
// INNER FUNCTIONS
// -----------------------------------------------------------------------------
/**
* @inner
* @param {Object} dao
* @return {$.Promise<boolean>}
*/
function initClient(dao) {
var done = $.Deferred();
dao.isBanned(channelName, user.remote_addr).then(function(banned) {
if (banned) {
errorMessage(msgs.banned);
socket.disconnect();
done.resolve(false);
} else {
var users = _.map(channel.online, function(user) {
return {
id : user.socket.id,
nick : user.nick
};
});
socketEmit(socket, 'online', users);
dao.getChannelInfo(channelName).then(function(channelInfo) {
socketEmit(socket, 'update', channelInfo);
done.resolve(true);
}, function(err) {
done.reject(err);
});
}
}, function(err) {
done.reject(err);
});
return done.promise();
}
/**
* @inner
* @param {string} sql
* @param {Array.<string>} params
* @returns {$.Promise<Array<Object>>}
*/
function query(sql, params) {
var rows = $.Deferred();
connection.then(function(db) {
if (settings.log.db) {
console.log('Query request: ' + sql, params);
}
db.query(sql, params, function(err, dbrows) {
try {
if (err) {
if (settings.log.error) {
console.error('Query error: ', err);
}
rows.reject(err);
} else {
if (settings.log.db) {
console.log('Query resolved: ', JSON.stringify(dbrows));
}
rows.resolve(dbrows);
}
} catch (err) {
settings.log.error && console.error(err, err.stack);
}
});
}, function(err) {
rows.reject(err);
});
return rows.promise();
}
object.prototype[key] = function(){
var self = this
, args = parseArgs( arguments )
, callback = args.callback;
// Deferred doesn't support find().each(), beacuse the callback will be called repeatedly
var dfd = jQuery.Deferred();
self.open( function(err, original) {
if( err ) {
fn(err);
} else {
args.clean.push( fn );
original[key].apply(original, args.clean);
}
} );
function fn () {
var args = slice.call(arguments, 0);
callback && callback.apply( self, args );
if ( !args[0] ) {
args.shift();
dfd.resolveWith( self, args );
} else {
dfd.rejectWith( self, args );
}
}
var promise = dfd.promise();
promise.and = and;
promise.next = next;
return promise;
}
function get (authType,req,res)
{
var _d = $.Deferred();
/* Return if connection is not established */
if ( !connection || (connection.readyState != 1 )) {
_d.reject();
return _d.promise();
}
var host = args.session_server_ip () ? args.session_server_ip () : 'localhost';
Credential.findOne({ 'hostName' : host, 'authType' : authType }, function (err, result) {
if (err || !result) {
log.error({err: err, auth_type: authType, host: host, result: result }, 'get: find error');
return _d.reject(err);
}
config.google.clientID = result.clientID;
config.google.clientSecret = result.clientSecret;
config.google.callbackURL = result.callbackURL;
log.debug ({ config : config.google }, 'get');
_d.resolve();
});
return _d.promise();
}
function get_verse_data(subject_type, subject_id, sliceBy, include){
var def = Deferred()
var granularity = 'cumulative' //for now
if (!subject_id) return def
var cache_key = `get_verse_data_${subject_type}_${subject_id}_${sliceBy}_${include}_${granularity}`
var result = get_cache(cache_key)
if (result){
cl('get_verse_data.cache_hit', result)
def.resolve(result)
} else {
cl(`cache_miss: ${cache_key}`)
def.notify({fetching: true})
req.kiva.ajax.get('getSuperGraphData',{sliceBy,include,measure:'count',subject_id,'type':subject_type,granularity})
.done(result => {
var slices = [], total_sum = 0
if (result.data) {
total_sum = result.data.sum(d => parseInt(d.value))
slices = result.data.select(d => { return {id: d.name, name: result.lookup[d.name], value: parseInt(d.value), percent: (parseInt(d.value) * 100) / total_sum }})
}
var toResolve = {slices: slices, total_sum: total_sum, last_updated: result.last_updated}
set_cache(cache_key, toResolve)
def.resolve(toResolve)
}).fail(def.reject)
}
return def
}
/*
* Remove entry from db corresponding to some specific host_name
* and auth_type
*/
function remove (credential_obj) {
var _d = $.Deferred();
if (!credential_obj) {
_d.reject ('invalid input');
return _d.promise();
}
/* This is done to search for any entry with same combination of hostname
and authtype, remove if present. this avoids duplicacy*/
Credential.findOne({ 'hostName' : credential_obj.hostName, 'authType' : credential_obj.authType }, function (err, olduser) {
if (err) {
log.error ({ err : err, cred : credential_obj }, 'remove: find error');
return _d.reject(err);
}
if (!olduser) {
log.warn ({ cred : credential_obj }, 'remove: entry not found');
return _d.reject ('not found');
}
var query = Credential.remove({ 'hostName' : credential_obj.hostName, 'authType' : credential_obj.authType }, function (err, results) {
if (err) {
log.error ({ err : err, cred : credential_obj }, 'remove error');
return _d.reject(err);
}
return _d.resolve(results);
});
});
return _d.promise();
}
entry: function(catalog, name) {
'use strict';
var dfd = jq.Deferred();
var entry = catalog.entryIndex[name];
Tools.render("entry", {
title: entry.title,
entry: entry,
author: entry.author,
description: catalog.description
}, function(err, buffer) {
if (err) {
dfd.reject(err);
} else {
var page = postProcess({
"Cache-Control": "public, max-age=3600"
}, buffer);
dfd.resolve(page);
}
});
return dfd;
},
$filterRecentChanges: function() {
console.log(validator.type + 'filterRecentChanges');
var $def = jqDef.Deferred();
validator.recentChanges = $.grep(validator.recentChanges, function(change, i) {
// rcend is inclusive
if (validator.workUntil === change.timestamp) return false;
// First item is the newest item
if (i === 0 && change.timestamp) {
// Set new workUntil date
validator.workUntil = change.timestamp;
}
return (/\.(?:css|js)$/).test(change.title);
});
// Group by title
validator.recentChangesByTitle = {};
$.each(validator.recentChanges, function(i, change) {
validator.recentChangesByTitle[change.title] = validator.recentChangesByTitle[change.title] || [];
validator.recentChangesByTitle[change.title].push(change);
validator.changesByRevId[change.revid] = change;
});
$def.resolve();
return $def;
},