qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Proxies/WarehouseManagement/data_manager.h

#pragma once

#include <memory>
#include "dds_handler.h"
#include "exercises_handler.h"
#include "interface_wms2ecc_impl.h"
#include <WMS_Interface/json_keys.h>
#include <ParticipantManagement/ppm_ftc.h>

#include "logger.h"
#include <QtWebSockets/QWebSocket>
#include <QtCore/QTimer>
#include <QtCore/QObject>


#include <LtsWebSocket/client_connection.h>
#include <LtsWebSocket/client_message_factory.h>

class EquipmentTypes;
class Registration;
namespace WarehouseManagement
{
class DataManager;


class ClientMessageFactory final : public LtsWebSocket::AbstractClientMessageFactory
{
public:
  explicit ClientMessageFactory(DataManager *dataManager);

  

  LtsWebSocket::AbstractClientMessage *createMessage(LtsWebSocket::ReplyHandler *client,
                                                     const QString &message);

private:

NGL::INGLLogger &m_logger;
  DataManager *m_dataManager;

}; 

class ClientMessage : public LtsWebSocket::AbstractClientMessage
{
protected: 
  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)
  {}

protected: 
  DataManager *m_dataManager;
}; 

class EquipmentTypesReply final : public ClientMessage
{
public:
  explicit EquipmentTypesReply (DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data);

  void process() override;
  bool hasValidData() const override { return true; }
}; 

class ExercisesRequest final : public ClientMessage
{
public:
  explicit ExercisesRequest (DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data);

  void process() override;
  bool hasValidData() const override { return true; }
}; 

class ParticipantRequest final : public ClientMessage
{
public:
  explicit ParticipantRequest (DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data);

  void process() override;
  bool hasValidData() const override { return true; }
}; 



class EquipmentTypeRequest : public LtsWebSocket::ReplyMessage
{
public:
  EquipmentTypeRequest()
    : LtsWebSocket::ReplyMessage(WebSocketInterface::JsonKeys::EQUIPMENT_TYPES_REQUEST(), 1, QStringLiteral("eins"))
  {}
};

class ExerciseReply : public LtsWebSocket::ReplyMessage
{
public:
  explicit ExerciseReply(const std::shared_ptr<IWMS2ECC_Impl> &wms2ecc);
};

class ExerciseUpdate : public LtsWebSocket::ReplyMessage
{
public:
  explicit ExerciseUpdate(const IWMS2ECC::Exercise &data, DataModification modType);
};

class ParticipantReply : public LtsWebSocket::ReplyMessage
{
public:
  explicit ParticipantReply(const std::shared_ptr<IWMS2ECC_Impl> &wms2ecc, int exerciseId);

};

class ParticipantUpdate : public LtsWebSocket::ReplyMessage
{
public:
  explicit ParticipantUpdate(const IWMS2ECC::PlayerInfo &pl, DataModification modType);
};

class ParticipantRegisterInExconRequest final : public ClientMessage
{
public:
  explicit ParticipantRegisterInExconRequest (DataManager *dataManager, LtsWebSocket::ReplyHandler *client, const QString &type, const int typeId, const QString &uuid, const QJsonValue &data);

  void process() override;
  bool hasValidData() const override { return true; }
}; 


class ParticipantRegisterInExconReply : public LtsWebSocket::ReplyMessage
{
public:
  explicit ParticipantRegisterInExconReply(int exerciseId, qint32 participantId, ParticipantManagement::RegisterReturnValue retValue);

};


class DataManager : public QObject
                  , ParticipantManagement::Interface::Ftc::ModifyEquipmentTypeDataReplyHandler
{
  Q_OBJECT
public:
  explicit DataManager(const std::shared_ptr<IWMS2ECC_Impl> &wms2ecc, const std::shared_ptr<DdsHandler> &ddsHandler, const std::shared_ptr<ExercisesHandler> &exHandler);
  ~DataManager();

  bool init();

  std::shared_ptr<IWMS2ECC_Impl> getWms2Ecc() { return m_wms2ecc; }
  void handleEquipmentTypes(const ::EquipmentTypes &eTypes);
  void registerParticipant(const Registration &reg);

public Q_SLOTS:
  void onParticipantChanged(const ParticipantManagement::Participant &data, DataModification modType, int exerciseId);
  void onExerciseChanged(const ExerciseManagement::Exercise &data, DataModification modType);
  void onRegistrationReturnValue(int exerciseId, qint32 participantId, ParticipantManagement::RegisterReturnValue retValue);

private Q_SLOTS:
  void openWebSocket();
  void closeWebSocket();
  void onWebSocketError(QAbstractSocket::SocketError error);
  void onWebSocketConnected();
  void onWebSocketDisconnected();

  bool addEquipmentTypeRequest();
  bool sendAllExercises();
  bool sendAllParticipants();
  void newTextMessageFromClient(LtsWebSocket::ClientConnection *client, const QString &message);
  void onModifyEquipmentTypeDataReply(const Core::FunctionReplyObject &replyObject) override final;

private:

  ClientMessageFactory *m_messageFactory;
  LtsWebSocket::ClientConnection *m_clientConnection;
  QTimer *m_wsReconnectTimer;
  std::shared_ptr<IWMS2ECC_Impl>    m_wms2ecc;
  std::shared_ptr<DdsHandler>       m_ddsHandler;
  std::shared_ptr<ExercisesHandler> m_exercisesHandler;
};
}