Replace Discord.cpp with DiscordHook

Author: Salanto

CMakeLists.txt

@@ -97,8 +97,6 @@ qt_add_executable(akashi
   src/data_types.h
   src/db_manager.cpp
   src/db_manager.h
-  src/discord.cpp
-  src/discord.h
   src/main.cpp
   src/medieval_parser.cpp
   src/medieval_parser.h

library/include/discordhook.h

@@ -38,7 +38,7 @@ class AKASHI_ADDON_EXPORT DiscordMessage : public DiscordMessageCommon
     DiscordMessage &setEmbedTitle(const QString &title);
     DiscordMessage &setEmbedDescription(const QString &description);
     DiscordMessage &setEmbedUrl(const QString &url);
-    DiscordMessage &setEmbedColor(int color);
+    DiscordMessage &setEmbedColor(QString color);
     DiscordMessage &setEmbedTimestamp(const QString &timestamp);
     DiscordMessage &setEmbedFooter(const QString &text, const QString &icon_url = "");
     DiscordMessage &setEmbedImage(const QString &url);
@@ -82,9 +82,9 @@ class AKASHI_ADDON_EXPORT DiscordMultipartMessage : public DiscordMessageCommon
     ~DiscordMultipartMessage() = default;
 
     template <typename T>
-    DiscordMultipartMessage &addPart(T data, QString name, QString filename = "")
+    DiscordMultipartMessage &addPart(T data, QString name, QString filename = "", QString mime_type = "", QString charset = "")
     {
-        m_parts.append(DiscordMultipart(std::move(data), std::move(name), std::move(filename)));
+        m_parts.append(DiscordMultipart(std::move(data), std::move(name), std::move(filename), std::move(mime_type), std::move(charset)));
         return *this;
     }
 
@@ -101,6 +101,7 @@ class AKASHI_ADDON_EXPORT DiscordMultipartMessage : public DiscordMessageCommon
     QJsonObject m_payload_json;
 };
 
