qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Services/AssetManagement/handler_training_area.cpp

/**
  * Handler for all training area objects
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Hanna E. Rathje, SLSE, 2016-03-04
  */

#include "handler_training_area.h"
#include <utility>
#include "object_training_area.h"
#include "main_handler.h"
#include "convert_db_to_dds.h"
#include <ngldb/dbtransaction.h>

namespace AssetManagement
{
//----------------------------------------------------------------------------------------------
HandlerTrainingArea::HandlerTrainingArea(MainHandler *mainHandler, QObject *parent)
  : QObject(parent)
  , Interface::Fts::TrainingAreaModifyRequestHandler(mainHandler->dds()->fts())
  , Interface::Fts::TrainingAreaRemoveRequestHandler(mainHandler->dds()->fts())
  , Interface::Fts::MapDescriptionModifyRequestHandler(mainHandler->dds()->fts())
  , Interface::Fts::MapDescriptionRemoveRequestHandler(mainHandler->dds()->fts())
  , m_mainHandler(mainHandler)
{
}

//----------------------------------------------------------------------------------------------
HandlerTrainingArea::~HandlerTrainingArea()
{
  qDeleteAll(m_objectTrainingAreaMap);
  qDeleteAll(m_objectMapDescriptionMap);
}

//----------------------------------------------------------------------------------------------
bool HandlerTrainingArea::init()
{
  QMap <int, MapDescriptionSeq> mapDescriptionSeqences; // key = TrainingAreaId

  // create map description objects
  QVector<Database::AsmMapDescription> dataVecMD;
  if (!m_mainHandler->db()->select(dataVecMD))
  {
    ERROR_LOG() << "Error reading data from database!";
    return false;
  }

  for (const Database::AsmMapDescription &data : std::as_const(dataVecMD))
  {
    ObjectMapDescription *ifs(new ObjectMapDescription(m_mainHandler));
    Core::FunctionReplyObject ret = ifs->createObject(convert(data), data.objOrder);
    MapDescriptionSeq mapDescriptionSeq;
    if (mapDescriptionSeqences.contains(data.trainingAreaId))
      mapDescriptionSeq = mapDescriptionSeqences.value(data.trainingAreaId);

    switch (data.mapDescriptionTypeId.underlying())
    {
    case AssetManagement::MapDescriptionType_def::Map2D:
      mapDescriptionSeq.map2D.insert(data.objOrder, data);
      INFO_LOG() << "map2D.insert order =" << data.objOrder;
      break;
    case AssetManagement::MapDescriptionType_def::Scene3D:
      mapDescriptionSeq.scene3D.insert(data.objOrder, data);
      INFO_LOG() << "Scene3D.insert order =" << data.objOrder;
      break;
    case AssetManagement::MapDescriptionType_def::Elevation:
      mapDescriptionSeq.elevation.insert(data.objOrder, data);
      INFO_LOG() << "Elevation.insert order =" << data.objOrder;
      break;
    case AssetManagement::MapDescriptionType_def::SceneObj:
      mapDescriptionSeq.sceneObj.insert(data.objOrder, data);
      INFO_LOG() << "sceneObj.insert order =" << data.objOrder;
      break;
    }
    mapDescriptionSeqences.insert(data.trainingAreaId, mapDescriptionSeq);
    if (ret.error())
    {
      delete ifs;
      ERROR_LOG() << ret();
      return false;
    }
    m_objectMapDescriptionMap.insert(ifs->getId(), ifs);
  }

  DEBUG_LOG() << "m_objectMapDescriptionMap.size() = " << m_objectMapDescriptionMap.size();

  QVector<Database::AsmTrainingArea> dataVec;
  // read all training areas from database
  if (!m_mainHandler->db()->select(dataVec))
  {
    ERROR_LOG() << "Error reading data from database!";
    return false;
  }

  // create asm_training_area
  for (const Database::AsmTrainingArea &data : std::as_const(dataVec))
  {
    // insert sequences of map descriptions in data
    ObjectTrainingArea *ifs(new ObjectTrainingArea(m_mainHandler));
    TrainingArea taData = convert(data);
    // insert sequences
    if (mapDescriptionSeqences.contains(taData.id()) )
    {
      const MapDescriptionSeq mapDescriptionSeq = mapDescriptionSeqences.value(taData.id());

      taData.map2D().reserve(mapDescriptionSeq.map2D.size());
      for (const auto &dbDesc : mapDescriptionSeq.map2D)
        taData.map2D().push_back(ObjectMapDescription::toDdsData(dbDesc));

      taData.scene3D().reserve(mapDescriptionSeq.scene3D.size());
      for (const auto &dbDesc : mapDescriptionSeq.scene3D)
        taData.scene3D().push_back(ObjectMapDescription::toDdsData(dbDesc));

      taData.elevation().reserve(mapDescriptionSeq.elevation.size());
      for (const auto &dbDesc : mapDescriptionSeq.elevation)
        taData.elevation().push_back(ObjectMapDescription::toDdsData(dbDesc));

      taData.sceneObjects().reserve(mapDescriptionSeq.sceneObj.size());
      for (const auto &dbDesc : mapDescriptionSeq.sceneObj)
        taData.sceneObjects().push_back(ObjectMapDescription::toDdsData(dbDesc));
    }
    // end insert sequences
    Core::FunctionReplyObject ret = ifs->createObject(taData);
    if (ret.error())
    {
      delete ifs;
      ERROR_LOG() << ret();
      return false;
    }
    m_objectTrainingAreaMap.insert(ifs->getId(), ifs);
  }

  DEBUG_LOG() << "m_objectTrainingAreaMap.size() = " << m_objectTrainingAreaMap.size();

  return true;
}

//----------------------------------------------------------------------------------------------
void HandlerTrainingArea::removeMapDescriptions(int trainingAreaId)
{
  INFO_LOG() << "removeMapDescriptions trainingAreaId = " << trainingAreaId
                     << " m_objectMapDescriptionMap.size = " << m_objectMapDescriptionMap.size();
  QMapIterator< int, ObjectMapDescription *> it(m_objectMapDescriptionMap);
  while ( it.hasNext())
  {
    it.next();
    INFO_LOG() << "remove map description key = " << it.key();
    if (  it.value()->getData().trainingAreaId() == trainingAreaId)
    {
      DEBUG_LOG() << "remove id= " <<  it.key();

      ObjectMapDescription *ifs = m_objectMapDescriptionMap.value(it.key());

      ifs->removeObject();

      m_objectMapDescriptionMap.remove(it.key());
    }
  }
}

//----------------------------------------------------------------------------------------------
void HandlerTrainingArea::onTrainingAreaModifyRequest(const rti::core::SampleIdentity &cookie,
                                                      const AssetManagement::TrainingArea &request)
{
  const auto ret = trainingAreaModifyRequest(request);
  if (ret.error())
    WARNING_LOG() << ret();
  m_mainHandler->dds()->fts()->trainingAreaModifyReply(cookie, ret);
}

Core::FunctionReplyObject HandlerTrainingArea::trainingAreaModifyRequest(const TrainingArea &request)
{
  TrainingArea ddsData(request);
  ObjectTrainingArea *ifs;

  Core::FunctionReplyObject ret;
  if (request.id() > 0)
  {
    ifs = m_objectTrainingAreaMap.value(request.id());

    if (ifs == nullptr)
      return Core::FunctionReplyObject(request.id(), tr_lts("dds", "Training area with id %1 not found")).arg(request.id());
    ret = ifs->updateObject(ddsData);
    if (ret.error())
      return ret;
  }
  else
  {
    ifs = new ObjectTrainingArea(m_mainHandler);
    ret = ifs->createObject(ddsData);
    if (ret.error())
    {
      delete ifs;
      ifs = nullptr;
      return ret;
    }
    else
      m_objectTrainingAreaMap.insert(ifs->getId(), ifs);
  }
  if (request.id() > 0) // Modify
  {
    DEBUG_LOG() << "modify: delete old entries in map_description";
    removeMapDescriptions(ifs->getId());
  }

  // insert new entries

  auto &map2D = ddsData.map2D();
  map2D.resize(request.map2D().size());
  for (unsigned int i = 0; i < request.map2D().size(); i++)
  {
    MapDescription mdData = request.map2D().at(i);
    ObjectMapDescription *md (new ObjectMapDescription(m_mainHandler));
    mdData.id(0);
    mdData.trainingAreaId(ifs->getId());
    ret = md->createObject(mdData, i);
    DEBUG_LOG() << "insert topographic entries in map_description"
                        << " for training area id " << ifs->getId()
                        << " mapTypeId=" << mdData.mapTypeId()
                        << " mapDescriptionTypeId=" << mdData.mapDescriptionTypeId();
    if (!ret.error())
    {
      map2D[i] = md->getData();
      m_objectMapDescriptionMap.insert(md->getId(), md);
    }
    else
    {
      map2D[i] = MapDescription();
      delete md;
    }
  }

  auto &elevation = ddsData.elevation();
  elevation.resize(request.elevation().size());
  for (unsigned int i = 0; i < request.elevation().size(); i++)
  {
    MapDescription mdData = request.elevation().at(i);
    ObjectMapDescription *md (new ObjectMapDescription(m_mainHandler));
    mdData.id(0);
    mdData.trainingAreaId(ifs->getId());
    ret = md->createObject(mdData, i);
    DEBUG_LOG() << "insert elevation entries in map_description"
                        << " for training area id " << ifs->getId()
                        << " mapTypeId=" << mdData.mapTypeId()
                        << " mapDescriptionTypeId=" << mdData.mapDescriptionTypeId();
    if (!ret.error())
    {
      elevation[i] = md->getData();
      m_objectMapDescriptionMap.insert(md->getId(), md);
    }
    else
    {
      elevation[i] = MapDescription();
      delete md;
    }
  }

  auto &scene3D = ddsData.scene3D();
  scene3D.resize(request.scene3D().size());
  for (unsigned int i = 0; i < request.scene3D().size(); i++)
  {
    MapDescription mdData = request.scene3D().at(i);
    ObjectMapDescription *md (new ObjectMapDescription(m_mainHandler));
    mdData.id(0);
    mdData.trainingAreaId(ifs->getId());
    ret = md->createObject(mdData, i);
    DEBUG_LOG() << "insert scene3D entries in map_description"
                        << " for training area id " << ifs->getId()
                        << " mapTypeId=" << mdData.mapTypeId()
                        << " mapDescriptionTypeId=" << mdData.mapDescriptionTypeId();
    if (!ret.error())
    {
      scene3D[i] = md->getData();
      m_objectMapDescriptionMap.insert(md->getId(), md);
    }
    else
    {
      scene3D[i] = MapDescription();
      delete md;
    }
  }

  auto &sceneObj = ddsData.sceneObjects();
  sceneObj.resize(request.sceneObjects().size());
  for (unsigned int i = 0; i < request.sceneObjects().size(); i++)
  {
    MapDescription mdData = request.sceneObjects().at(i);
    ObjectMapDescription *md (new ObjectMapDescription(m_mainHandler));
    mdData.id(0);
    mdData.trainingAreaId(ifs->getId());
    ret = md->createObject(mdData, i);
    DEBUG_LOG() << "insert sceneObjects entries in map_description"
                        << " for training area id " << ifs->getId()
                        << " mapTypeId=" << mdData.mapTypeId()
                        << " mapDescriptionTypeId=" << mdData.mapDescriptionTypeId();
    if (!ret.error())
    {
      sceneObj[i] = md->getData();
      m_objectMapDescriptionMap.insert(md->getId(), md);
    }
    else
    {
      sceneObj[i] = MapDescription();
      delete md;
    }
  }

  ddsData.id(ifs->getId());
  return ifs->updateObject(ddsData);
}

//----------------------------------------------------------------------------------------------
void HandlerTrainingArea::onTrainingAreaRemoveRequest(const rti::core::SampleIdentity &cookie,
                                                      const Core::RemoveElementRequest &request)
{
  Core::FunctionReplyObject ret;
  ObjectTrainingArea *ifs = m_objectTrainingAreaMap.value(request.id());
  if (ifs == nullptr)
  {
    ret = Core::FunctionReplyObject(request.id(), tr_lts("dds", "Training area with id %1 not found")).arg(request.id());
    m_mainHandler->dds()->fts()->trainingAreaRemoveReply(cookie, ret);
    return;
  }

  if (m_mainHandler->dds()->topicLockMaster()->isLocked(ifs->getData(), m_mainHandler->exerciseId()))
  {
    ret = Core::FunctionReplyObject(request.id(), tr_lts("dds", "Training area '%1' is used by another user!")).arg(ifs->getName());
    m_mainHandler->dds()->fts()->trainingAreaRemoveReply(cookie, ret);
    return;
  }

  DBTransaction trans(m_mainHandler->db()->database());

  ret = ifs->removeObject();

  if (ret.error())
    ERROR_LOG() << ret();
  else
  {
    // delete ObjectTrainingArea
    delete ifs;
    m_objectTrainingAreaMap.remove(request.id());
    removeMapDescriptions(request.id());
    trans.commit();
  }

  m_mainHandler->dds()->fts()->trainingAreaRemoveReply(cookie, ret);

  return;
}

//----------------------------------------------------------------------------------------------
void HandlerTrainingArea::onMapDescriptionModifyRequest(const rti::core::SampleIdentity &cookie,
                                                        const MapDescription &request)
{
  const auto ret = mapDescriptionModifyRequest(request);
  if (ret.error())
    WARNING_LOG() << ret();
  m_mainHandler->dds()->fts()->mapDescriptionModifyReply(cookie, ret);
}

Core::FunctionReplyObject HandlerTrainingArea::mapDescriptionModifyRequest(const MapDescription &request)
{
  ObjectMapDescription *ifs = m_objectMapDescriptionMap.value(request.id());

  if (ifs == nullptr)
    return Core::FunctionReplyObject(request.id(), tr_lts("dds", "MapDescription with id %1 not found")).arg(request.id());

  return ifs->updateObject(request);
}

//----------------------------------------------------------------------------------------------
void HandlerTrainingArea::onMapDescriptionRemoveRequest(const rti::core::SampleIdentity &cookie,
                                                        const Core::RemoveElementRequest &request)
{
  Core::FunctionReplyObject ret;
  ObjectMapDescription *ifs = m_objectMapDescriptionMap.value(request.id());
  if (ifs == nullptr)
  {
    ret = Core::FunctionReplyObject(request.id(), tr_lts("dds", "MapDescription with id %1 not found")).arg(request.id());
    m_mainHandler->dds()->fts()->mapDescriptionRemoveReply(cookie, ret);
    return;
  }

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

  ret = ifs->removeObject();

  if (ret.error())
    ERROR_LOG() << ret();
  else
  {
    // delete ObjectMapDescription
    delete ifs;
    m_objectMapDescriptionMap.remove(request.id());
  }

  m_mainHandler->dds()->fts()->mapDescriptionRemoveReply(cookie, ret);

  return;
}

} // Namespace AssetManagement