nodebb-plugin-poll 3.2.9 → 4.0.0

package/lib/poll.js

@@ -1,111 +1,263 @@
 'use strict';
 
-const NodeBB = require('./nodebb');
+const db = require.main.require('./src/database');
+const privileges = require.main.require('./src/privileges');
 
 const Vote = require('./vote');
-const Scheduler = require('./scheduler');
 
 const Poll = exports;
 
-const POLL_DATA_VERSION = 2;
-
-Poll.add = async function (pollData, postData) {
-	const pollId = await NodeBB.db.incrObjectField('global', 'nextPollId');
+Poll.add = async function (postData, polls) {
+	// postData is what is being saved to db
+	// polls is submited by user
+	const savePolls = [];
+	for (const pollData of polls) {
+		// eslint-disable-next-line no-await-in-loop
+		const pollId = await db.incrObjectField('global', 'nextPollId');
+
+		const poll = {
+			pollId: pollId,
+			title: pollData.title,
+			uid: postData.editor || postData.uid,
+			pid: postData.pid,
+			deleted: 0,
+			end: pollData.end || 0,
+			maximumVotesPerUser: pollData.maximumVotesPerUser || 1,
+			timestamp: postData.edited || postData.timestamp,
+		};
+		if (Object.hasOwn(pollData, 'allowAnonVoting')) {
+			poll.allowAnonVoting = pollData.allowAnonVoting;
+		}
+		if (Object.hasOwn(pollData, 'disallowVoteUpdate')) {
+			poll.disallowVoteUpdate = pollData.disallowVoteUpdate;
+		}
+		// [{id: '1772931625035', title: 'option 1'} {id: '1772931626635', title: 'option 2'}]
+		poll.options = JSON.stringify(pollData.options || []);
+
+		savePolls.push(poll);
+	}
 
-	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,
-	};
+	await Promise.all([
+		db.setObjectBulk(savePolls.map(p => [`poll:${p.pollId}`, p])),
+		db.sortedSetAdd('polls:createtime', savePolls.map(p => p.timestamp), savePolls.map(p => p.pollId)),
+	]);
+	return savePolls;
+};
 
-	pollData.options = pollData.options.map((val, i) => ({
-		id: i,
-		title: val,
-	}));
+Poll.deletePolls = async function (pollIds) {
+	if (!pollIds.length) return;
+	const polls = await db.getObjects(pollIds.map(pollId => `poll:${pollId}`));
+	const bulkDelete = [];
+	polls.forEach((poll) => {
+		if (poll && poll.options) {
+			const options = tryParseOptions(poll.options);
+			options.forEach((option) => {
+				bulkDelete.push(`poll:${poll.pollId}:options:${option.id}:votes`);
+			});
+		}
+	});
 
+	bulkDelete.push(...pollIds.map(pollId => `poll:${pollId}`));
+	bulkDelete.push(...pollIds.map(pollId => `poll:${pollId}:voters`));
+	bulkDelete.push(...pollIds.map(pollId => `poll:${pollId}:anon:voters`));
 	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])
-		)),
+		db.deleteAll(bulkDelete),
+		db.sortedSetRemove('polls:createtime', pollIds),
 	]);
+};
 
