No OneTemporary
Actions

Authored By

Unknown

Size

12 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/tools/uploader/imguruploader.cpp b/tools/uploader/imguruploader.cpp
	index fa6172a..86e2606 100644
	--- a/tools/uploader/imguruploader.cpp
	+++ b/tools/uploader/imguruploader.cpp
	@@ -1,104 +1,114 @@
	#include "imguruploader.h"
	#include <QNetworkAccessManager>
	#include <QtNetwork>

	ImgurUploader::ImgurUploader(const QVariantHash &options) : ImageUploader(options) {}

	+const QString ImgurUploader::clientId()
	+{
	+ return QString("3ebe94c791445c1");
	+}
	+
	+const QString ImgurUploader::clientSecret()
	+{
	+ return QString("0546b05d6a80b2092dcea86c57b792c9c9faebf0");
	+}
	+
	void ImgurUploader::upload(const QString &fileName)
	{
	QFile *file = new QFile(fileName);

	if (!file->open(QIODevice::ReadOnly)) {
	emit error(ImageUploader::FileError, tr("Unable to read screenshot file"), fileName);
	file->deleteLater();
	return;
	}

	QNetworkRequest request(QUrl("https://api.imgur.com/3/image"));
	- request.setRawHeader("Authorization", "Client-ID 3ebe94c791445c1");
	+ request.setRawHeader("Authorization", QString("Client-ID %1").arg(clientId()).toLatin1());

	QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);

	if (!mOptions.value("anonymous", true).toBool()) {
	request.setRawHeader("Authorization", QByteArray("Bearer ") + mOptions.value("access_token").toByteArray());

	if (!mOptions.value("album").toString().isEmpty()) {
	QHttpPart albumPart;
	albumPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"album\""));
	albumPart.setBody(mOptions.value("album").toByteArray());
	multiPart->append(albumPart);
	}
	}

	QHttpPart imagePart;
	imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QMimeDatabase().mimeTypeForFile(fileName, QMimeDatabase::MatchExtension).name());
	imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"image\""));

	imagePart.setBodyDevice(file);
	file->setParent(multiPart);
	multiPart->append(imagePart);

	QNetworkReply reply = mOptions.value("networkManager").value<QNetworkAccessManager >()->post(request, multiPart);
	reply->setProperty("fileName", fileName);
	this->setProperty("fileName", fileName);

	connect(reply, SIGNAL(uploadProgress(qint64, qint64)), this, SLOT(uploadProgress(qint64, qint64)));
	connect(this , SIGNAL(cancelRequest()), reply, SLOT(abort()));
	connect(this , SIGNAL(cancelRequest()), reply, SLOT(deleteLater()));
	connect(reply, SIGNAL(finished()), this, SLOT(finished()));
	}

	void ImgurUploader::retry()
	{
	upload(property("fileName").toString());
	}

	void ImgurUploader::cancel()
	{
	emit cancelRequest();
	}

	void ImgurUploader::finished()
	{
	QNetworkReply reply = qobject_cast<QNetworkReply >(sender());
	reply->deleteLater();

	QString fileName = reply->property("fileName").toString();

	if (reply->error() != QNetworkReply::NoError) {
	if (reply->error() == QNetworkReply::OperationCanceledError) {
	emit error(ImageUploader::CancelError, "", fileName);
	} else if (reply->error() == QNetworkReply::ContentOperationNotPermittedError \|\|
	reply->error() == QNetworkReply::AuthenticationRequiredError) {
	emit needAuthRefresh();
	} else {
	emit error(ImageUploader::NetworkError, reply->errorString(), fileName);
	}

	return;
	}

	if (reply->rawHeader("X-RateLimit-Remaining") == "0") {
	emit error(ImageUploader::HostError, tr("Imgur upload limit reached"), fileName);
	return;
	}

	QJsonObject imgurResponse = QJsonDocument::fromJson(reply->readAll()).object();

	if (imgurResponse.value("success").toBool() == true && imgurResponse.value("status").toInt() == 200) {
	QJsonObject imageData = imgurResponse.value("data").toObject();

	emit uploaded(fileName, imageData["link"].toString(), imageData["deletehash"].toString());
	} else {
	emit error(ImageUploader::HostError, tr("Imgur error"), fileName);
	}
	}

	void ImgurUploader::uploadProgress(qint64 bytesReceived, qint64 bytesTotal)
	{
	float b = (float) bytesReceived / bytesTotal;
	int p = qRound(b * 100);
	setProgress(p);
	emit progressChange(p);
	}

	diff --git a/tools/uploader/imguruploader.h b/tools/uploader/imguruploader.h
	index 769f9eb..8f3f99f 100644
	--- a/tools/uploader/imguruploader.h
	+++ b/tools/uploader/imguruploader.h
	@@ -1,31 +1,33 @@
	#ifndef IMGURUPLOADER_H
	#define IMGURUPLOADER_H

	#include <QObject>
	#include <QNetworkAccessManager>
	#include <QNetworkReply>
	#include "imageuploader.h"

	class ImgurUploader : public ImageUploader
	{
	Q_OBJECT

	public:
	ImgurUploader(const QVariantHash &options);
	+ static const QString clientId();
	+ static const QString clientSecret();

	public slots:
	void upload(const QString &fileName);
	void retry();
	void cancel();

	private slots:
	void finished();
	void uploadProgress(qint64 bytesReceived, qint64 bytesTotal);

	signals:
	void cancelRequest();
	void needAuthRefresh();

	};

	#endif // IMGURUPLOADER_H
	diff --git a/widgets/imguroptions.cpp b/widgets/imguroptions.cpp
	index 71b6cfb..b117589 100644
	--- a/widgets/imguroptions.cpp
	+++ b/widgets/imguroptions.cpp
	@@ -1,171 +1,173 @@
	#include <QJsonObject>
	#include <QInputDialog>
	#include <QNetworkReply>
	#include <QDesktopServices>
	#include <QMessageBox>

	#include "imguroptions.h"
	#include "../uploader/uploader.h"
	+#include "../uploader/imguruploader.h"
	+
	#include "../screenshotmanager.h"

	ImgurOptions::ImgurOptions(QWidget *parent) : QWidget(parent)
	{
	ui.setupUi(this);
	connect(Uploader::instance(), &Uploader::imgurAuthRefreshed, this, &ImgurOptions::requestAlbumList);

	connect(ui.authButton , &QPushButton::clicked, this, &ImgurOptions::authorize);
	connect(ui.refreshAlbumButton, &QPushButton::clicked, this, &ImgurOptions::requestAlbumList);
	connect(ui.authUserLabel , &QLabel::linkActivated, this, [](const QString &link) {
	QDesktopServices::openUrl(link);
	});
	}

	QSettings *ImgurOptions::settings()
	{
	return ScreenshotManager::instance()->settings();
	}

	void ImgurOptions::setUser(const QString &username)
	{
	mCurrentUser = username;

	setUpdatesEnabled(false);

	if (mCurrentUser.isEmpty()) {
	ui.authUserLabel->setText(tr("<i>none</i>"));
	ui.albumComboBox->setEnabled(false);
	ui.refreshAlbumButton->setEnabled(false);
	ui.albumComboBox->clear();
	ui.albumComboBox->addItem(tr("- None -"));
	ui.authButton->setText(tr("Authorize"));
	ui.helpLabel->setEnabled(true);

	settings()->setValue("upload/imgur/access_token", "");
	settings()->setValue("upload/imgur/refresh_token", "");
	settings()->setValue("upload/imgur/account_username", "");
	settings()->setValue("upload/imgur/expires_in", 0);
	} else {
	ui.authButton->setText(tr("Deauthorize"));
	- ui.authUserLabel->setText("<b><a href=\"http://"+ username +"..com/all/\">" + username + "</a></b>");
	+ ui.authUserLabel->setText("<b><a href=\"http://"+ username +".imgur.com/all/\">" + username + "</a></b>");
	ui.refreshAlbumButton->setEnabled(true);
	ui.helpLabel->setEnabled(false);
	}

	setUpdatesEnabled(true);
	}

	void ImgurOptions::authorize()
	{
	if (!mCurrentUser.isEmpty()) {
	setUser("");
	return;
	}

	- QDesktopServices::openUrl(QUrl("https://api..com/oauth2/authorize?client_id=3ebe94c791445c1&response_type=pin")); //TODO: get the client-id from somewhere?
	+ QDesktopServices::openUrl(QUrl("https://api.imgur.com/oauth2/authorize?client_id=" + ImgurUploader::clientId() + "&response_type=pin")); //TODO: get the client-id from somewhere?

	bool ok;
	QString pin = QInputDialog::getText(this, tr("Imgur Authorization"),
	tr("Authentication PIN:"), QLineEdit::Normal,
	"", &ok);
	if (ok) {
	QByteArray parameters;
	parameters.append(QString("client_id=").toUtf8());
	- parameters.append(QUrl::toPercentEncoding("3ebe94c791445c1"));
	+ parameters.append(QUrl::toPercentEncoding(ImgurUploader::clientId()));
	parameters.append(QString("&client_secret=").toUtf8());
	- parameters.append(QUrl::toPercentEncoding("0546b05d6a80b2092dcea86c57b792c9c9faebf0")); // TODO: TA.png
	+ parameters.append(QUrl::toPercentEncoding(ImgurUploader::clientSecret()));
	parameters.append(QString("&grant_type=pin").toUtf8());
	parameters.append(QString("&pin=").toUtf8());
	parameters.append(QUrl::toPercentEncoding(pin));

	- QNetworkRequest request(QUrl("https://api..com/oauth2/token"));
	+ QNetworkRequest request(QUrl("https://api.imgur.com/oauth2/token"));
	request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");

	QNetworkReply *reply = Uploader::instance()->nam()->post(request, parameters);
	connect(reply, &QNetworkReply::finished, this, [&, reply] {
	ui.authButton->setEnabled(true);

	if (reply->error() != QNetworkReply::NoError) {
	QMessageBox::critical(this, tr("Imgur Authorization Error"), tr("There's been an error authorizing your account with Imgur, please try again."));
	setUser("");
	return;
	}

	QJsonObject imgurResponse = QJsonDocument::fromJson(reply->readAll()).object();

	settings()->setValue("upload/imgur/access_token" , imgurResponse.value("access_token").toString());
	settings()->setValue("upload/imgur/refresh_token" , imgurResponse.value("refresh_token").toString());
	settings()->setValue("upload/imgur/account_username", imgurResponse.value("account_username").toString());
	settings()->setValue("upload/imgur/expires_in" , imgurResponse.value("expires_in").toInt());
	settings()->sync();

	setUser(imgurResponse.value("account_username").toString());

	QTimer::singleShot(0, this, &ImgurOptions::requestAlbumList);
	});

	ui.authButton->setText(tr("Authorizing.."));
	ui.authButton->setEnabled(false);
	}
	}

	void ImgurOptions::requestAlbumList()
	{
	if (mCurrentUser.isEmpty()) {
	return;
	}

	ui.refreshAlbumButton->setEnabled(true);
	ui.albumComboBox->clear();
	ui.albumComboBox->setEnabled(false);
	ui.albumComboBox->addItem(tr("Loading album data..."));

	QNetworkRequest request(QUrl::fromUserInput("https://api.imgur.com/3/account/" + mCurrentUser + "/albums/"));
	request.setRawHeader("Authorization", QByteArray("Bearer ") + settings()->value("upload/imgur/access_token").toByteArray());

	QNetworkReply *reply = Uploader::instance()->nam()->get(request);
	connect(reply, &QNetworkReply::finished, this, [&, reply] {
	if (reply->error() != QNetworkReply::NoError) {
	if (reply->error() == QNetworkReply::ContentOperationNotPermittedError \|\|
	reply->error() == QNetworkReply::AuthenticationRequiredError) {
	Uploader::instance()->imgurAuthRefresh();
	qDebug() << "Attempting imgur auth refresh";
	}

	ui.albumComboBox->addItem(tr("Loading failed :("));
	return;
	}

	const QJsonObject imgurResponse = QJsonDocument::fromJson(reply->readAll()).object();

	if (imgurResponse["success"].toBool() != true \|\| imgurResponse["status"].toInt() != 200) {
	return;
	}

	const QJsonArray albumList = imgurResponse["data"].toArray();

	ui.albumComboBox->clear();
	ui.albumComboBox->setEnabled(true);
	ui.albumComboBox->addItem(tr("- None -"), "");
	ui.refreshAlbumButton->setEnabled(true);

	int settingsIndex = 0;

	for (auto albumValue : albumList) {
	const QJsonObject album = albumValue.toObject();

	QString albumVisibleTitle = album["title"].toString();

	if (albumVisibleTitle.isEmpty()) {
	albumVisibleTitle = tr("untitled");
	}

	ui.albumComboBox->addItem(albumVisibleTitle, album["id"].toString());

	if (album["id"].toString() == settings()->value("upload/imgur/album").toString()) {
	settingsIndex = ui.albumComboBox->count() - 1;
	}
	}

	ui.albumComboBox->setCurrentIndex(settingsIndex);
	});
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jun 16, 12:27 AM (2 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 70900
Default Alt Text: (12 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions