nodebb-plugin-poll 3.1.8 → 3.2.1

package/lib/poll.js

@@ -1,312 +1,226 @@
 'use strict';
 
-const async = require('async');
-
 const NodeBB = require('./nodebb');
 
 const Vote = require('./vote');
 const Scheduler = require('./scheduler');
 
-(function (Poll) {
-	const POLL_DATA_VERSION = 2;
-
-	Poll.add = function (pollData, postData, callback) {
-		NodeBB.db.incrObjectField('global', 'nextPollId', (err, pollId) => {
-			if (err) {
-				return callback(err);
-			}
-
-			const poll = {
-				pollId: pollId,
-				uid: postData.editor || postData.uid,
-				tid: postData.tid,
-				pid: postData.pid,
-				deleted: 0,
-				ended: 0,
-				timestamp: postData.edited || postData.timestamp,
-				version: POLL_DATA_VERSION,
-			};
-
-			pollData.options = pollData.options.map((val, i) => ({
-				id: i,
-				title: val,
-			}));
-
-			// Save asynchronously
-			async.parallel([
-				async.apply(async.series, [
-					// Save poll options in parallel
-					async.apply(
-						async.parallel,
-						pollData.options.map(
-							option => async.apply(NodeBB.db.setObject, `poll:${pollId}:options:${option.id}`, option)
-						),
-					),
-					// Add poll option id to option list synchronously
-					// To avoid race condition causing duplicate error
-					async.apply(
-						async.series,
-						pollData.options.map(
-							option => async.apply(NodeBB.db.setAdd, `poll:${pollId}:options`, option.id)
-						),
-					),
-				]),
-				async.apply(NodeBB.db.setObject, `poll:${pollId}`, poll),
-				async.apply(NodeBB.db.setObject, `poll:${pollId}:settings`, pollData.settings),
-				async.apply(NodeBB.db.listAppend, 'polls', pollId),
-				async.apply(NodeBB.db.setObjectField, `topic:${poll.tid}`, 'pollId', pollId),
-			], (err) => {
-				if (err) {
-					return callback(err);
-				}
-
-				// Check if this poll is scheduled to end
-				if (parseInt(pollData.settings.end, 10) > 0) {
-					Poll.schedule(pollId);
-				}
-
-				return callback(null, pollId);
-			});
-		});
-	};
-
-	Poll.get = function (pollId, uid, withVotes, callback) {
-		async.parallel({
-			info: function (next) {
-				Poll.getInfo(pollId, next);
-			},
-			options: function (next) {
-				Poll.getOptions(pollId, withVotes, next);
-			},
-			settings: function (next) {
-				Poll.getSettings(pollId, next);
-			},
-			hasVoted: function (next) {
-				if (uid) {
-					Vote.hasUidVoted(uid, pollId, next);
-				} else {
-					next(null, false);
-				}
-			},
-			vote: function (next) {
-				if (uid) {
-					Vote.getUidVote(uid, pollId, next);
-				} else {
-					next(null, null);
-				}
-			},
-		}, (err, pollData) => {
-			if (err) {
-				return callback(err);
-			}
-			pollData.options.forEach((option) => {
-				const percentage = ((option.voteCount / pollData.info.voteCount) * 100).toFixed(0);
-				option.percentage = isNaN(percentage) ? 0 : percentage;
-			});
-			pollData.settings.disallowVoteUpdate = parseInt(pollData.settings.disallowVoteUpdate, 10);
-			callback(null, pollData);
-		});
-	};
-
-	Poll.getPollIdByTid = function (tid, callback) {
-		NodeBB.db.getObjectField(`topic:${tid}`, 'pollId', callback);
-	};
-
-	Poll.getPollIdByPid = function (pid, callback) {
-		NodeBB.db.getObjectField(`post:${pid}`, 'pollId', callback);
-	};
-
-	Poll.getInfo = function (pollId, callback) {
-		async.parallel({
-			poll: function (next) {
-				NodeBB.db.getObject(`poll:${pollId}`, next);
-			},
-			voteCount: function (next) {
-				Poll.getVoteCount(pollId, next);
-			},
-		}, (err, results) => {
-			if (err) {
-				return callback(err);
-			}
-			results.poll.voteCount = parseInt(results.voteCount, 10) || 0;
-			callback(null, results.poll);
-		});
-	};
-
-	Poll.getOptions = function (pollId, withVotes, callback) {
-		if (typeof withVotes === 'function') {
-			callback = withVotes;
-			withVotes = false;
-		}
-
-		NodeBB.db.getSetMembers(`poll:${pollId}:options`, (err, options) => {
-			if (err) {
-				return callback(err);
-			}
-			// sort options according to option id. option id are supposed to preseve the order as in Poll.add(),
-			// when the user create the poll
-			options.sort((a, b) => a - b);
-			async.map(options, (option, next) => {
-				Poll.getOption(pollId, option, withVotes, next);
-			}, callback);
-		});
-	};
-
-	Poll.getOption = function (pollId, option, withVotes, callback) {
-		async.parallel({
-			option: function (next) {
-				NodeBB.db.getObject(`poll:${pollId}:options:${option}`, next);
-			},
-			votes: function (next) {
-				if (withVotes) {
-					NodeBB.db.getSortedSetRange(`poll:${pollId}:options:${option}:votes`, 0, -1, next);
-				} else {
-					next();
-				}
-			},
-			voteCount: function (next) {
-				Poll.getOptionVoteCount(pollId, option, next);
-			},
-		}, (err, results) => {
-			if (err) {
-				return callback(err);
-			}
-			if (results.votes) {
-				results.option.votes = results.votes;
-			}
-			results.option.voteCount = parseInt(results.voteCount, 10) || 0;
-
-			callback(null, results.option);
-		});
-	};
-
-	Poll.getVotersCount = function (pollId, callback) {
-		NodeBB.db.sortedSetCard(`poll:${pollId}:voters`, callback);
-	};
-
-	Poll.getVoteCount = function (pollId, callback) {
-		NodeBB.db.getSetMembers(`poll:${pollId}:options`, (err, options) => {
-			if (err) {
-				console.error(err);
-			}
-
-			async.map(options, (option, next) => {
-				Poll.getOptionVoteCount(pollId, option, next);
-			}, (err, results) => {
-				if (err) {
-					return callback(err);
-				}
-				callback(null, results.reduce((a, b) => a + b, 0));
-			});
-		});
-	};
-
-	Poll.getOptionVoteCount = function (pollId, option, callback) {
-		NodeBB.db.sortedSetCard(`poll:${pollId}:options:${option}:votes`, callback);
-	};
-
-	Poll.hasOption = function (pollId, option, callback) {
-		NodeBB.db.isSetMember(`poll:${pollId}:options`, option, callback);
-	};
-
-	Poll.hasOptions = function (pollId, options, callback) {
-		NodeBB.db.isSetMembers(`poll:${pollId}:options`, options, callback);
-	};
-
-	Poll.getSettings = function (pollId, callback) {
-		NodeBB.db.getObject(`poll:${pollId}:settings`, callback);
-	};
-
-	Poll.isDeleted = function (pollId, callback) {
-		Poll.getField(pollId, 'deleted', (err, result) => {
-			callback(err, parseInt(result, 10) === 1);
-		});
-	};
-
-	Poll.delete = function (pollId) {
-		Poll.setField(pollId, 'deleted', 1);
-	};
+const Poll = exports;
+
+const POLL_DATA_VERSION = 2;
+
+Poll.add = async function (pollData, postData) {
+	const pollId = await NodeBB.db.incrObjectField('global', 'nextPollId');
+
+	const poll = {
+		pollId: pollId,
+		uid: postData.editor || postData.uid,
+		tid: postData.tid,
+		pid: postData.pid,
+		deleted: 0,
+		ended: 0,
+		timestamp: postData.edited || postData.timestamp,
+		version: POLL_DATA_VERSION,
+	};
+
+	pollData.options = pollData.options.map((val, i) => ({
+		id: i,
+		title: val,
+	}));
+
+	await Promise.all([
+		NodeBB.db.setObject(`poll:${pollId}`, poll),
+		NodeBB.db.setObject(`poll:${pollId}:settings`, pollData.settings),
+		NodeBB.db.listAppend('polls', pollId),
+		NodeBB.db.setObjectField(`topic:${poll.tid}`, 'pollId', pollId),
+		NodeBB.db.setAdd(`poll:${pollId}:options`, pollData.options.map(option => option.id)),
+		NodeBB.db.setObjectBulk(pollData.options.map(
+			option => ([`poll:${pollId}:options:${option.id}`, option])
+		)),
+	]);
+
+	// Check if this poll is scheduled to end
+	if (parseInt(pollData.settings.end, 10) > 0) {
+		Poll.schedule(pollId);
+	}
+
+	return pollId;
+};
+
+Poll.get = async function (pollId, uid, withVotes) {
+	const [info, options, settings, hasVoted, vote] = await Promise.all([
+		Poll.getInfo(pollId),
+		Poll.getOptions(pollId, withVotes),
+		Poll.getSettings(pollId),
+		uid ? Vote.hasUidVoted(uid, pollId) : false,
+		uid ? Vote.getUidVote(uid, pollId) : null,
+	]);
+
+	options.forEach((option) => {
+		const percentage = ((option.voteCount / info.voteCount) * 100).toFixed(0);
+		option.percentage = isNaN(percentage) ? 0 : percentage;
+	});
+
+	settings.disallowVoteUpdate = parseInt(settings.disallowVoteUpdate, 10);
+	return {
+		info,
+		options,
+		settings,
+		hasVoted,
+		vote,
+	};
+};
+
+Poll.getPollIdByTid = async function (tid) {
+	return await NodeBB.db.getObjectField(`topic:${tid}`, 'pollId');
+};
+
+Poll.getPollIdByPid = async function (pid) {
+	return await NodeBB.db.getObjectField(`post:${pid}`, 'pollId');
+};
+
+Poll.getInfo = async function (pollId) {
+	const [poll, voteCount] = await Promise.all([
+		NodeBB.db.getObject(`poll:${pollId}`),
+		Poll.getVoteCount(pollId),
+	]);
+	poll.voteCount = parseInt(voteCount, 10) || 0;
+	return poll;
+};
+
+Poll.getOptions = async function (pollId, withVotes = false) {
+	const options = await NodeBB.db.getSetMembers(`poll:${pollId}:options`);
+	// sort options according to option id. option id are supposed to preseve the order as in Poll.add(),
+	// when the user create the poll
+	options.sort((a, b) => a - b);
+	return await Promise.all(
+		options.map(option => Poll.getOption(pollId, option, withVotes))
+	);
+};
+
+Poll.getOption = async function (pollId, option, withVotes = false) {
+	const [optionData, votes, voteCount] = await Promise.all([
+		NodeBB.db.getObject(`poll:${pollId}:options:${option}`),
+		withVotes ?
+			NodeBB.db.getSortedSetRange(`poll:${pollId}:options:${option}:votes`, 0, -1) :
+			null,
+		Poll.getOptionVoteCount(pollId, option),
+	]);
+
+	if (votes) {
+		optionData.votes = votes;
+	}
+	optionData.voteCount = parseInt(voteCount, 10) || 0;
+	return optionData;
+};
+
+Poll.getVotersCount = async function (pollId) {
+	return await NodeBB.db.sortedSetCard(`poll:${pollId}:voters`);
+};
+
+Poll.getVoteCount = async function (pollId) {
+	const options = await NodeBB.db.getSetMembers(`poll:${pollId}:options`);
+	return await NodeBB.db.sortedSetsCardSum(
+		options.map(option => `poll:${pollId}:options:${option}:votes`)
+	);
+};
+
+Poll.getOptionVoteCount = async function (pollId, option) {
+	return await NodeBB.db.sortedSetCard(`poll:${pollId}:options:${option}:votes`);
+};
+
+Poll.hasOption = async function (pollId, option) {
+	return await NodeBB.db.isSetMember(`poll:${pollId}:options`, option);
+};
+
+Poll.hasOptions = async function (pollId, options) {
+	return await NodeBB.db.isSetMembers(`poll:${pollId}:options`, options);
+};
+
+Poll.getSettings = async function (pollId) {
+	return await NodeBB.db.getObject(`poll:${pollId}:settings`);
+};
+
+Poll.isDeleted = async function (pollId) {
+	const result = await Poll.getField(pollId, 'deleted');
+	return parseInt(result, 10) === 1;
+};
+
+Poll.delete = async function (pollId) {
+	await Poll.setField(pollId, 'deleted', 1);
+};
+
+Poll.restore = async function (pollId) {
+	await Poll.setFields(pollId, {
+		edited: 0,
+		deleted: 0,
+	});
+};
+
+Poll.schedule = async function (pollId) {
+	await NodeBB.db.setAdd('polls:scheduled', pollId);
+	Scheduler.add(pollId);
+};
+
+Poll.getScheduled = async function () {
+	return await NodeBB.db.getSetMembers('polls:scheduled');
+};
+
+Poll.hasEnded = async function (pollId) {
+	const result = await Poll.getField(pollId, 'ended');
+	return parseInt(result, 10) === 1;
+};
+
+Poll.doesDisallowVoteUpdate = async function (pollId) {
+	const result = await Poll.getSettingsField(pollId, 'disallowVoteUpdate');
+	return parseInt(result, 10) === 1;
+};
+
+Poll.doesAllowVoteUpdate = async function (pollId) {
+	const result = await Poll.getSettingsField(pollId, 'disallowVoteUpdate');
+	return parseInt(result, 10) !== 1;
+};
+
+Poll.end = async function (pollId) {
+	await NodeBB.db.setRemove('polls:scheduled', pollId);
+	await Poll.setField(pollId, 'ended', 1);
+};
+
+Poll.changePid = async function (pollId, pid) {
+	await Promise.all([
+		Poll.setField(pollId, 'pid', pid),
+		NodeBB.db.setObjectField(`post:${pid}`, 'pollId', pollId),
+	]);
+};
+
+Poll.changeTid = async function (pollId, tid) {
+	await Promise.all([
+		Poll.setField(pollId, 'tid', tid),
+		NodeBB.db.setObjectField(`topic:${tid}`, 'pollId', pollId),
+	]);
+};
+
+Poll.setField = async function (pollId, field, value) {
+	await NodeBB.db.setObjectField(`poll:${pollId}`, field, value);
+};
+
+Poll.setFields = async function (pollId, data) {
+	await NodeBB.db.setObject(`poll:${pollId}`, data);
+};
+
+Poll.getField = async function (pollId, field) {
+	return await NodeBB.db.getObjectField(`poll:${pollId}`, field);
+};
+
+Poll.getFields = async function (pollId, fields) {
+	return await NodeBB.db.getObjectFields(`poll:${pollId}`, fields);
+};
+
+Poll.getSettingsField = async function (pollId, field) {
+	return await NodeBB.db.getObjectField(`poll:${pollId}:settings`, field);
+};
+
+Poll.setSettingsField = async function (pollId, field, value) {
+	await NodeBB.db.setObjectField(`poll:${pollId}:settings`, field, value);
+};
 
-	Poll.restore = function (pollId) {
-		Poll.setField(pollId, 'edited', 0);
-		Poll.setField(pollId, 'deleted', 0);
-	};
-
-	Poll.schedule = function (pollId) {
-		NodeBB.db.setAdd('polls:scheduled', pollId);
-		Scheduler.add(pollId);
-	};
-
-	Poll.getScheduled = function (callback) {
-		NodeBB.db.getSetMembers('polls:scheduled', callback);
-	};
-
-	Poll.hasEnded = function (pollId, callback) {
-		Poll.getField(pollId, 'ended', (err, result) => {
-			callback(err, parseInt(result, 10) === 1);
-		});
-	};
-
-	Poll.doesDisallowVoteUpdate = function (pollId, callback) {
-		Poll.getSettingsField(pollId, 'disallowVoteUpdate', (err, result) => {
-			callback(err, parseInt(result, 10) === 1);
-		});
-	};
-
-	Poll.doesAllowVoteUpdate = function (pollId, callback) {
-		Poll.getSettingsField(pollId, 'disallowVoteUpdate', (err, result) => {
-			callback(err, parseInt(result, 10) !== 1);
-		});
-	};
-
-	Poll.end = function (pollId) {
-		NodeBB.db.setRemove('polls:scheduled', pollId);
-		Poll.setField(pollId, 'ended', 1);
-	};
-
-	Poll.changePid = function (pollId, pid, callback) {
-		async.parallel([
-			function (next) {
-				Poll.setField(pollId, 'pid', pid, next);
-			},
-			function (next) {
-				NodeBB.db.setObjectField(`post:${pid}`, 'pollId', pollId, next);
-			},
-		], callback);
-	};
-
-	Poll.changeTid = function (pollId, tid, callback) {
-		async.parallel([
-			function (next) {
-				Poll.setField(pollId, 'tid', tid, next);
-			},
-			function (next) {
-				NodeBB.db.setObjectField(`topic:${tid}`, 'pollId', pollId, next);
-			},
-		], callback);
-	};
-
-	Poll.setField = function (pollId, field, value, callback) {
-		NodeBB.db.setObjectField(`poll:${pollId}`, field, value, callback);
-	};
-
-	Poll.setFields = function (pollId, fields, values, callback) {
-		NodeBB.db.setObjectFields(`poll:${pollId}`, fields, values, callback);
-	};
-
-	Poll.getField = function (pollId, field, callback) {
-		NodeBB.db.getObjectField(`poll:${pollId}`, field, callback);
-	};
-
-	Poll.getFields = function (pollId, fields, callback) {
-		NodeBB.db.getObjectFields(`poll:${pollId}`, fields, callback);
-	};
-
-	Poll.getSettingsField = function (pollId, field, callback) {
-		NodeBB.db.getObjectField(`poll:${pollId}:settings`, field, callback);
-	};
-
-	Poll.setSettingsField = function (pollId, field, value, callback) {
-		NodeBB.db.setObjectField(`poll:${pollId}:settings`, field, callback);
-	};
-}(exports));

