diff --git a/src/groups.js b/src/groups.js
index 0c667c9871..17d39c413b 100644
--- a/src/groups.js
+++ b/src/groups.js
@@ -2,8 +2,6 @@
 
 var async = require('async'),
 	winston = require('winston'),
-	_ = require('underscore'),
-	crypto = require('crypto'),
 	path = require('path'),
 	nconf = require('nconf'),
 	fs = require('fs'),
@@ -16,15 +14,16 @@ var async = require('async'),
 	posts = require('./posts'),
 	privileges = require('./privileges'),
 	utils = require('../public/src/utils'),
-	util = require('util'),
-
-	uploadsController = require('./controllers/uploads');
+	util = require('util');
 
 (function(Groups) {
 
 	require('./groups/create')(Groups);
 	require('./groups/delete')(Groups);
 	require('./groups/update')(Groups);
+	require('./groups/membership')(Groups);
+	require('./groups/ownership')(Groups);
+	require('./groups/search')(Groups);
 
 	var ephemeralGroups = ['guests'],
 
@@ -70,6 +69,8 @@ var async = require('async'),
 			}
 		};
 
+	Groups.internals = internals;
+
 	var isPrivilegeGroupRegex = /^cid:\d+:privileges:[\w:]+$/;
 	Groups.isPrivilegeGroup = function(groupName) {
 		return isPrivilegeGroupRegex.test(groupName);
@@ -330,144 +331,6 @@ var async = require('async'),
 		});
 	};
 
