Initial commit

Lts/Services/ExerciseManagement/WebSocketInterface/Messages/client_message.cpp

@@ -0,0 +1,90 @@
+/**
+  * @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 ExerciseManagement
+{
+namespace WebSocketInterface
+{
+namespace Messages
+{
+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 == OcBaseDownload::WebSocketInterface::JsonKeys::BASE_DL_REQUEST())
+    result = new BaseDlRequest(m_dataManager, client, m_type, m_typeId, m_uuid);
+
+  if (m_type == JsonKeys::EXERCISE_INFORMATION_REQUEST())
+    result = new ExerciseDlRequest(m_dataManager, client, m_type, m_typeId, m_uuid);
+
+  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)
+{}
+// ####### ClientMessage end #######
+
+// ####### BaseDlRequest begin #######
+BaseDlRequest::BaseDlRequest(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid)
+  : ClientMessage(dataManager, client, type, typeId, uuid)
+{}
+
+void BaseDlRequest::process()
+{
+  m_client->addReply(m_dataManager->exercisePhaseBaseData(m_uuid));
+  m_client->addReply(m_dataManager->exerciseStateChangeBaseData(m_uuid));
+  m_client->addReply(m_dataManager->exerciseBaseData(m_uuid));
+}
+
+bool BaseDlRequest::hasValidData() const
+{
+  return true;
+}
+
+ExerciseDlRequest::ExerciseDlRequest(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid)
+  : ClientMessage(dataManager, client, type, typeId, uuid)
+{}
+
+void ExerciseDlRequest::process()
+{
+  m_client->addReply(m_dataManager->exerciseInformation(m_uuid));
+}
+
+bool ExerciseDlRequest::hasValidData() const
+{
+  return true;
+}
+
+// ####### BaseDlRequest end #######
+
+} // namespace Messages
+} // namespace WebSocketInterface
+} // namespace ExerciseManagement

Lts/Services/ExerciseManagement/WebSocketInterface/Messages/client_message.h

@@ -0,0 +1,87 @@
+/**
+  * @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 ExerciseManagement
+{
+namespace WebSocketInterface
+{
+class DataManager;
+
+namespace Messages
+{
+
+/**
+ * @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);
+
+  DataManager *dataManager() { return m_dataManager; }
+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;
+}; // class ClientMessage
+
+/**
+ * @brief The BaseDlRequest class handles the base DL request and sends multiple replys depending on the data requested
+ */
+class BaseDlRequest : public ClientMessage
+{
+public:
+  explicit BaseDlRequest(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid);
+
+  void process();
+  bool hasValidData() const;
+}; // class BaseDlRequest
+
+/**
+ * @brief The ExerciseDlRequest class handles the exercise DL request
+ */
+class ExerciseDlRequest : public ClientMessage
+{
+public:
+  explicit ExerciseDlRequest(DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid);
+
+  void process();
+  bool hasValidData() const;
+}; // class BaseDlRequest
+
+} // namespace Messages
+} // namespace WebSocketInterface
+} // namespace ExerciseManagement

Lts/Services/ExerciseManagement/WebSocketInterface/Messages/reply_message.cpp