package/lib/scheduler.js

@@ -5,59 +5,48 @@ const NodeBB = require('./nodebb');
 
 const Poll = require('./poll');
 
-(function (Scheduler) {
-	const jobs = {};
-
-	Scheduler.start = function () {
-		Poll.getScheduled((err, pollIds) => {
-			if (err) {
-				console.error(err);
-			}
-			pollIds.forEach((pollId) => {
-				Scheduler.add(pollId);
-			});
-		});
-	};
-
-	Scheduler.add = function (pollId) {
-		if (Object.keys(jobs).indexOf(pollId.toString()) !== -1) {
-			return;
-		}
-
-		Poll.getSettings(pollId, (err, settings) => {
-			if (err) {
-				return NodeBB.winston.error(err);
-			}
-
-			if (!settings) {
-				return NodeBB.winston.error(`[nodebb-plugin-poll/scheduler] Poll ID ${pollId} has no settings!`);
-			}
-
-			const now = Date.now();
-			const end = parseInt(settings.end, 10);
-
-			if (end < now) {
-				Scheduler.end(pollId);
-			} else {
-				const date = new Date(end);
-				NodeBB.winston.verbose(`[nodebb-plugin-poll/scheduler] Starting scheduler for poll with ID ${pollId} to end on ${date}`);
-				jobs[pollId] = new cron(date, (() => {
-					Scheduler.end(pollId);
-				}), null, true);
-			}
-		});
-	};
-
-	Scheduler.end = function (pollId) {
-		NodeBB.winston.verbose(`[nodebb-plugin-poll/scheduler] Ending poll with ID ${pollId}`);
-
-		const index = Object.keys(jobs).indexOf(pollId.toString());
-
-		if (index !== -1 && jobs[pollId] !== undefined) {
-			jobs[pollId].stop();
-			delete jobs[pollId];
-		}
-
-		Poll.end(pollId);
-	};
-}(exports));
+const Scheduler = exports;
+const jobs = {};
+
+Scheduler.start = async function () {
+	const pollIds = await Poll.getScheduled();
+	await Promise.all(pollIds.map(Scheduler.add));
+};
+
+Scheduler.add = async function (pollId) {
+	if (Object.keys(jobs).indexOf(pollId.toString()) !== -1) {
+		return;
+	}
+
+	const settings = await Poll.getSettings(pollId);
+	if (!settings) {
+		return NodeBB.winston.error(`[nodebb-plugin-poll/scheduler] Poll ID ${pollId} has no settings!`);
+	}
+
+	const now = Date.now();
+	const end = parseInt(settings.end, 10);
+
+	if (end < now) {
+		Scheduler.end(pollId);
+	} else {
+		const date = new Date(end);
+		NodeBB.winston.verbose(`[nodebb-plugin-poll/scheduler] Starting scheduler for poll with ID ${pollId} to end on ${date}`);
+		jobs[pollId] = new cron(date, (() => {
+			Scheduler.end(pollId);
+		}), null, true);
+	}
+};
+
+Scheduler.end = async function (pollId) {
+	NodeBB.winston.verbose(`[nodebb-plugin-poll/scheduler] Ending poll with ID ${pollId}`);
+
+	const index = Object.keys(jobs).indexOf(pollId.toString());
+
+	if (index !== -1 && jobs[pollId] !== undefined) {
+		jobs[pollId].stop();
+		delete jobs[pollId];
+	}
+
+	await Poll.end(pollId);
+};
+