Initial commit

Lts/Proxies/CombatNetRadio/WebSocketInterface/Messages/client_message.cpp

@@ -0,0 +1,210 @@
+/**
+  * @RDE_HEADER@
+  * The ClientMessage class is an abstract base class for concrete ClientMessage objects
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hannes Fritsche, SLSE, 2017-09-07
+  */
+#include "client_message.h"
+#include "reply_message.h"
+#include "exercise_manager.h"
+#include "WebSocketInterface/Messages/message_transmitter.h"
+#include "WebSocketInterface/Messages/reply_message.h"
+#include "WebSocketInterface/json_keys.h"
+
+#include <QtCore/QJsonDocument>
+#include <QtCore/QUuid>
+#include <chrono>
+
+/*
+ *python testing:
+
+import websocket
+import json
+import time
+ws = websocket.create_connection("ws://127.0.0.1:2081")
+d = { 'type' : 'getEssentials', 'uuid': 'blub' }
+ws.send(json.dumps(d))
+d = { 'type' : 'getConfigCNR', 'uuid': 'blub' }
+ws.send(json.dumps(d))
+d = { 'type' : 'getPositionsCNR', 'uuid': 'blub', 'data': {'repeat': 10}}
+ws.send(json.dumps(d))
+while True:
+  ws.recv()
+
+*/
+
+namespace CombatNetRadio
+{
+namespace WebSocketInterface
+{
+
+using namespace JsonKeys;
+
+namespace Messages
+{
+
+// ####### ClientMessage begin #######
+ClientMessage *ClientMessage::create(const QString &message, NGL::INGLLogger &logger)
+{
+  ClientMessage *result = nullptr;
+  QJsonParseError error;
+  QJsonDocument doc = QJsonDocument::fromJson(message.toUtf8(), &error);
+
+  if (error.error != QJsonParseError::NoError)
+  {
+    ERROR_LOG(logger) << "Got message which is not JSON conform: " << message;
+    return new InvalidMessage(QString(), QStringLiteral("Got message which is not JSON conform"));
+  }
+
+  QJsonObject obj       = doc.object();
+
+  QJsonObject dataPart  = obj.value(DATA()).toObject();
+  QString type          = obj.value(TYPE()).toString();
+  QString uuid          = obj.value(UUID_()).toString();
+
+  if (type.isEmpty())
+  {
+    ERROR_LOG(logger) << "Got message without type: " << message;
+    result = new InvalidMessage(uuid, QStringLiteral("Message has no type"));
+  }
+  else if (type == ERROR_() && dataPart.contains(ERROR_MESSAGE()) && dataPart.contains(ERROR_CLASS()) && dataPart.contains(UUID_()))
+  {
+    ERROR_LOG(logger) << "Got error message: " << QJsonDocument(dataPart).toJson();
+    return nullptr;
+  }
+  else if (uuid.isEmpty())
+  {
+    ERROR_LOG(logger) << "Got message without uuid: " << message;
+    result = new InvalidMessage(QString(), QStringLiteral("Got message without uuid"));
+  }
+  else if (type == GET_ESSENTIALS())
+    result = new GetEssentialsMessage(type, uuid, dataPart);
+  else if (type == GET_CONFIG_CNR())
+    result = new GetConfigCnrMessage(type, uuid, dataPart);
+  else if (type == GET_POSITIONS_CNR())
+    result = new GetPositionsCnrMessage(type, uuid, dataPart);
+  else if (type == ALIVE_REQUEST())
+    result = new AliveRequest(type, uuid, dataPart);
+  else if (type == OK())
+    result = new OkMessageC(type, uuid, dataPart);
+  else if (type == CONFIG_CNR())
+    result = new ConfigCnrMessageC(type, uuid, dataPart);
+
+  if (result == nullptr)
+  {
+    ERROR_LOG(logger) << "Got message with invalid type: " << message;
+    result = new InvalidMessage(uuid, QStringLiteral("Invalid type"));
+  }
+
+  if (!result->hasValidData())
+  {
+    ERROR_LOG(logger) << "Got message with invalid data part: " << message;
+    delete result;
+    result = new InvalidMessage(uuid, QStringLiteral("Has invalid data part"));
+  }
+
+  return result;
+}
+
+ClientMessage::ClientMessage(const QString &type, const QString &uuid, const QJsonObject &data)
+  : m_type(type)
+  , m_uuid(uuid)
+  , m_data(data)
+{
+}
+
+// ####### ClientMessage end #######
+
+// ####### InvalidMessage begin #######
+void InvalidMessage::process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter)
+{
+  Q_UNUSED(exerciseManager);
+  ErrorMessage::ErrorData errorData;
+
+  errorData.errorClass    = 1; // ??????????
+  errorData.errorMessage  = m_errorText;
+  errorData.uuid          = m_uuid;
+
+  transmitter->addMessage(ErrorMessage(errorData));
+}
+
+bool InvalidMessage::hasValidData() const
+{
+  // always true because there is no data part
+  return true;
+}
+
+// ####### InvalidMessage end #######
+
+
+// ####### GetEssentialsMessage begin #######
+void GetEssentialsMessage::process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter)
+{
+  using namespace Messages;
+  transmitter->addMessage(exerciseManager->trainingAreaData(m_uuid));
+
+  for (const ReplyMessage &currentMessage : exerciseManager->radioStations(m_uuid))
+    transmitter->addMessage(currentMessage);
+
+  QString requester      = m_data.value(REQUESTER()).toString();
+  bool    isActiveClient = m_data.value(ISACTIVECLIENT()).toBool();
+
+  transmitter->addMessage(exerciseManager->configCnr(m_uuid));
+  exerciseManager->onConfigCnrSent((qint64) transmitter, m_uuid, requester, isActiveClient);
+}
+
+// ####### GetEssentialsMessage end #######
+
+// ####### GetConfigCnrMessage begin #######
+void GetConfigCnrMessage::process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter)
+{
+  QString requester      = m_data.value(REQUESTER()).toString();
+  bool    isActiveClient = m_data.value(ISACTIVECLIENT()).toBool();
+  transmitter->addMessage(exerciseManager->configCnr(m_uuid));
+  exerciseManager->onConfigCnrSent((qint64) transmitter, m_uuid, requester, isActiveClient);
+}
+
+// ####### GetConfigCnrMessage end #######
+
+void OkMessageC::process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter)
+{
+  exerciseManager->onConfigCnrReceived((qint64) transmitter, m_uuid);
+}
+
+// ####### GetPositionsCnrMessage begin #######
+void GetPositionsCnrMessage::process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter)
+{
+  transmitter->addMessage(exerciseManager->positionsCnr(m_uuid));
+
+  int   updateInterval = m_data.value(REPEAT()).toInt();
+  if (updateInterval > 0)
+    exerciseManager->setPositionsUpdateInterval(std::chrono::seconds(updateInterval));
+  else
+    exerciseManager->stopPositionsUpdate();
+}
+
+bool GetPositionsCnrMessage::hasValidData() const
+{
+  return m_data.contains(REPEAT());
+}
+
+// ####### GetPositionsCnrMessage end #######
+
+// ####### GetPositionsCnrMessage begin #######
+void AliveRequest::process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter)
+{
+  Q_UNUSED(exerciseManager);
+  transmitter->addMessage(AliveResponse(m_uuid));
+}
+
+void ConfigCnrMessageC::process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter)
+{
+  exerciseManager->onConfigCnrProcessed((qint64) transmitter, m_uuid, m_data);
+}
+
+// ####### GetPositionsCnrMessage end #######
+} // namespace Messages
+} // namespace WebSocketInterface
+} // namespace CombatNetRadio