@@ -0,0 +1,79 @@
+/**
+  * @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 Philipp Dassow, SLST, 2017-12-05
+  */
+#include "reply_message.h"
+
+#include <LtsWebSocket/json_keys.h>
+#include "WebSocketInterface/json_keys.h"
+
+#include <QtCore/QUuid>
+
+namespace ExerciseManagement
+{
+namespace WebSocketInterface
+{
+namespace Messages
+{
+using namespace JsonKeys;
+using namespace LtsWebSocket::JsonKeys;
+
+// ####### ExercisePhaseBaseData begin #######
+ExercisePhaseBaseData::ExercisePhaseBaseData(const QJsonArray &data, const QString &uuid)
+  : LtsWebSocket::ReplyMessage (EXERCISE_PHASE_BASE_DATA(), 1, uuid) // Todo: Check whether typeId is correct
+{
+  m_jsonRepresentation.insert(DATA(), data);
+}
+// ####### ExercisePhaseBaseData begin #######
+
+// ####### ExerciseStateChangeBaseData begin #######
+ExerciseStateChangeBaseData::ExerciseStateChangeBaseData(const QJsonArray &data, const QString &uuid)
+  : LtsWebSocket::ReplyMessage (EXERCISE_STATE_CHANGE_BASE_DATA(), 2, uuid) // Todo: Check whether typeId is correct
+{
+  m_jsonRepresentation.insert(DATA(), data);
+}
+// ####### ExerciseStateChangeBaseData begin #######
+
+// ####### ExerciseBaseData begin #######
+ExerciseBaseData::ExerciseBaseData(const QJsonArray &data, const QString &uuid)
+  : LtsWebSocket::ReplyMessage (EXERCISE_BASE_DATA(), 3, uuid) // Todo: Check whether typeId is correct
+{
+  m_jsonRepresentation.insert(DATA(), data);
+}
+
+/**************************************************************
+ * Attention: 6004 is negotiated with ESG for use with ADLER! *
+ **************************************************************/
+ExerciseInformationMessage::ExerciseInformationMessage(const QVector<ExInformation> &data, const QString &uuid)
+  : ReplyMessage (EXERCISE_INFORMATION(), 6004, uuid) // Todo: Check whether typeId is correct
+{
+  QJsonArray exercises;
+  for (const auto &exercise : data)
+  {
+    QJsonObject ex;
+    ex.insert(QStringLiteral("id"),    exercise.exerciseId);
+    ex.insert(QStringLiteral("name"), exercise.name);
+    ex.insert(QStringLiteral("beginTime"), exercise.beginTime);
+    ex.insert(QStringLiteral("endTime"), exercise.endTime);
+    ex.insert(QStringLiteral("startTime"), exercise.startTime);
+    ex.insert(QStringLiteral("stopTime"), exercise.stopTime);
+    ex.insert(QStringLiteral("timeZone"), exercise.timeZone);
+    ex.insert(QStringLiteral("status"), exercise.status);
+    ex.insert(QStringLiteral("description"), exercise.description);
+    ex.insert(QStringLiteral("trainingAreaId"), exercise.trainingAreaId);
+
+    exercises.append(ex);
+  }
+
+  m_jsonRepresentation.insert(DATA(), exercises);
+}
+
+// ####### ExerciseBaseData begin #######
+
+} // namespace Messages
+} // namespace WebSocketInterface
+} // namespace ExerciseManagement

Lts/Services/ExerciseManagement/WebSocketInterface/Messages/reply_message.h

@@ -0,0 +1,78 @@
+/**
+  * @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 Philipp Dassow, SLST, 2017-12-05
+  */
+#pragma once
+
+#include <LtsWebSocket/reply_message.h>
+
+#include <QJsonArray>
+#include <QString>
+#include <QtCore/QVector>
+
+
+namespace ExerciseManagement
+{
+namespace WebSocketInterface
+{
+namespace Messages
+{
+/**
+ * @brief The ExercisePhaseBaseData class exercise phase data for base DL
+ */
+class ExercisePhaseBaseData : public LtsWebSocket::ReplyMessage
+{
+public:
+  explicit ExercisePhaseBaseData(const QJsonArray &data, const QString &uuid);
+}; // class ExercisePhaseBaseData
+
+/**
+ * @brief The ExerciseStateChangeBaseData class exercise state change data for base DL
+ */
+class ExerciseStateChangeBaseData : public LtsWebSocket::ReplyMessage
+{
+public:
+  explicit ExerciseStateChangeBaseData(const QJsonArray &data, const QString &uuid);
+}; // class ExerciseStateChangeBaseData
+
+/**
+ * @brief The ExerciseBaseData class exercise data for base DL
+ */
+class ExerciseBaseData : public LtsWebSocket::ReplyMessage
+{
+public:
+  explicit ExerciseBaseData(const QJsonArray &data, const QString &uuid);
+}; // class ExerciseBaseData
+
+
+class ExerciseInformationMessage final : public LtsWebSocket::ReplyMessage
+{
+public:
+
+  struct ExInformation
+  {
+    int32_t exerciseId;
+    QString name;
+    qint64  beginTime;
+    qint64  endTime;
+    qint64  startTime;
+    qint64  stopTime;
+    QString timeZone;
+    int     status;
+    int     trainingAreaId;
+    QString description;
+  };
+
+  explicit ExerciseInformationMessage (const QVector<ExInformation> &data, const QString &uuid);
+
+};
+
+
+} // namespace Messages
+} // namespace WebSocketInterface
+} // namespace ExerciseManagement
+

Lts/Services/ExerciseManagement/WebSocketInterface/data_manager.cpp

