void DeviceAccess::pushSales()
{
QByteArray data;
QNetworkAccessManager *manager = new QNetworkAccessManager(this);
connect(manager, SIGNAL(finished(QNetworkReply*)),
this, SLOT(replypushsalescomplete(QNetworkReply *)));
for(int i = 0; i < sales.size(); i++)
{
string s = sales.at(i).value("item").toStdString();
s.erase(
remove( s.begin(), s.end(), '\"' ),
s.end()
);
QNetworkRequest request;
request.setUrl(QUrl("http://vergeapp.com/api/v2/addsales.json"));
QUrlQuery params;
params.addQueryItem("firm", firm);
params.addQueryItem("outlet", outlet);
params.addQueryItem("product_name", QString::fromStdString(s));
params.addQueryItem("price", sales.at(i).value("price"));
params.addQueryItem("quantity", sales.at(i).value("qty"));
params.addQueryItem("reorder", "1");
params.addQueryItem("cost", "2");
qDebug() << params.toString();
manager->post(request, data.append(params.toString()));
}
}
void UsageTrackerPlugin::trackUsage()
{
QMap<QString, QString> parameters;
collectUsageParameters(parameters);
QUrlQuery query;
QMapIterator<QString, QString> iter(parameters);
while (iter.hasNext()) {
iter.next();
query.addQueryItem(iter.key(), iter.value());
}
// Add checksum
QString hash = getQueryHash(query.toString());
if (shouldSend(hash)) {
query.addQueryItem("hash", hash);
QUrl url("https://www.ratemode.ninja/opver?" + query.toString(QUrl::FullyEncoded));
QNetworkAccessManager *networkAccessManager = new QNetworkAccessManager();
// This will delete the network access manager instance when we're done
connect(networkAccessManager, SIGNAL(finished(QNetworkReply *)), this, SLOT(onFinished(QNetworkReply *)));
connect(networkAccessManager, SIGNAL(finished(QNetworkReply *)), networkAccessManager, SLOT(deleteLater()));
qDebug() << "Sending usage tracking as:" << url.toEncoded(QUrl::FullyEncoded);
networkAccessManager->get(QNetworkRequest(QUrl(url.toEncoded(QUrl::FullyEncoded))));
}
}
void DeviceAccess::processSales()
{
//QVector<QHash<QString, QString> >group;
if(transactiongroup.isEmpty())
return;
QByteArray data;
QNetworkAccessManager *manager = new QNetworkAccessManager(this);
for (int i = 0; i < transactiongroup.size(); i++)
{
currentTransactiongroupindex = i;
QVector<QHash<QString, QString> >group = transactiongroup.at(i);
QJsonArray jsonarray;
QString total;
QString receiptno;
QString time;
for (int j = 0; j < group.size(); j++)
{
QJsonObject jsonobject;
total = group.at(j).value("total");
receiptno = group.at(j).value("receiptno");
time = group.at(j).value("time");
jsonobject["item_id"] = QJsonValue(group.at(j).value("id"));
jsonobject["price"] = QJsonValue(group.at(j).value("price"));
jsonobject["quantity"] = QJsonValue(group.at(j).value("qty"));
jsonarray.append(QJsonValue(jsonobject));
}
qDebug() << "Json Array:" << jsonarray;
QNetworkRequest request;
QJsonDocument jdoc = QJsonDocument(jsonarray);
request.setUrl(QUrl("http://vergeapp.com/api/v2/addsales.json"));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QUrlQuery params;
params.addQueryItem("appid", appid);
params.addQueryItem("locid", locid);
params.addQueryItem("consumerkey", consumerkey);
params.addQueryItem("paid", total);
params.addQueryItem("payment_type", "cash");
params.addQueryItem("receipt", receiptno);
params.addQueryItem("trans_date", time);
params.addQueryItem("products", jdoc.toJson());
qDebug() << "json::" << jdoc.toJson();
qDebug() << "url---->" << params.toString();
QEventLoop loop;
QNetworkReply *reply = manager->post(request, data.append(params.toString()));
connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
loop.exec();
replypushsalescomplete(reply);
}
}
bool BSClient::isCaptcha(const QByteArray &byteArray)
{
if(byteArray.contains("<head>"))
{
CaptchaDialog dialog(QUrl("http://bs.to/captcha007.gif"));
if(dialog.exec() == QDialog::Accepted)
{
QNetworkRequest request(QUrl("http://bs.to/check-captcha.cgi"));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QUrlQuery postData;
postData.addQueryItem("sec", dialog.getText());
QNetworkReply *reply = m_manager->post(request, postData.toString(QUrl::FullyEncoded).toUtf8());
QEventLoop loop;
connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
loop.exec();
return true;
}
else
qApp->quit();
}
return false;
}
void GagBookManager::login(const QString &username, const QString &password)
{
Q_ASSERT(m_netManager);
if (m_loginReply != 0) {
m_loginReply->disconnect();
m_loginReply->deleteLater();
m_loginReply = 0;
}
if (m_isBusy != true) {
m_isBusy = true;
emit busyChanged();
}
QByteArray postData;
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
QUrlQuery postDataQuery;
postDataQuery.addQueryItem("username", username);
postDataQuery.addQueryItem("password", password);
postData = postDataQuery.toString(QUrl::FullyEncoded).toUtf8();
#else
QUrl postDataQuery;
postDataQuery.addQueryItem("username", username);
postDataQuery.addQueryItem("password", password);
postData = postDataQuery.encodedQuery();
#endif
m_loginReply = m_netManager->createPostRequest(QUrl("https://9gag.com/login"), postData);
connect(m_loginReply, SIGNAL(finished()), SLOT(onLoginFinished()));
}
bool Load::canHist(const Record *record)
{
QUrlQuery query;
query.addQueryItem("source", record->source);
query.addQueryItem("date", "0");
return getProc("hist?" + query.toString());
}
void CWizCrashReportDialog::on_btn_yes_clicked()
{
accept();
QString text = m_reports;
QtConcurrent::run([text](){
QString reportText = text;
const int maxSize = 1024 * 128 - 100;
if (reportText.size() > maxSize)
{
reportText.truncate(maxSize);
reportText.append("\n Wow! too may words, truncated!");
}
//
QString url = WizService::WizApiEntry::crashReportUrl();
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader,
"application/x-www-form-urlencoded");
QUrlQuery postData;
postData.addQueryItem("platform", "mac");
postData.addQueryItem("token", "");
postData.addQueryItem("subject", "Version: " + QString(WIZ_CLIENT_VERSION) + " UUID : " + WizGenGUIDLowerCaseLetterOnly());
postData.addQueryItem("error", reportText);
QNetworkAccessManager net;
QNetworkReply* reply = net.post(request, postData.toString(QUrl::FullyEncoded).toUtf8());
CWizAutoTimeOutEventLoop loop(reply);
loop.exec();
if (loop.error() != QNetworkReply::NoError)
{
qDebug() << "[Crash report]Upload failed!";
return;
}
rapidjson::Document d;
d.Parse<0>(loop.result().toUtf8().constData());
if (!d.HasMember("return_code"))
{
qDebug() << "[Crash report]Can not get return code ";
return;
}
int returnCode = d.FindMember("return_code")->value.GetInt();
if (returnCode != 200)
{
qDebug() << "[Crash report]Return code was not 200, error : " << returnCode << loop.result();
return;
}
else
{
qDebug() << "[Crash report]Upload OK";
}
});
}
void Load::loadHistory(const Record *record, QDate date)
{
QUrlQuery query;
query.addQueryItem("source", record->source);
query.addQueryItem("date", QString::number(date.isValid() ? QDateTime(date).toTime_t() : 0));
const Task &task = codeToTask("hist?" + query.toString());
enqueue(task);
}
void QPushbulletHandler::requestCreateContact(QString name, QString email)
{
QUrlQuery query;
query.addQueryItem("name", name);
query.addQueryItem("email", email);
m_CurrentOperation = CURRENT_OPERATION::CREATE_CONTACT;
postRequest(m_URLContacts, query.toString(QUrl::FullyEncoded).toUtf8());
}
void ApiRequest::post(const QUrlQuery & data) const
{
m_request->setUrl(url());
m_request->setHeader(QNetworkRequest::ContentTypeHeader,
QStringLiteral("application/x-www-form-urlencoded"));
QNetworkReply * reply =
m_networkManager->post(*m_request, data.toString(QUrl::FullyEncoded).toUtf8());
connect(reply, &QNetworkReply::finished, this, &ApiRequest::processReply);
}
QNetworkReply* Connection::connectToAccount(const QString &email,
const QString &password,
PMS::SimpleResultHandler handler)
{
QUrlQuery query;
query.addQueryItem("api_subscription[email]", email);
query.addQueryItem("api_subscription[password]", password);
query.addQueryItem("api_subscription[client_name]", qApp->applicationName());
query.addQueryItem("api_subscription[client_vendor]", qApp->organizationName());
QNetworkRequest request(apiUrl_);
request.setHeader(QNetworkRequest::KnownHeaders::ContentTypeHeader, "application/x-www-form-urlencoded");
auto reply = client_->post(request, query.toString().toUtf8());
QPointer<QObject> self = this;
QObject::connect(reply, &QNetworkReply::finished, [self, this, reply, handler]()
{
if (!self)
return;
try
{
checkReply(reply);
auto str = reply->readAll().trimmed();
QRegExp apiKeyRx("^API key: (.+)$");
if (apiKeyRx.exactMatch(str))
{
setApiKey(apiKeyRx.cap(1));
handler(Error());
return;
}
QRegExp errorRx("^Error Code: (\\d+)$");
if (errorRx.exactMatch(str))
{
int code = errorRx.cap(1).toInt();
QString error;
switch (code)
{
case 1: error = tr("Client details not set"); break;
case 2: error = tr("Unknown user"); break;
case 3: error = tr("Invalid password"); break;
case 4: error = tr("Not allowed for given User and their System Role"); break;
default: error = tr("Unknown error"); break;
}
throw Error(Error::Authorization, error);
}
throw Error(Error::Authorization, tr("Unknown error"));
}
catch (const Error& err)
{
handler(err);
}
});
}
void QPushbulletHandler::requestDeviceUpdate(QString deviceID, QString newNickname)
{
QString url = m_URLDevices.toString();
url.append("/");
url.append(deviceID);
QUrl modifiedURL(url);
QUrlQuery query;
query.addQueryItem("nickname", newNickname);
m_CurrentOperation = CURRENT_OPERATION::UPDATE_DEVICE;
postRequest(modifiedURL, query.toString(QUrl::FullyEncoded).toUtf8());
}
void QPushbulletHandler::requestPushUpdate(QString pushID, bool dismissed)
{
QUrlQuery query;
query.addQueryItem("dismissed", dismissed ? "true" : "false");
QString url = m_URLPushes.toString();
url.append("/");
url.append(pushID);
QUrl modifiedURL(url);
m_CurrentOperation = CURRENT_OPERATION::PUSH_UPDATE;
postRequest(modifiedURL, query.toString(QUrl::FullyEncoded).toUtf8());
}
void QPushbulletHandler::requestContactUpdate(QString contactID, QString newName)
{
QString url = m_URLContacts.toString();
url.append("/");
url.append(contactID);
QUrl modifiedURL(url);
QUrlQuery query;
query.addQueryItem("name", newName);
m_CurrentOperation = CURRENT_OPERATION::UPDATE_CONTACT;
postRequest(modifiedURL, query.toString(QUrl::FullyEncoded).toUtf8());
}
void QPushbulletHandler::requestDeviceDelete(QString deviceID)
{
QString url = m_URLDevices.toString();
url.append("/");
url.append(deviceID);
QUrl modifiedURL(url);
m_CurrentOperation = CURRENT_OPERATION::DELETE_DEVICE;
QUrlQuery query;
query.setQueryDelimiters(' ', '&');
query.addQueryItem("-X", "DELETE");
postRequest(modifiedURL, query.toString(QUrl::FullyEncoded).toUtf8());
}
void Session::Request::loginWithOAuth(const QString &authorizationCode) {
QUrl url("https://webdev2.office.grindinggear.com/oauth/token");
QUrlQuery query;
query.addQueryItem("client_id", "test");
query.addQueryItem("client_secret", "testpassword");
query.addQueryItem("code", authorizationCode);
query.addQueryItem("grant_type", "authorization_code");
QNetworkRequest request = createRequest(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QNetworkReply *r = _manager->post(request, query.toString().toUtf8());
connect(r, &QNetworkReply::finished, this, &Session::Request::Request::onOAuthResultPath);
}
QNetworkReply * TwitterQueryUtil::post(QNetworkAccessManager &network,
const QString &path,
const std::map<QByteArray, QByteArray> ¶meters,
const std::map<QByteArray, QByteArray> &postData,
const Account &account)
{
QNetworkRequest request {createPostRequest(path, parameters, postData, account)};
QUrlQuery postDataQuery {};
for (const std::pair<QByteArray, QByteArray> ¶meter : postData) {
postDataQuery.addQueryItem(QLatin1String(parameter.first), QLatin1String(parameter.second));
}
return network.post(request, postDataQuery.toString(QUrl::FullyEncoded).toLatin1());
}
void TelemetryWorker::processOneItem(const std::shared_ptr<AnalyticsUserEvent> &item) {
LOG_INFO << "Reporting action:" << item->getActionString();
QUrlQuery query;
buildQuery(item, m_UserAgentId, query);
QString customVarsStr = QString::fromLatin1("{\"1\":[\"OS_type\",\"%1\"],\"2\":[\"OS_version\",\"%2\"],\"3\":[\"Xpiks_version\",\"%3\"],\"4\":[\"UI_language\",\"%4\"]}");
#if (QT_VERSION >= QT_VERSION_CHECK(5, 4, 0))
query.addQueryItem(QLatin1String("_cvar"),
customVarsStr
.arg(QSysInfo::productType())
.arg(QSysInfo::productVersion())
.arg(XPIKS_VERSION_STRING)
.arg(m_InterfaceLanguage));
#else
query.addQueryItem(QLatin1String("_cvar"),
customVarsStr
# ifdef Q_OS_WIN
.arg(QString("windows"))
# elsif Q_OS_DARWIN
.arg(QString("osx"))
# else
.arg(QString("Linux QT<5.4"))
# endif
.arg(QString("-"))
.arg(XPIKS_VERSION_STRING)
.arg(m_InterfaceLanguage));
#endif
#ifdef QT_DEBUG
LOG_DEBUG << "Telemetry request:" << m_ReportingEndpoint << query.toString();
#endif
#if defined(TELEMETRY_ENABLED) && !defined(INTEGRATION_TESTS) && !defined(UI_TESTS)
sendOneReport(m_ReportingEndpoint, query.toString());
#endif
}
void QmlMarketplace::send(const QString& endpoint, const QString& success, const QString& fail, QNetworkAccessManager::Operation method, AccountManagerAuth::Type authType, const QUrlQuery & request) {
auto accountManager = DependencyManager::get<AccountManager>();
const QString URL = "/api/v1/marketplace/";
JSONCallbackParameters callbackParams(this, success, fail);
accountManager->sendRequest(URL + endpoint + "?" + request.toString(),
authType,
method,
callbackParams,
QByteArray(),
NULL,
QVariantMap());
}
void OAuth2::GetTokensFromCode()
{
QNetworkRequest request(m_AccessRequestURL);
QUrlQuery urlQuery;
urlQuery.addQueryItem("grant_type", "authorization_code");
urlQuery.addQueryItem("code", m_code);
urlQuery.addQueryItem("client_id", m_strClientID);
urlQuery.addQueryItem("client_secret", m_clientSecret);
QByteArray postData;
postData.append(urlQuery.toString(QUrl::FullyEncoded));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
m_network->PostLoginRequest(request, postData);
}
void AboutDialog::processSubscribe_()
{
// Set query
QUrlQuery urlQuery;
urlQuery.addQueryItem("emailaddress", subscribeLineEdit_->text());
QUrl url = QUrl("http://www.vpaint.org/subscribeext.php");
QNetworkRequest networkRequest(url);
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
// Send query
reply_ = networkManager_->post(networkRequest, urlQuery.toString(QUrl::FullyEncoded).toUtf8());
// Connection to process reply
connect(reply_, SIGNAL(finished()), this, SLOT(processFinished_()));
}
QByteArray SnapSocket::createRequest(const QByteArray& method, const QByteArray& path, const QJsonObject& content) const
{
QByteArray ret;
if (method == "GET") {
QUrlQuery uq;
for(auto it = content.constBegin(), itEnd = content.constEnd(); it!=itEnd; ++it) {
uq.addQueryItem(it.key(), it.value().toString());
}
const auto query = uq.toString().toUtf8();
ret = createRequest(method, path+'?'+query, QByteArray());
} else if(method == "POST")
ret = createRequest(method, path, QJsonDocument(content).toJson());
else
qWarning() << "unknown method" << method;
return ret;
}
void CloudAuthenticator::refreshTimeout()
{
qCDebug(dcCloud()) << "Authenticator: Refresh authentication token for" << m_username;
QUrlQuery query;
query.addQueryItem("grant_type", "refresh_token");
query.addQueryItem("refresh_token", m_refreshToken);
QNetworkRequest request(m_url);
QByteArray data = QString(m_clientId + ":" + m_clientSecret).toUtf8().toBase64();
QString header = "Basic " + data;
request.setRawHeader("Authorization", header.toLocal8Bit());
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QNetworkReply *reply = m_networkManager->post(request, query.toString().toUtf8());
m_refreshTokenRequests.append(reply);
}
void FeedFetcher::getNewToken()
{
QString url = "https://www.googleapis.com/oauth2/v4/token";
QUrlQuery postData;
postData.addQueryItem("client_id", clientId);
postData.addQueryItem("client_secret", clientSecret);
postData.addQueryItem("refresh_token", settings->value("refreshToken", "").toString());
postData.addQueryItem("grant_type", "refresh_token");
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
tokenManager.post(request, postData.toString(QUrl::FullyEncoded).toUtf8());
//qDebug() << "Ask for a new tocken";
connect(&tokenManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(decodeNewToken(QNetworkReply*)), Qt::UniqueConnection);
}
void Extend::get(const ExtendItem& extendItem, const QString& broadcastToken,
const QString& userSession)
{
QNetworkRequest rq;
rq.setUrl(QUrl("http://watch.live.nicovideo.jp/api/usepoint/" + extendItem.broadID));
rq.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QVariant&& postData = makePostData(userSession);
rq.setHeader(QNetworkRequest::CookieHeader, postData);
rq.setRawHeader("accept-language", "ja");
QUrlQuery params;
params.addQueryItem("num", extendItem.num);
// params.addQueryItem("remain", "%2D1");
params.addQueryItem("date", QString::number(QDateTime::currentDateTimeUtc().toTime_t()));
params.addQueryItem("item", extendItem.item);
params.addQueryItem("code", QUrl::toPercentEncoding(extendItem.code));
params.addQueryItem("token", QUrl::toPercentEncoding(broadcastToken));
requestPost(rq, params.toString(QUrl::FullyEncoded).toUtf8());
}
void Api::post(QString url, QVariantMap parameters)
{
DEBUG << Q_FUNC_INFO;
m_future.cancel();
QUrlQuery postData;
QStringList keys = parameters.keys();
for(int i = 0; i < keys.count(); i++)
{
QString key = keys.at(i);
QString value = QVariant(parameters.value(key)).toString();
postData.addQueryItem(key, value);
}
QNetworkRequest request(url);
request.setHeader(QNetworkRequest::ContentTypeHeader,
"application/x-www-form-urlencoded");
m_networkManager->post(request, postData.toString(QUrl::FullyEncoded).toUtf8());
}
void Tracker::track( const QUrlQuery& query )
{
QNetworkRequest req;
req.setHeader( QNetworkRequest::UserAgentHeader, m_userAgent );
if ( m_operation == QNetworkAccessManager::PostOperation )
{
QByteArray data = query.toString( QUrl::FullyEncoded ).toLatin1();
if ( data.size() > 8192 )
{
qWarning( "%d exceeds 8192 byte payload size limit for POST operations.", data.size() );
}
req.setHeader( QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded" );
req.setUrl( m_endpoint );
m_replies.insert( m_nam->post( req, data ) );
}
else if ( m_operation == QNetworkAccessManager::GetOperation )
{
QUrl url = m_endpoint;
QUrlQuery q = query;
if ( m_cacheBusting )
{
q.addQueryItem( "z", QString::number( qrand() % 100000000 ) );
}
url.setQuery( q );
req.setUrl( url );
int size = url.toString( QUrl::FullyEncoded ).size();
if ( size > 2000 )
{
qWarning( "%d exceeds 2000 byte payload size limit for GET operations.", size );
}
m_replies.insert( m_nam->get( req ) );
}
}
void YoutubeProtocolHandler::execute(const QUrl &uri, bool queue)
{
QStringList parts = uri.path().split('/');
QUrlQuery query;
if (parts.count()) {
query.addQueryItem("action", "play_video");
query.addQueryItem("videoid", parts.last());
}
if (query.isEmpty()) {
return;
}
PlaylistItem item;
item.setFile("plugin://plugin.video.youtube/?" + query.toString());
Player *player = Kodi::instance()->videoPlayer();
if (queue) {
player->playlist()->addItems(item);
} else {
player->open(item);
}
}
void NicoLiveManager::login(QString mail, QString pass)
{
if(mLoginManager!=nullptr) delete mLoginManager;
mLoginManager = new QNetworkAccessManager(this);
connect(mLoginManager, SIGNAL(finished(QNetworkReply*)),
this, SLOT(loginFinished(QNetworkReply*)));
QNetworkRequest rq(QUrl("https://secure.nicovideo.jp/secure/login?site=nicolive"));
rq.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
QUrlQuery params;
params.addQueryItem("next_url", "");
params.addQueryItem("show_button_facebook", "0");
params.addQueryItem("show_button_twitter", "0");
params.addQueryItem("nolinks", "0");
params.addQueryItem("_use_valid_error_code", "0");
params.addQueryItem("mail", QUrl::toPercentEncoding(mail));
params.addQueryItem("password", QUrl::toPercentEncoding(pass));
mLoginManager->post(rq, params.toString(QUrl::FullyEncoded).toUtf8());
}
void Parse::login( QString username, QString password )
{
setHostURI(Cloud::getValueFor("serverURL",""));
if (!isReady()) return;
QUrlQuery postData;
postData.addQueryItem("username", username);
postData.addQueryItem("password", password);
setEndPoint( "login?" + postData.toString() ); //TODO improve me : not use endpoint to give url encoded params
initHeaders();
if (registerInstallationOnLogin)
setRawHeader("X-Parse-Installation-Id", "1");
m_conn = connect(this, &BaaS::replyFinished, [=]( QJsonDocument json){
disconnect(m_conn);
if ( isLastRequestSuccessful() ) { //getHttpCode() == 201 ){
QJsonObject obj = json.object();
sessionId = obj.value("sessionToken").toString();
userId = obj.value("objectId").toString();
userName = obj.value("username").toString();
// qWarning()<<obj;
qWarning() << "objectId" << obj.value("objectId").toString();
qWarning() << "sessionToken" << sessionId;
setRawHeader("X-Parse-Session-Token", sessionId.toUtf8());
emit loginChanged();
}
} );
request( BaaS::GET);
}
