void NetworkManager::sendServiceMessageToMobile(const Message& message)
{
QNetworkRequest request;
request.setUrl(QUrl(mobileParams_.server));
request.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("application/x-www-form-urlencoded"));
QUrlQuery params;
params.addQueryItem("text", QUrl::toPercentEncoding(message.text));
params.addQueryItem("id", QString::number(7777));
params.addQueryItem("priority", QString::number(0));
params.addQueryItem("time", message.receiveTime.toString());
if (cache_.logging)
{
Loggers::net->info() << params.query();
}
QNetworkReply* reply = manager_->post(request, params.query().toUtf8());
if (reply)
{
auto handler = [=](QNetworkReply* reply)
{
if(reply->error() != QNetworkReply::NoError)
{
Loggers::app->warn() << "gor error in sendServiceMessageToMobile";
}
};
restartTimer(reply, handler);
}
}
void NXMAccessManager::pageLogin()
{
qDebug("logging %s in on Nexus", qPrintable(m_Username));
QString requestString = (ToQString(GameInfo::instance().getNexusPage()) + "/Sessions/?Login&uri=%1")
.arg(QString(QUrl::toPercentEncoding(ToQString(GameInfo::instance().getNexusPage()))));
QNetworkRequest request(requestString);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QByteArray postDataQuery;
QUrlQuery postData;
postData.addQueryItem("username", m_Username);
postData.addQueryItem("password", m_Password);
postDataQuery = postData.query(QUrl::FullyEncoded).toUtf8();
request.setRawHeader("User-Agent", userAgent().toUtf8());
m_ProgressDialog = new QProgressDialog(nullptr);
m_ProgressDialog->setLabelText(tr("Logging into Nexus"));
QList<QPushButton*> buttons = m_ProgressDialog->findChildren<QPushButton*>();
buttons.at(0)->setEnabled(false);
m_ProgressDialog->show();
QCoreApplication::processEvents(); // for some reason the whole app hangs during the login. This way the user has at least a little feedback
m_LoginReply = post(request, postDataQuery);
m_LoginTimeout.start();
m_LoginState = LOGIN_CHECKING;
connect(m_LoginReply, SIGNAL(finished()), this, SLOT(loginFinished()));
connect(m_LoginReply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(loginError(QNetworkReply::NetworkError)));
}
void LoginDialog::OnLoginPageFinished() {
QNetworkReply *reply = qobject_cast<QNetworkReply *>(QObject::sender());
if (reply->error()) {
DisplayError("Network error: " + reply->errorString() + "\nTry using another login method.");
return;
}
QByteArray bytes = reply->readAll();
std::string page(bytes.constData(), bytes.size());
std::string hash = Util::GetCsrfToken(page, "hash");
if (hash.empty()) {
DisplayError("Failed to log in (can't extract form hash from page)");
return;
}
QUrlQuery query;
query.addQueryItem("login_email", EncodeSpecialCharacters(ui->emailLineEdit->text()));
query.addQueryItem("login_password", EncodeSpecialCharacters(ui->passwordLineEdit->text()));
query.addQueryItem("hash", QString(hash.c_str()));
query.addQueryItem("login", "Login");
query.addQueryItem("remember_me", "1");
QUrl url(POE_LOGIN_URL);
QByteArray data(query.query().toUtf8());
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QNetworkReply *logged_in = login_manager_->post(request, data);
connect(logged_in, SIGNAL(finished()), this, SLOT(OnLoggedIn()));
}
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
TrainingstagebuchUploader::requestSession()
{
parent->progressLabel->setText(tr("getting new Trainingstagebuch.org Session..."));
currentRequest = reqSession;
QString username = appsettings->cvalue(context->athlete->cyclist, GC_TTBUSER).toString();
QString password = appsettings->cvalue(context->athlete->cyclist, GC_TTBPASS).toString();
#if QT_VERSION > 0x050000
QUrlQuery urlquery;
#else
QUrl urlquery( TTB_URL + "/login/sso" );
#endif
urlquery.addQueryItem( "view", "xml" );
urlquery.addQueryItem( "user", username );
urlquery.addQueryItem( "pass", password );
#if QT_VERSION > 0x050000
QUrl url (TTB_URL + "/login/sso");
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" );
networkMgr.get( request );
parent->progressBar->setValue(parent->progressBar->value()+5/parent->shareSiteCount);
}
bool QXmppSaslClientFacebook::respond(const QByteArray &challenge, QByteArray &response)
{
if (m_step == 0) {
// no initial response
response = QByteArray();
m_step++;
return true;
} else if (m_step == 1) {
// parse request
QUrlQuery requestUrl(challenge);
if (!requestUrl.hasQueryItem("method") || !requestUrl.hasQueryItem("nonce")) {
warning("QXmppSaslClientFacebook : Invalid challenge, nonce or method missing");
return false;
}
// build response
QUrlQuery responseUrl;
responseUrl.addQueryItem("access_token", password());
responseUrl.addQueryItem("api_key", username());
responseUrl.addQueryItem("call_id", 0);
responseUrl.addQueryItem("method", requestUrl.queryItemValue("method"));
responseUrl.addQueryItem("nonce", requestUrl.queryItemValue("nonce"));
responseUrl.addQueryItem("v", "1.0");
response = responseUrl.query().toUtf8();
m_step++;
return true;
} else {
warning("QXmppSaslClientFacebook : Invalid step");
return false;
}
}
void UserManagementAPI::handleGitHubRegisterGet(HttpRequest &request, HttpResponse &response)
{
const QHash<QString, QSharedPointer<QString>> &queries = request.getHeader().getQueries();
QString code;
if (!queries.contains("code"))
{
respond(response, StatusCode::MissingParameters, "no code");
}
code = *queries["code"].data();
QString client_id = SettingsManager::getSingleton().get("GitHub/client_id").toString();
QString client_secret = SettingsManager::getSingleton().get("GitHub/client_secret").toString();
QUrl verificationUrl = QUrl("https://github.com/login/oauth/access_token");
QUrlQuery query;
query.addQueryItem("code", code);
query.addQueryItem("client_id", client_id);
query.addQueryItem("client_secret", client_secret);
verificationUrl.setQuery(query.query());
QNetworkRequest gitHubRequest;
gitHubRequest.setUrl(verificationUrl);
QByteArray replyData;
m_networkServiceAccessor.post(gitHubRequest, QByteArray(), replyData);
respondSuccess(response);
}
void QgsServerParameters::load( const QUrlQuery &query )
{
// clean query string first
QUrlQuery cleanQuery( query );
cleanQuery.setQuery( query.query().replace( '+', QStringLiteral( "%20" ) ) );
// load parameters
for ( const auto &item : cleanQuery.queryItems( QUrl::FullyDecoded ) )
{
const QgsServerParameter::Name name = QgsServerParameter::name( item.first );
if ( name >= 0 )
{
mParameters[name].mValue = item.second;
if ( ! mParameters[name].isValid() )
{
mParameters[name].raiseError();
}
}
else if ( item.first.compare( QLatin1String( "VERSION" ) ) == 0 )
{
const QgsServerParameter::Name name = QgsServerParameter::VERSION_SERVICE;
mParameters[name].mValue = item.second;
if ( ! mParameters[name].isValid() )
{
mParameters[name].raiseError();
}
}
else if ( ! loadParameter( item.first, item.second ) )
{
mUnmanagedParameters[item.first.toUpper()] = item.second;
}
}
}
static std::string qUrlQueryToPostData(const QUrlQuery & query) {
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
return toStdString(query.encodedQuery());
#else
return toUTF8(query.query(QUrl::FullyEncoded));
#endif
}
void Shop::OnEditPageFinished() {
QNetworkReply *reply = qobject_cast<QNetworkReply *>(QObject::sender());
QByteArray bytes = reply->readAll();
std::string page(bytes.constData(), bytes.size());
std::string hash = Util::GetCsrfToken(page, "forum_thread");
if (hash.empty()) {
QLOG_ERROR() << "Can't update shop -- cannot extract CSRF token from the page. Check if thread ID is valid.";
submitting_ = false;
return;
}
// now submit our edit
// holy shit give me some html parser library please
std::string title = Util::FindTextBetween(page, "<input type=\"text\" name=\"title\" id=\"title\" value=\"", "\" class=\"textInput\">");
if (title.empty()) {
QLOG_ERROR() << "Can't update shop -- title is empty. Check if thread ID is valid.";
submitting_ = false;
return;
}
QUrlQuery query;
query.addQueryItem("forum_thread", hash.c_str());
query.addQueryItem("title", title.c_str());
query.addQueryItem("content", requests_completed_ < shop_data_.size() ? shop_data_[requests_completed_].c_str() : "Empty");
query.addQueryItem("submit", "Submit");
QByteArray data(query.query().toUtf8());
QNetworkRequest request((QUrl(ShopEditUrl(requests_completed_).c_str())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QNetworkReply *submitted = app_.logged_in_nm().post(request, data);
new QReplyTimeout(submitted, kEditThreadTimeout);
connect(submitted, SIGNAL(finished()), this, SLOT(OnShopSubmitted()));
}
void Session::Request::onLoginPage() {
QNetworkReply *reply = qobject_cast<QNetworkReply*>(QObject::sender());
if (reply->error()) {
emit loginResult(0x01, "A network error occured: " + reply->errorString());
}
else {
QNetworkRequest request = reply->request();
// Extract CSF
const QString hash = getCSRFToken(reply->readAll());
const QString username = getAttribute(&request, LoginUsername).toString();
const QString password = getAttribute(&request, LoginPassword).toString();
QUrlQuery query;
query.addQueryItem("login_email", username);
query.addQueryItem("login_password", password);
query.addQueryItem("hash", hash);
query.addQueryItem("login", "Login");
QByteArray data(query.query().toUtf8());
request = createRequest(LoginUrl());
setAttribute(&request, LoginUsername, username);
setAttribute(&request, LoginPassword, password);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QNetworkReply *r = _manager->post(request, data);
connect(r, &QNetworkReply::finished, this, &Session::Request::Request::onLoginPageResult);
}
reply->deleteLater();
}
void writeGetTile( QgsServerInterface *serverIface, const QgsProject *project,
const QString &version, const QgsServerRequest &request,
QgsServerResponse &response )
{
Q_UNUSED( version );
const QgsWmtsParameters params( QUrlQuery( request.url() ) );
// WMS query
QUrlQuery query = translateWmtsParamToWmsQueryItem( QStringLiteral( "GetMap" ), params, project, serverIface );
// Get cached image
QgsAccessControl *accessControl = serverIface->accessControls();
QgsServerCacheManager *cacheManager = serverIface->cacheManager();
if ( cacheManager )
{
QgsWmtsParameters::Format f = params.format();
QString contentType;
QString saveFormat;
std::unique_ptr<QImage> image;
if ( f == QgsWmtsParameters::Format::JPG )
{
contentType = QStringLiteral( "image/jpeg" );
saveFormat = QStringLiteral( "JPEG" );
image = qgis::make_unique<QImage>( 256, 256, QImage::Format_RGB32 );
}
else
{
contentType = QStringLiteral( "image/png" );
saveFormat = QStringLiteral( "PNG" );
image = qgis::make_unique<QImage>( 256, 256, QImage::Format_ARGB32_Premultiplied );
}
QByteArray content = cacheManager->getCachedImage( project, request, accessControl );
if ( !content.isEmpty() && image->loadFromData( content ) )
{
response.setHeader( QStringLiteral( "Content-Type" ), contentType );
image->save( response.io(), qPrintable( saveFormat ) );
return;
}
}
QgsServerParameters wmsParams( query );
QgsServerRequest wmsRequest( "?" + query.query( QUrl::FullyDecoded ) );
QgsService *service = serverIface->serviceRegistry()->getService( wmsParams.service(), wmsParams.version() );
service->executeRequest( wmsRequest, response, project );
if ( cacheManager )
{
QByteArray content = response.data();
if ( !content.isEmpty() )
cacheManager->setCachedImage( &content, project, request, accessControl );
}
}
QNetworkReply* NetworkManager::sendRequest(const char* type)
{
QNetworkRequest request;
request.setUrl(QUrl(cache_.server));
request.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("application/x-www-form-urlencoded"));
QUrlQuery params;
params.addQueryItem("id", QString::number(cache_.id));
params.addQueryItem("sig", cache_.hash);
params.addQueryItem("req", QString(type).toUtf8());
if (cache_.logging)
{
Loggers::net->info() << params.query();
}
Loggers::net->trace() << "sending request " << type;
return manager_->post(request, params.query().toUtf8());
}
QString OAuth2::loginUrl()
{
QUrlQuery urlQuery;
urlQuery.addQueryItem("client_id", m_strClientID);
urlQuery.addQueryItem("response_type", m_strResponseType);
QString str = QString("%1?%2").arg(m_codeRequestURL).arg(urlQuery.query(QUrl::FullyEncoded));
// optional if you have registered redirectURL at Box
str += QString("&redirect_uri=%1").arg(QString(QUrl::toPercentEncoding(m_strRedirectURI)));
qDebug() << "Login URL" << str;
return str;
}
void tst_QUrlQuery::reconstructQuery()
{
QFETCH(QString, queryString);
QFETCH(QueryItems, items);
QUrlQuery query;
// add the items
for (QueryItems::ConstIterator it = items.constBegin(); it != items.constEnd(); ++it) {
query.addQueryItem(it->first, it->second);
}
QCOMPARE(query.query(), queryString);
}
void tst_QUrlQuery::encodedSetQueryItems()
{
QFETCH(QString, key);
QFETCH(QString, value);
QFETCH(QString, expectedQuery);
QFETCH(QString, expectedKey);
QFETCH(QString, expectedValue);
QFETCH(QUrl::ComponentFormattingOptions, encoding);
QUrlQuery query;
query.addQueryItem(key, value);
COMPARE_ITEMS(query.queryItems(encoding), QueryItems() << qItem(expectedKey, expectedValue));
QCOMPARE(query.query(encoding), expectedQuery);
}
void NetworkManager::messageSetConfirm(long id, const Callback<>& callback)
{
QNetworkRequest request;
request.setUrl(QUrl(cache_.server));
request.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("application/x-www-form-urlencoded"));
QUrlQuery params;
params.addQueryItem("id", QString::number(cache_.id));
params.addQueryItem("sig", cache_.hash);
params.addQueryItem("req", "MESSAGE_SHOWN");
params.addQueryItem("req_data", QString::number(id) + "#");
if (cache_.logging)
{
Loggers::net->info() << params.query();
}
QNetworkReply* reply = manager_->post(request, params.query().toUtf8());
if (reply)
{
auto handler = [=](QNetworkReply* reply)
{
if(reply->error() != QNetworkReply::NoError)
{
Loggers::net->error() << "gor error in MESSAGE_SHOWN";
if (callback)
{
callback(OpResult::RequestError);
}
}
};
restartTimer(reply, handler);
}
}
void tst_QUrlQuery::differentDelimiters()
{
QUrlQuery query;
query.setQueryDelimiters('(', ')');
{
// parse:
query.setQuery("foo(bar)hello(world)");
QueryItems expected;
expected << qItem("foo", "bar") << qItem("hello", "world");
COMPARE_ITEMS(query.queryItems(), expected);
COMPARE_ITEMS(query.queryItems(QUrl::FullyEncoded), expected);
COMPARE_ITEMS(query.queryItems(QUrl::PrettyDecoded), expected);
}
{
// reconstruct:
// note the final ')' is missing because there are no further items
QCOMPARE(query.query(), QString("foo(bar)hello(world"));
}
{
// set items containing the new delimiters and the old ones
query.clear();
query.addQueryItem("z(=)", "y(&)");
QCOMPARE(query.query(), QString("z%28=%29(y%28&%29"));
QUrlQuery copy = query;
QCOMPARE(query.query(), QString("z%28=%29(y%28&%29"));
copy.setQueryDelimiters(QUrlQuery::defaultQueryValueDelimiter(),
QUrlQuery::defaultQueryPairDelimiter());
QCOMPARE(copy.query(), QString("z(%3D)=y(%26)"));
}
}
QNetworkReply *NineGagRequest::createRequest(const QString §ion, const QString &lastId)
{
QUrl requestUrl("http://9gag.com/" + section);
if (!lastId.isEmpty()) {
#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
requestUrl.addQueryItem("id", lastId);
#else
QUrlQuery q;
q.addQueryItem("id", lastId);
requestUrl.setQuery(q.query());
#endif
}
return networkManager()->createGetRequest(requestUrl, NetworkManager::HTML);
}
void ShopSubmitter::BumpShop(ShopSubmission *submission) {
QUrlQuery query;
query.addQueryItem("forum_post", submission->data.value("forum_post").toString());
query.addQueryItem("content", BUMP_MESSAGE);
query.addQueryItem("post_submit", "Submit");
submission->timerId = startTimer(GetTimeout());
QNetworkRequest request(QUrl(ShopBumpUrl(submission->threadId)));
request.setAttribute((QNetworkRequest::Attribute) SHOP_DATA_THREAD, submission->threadId);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QNetworkReply *submitted = network->post(request, query.query().toUtf8());
submission->state = SHOP_SUBMISSION_BUMPING;
submission->currentReply = submitted;
connect(submitted, SIGNAL(finished()), this, SLOT(OnBumpFinished()));
}
void LoginTask::executeTask()
{
setStatus("Logging in...");
auto worker = MMC->qnam();
connect(worker, SIGNAL(finished(QNetworkReply*)), this, SLOT(processNetReply(QNetworkReply*)));
QUrl loginURL("https://login.minecraft.net/");
QNetworkRequest netRequest(loginURL);
netRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QUrlQuery params;
params.addQueryItem("user", uInfo.username);
params.addQueryItem("password", uInfo.password);
params.addQueryItem("version", "13");
netReply = worker->post(netRequest, params.query(QUrl::EncodeSpaces).toUtf8());
}
string CoordinatesRegister::sendCoordinates()
{
double dlng;
double dlat;
dlng = static_cast<double>(lng) / 1000000.0;
dlat = static_cast<double>(lat) / 1000000.0;
string response;
QEventLoop eventLoop;
QNetworkAccessManager mgr;
QUrlQuery params;
params.addQueryItem("lng", QString::number(dlng, 'f'));
params.addQueryItem("lat", QString::number(dlat, 'f'));
params.addQueryItem("new_pothole", "Submit");
QObject::connect(&mgr, SIGNAL(finished(QNetworkReply*)), &eventLoop, SLOT(quit()));
QNetworkRequest req(QUrl(host.c_str()));
req.setRawHeader("Content-Type", "application/x-www-form-urlencoded");
mgr.post(req, params.query(QUrl::FullyEncoded).toUtf8());
QNetworkReply * reply = mgr.get(req);
eventLoop.exec(); // blocks stack until "finished()" has been called
if (reply->error() == QNetworkReply::NoError) // Success
{
response = "Success: ";
response += reply->readAll().toStdString();
}
else // Failure
{
response = "Failure :";
response += reply->errorString().toStdString();
}
delete reply;
return response;
}
void LoginDialog::OnLoginPageFinished() {
QNetworkReply *reply = qobject_cast<QNetworkReply *>(QObject::sender());
if (reply->error()) {
DisplayError("Network error: " + reply->errorString());
return;
}
switch (ui->loginTabs->currentIndex()) {
case LOGIN_PASSWORD: {
QByteArray bytes = reply->readAll();
std::string page(bytes.constData(), bytes.size());
std::string hash = Util::GetCsrfToken(page, "hash");
if (hash.empty()) {
DisplayError("Failed to log in (can't extract form hash from page)");
return;
}
QUrlQuery query;
query.addQueryItem("login_email", EncodeSpecialCharacters(ui->emailLineEdit->text()));
query.addQueryItem("login_password", EncodeSpecialCharacters(ui->passwordLineEdit->text()));
query.addQueryItem("hash", QString(hash.c_str()));
query.addQueryItem("login", "Login");
QUrl url(POE_LOGIN_URL);
QByteArray data(query.query().toUtf8());
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QNetworkReply *logged_in = login_manager_->post(request, data);
connect(logged_in, SIGNAL(finished()), this, SLOT(OnLoggedIn()));
break;
}
case LOGIN_STEAM: {
if (!steam_login_dialog_)
InitSteamDialog();
steam_login_dialog_->show();
steam_login_dialog_->Init();
break;
}
case LOGIN_SESSIONID: {
LoginWithCookie(ui->sessionIDLineEdit->text());
break;
}
}
}
//******************************************************************************************
//function: doGet
//params: const QHash<QString, QString> ¶meters
//return: QJsonObject
//Description:
//******************************************************************************************
QJsonObject WSClient::Get(const QString &operation, const QHash<QString, QString> ¶meters)
{
QJsonObject response;
QUrlQuery values;
values.addQueryItem("operation", operation);
if (!this->lpzSessionId.isEmpty())
values.addQueryItem("sessionName", this->lpzSessionId);
QHashIterator<QString, QString> params(parameters);
while(params.hasNext()) {
params.next();
values.addQueryItem(params.key(), params.value());
}
if(!values.isEmpty()) {
QUrl url ( this->lpzURL );
url.setQuery(values.query());
if(url.isValid()) {
QJsonObject result = this->doGet(url);
#ifdef QT_DEBUG
//qDebug() << result;
#endif
if ( !result.isEmpty() ) {
return result;
}
else {
QJsonObject error;
error["code"] = "General";
error["message"] = "No data";
throw WSClientException( response );
}
}
}
return response;
}
void writeGetFeatureInfo( QgsServerInterface *serverIface, const QgsProject *project,
const QString &version, const QgsServerRequest &request,
QgsServerResponse &response )
{
Q_UNUSED( version );
const QgsWmtsParameters params( QUrlQuery( request.url() ) );
// WMS query
QUrlQuery query = translateWmtsParamToWmsQueryItem( QStringLiteral( "GetFeatureInfo" ), params, project, serverIface );
// GetFeatureInfo query items
query.addQueryItem( QgsWmsParameterForWmts::name( QgsWmsParameterForWmts::QUERY_LAYERS ), params.layer() );
query.addQueryItem( QgsWmsParameterForWmts::name( QgsWmsParameterForWmts::I ), params.i() );
query.addQueryItem( QgsWmsParameterForWmts::name( QgsWmsParameterForWmts::J ), params.j() );
query.addQueryItem( QgsWmsParameterForWmts::name( QgsWmsParameterForWmts::INFO_FORMAT ), params.infoFormatAsString() );
QgsServerParameters wmsParams( query );
QgsServerRequest wmsRequest( "?" + query.query( QUrl::FullyDecoded ) );
QgsService *service = serverIface->serviceRegistry()->getService( wmsParams.service(), wmsParams.version() );
service->executeRequest( wmsRequest, response, project );
}
const QByteArray& BtTrackerRequest::toRequestData() const
{
/* If not generated or out of date */
if(!requestDataGenerated) {
const_cast<QByteArray &>(requestData).clear();
/* generate */
QUrlQuery params;
params.addQueryItem("info_hash", urlencodeUnicode(info_hash));
params.addQueryItem("peer_id", urlencodeUnicode(peer_id));
params.addQueryItem("port", QByteArray::number(port));
params.addQueryItem("uploaded", QByteArray::number(uploaded));
params.addQueryItem("downloaded", QByteArray::number(downloaded));
params.addQueryItem("left", QByteArray::number(left));
if(!ip.isNull()) params.addQueryItem("ip", ip.toString());
switch(event) {
case BtTrackerDownloadEvent::started:
params.addQueryItem("event", "started");
break;
case BtTrackerDownloadEvent::completed:
params.addQueryItem("event", "completed");
break;
case BtTrackerDownloadEvent::stopped:
params.addQueryItem("event", "stopped");
break;
default:
/* same as empty */
break;
}
if(compact) params.addQueryItem("compact", compact?"1":"0");
else if(no_peer_id) params.addQueryItem("no_peer_id", no_peer_id?"1":"0");
if(numwant != 50) params.addQueryItem("numwant", QByteArray::number(numwant));
const_cast<QByteArray &>(requestData).append(params.query(QUrl::EncodeUnicode));
const_cast<bool &>(requestDataGenerated) = true;
}
return requestData;
}
void GoogleMap::executa(QString endereco) {
QTextStream qout(stdout);
QUrl uendereco;
uendereco.setScheme("http");
uendereco.setHost("maps.googleapis.com");
uendereco.setPath("/maps/api/geocode/json");
QUrlQuery qendereco;
qendereco.addQueryItem("address",QUrl::toPercentEncoding(endereco));
qendereco.addQueryItem("sensor","false");
qout << qendereco.query();
uendereco.setQuery(qendereco);
GerenciadorConexao->get(QNetworkRequest(uendereco));
}
void WarptenCli::execute(QString method, QString path, QUrlQuery &data) {
// reset variables
response = "";
errorType = QNetworkReply::NoError;
errorStr = "";
// prepare request content
QUrl url = baseUrl;
url.setPath(path);
QByteArray requestContent = data.query(QUrl::FullyEncoded).toUtf8();
if (method == "GET") {
url.setQuery(data);
}
// prepare connection
QNetworkRequest request = QNetworkRequest(url);
request.setRawHeader("User-Agent", "Agent name goes here");
if (method != "GET") {
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
}
if (method == "GET") {
networkManager->get(request);
}
else if (method == "PUT") {
networkManager->put(request, requestContent);
}
else if (method == "POST") {
networkManager->post(request, requestContent);
}
else if (method == "DELETE") {
networkManager->deleteResource(request);
}
qDebug() << method + " " + url.toString(QUrl::FullyEncoded) + " " + requestContent;
}
void Shop::OnEditPageFinished() {
QNetworkReply *reply = qobject_cast<QNetworkReply *>(QObject::sender());
QByteArray bytes = reply->readAll();
std::string page(bytes.constData(), bytes.size());
std::string hash = Util::GetCsrfToken(page, "forum_thread");
if (hash.empty()) {
QLOG_ERROR() << "Can't update shop -- cannot extract CSRF token from the page. Check if thread ID is valid."
<< "If you're using Steam to login make sure you use the same login method (steam or login/password) in Acquisition, Path of Exile website and Path of Exile game client."
<< "For example, if you created a shop thread while using Steam to log into the website and then logged into Acquisition with login/password it will not work."
<< "In this case you should either recreate your shop thread or use a correct login method in Acquisition.";
submitting_ = false;
return;
}
// now submit our edit
// holy shit give me some html parser library please
std::string title = Util::FindTextBetween(page, "<input type=\"text\" name=\"title\" id=\"title\" value=\"", "\" class=\"textInput\">");
if (title.empty()) {
QLOG_ERROR() << "Can't update shop -- title is empty. Check if thread ID is valid.";
submitting_ = false;
return;
}
QUrlQuery query;
query.addQueryItem("forum_thread", hash.c_str());
query.addQueryItem("title", Util::Decode(title).c_str());
query.addQueryItem("content", requests_completed_ < shop_data_.size() ? shop_data_[requests_completed_].c_str() : "Empty");
query.addQueryItem("submit", "Submit");
QByteArray data(query.query().toUtf8());
QNetworkRequest request((QUrl(ShopEditUrl(requests_completed_).c_str())));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QNetworkReply *submitted = app_.logged_in_nm().post(request, data);
new QReplyTimeout(submitted, kEditThreadTimeout);
connect(submitted, SIGNAL(finished()), this, SLOT(OnShopSubmitted()));
}
bool HttpAgent::async(const QObject * receiver, const char * method,
const QString& httpMethod, const Route& route, const QMap<QString, QVariant>& params,
const QMap<QString, QString>& filePaths,
const QMap<QString, QVariant>& argsToSlot,
const QObject * downloadProgressReceiver, const char * downloadProgressMethod
)
{
//在路由里取出url规则
QString routePattern = route.pattern();
qDebug() << "Services::async():" << routePattern;
//遍历所有"默认参数"（如：_format, _locale）, 做替换
QMapIterator<QString, QVariant> defaultParamIterator(defaultParams);
while ( defaultParamIterator.hasNext() )
{
defaultParamIterator.next();
QString toReplace = QString("{") + defaultParamIterator.key() + QString("}");
routePattern.replace( toReplace, defaultParamIterator.value().toString() );
qDebug() << "Services::async():replace("<< defaultParamIterator.key() << "," << defaultParamIterator.value() << "):" << routePattern;
}
qDebug() << "Services::async():" << routePattern;
//QString paramsString;
QUrlQuery query;
int paramCount = 0;
QMapIterator<QString, QVariant> i(params);
while ( i.hasNext() )
{
i.next();
/*if ( paramCount > 0 )
{
paramsString += "&";
}
paramsString += i.key();
paramsString += '=';
paramsString += i.value();*/
QString value = QString( QUrl::toPercentEncoding( i.value().toString(), "", "+" ) );
query.addQueryItem(i.key(), value);
//replace if found in urlPattern
QString toReplace = QString("{") + i.key() + QString("}");
routePattern.replace( toReplace, i.value().toString() );
paramCount++;
}
/*QString paramString = query.query(QUrl::FullyEncoded);
QByteArray ba = QUrl::toPercentEncoding(paramString, "&=", "+");
qDebug() << "BA ==== " << ba;*/
qDebug() << "Services::async(): paramsString: \"" << query.query(QUrl::FullyEncoded) << "\""; //paramsString << "\"";
QString host = !route.host().isEmpty() ? route.host() : defaultHost;
QString url(defaultProtocol + "://" + host + routePattern);
//req.setRawHeader(QByteArray("X-Requested-With"), QByteArray("XMLHttpRequest"));
QMap<QString, QString> headers;
headers[ "X-Requested-With" ] = "XMLHttpRequest";
return sendRequest(httpMethod,
url,
params, //query.query(QUrl::FullyEncoded), //paramsString, //"email="+loginName+"&password="+password,
filePaths,
headers,
receiver, method, argsToSlot, downloadProgressReceiver, downloadProgressMethod );
}