-	Groups.getMembers = function(groupName, start, stop, callback) {
-		db.getSortedSetRevRange('group:' + groupName + ':members', start, stop, callback);
-	};
-
-	Groups.getMembersOfGroups = function(groupNames, callback) {
-		db.getSortedSetsMembers(groupNames.map(function(name) {
-			return 'group:' + name + ':members';
-		}), callback);
-	};
-
-	Groups.isMember = function(uid, groupName, callback) {
-		if (!uid || parseInt(uid, 10) <= 0) {
-			return callback(null, false);
-		}
-		db.isSortedSetMember('group:' + groupName + ':members', uid, callback);
-	};
-
-	Groups.isMembers = function(uids, groupName, callback) {
-		db.isSortedSetMembers('group:' + groupName + ':members', uids, callback);
-	};
-
-	Groups.isMemberOfGroups = function(uid, groups, callback) {
-		if (!uid || parseInt(uid, 10) <= 0) {
-			return callback(null, groups.map(function() {return false;}));
-		}
-		groups = groups.map(function(groupName) {
-			return 'group:' + groupName + ':members';
-		});
-
-		db.isMemberOfSortedSets(groups, uid, callback);
-	};
-
-	Groups.getMemberCount = function(groupName, callback) {
-		db.getObjectField('group:' + groupName, 'memberCount', function(err, count) {
-			if (err) {
-				return callback(err);
-			}
-			callback(null, parseInt(count, 10));
-		});
-	};
-
-	Groups.isMemberOfGroupList = function(uid, groupListKey, callback) {
-		db.getSortedSetRange('group:' + groupListKey + ':members', 0, -1, function(err, groupNames) {
-			if (err) {
-				return callback(err);
-			}
-			groupNames = internals.removeEphemeralGroups(groupNames);
-			if (groupNames.length === 0) {
-				return callback(null, false);
-			}
-
-			Groups.isMemberOfGroups(uid, groupNames, function(err, isMembers) {
-				if (err) {
-					return callback(err);
-				}
-
-				callback(null, isMembers.indexOf(true) !== -1);
-			});
-		});
-	};
-
-	Groups.isMemberOfGroupsList = function(uid, groupListKeys, callback) {
-		var sets = groupListKeys.map(function(groupName) {
-			return 'group:' + groupName + ':members';
-		});
-
-		db.getSortedSetsMembers(sets, function(err, members) {
-			if (err) {
-				return callback(err);
-			}
-
-			var uniqueGroups = _.unique(_.flatten(members));
-			uniqueGroups = internals.removeEphemeralGroups(uniqueGroups);
-
-			Groups.isMemberOfGroups(uid, uniqueGroups, function(err, isMembers) {
-				if (err) {
-					return callback(err);
-				}
-
-				var map = {};
-
-				uniqueGroups.forEach(function(groupName, index) {
-					map[groupName] = isMembers[index];
-				});
-
-				var result = members.map(function(groupNames) {
-					for (var i=0; i<groupNames.length; ++i) {
-						if (map[groupNames[i]]) {
-							return true;
-						}
-					}
-					return false;
-				});
-
-				callback(null, result);
-			});
-		});
-	};
-
-	Groups.isMembersOfGroupList = function(uids, groupListKey, callback) {
-		db.getSortedSetRange('group:' + groupListKey + ':members', 0, -1, function(err, groupNames) {
-			if (err) {
-				return callback(err);
-			}
-
-			var results = [];
-			uids.forEach(function() {
-				results.push(false);
-			});
-
-			groupNames = internals.removeEphemeralGroups(groupNames);
-			if (groupNames.length === 0) {
-				return callback(null, results);
-			}
-
-			async.each(groupNames, function(groupName, next) {
-				Groups.isMembers(uids, groupName, function(err, isMembers) {
-					if (err) {
-						return next(err);
-					}
-					results.forEach(function(isMember, index) {
-						if (!isMember && isMembers[index]) {
-							results[index] = true;
-						}
-					});
-					next();
-				});
-			}, function(err) {
-				callback(err, results);
-			});
-		});
-	};
-
-	Groups.isInvited = function(uid, groupName, callback) {
-		if (!uid) { return callback(null, false); }
-		db.isSetMember('group:' + groupName + ':invited', uid, callback);
-	};
-
 	Groups.exists = function(name, callback) {
 		if (Array.isArray(name)) {
 			var slugs = name.map(function(groupName) {
@@ -510,179 +373,6 @@ var async = require('async'),
 		}
 	};
 
-	Groups.hide = function(groupName, callback) {
-		callback = callback || function() {};
-		db.setObjectField('group:' + groupName, 'hidden', 1, callback);
-	};
-
-	Groups.join = function(groupName, uid, callback) {
-		function join() {
-			var tasks = [
-				async.apply(db.sortedSetAdd, 'group:' + groupName + ':members', Date.now(), uid),
-				async.apply(db.incrObjectField, 'group:' + groupName, 'memberCount')
-			];
-
-			async.waterfall([
-				function(next) {
-					user.isAdministrator(uid, next);
-				},
-				function(isAdmin, next) {
-					if (isAdmin) {
-						tasks.push(async.apply(db.setAdd, 'group:' + groupName + ':owners', uid));
-					}
-					async.parallel(tasks, next);
-				},
-				function(results, next) {
-					user.setGroupTitle(groupName, uid, next);
-				},
-				function(next) {
-					plugins.fireHook('action:group.join', {
-						groupName: groupName,
-						uid: uid
-					});
-					next();
-				}
-			], callback);
-		}
-
-		callback = callback || function() {};
-
-		Groups.exists(groupName, function(err, exists) {
-			if (err) {
-				return callback(err);
-			}
-
-			if (exists) {
-				return join();
-			}
-
-			Groups.create({
-				name: groupName,
-				description: '',
-				hidden: 1
-			}, function(err) {
-				if (err && err.message !== '[[error:group-already-exists]]') {
-					winston.error('[groups.join] Could not create new hidden group: ' + err.message);
-					return callback(err);
-				}
-				join();
-			});
-		});
-	};
-
-	Groups.requestMembership = function(groupName, uid, callback) {
-		async.parallel({
-			exists: async.apply(Groups.exists, groupName),
-			isMember: async.apply(Groups.isMember, uid, groupName)
-		}, function(err, checks) {
-			if (!checks.exists) {
-				return callback(new Error('[[error:no-group]]'));
-			} else if (checks.isMember) {
-				return callback(new Error('[[error:group-already-member]]'));
-			}
-
-			if (parseInt(uid, 10) > 0) {
-				db.setAdd('group:' + groupName + ':pending', uid, callback);
-				plugins.fireHook('action:group.requestMembership', {
-					groupName: groupName,
-					uid: uid
-				});
-			} else {
-				callback(new Error('[[error:not-logged-in]]'));
-			}
-		});
-	};
-
-	Groups.acceptMembership = function(groupName, uid, callback) {
-		// Note: For simplicity, this method intentially doesn't check the caller uid for ownership!
-		async.waterfall([
-			async.apply(db.setRemove, 'group:' + groupName + ':pending', uid),
-			async.apply(db.setRemove, 'group:' + groupName + ':invited', uid),
-			async.apply(Groups.join, groupName, uid)
-		], callback);
-	};
-
-	Groups.rejectMembership = function(groupName, uid, callback) {
-		// Note: For simplicity, this method intentially doesn't check the caller uid for ownership!
-		async.parallel([
-			async.apply(db.setRemove, 'group:' + groupName + ':pending', uid),
-			async.apply(db.setRemove, 'group:' + groupName + ':invited', uid)
-		], callback);
-	};
-
-	Groups.invite = function(groupName, uid, callback) {
-		async.parallel({
-			exists: async.apply(Groups.exists, groupName),
-			isMember: async.apply(Groups.isMember, uid, groupName)
-		}, function(err, checks) {
-			if (!checks.exists) {
-				return callback(new Error('[[error:no-group]]'));
-			} else if (checks.isMember) {
-				return callback(new Error('[[error:group-already-member]]'));
-			}
-
-			if (parseInt(uid, 10) > 0) {
-				db.setAdd('group:' + groupName + ':invited', uid, callback);
-				plugins.fireHook('action:group.inviteMember', {
-					groupName: groupName,
-					uid: uid
-				});
-			} else {
-				callback(new Error('[[error:not-logged-in]]'));
-			}
-		});
-	};
-
-	Groups.leave = function(groupName, uid, callback) {
-		callback = callback || function() {};
-
-		var tasks = [
-			async.apply(db.sortedSetRemove, 'group:' + groupName + ':members', uid),
-			async.apply(db.setRemove, 'group:' + groupName + ':owners', uid),
-			async.apply(db.decrObjectField, 'group:' + groupName, 'memberCount')
-		];
-
-		async.parallel(tasks, function(err) {
-			if (err) {
-				return callback(err);
-			}
-
-			plugins.fireHook('action:group.leave', {
-				groupName: groupName,
-				uid: uid
-			});
-
-			Groups.getGroupFields(groupName, ['hidden', 'memberCount'], function(err, groupData) {
-				if (err || !groupData) {
-					return callback(err);
-				}
-
-				if (parseInt(groupData.hidden, 10) === 1 && parseInt(groupData.memberCount, 10) === 0) {
-					Groups.destroy(groupName, callback);
-				} else {
-					callback();
-				}
-			});
-		});
-	};
-
-	Groups.leaveAllGroups = function(uid, callback) {
-		db.getSortedSetRange('groups:createtime', 0, -1, function(err, groups) {
-			if (err) {
-				return callback(err);
-			}
-			async.each(groups, function(groupName, next) {
-				Groups.isMember(uid, groupName, function(err, isMember) {
-					if (!err && isMember) {
-						Groups.leave(groupName, uid, next);
-					} else {
-						next();
-					}
-				});
-			}, callback);
-		});
-	};
-
 	Groups.getLatestMemberPosts = function(groupName, max, uid, callback) {
 		async.waterfall([
 			async.apply(Groups.getMembers, groupName, 0, -1),
@@ -780,164 +470,4 @@ var async = require('async'),
 			});
 		});
 	};
