bool
TrainingsTageBuch::writeFile(QByteArray &data, QString remotename, RideFile *ride)
{
Q_UNUSED(ride);
printd("TrainingStageBuch::writeFile(%s)\n", remotename.toStdString().c_str());
QHttpMultiPart *body = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart textPart;
textPart.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name=\"upload_submit\""));
textPart.setBody("hrm");
body->append(textPart);
int limit = proMember ? 8 * 1024 * 1024 : 4 * 1024 * 1024;
if(data.size() >= limit ){
return false;
}
QHttpPart filePart;
filePart.setHeader(QNetworkRequest::ContentTypeHeader,
QVariant("application/octet-stream"));
filePart.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name=\"file\"; filename=\"gc-upload-ttb.pwx\""));
filePart.setBody(data);
body->append(filePart);
#if QT_VERSION > 0x050000
QUrlQuery urlquery;
#else
QUrl urlquery( TTB_URL + "/file/upload" );
#endif
urlquery.addQueryItem( "view", "xml" );
urlquery.addQueryItem( "sso", sessionId );
#if QT_VERSION > 0x050000
QUrl url (TTB_URL + "/file/upload");
url.setQuery(urlquery.query());
QNetworkRequest request = QNetworkRequest(url);
#else
QNetworkRequest request = QNetworkRequest(urlquery);
#endif
request.setRawHeader( "Accept-Encoding", "identity" );
request.setRawHeader( "Accept", "application/xml" );
request.setRawHeader( "Accept-Charset", "utf-8" );
// this must be performed asyncronously and call made
// to notifyWriteCompleted(QString remotename, QString message) when done
reply = nam->post(request, body);
// catch finished signal
connect(reply, SIGNAL(finished()), this, SLOT(writeFileCompleted()));
// remember
mapReply(reply,remotename);
return true;
}
void imgUploader::uploadImage(QString FileName, QString PhpUploadURL, QString FieldName)
{
QUrl serviceUrl = QUrl(PhpUploadURL);
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QNetworkRequest request(serviceUrl);
request.setRawHeader("User-Agent", UserAgent.toAscii());
QHttpPart imagePart;
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/jpeg"));
imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"" + FieldName + "\"; filename=\"" + FileName + "\""));
QFile *file = new QFile(FileName);
file->setParent(multiPart); // we cannot delete the file now, so delete it with the multiPart
file->open(QIODevice::ReadOnly);
imagePart.setBodyDevice(file);
multiPart->append(imagePart);
// Call the webservice
//QNetworkAccessManager *networkManager = new QNetworkAccessManager(this);
currentUpload = manager.post(request, multiPart);
connect(currentUpload,SIGNAL(uploadProgress(qint64,qint64)),this, SLOT(onUploadProgress(qint64,qint64)));
connect(currentUpload, SIGNAL(finished()),this,SLOT(onUploadFinished()));
Uploading = true;
//reply->deleteLater();
}
bool ServerListener::postTaskResults(QString taskId, QString filepath)
{
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart textPart;
textPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"task_assignment_id\""));
textPart.setBody(taskId.toUtf8());
QHttpPart filePart;
filePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("text/plain"));
filePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("attachment; name=\"result_file\"; filename=\"out.csv\""));
QFile *file = new QFile(filepath);
file->open(QIODevice::ReadOnly);
filePart.setBodyDevice(file);
file->setParent(multiPart); // we cannot delete the file now, so delete it with the multiPart
multiPart->append(textPart);
multiPart->append(filePart);
QEventLoop loop;
QNetworkAccessManager* manager = new QNetworkAccessManager();
QNetworkRequest request = QNetworkRequest(QUrl(ClientSettingsManager::getServerUrl() + "postTaskData"));
connect(manager, SIGNAL(finished(QNetworkReply*)), &loop, SLOT(quit()));
manager->post(request, multiPart);
loop.exec();
file->close();
delete multiPart;
delete manager;
return true;
}
void Syncer::send(QMap<QString, QString>& posts, QStringList& files)
{
QNetworkRequest request(QUrl(url + posts["command"]));
QHttpMultiPart* parts = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QMapIterator<QString, QString> i(posts);
while (i.hasNext()) {
i.next();
QHttpPart* part = new QHttpPart();
part->setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\""+ i.key() +"\""));
part->setBody(i.value().toUtf8());
parts->append(*part);
}
foreach (QString filename, files) {
QFileInfo finfo(filename);
QFile* file = new QFile(finfo.absoluteFilePath());
if (file->open(QIODevice::ReadOnly)) {
QHttpPart* part = new QHttpPart();
part->setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/"+ finfo.suffix().toLower() +""));
part->setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; filename=\""+ finfo.fileName() +"\""));
part->setBodyDevice(file);
file->setParent(parts); // for delete time
parts->append(*part);
}
}
void UserActivityLogger::logAction(QString action, QJsonObject details, JSONCallbackParameters params) {
if (_disabled.get()) {
return;
}
auto accountManager = DependencyManager::get<AccountManager>();
QHttpMultiPart* multipart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
// Adding the action name
QHttpPart actionPart;
actionPart.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data; name=\"action_name\"");
actionPart.setBody(QByteArray().append(action));
multipart->append(actionPart);
// If there are action details, add them to the multipart
if (!details.isEmpty()) {
QHttpPart detailsPart;
detailsPart.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data;"
" name=\"action_details\"");
detailsPart.setBody(QJsonDocument(details).toJson(QJsonDocument::Compact));
multipart->append(detailsPart);
}
// if no callbacks specified, call our owns
if (params.isEmpty()) {
params.errorCallbackReceiver = this;
params.errorCallbackMethod = "requestError";
}
accountManager->sendRequest(USER_ACTIVITY_URL,
AccountManagerAuth::Optional,
QNetworkAccessManager::PostOperation,
params, NULL, multipart);
}
Authorization::Authorization(const QString &login, const QString &password) :
QObject(NULL),
m_login(login),
m_password(password)
{
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart loginPart;
loginPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"login\""));
loginPart.setBody(m_login.toLatin1());
QHttpPart passPart;
passPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"pass\""));
passPart.setBody(m_password.toLatin1());
multiPart->append(loginPart);
multiPart->append(passPart);
QUrl url("http://freedomsex.net/login.php");
QNetworkRequest request(url);
QNetworkAccessManager *manager = new QNetworkAccessManager(this);
QNetworkReply *reply = manager->post(request, multiPart);
multiPart->setParent(reply);
connect(manager, SIGNAL(finished(QNetworkReply*)), SLOT(test_answer(QNetworkReply*)));
connect(manager, SIGNAL(finished(QNetworkReply*)), manager, SLOT(deleteLater()));
}
void NicoLiveManager::getNewWakuAPI(const int type, QString liveNum)
{
if (type == 2) {
if (!nwin->isSetNecessary()) {
mwin->insLog("NicoLiveManager::getNewWakuAPI type" + QString::number(type) + " no necessary item(s)");
QMessageBox::information(mwin, "Viqo", QStringLiteral("設定されていない必須項目があります"));
return;
}
if (!nwin->isTwitterTagValid()) {
mwin->insLog("NicoLiveManager::getNewWakuAPI type" + QString::number(type) + " twitter tag must start with \"#\"");
QMessageBox::information(mwin, "Viqo", QStringLiteral("ツイッタータグは # で始めてください"));
return;
}
}
if (mNewWaku!=nullptr) mNewWaku->deleteLater();
mNewWaku = new QNetworkAccessManager(this);
QHttpMultiPart *multiPart;
if (type > 2) {
multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
multiPart->setParent(mNewWaku);
} else {
multiPart = nullptr;
}
if (type == 0) {
connect(mNewWaku, SIGNAL(finished(QNetworkReply*)), this,
SLOT(newWakuNewReuseFinished(QNetworkReply*)));
} else if (type == 1) {
void YfrogUpload::upload(const QString& filename)
{
QString realm("http://api.twitter.com/");
QString authProviderUrl("https://api.twitter.com/1/account/verify_credentials.xml");
QUrl url("http://yfrog.com/api/xauth_upload");
QHttpMultiPart* mp = new QHttpMultiPart(QHttpMultiPart::FormDataType);
// Add the image data.
QFile file(filename);
file.open(QIODevice::ReadOnly);
QHttpPart imagePart;
imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data; name=\"media\"; filename=\"" + file.fileName() + "\"");
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, "application/octet-stream");
imagePart.setBody(file.readAll());
mp->append(imagePart);
// key
QHttpPart keyPart;
keyPart.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data; name=\"key\"");
keyPart.setBody(m_yfrogApiKey.toLatin1());
mp->append(keyPart);
QByteArray oauthHeader = m_oauthTwitter->generateAuthorizationHeader(authProviderUrl, OAuth::GET, realm);
QNetworkRequest req(url);
req.setRawHeader("X-Auth-Service-Provider", authProviderUrl.toLatin1());
req.setRawHeader("X-Verify-Credentials-Authorization", oauthHeader);
// Post it!
QNetworkReply* reply = m_oauthTwitter->networkAccessManager()->post(req, mp);
mp->setParent(reply);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
QString ccloud::uploadHtmlSchedule(QString htmlpath)
{
qDebug() << "upload test";
QFile *file = new QFile( htmlpath );
QFileInfo info( htmlpath );
if (!file->exists()){
qDebug() << "file not exists";
return "";
}
QSettings settings;
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart textPart;
textPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"upload\""));
textPart.setBody("upload");
QHttpPart userPart;
userPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"user_id\""));
userPart.setBody( settings.value("cloud/id").toString().toLatin1() );
QHttpPart filePart;
filePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("text/html"));
filePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant(
QString("form-data; name=\"userfile\"; filename=\"%1\"").arg( info.fileName() )));
file->open(QIODevice::ReadOnly);
filePart.setBodyDevice(file);
file->setParent(multiPart);
multiPart->append(textPart);
multiPart->append(userPart);
multiPart->append(filePart);
QUrl url("https://api.theocbase.net/theocbase_get.php");
QNetworkRequest request(url);
QNetworkAccessManager *manager = new QNetworkAccessManager(this);
QNetworkReply *reply = manager->post(request,multiPart);
multiPart->setParent(reply);
QEventLoop loop;
connect(reply,SIGNAL(finished()),&loop,SLOT(quit()));
loop.exec();
QString replystr = reply->readAll();
if (reply->error() == QNetworkReply::NoError) {
if (replystr == "true"){
return "https://schedule.theocbase.net/" + info.fileName();
}else{
return "";
}
} else {
QMessageBox::information(0,"","Error when uploding html-schedule to cloud\n" + reply->errorString());
return "";
}
}
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", QString("Client-ID %1").arg(clientId()).toLatin1());
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
if (!mSettings.value("anonymous", true).toBool()) {
request.setRawHeader("Authorization", QByteArray("Bearer ") + mSettings.value("access_token").toByteArray());
if (!mSettings.value("album").toString().isEmpty()) {
QHttpPart albumPart;
albumPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"album\""));
albumPart.setBody(mSettings.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 = Uploader::network()->post(request, multiPart);
reply->setProperty("fileName", fileName);
this->setProperty("fileName", fileName);
multiPart->setParent(reply);
#ifdef Q_OS_WIN
connect(reply, &QNetworkReply::sslErrors, [reply](const QList<QSslError> &errors) {
Q_UNUSED(errors);
if (QSysInfo::WindowsVersion <= QSysInfo::WV_2003) {
reply->ignoreSslErrors();
}
});
#endif
connect(reply, &QNetworkReply::uploadProgress, this, &ImgurUploader::uploadProgress);
connect(this , &ImgurUploader::cancelRequest, reply, &QNetworkReply::abort);
connect(this , &ImgurUploader::cancelRequest, reply, &QNetworkReply::deleteLater);
connect(reply, &QNetworkReply::finished, this, &ImgurUploader::finished);
}
/**
* @brief downloader::onRequest
* @param request
*/
void downloader::onRequest(QNetworkRequest *request)
{
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart textPart;
textPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"text\""));
textPart.setBody("my text");
multiPart->append(textPart);
QUrl url("http://localhost:55555");
request->setUrl(url);
QNetworkReply *reply = http->post(*request,multiPart);
multiPart->setParent(reply);
}
void Shoter::onButtonSendClicked()
{
/*Create file */
QDate date = QDate::currentDate();
QString name_file = date.toString();
QString savedFile = name_file+".png";
QTemporaryFile file;
file.setFileName(savedFile);
if (!m_screenshot.save(&file)) {
qDebug("file is not saved");
exit(1);
}
// qDebug()<<file.fileName();
QFile *openFile = new QFile(savedFile);
openFile->open(QIODevice::ReadOnly);
QHttpMultiPart *multi = new QHttpMultiPart(QHttpMultiPart::FormDataType);
/* Upload to ipix.su */
if (ui->comboBox->currentIndex()== 0) {
QHttpPart file;
file.setHeader(QNetworkRequest::ContentTypeHeader,QVariant("image/png"));
file.setHeader(QNetworkRequest::ContentDispositionHeader,QVariant("form-data; name=\"file\"; filename=\""+savedFile+"\""));
file.setBodyDevice(openFile);
openFile->setParent(multi);
multi->append(file);
this->upload("http://ipix.su/api/upload",multi);
/* upload to pix.academ.org */
} else if (ui->comboBox->currentIndex() == 1) {
QHttpPart action;
action.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("name=\"action\""));
action.setBody("upload_image");
QHttpPart image;
image.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/png"));
image.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name=\"image\"; filename=\""+savedFile+"\""));
image.setBodyDevice(openFile);
openFile->setParent(multi);
multi->append(action);
multi->append(image);
upload("http://pix.academ.org", multi);
/* Upload to ompldr.org*/
} else if (ui->comboBox->currentIndex() == 2) {
QHttpPart file1;
file1.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/png"));
file1.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name=\"file1\"; filename=\""+savedFile+"\""));
file1.setBodyDevice(openFile);
openFile->setParent(multi);
multi->append(file1);
upload("http://ompldr.org/upload", multi);
}
}
void ImgurUploader::upload(QNetworkAccessManager *net, UploadItemPtr item, const QVariant &data)
{
m_net = net;
const QVariantMap map = data.toMap();
const QVariantList authData = map.value(LS("a")).toList();
if (authData.size() == 3) {
m_clientId = authData.at(0).toString();
m_clientSecret = authData.at(1).toString();
m_queue.enqueue(item);
getToken(ChatId(ChatId::MessageId), "refresh_token", authData.value(2).toByteArray(), authData);
return;
}
QNetworkReply *reply = 0;
if (item->type() == ImageItem::Type) {
ImageItem *i = uploaditem_cast<ImageItem*>(item.data());
QHttpPart image;
image.setHeader(QNetworkRequest::ContentTypeHeader, "image/png");
image.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data; name=\"image\"; filename=\"" + DateTime::toDateTime(item->date()).toString(LS("yyyy-MM-dd_hh-mm-ss")).toLatin1() + ".png\"");
image.setBody(i->raw);
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
multiPart->append(image);
if (!item->title().isEmpty()) {
QHttpPart title;
title.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"title\""));
title.setBody(item->title().toUtf8());
multiPart->append(title);
}
QNetworkRequest request(QUrl(LS("https://api.imgur.com/3/image")));
request.setRawHeader("User-Agent", OsInfo::userAgent());
if (authData.size() == 4)
request.setRawHeader("Authorization", "Bearer " + authData.value(3).toByteArray());
else
request.setRawHeader("Authorization", "Client-ID " + authData.value(0).toByteArray());
reply = net->post(request, multiPart);
multiPart->setParent(reply);
}
prepare(reply, item->id());
}
QHttpMultiPart * DataSender::prepareMultipart()
{
QHttpMultiPart * multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
multiPart->append(createPart("form-data; name=\"entry[text]\"", this->text));
multiPart->append(createPart("form-data; name=\"entry[name]\"", this->name));
QFile file(this->filepath);
file.open(QIODevice::ReadOnly);
if(file.isOpen())
multiPart->append(createFilePart("form-data; name=\"entry[file]\"", &file));
return multiPart;
}
QHttpMultiPart *createForm(QList<FormField> fields) {
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
for (int i = 0; i < fields.count(); ++i) {
FormField &field = fields[i];
QHttpPart part;
if (!field.type.isEmpty())
part.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(field.type));
if (!field.disposition.isEmpty())
part.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant(field.disposition));
part.setBody(field.body);
multiPart->append(part);
}
return multiPart;
}
/**
* This member function may be called in two places:
* 1. when task is first started
* 2. when the request is redirected
*/
void PostFileTask::sendRequest()
{
QHttpMultiPart *multipart = new QHttpMultiPart(QHttpMultiPart::FormDataType, this);
// parent_dir param
QHttpPart parentdir_part, file_part;
if (use_upload_) {
parentdir_part.setHeader(QNetworkRequest::ContentDispositionHeader,
kParentDirParam);
parentdir_part.setBody(parent_dir_.toUtf8());
} else {
parentdir_part.setHeader(QNetworkRequest::ContentDispositionHeader,
kTargetFileParam);
parentdir_part.setBody(::pathJoin(parent_dir_, name_).toUtf8());
}
multipart->append(parentdir_part);
// relative_path param
if (!relative_path_.isEmpty()) {
QHttpPart part;
part.setHeader(QNetworkRequest::ContentDispositionHeader,
kRelativePathParam);
part.setBody(relative_path_.toUtf8());
multipart->append(part);
}
// "file" param
file_part.setHeader(QNetworkRequest::ContentDispositionHeader,
QString(kFileParamTemplate).arg(name_).toUtf8());
file_part.setHeader(QNetworkRequest::ContentTypeHeader,
kContentTypeApplicationOctetStream);
file_part.setBodyDevice(file_);
multipart->append(file_part);
QNetworkRequest request(url_);
request.setRawHeader("Content-Type",
"multipart/form-data; boundary=" + multipart->boundary());
if (!network_mgr_) {
static QNetworkAccessManager *manager = new QNetworkAccessManager(qApp);
network_mgr_ = manager;
NetworkManager::instance()->addWatch(network_mgr_);
}
reply_ = network_mgr_->post(request, multipart);
connect(reply_, SIGNAL(sslErrors(const QList<QSslError>&)),
this, SLOT(onSslErrors(const QList<QSslError>&)));
connect(reply_, SIGNAL(finished()), this, SLOT(httpRequestFinished()));
connect(reply_, SIGNAL(uploadProgress(qint64,qint64)),
this, SIGNAL(progressUpdate(qint64, qint64)));
}
bool uploadImage::check_interface_authencity(QString code){
QEventLoop eventLoop;
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart textPart2;
textPart2.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name=\"isGenuine\""));
textPart2.setBody(code.toUtf8());
multiPart->append(textPart2);
QNetworkAccessManager mgr;
QObject::connect(&mgr, SIGNAL(finished(QNetworkReply*)), &eventLoop, SLOT(quit()));
QNetworkRequest req( QUrl( QString(MainWindow::serverAddress+"/recieveVotersData.php") ) );
QNetworkReply *reply = mgr.post(req,multiPart);
multiPart->setParent(reply);
eventLoop.exec(); // blocks stack until "finished()" has been called
if (reply->error() == QNetworkReply::NoError) {
//success
QString strx=reply->readAll();
QJsonDocument jsonResponse = QJsonDocument::fromJson(strx.toUtf8());
QJsonObject jsonObject = jsonResponse.object();
QJsonObject obj=jsonObject["code"].toObject();
code=obj.value("response").toString();
bool isGenuineServer=obj.value("validity").toString().toInt()>0;
if(isGenuineServer){
networkManagement::systemCode=code;
networkManagement::isGenuine=true;
}
delete reply;
return true;
}
else {
//failure
qDebug() << "Failure" <<reply->errorString();
delete reply;
return false;
}
}
QNetworkReply* MNetworkManager::sendJWT(const QString url, QJsonObject ¶ms, QString method, const QString snapshotUrl, quint32 timestamp) {
QJsonObject header;
header["typ"] = "JWT";
header["alg"] = "sha256";
QByteArray encode;
encode.append(QJsonDocument(header).toJson().toBase64(QByteArray::Base64Encoding));
encode.append(".");
encode.append(QJsonDocument(params).toJson().toBase64(QByteArray::Base64Encoding));
QByteArray signature = QMessageAuthenticationCode::hash(encode, QByteArray(SECRET), QCryptographicHash::Sha256).toHex();
QByteArray jwt;
jwt.append(encode);
jwt.append(".");
jwt.append(signature);
QString apiUrl = APIHOST;
apiUrl.append(url);
QNetworkRequest request;
request.setUrl(QUrl(apiUrl));
request.setRawHeader("JWT", jwt);
QNetworkReply* reply;
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart imagePart;
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/png"));
imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"screenshot_" + QString("%1").arg(timestamp) + "\"; filename=\"screenshot.jpg\""));
QFile *file = new QFile(snapshotUrl);
file->open(QIODevice::ReadOnly);
imagePart.setBodyDevice(file);
file->setParent(multiPart); // we cannot delete the file now, so delete it with the multiPart
multiPart->append(imagePart);
if (method == "post") {
reply = this->post(request, multiPart);
} else {
reply = this->get(request);
}
multiPart->setParent(reply);
reply->setProperty("imagePath", snapshotUrl);
reply->setProperty("timestamp", timestamp);
return reply;
}
void ChooseFileDlg::onFileSelect(bool)
{
QString path = QFileDialog::getOpenFileName(this, tr("Open File"), NULL, tr("All files *.*"));
QFile *file = new QFile(path);
if (!file->exists() || !file->open(QIODevice::ReadOnly))
return;
QProgressDialog progress(tr("Uploading..."), tr("Abort"), 0, 100, this);
progress.setMinimumDuration(0);
QHttpPart httpFilePart;
httpFilePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant(QString("form-data; name=\"file\"; filename=\"%1\"").arg(QFileInfo(path).fileName())));
httpFilePart.setBodyDevice(file);
QHttpMultiPart *httpMultiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
httpMultiPart->append(httpFilePart);
QNetworkAccessManager manager;
QNetworkReply *reply = manager.post(QNetworkRequest(QUrl("http://127.0.0.1:3000/media/upload")), httpMultiPart);
connect(reply, &QNetworkReply::uploadProgress, [&](qint64 bytesSent, qint64 bytesTotal){
if (bytesSent && bytesTotal) progress.setValue((100 * bytesSent) / bytesTotal);
});
file->setParent(httpMultiPart);
httpMultiPart->setParent(reply);
connect(&progress, &QProgressDialog::canceled, [&]() {
reply->abort();
});
while (reply->isRunning()) {
QCoreApplication::processEvents();
}
if (reply->error() != QNetworkReply::NoError) {
if (reply->error() != QNetworkReply::OperationCanceledError)
QMessageBox::warning(this, tr("Failed to upload"), reply->errorString());
return;
}
QByteArray content = reply->readAll();
qDebug() << content;
}
bool uploadImage::take_remote_back(const int remoteid){
QEventLoop eventLoop;
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart textPart2,textPart1;
textPart2.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name=\"take_remote_back\""));
textPart2.setBody(QByteArray::number(remoteid));
textPart1.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name=\"systemCode\""));
textPart1.setBody(networkManagement::systemCode.toUtf8());
multiPart->append(textPart2);
multiPart->append(textPart1);
// "quit()" the event-loop, when the network request "finished()"
QNetworkAccessManager mgr;
QObject::connect(&mgr, SIGNAL(finished(QNetworkReply*)), &eventLoop, SLOT(quit()));
QNetworkRequest req( QUrl( QString(MainWindow::serverAddress+"/syncRemotes.php") ) );
QNetworkReply *reply = mgr.post(req,multiPart);
multiPart->setParent(reply);
eventLoop.exec(); // blocks stack until "finished()" has been called
if (reply->error() == QNetworkReply::NoError) {
//success
QString strx=reply->readAll();
qDebug()<<strx;
// qDebug()<<propertyKeys;
delete reply;
return true;
}
else {
//failure
qDebug() << "Failure" <<reply->errorString();
delete reply;
return false;
}
}
void Snapshot::uploadSnapshot(const QString& filename, const QUrl& href) {
const QString SNAPSHOT_UPLOAD_URL = "/api/v1/snapshots";
QUrl url = href;
if (url.isEmpty()) {
SnapshotMetaData* snapshotData = Snapshot::parseSnapshotData(filename);
if (snapshotData) {
url = snapshotData->getURL();
}
delete snapshotData;
}
if (url.isEmpty()) {
url = QUrl(DependencyManager::get<AddressManager>()->currentShareableAddress());
}
SnapshotUploader* uploader = new SnapshotUploader(url, filename);
QFile* file = new QFile(filename);
Q_ASSERT(file->exists());
file->open(QIODevice::ReadOnly);
QHttpPart imagePart;
if (filename.right(3) == "gif") {
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/gif"));
} else {
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/jpeg"));
}
imagePart.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name=\"image\"; filename=\"" + file->fileName() + "\""));
imagePart.setBodyDevice(file);
QHttpMultiPart* multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
file->setParent(multiPart); // we cannot delete the file now, so delete it with the multiPart
multiPart->append(imagePart);
auto accountManager = DependencyManager::get<AccountManager>();
JSONCallbackParameters callbackParams(uploader, "uploadSuccess", uploader, "uploadFailure");
accountManager->sendRequest(SNAPSHOT_UPLOAD_URL,
AccountManagerAuth::Required,
QNetworkAccessManager::PostOperation,
callbackParams,
nullptr,
multiPart);
}
void SnapshotShareDialog::uploadSnapshot() {
if (AccountManager::getInstance().getAccountInfo().getDiscourseApiKey().isEmpty()) {
QMessageBox::warning(this, "",
"Your Discourse API key is missing, you cannot share snapshots. Please try to relog.");
return;
}
if (!_networkAccessManager) {
_networkAccessManager = new QNetworkAccessManager(this);
}
QHttpMultiPart* multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart apiKeyPart;
apiKeyPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"api_key\""));
apiKeyPart.setBody(AccountManager::getInstance().getAccountInfo().getDiscourseApiKey().toLatin1());
QFile* file = new QFile(_fileName);
file->open(QIODevice::ReadOnly);
QHttpPart imagePart;
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/jpeg"));
imagePart.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name=\"file\"; filename=\"" + file->fileName() +"\""));
imagePart.setBodyDevice(file);
file->setParent(multiPart); // we cannot delete the file now, so delete it with the multiPart
multiPart->append(apiKeyPart);
multiPart->append(imagePart);
QUrl url(FORUM_UPLOADS_URL);
QNetworkRequest request(url);
QNetworkReply* reply = _networkAccessManager->post(request, multiPart);
connect(reply, &QNetworkReply::finished, this, &SnapshotShareDialog::uploadRequestFinished);
QEventLoop loop;
connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
loop.exec();
}
/// <summary>
/// Execute http post
/// </summary>
/// <param name="url">url for the http post</param>
/// <param name="data">string data to post</param>
/// <returns>Server answer</returns>
string VulkanDatabase::httpPost(string url, string data)
{
manager = new QNetworkAccessManager(NULL);
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart jsonPart;
jsonPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"data\"; filename=\"vulkanreport.json\""));
jsonPart.setBody(QString::fromStdString(data).toLatin1());
multiPart->append(jsonPart);
QUrl qurl(QString::fromStdString(url));
if (dbLogin)
{
qurl.setUserName(dbUser);
qurl.setPassword(dbPass);
}
QNetworkRequest request(qurl);
QNetworkReply *reply = manager->post(request, multiPart);
multiPart->setParent(reply);
QEventLoop loop;
connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
loop.exec();
if (reply->error() == QNetworkReply::NoError)
{
QByteArray bytes = reply->readAll();
QString replyStr(bytes);
delete(manager);
return replyStr.toStdString();
}
else
{
QString err;
err = reply->errorString();
delete(manager);
return err.toStdString();
}
}
void LoginManager::upload(const QString &path, int nid, const QString &title, const QString &description, const QString& priv, const QString& license, const QString& tags)
{
//qDebug() << "file upload";
KQOAuthRequest *oauthRequest = new KQOAuthRequest(this);
QUrl url("https://api.musescore.com/services/rest/score.json");
if (nid > 0)
url = QUrl(QString("https://api.musescore.com/services/rest/score/%1/update.json").arg(nid));
oauthRequest->initRequest(KQOAuthRequest::AuthorizedRequest, url);
oauthRequest->setConsumerKey(_consumerKey);
oauthRequest->setConsumerSecretKey(_consumerSecret);
oauthRequest->setToken(_accessToken);
oauthRequest->setTokenSecret(_accessTokenSecret);
oauthRequest->setContentType("multipart/form-data");
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart filePart;
filePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("application/octet-stream"));
filePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"score_data\"; filename=\"temp.mscz\""));
QFile *file = new QFile(path);
file->open(QIODevice::ReadOnly);
filePart.setBodyDevice(file);
file->setParent(multiPart); // we cannot delete the file now, so delete it with the multiPart
multiPart->append(filePart);
QHttpPart titlePart;
titlePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"title\""));
titlePart.setBody(title.toUtf8());
multiPart->append(titlePart);
QHttpPart descriptionPart;
descriptionPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"description\""));
descriptionPart.setBody(description.toUtf8());
multiPart->append(descriptionPart);
QHttpPart privatePart;
privatePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"private\""));
privatePart.setBody(priv.toUtf8());
multiPart->append(privatePart);
QHttpPart licensePart;
licensePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"license\""));
licensePart.setBody(license.toUtf8());
multiPart->append(licensePart);
QHttpPart tagsPart;
tagsPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"tags\""));
tagsPart.setBody(tags.toUtf8());
multiPart->append(tagsPart);
connect(_oauthManager, SIGNAL(requestReady(QByteArray)),
this, SLOT(onUploadRequestReady(QByteArray)));
oauthRequest->setHttpMultiPart(multiPart);
_oauthManager->executeRequest(oauthRequest);
}
void
SportPlusHealthUploader::requestUpload()
{
parent->progressLabel->setText(tr("sending to SportPlusHealth..."));
parent->progressBar->setValue(parent->progressBar->value()+10/parent->shareSiteCount);
QString username = appsettings->cvalue(context->athlete->cyclist, GC_SPORTPLUSHEALTHUSER).toString();
QString password = appsettings->cvalue(context->athlete->cyclist, GC_SPORTPLUSHEALTHPASS).toString();
//Building the message content
QHttpMultiPart *body = new QHttpMultiPart( QHttpMultiPart::FormDataType );
//Including the optional session name
QHttpPart textPart;
textPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"session_name\""));
textPart.setBody(QByteArray(insertedName.toLatin1()));
body->append(textPart);
//Including the content data type
QHttpPart dataTypePart;
dataTypePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"format\""));
dataTypePart.setBody("tcx");
body->append(dataTypePart);
//Including file in the request
TcxFileReader reader;
QByteArray file = reader.toByteArray(context, ride->ride(), parent->altitudeChk->isChecked(), parent->powerChk->isChecked(), parent->heartrateChk->isChecked(), parent->cadenceChk->isChecked());
QHttpPart filePart;
filePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"datafile\"; filename=\"sph_file.tcx\"; type=\"text/xml\""));
filePart.setBody(file);
body->append(filePart);
//Sending the authenticated post request to the API
parent->progressBar->setValue(parent->progressBar->value()+20/parent->shareSiteCount);
QUrl url(SPH_URL + "/" + username + "/importGC");
QNetworkRequest request;
request.setUrl(url);
request.setRawHeader("Authorization", "Basic " + QByteArray(QString("%1:%2").arg(username).arg(password).toLatin1()).toBase64());
networkMgr.post(request, body);
parent->progressBar->setValue(parent->progressBar->value()+10/parent->shareSiteCount);
}
/**
* @brief Function that sends the multipart message request to the API server.
* Shows the image being OCR'd in the left-hand side of the interface
*/
void MainWindow::recognize(){
QHttpMultiPart* multipart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
//set up http part message to send to api that contains image data
QHttpPart imagePart;
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/gif"));
imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"file\"; filename=\"./Polish_test2.gif\""));
QFile* file = new QFile(fileName);
//debugging: make sure file was uploaded
if(!file->open(QIODevice::ReadOnly)){
qDebug() << "# Could not upload/open file";
}
QByteArray fileContent(file->readAll());
imagePart.setBody(fileContent);
//append image data, api key, language, and overlay setting to multipart
multipart->append(imagePart);
multipart->append(part_parameter("apikey","3653fc62e388957"));
multipart->append(part_parameter("language","pol"));
multipart->append(part_parameter("isOverlayRequired","false"));
//ocr api url
QUrl api_url("https://apifree2.ocr.space/parse/image");
//create network request obj that contains the api url
QNetworkRequest api_request(api_url);
manager = new QNetworkAccessManager;
//=(url, multipart encoded message)
reply = manager->post(api_request, multipart);
QObject::connect(reply, SIGNAL(finished()), this, SLOT(networkData()));
//debugging: make sure file was opened; if 0 bytes, it wasn't!
qDebug() << file->size() << "bytes";
imagePart.setBodyDevice(file);
file->setParent(multipart);
networkData();
}
//Use mime parts iff the SOAP version is XOP.
QHttpMultiPart* KDSoapClientInterfacePrivate::prepareMimeRequestBuffer(const QString& method, const KDSoapMessage& message, const KDSoapHeaders& headers)
{
QHttpMultiPart *mime = new QHttpMultiPart(QHttpMultiPart::RelatedType);
QHttpPart soapPart;
soapPart.setRawHeader("Content-Id", "<http://tempuri.org/0>");
soapPart.setRawHeader("Content-Transfer-Encoding", "binary");
if (m_version == SOAP1_1_XOP) {
soapPart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(QString::fromLatin1("application/xop+xml;charset=utf-8;type=\"text/xml\"")));
} else if (m_version == SOAP1_2_XOP) {
soapPart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(QString::fromLatin1("application/xop+xml;charset=utf-8;type=\"application/soap+xml\"")));
}
//TODO: Catch base64 and use xop instead. B4152: WCF optimizes element information items that contain base64-encoded data and exceed 1024 bytes in length.
KDSoapMessageWriter msgWriter;
msgWriter.setMessageNamespace(m_messageNamespace);
const QByteArray data = msgWriter.messageToXml(message, (m_style == KDSoapClientInterface::RPCStyle) ? method : QString(), headers, m_persistentHeaders, m_version);
soapPart.setBody(data);
mime->append(soapPart);
return mime;
}
////////////
/// \brief QQPalmiFilePoster::postFileUpload3TerOrg
/// \param file
///
QNetworkReply * QQPalmiFilePoster::postFileUpload3TerOrg(QFile *file)
{
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart filePart;
#if(QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
QMimeDatabase mimeDatabase;
QMimeType mimeType = mimeDatabase.mimeTypeForFile(file->fileName(), QMimeDatabase::MatchDefault);
filePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(mimeType.name()));
#else
filePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("application/octet-stream"));
#endif
filePart.setHeader(QNetworkRequest::ContentDispositionHeader,
QString("form-data; name=\"file\"; filename=\"%1\"").arg(file->fileName()));
filePart.setBodyDevice(file);
file->setParent(multiPart); // we cannot delete the file now, so delete it with the multiPart
multiPart->append(filePart);
QHttpPart timePart;
timePart.setHeader(QNetworkRequest::ContentDispositionHeader,
QString("form-data; name=\"time\""));
timePart.setBody(QString::fromLatin1("week").toLatin1());
multiPart->append(timePart);
QUrl url(QString("http://%1/script.php").arg(FILE_SHARING_SERVICE_JIRAFEAU_3TER_ORG));
QNetworkRequest request(url);
//request.setRawHeader("User-Agent", "Mozilla/5.0 (quteqoin)"); // Le service n'accepte pas l'ua par défaut ...
//request.setRawHeader("Accept", "application/json, text/javascript, */*; q=0.01");
//request.setRawHeader("Accept-Language", "en-US,en;q=0.5");
//request.setRawHeader("Accept-Encoding", "gzip, deflate"); // Qt 4 ne supporte pas gunzip nativement ....
//request.setRawHeader("X-Requested-With", "XMLHttpRequest");
request.setRawHeader("Referer", QString("http://%1/").arg(FILE_SHARING_SERVICE_JIRAFEAU_3TER_ORG).toLatin1());
QNetworkReply *reply = httpPost(request, multiPart);
multiPart->setParent(reply); // delete the multiPart with the reply
return reply;
}
fileUploader::fileUploader(QString filePath, QUrl url, QObject *parent) : QObject(parent)
{
QHttpMultiPart* multipart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart uploaderPart;
uploaderPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"uploaderId\""));
//uploaderPart.setBody(UserObjectId);
QFile* file = new QFile(filePath);
file->open(QIODevice::ReadOnly);
QHttpPart filePart;
filePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"file\""));
filePart.setBodyDevice(file);
file->setParent(multipart);
multipart->append(uploaderPart);
multipart->append(filePart);
QNetworkRequest request(QUrl(SERVER_FILE));
_networkManager.post(request, multipart);
}
QNetworkReply* MNetworkManager::sendJWT(const QString url, QJsonObject ¶ms, QString method ) {
QJsonObject header;
header["typ"] = "JWT";
header["alg"] = "sha256";
QByteArray encode;
encode.append(QJsonDocument(header).toJson().toBase64(QByteArray::Base64Encoding));
encode.append(".");
encode.append(QJsonDocument(params).toJson().toBase64(QByteArray::Base64Encoding));
QByteArray signature = QMessageAuthenticationCode::hash(encode, QByteArray(SECRET), QCryptographicHash::Sha256).toHex();
QByteArray jwt;
jwt.append(encode);
jwt.append(".");
jwt.append(signature);
QString apiUrl = APIHOST;
apiUrl.append(url);
QNetworkRequest request;
request.setUrl(QUrl(apiUrl));
request.setRawHeader("JWT", jwt);
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QNetworkReply* reply;
if (method == "post") {
reply = this->post(request,multiPart);
} else {
reply = this->get(request);
}
multiPart->setParent(reply);
return reply;
}
