Initial commit

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

@@ -0,0 +1,79 @@
+/**
+  * @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 OperatorManagement
+{
+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 == OcBaseDownload::WebSocketInterface::JsonKeys::BASE_DL_REQUEST())
+    result = new BaseDlRequest(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)
+  , m_logger(getLogger("ClientMessage"))
+{}
+// ####### 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->groupBaseData(m_uuid));
+  m_client->addReply(m_dataManager->groupGroupBaseData(m_uuid));
+  m_client->addReply(m_dataManager->operatorBaseData(m_uuid));
+  m_client->addReply(m_dataManager->operatorExerciseBaseData(m_uuid));
+  m_client->addReply(m_dataManager->settingsBaseData(m_uuid));
+  m_client->addReply(m_dataManager->accessControlLevelBaseData(m_uuid));
+  m_client->addReply(m_dataManager->aclAllowBaseData(m_uuid));
+  m_client->addReply(m_dataManager->aclDenyBaseData(m_uuid));
+}
+
+bool BaseDlRequest::hasValidData() const
+{
+  return true;
+}
+// ####### BaseDlRequest end #######
+
+} // namespace ClientMessages
+} // namespace WebSocketInterface
+} // namespace OperatorManagement

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

@@ -0,0 +1,75 @@
+/**
+  * @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 OperatorManagement
+{
+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
+
+/**
+ * @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
+
+} // namespace ClientMessages
+} // namespace WebSocketInterface
+} // namespace OperatorManagement

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

@@ -0,0 +1,90 @@
+/**
+  * @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"
+
+namespace OperatorManagement
+{
+namespace WebSocketInterface
+{
+namespace ReplyMessages
+{
+using namespace JsonKeys;
+using namespace LtsWebSocket::JsonKeys;
+
+// ####### GroupBaseData begin #######
+GroupBaseData::GroupBaseData(const QJsonArray &data, const QString &uuid)
+  : LtsWebSocket::ReplyMessage (GROUP_BASE_DATA(), 1, uuid) // Todo: Check whether typeId is correct
+{
+  m_jsonRepresentation.insert(DATA(), data);
+}
+// ####### GroupBaseData end #######
+
+// ####### GroupGroupBaseData begin #######
+GroupGroupBaseData::GroupGroupBaseData(const QJsonArray &data, const QString &uuid)
+  : LtsWebSocket::ReplyMessage (GROUP_GROUP_BASE_DATA(), 2, uuid) // Todo: Check whether typeId is correct
+{
+  m_jsonRepresentation.insert(DATA(), data);
+}
+// ####### GroupGroupBaseData end #######
+
+// ####### OperatorBaseData begin #######
+OperatorBaseData::OperatorBaseData(const QJsonArray &data, const QString &uuid)
+  : LtsWebSocket::ReplyMessage (OPERATOR_BASE_DATA(), 3, uuid) // Todo: Check whether typeId is correct
+{
+  m_jsonRepresentation.insert(DATA(), data);
+}
+// ####### OperatorBaseData end #######
+
+// ####### OperatorExerciseBaseData begin #######
+OperatorExerciseBaseData::OperatorExerciseBaseData(const QJsonArray &data, const QString &uuid)
+  : LtsWebSocket::ReplyMessage (OPERATOR_EXERCISE_BASE_DATA(), 4, uuid) // Todo: Check whether typeId is correct
+{
+  m_jsonRepresentation.insert(DATA(), data);
+}
+// ####### OperatorExerciseBaseData end #######
+
+// ####### SettingsBaseData begin #######
+SettingsBaseData::SettingsBaseData(const QJsonArray &data, const QString &uuid)
+  : LtsWebSocket::ReplyMessage (SETTINGS_BASE_DATA(), 5, uuid) // Todo: Check whether typeId is correct
+{
+  m_jsonRepresentation.insert(DATA(), data);
+}
+// ####### SettingsBaseData end #######
+
+// ####### AccessControlLevelBaseData begin #######
+AccessControlLevelBaseData::AccessControlLevelBaseData(const QJsonArray &data, const QString &uuid)
+  : LtsWebSocket::ReplyMessage (ACCESS_CONTROL_LEVEL_BASE_DATA(), 6, uuid) // Todo: Check whether typeId is correct
+{
+  m_jsonRepresentation.insert(DATA(), data);
+}
+// ####### AccessControlLevelBaseData end #######
+
+// ####### AclAllowBaseData begin #######
+AclAllowBaseData::AclAllowBaseData(const QJsonArray &data, const QString &uuid)
+  : LtsWebSocket::ReplyMessage (ACL_ALLOW_BASE_DATA(), 7, uuid) // Todo: Check whether typeId is correct
+{
+  m_jsonRepresentation.insert(DATA(), data);
+}
+// ####### AclAllowBaseData end #######
+
+// ####### AclDenyBaseData begin #######
+AclDenyBaseData::AclDenyBaseData(const QJsonArray &data, const QString &uuid)
+  : LtsWebSocket::ReplyMessage (ACL_DENY_BASE_DATA(), 8, uuid) // Todo: Check whether typeId is correct
+{
+  m_jsonRepresentation.insert(DATA(), data);
+}
+// ####### AclDenyBaseData end #######
+
+
+} // namespace ReplyMessages
+} // namespace WebSocketInterface
+} // namespace OperatorManagement

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

@@ -0,0 +1,98 @@
+/**
+  * @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>
+
+namespace OperatorManagement
+{
+namespace WebSocketInterface
+{
+namespace ReplyMessages
+{
+
+/**
+ * @brief The GroupBaseData class training area data for base DL
+ */
+class GroupBaseData : public LtsWebSocket::ReplyMessage
+{
+public:
+  explicit GroupBaseData(const QJsonArray &data, const QString &uuid);
+}; // class GroupBaseData
+
+/**
+ * @brief The GroupGroupBaseData class map description data for base DL
+ */
+class GroupGroupBaseData : public LtsWebSocket::ReplyMessage
+{
+public:
+  explicit GroupGroupBaseData(const QJsonArray &data, const QString &uuid);
+}; // class GroupGroupBaseData
+
+/**
+ * @brief The OperatorBaseData class location data for base DL
+ */
+class OperatorBaseData : public LtsWebSocket::ReplyMessage
+{
+public:
+  explicit OperatorBaseData(const QJsonArray &data, const QString &uuid);
+}; // class OperatorBaseData
+
+/**
+ * @brief The OperatorExerciseBaseData class asset data for base DL
+ */
+class OperatorExerciseBaseData : public LtsWebSocket::ReplyMessage
+{
+public:
+  explicit OperatorExerciseBaseData(const QJsonArray &data, const QString &uuid);
+}; // class OperatorExerciseBaseData
+
+/**
+ * @brief The SettingsBaseData class asset data for base DL
+ */
+class SettingsBaseData : public LtsWebSocket::ReplyMessage
+{
+public:
+  explicit SettingsBaseData(const QJsonArray &data, const QString &uuid);
+}; // class SettingsBaseData
+
+/**
+ * @brief The AccessControlLevelBaseData class asset data for base DL
+ */
+class AccessControlLevelBaseData : public LtsWebSocket::ReplyMessage
+{
+public:
+  explicit AccessControlLevelBaseData(const QJsonArray &data, const QString &uuid);
+}; // class AccessControlLevelBaseData
+
+/**
+ * @brief The AclAllowBaseData class asset data for base DL
+ */
+class AclAllowBaseData : public LtsWebSocket::ReplyMessage
+{
+public:
+  explicit AclAllowBaseData(const QJsonArray &data, const QString &uuid);
+}; // class AclAllowBaseData
+
+/**
+ * @brief The AclDenyBaseData class asset data for base DL
+ */
+class AclDenyBaseData : public LtsWebSocket::ReplyMessage
+{
+public:
+  explicit AclDenyBaseData(const QJsonArray &data, const QString &uuid);
+}; // class AclDenyBaseData
+
+} // namespace ReplyMessages
+} // namespace WebSocketInterface
+} // namespace OperatorManagement
+