-	// Check if this poll is scheduled to end
-	if (parseInt(pollData.settings.end, 10) > 0) {
-		Poll.schedule(pollId);
-	}
+Poll.edit = async function (postData, newPolls) {
+	// figure out which polls are new, which are edited and which are deleted
+	const newPollIds = newPolls.map(p => String(p.pollId));
+	const currentPollIds = await Poll.getPollIdsByPid(postData.pid);
+	const toAdd = newPolls.filter(p => !currentPollIds.includes(String(p.pollId)));
+	const toUpdate = newPolls.filter(p => currentPollIds.includes(String(p.pollId)));
+	const toDelete = currentPollIds.filter(pollId => !newPollIds.includes(String(pollId)));
+	const currentPolls = await db.getObjects(currentPollIds.map(pollId => `poll:${pollId}`));
+
+	await Poll.deletePolls(toDelete);
+
+	const savedPolls = await Poll.add(postData, toAdd);
+	toAdd.forEach((poll, index) => {
+		// overwrite with correct pollId generated in add function
+		// this also updates items in newPolls array with correct pollId so that it can be saved to post object at the end
+		poll.pollId = savedPolls[index].pollId;
+	});
 
-	return pollId;
+	const bulkUpdateOptions = [];
+	const bulkDeleteOptions = [];
+	toUpdate.forEach((poll) => {
+		if (poll) {
+			const currentPoll = currentPolls.find(p => String(p.pollId) === String(poll.pollId));
+			if (currentPoll) {
+				const currentOptions = tryParseOptions(currentPoll.options);
+				const newOptions = poll.options || [];
+				currentOptions.forEach((option) => {
+					if (!newOptions.find(o => String(o.id) === String(option.id))) {
+						bulkDeleteOptions.push(`poll:${poll.pollId}:options:${option.id}:votes`);
+					}
+				});
+			}
+
+			bulkUpdateOptions.push([`poll:${poll.pollId}`, {
+				title: poll.title,
+				end: poll.end || 0,
+				maximumVotesPerUser: poll.maximumVotesPerUser || 1,
+				disallowVoteUpdate: poll.disallowVoteUpdate || 0,
+				allowAnonVoting: poll.allowAnonVoting || 0,
+				options: JSON.stringify(poll.options || []),
+			}]);
+		}
+	});
+	await db.setObjectBulk(bulkUpdateOptions);
+	await db.deleteAll(bulkDeleteOptions);
+
+	await Promise.all(toUpdate.map(poll => updateVotersFromOptions(poll)));
+
+	if (newPollIds.length) {
+		await db.setObjectField(
+			`post:${postData.pid}`,
+			'pollIds',
+			JSON.stringify(newPolls.map(p => p.pollId))
+		);
+	} else {
+		await db.deleteObjectField(`post:${postData.pid}`, 'pollIds');
+	}
 };
 