@@ -0,0 +1,68 @@
+/**
+  * @RDE_HEADER@
+  * The DataManager class handles data to be send to the websocket
+  * offers an interface to get and set structure data
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Philipp Dassow, SLST, 2017-12-05
+  */
+#include "data_manager.h"
+#include "Messages/reply_message.h"
+#include "object_exercise.h"
+
+namespace ExerciseManagement
+{
+namespace WebSocketInterface
+{
+//---------------------------------------------------------------------------------------------------------
+DataManager::DataManager(const std::shared_ptr<DatabaseInterface> &dbInterface, const std::shared_ptr<HandlerExercise> &exHandler)
+  : LtsWebSocket::DataManagerBaseDl<DatabaseInterface>(dbInterface, getLogger("DataManager"))
+  , m_exerciseHandler(exHandler)
+{}
+
+LtsWebSocket::ReplyMessage *DataManager::exercisePhaseBaseData(const QString &uuid) const
+{
+  return toBaseDataMessageFromDb<Database::ExmExercisePhase, Messages::ExercisePhaseBaseData>(uuid);
+}
+
+LtsWebSocket::ReplyMessage *DataManager::exerciseStateChangeBaseData(const QString &uuid) const
+{
+  return toBaseDataMessageFromDb<Database::ExmExerciseStateChange, Messages::ExerciseStateChangeBaseData>(uuid);
+}
+
+LtsWebSocket::ReplyMessage *DataManager::exerciseBaseData(const QString &uuid) const
+{
+  return toBaseDataMessageFromDb<Database::ExmExercise, Messages::ExerciseBaseData>(uuid);
+}
+
+LtsWebSocket::ReplyMessage *DataManager::exerciseInformation(const QString &uuid) const
+{
+  using namespace Messages;
+
+  ExerciseInformationMessage::ExInformation exInfo;
+  QVector<ExerciseInformationMessage::ExInformation> data;
+  const auto &exerciseMap = m_exerciseHandler->getExerciseMap();
+  data.reserve(exerciseMap.size());
+  for (const ObjectExercise *ex : exerciseMap)
+  {
+    const auto &exData = ex->data();
+
+    exInfo.exerciseId  = exData.id;
+    exInfo.name        = exData.name;
+    exInfo.beginTime   = exData.beginTime.toMSecsSinceEpoch();
+    exInfo.endTime     = exData.endTime.toMSecsSinceEpoch();
+    exInfo.startTime   = exData.startTime.toMSecsSinceEpoch();
+    exInfo.stopTime    = exData.stopTime.toMSecsSinceEpoch();
+    exInfo.timeZone    = exData.defaultTimeZone;
+    exInfo.status      = exData.exerciseStateId.underlying();
+    exInfo.description = exData.description;
+
+    data.append(exInfo);
+  }
+
+  return new ExerciseInformationMessage(data, uuid);
+}
+
+} // namespace WebSocketInterface
+} // namespace ExerciseManagement

Lts/Services/ExerciseManagement/WebSocketInterface/data_manager.h

@@ -0,0 +1,44 @@
+/**
+  * @RDE_HEADER@
+  * The DataManager class handles data to be send to the websocket
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Philipp Dassow, SLST, 2017-12-05
+  */
+#pragma once
+
+#include <LtsWebSocket/data_manager_base_dl.h>
+#include "handler_exercise.h"
+#include "logger.h"
+
+namespace ExerciseManagement
+{
+
+namespace WebSocketInterface
+{
+
+/**
+ * @brief The DataManager class is a convenience class for managing structure data
+ */
+class DataManager final : public LtsWebSocket::DataManagerBaseDl<DatabaseInterface>
+{
+public:
+
+  /**
+   * @brief DataManager Constructor
+   * @param mainHandler Source for needed handlers
+   */
+  explicit DataManager(const std::shared_ptr<DatabaseInterface> &dbInterface, const std::shared_ptr<HandlerExercise> &exHandler);
+
+  LtsWebSocket::ReplyMessage *exercisePhaseBaseData(const QString &uuid) const;
+  LtsWebSocket::ReplyMessage *exerciseStateChangeBaseData(const QString &uuid) const;
+  LtsWebSocket::ReplyMessage *exerciseBaseData(const QString &uuid) const;
+  LtsWebSocket::ReplyMessage *exerciseInformation(const QString &uuid) const;
+private:
+  std::shared_ptr <HandlerExercise> m_exerciseHandler;
+
+
+}; // class DataManager
+} // namespace WebSocketInterface
+} // namespace ExerciseManagement

Lts/Services/ExerciseManagement/WebSocketInterface/json_keys.h

@@ -0,0 +1,35 @@
+/**
+  * @RDE_HEADER@
+  * Header file which holds all occuring JSON keys
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Philipp Dassow, SLST, 2017-12-05
+  */
+#pragma once
+
+#include <QString>
+
+#include <OcBaseDownload/WebSocketInterface/json_keys.h>
+
+namespace ExerciseManagement
+{
+namespace WebSocketInterface
+{
+/**
+ * @brief Namespace which holds all occuring JSON keys as const QString objects
+ */
+namespace JsonKeys
+{
+// types for client --> server messages
+inline QString EXERCISE_INFORMATION_REQUEST()      { return QStringLiteral("exerciseInformationRequest"); }
+
+// types for server --> client messages
+inline QString EXERCISE_INFORMATION()                   { return QStringLiteral("exerciseInformation"); }
+inline QString EXERCISE_PHASE_BASE_DATA()               { return QStringLiteral("exercisePhaseBaseData"); }
+inline QString EXERCISE_STATE_CHANGE_BASE_DATA()        { return QStringLiteral("exerciseStateChangeBaseData"); }
+inline QString EXERCISE_BASE_DATA()                     { return QStringLiteral("exerciseBaseData"); }
+
+} // namespace JsonKeys
+} // namespace WebSocketInterface
+} // namespace ExerciseManagement

