684 lines
30 KiB
C++
Executable File
684 lines
30 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* ISM Handler Main Structure Elements
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Iuliana Ojog, SLSE, 2016-11-26
|
|
*/
|
|
|
|
#include "handler_main_structure_element.h"
|
|
#include "handler_mounting_point_asset.h"
|
|
#include "handler_instrumentation_asset.h"
|
|
#include "object_main_structure_element.h"
|
|
#include "object_structure_element.h"
|
|
#include "object_instrumentation_asset.h"
|
|
#include <ngldb/dbtransaction.h>
|
|
#include "convert_db_to_dds.h"
|
|
#include <QJsonObject>
|
|
#include <QJsonDocument>
|
|
|
|
namespace InfrastructureManagement
|
|
{
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------------------------------------
|
|
HandlerMainStructureElement::HandlerMainStructureElement(MainHandler *mainHandler)
|
|
: Base(mainHandler, getLogger("HandlerMainStructureElement"))
|
|
, Interface::Fts::MainStructureElementModifyRequestHandler(mainHandler->dds()->fts())
|
|
, Interface::Fts::MainStructureElementModifyBridgeStatusRequestHandler(m_mainHandler->dds()->fts())
|
|
, Interface::Fts::MainStructureElementModifyPositionRequestHandler(m_mainHandler->dds()->fts())
|
|
, Interface::Fts::MainStructureElementRemoveRequestHandler(mainHandler->dds()->fts())
|
|
, Interface::Fts::StructureElementModifyRequestHandler(mainHandler->dds()->fts())
|
|
, Interface::Fts::StructureElementUpdateEffectOverrideRequestHandler(mainHandler->dds()->fts())
|
|
{
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------------------------------------
|
|
HandlerMainStructureElement::~HandlerMainStructureElement()
|
|
{
|
|
qDeleteAll(m_objectMainStructureElementMap);
|
|
// ptr in m_objectStructureElementMap are deleted inside their corresponding MainStructureElement objects
|
|
// qDeleteAll(m_objectStructureElementMap);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------------------------------------
|
|
bool HandlerMainStructureElement::init()
|
|
{
|
|
// read all MSE from database
|
|
QVector<Database::IsmMainStructureElement> dataVec;
|
|
if (!db()->select(dataVec))
|
|
{
|
|
ERROR_LOG(m_logger) << "Error reading data from database!";
|
|
return false;
|
|
}
|
|
// read all SE from database
|
|
QVector<Database::IsmStructureElement> dataVecSE;
|
|
if (!db()->select(dataVecSE))
|
|
{
|
|
ERROR_LOG(m_logger) << "Error reading data from database!";
|
|
return false;
|
|
}
|
|
// TODO: add sql 'ORDER BY foo' support
|
|
auto sortSE = [](const Database::IsmStructureElement & e1, const Database::IsmStructureElement & e2)
|
|
{
|
|
return e1.id < e2.id;
|
|
};
|
|
std::sort(dataVecSE.begin(), dataVecSE.end(), sortSE);
|
|
|
|
// create MSE objects
|
|
for (const Database::IsmMainStructureElement &dbData : qAsConst(dataVec))
|
|
{
|
|
ObjectMainStructureElement *ifs(new ObjectMainStructureElement(dbData, m_mainHandler));
|
|
m_objectMainStructureElementMap.insert(ifs->getId(), ifs);
|
|
}
|
|
DEBUG_LOG(m_logger) << "m_objectMainStructureElementMap.size() = " << m_objectMainStructureElementMap.size();
|
|
|
|
// create SE objects, add them to MSE
|
|
for (const Database::IsmStructureElement &dbData : qAsConst(dataVecSE))
|
|
{
|
|
ObjectMainStructureElement *objMse = m_objectMainStructureElementMap.value(dbData.mainStructureElementId);
|
|
if (!objMse || !objMse->isValid())
|
|
{
|
|
WARNING_LOG(m_logger) << "Cannot find Main Structure Element Id = " << dbData.mainStructureElementId
|
|
<< " for structure element " << dbData.id;
|
|
continue;
|
|
}
|
|
|
|
ObjectStructureElement *ifse = objMse->createStructureElementObject(dbData);
|
|
if (!ifse)
|
|
{
|
|
ERROR_LOG(m_logger) << "Could not create SE!";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// add structure elements to global map for lookup (e.g. in 'add Footprints to MSE objects')
|
|
for (ObjectMainStructureElement *objMse : qAsConst(m_objectMainStructureElementMap))
|
|
m_objectStructureElementMap.unite(objMse->getStructureElements());
|
|
|
|
// add Footprints to MSE objects
|
|
// read all FP from database
|
|
QMap<int, QMap<int, Database::IsmStructureElementFootprint>> footprintSorted;
|
|
{
|
|
auto cb = [&footprintSorted](const Database::IsmStructureElementFootprint & fp)
|
|
{
|
|
footprintSorted[fp.structureElementId][fp.indexNo] = fp;
|
|
};
|
|
if (!db()->select(cb))
|
|
{
|
|
ERROR_LOG(m_logger) << "Error reading data from database!";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for (const QMap<int, Database::IsmStructureElementFootprint> &cont : qAsConst(footprintSorted))
|
|
{
|
|
if (cont.empty())
|
|
continue;
|
|
const int structureElementId = cont.first().structureElementId;
|
|
const ObjectStructureElement *objSe = m_objectStructureElementMap.value(structureElementId);
|
|
ObjectMainStructureElement *objMse = objSe ? m_objectMainStructureElementMap.value(objSe->getMainStructureElementId()) : nullptr;
|
|
if (!objMse || !objMse->isValid())
|
|
{
|
|
WARNING_LOG(m_logger) << "Cannot find Main Structure Element Id = " << structureElementId
|
|
<< " for footprint element " << cont.first().id;
|
|
continue;
|
|
}
|
|
std::vector<FootprintElement> elements;
|
|
elements.reserve(cont.size());
|
|
FootprintElement elem;
|
|
for (const auto &pos : cont)
|
|
{
|
|
elem.id = pos.id;
|
|
elem.relPosition = Core::RelativePosition(pos.relPosition.x(),
|
|
pos.relPosition.y(),
|
|
pos.relPosition.z());
|
|
elem.isGroundLevel = pos.isGroundLevel;
|
|
elements.push_back(elem);
|
|
}
|
|
objMse->setFootprintData(elements);
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "m_objectStructureElementMap.size() = " << m_objectStructureElementMap.size();
|
|
|
|
// publish
|
|
for (auto it = m_objectMainStructureElementMap.begin(); it != m_objectMainStructureElementMap.end(); ++it)
|
|
{
|
|
const int buildingId = it.key();
|
|
publishMainStructureElement(buildingId);
|
|
it.value()->noticeNewProperties();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------------------------------------
|
|
void HandlerMainStructureElement::onMainStructureElementModifyRequest(const rti::core::SampleIdentity &cookie,
|
|
const MainStructureElementModifyRequest &request)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onMainStructureElementModifyRequest: " << request;
|
|
const Core::FunctionReplyObject ret = request.id == 0 ? onMainStructureElementCreate(request) : onMainStructureElementModify(request);
|
|
if (ret.error())
|
|
ERROR_LOG(m_logger) << ret()
|
|
<< " request.id()=" << request.id;
|
|
m_mainHandler->dds()->fts()->mainStructureElementModifyReply(cookie, ret);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------------------------------------
|
|
Core::FunctionReplyObject HandlerMainStructureElement::onMainStructureElementCreate(const MainStructureElementModifyRequest &request)
|
|
{
|
|
if (request.elements.size() < 1)
|
|
return Core::FunctionReplyObject(0, tr_lts("dds", "No structure elements given"));
|
|
if (request.elements.size() != request.childParentRelations.size())
|
|
return Core::FunctionReplyObject(0, tr_lts("dds", "Structure elements do not match child - parent relations"));
|
|
|
|
const StructureElement &seBuilding = request.elements.at(0);
|
|
const InfrastructureManagement::StructureElementType &seType = seBuilding.structureElementTypeId;
|
|
if ((seType != InfrastructureManagement::StructureElementType::Building &&
|
|
seType != InfrastructureManagement::StructureElementType::Announcement &&
|
|
seType != InfrastructureManagement::StructureElementType::ApproachingPoint &&
|
|
seType != InfrastructureManagement::StructureElementType::MeteoDataUnit &&
|
|
seType != InfrastructureManagement::StructureElementType::RadioStation &&
|
|
seType != InfrastructureManagement::StructureElementType::Bridge) ||
|
|
seBuilding.mountingPointTypeId != InfrastructureManagement::MountingPointType::Unknown)
|
|
return Core::FunctionReplyObject(0, tr_lts("dds", "First structure element is not from a top level type"));
|
|
|
|
if (request.elements.size() > 1) // Buildings must have min 2 elements
|
|
{
|
|
const StructureElement &seBuildingBCU = request.elements.at(1);
|
|
if (seBuildingBCU.structureElementTypeId != InfrastructureManagement::StructureElementType::MountingPoint ||
|
|
seBuildingBCU.mountingPointTypeId != InfrastructureManagement::MountingPointType::BuildingControlUnit)
|
|
return Core::FunctionReplyObject(0, tr_lts("dds", "Second structure element is not from type 'MountingPoint' for 'BuildingControlUnit'"));
|
|
}
|
|
|
|
InfrastructureManagement::ObjectMainStructureElement *ifs(new ObjectMainStructureElement(m_mainHandler));
|
|
Core::FunctionReplyObject ret = ifs->createObject(request);
|
|
if (ret.error())
|
|
{
|
|
delete ifs;
|
|
return ret;
|
|
}
|
|
|
|
// add MSE, SE in corresponding maps
|
|
const int buildingId = ifs->getId();
|
|
m_objectMainStructureElementMap.insert(buildingId, ifs);
|
|
|
|
const ObjectStructureElement *oseBcu = ifs->getMainStructureElementMountingPoint();
|
|
bool bMountSucessful = false;
|
|
if (oseBcu)
|
|
{
|
|
// after adding elements to m_objectMainStructureElementMap / m_objectStructureElementMap!
|
|
ObjectInstrumentationAsset *objAsset = m_mainHandler->getHandlerInstrumentationAsset()->createInstrumentationAssetForMse(ifs->getId(),
|
|
oseBcu->getId());
|
|
if (objAsset)
|
|
{
|
|
if (m_mainHandler->getHandlerMountingPointAsset()->mount(objAsset->getId(), oseBcu->getId()))
|
|
bMountSucessful = true;
|
|
}
|
|
}
|
|
if (!bMountSucessful)
|
|
ERROR_LOG(m_logger) << "Can not create/mount an asset for main structure element " << ifs->getId();
|
|
|
|
// publish MSE
|
|
publishMainStructureElement(buildingId);
|
|
|
|
return ret;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------------------------------------
|
|
Core::FunctionReplyObject HandlerMainStructureElement::onMainStructureElementModify(const MainStructureElementModifyRequest &request)
|
|
{
|
|
InfrastructureManagement::ObjectMainStructureElement *ifs = m_objectMainStructureElementMap.value(request.id);
|
|
if (ifs == nullptr)
|
|
return Core::FunctionReplyObject(request.id, tr_lts("dds", "MainStructureElement with id %1 not found")).arg(request.id);
|
|
|
|
Core::FunctionReplyObject ret = ifs->updateObject(request);
|
|
if (ret.error())
|
|
return ret;
|
|
|
|
// updating corresponding SE, if exists
|
|
if (ifs->getStructureElementId() > 0)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Updating corresponding Structure Element id = " << ifs->getStructureElementId();
|
|
|
|
InfrastructureManagement::ObjectStructureElement *ifse = m_objectStructureElementMap.value(ifs->getStructureElementId());
|
|
if (!ifse)
|
|
return Core::FunctionReplyObject(request.id, tr_lts("dds", "StructureElement with id %1 not found for MainStructureElement %2"))
|
|
.arg(ifs->getStructureElementId()).arg(request.id);
|
|
InfrastructureManagement::StructureElement seData = ifse->getData();
|
|
|
|
seData.name = request.name;
|
|
seData.displayName = ifse->getData().displayName;
|
|
DEBUG_LOG(m_logger) << "Updating corresponding Structure Element id = " << ifs->getStructureElementId()
|
|
<< " seData.displayName=" << seData.displayName;
|
|
|
|
Core::FunctionReplyObject retSe = ifse->updateObject(seData);
|
|
if (retSe.error())
|
|
return retSe;
|
|
}
|
|
|
|
publishMainStructureElement(request.id);
|
|
|
|
return ret;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------------------------------------
|
|
void HandlerMainStructureElement::onMainStructureElementRemoveRequest(const rti::core::SampleIdentity &cookie,
|
|
const InfrastructureManagement::MainStructureElementRemoveRequest &request)
|
|
{
|
|
Core::FunctionReplyObject ret;
|
|
int buildingId = request.id;
|
|
|
|
// gest MSE object
|
|
InfrastructureManagement::ObjectMainStructureElement *ifs = m_objectMainStructureElementMap.value(buildingId);
|
|
if (ifs == nullptr)
|
|
{
|
|
ret = Core::FunctionReplyObject(buildingId, tr_lts("dds", "MainStructureElement with id %1 not found")).arg(buildingId);
|
|
m_mainHandler->dds()->fts()->mainStructureElementRemoveReply(cookie, ret);
|
|
return;
|
|
}
|
|
|
|
if (m_mainHandler->dds()->topicLockMaster()->isLocked(ifs->getData(), m_mainHandler->exerciseId()))
|
|
{
|
|
ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "MainStructureElement '%1' is used by another user!")).arg(ifs->getName());
|
|
m_mainHandler->dds()->fts()->mainStructureElementRemoveReply(cookie, ret);
|
|
return;
|
|
}
|
|
|
|
// Unmount and remove the BuildingControlUnit which was implicitly created and mounted upon import of the Building.
|
|
const ObjectStructureElement *bcuMountingPoint = ifs->getMainStructureElementMountingPoint();
|
|
int bcuAssetId = 0;
|
|
if (bcuMountingPoint)
|
|
bcuAssetId = m_mainHandler->getHandlerMountingPointAsset()->getMountedAssetId(bcuMountingPoint->getId());
|
|
|
|
if (bcuAssetId == 0 || !m_mainHandler->getHandlerInstrumentationAsset()->removeInstrumentationAssetForMse(bcuAssetId))
|
|
WARNING_LOG(m_logger) << "Can not remove BuildingControlUnit with id " << bcuAssetId << " from main structure element which got removed: " << buildingId;
|
|
|
|
// remove MSE elements from local map and unmount the assets from mounting points
|
|
const auto seElements = ifs->getStructureElements();
|
|
for (ObjectStructureElement *ose : seElements)
|
|
{
|
|
if (ose->getStructureElementTypeId() == StructureElementType::MountingPoint)
|
|
{
|
|
int mountedAssetId = m_mainHandler->getHandlerMountingPointAsset()->getMountedAssetId(ose->getId());
|
|
if (mountedAssetId > 0)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Unmounting instrumentation asset with id " << mountedAssetId << " from mounting point with id " << ose->getId();
|
|
if (!m_mainHandler->getHandlerMountingPointAsset()->unmountAsset(mountedAssetId))
|
|
WARNING_LOG(m_logger) << "Can not unmount instrumentation asset with id " << mountedAssetId << " from mounting point " << ose->getId();
|
|
}
|
|
}
|
|
m_objectStructureElementMap.remove(ose->getId());
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "Deleting MSE id = " << buildingId;
|
|
ret = ifs->removeObject(); // removes all from db due to fk
|
|
if (ret.error())
|
|
ERROR_LOG(m_logger) << ret();
|
|
|
|
// delete ObjectMainStructureElement (including Map)
|
|
delete ifs;
|
|
m_objectMainStructureElementMap.remove(buildingId);
|
|
|
|
dts()->removeMainStructureElementByKey(buildingId);
|
|
dts()->removeMainFootprintByKey(buildingId);
|
|
|
|
m_mainHandler->dds()->fts()->mainStructureElementRemoveReply(cookie, ret);
|
|
|
|
return;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------------
|
|
void HandlerMainStructureElement::onMainStructureElementModifyPositionRequest(const rti::core::SampleIdentity &cookie,
|
|
const MainStructureElementModifyPositionRequest &request)
|
|
{
|
|
const int mseId = request.id;
|
|
Core::FunctionReplyObject ret;
|
|
InfrastructureManagement::ObjectMainStructureElement *ifs = m_objectMainStructureElementMap.value(mseId);
|
|
if (ifs == nullptr)
|
|
ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "MainStructureElement with id %1 not found")).arg(mseId);
|
|
else
|
|
{
|
|
ret = ifs->updatePosition(request.geoPosition);
|
|
if (!ret.error())
|
|
publishMainStructureElement(request.id);
|
|
}
|
|
m_mainHandler->dds()->fts()->mainStructureElementModifyPositionReply(cookie, ret);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------------
|
|
void HandlerMainStructureElement::onMainStructureElementModifyBridgeStatusRequest(const rti::core::SampleIdentity &cookie,
|
|
const MainStructureElementModifyBridgeStatusRequest &request)
|
|
{
|
|
static int s_id = 1;
|
|
const int mseId = request.id;
|
|
Core::FunctionReplyObject ret;
|
|
InfrastructureManagement::ObjectMainStructureElement *ifs = m_objectMainStructureElementMap.value(mseId);
|
|
if (ifs == nullptr)
|
|
ret = Core::FunctionReplyObject(request.id, tr_lts("dds", "MainStructureElement with id %1 not found")).arg(mseId);
|
|
else
|
|
{
|
|
ret = ifs->setBridgeStatus(request.status);
|
|
if (!ret.error())
|
|
{
|
|
publishMainStructureElement(request.id);
|
|
// publish BridgeStatus
|
|
BridgeChangeStatus bcs;
|
|
bcs.id = s_id++;
|
|
bcs.buildingId = mseId;
|
|
bcs.sampleTime = QDateTime::currentMSecsSinceEpoch();
|
|
bcs.status = request.status;
|
|
m_mainHandler->dds()->dts()->publish(bcs);
|
|
}
|
|
}
|
|
m_mainHandler->dds()->fts()->mainStructureElementModifyBridgeStatusReply(cookie, ret);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------------
|
|
void HandlerMainStructureElement::onStructureElementModifyRequest(const rti::core::SampleIdentity &cookie,
|
|
const StructureElementModifyRequest &request)
|
|
{
|
|
const Core::FunctionReplyObject ret = onStructureElementModify(request);
|
|
if (ret.error())
|
|
ERROR_LOG(m_logger) << ret();
|
|
m_mainHandler->dds()->fts()->structureElementModifyReply(cookie, ret);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------------
|
|
void HandlerMainStructureElement::onStructureElementUpdateEffectOverrideRequest(const rti::core::SampleIdentity &cookie,
|
|
const StructureElementUpdateEffectOverrideRequest &request)
|
|
{
|
|
INFO_LOG(m_logger) << "onStructureElementUpdateEffectOverrideRequest "
|
|
<< " structureElementId=" << request.structureElementId
|
|
<< " effectId=" << request.effectId
|
|
<< " effectOverride=" << request.effectOverride;
|
|
|
|
if (!m_objectStructureElementMap.contains(request.structureElementId))
|
|
{
|
|
ERROR_LOG(m_logger) << "structureElementId=" << request.structureElementId << " not valid";
|
|
const Core::FunctionReplyObject ret = Core::FunctionReplyObject(-1, tr_lts("dds", "structureElementId %1 not valid")).arg(request.structureElementId);
|
|
m_mainHandler->dds()->fts()->structureElementUpdateEffectOverrideReply(cookie, ret);
|
|
return;
|
|
}
|
|
InfrastructureManagement::StructureElement structureElement = getStructureElement(request.structureElementId)->getData();
|
|
udpatePropertiesForRelayOverride(request.effectId, request.effectOverride, structureElement);
|
|
InfrastructureManagement::ObjectStructureElement *ifse = m_objectStructureElementMap.value(structureElement.id);
|
|
StructureElementModifyRequest requestSe;
|
|
int mseId = ifse->getMainStructureElementId();
|
|
//m_mainHandler->dds()->dts()->getBuildingId (structureElement.id(), mseId);
|
|
requestSe.mainStructureElementId = mseId;
|
|
requestSe.elements.resize(1);
|
|
requestSe.elements[0] = structureElement;
|
|
const Core::FunctionReplyObject ret = onStructureElementModify(requestSe);
|
|
|
|
if (ret.error())
|
|
ERROR_LOG(m_logger) << ret();
|
|
m_mainHandler->dds()->fts()->structureElementUpdateEffectOverrideReply(cookie, ret);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------------
|
|
void HandlerMainStructureElement::changeBuildingNameinMountingPoints(const StructureElement &se, MainStructureElementModifyRequest &mseData)
|
|
{
|
|
QString oldBuildingName;
|
|
QString newBuildingName;
|
|
|
|
// search old building Display Name:
|
|
for (auto it = m_objectStructureElementMap.begin(); it != m_objectStructureElementMap.end(); ++it)
|
|
{
|
|
const int structureElementId = it.key();
|
|
const int buildingId = se.mainStructureElementId;
|
|
ObjectStructureElement *ose = it.value();
|
|
|
|
DEBUG_LOG(m_logger) << "buildingId=" << buildingId
|
|
<< " structureElementId=" << structureElementId
|
|
<< " se.id=" << se.id
|
|
<< " id=" << ose->getId()
|
|
<< " type=" << ose->getStructureElementTypeId()
|
|
<< " displayName=" << ose->getData().displayName
|
|
<< " MainStructureElementId=" << ose->getMainStructureElementId();
|
|
if ((buildingId == ose->getMainStructureElementId())
|
|
//&& (ose->getStructureElementTypeId() == StructureElementType::Building))
|
|
&& (ose->getData().mountingPointTypeId == MountingPointType::BuildingControlUnit))
|
|
{
|
|
oldBuildingName = QString::fromStdString(ose->getData().displayName);
|
|
newBuildingName = QString::fromStdString(se.displayName);
|
|
DEBUG_LOG(m_logger) << "old BuildingName= " << oldBuildingName
|
|
<< " newBuildingName= " << newBuildingName;
|
|
break;
|
|
}
|
|
}
|
|
// search for mse
|
|
for (auto it = m_objectStructureElementMap.begin(); it != m_objectStructureElementMap.end(); ++it)
|
|
{
|
|
const int structureElementId = it.key();
|
|
const int buildingId = se.mainStructureElementId;
|
|
ObjectStructureElement *ose = it.value();
|
|
|
|
DEBUG_LOG(m_logger) << "buildingId=" << buildingId
|
|
<< " structureElementId=" << structureElementId
|
|
<< " se.id=" << se.id
|
|
<< " id=" << ose->getId()
|
|
<< " type=" << ose->getStructureElementTypeId()
|
|
<< " displayName=" << ose->getData().displayName
|
|
<< " MainStructureElementId=" << ose->getMainStructureElementId();
|
|
if ((buildingId == ose->getMainStructureElementId())
|
|
&& ((ose->getStructureElementTypeId() == StructureElementType::MountingPoint)
|
|
|| (ose->getStructureElementTypeId() == StructureElementType::Building)))
|
|
{
|
|
QString displayName = QString::fromStdString(ose->getData().displayName);
|
|
if (displayName.contains(oldBuildingName))
|
|
{
|
|
DEBUG_LOG(m_logger) << "update = displayName=" << displayName
|
|
<< " oldBuildingName=" << oldBuildingName
|
|
<< " newBuildingName=" << newBuildingName;
|
|
displayName.replace(oldBuildingName, newBuildingName);
|
|
|
|
InfrastructureManagement::StructureElement seData = ose->getData();
|
|
seData.displayName = displayName.toStdString();
|
|
|
|
// update mseData before publishing
|
|
for (size_t j = 0; j < mseData.elements.size(); ++j)
|
|
{
|
|
const StructureElement &curSe = mseData.elements.at(j);
|
|
if (curSe.id == structureElementId)
|
|
{
|
|
DEBUG_LOG(m_logger) << "i=" << j
|
|
<< " id=" << curSe.id
|
|
<< " displayName=" << curSe.displayName;
|
|
mseData.elements.at(j) = seData;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Core::FunctionReplyObject retSe = ose->updateObject(seData);
|
|
if (retSe.error())
|
|
ERROR_LOG(m_logger) << "Error update displayName:" << displayName;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------------------------------------------------------------
|
|
Core::FunctionReplyObject HandlerMainStructureElement::onStructureElementModify(const StructureElementModifyRequest &request)
|
|
{
|
|
const int mseId = request.mainStructureElementId;
|
|
InfrastructureManagement::ObjectMainStructureElement *ifs = m_objectMainStructureElementMap.value(mseId);
|
|
if (ifs == nullptr)
|
|
return Core::FunctionReplyObject(request.mainStructureElementId, tr_lts("dds", "MainStructureElement with id %1 not found")).arg(mseId);
|
|
|
|
MainStructureElementModifyRequest mseData;
|
|
// copy for lazy people ...
|
|
MainStructureElement &mse = mseData;
|
|
mse = ifs->getData();
|
|
|
|
DEBUG_LOG(m_logger) << "request.mseId: " << mseId << " #elements: " << mseData.elements.size() << "request count: " << request.elements.size();
|
|
for (const StructureElement &se : request.elements)
|
|
{
|
|
bool bFound = false;
|
|
for (size_t i = 0; i < mseData.elements.size(); ++i)
|
|
{
|
|
const StructureElement &curSe = mseData.elements.at(i);
|
|
if (se.id == curSe.id)
|
|
{
|
|
bFound = true;
|
|
mseData.elements[i] = se;
|
|
DEBUG_LOG(m_logger) << "StructureElement Modify = " << mseData.elements[i];
|
|
if (se.structureElementTypeId == StructureElementType::Building
|
|
&& se.displayName != curSe.displayName)
|
|
changeBuildingNameinMountingPoints(se, mseData);
|
|
|
|
break;
|
|
}
|
|
}
|
|
if (!bFound)
|
|
return Core::FunctionReplyObject(mseId,
|
|
tr_lts("dds", "StructureElement with id %1 not found in MainStructure with id %2")).arg(se.id).arg(mseId);
|
|
}
|
|
return onMainStructureElementModify(mseData);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------------
|
|
void HandlerMainStructureElement::publishMainStructureElement(int buildingId)
|
|
{
|
|
DEBUG_LOG(m_logger) << " Publishing MainStructureElement buildingId = " << buildingId;
|
|
|
|
// retrieve MSE from map
|
|
ObjectMainStructureElement *objMse = m_mainHandler->getHandlerMainStructureElement()->getMainStructureElement(buildingId);
|
|
if (!objMse || !objMse->isValid())
|
|
{
|
|
DEBUG_LOG(m_logger) << " Could not publish MainStructureElement Id = " << buildingId;
|
|
return;
|
|
}
|
|
DEBUG_LOG(m_logger) << " MSE Id = " << buildingId << " , structureElementId = " << objMse->getStructureElementId();
|
|
|
|
// publish
|
|
objMse->onPublishData();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------------
|
|
void HandlerMainStructureElement::removedStructureElements(const QMap<int, ObjectStructureElement *> &removedElements)
|
|
{
|
|
for (auto it = removedElements.begin(); it != removedElements.end(); ++it)
|
|
m_objectStructureElementMap.remove(it.key());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------------------------------
|
|
void HandlerMainStructureElement::addedStructureElements(const QMap<int, ObjectStructureElement *> &addedElements)
|
|
{
|
|
for (auto it = addedElements.begin(); it != addedElements.end(); ++it)
|
|
m_objectStructureElementMap[it.key()] = it.value();
|
|
}
|
|
/*!
|
|
* \brief HandlerMainStructureElement::onExerciseStateChanged
|
|
* \param data
|
|
* \param mod
|
|
* \author Niklas Schmidt
|
|
* \details If the exercise, the MSE is in, were deleted, delete the exercise from MSE properties and delete recording in MSE Structure elements and send to dds
|
|
*/
|
|
void HandlerMainStructureElement::onExerciseStateChanged(const ExerciseManagement::Exercise &data, DataModification mod)
|
|
{
|
|
Q_UNUSED(mod)
|
|
if (data.state != ExerciseManagement::ExerciseState::Terminated)
|
|
return;
|
|
|
|
for (auto mseObj : qAsConst(m_objectMainStructureElementMap))
|
|
{
|
|
const MainStructureElement &mse = mseObj->getData();
|
|
QJsonObject obj = QJsonDocument::fromJson(QByteArray::fromStdString(mse.properties)).object();
|
|
if (obj.value(QStringLiteral("available_in_exercise")).toArray().at(0).toInt() == data.id)
|
|
{
|
|
MainStructureElementModifyRequest modReq;
|
|
modReq.angle = mse.angle;
|
|
modReq.description = mse.description;
|
|
modReq.externalWlsId = mse.externalWlsId;
|
|
modReq.elements = mse.elements;
|
|
// modReq.footprint(mseObj->getFootprint());
|
|
modReq.geoPosition = mse.geoPosition;
|
|
modReq.groupId = mse.groupId;
|
|
modReq.id = mse.id;
|
|
modReq.isDeleted = mse.isDeleted;
|
|
modReq.isUsed = mse.isUsed;
|
|
modReq.modelId = mse.modelId;
|
|
modReq.name = mse.name;
|
|
std::vector<InfrastructureManagement::StructureElement> resElements;
|
|
for (auto element : qAsConst(mse.elements))
|
|
{
|
|
QJsonDocument doc = QJsonDocument::fromJson(QByteArray::fromStdString(element.properties));
|
|
QJsonObject objEle = doc.object();
|
|
if (objEle.contains(QStringLiteral("record")))
|
|
{
|
|
objEle[QStringLiteral("record")] = false;
|
|
element.properties = QJsonDocument(objEle).toJson().toStdString();
|
|
}
|
|
resElements.push_back(element);
|
|
}
|
|
modReq.elements = resElements;
|
|
QJsonObject root;
|
|
try
|
|
{
|
|
obj.remove(QStringLiteral("available_in_exercise"));
|
|
}
|
|
catch (...)
|
|
{
|
|
ERROR_LOG(m_logger) << "can't parse json";
|
|
Q_ASSERT(false);
|
|
}
|
|
modReq.properties = QString::fromUtf8(QJsonDocument(obj).toJson()).toStdString();
|
|
modReq.structureElementId = mse.structureElementId;
|
|
modReq.structureElementTypeId = mse.structureElementTypeId;
|
|
|
|
onMainStructureElementModify(modReq);
|
|
}
|
|
}
|
|
}
|
|
|
|
void HandlerMainStructureElement::udpatePropertiesForRelayOverride(const int relay,
|
|
const InfrastructureManagement::EffectOverride state,
|
|
InfrastructureManagement::StructureElement &se)
|
|
{
|
|
QByteArray content = QByteArray::fromStdString(se.properties);
|
|
const QJsonDocument doc(QJsonDocument::fromJson(content));
|
|
|
|
QJsonObject docObj = QJsonObject(doc.object());
|
|
QJsonObject overridesObj = docObj.value(QStringLiteral("Overrides")).toObject();
|
|
|
|
bool containsRelay = false;
|
|
|
|
QJsonArray arrRelays = overridesObj.value(QStringLiteral("relays")).toArray();
|
|
for (int i = 0; i < arrRelays.size(); ++i)
|
|
{
|
|
QJsonObject objState = arrRelays[i].toObject();
|
|
QStringList keys = objState.keys();
|
|
QString keyStr = keys.at(0);
|
|
int key = keyStr.toInt();
|
|
if (key != relay)
|
|
continue;
|
|
|
|
if (state != InfrastructureManagement::EffectOverride::Automatic)
|
|
arrRelays[i] = QJsonObject({qMakePair<QString, QJsonValue>(keyStr, static_cast<int>(state))});
|
|
else
|
|
arrRelays.removeAt(i);
|
|
containsRelay = true;
|
|
break;
|
|
}
|
|
if (!containsRelay && state != InfrastructureManagement::EffectOverride::Automatic)
|
|
arrRelays.append(QJsonObject({qMakePair<QString, QJsonValue>(QString::number(relay), static_cast<int>(state))}));
|
|
|
|
if (arrRelays.isEmpty())
|
|
overridesObj.remove(QStringLiteral("relays"));
|
|
else
|
|
overridesObj.insert(QStringLiteral("relays"), arrRelays);
|
|
|
|
if (overridesObj.isEmpty())
|
|
docObj.remove(QStringLiteral("Overrides"));
|
|
else
|
|
docObj.insert(QStringLiteral("Overrides"), overridesObj);
|
|
|
|
QByteArray content_neu = QJsonDocument(docObj).toJson(QJsonDocument::Compact);
|
|
|
|
se.properties = content_neu.toStdString();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------------------------------------------
|
|
} // Namespace InfrastructureManagement
|