removed some duplicate code

Signed-off-by: Trial97 <alexandru.tripon97@gmail.com>
2025-03-30 00:32:59 +02:00
parent ab3bfb0f74
commit 29cff14fd6
52 changed files with 928 additions and 2318 deletions
--- a/launcher/ui/pages/modplatform/flame/FlameModel.cpp
+++ b/launcher/ui/pages/modplatform/flame/FlameModel.cpp
@@ -20,7 +20,7 @@ ListModel::~ListModel() {}

 int ListModel::rowCount(const QModelIndex& parent) const
 {
-    return parent.isValid() ? 0 : modpacks.size();
+    return parent.isValid() ? 0 : m_modpacks.size();
 }

 int ListModel::columnCount(const QModelIndex& parent) const
@@ -31,27 +31,27 @@ int ListModel::columnCount(const QModelIndex& parent) const
 QVariant ListModel::data(const QModelIndex& index, int role) const
 {
    int pos = index.row();
-    if (pos >= modpacks.size() || pos < 0 || !index.isValid()) {
+    if (pos >= m_modpacks.size() || pos < 0 || !index.isValid()) {
        return QString("INVALID INDEX %1").arg(pos);
    }

-    IndexedPack pack = modpacks.at(pos);
+    auto pack = m_modpacks.at(pos);
    switch (role) {
        case Qt::ToolTipRole: {
-            if (pack.description.length() > 100) {
+            if (pack->description.length() > 100) {
                // some magic to prevent to long tooltips and replace html linebreaks
-                QString edit = pack.description.left(97);
+                QString edit = pack->description.left(97);
                edit = edit.left(edit.lastIndexOf("<br>")).left(edit.lastIndexOf(" ")).append("...");
                return edit;
            }
-            return pack.description;
+            return pack->description;
        }
        case Qt::DecorationRole: {
-            if (m_logoMap.contains(pack.logoName)) {
-                return (m_logoMap.value(pack.logoName));
+            if (m_logoMap.contains(pack->logoName)) {
+                return (m_logoMap.value(pack->logoName));
            }
            QIcon icon = APPLICATION->getThemedIcon("screenshot-placeholder");
-            ((ListModel*)this)->requestLogo(pack.logoName, pack.logoUrl);
+            ((ListModel*)this)->requestLogo(pack->logoName, pack->logoUrl);
            return icon;
        }
        case Qt::UserRole: {
@@ -62,9 +62,9 @@ QVariant ListModel::data(const QModelIndex& index, int role) const
        case Qt::SizeHintRole:
            return QSize(0, 58);
        case UserDataTypes::TITLE:
-            return pack.name;
+            return pack->name;
        case UserDataTypes::DESCRIPTION:
-            return pack.description;
+            return pack->description;
        case UserDataTypes::INSTALLED:
            return false;
        default:
@@ -76,11 +76,10 @@ QVariant ListModel::data(const QModelIndex& index, int role) const
 bool ListModel::setData(const QModelIndex& index, const QVariant& value, [[maybe_unused]] int role)
 {
    int pos = index.row();
-    if (pos >= modpacks.size() || pos < 0 || !index.isValid())
+    if (pos >= m_modpacks.size() || pos < 0 || !index.isValid())
        return false;

-    Q_ASSERT(value.canConvert<Flame::IndexedPack>());
-    modpacks[pos] = value.value<Flame::IndexedPack>();
+    m_modpacks[pos] = value.value<ModPlatform::IndexedPack::Ptr>();

    return true;
 }
@@ -89,8 +88,8 @@ void ListModel::logoLoaded(QString logo, QIcon out)
 {
    m_loadingLogos.removeAll(logo);
    m_logoMap.insert(logo, out);
-    for (int i = 0; i < modpacks.size(); i++) {
-        if (modpacks[i].logoName == logo) {
+    for (int i = 0; i < m_modpacks.size(); i++) {
+        if (m_modpacks[i]->logoName == logo) {
            emit dataChanged(createIndex(i, 0), createIndex(i, 0), { Qt::DecorationRole });
        }
    }
@@ -117,8 +116,8 @@ void ListModel::requestLogo(QString logo, QString url)
    connect(job, &NetJob::succeeded, this, [this, logo, fullPath, job] {
        job->deleteLater();
        emit logoLoaded(logo, QIcon(fullPath));
-        if (waitingCallbacks.contains(logo)) {
-            waitingCallbacks.value(logo)(fullPath);
+        if (m_waitingCallbacks.contains(logo)) {
+            m_waitingCallbacks.value(logo)(fullPath);
        }
    });

@@ -148,14 +147,14 @@ Qt::ItemFlags ListModel::flags(const QModelIndex& index) const

 bool ListModel::canFetchMore([[maybe_unused]] const QModelIndex& parent) const
 {
-    return searchState == CanPossiblyFetchMore;
+    return m_searchState == CanPossiblyFetchMore;
 }

 void ListModel::fetchMore(const QModelIndex& parent)
 {
    if (parent.isValid())
        return;
-    if (nextSearchOffset == 0) {
+    if (m_nextSearchOffset == 0) {
        qWarning() << "fetchMore with 0 offset is wrong...";
        return;
    }
@@ -164,138 +163,106 @@ void ListModel::fetchMore(const QModelIndex& parent)

 void ListModel::performPaginatedSearch()
 {
-    if (currentSearchTerm.startsWith("#")) {
-        auto projectId = currentSearchTerm.mid(1);
+    static const FlameAPI api;
+    if (m_currentSearchTerm.startsWith("#")) {
+        auto projectId = m_currentSearchTerm.mid(1);
        if (!projectId.isEmpty()) {
-            ResourceAPI::ProjectInfoCallbacks callbacks;
+            ResourceAPI::Callback<ModPlatform::IndexedPack> callbacks;

-            callbacks.on_fail = [this](QString reason) { searchRequestFailed(reason); };
-            callbacks.on_succeed = [this](auto& doc, auto& pack) { searchRequestForOneSucceeded(doc); };
+            callbacks.on_fail = [this](QString reason, int) { searchRequestFailed(reason); };
+            callbacks.on_succeed = [this](auto& pack) { searchRequestForOneSucceeded(pack); };
            callbacks.on_abort = [this] {
                qCritical() << "Search task aborted by an unknown reason!";
                searchRequestFailed("Aborted");
            };
-            static const FlameAPI api;
-            if (auto job = api.getProjectInfo({ projectId }, std::move(callbacks)); job) {
-                jobPtr = job;
-                jobPtr->start();
+            if (auto job = api.getProjectInfo({ { projectId } }, std::move(callbacks)); job) {
+                m_jobPtr = job;
+                m_jobPtr->start();
            }
            return;
        }
    }
    ResourceAPI::SortingMethod sort{};
-    sort.index = currentSort + 1;
+    sort.index = m_currentSort + 1;

-    auto netJob = makeShared<NetJob>("Flame::Search", APPLICATION->network());
-    auto searchUrl =
-        FlameAPI().getSearchURL({ ModPlatform::ResourceType::Modpack, nextSearchOffset, currentSearchTerm, sort, m_filter->loaders,
-                                  m_filter->versions, ModPlatform::Side::NoSide, m_filter->categoryIds, m_filter->openSource });
+    ResourceAPI::Callback<QList<ModPlatform::IndexedPack::Ptr>> callbacks{};

-    netJob->addNetAction(Net::ApiDownload::makeByteArray(QUrl(searchUrl.value()), response));
-    jobPtr = netJob;
-    jobPtr->start();
-    connect(netJob.get(), &NetJob::succeeded, this, &ListModel::searchRequestFinished);
-    connect(netJob.get(), &NetJob::failed, this, &ListModel::searchRequestFailed);
+    callbacks.on_succeed = [this](auto& doc) { searchRequestFinished(doc); };
+    callbacks.on_fail = [this](QString reason, int) { searchRequestFailed(reason); };
+
+    auto netJob = api.searchProjects({ ModPlatform::ResourceType::Modpack, m_nextSearchOffset, m_currentSearchTerm, sort, m_filter->loaders,
+                                       m_filter->versions, ModPlatform::Side::NoSide, m_filter->categoryIds, m_filter->openSource },
+                                     std::move(callbacks));
+
+    m_jobPtr = netJob;
+    m_jobPtr->start();
 }

 void ListModel::searchWithTerm(const QString& term, int sort, std::shared_ptr<ModFilterWidget::Filter> filter, bool filterChanged)
 {
-    if (currentSearchTerm == term && currentSearchTerm.isNull() == term.isNull() && currentSort == sort && !filterChanged) {
+    if (m_currentSearchTerm == term && m_currentSearchTerm.isNull() == term.isNull() && m_currentSort == sort && !filterChanged) {
        return;
    }
-    currentSearchTerm = term;
-    currentSort = sort;
+    m_currentSearchTerm = term;
+    m_currentSort = sort;
    m_filter = filter;
    if (hasActiveSearchJob()) {
-        jobPtr->abort();
-        searchState = ResetRequested;
+        m_jobPtr->abort();
+        m_searchState = ResetRequested;
        return;
    }
    beginResetModel();
-    modpacks.clear();
+    m_modpacks.clear();
    endResetModel();
-    searchState = None;
+    m_searchState = None;

-    nextSearchOffset = 0;
+    m_nextSearchOffset = 0;
    performPaginatedSearch();
 }

-void Flame::ListModel::searchRequestFinished()
+void Flame::ListModel::searchRequestFinished(QList<ModPlatform::IndexedPack::Ptr>& newList)
 {
    if (hasActiveSearchJob())
        return;

-    QJsonParseError parse_error;
-    QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
-    if (parse_error.error != QJsonParseError::NoError) {
-        qWarning() << "Error while parsing JSON response from CurseForge at " << parse_error.offset
-                   << " reason: " << parse_error.errorString();
-        qWarning() << *response;
-        return;
-    }
-
-    QList<Flame::IndexedPack> newList;
-    auto packs = Json::ensureArray(doc.object(), "data");
-    for (auto packRaw : packs) {
-        auto packObj = packRaw.toObject();
-
-        Flame::IndexedPack pack;
-        try {
-            Flame::loadIndexedPack(pack, packObj);
-            newList.append(pack);
-        } catch (const JSONValidationError& e) {
-            qWarning() << "Error while loading pack from CurseForge: " << e.cause();
-            continue;
-        }
-    }
-    if (packs.size() < 25) {
-        searchState = Finished;
+    if (newList.size() < 25) {
+        m_searchState = Finished;
    } else {
-        nextSearchOffset += 25;
-        searchState = CanPossiblyFetchMore;
+        m_nextSearchOffset += 25;
+        m_searchState = CanPossiblyFetchMore;
    }

    // When you have a Qt build with assertions turned on, proceeding here will abort the application
    if (newList.size() == 0)
        return;

-    beginInsertRows(QModelIndex(), modpacks.size(), modpacks.size() + newList.size() - 1);
-    modpacks.append(newList);
+    beginInsertRows(QModelIndex(), m_modpacks.size(), m_modpacks.size() + newList.size() - 1);
+    m_modpacks.append(newList);
    endInsertRows();
 }

-void Flame::ListModel::searchRequestForOneSucceeded(QJsonDocument& doc)
+void Flame::ListModel::searchRequestForOneSucceeded(ModPlatform::IndexedPack& pack)
 {
-    jobPtr.reset();
+    m_jobPtr.reset();

-    auto packObj = Json::ensureObject(doc.object(), "data");
-
-    Flame::IndexedPack pack;
-    try {
-        Flame::loadIndexedPack(pack, packObj);
-    } catch (const JSONValidationError& e) {
-        qWarning() << "Error while loading pack from CurseForge: " << e.cause();
-        return;
-    }
-
-    beginInsertRows(QModelIndex(), modpacks.size(), modpacks.size() + 1);
-    modpacks.append({ pack });
+    beginInsertRows(QModelIndex(), m_modpacks.size(), m_modpacks.size() + 1);
+    m_modpacks.append(std::make_shared<ModPlatform::IndexedPack>(pack));
    endInsertRows();
 }

 void Flame::ListModel::searchRequestFailed(QString reason)
 {
-    jobPtr.reset();
+    m_jobPtr.reset();

-    if (searchState == ResetRequested) {
+    if (m_searchState == ResetRequested) {
        beginResetModel();
-        modpacks.clear();
+        m_modpacks.clear();
        endResetModel();

-        nextSearchOffset = 0;
+        m_nextSearchOffset = 0;
        performPaginatedSearch();
    } else {
-        searchState = Finished;
+        m_searchState = Finished;
    }
 }

--- a/launcher/ui/pages/modplatform/flame/FlameModel.h
+++ b/launcher/ui/pages/modplatform/flame/FlameModel.h
@@ -16,8 +16,6 @@
 #include <functional>
 #include "ui/widgets/ModFilterWidget.h"

-#include <modplatform/flame/FlamePackIndex.h>
-
 namespace Flame {

 using LogoMap = QMap<QString, QIcon>;
@@ -41,8 +39,8 @@ class ListModel : public QAbstractListModel {
    void getLogo(const QString& logo, const QString& logoUrl, LogoCallback callback);
    void searchWithTerm(const QString& term, int sort, std::shared_ptr<ModFilterWidget::Filter> filter, bool filterChanged);

-    bool hasActiveSearchJob() const { return jobPtr && jobPtr->isRunning(); }
-    Task::Ptr activeSearchJob() { return hasActiveSearchJob() ? jobPtr : nullptr; }
+    bool hasActiveSearchJob() const { return m_jobPtr && m_jobPtr->isRunning(); }
+    Task::Ptr activeSearchJob() { return hasActiveSearchJob() ? m_jobPtr : nullptr; }

   private slots:
    void performPaginatedSearch();
@@ -50,27 +48,26 @@ class ListModel : public QAbstractListModel {
    void logoFailed(QString logo);
    void logoLoaded(QString logo, QIcon out);

-    void searchRequestFinished();
+    void searchRequestFinished(QList<ModPlatform::IndexedPack::Ptr>&);
    void searchRequestFailed(QString reason);
-    void searchRequestForOneSucceeded(QJsonDocument&);
+    void searchRequestForOneSucceeded(ModPlatform::IndexedPack&);

   private:
    void requestLogo(QString file, QString url);

   private:
-    QList<IndexedPack> modpacks;
+    QList<ModPlatform::IndexedPack::Ptr> m_modpacks;
    QStringList m_failedLogos;
    QStringList m_loadingLogos;
    LogoMap m_logoMap;
-    QMap<QString, LogoCallback> waitingCallbacks;
+    QMap<QString, LogoCallback> m_waitingCallbacks;

-    QString currentSearchTerm;
-    int currentSort = 0;
+    QString m_currentSearchTerm;
+    int m_currentSort = 0;
    std::shared_ptr<ModFilterWidget::Filter> m_filter;
-    int nextSearchOffset = 0;
-    enum SearchState { None, CanPossiblyFetchMore, ResetRequested, Finished } searchState = None;
-    Task::Ptr jobPtr;
-    std::shared_ptr<QByteArray> response = std::make_shared<QByteArray>();
+    int m_nextSearchOffset = 0;
+    enum SearchState { None, CanPossiblyFetchMore, ResetRequested, Finished } m_searchState = None;
+    Task::Ptr m_jobPtr;
 };

 }  // namespace Flame
--- a/launcher/ui/pages/modplatform/flame/FlamePage.cpp
+++ b/launcher/ui/pages/modplatform/flame/FlamePage.cpp
@@ -35,7 +35,8 @@

 #include "FlamePage.h"
 #include "Version.h"
-#include "modplatform/flame/FlamePackIndex.h"
+#include "modplatform/ModIndex.h"
+#include "modplatform/ResourceAPI.h"
 #include "ui/dialogs/CustomMessageBox.h"
 #include "ui/widgets/ModFilterWidget.h"
 #include "ui_FlamePage.h"
@@ -43,29 +44,25 @@
 #include <QKeyEvent>
 #include <memory>

-#include "Application.h"
 #include "FlameModel.h"
 #include "InstanceImportTask.h"
-#include "Json.h"
 #include "StringUtils.h"
 #include "modplatform/flame/FlameAPI.h"
 #include "ui/dialogs/NewInstanceDialog.h"
 #include "ui/widgets/ProjectItem.h"

-#include "net/ApiDownload.h"
-
 static FlameAPI api;

 FlamePage::FlamePage(NewInstanceDialog* dialog, QWidget* parent)
-    : QWidget(parent), ui(new Ui::FlamePage), dialog(dialog), m_fetch_progress(this, false)
+    : QWidget(parent), m_ui(new Ui::FlamePage), m_dialog(dialog), m_fetch_progress(this, false)
 {
-    ui->setupUi(this);
-    ui->searchEdit->installEventFilter(this);
-    listModel = new Flame::ListModel(this);
-    ui->packView->setModel(listModel);
+    m_ui->setupUi(this);
+    m_ui->searchEdit->installEventFilter(this);
+    m_listModel = new Flame::ListModel(this);
+    m_ui->packView->setModel(m_listModel);

-    ui->versionSelectionBox->view()->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
-    ui->versionSelectionBox->view()->parentWidget()->setMaximumHeight(300);
+    m_ui->versionSelectionBox->view()->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+    m_ui->versionSelectionBox->view()->parentWidget()->setMaximumHeight(300);

    m_search_timer.setTimerType(Qt::TimerType::CoarseTimer);
    m_search_timer.setSingleShot(true);
@@ -76,33 +73,33 @@ FlamePage::FlamePage(NewInstanceDialog* dialog, QWidget* parent)
    m_fetch_progress.setFixedHeight(24);
    m_fetch_progress.progressFormat("");

-    ui->verticalLayout->insertWidget(2, &m_fetch_progress);
+    m_ui->verticalLayout->insertWidget(2, &m_fetch_progress);

    // index is used to set the sorting with the curseforge api
-    ui->sortByBox->addItem(tr("Sort by Featured"));
-    ui->sortByBox->addItem(tr("Sort by Popularity"));
-    ui->sortByBox->addItem(tr("Sort by Last Updated"));
-    ui->sortByBox->addItem(tr("Sort by Name"));
-    ui->sortByBox->addItem(tr("Sort by Author"));
-    ui->sortByBox->addItem(tr("Sort by Total Downloads"));
+    m_ui->sortByBox->addItem(tr("Sort by Featured"));
+    m_ui->sortByBox->addItem(tr("Sort by Popularity"));
+    m_ui->sortByBox->addItem(tr("Sort by Last Updated"));
+    m_ui->sortByBox->addItem(tr("Sort by Name"));
+    m_ui->sortByBox->addItem(tr("Sort by Author"));
+    m_ui->sortByBox->addItem(tr("Sort by Total Downloads"));

-    connect(ui->sortByBox, &QComboBox::currentIndexChanged, this, &FlamePage::triggerSearch);
-    connect(ui->packView->selectionModel(), &QItemSelectionModel::currentChanged, this, &FlamePage::onSelectionChanged);
-    connect(ui->versionSelectionBox, &QComboBox::currentIndexChanged, this, &FlamePage::onVersionSelectionChanged);
+    connect(m_ui->sortByBox, &QComboBox::currentIndexChanged, this, &FlamePage::triggerSearch);
+    connect(m_ui->packView->selectionModel(), &QItemSelectionModel::currentChanged, this, &FlamePage::onSelectionChanged);
+    connect(m_ui->versionSelectionBox, &QComboBox::currentIndexChanged, this, &FlamePage::onVersionSelectionChanged);

-    ui->packView->setItemDelegate(new ProjectItemDelegate(this));
-    ui->packDescription->setMetaEntry("FlamePacks");
+    m_ui->packView->setItemDelegate(new ProjectItemDelegate(this));
+    m_ui->packDescription->setMetaEntry("FlamePacks");
    createFilterWidget();
 }

 FlamePage::~FlamePage()
 {
-    delete ui;
+    delete m_ui;
 }

 bool FlamePage::eventFilter(QObject* watched, QEvent* event)
 {
-    if (watched == ui->searchEdit && event->type() == QEvent::KeyPress) {
+    if (watched == m_ui->searchEdit && event->type() == QEvent::KeyPress) {
        QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
        if (keyEvent->key() == Qt::Key_Return) {
            triggerSearch();
@@ -125,7 +122,7 @@ bool FlamePage::shouldDisplay() const

 void FlamePage::retranslate()
 {
-    ui->retranslateUi(this);
+    m_ui->retranslateUi(this);
 }

 void FlamePage::openedImpl()
@@ -136,109 +133,91 @@ void FlamePage::openedImpl()

 void FlamePage::triggerSearch()
 {
-    ui->packView->selectionModel()->setCurrentIndex({}, QItemSelectionModel::SelectionFlag::ClearAndSelect);
-    ui->packView->clearSelection();
-    ui->packDescription->clear();
-    ui->versionSelectionBox->clear();
+    m_ui->packView->selectionModel()->setCurrentIndex({}, QItemSelectionModel::SelectionFlag::ClearAndSelect);
+    m_ui->packView->clearSelection();
+    m_ui->packDescription->clear();
+    m_ui->versionSelectionBox->clear();
    bool filterChanged = m_filterWidget->changed();
-    listModel->searchWithTerm(ui->searchEdit->text(), ui->sortByBox->currentIndex(), m_filterWidget->getFilter(), filterChanged);
-    m_fetch_progress.watch(listModel->activeSearchJob().get());
-}
-
-bool checkVersionFilters(const Flame::IndexedVersion& v, std::shared_ptr<ModFilterWidget::Filter> filter)
-{
-    if (!filter)
-        return true;
-    return ((!filter->loaders || !v.loaders || filter->loaders & v.loaders) &&  // loaders
-            (filter->releases.empty() ||                                        // releases
-             std::find(filter->releases.cbegin(), filter->releases.cend(), v.version_type) != filter->releases.cend()) &&
-            filter->checkMcVersions({ v.mcVersion }));  // mcVersions}
+    m_listModel->searchWithTerm(m_ui->searchEdit->text(), m_ui->sortByBox->currentIndex(), m_filterWidget->getFilter(), filterChanged);
+    m_fetch_progress.watch(m_listModel->activeSearchJob().get());
 }

 void FlamePage::onSelectionChanged(QModelIndex curr, [[maybe_unused]] QModelIndex prev)
 {
-    ui->versionSelectionBox->clear();
+    m_ui->versionSelectionBox->clear();

    if (!curr.isValid()) {
        if (isOpened) {
-            dialog->setSuggestedPack();
+            m_dialog->setSuggestedPack();
        }
        return;
    }

-    QVariant raw = listModel->data(curr, Qt::UserRole);
-    Q_ASSERT(raw.canConvert<Flame::IndexedPack>());
-    current = raw.value<Flame::IndexedPack>();
+    m_current = m_listModel->data(curr, Qt::UserRole).value<ModPlatform::IndexedPack::Ptr>();

-    if (!current.versionsLoaded || m_filterWidget->changed()) {
+    if (!m_current->versionsLoaded || m_filterWidget->changed()) {
        qDebug() << "Loading flame modpack versions";
-        auto netJob = new NetJob(QString("Flame::PackVersions(%1)").arg(current.name), APPLICATION->network());
-        auto response = std::make_shared<QByteArray>();
-        int addonId = current.addonId;
-        netJob->addNetAction(
-            Net::ApiDownload::makeByteArray(QString(BuildConfig.FLAME_BASE_URL + "/mods/%1/files").arg(addonId), response));

-        connect(netJob, &NetJob::succeeded, this, [this, response, addonId, curr] {
-            if (addonId != current.addonId) {
+        ResourceAPI::Callback<QVector<ModPlatform::IndexedVersion> > callbacks{};
+
+        auto addonId = m_current->addonId;
+        // Use default if no callbacks are set
+        callbacks.on_succeed = [this, curr, addonId](auto& doc) {
+            if (addonId != m_current->addonId) {
                return;  // wrong request
            }
-            QJsonParseError parse_error;
-            QJsonDocument doc = QJsonDocument::fromJson(*response, &parse_error);
-            if (parse_error.error != QJsonParseError::NoError) {
-                qWarning() << "Error while parsing JSON response from CurseForge at " << parse_error.offset
-                           << " reason: " << parse_error.errorString();
-                qWarning() << *response;
-                return;
-            }
-            auto arr = Json::ensureArray(doc.object(), "data");
-            try {
-                Flame::loadIndexedPackVersions(current, arr);
-            } catch (const JSONValidationError& e) {
-                qDebug() << *response;
-                qWarning() << "Error while reading flame modpack version: " << e.cause();
-            }

-            auto pred = [this](const Flame::IndexedVersion& v) { return !checkVersionFilters(v, m_filterWidget->getFilter()); };
+            m_current->versions = doc;
+            m_current->versionsLoaded = true;
+            auto pred = [this](const ModPlatform::IndexedVersion& v) {
+                if (auto filter = m_filterWidget->getFilter())
+                    return !filter->checkModpackFilters(v);
+                return false;
+            };
 #if QT_VERSION >= QT_VERSION_CHECK(6, 1, 0)
-            current.versions.removeIf(pred);
+            m_current->versions.removeIf(pred);
 #else
-    for (auto it = current.versions.begin(); it != current.versions.end();)
-        if (pred(*it))
-            it = current.versions.erase(it);
-        else
-            ++it;
+            for (auto it = m_current->versions.begin(); it != m_current->versions.end();)
+                if (pred(*it))
+                    it = m_current->versions.erase(it);
+                else
+                    ++it;
 #endif
-            for (const auto& version : current.versions) {
-                ui->versionSelectionBox->addItem(Flame::getVersionDisplayString(version), QVariant(version.downloadUrl));
+            for (auto version : m_current->versions) {
+                m_ui->versionSelectionBox->addItem(version.getVersionDisplayString(), QVariant(version.downloadUrl));
            }

            QVariant current_updated;
-            current_updated.setValue(current);
+            current_updated.setValue(m_current);

-            if (!listModel->setData(curr, current_updated, Qt::UserRole))
+            if (!m_listModel->setData(curr, current_updated, Qt::UserRole))
                qWarning() << "Failed to cache versions for the current pack!";

            // TODO: Check whether it's a connection issue or the project disabled 3rd-party distribution.
-            if (current.versionsLoaded && ui->versionSelectionBox->count() < 1) {
-                ui->versionSelectionBox->addItem(tr("No version is available!"), -1);
+            if (m_current->versionsLoaded && m_ui->versionSelectionBox->count() < 1) {
+                m_ui->versionSelectionBox->addItem(tr("No version is available!"), -1);
            }
            suggestCurrent();
-        });
-        connect(netJob, &NetJob::finished, this, [response, netJob] { netJob->deleteLater(); });
-        connect(netJob, &NetJob::failed,
-                [this](QString reason) { CustomMessageBox::selectable(this, tr("Error"), reason, QMessageBox::Critical)->exec(); });
+        };
+        callbacks.on_fail = [this](QString reason, int) {
+            CustomMessageBox::selectable(this, tr("Error"), reason, QMessageBox::Critical)->exec();
+        };
+
+        auto netJob = api.getProjectVersions({ *m_current, {}, {}, ModPlatform::ResourceType::Modpack }, std::move(callbacks));
+
+        m_job = netJob;
        netJob->start();
    } else {
-        for (auto version : current.versions) {
-            ui->versionSelectionBox->addItem(version.version, QVariant(version.downloadUrl));
+        for (auto version : m_current->versions) {
+            m_ui->versionSelectionBox->addItem(version.version, QVariant(version.downloadUrl));
        }

        suggestCurrent();
    }

    // TODO: Check whether it's a connection issue or the project disabled 3rd-party distribution.
-    if (current.versionsLoaded && ui->versionSelectionBox->count() < 1) {
-        ui->versionSelectionBox->addItem(tr("No version is available!"), -1);
+    if (m_current->versionsLoaded && m_ui->versionSelectionBox->count() < 1) {
+        m_ui->versionSelectionBox->addItem(tr("No version is available!"), -1);
    }

    updateUi();
@@ -251,26 +230,26 @@ void FlamePage::suggestCurrent()
    }

    if (m_selected_version_index == -1) {
-        dialog->setSuggestedPack();
+        m_dialog->setSuggestedPack();
        return;
    }

-    auto version = current.versions.at(m_selected_version_index);
+    auto version = m_current->versions.at(m_selected_version_index);

    QMap<QString, QString> extra_info;
-    extra_info.insert("pack_id", QString::number(current.addonId));
-    extra_info.insert("pack_version_id", QString::number(version.fileId));
+    extra_info.insert("pack_id", m_current->addonId.toString());
+    extra_info.insert("pack_version_id", version.fileId.toString());

-    dialog->setSuggestedPack(current.name, new InstanceImportTask(version.downloadUrl, this, std::move(extra_info)));
-    QString editedLogoName = "curseforge_" + current.logoName;
-    listModel->getLogo(current.logoName, current.logoUrl,
-                       [this, editedLogoName](QString logo) { dialog->setSuggestedIconFromFile(logo, editedLogoName); });
+    m_dialog->setSuggestedPack(m_current->name, new InstanceImportTask(version.downloadUrl, this, std::move(extra_info)));
+    QString editedLogoName = "curseforge_" + m_current->logoName;
+    m_listModel->getLogo(m_current->logoName, m_current->logoUrl,
+                         [this, editedLogoName](QString logo) { m_dialog->setSuggestedIconFromFile(logo, editedLogoName); });
 }

 void FlamePage::onVersionSelectionChanged(int index)
 {
    bool is_blocked = false;
-    ui->versionSelectionBox->itemData(index).toInt(&is_blocked);
+    m_ui->versionSelectionBox->itemData(index).toInt(&is_blocked);

    if (index == -1 || is_blocked) {
        m_selected_version_index = -1;
@@ -279,7 +258,7 @@ void FlamePage::onVersionSelectionChanged(int index)

    m_selected_version_index = index;

-    Q_ASSERT(current.versions.at(m_selected_version_index).downloadUrl == ui->versionSelectionBox->currentData().toString());
+    Q_ASSERT(m_current->versions.at(m_selected_version_index).downloadUrl == m_ui->versionSelectionBox->currentData().toString());

    suggestCurrent();
 }
@@ -287,66 +266,67 @@ void FlamePage::onVersionSelectionChanged(int index)
 void FlamePage::updateUi()
 {
    QString text = "";
-    QString name = current.name;
+    QString name = m_current->name;

-    if (current.extra.websiteUrl.isEmpty())
+    if (m_current->websiteUrl.isEmpty())
        text = name;
    else
-        text = "<a href=\"" + current.extra.websiteUrl + "\">" + name + "</a>";
-    if (!current.authors.empty()) {
-        auto authorToStr = [](Flame::ModpackAuthor& author) {
+        text = "<a href=\"" + m_current->websiteUrl + "\">" + name + "</a>";
+    if (!m_current->authors.empty()) {
+        auto authorToStr = [](ModPlatform::ModpackAuthor& author) {
            if (author.url.isEmpty()) {
                return author.name;
            }
            return QString("<a href=\"%1\">%2</a>").arg(author.url, author.name);
        };
        QStringList authorStrs;
-        for (auto& author : current.authors) {
+        for (auto& author : m_current->authors) {
            authorStrs.push_back(authorToStr(author));
        }
        text += "<br>" + tr(" by ") + authorStrs.join(", ");
    }

-    if (current.extraInfoLoaded) {
-        if (!current.extra.issuesUrl.isEmpty() || !current.extra.sourceUrl.isEmpty() || !current.extra.wikiUrl.isEmpty()) {
+    if (m_current->extraDataLoaded) {
+        if (!m_current->extraData.issuesUrl.isEmpty() || !m_current->extraData.sourceUrl.isEmpty() ||
+            !m_current->extraData.wikiUrl.isEmpty()) {
            text += "<br><br>" + tr("External links:") + "<br>";
        }

-        if (!current.extra.issuesUrl.isEmpty())
-            text += "- " + tr("Issues: <a href=%1>%1</a>").arg(current.extra.issuesUrl) + "<br>";
-        if (!current.extra.wikiUrl.isEmpty())
-            text += "- " + tr("Wiki: <a href=%1>%1</a>").arg(current.extra.wikiUrl) + "<br>";
-        if (!current.extra.sourceUrl.isEmpty())
-            text += "- " + tr("Source code: <a href=%1>%1</a>").arg(current.extra.sourceUrl) + "<br>";
+        if (!m_current->extraData.issuesUrl.isEmpty())
+            text += "- " + tr("Issues: <a href=%1>%1</a>").arg(m_current->extraData.issuesUrl) + "<br>";
+        if (!m_current->extraData.wikiUrl.isEmpty())
+            text += "- " + tr("Wiki: <a href=%1>%1</a>").arg(m_current->extraData.wikiUrl) + "<br>";
+        if (!m_current->extraData.sourceUrl.isEmpty())
+            text += "- " + tr("Source code: <a href=%1>%1</a>").arg(m_current->extraData.sourceUrl) + "<br>";
    }

    text += "<hr>";
-    text += api.getModDescription(current.addonId).toUtf8();
+    text += api.getModDescription(m_current->addonId.toInt()).toUtf8();

-    ui->packDescription->setHtml(StringUtils::htmlListPatch(text + current.description));
-    ui->packDescription->flush();
+    m_ui->packDescription->setHtml(StringUtils::htmlListPatch(text + m_current->description));
+    m_ui->packDescription->flush();
 }
 QString FlamePage::getSerachTerm() const
 {
-    return ui->searchEdit->text();
+    return m_ui->searchEdit->text();
 }

 void FlamePage::setSearchTerm(QString term)
 {
-    ui->searchEdit->setText(term);
+    m_ui->searchEdit->setText(term);
 }

 void FlamePage::createFilterWidget()
 {
    auto widget = ModFilterWidget::create(nullptr, false);
    m_filterWidget.swap(widget);
-    auto old = ui->splitter->replaceWidget(0, m_filterWidget.get());
+    auto old = m_ui->splitter->replaceWidget(0, m_filterWidget.get());
    // because we replaced the widget we also need to delete it
    if (old) {
        delete old;
    }

-    connect(ui->filterButton, &QPushButton::clicked, this, [this] { m_filterWidget->setHidden(!m_filterWidget->isHidden()); });
+    connect(m_ui->filterButton, &QPushButton::clicked, this, [this] { m_filterWidget->setHidden(!m_filterWidget->isHidden()); });

    connect(m_filterWidget.get(), &ModFilterWidget::filterChanged, this, &FlamePage::triggerSearch);
    auto response = std::make_shared<QByteArray>();
--- a/launcher/ui/pages/modplatform/flame/FlamePage.h
+++ b/launcher/ui/pages/modplatform/flame/FlamePage.h
@@ -38,8 +38,8 @@
 #include <QWidget>

 #include <Application.h>
-#include <modplatform/flame/FlamePackIndex.h>
 #include <QTimer>
+#include "modplatform/ModIndex.h"
 #include "ui/pages/modplatform/ModpackProviderBasePage.h"
 #include "ui/widgets/ModFilterWidget.h"
 #include "ui/widgets/ProgressWidget.h"
@@ -88,10 +88,10 @@ class FlamePage : public QWidget, public ModpackProviderBasePage {
    void createFilterWidget();

   private:
-    Ui::FlamePage* ui = nullptr;
-    NewInstanceDialog* dialog = nullptr;
-    Flame::ListModel* listModel = nullptr;
-    Flame::IndexedPack current;
+    Ui::FlamePage* m_ui = nullptr;
+    NewInstanceDialog* m_dialog = nullptr;
+    Flame::ListModel* m_listModel = nullptr;
+    ModPlatform::IndexedPack::Ptr m_current;

    int m_selected_version_index = -1;

@@ -102,4 +102,5 @@ class FlamePage : public QWidget, public ModpackProviderBasePage {

    std::unique_ptr<ModFilterWidget> m_filterWidget;
    Task::Ptr m_categoriesTask;
+    Task::Ptr m_job;
 };
--- a/launcher/ui/pages/modplatform/flame/FlameResourceModels.cpp
+++ b/launcher/ui/pages/modplatform/flame/FlameResourceModels.cpp
@@ -8,7 +8,7 @@

 #include "minecraft/PackProfile.h"
 #include "modplatform/flame/FlameAPI.h"
-#include "modplatform/flame/FlameModIndex.h"
+#include "ui/pages/modplatform/flame/FlameResourcePages.h"

 namespace ResourceDownload {

@@ -17,97 +17,9 @@ static bool isOptedOut(const ModPlatform::IndexedVersion& ver)
    return ver.downloadUrl.isEmpty();
 }

-FlameModModel::FlameModModel(BaseInstance& base) : ModModel(base, new FlameAPI) {}
-
-void FlameModModel::loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj)
-{
-    FlameMod::loadIndexedPack(m, obj);
-}
-
-// We already deal with the URLs when initializing the pack, due to the API response's structure
-void FlameModModel::loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj)
-{
-    FlameMod::loadBody(m, obj);
-}
-
-void FlameModModel::loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr)
-{
-    FlameMod::loadIndexedPackVersions(m, arr);
-}
-
-auto FlameModModel::loadDependencyVersions(const ModPlatform::Dependency& m, QJsonArray& arr) -> ModPlatform::IndexedVersion
-{
-    return FlameMod::loadDependencyVersions(m, arr, &m_base_instance);
-}
-
-bool FlameModModel::optedOut(const ModPlatform::IndexedVersion& ver) const
-{
-    return isOptedOut(ver);
-}
-
-auto FlameModModel::documentToArray(QJsonDocument& obj) const -> QJsonArray
-{
-    return Json::ensureArray(obj.object(), "data");
-}
-
-FlameResourcePackModel::FlameResourcePackModel(const BaseInstance& base) : ResourcePackResourceModel(base, new FlameAPI) {}
-
-void FlameResourcePackModel::loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj)
-{
-    FlameMod::loadIndexedPack(m, obj);
-}
-
-// We already deal with the URLs when initializing the pack, due to the API response's structure
-void FlameResourcePackModel::loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj)
-{
-    FlameMod::loadBody(m, obj);
-}
-
-void FlameResourcePackModel::loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr)
-{
-    FlameMod::loadIndexedPackVersions(m, arr);
-}
-
-bool FlameResourcePackModel::optedOut(const ModPlatform::IndexedVersion& ver) const
-{
-    return isOptedOut(ver);
-}
-
-auto FlameResourcePackModel::documentToArray(QJsonDocument& obj) const -> QJsonArray
-{
-    return Json::ensureArray(obj.object(), "data");
-}
-
-FlameTexturePackModel::FlameTexturePackModel(const BaseInstance& base) : TexturePackResourceModel(base, new FlameAPI) {}
-
-void FlameTexturePackModel::loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj)
-{
-    FlameMod::loadIndexedPack(m, obj);
-}
-
-// We already deal with the URLs when initializing the pack, due to the API response's structure
-void FlameTexturePackModel::loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj)
-{
-    FlameMod::loadBody(m, obj);
-}
-
-void FlameTexturePackModel::loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr)
-{
-    FlameMod::loadIndexedPackVersions(m, arr);
-
-    QList<ModPlatform::IndexedVersion> filtered_versions(m.versions.size());
-
-    // FIXME: Client-side version filtering. This won't take into account any user-selected filtering.
-    for (auto const& version : m.versions) {
-        auto const& mc_versions = version.mcVersion;
-
-        if (std::any_of(mc_versions.constBegin(), mc_versions.constEnd(),
-                        [this](auto const& mc_version) { return Version(mc_version) <= maximumTexturePackVersion(); }))
-            filtered_versions.push_back(version);
-    }
-
-    m.versions = filtered_versions;
-}
+FlameTexturePackModel::FlameTexturePackModel(const BaseInstance& base)
+    : TexturePackResourceModel(base, new FlameAPI, Flame::debugName(), Flame::metaEntryBase())
+{}

 ResourceAPI::SearchArgs FlameTexturePackModel::createSearchArguments()
 {
@@ -137,65 +49,4 @@ bool FlameTexturePackModel::optedOut(const ModPlatform::IndexedVersion& ver) con
    return isOptedOut(ver);
 }

-auto FlameTexturePackModel::documentToArray(QJsonDocument& obj) const -> QJsonArray
-{
-    return Json::ensureArray(obj.object(), "data");
-}
-
-FlameShaderPackModel::FlameShaderPackModel(const BaseInstance& base) : ShaderPackResourceModel(base, new FlameAPI) {}
-
-void FlameShaderPackModel::loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj)
-{
-    FlameMod::loadIndexedPack(m, obj);
-}
-
-// We already deal with the URLs when initializing the pack, due to the API response's structure
-void FlameShaderPackModel::loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj)
-{
-    FlameMod::loadBody(m, obj);
-}
-
-void FlameShaderPackModel::loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr)
-{
-    FlameMod::loadIndexedPackVersions(m, arr);
-}
-
-bool FlameShaderPackModel::optedOut(const ModPlatform::IndexedVersion& ver) const
-{
-    return isOptedOut(ver);
-}
-
-auto FlameShaderPackModel::documentToArray(QJsonDocument& obj) const -> QJsonArray
-{
-    return Json::ensureArray(obj.object(), "data");
-}
-
-FlameDataPackModel::FlameDataPackModel(const BaseInstance& base) : DataPackResourceModel(base, new FlameAPI) {}
-
-void FlameDataPackModel::loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj)
-{
-    FlameMod::loadIndexedPack(m, obj);
-}
-
-// We already deal with the URLs when initializing the pack, due to the API response's structure
-void FlameDataPackModel::loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj)
-{
-    FlameMod::loadBody(m, obj);
-}
-
-void FlameDataPackModel::loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr)
-{
-    FlameMod::loadIndexedPackVersions(m, arr);
-}
-
-bool FlameDataPackModel::optedOut(const ModPlatform::IndexedVersion& ver) const
-{
-    return isOptedOut(ver);
-}
-
-auto FlameDataPackModel::documentToArray(QJsonDocument& obj) const -> QJsonArray
-{
-    return Json::ensureArray(obj.object(), "data");
-}
-
 }  // namespace ResourceDownload
--- a/launcher/ui/pages/modplatform/flame/FlameResourceModels.h
+++ b/launcher/ui/pages/modplatform/flame/FlameResourceModels.h
@@ -5,52 +5,10 @@
 #pragma once

 #include "ui/pages/modplatform/ModModel.h"
-#include "ui/pages/modplatform/ResourcePackModel.h"
 #include "ui/pages/modplatform/flame/FlameResourcePages.h"

 namespace ResourceDownload {

-class FlameModModel : public ModModel {
-    Q_OBJECT
-
-   public:
-    FlameModModel(BaseInstance&);
-    ~FlameModModel() override = default;
-
-    bool optedOut(const ModPlatform::IndexedVersion& ver) const override;
-
-   private:
-    QString debugName() const override { return Flame::debugName() + " (Model)"; }
-    QString metaEntryBase() const override { return Flame::metaEntryBase(); }
-
-    void loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
-    void loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
-    void loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr) override;
-    auto loadDependencyVersions(const ModPlatform::Dependency& m, QJsonArray& arr) -> ModPlatform::IndexedVersion override;
-
-    auto documentToArray(QJsonDocument& obj) const -> QJsonArray override;
-};
-
-class FlameResourcePackModel : public ResourcePackResourceModel {
-    Q_OBJECT
-
-   public:
-    FlameResourcePackModel(const BaseInstance&);
-    ~FlameResourcePackModel() override = default;
-
-    bool optedOut(const ModPlatform::IndexedVersion& ver) const override;
-
-   private:
-    QString debugName() const override { return Flame::debugName() + " (Model)"; }
-    QString metaEntryBase() const override { return Flame::metaEntryBase(); }
-
-    void loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
-    void loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
-    void loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr) override;
-
-    auto documentToArray(QJsonDocument& obj) const -> QJsonArray override;
-};
-
 class FlameTexturePackModel : public TexturePackResourceModel {
    Q_OBJECT

@@ -64,52 +22,8 @@ class FlameTexturePackModel : public TexturePackResourceModel {
    QString debugName() const override { return Flame::debugName() + " (Model)"; }
    QString metaEntryBase() const override { return Flame::metaEntryBase(); }

-    void loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
-    void loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
-    void loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr) override;
-
    ResourceAPI::SearchArgs createSearchArguments() override;
    ResourceAPI::VersionSearchArgs createVersionsArguments(const QModelIndex&) override;
-
-    auto documentToArray(QJsonDocument& obj) const -> QJsonArray override;
-};
-
-class FlameShaderPackModel : public ShaderPackResourceModel {
-    Q_OBJECT
-
-   public:
-    FlameShaderPackModel(const BaseInstance&);
-    ~FlameShaderPackModel() override = default;
-
-    bool optedOut(const ModPlatform::IndexedVersion& ver) const override;
-
-   private:
-    QString debugName() const override { return Flame::debugName() + " (Model)"; }
-    QString metaEntryBase() const override { return Flame::metaEntryBase(); }
-
-    void loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
-    void loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
-    void loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr) override;
-    auto documentToArray(QJsonDocument& obj) const -> QJsonArray override;
-};
-
-class FlameDataPackModel : public DataPackResourceModel {
-    Q_OBJECT
-
-   public:
-    FlameDataPackModel(const BaseInstance&);
-    ~FlameDataPackModel() override = default;
-
-    bool optedOut(const ModPlatform::IndexedVersion& ver) const override;
-
-   private:
-    QString debugName() const override { return Flame::debugName() + " (Model)"; }
-    QString metaEntryBase() const override { return Flame::metaEntryBase(); }
-
-    void loadIndexedPack(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
-    void loadExtraPackInfo(ModPlatform::IndexedPack& m, QJsonObject& obj) override;
-    void loadIndexedPackVersions(ModPlatform::IndexedPack& m, QJsonArray& arr) override;
-    auto documentToArray(QJsonDocument& obj) const -> QJsonArray override;
 };

 }  // namespace ResourceDownload
--- a/launcher/ui/pages/modplatform/flame/FlameResourcePages.cpp
+++ b/launcher/ui/pages/modplatform/flame/FlameResourcePages.cpp
@@ -40,7 +40,6 @@
 #include "FlameResourcePages.h"
 #include <QList>
 #include <memory>
-#include "modplatform/ModIndex.h"
 #include "modplatform/flame/FlameAPI.h"
 #include "ui_ResourcePage.h"

@@ -51,7 +50,7 @@ namespace ResourceDownload {

 FlameModPage::FlameModPage(ModDownloadDialog* dialog, BaseInstance& instance) : ModPage(dialog, instance)
 {
-    m_model = new FlameModModel(instance);
+    m_model = new ModModel(instance, new FlameAPI(), Flame::debugName(), Flame::metaEntryBase());
    m_ui->packView->setModel(m_model);

    addSortings();
@@ -85,7 +84,7 @@ void FlameModPage::openUrl(const QUrl& url)
 FlameResourcePackPage::FlameResourcePackPage(ResourcePackDownloadDialog* dialog, BaseInstance& instance)
    : ResourcePackResourcePage(dialog, instance)
 {
-    m_model = new FlameResourcePackModel(instance);
+    m_model = new ResourcePackResourceModel(instance, new FlameAPI(), Flame::debugName(), Flame::metaEntryBase());
    m_ui->packView->setModel(m_model);

    addSortings();
@@ -169,7 +168,7 @@ void FlameDataPackPage::openUrl(const QUrl& url)
 FlameShaderPackPage::FlameShaderPackPage(ShaderPackDownloadDialog* dialog, BaseInstance& instance)
    : ShaderPackResourcePage(dialog, instance)
 {
-    m_model = new FlameShaderPackModel(instance);
+    m_model = new ShaderPackResourceModel(instance, new FlameAPI(), Flame::debugName(), Flame::metaEntryBase());
    m_ui->packView->setModel(m_model);

    addSortings();
@@ -184,10 +183,9 @@ FlameShaderPackPage::FlameShaderPackPage(ShaderPackDownloadDialog* dialog, BaseI
    m_ui->packDescription->setMetaEntry(metaEntryBase());
 }

-FlameDataPackPage::FlameDataPackPage(DataPackDownloadDialog* dialog, BaseInstance& instance)
-    : DataPackResourcePage(dialog, instance)
+FlameDataPackPage::FlameDataPackPage(DataPackDownloadDialog* dialog, BaseInstance& instance) : DataPackResourcePage(dialog, instance)
 {
-    m_model = new FlameDataPackModel(instance);
+    m_model = new DataPackResourceModel(instance, new FlameAPI(), Flame::debugName(), Flame::metaEntryBase());
    m_ui->packView->setModel(m_model);

    addSortings();