KShare/uploaders/customuploader.cpp

372 lines
15 KiB
C++
Raw Normal View History

2017-04-24 23:14:01 +02:00
#include "customuploader.hpp"
#include <QApplication>
#include <QBuffer>
#include <QClipboard>
#include <QFile>
2017-06-23 16:41:21 +02:00
#include <QHttpMultiPart>
#include <QJsonArray>
2017-04-24 23:14:01 +02:00
#include <QJsonDocument>
#include <QNetworkReply>
#include <formats.hpp>
2017-04-24 23:14:01 +02:00
#include <io/ioutils.hpp>
2017-04-25 22:17:36 +02:00
#include <notifications.hpp>
2017-04-24 23:14:01 +02:00
using formats::normalFormatFromName;
using formats::normalFormatMIME;
using formats::recordingFormatFromName;
using formats::recordingFormatMIME;
2017-04-24 23:14:01 +02:00
using std::runtime_error;
2017-05-06 13:21:12 +02:00
void error(QString absFilePath, QString err) {
2017-07-03 01:50:19 +02:00
throw runtime_error((QString("Invalid file: ").append(absFilePath) + ": " + err).toStdString());
2017-04-25 16:04:46 +02:00
}
2017-05-06 13:21:12 +02:00
CustomUploader::CustomUploader(QString absFilePath) {
// Let's go
QFile file(absFilePath);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) error(absFilePath, file.errorString());
QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
if (!doc.isObject()) {
error(absFilePath, "Root not an object");
2017-04-24 23:14:01 +02:00
}
QJsonObject obj = doc.object();
if (!obj["name"].isString())
error(absFilePath, "name is not a string");
2017-04-24 23:14:01 +02:00
else
uName = obj["name"].toString();
if (!obj.contains("desc")) {
if (!obj["desc"].isString())
/*t*/ error(absFilePath, "desc not a string");
else
desc = obj["desc"].toString();
} else
desc = absFilePath;
QJsonValue m = obj["method"];
if (!m.isUndefined() && !m.isNull()) {
if (!m.isString()) error(absFilePath, "method not a string");
QString toCheck = m.toString().toLower();
if (toCheck == "post")
method = HttpMethod::POST;
else
error(absFilePath, "method invalid");
}
QJsonValue url = obj["target"];
if (!url.isString()) {
error(absFilePath, "target missing");
}
QUrl target(url.toString());
if (!target.isValid()) error(absFilePath, "target not URL");
this->target = target;
QJsonValue formatValue = obj["format"];
if (!formatValue.isUndefined() && !formatValue.isNull()) {
if (formatValue.isString()) {
QString formatString = formatValue.toString().toLower();
if (formatString == "x-www-form-urlencoded")
rFormat = RequestFormat::X_WWW_FORM_URLENCODED;
else if (formatString == "json")
rFormat = RequestFormat::JSON;
else if (formatString == "plain")
rFormat = RequestFormat::PLAIN;
2017-06-23 16:41:21 +02:00
else if (formatString == "multipart-form-data")
rFormat = RequestFormat::MULTIPART_FORM_DATA;
else
error(absFilePath, "format invalid");
}
} else
error(absFilePath, "format provided but not string");
QJsonValue bodyValue = obj["body"];
if (rFormat != RequestFormat::PLAIN) {
if (bodyValue.isUndefined()) error(absFilePath, "body not set");
2017-06-23 16:41:21 +02:00
if (rFormat == RequestFormat::MULTIPART_FORM_DATA) {
if (bodyValue.isArray()) {
for (QJsonValue val : bodyValue.toArray()) {
if (!val.isObject()) error(absFilePath, "all elements of body must be objects");
if (!val.toObject()["body"].isObject() && !val.toObject().value("body").isString())
error(absFilePath, "all parts must have a body which is object or string!");
QJsonObject vo = val.toObject();
for (auto v : vo["body"].toObject())
if (!v.isObject() && !v.isString())
error(absFilePath, "all parts of body must be string or object");
for (auto v : vo.keys())
if (v.startsWith("__") && !vo[v].isString())
error(absFilePath, "all __headers must be strings");
}
body = bodyValue;
} else
error(absFilePath, "body not array (needed for multipart)");
} else {
if (bodyValue.isObject())
body = bodyValue;
else
error(absFilePath, "body not object");
}
} else {
if (bodyValue.isString()) {
body = bodyValue;
} else
error(absFilePath, "body not string (reason: format: PLAIN)");
}
QJsonValue headerVal = obj["headers"];
if (!(headerVal.isUndefined() || headerVal.isNull())) {
if (!headerVal.isObject()) error(absFilePath, "headers must be object");
headers = headerVal.toObject();
} else
headers = QJsonObject();
QJsonValue returnPsVal = obj["return"];
if (returnPsVal.isString()) {
returnPathspec = returnPsVal.toString();
} else
error(absFilePath, "return invalid");
2017-05-17 22:59:33 +02:00
QJsonValue fileLimit = obj["fileLimit"];
if (!fileLimit.isNull() && !fileLimit.isUndefined()) {
if (!fileLimit.isDouble()) error(absFilePath, "fileLimit not double");
limit = fileLimit.toDouble();
}
QJsonValue bool64 = obj["base64"];
if (!bool64.isNull() && !bool64.isUndefined()) {
if (!bool64.isBool()) error(absFilePath, "base64 must be boolean");
base64 = bool64.toBool();
2017-06-18 23:23:53 +02:00
if (rFormat == RequestFormat::JSON && !base64) error(absFilePath, "base64 required with json");
}
2017-04-24 23:14:01 +02:00
}
QString CustomUploader::name() {
return uName;
}
2017-04-24 23:14:01 +02:00
QString CustomUploader::description() {
return desc;
}
2017-04-24 23:14:01 +02:00
2017-05-06 13:21:12 +02:00
QString getCType(RequestFormat format, QString plainType) {
switch (format) {
case RequestFormat::X_WWW_FORM_URLENCODED:
return "application/x-www-form-urlencoded";
case RequestFormat::JSON:
return "application/json";
2017-06-23 16:41:21 +02:00
case RequestFormat::MULTIPART_FORM_DATA:
return "multipart/form-data";
case RequestFormat::PLAIN:
return plainType;
}
2017-04-24 23:14:01 +02:00
return plainType;
}
QList<QPair<QString, QString>> getHeaders(QJsonObject h, QString imageFormat, RequestFormat format) {
QList<QPair<QString, QString>> headers;
for (QString s : h.keys()) {
if (s.toLower() == "content-type") continue;
QJsonValue v = h[s];
if (!v.isString())
headers << QPair<QString, QString>(s, QJsonDocument::fromVariant(v.toVariant()).toJson());
else
headers << QPair<QString, QString>(s, v.toString());
}
headers << QPair<QString, QString>("Content-Type", getCType(format, normalFormatMIME(normalFormatFromName(imageFormat))));
return headers;
2017-04-24 23:14:01 +02:00
}
QJsonObject recurseAndReplace(QJsonObject &body, QByteArray &data, QString contentType) {
QJsonObject o;
for (QString s : body.keys()) {
QJsonValue v = body[s];
if (v.isObject()) {
QJsonObject vo = v.toObject();
o.insert(s, recurseAndReplace(vo, data, contentType));
} else if (v.isString()) {
QString str = v.toString();
if (str.startsWith("/") && str.endsWith("/")) {
2017-06-06 22:12:22 +02:00
o.insert(s, str.mid(1, str.length() - 2).replace("%imagedata", data).replace("%contenttype", contentType));
2017-06-06 13:06:41 +02:00
} else
o.insert(s, v);
2017-06-05 13:12:12 +02:00
} else
o.insert(s, v);
2017-04-24 23:14:01 +02:00
}
return o;
2017-04-24 23:14:01 +02:00
}
2017-05-06 13:21:12 +02:00
QString parsePathspec(QJsonDocument &response, QString &pathspec) {
if (!pathspec.startsWith(".")) {
// Does not point to anything
2017-05-06 13:21:12 +02:00
return "";
} else {
if (!response.isObject()) return "";
QStringList fields = pathspec.right(pathspec.length() - 1).split('.', QString::SkipEmptyParts);
QJsonObject o = response.object();
if (pathspec == ".") {
return QString::fromUtf8(response.toJson());
}
QJsonValue val = o[fields.at(0)];
if (val.isUndefined() || val.isNull())
return "";
else if (val.isString())
return val.toString();
else if (!val.isObject())
return QString::fromUtf8(QJsonDocument::fromVariant(val.toVariant()).toJson());
for (int i = 1; i < fields.size(); i++) {
if (val.isUndefined() || val.isNull())
return "";
else if (val.isString())
return val.toString();
else if (!val.isObject())
return QString::fromUtf8(QJsonDocument::fromVariant(val.toVariant()).toJson());
else
val = val.toObject()[fields.at(i)];
}
if (val.isUndefined() || val.isNull())
return "";
else if (val.isString())
return val.toString();
else if (!val.isObject())
return QString::fromUtf8(QJsonDocument::fromVariant(val.toVariant()).toJson());
2017-04-24 23:14:01 +02:00
}
return "";
2017-04-24 23:14:01 +02:00
}
2017-05-13 22:47:01 +02:00
void parseResult(QJsonDocument result, QByteArray data, QString returnPathspec, QString name) {
if (result.isObject()) {
qDebug() << result.object()[".url"];
QString url = parsePathspec(result, returnPathspec);
if (!url.isEmpty()) {
QApplication::clipboard()->setText(url);
notifications::notify("KShare Custom Uploader " + name, "Copied upload link to clipboard!");
} else {
notifications::notify("KShare Custom Uploader " + name, "Upload done, but result empty!");
QApplication::clipboard()->setText(data);
}
2017-05-13 22:47:01 +02:00
} else {
notifications::notify("KShare Custom Uploader " + name,
"Upload done, but result is not JSON Object! Result in clipboard.");
2017-05-13 22:47:01 +02:00
QApplication::clipboard()->setText(data);
}
2017-04-25 22:17:36 +02:00
}
void CustomUploader::doUpload(QByteArray imgData, QString format) {
auto h = getHeaders(headers, format, this->rFormat);
QByteArray data;
if (base64) imgData = imgData.toBase64();
QString mime = normalFormatMIME(normalFormatFromName(format));
if (mime.isEmpty()) mime = recordingFormatMIME(recordingFormatFromName(format));
switch (this->rFormat) {
case RequestFormat::PLAIN: {
data = imgData;
} break;
case RequestFormat::JSON: {
if (body.isString()) {
QStringList split = body.toString().replace("%contenttype", mime).split("%imagedata");
for (int i = 0; i < split.size(); i++) {
data.append(split[i]);
if (i < split.size() - 1) data.append(imgData);
}
} else {
QJsonObject vo = body.toObject();
data = QJsonDocument::fromVariant(recurseAndReplace(vo, imgData, mime).toVariantMap()).toJson();
2017-04-24 23:14:01 +02:00
}
} break;
case RequestFormat::X_WWW_FORM_URLENCODED: {
QJsonObject body = this->body.toObject();
for (QString key : body.keys()) {
QJsonValue val = body[key];
if (val.isString()) {
QString str = val.toString();
QByteArray strB;
if (str.startsWith("/") && str.endsWith("/")) {
str = str.mid(1, str.length() - 2);
QStringList split = str.replace("%contenttype", mime).split("%imagedata");
for (int i = 0; i < split.size(); i++) {
strB.append(split[i]);
if (i < split.size() - 1) strB.append(imgData);
}
}
data.append(QUrl::toPercentEncoding(key)).append('=').append(strB);
} else {
if (!data.isEmpty()) data.append('&');
data.append(QUrl::toPercentEncoding(key))
.append('=')
.append(QUrl::toPercentEncoding(QJsonDocument::fromVariant(body[key].toVariant()).toJson()));
}
}
} break;
2017-06-23 16:41:21 +02:00
case RequestFormat::MULTIPART_FORM_DATA: {
2017-06-23 16:56:15 +02:00
QHttpMultiPart *multipart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
2017-06-23 16:41:21 +02:00
auto arr = body.toArray();
for (QJsonValue val : arr) {
auto valo = val.toObject();
QHttpPart part;
QJsonValue bd = valo["body"];
if (bd.isString()) {
QString s = bd.toString();
QByteArray body;
if (s.startsWith("/") && s.endsWith("/")) {
s = s.mid(1, s.length() - 1);
QStringList split = s.replace("%contenttype", mime).split("%imagedata");
for (int i = 0; i < split.size(); i++) {
body.append(split[i]);
if (i < split.size() - 1) body.append(imgData);
}
}
2017-07-12 22:59:26 +02:00
QByteArray *bodyHeap = new QByteArray;
body.swap(*bodyHeap);
QBuffer *buffer = new QBuffer(bodyHeap);
2017-06-23 16:41:21 +02:00
buffer->open(QIODevice::ReadOnly);
part.setBodyDevice(buffer);
2017-06-23 16:56:15 +02:00
multipart->append(part);
2017-06-23 16:41:21 +02:00
} else {
auto bdo = bd.toObject();
QJsonObject result = recurseAndReplace(bdo, imgData, mime);
part.setBody(QJsonDocument::fromVariant(result.toVariantMap()).toJson());
2017-06-23 16:56:15 +02:00
multipart->append(part);
2017-06-23 16:41:21 +02:00
}
QByteArray cdh("form-data");
2017-06-23 16:41:21 +02:00
for (QString headerVal : valo.keys()) {
if (headerVal.startsWith("__")) {
headerVal = headerVal.mid(2);
QString str = valo[headerVal].toString();
if (str.startsWith("/") && str.endsWith("/"))
str = str.mid(1, str.length() - 1).replace("%contenttype", mime);
part.setRawHeader(headerVal.toLatin1(), str.toLatin1());
} else
2017-07-12 22:59:26 +02:00
cdh += "; " + headerVal + "= \"" + valo[headerVal].toString().replace("\"", "\\\"") + "\"";
2017-06-23 16:41:21 +02:00
}
2017-07-12 20:24:16 +02:00
part.setHeader(QNetworkRequest::ContentDispositionHeader, cdh);
2017-06-23 16:41:21 +02:00
}
2017-06-23 16:56:15 +02:00
switch (method) {
case HttpMethod::POST:
if (returnPathspec == "|") {
ioutils::postMultipartData(target, h, multipart, [&](QByteArray result, QNetworkReply *) {
QApplication::clipboard()->setText(QString::fromUtf8(result));
notifications::notify("KShare Custom Uploader " + name(), "Copied upload result to clipboard!");
});
} else {
ioutils::postMultipart(target, h, multipart, [&](QJsonDocument result, QByteArray data, QNetworkReply *) {
parseResult(result, data, returnPathspec, name());
});
}
break;
}
return;
2017-06-23 16:41:21 +02:00
} break;
2017-04-24 23:14:01 +02:00
}
2017-05-21 11:16:00 +02:00
if (limit > 0 && data.size() > limit) {
2017-05-17 22:59:33 +02:00
notifications::notify("KShare Custom Uploader " + name(), "File limit exceeded!");
return;
}
switch (method) {
case HttpMethod::POST:
if (returnPathspec == "|") {
ioutils::postData(target, h, data, [&](QByteArray result, QNetworkReply *) {
QApplication::clipboard()->setText(QString::fromUtf8(result));
notifications::notify("KShare Custom Uploader " + name(), "Copied upload result to clipboard!");
});
} else {
2017-05-13 22:47:01 +02:00
ioutils::postJson(target, h, data, [&](QJsonDocument result, QByteArray data, QNetworkReply *) {
parseResult(result, data, returnPathspec, name());
2017-05-13 22:39:05 +02:00
});
}
break;
2017-04-24 23:14:01 +02:00
}
}