Adds initial intermediate qt6 porting state

qt6-after/qt6-migrated-legatus/Lts/Proxies/TrainingAreaBase/WebSocketInterface/Messages/client_message.cpp

@@ -0,0 +1,66 @@
+
+
+#include "client_message.h"
+
+#include "WebSocketInterface/Messages/reply_message.h"
+#include "WebSocketInterface/json_keys.h"
+#include "WebSocketInterface/data_manager.h"
+
+#include <QtCore/QJsonDocument>
+#include <QtCore/QUuid>
+
+namespace TrainingAreaBase
+{
+namespace WebSocketInterface
+{
+namespace ClientMessages
+{
+using namespace JsonKeys;
+
+
+ClientMessageFactory::ClientMessageFactory(DataManager *dataManager)
+  : LtsWebSocket::AbstractClientMessageFactory(getLogger("ClientMessageFactory"))
+  , m_dataManager(dataManager)
+{}
+
+LtsWebSocket::AbstractClientMessage *ClientMessageFactory::createMessage(LtsWebSocket::ReplyHandler *client,
+                                                                         const QString &message)
+{
+  LtsWebSocket::AbstractClientMessage *result = checkAttributes(client, message);
+  if (result)
+    return result;
+
+  if (m_type == WebSocketInterface::JsonKeys::SEND_BITE_REQUEST())
+    result = new SendBiteRequest(m_dataManager, client, m_type, m_typeId, m_uuid, m_data);
+
+  return checkResult(client, message, result);
+}
+
+
+
+
+ClientMessage::ClientMessage(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data)
+  : LtsWebSocket::AbstractClientMessage(client, type, typeId, uuid, data)
+  , m_dataManager(dataManager)
+  , m_logger(getLogger("ClientMessage"))
+{}
+
+
+
+SendBiteRequest::SendBiteRequest(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data)
+  : ClientMessage(dataManager, client, type, typeId, uuid, data)
+{}
+
+void SendBiteRequest::process()
+{
+  m_client->addReply(m_dataManager->sendBiteRequest(m_uuid, m_data.toObject().value(WebSocketInterface::JsonKeys::EQUIP_NO()).toInt()));
+}
+
+bool SendBiteRequest::hasValidData() const
+{
+  return true;
+}
+
+} 
+} 
+} 

qt6-after/qt6-migrated-legatus/Lts/Proxies/TrainingAreaBase/WebSocketInterface/Messages/client_message.h

@@ -0,0 +1,61 @@
+
+
+#pragma once
+
+#include <QtCore/QJsonObject>
+
+#include <LtsWebSocket/client_message_factory.h>
+#include <LtsWebSocket/client_message.h>
+
+#include "logger.h"
+
+namespace TrainingAreaBase
+{
+namespace WebSocketInterface
+{
+class DataManager;
+
+namespace ClientMessages
+{
+
+
+
+class ClientMessageFactory final : public LtsWebSocket::AbstractClientMessageFactory
+{
+public:
+  explicit ClientMessageFactory(DataManager *dataManager);
+
+  
+
+  LtsWebSocket::AbstractClientMessage *createMessage(LtsWebSocket::ReplyHandler *client,
+                                                     const QString &message);
+
+private:
+  DataManager *m_dataManager;
+
+}; 
+
+
+
+class ClientMessage : public LtsWebSocket::AbstractClientMessage
+{
+protected: 
+  explicit ClientMessage(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data = QJsonValue());
+
+protected: 
+  DataManager *m_dataManager;
+  LOGGER_T     m_logger;
+}; 
+
+class SendBiteRequest : public ClientMessage
+{
+public:
+  explicit SendBiteRequest(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid,  const QJsonValue &data);
+
+  void process();
+  bool hasValidData() const;
+}; 
+
+} 
+} 
+} 

qt6-after/qt6-migrated-legatus/Lts/Proxies/TrainingAreaBase/WebSocketInterface/Messages/reply_message.cpp

