Migrate /chatters commands to use Helix api

CHANGELOG.md

@@ -69,6 +69,7 @@
 - Minor: Migrated /uniquechatoff and /r9kbetaoff to Helix API. (#4057)
 - Minor: Added stream titles to windows live toast notifications. (#1297)
 - Minor: Make menus and placeholders display appropriate custom key combos. (#4045)
+- Minor: Migrated /chatters to Helix API. (#4088)
 - Minor: Add settings tooltips. (#3437)
 - Bugfix: Connection to Twitch PubSub now recovers more reliably. (#3643, #3716)
 - Bugfix: Fixed `Smooth scrolling on new messages` setting sometimes hiding messages. (#4028)

src/controllers/commands/CommandController.cpp

@@ -878,23 +878,65 @@ void CommandController::initialize(Settings &, Paths &paths)
         return "";
     });
 
-    this->registerCommand(
-        "/chatters", [](const auto & /*words*/, auto channel) {
-            auto twitchChannel = dynamic_cast<TwitchChannel *>(channel.get());
+    this->registerCommand("/chatters", [](const auto &words, auto channel) {
+        auto formatError = [](HelixGetChattersError error, QString message) {
+            using Error = HelixGetChattersError;
 
-            if (twitchChannel == nullptr)
+            QString errorMessage = QString("Failed to get chatter count: ");
+
+            switch (error)
             {
-                channel->addMessage(makeSystemMessage(
-                    "The /chatters command only works in Twitch Channels"));
-                return "";
+                case Error::Forwarded: {
+                    errorMessage += message;
+                }
+                break;
+
+                case Error::UserMissingScope: {
+                    errorMessage += "Missing required scope. "
+                                    "Re-login with your "
+                                    "account and try again.";
+                }
+                break;
+
+                case Error::UserNotAuthorized: {
+                    errorMessage += "You must have moderator permissions to "
+                                    "use this command.";
+                }
+                break;
+
+                case Error::Unknown: {
+                    errorMessage += "An unknown error has occurred.";
+                }
+                break;
             }
+            return errorMessage;
+        };
 
-            channel->addMessage(makeSystemMessage(
-                QString("Chatter count: %1")
-                    .arg(localizeNumbers(twitchChannel->chatterCount()))));
+        auto twitchChannel = dynamic_cast<TwitchChannel *>(channel.get());
 
+        if (twitchChannel == nullptr)
+        {
+            channel->addMessage(makeSystemMessage(
+                "The /chatters command only works in Twitch Channels"));
             return "";
-        });
+        }
+
+        // Refresh chatter list via helix api for mods
+        getHelix()->getChatters(
+            twitchChannel->roomId(),
+            getApp()->accounts->twitch.getCurrent()->getUserId(), 1,
+            [channel](auto result) {
+                channel->addMessage(
+                    makeSystemMessage(QString("Chatter count: %1")
+                                          .arg(localizeNumbers(result.total))));
+            },
+            [channel, formatError](auto error, auto message) {
+                auto errorMessage = formatError(error, message);
+                channel->addMessage(makeSystemMessage(errorMessage));
+            });
+
+        return "";
+    });
 
     this->registerCommand("/clip", [](const auto & /*words*/, auto channel) {
         if (const auto type = channel->getType();

src/providers/twitch/TwitchChannel.cpp

@@ -49,29 +49,8 @@ namespace {
     const QString LOGIN_PROMPT_TEXT("Click here to add your account again.");
     const Link ACCOUNTS_LINK(Link::OpenAccountsPage, QString());
 
-    std::pair<Outcome, std::unordered_set<QString>> parseChatters(
-        const QJsonObject &jsonRoot)
-    {
-        static QStringList categories = {"broadcaster", "vips",   "moderators",
-                                         "staff",       "admins", "global_mods",
-                                         "viewers"};
-
-        auto usernames = std::unordered_set<QString>();
-
-        // parse json
-        QJsonObject jsonCategories = jsonRoot.value("chatters").toObject();
-
-        for (const auto &category : categories)
-        {
-            for (auto jsonCategory : jsonCategories.value(category).toArray())
-            {
-                usernames.insert(jsonCategory.toString());
-            }
-        }
-
-        return {Success, std::move(usernames)};
-    }
-
+    // Maximum number of chatters to fetch when refreshing chatters
+    constexpr auto MAX_CHATTERS_TO_FETCH = 5000;
 }  // namespace
 
 TwitchChannel::TwitchChannel(const QString &name)
@@ -136,9 +115,11 @@ TwitchChannel::TwitchChannel(const QString &name)
     });
 
     // timers
+
     QObject::connect(&this->chattersListTimer_, &QTimer::timeout, [=] {
         this->refreshChatters();
     });
+
     this->chattersListTimer_.start(5 * 60 * 1000);
 
     QObject::connect(&this->threadClearTimer_, &QTimer::timeout, [=] {
@@ -905,6 +886,12 @@ void TwitchChannel::refreshPubSub()
 
 void TwitchChannel::refreshChatters()
 {
+    // helix endpoint only works for mods
+    if (!this->hasModRights())
+    {
+        return;
+    }
+
     // setting?
     const auto streamStatus = this->accessStreamStatus();
     const auto viewerCount = static_cast<int>(streamStatus->viewerCount);
@@ -917,31 +904,19 @@ void TwitchChannel::refreshChatters()
         }
     }
 
-    // get viewer list
-    NetworkRequest("https://tmi.twitch.tv/group/user/" + this->getName() +
-                   "/chatters")
-
-        .onSuccess(
-            [this, weak = weakOf<Channel>(this)](auto result) -> Outcome {
-                // channel still exists?
-                auto shared = weak.lock();
-                if (!shared)
-                {
-                    return Failure;
-                }
-
-                auto data = result.parseJson();
-                this->chatterCount_ = data.value("chatter_count").toInt();
-
-                auto pair = parseChatters(std::move(data));
-                if (pair.first)
-                {
-                    this->updateOnlineChatters(pair.second);
-                }
-
-                return pair.first;
-            })
-        .execute();
+    // Get chatter list via helix api
+    getHelix()->getChatters(
+        this->roomId(), getApp()->accounts->twitch.getCurrent()->getUserId(),
+        MAX_CHATTERS_TO_FETCH,
+        [this, weak = weakOf<Channel>(this)](auto result) {
+            if (auto shared = weak.lock())
+            {
+                this->updateOnlineChatters(result.chatters);
+                this->chatterCount_ = result.total;
+            }
+        },
+        // Refresh chatters should only be used when failing silently is an option
+        [](auto error, auto message) {});
 }
 
 void TwitchChannel::fetchDisplayName()

src/providers/twitch/api/Helix.cpp

@@ -1782,6 +1782,83 @@ void Helix::updateChatSettings(
         .execute();
 }
 
+// https://dev.twitch.tv/docs/api/reference#get-chatters
+void Helix::fetchChatters(
+    QString broadcasterID, QString moderatorID, int first, QString after,
+    ResultCallback<HelixChatters> successCallback,
+    FailureCallback<HelixGetChattersError, QString> failureCallback)
+{
+    using Error = HelixGetChattersError;
+
+    QUrlQuery urlQuery;
+
+    urlQuery.addQueryItem("broadcaster_id", broadcasterID);
+    urlQuery.addQueryItem("moderator_id", moderatorID);
+    urlQuery.addQueryItem("first", QString::number(first));
+
+    if (!after.isEmpty())
+    {
+        urlQuery.addQueryItem("after", after);
+    }
+
+    this->makeRequest("chat/chatters", urlQuery)
+        .onSuccess([successCallback](auto result) -> Outcome {
+            if (result.status() != 200)
+            {
+                qCWarning(chatterinoTwitch)
+                    << "Success result for getting chatters was "
+                    << result.status() << "but we expected it to be 200";
+            }
+
+            auto response = result.parseJson();
+            successCallback(HelixChatters(response));
+            return Success;
+        })
+        .onError([failureCallback](auto result) {
+            auto obj = result.parseJson();
+            auto message = obj.value("message").toString();
+
+            switch (result.status())
+            {
+                case 400: {
+                    failureCallback(Error::Forwarded, message);
+                }
+                break;
+
+                case 401: {
+                    if (message.startsWith("Missing scope",
+                                           Qt::CaseInsensitive))
+                    {
+                        failureCallback(Error::UserMissingScope, message);
+                    }
+                    else if (message.contains("OAuth token"))
+                    {
+                        failureCallback(Error::UserNotAuthorized, message);
+                    }
+                    else
+                    {
+                        failureCallback(Error::Forwarded, message);
+                    }
+                }
+                break;
+
+                case 403: {
+                    failureCallback(Error::UserNotAuthorized, message);
+                }
+                break;
+
+                default: {
+                    qCDebug(chatterinoTwitch)
+                        << "Unhandled error data:" << result.status()
+                        << result.getData() << obj;
+                    failureCallback(Error::Unknown, message);
+                }
+                break;
+            }
+        })
+        .execute();
+}
+
 // Ban/timeout a user
 // https://dev.twitch.tv/docs/api/reference#ban-user
 void Helix::banUser(QString broadcasterID, QString moderatorID, QString userID,
@@ -1991,6 +2068,43 @@ void Helix::sendWhisper(
         .execute();
 }
 
+// https://dev.twitch.tv/docs/api/reference#get-chatters
+void Helix::getChatters(
+    QString broadcasterID, QString moderatorID, int maxChattersToFetch,
+    ResultCallback<HelixChatters> successCallback,
+    FailureCallback<HelixGetChattersError, QString> failureCallback)
+{
+    static const auto NUM_CHATTERS_TO_FETCH = 1000;
+
+    auto finalChatters = std::make_shared<HelixChatters>();
+
+    ResultCallback<HelixChatters> fetchSuccess;
+
+    fetchSuccess = [this, broadcasterID, moderatorID, maxChattersToFetch,
+                    finalChatters, &fetchSuccess, successCallback,
+                    failureCallback](auto chatters) {
+        qCDebug(chatterinoTwitch)
+            << "Fetched" << chatters.chatters.size() << "chatters";
+        finalChatters->chatters.merge(chatters.chatters);
+        finalChatters->total = chatters.total;
+
+        if (chatters.cursor.isEmpty() ||
+            finalChatters->chatters.size() >= maxChattersToFetch)
+        {
+            // Done paginating
+            successCallback(*finalChatters);
+            return;
+        }
+
+        this->fetchChatters(broadcasterID, moderatorID, NUM_CHATTERS_TO_FETCH,
+                            chatters.cursor, fetchSuccess, failureCallback);
+    };
+
+    // Initiate the recursive calls
+    this->fetchChatters(broadcasterID, moderatorID, NUM_CHATTERS_TO_FETCH, "",
+                        fetchSuccess, failureCallback);
+}
+
 // List the VIPs of a channel
 // https://dev.twitch.tv/docs/api/reference#get-vips
 void Helix::getChannelVIPs(