+Q_DECLARE_EXPORTED_LOGGING_CATEGORY(akashiDiscordHook, AKASHI_ADDON_EXPORT)
 class AKASHI_ADDON_EXPORT DiscordHook : public Service
 {
     Q_OBJECT
@@ -109,7 +110,10 @@ class AKASHI_ADDON_EXPORT DiscordHook : public Service
     DiscordHook(QObject *parent = nullptr);
     ~DiscordHook() = default;
 
-    void setServiceRegistry(ServiceRegistry *f_registry = nullptr) override;
+    inline const static QString SERVICE_ID = "akashi.addon.discordook";
+
+    void
+    setServiceRegistry(ServiceRegistry *f_registry = nullptr) override;
 
     void
     post(const DiscordMessage &message);

library/include/service.h

@@ -2,13 +2,14 @@
 
 #include "akashi_addon_global.h"
 
+#include <QLoggingCategory>
 #include <QMap>
 #include <QObject>
 #include <QVariant>
-#include <QVersionNumber>
 
 class ServiceRegistry;
 
+Q_DECLARE_EXPORTED_LOGGING_CATEGORY(akashiService, AKASHI_ADDON_EXPORT)
 class AKASHI_ADDON_EXPORT Service : public QObject
 {
     Q_OBJECT
@@ -25,13 +26,11 @@ class AKASHI_ADDON_EXPORT Service : public QObject
     Service(QObject *parent = nullptr) : QObject{parent} {};
     ~Service() = default;
 
-    virtual void setServiceRegistry(ServiceRegistry *f_registry = nullptr) {};
-    Service::State getState() { return m_state; };
+    virtual void setServiceRegistry(ServiceRegistry *f_registry = nullptr);
+    void setState(Service::State f_state);
+    Service::State getState();
 
-    QString getServiceProperty(QString f_key) const
-    {
-        return m_service_properties.value(f_key, {});
-    }
+    QString getServiceProperty(QString f_key) const;
 
   protected:
     Service::State m_state = State::PENDING;

library/include/serviceregistry.h

@@ -5,11 +5,14 @@
 #include "akashi_addon_global.h"
 #include "servicewrapper.h"
 
+#include <QLoggingCategory>
 #include <QMap>
 #include <QObject>
 
 class Service;
 
+Q_DECLARE_EXPORTED_LOGGING_CATEGORY(akashiServiceRegistry, AKASHI_ADDON_EXPORT)
+
 // Services are commonly owned by the ServiceRegistry.
 // Why? Because I say so. - Salanto
 
@@ -19,14 +22,15 @@ class AKASHI_ADDON_EXPORT ServiceRegistry : public QObject
 
   public:
     ServiceRegistry(QObject *parent = nullptr);
+    ~ServiceRegistry();
 
     template <class T>
         requires std::is_base_of_v<Service, T>
     inline void create()
     {
         T *l_ptr = new T(this);
         l_ptr->setServiceRegistry(this);
-        insertService(l_ptr);
+        insertService<T>(l_ptr);
     }
 
     template <class T>
@@ -36,31 +40,60 @@ class AKASHI_ADDON_EXPORT ServiceRegistry : public QObject
     {
         T *l_ptr = new T(this);
         ServiceWrapper<T> *l_wrapper = new ServiceWrapper<T>(l_ptr, f_identifier, f_version, f_author, this);
-        insertService(l_wrapper);
+        insertService<ServiceWrapper<T>>(l_wrapper);
     }
 
     template <class T>
         requires std::is_base_of_v<Service, T>
     inline std::optional<T *> get(const QString f_identifier)
     {
         if (!m_services.contains(f_identifier)) {
-            qCritical() << "Unable to get service with identifier" << f_identifier;
+            qCCritical(akashiServiceRegistry) << qUtf8Printable(QString("Unable to get service with identifier %1").arg(f_identifier));
             return std::nullopt;
         }
 
         Service *l_service = m_services.value(f_identifier);
 
         const Service::State l_service_state = l_service->getState();
         if (l_service_state != Service::OK) {
-            qCritical() << "Unable to get service with identifier" << f_identifier << "due to state:" << l_service_state;
+            qCCritical(akashiServiceRegistry) << qUtf8Printable(QString("Unable to get service with identifier %1 due to state: %2").arg(f_identifier).arg(l_service_state));
             return std::nullopt;
         }
 
         return std::make_optional<T *>(static_cast<T *>(l_service));
     }
 
+    inline bool exists(const QString &f_identifier)
+    {
+        return m_services.contains(f_identifier);
+    }
+
   private:
-    void insertService(Service *f_ptr);
+    template <class T>
+        requires std::is_base_of_v<Service, T>
+    void insertService(T *f_ptr)
+    {
+        std::unique_ptr<T> l_ptr_scoped(f_ptr);
+        const QString l_identifier = l_ptr_scoped->getServiceProperty("identifier");
+        const QString l_version = l_ptr_scoped->getServiceProperty("version");
+        const QString l_author = l_ptr_scoped->getServiceProperty("author");
+
+        if (l_identifier.isEmpty()) {
+            qCCritical(akashiServiceRegistry) << "Unable to register service: Service identifier is empty.";
+            return;
+        }
+
+        if (m_services.contains(l_identifier)) {
+            qCCritical(akashiServiceRegistry) << "Unable to register service: Service identifier is already taken.";
+            return;
+        }
+
+        // We are out of the hot path. We can now safely remove ourselves from this equation.
+        T *l_ptr = l_ptr_scoped.release();
+        m_services.insert(l_identifier, l_ptr);
+
+        qCInfo(akashiServiceRegistry) << qUtf8Printable(QString("Adding Service: %1:%2:%3").arg(l_identifier, l_version, l_author));
+    }
 
     QMap<QString, Service *> m_services;
 };

library/include/servicewrapper.h

@@ -7,6 +7,8 @@
 
 // This is a non-owning wrapper. Because I say so. - Salanto
 
+Q_DECLARE_EXPORTED_LOGGING_CATEGORY(akashiServiceWrapper, AKASHI_ADDON_EXPORT)
+
 template <class T>
     requires std::is_base_of_v<QObject, T>
 class ServiceWrapper : public Service

library/src/discordhook.cpp

@@ -11,6 +11,8 @@
 #include <QNetworkReply>
 #include <QNetworkRequest>
 
+Q_LOGGING_CATEGORY(akashiDiscordHook, "akashi.addon.discordhook")
+
 DiscordMessage &DiscordMessage::setRequestUrl(const QString &url)
 {
     m_request_url = url;
@@ -75,7 +77,7 @@ DiscordMessage &DiscordMessage::setEmbedUrl(const QString &url)
     return *this;
 }
 
-DiscordMessage &DiscordMessage::setEmbedColor(int color)
+DiscordMessage &DiscordMessage::setEmbedColor(QString color)
 {
     if (m_building_embed) {
         m_current_embed["color"] = color;
@@ -238,7 +240,7 @@ DiscordHook::DiscordHook(QObject *parent) : Service{parent}
 {
     m_service_properties = {{"author", "Salanto"},
                             {"version", "1.0.0"},
-                            {"identifier", "akashi.network.discordhook"}};
+                            {"identifier", SERVICE_ID}};
 }
 
 void DiscordHook::setServiceRegistry(ServiceRegistry *f_registry)
@@ -247,23 +249,23 @@ void DiscordHook::setServiceRegistry(ServiceRegistry *f_registry)
 
     auto l_service = m_registry->get<ServiceWrapper<QNetworkAccessManager>>("qt.network.manager");
     if (!l_service.has_value()) {
-        m_state = FAILED;
+        setState(State::FAILED);
     }
 
-    m_state = OK;
+    setState(State::OK);
     m_network_manager = l_service.value()->get();
 }
 
 void DiscordHook::post(const DiscordMessage &message)
 {
     if (!m_network_manager) {
-        qWarning() << "Cannot post DiscordMessage: QNetworkAccessManager not installed";
+        qCWarning(akashiDiscordHook) << "Cannot post DiscordMessage: QNetworkAccessManager not installed";
         return;
     }
 
     QUrl url(message.requestUrl());
     if (!url.isValid()) {
-        qWarning() << "Failed to post DiscordMessage: Invalid URL" << message.requestUrl();
+        qCWarning(akashiDiscordHook) << "Failed to post DiscordMessage: Invalid URL" << qUtf8Printable(message.requestUrl());
         return;
     }
 
@@ -280,27 +282,14 @@ void DiscordHook::post(const DiscordMessage &message)
 
 void DiscordHook::post(const DiscordMultipartMessage &message)
 {
-    if (!m_network_manager) {
-        qWarning() << "Cannot post DiscordMultipartMessage: QNetworkAccessManager not installed";
-        return;
-    }
-
     QUrl url(message.requestUrl());
     if (!url.isValid()) {
-        qWarning() << "Failed to post DiscordMultipartMessage: Invalid URL" << message.requestUrl();
+        qCWarning(akashiDiscordHook) << "Failed to post DiscordMultipartMessage: Invalid URL" << qUtf8Printable(message.requestUrl());
         return;
     }
 
     auto *multipart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
 
-    if (!message.payloadJson().isEmpty()) {
-        QHttpPart json_part;
-        json_part.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data; name=\"payload_json\"");
-        json_part.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
-        json_part.setBody(QJsonDocument(message.payloadJson()).toJson(QJsonDocument::Compact));
-        multipart->append(json_part);
-    }
-
     for (int i = 0; i < message.size(); ++i) {
         const DiscordMultipart &part_data = message.partAt(i);
 
@@ -324,6 +313,14 @@ void DiscordHook::post(const DiscordMultipartMessage &message)
         multipart->append(http_part);
     }
 
+    if (!message.payloadJson().isEmpty()) {
+        QHttpPart json_part;
+        json_part.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data; name=\"payload_json\"");
+        json_part.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+        json_part.setBody(QJsonDocument(message.payloadJson()).toJson(QJsonDocument::Compact));
+        multipart->append(json_part);
+    }
+
     QNetworkRequest request(url);
 
     QNetworkReply *reply = m_network_manager->post(request, multipart);
@@ -339,8 +336,8 @@ void DiscordHook::onDiscordResponse(QNetworkReply *reply)
     reply->deleteLater();
 
     if (reply->error() != QNetworkReply::NoError) {
-        qWarning() << "Discord webhook failed:" << reply->errorString();
-        qWarning() << "Response body:" << reply->readAll();
+        qCWarning(akashiDiscordHook) << "Discord webhook failed:" << qUtf8Printable(reply->errorString());
+        qCWarning(akashiDiscordHook) << "Response body:" << reply->readAll();
         return;
     }
 }

