Migrate /emoteonly and /emoteonlyoff commands to the Helix API (#4015)

Co-authored-by: Felanbird <41973452+Felanbird@users.noreply.github.com> Co-authored-by: Rasmus Karlsson <rasmus.karlsson@pajlada.com>
2022-10-02 16:18:10 +02:00
parent f8f9903892
commit 54129f76a3
6 changed files with 544 additions and 35 deletions
@@ -1530,6 +1530,170 @@ void Helix::startRaid(
        .execute();
 }

+void Helix::updateEmoteMode(
+    QString broadcasterID, QString moderatorID, bool emoteMode,
+    ResultCallback<HelixChatSettings> successCallback,
+    FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+{
+    QJsonObject json;
+    json["emote_mode"] = emoteMode;
+    this->updateChatSettings(broadcasterID, moderatorID, json, successCallback,
+                             failureCallback);
+}
+
+void Helix::updateFollowerMode(
+    QString broadcasterID, QString moderatorID,
+    boost::optional<int> followerModeDuration,
+    ResultCallback<HelixChatSettings> successCallback,
+    FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+{
+    QJsonObject json;
+    json["follower_mode"] = followerModeDuration.has_value();
+    if (followerModeDuration)
+    {
+        json["follower_mode_duration"] = *followerModeDuration;
+    }
+
+    this->updateChatSettings(broadcasterID, moderatorID, json, successCallback,
+                             failureCallback);
+}
+
+void Helix::updateNonModeratorChatDelay(
+    QString broadcasterID, QString moderatorID,
+    boost::optional<int> nonModeratorChatDelayDuration,
+    ResultCallback<HelixChatSettings> successCallback,
+    FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+{
+    QJsonObject json;
+    json["non_moderator_chat_delay"] =
+        nonModeratorChatDelayDuration.has_value();
+    if (nonModeratorChatDelayDuration)
+    {
+        json["non_moderator_chat_delay_duration"] =
+            *nonModeratorChatDelayDuration;
+    }
+
+    this->updateChatSettings(broadcasterID, moderatorID, json, successCallback,
+                             failureCallback);
+}
+
+void Helix::updateSlowMode(
+    QString broadcasterID, QString moderatorID,
+    boost::optional<int> slowModeWaitTime,
+    ResultCallback<HelixChatSettings> successCallback,
+    FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+{
+    QJsonObject json;
+    json["slow_mode"] = slowModeWaitTime.has_value();
+    if (slowModeWaitTime)
+    {
+        json["slow_mode_wait_time"] = *slowModeWaitTime;
+    }
+
+    this->updateChatSettings(broadcasterID, moderatorID, json, successCallback,
+                             failureCallback);
+}
+
+void Helix::updateSubscriberMode(
+    QString broadcasterID, QString moderatorID, bool subscriberMode,
+    ResultCallback<HelixChatSettings> successCallback,
+    FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+{
+    QJsonObject json;
+    json["subscriber_mode"] = subscriberMode;
+    this->updateChatSettings(broadcasterID, moderatorID, json, successCallback,
+                             failureCallback);
+}
+
+void Helix::updateUniqueChatMode(
+    QString broadcasterID, QString moderatorID, bool uniqueChatMode,
+    ResultCallback<HelixChatSettings> successCallback,
+    FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+{
+    QJsonObject json;
+    json["unique_chat_mode"] = uniqueChatMode;
+    this->updateChatSettings(broadcasterID, moderatorID, json, successCallback,
+                             failureCallback);
+}
+
+void Helix::updateChatSettings(
+    QString broadcasterID, QString moderatorID, QJsonObject payload,
+    ResultCallback<HelixChatSettings> successCallback,
+    FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+{
+    using Error = HelixUpdateChatSettingsError;
+
+    QUrlQuery urlQuery;
+
+    urlQuery.addQueryItem("broadcaster_id", broadcasterID);
+    urlQuery.addQueryItem("moderator_id", moderatorID);
+
+    this->makeRequest("chat/settings", urlQuery)
+        .type(NetworkRequestType::Patch)
+        .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 chat settings was"
+                    << result.status() << "but we expected it to be 200";
+            }
+            auto response = result.parseJson();
+            successCallback(HelixChatSettings(
+                response.value("data").toArray().first().toObject()));
+            return Success;
+        })
+        .onError([failureCallback](auto result) {
+            auto obj = result.parseJson();
+            auto message = obj.value("message").toString();
+
+            switch (result.status())
+            {
+                case 400:
+                case 409:
+                case 422:
+                case 425: {
+                    failureCallback(Error::Forwarded, message);
+                }
+                break;
+
+                case 401: {
+                    if (message.startsWith("Missing scope",
+                                           Qt::CaseInsensitive))
+                    {
+                        // Handle this error specifically because its API error is especially unfriendly
+                        failureCallback(Error::UserMissingScope, message);
+                    }
+                    else
+                    {
+                        failureCallback(Error::Forwarded, message);
+                    }
+                }
+                break;
+
+                case 403: {
+                    failureCallback(Error::UserNotAuthorized, message);
+                }
+                break;
+
+                case 429: {
+                    failureCallback(Error::Ratelimited, message);
+                }
+                break;
+
+                default: {
+                    qCDebug(chatterinoTwitch)
+                        << "Unhandled error updating chat settings:"
+                        << result.status() << result.getData() << obj;
+                    failureCallback(Error::Unknown, message);
+                }
+                break;
+            }
+        })
+        .execute();
+}
+
 NetworkRequest Helix::makeRequest(QString url, QUrlQuery urlQuery)
 {
    assert(!url.startsWith("/"));
@@ -300,6 +300,35 @@ struct HelixChannelEmote {
    }
 };

+struct HelixChatSettings {
+    const QString broadcasterId;
+    const bool emoteMode;
+    // boost::none if disabled
+    const boost::optional<int> followerModeDuration;  // time in minutes
+    const boost::optional<int>
+        nonModeratorChatDelayDuration;            // time in seconds
+    const boost::optional<int> slowModeWaitTime;  // time in seconds
+    const bool subscriberMode;
+    const bool uniqueChatMode;
+
+    explicit HelixChatSettings(QJsonObject jsonObject)
+        : broadcasterId(jsonObject.value("broadcaster_id").toString())
+        , emoteMode(jsonObject.value("emote_mode").toBool())
+        , followerModeDuration(boost::make_optional(
+              jsonObject.value("follower_mode").toBool(),
+              jsonObject.value("follower_mode_duration").toInt()))
+        , nonModeratorChatDelayDuration(boost::make_optional(
+              jsonObject.value("non_moderator_chat_delay").toBool(),
+              jsonObject.value("non_moderator_chat_delay_duration").toInt()))
+        , slowModeWaitTime(boost::make_optional(
+              jsonObject.value("slow_mode").toBool(),
+              jsonObject.value("slow_mode_wait_time").toInt()))
+        , subscriberMode(jsonObject.value("subscriber_mode").toBool())
+        , uniqueChatMode(jsonObject.value("unique_chat_mode").toBool())
+    {
+    }
+};
+
 enum class HelixAnnouncementColor {
    Blue,
    Green,
@@ -425,6 +454,16 @@ enum class HelixStartRaidError {  // /raid
    Forwarded,
 };  // /raid

+enum class HelixUpdateChatSettingsError {  // update chat settings
+    Unknown,
+    UserMissingScope,
+    UserNotAuthorized,
+    Ratelimited,
+    Forbidden,
+    // The error message is forwarded directly from the Twitch API
+    Forwarded,
+};  // update chat settings
+
 class IHelix
 {
 public:
@@ -607,7 +646,67 @@ public:
        FailureCallback<HelixStartRaidError, QString> failureCallback) = 0;
    // https://dev.twitch.tv/docs/api/reference#start-a-raid

+    // Updates the emote mode using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    virtual void updateEmoteMode(
+        QString broadcasterID, QString moderatorID, bool emoteMode,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString>
+            failureCallback) = 0;
+
+    // Updates the follower mode using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    virtual void updateFollowerMode(
+        QString broadcasterID, QString moderatorID,
+        boost::optional<int> followerModeDuration,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString>
+            failureCallback) = 0;
+
+    // Updates the non-moderator chat delay using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    virtual void updateNonModeratorChatDelay(
+        QString broadcasterID, QString moderatorID,
+        boost::optional<int> nonModeratorChatDelayDuration,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString>
+            failureCallback) = 0;
+
+    // Updates the slow mode using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    virtual void updateSlowMode(
+        QString broadcasterID, QString moderatorID,
+        boost::optional<int> slowModeWaitTime,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString>
+            failureCallback) = 0;
+
+    // Updates the subscriber mode using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    virtual void updateSubscriberMode(
+        QString broadcasterID, QString moderatorID, bool subscriberMode,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString>
+            failureCallback) = 0;
+
+    // Updates the unique chat mode using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    virtual void updateUniqueChatMode(
+        QString broadcasterID, QString moderatorID, bool uniqueChatMode,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString>
+            failureCallback) = 0;
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+
    virtual void update(QString clientId, QString oauthToken) = 0;