Lts/Proxies/CombatNetRadio/WebSocketInterface/Messages/client_message.h

@@ -0,0 +1,116 @@
+/**
+  * @RDE_HEADER@
+  * The ClientMessage class is an abstract base class for concrete ClientMessage objects
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hannes Fritsche, SLSE, 2017-09-07
+  */
+#pragma once
+
+#include <QtCore/QJsonObject>
+
+#include "logger.h"
+
+namespace CombatNetRadio
+{
+class ExerciseManager;
+
+namespace WebSocketInterface
+{
+
+namespace Messages
+{
+class MessageTransmitter;
+
+class ClientMessage
+{
+public:
+  static ClientMessage *create(const QString &message, NGL::INGLLogger &logger);
+
+  virtual void process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter) = 0;
+  virtual bool hasValidData() const = 0;
+  virtual ~ClientMessage() = default;
+  ClientMessage(const QString &type, const QString &uuid, const QJsonObject &data = QJsonObject());
+
+protected: // attributes
+  const QString     m_type;
+  const QString     m_uuid;
+  const QJsonObject m_data;
+
+}; // class ClientMessage
+
+
+class GetEssentialsMessage final : public ClientMessage
+{
+public:
+  void process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter) override;
+  bool hasValidData() const override { return true; }
+
+  using ClientMessage::ClientMessage;
+}; // class GetEssentialsMessage
+
+class GetConfigCnrMessage final : public ClientMessage
+{
+public:
+  void process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter) override;
+  bool hasValidData() const override { return true; }
+
+  using ClientMessage::ClientMessage;
+}; // GetConfigCnrMessage
+
+class GetPositionsCnrMessage final : public ClientMessage
+{
+public:
+  void process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter) override;
+  bool hasValidData() const override;
+
+  using ClientMessage::ClientMessage;
+}; // PositionsCnrMessage
+
+class AliveRequest final : public ClientMessage
+{
+public:
+  void process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter) override;
+  bool hasValidData() const override { return true; }
+
+  using ClientMessage::ClientMessage;
+};
+
+
+class OkMessageC final : public ClientMessage
+{
+public:
+  void process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter) override;
+  bool hasValidData() const override { return true; }
+
+  using ClientMessage::ClientMessage;
+};
+
+class ConfigCnrMessageC final : public ClientMessage
+{
+public:
+  void process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter) override;
+  bool hasValidData() const override { return true; }
+
+  using ClientMessage::ClientMessage;
+}; // ConfigCnrMessageC
+
+class InvalidMessage final : public ClientMessage
+{
+  friend class ClientMessage;
+
+public:
+  void process(ExerciseManager *exerciseManager, MessageTransmitter *transmitter) override;
+  bool hasValidData() const override;
+
+  using ClientMessage::ClientMessage;
+
+private: // attributes
+  QString m_errorText;
+
+}; // class InvalidMessage
+
+} // namespace Messages
+} // namespace WebSocketInterface
+} // namespace CombatNetRadio

