External/UltimMC_Launcher
1
0
Fork 0
mirror of https://github.com/UltimMC/Launcher.git synced 2025-10-03 16:51:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

NOISSUE Working import from Modrinth, license update to accomodate it

Browse Source
This commit is contained in:
Petr Mrázek
2022-05-16 00:25:36 +02:00
parent acc637cfcb
commit 5c1026bd12
9 changed files with 617 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
launcher/ui/pages/modplatform/modrinth/ModrinthData.h
View File

@@ -10,8 +10,40 @@
#include <QString>
#include <QMetaType>
#include <QUrl>
#include <QDateTime>
#include <QVector>
namespace Modrinth {
enum class LoadState {
NotLoaded = 0,
Loaded = 1,
Errored = 2
};
enum class VersionType {
Alpha,
Beta,
Release,
Unknown
};
struct Download {
bool valid = false;
QString filename;
QString url;
QString sha1;
uint64_t size = 0;
bool primary = false;
};
struct Version {
QString name;
Download download;
QDateTime released;
VersionType type = VersionType::Unknown;
bool featured = false;
};
struct Modpack {
QString id;
@@ -20,10 +52,15 @@ struct Modpack {
QString author;
QString description;
bool metadataLoaded = false;
LoadState detailsLoaded = LoadState::NotLoaded;
QString wikiUrl;
QString body;
LoadState versionsLoaded = LoadState::NotLoaded;
QVector<Version> versions;
};
}
Q_DECLARE_METATYPE(Modrinth::Download)
Q_DECLARE_METATYPE(Modrinth::Version)
Q_DECLARE_METATYPE(Modrinth::Modpack)

327
launcher/ui/pages/modplatform/modrinth/ModrinthModel.cpp
View File

@@ -108,12 +108,12 @@ void Modrinth::ListModel::performPaginatedSearch()
auto *netJob = new NetJob("Modrinth::Search", APPLICATION->network());
QString searchUrl = "";
if (currentSearchTerm.isEmpty()) {
searchUrl = QString("https://staging-api.modrinth.com/v2/search?facets=[[%22project_type:modpack%22]]&index=%1&limit=25&offset=%2").arg(currentSort).arg(nextSearchOffset);
searchUrl = QString("https://api.modrinth.com/v2/search?facets=[[%22project_type:modpack%22]]&index=%1&limit=25&offset=%2").arg(currentSort).arg(nextSearchOffset);
}
else
{
searchUrl = QString(
"https://staging-api.modrinth.com/v2/search?facets=[[%22project_type:modpack%22]]&index=%1&limit=25&offset=%2&query=%3"
"https://api.modrinth.com/v2/search?facets=[[%22project_type:modpack%22]]&index=%1&limit=25&offset=%2&query=%3"
).arg(currentSort).arg(nextSearchOffset).arg(currentSearchTerm);
}
netJob->addNetAction(Net::Download::makeByteArray(QUrl(searchUrl), &response));
@@ -136,7 +136,7 @@ void Modrinth::ListModel::searchRequestFinished()
return;
}
QList<Modrinth::Modpack> newList;
QVector<Modrinth::Modpack> newList;
QJsonArray hits;
int total_hits;
@@ -228,8 +228,8 @@ void Modrinth::ListModel::requestLogo(const QString &logo, const QUrl &url)
return;
}
MetaEntryPtr entry = APPLICATION->metacache()->resolveEntry("FlamePacks", QString("logos/%1").arg(logo.section(".", 0, 0)));
auto *job = new NetJob(QString("Flame Icon Download %1").arg(logo), APPLICATION->network());
MetaEntryPtr entry = APPLICATION->metacache()->resolveEntry("ModrinthPacks", QString("logos/%1").arg(logo.section(".", 0, 0)));
auto *job = new NetJob(QString("Modrinth Icon Download %1").arg(logo), APPLICATION->network());
job->addNetAction(Net::Download::makeCached(url, entry));
auto fullPath = entry->getFullPath();
@@ -239,10 +239,7 @@ void Modrinth::ListModel::requestLogo(const QString &logo, const QUrl &url)
QSize size = icon.actualSize(QSize(48, 48));
if (size.width() < 48 && size.height() < 48)
{
/*while (size.width() < 48 && size.height() < 48)
size *= 2;
icon = icon.pixmap(48, 48).scaled(size);*/
icon = icon.pixmap(48,48).scaled(48,48, Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation);
icon = icon.pixmap(48, 48).scaled(48,48, Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation);
}
logoLoaded(logo, icon);
if(waitingCallbacks.contains(logo))
@@ -260,3 +257,315 @@ void Modrinth::ListModel::requestLogo(const QString &logo, const QUrl &url)
m_loadingLogos.append(logo);
}
void Modrinth::ListModel::getPackDetails(const QString& id)
{
auto index = getIndexFromId(id);
if(!index) {
return;
}
if(isPackDetailInProgress()) {
queuedPackDetailRequest = id;
cancelPackDetail();
return;
}
currentPackDetailRequest = id;
QString detailsUrl = "https://api.modrinth.com/v2/project/" + id;
auto & modpack = modpacks[*index];
if(modpack.detailsLoaded != LoadState::Loaded)
{
auto *netJob = new NetJob("Modrinth::PackDetails", APPLICATION->network());
netJob->addNetAction(Net::Download::makeByteArray(QUrl(detailsUrl), &detailsResponse));
detailsPtr = netJob;
detailsPtr->start();
QObject::connect(netJob, &NetJob::succeeded, this, &ListModel::detailsRequestFinished);
QObject::connect(netJob, &NetJob::failed, this, &ListModel::detailsRequestFailed);
}
QString versionsUrl = detailsUrl + "/version";
if(modpack.versionsLoaded != LoadState::Loaded)
{
auto *netJob = new NetJob("Modrinth::PackVersions", APPLICATION->network());
netJob->addNetAction(Net::Download::makeByteArray(QUrl(versionsUrl), &versionsResponse));
versionsPtr = netJob;
versionsPtr->start();
QObject::connect(netJob, &NetJob::succeeded, this, &ListModel::versionsRequestFinished);
QObject::connect(netJob, &NetJob::failed, this, &ListModel::versionsRequestFailed);
}
}
bool Modrinth::ListModel::isPackDetailInProgress()
{
return detailsPtr || versionsPtr;
}
void Modrinth::ListModel::cancelPackDetail()
{
if(detailsPtr) {
detailsPtr->abort();
}
if(versionsPtr) {
versionsPtr->abort();
}
}
nonstd::optional<int> Modrinth::ListModel::getIndexFromId(const QString& id)
{
for(int i = 0; i < modpacks.size(); i++) {
if(modpacks[i].id == id) {
return i;
}
}
return nonstd::nullopt;
}
nonstd::optional<Modrinth::Modpack> Modrinth::ListModel::getModpackById(const QString& id)
{
auto index = getIndexFromId(id);
if(!index) {
return nonstd::nullopt;
}
return modpacks[*index];
}
namespace {
bool parseDetailsInto(QByteArray & input, Modrinth::Modpack& output) {
QJsonParseError parse_error;
QJsonDocument doc = QJsonDocument::fromJson(input, &parse_error);
if(parse_error.error != QJsonParseError::NoError)
{
qWarning() << "Error while parsing pack details response from Modrinth at " << parse_error.offset << " reason: " << parse_error.errorString();
qWarning() << input;
return false;
}
try
{
auto obj = Json::requireObject(doc);
QString body = Json::requireString(obj, "body");
output.body = body;
return true;
}
catch(const JSONValidationError &e)
{
qWarning() << "Error while parsing response from Modrinth: " << e.cause();
return false;
}
}
}
void Modrinth::ListModel::detailsRequestFinished()
{
auto index = getIndexFromId(currentPackDetailRequest);
if(index) {
auto & modpack = modpacks[*index];
if(parseDetailsInto(detailsResponse, modpack)) {
modpack.detailsLoaded = LoadState::Loaded;
}
else {
modpack.detailsLoaded = LoadState::Errored;
}
emit packDataChanged(currentPackDetailRequest);
}
detailsPtr.reset();
checkDetailsDone();
}
void Modrinth::ListModel::detailsRequestFailed()
{
auto index = getIndexFromId(currentPackDetailRequest);
if(index) {
auto & modpack = modpacks[*index];
if(modpack.detailsLoaded == LoadState::NotLoaded) {
modpack.detailsLoaded = LoadState::Errored;
emit packDataChanged(currentPackDetailRequest);
}
}
detailsPtr.reset();
checkDetailsDone();
}
/*
{
"id": "8mMRnfwS",
"project_id": "WCJmvhgU",
"author_id": "akScBBW1",
"featured": true,
"name": "Third Release",
"version_number": "2022.1.12",
"changelog": "This is the third release!",
"changelog_url": null,
"date_published": "2022-01-12T20:41:27+00:00",
"downloads": 22,
"version_type": "release",
"files": [
{
"hashes": {
"sha1": "0fe87efacfd25c4c5e011cd1433e9be494b23b1c",
"sha512": "d43e148d35d0267b49ed14a7bb4bb5879aa3ebbf5805c2fe125f0f0f19fd84994242bdcd568399c9ff80ecfbe0e975ab632d8c71773bc09d54cfc857f9a6f716"
},
"url": "https://cdn.modrinth.com/data/WCJmvhgU/versions/2022.1.12/waffles_Modpack-2022.1.12no-hydrogen.mrpack",
"filename": "waffles_Modpack-2022.1.12no-hydrogen.mrpack",
"primary": false,
"size": 0
}
],
"dependencies": [],
"game_versions": [
"1.18.1"
],
"loaders": [
"fabric"
]
}
*/
bool parseFile(QJsonObject & fileObj, Modrinth::Download & out) {
out.primary = Json::requireBoolean(fileObj, "primary");
out.size = Json::requireInteger(fileObj, "size");
out.url = Json::requireString(fileObj, "url");
out.filename = Json::requireString(fileObj, "filename");
auto hashesObj = fileObj["hashes"].toObject();
out.sha1 = Json::requireString(hashesObj, "sha1");
if(!out.filename.endsWith(".mrpack")) {
out.valid = false;
return false;
}
else {
out.valid = true;
return true;
}
}
namespace {
bool parseVersionsInto(QByteArray & input, Modrinth::Modpack& output) {
QJsonParseError parse_error;
QJsonDocument doc = QJsonDocument::fromJson(input, &parse_error);
if(parse_error.error != QJsonParseError::NoError)
{
qWarning() << "Error while parsing pack versions response from Modrinth at " << parse_error.offset << " reason: " << parse_error.errorString();
qWarning() << input;
return false;
}
qDebug() << input;
try
{
QVector<Modrinth::Version> newList;
QJsonArray versions = Json::requireArray(doc);
for (auto obj : versions)
{
auto packObj = obj.toObject();
Modrinth::Version version;
try
{
if (Json::ensureString(packObj, "client_side", "required") == QStringLiteral("unsupported"))
continue;
version.name = Json::requireString(packObj, "version_number");
version.released = Json::requireDateTime(packObj, "date_published");
version.featured = Json::requireBoolean(packObj, "featured");
auto versionTypeString = Json::requireString(packObj, "version_type");
if(versionTypeString == "alpha") {
version.type = Modrinth::VersionType::Alpha;
}
else if(versionTypeString == "beta") {
version.type = Modrinth::VersionType::Beta;
}
else if (versionTypeString == "release") {
version.type = Modrinth::VersionType::Release;
}
else {
qWarning() << "Unknown version type of Modrinth modpack: " << versionTypeString;
version.type = Modrinth::VersionType::Unknown;
}
Modrinth::Download fallbackOut = {};
auto filesArray = Json::requireArray(packObj, "files");
for(int i = 0; i < filesArray.size(); i++) {
Modrinth::Download maybeFileOut = {};
QJsonObject fileObj = filesArray[i].toObject();
parseFile(fileObj, maybeFileOut);
if(i == 0) {
fallbackOut = maybeFileOut;
}
if(maybeFileOut.valid && maybeFileOut.primary) {
version.download = maybeFileOut;
break;
}
}
if(!version.download.valid) {
version.download = fallbackOut;
}
if(version.download.valid) {
newList.append(version);
}
}
catch(const JSONValidationError &e)
{
qWarning() << "Error while loading pack from Modrinth: " << e.cause();
continue;
}
}
output.versions = newList;
return true;
}
catch(const JSONValidationError &e)
{
qWarning() << "Error while parsing response from Modrinth: " << e.cause();
return false;
}
}
}
void Modrinth::ListModel::versionsRequestFinished()
{
auto index = getIndexFromId(currentPackDetailRequest);
if(index) {
auto & modpack = modpacks[*index];
parseVersionsInto(versionsResponse, modpack);
modpack.versionsLoaded = LoadState::Loaded;
emit packDataChanged(currentPackDetailRequest);
}
versionsPtr.reset();
checkDetailsDone();
}
void Modrinth::ListModel::versionsRequestFailed()
{
auto index = getIndexFromId(currentPackDetailRequest);
if(index) {
auto & modpack = modpacks[*index];
if(modpack.versionsLoaded == LoadState::NotLoaded) {
modpack.versionsLoaded = LoadState::Errored;
emit packDataChanged(currentPackDetailRequest);
}
}
versionsPtr.reset();
checkDetailsDone();
}
void Modrinth::ListModel::checkDetailsDone()
{
if(isPackDetailInProgress()) {
return;
}
// all detail requests are finished
currentPackDetailRequest.clear();
// is there a new one queued?
if(!queuedPackDetailRequest.isNull()) {
getPackDetails(queuedPackDetailRequest);
queuedPackDetailRequest.clear();
}
}

