source: SMSSender/lib/libdatatypes/src/shttphelper.cpp @ 71:415b45c71663

#include "shttphelper.h"

#include <QBuffer>
#include <QDebug>
#include <QSslError>
#include <QThread>
#include <QUrl>

#include "exceptions/httpexceptions.h"

SHttpHelper::SHttpHelper() {
    // TODO: Proxy...

    http_ = new QHttp();

    connect(http_, SIGNAL(responseHeaderReceived(const QHttpResponseHeader&)),
            this, SLOT(responseHeaderReceived(const QHttpResponseHeader&)));
    connect(http_, SIGNAL(requestFinished(int, bool)),
            this, SLOT(httpRequestFinished(int, bool)));
    connect(http_, SIGNAL(sslErrors(const QList<QSslError>&)),
            this, SLOT(sslErrors(const QList<QSslError>&)));


    cookieManager_ = new SHttpCookieManager(http_);

    defaultHeader_ = new QHttpRequestHeader();
    defaultHeader_->setContentType("application/x-www-form-urlencoded");
    defaultHeader_->setValue("user-agent", "Mozilla/3.0 (compatible; SMSSender; http://www.gorrion.ch/p/smssender)"); //TODO: include version, if needed (don't generate the instance here, but in a central bchttpmanager or so)
}

SHttpHelper::~SHttpHelper() {
    delete defaultHeader_;
    delete cookieManager_;
    delete http_;
}


QHttp* SHttpHelper::http() const {
    return http_;
}
SHttpCookieManager* SHttpHelper::cookieManager() const {
    return cookieManager_;
}

QHttpRequestHeader SHttpHelper::defaultHeader(const QUrl& url) const {
    QHttpRequestHeader req = QHttpRequestHeader(*defaultHeader_); // return a copy, to not get touched by further modifications
    cookieManager_->addCookieToHeader(&req, url);

    return req;
}

QString SHttpHelper::get(const QString& destination, const QMap<QString, QString>& requests /* = QMap<QString, QString>() */) {
    waitForRequest(false); // Wait until a running request has been finished

    startRequest("GET", destination, requests, QMap<QString, QString>());
    waitForRequest();
    return getRequestResult();
}

QString SHttpHelper::post(const QString& destination, const QMap<QString, QString>& requests /* = QMap<QString, QString>() */,
        const QMap<QString, QString>& posts /* = QMap<QString, QString>() */)
{
    waitForRequest(false); // Wait until a running request has been finished

    startRequest("POST", destination, requests, posts);
    waitForRequest();
    return getRequestResult();
}

void SHttpHelper::startRequest(const QString& method, const QString& destination, const QMap<QString, QString>& requests /* = QMap<QString, QString>() */,
        const QMap<QString, QString>& posts /* = QMap<QString, QString>() */)
{
    requestResult_ = "";

    QUrl url_ = QUrl(destination);

    // Add request parameters to url_
    QMapIterator<QString, QString> i(requests);
    while (i.hasNext()){
        i.next();
        url_.addQueryItem(i.key(), i.value());
    }

    QString uri_ = url_.scheme() + "://" + url_.host() + url_.encodedPath() + "?" + url_.encodedQuery();
    //qDebug() << uri_;

    /* Create the request record */
    request_.finished = false;
    request_.method   = method;
    request_.posts    = getParamStr(posts);

    /* Do the request */
    doRequest(uri_);
}

int SHttpHelper::doRequest(const QString& destination) {
    QUrl url_ = QUrl(destination);

    /* Connection */
    QHttp::ConnectionMode mode = url_.scheme().toLower() == "https" ? QHttp::ConnectionModeHttps : QHttp::ConnectionModeHttp;
    http_->setHost(url_.host(), mode, url_.port(0));

    if (!url_.userName().isEmpty())
        http_->setUser(url_.userName(), url_.password());

    /* Header */
    QHttpRequestHeader header_ = defaultHeader(url_);
    header_.setValue("Host", url_.host());
    header_.setValue("Connection", "Keep-Alive");

    QByteArray path_ = url_.encodedPath();
    if (path_.isEmpty())
        path_ = "/";

    header_.setRequest(request_.method, path_ + "?" + url_.encodedQuery());

    /* Start the request */
    //qDebug() << destination;
    //qDebug() << header_.toString();
    //qDebug() << request_.posts;

    request_.httpRequestId = http_->request(header_, request_.posts.toUtf8()/*, req.buffer*/);
    qDebug() << "Started request " + QString::number(request_.httpRequestId) + ": " + request_.method + ": " + url_.path();

    return request_.httpRequestId;
}


