[Move refactor] Reparent orphan classes (#6236)

* Move orphaned classes to their correct parent folders.

---------

Co-authored-by: Lukas Brübach <Bruebach.Lukas@bdosecurity.de>

cockatrice/src/client/network/interfaces/deck_stats_interface.cpp

@@ -0,0 +1,81 @@
+#include "deck_stats_interface.h"
+
+#include <QDesktopServices>
+#include <QMessageBox>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QRegularExpression>
+#include <QUrlQuery>
+#include <libcockatrice/deck_list/deck_list.h>
+#include <libcockatrice/deck_list/deck_list_card_node.h>
+
+DeckStatsInterface::DeckStatsInterface(CardDatabase &_cardDatabase, QObject *parent)
+    : QObject(parent), cardDatabase(_cardDatabase)
+{
+    manager = new QNetworkAccessManager(this);
+    connect(manager, &QNetworkAccessManager::finished, this, &DeckStatsInterface::queryFinished);
+}
+
+void DeckStatsInterface::queryFinished(QNetworkReply *reply)
+{
+    if (reply->error() != QNetworkReply::NoError) {
+        QMessageBox::critical(nullptr, tr("Error"), reply->errorString());
+        reply->deleteLater();
+        deleteLater();
+        return;
+    }
+
+    QString data(reply->readAll());
+    reply->deleteLater();
+
+    static const QRegularExpression rx("<meta property=\"og:url\" content=\"([^\"]+)\"");
+    auto match = rx.match(data);
+    if (!match.hasMatch()) {
+        QMessageBox::critical(nullptr, tr("Error"), tr("The reply from the server could not be parsed."));
+        deleteLater();
+        return;
+    }
+
+    QString deckUrl = match.captured(1);
+    QDesktopServices::openUrl(deckUrl);
+
+    deleteLater();
+}
+
+void DeckStatsInterface::getAnalyzeRequestData(DeckList *deck, QByteArray *data)
+{
+    DeckList deckWithoutTokens;
+    copyDeckWithoutTokens(*deck, deckWithoutTokens);
+
+    QUrl params;
+    QUrlQuery urlQuery;
+    urlQuery.addQueryItem("deck", deckWithoutTokens.writeToString_Plain());
+    urlQuery.addQueryItem("decktitle", deck->getName());
+    params.setQuery(urlQuery);
+    data->append(params.query(QUrl::EncodeReserved).toUtf8());
+}
+
+void DeckStatsInterface::analyzeDeck(DeckList *deck)
+{
+    QByteArray data;
+    getAnalyzeRequestData(deck, &data);
+
+    QNetworkRequest request(QUrl("https://deckstats.net/index.php"));
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
+
+    manager->post(request, data);
+}
+
+void DeckStatsInterface::copyDeckWithoutTokens(DeckList &source, DeckList &destination)
+{
+    auto copyIfNotAToken = [this, &destination](const auto node, const auto card) {
+        CardInfoPtr dbCard = cardDatabase.query()->getCardInfo(card->getName());
+        if (dbCard && !dbCard->getIsToken()) {
+            DecklistCardNode *addedCard = destination.addCard(card->getName(), node->getName(), -1);
+            addedCard->setNumber(card->getNumber());
+        }
+    };
+
+    source.forEachCard(copyIfNotAToken);
+}

cockatrice/src/client/network/interfaces/deck_stats_interface.h

@@ -0,0 +1,43 @@
+/**
+ * @file deck_stats_interface.h
+ * @ingroup ApiInterfaces
+ * @brief TODO: Document this.
+ */
+
+#ifndef DECKSTATS_INTERFACE_H
+#define DECKSTATS_INTERFACE_H
+
+#include <QObject>
+#include <libcockatrice/card/card_database/card_database.h>
+#include <libcockatrice/deck_list/deck_list.h>
+
+class QByteArray;
+class QNetworkAccessManager;
+class QNetworkReply;
+class DeckList;
+
+class DeckStatsInterface : public QObject
+{
+    Q_OBJECT
+private:
+    QNetworkAccessManager *manager;
+
+    CardDatabase &cardDatabase;
+
+    /**
+     * Deckstats doesn't recognize token cards, and instead tries to find the
+     * closest non-token card instead. So we construct a new deck which has no
+     * tokens.
+     */
+    void copyDeckWithoutTokens(DeckList &source, DeckList &destination);
+
+private slots:
+    void queryFinished(QNetworkReply *reply);
+    void getAnalyzeRequestData(DeckList *deck, QByteArray *data);
+
+public:
+    explicit DeckStatsInterface(CardDatabase &_cardDatabase, QObject *parent = nullptr);
+    void analyzeDeck(DeckList *deck);
+};
+
+#endif

cockatrice/src/client/network/interfaces/tapped_out_interface.cpp

@@ -0,0 +1,111 @@
+#include "tapped_out_interface.h"
+
+#include <QDesktopServices>
+#include <QMessageBox>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QRegularExpression>
+#include <QUrlQuery>
+#include <libcockatrice/deck_list/deck_list.h>
+#include <libcockatrice/deck_list/deck_list_card_node.h>
+
+TappedOutInterface::TappedOutInterface(CardDatabase &_cardDatabase, QObject *parent)
+    : QObject(parent), cardDatabase(_cardDatabase)
+{
+    manager = new QNetworkAccessManager(this);
+    connect(manager, &QNetworkAccessManager::finished, this, &TappedOutInterface::queryFinished);
+}
+
+void TappedOutInterface::queryFinished(QNetworkReply *reply)
+{
+    if (reply->error() != QNetworkReply::NoError) {
+        QMessageBox::critical(nullptr, tr("Error"), reply->errorString());
+        reply->deleteLater();
+        deleteLater();
+        return;
+    }
+
+    int httpStatus = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+    if (reply->hasRawHeader("Location")) {
+        /*
+         * If the reply contains a "Location" header, a relative URL to the deck on TappedOut
+         * can be extracted from the header. The http status is a 302 "redirect".
+         */
+        QString deckUrl = reply->rawHeader("Location");
+        qCInfo(TappedOutInterfaceLog) << "Tappedout: good reply, http status" << httpStatus << "location" << deckUrl;
+        QDesktopServices::openUrl("https://tappedout.net" + deckUrl);
+    } else {
+        /*
+         * Otherwise, the deck has not been parsed correctly. Error messages can be extracted
+         * from the html. Css pseudo selector for errors: $("div.alert-danger > ul > li")
+         */
+        QString data(reply->readAll());
+        QStringList errorMessageList = {tr("Unable to analyze the deck.")};
+
+        static const QRegularExpression rx("<div class=\"alert alert-danger.*?<ul>(.*?)</ul>");
+        auto match = rx.match(data);
+        if (match.hasMatch()) {
+            QString errors = match.captured(1);
+            static const QRegularExpression rx2("<li>(.*?)</li>");
+            static const QRegularExpression rxremove("<[^>]*>");
+            auto matchIterator = rx2.globalMatch(errors);
+            while (matchIterator.hasNext()) {
+                auto match2 = matchIterator.next();
+                errorMessageList.append(match2.captured(1).remove(rxremove).simplified());
+            }
+        }
+
+        QString errorMessage = errorMessageList.join("\n");
+        qCWarning(TappedOutInterfaceLog) << "Tappedout: bad reply, http status" << httpStatus << "size" << data.size()
+                                         << "message" << errorMessage;
+
+        QMessageBox::critical(nullptr, tr("Error"), errorMessage);
+    }
+
+    reply->deleteLater();
+    deleteLater();
+}
+
+void TappedOutInterface::getAnalyzeRequestData(DeckList *deck, QByteArray *data)
+{
+    DeckList mainboard, sideboard;
+    copyDeckSplitMainAndSide(*deck, mainboard, sideboard);
+
+    QUrl params;
+    QUrlQuery urlQuery;
+    urlQuery.addQueryItem("name", deck->getName());
+    urlQuery.addQueryItem("mainboard", mainboard.writeToString_Plain(false, true));
+    urlQuery.addQueryItem("sideboard", sideboard.writeToString_Plain(false, true));
+    params.setQuery(urlQuery);
+    data->append(params.query(QUrl::EncodeReserved).toUtf8());
+}
+
+void TappedOutInterface::analyzeDeck(DeckList *deck)
+{
+    QByteArray data;
+    getAnalyzeRequestData(deck, &data);
+
+    QNetworkRequest request(QUrl("https://tappedout.net/mtg-decks/paste/"));
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
+
+    manager->post(request, data);
+}
+
+void TappedOutInterface::copyDeckSplitMainAndSide(DeckList &source, DeckList &mainboard, DeckList &sideboard)
+{
+    auto copyMainOrSide = [this, &mainboard, &sideboard](const auto node, const auto card) {
+        CardInfoPtr dbCard = cardDatabase.query()->getCardInfo(card->getName());
+        if (!dbCard || dbCard->getIsToken())
+            return;
+
+        DecklistCardNode *addedCard;
+        if (node->getName() == DECK_ZONE_SIDE)
+            addedCard = sideboard.addCard(card->getName(), node->getName(), -1);
+        else
+            addedCard = mainboard.addCard(card->getName(), node->getName(), -1);
+        addedCard->setNumber(card->getNumber());
+    };
+
+    source.forEachCard(copyMainOrSide);
+}

cockatrice/src/client/network/interfaces/tapped_out_interface.h

@@ -0,0 +1,45 @@
+/**
+ * @file tapped_out_interface.h
+ * @ingroup ApiInterfaces
+ * @brief TODO: Document this.
+ */
+
+#ifndef TAPPEDOUT_INTERFACE_H
+#define TAPPEDOUT_INTERFACE_H
+
+#include <QLoggingCategory>
+#include <QObject>
+#include <libcockatrice/card/card_database/card_database.h>
+#include <libcockatrice/deck_list/deck_list.h>
+
+inline Q_LOGGING_CATEGORY(TappedOutInterfaceLog, "tapped_out_interface");
+
+class QByteArray;
+class QNetworkAccessManager;
+class QNetworkReply;
+class DeckList;
+
+/**
+ * TappedOutInterface exists in order to support the "Analyze on TappedOut" feature.
+ * An http POST request is sent and the result is retrieved from the reply. Parsing
+ * logic is implemented in TappedOutInterface::queryFinished().
+ */
+
+class TappedOutInterface : public QObject
+{
+    Q_OBJECT
+private:
+    QNetworkAccessManager *manager;
+
+    CardDatabase &cardDatabase;
+    void copyDeckSplitMainAndSide(DeckList &source, DeckList &mainboard, DeckList &sideboard);
+private slots:
+    void queryFinished(QNetworkReply *reply);
+    void getAnalyzeRequestData(DeckList *deck, QByteArray *data);
+
+public:
+    explicit TappedOutInterface(CardDatabase &_cardDatabase, QObject *parent = nullptr);
+    void analyzeDeck(DeckList *deck);
+};
+
+#endif