Beispiel #1
0
void ParserHafasBinary::searchJourney(const QString &departureStation, const QString &arrivalStation, const QString &viaStation, const QDate &date, const QTime &time, Mode mode, int trainrestrictions)
{
    if (currentRequestState != FahrplanNS::noneRequest) {
        return;
    }

    currentRequestState = FahrplanNS::searchJourneyRequest;
    hafasContext.seqNr = "";
    lastJourneyResultList = NULL;

    QString trainrestr = getTrainRestrictionsCodes(trainrestrictions);

    QUrl uri = baseBinaryUrl;
    uri.addQueryItem("start", "Suchen");
    uri.addEncodedQueryItem("REQ0JourneyStopsS0ID", QUrl::toPercentEncoding("A=1@G=" + departureStation));
    uri.addEncodedQueryItem("REQ0JourneyStopsZ0ID", QUrl::toPercentEncoding("A=1@G=" + arrivalStation));

    if (!viaStation.isEmpty()) {
        uri.addQueryItem("REQ0JourneyStops1.0A", "1");
        uri.addQueryItem("REQ0JourneyStops1.0G", viaStation);
    }

    uri.addQueryItem("REQ0JourneyDate", date.toString("dd.MM.yyyy"));
    uri.addQueryItem("REQ0JourneyTime", time.toString("hh:mm"));
    uri.addQueryItem("REQ0HafasSearchForw", QString::number(mode));
    uri.addQueryItem("REQ0JourneyProduct_prod_list_1", trainrestr);
    uri.addQueryItem("h2g-direct", "11");
    sendHttpRequest(uri);
}
LegacyTuner::LegacyTuner( const RadioStation& station, const QString& password_md5 )
    : m_retry_counter( 0 ),
      m_station( station )
{
#ifdef WIN32
    static const char *PLATFORM = "win32";
#elif defined Q_WS_X11
    static const char *PLATFORM = "linux";
#elif defined Q_WS_MAC
    static const char *PLATFORM = "mac";
#else
    static const char *PLATFORM = "unknown";
#endif

    QUrl url;
    url.setScheme( "http" );
    url.setHost( "ws.audioscrobbler.com" );
    url.setPath( "/radio/handshake.php" );
    url.addEncodedQueryItem( "version", QCoreApplication::applicationVersion().toAscii() );
    url.addEncodedQueryItem( "platform", PLATFORM );
    url.addEncodedQueryItem( "username", QUrl::toPercentEncoding(lastfm::ws::Username) );
    url.addEncodedQueryItem( "passwordmd5", password_md5.toAscii() );
    url.addEncodedQueryItem( "language", iso3166() );

    QNetworkRequest request( url );
    QNetworkReply* reply = lastfm::nam()->get( request );
    connect( reply, SIGNAL(finished()), SLOT(onHandshakeReturn()) );
}
QNetworkReply* Echonest::Track::profileFromMD5( const QByteArray& md5 )
{
    QUrl url = Echonest::baseGetQuery( "track", "profile" );
    url.addEncodedQueryItem( "md5", md5 );
    url.addEncodedQueryItem( "bucket", "audio_summary" );
    
    qDebug() << "Creating profileFromMD5 URL" << url;
    return Echonest::Config::instance()->nam()->get( QNetworkRequest( url ) );
}
Beispiel #4
0
QNetworkReply* Echonest::Artist::suggest( const QString& name, int results )
{
    QUrl url = Echonest::baseGetQuery( "artist", "suggest" );
    QString realname = name;
    url.addEncodedQueryItem( "name", Echonest::escapeSpacesAndPluses( realname ) );
    url.addEncodedQueryItem( "results", QByteArray::number( results ) );

    return Echonest::Config::instance()->nam()->get( QNetworkRequest( url ) );
}
QNetworkReply* Echonest::Track::analyzeTrackMD5( const QByteArray& md5, bool wait )
{
    QUrl url = Echonest::baseGetQuery( "track", "analyze" );
    url.addEncodedQueryItem( "md5", md5 );
    url.addEncodedQueryItem( "bucket", "audio_summary" );
    url.addEncodedQueryItem( "wait", ( wait ? "true" : "false" ) );
    
    qDebug() << "Creating analyzeTrackMD5 URL" << url;
    return Echonest::Config::instance()->nam()->post( QNetworkRequest( url ), QByteArray() );
}
QNetworkReply* Echonest::Track::uploadURL( const QUrl& remoteURL, bool waitForResult )
{
    QUrl url = Echonest::baseGetQuery( "track", "upload" );
    url.addEncodedQueryItem( "url", remoteURL.toEncoded() );
    url.addEncodedQueryItem( "bucket", "audio_summary" );
    url.addEncodedQueryItem( "wait", ( waitForResult ? "true" : "false" ) );
    
    qDebug() << "Uploading URL:" << url;
    return Echonest::Config::instance()->nam()->post( QNetworkRequest( url ), QByteArray() );
}
QNetworkReply* Echonest::Artist::fetchTerms( Echonest::Artist::TermSorting sorting ) const
{
    QUrl url = setupQuery( "terms", 0, -1 );
    if( sorting == Echonest::Artist::Weight )
        url.addEncodedQueryItem( "sort", "weight" );
    else if( sorting == Echonest::Artist::Frequency )
        url.addEncodedQueryItem( "sort", "frequency" );
    
    return Echonest::Config::instance()->nam()->get( QNetworkRequest( url ) );
}
Beispiel #8
0
QNetworkReply* Echonest::Artist::search(const Echonest::Artist::SearchParams& params, Echonest::ArtistInformation information, bool limit)
{
    QUrl url = Echonest::baseGetQuery( "artist", "search" );

    Echonest::Artist::SearchParams::const_iterator iter = params.constBegin();
    for( ; iter < params.constEnd(); ++iter )
        url.addEncodedQueryItem( searchParamToString( iter->first ), Echonest::escapeSpacesAndPluses( iter->second.toString() ) );
    url.addEncodedQueryItem( "limit", limit ? "true" : "false" );
    addQueryInformation( url, information );

    return Echonest::Config::instance()->nam()->get( QNetworkRequest( url ) );
}
Beispiel #9
0
void Pastebin::trendingPastes()
{
    QUrl requestUrl(PASTEBIN_URL + PASTEBIN_POST);
    QUrl requestArgs;
    QNetworkRequest request(requestUrl);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");

    requestArgs.addEncodedQueryItem("api_dev_key", m_developerKey.toUtf8());
    requestArgs.addEncodedQueryItem("api_option",  "trends");

    m_networkAccess->post(request, requestArgs.encodedQuery());
}
Beispiel #10
0
QNetworkReply* Echonest::Track::uploadLocalFile( const QUrl& localFile, const QByteArray& data, bool waitForResult )
{
    QUrl url = Echonest::baseGetQuery( "track", "upload" );
    QFileInfo info( localFile.path() );
    url.addQueryItem( QLatin1String( "filetype" ), info.suffix() );
    url.addEncodedQueryItem( "bucket", "audio_summary" );
    url.addEncodedQueryItem( "wait", ( waitForResult ? "true" : "false" ) );
    QNetworkRequest request( url );
    
    request.setHeader( QNetworkRequest::ContentTypeHeader, QLatin1String( "application/octet-stream" ) );
//     qDebug() << "Uploading local file to" << url;
    return Echonest::Config::instance()->nam()->post( request, data );
}
Beispiel #11
0
void Pastebin::login()
{
    QUrl requestUrl(PASTEBIN_URL + PASTEBIN_LOGIN);
    QUrl requestArgs;
    QNetworkRequest request(requestUrl);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");

    requestArgs.addEncodedQueryItem("api_dev_key",       m_developerKey.toUtf8());
    requestArgs.addEncodedQueryItem("api_user_name",     QUrl::toPercentEncoding(m_userName));
    requestArgs.addEncodedQueryItem("api_user_password", QUrl::toPercentEncoding(m_password));

    m_networkAccess->post(request, requestArgs.encodedQuery());
}
Beispiel #12
0
void Pastebin::postPaste(const QByteArray& data, Language lang, const QString& title, const QString& expire, quint32 vis)
{
    QUrl requestUrl(PASTEBIN_URL + PASTEBIN_POST);
    QUrl requestArgs;
    QNetworkRequest request(requestUrl);
    QString langOpt = "text";

    if (lang != PlainText)
        langOpt = languageString(lang);
    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");

    requestArgs.addEncodedQueryItem("api_dev_key",           m_developerKey.toUtf8());
    requestArgs.addEncodedQueryItem("api_option",            "paste");
    requestArgs.addEncodedQueryItem("api_paste_expire_date", expire.toUtf8());
    requestArgs.addEncodedQueryItem("api_paste_private",     QString("%1").arg(vis).toUtf8());
    requestArgs.addEncodedQueryItem("api_paste_format",      langOpt.toUtf8());
    requestArgs.addEncodedQueryItem("api_paste_code",        QUrl::toPercentEncoding(QString(data).toAscii()));

    if (!title.isEmpty())
        requestArgs.addEncodedQueryItem("api_paste_name", QUrl::toPercentEncoding(title.toAscii()));

    if (!m_userKey.isEmpty())
        requestArgs.addEncodedQueryItem("api_user_key", m_userKey.toUtf8());

    m_networkAccess->post(request, requestArgs.encodedQuery());
}
QNetworkReply* Echonest::Artist::topHottt(Echonest::Artist::ArtistInformation information, int numResults, int offset, bool limit)
{
    QUrl url = Echonest::baseGetQuery( "artist", "top_hottt" );
    addQueryInformation( url, information );
    
    if( numResults > 0 )
        url.addEncodedQueryItem( "results", QByteArray::number( numResults ) );
    if( offset >= 0 ) 
        url.addEncodedQueryItem( "start", QByteArray::number( offset ) );
    
    url.addEncodedQueryItem( "limit", limit ? "true" : "false" );
    
    return Echonest::Config::instance()->nam()->get( QNetworkRequest( url ) );
}
void
SendLogsRequest::send()
{
    QUrl url;
    url.setScheme( "http" );
    url.setHost( "oops.last.fm" );
    url.setPath( "logsubmission/add" );
    url.addEncodedQueryItem( "username", QUrl::toPercentEncoding(Ws::Username) );
    #ifdef Q_WS_MAC
        url.addQueryItem( "platform", "macosx" );
    #elif defined WIN32
        url.addQueryItem( "platform", "win32" );
    #else
        url.addQueryItem( "platform", "linux" );
    #endif
    url.addQueryItem( "clientname", QCoreApplication::applicationName() );
    url.addQueryItem( "clientversion", QCoreApplication::applicationVersion() );

    QNetworkRequest request = QNetworkRequest( url );
    request.setRawHeader( "Content-Type", "multipart/form-data;boundary=8e61d618ca16" );
    request.setRawHeader( "Accept", "*/*" );

    m_data.append( postData( "usernotes", escapeString( m_usernotes ).toLatin1() ) );
    m_data.append( postData( "logs", m_logs.join(",").toLatin1() ) );
    m_data.append( "--8e61d618ca16--" ); // close the post request
    
    m_error = false;
    QNetworkReply *reply = (new WsAccessManager( this ))->post( request, m_data );
    
    connect( reply, SIGNAL( finished() ),
             this, SLOT( onFinished() ) );
    connect( reply, SIGNAL( error( QNetworkReply::NetworkError ) ),
             this, SLOT( onError( QNetworkReply::NetworkError ) ) );
}
Beispiel #15
0
void Pastebin::deletePaste(const QString& pasteKey)
{
    QUrl requestUrl(PASTEBIN_URL + PASTEBIN_POST);
    QUrl requestArgs;
    QNetworkRequest request(requestUrl);

    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
    requestArgs.addEncodedQueryItem("api_dev_key",   m_developerKey.toUtf8());
    requestArgs.addEncodedQueryItem("api_option",    "delete");
    requestArgs.addEncodedQueryItem("api_paste_key", pasteKey.toUtf8());

    if (!m_userKey.isEmpty())
        requestArgs.addEncodedQueryItem("api_user_key", m_userKey.toUtf8());

    m_networkAccess->post(request, requestArgs.encodedQuery());
}
QNetworkReply* Echonest::Artist::fetchSimilar(const Echonest::Artist::SearchParams& params, Echonest::Artist::ArtistInformation information, int numResults, int offset )
{
    QUrl url = Echonest::baseGetQuery( "artist", "similar" );
    addQueryInformation( url, information );
    
    if( numResults > 0 )
        url.addEncodedQueryItem( "results", QByteArray::number( numResults ) );
    if( offset >= 0 ) 
        url.addEncodedQueryItem( "start", QByteArray::number( offset ) );
        
    Echonest::Artist::SearchParams::const_iterator iter = params.constBegin();
    for( ; iter < params.constEnd(); ++iter )
        url.addQueryItem( QLatin1String( searchParamToString( iter->first ) ), iter->second.toString().replace( QLatin1Char( ' ' ), QLatin1Char( '+' ) ) );
    
    return Echonest::Config::instance()->nam()->get( QNetworkRequest( url ) );
}
void SongdisplayWidget::updateDisplay()
{
    if (currentTrack->isValid())
    {
        this->title->setText( currentTrack->getUrl().toString() );
        this->artist->setText( "artist" );
        this->album->setText( "album" );

        QUrl url = preferences->getBaseUrl();
        url.setPath( url.path() + "/track/image" );

        url.addEncodedQueryItem(
            QString( "track_id" ).toUtf8(),
            QString::number( currentTrack->getID() ).toUtf8()
        );

        QNetworkRequest request = QNetworkRequest( url );
        manager->get( request );
    }
    else
    {
        setDefaultIcon();
    }

}
Beispiel #18
0
void SeafileApiRequest::send()
{
    if (token_.size() > 0) {
        api_client_->setToken(token_);
    }

    switch (method_) {
    case METHOD_GET:
        url_.setQueryItems(params_);
        api_client_->get(url_);
        break;
    case METHOD_POST:
        QUrl params;
        for (int i = 0; i < params_.size(); i++) {
            QPair<QString, QString> pair = params_[i];
            params.addEncodedQueryItem(QUrl::toPercentEncoding(pair.first),
                                       QUrl::toPercentEncoding(pair.second));
        }
        api_client_->post(url_, params.encodedQuery());
        break;
    }

    connect(api_client_, SIGNAL(requestSuccess(QNetworkReply&)),
            this, SLOT(requestSuccess(QNetworkReply&)));

    connect(api_client_, SIGNAL(networkError(const QNetworkReply::NetworkError&, const QString&)),
            this, SIGNAL(networkError(const QNetworkReply::NetworkError&, const QString&)));

    connect(api_client_, SIGNAL(requestFailed(int)),
            this, SIGNAL(failed(int)));

    connect(api_client_, SIGNAL(sslErrors(QNetworkReply*, const QList<QSslError>&)),
            this, SLOT(onSslErrors(QNetworkReply*, const QList<QSslError>&)));

}
Beispiel #19
0
void QUrlProto::addEncodedQueryItem(const QByteArray &key,
                                    const QByteArray &value)
{
  QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
  if (item)
    item->addEncodedQueryItem(key, value);
}
Beispiel #20
0
LoginForm::LoginForm(QUrl url, QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::LoginForm)
{
    url.addEncodedQueryItem(OAUTH_CALLBACK,QByteArray(REDIRECT_URL).toPercentEncoding());
    qDebug() << url;

#ifdef Q_WS_MAEMO_5
        setAttribute(Qt::WA_Maemo5AutoOrientation);
        setAttribute(Qt::WA_Maemo5StackedWindow);
#endif

        QWebSettings* defaultSettings = QWebSettings::globalSettings();
        defaultSettings->setAttribute(QWebSettings::JavascriptEnabled, true);
        defaultSettings->setAttribute(QWebSettings::LocalContentCanAccessRemoteUrls, true);

    ui->setupUi(this);


    //    defaultSettings->setAttribute(QWebSettings::DeveloperExtrasEnabled,true);

    page = new JsConsoleWebPage(this);
    ui->webView->setPage(page);
    QWebViewSelectionSuppressor *suppressor = new QWebViewSelectionSuppressor(ui->webView);
    suppressor->enable();
    ui->webView->setInputMethodHints(Qt::ImhNoAutoUppercase|Qt::ImhNoPredictiveText);
    connect(page,SIGNAL(consoleMessage(QString)),this,SLOT(consoleMessage(QString)));
    connect(ui->webView, SIGNAL(urlChanged(QUrl)), this, SLOT(handleChange(QUrl)));


    ui->webView->load(url);

}
QNetworkReply* Echonest::Artist::topTerms(int numResults)
{
    QUrl url = Echonest::baseGetQuery( "artist", "top_terms" );
    url.addEncodedQueryItem( "results", QByteArray::number( numResults ) );
    
    return Echonest::Config::instance()->nam()->get( QNetworkRequest( url ) );
}
QNetworkReply* Echonest::Artist::fetchNews( bool highRelevanceOnly, int numResults, int offset ) const
{
    QUrl url = setupQuery( "news", numResults, offset );
    if( highRelevanceOnly ) // false is default
    url.addEncodedQueryItem( "high_relevance", "true" );
    
    return Echonest::Config::instance()->nam()->get( QNetworkRequest( url ) );
}
Beispiel #23
0
QUrl Echonest::Artist::setupQuery( const QByteArray& methodName, int numResults, int start ) const
{
    QUrl url = Echonest::baseGetQuery( "artist", methodName );
    if( !d->id.isEmpty() )
        url.addEncodedQueryItem( "id", d->id );
    else if( !d->name.isEmpty() ) {
        url.addEncodedQueryItem( "name", Echonest::escapeSpacesAndPluses( d->name ) );
    } else {
        qWarning() << "Artist method" << methodName << "called on an artist object without name or id!";
        return QUrl();
    }
    if( numResults > 0 )
        url.addEncodedQueryItem( "results", QByteArray::number( numResults ) );
    if( start >= 0 )
        url.addEncodedQueryItem( "start", QByteArray::number( start ) );

    return url;
}
QNetworkReply* Echonest::Artist::fetchSongs( Echonest::Artist::ArtistInformation idspace, bool limitToIdSpace, int numResults, int offset  ) const
{
    QUrl url = setupQuery( "songs", numResults, offset );
    addQueryInformation( url, idspace );
    if( limitToIdSpace )
        url.addEncodedQueryItem( "limit", "true" );
    
    return Echonest::Config::instance()->nam()->get( QNetworkRequest( url ) );
}
QUrl Echonest::Artist::setupQuery( const QByteArray& methodName, int numResults, int start ) const
{
    QUrl url = Echonest::baseGetQuery( "artist", methodName );
    if( !d->id.isEmpty() ) 
        url.addEncodedQueryItem( "id", d->id );
    else if( !d->name.isEmpty() ) {
        QString name = d->name;
        name.replace( QLatin1Char( ' ' ), QLatin1Char( '+' ) );
        url.addQueryItem( QLatin1String( "name" ), name );
    } else {
        qWarning() << "Artist method" << methodName << "called on an artist object without name or id!";
        return QUrl();
    }
    if( numResults > 0 )
        url.addEncodedQueryItem( "results", QByteArray::number( numResults ) );
    if( start >= 0 ) 
        url.addEncodedQueryItem( "start", QByteArray::number( start ) );
    
    return url;
}
QUrl QgsVirtualLayerDefinition::toUrl() const
{
  QUrl url;
  if ( !filePath().isEmpty() )
    url = QUrl::fromLocalFile( filePath() );

  Q_FOREACH ( const QgsVirtualLayerDefinition::SourceLayer& l, sourceLayers() )
  {
    if ( l.isReferenced() )
      url.addQueryItem( "layer_ref", QString( "%1:%2" ).arg( l.reference(), l.name() ) );
    else
      url.addEncodedQueryItem( "layer", QString( "%1:%4:%2:%3" ) // the order is important, since the 4th argument may contain '%2' as well
                               .arg( l.provider(),
                                     QString( QUrl::toPercentEncoding( l.name() ) ),
                                     l.encoding(),
                                     QString( QUrl::toPercentEncoding( l.source() ) ) ).toUtf8() );
  }

  if ( !query().isEmpty() )
  {
    url.addQueryItem( "query", query() );
  }

  if ( !uid().isEmpty() )
    url.addQueryItem( "uid", uid() );

  if ( geometryWkbType() == QgsWKBTypes::NoGeometry )
    url.addQueryItem( "nogeometry", "" );
  else if ( !geometryField().isEmpty() )
  {
    if ( hasDefinedGeometry() )
      url.addQueryItem( "geometry", QString( "%1:%2:%3" ).arg( geometryField() ). arg( geometryWkbType() ).arg( geometrySrid() ).toUtf8() );
    else
      url.addQueryItem( "geometry", geometryField() );
  }

  Q_FOREACH ( const QgsField& f, fields() )
  {
    if ( f.type() == QVariant::Int )
      url.addQueryItem( "field", f.name() + ":int" );
    else if ( f.type() == QVariant::Double )
      url.addQueryItem( "field", f.name() + ":real" );
    else if ( f.type() == QVariant::String )
      url.addQueryItem( "field", f.name() + ":text" );
  }

  return url;
}
Beispiel #27
0
QNetworkReply*
bitspace::ws::get( QMap<QString, QString> params )
{
    QUrl url = ::url();
    QMapIterator<QString, QString> i( params );
    while (i.hasNext()) {
        i.next();
        QByteArray const key = QUrl::toPercentEncoding( i.key() );
        QByteArray const value = QUrl::toPercentEncoding( i.value() );
        url.addEncodedQueryItem( key, value );
    }

    qDebug() << url;

    return nam()->get( QNetworkRequest(url) );
}
Beispiel #28
0
QNetworkReply*
bitspace::ws::get( const QString &method )
{
    QUrl url = ::url( method );
    QNetworkRequest request;
    request.setRawHeader("Accept", "application/json");
    request.setRawHeader("User-Agent", "curl/7.20.0 (x86_64-unknown-linux-gnu) libcurl/7.20.0 OpenSSL/0.9.8l zlib/1.2.3.7");
    if( bitspace::ws::ApiToken.isEmpty() )
        request.setRawHeader("Authorization", authorizationHeader() );
    else
    {
        url.addEncodedQueryItem( "user_credentials", QUrl::toPercentEncoding(bitspace::ws::ApiToken) );
    }
    request.setUrl( url );
    qDebug() << url;
    return nam()->get( request );
}
Beispiel #29
0
QNetworkReply*
bitspace::ws::post( QMap<QString, QString> params, const QString &method )
{
    QUrl url = ::url( method );
    QByteArray query;
    QMapIterator<QString, QString> i( params );
    while (i.hasNext()) {
        i.next();
        query += QUrl::toPercentEncoding( i.key() )
               + '='
               + QUrl::toPercentEncoding( i.value() )
               + '&';
    }
    QNetworkRequest request;
    if( bitspace::ws::ApiToken.isEmpty() )
        request.setRawHeader("Authorization", authorizationHeader() );
    else
    {
        url.addEncodedQueryItem( "user_credentials", QUrl::toPercentEncoding(bitspace::ws::ApiToken) );
    }
    request.setUrl( url );
    qDebug() << url;
    return nam()->post( request, query );
}
Beispiel #30
0
QString signature_make(QString http_verb, QString hostname, QString url, QMap<QString, QString> params, QString api_key){
	QString to_sign = http_verb + " " + hostname.remove(0, 7) + url + "\n";
	QUrl request = QUrl("", QUrl::TolerantMode);
	QMapIterator<QString, QString> i(params);
	while (i.hasNext()) {
		i.next();
		//QString val = i.value();
		//QUrl::toPercentEncoding(val);
		//to_sign += i.key() + "=" +  QUrl::toPercentEncoding(i.value(), "", " +;");
		request.addEncodedQueryItem(QByteArray(i.key().toStdString().c_str()), QUrl::toPercentEncoding(i.value(), "", "+; "));
		//request.addQueryItem(i.key(), i.value());
		//if(i.hasNext()) to_sign += "&";
	}
	
	QString str_req(request.toEncoded());
	to_sign += str_req.remove(0, 1);

	std::cout << to_sign.toStdString() << "\n";
	QString sig = hmac_sha1(to_sign, api_key);

	//QUrl::toPercentEncoding(sig);
	std::cout << "[signature_make] " << sig.toStdString() << "\n";
	return sig;
}