QTNetworkRequest.h

Go to the documentation of this file.

#pragma once
#include <NDEVR/NtpClient.h>
#include <NDEVR/ItemDownloader.h>
#include <NDEVR/String.h>
#include <NDEVR/File.h>
#include <NDEVR/Thread.h>
#include <QNetworkRequest>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QFile>
namespace NDEVR
{
    static uint02 ntp_rx_port = 42912;
    class QtNetworkRequest : public NetworkRequest
    {
        Q_OBJECT
    public:
        QtNetworkRequest(const QNetworkRequest& request, QNetworkAccessManager* manager)
            : NetworkRequest()
            , m_request(request)
            , m_manager(manager)
        {
        
        }
        void setData(const Buffer<uint01>& data)
        {
            m_data = data;
        }
        void setData(const File& data)
        {
            m_file = data;
        }
        virtual void close() override
        {
            if (m_reply)
                m_reply->close();
        }
        virtual void abort() override
        {
            if (m_reply)
                m_reply->abort();
        }
        void setReply(QNetworkReply* reply)
        {
            m_reply = reply;
            //m_reply->setParent(this);
        #if QT_VERSION >= QT_VERSION_CHECK(6,0,0)
            connect(m_reply, &QNetworkReply::socketStartedConnecting, this
                , [this] {emit socketStartedConnectingSignal(); });
            connect(m_reply, &QNetworkReply::requestSent, this
                , [this] {emit requestSentSignal(); });
            connect(m_reply, &QNetworkReply::errorOccurred, this
                , [this](QNetworkReply::NetworkError error) 
            {
                emit errorOccurredSignal(cast<uint04>(error)); 
            });
        #else
            connect(m_reply, &QNetworkReply::error, this
                , [this](QNetworkReply::NetworkError error) {emit errorOccurredSignal(cast<uint04>(error)); });
        #endif
            connect(m_reply, &QNetworkReply::metaDataChanged, this
                , [this] {emit metaDataChangedSignal(); });
            connect(m_reply, &QNetworkReply::finished, this
                , [this] {emit finishedSignal(); });
            connect(m_reply, &QNetworkReply::redirectAllowed, this
                , [this] {emit redirectAllowedSignal(); });
            connect(m_reply, &QNetworkReply::uploadProgress, this
                , [this](qint64 bytesSent, qint64 bytesTotal) {emit uploadProgressSignal(bytesSent, bytesTotal); });
            connect(m_reply, &QNetworkReply::downloadProgress, this
                , [this](qint64 bytesSent, qint64 bytesTotal) {emit downloadProgressSignal(bytesSent, bytesTotal); });
            if (m_reply->error() != QNetworkReply::NoError)
            {
                emit errorOccurredSignal(cast<uint04>(m_reply->error()));
            }
            if (m_reply->isFinished())
            {
                emit finishedSignal();
            }
 
        }
        virtual bool isRunning() override
        {
            if (m_reply)
                return m_reply->isRunning();
            else
                return false;
        }
        virtual QByteArray data() override
        {
            if (m_reply)
                return m_reply->readAll();
            else
                return QByteArray();
        };
        virtual bool start() override
        {
            if (m_data.size() > 0)
            {
                QByteArray qdata(rcast<char*>(m_data.begin()), m_data.size());
                setReply(m_manager->put(m_request, qdata));
            }
            else if (m_file.size() > 0)
            {
                m_file.throwIfNotExist();
                QFile qfile(m_file.getAs<QString>());
                qfile.open(QIODeviceBase::ReadOnly);
                setReply(m_manager->put(m_request, &qfile));
                qfile.close();
            }
            else
            {
                setReply(m_manager->get(m_request));
            }
            return true;
        }
        QNetworkRequest m_request;
        QNetworkReply* m_reply = nullptr;
        QNetworkAccessManager* m_manager;
        Buffer<uint01> m_data;
        File m_file;
    };
    class QtNetworkAccessManager : public NetworkAccessManager
    {
    public:
        
        QNetworkRequest ConvertToRequest(const WebTarget& target)
        {
            QUrl urlup(target.url.getAs<QString>());
            if (target.password.size() > 0)
                urlup.setPassword(target.password.getAs<QString>());
            if(target.username.size() > 0)
                urlup.setUserName(target.username.getAs<QString>());
            if(!isNaN(target.port))
                urlup.setPort(cast<int>(target.port));
            return QNetworkRequest(urlup);
        }
        virtual NetworkRequest* downloadFromURL(const WebTarget& url) override
        {
            lib_assert(ThreadFunctions::IsPrimaryThread(), "Cannot download from non-main thread");
            if (m_manager == nullptr)
                m_manager = new QNetworkAccessManager();
            return new QtNetworkRequest(ConvertToRequest(url), m_manager);
        }
        virtual NetworkRequest* uploadToURL(const WebTarget& request, const Buffer<uint01>& data) override
        {
            if (m_manager == nullptr)
                m_manager = new QNetworkAccessManager();
            QtNetworkRequest* qtrequest = new QtNetworkRequest(ConvertToRequest(request), m_manager);
            qtrequest->setData(data);
            return qtrequest;
        }
        NetworkRequest* uploadToURL(const WebTarget& request, const File& data) override
        {
            if (m_manager == nullptr)
                m_manager = new QNetworkAccessManager();
            QtNetworkRequest* qtrequest = new QtNetworkRequest(ConvertToRequest(request), m_manager);
            qtrequest->setData(data);
            return qtrequest;
        }
        virtual TimeRequest* networkTimeFromURL(const String& url, uint02 port) override
        {
            NtpClient* client = new NtpClient(url, ntp_rx_port, port);
            return client;
        }
    protected:
        QNetworkAccessManager* m_manager = nullptr;
    };
}