QString SHttpHelper::getParamStr(const QMap<QString, QString>& params) {
    QString params_ = "";

    QMapIterator<QString, QString> i(params);
    while (i.hasNext()) {
        i.next();
        if (i.key().trimmed() != ""){
            params_ += i.key() + "=" + i.value() + "&";
        }
    }
    params_.remove(QRegExp("[&]$")); // remove last &

    return params_;
}

/*bool HttpAccountHelper::isRequestFinished(const int& requestId) const {
    return finishedRequests_.contains(requestId);
}*/

void SHttpHelper::waitForRequest(bool createLoopIfNotExisting) {
    if (!requestLoop_.isRunning() && !createLoopIfNotExisting){
        return;
    }

    qDebug() << "Waiting for the request to finish...";
    while (!request_.finished && thread()->isRunning()) {
        thread()->wait(100);
    }
/*    while (!request_.finished && thread()->isRunning()) {
        thread()->wait(100);
    }*/
//    requestLoop_.exec(QEventLoop::ExcludeUserInputEvents|QEventLoop::ExcludeSocketNotifiers|QEventLoop::WaitForMoreEvents);
    qDebug() << "The request finished -> continuing";
/*    while (!request_.finished) {
        qApp->processEvents(QEventLoop::Wai)(tForMore | QEventLoop::ExcludeUserInput);
    }
    qDebug() << "Starting request loop";
    requestLoop_.exec();
    qDebug() << "Request loop quitted";*/
}

QString SHttpHelper::getRequestResult() const {
    return requestResult_;
}

void SHttpHelper::responseHeaderReceived(const QHttpResponseHeader& responseHeader) {
    //qDebug() << responseHeader.statusCode() << " " << responseHeader.reasonPhrase();
    //qDebug() << responseHeader.values();

    switch (responseHeader.statusCode()) {
        case 200:
            break;                  // Ok

        case 301:                   // Moved Permanently
        case 302:                   // Found
        case 303:                   // See Other
        case 307:                   // Temporary Redirect
            qDebug() << "Have to redirect [" + QString::number(request_.httpRequestId) + "]";

            request_.httpRequestId = -1; // To avoid error in httpRequestFinished
            http_->abort();

            // Since the responseHeaderReceived-Slot could eventually not be called yet in cookieManager -> this would lead to a wrong header in doRequest
            cookieManager_->processResponseHeader(responseHeader);

            //cookiemanager has not handled the response yet...
            doRequest(responseHeader.value("location")); // Do the redirect
            break;

        default:
            throw Http::EReadException("Unknown response code!");
            break;
    }
}

void SHttpHelper::httpRequestFinished(int httpRequestId, bool error) {
     if (request_.httpRequestId != httpRequestId) {
         qDebug() << "Request [" + QString::number(httpRequestId) + "] finished (but is not parsed, since it is detached)";
         return;
     }

     qDebug() << "Quitting request loop";
     requestLoop_.quit();
     request_.finished = true;

     if (error) {
         qDebug() << "Request [" + QString::number(httpRequestId) + "] finished with an error: " + http_->errorString();
         throw Http::EReadException(http_->errorString()); // TODO: Perhaps this error has to be thrown in the waitForRequest by passing a status value to requestLoop_.exit()
     } else {
         qDebug() << "Request [" + QString::number(httpRequestId) + "] finished";
         requestResult_ = /*request.buffer.readAll()*/ http_->readAll();
         //qDebug() << requestResult_;
     }

     requestLoop_.processEvents();
 }

void SHttpHelper::sslErrors(const QList<QSslError>& errors) {
    QListIterator<QSslError> i(errors);
    while (i.hasNext()){
        QSslError err = i.next();
        qDebug() << "SSL-error: " + err.errorString();
    }
}