removed functions from SettingsManager that shouldn't be there

src/controllers/moderationactions/ModerationAction.cpp

@@ -0,0 +1,101 @@
+#include "ModerationAction.hpp"
+
+#include "Application.hpp"
+#include "singletons/ResourceManager.hpp"
+
+namespace chatterino {
+
+// ModerationAction::ModerationAction(Image *_image, const QString &_action)
+//    : _isImage(true)
+//    , image(_image)
+//    , action(_action)
+//{
+//}
+
+// ModerationAction::ModerationAction(const QString &_line1, const QString &_line2,
+//                                   const QString &_action)
+//    : _isImage(false)
+//    , image(nullptr)
+//    , line1(_line1)
+//    , line2(_line2)
+//    , action(_action)
+//{
+//}
+
+ModerationAction::ModerationAction(const QString &action)
+    : action_(action)
+{
+    static QRegularExpression replaceRegex("[!/.]");
+    static QRegularExpression timeoutRegex("^[./]timeout.* (\\d+)");
+
+    auto timeoutMatch = timeoutRegex.match(action);
+
+    if (timeoutMatch.hasMatch()) {
+        // if (multipleTimeouts > 1) {
+        QString line1;
+        QString line2;
+
+        int amount = timeoutMatch.captured(1).toInt();
+
+        if (amount < 60) {
+            this->line1_ = QString::number(amount);
+            this->line2_ = "s";
+        } else if (amount < 60 * 60) {
+            this->line1_ = QString::number(amount / 60);
+            this->line2_ = "m";
+        } else if (amount < 60 * 60 * 24) {
+            this->line1_ = QString::number(amount / 60 / 60);
+            this->line2_ = "h";
+        } else {
+            this->line1_ = QString::number(amount / 60 / 60 / 24);
+            this->line2_ = "d";
+        }
+
+        this->line1_ = line1;
+        this->line2_ = line2;
+        // } else {
+        //     this->_moderationActions.emplace_back(app->resources->buttonTimeout, str);
+        // }
+    } else if (action.startsWith("/ban ")) {
+        this->image_ = getApp()->resources->buttonBan;
+    } else {
+        QString xD = action;
+
+        xD.replace(replaceRegex, "");
+
+        this->line1_ = xD.mid(0, 2);
+        this->line2_ = xD.mid(2, 2);
+    }
+}
+
+bool ModerationAction::operator==(const ModerationAction &other) const
+{
+    return this == std::addressof(other);
+}
+
+bool ModerationAction::isImage() const
+{
+    return this->image_ != nullptr;
+}
+
+Image *ModerationAction::getImage() const
+{
+    return this->image_;
+}
+
+const QString &ModerationAction::getLine1() const
+{
+    return this->line1_;
+}
+
+const QString &ModerationAction::getLine2() const
+{
+    return this->line2_;
+}
+
+const QString &ModerationAction::getAction() const
+{
+    return this->action_;
+}
+
+}  // namespace chatterino

src/controllers/moderationactions/ModerationAction.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <QString>
+#include <pajlada/settings/serialize.hpp>
+
+#include "util/RapidjsonHelpers.hpp"
+
+namespace chatterino {
+
+class Image;
+
+class ModerationAction
+{
+public:
+    ModerationAction(const QString &action_);
+
+    bool operator==(const ModerationAction &other) const;
+
+    bool isImage() const;
+    Image *getImage() const;
+    const QString &getLine1() const;
+    const QString &getLine2() const;
+    const QString &getAction() const;
+
+private:
+    bool isImage_;
+    Image *image_;
+    QString line1_;
+    QString line2_;
+    QString action_;
+};
+
+}  // namespace chatterino
+
+namespace pajlada {
+namespace Settings {
+
+template <>
+struct Serialize<chatterino::ModerationAction> {
+    static rapidjson::Value get(const chatterino::ModerationAction &value,
+                                rapidjson::Document::AllocatorType &a)
+    {
+        rapidjson::Value ret(rapidjson::kObjectType);
+
+        AddMember(ret, "pattern", value.getAction(), a);
+
+        return ret;
+    }
+};
+
+template <>
+struct Deserialize<chatterino::ModerationAction> {
+    static chatterino::ModerationAction get(const rapidjson::Value &value)
+    {
+        if (!value.IsObject()) {
+            return chatterino::ModerationAction(QString());
+        }
+
+        QString pattern;
+
+        chatterino::rj::getSafe(value, "pattern", pattern);
+
+        return chatterino::ModerationAction(pattern);
+    }
+};
+
+}  // namespace Settings
+}  // namespace pajlada

src/controllers/moderationactions/ModerationActions.cpp

@@ -0,0 +1,28 @@
+#include "ModerationActions.hpp"
+
+#include "Application.hpp"
+#include "singletons/SettingsManager.hpp"
+
+#include <QRegularExpression>
+
+namespace chatterino {
+
+ModerationActions::ModerationActions()
+{
+}
+
+void ModerationActions::initialize()
+{
+    assert(!this->initialized);
+    this->initialized = true;
+
+    for (auto &val : this->setting.getValue()) {
+        this->items.insertItem(val);
+    }
+
+    this->items.delayedItemsChanged.connect([this] {  //
+        this->setting.setValue(this->items.getVector());
+    });
+}
+
+}  // namespace chatterino

src/controllers/moderationactions/ModerationActions.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "common/SignalVector2.hpp"
+#include "controllers/moderationactions/ModerationAction.hpp"
+#include "singletons/helper/ChatterinoSetting.hpp"
+
+namespace chatterino {
+
+class ModerationActions
+{
+public:
+    ModerationActions();
+
+    void initialize();
+
+    UnsortedSignalVector<ModerationAction> items;
+
+private:
+    ChatterinoSetting<std::vector<ModerationAction>> setting = {"/moderation/actions"};
+    bool initialized = false;
+};
+
+}  // namespace chatterino