Lts/Proxies/CombatNetRadio/WebSocketInterface/Messages/message_handler.cpp

@@ -0,0 +1,49 @@
+/**
+  * @RDE_HEADER@
+  * The MessageHandler class processes messages from the client an creates appropriate replys
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hannes Fritsche, SLSE, 2017-09-07
+  */
+#include "message_handler.h"
+#include "message_transmitter.h"
+#include "client_message.h"
+#include <memory>
+
+namespace CombatNetRadio
+{
+namespace WebSocketInterface
+{
+namespace Messages
+{
+
+MessageHandler::MessageHandler(ExerciseManager *exerciseManager)
+  : m_exerciseManager(exerciseManager)
+  , m_logger(getLogger("MessageHandler"))
+{
+  Q_ASSERT(exerciseManager);
+}
+
+void MessageHandler::onNewTextMessage(MessageTransmitter *transmitter, const QString &message)
+{
+  Q_ASSERT(transmitter);
+
+  const QString pingMsg(QStringLiteral("ping"));
+  if (message.startsWith(pingMsg))
+  {
+    transmitter->addMessage(PongMessage(message.mid(pingMsg.size())));
+    return;
+  }
+
+  std::unique_ptr<ClientMessage> clientMessage(ClientMessage::create(message, m_logger));
+
+  if (!clientMessage)
+    return;
+
+  clientMessage->process(m_exerciseManager, transmitter);
+}
+
+} // namespace CombatNetRadio
+} // namespace WebSocketInterface
+} // namespace Messages

