ItemDownloader.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Widgets
File: ItemDownloader
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/SoftwareService.h>
#include <NDEVR/BaseValues.h>
#include <NDEVR/TimeSpan.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/String.h>
#include <QObject>
#include <QByteArray>
class QNetworkRequest;
class QNetworkReply;
class QNetworkAccessManager;
namespace NDEVR
{
    class ProgressInfo;
    class ReplyTimeout;
    class String;
    class NDEVR_WIDGETS_API NetworkRequest : public QObject
    {
        Q_OBJECT
    public:
        virtual void close() = 0;
        virtual void abort() = 0;
        virtual bool isRunning() = 0;
        virtual bool start() = 0;
        virtual QByteArray data() = 0;
    signals:
        void socketStartedConnectingSignal(); 
        void requestSentSignal(); 
        void metaDataChangedSignal(); 
        void finishedSignal(); 
        void errorOccurredSignal(StringView error); 
        //void encryptedSignal();
        //void sslErrorsSignal(const QList<QSslError>& errors);
        //void preSharedKeyAuthenticationRequiredSignal(QSslPreSharedKeyAuthenticator* authenticator);
        //void redirectedSignal(const QUrl& url);
        void redirectAllowedSignal(); 
        void uploadProgressSignal(qint64 bytesSent, qint64 bytesTotal); 
        void downloadProgressSignal(qint64 bytesReceived, qint64 bytesTotal); 
    };

    class NDEVR_WIDGETS_API TimeRequest : public QObject
    {
        Q_OBJECT
    public:
        virtual Time serverTime() const = 0;
        virtual Time txTime() const = 0;
        virtual Time rxTime() const = 0;
        TimeSpan roundTripDelay() const
        {
            return rxTime() - txTime();
        }

        TimeSpan localClockOffset() const
        {
            return ((serverTime() - rxTime()) - (serverTime() - txTime())) / 2.0;
        }
    signals:
        void finishedSignal(); 
        void errorOccurredSignal(int error); 
    };

    struct WebTarget
    {
        String url; 
        String username; 
        String password; 
        uint02 port = Constant<uint02>::Invalid; 
    };

    class NDEVR_WIDGETS_API NetworkAccessManager : public SoftwareService
    {
    public:
        virtual NetworkRequest* downloadFromURL(const WebTarget& url) = 0;
        virtual NetworkRequest* uploadToURL(const WebTarget& request, const Buffer<uint01>& data) = 0;
        virtual NetworkRequest* uploadToURL(const WebTarget& request, const File& data) = 0;
        virtual TimeRequest* networkTimeFromURL(const StringView& url, uint02 port = 123) = 0;
    };

    class NDEVR_WIDGETS_API ItemDownloader : public QObject, public SoftwareServiceManager
    {
        Q_OBJECT
    protected:
        explicit ItemDownloader(const StringView& url, QObject* parent = nullptr);
        explicit ItemDownloader(QUrl url, QObject* parent = nullptr);
        virtual ~ItemDownloader();
    public:
        static ItemDownloader* GetItemDownloader(const StringView& url);
        [[nodiscard]] const QByteArray& downloadedData() const;
        [[nodiscard]] uint08 currentDownloadSize() const { return m_current_download_size; }
        [[nodiscard]] uint08 totalDownloadSize() const { return m_total_download_size; }
        [[nodiscard]] fltp08 downloadPercent() const;
        static void SetAccessManager(NetworkAccessManager* manager);
        static NetworkAccessManager* NetworkManager();
        static bool HasNetworkManager();
        static bool DownloadToFile(const StringView& url, const File& location, ProgressInfo& log);
        void start(TimeSpan timeout = TimeSpan(10.0));
    signals:
        void downloadFailedSignal(StringView); 
        void downloadedSignal(); 
        void percentChangedSignal(); 
    protected:
        void setNetworkRequest(const StringView& url);
    private slots:
        void fileDownloadedSlot();
        void downloadedErrorSlot(StringView error);
        void updateDownloadProgressSlot(qint64 ist, qint64 max);
    private:
        static NetworkAccessManager* s_web_ctrl; 
        static Dictionary<String, ItemDownloader*> s_current_downloads; 
        NetworkRequest* m_request; 
        ReplyTimeout* m_reply_timeout; 
        //QNetworkAccessManager* m_web_ctrl;
        QByteArray m_data; 
        uint08 m_last_percent = 0U; 
        uint08 m_current_download_size; 
        uint08 m_total_download_size; 
        bool m_failed; 
    };
 
}