179 lines
5.5 KiB
C++
179 lines
5.5 KiB
C++
#include "ProfileUtils.h"
|
|
#include "minecraft/VersionFilterData.h"
|
|
#include "minecraft/OneSixVersionFormat.h"
|
|
#include "Json.h"
|
|
#include <QDebug>
|
|
|
|
#include <QJsonDocument>
|
|
#include <QJsonArray>
|
|
#include <QRegularExpression>
|
|
#include <QSaveFile>
|
|
|
|
namespace ProfileUtils
|
|
{
|
|
|
|
static const int currentOrderFileVersion = 1;
|
|
|
|
bool readOverrideOrders(QString path, PatchOrder &order)
|
|
{
|
|
QFile orderFile(path);
|
|
if (!orderFile.exists())
|
|
{
|
|
qWarning() << "Order file doesn't exist. Ignoring.";
|
|
return false;
|
|
}
|
|
if (!orderFile.open(QFile::ReadOnly))
|
|
{
|
|
qCritical() << "Couldn't open" << orderFile.fileName()
|
|
<< " for reading:" << orderFile.errorString();
|
|
qWarning() << "Ignoring overriden order";
|
|
return false;
|
|
}
|
|
|
|
// and it's valid JSON
|
|
QJsonParseError error;
|
|
QJsonDocument doc = QJsonDocument::fromJson(orderFile.readAll(), &error);
|
|
if (error.error != QJsonParseError::NoError)
|
|
{
|
|
qCritical() << "Couldn't parse" << orderFile.fileName() << ":" << error.errorString();
|
|
qWarning() << "Ignoring overriden order";
|
|
return false;
|
|
}
|
|
|
|
// and then read it and process it if all above is true.
|
|
try
|
|
{
|
|
auto obj = Json::requireObject(doc);
|
|
// check order file version.
|
|
auto version = Json::requireInteger(obj.value("version"));
|
|
if (version != currentOrderFileVersion)
|
|
{
|
|
throw JSONValidationError(QObject::tr("Invalid order file version, expected %1")
|
|
.arg(currentOrderFileVersion));
|
|
}
|
|
auto orderArray = Json::requireArray(obj.value("order"));
|
|
for(auto item: orderArray)
|
|
{
|
|
order.append(Json::requireString(item));
|
|
}
|
|
}
|
|
catch (const JSONValidationError &err)
|
|
{
|
|
qCritical() << "Couldn't parse" << orderFile.fileName() << ": bad file format";
|
|
qWarning() << "Ignoring overriden order";
|
|
order.clear();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static VersionFilePtr createErrorVersionFile(QString fileId, QString filepath, QString error)
|
|
{
|
|
auto outError = std::make_shared<VersionFile>();
|
|
outError->uid = outError->name = fileId;
|
|
// outError->filename = filepath;
|
|
outError->addProblem(ProblemSeverity::Error, error);
|
|
return outError;
|
|
}
|
|
|
|
static VersionFilePtr guardedParseJson(const QJsonDocument & doc,const QString &fileId,const QString &filepath,const bool &requireOrder)
|
|
{
|
|
try
|
|
{
|
|
return OneSixVersionFormat::versionFileFromJson(doc, filepath, requireOrder);
|
|
}
|
|
catch (const Exception &e)
|
|
{
|
|
return createErrorVersionFile(fileId, filepath, e.cause());
|
|
}
|
|
}
|
|
|
|
VersionFilePtr parseJsonFile(const QFileInfo &fileInfo, const bool requireOrder)
|
|
{
|
|
QFile file(fileInfo.absoluteFilePath());
|
|
if (!file.open(QFile::ReadOnly))
|
|
{
|
|
auto errorStr = QObject::tr("Unable to open the version file %1: %2.").arg(fileInfo.fileName(), file.errorString());
|
|
return createErrorVersionFile(fileInfo.completeBaseName(), fileInfo.absoluteFilePath(), errorStr);
|
|
}
|
|
QJsonParseError error;
|
|
auto data = file.readAll();
|
|
QJsonDocument doc = QJsonDocument::fromJson(data, &error);
|
|
file.close();
|
|
if (error.error != QJsonParseError::NoError)
|
|
{
|
|
int line = 1;
|
|
int column = 0;
|
|
for(int i = 0; i < error.offset; i++)
|
|
{
|
|
if(data[i] == '\n')
|
|
{
|
|
line++;
|
|
column = 0;
|
|
continue;
|
|
}
|
|
column++;
|
|
}
|
|
auto errorStr = QObject::tr("Unable to process the version file %1: %2 at line %3 column %4.")
|
|
.arg(fileInfo.fileName(), error.errorString())
|
|
.arg(line).arg(column);
|
|
return createErrorVersionFile(fileInfo.completeBaseName(), fileInfo.absoluteFilePath(), errorStr);
|
|
}
|
|
return guardedParseJson(doc, fileInfo.completeBaseName(), fileInfo.absoluteFilePath(), requireOrder);
|
|
}
|
|
|
|
bool saveJsonFile(const QJsonDocument doc, const QString & filename)
|
|
{
|
|
auto data = doc.toJson();
|
|
QSaveFile jsonFile(filename);
|
|
if(!jsonFile.open(QIODevice::WriteOnly))
|
|
{
|
|
jsonFile.cancelWriting();
|
|
qWarning() << "Couldn't open" << filename << "for writing";
|
|
return false;
|
|
}
|
|
jsonFile.write(data);
|
|
if(!jsonFile.commit())
|
|
{
|
|
qWarning() << "Couldn't save" << filename;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
VersionFilePtr parseBinaryJsonFile(const QFileInfo &fileInfo)
|
|
{
|
|
QFile file(fileInfo.absoluteFilePath());
|
|
if (!file.open(QFile::ReadOnly))
|
|
{
|
|
auto errorStr = QObject::tr("Unable to open the version file %1: %2.").arg(fileInfo.fileName(), file.errorString());
|
|
return createErrorVersionFile(fileInfo.completeBaseName(), fileInfo.absoluteFilePath(), errorStr);
|
|
}
|
|
QJsonDocument doc = QJsonDocument::fromBinaryData(file.readAll());
|
|
file.close();
|
|
if (doc.isNull())
|
|
{
|
|
file.remove();
|
|
throw JSONValidationError(QObject::tr("Unable to process the version file %1.").arg(fileInfo.fileName()));
|
|
}
|
|
return guardedParseJson(doc, fileInfo.completeBaseName(), fileInfo.absoluteFilePath(), false);
|
|
}
|
|
|
|
void removeLwjglFromPatch(VersionFilePtr patch)
|
|
{
|
|
auto filter = [](QList<LibraryPtr>& libs)
|
|
{
|
|
QList<LibraryPtr> filteredLibs;
|
|
for (auto lib : libs)
|
|
{
|
|
if (!g_VersionFilterData.lwjglWhitelist.contains(lib->artifactPrefix()))
|
|
{
|
|
filteredLibs.append(lib);
|
|
}
|
|
}
|
|
libs = filteredLibs;
|
|
};
|
|
filter(patch->libraries);
|
|
}
|
|
}
|