Lts/Services/ExerciseManagement/WebSocketInterface/websocket_interface_handler.cpp

@@ -0,0 +1,69 @@
+/**
+  * @RDE_HEADER@
+  * Handler for the WebSocket Interface
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Philipp Dassow, SLST, 2017-12-05
+  */
+#include "websocket_interface_handler.h"
+
+#include "main_handler.h"
+#include "data_manager.h"
+#include "WebSocketInterface/Messages/client_message.h"
+#include "settings.h"
+
+namespace ExerciseManagement
+{
+namespace WebSocketInterface
+{
+
+WebSocketInterfaceHandler::WebSocketInterfaceHandler(MainHandler *mainHandler, QObject *parent)
+  : QObject(parent)
+  , m_webSocketServer(nullptr)
+  , m_messageFactory(nullptr)
+  , m_dataManager(nullptr)
+  , m_mainHandler(mainHandler)
+  , m_logger(getLogger("WebSocketInterfaceHandler"))
+{
+}
+
+WebSocketInterfaceHandler::~WebSocketInterfaceHandler()
+{
+  cleanup();
+}
+
+bool WebSocketInterfaceHandler::init()
+{
+  cleanup();
+
+  DEBUG_LOG(m_logger) << "... ok";
+
+  m_dataManager = new DataManager(m_mainHandler->db(), m_mainHandler->exerciseHandler());
+
+  m_messageFactory = new Messages::ClientMessageFactory(m_dataManager);
+
+  m_webSocketServer = new LtsWebSocket::LtsWebSocketServer(m_messageFactory, this);
+
+  DEBUG_LOG(m_logger) << "Initialising LtsWebSocketServer";
+  if (!m_webSocketServer->init(QStringLiteral("EXM"), Settings::getWebSocketServerPortRange(1)))
+  {
+    ERROR_LOG(m_logger) << "Failed to initialise LtsWebSocketServer";
+    return false;
+  }
+  DEBUG_LOG(m_logger) << "... ok";
+
+  DEBUG_LOG(m_logger) << "Connection signals and slots";
+
+  return true;
+}
+
+void WebSocketInterfaceHandler::cleanup()
+{
+  delete m_webSocketServer;
+  delete m_messageFactory;
+  delete m_dataManager;
+}
+
+} // namespace WebSocketInterface
+} // namespace ExerciseManagement

Lts/Services/ExerciseManagement/WebSocketInterface/websocket_interface_handler.h

@@ -0,0 +1,69 @@
+/**
+  * @RDE_HEADER@
+  * Handler for the WebSocket Interface
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Philipp Dassow, SLST, 2017-12-05
+  */
+#pragma once
+
+#include <QtCore/QObject>
+
+#include <LtsWebSocket/lts_web_socket_server.h>
+
+#include "logger.h"
+
+namespace ExerciseManagement
+{
+class MainHandler;
+namespace WebSocketInterface
+{
+namespace Messages
+{
+class ClientMessageFactory;
+}
+class DataManager;
+
+/**
+ * @brief The WebSocketInterfaceHandler class is the main class for the WebSocketInterface
+ */
+class WebSocketInterfaceHandler final : public QObject
+{
+public:
+  /**
+   * @brief WebSocketInterfaceHandler Constructor
+   * @param mainHandler MainHandler to get the HandlerStructureElement from
+   */
+  explicit WebSocketInterfaceHandler(MainHandler *mainHandler, QObject *parent = nullptr);
+
+  /**
+   * @brief ~WebSocketInterfaceHandler Destructor
+   */
+  ~WebSocketInterfaceHandler();
+
+  /**
+   * @brief init Initialises all needed classes for the WebSocketInterface
+   * @return True on success, otherwise false
+   */
+  bool init();
+
+  /**
+   * @brief webSocketPort returns the listen port
+   * @return listen port
+   */
+  unsigned short webSocketPort() { return m_webSocketServer->webSocketPort(); }
+
+private:
+  void cleanup();
+
+private:
+  LtsWebSocket::LtsWebSocketServer *m_webSocketServer;
+  Messages::ClientMessageFactory *m_messageFactory;
+  DataManager                    *m_dataManager;
+  MainHandler                    *m_mainHandler;
+  LOGGER_T                        m_logger;
+}; // class WebSocketInterfaceHandle
+
+} // namespace WebSocketInterface
+} // namespace ExerciseManagement