Migrate Twitch badges to Helix

CHANGELOG.md

@@ -9,6 +9,7 @@
 - Minor: Added the ability to reply to a message by `Shift + Right Click`ing the username. (#4424)
 - Minor: Added better filter validation and error messages. (#4364)
 - Minor: Updated the look of the Black Theme to be more in line with the other themes. (#4523)
+- Minor: Migrated badges to Helix API. (#4537)
 - Bugfix: Fixed an issue where animated emotes would render on top of zero-width emotes. (#4314)
 - Bugfix: Fixed an issue where it was difficult to hover a zero-width emote. (#4314)
 - Bugfix: Fixed an issue where context-menu items for zero-width emotes displayed the wrong provider. (#4460)

src/providers/twitch/api/Helix.cpp

@@ -2468,6 +2468,100 @@ void Helix::startCommercial(
         .execute();
 }
 
+// Twitch global badges
+// https://dev.twitch.tv/docs/api/reference/#get-global-chat-badges
+void Helix::getGlobalBadges(
+    ResultCallback<HelixGlobalBadges> successCallback,
+    FailureCallback<HelixGetGlobalBadgesError, QString> failureCallback)
+{
+    using Error = HelixGetGlobalBadgesError;
+    this->makeRequest("chat/badges/global")
+        .type(NetworkRequestType::Get)
+        .header("Content-Type", "application/json")
+        .onSuccess([successCallback](auto result) -> Outcome {
+            if (result.status() != 200)
+            {
+                qCWarning(chatterinoTwitch)
+                    << "Success result for getting global badges was "
+                    << result.status() << "but we expected it to be 200";
+            }
+
+            auto response = result.parseJson();
+            successCallback(HelixGlobalBadges(response));
+            return Success;
+        })
+        .onError([failureCallback](auto result) {
+            auto obj = result.parseJson();
+            auto message = obj.value("message").toString();
+
+            switch (result.status())
+            {
+                case 401: {
+                    failureCallback(Error::Forwarded, message);
+                }
+                break;
+
+                default: {
+                    qCDebug(chatterinoTwitch)
+                        << "Unhandled error data:" << result.status()
+                        << result.getData() << obj;
+                    failureCallback(Error::Unknown, message);
+                }
+                break;
+            }
+        })
+        .execute();
+}
+
+// Badges for the `broadcasterID` channel
+// https://dev.twitch.tv/docs/api/reference/#get-channel-chat-badges
+void Helix::getChannelBadges(
+    QString broadcasterID, ResultCallback<HelixChannelBadges> successCallback,
+    FailureCallback<HelixGetChannelBadgesError, QString> failureCallback)
+{
+    using Error = HelixGetChannelBadgesError;
+    QUrlQuery urlQuery;
+    urlQuery.addQueryItem("broadcaster_id", broadcasterID);
+
+    this->makeRequest("chat/badges", urlQuery)
+        .type(NetworkRequestType::Get)
+        .header("Content-Type", "application/json")
+        .onSuccess([successCallback](auto result) -> Outcome {
+            if (result.status() != 200)
+            {
+                qCWarning(chatterinoTwitch)
+                    << "Success result for getting badges was "
+                    << result.status() << "but we expected it to be 200";
+            }
+
+            auto response = result.parseJson();
+            successCallback(HelixChannelBadges(response));
+            return Success;
+        })
+        .onError([failureCallback](auto result) {
+            auto obj = result.parseJson();
+            auto message = obj.value("message").toString();
+
+            switch (result.status())
+            {   
+                case 400:
+                case 401: {
+                    failureCallback(Error::Forwarded, message);
+                }
+                break;
+
+                default: {
+                    qCDebug(chatterinoTwitch)
+                        << "Unhandled error data:" << result.status()
+                        << result.getData() << obj;
+                    failureCallback(Error::Unknown, message);
+                }
+                break;
+            }
+        })
+        .execute();
+}
+
 NetworkRequest Helix::makeRequest(QString url, QUrlQuery urlQuery)
 {
     assert(!url.startsWith("/"));

src/providers/twitch/api/Helix.hpp

@@ -384,6 +384,59 @@ struct HelixModerators {
     }
 };
 
+struct HelixBadgeVersion
+{
+    QString id;
+    Url imageURL1x;
+    Url imageURL2x;
+    Url imageURL4x;
+    QString title;
+    QString clickURL;
+
+    explicit HelixBadgeVersion(QJsonObject jsonObject)
+        : id(jsonObject.value("id").toString())
+        , imageURL1x(Url{jsonObject.value("image_url_1x").toString()})
+        , imageURL2x(Url{jsonObject.value("image_url_2x").toString()})
+        , imageURL4x(Url{jsonObject.value("image_url_4x").toString()})
+        , title(jsonObject.value("title").toString())
+        , clickURL(Url{jsonObject.value("click_url").toString()})
+    {
+    }
+};
+
+struct HelixBadgeSet
+{
+    QString setID;
+    std::vector<HelixBadgeVersion> versions;
+
+    explicit HelixBadgeSet(const QJsonObject& json)
+        : setID(json.value("set_id").toString())
+    {
+        const auto json_versions = json.value("versions").toArray();
+        for (const auto& version : json_versions)
+        {
+            HelixBadgeVersion badge_version(version.toObject());
+            versions.push_back(badge_version);
+        }
+    }
+};
+
+struct HelixGlobalBadges {
+    std::vector<HelixBadgeSet> data;
+    HelixGlobalBadges() = default;
+    explicit HelixGlobalBadges(const QJsonObject &jsonObject)
+    {
+        const auto &data = jsonObject.value("data").toArray();
+        for (const auto &set : data)
+        {
+            HelixBadgeSet badgeSet(set.toObject());
+            this->data.push_back(badgeSet);
+        }
+    }
+};
+
+using HelixChannelBadges = HelixGlobalBadges;
+
 enum class HelixAnnouncementColor {
     Blue,
     Green,
@@ -616,6 +669,20 @@ enum class HelixStartCommercialError {
     Forwarded,
 };
 
+enum class HelixGetGlobalBadgesError {
+    Unknown,
+
+    // The error message is forwarded directly from the Twitch API
+    Forwarded,
+};
+
+enum class HelixGetChannelBadgesError {
+    Unknown,
+
+    // The error message is forwarded directly from the Twitch API
+    Forwarded,
+};
+
 class IHelix
 {
 public:
@@ -896,8 +963,7 @@ class IHelix
     virtual void startCommercial(
         QString broadcasterID, int length,
         ResultCallback<HelixStartCommercialResponse> successCallback,
-        FailureCallback<HelixStartCommercialError, QString>
-            failureCallback) = 0;
+        FailureCallback<HelixStartCommercialError, QString> failureCallback) = 0;
 
     virtual void update(QString clientId, QString oauthToken) = 0;
 
@@ -1184,6 +1250,18 @@ class Helix final : public IHelix
         FailureCallback<HelixStartCommercialError, QString> failureCallback)
         final;
 
+    // Get global Twitch badges
+    // https://dev.twitch.tv/docs/api/reference/#get-global-chat-badges
+    void getGlobalBadges(
+        ResultCallback<HelixGlobalBadges> successCallback,
+        FailureCallback<HelixGetGlobalBadgesError, QString> failureCallback) final;
+
+    // Get badges for the `broadcasterID` channel
+    // https://dev.twitch.tv/docs/api/reference/#get-channel-chat-badges
+    void getChannelBadges(
+        QString broadcasterID, ResultCallback<HelixChannelBadges> successCallback,
+        FailureCallback<HelixGetChannelBadgesError, QString> failureCallback) final;
+
     void update(QString clientId, QString oauthToken) final;
 
     static void initialize();