Lts/Services/OperatorManagement/WebSocketInterface/data_manager.cpp

@@ -0,0 +1,66 @@
+/**
+  * @RDE_HEADER@
+  * The DataManager class handles data to be send to the websocket
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Philipp Dassow, SLST, 2017-12-05
+  */
+#include "data_manager.h"
+#include "Messages/reply_message.h"
+#include "main_handler.h"
+
+namespace OperatorManagement
+{
+namespace WebSocketInterface
+{
+//---------------------------------------------------------------------------------------------------------
+DataManager::DataManager(MainHandler *mainHandler)
+  : LtsWebSocket::DataManagerBaseDl<DatabaseInterface>(mainHandler->db(), getLogger("DataManager"))
+{}
+
+//---------------------------------------------------------------------------------------------------------
+
+
+LtsWebSocket::ReplyMessage *DataManager::groupBaseData(const QString &uuid) const
+{
+  return toBaseDataMessageFromDb<Database::OpmGroup, ReplyMessages::GroupBaseData>(uuid);
+}
+
+LtsWebSocket::ReplyMessage *DataManager::groupGroupBaseData(const QString &uuid) const
+{
+  return toBaseDataMessageFromDb<Database::OpmGroupGroup, ReplyMessages::GroupGroupBaseData>(uuid);
+}
+
+LtsWebSocket::ReplyMessage *DataManager::operatorBaseData(const QString &uuid) const
+{
+  return toBaseDataMessageFromDb<Database::OpmOperator, ReplyMessages::OperatorBaseData>(uuid);
+}
+
+LtsWebSocket::ReplyMessage *DataManager::operatorExerciseBaseData(const QString &uuid) const
+{
+  return toBaseDataMessageFromDb<Database::OpmOperatorExercise, ReplyMessages::OperatorExerciseBaseData>(uuid);
+}
+
+LtsWebSocket::ReplyMessage *DataManager::settingsBaseData(const QString &uuid) const
+{
+  return toBaseDataMessageFromDb<Database::OpmSettings, ReplyMessages::SettingsBaseData>(uuid);
+}
+
+LtsWebSocket::ReplyMessage *DataManager::accessControlLevelBaseData(const QString &uuid) const
+{
+  return toBaseDataMessageFromDb<Database::OpmAccessControlLevel, ReplyMessages::AccessControlLevelBaseData>(uuid);
+}
+
+LtsWebSocket::ReplyMessage *DataManager::aclAllowBaseData(const QString &uuid) const
+{
+  return toBaseDataMessageFromDb<Database::OpmAclAllow, ReplyMessages::AclAllowBaseData>(uuid);
+}
+
+LtsWebSocket::ReplyMessage *DataManager::aclDenyBaseData(const QString &uuid) const
+{
+  return toBaseDataMessageFromDb<Database::OpmAclDeny, ReplyMessages::AclDenyBaseData>(uuid);
+}
+
+} // namespace WebSocketInterface
+} // namespace OperatorManagement

