qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Services/ExerciseManagement/handler_exercise_phase.cpp

/**
  * Handler for all exercise phase objects
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "handler_exercise_phase.h"

#include <QtCore/QDateTime>
#include <QtCore/QString>

#include "dds_handler.h"
#include "exm_db.h"
#include "handler_exercise.h"
#include "object_exercise_phase.h"
#include "object_exercise.h"
#include "main_handler.h"

namespace ExerciseManagement
{

HandlerExercisePhase::HandlerExercisePhase(MainHandler *mainHandler,
                                           const std::shared_ptr<DdsHandler> &ddsHandler,
                                           const std::shared_ptr<DatabaseInterface> &db)
  : Interface::Fts::ExercisePhaseCreateRequestHandler(ddsHandler->fts())
  , Interface::Fts::ExercisePhaseModifyRequestHandler(ddsHandler->fts())
  , Interface::Fts::ExercisePhaseRemoveRequestHandler(ddsHandler->fts())
  , m_mainHandler(mainHandler)
  , m_ddsHandler(ddsHandler)
  , m_db(db)
  , m_logger(getLogger("HandlerExercisePhase"))
{}

HandlerExercisePhase::~HandlerExercisePhase()
{
  qDeleteAll(m_exercisePhaseObjMap);
}

bool HandlerExercisePhase::init()
{
  bool bRet = true;
  // create exercise objects
  auto cbPhase = [this, &bRet](const Database::ExmExercisePhase &data)
  {
    ObjectExercisePhase *ifs(new ObjectExercisePhase(m_ddsHandler, m_db));
    Core::FunctionReplyObject ret = ifs->createObject(data);
    if (ret.error())
    {
      delete ifs;
      ERROR_LOG(m_logger) << ret();
      bRet = false;
      return;
    }
    m_exercisePhaseObjMap.insert(ifs->getId(), ifs);
  };
  if (!m_db->select(cbPhase) || !bRet)
  {
    ERROR_LOG(m_logger) << "Error reading data from database!";
    return true;
  }

  DEBUG_LOG(m_logger) << "m_exercisePhaseObjMap.size() = " << m_exercisePhaseObjMap.size();

  return true;
}

Core::FunctionReplyObject HandlerExercisePhase::exercisePhaseCreateRequest(const ExercisePhaseCreateRequest &request)
{
  Database::ExmExercisePhase newData;

  newData.name        = QString::fromStdString(request.name);
  newData.description = QString::fromStdString(request.description);
  newData.beginTime   = QDateTime::fromMSecsSinceEpoch(request.beginTime);
  newData.endTime     = QDateTime::fromMSecsSinceEpoch(request.endTime);
  newData.exerciseId  = request.exerciseId;

  ObjectExercisePhase *ifs(new ObjectExercisePhase(m_ddsHandler, m_db));
  Core::FunctionReplyObject ret = ifs->createObject(newData);

  if (ret.error())
    delete ifs;
  else
  {
    m_exercisePhaseObjMap.insert(ifs->getId(), ifs);
    ret.setId(ifs->getId());  // set the returned id to the new phase id
  }
  return ret;
}

Core::FunctionReplyObject HandlerExercisePhase::removeAllPhasesByExerciseId(qint64 exerciseId)
{
  QMutableMapIterator<int, ObjectExercisePhase *> it(m_exercisePhaseObjMap);

  while (it.hasNext())
  {
    auto phase = it.next().value()->getData();
    if (exerciseId == phase.exerciseId)
    {
      if (!m_ddsHandler->dts()->removeExercisePhaseByKey(phase.id))
        return Core::FunctionReplyObject(phase.id, tr_lts("dds", "ExercisePhase with id %1 can not be removed from DDS")).arg(phase.id);
      it.remove();
    }
  }

  return Core::FunctionReplyObject();
}

void HandlerExercisePhase::onExercisePhaseCreateRequest(const rti::core::SampleIdentity &cookie,
                                                        const ExercisePhaseCreateRequest &request)
{
  DEBUG_LOG(m_logger) << "onExercisePhaseCreateRequest " << request;
  Core::FunctionReplyObject ret = exercisePhaseCreateRequest(request);
  if (ret.error())
    ERROR_LOG(m_logger) << ret();

  m_ddsHandler->fts()->exercisePhaseCreateReply(cookie, ret);
}

void HandlerExercisePhase::onExercisePhaseModifyRequest(const rti::core::SampleIdentity &cookie, const ExercisePhaseModifyRequest &request)
{
  DEBUG_LOG(m_logger) << "onExercisePhaseModifyRequest " << request;
  Core::FunctionReplyObject ret;

  ObjectExercisePhase *ifs = m_exercisePhaseObjMap.value(request.id);
  if (ifs == nullptr)
  {
    ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "ExercisePhase with id %1 not found")).arg(request.id);
    m_ddsHandler->fts()->exercisePhaseModifyReply(cookie, ret);
    return;
  }

  Database::ExmExercisePhase data;
  data.id          = request.id;
  data.name        = QString::fromStdString(request.name);
  data.description = QString::fromStdString(request.description);
  data.beginTime   = QDateTime::fromMSecsSinceEpoch(request.beginTime);
  data.endTime     = QDateTime::fromMSecsSinceEpoch(request.endTime);
  data.exerciseId  = request.exerciseId;

  ret = ifs->updateObject(data);
  if (ret.error())
    ERROR_LOG(m_logger) << ret();
  m_ddsHandler->fts()->exercisePhaseModifyReply(cookie, ret);
}

void HandlerExercisePhase::onExercisePhaseRemoveRequest(const rti::core::SampleIdentity &cookie, const Core::RemoveElementRequest &request)
{
  DEBUG_LOG(m_logger) << "onExercisePhaseRemoveRequest " << request;
  Core::FunctionReplyObject ret;
  ObjectExercisePhase *ifs = m_exercisePhaseObjMap.value(request.id);

  if (ifs == nullptr)
  {
    ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "ExercisePhase with id %1 not found")).arg(request.id);
    m_ddsHandler->fts()->exercisePhaseRemoveReply(cookie, ret);
    return;
  }

  // check if phase is active phase in corresponding exercise
  ObjectExercise *exercise = m_mainHandler->exerciseHandler()->getExerciseById(ifs->getData().exerciseId);
  if (exercise->data().activePhaseId == request.id)
  {
    ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "ExercisePhase with id %1 is current phase in exercise")).arg(request.id);
    m_ddsHandler->fts()->exercisePhaseRemoveReply(cookie, ret);
    return;
  }

  ExerciseManagement::ExercisePhase ddsData;
  ddsData.id = request.id;

  if (m_mainHandler->dds()->topicLockMaster()->isLocked(ddsData, 0))
  {
    ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "ExercisePhase '%1' is used by another user!")).arg(ifs->getData().name);
    m_mainHandler->dds()->fts()->exercisePhaseRemoveReply(cookie, ret);
    return;
  }

  ret = ifs->removeObject();

  if (ret.error())
    ERROR_LOG(m_logger) << ret();
  else
  {
    // delete ObjectExercise (including ExerciseStateMachine)
    delete ifs;
    m_exercisePhaseObjMap.remove(request.id);
  }

  m_ddsHandler->fts()->exercisePhaseRemoveReply(cookie, ret);
}

} // namespace ExerciseManagement