Migrate /chatters commands to use Helix api

CHANGELOG.md

@@ -68,6 +68,7 @@
 - Minor: Migrated /uniquechat and /r9kbeta to Helix API. (#4057)
 - Minor: Migrated /uniquechatoff and /r9kbetaoff to Helix API. (#4057)
 - Minor: Make menus and placeholders display appropriate custom key combos. (#4045)
+- Minor: Migrated /chatters to Helix API. (#4019)
 - Bugfix: Connection to Twitch PubSub now recovers more reliably. (#3643, #3716)
 - Bugfix: Fixed `Smooth scrolling on new messages` setting sometimes hiding messages. (#4028)
 - Bugfix: Fixed a crash that can occur when closing and quickly reopening a split, then running a command. (#3852)

src/common/ChatterSet.cpp

@@ -55,4 +55,9 @@ std::vector<QString> ChatterSet::filterByPrefix(const QString &prefix) const
     return result;
 }
 
+int ChatterSet::getNumChatters() const
+{
+    return this->items.size();
+}
+
 }  // namespace chatterino

src/common/ChatterSet.hpp

@@ -36,6 +36,8 @@ class ChatterSet
     /// are in mixed case if available.
     std::vector<QString> filterByPrefix(const QString &prefix) const;
 
+    int getNumChatters() const;
+
 private:
     // user name in lower case -> user name in normal case
     cache::lru_cache<QString, QString> items;

src/controllers/commands/CommandController.cpp

@@ -879,7 +879,13 @@ void CommandController::initialize(Settings &, Paths &paths)
     });
 
     this->registerCommand(
-        "/chatters", [](const auto & /*words*/, auto channel) {
+        "/chatters", [](const auto & words, auto channel) {
+            if (words.size() != 1)
+            {
+                channel->addMessage(makeSystemMessage("Usage: /chatters"));
+                return "";
+            }
+
             auto twitchChannel = dynamic_cast<TwitchChannel *>(channel.get());
 
             if (twitchChannel == nullptr)
@@ -889,9 +895,31 @@ void CommandController::initialize(Settings &, Paths &paths)
                 return "";
             }
 
-            channel->addMessage(makeSystemMessage(
-                QString("Chatter count: %1")
-                    .arg(localizeNumbers(twitchChannel->chatterCount()))));
+            auto addChatterCountMessage = [channel, twitchChannel]() -> void {
+                channel->addMessage(makeSystemMessage(
+                    QString("Chatter count: %1")
+                        .arg(localizeNumbers(twitchChannel->chatterCount()))));
+            };
+
+            // Fail when user is not a moderator
+            if (!twitchChannel->hasModRights()) {
+                channel->addMessage(makeSystemMessage(QString("Error: Only moderators can get number of chatters")));
+                return "";
+            }
+
+            // Refresh chatter list via helix api for mods
+            getHelix()->getChatters(
+                twitchChannel->roomId(),
+                getApp()->accounts->twitch.getCurrent()->getUserId(),
+                [twitchChannel, addChatterCountMessage](HelixUserList *chatterList) {
+                    twitchChannel->updateOnlineChatters(chatterList->users);
+                    addChatterCountMessage();
+                },
+                [channel](auto error, auto message) {
+                    auto errorMessage = Helix::formatHelixUserListErrorString(QString("chatters"), error, message);
+                    channel->addMessage(makeSystemMessage(errorMessage));
+                }
+            );
 
             return "";
         });

src/providers/twitch/TwitchChannel.cpp

@@ -48,30 +48,6 @@ namespace {
         "Failed to create a clip - an unknown error occurred.");
     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)};
-    }
-
 }  // namespace
 
 TwitchChannel::TwitchChannel(const QString &name)
@@ -135,10 +111,10 @@ 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, [=] {
@@ -164,8 +140,8 @@ TwitchChannel::TwitchChannel(const QString &name)
 void TwitchChannel::initialize()
 {
     this->fetchDisplayName();
-    this->refreshChatters();
     this->refreshBadges();
+    this->refreshChatters();
 }
 
 bool TwitchChannel::isEmpty() const
@@ -621,7 +597,7 @@ const QString &TwitchChannel::popoutPlayerUrl()
 
 int TwitchChannel::chatterCount()
 {
-    return this->chatterCount_;
+    return this->accessChatters()->getNumChatters();
 }
 
 void TwitchChannel::setLive(bool newLiveStatus)
@@ -903,8 +879,13 @@ void TwitchChannel::refreshPubSub()
     getApp()->twitch->pubsub->listenToChannelPointRewards(roomId);
 }
 
-void TwitchChannel::refreshChatters()
-{
+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 +898,16 @@ 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(),
+        [this](HelixUserList *chatterList) {
+            this->updateOnlineChatters(chatterList->users);
+        },
+        // Refresh chatters should only be used when failing silently is an option
+        [this](auto error, auto message) { }
+    );
 }
 
 void TwitchChannel::fetchDisplayName()

src/providers/twitch/TwitchChannel.hpp

