🛡 Add /shield and /shieldoff 🛡 (#4580)

Co-authored-by: Rasmus Karlsson <rasmus.karlsson@pajlada.com>

src/providers/twitch/api/Helix.cpp

@@ -2560,6 +2560,77 @@ void Helix::getChannelBadges(
         .execute();
 }
 
+// https://dev.twitch.tv/docs/api/reference/#update-shield-mode-status
+void Helix::updateShieldMode(
+    QString broadcasterID, QString moderatorID, bool isActive,
+    ResultCallback<HelixShieldModeStatus> successCallback,
+    FailureCallback<HelixUpdateShieldModeError, QString> failureCallback)
+{
+    using Error = HelixUpdateShieldModeError;
+
+    QUrlQuery urlQuery;
+    urlQuery.addQueryItem("broadcaster_id", broadcasterID);
+    urlQuery.addQueryItem("moderator_id", moderatorID);
+
+    QJsonObject payload;
+    payload["is_active"] = isActive;
+
+    this->makeRequest("moderation/shield_mode", urlQuery)
+        .type(NetworkRequestType::Put)
+        .header("Content-Type", "application/json")
+        .payload(QJsonDocument(payload).toJson(QJsonDocument::Compact))
+        .onSuccess([successCallback](auto result) -> Outcome {
+            if (result.status() != 200)
+            {
+                qCWarning(chatterinoTwitch)
+                    << "Success result for updating shield mode was "
+                    << result.status() << "but we expected it to be 200";
+            }
+
+            const auto response = result.parseJson();
+            successCallback(
+                HelixShieldModeStatus(response["data"][0].toObject()));
+            return Success;
+        })
+        .onError([failureCallback](auto result) {
+            const auto obj = result.parseJson();
+            auto message = obj["message"].toString();
+
+            switch (result.status())
+            {
+                case 400: {
+                    if (message.startsWith("Missing scope",
+                                           Qt::CaseInsensitive))
+                    {
+                        failureCallback(Error::UserMissingScope, message);
+                    }
+                }
+                case 401: {
+                    failureCallback(Error::Forwarded, message);
+                }
+                break;
+                case 403: {
+                    if (message.startsWith(
+                            "Requester does not have permissions",
+                            Qt::CaseInsensitive))
+                    {
+                        failureCallback(Error::MissingPermission, message);
+                        break;
+                    }
+                }
+
+                default: {
+                    qCWarning(chatterinoTwitch)
+                        << "Helix shield mode, 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

@@ -6,6 +6,7 @@
 #include "util/QStringHash.hpp"
 
 #include <boost/optional.hpp>
+#include <QDateTime>
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QString>
@@ -653,6 +654,39 @@ struct HelixStartCommercialResponse {
     }
 };
 
+struct HelixShieldModeStatus {
+    /// A Boolean value that determines whether Shield Mode is active. Is `true` if Shield Mode is active; otherwise, `false`.
+    bool isActive;
+    /// An ID that identifies the moderator that last activated Shield Mode.
+    QString moderatorID;
+    /// The moderator's login name.
+    QString moderatorLogin;
+    /// The moderator's display name.
+    QString moderatorName;
+    /// The UTC timestamp of when Shield Mode was last activated.
+    QDateTime lastActivatedAt;
+
+    explicit HelixShieldModeStatus(const QJsonObject &json)
+        : isActive(json["is_active"].toBool())
+        , moderatorID(json["moderator_id"].toString())
+        , moderatorLogin(json["moderator_login"].toString())
+        , moderatorName(json["moderator_name"].toString())
+        , lastActivatedAt(QDateTime::fromString(
+              json["last_activated_at"].toString(), Qt::ISODate))
+    {
+        this->lastActivatedAt.setTimeSpec(Qt::UTC);
+    }
+};
+
+enum class HelixUpdateShieldModeError {
+    Unknown,
+    UserMissingScope,
+    MissingPermission,
+
+    // The error message is forwarded directly from the Twitch API
+    Forwarded,
+};
+
 enum class HelixStartCommercialError {
     Unknown,
     TokenMustMatchBroadcaster,
@@ -972,6 +1006,13 @@ public:
         FailureCallback<HelixGetChannelBadgesError, QString>
             failureCallback) = 0;
 
+    // https://dev.twitch.tv/docs/api/reference/#update-shield-mode-status
+    virtual void updateShieldMode(
+        QString broadcasterID, QString moderatorID, bool isActive,
+        ResultCallback<HelixShieldModeStatus> successCallback,
+        FailureCallback<HelixUpdateShieldModeError, QString>
+            failureCallback) = 0;
+
     virtual void update(QString clientId, QString oauthToken) = 0;
 
 protected:
@@ -1270,6 +1311,13 @@ public:
                           FailureCallback<HelixGetChannelBadgesError, QString>
                               failureCallback) final;
 
+    // https://dev.twitch.tv/docs/api/reference/#update-shield-mode-status
+    void updateShieldMode(QString broadcasterID, QString moderatorID,
+                          bool isActive,
+                          ResultCallback<HelixShieldModeStatus> successCallback,
+                          FailureCallback<HelixUpdateShieldModeError, QString>
+                              failureCallback) final;
+
     void update(QString clientId, QString oauthToken) final;
 
     static void initialize();