410 lines
14 KiB
C++
Executable File
410 lines
14 KiB
C++
Executable File
/**
|
|
* Handler for all training area objects
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Hanna E. Rathje, SLSE, 2016-03-04
|
|
*/
|
|
|
|
#include "handler_training_area.h"
|
|
#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)
|
|
, m_logger(getLogger("HandlerTrainingArea"))
|
|
{
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
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(m_logger) << "Error reading data from database!";
|
|
return false;
|
|
}
|
|
|
|
for (const Database::AsmMapDescription &data : qAsConst(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(m_logger) << "map2D.insert order =" << data.objOrder;
|
|
break;
|
|
case AssetManagement::MapDescriptionType_def::Scene3D:
|
|
mapDescriptionSeq.scene3D.insert(data.objOrder, data);
|
|
INFO_LOG(m_logger) << "Scene3D.insert order =" << data.objOrder;
|
|
break;
|
|
case AssetManagement::MapDescriptionType_def::Elevation:
|
|
mapDescriptionSeq.elevation.insert(data.objOrder, data);
|
|
INFO_LOG(m_logger) << "Elevation.insert order =" << data.objOrder;
|
|
break;
|
|
case AssetManagement::MapDescriptionType_def::SceneObj:
|
|
mapDescriptionSeq.sceneObj.insert(data.objOrder, data);
|
|
INFO_LOG(m_logger) << "sceneObj.insert order =" << data.objOrder;
|
|
break;
|
|
}
|
|
mapDescriptionSeqences.insert(data.trainingAreaId, mapDescriptionSeq);
|
|
if (ret.error())
|
|
{
|
|
delete ifs;
|
|
ERROR_LOG(m_logger) << ret();
|
|
return false;
|
|
}
|
|
m_objectMapDescriptionMap.insert(ifs->getId(), ifs);
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "m_objectMapDescriptionMap.size() = " << m_objectMapDescriptionMap.size();
|
|
|
|
QVector<Database::AsmTrainingArea> dataVec;
|
|
// read all training areas from database
|
|
if (!m_mainHandler->db()->select(dataVec))
|
|
{
|
|
ERROR_LOG(m_logger) << "Error reading data from database!";
|
|
return false;
|
|
}
|
|
|
|
// create asm_training_area
|
|
for (const Database::AsmTrainingArea &data : qAsConst(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(m_logger) << ret();
|
|
return false;
|
|
}
|
|
m_objectTrainingAreaMap.insert(ifs->getId(), ifs);
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "m_objectTrainingAreaMap.size() = " << m_objectTrainingAreaMap.size();
|
|
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
void HandlerTrainingArea::removeMapDescriptions(int trainingAreaId)
|
|
{
|
|
INFO_LOG(m_logger) << "removeMapDescriptions trainingAreaId = " << trainingAreaId
|
|
<< " m_objectMapDescriptionMap.size = " << m_objectMapDescriptionMap.size();
|
|
QMapIterator< int, ObjectMapDescription *> it(m_objectMapDescriptionMap);
|
|
while ( it.hasNext())
|
|
{
|
|
it.next();
|
|
INFO_LOG(m_logger) << "remove map description key = " << it.key();
|
|
if ( it.value()->getData().trainingAreaId() == trainingAreaId)
|
|
{
|
|
DEBUG_LOG(m_logger) << "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(m_logger) << 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(m_logger) << "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(m_logger) << "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(m_logger) << "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(m_logger) << "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(m_logger) << "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(m_logger) << 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(m_logger) << 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(m_logger) << ret();
|
|
else
|
|
{
|
|
// delete ObjectMapDescription
|
|
delete ifs;
|
|
m_objectMapDescriptionMap.remove(request.id());
|
|
}
|
|
|
|
m_mainHandler->dds()->fts()->mapDescriptionRemoveReply(cookie, ret);
|
|
|
|
return;
|
|
}
|
|
|
|
} // Namespace AssetManagement
|