Merge remote-tracking branch 'origin/develop' into activitypub

src/controllers/admin/groups.js

@@ -42,7 +42,6 @@ groupsController.get = async function (req, res, next) {
 	if (!group || groupName === groups.BANNED_USERS) {
 		return next();
 	}
-	group.isOwner = true;
 
 	const groupNameData = groupNames.map(name => ({
 		encodedName: encodeURIComponent(name),

src/controllers/groups.js

@@ -72,7 +72,6 @@ groupsController.details = async function (req, res, next) {
 	if (!groupData) {
 		return next();
 	}
-	groupData.isOwner = groupData.isOwner || isAdmin || (isGlobalMod && !groupData.system);
 
 	res.render('groups/details', {
 		title: `[[pages:group, ${groupData.displayName}]]`,

src/database/mongo/sets.js

@@ -13,17 +13,25 @@ module.exports = function (module) {
 		}
 		value = value.map(v => helpers.valueToString(v));
 
-		await module.client.collection('objects').updateOne({
-			_key: key,
-		}, {
-			$addToSet: {
-				members: {
-					$each: value,
+		try {
+			await module.client.collection('objects').updateOne({
+				_key: key,
+			}, {
+				$addToSet: {
+					members: {
+						$each: value,
+					},
 				},
-			},
-		}, {
-			upsert: true,
-		});
+			}, {
+				upsert: true,
+			});
+		} catch (err) {
+			if (err && err.message.includes('E11000 duplicate key error')) {
+				console.log(new Error('e11000').stack, key, value);
+				return await module.setAdd(key, value);
+			}
+			throw err;
+		}
 	};
 
 	module.setsAdd = async function (keys, value) {

src/groups/index.js

@@ -3,6 +3,7 @@
 const user = require('../user');
 const db = require('../database');
 const plugins = require('../plugins');
+const privileges = require('../privileges');
 const slugify = require('../slugify');
 
 const Groups = module.exports;
@@ -130,30 +131,37 @@ Groups.get = async function (groupName, options) {
 		stop = (parseInt(options.userListCount, 10) || 4) - 1;
 	}
 
-	const [groupData, members, pending, invited, isMember, isPending, isInvited, isOwner] = await Promise.all([
+	const [groupData, members, isMember, isPending, isInvited, isOwner, isAdmin, isGlobalMod] = await Promise.all([
 		Groups.getGroupData(groupName),
 		Groups.getOwnersAndMembers(groupName, options.uid, 0, stop),
-		Groups.getPending(groupName),
-		Groups.getInvites(groupName),
 		Groups.isMember(options.uid, groupName),
 		Groups.isPending(options.uid, groupName),
 		Groups.isInvited(options.uid, groupName),
 		Groups.ownership.isOwner(options.uid, groupName),
+		privileges.admin.can('admin:groups', options.uid),
+		user.isGlobalModerator(options.uid),
 	]);
 
 	if (!groupData) {
 		return null;
 	}
+
+	groupData.isOwner = isOwner || isAdmin || (isGlobalMod && !groupData.system);
+	if (groupData.isOwner) {
+		([groupData.pending, groupData.invited] = await Promise.all([
+			Groups.getPending(groupName),
+			Groups.getInvites(groupName),
+		]));
+	}
+
+
 	const descriptionParsed = await plugins.hooks.fire('filter:parse.raw', String(groupData.description || ''));
 	groupData.descriptionParsed = descriptionParsed;
 	groupData.members = members;
 	groupData.membersNextStart = stop + 1;
-	groupData.pending = pending.filter(Boolean);
-	groupData.invited = invited.filter(Boolean);
 	groupData.isMember = isMember;
 	groupData.isPending = isPending;
 	groupData.isInvited = isInvited;
-	groupData.isOwner = isOwner;
 	const results = await plugins.hooks.fire('filter:group.get', { group: groupData });
 	return results.group;
 };

src/groups/user.js

@@ -4,13 +4,10 @@ const db = require('../database');
 const user = require('../user');
 
 module.exports = function (Groups) {
-	Groups.getUsersFromSet = async function (set, fields) {
+	Groups.getUsersFromSet = async function (set, fields = []) {
 		const uids = await db.getSetMembers(set);
-
-		if (fields) {
-			return await user.getUsersFields(uids, fields);
-		}
-		return await user.getUsersData(uids);
+		const userData = await user.getUsersFields(uids, fields);
+		return userData.filter(u => u && u.uid);
 	};
 
 	Groups.getUserGroups = async function (uids) {

src/plugins/hooks.js

@@ -207,6 +207,38 @@ Hooks.hasListeners = function (hook) {
 	return !!(plugins.loadedHooks[hook] && plugins.loadedHooks[hook].length > 0);
 };
 
+function hookHandlerPromise(hook, hookObj, params) {
+	return new Promise((resolve, reject) => {
+		let resolved = false;
+		function _resolve(result) {
+			if (resolved) {
+				winston.warn(`[plugins] ${hook} already resolved in plugin ${hookObj.id}`);
+				return;
+			}
+			resolved = true;
+			resolve(result);
+		}
+		const returned = hookObj.method(params, (err, result) => {
+			if (err) reject(err); else _resolve(result);
+		});
+
+		if (utils.isPromise(returned)) {
+			returned.then(
+				payload => _resolve(payload),
+				err => reject(err)
+			);
+			return;
+		}
+
+		if (hook.startsWith('filter:') && returned !== undefined) {
+			_resolve(returned);
+		} else if (hook.startsWith('static:') && hookObj.method.length <= 1) {
+			// make sure it is resolved if static hook doesn't return anything and doesn't use callback
+			_resolve();
+		}
+	});
+}
+
 async function fireFilterHook(hook, hookList, params) {
 	if (!Array.isArray(hookList) || !hookList.length) {
 		return params;
@@ -223,31 +255,7 @@ async function fireFilterHook(hook, hookList, params) {
 		if (hookObj.method.constructor && hookObj.method.constructor.name === 'AsyncFunction') {
 			return await hookObj.method(params);
 		}
-		return new Promise((resolve, reject) => {
-			let resolved = false;
-			function _resolve(result) {
-				if (resolved) {
-					winston.warn(`[plugins] ${hook} already resolved in plugin ${hookObj.id}`);
-					return;
-				}
-				resolved = true;
-				resolve(result);
-			}
-			const returned = hookObj.method(params, (err, result) => {
-				if (err) reject(err); else _resolve(result);
-			});
-
-			if (utils.isPromise(returned)) {
-				returned.then(
-					payload => _resolve(payload),
-					err => reject(err)
-				);
-				return;
-			}
-			if (returned) {
-				_resolve(returned);
-			}
-		});
+		return hookHandlerPromise(hook, hookObj, params);
 	}
 
 	for (const hookObj of hookList) {
@@ -303,28 +311,7 @@ async function fireStaticHook(hook, hookList, params) {
 			return timeout(hookObj.method(params), 10000, 'timeout');
 		}
 
-		return new Promise((resolve, reject) => {
-			let resolved = false;
-			function _resolve(result) {
-				if (resolved) {
-					return;
-				}
-				resolved = true;
-				resolve(result);
-			}
-			const returned = hookObj.method(params, (err, result) => {
-				if (err) reject(err); else _resolve(result);
-			});
-
-			if (utils.isPromise(returned)) {
-				returned.then(
-					payload => _resolve(payload),
-					err => reject(err)
-				);
-				return;
-			}
-			_resolve();
-		});
+		return hookHandlerPromise(hook, hookObj, params);
 	}
 
 	for (const hookObj of hookList) {

src/request.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { CookieJar } = require('tough-cookie');
-const fetchCookie = require('fetch-cookie');
+const fetchCookie = require('fetch-cookie').default;
 
 exports.jar = function () {
 	return new CookieJar();