@@ -191,7 +191,6 @@ class TwitchChannel : public Channel, public ChannelChatters
     const QString subscriptionUrl_;
     const QString channelUrl_;
     const QString popoutPlayerUrl_;
-    int chatterCount_;
     UniqueAccess<StreamStatus> streamStatus_;
     UniqueAccess<RoomModes> roomModes_;
     std::atomic_flag loadingRecentMessages_ = ATOMIC_FLAG_INIT;

src/providers/twitch/api/Helix.cpp

@@ -8,6 +8,19 @@
 
 namespace chatterino {
 
+HelixUserList::HelixUserList() {
+    users = std::unordered_set<QString>();
+}
+
+void HelixUserList::AddUsersFromResponse(const QJsonObject &response) {
+    for (const auto jsonStream : response.value("data").toArray()) 
+    {
+        auto user = jsonStream.toObject().value("user_login").toString();
+        users.insert(user);
+    }
+    users = std::move(users);
+}
+
 static IHelix *instance = nullptr;
 
 void Helix::fetchUsers(QStringList userIds, QStringList userLogins,
@@ -1991,6 +2004,157 @@ void Helix::sendWhisper(
         .execute();
 }
 
+QString Helix::formatHelixUserListErrorString(
+    QString userType,
+    HelixUserListError error,
+    QString message
+) {
+    using Error = HelixUserListError;
+
+    QString errorMessage = QString("Failed to get list of ") + userType + QString(": ");
+
+    switch (error)
+    {
+        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 don't have permission to "
+                            "perform that action.";
+        }
+        break;
+
+        case Error::Unknown: {
+            errorMessage += "An unknown error has occurred.";
+        }
+        break;
+    }
+    return errorMessage;
+}
+
+// Recursive function with a maximun page of 50
+void Helix::getApiListRecursive(
+    HelixUserList *list,
+    QString url, QUrlQuery urlQuery,
+    int page, QString paginationCursor,
+    ResultCallback<HelixUserList*> successCallback,
+    FailureCallback<HelixUserListError, QString> failureCallback
+) {
+    using Error = HelixUserListError;
+
+    if (!paginationCursor.isEmpty()) {
+        if (urlQuery.hasQueryItem("after")) {
+            urlQuery.removeQueryItem("after");
+        }
+        urlQuery.addQueryItem("after", paginationCursor);
+    }
+
+    this->makeRequest(url, urlQuery)
+        .type(NetworkRequestType::Get)
+        .header("Content-Type", "application/json")
+        .onSuccess([=](auto result) -> Outcome {
+            if (result.status() != 200)
+            {
+                qCWarning(chatterinoTwitch)
+                    << "Success result for getting user list data was "
+                    << result.status() << "but we expected it to be 200";
+            }
+
+            auto response = result.parseJson();
+
+            if (page == 1) {
+                list->total = response.value("total").toInt();
+            }
+
+            QString newCursor = response.value("pagination").toObject().value("cursor").toString();
+            list->AddUsersFromResponse(response);
+
+            // Call function with next page until page 50 is reached or there are no more results
+            if (page <= 50 && !newCursor.isEmpty()) {
+                getApiListRecursive(list, url, urlQuery, page+1, newCursor, successCallback, failureCallback);
+            } else {
+                successCallback(list);
+            }
+            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.compare(
+                                 "The ID in moderator_id must match the user "
+                                 "ID found in the request's OAuth token.",
+                                 Qt::CaseInsensitive) == 0 || message.compare(
+                                 "The ID in broadcaster_id must match the user "
+                                 "ID found in the request's OAuth token.",
+                                 Qt::CaseInsensitive) == 0)
+                    {
+                        // get moderators: Must be broadcaster
+                        // get chatters: Must must have permission to moderate the broadcaster’s chat room.
+                        failureCallback(Error::UserNotAuthorized, message);
+                    }
+                    else
+                    {
+                        failureCallback(Error::Forwarded, message);
+                    }
+                }
+                break;
+
+                case 403: {
+                    failureCallback(Error::UserNotAuthorized, message);
+                }
+                break;
+
+                default: {
+                    qCDebug(chatterinoTwitch)
+                        << "Unhandled error getting user list:" << result.status()
+                        << result.getData() << obj;
+                    failureCallback(Error::Unknown, message);
+                }
+                break;
+            }
+        })
+        .execute();
+}
+
+// https://dev.twitch.tv/docs/api/reference#get-chatters
+void Helix::getChatters(
+    QString broadcasterID, QString moderatorID,
+    ResultCallback<HelixUserList*> successCallback,
+    FailureCallback<HelixUserListError, QString> failureCallback)  
+{
+    auto chatterList = new HelixUserList();
+    QString paginationCursor("");
+
+    QUrlQuery urlQuery;
+
+    urlQuery.addQueryItem("broadcaster_id", broadcasterID);
+    urlQuery.addQueryItem("moderator_id", moderatorID);
+
+    this->getApiListRecursive(chatterList, "chat/chatters", urlQuery, 1, paginationCursor, successCallback, failureCallback);
+}
+
 // List the VIPs of a channel
 // https://dev.twitch.tv/docs/api/reference#get-vips
 void Helix::getChannelVIPs(