databasereader.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2015 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_CORE_DB_DATABASEREADER_H
#define SWIFT_CORE_DB_DATABASEREADER_H
 
#include <QDateTime>
#include <QJsonArray>
#include <QMap>
#include <QNetworkReply>
#include <QObject>
#include <QReadWriteLock>
#include <QString>
#include <QtGlobal>
 
#include "core/db/databasereaderconfig.h"
#include "core/swiftcoreexport.h"
#include "core/threadedreader.h"
#include "misc/db/dbinfolist.h"
#include "misc/network/url.h"
#include "misc/pq/time.h"
#include "misc/statusmessage.h"
#include "misc/valueobject.h"
 
class QNetworkReply;
class QFileInfo;
 
namespace swift::misc
{
    class CLogCategoryList;
}
namespace swift::core::db
{
    class SWIFT_CORE_EXPORT CDatabaseReader : public CThreadedReader
    {
        Q_OBJECT
 
    public:
        struct HeaderResponse
        {
        private:
            QDateTime m_lastModified; 
            int m_httpStatusCode = -1; 
            qulonglong m_contentLengthHeader = 0; 
            qint64 m_requestStarted = -1; 
            qint64 m_responseReceived = -1; 
            qint64 m_loadTimeMs = -1; 
            swift::misc::CStatusMessage m_message; 
            swift::misc::network::CUrl m_url; 
 
        public:
            bool hasTimestamp() const { return m_lastModified.isValid(); }
 
            bool isNewer(const QDateTime &ts) const
            {
                return m_lastModified.toMSecsSinceEpoch() > ts.toMSecsSinceEpoch();
            }
 
            bool isNewer(qint64 mSecsSinceEpoch) const { return m_lastModified.toMSecsSinceEpoch() > mSecsSinceEpoch; }
 
            const QDateTime &getLastModifiedTimestamp() const { return m_lastModified; }
 
            void setLastModifiedTimestamp(const QDateTime &updated) { m_lastModified = updated; }
 
            qulonglong getContentLengthHeader() const { return m_contentLengthHeader; }
 
            void setContentLengthHeader(qulonglong size) { m_contentLengthHeader = size; }
 
            bool hasErrorMessage() const
            {
                return m_message.getSeverity() == swift::misc::CStatusMessage::SeverityError;
            }
 
            bool hasWarningOrAboveMessage() const { return m_message.isWarningOrAbove(); }
 
            const swift::misc::CStatusMessage &lastWarningOrAbove() const { return m_message; }
 
            void setMessage(const swift::misc::CStatusMessage &lastErrorOrWarning) { m_message = lastErrorOrWarning; }
 
            const swift::misc::network::CUrl &getUrl() const { return m_url; }
 
            QString getUrlString() const { return m_url.toQString(); }
 
            void setUrl(const swift::misc::network::CUrl &url) { m_url = url; }
 
            bool isSharedFile() const;
 
            bool hasHttpStatusCode() const { return m_httpStatusCode >= 0; }
 
            int getHttpStatusCode() const { return m_httpStatusCode; }
 
            qint64 getLoadTimeMs() const { return m_loadTimeMs; }
 
            QString getLoadTimeString() const;
 
            QString getLoadTimeStringWithStartedHint() const;
 
            void setLoadTimeMs(qint64 deltaTime) { m_loadTimeMs = deltaTime; }
 
            void setValues(const QNetworkReply *nwReply);
        };
 
        struct JsonDatastoreResponse : public HeaderResponse
        {
        private:
            QJsonArray m_jsonArray; 
            int m_arraySize = -1; 
            int m_stringSize = 0; 
            bool m_restricted = false; 
 
        public:
            bool isEmpty() const { return m_jsonArray.isEmpty(); }
 
            bool isLoadedFromDb() const;
 
            bool isRestricted() const { return m_restricted; }
 
            void setRestricted(bool restricted) { m_restricted = restricted; }
 
            QJsonArray getJsonArray() const { return m_jsonArray; }
 
            int getArraySize() const { return m_jsonArray.size(); }
 
            void setJsonArray(const QJsonArray &value);
 
            void setStringSize(int size) { m_stringSize = size; }
 
            QString toQString() const;
 
            operator QJsonArray() const { return m_jsonArray; }
        };
 
        void readInBackgroundThread(swift::misc::network::CEntityFlags::Entity entities, const QDateTime &newerThan);
 
        swift::misc::network::CEntityFlags::Entity
        triggerLoadingDirectlyFromDb(swift::misc::network::CEntityFlags::Entity entities, const QDateTime &newerThan);
 
