apiserverconnection.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2019 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1

 
#ifndef SWIFT_CORE_AFV_CONNECTION_APISERVERCONNECTION_H
#define SWIFT_CORE_AFV_CONNECTION_APISERVERCONNECTION_H
 
#include <QEventLoop>
#include <QJsonDocument>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QObject>
#include <QString>
#include <QUuid>
 
#include "core/afv/dto.h"
#include "core/application.h"
#include "misc/logcategories.h"
#include "misc/logmessage.h"
#include "misc/slot.h"
 
namespace swift::core::afv::connection
{
    using ConnectionCallback = swift::misc::CSlot<void(bool)>;

    class CApiServerConnection : public QObject
    {
        Q_OBJECT
 
    public:
        enum ServerError
        {
            NoError
        };

        static const QStringList &getLogCategories();

        CApiServerConnection(const QString &address, QObject *parent = nullptr);

        bool isAuthenticated() const { return m_isAuthenticated; }

        void connectTo(const QString &username, const QString &password, const QString &client,
                       const QUuid &networkVersion, ConnectionCallback callback);

        PostCallsignResponseDto addCallsign(const QString &callsign);

        void removeCallsign(const QString &callsign);

        void updateTransceivers(const QString &callsign, const QVector<TransceiverDto> &transceivers);

        void forceDisconnect();

        QVector<StationDto> getAllAliasedStations();

        bool setUrl(const QString &url);

        const QString &getUrl() const { return m_addressUrl; }

        const QString &getUserName() const { return m_username; }
        const QString &getPassword() const { return m_password; }
        const QString &getClient() const { return m_client; }
        const QUuid &getNetworkVersion() const { return m_networkVersion; }
 
    private:
        template <typename TResponse>
        TResponse postNoRequest(const QString &resource)
        {
            if (!this->sendToNetworkIfAuthenticated())
            {
                // swift::misc::CLogMessage(this).debug(u"AFV not authenticated");
                return {};
            }
 
            this->checkExpiry();
 
            QUrl url(m_addressUrl);
            url.setPath(resource);
            QNetworkRequest request(url);
            request.setRawHeader("Authorization", "Bearer " + m_jwt);
 
            const QByteArray receivedData = this->postWithResponse(request);
            const QJsonDocument doc = QJsonDocument::fromJson(receivedData);
            const TResponse response = TResponse::fromJson(doc.object());
            return response;
        }

        template <typename TResponse>
        QVector<TResponse> getAsVector(const QString &resource)
        {
            if (!this->sendToNetworkIfAuthenticated())
            {
                // swift::misc::CLogMessage(this).debug(u"AFV not authenticated");
                return {};
            }
 
            this->checkExpiry();
 
            QUrl url(m_addressUrl);
            url.setPath(resource);
            QNetworkRequest request(url);
            request.setRawHeader("Authorization", "Bearer " + m_jwt);
 
            const QByteArray receivedData = this->getWithResponse(request);
            const QJsonDocument jsonDoc = QJsonDocument::fromJson(receivedData);
            QVector<TResponse> dtos;
            if (jsonDoc.isArray())
            {
                const QJsonArray rootArray = jsonDoc.array();
                for (const auto &o : rootArray)
                {
                    const QJsonObject d = o.toObject();
                    const TResponse dto = TResponse::fromJson(d);
                    dtos.push_back(dto);
                }
            }
            return dtos;
        }

        QByteArray getWithResponse(const QNetworkRequest &request);

        QByteArray postWithResponse(const QNetworkRequest &request, const QByteArray &data = {});

        void postNoResponse(const QString &resource, const QJsonDocument &json);

        void deleteResource(const QString &resource);

        void checkExpiry();

        void logReplyErrorMessage(const QNetworkReply *reply, const QString &addMsg = {});

        void logRequestDuration(const QNetworkReply *reply, const QString &addMsg = {});

        QEventLoop *newEventLoop();

        bool sendToNetworkIfAuthenticated() const;

        static bool isShuttingDown();
 
        QString m_addressUrl;
        QByteArray m_jwt;
        QString m_username;
        QString m_password;
        QUuid m_networkVersion;
        QString m_client;
        QDateTime m_expiryLocalUtc;
        qint64 m_serverToUserOffsetMs;
        bool m_isAuthenticated = false;
    };
} // namespace swift::core::afv::connection
 
#endif // SWIFT_CORE_AFV_CONNECTION_APISERVERCONNECTION_H