chatterino2
Code Issues

feat: add /endpoll and /cancelpoll commands for broadcasters (#6605)

Browse Source 
Reviewed-by: pajlada <rasmus.karlsson@pajlada.com>
This commit is contained in:
iProdigy
2025-11-29 14:12:21 -06:00
committed by GitHub
parent e06021293c
commit b9446990a7
7 changed files with 352 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CHANGELOG.md
+1 -1
View File
@@ -13,7 +13,7 @@
- Minor: Added a menu action to sort tabs alphabetically. (#6551)
- Minor: Fixed "edit hotkey" dialog opening like a normal window. (#6540)
- Minor: Added a setting to show the stream title in live messages. (#6572)
- Minor: Added broadcaster-only `/poll` command to start a poll. (#6583)
- Minor: Added broadcaster-only `/poll`, `/cancelpoll`, and `/endpoll` commands. (#6583, #6605)
- Minor: Added broadcaster-only `/prediction` command to start a prediction. (#6583)
- Bugfix: Expose the "Extra extension IDs" setting on non-Windows systems too. (#6509)
- Bugfix: Fixed some commands and filters not working as expected in seach popups. (#6539)
mocks/include/mocks/Helix.hpp
+14
View File
@@ -437,6 +437,20 @@ public:
FailureCallback<QString> failureCallback),
(override));
// get polls
MOCK_METHOD(void, getPolls,
(QString broadcasterID, QStringList ids, int first,
QString after, ResultCallback<HelixPolls> successCallback,
FailureCallback<QString> failureCallback),
(override));
// end poll
MOCK_METHOD(void, endPoll,
(QString broadcasterID, QString id, bool immediatelyHide,
ResultCallback<HelixPoll> successCallback,
FailureCallback<QString> failureCallback),
(override));
// create prediction
MOCK_METHOD(void, createPrediction,
(QString broadcasterID, QString title, QStringList outcomes,
src/controllers/commands/CommandController.cpp
+3
View File
@@ -484,6 +484,9 @@ CommandController::CommandController(const Paths &paths)
this->registerCommand("/shoutout", &commands::sendShoutout);
this->registerCommand("/poll", &commands::createPoll);
this->registerCommand("/cancelpoll", &commands::cancelPoll);
this->registerCommand("/endpoll", &commands::endPoll);
this->registerCommand("/prediction", &commands::createPrediction);
this->registerCommand("/c2-set-logging-rules", &commands::setLoggingRules);
src/controllers/commands/builtin/twitch/Poll.cpp
+160
View File
@@ -67,4 +67,164 @@ QString createPoll(const CommandContext &ctx)
return "";
}
QString endPoll(const CommandContext &ctx)
{
if (ctx.twitchChannel == nullptr)
{
const auto err = QStringLiteral(
"The /endpoll command only works in Twitch channels");
if (ctx.channel != nullptr)
{
ctx.channel->addSystemMessage(err);
}
else
{
qCWarning(chatterinoCommands) << "Invalid command context:" << err;
}
return "";
}
auto currentUser = getApp()->getAccounts()->twitch.getCurrent();
if (currentUser->isAnon())
{
ctx.channel->addSystemMessage("You must be logged in to end a poll!");
return "";
}
const auto roomId = ctx.twitchChannel->roomId();
getHelix()->getPolls(
roomId, {}, 1, {},
[channel = ctx.channel, roomId](const auto &result) {
if (result.polls.empty())
{
channel->addSystemMessage("Failed to find any polls");
return;
}
auto poll = result.polls.front();
if (poll.status != "ACTIVE")
{
channel->addSystemMessage("Could not find an active poll");
return;
}
getHelix()->endPoll(
roomId, poll.id, false,
[channel](const HelixPoll &data) {
// find most popular choice
HelixPollChoice winner = data.choices.front();
int totalVotes = 0;
int winnerCount = 0;
for (const auto &choice : data.choices)
{
totalVotes += choice.votes;
if (choice.votes > winner.votes)
{
winner = choice;
winnerCount = 1;
}
else if (choice.votes == winner.votes)
{
winnerCount++;
}
}
if (totalVotes == 0)
{
channel->addSystemMessage(
QString("Poll ended with zero votes: '%1'")
.arg(data.title));
return;
}
if (winnerCount > 1)
{
channel->addSystemMessage(
QString("Poll ended in a draw: '%1'")
.arg(data.title));
return;
}
const double percent =
100.0 * winner.votes / std::max(totalVotes, 1);
channel->addSystemMessage(
QString(
"Ended poll: '%1' - '%2' won with %3 votes (%4%)")
.arg(data.title, winner.title,
QString::number(winner.votes),
QString::number(percent, 'f', 1)));
},
[channel](const auto &error) {
channel->addSystemMessage("Failed to end the poll - " +
error);
});
},
[channel = ctx.channel](const auto &error) {
channel->addSystemMessage("Failed to query polls - " + error);
});
return "";
}
QString cancelPoll(const CommandContext &ctx)
{
if (ctx.twitchChannel == nullptr)
{
const auto err = QStringLiteral(
"The /cancelpoll command only works in Twitch channels");
if (ctx.channel != nullptr)
{
ctx.channel->addSystemMessage(err);
}
else
{
qCWarning(chatterinoCommands) << "Invalid command context:" << err;
}
return "";
}
auto currentUser = getApp()->getAccounts()->twitch.getCurrent();
if (currentUser->isAnon())
{
ctx.channel->addSystemMessage(
"You must be logged in to cancel a poll!");
return "";
}
const auto roomId = ctx.twitchChannel->roomId();
getHelix()->getPolls(
roomId, {}, 1, {},
[channel = ctx.channel, roomId](const auto &result) {
if (result.polls.empty())
{
channel->addSystemMessage("Failed to find any polls");
return;
}
auto poll = result.polls.front();
if (poll.status != "ACTIVE")
{
channel->addSystemMessage("Could not find an active poll");
return;
}
getHelix()->endPoll(
roomId, poll.id, true,
[channel](const HelixPoll &data) {
channel->addSystemMessage(
QString("Canceled poll: '%1'").arg(data.title));
},
[channel](const auto &error) {
channel->addSystemMessage("Failed to cancel the poll - " +
error);
});
},
[channel = ctx.channel](const auto &error) {
channel->addSystemMessage("Failed to query polls - " + error);
});
return "";
}
} // namespace chatterino::commands
src/controllers/commands/builtin/twitch/Poll.hpp
+6
View File
@@ -13,4 +13,10 @@ namespace chatterino::commands {
/// /poll
QString createPoll(const CommandContext &ctx);
/// /endpoll
QString endPoll(const CommandContext &ctx);
/// /cancelpoll
QString cancelPoll(const CommandContext &ctx);
} // namespace chatterino::commands
src/providers/twitch/api/Helix.cpp
+97
View File
@@ -3276,6 +3276,103 @@ void Helix::createPoll(QString broadcasterID, QString title,
.execute();
}
void Helix::getPolls(const QString broadcasterID, QStringList ids,
const int first, const QString after,
ResultCallback<HelixPolls> successCallback,
FailureCallback<QString> failureCallback)
{
QUrlQuery urlQuery;
urlQuery.addQueryItem("broadcaster_id", broadcasterID);
urlQuery.addQueryItem("first", QString::number(first));
if (!after.isEmpty())
{
urlQuery.addQueryItem("after", after);
}
for (const auto &id : ids)
{
urlQuery.addQueryItem("id", id);
}
this->makeGet("polls", urlQuery)
.onSuccess([successCallback](const auto &result) {
if (result.status() != 200)
{
qCWarning(chatterinoTwitch)
<< "Success result for getting polls was "
<< result.formatError() << "but we expected it to be 200";
}
const auto response = result.parseJson();
successCallback(HelixPolls(response));
})
.onError([failureCallback](const auto &result) -> void {
if (!result.status())
{
failureCallback(result.formatError());
return;
}
auto obj = result.parseJson();
auto message = obj.value("message").toString();
if (!message.isEmpty())
{
failureCallback(message);
}
else
{
failureCallback(result.formatError());
}
})
.execute();
}
void Helix::endPoll(const QString broadcasterID, const QString id,
const bool immediatelyHide,
ResultCallback<HelixPoll> successCallback,
FailureCallback<QString> failureCallback)
{
QJsonObject payload;
payload.insert("broadcaster_id", broadcasterID);
payload.insert("id", id);
payload.insert("status", immediatelyHide ? "ARCHIVED" : "TERMINATED");
this->makePatch("polls", {})
.json(payload)
.onSuccess([successCallback](const NetworkResult &result) {
if (result.status() != 200)
{
qCWarning(chatterinoTwitch)
<< "Success result for ending a poll was "
<< result.formatError() << "but we expected it to be 200";
}
const auto response = result.parseJson();
const auto data = HelixPolls(response);
successCallback(data.polls.front());
})
.onError([failureCallback](const NetworkResult &result) -> void {
if (!result.status())
{
failureCallback(result.formatError());
return;
}
const auto obj = result.parseJson();
const auto message = obj.value("message").toString();
if (!message.isEmpty())
{
failureCallback(message);
}
else
{
failureCallback(result.formatError());
}
})
.execute();
}
void Helix::createPrediction(const QString broadcasterID, const QString title,
QStringList outcomes,
const std::chrono::seconds duration,
src/providers/twitch/api/Helix.hpp
+71
View File
@@ -464,6 +464,55 @@ struct HelixSendMessageArgs {
QString replyParentMessageID;
};
struct HelixPollChoice {
QString id;
QString title;
int votes;
explicit HelixPollChoice(const QJsonObject &jsonObject)
: id(jsonObject.value("id").toString())
, title(jsonObject.value("title").toString())
, votes(jsonObject.value("votes").toInt())
{
}
};
struct HelixPoll {
QString id;
QString title;
std::vector<HelixPollChoice> choices;
QString status;
explicit HelixPoll(const QJsonObject &jsonObject)
: id(jsonObject.value("id").toString())
, title(jsonObject.value("title").toString())
, status(jsonObject.value("status").toString())
{
for (const auto &data = jsonObject.value("choices").toArray();
const auto &c : data)
{
HelixPollChoice choice(c.toObject());
this->choices.push_back(choice);
}
}
};
struct HelixPolls {
std::vector<HelixPoll> polls;
HelixPolls() = default;
explicit HelixPolls(const QJsonObject &jsonObject)
{
for (const auto &data = jsonObject.value("data").toArray();
const auto &p : data)
{
HelixPoll poll(p.toObject());
this->polls.push_back(poll);
}
}
};
enum class HelixAnnouncementColor {
Blue,
Green,
@@ -1218,6 +1267,18 @@ public:
int pointsPerVote, ResultCallback<> successCallback,
FailureCallback<QString> failureCallback) = 0;
/// https://dev.twitch.tv/docs/api/reference#get-polls
virtual void getPolls(QString broadcasterID, QStringList ids, int first,
QString after,
ResultCallback<HelixPolls> successCallback,
FailureCallback<QString> failureCallback) = 0;
/// https://dev.twitch.tv/docs/api/reference#end-poll
virtual void endPoll(QString broadcasterID, QString id,
bool immediatelyHide,
ResultCallback<HelixPoll> successCallback,
FailureCallback<QString> failureCallback) = 0;
/// https://dev.twitch.tv/docs/api/reference#create-prediction
virtual void createPrediction(QString broadcasterID, QString title,
QStringList choices,
@@ -1586,6 +1647,16 @@ public:
ResultCallback<> successCallback,
FailureCallback<QString> failureCallback) final;
/// https://dev.twitch.tv/docs/api/reference#get-polls
void getPolls(QString broadcasterID, QStringList ids, int first,
QString after, ResultCallback<HelixPolls> successCallback,
FailureCallback<QString> failureCallback) final;
/// https://dev.twitch.tv/docs/api/reference#end-poll
void endPoll(QString broadcasterID, QString id, bool immediatelyHide,
ResultCallback<HelixPoll> successCallback,
FailureCallback<QString> failureCallback) final;
/// https://dev.twitch.tv/docs/api/reference#create-prediction
void createPrediction(QString broadcasterID, QString title,
QStringList outcomes, std::chrono::seconds duration,