        swift::misc::network::CEntityFlags::Entity
        triggerLoadingDirectlyFromSharedFiles(swift::misc::network::CEntityFlags::Entity entities,
                                              bool checkCacheTsUpfront);
 
        bool hasReceivedOkReply() const;
 
        bool hasReceivedOkReply(QString &message) const;
 
        bool hasReceivedFirstReply() const;
 
        virtual swift::misc::network::CEntityFlags::Entity getSupportedEntities() const = 0;
 
        QString getSupportedEntitiesAsString() const;
 
        swift::misc::network::CEntityFlags::Entity
        maskBySupportedEntities(swift::misc::network::CEntityFlags::Entity entities) const;
 
        bool supportsAnyOfEntities(swift::misc::network::CEntityFlags::Entity entities) const;
 
        virtual QDateTime getCacheTimestamp(swift::misc::network::CEntityFlags::Entity entity) const = 0;
 
        bool hasCacheTimestampNewerThan(swift::misc::network::CEntityFlags::Entity entity,
                                        const QDateTime &threshold) const;
 
        virtual int getCacheCount(swift::misc::network::CEntityFlags::Entity entity) const = 0;
 
        virtual swift::misc::network::CEntityFlags::Entity getEntitiesWithCacheCount() const = 0;
 
        virtual swift::misc::network::CEntityFlags::Entity
        getEntitiesWithCacheTimestampNewerThan(const QDateTime &threshold) const = 0;
 
        bool hasDbInfoObjects() const;
 
        bool hasSharedInfoObjects() const;
 
        bool hasSharedFileHeader(const swift::misc::network::CEntityFlags::Entity entity) const;
 
        bool hasSharedFileHeaders(const swift::misc::network::CEntityFlags::Entity entities) const;
 
        QDateTime getLatestEntityTimestampFromDbInfoObjects(swift::misc::network::CEntityFlags::Entity entity) const;
 
        QDateTime
        getLatestEntityTimestampFromSharedInfoObjects(swift::misc::network::CEntityFlags::Entity entity) const;
 
        QDateTime getLatestSharedFileHeaderTimestamp(swift::misc::network::CEntityFlags::Entity entity) const;
 
        bool isSharedHeaderNewerThanCacheTimestamp(swift::misc::network::CEntityFlags::Entity entity) const;
 
        bool isSharedInfoObjectNewerThanCacheTimestamp(swift::misc::network::CEntityFlags::Entity entity) const;
 
        swift::misc::network::CEntityFlags::Entity
        getEntitesWithNewerHeaderTimestamp(swift::misc::network::CEntityFlags::Entity entities) const;
 
        swift::misc::network::CEntityFlags::Entity
        getEntitesWithNewerSharedInfoObject(swift::misc::network::CEntityFlags::Entity entities) const;
 
        const QString &getStatusMessage() const;
 
        void setSeverityNoWorkingUrl(swift::misc::CStatusMessage::StatusSeverity s) { m_severityNoWorkingUrl = s; }
 
        swift::misc::CStatusMessageList initFromLocalResourceFiles(bool inBackground);
 
        swift::misc::CStatusMessageList initFromLocalResourceFiles(swift::misc::network::CEntityFlags::Entity entities,
                                                                   bool inBackground);
 
        virtual swift::misc::CStatusMessageList readFromJsonFiles(const QString &dir,
                                                                  swift::misc::network::CEntityFlags::Entity whatToRead,
                                                                  bool overrideNewer) = 0;
 
        virtual bool readFromJsonFilesInBackground(const QString &dir,
                                                   swift::misc::network::CEntityFlags::Entity whatToRead,
                                                   bool overrideNewer) = 0;
 
        static const QStringList &getLogCategories();
 
        static void stringToDatastoreResponse(const QString &jsonContent,
                                              CDatabaseReader::JsonDatastoreResponse &datastoreResponse);
 
    signals:
        void swiftDbDataRead(bool success);
 
        void dataRead(swift::misc::network::CEntityFlags::Entity entities,
                      swift::misc::network::CEntityFlags::ReadState state, int number, const QUrl &url);
 
        void sharedFileHeaderRead(swift::misc::network::CEntityFlags::Entity entity, const QString &fileName,
                                  bool success);
 
        void databaseReaderMessages(const swift::misc::CStatusMessageList &messages);
 
        void entityDownloadProgress(swift::misc::network::CEntityFlags::Entity entity, int logId, int progress,
                                    qint64 current, qint64 max, const QUrl &url);
 