@@ -0,0 +1,122 @@
+
+
+#include "WebSocketInterface/Messages/reply_message.h"
+#include "WebSocketInterface/json_keys.h"
+
+#include <QtCore/QUuid>
+#include <QtCore/QJsonDocument>
+#include <QtGlobal>
+namespace TrainingAreaBase
+{
+namespace WebSocketInterface
+{
+
+using namespace JsonKeys;
+
+namespace Messages
+{
+
+
+
+QString ReplyMessage::toJsonString() const
+{
+  return QString::fromUtf8(QJsonDocument(m_jsonRepresentation).toJson(QJsonDocument::Compact));
+}
+
+ReplyMessage::ReplyMessage(const QString &type, const int typeId, const QString &uuid)
+    : LtsWebSocket::ReplyMessage(type, typeId, uuid)
+{
+
+}
+
+
+
+OkMessage::OkMessage(const OkMessage::OkData &data)
+  : ReplyMessage(OK(), 1, data.uuid) 
+{
+  m_jsonRepresentation.insert(DATA(),
+  QJsonObject({
+    {MESSAGE_TYPE(), data.messageType},
+    {INFO(), data.info}
+  }));
+}
+
+
+
+ErrorMessage::ErrorMessage(const ErrorMessage::ErrorData &data)
+  : ReplyMessage(ERROR_(), -1, data.uuid) 
+{
+  m_jsonRepresentation.insert(DATA(),
+  QJsonObject({
+    {ERROR_CLASS(), data.errorClass},
+    {ERROR_MESSAGE(), data.errorMessage}
+              }));
+}
+
+
+
+
+QJsonObject BiteDataMessage::ErrorText::toJson() const
+{
+  return QJsonObject({{LANG(), lang},
+    {_TEXT(), text}
+  });
+}
+
+QJsonObject BiteDataMessage::ConfigurationError::toJson() const
+{
+  return QJsonObject({{COMPONENT_NAME(), componentName},
+    {_TEXT(), text}
+  });
+}
+
+QJsonObject BiteDataMessage::BasicError::toJson() const
+{
+  return QJsonObject({{ERROR_TEXT(), text}});
+}
+
+
+QJsonObject BiteDataMessage::BiteError::toJson() const
+{
+  return QJsonObject({{ERROR_TEXT(), vecToPath(errorTexts)},
+    {DEVICE_ID(), deviceId},
+    {SUBDEVICE(), subDevice},
+    {UNIQUE_ID(), uniqueId},
+    {ERROR_NO(),  errorNo},
+  });
+}
+
+
+BiteDataMessage::BiteDataMessage(const BiteDataMessage::BiteData &data, const QString &uuid)
+  : ReplyMessage(BITE_DATA(), 2, uuid) 
+{
+  m_jsonRepresentation.insert(DATA(),
+  QJsonObject({{EQUIP_NO(), data.equipNo},
+    {BOX(), data.box},
+    {LAST_UPDATE(), data.lastUpdate},
+    {BITE_ERRORS(), vecToPath(data.biteErrors)},
+    {CONFIGURATION_ERRORS(), vecToPath(data.configurationErrors)},
+    {BASIC_ERRORS(), vecToPath(data.basicErrors)},
+    {LAST_POSITION_UPDATE(), data.lastPositionUpdate},
+    {IS_LICENSED(), data.isLicensed}
+  }));
+}
+
+
+PositionMessage::PositionMessage(const PositionMessage::PositionData &data, const QString &uuid)
+  : ReplyMessage(POSITION_DATA(), 3, uuid) 
+{
+  m_jsonRepresentation.insert(DATA(),
+  QJsonObject({{EQUIP_NO(), data.equipNo},
+    {POS_LAT(), data.pos.lat()},
+    {POS_LON(), data.pos.lon()},
+    {POS_Z(), data.pos.z()},
+    {LAST_POSITION_UPDATE(), data.gpsTime}
+  }));
+}
+
+
+
+} 
+} 
+} 

qt6-after/qt6-migrated-legatus/Lts/Proxies/TrainingAreaBase/WebSocketInterface/Messages/reply_message.h

@@ -0,0 +1,160 @@
+
+
+#pragma once
+
+#include <QtCore/QVector>
+#include <QtCore/QJsonObject>
+#include <QtCore/QJsonArray>
+#include <QtCore/QString>
+#include <LtsWebSocket/reply_message.h>
+
+#include <Core/core.hpp>
+
+namespace TrainingAreaBase
+{
+
+namespace WebSocketInterface
+{
+namespace Messages
+{
+
+class ReplyMessage : public LtsWebSocket::ReplyMessage
+{
+public:
+
+  ReplyMessage() = default; 
+
+  virtual ~ReplyMessage() = default;
+
+  virtual QString toJsonString() const;
+
+protected:
+  template<typename T>
+  static QJsonArray vecToPath(const QVector<T> &data)
+  {
+    QJsonArray result;
+    for (const T &p : data)
+      result.append(p.toJson());
+    return result;
+  }
+
+protected: 
+  explicit ReplyMessage(const QString &type, const int typeId, const QString &uuid);
+
+}; 
+
+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 OkMessage final
+    : public ReplyMessage
+{
+public:
+  struct OkData
+  {
+    QString uuid;
+    QString messageType;
+    QString info;
+  };
+
+  explicit OkMessage(const OkData &data);
+}; 
+
+
+class BiteDataMessage final
+    : public ReplyMessage
+{
+public:
+  struct ErrorText
+  {
+    QString lang;
+    QString text;
+
+    QJsonObject toJson() const;
+  };
+
+  struct BiteError
+  {
+    QVector<ErrorText> errorTexts;
+    int deviceId  = 0;
+    int subDevice = 0;
+    int uniqueId  = 0;
+    int errorNo   = 0;
+
+    QJsonObject toJson() const;
+  };
+
+  struct ConfigurationError
+  {
+    QString componentName;
+    QString text;
+
+    QJsonObject toJson() const;
+  };
+
+  struct BasicError
+  {
+    QString text;
+
+    QJsonObject toJson() const;
+  };
+
+  struct BiteData
+  {
+    int equipNo = 0;
+    int box = 0;
+    QString lastUpdate;
+    QVector<BiteError> biteErrors;
+    QVector<ConfigurationError> configurationErrors;
+    QVector<BasicError> basicErrors;
+    QString lastPositionUpdate;
+    bool isLicensed;
+
+    QJsonObject toJson() const;
+  };  
+
+  explicit BiteDataMessage(const BiteData &data, const QString &uuid);
+}; 
+
+class PositionMessage final
+    : public ReplyMessage
+{
+public:
+  struct PositionData
+  {
+    int equipNo = 0;
+    Core::GeoPosition pos;
+    qint64 gpsTime = 0;
+  };
+
+  QJsonObject toJson() const;
+
+  explicit PositionMessage(const PositionData &data, const QString &uuid);
+}; 
+
+} 
+} 
+} 
+