Lts/Proxies/CombatNetRadio/WebSocketInterface/Messages/message_handler.h

@@ -0,0 +1,43 @@
+/**
+  * @RDE_HEADER@
+  * The MessageHandler class processes messages from the client an creates appropriate replys
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hannes Fritsche, SLSE, 2017-09-07
+  */
+#pragma once
+
+#include <QtCore/QObject>
+
+#include "logger.h"
+
+namespace CombatNetRadio
+{
+class ExerciseManager;
+
+namespace WebSocketInterface
+{
+
+namespace Messages
+{
+class MessageTransmitter;
+
+class MessageHandler
+  : public QObject
+{
+  Q_OBJECT
+public:
+  explicit MessageHandler(ExerciseManager *exerciseManager);
+
+public Q_SLOTS:
+  void onNewTextMessage(MessageTransmitter *transmitter, const QString &message);
+
+private:
+  ExerciseManager   *m_exerciseManager;
+
+  LOGGER_T m_logger;
+};
+} // namespace Messages
+} // namespace WebSocketInterface
+} // namespace CombatNetRadio

Lts/Proxies/CombatNetRadio/WebSocketInterface/Messages/message_transmitter.h

@@ -0,0 +1,26 @@
+/**
+  * @RDE_HEADER@
+  * The MessageTransmitter Interface offers an extremely lightweight API for a class to just write textmessages to
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hannes Fritsche, SLSE, 2017-09-07
+  */
+#pragma once
+
+#include "reply_message.h"
+
+namespace CombatNetRadio
+{
+namespace WebSocketInterface
+{
+namespace Messages
+{
+class MessageTransmitter
+{
+public:
+  virtual void addMessage(const ReplyMessage &message) = 0;
+};
+} // namespace Messages
+} // namespace WebSocketInterface
+} // namespace CombatNetRadio

Lts/Proxies/CombatNetRadio/WebSocketInterface/Messages/reply_message.cpp

