QHttpPart DataSender::createPart(const QString &header, const QString &body)
{
QHttpPart part;
part.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant(header));
part.setBody(body.toUtf8());
return part;
}
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();
}
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 RemoteDatabase::addPart(QHttpMultiPart* multipart, const QString& name, const QString& value)
{
QHttpPart part;
part.setHeader(QNetworkRequest::ContentDispositionHeader, QString("form-data; name=\"%1\"").arg(name));
part.setBody(value.toUtf8());
multipart->append(part);
}
void RemoteDatabase::addPart(QHttpMultiPart* multipart, const QString& name, QFile* file, const QString& filename)
{
QHttpPart part;
part.setHeader(QNetworkRequest::ContentDispositionHeader, QString("form-data; name=\"%1\"; filename=\"%2\"").arg(name).arg(filename));
part.setBodyDevice(file);
file->setParent(multipart); // Close the file and delete the file object as soon as the multi-part object is destroyed
multipart->append(part);
}
/*
make a multipart HTTP POST at the following path "/restapi/public/activities/upload.json"
on selflloops web site using SSL.
The requested parameters are:
- "email" the email of a valid SelfLoops account
- "pw" the password
- "tcxfile" the zipped TCX file (example: test.tcx.gz).
On success, response message contains a JSON encoded data
with the new "activity_id" created.
On error, SelfLoops response contains a JSON encoded data with "error_code" and "message" key.
*/
void
SelfLoopsUploader::requestUploadSelfLoops()
{
parent->progressLabel->setText(tr("Upload ride to Selfloops..."));
parent->progressBar->setValue(parent->progressBar->value()+10/parent->shareSiteCount);
QEventLoop eventLoop;
QNetworkAccessManager networkMgr;
connect(&networkMgr, SIGNAL(finished(QNetworkReply*)), this, SLOT(requestUploadSelfLoopsFinished(QNetworkReply*)));
connect(&networkMgr, SIGNAL(finished(QNetworkReply *)), &eventLoop, SLOT(quit()));
QUrl url = QUrl( "https://www.selfloops.com/restapi/public/activities/upload.json" );
QNetworkRequest request = QNetworkRequest(url);
QString boundary = QVariant(qrand()).toString()+QVariant(qrand()).toString()+QVariant(qrand()).toString();
// The TCX file have to be gzipped
TcxFileReader reader;
QByteArray file = zCompress(reader.toByteArray(context, ride->ride(), parent->altitudeChk->isChecked(), parent->powerChk->isChecked(), parent->heartrateChk->isChecked(), parent->cadenceChk->isChecked()));
QString username = appsettings->cvalue(context->athlete->cyclist, GC_SELUSER).toString();
QString password = appsettings->cvalue(context->athlete->cyclist, GC_SELPASS).toString();
// MULTIPART *****************
QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::MixedType);
multiPart->setBoundary(boundary.toLatin1());
QHttpPart emailPart;
emailPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"email\""));
emailPart.setBody(username.toLatin1());
QHttpPart passwordPart;
passwordPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"pw\""));
passwordPart.setBody(password.toLatin1());
QHttpPart filePart;
filePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"tcxfile\"; filename=\"myfile.tcx.gz\"; type=\"application/x-gzip\""));
filePart.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-gzip");
filePart.setBody(file);
multiPart->append(emailPart);
multiPart->append(passwordPart);
multiPart->append(filePart);
QScopedPointer<QNetworkReply> reply( networkMgr.post(request, multiPart) );
multiPart->setParent(reply.data());
parent->progressBar->setValue(parent->progressBar->value()+30/parent->shareSiteCount);
parent->progressLabel->setText(tr("Upload ride... Sending to Selfloops"));
eventLoop.exec();
}
void NetworkComm::addFile(QString key, const QByteArray value, const QByteArray file_extension, const QByteArray file_type){
QHttpPart* filePart;
filePart = new QHttpPart();
filePart->setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\""+key+"\"; filename=\""+"myfile."+file_extension+"\""));
filePart->setHeader(QNetworkRequest::ContentTypeHeader, QVariant(file_type));
QFile *file = new QFile(value);
file->open(QIODevice::ReadOnly);
filePart->setBodyDevice(file);
file->setParent(multiPart);
multiPart->append(*filePart);
}
QHttpPart DataSender::createFilePart(const QString &header, QFile * file)
{
QHttpPart part;
QFileInfo info(*file);
QString extension = info.suffix();
QString filename = info.fileName();
part.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(QString("image/%1").arg(extension)));
part.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant(
QString("%1; filename=\"%2\"").arg(header).arg(filename)));
part.setBody(file->readAll());
return part;
}
void NetworkComm::addImage(QString key, const QByteArray value){
QHttpPart* imagePart;
imagePart = new QHttpPart();
imagePart->setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\""+key+"\"; filename=\"myfile.jpg\""));
imagePart->setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/jpeg"));
QFile *file = new QFile(value);
file->open(QIODevice::ReadOnly);
imagePart->setBodyDevice(file);
file->setParent(multiPart);
multiPart->append(*imagePart);
//params.addQueryItem(key,value);
}
/**
* @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);
}
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)));
}
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()));
}
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 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);
}
}
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;
}
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;
}
bool FstReader::addPart(const QString &path, const QString& name) {
QFile* file = new QFile(path);
if (!file->open(QIODevice::ReadOnly)) {
qDebug() << "[ERROR] Couldn't open " << file->fileName();
return false;
}
QHttpPart part;
part.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data;"
" name=\"" + name.toUtf8() + "\";"
" filename=\"" + QFileInfo(*file).fileName().toUtf8() + "\"");
part.setHeader(QNetworkRequest::ContentTypeHeader, "application/octet-stream");
part.setBodyDevice(file);
_dataMultiPart->append(part);
file->setParent(_dataMultiPart);
return true;
}
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 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;
}
/// <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();
}
}
QByteArray WebUtils::postByUrl(const QUrl &url,
const QMap<QString, QString> &sysAndAppParams,
const QMap<QString, FileItem> &tmpFiles)
{
QHttpMultiPart multiParts(QHttpMultiPart::FormDataType);
QMapIterator<QString, QString> appParamIter(sysAndAppParams);
while (appParamIter.hasNext()) {
appParamIter.next();
QHttpPart appParamPart;
appParamPart.setHeader(QNetworkRequest::ContentTypeHeader,
QVariant("text/plain; charset = UTF-8"));
appParamPart.setHeader(QNetworkRequest::ContentDispositionHeader,
QVariant("form-data; name =" + appParamIter.key().toUtf8()));
appParamPart.setBody(appParamIter.value().toUtf8());
multiParts.append(appParamPart);
}
QMapIterator<QString, FileItem> i(tmpFiles);
while (i.hasNext()) {
i.next();
FileItem fileItem = i.value();
QHttpPart filePart;
filePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(fileItem.getMimeType()));
QString disposition = QString("form-data; name = %1; filename = %2")
.arg(i.key()).arg(fileItem.getFileName());
filePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant(disposition));
filePart.setBody(fileItem.getContent());
multiParts.append(filePart);
}
QNetworkReply *reply = qnam.post(QNetworkRequest(url), &multiParts);
QEventLoop loop;
connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
loop.exec();
QVariant redirectionTarget = reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
if (reply->error()) {
qDebug() << reply->errorString();
return reply->errorString().toUtf8();
} else if (!redirectionTarget.isNull()) {
QUrl newUrl = url.resolved(redirectionTarget.toUrl());
reply->deleteLater();
return postByUrl(newUrl, sysAndAppParams, tmpFiles);
}
QByteArray returnStr = reply->readAll();
reply->deleteLater();
return returnStr;
}
void Server::upload(QByteArray bytes) {
auto multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart imagePart;
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/png"));
imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"image\"; filename=\"screen.png\""));
imagePart.setBody(bytes);
multiPart->append(imagePart);
QNetworkRequest request;
request.setUrl(QUrl(url_ + "/screen/upload"));
request.setRawHeader("User-Agent", "Screenshotgun client");
connect(&manager_, SIGNAL(finished(QNetworkReply*)),
this, SLOT(uploadedSlot(QNetworkReply*)));
QNetworkReply* reply = manager_.post(request, multiPart);
multiPart->setParent(reply); // delete the multiPart with the reply
}
/**
* @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();
}
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()));
}
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);
}
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);
}
/*!
* Prepare image data for uploading
*/
void Uploader_MediaCrush::createData(bool inBase64)
{
Uploader::createData(inBase64);
_multipartData = new QHttpMultiPart(QHttpMultiPart::FormDataType);
QHttpPart imagePart;
if (_formatString == "jpg")
{
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/jpeg"));
}
else
{
imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("image/" + _formatString));
}
QByteArray disposition = "form-data; name=\"file\"; filename='"+ _uploadFilename.toLatin1() +"'";
imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant(disposition));
imagePart.setBody(imageData);
_multipartData->append(imagePart);
imageData.clear();
}
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);
}
