dto.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_DTO_H
#define SWIFT_CORE_AFV_DTO_H
 
#include <QByteArray>
#include <QJsonObject>
#include <QString>
#include <QUuid>
 
#include "msgpack.hpp"
 
namespace swift::core::afv
{
    struct CryptoDtoChannelConfigDto
    {
        QString channelTag;
        QByteArray aeadReceiveKey;
        QByteArray aeadTransmitKey;
        QByteArray hmacKey;
 
        QJsonObject toJson() const
        {
            QJsonObject json;
            json["channelTag"] = channelTag;
            json["aeadReceiveKey"] = QString(aeadReceiveKey);
            json["aeadTransmitKey"] = QString(aeadTransmitKey);
            json["hmacKey"] = QString(hmacKey);
            return json;
        }
 
        static CryptoDtoChannelConfigDto fromJson(const QJsonObject &json)
        {
            CryptoDtoChannelConfigDto dto;
 
            dto.channelTag = json.value("channelTag").toString();
            dto.aeadReceiveKey = QByteArray::fromBase64(json.value("aeadReceiveKey").toString().toLocal8Bit());
            dto.aeadTransmitKey = QByteArray::fromBase64(json.value("aeadTransmitKey").toString().toLocal8Bit());
            dto.hmacKey = QByteArray::fromBase64(json.value("hmacKey").toString().toLocal8Bit());
            return dto;
        }
    };
 
    struct VoiceServerConnectionDataDto
    {
        QString addressIpV4; // Example: 123.123.123.123:50000
        QString addressIpV6; // Example: 123.123.123.123:50000
        CryptoDtoChannelConfigDto channelConfig;
 
        QJsonObject toJson() const
        {
            QJsonObject json;
            json["addressIpV4"] = addressIpV4;
            json["addressIpV6"] = addressIpV6;
            json["channelConfig"] = channelConfig.toJson();
            return json;
        }
 
        static VoiceServerConnectionDataDto fromJson(const QJsonObject &json)
        {
            VoiceServerConnectionDataDto dto;
            dto.addressIpV4 = json.value("addressIpV4").toString();
            dto.addressIpV6 = json.value("addressIpV6").toString();
            dto.channelConfig = CryptoDtoChannelConfigDto::fromJson(json.value("channelConfig").toObject());
            return dto;
        }
    };
 
    struct PostCallsignResponseDto
    {
        // DataServerConnectionDataDto DataServer;
        VoiceServerConnectionDataDto VoiceServer;
        bool isValid = false;
 
        QJsonObject toJson() const
        {
            QJsonObject json;
            json["voiceserverauthdatadto"] = VoiceServer.toJson();
            // json["dataserverauthdatadto"] = DataServer.toJson();
            return json;
        }
 
        static PostCallsignResponseDto fromJson(const QJsonObject &json)
        {
            PostCallsignResponseDto dto;
            dto.VoiceServer = VoiceServerConnectionDataDto::fromJson(json.value("voiceServer").toObject());
            // dto.DataServer = DataServerConnectionDataDto::fromJson(json.value("dataServer").toObject());
            dto.isValid = true;
            return dto;
        }
    };
 
    struct TransceiverDto
    {
        quint16 id {};
        quint32 frequencyHz {};
        double LatDeg = 0.0;
        double LonDeg = 0.0;
        double HeightMslM = 0.0;
        double HeightAglM = 0.0;
        MSGPACK_DEFINE(id, frequencyHz, LatDeg, LonDeg, HeightMslM, HeightAglM)
 
        
        QJsonObject toJson() const
        {
            QJsonObject json;
            json["ID"] = id;
            json["Frequency"] = static_cast<int>(frequencyHz);
            json["LatDeg"] = LatDeg;
            json["LonDeg"] = LonDeg;
            json["HeightMslM"] = HeightMslM;
            json["HeightAglM"] = HeightAglM;
            return json;
        }
 
        static TransceiverDto fromJson(const QJsonObject &json)
        {
            TransceiverDto dto;
            dto.id = static_cast<quint16>(json.value("id").toInt());
            dto.frequencyHz = static_cast<quint32>(json.value("frequency").toInt());
            dto.LatDeg = json.value("latDeg").toDouble();
            dto.LonDeg = json.value("lonDeg").toDouble();
            dto.HeightMslM = json.value("heightMslM").toDouble();
            dto.HeightAglM = json.value("heightAglM").toDouble();
            return dto;
        }
    };
 
    struct StationDto
    {
        QUuid id;
        QString name;
        quint32 frequencyHz {};
        quint32 frequencyAliasHz {};
 
        static StationDto fromJson(const QJsonObject &json)
        {
            StationDto dto;
            dto.id = QUuid(json.value("id").toString());
            dto.name = json.value("name").toString();
            dto.frequencyHz = static_cast<quint32>(json.value("frequency").toInt());
            dto.frequencyAliasHz = static_cast<quint32>(json.value("frequencyAlias").toInt());
            return dto;
        }
    };
 
    struct HeartbeatDto
    {
        static QByteArray getDtoName() { return "HeartbeatDto"; }
        static QByteArray getShortDtoName() { return "H"; }
 
        std::string callsign; 
        MSGPACK_DEFINE(callsign)
    };
 
    struct HeartbeatAckDto
    {
        static QByteArray getDtoName() { return "HeartbeatAckDto"; }
        static QByteArray getShortDtoName() { return "HA"; }
 
        MSGPACK_DEFINE()
    };
 
    struct RxTransceiverDto
    {
        uint16_t id;
        uint32_t frequency;
        float distanceRatio;
        // std::string RelayCallsign;
 
        MSGPACK_DEFINE(id, frequency, distanceRatio /*, RelayCallsign*/)
    };
 
    struct TxTransceiverDto
    {
        TxTransceiverDto() = default;
 
        TxTransceiverDto(const TransceiverDto &dto) : id(dto.id) {}
 
        TxTransceiverDto(uint16_t value) : id(value) {}
 
        uint16_t id {}; 
        MSGPACK_DEFINE(id)
    };
 
    struct AudioTxOnTransceiversDto
    {
        static QByteArray getDtoName() { return "AudioTxOnTransceiversDto"; }
        static QByteArray getShortDtoName() { return "AT"; }
 
        std::string callsign;
        uint sequenceCounter;
        std::vector<char> audio;
        bool lastPacket;
        std::vector<TxTransceiverDto> transceivers;
        MSGPACK_DEFINE(callsign, sequenceCounter, audio, lastPacket, transceivers)
    };
 
    struct AudioRxOnTransceiversDto
    {
        static QByteArray getDtoName() { return "AudioRxOnTransceiversDto"; }
        static QByteArray getShortDtoName() { return "AR"; }
 
        std::string callsign;
        uint sequenceCounter;
        std::vector<char> audio;
        bool lastPacket;
        std::vector<RxTransceiverDto> transceivers;
        MSGPACK_DEFINE(callsign, sequenceCounter, audio, lastPacket, transceivers)
    };
 
    struct IAudioDto
    {
        QString callsign; 
        uint sequenceCounter; 
        QByteArray audio; 
        bool lastPacket; 
    };
} // namespace swift::core::afv
 
#endif // SWIFT_CORE_AFV_DTO_H