library/src/service.cpp

@@ -1 +1,28 @@
 #include "service.h"
+
+#include <QDebug>
+
+Q_LOGGING_CATEGORY(akashiService, "akashi.addon.service")
+
+void Service::setServiceRegistry(ServiceRegistry *f_registry)
+{
+    qCDebug(akashiService) << "Called dummy implementation of" << Q_FUNC_INFO;
+    qCDebug(akashiService) << "This is likely not what is being intended.";
+}
+
+void Service::setState(State f_state)
+{
+    m_state = f_state;
+    qCDebug(akashiService) << "ServiceState of" << getServiceProperty("identifier") << "is set to" << m_state;
+}
+
+Service::State Service::getState()
+{
+    qCDebug(akashiService) << "ServiceState of" << getServiceProperty("identifier") << "is" << m_state;
+    return m_state;
+}
+
+QString Service::getServiceProperty(QString f_key) const
+{
+    return m_service_properties.value(f_key, {});
+}

library/src/serviceregistry.cpp

@@ -1,34 +1,13 @@
 #include "serviceregistry.h"
 #include "service.h"
-#include "servicewrapper.h"
 
 #include <QDebug>
 
+Q_LOGGING_CATEGORY(akashiServiceRegistry, "akashi.addon.serviceregistry")
+
 ServiceRegistry::ServiceRegistry(QObject *parent) : QObject{parent}
 {
-    qInfo() << "Creating new service registry instance at" << this;
+    qCDebug(akashiServiceRegistry) << "Created at" << this;
 }
 
