qt-migration-legatus/qt6-after/qt6-migrated-legatus/Lts/Services/MarkerManagement/handler_marker.cpp

/**
  * Handler for all marker objects
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by hjl, SLSE, 2016-04-12
  */

#include "handler_marker.h"
#include "object_marker.h"
#include "dds_handler.h"

namespace MarkerManagement
{

HandlerMarker::HandlerMarker(const std::shared_ptr<DdsHandler> &ddsHandler,
                             const std::shared_ptr<DatabaseInterface> &db)
  : Interface::Fts::MarkerModifyRequestHandler(ddsHandler->fts())
  , Interface::Fts::MarkerRemoveRequestHandler(ddsHandler->fts())
  , m_ddsHandler(ddsHandler)
  , m_db(db)
  , m_logger(getLogger("HandlerMarker"))
{
} // end of ctor()
//-----------------------------------------------------------------------------

HandlerMarker::~HandlerMarker()
{
  qDeleteAll(m_objectMarkerMap);
} // end of dtor()
//-----------------------------------------------------------------------------

bool HandlerMarker::init()
{
  INFO_LOG(m_logger) << "--- Start MarkerManagement HandlerMarker.";

  QVector<Database::MrkMarkerDescription> dataDescriptionVec;

  // read all marker from database
  if (!m_db->select(dataDescriptionVec))
  {
    ERROR_LOG(m_logger) << "Error reading data from database!";
    return false;
  }

  // create markerObjects
  bool bRet = true;
  auto cb = [this, &bRet, &dataDescriptionVec] (const Database::MrkMarker &data)
  {
    Marker ddsMoData = ObjectMarker::toDdsData(data);

    // alle Descriptions zu der Marke eintragen
    // TODO: select descBymarkerId
    for (const Database::MrkMarkerDescription &desc : qAsConst(dataDescriptionVec))
    {
      if (desc.markerId == ddsMoData.id)
        ddsMoData.descriptions.push_back(ObjectMarker::toDdsData(desc));
    }

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

    if (ret.error())
    {
      delete ifs;
      ERROR_LOG(m_logger) << ret();
      bRet = false;
      return;
    }
    m_objectMarkerMap.insert(ifs->getId(), ifs);
  };
  if (!m_db->select(cb) || !bRet)
  {
    ERROR_LOG(m_logger) << "Error reading data from database!";
    return false;
  }

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

  if (m_ddsHandler->fts() == nullptr)
  {
    ERROR_LOG(m_logger) << "m_ddsHandler->fts() == nullptr!";
    return false;
  }

  return true;
} // end of init()
//-----------------------------------------------------------------------------

void HandlerMarker::onMarkerModifyRequest(const rti::core::SampleIdentity &cookie,
                                          const Marker &request)
{
  DEBUG_LOG(m_logger) << "MarkerModifyRequest: " << request;
  auto ret = request.id > 0 ? markerModifyRequest(request) : markerCreateRequest(request);
  if (ret.error())
    WARNING_LOG(m_logger) << ret();
  m_ddsHandler->fts()->markerModifyReply(cookie, ret);
}
//-----------------------------------------------------------------------------

Core::FunctionReplyObject HandlerMarker::markerCreateRequest(const Marker &request)
{
  if (m_objectMarkerMap.size() > 5000)
    return Core::FunctionReplyObject(tr_lts("dds", "Can not create more than 5000 marker."));

  ObjectMarker *ifs(new ObjectMarker(m_ddsHandler, m_db));
  const Core::FunctionReplyObject ret = ifs->createObject(request);
  if (ret.error())
  {
    delete ifs;
    return ret;
  }

  m_objectMarkerMap.insert(ifs->getId(), ifs);

  return ret;

} // end of onMarkerCreateRequest()
//-----------------------------------------------------------------------------

Core::FunctionReplyObject HandlerMarker::markerModifyRequest(const Marker &request)
{
  ObjectMarker *ifs = m_objectMarkerMap.value(request.id);
  if (ifs == nullptr)
    return Core::FunctionReplyObject(request.id,
                                     tr_lts("dds", "Marker with id %1 not found")).arg(request.id);

  return ifs->updateObject(request);
} // end of markerModifyRequest()
//-----------------------------------------------------------------------------

void HandlerMarker::onMarkerRemoveRequest(const rti::core::SampleIdentity &cookie,
                                          const Core::RemoveElementRequest &request)
{
  DEBUG_LOG(m_logger) << "MarkerRemoveRequest: " << request;
  auto ret = markerRemoveRequest(request);
  if (ret.error())
    WARNING_LOG(m_logger) << ret();
  m_ddsHandler->fts()->markerRemoveReply(cookie, ret);
}
//-----------------------------------------------------------------------------

Core::FunctionReplyObject HandlerMarker::markerRemoveRequest(const Core::RemoveElementRequest &request)
{
  ObjectMarker *ifs = m_objectMarkerMap.value(request.id);
  if (ifs == nullptr)
    return Core::FunctionReplyObject(request.id,
                                     tr_lts("dds", "Marker with id %1 not found")).arg(request.id);

  if (m_ddsHandler->topicLockMaster()->isLocked(ifs->getData(), m_ddsHandler->ddsConnector()->getPartitionId()))
    return Core::FunctionReplyObject(request.id, tr_lts("dds", "Marker '%1' is used by another user!")).arg(ifs->getName());

  const Core::FunctionReplyObject ret = ifs->removeObject();

  if (ret.error())
    return ret;

  // delete ObjectMarker
  delete ifs;
  m_objectMarkerMap.remove(request.id);

  return ret;
} // end of onMarkerRemoveRequest()
//-----------------------------------------------------------------------------

} // namespace MarkerManagement