feat: add initial experimental Twitch Eventsub support (#5837)

Co-authored-by: nerix <nerixdev@outlook.de>

src/providers/twitch/api/Helix.cpp

@@ -3216,6 +3216,124 @@ void Helix::getFollowedChannel(
         .execute();
 }
 
+void Helix::createEventSubSubscription(
+    const eventsub::SubscriptionRequest &request, const QString &sessionID,
+    ResultCallback<HelixCreateEventSubSubscriptionResponse> successCallback,
+    FailureCallback<HelixCreateEventSubSubscriptionError, QString>
+        failureCallback)
+{
+    using Error = HelixCreateEventSubSubscriptionError;
+
+    QJsonObject condition;
+    for (const auto &[conditionKey, conditionValue] : request.conditions)
+    {
+        condition.insert(conditionKey, conditionValue);
+    }
+
+    QJsonObject body;
+    body.insert("type", request.subscriptionType);
+    body.insert("version", request.subscriptionVersion);
+    body.insert("condition", condition);
+
+    QJsonObject transport;
+    transport.insert("method", "websocket");
+    transport.insert("session_id", sessionID);
+
+    body.insert("transport", transport);
+
+    this->makePost("eventsub/subscriptions", {})
+        .json(body)
+        .onSuccess([successCallback](const auto &result) {
+            if (result.status() != 202)
+            {
+                qCWarning(chatterinoTwitchEventSub)
+                    << "Success result for creating eventsub subscription was "
+                    << result.formatError() << "but we expected it to be 202";
+            }
+
+            HelixCreateEventSubSubscriptionResponse response(
+                result.parseJson());
+
+            successCallback(response);
+        })
+        .onError([failureCallback](const NetworkResult &result) {
+            if (!result.status())
+            {
+                failureCallback(Error::Forwarded, result.formatError());
+                return;
+            }
+
+            const auto obj = result.parseJson();
+            auto message = obj["message"].toString();
+
+            switch (*result.status())
+            {
+                case 400: {
+                    failureCallback(Error::BadRequest, message);
+                }
+                break;
+
+                case 401: {
+                    failureCallback(Error::Unauthorized, message);
+                }
+                break;
+
+                case 403: {
+                    failureCallback(Error::Forbidden, message);
+                }
+                break;
+                case 409: {
+                    failureCallback(Error::Conflict, message);
+                }
+                break;
+
+                case 429: {
+                    failureCallback(Error::Ratelimited, message);
+                }
+                break;
+
+                case 500: {
+                    if (message.isEmpty())
+                    {
+                        failureCallback(Error::Forwarded,
+                                        "Twitch internal server error");
+                    }
+                    else
+                    {
+                        failureCallback(Error::Forwarded, message);
+                    }
+                }
+                break;
+
+                default: {
+                    qCWarning(chatterinoTwitchEventSub)
+                        << "Helix Create EventSub Subscription, unhandled "
+                           "error data:"
+                        << result.formatError() << result.getData() << obj;
+                    failureCallback(Error::Forwarded, message);
+                }
+            }
+        })
+        .execute();
+}
+
+QDebug &operator<<(QDebug &dbg,
+                   const HelixCreateEventSubSubscriptionResponse &data)
+{
+    dbg << "HelixCreateEventSubSubscriptionResponse{ id:" << data.subscriptionID
+        << "status:" << data.subscriptionStatus
+        << "type:" << data.subscriptionType
+        << "version:" << data.subscriptionVersion
+        << "condition:" << data.subscriptionCondition
+        << "createdAt:" << data.subscriptionCreatedAt
+        << "sessionID:" << data.subscriptionSessionID
+        << "connectedAt:" << data.subscriptionConnectedAt
+        << "cost:" << data.subscriptionCost << "total:" << data.total
+        << "totalCost:" << data.totalCost
+        << "maxTotalCost:" << data.maxTotalCost << '}';
+    return dbg;
+}
+
 NetworkRequest Helix::makeRequest(const QString &url, const QUrlQuery &urlQuery,
                                   NetworkRequestType type)
 {

src/providers/twitch/api/Helix.hpp

@@ -2,6 +2,7 @@
 
 #include "common/Aliases.hpp"
 #include "common/network/NetworkRequest.hpp"
+#include "providers/twitch/eventsub/SubscriptionRequest.hpp"
 #include "providers/twitch/TwitchEmotes.hpp"
 #include "util/Helpers.hpp"
 #include "util/QStringHash.hpp"
@@ -809,6 +810,65 @@ struct HelixPaginationState {
     bool done;
 };
 
+struct HelixCreateEventSubSubscriptionResponse {
+    QString subscriptionID;
+    QString subscriptionStatus;
+    QString subscriptionType;
+    QString subscriptionVersion;
+    QJsonObject subscriptionCondition;
+    QString subscriptionCreatedAt;
+    QString subscriptionSessionID;
+    QString subscriptionConnectedAt;
+    int subscriptionCost;
+
+    int total;
+    int totalCost;
+    int maxTotalCost;
+
+    explicit HelixCreateEventSubSubscriptionResponse(
+        const QJsonObject &jsonObject)
+    {
+        {
+            auto jsonData = jsonObject.value("data").toArray().at(0).toObject();
+            this->subscriptionID = jsonData.value("id").toString();
+            this->subscriptionStatus = jsonData.value("status").toString();
+            this->subscriptionType = jsonData.value("type").toString();
+            this->subscriptionVersion = jsonData.value("version").toString();
+            this->subscriptionCondition =
+                jsonData.value("condition").toObject();
+            this->subscriptionCreatedAt =
+                jsonData.value("created_at").toString();
+            this->subscriptionSessionID = jsonData.value("transport")
+                                              .toObject()
+                                              .value("session_id")
+                                              .toString();
+            this->subscriptionConnectedAt = jsonData.value("transport")
+                                                .toObject()
+                                                .value("connected_at")
+                                                .toString();
+            this->subscriptionCost = jsonData.value("cost").toInt();
+        }
+
+        this->total = jsonObject.value("total").toInt();
+        this->totalCost = jsonObject.value("total_cost").toInt();
+        this->maxTotalCost = jsonObject.value("max_total_cost").toInt();
+    }
+
+    friend QDebug &operator<<(
+        QDebug &dbg, const HelixCreateEventSubSubscriptionResponse &data);
+};
+
+enum class HelixCreateEventSubSubscriptionError : std::uint8_t {
+    BadRequest,
+    Unauthorized,
+    Forbidden,
+    Conflict,
+    Ratelimited,
+
+    // The error message is forwarded directly from the Twitch API
+    Forwarded,
+};
+
 class IHelix
 {
 public:
@@ -1150,6 +1210,13 @@ public:
         ResultCallback<std::optional<HelixFollowedChannel>> successCallback,
         FailureCallback<QString> failureCallback) = 0;
 
+    // https://dev.twitch.tv/docs/api/reference/#create-eventsub-subscription
+    virtual void createEventSubSubscription(
+        const eventsub::SubscriptionRequest &request, const QString &sessionID,
+        ResultCallback<HelixCreateEventSubSubscriptionResponse> successCallback,
+        FailureCallback<HelixCreateEventSubSubscriptionError, QString>
+            failureCallback) = 0;
+
     virtual void update(QString clientId, QString oauthToken) = 0;
 
 protected:
@@ -1493,6 +1560,13 @@ public:
         ResultCallback<std::optional<HelixFollowedChannel>> successCallback,
         FailureCallback<QString> failureCallback) final;
 
+    // https://dev.twitch.tv/docs/api/reference/#create-eventsub-subscription
+    void createEventSubSubscription(
+        const eventsub::SubscriptionRequest &request, const QString &sessionID,
+        ResultCallback<HelixCreateEventSubSubscriptionResponse> successCallback,
+        FailureCallback<HelixCreateEventSubSubscriptionError, QString>
+            failureCallback) final;
+
     void update(QString clientId, QString oauthToken) final;
 
     static void initialize();