Friendiqa/source-linux/common/xhr.cpp

#include "xhr.h"

#include <QHttpPart>
#include <QTextCodec>
#include <QUrlQuery>
#include <QNetworkCookieJar>
#include <QNetworkCookie>
#include <QList>
#include <QDataStream>
#include "uploadableimage.h"

XHR *XHR::instance()
{
    static XHR xhr;
    return &xhr;
}

XHR::XHR(QObject *parent) : QObject(parent)
{
    request.setSslConfiguration(QSslConfiguration::defaultConfiguration());
}

void XHR::setUrl(QString url)
{
   if (url!=m_url) {
       m_url = url;
       emit urlChanged();
   }
}

void XHR::setLogin(QString login)
{
   if (login!=m_login) {
       m_login = login;
       emit loginChanged();
   }
}

void XHR::setFilename(QString filename)
{
   if (filename!=m_filename) {
       m_filename = filename;
       emit filenameChanged();
   }
}

void XHR::setDownloadtype(QString downloadtype)
{
   if (downloadtype!=m_downloadtype) {
       m_downloadtype = downloadtype;
       emit downloadtypeChanged();
   }
}

QString XHR::url() const
{
    return m_url;
}

QString XHR::login() const
{
    return m_login;
}

QString XHR::filename() const
{
    return m_filename;
}

QString XHR::downloadtype() const
{
    return m_downloadtype;
}

void XHR::setParam(QString name, QString value)
{
    params.insert(name, value);
}

void XHR::setImageFileParam(QString name, QString url)
{
    files.insert(name, url);
}

void XHR::clearParams()
{
    files.clear();
    params.clear();
}

void XHR::download()
{
    QUrl requrl(m_url);
    request.setUrl(requrl);
    reply = manager.get(request);
 //   reply->ignoreSslErrors();
    connect(reply, &QNetworkReply::readyRead,this, &XHR::onReadyRead);
    //connect(reply,SIGNAL(downloadProgress(qint64,qint64)), this,SLOT(updateDownloadProgress(qint64,qint64)));
    connect(reply, &QNetworkReply::finished,this, &XHR::onRequestFinished);
    connect(reply, &QNetworkReply::sslErrors, this, &XHR::onSSLError);
    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onReplyError(QNetworkReply::NetworkError)));
}

void XHR::get()
{
    QUrlQuery query;

    QHashIterator<QString, QString> i(params);
    while(i.hasNext()) {
        i.next();
        query.addQueryItem(i.key(), i.value());
    }

    QUrl requrl(m_url);
    requrl.setQuery(query);

    QByteArray loginData = m_login.toLocal8Bit().toBase64();
    QString headerData = "Basic " + loginData;
    request.setRawHeader("Authorization", headerData.toLocal8Bit());
//    QNetworkCookieJar* cJar = new QNetworkCookieJar;
//    manager.setCookieJar(cJar);

    request.setUrl(requrl);
    reply = manager.get(request);

    connect(reply, &QNetworkReply::finished, this, &XHR::onReplySuccess);
    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onReplyError(QNetworkReply::NetworkError)));
    connect(reply, &QNetworkReply::readyRead, this, &XHR::onReadyRead);
    connect(reply, &QNetworkReply::sslErrors, this, &XHR::onSSLError);
}

void XHR::post()
{
    qDebug() << "start post to " << m_url;
    QHttpMultiPart *multiPart = new QHttpMultiPart(QHttpMultiPart::FormDataType);

    QHashIterator<QString, QString> iparams(params);
    while(iparams.hasNext()) {
        iparams.next();
        qDebug() << "\t add param " << iparams.key() << " : " << iparams.value();
        QHttpPart textPart;
        textPart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"" + iparams.key() + "\""));


        textPart.setBody(iparams.value().toUtf8());
        multiPart->append(textPart);
    }

    UploadableImage uimg;
    QHashIterator<QString, QString> ifiles(files);
    while(ifiles.hasNext()) {
        ifiles.next();

        uimg.setSource(ifiles.value());
        qDebug() << "\t image: " << uimg.mimetype() << ", " << ifiles.key();

        QHttpPart imagePart;
        imagePart.setHeader(QNetworkRequest::ContentTypeHeader, QVariant(uimg.mimetype()));
        imagePart.setHeader(QNetworkRequest::ContentDispositionHeader, QVariant("form-data; name=\"" + ifiles.key() + "\"; filename=\""+uimg.filename()+"\""));
        imagePart.setBody(uimg.bytes());
        multiPart->append(imagePart);
    }

    QByteArray loginData = m_login.toLocal8Bit().toBase64();
    QString headerData = "Basic " + loginData;
    request.setRawHeader(QByteArray("Authorization"), headerData.toLocal8Bit());

    request.setUrl(m_url);
    reply = manager.post(request, multiPart);
    qDebug() << "\t request sent";
    connect(reply, &QNetworkReply::finished, this, &XHR::onReplySuccess);
    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(onReplyError(QNetworkReply::NetworkError)));
    connect(reply, &QNetworkReply::readyRead, this, &XHR::onReadyRead);
    connect(reply, &QNetworkReply::sslErrors, this, &XHR::onSSLError);
    qDebug() << "\t reply signals connected";
}

void XHR::onReplyError(QNetworkReply::NetworkError code)
{
    qDebug() << code;
    emit this->error( bufferToString(), (int) code);
    buffer.clear();
    reply->deleteLater();
}

void XHR::onReplySuccess()
{
    qDebug() << "!";
    emit this->success( bufferToString() );
    buffer.clear();
//    reply->deleteLater();
}

void XHR::onRequestFinished()
{
    // Save the file here
    //qDebug() << "buffer downloaded "<<buffer;
    if (buffer.isNull()){qDebug() << "File empty"<<m_url; buffer.clear(); emit this->error(m_downloadtype,1);}
    else  {QFile file(m_filename);
    file.open(QIODevice::WriteOnly);
    file.write(buffer);
    buffer.clear();
    file.close();
    emit this->downloaded(m_downloadtype);
    //reply->deleteLater();
    }
}

void XHR::onReadyRead()
{
    qDebug() << ".";
    buffer += reply->readAll();
//    QList<QNetworkCookie> list =  manager.cookieJar()->cookiesForUrl(m_url);
//        QFile f("/home/pankraz/cookie.txt");
//        f.open(QIODevice::ReadWrite);
//        for(int i = 0; i < list.size(); ++i){
//            QDataStream s(&f);
//            s << list.at(i).toRawForm();
//        }
//        f.close();

}

//void XHR::updateDownloadProgress(qint64 bytesRead, qint64 totalBytes)
//{
//    qDebug() << "Bytes: " << bytesRead<<" / "<<totalBytes;
    
//}

void XHR::onSSLError(const QList<QSslError> &errors)
{
    qDebug() << "XHR::onSSLError :" ;
    QListIterator<QSslError> ierrs(errors);
    while(ierrs.hasNext()) {
        qDebug() << "\t" <<  ierrs.next().errorString();
    }
}

QString XHR::bufferToString()
{
    return QTextCodec::codecForName("utf-8")->toUnicode(buffer);
}