@@ -0,0 +1,192 @@
+/**
+  * @RDE_HEADER@
+  * The ReplyMessage class is an abstract base class for all possible messages which are sent to the client
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hannes Fritsche, SLSE, 2017-09-07
+  */
+#include "reply_message.h"
+
+#include "WebSocketInterface/json_keys.h"
+#include "helper.h"
+
+#include <QtCore/QUuid>
+#include <QtCore/QJsonDocument>
+#include <QtGlobal>
+#include <QDateTime>
+
+namespace CombatNetRadio
+{
+namespace WebSocketInterface
+{
+
+using namespace JsonKeys;
+
+namespace Messages
+{
+
+// ####### ReplyMessage begin #######
+QJsonObject ReplyMessage::LonLatPoint::toJSon() const
+{
+  if (lon < 0 || lat < 0)
+    return QJsonObject();
+  return {{LONGITUDE(), lon}, {LATITUDE(), lat}};
+}
+
+QJsonObject ReplyMessage::XYPoint::toJSon() const
+{
+  return {{X(), x}, {Y(), y}};
+}
+
+QString ReplyMessage::toJsonString() const
+{
+  return QString::fromUtf8(QJsonDocument(m_jsonRepresentation).toJson()); //QJsonDocument::Compact));
+}
+
+ReplyMessage::ReplyMessage(const QString &type, const QString &uuid)
+{
+  m_jsonRepresentation.insert(TYPE(), type);
+
+  Q_ASSERT(!uuid.isEmpty());
+  m_jsonRepresentation.insert(UUID_(), uuid);
+}
+
+QString ReplyMessage::uuid() const
+{
+  return m_jsonRepresentation.value(UUID_()).toString();
+}
+
+// ####### ReplyMessage end #######
+
+// ####### OkMessage begin #######
+OkMessage::OkMessage(const OkMessage::OkData &data)
+  : ReplyMessage(OK(), data.uuid)
+{
+  m_jsonRepresentation.insert(DATA(),
+  QJsonObject({
+    {MESSAGE_TYPE(), data.messageType},
+    {INFO(), data.info}
+  }));
+}
+// ####### OkMessage end #######
+
+// ####### ErrorMessage begin #######
+ErrorMessage::ErrorMessage(const ErrorMessage::ErrorData &data)
+  : ReplyMessage(ERROR_(), data.uuid)
+{
+  m_jsonRepresentation.insert(DATA(),
+  QJsonObject({
+    {ERROR_CLASS(), data.errorClass},
+    {ERROR_MESSAGE(), data.errorMessage}
+              }));
+}
+
+// ####### ErrorMessage end #######
+
+// ####### TrainingAreaMessage begin #######
+TrainingAreaMessage::TrainingAreaMessage(const TrainingAreaMessage::TrainingAreaData &data, const QString &uuid)
+  : ReplyMessage(TRAINING_AREA(), uuid)
+{
+  m_jsonRepresentation.insert(DATA(),
+  QJsonObject({{ID(), data.id},
+    {DESIGNATION(), data.designation},
+    {REF_POINT(), data.refPoint.toJSon()},
+    {PATH(), vecToPath(data.path)}
+  }));
+}
+// ####### TrainingAreaMessage end #######
+
+// ####### RadioStationMessage begin #######
+RadioStationMessage::RadioStationMessage(const RadioStationMessage::RadioStationData &data, const QString &uuid)
+  : ReplyMessage(RADIO_STATION(), uuid)
+{
+  m_jsonRepresentation.insert(DATA(),
+  QJsonObject({{ID(), data.id},
+    {DESIGNATION(), data.designation},
+    {GEO_POINT(), data.geoPoint.toJSon()},
+    {TRAINING_AREA_ID(), data.trainingAreaId}
+  }));
+}
+// ####### RadioStationMessage end #######
+
+// ####### ConfigCnrMessage begin #######
+QJsonObject ConfigCnrMessage::SubRadioCircuit::toJSon() const
+{
+
+  return QJsonObject({{RC_ID(), rcSubId},
+    {RC_SUB_NAME(), rcSubName},
+    {RC_MODE(), rcMode},
+    {STATION(), station},
+    {PT_SIG(), ptSig},
+    {RC_TYPE(), rcType},
+    {CROSSBEAM(), crossbeam},
+    {ORIENTATION(), orientation},
+    {FREQUENCY(), frequency},
+    {AKW(), akw},
+    {FSB(), fsb},
+    {RC_AKW(), rcAkw},
+    {COMSEC(), comsec},
+    {MODULATION_TYPE(), modulationType},
+    {CHANNEL_SPACING(), channelSpacing},
+    {SQUELCH(), squelch},
+    {CLIPPER(), clipper},
+    {AGC(), agc}
+  });
+}
+
+QJsonObject ConfigCnrMessage::RadioCircuit::toJSon() const
+{
+  return QJsonObject({{RC_ID(), rcId},
+    {SSRC(), ssrc},
+    {RC_NAME(), rcName},
+    {IS_ROAMING(), isRoaming},
+    {SUB_CIRCUIT(), vecToPath(subCircuits)}
+  });
+}
+
+ConfigCnrMessage::ConfigCnrMessage(const ConfigCnrMessage::ConfigCnrData &data, const QString &uuid)
+  : ReplyMessage(CONFIG_CNR(), uuid)
+{
+  m_jsonRepresentation.insert(DATA(),
+  QJsonObject({{SET_ID(), data.setId},
+    {TIME(), QDateTime::currentDateTime().toString(Qt::ISODate)},
+    {RADIO_CIRCUIT(), vecToPath(data.radioCircuit)}
+  }));
+}
+// ####### ConfigCnrMessage end #######
+
+// ####### PositionsCnrMessage begin #######
+QJsonObject PositionsCnrMessage::RadioCircuit::toJSon() const
+{
+  return QJsonObject{{RC_ID(), rcId}, {POSITIONS(), vecToPath(positions)}};
+}
+
+PositionsCnrMessage::PositionsCnrMessage(const PositionsCnrMessage::PositionsCnrMessageData &data, const QString &uuid)
+  : ReplyMessage(POSITIONS_CNR(), uuid)
+{
+  m_jsonRepresentation.insert(DATA(),
+  QJsonObject({{TIME(), data.time},
+    {RADIO_CIRCUIT(), vecToPath(data.radioCircuit)}
+  }));
+}
+// ####### PositionsCnrMessage end #######
+
+// ####### UpdateMessage begin ######
+UpdateMessage::UpdateMessage(const QString &info)
+  : ReplyMessage(UPDATE(), QUuid::createUuid().toString())
+{
+  m_jsonRepresentation.insert(DATA(), QJsonObject({{INFO(), info}}));
+}
+// ####### UpdateMessage end ######
+
+// ####### UpdateMessage begin ######
+AliveResponse::AliveResponse(const QString &uuid)
+  : ReplyMessage(ALIVE_RESPONSE(), uuid)
+{
+}
+// ####### UpdateMessage end ######
+
+} // namespace Messages
+} // namespace WebSocketInterface
+} // namespace CombatNetRadio