30
launcher/ui/pages/modplatform/modrinth/ModrinthModel.h
View File

@@ -12,6 +12,8 @@
#include "net/NetJob.h"
#include <QAbstractListModel>
#include <QVector>
#include <nonstd/optional>
namespace Modrinth {
@@ -31,11 +33,22 @@ public:
void fetchMore(const QModelIndex &parent) override;
void searchWithTerm(const QString &term, const QString &sort);
void getPackDetails(const QString &id);
nonstd::optional<Modpack> getModpackById(const QString &id);
signals:
void packDataChanged(const QString &id);
private slots:
void searchRequestFinished();
void searchRequestFailed();
void detailsRequestFinished();
void detailsRequestFailed();
void versionsRequestFinished();
void versionsRequestFailed();
private:
void performPaginatedSearch();
@@ -44,7 +57,13 @@ private:
void requestLogo(const QString &logo, const QUrl &url);
QList<Modpack> modpacks;
nonstd::optional<int> getIndexFromId(const QString &id);
bool isPackDetailInProgress();
void cancelPackDetail();
void checkDetailsDone();
QVector<Modpack> modpacks;
QStringList m_failedLogos;
QStringList m_loadingLogos;
QMap<QString, QIcon> m_logoMap;
@@ -59,8 +78,17 @@ private:
ResetRequested,
Finished
} searchState = None;
QString queuedPackDetailRequest;
QString currentPackDetailRequest;
NetJob::Ptr jobPtr;
QByteArray response;
NetJob::Ptr detailsPtr;
QByteArray detailsResponse;
NetJob::Ptr versionsPtr;
QByteArray versionsResponse;
};
}