-
-	Groups.updateCoverPosition = function(groupName, position, callback) {
-		Groups.setGroupField(groupName, 'cover:position', position, callback);
-	};
-
-	Groups.updateCover = function(data, callback) {
-		var tempPath, md5sum, url;
-
-		// Position only? That's fine
-		if (!data.imageData && data.position) {
-			return Groups.updateCoverPosition(data.groupName, data.position, callback);
-		}
-
-		async.series([
-			function(next) {
-				// Calculate md5sum of image
-				// This is required because user data can be private
-				md5sum = crypto.createHash('md5');
-				md5sum.update(data.imageData);
-				md5sum = md5sum.digest('hex');
-				next();
-			},
-			function(next) {
-				// Save image
-				tempPath = path.join(nconf.get('base_dir'), nconf.get('upload_path'), md5sum);
-				var buffer = new Buffer(data.imageData.slice(data.imageData.indexOf('base64') + 7), 'base64');
-
-				fs.writeFile(tempPath, buffer, {
-					encoding: 'base64'
-				}, next);
-			},
-			function(next) {
-				uploadsController.uploadGroupCover({
-					path: tempPath
-				}, function(err, uploadData) {
-					if (err) {
-						return next(err);
-					}
-
-					url = uploadData.url;
-					next();
-				});
-			},
-			function(next) {
-				Groups.setGroupField(data.groupName, 'cover:url', url, next);
-			},
-			function(next) {
-				fs.unlink(tempPath, next);	// Delete temporary file
-			}
-		], function(err) {
-			if (err) {
-				return callback(err);
-			}
-
-			Groups.updateCoverPosition(data.groupName, data.position, callback);
-		});
-	};
-
-	Groups.ownership = {};
-
-	Groups.ownership.isOwner = function(uid, groupName, callback) {
-		// Note: All admins automatically become owners upon joining
-		db.isSetMember('group:' + groupName + ':owners', uid, callback);
-	};
-
-	Groups.ownership.grant = function(toUid, groupName, callback) {
-		// Note: No ownership checking is done here on purpose!
-		db.setAdd('group:' + groupName + ':owners', toUid, callback);
-	};
-
-	Groups.ownership.rescind = function(toUid, groupName, callback) {
-		// Note: No ownership checking is done here on purpose!
-
-		// If the owners set only contains one member, error out!
-		db.setCount('group:' + groupName + ':owners', function(err, numOwners) {
-			if (numOwners <= 1) {
-				return callback(new Error('[[error:group-needs-owner]]'));
-			}
-
-			db.setRemove('group:' + groupName + ':owners', toUid, callback);
-		});
-	};
-
-	Groups.search = function(query, options, callback) {
-		if (!query) {
-			return callback(null, []);
-		}
-		query = query.toLowerCase();
-		async.waterfall([
-			async.apply(db.getObjectValues, 'groupslug:groupname'),
-			function(groupNames, next) {
-				groupNames = groupNames.filter(function(name) {
-					return name.toLowerCase().indexOf(query) !== -1 && name !== 'administrators';
-				});
-				groupNames = groupNames.slice(0, 100);
-				Groups.getGroupsData(groupNames, next);
-			},
-			async.apply(Groups.sort, options.sort)
-		], callback);
-	};
-
-	Groups.sort = function(strategy, groups, next) {
-		switch(strategy) {
-			case 'count':
-				groups = groups.sort(function(a, b) {
-					return a.slug > b.slug;
-				}).sort(function(a, b) {
-					return a.memberCount < b.memberCount;
-				});
-				break;
-
-			case 'date':
-				groups = groups.sort(function(a, b) {
-					return a.createtime < b.createtime;
-				});
-				break;
-
-			case 'alpha':	// intentional fall-through
-			default:
-				groups = groups.sort(function(a, b) {
-					return a.slug > b.slug ? 1 : -1;
-				});
-		}
-
-		next(null, groups);
-	};
-
-	Groups.searchMembers = function(data, callback) {
-
-		function findUids(query, searchBy, callback) {
-			if (!query) {
-				return Groups.getMembers(data.groupName, 0, -1, callback);
-			}
-
-			query = query.toLowerCase();
-
-			async.waterfall([
-				function(next) {
-					Groups.getMembers(data.groupName, 0, -1, next);
-				},
-				function(members, next) {
-					user.getMultipleUserFields(members, ['uid'].concat([searchBy]), next);
-				},
-				function(users, next) {
-					var uids = [];
-					for(var i=0; i<users.length; ++i) {
-						var field = users[i][searchBy];
-						if (field.toLowerCase().startsWith(query)) {
-							uids.push(users[i].uid);
-						}
-					}
-					next(null, uids);
-				}
-			], callback);
-		}
-
-		data.findUids = findUids;
-		user.search(data, callback);
-	};
-
 }(module.exports));