Lts/Services/OperatorManagement/WebSocketInterface/data_manager.h

@@ -0,0 +1,45 @@
+/**
+  * @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 <OperatorManagement/opm_db.h>
+#include "logger.h"
+
+namespace OperatorManagement
+{
+class MainHandler;
+
+namespace WebSocketInterface
+{
+
+/**
+ * @brief The DataManager class is a convenience class for managing base DL data
+ */
+class DataManager final : public LtsWebSocket::DataManagerBaseDl<DatabaseInterface>
+{
+public:
+  /**
+   * @brief DataManager Constructor
+   * @param mainHandler Source for needed handlers
+   */
+  explicit DataManager(MainHandler *mainHandler);
+
+  LtsWebSocket::ReplyMessage* groupBaseData(const QString &uuid) const;
+  LtsWebSocket::ReplyMessage* groupGroupBaseData(const QString &uuid) const;
+  LtsWebSocket::ReplyMessage* operatorBaseData(const QString &uuid) const;
+  LtsWebSocket::ReplyMessage* operatorExerciseBaseData(const QString &uuid) const;
+  LtsWebSocket::ReplyMessage* settingsBaseData(const QString &uuid) const;
+  LtsWebSocket::ReplyMessage* accessControlLevelBaseData(const QString &uuid) const;
+  LtsWebSocket::ReplyMessage* aclAllowBaseData(const QString &uuid) const;
+  LtsWebSocket::ReplyMessage* aclDenyBaseData(const QString &uuid) const;
+}; // class DataManager
+
+} // namespace WebSocketInterface
+} // namespace OperatorManagement