112
launcher/ui/pages/modplatform/modrinth/ModrinthPage.cpp
View File

@@ -22,6 +22,8 @@
#include "ui_ModrinthPage.h"
#include <QKeyEvent>
#include <HoeDown.h>
#include <InstanceImportTask.h>
ModrinthPage::ModrinthPage(NewInstanceDialog *dialog, QWidget *parent) : QWidget(parent), ui(new Ui::ModrinthPage), dialog(dialog)
{
@@ -42,7 +44,8 @@ ModrinthPage::ModrinthPage(NewInstanceDialog *dialog, QWidget *parent) : QWidget
connect(ui->sortByBox, SIGNAL(currentIndexChanged(int)), this, SLOT(triggerSearch()));
connect(ui->packView->selectionModel(), &QItemSelectionModel::currentChanged, this, &ModrinthPage::onSelectionChanged);
//connect(ui->versionSelectionBox, &QComboBox::currentTextChanged, this, &ModrinthPage::onVersionSelectionChanged);
connect(ui->versionSelectionBox, &QComboBox::currentTextChanged, this, &ModrinthPage::onVersionSelectionChanged);
connect(model, &Modrinth::ListModel::packDataChanged, this, &ModrinthPage::onPackDataChanged);
}
ModrinthPage::~ModrinthPage()
@@ -85,9 +88,112 @@ void ModrinthPage::onSelectionChanged(QModelIndex first, QModelIndex second) {
}
current = model->data(first, Qt::UserRole).value<Modrinth::Modpack>();
model->getPackDetails(current.id);
updateCurrentPackUI();
suggestCurrent();
}
void ModrinthPage::suggestCurrent() {
void ModrinthPage::onVersionSelectionChanged(const QString& version) {
if(version.isEmpty() || ui->versionSelectionBox->count() == 0) {
currentVersion = Modrinth::Version();
}
else {
currentVersion = ui->versionSelectionBox->currentData().value<Modrinth::Version>();
}
}
}
void ModrinthPage::suggestCurrent()
{
if(!isOpened)
{
return;
}
if (!currentVersion.name.size())
{
dialog->setSuggestedPack();
return;
}
dialog->setSuggestedPack(current.name + " " + currentVersion.name, new InstanceImportTask(currentVersion.download.url));
MetaEntryPtr entry = APPLICATION->metacache()->resolveEntry("ModrinthPacks", QString("logos/%1").arg(current.id));
dialog->setSuggestedIconFromFile(entry->getFullPath(), QString("modrinth-%1").arg(current.id));
}
void ModrinthPage::onPackDataChanged(const QString& id)
{
if(id != current.id) {
return;
}
auto newData = model->getModpackById(id);
if(newData) {
current = *newData;
updateCurrentPackUI();
}
}
namespace {
QString processMarkdown(QString input)
{
HoeDown hoedown;
return hoedown.process(input.toUtf8());
}
}
QString versionToString(const Modrinth::Version& version) {
switch(version.type) {
case Modrinth::VersionType::Alpha: {
return QString("%1 (Alpha)").arg(version.name);
}
case Modrinth::VersionType::Beta: {
return QString("%1 (Beta)").arg(version.name);
}
case Modrinth::VersionType::Release: {
return version.name;
}
case Modrinth::VersionType::Unknown: {
return QString("%1 (?)").arg(version.name);
}
}
}
void ModrinthPage::updateCurrentPackUI()
{
switch(current.detailsLoaded) {
case Modrinth::LoadState::Errored: {
ui->packDescription->setText(tr("Failed to get Modrinth modpack details..."));
break;
}
case Modrinth::LoadState::NotLoaded: {
ui->packDescription->setText(tr("Loading..."));
break;
}
case Modrinth::LoadState::Loaded: {
ui->packDescription->setText(processMarkdown(current.body));
break;
}
}
if(current.versions.size() == 0) {
ui->versionSelectionBox->clear();
}
else {
ui->versionSelectionBox->clear();
int releaseFound = -1;
int i = 0;
for(auto & version: current.versions) {
ui->versionSelectionBox->addItem(versionToString(version), QVariant::fromValue(version));
if(releaseFound == -1 && version.type == Modrinth::VersionType::Release) {
releaseFound = i;
}
i++;
}
if(releaseFound != -1) {
ui->versionSelectionBox->setCurrentIndex(releaseFound);
}
else if(current.versions.size() != 0) {
ui->versionSelectionBox->setCurrentIndex(0);
}
// select first release found from the top
}
suggestCurrent();
}

6
launcher/ui/pages/modplatform/modrinth/ModrinthPage.h
View File

@@ -44,7 +44,7 @@ public:
QString displayName() const override
{
return tr("Modrinth");
return tr("Modrinth (WIP)");
}
QIcon icon() const override
{
@@ -62,12 +62,16 @@ public:
private slots:
void triggerSearch();
void onSelectionChanged(QModelIndex first, QModelIndex second);
void onVersionSelectionChanged(const QString & version);
void onPackDataChanged(const QString &id);
private:
void updateCurrentPackUI();
void suggestCurrent();
Ui::ModrinthPage *ui;
NewInstanceDialog *dialog;
Modrinth::ListModel *model = nullptr;
Modrinth::Modpack current;
Modrinth::Version currentVersion;
};