-void ServiceRegistry::insertService(Service *f_ptr)
-{
-    std::unique_ptr<Service> l_ptr_scoped(f_ptr);
-    const QString l_identifier = l_ptr_scoped->getServiceProperty("identifier");
-    const QString l_version = l_ptr_scoped->getServiceProperty("version");
-    const QString l_author = l_ptr_scoped->getServiceProperty("author");
-
-    if (l_identifier.isEmpty()) {
-        qCritical() << "Unable to register service: Service identifier is empty.";
-        return;
-    }
-
-    if (m_services.contains(l_identifier)) {
-        qCritical() << "Unable to register service: Service identifier is already taken.";
-        return;
-    }
-
-    // We are out of the hot path. We can now safely remove ourselves from this equation.
-    Service *l_ptr = l_ptr_scoped.release();
-    m_services.insert(l_identifier, l_ptr);
-
-    qInfo() << QString("Adding Service: %1:%2:%3").arg(l_identifier, l_version, l_author);
-}
+ServiceRegistry::~ServiceRegistry() {}

library/src/servicewrapper.cpp

@@ -1 +1,3 @@
 #include "servicewrapper.h"
+
+Q_LOGGING_CATEGORY(akashiServiceWrapper, "akashi.addon.servicewrapper")

src/aoclient.cpp

@@ -607,13 +607,14 @@ void AOClient::onAfkTimeout()
     m_is_afk = true;
 }
 
-AOClient::AOClient(Server *p_server, NetworkSocket *socket, QObject *parent, int user_id, MusicManager *p_manager) :
+AOClient::AOClient(Server *p_server, NetworkSocket *socket, QObject *parent, int user_id, MusicManager *p_manager, ServiceRegistry *f_registry) :
     QObject(parent),
     m_remote_ip(socket->peerAddress()),
     m_password(""),
     m_joined(false),
     m_socket(socket),
     m_music_manager(p_manager),
+    m_service_registry(f_registry),
     m_last_wtce_time(0),
     m_id(user_id),
     m_current_area(0),