nodebb-plugin-poll 4.0.15 → 4.1.0

package/.editorconfig

@@ -1,8 +1,8 @@
-root = true
-
-[{*.js, *.css, *.tpl, *.json}]
-indent_style = tab
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
+root = true
+
+[{*.js, *.css, *.tpl, *.json}]
+indent_style = tab
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
 insert_final_newline = false

package/LICENSE

@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Erik Schamper
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+The MIT License (MIT)
+
+Copyright (c) 2015 Erik Schamper
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/eslint.config.mjs

@@ -6,5 +6,12 @@ import publicConfig from 'eslint-config-nodebb/public';
 export default [
 	...publicConfig,
 	...serverConfig,
+	{
+		languageOptions: {
+			globals: {
+				nodebb: 'readonly',
+			},
+		},
+	},
 ];
 

package/languages/en_GB/poll.json

@@ -10,6 +10,7 @@
   "max_votes": "Maximum number of votes per user",
   "disallow_vote_update": "Don't allow users to update their vote",
   "allow_anon_voting": "Allow anonymous voting",
+  "anon_voting_not_federated": "Anonymous votes are not federated to other servers.",
   "info_choices": "A number greater than 1 will enable multiple choice polls.",
   "settings": "Settings",
   "save": "Save",

package/lib/hooks.js

@@ -49,6 +49,14 @@ Hooks.filter.postCreate = async function (hookData) {
 			post.pollIds = JSON.stringify(savedPolls.map(p => String(p.pollId)));
 		}
 	}
+
+	// Federated Question (FEP-9967): build a remote poll from the AP data
+	const ap = data?._activitypub;
+	if (ap && (Array.isArray(ap.oneOf) || Array.isArray(ap.anyOf))) {
+		const saved = await Poll.createFromQuestion(post, ap);
+		const existing = post.pollIds ? JSON.parse(post.pollIds) : [];
+		post.pollIds = JSON.stringify([...existing, String(saved.pollId)]);
+	}
 	return hookData;
 };
 
