Merge remote-tracking branch 'origin/master' into webserver.js-refactor

src/categories.js

@@ -168,7 +168,7 @@ var db = require('./database'),
 				return callback(err);
 			}
 
-			if (!cids || (cids && cids.length === 0)) {
+			if (!Array.isArray(cids) || !cids.length) {
 				return callback(null, {categories : []});
 			}
 
@@ -213,9 +213,7 @@ var db = require('./database'),
 			sets.push('cid:' + cids[i] + ':read_by_uid');
 		}
 
-		db.isMemberOfSets(sets, uid, function(err, hasRead) {
-			callback(hasRead);
-		});
+		db.isMemberOfSets(sets, uid, callback);
 	};
 
 	Categories.hasReadCategory = function(cid, uid, callback) {
@@ -279,16 +277,32 @@ var db = require('./database'),
 	};
 
 	Categories.getCategoryData = function(cid, callback) {
-		db.exists('category:' + cid, function(err, exists) {
-			if (exists) {
-				db.getObject('category:' + cid, function(err, data) {
-					data.background = data.image ? 'url(' + data.image + ')' : data.bgColor;
-					data.disabled = data.disabled ? parseInt(data.disabled, 10) !== 0 : false;
-					callback(err, data);
-				});
-			} else {
-				callback(new Error('No category found!'));
+		Categories.getCategoriesData([cid], function(err, categories) {
+			callback(err, categories ? categories[0] : null);
+		});
+	};
+
+	Categories.getCategoriesData = function(cids, callback) {
+		var keys = cids.map(function(cid) {
+			return 'category:'+cid;
+		});
+
+		db.getObjects(keys, function(err, categories) {
+			if (err) {
+				return callback(err);
+			}
+
+			if (!Array.isArray(categories)) {
+				return callback(null, []);
 			}
+
+			for (var i=0; i<categories.length; ++i) {
+				if (categories[i]) {
+					categories[i].background = categories[i].image ? 'url(' + categories[i].image + ')' : categories[i].bgColor;
+					categories[i].disabled = categories[i].disabled ? parseInt(categories[i].disabled, 10) !== 0 : false;
+				}
+			}
+			callback(null, categories);
 		});
 	};
 
@@ -309,38 +323,31 @@ var db = require('./database'),
 	};
 
 	Categories.getCategories = function(cids, uid, callback) {
-		if (!cids || !Array.isArray(cids) || cids.length === 0) {
-			return callback(new Error('invalid-cids'));
-		}
-
-		function getCategory(cid, callback) {
-			Categories.getCategoryData(cid, function(err, categoryData) {
-				if (err) {
-					winston.warn('Attempted to retrieve cid ' + cid + ', but nothing was returned!');
-					return callback(err);
-				}
 
-				Categories.hasReadCategory(cid, uid, function(hasRead) {
-
-					categoryData['unread-class'] = (parseInt(categoryData.topic_count, 10) === 0 || (hasRead && parseInt(uid, 10) !== 0)) ? '' : 'unread';
-
-					callback(null, categoryData);
-				});
-			});
+		if (!Array.isArray(cids) || cids.length === 0) {
+			return callback(new Error('invalid-cids'));
 		}
 
-		async.map(cids, getCategory, function(err, categories) {
+		async.parallel({
+			categories: function(next) {
+				Categories.getCategoriesData(cids, next);
+			},
+			hasRead: function(next) {
+				Categories.hasReadCategories(cids, uid, next);
+			}
+		}, function(err, results) {
 			if (err) {
 				return callback(err);
 			}
 
-			categories = categories.filter(function(category) {
-				return !!category;
-			});
+			var categories = results.categories;
+			var hasRead = results.hasRead;
+			uid = parseInt(uid, 10);
+			for(var i=0; i<results.categories.length; ++i) {
+				categories[i]['unread-class'] = (parseInt(categories[i].topic_count, 10) === 0 || (hasRead[i] && uid !== 0)) ? '' : 'unread';
+			}
 
-			callback(null, {
-				'categories': categories
-			});
+			callback(null, {categories: categories});
 		});
 	};
 

src/database/redis.js

@@ -223,7 +223,7 @@
 	module.getObjectFields = function(key, fields, callback) {
 		redisClient.hmget(key, fields, function(err, data) {
 			if(err) {
-				return callback(err, null);
+				return callback(err);
 			}
 
 			var returnData = {};

src/groups.js

@@ -1,7 +1,9 @@
+'use strict';
+
 (function(Groups) {
-	"use strict";
 
 	var async = require('async'),
+		winston = require('winston'),
 		user = require('./user'),
 		db = require('./database');
 
@@ -34,7 +36,7 @@
 
 		async.map(systemGroups, function(groupName, next) {
 			Groups.getByGroupName(groupName, options, function(err, groupObj) {
-				groupObj['name'] = humanNames[systemGroups.indexOf(groupObj['name'])];
+				groupObj.name = humanNames[systemGroups.indexOf(groupObj.name)];
 				next(err, groupObj);
 			});
 		}, callback);
@@ -52,11 +54,8 @@
 							return next(err);
 						}
 
-						async.map(uids, function (uid, next) {
-							user.getUserData(uid, next);
-						}, function (err, users) {
-							next(err, users);
-						});
+						async.map(uids, user.getUserData, next);
+
 					} else {
 						next(err, uids);
 					}
@@ -155,7 +154,7 @@
 					callback(null, result);
 				});
 			});
-		})
+		});
 	};
 
 	Groups.isEmpty = function(gid, callback) {
@@ -230,16 +229,16 @@
 		db.exists('gid:' + gid, function (err, exists) {
 			if (!err && exists) {
 				// If the group was renamed, check for dupes, fix the assoc. hash
-				if (values['name']) {
-					Groups.exists(values['name'], function(err, exists) {
+				if (values.name) {
+					Groups.exists(values.name, function(err, exists) {
 						if (!exists) {
 							Groups.get(gid, {}, function(err, groupObj) {
 								if (err) {
 									return callback(new Error('group-not-found'));
 								}
 
-								db.deleteObjectField('group:gid', groupObj['name']);
-								db.setObjectField('group:gid', values['name'], gid);
+								db.deleteObjectField('group:gid', groupObj.name);
+								db.setObjectField('group:gid', values.name, gid);
 								db.setObject('gid:' + gid, values, callback);
 							});
 						} else {
@@ -332,40 +331,4 @@
 		});
 	};
 
-	Groups.getCategoryAccess = function(cid, uid, callback){
-		var access = false;
-		// check user group read access level
-		async.series([function(callback){
-			// get groups with read permission
-			db.getObjectField('group:gid', 'cid:' + cid + ':privileges:g+r', function(err, gid){
-				// get the user groups that belong to this read group
-				db.getSetMembers('gid:' + gid + ':members', function (err, gids) {
-					// check if user belong to any of these user groups
-					var groups_check = new Array();
-					gids.forEach(function(cgid){
-						groups_check.push(function(callback){
-							Groups.isMember(uid, cgid, function(err, isMember){
-								if (isMember){
-									access = true;
-								}
-								callback(null, gids);
-							})
-						});
-					});
-					// do a series check. We want to make sure we check all the groups before determining if the user
-					// has access or not.
-					async.series(groups_check, function(err, results){
-						callback(null, results);
-					});
-				});
-			});
-
-		}],
-		function(err, results){
-			// if the read group is empty we will asume that read access has been granted to ALL
-			if (results[0].length == 0){ access = true; }
-			callback(false, access);
-		});
-	};
-
 }(module.exports));

src/socket.io/topics.js

@@ -261,9 +261,7 @@ SocketTopics.loadMore = function(socket, data, callback) {
 			privileges: function(next) {
 				threadTools.privileges(data.tid, socket.uid, next);
 			}
-		}, function(err, results) {
-			callback(err, results);
-		});
+		}, callback);
 	});
 };