nodebb-plugin-poll 3.1.8 → 3.2.1

package/lib/sockets.js

@@ -1,258 +1,169 @@
 'use strict';
 
-const async = require('async');
-
 const NodeBB = require('./nodebb');
 
 const Config = require('./config');
 const Poll = require('./poll');
 const Vote = require('./vote');
 
-(function (Sockets) {
-	Sockets.getConfig = function (socket, data, callback) {
-		callback(null, Config.settings.get());
-	};
-
-	Sockets.get = function (socket, data, callback) {
-		const allowAnon = Config.settings.get('toggles.allowAnon');
-
-		if (!data) {
-			return callback(new Error('Invalid request, request data is not defined'));
-		}
-		if (isNaN(parseInt(data.pollId, 10))) {
-			return callback(new Error('Invalid request, pollId is required'));
-		}
-		if ((!socket.uid && !allowAnon)) {
-			return callback(new Error('Invalid request, anonymous access is not allowed'));
-		}
-
-		const pollId = parseInt(data.pollId, 10);
-		Poll.get(pollId, socket.uid, !!socket.uid, (err, pollData) => {
-			if (err) {
-				console.error(err);
-			}
-			if (!pollData.info.version) {
-				return callback(new Error('Legacy polls are not supported'));
-			}
-
-			pollData.optionType = parseInt(pollData.settings.maxvotes, 10) > 1 ? 'checkbox' : 'radio';
-			callback(null, pollData);
-		});
-	};
-
-	Sockets.vote = function (socket, data, callback) {
-		if (!socket.uid) {
-			return callback(new Error('You need to be logged in to vote'));
-		}
-		if (!data || isNaN(parseInt(data.pollId, 10)) || !data.options || !data.options.length) {
-			return callback(new Error('Invalid vote'));
-		}
-
-		data.uid = socket.uid;
-
-		async.parallel({
-			canVote: function (next) {
-				Vote.canVote(data.uid, data.pollId, next);
-			},
-			optionsFilter: function (next) {
-				Poll.hasOptions(data.pollId, data.options, next);
-			},
-			settings: function (next) {
-				Poll.getSettings(data.pollId, next);
-			},
-		}, (err, result) => {
-			// Filter the options on their existence
-			data.options = data.options.filter((el, index) => result.optionsFilter[index]);
-
-			// Give an error if there are too many votes
-			if (data.options.length > parseInt(result.settings.maxvotes, 10)) {
-				return callback(new Error(`You can only vote for ${result.settings.maxvotes} options on this poll.`));
-			}
-
-			if (err || !result.canVote || !data.options.length) {
-				return callback(new Error('Already voted or invalid option'));
-			}
-
-			Vote.add(data, (err) => {
-				if (err) {
-					return callback(new Error('Error during voting'));
-				}
-
-				Poll.get(data.pollId, socket.uid, false, (err, pollData) => {
-					if (err) {
-						console.error(err);
-					}
-
-					NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', pollData);
-
-					callback();
-				});
-			});
-		});
-	};
-
-	Sockets.updateVote = function (socket, data, callback) {
-		if (!socket.uid) {
-			return callback(new Error('You need to be logged in to make changes'));
-		}
-		if (!data || isNaN(parseInt(data.pollId, 10)) || !data.options || !data.options.length) {
-			return callback(new Error('Invalid vote'));
-		}
-		data.uid = socket.uid;
-
-		async.parallel({
-			canUpdateVote: function (next) {
-				Vote.canUpdateVote(data.uid, data.pollId, next);
-			},
-			optionsFilter: function (next) {
-				Poll.hasOptions(data.pollId, data.options, next);
-			},
-			settings: function (next) {
-				Poll.getSettings(data.pollId, next);
-			},
-		}, (err, result) => {
-			// Filter the options on their existence
-			data.options = data.options.filter((el, index) => result.optionsFilter[index]);
-
-			// Give an error if there are too many votes
-			if (data.options.length > parseInt(result.settings.maxvotes, 10)) {
-				return callback(new Error(`You can only vote for ${result.settings.maxvotes} options on this poll.`));
-			}
-			if (!result.canUpdateVote) {
-				return callback(new Error('Can\'t update vote'));
-			}
-			if (err || !data.options.length) {
-				if (err) {
-					console.error(err);
-				}
-				return callback(new Error('Invalid option'));
-			}
-
-			Vote.update(data, (err) => {
-				if (err) {
-					return callback(new Error('Error during updating vote'));
-				}
-
-				Poll.get(data.pollId, socket.uid, false, (err, pollData) => {
-					if (err) {
-						console.error(err);
-					}
-
-					NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', pollData);
-
-					callback();
-				});
-			});
-		});
-	};
-
-	Sockets.removeVote = function (socket, data, callback) {
-		if (!socket.uid) {
-			return callback(new Error('You need to be logged in to make changes'));
-		}
-		if (!data || isNaN(parseInt(data.pollId, 10))) {
-			return callback(new Error('Invalid request'));
-		}
-		data.uid = socket.uid;
-
-		async.parallel({
-			canUpdateVote: function (next) {
-				Vote.canUpdateVote(data.uid, data.pollId, next);
-			},
-		}, (err, result) => {
-			if (!result.canUpdateVote) {
-				return callback(new Error('Can\'t remove vote'));
-			}
-			if (err) {
-				console.error(err);
-				return callback(new Error('Something went wrong'));
-			}
-			Vote.remove(data, (err) => {
-				if (err) {
-					return callback(new Error('Error during removing vote'));
-				}
-				Poll.get(data.pollId, socket.uid, false, (err, pollData) => {
-					if (err) {
-						console.error(err);
-					}
-
-					NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', pollData);
-					callback();
-				});
-			});
-		});
-	};
-
-	Sockets.getOptionDetails = function (socket, data, callback) {
-		if (!socket.uid || !data || isNaN(parseInt(data.pollId, 10)) || isNaN(parseInt(data.optionId, 10))) {
-			return callback(new Error('Invalid request'));
-		}
-		async.parallel({
-			poll: function (next) {
-				Poll.getInfo(data.pollId, next);
-			},
-			option: function (next) {
-				Poll.getOption(data.pollId, data.optionId, true, next);
-			},
-		}, (err, result) => {
-			if (err) {
-				return callback(new Error('Something went wrong!'));
-			}
-			const { poll, option } = result;
-			if (!option.votes || !option.votes.length) {
-				return callback(null, option);
-			}
-
-			NodeBB.User.getUsersFields(option.votes, ['uid', 'username', 'userslug', 'picture'], (err, userData) => {
-				if (err) {
-					console.error(err);
-					return callback(err);
-				}
-				option.votes = userData;
-				NodeBB.Plugins.hooks.fire('filter:poll.getOptionDetails', {
-					poll,
-					option,
-				}, (err, result) => {
-					callback(err, result.option);
-				});
-			});
-		});
-	};
-
-	Sockets.canCreate = function (socket, data, callback) {
-		if (!socket.uid || !data || (isNaN(parseInt(data.cid, 10)) && isNaN(parseInt(data.pid, 10)))) {
-			return callback(new Error('Invalid request'));
-		}
-
-		if (!data.cid) {
-			async.waterfall([
-				function (next) {
-					NodeBB.Posts.getPostField(data.pid, 'tid', next);
-				},
-				function (tid, next) {
-					NodeBB.Topics.getTopicField(tid, 'cid', (err, cid) => {
-						if (err) {
-							console.error(err);
-							return callback(new Error('Invalid request'));
-						}
-						next(null, cid);
-					});
-				},
-				function (cid) {
-					checkPrivs(cid, socket.uid, callback);
-				},
-			]);
-		} else {
-			checkPrivs(data.cid, socket.uid, callback);
-		}
-	};
-
-	function checkPrivs(cid, socketUid, callback) {
-		NodeBB.Privileges.categories.can('poll:create', cid, socketUid, (err, can) => {
-			if (err || !can) {
-				return callback(new Error('[[poll:error.privilege.create]]'), can);
-			}
-			return callback(null, can);
-		});
+const Sockets = exports;
+
+Sockets.getConfig = function (socket, data, callback) {
+	callback(null, Config.settings.get());
+};
+
+Sockets.get = async function (socket, data) {
+	const allowAnon = Config.settings.get('toggles.allowAnon');
+
+	if (!data) {
+		throw new Error('Invalid request, request data is not defined');
+	}
+	if (isNaN(parseInt(data.pollId, 10))) {
+		throw new Error('Invalid request, pollId is required');
+	}
+	if ((!socket.uid && !allowAnon)) {
+		throw new Error('Invalid request, anonymous access is not allowed');
+	}
+
+	const pollId = parseInt(data.pollId, 10);
+	const pollData = await Poll.get(pollId, socket.uid, !!socket.uid);
+	if (!pollData.info.version) {
+		throw new Error('Legacy polls are not supported');
+	}
+
+	pollData.optionType = parseInt(pollData.settings.maxvotes, 10) > 1 ? 'checkbox' : 'radio';
+	return pollData;
+};
+
+Sockets.vote = async function (socket, data) {
+	if (!socket.uid) {
+		throw new Error('You need to be logged in to vote');
+	}
+	if (!data || isNaN(parseInt(data.pollId, 10)) || !data.options || !data.options.length) {
+		throw new Error('Invalid vote');
+	}
+
+	data.uid = socket.uid;
+
+	const [canVote, optionsFilter, settings] = await Promise.all([
+		Vote.canVote(data.uid, data.pollId),
+		Poll.hasOptions(data.pollId, data.options),
+		Poll.getSettings(data.pollId),
+	]);
+
+	// Filter the options on their existence
+	data.options = data.options.filter((el, index) => optionsFilter[index]);
+
+	// Give an error if there are too many votes
+	if (data.options.length > parseInt(settings.maxvotes, 10)) {
+		throw new Error(`You can only vote for ${settings.maxvotes} options on this poll.`);
+	}
+
+	if (!canVote || !data.options.length) {
+		throw new Error('Already voted or invalid option');
+	}
+
+	await Vote.add(data);
+
+	const pollData = await Poll.get(data.pollId, socket.uid, false);
+	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', pollData);
+};
+
+Sockets.updateVote = async function (socket, data) {
+	if (!socket.uid) {
+		throw new Error('You need to be logged in to make changes');
+	}
+	if (!data || isNaN(parseInt(data.pollId, 10)) || !data.options || !data.options.length) {
+		throw new Error('Invalid vote');
+	}
+	data.uid = socket.uid;
+
+	const [canUpdateVote, optionsFilter, settings] = await Promise.all([
+		Vote.canUpdateVote(data.uid, data.pollId),
+		Poll.hasOptions(data.pollId, data.options),
+		Poll.getSettings(data.pollId),
+	]);
+
+	// Filter the options on their existence
+	data.options = data.options.filter((el, index) => optionsFilter[index]);
+
+	// Give an error if there are too many votes
+	if (data.options.length > parseInt(settings.maxvotes, 10)) {
+		throw new Error(`You can only vote for ${settings.maxvotes} options on this poll.`);
+	}
+
+	if (!canUpdateVote) {
+		throw new Error('Can\'t update vote');
+	}
+
+	if (!data.options.length) {
+		throw new Error('Invalid option');
+	}
+
+	await Vote.update(data);
+	const pollData = await Poll.get(data.pollId, socket.uid, false);
+	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', pollData);
+};
+
+Sockets.removeVote = async function (socket, data) {
+	if (!socket.uid) {
+		throw new Error('You need to be logged in to make changes');
+	}
+	if (!data || isNaN(parseInt(data.pollId, 10))) {
+		throw new Error('Invalid request');
+	}
+	data.uid = socket.uid;
+
+	const canUpdateVote = await Vote.canUpdateVote(data.uid, data.pollId);
+	if (!canUpdateVote) {
+		throw new Error('Can\'t remove vote');
+	}
+
+	await Vote.remove(data);
+	const pollData = await Poll.get(data.pollId, socket.uid, false);
+	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', pollData);
+};
+
+Sockets.getOptionDetails = async function (socket, data) {
+	if (!socket.uid || !data || isNaN(parseInt(data.pollId, 10)) || isNaN(parseInt(data.optionId, 10))) {
+		throw new Error('Invalid request');
+	}
+	const [poll, option] = await Promise.all([
+		Poll.getInfo(data.pollId),
+		Poll.getOption(data.pollId, data.optionId, true),
+	]);
+
+	if (!option.votes || !option.votes.length) {
+		return option;
+	}
+	const userData = await NodeBB.User.getUsersFields(option.votes, [
+		'uid', 'username', 'userslug', 'picture',
+	]);
+	option.votes = userData;
+
+	const result = await NodeBB.Plugins.hooks.fire('filter:poll.getOptionDetails', {
+		poll,
+		option,
+	});
+	return result.option;
+};
+
+Sockets.canCreate = async function (socket, data) {
+	if (!socket.uid || !data || (isNaN(parseInt(data.cid, 10)) && isNaN(parseInt(data.pid, 10)))) {
+		throw new Error('Invalid request');
+	}
+
+	if (!data.cid) {
+		const tid = await NodeBB.Posts.getPostField(data.pid, 'tid');
+		data.cid = await NodeBB.Topics.getTopicField(tid, 'cid');
+	}
+	return await checkPrivs(data.cid, socket.uid);
+};
+
+async function checkPrivs(cid, socketUid) {
+	const can = await NodeBB.Privileges.categories.can('poll:create', cid, socketUid);
+	if (!can) {
+		throw new Error('[[poll:error.privilege.create]]');
 	}
-}(exports));
+	return true;
+}

package/lib/vote.js

@@ -1,138 +1,83 @@
 'use strict';
 
-const async = require('async');
 const NodeBB = require('./nodebb');
 const Poll = require('./poll');
 
-(function (Vote) {
-	Vote.add = function (voteData, callback) {
-		const { pollId } = voteData;
-		const { options } = voteData;
-		const { uid } = voteData;
-		const timestamp = +new Date();
+const Vote = exports;
 
-		async.parallel([
-			function (next) {
-				async.each(options, (option, next) => {
-					// Add uid to list of votes
-					NodeBB.db.sortedSetAdd(`poll:${pollId}:options:${option}:votes`, timestamp, uid, next);
-				}, next);
-			},
-			function (next) {
-				NodeBB.db.sortedSetAdd(`poll:${pollId}:voters`, timestamp, uid, next);
-			},
-		], (err) => {
-			if (err) {
-				return callback(err, false);
-			}
+Vote.add = async function (voteData) {
+	const { pollId, options, uid } = voteData;
+	const timestamp = +new Date();
 
-			callback(null, true);
-		});
-	};
+	await Promise.all([
+		NodeBB.db.sortedSetAdd(`poll:${pollId}:voters`, timestamp, uid),
+		NodeBB.db.sortedSetAddBulk(
+			options.map(option => ([`poll:${pollId}:options:${option}:votes`, timestamp, uid]))
+		),
+	]);
+};
 
-	Vote.remove = function (voteData, callback) {
-		return Vote.removeUidVote(voteData.uid, voteData.pollId, callback);
-	};
+Vote.remove = async function (voteData) {
+	return await Vote.removeUidVote(voteData.uid, voteData.pollId);
+};
 
-	Vote.get = function (voteData, callback) {
-		return Vote.getUidVote(voteData.uid, voteData.pollId, callback);
-	};
+Vote.get = async function (voteData) {
+	return await Vote.getUidVote(voteData.uid, voteData.pollId);
+};
 
-	Vote.removeUidVote = function (uid, pollId, callback) {
-		Vote.getUidVote(uid, pollId, (err, vote) => {
-			if (err) {
-				console.error(err);
-			}
+Vote.removeUidVote = async function (uid, pollId) {
+	const vote = await Vote.getUidVote(uid, pollId);
+	const options = vote.options || [];
+	await Promise.all([
+		NodeBB.db.sortedSetRemove(`poll:${pollId}:voters`, uid),
+		NodeBB.db.sortedSetsRemove(
+			options.map(option => `poll:${pollId}:options:${option}:votes`),
+			uid,
+		),
+	]);
+};
 
-			async.parallel([
-				function (next) {
-					async.each(vote.options || [], (option, next) => {
-						NodeBB.db.sortedSetRemove(`poll:${pollId}:options:${option}:votes`, uid, next);
-					}, next);
-				},
-				function (next) {
-					NodeBB.db.sortedSetRemove(`poll:${pollId}:voters`, uid, next);
-				},
-			], (err) => {
-				if (err) {
-					return callback(err, false);
-				}
-
-				callback(null, true);
-			});
-		});
+Vote.getUidVote = async function (uid, pollId) {
+	const options = await Poll.getOptions(pollId, true);
+	return {
+		pollId: pollId,
+		uid: uid,
+		options: options
+			.filter(option => option.votes.some(_uid => parseInt(_uid, 10) === parseInt(uid, 10)))
+			.map(option => option.id),
 	};
+};
 
-	Vote.getUidVote = function (uid, pollId, callback) {
-		Poll.getOptions(pollId, true, (err, options) => {
-			callback(err, {
-				pollId: pollId,
-				uid: uid,
-				options: options
-					.filter(option => option.votes.some(_uid => parseInt(_uid, 10) === parseInt(uid, 10)))
-					.map(option => option.id),
-			});
-		});
-	};
+Vote.update = async function (voteData) {
+	await Vote.remove(voteData);
+	await Vote.add(voteData);
+};
 
-	Vote.update = function (voteData, callback) {
-		async.series([
-			function (next) {
-				Vote.remove(voteData, next);
-			},
-			function (next) {
-				Vote.add(voteData, next);
-			},
-		], callback);
-	};
+Vote.canUpdateVote = async function (uid, pollId) {
+	const [ended, deleted, updateDisabled] = await Promise.all([
+		Poll.hasEnded(pollId),
+		Poll.isDeleted(pollId),
+		Poll.doesDisallowVoteUpdate(pollId),
+	]);
+	return !ended && !deleted && !updateDisabled;
+};
 
-	Vote.canUpdateVote = function (uid, pollId, callback) {
-		async.parallel([
-			function (next) {
-				// Ended?
-				Poll.hasEnded(pollId, next);
-			},
-			function (next) {
-				// Deleted?
-				Poll.isDeleted(pollId, next);
-			},
-			function (next) {
-				// voteUpdate?
-				Poll.doesDisallowVoteUpdate(pollId, next);
-			},
-		], (err, result) => {
-			callback(err, result.indexOf(true) === -1);
-		});
-	};
+Vote.canVote = async function (uid, pollId) {
+	const [ended, deleted, hasVoted] = await Promise.all([
+		Poll.hasEnded(pollId),
+		Poll.isDeleted(pollId),
+		Vote.hasUidVoted(uid, pollId),
+	]);
+	return !ended && !deleted && !hasVoted;
+};
 
-	Vote.canVote = function (uid, pollId, callback) {
-		async.parallel([
-			function (next) {
-				// Ended?
-				Poll.hasEnded(pollId, next);
-			},
-			function (next) {
-				// Deleted?
-				Poll.isDeleted(pollId, next);
-			},
-			function (next) {
-				// Already voted?
-				Vote.hasUidVoted(uid, pollId, next);
-			},
-		], (err, result) => {
-			callback(err, result.indexOf(true) === -1);
-		});
-	};
+Vote.hasUidVoted = async function (uid, pollId) {
+	const score = await NodeBB.db.sortedSetScore(`poll:${pollId}:voters`, uid);
+	return !!score;
+};
 
-	Vote.hasUidVoted = function (uid, pollId, callback) {
-		NodeBB.db.sortedSetScore(`poll:${pollId}:voters`, uid, (err, score) => {
-			callback(err, !!score);
-		});
-	};
+Vote.hasUidVotedOnOption = async function (uid, pollId, option) {
+	const score = await NodeBB.db.sortedSetScore(`poll:${pollId}:options:${option}:votes`, uid);
+	return !!score;
+};
 
-	Vote.hasUidVotedOnOption = function (uid, pollId, option, callback) {
-		NodeBB.db.sortedSetScore(`poll:${pollId}:options:${option}:votes`, uid, (err, score) => {
-			callback(err, !!score);
-		});
-	};
-}(exports));