Initial commit

This commit is contained in:
torsten committed 2026-08-13 18:33:10 +02:00
commit b7d90b9afe
16245 files changed
+3396666

No files matched your search

@@ -0,0 +1,72 @@
/**
* @RDE_HEADER@
* The ClientMessage class is an abstract base class for concrete ClientMessage objects
* $Id$
* $HeadURL$
* $Author$
* Created by Philipp Dassow, SLST, 2017-12-05
*/
#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 begin #######
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);
}
// ####### ClientMessageFactory end #######
// ####### ClientMessage begin #######
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"))
{}
// ####### ClientMessage end #######
// ####### SendBiteRequest begin #######
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;
}
} // namespace ClientMessages
} // namespace WebSocketInterface
} // namespace TrainingAreaBase
@@ -0,0 +1,72 @@
/**
* @RDE_HEADER@
* The ClientMessage class is an abstract base class for concrete ClientMessage objects
* $Id$
* $HeadURL$
* $Author$
* Created by Philipp Dassow, SLST, 2017-12-05
*/
#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
{
/**
* @brief The ClientMessageFactory class creates ClientMessages which will then be processed
*/
class ClientMessageFactory final : public LtsWebSocket::AbstractClientMessageFactory
{
public:
explicit ClientMessageFactory(DataManager *dataManager);
/**
* @brief create Only way to create a ClientMessage object
* @param message Text message which will be converted to a ClientMessage object
* @return A ClientMessage object, which represents a concrete ClientMessage
*/
LtsWebSocket::AbstractClientMessage *createMessage(LtsWebSocket::ReplyHandler *client,
const QString &message);
private:
DataManager *m_dataManager;
}; // class ClientMessageFactory
/**
* @brief The ClientMessage class is an abstract base class for concrete ClientMessage objects
*/
class ClientMessage : public LtsWebSocket::AbstractClientMessage
{
protected: // method
explicit ClientMessage(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data = QJsonValue());
protected: // attributes
DataManager *m_dataManager;
LOGGER_T m_logger;
}; // class ClientMessage
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;
}; // class SendBiteRequest
} // namespace ClientMessages
} // namespace WebSocketInterface
} // namespace TrainingAreaBase
@@ -0,0 +1,128 @@
/**
* @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 "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
{
// ####### ReplyMessage begin #######
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)
{
//we could skip the whole sub class here!
}
// ####### ReplyMessage end #######
// ####### OkMessage begin #######
OkMessage::OkMessage(const OkMessage::OkData &data)
: ReplyMessage(OK(), 1, data.uuid) // Todo: Check whether typeId is correct
{
m_jsonRepresentation.insert(DATA(),
QJsonObject({
{MESSAGE_TYPE(), data.messageType},
{INFO(), data.info}
}));
}
// ####### OkMessage end #######
// ####### ErrorMessage begin #######
ErrorMessage::ErrorMessage(const ErrorMessage::ErrorData &data)
: ReplyMessage(ERROR_(), -1, data.uuid) // Todo: Check whether typeId is correct
{
m_jsonRepresentation.insert(DATA(),
QJsonObject({
{ERROR_CLASS(), data.errorClass},
{ERROR_MESSAGE(), data.errorMessage}
}));
}
// ####### ErrorMessage end #######
// ####### BiteDataMessage begin #######
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) // Todo: Check whether typeId is correct
{
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}
}));
}
// ####### BiteDataMessage end #######
PositionMessage::PositionMessage(const PositionMessage::PositionData &data, const QString &uuid)
: ReplyMessage(POSITION_DATA(), 3, uuid) // Todo: Check whether typeId is correct
{
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}
}));
}
// ####### PositionMessage end #######
} // namespace Messages
} // namespace WebSocketInterface
} // namespace TrainingAreaBase
@@ -0,0 +1,166 @@
/**
* @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>
#include <LtsWebSocket/reply_message.h>
#include <Core/core.hpp>
namespace TrainingAreaBase
{
namespace WebSocketInterface
{
namespace Messages
{
class ReplyMessage : public LtsWebSocket::ReplyMessage
{
public:
ReplyMessage() = default; //!< QVector requires this; don't use directly
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: // methods
explicit ReplyMessage(const QString &type, const int typeId, const QString &uuid);
}; // 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 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);
}; // BiteDataMessage
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);
}; // PositionsMessage
} // namespace Messages
} // namespace WebSocketInterface
} // namespace TrainingAreaBase