    protected:
        CDatabaseReaderConfigList m_config; 
        QString m_statusMessage; 
        bool m_1stReplyReceived = false; 
        mutable QReadWriteLock m_statusLock; 
        QNetworkReply::NetworkError m_1stReplyStatus = QNetworkReply::UnknownServerError; 
        QMap<swift::misc::network::CEntityFlags::Entity, HeaderResponse>
            m_sharedFileResponses; 
        swift::misc::CStatusMessage::StatusSeverity m_severityNoWorkingUrl =
            swift::misc::CStatusMessage::SeverityWarning; 
 
        CDatabaseReader(QObject *owner, const CDatabaseReaderConfigList &config, const QString &name);
 
        CDatabaseReader::JsonDatastoreResponse setStatusAndTransformReplyIntoDatastoreResponse(QNetworkReply *nwReply);
 
        swift::misc::db::CDbInfoList getDbInfoObjects() const;
 
        swift::misc::db::CDbInfoList getSharedInfoObjects() const;
 
        CDatabaseReaderConfig getConfigForEntity(swift::misc::network::CEntityFlags::Entity entity) const;
 
        swift::misc::network::CEntityFlags::Entity
        emitReadSignalPerSingleCachedEntity(swift::misc::network::CEntityFlags::Entity cachedEntities,
                                            bool onlyIfHasData);
 
        void emitAndLogDataRead(swift::misc::network::CEntityFlags::Entity entity, int number,
                                const JsonDatastoreResponse &res);
 
        virtual swift::misc::network::CUrl getDbServiceBaseUrl() const = 0;
 
        void logNoWorkingUrl(swift::misc::network::CEntityFlags::Entity entity);
 
        swift::misc::network::CUrl getBaseUrl(swift::misc::db::CDbFlags::DataRetrievalModeFlag mode) const;
 
        static const swift::misc::network::CUrl &getDbUrl();
 
        static QString fileNameForMode(swift::misc::network::CEntityFlags::Entity entity,
                                       swift::misc::db::CDbFlags::DataRetrievalModeFlag mode);
 
        static const QString &parameterLatestTimestamp();
 
        static QString dateTimeToDbLatestTs(const QDateTime &ts);
 
        static QString queryLatestTimestamp(const QDateTime &ts);
 
        virtual void synchronizeCaches(swift::misc::network::CEntityFlags::Entity entities) = 0;
 
        virtual void admitCaches(swift::misc::network::CEntityFlags::Entity entities) = 0;
 
        virtual void invalidateCaches(swift::misc::network::CEntityFlags::Entity entities) = 0;
 
        virtual bool hasChangedUrl(swift::misc::network::CEntityFlags::Entity entity,
                                   swift::misc::network::CUrl &oldUrlInfo,
                                   swift::misc::network::CUrl &newUrlInfo) const = 0;
 
        virtual void cacheHasChanged(swift::misc::network::CEntityFlags::Entity entities);
 
        static bool isChangedUrl(const swift::misc::network::CUrl &oldUrl,
                                 const swift::misc::network::CUrl &currentUrl);
 
        void startReadFromBackendInBackgroundThread(swift::misc::network::CEntityFlags::Entity entities,
                                                    swift::misc::db::CDbFlags::DataRetrievalModeFlag mode,
                                                    const QDateTime &newerThan = QDateTime());
 
        void receivedSharedFileHeader(QNetworkReply *nwReplyPtr);
 
        void receivedSharedFileHeaderNonClosing(QNetworkReply *nwReplyPtr);
 
        JsonDatastoreResponse transformReplyIntoDatastoreResponse(QNetworkReply *nwReply) const;
 
        HeaderResponse transformReplyIntoHeaderResponse(QNetworkReply *nwReply) const;
 
        bool setHeaderInfoPart(HeaderResponse &headerResponse, QNetworkReply *nwReply) const;
 
        void setReplyStatus(QNetworkReply::NetworkError status, const QString &message = "");
 
        void setReplyStatus(QNetworkReply *nwReply);
 
        bool overrideCacheFromFile(bool overrideNewerOnly, const QFileInfo &fileInfo,
                                   swift::misc::network::CEntityFlags::Entity entity,
                                   swift::misc::CStatusMessageList &msgs) const;
 
        void logParseMessage(const QString &entity, int size, int msElapsed,
                             const JsonDatastoreResponse &response) const;
 
        virtual void networkReplyProgress(int logId, qint64 current, qint64 max, const QUrl &url) override;
 
    private:
        virtual void read(swift::misc::network::CEntityFlags::Entity entities,
                          swift::misc::db::CDbFlags::DataRetrievalModeFlag mode, const QDateTime &newerThan) = 0;
    };
} // namespace swift::core::db
 
#endif // SWIFT_CORE_DB_DATABASEREADER_H