@@ -67,6 +75,33 @@ Hooks.filter.postGetFields = async function (hookData) {
 };
 
 Hooks.filter.postEdit = async function (hookData) {
+	// Federated Question update (FEP-9967): refresh the existing remote poll
+	const ap = hookData.data?._activitypub;
+	if (ap && (Array.isArray(ap.oneOf) || Array.isArray(ap.anyOf))) {
+		const currentPollIds = await Poll.getPollIdsByPid(hookData.data.pid);
+		let remotePollId = null;
+		for (const pid of currentPollIds) {
+			// eslint-disable-next-line no-await-in-loop
+			if (await Poll.isRemote(pid)) {
+				remotePollId = pid;
+				break;
+			}
+		}
+		if (remotePollId) {
+			await Poll.updateFromQuestion(remotePollId, ap);
+		} else {
+			// No existing poll (e.g. the initial Create was missed); create one
+			const saved = await Poll.createFromQuestion({
+				uid: hookData.data.uid,
+				pid: hookData.data.pid,
+				timestamp: hookData.data.timestamp,
+				edited: hookData.data.edited,
+			}, ap);
+			hookData.post.pollIds = JSON.stringify([String(saved.pollId)]);
+		}
+		return hookData;
+	}
+
 	const currentPollIds = await Poll.getPollIdsByPid(hookData.data.pid);
 	if (!currentPollIds.length && (!Array.isArray(hookData.data.polls) || !hookData.data.polls.length)) {
 		// no polls before or after, nothing to do
@@ -89,6 +124,71 @@ Hooks.filter.postEdit = async function (hookData) {
 	return hookData;
 };
 
+// FEP-9967 outbound: transform a local post with a poll into a `Question`
+// object. Fired at the end of `Mocks.notes.public` (core), which has already
+// built a `Note`/`Article`. Only the first poll on a post is federated.
+Hooks.filter.activitypubMocksNote = async function (hookData) {
+	const { object, post } = hookData;
+	if (!object || !post || !post.pid) {
+		return hookData;
+	}
+
+	const pollIds = await Poll.getPollIdsByPid(post.pid);
+	if (!pollIds.length) {
+		return hookData;
+	}
+
+	const pollId = pollIds[0];
+	const [info, votersCount] = await Promise.all([
+		Poll.getInfo(pollId),
+		Poll.getVotersCount(pollId),
+	]);
+	if (!info || !Array.isArray(info.options) || !info.options.length) {
+		return hookData;
+	}
+
+	const options = info.options
+		.filter(opt => opt && typeof opt.title === 'string')
+		.map(opt => ({
+			type: 'Note',
+			name: opt.title,
+			replies: { type: 'Collection', totalItems: opt.voteCount || 0 },
+		}));
+
+	const isMulti = parseInt(info.maximumVotesPerUser, 10) > 1;
+	const end = parseInt(info.end, 10);
+	const ended = end > 0 && Date.now() > end;
+
+	object.type = 'Question';
+	// Embed the poll title in the content so it renders as the question text
+	// on Mastodon (which displays `content` above the options).
+	if (info.title) {
+		object.content = `<p>${info.title}</p>${object.content || ''}`;
+	}
+	if (isMulti) {
+		object.anyOf = options;
+	} else {
+		object.oneOf = options;
+	}
+	if (end > 0) {
+		object.endTime = new Date(end).toISOString();
+	}
+	if (ended) {
+		object.closed = true;
+	}
+	if (votersCount > 0) {
+		object.votersCount = votersCount;
+	}
+
+	// A poll post is a Note, not an Article — drop the Article-only fields.
+	// `name` (topic title) is kept: harmless and non-conflicting.
+	delete object.preview;
+	delete object.summary;
+	delete object.sensitive;
+
+	return hookData;
+};
+
 Hooks.filter.topicPost = async function (data) {
 	if (Array.isArray(data.polls) && data.polls.length) {
 		await canCreate(data.cid, data.uid);
@@ -104,6 +204,137 @@ Hooks.filter.topicReply = async function (data) {
 	return data;
 };
 
+// FEP-9967 inbound: detect a remote vote on a local poll and apply it.
+// A vote is a Create(Note) where the Note has `name` + `inReplyTo` and no
+// `content`, and `inReplyTo` resolves to a local post that has a poll.
+Hooks.filter.activitypubCreate = async function (hookData) {
+	const { activity } = hookData;
+	if (!activity || activity.type !== 'Create' || !activity.object) {
+		return hookData;
+	}
+
+	const { object } = activity;
+	// FEP-9967 vote shape: Note with name + inReplyTo, no content
+	if (object.type !== 'Note' || !object.name || !object.inReplyTo || object.content) {
+		return hookData;
+	}
+
+	// Resolve inReplyTo to a local post (e.g. https://example.org/post/123)
+	const match = object.inReplyTo.match(/\/post\/(\d+)/);
+	if (!match) return hookData;
+	const pid = parseInt(match[1], 10);
+	if (!(await posts.exists(pid))) return hookData;
+
+	const pollIds = await Poll.getPollIdsByPid(pid);
+	if (!pollIds.length) return hookData;
+
+	const pollId = pollIds[0];
+	const info = await Poll.getInfo(pollId);
+	if (!info) return hookData;
+
+	// Poll must be active
+	if (await Poll.hasEnded(pollId) || await Poll.isDeleted(pollId)) {
+		return hookData;
+	}
+
+	// Match name to a poll option
+	const option = info.options.find(opt => opt && opt.title === object.name);
+	if (!option) return hookData;
+
+	const remoteActorUrl = activity.actor;
+	if (!remoteActorUrl) return hookData;
+	const isMulti = parseInt(info.maximumVotesPerUser, 10) > 1;
+
+	// Idempotency: check if the actor has already voted
+	if (isMulti) {
+		const alreadyVoted = await db.sortedSetScore(`poll:${pollId}:options:${option.id}:votes`, remoteActorUrl);
+		if (alreadyVoted) return hookData;
+	} else {
+		const alreadyVoted = await db.sortedSetScore(`poll:${pollId}:voters`, remoteActorUrl);
+		if (alreadyVoted) return hookData;
+	}
+
+	// Apply the vote (remote actor URL as the uid — sorted sets handle strings)
+	const Vote = require('./vote');
+	await Vote.add({
+		pollId,
+		options: [option.id],
+		uid: remoteActorUrl,
+		voteAnon: false,
+	});
+
+	// Claim the activity so it is not processed as a regular post
+	hookData.claimed = true;
+
+	// Publish Update(Question) with refreshed results back to the voter
+	const activitypub = nodebb.require('./src/activitypub');
+	const [votersCount, refreshedOptions] = await Promise.all([
+		Poll.getVotersCount(pollId),
+		Poll.getOptions(pollId, false),
+	]);
+	const questionObject = {
+		id: object.inReplyTo,
+		type: 'Question',
+		attributedTo: await posts.getPostField(pid, 'uid'),
+		to: ['https://www.w3.org/ns/activitystreams#Public'],
+		content: await posts.getPostField(pid, 'content'),
+	};
+	const isMultiChoice = parseInt(info.maximumVotesPerUser, 10) > 1;
+	const optionsPayload = refreshedOptions
+		.filter(opt => opt && typeof opt.title === 'string')
+		.map(opt => ({
+			type: 'Note',
+			name: opt.title,
+			replies: { type: 'Collection', totalItems: opt.voteCount || 0 },
+		}));
+	if (isMultiChoice) {
+		questionObject.anyOf = optionsPayload;
+	} else {
+		questionObject.oneOf = optionsPayload;
+	}
+	if (votersCount > 0) {
+		questionObject.votersCount = votersCount;
+	}
+	const end = parseInt(info.end, 10);
+	if (end > 0) {
+		questionObject.endTime = new Date(end).toISOString();
+	}
+	if (end > 0 && Date.now() > end) {
+		questionObject.closed = true;
+	}
+
+	// Publish Update(Question) to all recipients (public, followers, voters)
+	setImmediate(async () => {
+		try {
+			const utils = nodebb.require('./src/utils');
+			const authorUid = parseInt(await posts.getPostField(pid, 'uid'), 10);
+			const remoteVoters = (await db.getSortedSetMembers(`poll:${pollId}:voters`))
+				.filter(v => !utils.isNumber(v));
+
+			const { to, cc, targets } = await activitypub.buildRecipients(
+				{ to: ['https://www.w3.org/ns/activitystreams#Public'], cc: remoteVoters },
+				{ pid, uid: authorUid }
+			);
+
+			questionObject.to = to;
+			questionObject.cc = cc;
+
+			await activitypub.send('uid', authorUid, Array.from(targets), {
+				id: `${object.id || object.inReplyTo}#update/${Date.now()}`,
+				type: 'Update',
+				actor: questionObject.attributedTo,
+				to,
+				cc,
+				object: questionObject,
+			});
+		} catch (e) {
+			// Non-fatal: log and move on
+		}
+	});
+
+	return hookData;
+};
+
 Hooks.action.postDelete = async function (data) {
 	const pollIds = await Poll.getPollIdsByPid(data.post.pid);
 	if (pollIds.length) {

package/lib/poll.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const crypto = require('crypto');
+
 const db = nodebb.require('./src/database');
 const privileges = nodebb.require('./src/privileges');
 
@@ -46,6 +48,92 @@ Poll.add = async function (postData, polls) {
 	return savePolls;
 };
 
+// ---------------------------------------------------------------------------
+// Federated (remote) polls — FEP-9967 `Question` objects
+// ---------------------------------------------------------------------------
+
+// Stable option id derived from the option name (the FEP guarantees name
+// uniqueness within a poll), so ids survive `Update`s even if order changes.
+function hashOptionId(name) {
+	return crypto.createHash('sha256').update(String(name)).digest('hex').slice(0, 12);
+}
+
+// Parse a Question's `_activitypub` poll data into the plugin's option shape.
+function parseQuestion(ap) {
+	const rawOptions = Array.isArray(ap.anyOf) ? ap.anyOf : (Array.isArray(ap.oneOf) ? ap.oneOf : []);
+	const isMulti = Array.isArray(ap.anyOf);
+	const options = [];
+	const remoteVotes = {};
+	rawOptions.forEach((opt) => {
+		if (!opt || typeof opt.name !== 'string') {
+			return;
+		}
+		const id = hashOptionId(opt.name);
+		options.push({ id, title: opt.name });
+		remoteVotes[id] = (opt.replies && opt.replies.totalItems) || 0;
+	});
+	return {
+		options,
+		remoteVotes,
+		maximumVotesPerUser: isMulti ? Math.max(options.length, 1) : 1,
+	};
+}
+
+function tryParseRemoteVotes(json) {
+	if (!json) {
+		return {};
+	}
+	try {
+		const obj = JSON.parse(json);
+		return obj && typeof obj === 'object' && !Array.isArray(obj) ? obj : {};
+	} catch (err) {
+		return {};
+	}
+}
+
+// Create a poll from a federated Question. Bypasses the local `maxOptions`
+// limit (that cap applies to locally-authored polls, not ingested ones).
+Poll.createFromQuestion = async function (postData, ap) {
+	const { options, remoteVotes, maximumVotesPerUser } = parseQuestion(ap);
+	const pollId = await db.incrObjectField('global', 'nextPollId');
+	const poll = {
+		pollId,
+		title: 'Poll',
+		uid: postData.editor || postData.uid,
+		pid: postData.pid,
+		deleted: 0,
+		end: ap.endTime ? new Date(ap.endTime).getTime() : 0,
+		maximumVotesPerUser,
+		timestamp: postData.edited || postData.timestamp,
+		remote: 1,
+		remoteVotes: JSON.stringify(remoteVotes),
+		options: JSON.stringify(options),
+		...(ap.votersCount !== undefined && { remoteVotersCount: ap.votersCount }),
+	};
+	await Promise.all([
+		db.setObject(`poll:${pollId}`, poll),
+		db.sortedSetAdd('polls:createtime', poll.timestamp, pollId),
+	]);
+	return poll;
+};
+
+// Refresh an existing remote poll from an updated Question (FEP-9967 `Update`).
+Poll.updateFromQuestion = async function (pollId, ap) {
+	const { options, remoteVotes, maximumVotesPerUser } = parseQuestion(ap);
+	await db.setObject(`poll:${pollId}`, {
+		options: JSON.stringify(options),
+		remoteVotes: JSON.stringify(remoteVotes),
+		end: ap.endTime ? new Date(ap.endTime).getTime() : 0,
+		maximumVotesPerUser,
+		...(ap.votersCount !== undefined && { remoteVotersCount: ap.votersCount }),
+	});
+};
+
+Poll.isRemote = async function (pollId) {
+	const result = await Poll.getField(pollId, 'remote');
+	return parseInt(result, 10) === 1;
+};
+
 Poll.deletePolls = async function (pollIds) {
 	if (!pollIds.length) return;
 	const polls = await db.getObjects(pollIds.map(pollId => `poll:${pollId}`));
@@ -211,6 +299,20 @@ Poll.getInfo = async function (pollId, withVotes = false) {
 	const end = parseInt(poll.end, 10);
 	poll.ended = end > 0 && Date.now() > end;
 	poll.options = await loadOptions(pollId, poll.options, withVotes);
+
+	// Federated (remote) polls: displayed count = ingested baseline + local votes.
+	// (v1 reconciliation: a local voter sees their vote reflect immediately; a small
+	// over-count is accepted until the next remote Update refreshes the baseline.)
+	if (parseInt(poll.remote, 10) === 1) {
+		const remoteVotes = tryParseRemoteVotes(poll.remoteVotes);
+		poll.options.forEach((option) => {
+			if (option) {
+				const baseline = remoteVotes[option.id] || 0;
+				option.voteCount = baseline + (option.voteCount || 0);
+			}
+		});
+		poll.voteCount = poll.options.reduce((sum, o) => sum + (o ? (o.voteCount || 0) : 0), 0);
+	}
 	return poll;
 };
 

package/lib/sockets.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const nconf = nodebb.require('nconf');
 const _ = nodebb.require('lodash');
 const db = nodebb.require('./src/database');
 const posts = nodebb.require('./src/posts');
@@ -76,6 +77,13 @@ Sockets.vote = async function (socket, data) {
 
 	await Vote.add(data);
 
+	// Federate the vote out (FEP-9967) if this is a remote poll
+	if (parseInt(pollData.remote, 10) === 1) {
+		await federateVoteChange({
+			pollData, socket, voteAnon: data.voteAnon, removedOptionIds: [], addedOptionIds: data.options,
+		});
+	}
+
 	const returnPoll = await Poll.get(data.pollId, socket.uid, false);
 	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', {
 		pollData: returnPoll,
@@ -114,7 +122,20 @@ Sockets.updateVote = async function (socket, data) {
 		throw new Error('Invalid option');
 	}
 
+	// Capture the prior vote so we can federate the diff (remote polls only)
+	const isRemote = parseInt(pollData.remote, 10) === 1;
+	const oldOptions = isRemote ? (await Vote.get({ uid: socket.uid, pollId: data.pollId })).options : [];
+
 	await Vote.update(data);
+
+	// Federate the vote change out (FEP-9967) if this is a remote poll
+	if (isRemote) {
+		const oldSet = oldOptions.map(String);
+		const removedOptionIds = oldOptions.filter(id => !data.options.map(String).includes(String(id)));
+		const addedOptionIds = data.options.filter(id => !oldSet.includes(String(id)));
+		await federateVoteChange({ pollData, socket, voteAnon: data.voteAnon, removedOptionIds, addedOptionIds });
+	}
+
 	const returnPoll = await Poll.get(data.pollId, socket.uid, false);
 	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', {
 		pollData: returnPoll,
@@ -136,10 +157,22 @@ Sockets.removeVote = async function (socket, data) {
 		throw new Error('Can\'t remove vote');
 	}
 
+	const pollData = await db.getObject(`poll:${data.pollId}`);
+	const isRemote = parseInt(pollData.remote, 10) === 1;
+	// Capture the prior vote + anon flag before removal (remote polls only)
+	const oldOptions = isRemote ? (await Vote.get({ uid: socket.uid, pollId: data.pollId })).options : [];
+	const voteAnon = isRemote ? await db.isSortedSetMember(`poll:${data.pollId}:anon:voters`, socket.uid) : false;
+
 	await Vote.remove(data);
-	const pollData = await Poll.get(data.pollId, socket.uid, false);
+
+	// Federate the vote removal out (FEP-9967) if this is a remote poll
+	if (isRemote) {
+		await federateVoteChange({ pollData, socket, voteAnon, removedOptionIds: oldOptions, addedOptionIds: [] });
+	}
+
+	const returnPoll = await Poll.get(data.pollId, socket.uid, false);
 	NodeBB.SocketIndex.server.sockets.emit('event:poll.voteChange', {
-		pollData,
+		pollData: returnPoll,
 		uid: socket.uid,
 	});
 };
@@ -216,3 +249,77 @@ async function checkPrivs(cid, socketUid) {
 	}
 	return true;
 }
+
+// ---------------------------------------------------------------------------
+// FEP-9967 outbound vote federation
+// ---------------------------------------------------------------------------
+
+// Build a FEP-9967 vote Note. Stable, idempotent id so re-sends and Undos
+// dedupe remotely.
+function buildVoteNote({ voterUrl, questionId, optionName, pollAuthorUrl }) {
+	const voteId = `${voterUrl}#activity/vote/${encodeURIComponent(questionId)}/${encodeURIComponent(optionName)}`;
+	return {
+		id: voteId,
+		type: 'Note',
+		attributedTo: voterUrl,
+		inReplyTo: questionId,
+		name: optionName,
+		to: [pollAuthorUrl],
+	};
+}
+
+// Federate a vote change (additions and/or removals) for a remote poll.
+// Anonymous votes are not federated (FEP votes are attributed to the voter
+// actor, which anon votes lack).
+async function federateVoteChange({ pollData, socket, voteAnon, removedOptionIds, addedOptionIds }) {
+	if (voteAnon) {
+		return;
+	}
+	if (!removedOptionIds.length && !addedOptionIds.length) {
+		return;
+	}
+
+	const activitypub = nodebb.require('./src/activitypub');
+	const options = JSON.parse(pollData.options || '[]');
+	const [questionId, pollAuthorUrl] = await Promise.all([
+		posts.getPostField(pollData.pid, 'url'), // remote Question id (a URL)
+		posts.getPostField(pollData.pid, 'uid'), // remote actor URL (poll author)
+	]);
+	const voterUrl = `${nconf.get('url')}/uid/${socket.uid}`;
+
+	const toName = (id) => {
+		const opt = options.find(o => String(o.id) === String(id));
+		return opt ? opt.title : null;
+	};
+
+	// Undo removed options
+	for (const id of removedOptionIds) {
+		const name = toName(id);
+		if (!name) continue;
+		const voteNote = buildVoteNote({ voterUrl, questionId, optionName: name, pollAuthorUrl });
+		// eslint-disable-next-line no-await-in-loop
+		await activitypub.send('uid', socket.uid, [pollAuthorUrl], {
+			id: `${voteNote.id}#undo`,
+			type: 'Undo',
+			object: {
+				id: voteNote.id,
+				type: 'Create',
+				actor: voterUrl,
+				object: voteNote,
+			},
+		});
+	}
+
+	// Create added options
+	for (const id of addedOptionIds) {
+		const name = toName(id);
+		if (!name) continue;
+		const voteNote = buildVoteNote({ voterUrl, questionId, optionName: name, pollAuthorUrl });
+		// eslint-disable-next-line no-await-in-loop
+		await activitypub.send('uid', socket.uid, [pollAuthorUrl], {
+			id: voteNote.id,
+			type: 'Create',
+			object: voteNote,
+		});
+	}
+}

package/lib/vote.js

@@ -73,6 +73,10 @@ Vote.canUpdateVote = async function (uid, pollId) {
 	if (!pollInfo) {
 		throw new Error('[[error:invalid-data]]');
 	}
+	// Remote polls: vote changes/removals are not federated (no OSW support yet)
+	if (parseInt(pollInfo.remote, 10) === 1) {
+		return false;
+	}
 	const [canRead, ended, deleted, updateDisabled] = await Promise.all([
 		privileges.posts.can('topics:read', pollInfo.pid, uid),
 		Poll.hasEnded(pollId),