-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),
+async function updateVotersFromOptions(poll) {
+	// this function updates `poll:${pollId}:voters` sorted set based on the votes on options,
+	// this is needed when options are removed from a poll via edit
+	const options = poll.options || [];
+
+	const currentVoters = await db.getSortedSetsMembers(
+		options.map(option => `poll:${poll.pollId}:options:${option.id}:votes`)
+	);
+	const currentVoterSet = [...new Set(currentVoters.flat())];
+	const timestamps = await db.sortedSetScores(`poll:${poll.pollId}:voters`, currentVoterSet);
+	await db.delete(`poll:${poll.pollId}:voters`);
+	await db.sortedSetAdd(`poll:${poll.pollId}:voters`, timestamps, currentVoterSet);
+}
+
+Poll.get = async function (pollId, uid, withVotes = false) {
+	const [info, hasVoted, vote] = await Promise.all([
+		Poll.getInfo(pollId, withVotes),
 		uid ? Vote.hasUidVoted(uid, pollId) : false,
 		uid ? Vote.getUidVote(uid, pollId) : null,
 	]);
-
-	options.forEach((option) => {
+	if (!info) {
+		return null;
+	}
+	const canRead = await privileges.posts.can('topics:read', info.pid, uid);
+	if (!canRead) {
+		throw new Error('[[error:no-privileges]]');
+	}
+	info.options.forEach((option) => {
 		const percentage = ((option.voteCount / info.voteCount) * 100).toFixed(0);
 		option.percentage = isNaN(percentage) ? 0 : percentage;
 	});
 
-	settings.disallowVoteUpdate = parseInt(settings.disallowVoteUpdate, 10);
+	info.disallowVoteUpdate = parseInt(info.disallowVoteUpdate, 10);
 	return {
 		info,
-		options,
-		settings,
+		options: info.options,
 		hasVoted,
 		vote,
 	};
 };
 
-Poll.getPollIdByTid = async function (tid) {
-	return await NodeBB.db.getObjectField(`topic:${tid}`, 'pollId');
+Poll.getPollIdsByPid = async function (pid) {
+	const pollIdsJson = await db.getObjectField(`post:${pid}`, 'pollIds');
+	if (!pollIdsJson) {
+		return [];
+	}
+	try {
+		const pollIds = JSON.parse(pollIdsJson || '[]');
+		return Array.isArray(pollIds) ? pollIds.map(p => String(p)) : [];
+	} catch (err) {
+		return [];
+	}
 };
 
-Poll.getPollIdByPid = async function (pid) {
-	return await NodeBB.db.getObjectField(`post:${pid}`, 'pollId');
+Poll.getPollIdsByPids = async function (pids) {
+	const postData = await db.getObjectsFields(pids.map(pid => `post:${pid}`), ['pollIds']);
+	return postData.map((post) => {
+		if (!post || !post.pollIds) {
+			return [];
+		}
+		try {
+			const pollIds = JSON.parse(post.pollIds || '[]');
+			return Array.isArray(pollIds) ? pollIds.map(p => String(p)) : [];
+		} catch (err) {
+			return [];
+		}
+	});
 };
 
-Poll.getInfo = async function (pollId) {
+Poll.getInfo = async function (pollId, withVotes = false) {
 	const [poll, voteCount] = await Promise.all([
-		NodeBB.db.getObject(`poll:${pollId}`),
+		db.getObject(`poll:${pollId}`),
 		Poll.getVoteCount(pollId),
 	]);
+	if (!poll) {
+		return null;
+	}
 	poll.voteCount = parseInt(voteCount, 10) || 0;
+	const end = parseInt(poll.end, 10);
+	poll.ended = end > 0 && Date.now() > end;
+	poll.options = await loadOptions(pollId, poll.options, withVotes);
 	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))
-	);
+	const optionsJson = await db.getObjectField(`poll:${pollId}`, 'options');
+	return await loadOptions(pollId, optionsJson, withVotes);
+};
+
+Poll.getPollOptionIds = async function (pollId) {
+	const optionsJson = await db.getObjectField(`poll:${pollId}`, 'options');
+	return tryParseOptions(optionsJson).map(opts => opts && String(opts.id));
 };
 
+async function loadOptions(pollId, optionsJson, withVotes = false) {
+	const options = tryParseOptions(optionsJson);
+
+	const votes = await db.getSortedSetsMembers(options.map(o => `poll:${pollId}:options:${o.id}:votes`));
+
+	options.forEach((option, index) => {
+		if (option) {
+			option.voteCount = votes[index].length;
+			if (withVotes) {
+				option.votes = votes[index];
+			}
+		}
+	});
+	return options;
+}
+
+function tryParseOptions(optionsJson) {
+	if (!optionsJson) return [];
+	try {
+		const optionsArray = JSON.parse(optionsJson || '[]');
+		return Array.isArray(optionsArray) ? optionsArray : [];
+	} catch (err) {
+		return [];
+	}
+}
+
 Poll.getOption = async function (pollId, option, withVotes = false) {
-	const [optionData, votes, voteCount] = await Promise.all([
-		NodeBB.db.getObject(`poll:${pollId}:options:${option}`),
+	const [optionsJson, votes, voteCount] = await Promise.all([
+		db.getObjectField(`poll:${pollId}`, 'options'),
 		withVotes ?
-			NodeBB.db.getSortedSetRange(`poll:${pollId}:options:${option}:votes`, 0, -1) :
+			db.getSortedSetRange(`poll:${pollId}:options:${option}:votes`, 0, -1) :
 			null,
 		Poll.getOptionVoteCount(pollId, option),
 	]);
+	const options = tryParseOptions(optionsJson);
+	const optionData = options.find(opt => String(opt.id) === String(option));
+	if (!optionData) {
+		return null;
+	}
 
 	if (votes) {
 		optionData.votes = votes;
@@ -115,30 +267,28 @@ Poll.getOption = async function (pollId, option, withVotes = false) {
 };
 
 Poll.getVotersCount = async function (pollId) {
-	return await NodeBB.db.sortedSetCard(`poll:${pollId}:voters`);
+	return await 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`)
+	const optionIds = await Poll.getPollOptionIds(pollId);
+	return await db.sortedSetsCardSum(
+		optionIds.map(option => `poll:${pollId}:options:${option}:votes`)
 	);
 };
 
 Poll.getOptionVoteCount = async function (pollId, option) {
-	return await NodeBB.db.sortedSetCard(`poll:${pollId}:options:${option}:votes`);
+	return await db.sortedSetCard(`poll:${pollId}:options:${option}:votes`);
 };
 
 Poll.hasOption = async function (pollId, option) {
-	return await NodeBB.db.isSetMember(`poll:${pollId}:options`, option);
+	const optionIds = new Set(await Poll.getPollOptionIds(pollId));
+	return optionIds.has(String(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`);
+	const optionIds = new Set(await Poll.getPollOptionIds(pollId));
+	return options.map(option => optionIds.has(String(option)));
 };
 
 Poll.isDeleted = async function (pollId) {
@@ -146,81 +296,52 @@ Poll.isDeleted = async function (pollId) {
 	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.delete = async function (pollIds) {
+	await db.setObject(
+		pollIds.map(pollId => `poll:${pollId}`),
+		{ deleted: 1 },
+	);
 };
 
-Poll.getScheduled = async function () {
-	return await NodeBB.db.getSetMembers('polls:scheduled');
+Poll.restore = async function (pollIds) {
+	await db.setObject(
+		pollIds.map(pollId => `poll:${pollId}`),
+		{
+			edited: 0,
+			deleted: 0,
+		},
+	);
 };
 
 Poll.hasEnded = async function (pollId) {
-	const result = await Poll.getField(pollId, 'ended');
-	return parseInt(result, 10) === 1;
+	let end = await Poll.getField(pollId, 'end');
+	end = parseInt(end, 10);
+	return end > 0 && Date.now() > end;
 };
 
 Poll.doesDisallowVoteUpdate = async function (pollId) {
-	const result = await Poll.getSettingsField(pollId, 'disallowVoteUpdate');
+	const result = await Poll.getField(pollId, 'disallowVoteUpdate');
 	return parseInt(result, 10) === 1;
 };
 
 Poll.doesAllowVoteUpdate = async function (pollId) {
-	const result = await Poll.getSettingsField(pollId, 'disallowVoteUpdate');
+	const result = await Poll.getField(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);
+	await db.setObjectField(`poll:${pollId}`, field, value);
 };
 
 Poll.setFields = async function (pollId, data) {
-	await NodeBB.db.setObject(`poll:${pollId}`, data);
+	await db.setObject(`poll:${pollId}`, data);
 };
 
 Poll.getField = async function (pollId, field) {
-	return await NodeBB.db.getObjectField(`poll:${pollId}`, field);
+	return await 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);
+	return await db.getObjectFields(`poll:${pollId}`, fields);
 };
 

package/lib/sockets.js

@@ -1,43 +1,44 @@
 'use strict';
 
 const _ = require.main.require('lodash');
-const NodeBB = require('./nodebb');
+const db = require.main.require('./src/database');
+const posts = require.main.require('./src/posts');
+const topics = require.main.require('./src/topics');
+const privileges = require.main.require('./src/privileges');
 
+const NodeBB = require('./nodebb');
 const Config = require('./config');
 const Poll = require('./poll');
 const Vote = require('./vote');
 
 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');
+	const settings = await Config.getSettings();
+	const allowAnon = parseInt(settings.allowGuestsToViewResults, 10) === 1;
 
 	if (!data) {
 		throw new Error('Invalid request, request data is not defined');
 	}
-	if (isNaN(parseInt(data.pollId, 10))) {
+	if (!Array.isArray(data.pollIds) || !data.pollIds.length) {
 		throw new Error('Invalid request, pollId is required');
 	}
 	if ((!socket.uid && !allowAnon)) {
 		throw new Error('Invalid request, anonymous access is not allowed');
 	}
+	return await Promise.all(data.pollIds.map(async (pollId) => {
+		const pollData = await Poll.get(pollId, socket.uid, !!socket.uid);
+		if (!pollData) {
+			return null;
+		}
 
-	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');
-	}
-
-	if (parseInt(pollData.settings.allowAnonVoting, 10) === 1) {
-		await anonymizeVoters(socket.uid, data.pollId, pollData.options);
-	}
+		if (parseInt(pollData.allowAnonVoting, 10) === 1) {
+			await anonymizeVoters(socket.uid, pollId, pollData.options);
+		}
 
-	pollData.optionType = parseInt(pollData.settings.maxvotes, 10) > 1 ? 'checkbox' : 'radio';
-	return pollData;
+		pollData.optionType = parseInt(pollData.maximumVotesPerUser, 10) > 1 ? 'checkbox' : 'radio';
+		return pollData;
+	}));
 };
 
 Sockets.vote = async function (socket, data) {
@@ -50,21 +51,21 @@ Sockets.vote = async function (socket, data) {
 
 	data.uid = socket.uid;
 
-	const [canVote, optionsFilter, settings] = await Promise.all([
+	const [pollData, canVote, optionsFilter] = await Promise.all([
+		db.getObject(`poll:${data.pollId}`),
 		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 (data.options.length > parseInt(pollData.maximumVotesPerUser, 10)) {
+		throw new Error(`You can only vote for ${pollData.maximumVotesPerUser} options on this poll.`);
 	}
 
-	if (data.voteAnon && parseInt(settings.allowAnonVoting, 10) !== 1) {
+	if (data.voteAnon && parseInt(pollData.allowAnonVoting, 10) !== 1) {
 		throw new Error('[[poll:error.anon-voting-not-allowed]]');
 	}
 
@@ -74,8 +75,11 @@ Sockets.vote = async function (socket, data) {
 
 	await Vote.add(data);
 
-	const pollData = await Poll.get(data.pollId, socket.uid, false);
-	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', { pollData, uid: socket.uid });
+	const returnPoll = await Poll.get(data.pollId, socket.uid, false);
+	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', {
+		pollData: returnPoll,
+		uid: socket.uid,
+	});
 };
 
 Sockets.updateVote = async function (socket, data) {
@@ -87,18 +91,18 @@ Sockets.updateVote = async function (socket, data) {
 	}
 	data.uid = socket.uid;
 
-	const [canUpdateVote, optionsFilter, settings] = await Promise.all([
+	const [pollData, canUpdateVote, optionsFilter] = await Promise.all([
+		db.getObject(`poll:${data.pollId}`),
 		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 (data.options.length > parseInt(pollData.maximumVotesPerUser, 10)) {
+		throw new Error(`You can only vote for ${pollData.maximumVotesPerUser} options on this poll.`);
 	}
 
 	if (!canUpdateVote) {
@@ -110,8 +114,11 @@ Sockets.updateVote = async function (socket, data) {
 	}
 
 	await Vote.update(data);
-	const pollData = await Poll.get(data.pollId, socket.uid, false);
-	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', { pollData, uid: socket.uid });
+	const returnPoll = await Poll.get(data.pollId, socket.uid, false);
+	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', {
+		pollData: returnPoll,
+		uid: socket.uid,
+	});
 };
 
 Sockets.removeVote = async function (socket, data) {
@@ -130,24 +137,32 @@ Sockets.removeVote = async function (socket, data) {
 
 	await Vote.remove(data);
 	const pollData = await Poll.get(data.pollId, socket.uid, false);
-	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', { pollData, uid: socket.uid });
+	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', {
+		pollData,
+		uid: socket.uid,
+	});
 };
 
 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, settings, option] = await Promise.all([
+	const [poll, option] = await Promise.all([
 		Poll.getInfo(data.pollId),
-		Poll.getSettings(data.pollId),
 		Poll.getOption(data.pollId, data.optionId, true),
 	]);
-
-	if (!option.votes || !option.votes.length) {
+	if (!poll) {
+		throw new Error('[[error:invalid-data]]');
+	}
+	const canRead = await privileges.posts.can('topics:read', poll.pid, socket.uid);
+	if (!canRead) {
+		throw new Error('[[error:no-privileges]]');
+	}
+	if (!option || !option.votes || !option.votes.length) {
 		return option;
 	}
 
-	if (parseInt(settings.allowAnonVoting, 10) === 1) {
+	if (parseInt(poll.allowAnonVoting, 10) === 1) {
 		await anonymizeVoters(socket.uid, data.pollId, [option]);
 	}
 
@@ -164,21 +179,22 @@ Sockets.getOptionDetails = async function (socket, data) {
 };
 
 Sockets.canCreate = async function (socket, data) {
-	if (!socket.uid || !data || (isNaN(parseInt(data.cid, 10)) && isNaN(parseInt(data.pid, 10)))) {
+	if (!socket.uid || !data) {
 		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');
+	let { cid, tid, pid } = data;
+	if (pid) {
+		cid = await posts.getCidByPid(pid);
+	} else if (tid) {
+		cid = await topics.getTopicField(tid, 'cid');
 	}
-	return await checkPrivs(data.cid, socket.uid);
+	return await checkPrivs(cid, socket.uid);
 };
 
 async function anonymizeVoters(callerUid, pollId, options) {
 	const uids = _.uniq(options.map(opt => opt.votes).flat());
 	const [isAnon, isPrivileged] = await Promise.all([
-		NodeBB.db.isSortedSetMembers(`poll:${pollId}:anon:voters`, uids),
+		db.isSortedSetMembers(`poll:${pollId}:anon:voters`, uids),
 		NodeBB.User.isPrivileged(callerUid),
 	]);
 	if (isPrivileged) {