CactiChameleon9/PrismLauncher
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor ImgurUpload

Browse Source 
Signed-off-by: Trial97 <alexandru.tripon97@gmail.com>
This commit is contained in:
Trial97
2023-06-29 17:58:09 +03:00
parent 1c3402d081
commit 25ffc4c4b0
8 changed files with 224 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
launcher/screenshots/ImgurAlbumCreation.cpp
View File

@ -36,96 +36,79 @@
#include "ImgurAlbumCreation.h"
#include <QNetworkRequest>
#include <QDebug>
#include <QJsonDocument>
#include <QJsonObject>
#include <QUrl>
#include <QList>
#include <QNetworkRequest>
#include <QStringList>
#include <QDebug>
#include <QUrl>
#include <memory>
#include "BuildConfig.h"
#include "Application.h"
#include "net/StaticHeaderProxy.h"
ImgurAlbumCreation::ImgurAlbumCreation(QList<ScreenShot::Ptr> screenshots) : NetAction(), m_screenshots(screenshots)
Net::NetRequest::Ptr ImgurAlbumCreation::make(std::shared_ptr<ImgurAlbumCreation::Result> output, QList<ScreenShot::Ptr> screenshots)
{
m_url = BuildConfig.IMGUR_BASE_URL + "album.json";
m_state = State::Inactive;
auto up = makeShared<ImgurAlbumCreation>();
up->m_url = BuildConfig.IMGUR_BASE_URL + "album.json";
up->m_sink.reset(new Sink(output));
up->m_screenshots = screenshots;
return up;
}
void ImgurAlbumCreation::executeTask()
QNetworkReply* ImgurAlbumCreation::getReply(QNetworkRequest& request)
{
m_state = State::Running;
QNetworkRequest request(m_url);
request.setHeader(QNetworkRequest::UserAgentHeader, APPLICATION->getUserAgentUncached().toUtf8());
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
request.setRawHeader("Authorization", QString("Client-ID %1").arg(BuildConfig.IMGUR_CLIENT_ID).toStdString().c_str());
request.setRawHeader("Accept", "application/json");
QStringList hashes;
for (auto shot : m_screenshots)
{
for (auto shot : m_screenshots) {
hashes.append(shot->m_imgurDeleteHash);
}
const QByteArray data = "deletehashes=" + hashes.join(',').toUtf8() + "&title=Minecraft%20Screenshots&privacy=hidden";
return m_network->post(request, data);
};
QNetworkReply *rep = APPLICATION->network()->post(request, data);
m_reply.reset(rep);
connect(rep, &QNetworkReply::uploadProgress, this, &ImgurAlbumCreation::downloadProgress);
connect(rep, &QNetworkReply::finished, this, &ImgurAlbumCreation::downloadFinished);
#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0) // QNetworkReply::errorOccurred added in 5.15
connect(rep, &QNetworkReply::errorOccurred, this, &ImgurAlbumCreation::downloadError);
#else
connect(rep, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &ImgurAlbumCreation::downloadError);
#endif
connect(rep, &QNetworkReply::sslErrors, this, &ImgurAlbumCreation::sslErrors);
void ImgurAlbumCreation::init()
{
qDebug() << "Setting up imgur upload";
auto api_headers = new Net::StaticHeaderProxy(
QList<Net::HeaderPair>{ { "Content-Type", "application/x-www-form-urlencoded" },
{ "Authorization", QString("Client-ID %1").arg(BuildConfig.IMGUR_CLIENT_ID).toStdString().c_str() },
{ "Accept", "application/json" } });
addHeaderProxy(api_headers);
}
void ImgurAlbumCreation::downloadError(QNetworkReply::NetworkError error)
auto ImgurAlbumCreation::Sink::init(QNetworkRequest& request) -> Task::State
{
qDebug() << m_reply->errorString();
m_state = State::Failed;
m_output.clear();
return Task::State::Running;
};
auto ImgurAlbumCreation::Sink::write(QByteArray& data) -> Task::State
{
m_output.append(data);
return Task::State::Running;
}
void ImgurAlbumCreation::downloadFinished()
auto ImgurAlbumCreation::Sink::abort() -> Task::State
{
if (m_state != State::Failed)
{
QByteArray data = m_reply->readAll();
m_reply.reset();
QJsonParseError jsonError;
QJsonDocument doc = QJsonDocument::fromJson(data, &jsonError);
if (jsonError.error != QJsonParseError::NoError)
{
qDebug() << jsonError.errorString();
emitFailed();
return;
}
auto object = doc.object();
if (!object.value("success").toBool())
{
qDebug() << doc.toJson();
emitFailed();
return;
}
m_deleteHash = object.value("data").toObject().value("deletehash").toString();
m_id = object.value("data").toObject().value("id").toString();
m_state = State::Succeeded;
emit succeeded();
return;
m_output.clear();
return Task::State::Failed;
}
auto ImgurAlbumCreation::Sink::finalize(QNetworkReply&) -> Task::State
{
QJsonParseError jsonError;
QJsonDocument doc = QJsonDocument::fromJson(m_output, &jsonError);
if (jsonError.error != QJsonParseError::NoError) {
qDebug() << jsonError.errorString();
return Task::State::Failed;
}
else
{
qDebug() << m_reply->readAll();
m_reply.reset();
emitFailed();
return;
auto object = doc.object();
if (!object.value("success").toBool()) {
qDebug() << doc.toJson();
return Task::State::Failed;
}
}
void ImgurAlbumCreation::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
{
setProgress(bytesReceived, bytesTotal);
emit progress(bytesReceived, bytesTotal);
}
m_result->deleteHash = object.value("data").toObject().value("deletehash").toString();
m_result->id = object.value("data").toObject().value("id").toString();
return Task::State::Succeeded;
}

60
launcher/screenshots/ImgurAlbumCreation.h
View File

@ -35,44 +35,40 @@
#pragma once
#include "net/NetAction.h"
#include "Screenshot.h"
#include "net/NetRequest.h"
typedef shared_qobject_ptr<class ImgurAlbumCreation> ImgurAlbumCreationPtr;
class ImgurAlbumCreation : public NetAction
{
public:
explicit ImgurAlbumCreation(QList<ScreenShot::Ptr> screenshots);
static ImgurAlbumCreationPtr make(QList<ScreenShot::Ptr> screenshots)
{
return ImgurAlbumCreationPtr(new ImgurAlbumCreation(screenshots));
}
class ImgurAlbumCreation : public Net::NetRequest {
public:
virtual ~ImgurAlbumCreation() = default;
QString deleteHash() const
{
return m_deleteHash;
}
QString id() const
{
return m_id;
}
struct Result {
QString deleteHash;
QString id;
};
void init() override {};
class Sink : public Net::Sink {
public:
Sink(std::shared_ptr<Result> res) : m_result(res){};
virtual ~Sink() = default;
protected
slots:
void downloadProgress(qint64 bytesReceived, qint64 bytesTotal) override;
void downloadError(QNetworkReply::NetworkError error) override;
void downloadFinished() override;
void downloadReadyRead() override {}
public:
auto init(QNetworkRequest& request) -> Task::State override;
auto write(QByteArray& data) -> Task::State override;
auto abort() -> Task::State override;
auto finalize(QNetworkReply& reply) -> Task::State override;
auto hasLocalData() -> bool override { return false; }
public
slots:
void executeTask() override;
private:
std::shared_ptr<Result> m_result;
QByteArray m_output;
};
private:
static NetRequest::Ptr make(std::shared_ptr<Result> output, QList<ScreenShot::Ptr> screenshots);
QNetworkReply* getReply(QNetworkRequest& request) override;
void init() override;
private:
QList<ScreenShot::Ptr> m_screenshots;
QString m_deleteHash;
QString m_id;
};

119
launcher/screenshots/ImgurUpload.cpp
View File

@ -36,120 +36,95 @@
#include "ImgurUpload.h"
#include "BuildConfig.h"
#include "Application.h"
#include "net/StaticHeaderProxy.h"
#include <QNetworkRequest>
#include <QDebug>
#include <QFile>
#include <QHttpMultiPart>
#include <QHttpPart>
#include <QJsonDocument>
#include <QJsonObject>
#include <QHttpPart>
#include <QFile>
#include <QNetworkRequest>
#include <QUrl>
#include <QDebug>
ImgurUpload::ImgurUpload(ScreenShot::Ptr shot) : NetAction(), m_shot(shot)
void ImgurUpload::init()
{
m_url = BuildConfig.IMGUR_BASE_URL + "upload.json";
m_state = State::Inactive;
qDebug() << "Setting up imgur upload";
auto api_headers = new Net::StaticHeaderProxy(
QList<Net::HeaderPair>{ { "Authorization", QString("Client-ID %1").arg(BuildConfig.IMGUR_CLIENT_ID).toStdString().c_str() },
{ "Accept", "application/json" } });
addHeaderProxy(api_headers);
}
void ImgurUpload::executeTask()
QNetworkReply* ImgurUpload::getReply(QNetworkRequest& request)
{
finished = false;
m_state = Task::State::Running;
QNetworkRequest request(m_url);
request.setHeader(QNetworkRequest::UserAgentHeader, APPLICATION->getUserAgentUncached().toUtf8());
request.setRawHeader("Authorization", QString("Client-ID %1").arg(BuildConfig.IMGUR_CLIENT_ID).toStdString().c_str());
request.setRawHeader("Accept", "application/json");
auto file = new QFile(m_fileInfo.absoluteFilePath());
QFile f(m_shot->m_file.absoluteFilePath());
if (!f.open(QFile::ReadOnly))
{
if (!file->open(QFile::ReadOnly)) {
emitFailed();
return;
return nullptr;
}
QHttpMultiPart *multipart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpMultiPart* multipart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
file->setParent(multipart);
QHttpPart filePart;
filePart.setBody(f.readAll().toBase64());
filePart.setBodyDevice(file);
filePart.setHeader(QNetworkRequest::ContentTypeHeader, "image/png");
filePart.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data; name=\"image\"");
multipart->append(filePart);
QHttpPart typePart;
typePart.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data; name=\"type\"");
typePart.setBody("base64");
typePart.setBody("file");
multipart->append(typePart);
QHttpPart namePart;
namePart.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data; name=\"name\"");
namePart.setBody(m_shot->m_file.baseName().toUtf8());
namePart.setBody(m_fileInfo.baseName().toUtf8());
multipart->append(namePart);
QNetworkReply *rep = m_network->post(request, multipart);
return m_network->post(request, multipart);
};
m_reply.reset(rep);
connect(rep, &QNetworkReply::uploadProgress, this, &ImgurUpload::downloadProgress);
connect(rep, &QNetworkReply::finished, this, &ImgurUpload::downloadFinished);
#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0) // QNetworkReply::errorOccurred added in 5.15
connect(rep, &QNetworkReply::errorOccurred, this, &ImgurUpload::downloadError);
#else
connect(rep, QOverload<QNetworkReply::NetworkError>::of(&QNetworkReply::error), this, &ImgurUpload::downloadError);
#endif
connect(rep, &QNetworkReply::sslErrors, this, &ImgurUpload::sslErrors);
auto ImgurUpload::Sink::init(QNetworkRequest& request) -> Task::State
{
m_output.clear();
return Task::State::Running;
};
auto ImgurUpload::Sink::write(QByteArray& data) -> Task::State
{
m_output.append(data);
return Task::State::Running;
}
void ImgurUpload::downloadError(QNetworkReply::NetworkError error)
auto ImgurUpload::Sink::abort() -> Task::State
{
qCritical() << "ImgurUpload failed with error" << m_reply->errorString() << "Server reply:\n" << m_reply->readAll();
if(finished)
{
qCritical() << "Double finished ImgurUpload!";
return;
}
m_state = Task::State::Failed;
finished = true;
m_reply.reset();
emitFailed();
m_output.clear();
return Task::State::Failed;
}
void ImgurUpload::downloadFinished()
auto ImgurUpload::Sink::finalize(QNetworkReply&) -> Task::State
{
if(finished)
{
qCritical() << "Double finished ImgurUpload!";
return;
}
QByteArray data = m_reply->readAll();
m_reply.reset();
QJsonParseError jsonError;
QJsonDocument doc = QJsonDocument::fromJson(data, &jsonError);
if (jsonError.error != QJsonParseError::NoError)
{
QJsonDocument doc = QJsonDocument::fromJson(m_output, &jsonError);
if (jsonError.error != QJsonParseError::NoError) {
qDebug() << "imgur server did not reply with JSON" << jsonError.errorString();
finished = true;
m_reply.reset();
emitFailed();
return;
return Task::State::Failed;
}
auto object = doc.object();
if (!object.value("success").toBool())
{
if (!object.value("success").toBool()) {
qDebug() << "Screenshot upload not successful:" << doc.toJson();
finished = true;
m_reply.reset();
emitFailed();
return;
return Task::State::Failed;
}
m_shot->m_imgurId = object.value("data").toObject().value("id").toString();
m_shot->m_url = object.value("data").toObject().value("link").toString();
m_shot->m_imgurDeleteHash = object.value("data").toObject().value("deletehash").toString();
m_state = Task::State::Succeeded;
finished = true;
emit succeeded();
return;
return Task::State::Succeeded;
}
void ImgurUpload::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
Net::NetRequest::Ptr ImgurUpload::make(ScreenShot::Ptr m_shot)
{
setProgress(bytesReceived, bytesTotal);
emit progress(bytesReceived, bytesTotal);
auto up = makeShared<ImgurUpload>(m_shot->m_file);
up->m_url = std::move(BuildConfig.IMGUR_BASE_URL + "upload.json");
up->m_sink.reset(new Sink(m_shot));
return up;
}

47
launcher/screenshots/ImgurUpload.h
View File

@ -35,31 +35,36 @@
#pragma once
#include "net/NetAction.h"
#include <QFileInfo>
#include "Screenshot.h"
#include "net/NetRequest.h"
class ImgurUpload : public NetAction {
public:
using Ptr = shared_qobject_ptr<ImgurUpload>;
class ImgurUpload : public Net::NetRequest {
public:
class Sink : public Net::Sink {
public:
Sink(ScreenShot::Ptr shot) : m_shot(shot){};
virtual ~Sink() = default;
explicit ImgurUpload(ScreenShot::Ptr shot);
static Ptr make(ScreenShot::Ptr shot) {
return Ptr(new ImgurUpload(shot));
}
void init() override {};
public:
auto init(QNetworkRequest& request) -> Task::State override;
auto write(QByteArray& data) -> Task::State override;
auto abort() -> Task::State override;
auto finalize(QNetworkReply& reply) -> Task::State override;
auto hasLocalData() -> bool override { return false; }
protected
slots:
void downloadProgress(qint64 bytesReceived, qint64 bytesTotal) override;
void downloadError(QNetworkReply::NetworkError error) override;
void downloadFinished() override;
void downloadReadyRead() override {}
private:
ScreenShot::Ptr m_shot;
QByteArray m_output;
};
ImgurUpload(QFileInfo info) : m_fileInfo(info) {}
virtual ~ImgurUpload() = default;
public
slots:
void executeTask() override;
static NetRequest::Ptr make(ScreenShot::Ptr m_shot);
private:
ScreenShot::Ptr m_shot;
bool finished = true;
void init() override;
private:
virtual QNetworkReply* getReply(QNetworkRequest&) override;
const QFileInfo m_fileInfo;
};