Lts/Proxies/CombatNetRadio/WebSocketInterface/Messages/reply_message.h

@@ -0,0 +1,248 @@
+/**
+  * @RDE_HEADER@
+  * The ReplyMessage class is an abstract base class for all possible messages which are sent to the client
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hannes Fritsche, SLSE, 2017-09-07
+  */
+#pragma once
+
+#include <QtCore/QVector>
+#include <QtCore/QJsonObject>
+#include <QtCore/QJsonArray>
+#include <QtCore/QString>
+
+namespace CombatNetRadio
+{
+namespace WebSocketInterface
+{
+namespace Messages
+{
+
+class ReplyMessage
+{
+public:
+  struct LonLatPoint
+  {
+    double lon = 0.;
+    double lat = 0.;
+
+    LonLatPoint() = default;
+    LonLatPoint(double _lon, double _lat)
+      : lon(_lon)
+      , lat(_lat)
+    {}
+
+    QJsonObject toJSon() const;
+  };
+
+  struct XYPoint
+  {
+    double x = 0.;
+    double y = 0.;
+
+    QJsonObject toJSon() const;
+  };
+
+  ReplyMessage() = default; //!< QVector requires this; don't use directly
+
+  virtual ~ReplyMessage() = default;
+
+  virtual QString toJsonString() const;
+  QString uuid() const;
+
+
+protected:
+  template<typename T>
+  static QJsonArray vecToPath(const QVector<T> &points)
+  {
+    QJsonArray result;
+    for (const T &p : points)
+      result.append(p.toJSon());
+    return result;
+  }
+
+protected: // methods
+  explicit ReplyMessage(const QString &type, const QString &uuid);
+
+protected: // attributes
+  QJsonObject m_jsonRepresentation;
+
+}; // class Reply Message
+
+class ErrorMessage final
+    : public ReplyMessage
+{
+public:
+  struct ErrorData
+  {
+    int errorClass = 0;
+    QString uuid;
+    QString errorMessage;
+
+    ErrorData() = default;
+    explicit ErrorData(int errorClass_, const QString &uuid_, const QString &errorMessage_)
+      : errorClass(errorClass_)
+      , uuid(uuid_)
+      , errorMessage(errorMessage_)
+    {}
+  };
+
+  explicit ErrorMessage(const ErrorData &data);
+  explicit ErrorMessage(int errorClass, const QString &uuid, const QString &errorMessage)
+    : ErrorMessage(ErrorData(errorClass, uuid, errorMessage))
+  {}
+}; // class ErrorMessage
+
+
+class OkMessage final
+    : public ReplyMessage
+{
+public:
+  struct OkData
+  {
+    QString uuid;
+    QString messageType;
+    QString info;
+  };
+
+  explicit OkMessage(const OkData &data);
+}; // class OkMessage
+
+class TrainingAreaMessage final
+    : public ReplyMessage
+{
+public:
+  struct TrainingAreaData
+  {
+    int32_t id;
+    QString designation;
+    LonLatPoint refPoint;
+    QVector<LonLatPoint> path;
+  };
+
+  explicit TrainingAreaMessage(const TrainingAreaData &data, const QString &uuid);
+}; // class TrainingAreaMessage
+
+class RadioStationMessage final
+    : public ReplyMessage
+{
+public:
+
+  struct RadioStationData
+  {
+    int32_t id;
+    QString designation;
+    LonLatPoint geoPoint;
+    int32_t trainingAreaId;
+  };
+
+  explicit RadioStationMessage(const RadioStationData &data, const QString &uuid);
+}; // RadioStationMessage
+
+class ConfigCnrMessage final
+    : public ReplyMessage
+{
+public:
+  struct SubRadioCircuit
+  {
+    QString rcSubId;
+    QString rcSubName;
+    int32_t frequencyBand = 0;
+    int32_t rcMode = 0;
+    int32_t station = 0;
+    int32_t ptSig = 0;
+    int32_t rcType;
+    int32_t crossbeam;
+    int32_t orientation;
+    int32_t frequency = 0;
+    int32_t akw = 0;
+    int32_t fsb = 0;
+    int32_t rcAkw = 0;
+    int32_t comsec = 0;
+    int32_t modulationType;
+    int32_t channelSpacing;
+    int32_t squelch = 0;
+    bool clipper;
+    bool agc;
+
+    QJsonObject toJSon() const;
+  };
+
+  struct RadioCircuit
+  {
+    QString rcId;
+    int32_t ssrc = 0;
+    QString rcName;
+    bool    isRoaming;
+
+    QVector<SubRadioCircuit> subCircuits;
+    QJsonObject toJSon() const;
+  };
+
+  struct ConfigCnrData
+  {
+    int32_t setId = 0;
+    QString time;
+    QVector<RadioCircuit> radioCircuit;
+  };
+
+  explicit ConfigCnrMessage(const ConfigCnrData &data, const QString &uuid);
+}; // ConfigCnrMessage
+
+class PositionsCnrMessage final
+    : public ReplyMessage
+{
+public:
+  struct RadioCircuit
+  {
+    QString rcId;
+    QVector<LonLatPoint> positions;
+
+    QJsonObject toJSon() const;
+  };
+
+  struct PositionsCnrMessageData
+  {
+    QString time;
+    QVector<RadioCircuit> radioCircuit;
+  };
+
+  explicit PositionsCnrMessage(const PositionsCnrMessageData &data, const QString &uuid);
+}; // PositionsCnrMessage
+
+class UpdateMessage final
+    : public ReplyMessage
+{
+public:
+  explicit UpdateMessage(const QString &info = QString());
+}; // UpdateMessage
+
+class PongMessage final : public ReplyMessage
+{
+public:
+  static QString strPong() { return QStringLiteral("pong"); }
+  explicit PongMessage(const QString &payload)
+    : ReplyMessage(strPong(), QString())
+    , m_payload(payload)
+  {}
+
+  QString toJsonString() const override
+  {
+    return m_payload.isEmpty() ? strPong() : QStringLiteral("%1 %2").arg(strPong(), m_payload);
+  }
+private:
+  QString m_payload;
+};
+
+class AliveResponse final : public ReplyMessage
+{
+public:
+  explicit AliveResponse(const QString &uuid);
+};
+
+} // namespace Messages
+} // namespace WebSocketInterface
+} // namespace CombatNetRadio
+