Lts/Services/OperatorManagement/WebSocketInterface/json_keys.h

@@ -0,0 +1,40 @@
+/**
+  * @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 OperatorManagement
+{
+namespace WebSocketInterface
+{
+/**
+ * @brief Namespace which holds all occuring JSON keys as const QString objects
+ */
+namespace JsonKeys
+{
+// types for client --> server messages
+
+// types for server --> client messages
+inline QString GROUP_BASE_DATA()                        { return QStringLiteral("groupBaseData"); }
+inline QString GROUP_GROUP_BASE_DATA()                  { return QStringLiteral("groupGroupBaseData"); }
+inline QString OPERATOR_BASE_DATA()                     { return QStringLiteral("operatorBaseData"); }
+inline QString OPERATOR_EXERCISE_BASE_DATA()            { return QStringLiteral("operatorExerciseBaseData"); }
+inline QString SETTINGS_BASE_DATA()                     { return QStringLiteral("settingsBaseData"); }
+inline QString ACCESS_CONTROL_LEVEL_BASE_DATA()         { return QStringLiteral("accessControlLevelBaseData"); }
+inline QString ACL_ALLOW_BASE_DATA()                    { return QStringLiteral("aclAllowBaseData"); }
+inline QString ACL_DENY_BASE_DATA()                     { return QStringLiteral("aclDenyBaseData"); }
+
+// data keys
+
+} // namespace JsonKeys
+} // namespace WebSocketInterface
+} // namespace OperatorManagement

Lts/Services/OperatorManagement/WebSocketInterface/websocket_interface_handler.cpp

@@ -0,0 +1,70 @@
+/**
+  * @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 OperatorManagement
+{
+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);
+
+  m_messageFactory = new ClientMessages::ClientMessageFactory(m_dataManager);
+
+  m_webSocketServer = new LtsWebSocket::LtsWebSocketServer(m_messageFactory, this);
+
+  DEBUG_LOG(m_logger) << "Initialising LtsWebSocketServer";
+  if (!m_webSocketServer->init(QStringLiteral("ASM"), 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";
+  DEBUG_LOG(m_logger) << "... ok";
+
+  return true;
+}
+
+void WebSocketInterfaceHandler::cleanup()
+{
+  delete m_webSocketServer;
+  delete m_messageFactory;
+  delete m_dataManager;
+}
+
+} // namespace WebSocketInterface
+} // namespace OperatorManagement

Lts/Services/OperatorManagement/WebSocketInterface/websocket_interface_handler.h

@@ -0,0 +1,70 @@
+/**
+  * @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 OperatorManagement
+{
+class MainHandler;
+namespace WebSocketInterface
+{
+namespace ClientMessages
+{
+class ClientMessageFactory;
+}
+class DataManager;
+
+/**
+ * @brief The WebSocketInterfaceHandler class is the main class for the WebSocketInterface
+ */
+class WebSocketInterfaceHandler final : public QObject
+{
+  Q_OBJECT
+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 serverWebSocketPort() { return m_webSocketServer->webSocketPort(); }
+
+private:
+  void cleanup();
+
+private:
+  LtsWebSocket::LtsWebSocketServer     *m_webSocketServer;
+  ClientMessages::ClientMessageFactory *m_messageFactory;
+  DataManager                          *m_dataManager;
+  MainHandler                          *m_mainHandler;
+  LOGGER_T                              m_logger;
+}; // class WebSocketInterfaceHandle
+
+} // namespace WebSocketInterface
+} // namespace OperatorManagement