+
+protected:
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    virtual void updateChatSettings(
+        QString broadcasterID, QString moderatorID, QJsonObject json,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString>
+            failureCallback) = 0;
 };

 class Helix final : public IHelix
@@ -783,10 +882,68 @@ public:
        FailureCallback<HelixStartRaidError, QString> failureCallback) final;
    // https://dev.twitch.tv/docs/api/reference#start-a-raid

+    // Updates the emote mode using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    void updateEmoteMode(QString broadcasterID, QString moderatorID,
+                         bool emoteMode,
+                         ResultCallback<HelixChatSettings> successCallback,
+                         FailureCallback<HelixUpdateChatSettingsError, QString>
+                             failureCallback) final;
+
+    // Updates the follower mode using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    void updateFollowerMode(
+        QString broadcasterID, QString moderatorID,
+        boost::optional<int> followerModeDuration,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+        final;
+
+    // Updates the non-moderator chat delay using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    void updateNonModeratorChatDelay(
+        QString broadcasterID, QString moderatorID,
+        boost::optional<int> nonModeratorChatDelayDuration,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+        final;
+
+    // Updates the slow mode using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    void updateSlowMode(QString broadcasterID, QString moderatorID,
+                        boost::optional<int> slowModeWaitTime,
+                        ResultCallback<HelixChatSettings> successCallback,
+                        FailureCallback<HelixUpdateChatSettingsError, QString>
+                            failureCallback) final;
+
+    // Updates the subscriber mode using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    void updateSubscriberMode(
+        QString broadcasterID, QString moderatorID, bool subscriberMode,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+        final;
+
+    // Updates the unique chat mode using
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    void updateUniqueChatMode(
+        QString broadcasterID, QString moderatorID, bool uniqueChatMode,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+        final;
+
    void update(QString clientId, QString oauthToken) final;

    static void initialize();

+protected:
+    // https://dev.twitch.tv/docs/api/reference#update-chat-settings
+    void updateChatSettings(
+        QString broadcasterID, QString moderatorID, QJsonObject json,
+        ResultCallback<HelixChatSettings> successCallback,
+        FailureCallback<HelixUpdateChatSettingsError, QString> failureCallback)
+        final;
+
 private:
    NetworkRequest makeRequest(QString url, QUrlQuery urlQuery);