diff --git a/src/groups/membership.js b/src/groups/membership.js
new file mode 100644
index 0000000000..152029d6b1
--- /dev/null
+++ b/src/groups/membership.js
@@ -0,0 +1,317 @@
+'use strict';
+
+var	async = require('async'),
+	winston = require('winston'),
+	_ = require('underscore'),
+
+	user = require('../user'),
+	plugins = require('../plugins'),
+	db = require('./../database');
+
+module.exports = function(Groups) {
+	Groups.join = function(groupName, uid, callback) {
+		function join() {
+			var tasks = [
+				async.apply(db.sortedSetAdd, 'group:' + groupName + ':members', Date.now(), uid),
+				async.apply(db.incrObjectField, 'group:' + groupName, 'memberCount')
+			];
+
+			async.waterfall([
+				function(next) {
+					user.isAdministrator(uid, next);
+				},
+				function(isAdmin, next) {
+					if (isAdmin) {
+						tasks.push(async.apply(db.setAdd, 'group:' + groupName + ':owners', uid));
+					}
+					async.parallel(tasks, next);
+				},
+				function(results, next) {
+					user.setGroupTitle(groupName, uid, next);
+				},
+				function(next) {
+					plugins.fireHook('action:group.join', {
+						groupName: groupName,
+						uid: uid
+					});
+					next();
+				}
+			], callback);
+		}
+
+		callback = callback || function() {};
+
+		Groups.exists(groupName, function(err, exists) {
+			if (err) {
+				return callback(err);
+			}
+
+			if (exists) {
+				return join();
+			}
+
+			Groups.create({
+				name: groupName,
+				description: '',
+				hidden: 1
+			}, function(err) {
+				if (err && err.message !== '[[error:group-already-exists]]') {
+					winston.error('[groups.join] Could not create new hidden group: ' + err.message);
+					return callback(err);
+				}
+				join();
+			});
+		});
+	};
+
+	Groups.requestMembership = function(groupName, uid, callback) {
+		async.parallel({
+			exists: async.apply(Groups.exists, groupName),
+			isMember: async.apply(Groups.isMember, uid, groupName)
+		}, function(err, checks) {
+			if (!checks.exists) {
+				return callback(new Error('[[error:no-group]]'));
+			} else if (checks.isMember) {
+				return callback(new Error('[[error:group-already-member]]'));
+			}
+
+			if (parseInt(uid, 10) > 0) {
+				db.setAdd('group:' + groupName + ':pending', uid, callback);
+				plugins.fireHook('action:group.requestMembership', {
+					groupName: groupName,
+					uid: uid
+				});
+			} else {
+				callback(new Error('[[error:not-logged-in]]'));
+			}
+		});
+	};
+
+	Groups.acceptMembership = function(groupName, uid, callback) {
+		// Note: For simplicity, this method intentially doesn't check the caller uid for ownership!
+		async.waterfall([
+			async.apply(db.setRemove, 'group:' + groupName + ':pending', uid),
+			async.apply(db.setRemove, 'group:' + groupName + ':invited', uid),
+			async.apply(Groups.join, groupName, uid)
+		], callback);
+	};
+
+	Groups.rejectMembership = function(groupName, uid, callback) {
+		// Note: For simplicity, this method intentially doesn't check the caller uid for ownership!
+		async.parallel([
+			async.apply(db.setRemove, 'group:' + groupName + ':pending', uid),
+			async.apply(db.setRemove, 'group:' + groupName + ':invited', uid)
+		], callback);
+	};
+
+	Groups.invite = function(groupName, uid, callback) {
+		async.parallel({
+			exists: async.apply(Groups.exists, groupName),
+			isMember: async.apply(Groups.isMember, uid, groupName)
+		}, function(err, checks) {
+			if (!checks.exists) {
+				return callback(new Error('[[error:no-group]]'));
+			} else if (checks.isMember) {
+				return callback(new Error('[[error:group-already-member]]'));
+			}
+
+			if (parseInt(uid, 10) > 0) {
+				db.setAdd('group:' + groupName + ':invited', uid, callback);
+				plugins.fireHook('action:group.inviteMember', {
+					groupName: groupName,
+					uid: uid
+				});
+			} else {
+				callback(new Error('[[error:not-logged-in]]'));
+			}
+		});
+	};
+
+	Groups.leave = function(groupName, uid, callback) {
+		callback = callback || function() {};
+
+		var tasks = [
+			async.apply(db.sortedSetRemove, 'group:' + groupName + ':members', uid),
+			async.apply(db.setRemove, 'group:' + groupName + ':owners', uid),
+			async.apply(db.decrObjectField, 'group:' + groupName, 'memberCount')
+		];
+
+		async.parallel(tasks, function(err) {
+			if (err) {
+				return callback(err);
+			}
+
+			plugins.fireHook('action:group.leave', {
+				groupName: groupName,
+				uid: uid
+			});
+
+			Groups.getGroupFields(groupName, ['hidden', 'memberCount'], function(err, groupData) {
+				if (err || !groupData) {
+					return callback(err);
+				}
+
+				if (parseInt(groupData.hidden, 10) === 1 && parseInt(groupData.memberCount, 10) === 0) {
+					Groups.destroy(groupName, callback);
+				} else {
+					callback();
+				}
+			});
+		});
+	};
+
+	Groups.leaveAllGroups = function(uid, callback) {
+		db.getSortedSetRange('groups:createtime', 0, -1, function(err, groups) {
+			if (err) {
+				return callback(err);
+			}
+			async.each(groups, function(groupName, next) {
+				Groups.isMember(uid, groupName, function(err, isMember) {
+					if (!err && isMember) {
+						Groups.leave(groupName, uid, next);
+					} else {
+						next();
+					}
+				});
+			}, callback);
+		});
+	};
+
+	Groups.getMembers = function(groupName, start, stop, callback) {
+		db.getSortedSetRevRange('group:' + groupName + ':members', start, stop, callback);
+	};
+
+	Groups.getMembersOfGroups = function(groupNames, callback) {
+		db.getSortedSetsMembers(groupNames.map(function(name) {
+			return 'group:' + name + ':members';
+		}), callback);
+	};
+
+	Groups.isMember = function(uid, groupName, callback) {
+		if (!uid || parseInt(uid, 10) <= 0) {
+			return callback(null, false);
+		}
+		db.isSortedSetMember('group:' + groupName + ':members', uid, callback);
+	};
+
+	Groups.isMembers = function(uids, groupName, callback) {
+		db.isSortedSetMembers('group:' + groupName + ':members', uids, callback);
+	};
+
+	Groups.isMemberOfGroups = function(uid, groups, callback) {
+		if (!uid || parseInt(uid, 10) <= 0) {
+			return callback(null, groups.map(function() {return false;}));
+		}
+		groups = groups.map(function(groupName) {
+			return 'group:' + groupName + ':members';
+		});
+
+		db.isMemberOfSortedSets(groups, uid, callback);
+	};
+
+	Groups.getMemberCount = function(groupName, callback) {
+		db.getObjectField('group:' + groupName, 'memberCount', function(err, count) {
+			if (err) {
+				return callback(err);
+			}
+			callback(null, parseInt(count, 10));
+		});
+	};
+
+	Groups.isMemberOfGroupList = function(uid, groupListKey, callback) {
+		db.getSortedSetRange('group:' + groupListKey + ':members', 0, -1, function(err, groupNames) {
+			if (err) {
+				return callback(err);
+			}
+			groupNames = Groups.internals.removeEphemeralGroups(groupNames);
+			if (groupNames.length === 0) {
+				return callback(null, false);
+			}
+
+			Groups.isMemberOfGroups(uid, groupNames, function(err, isMembers) {
+				if (err) {
+					return callback(err);
+				}
+
+				callback(null, isMembers.indexOf(true) !== -1);
+			});
+		});
+	};
+
+	Groups.isMemberOfGroupsList = function(uid, groupListKeys, callback) {
+		var sets = groupListKeys.map(function(groupName) {
+			return 'group:' + groupName + ':members';
+		});
+
+		db.getSortedSetsMembers(sets, function(err, members) {
+			if (err) {
+				return callback(err);
+			}
+
+			var uniqueGroups = _.unique(_.flatten(members));
+			uniqueGroups = Groups.internals.removeEphemeralGroups(uniqueGroups);
+
+			Groups.isMemberOfGroups(uid, uniqueGroups, function(err, isMembers) {
+				if (err) {
+					return callback(err);
+				}
+
+				var map = {};
+
+				uniqueGroups.forEach(function(groupName, index) {
+					map[groupName] = isMembers[index];
+				});
+
+				var result = members.map(function(groupNames) {
+					for (var i=0; i<groupNames.length; ++i) {
+						if (map[groupNames[i]]) {
+							return true;
+						}
+					}
+					return false;
+				});
+
+				callback(null, result);
+			});
+		});
+	};
+
+	Groups.isMembersOfGroupList = function(uids, groupListKey, callback) {
+		db.getSortedSetRange('group:' + groupListKey + ':members', 0, -1, function(err, groupNames) {
+			if (err) {
+				return callback(err);
+			}
+
+			var results = [];
+			uids.forEach(function() {
+				results.push(false);
+			});
+
+			groupNames = Groups.internals.removeEphemeralGroups(groupNames);
+			if (groupNames.length === 0) {
+				return callback(null, results);
+			}
+
+			async.each(groupNames, function(groupName, next) {
+				Groups.isMembers(uids, groupName, function(err, isMembers) {
+					if (err) {
+						return next(err);
+					}
+					results.forEach(function(isMember, index) {
+						if (!isMember && isMembers[index]) {
+							results[index] = true;
+						}
+					});
+					next();
+				});
+			}, function(err) {
+				callback(err, results);
+			});
+		});
+	};
+
+	Groups.isInvited = function(uid, groupName, callback) {
+		if (!uid) { return callback(null, false); }
+		db.isSetMember('group:' + groupName + ':invited', uid, callback);
+	};
+};
diff --git a/src/groups/ownership.js b/src/groups/ownership.js
new file mode 100644
index 0000000000..38d5a699d8
--- /dev/null
+++ b/src/groups/ownership.js
@@ -0,0 +1,31 @@
+'use strict';
+
+var	db = require('./../database');
+
+module.exports = function(Groups) {
+
+	Groups.ownership = {};
+
+	Groups.ownership.isOwner = function(uid, groupName, callback) {
+		// Note: All admins automatically become owners upon joining
+		db.isSetMember('group:' + groupName + ':owners', uid, callback);
+	};
+
+	Groups.ownership.grant = function(toUid, groupName, callback) {
+		// Note: No ownership checking is done here on purpose!
+		db.setAdd('group:' + groupName + ':owners', toUid, callback);
+	};
+
+	Groups.ownership.rescind = function(toUid, groupName, callback) {
+		// Note: No ownership checking is done here on purpose!
+
+		// If the owners set only contains one member, error out!
+		db.setCount('group:' + groupName + ':owners', function(err, numOwners) {
+			if (numOwners <= 1) {
+				return callback(new Error('[[error:group-needs-owner]]'));
+			}
+
+			db.setRemove('group:' + groupName + ':owners', toUid, callback);
+		});
+	};
+};
diff --git a/src/groups/search.js b/src/groups/search.js
new file mode 100644
index 0000000000..4629d17af2
--- /dev/null
+++ b/src/groups/search.js
@@ -0,0 +1,86 @@
+'use strict';
+
+var	async = require('async'),
+
+	user = require('../user'),
+	db = require('./../database');
+
+module.exports = function(Groups) {
+
+	Groups.search = function(query, options, callback) {
+		if (!query) {
+			return callback(null, []);
+		}
+		query = query.toLowerCase();
+		async.waterfall([
+			async.apply(db.getObjectValues, 'groupslug:groupname'),
+			function(groupNames, next) {
+				groupNames = groupNames.filter(function(name) {
+					return name.toLowerCase().indexOf(query) !== -1 && name !== 'administrators';
+				});
+				groupNames = groupNames.slice(0, 100);
+				Groups.getGroupsData(groupNames, next);
+			},
+			async.apply(Groups.sort, options.sort)
+		], callback);
+	};
+
+	Groups.sort = function(strategy, groups, next) {
+		switch(strategy) {
+			case 'count':
+				groups = groups.sort(function(a, b) {
+					return a.slug > b.slug;
+				}).sort(function(a, b) {
+					return a.memberCount < b.memberCount;
+				});
+				break;
+
+			case 'date':
+				groups = groups.sort(function(a, b) {
+					return a.createtime < b.createtime;
+				});
+				break;
+
+			case 'alpha':	// intentional fall-through
+			default:
+				groups = groups.sort(function(a, b) {
+					return a.slug > b.slug ? 1 : -1;
+				});
+		}
+
+		next(null, groups);
+	};
+
+	Groups.searchMembers = function(data, callback) {
+
+		function findUids(query, searchBy, callback) {
+			if (!query) {
+				return Groups.getMembers(data.groupName, 0, -1, callback);
+			}
+
+			query = query.toLowerCase();
+
+			async.waterfall([
+				function(next) {
+					Groups.getMembers(data.groupName, 0, -1, next);
+				},
+				function(members, next) {
+					user.getMultipleUserFields(members, ['uid'].concat([searchBy]), next);
+				},
+				function(users, next) {
+					var uids = [];
+					for(var i=0; i<users.length; ++i) {
+						var field = users[i][searchBy];
+						if (field.toLowerCase().startsWith(query)) {
+							uids.push(users[i].uid);
+						}
+					}
+					next(null, uids);
+				}
+			], callback);
+		}
+
+		data.findUids = findUids;
+		user.search(data, callback);
+	};
+};
diff --git a/src/groups/update.js b/src/groups/update.js
index 4b2974b013..b533f63c4e 100644
--- a/src/groups/update.js
+++ b/src/groups/update.js
@@ -2,9 +2,16 @@
 
 var async = require('async'),
 	winston = require('winston'),
+	crypto = require('crypto'),
+	path = require('path'),
+	nconf = require('nconf'),
+	fs = require('fs'),
+
 	plugins = require('../plugins'),
 	utils = require('../../public/src/utils'),
-	db = require('./../database');
+	db = require('./../database'),
+
+	uploadsController = require('../controllers/uploads');
 
 module.exports = function(Groups) {
 
@@ -55,6 +62,68 @@ module.exports = function(Groups) {
 		});
 	};
 
+	Groups.hide = function(groupName, callback) {
+		callback = callback || function() {};
+		db.setObjectField('group:' + groupName, 'hidden', 1, callback);
+	};
+
+	Groups.updateCoverPosition = function(groupName, position, callback) {
+		Groups.setGroupField(groupName, 'cover:position', position, callback);
+	};
+
+	Groups.updateCover = function(data, callback) {
+		var tempPath, md5sum, url;
+
+		// Position only? That's fine
+		if (!data.imageData && data.position) {
+			return Groups.updateCoverPosition(data.groupName, data.position, callback);
+		}
+
+		async.series([
+			function(next) {
+				// Calculate md5sum of image
+				// This is required because user data can be private
+				md5sum = crypto.createHash('md5');
+				md5sum.update(data.imageData);
+				md5sum = md5sum.digest('hex');
+				next();
+			},
+			function(next) {
+				// Save image
+				tempPath = path.join(nconf.get('base_dir'), nconf.get('upload_path'), md5sum);
+				var buffer = new Buffer(data.imageData.slice(data.imageData.indexOf('base64') + 7), 'base64');
+
+				fs.writeFile(tempPath, buffer, {
+					encoding: 'base64'
+				}, next);
+			},
+			function(next) {
+				uploadsController.uploadGroupCover({
+					path: tempPath
+				}, function(err, uploadData) {
+					if (err) {
+						return next(err);
+					}
+
+					url = uploadData.url;
+					next();
+				});
+			},
+			function(next) {
+				Groups.setGroupField(data.groupName, 'cover:url', url, next);
+			},
+			function(next) {
+				fs.unlink(tempPath, next);	// Delete temporary file
+			}
+		], function(err) {
+			if (err) {
+				return callback(err);
+			}
+
+			Groups.updateCoverPosition(data.groupName, data.position, callback);
+		});
+	};
+
 	function updatePrivacy(groupName, newValue, callback) {
 		if (!newValue) {
 			return callback();
@@ -160,6 +229,4 @@ module.exports = function(Groups) {
 			], callback);
 		});
 	}
-
-
 };