1216 lines
47 KiB
C++
Executable File
1216 lines
47 KiB
C++
Executable File
/**
|
|
* A single building instance
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Christian Ehrlicher, SLSE, 2017-02-06
|
|
*/
|
|
|
|
|
|
#include "building_process.h"
|
|
#include "main_handler.h"
|
|
#include "BuildingControlUnit/ControlEffects/xmlreader.h"
|
|
// Qt
|
|
#include <QStandardPaths>
|
|
#include <QFile>
|
|
#include <QTimer>
|
|
#include <QTransform>
|
|
#include <QWebSocket>
|
|
#include <QXmlStreamWriter>
|
|
#include <QJsonArray>
|
|
#include <QJsonDocument>
|
|
#include <ngltools/ngltools_filesystem.h>
|
|
//Lts
|
|
#include <LtsCoordTrans/lts_coord_trans.h>
|
|
#include <LtsUtilsCore/outdated_position.h>
|
|
#include <bcu_types.h>
|
|
#include <ProjectDataManagement/pdm_to_string.h>
|
|
#include <AssetManagement/asm.hpp>
|
|
|
|
namespace Buildings
|
|
{
|
|
|
|
// some helper
|
|
QStringList idsToStringList(const std::vector< int32_t >& ids)
|
|
{
|
|
QStringList sl;
|
|
sl.reserve(ids.size());
|
|
for (const auto &id : qAsConst(ids))
|
|
sl.append(QString::number(id));
|
|
return sl;
|
|
}
|
|
|
|
|
|
//
|
|
// class BuildingProcess
|
|
//
|
|
BuildingProcess::BuildingProcess(MainHandler *mainHandler,
|
|
const QString &procName,
|
|
const BuildingInfo &info,
|
|
const bool initBuilding,
|
|
QObject *parent)
|
|
: QObject(parent)
|
|
, m_mainHandler(mainHandler)
|
|
, m_buildingInfo(info)
|
|
, m_wsSocket(nullptr)
|
|
, m_wsReconnectTimer(new QTimer(this))
|
|
, m_hitLineInfoTimer(new QTimer(this))
|
|
, m_hitLineId(info.mseId << 16)
|
|
, m_initBuilding(initBuilding)
|
|
, m_logger(getLogger("BuildingProcess"))
|
|
{
|
|
m_proc.setProgram(procName);
|
|
m_proc.setReadChannel(QProcess::StandardOutput);
|
|
|
|
connect(m_wsReconnectTimer, &QTimer::timeout,
|
|
this, &BuildingProcess::openWebSocket);
|
|
connect(m_hitLineInfoTimer, &QTimer::timeout,
|
|
this, &BuildingProcess::onHitLineInfoTimeout);
|
|
|
|
m_hitLineInfoTimer->setSingleShot(false);
|
|
m_hitLineInfoTimer->start(15000);
|
|
}
|
|
|
|
BuildingProcess::~BuildingProcess()
|
|
{
|
|
shutdown();
|
|
}
|
|
|
|
void BuildingProcess::setBuildingInfo(const BuildingInfo &info)
|
|
{
|
|
m_buildingInfo = info;
|
|
shutdown();
|
|
start();
|
|
}
|
|
|
|
void BuildingProcess::onStructureElementUpdateEffectOverrideReply(const Core::FunctionReplyObject &replyObject)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onSendCesHitReply for id " << replyObject.id() << " success= " << replyObject.error();
|
|
}
|
|
|
|
bool BuildingProcess::start()
|
|
{
|
|
DEBUG_LOG(m_logger) << "BuildingProcess::start mseId = " << m_buildingInfo.mseId
|
|
<< " m_historyState.size() = " << m_historyState.stateHistory().size()
|
|
<< " m_initBuilding=" << m_initBuilding;
|
|
if (m_buildingInfo.mseId <= 0)
|
|
{
|
|
WARNING_LOG(m_logger) << "No valid building information set - can not start building process";
|
|
return false;
|
|
}
|
|
if (m_proc.state() != QProcess::NotRunning)
|
|
{
|
|
WARNING_LOG(m_logger) << "Process for building " << m_buildingInfo.mseId << " is already running!";
|
|
return false;
|
|
}
|
|
// create config files
|
|
const QString tmpPath = QStandardPaths::writableLocation(QStandardPaths::TempLocation) + QLatin1Char('/');
|
|
const QString optPath = QStringLiteral("/opt/BuildingModels/StaticMeshes/");
|
|
const QString vulnerabilityModelFilename = optPath + QStringLiteral("%1.flt.VWM_Building.xml").arg(m_buildingInfo.name);
|
|
|
|
// QByteArray out;
|
|
// try
|
|
// {
|
|
// // may throw ... :/
|
|
// out = qUncompress(m_buildingInfo.vulnerabilityModelData);
|
|
// }
|
|
// catch (...)
|
|
// {}
|
|
// if (!writeFile(vulnerabilityModelFilename, out))
|
|
// {
|
|
// WARNING_LOG(m_logger) << "(!writeFile(vulnerabilityModelFilename, out)";
|
|
// return false;
|
|
// }
|
|
|
|
const QByteArray bldCfgData = generateBuildingConfigData();
|
|
// Lts/Projects/<ProjectName>/resources/effect_config.xml
|
|
const QString effectConfigFilename = NGL::findFile(NGL::FileType::ConfigFile, QStringLiteral("effect_config.xml"));
|
|
WARNING_LOG(m_logger) << "(effectConfigFilename) = " << effectConfigFilename;
|
|
|
|
//const QString effectConfigFilename = LtsUtils:: QStringLiteral("/tmp/effect_config.xml");
|
|
const QString bldDataFilename = tmpPath + QStringLiteral("bldg_%1_building_config.xml").arg(m_buildingInfo.mseId);
|
|
if (!writeFile(bldDataFilename, bldCfgData))
|
|
{
|
|
WARNING_LOG(m_logger) << "(!writeFile(bldDataFilename, bldCfgData)";
|
|
return false;
|
|
}
|
|
|
|
const QByteArray chargesData = generateChargesData();
|
|
const QString chargesDataFilename = tmpPath + QStringLiteral("bldg_%1_charges.xml").arg(m_buildingInfo.mseId);
|
|
if (!writeFile(chargesDataFilename, chargesData))
|
|
{
|
|
WARNING_LOG(m_logger) << "(!writeFile(chargesDataFilename, chargesData)";
|
|
return false;
|
|
}
|
|
|
|
// Read effectConfig.xml for overrides after reconnect EGCU [GUEZE-2011]
|
|
BuildingControlUnit::XmlReader *xmlReader = new BuildingControlUnit::XmlReader();
|
|
|
|
xmlReader->init(effectConfigFilename);
|
|
const QVector<BuildingControlUnit::Effect*> &effectsPtrRef = xmlReader->contents().effects;
|
|
for (auto effectPtr : effectsPtrRef)
|
|
{
|
|
if (!effectPtr)
|
|
continue;
|
|
|
|
DEBUG_LOG(m_logger) << "effect->id=" << effectPtr->id
|
|
<< " effect->category=" << effectPtr->category
|
|
<< " effect->effectType=" << effectPtr->effectType
|
|
<< " effect->override=" << static_cast<int>(effectPtr->override);
|
|
if (effectPtr->effectType == 1) // Relay
|
|
{
|
|
m_effectOverridesReconnect.insert(effectPtr->id, static_cast<int>(effectPtr->override));
|
|
}
|
|
}
|
|
|
|
delete xmlReader;
|
|
// End effectConfig.xml
|
|
|
|
|
|
// disconnected in shutdown()
|
|
connect(&m_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
|
|
this, &BuildingProcess::onProcessFinished,
|
|
Qt::UniqueConnection);
|
|
connect(&m_proc, &QProcess::readyRead,
|
|
this, &BuildingProcess::onReadyRead,
|
|
Qt::UniqueConnection);
|
|
|
|
// start process
|
|
m_proc.setArguments(
|
|
{
|
|
QStringLiteral("--charges"), chargesDataFilename,
|
|
QStringLiteral("--buildingConfig"), bldDataFilename,
|
|
QStringLiteral("--effectConfig"), effectConfigFilename,
|
|
QStringLiteral("--damage"), vulnerabilityModelFilename,
|
|
QStringLiteral("--buildingId"), QString::number(m_buildingInfo.mseId),
|
|
QStringLiteral("--percentDamageInit"), QString::number(m_initBuilding)
|
|
});
|
|
m_proc.start();
|
|
|
|
return m_proc.waitForStarted();
|
|
}
|
|
|
|
void BuildingProcess::shutdown()
|
|
{
|
|
m_proc.disconnect(this);
|
|
if (m_proc.state() == QProcess::Running)
|
|
{
|
|
m_proc.terminate();
|
|
m_proc.waitForFinished(5000);
|
|
if (m_proc.state() == QProcess::Running)
|
|
m_proc.kill();
|
|
}
|
|
closeWebSocket();
|
|
m_wsUrl.clear();
|
|
}
|
|
|
|
void BuildingProcess::setHistoryState(const Buildings::HistoryState &historyState)
|
|
{
|
|
DEBUG_LOG(m_logger) << "BuildingProcess::setHistoryState size =" << historyState.stateHistory().size();
|
|
|
|
ERROR_LOG(m_logger) << "[BuildingProcess::setHistoryState]>>> history =" << historyState;
|
|
m_historyState = historyState;
|
|
m_historyState.sampleTime(QDateTime::currentMSecsSinceEpoch());
|
|
m_mainHandler->ddsHandler()->dts()->publish(m_historyState);
|
|
}
|
|
|
|
bool BuildingProcess::setVulnerabilityState(ProjectDataManagement::VulnerabilityState state, const std::vector<int> &roomIds)
|
|
{
|
|
DEBUG_LOG(m_logger) << "BuildingProcess::setVulnerabilityState:" << state;
|
|
if (!m_wsSocket || !m_wsSocket->isValid())
|
|
return false;
|
|
BuildingControlUnit::Json::Telegrams::SetDamageState tele;
|
|
tele.damageState = (state == ProjectDataManagement::VulnerabilityState::CatastrophicKill ?
|
|
BuildingControlUnit::DamageState::Destroyed :
|
|
BuildingControlUnit::DamageState::NoDamage);
|
|
tele.roomIds.reserve(roomIds.size());
|
|
for (int id : roomIds)
|
|
tele.roomIds += m_buildingInfo.roomId2SubId.value(id);
|
|
|
|
tele.originatorId = 0; // exercise control
|
|
DEBUG_LOG(m_logger) << "setVulnerabilityState websocket send: " << QString::fromUtf8(tele.toJson());
|
|
m_wsSocket->sendTextMessage(QString::fromUtf8(tele.toJson()));
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BuildingProcess::setContaminationState(const int &bldId, const ContaminationState &contaminationState)
|
|
{
|
|
DEBUG_LOG(m_logger) << "BuildingProcess::setContaminationState bldId: "<<bldId;
|
|
if (!m_wsSocket || !m_wsSocket->isValid())
|
|
return false;
|
|
BuildingControlUnit::Json::Telegrams::SetContaminationState tele;
|
|
BuildingControlUnit::ContaminationState contState;
|
|
contState.aesId = contaminationState.aesId();
|
|
if ( contaminationState.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::CatastrophicKill )
|
|
contState.damagePercentNew = 100;
|
|
else
|
|
contState.damagePercentNew = 0;
|
|
contState.rooms = contaminationState.rooms();//cs.rooms();
|
|
tele.contaminationStates.push_back(contState);
|
|
|
|
DEBUG_LOG(m_logger) << "SetContaminationState websocket send: " << QString::fromUtf8(tele.toJson());
|
|
m_wsSocket->sendTextMessage(QString::fromUtf8(tele.toJson()));
|
|
return true;
|
|
}
|
|
|
|
bool BuildingProcess::resetContaminationState()
|
|
{
|
|
DEBUG_LOG(m_logger) << "BuildingProcess::resetContaminationState" ;
|
|
if (!m_wsSocket || !m_wsSocket->isValid())
|
|
return false;
|
|
BuildingControlUnit::Json::Telegrams::ResetContaminationState tele;
|
|
DEBUG_LOG(m_logger) << "ResetContaminationState websocket send: " << QString::fromUtf8(tele.toJson());
|
|
m_wsSocket->sendTextMessage(QString::fromUtf8(tele.toJson()));
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool BuildingProcess::setFortifyFactors(const std::vector<Buildings::FortifyFactor> &fortifyFactors)
|
|
{
|
|
if (!m_wsSocket || !m_wsSocket->isValid())
|
|
return false;
|
|
BuildingControlUnit::Json::Telegrams::SetFortifyFactor tele;
|
|
|
|
for (const auto &ff : fortifyFactors)
|
|
{
|
|
BuildingControlUnit::Json::Telegrams::SetFortifyFactor::FortifyInfo info;
|
|
info.roomId = m_buildingInfo.roomId2SubId.value(ff.roomId());
|
|
info.fortifyFactor = ff.fortifyFactor();
|
|
|
|
tele.fortifyFactors.push_back(info);
|
|
}
|
|
DEBUG_LOG(m_logger) << "setFortifyFactors websocket send: " << QString::fromUtf8(tele.toJson());
|
|
m_wsSocket->sendTextMessage(QString::fromUtf8(tele.toJson()));
|
|
return true;
|
|
}
|
|
|
|
void BuildingProcess::newRelayInfos(const QMap<int, AssetManagement::RelayInfo> &map)
|
|
{
|
|
m_relayInfos = map;
|
|
}
|
|
|
|
|
|
bool BuildingProcess::setEffectStates( const int assetId, const QByteArray &properties)
|
|
{
|
|
BuildingControlUnit::Json::Telegrams::SetEffectStates tele;
|
|
|
|
if (!m_wsSocket || !m_wsSocket->isValid())
|
|
return false;
|
|
DEBUG_LOG(m_logger) << "setEffectStates"
|
|
<< " assetId=" << assetId
|
|
<< " properties=" << properties;
|
|
|
|
if (assetId > 0)
|
|
{
|
|
for (const EgcuInfo &egcu : qAsConst(m_buildingInfo.egcus))
|
|
{
|
|
DEBUG_LOG(m_logger) << "EGCU: " << egcu.assetName
|
|
<< " assetId=" << egcu.assetId
|
|
<< " egcu.assetId=" << egcu.assetId
|
|
<< " hostname=" << egcu.hostname;
|
|
if ( assetId == egcu.assetId)
|
|
{
|
|
DEBUG_LOG(m_logger) << "segment=" << egcu.hostname;
|
|
tele.segment = egcu.hostname;
|
|
}
|
|
}
|
|
if (tele.segment.isEmpty())
|
|
{
|
|
WARNING_LOG(m_logger) << "Asset with id " << assetId << " not found in this building";
|
|
return false;
|
|
}
|
|
if (tele.segment == QString())
|
|
{
|
|
ERROR_LOG(m_logger) << "Asset with id=" << assetId << " has no Hostname!!!!";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
QJsonParseError parserError;
|
|
const QJsonDocument doc(QJsonDocument::fromJson(properties, &parserError));
|
|
|
|
if (parserError.error != QJsonParseError::NoError)
|
|
return false;
|
|
|
|
#if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
|
|
QSet<int> allRelayIds;
|
|
for (auto it = m_relayInfos.keyBegin(); it != m_relayInfos.keyEnd(); ++it)
|
|
allRelayIds.insert(*it);
|
|
#else
|
|
QSet<int> allRelayIds(m_relayInfos.keyBegin(), m_relayInfos.keyEnd());
|
|
#endif
|
|
|
|
QJsonObject docObj = QJsonObject(doc.object());
|
|
QJsonObject overridesObj = docObj.value(QStringLiteral("Overrides")).toObject();
|
|
QJsonArray arrEgcus = overridesObj.value(QStringLiteral("relays")).toArray();
|
|
for (int i=0; i<arrEgcus.size(); ++i)
|
|
{
|
|
QJsonObject objState = arrEgcus[i].toObject();
|
|
QStringList keys = objState.keys();
|
|
QString relayIdString = keys.at(0);
|
|
int relayId = relayIdString.toInt();
|
|
allRelayIds.remove(relayId);
|
|
int value = objState.value(relayIdString).toInt();
|
|
BuildingControlUnit::BcuEffectState bcuEffectState;
|
|
bcuEffectState.id = relayId;
|
|
bcuEffectState.type = BuildingControlUnit::BET_Relay; // so far only relays are handeled
|
|
if (relayId == 99) // Special Treatment for Sound
|
|
{
|
|
bcuEffectState.id = 1;
|
|
bcuEffectState.type = BuildingControlUnit::BET_BackgroundSound;
|
|
}
|
|
bcuEffectState.effectOverride = static_cast<BuildingControlUnit::BcuEffectOverride>(value);
|
|
tele.effectStates.append(bcuEffectState);
|
|
}
|
|
for (int relayId : qAsConst(allRelayIds))
|
|
{
|
|
BuildingControlUnit::BcuEffectState bcuEffectState;
|
|
bcuEffectState.id = relayId;
|
|
bcuEffectState.type = BuildingControlUnit::BET_Relay; // so far only relays are handeled
|
|
bcuEffectState.effectOverride = BuildingControlUnit::BcuEffectOverride::BEO_Auto;
|
|
if (relayId == 99) // Special Treatment for Sound
|
|
{
|
|
bcuEffectState.id = 1;
|
|
bcuEffectState.type = BuildingControlUnit::BET_BackgroundSound;
|
|
}
|
|
tele.effectStates.append(bcuEffectState);
|
|
}
|
|
|
|
{
|
|
BuildingControlUnit::BcuEffectState bcuEffectState;
|
|
bcuEffectState.id = 1; // Id aus effect_config.xml
|
|
bcuEffectState.type = BuildingControlUnit::BET_BsmFlash;
|
|
int flashVal = -1;
|
|
if (overridesObj.contains(QStringLiteral("flash")))
|
|
flashVal = overridesObj.value(QStringLiteral("flash")).toInt();
|
|
bcuEffectState.effectOverride = static_cast<BuildingControlUnit::BcuEffectOverride>(flashVal);
|
|
tele.effectStates.append(bcuEffectState);
|
|
}
|
|
|
|
QString valueStr = QString::fromUtf8(tele.toJson());
|
|
DEBUG_LOG(m_logger) << "setEffectStates websocket send: " << valueStr;
|
|
qint64 sendBytesCount = m_wsSocket->sendTextMessage(valueStr);
|
|
DEBUG_LOG(m_logger) << "sendBytesCount= " << sendBytesCount;
|
|
m_effectStates.insert(assetId, valueStr);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool BuildingProcess::relayState(const std::vector<Buildings::RelayStateItem> &relayStates)
|
|
{
|
|
if (!m_wsSocket || !m_wsSocket->isValid())
|
|
return false;
|
|
BuildingControlUnit::Json::Telegrams::RelayState tele;
|
|
|
|
for (const auto &ff : relayStates)
|
|
{
|
|
BuildingControlUnit::Json::Telegrams::RelayState::RelayStateInfo info;
|
|
info.id = ff.id();
|
|
info.state = ff.state();
|
|
|
|
tele.relayStates.push_back(info);
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "relayState websocket send: " << QString::fromUtf8(tele.toJson());
|
|
m_wsSocket->sendTextMessage(QString::fromUtf8(tele.toJson()));
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool BuildingProcess::sendCesHitOnBuilding(const qint64 effectTimeMSec,
|
|
const int chargeTypeId,
|
|
const int destructiveFactor,
|
|
const int penetrationFactor,
|
|
const int aesId,
|
|
const Core::GeoPosition &impactPosition,
|
|
const QString &properties)
|
|
{
|
|
if (!m_wsSocket || !m_wsSocket->isValid())
|
|
return false;
|
|
|
|
// currently we only support single/area fire, therefore the tas charge type is enough
|
|
const LtsCoordTrans::UtmCoordinate coord(LtsCoordTrans::UtmCoordinate::fromGeographic(m_buildingInfo.absPosition.lon(),
|
|
m_buildingInfo.absPosition.lat()));
|
|
const LtsCoordTrans::UtmCoordinate impact(LtsCoordTrans::UtmCoordinate::fromGeographic(impactPosition.lon(),
|
|
impactPosition.lat(),
|
|
coord.zone));
|
|
Core::RelativePosition relPos(impact.x - coord.x,
|
|
impact.y - coord.y,
|
|
impactPosition.z() - m_buildingInfo.absPosition.z());
|
|
double xRot, yRot;
|
|
QTransform m;
|
|
// - -> rotate back to 0°
|
|
m.rotate(-m_buildingInfo.angle);
|
|
m.map(relPos.offsetX(), relPos.offsetY(), &xRot, &yRot);
|
|
relPos.offsetX(xRot);
|
|
relPos.offsetY(yRot);
|
|
|
|
|
|
BuildingControlUnit::Json::Telegrams::CentralEffectSimulationHit tele;
|
|
tele.effectTimeMSec = effectTimeMSec;
|
|
tele.chargeTypeId = chargeTypeId;
|
|
tele.destructiveFactor = destructiveFactor;
|
|
tele.penetrationFactor = penetrationFactor;
|
|
tele.aesId = aesId;
|
|
tele.relPosition.x = relPos.offsetX();
|
|
tele.relPosition.y = relPos.offsetY();
|
|
tele.relPosition.z = relPos.offsetZ();
|
|
tele.properties = properties;
|
|
|
|
DEBUG_LOG(m_logger) << "sendCesHitOnBuilding websocket send: " << QString::fromUtf8(tele.toJson());
|
|
m_wsSocket->sendTextMessage(QString::fromUtf8(tele.toJson()));
|
|
return true;
|
|
}
|
|
|
|
bool BuildingProcess::sendCesHit3DonBuilding(const qint64 effectTimeMSec, const int chargeTypeId, const int destructiveFactor, const int penetrationFactor,
|
|
const int aesId, const Core::GeoPosition &impactPosition,
|
|
const Core::GeoPosition &detonationLocation, double detonationDistance,
|
|
const QString &properties)
|
|
{
|
|
if (!m_wsSocket || !m_wsSocket->isValid())
|
|
return false;
|
|
|
|
// currently we only support single/area fire, therefore the tas charge type is enough
|
|
const LtsCoordTrans::UtmCoordinate &coord(LtsCoordTrans::UtmCoordinate::fromGeographic(m_buildingInfo.absPosition.lon(),
|
|
m_buildingInfo.absPosition.lat()));
|
|
|
|
Core::RelativePosition relImpactPos;
|
|
{
|
|
const LtsCoordTrans::UtmCoordinate &impactUtm(LtsCoordTrans::UtmCoordinate::fromGeographic(impactPosition.lon(),
|
|
impactPosition.lat(),
|
|
coord.zone));
|
|
relImpactPos = Core::RelativePosition(impactUtm.x - coord.x,
|
|
impactUtm.y - coord.y,
|
|
impactPosition.z() - m_buildingInfo.absPosition.z());
|
|
}
|
|
|
|
Core::RelativePosition relDetoLoc;
|
|
{
|
|
const LtsCoordTrans::UtmCoordinate &detonationLocationUtm(LtsCoordTrans::UtmCoordinate::fromGeographic(detonationLocation.lon(),
|
|
detonationLocation.lat(),
|
|
coord.zone));
|
|
relDetoLoc = Core::RelativePosition(detonationLocationUtm.x - coord.x,
|
|
detonationLocationUtm.y - coord.y,
|
|
detonationLocation.z() - m_buildingInfo.absPosition.z());
|
|
}
|
|
|
|
|
|
double xRot, yRot;
|
|
QTransform m;
|
|
// - -> rotate back to 0°
|
|
m.rotate(-m_buildingInfo.angle);
|
|
|
|
m.map(relImpactPos.offsetX(), relImpactPos.offsetY(), &xRot, &yRot);
|
|
relImpactPos.offsetX(xRot);
|
|
relImpactPos.offsetY(yRot);
|
|
|
|
m.map(relDetoLoc.offsetX(), relDetoLoc.offsetY(), &xRot, &yRot);
|
|
relDetoLoc.offsetX(xRot);
|
|
relDetoLoc.offsetY(yRot);
|
|
|
|
|
|
BuildingControlUnit::Json::Telegrams::CentralEffectSimulationHit3D tele;
|
|
tele.effectTimeMSec = effectTimeMSec;
|
|
tele.chargeTypeId = chargeTypeId;
|
|
tele.destructiveFactor = destructiveFactor;
|
|
tele.penetrationFactor = penetrationFactor;
|
|
tele.aesId = aesId;
|
|
|
|
tele.impactPosition.x = relImpactPos.offsetX();
|
|
tele.impactPosition.y = relImpactPos.offsetY();
|
|
tele.impactPosition.z = relImpactPos.offsetZ();
|
|
|
|
tele.detonationLocation.x = relDetoLoc.offsetX();
|
|
tele.detonationLocation.y = relDetoLoc.offsetY();
|
|
tele.detonationLocation.z = relDetoLoc.offsetZ();
|
|
|
|
tele.detonationDistance = detonationDistance;
|
|
tele.properties = properties;
|
|
|
|
DEBUG_LOG(m_logger) << "sendCesHit3DonBuilding websocket send: " << QString::fromUtf8(tele.toJson());
|
|
m_wsSocket->sendTextMessage(QString::fromUtf8(tele.toJson()));
|
|
return true;
|
|
}
|
|
|
|
bool BuildingProcess::switchRelay(const SwitchRelayRequest &data)
|
|
{
|
|
BuildingControlUnit::Json::Telegrams::SwitchRelay tele;
|
|
|
|
if (!m_wsSocket || !m_wsSocket->isValid())
|
|
return false;
|
|
DEBUG_LOG(m_logger) << "switchRelay"
|
|
<< " buildingId=" << data.buildingId()
|
|
<< " assetId=" << data.assetId()
|
|
<< data.state();
|
|
|
|
|
|
for (const EgcuInfo &egcu : qAsConst(m_buildingInfo.egcus))
|
|
{
|
|
DEBUG_LOG(m_logger) << "EGCU: " << egcu.assetName
|
|
<< " assetId=" << egcu.assetId
|
|
<< " hostname=" << egcu.hostname;
|
|
DEBUG_LOG(m_logger) << "data.assetId()=" << data.assetId()
|
|
<< "egcu.assetId=" << egcu.assetId;
|
|
if ( data.assetId() != egcu.assetId)
|
|
continue;
|
|
|
|
tele.segment = egcu.hostname;
|
|
tele.switchRelayValues.id = data.number();
|
|
tele.switchRelayValues.bcuRelayState = static_cast <BuildingControlUnit::BcuRelayState>(data.state().underlying());
|
|
if ( data.state() == StateSetRelay_def::Pulse)
|
|
{
|
|
tele.switchRelayValues.count = data.pulseAttributes().get().count();
|
|
tele.switchRelayValues.delay = data.pulseAttributes().get().delay();
|
|
tele.switchRelayValues.pulse = data.pulseAttributes().get().pulse();
|
|
}
|
|
DEBUG_LOG(m_logger) << "switchRelay websocket send: " << QString::fromUtf8(tele.toJson());
|
|
m_wsSocket->sendTextMessage(QString::fromUtf8(tele.toJson()));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool BuildingProcess::triggerFlashlight(const TriggerBsmFlashRequest data)
|
|
{
|
|
BuildingControlUnit::Json::Telegrams::BsmTriggerFlashlight tele;
|
|
|
|
if (!m_wsSocket || !m_wsSocket->isValid())
|
|
return false;
|
|
DEBUG_LOG(m_logger) << "triggerFlashlight"
|
|
<< " BuildingId=" << data.buildingId()
|
|
<< " assetId=" << data.assetId()
|
|
<< " m_buildingInfo.bsms.size()" << m_buildingInfo.bsms.size();
|
|
|
|
QMapIterator<int, BsmInfo> i(m_buildingInfo.bsms);
|
|
while (i.hasNext()) {
|
|
i.next();
|
|
DEBUG_LOG(m_logger) << "key=" << i.key()
|
|
<< " assetId=" << i.value().assetId
|
|
<< " bsmId=" << i.value().bsmId
|
|
<< " hostname=" << i.value().hostname
|
|
<< " port=" << i.value().port;
|
|
|
|
}
|
|
if ( m_buildingInfo.bsms.contains(data.assetId()))
|
|
{
|
|
BsmInfo bsmInfo = m_buildingInfo.bsms.value(data.assetId());
|
|
DEBUG_LOG(m_logger) << " BuildingId=" << data.buildingId()
|
|
<< " assetId=" << bsmInfo.assetId
|
|
<< " hostname=" << bsmInfo.hostname;
|
|
|
|
tele.hostname = bsmInfo.hostname;
|
|
tele.numberOfFlashes = 1;
|
|
tele.pauseBetweenFlashesSec = 0;
|
|
tele.sensorId = 0; // Hostname reicht
|
|
|
|
DEBUG_LOG(m_logger) << "triggerFlashlight websocket send: " << QString::fromUtf8(tele.toJson());
|
|
m_wsSocket->sendTextMessage(QString::fromUtf8(tele.toJson()));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void BuildingProcess::onReadyRead()
|
|
{
|
|
const QString data = QString::fromLocal8Bit(m_proc.readAll());
|
|
const QString strToSearch(QStringLiteral("web socket url:"));
|
|
if (data.contains(strToSearch))
|
|
{
|
|
m_wsUrl = data.split(strToSearch).at(1).split(QLatin1Char('\n')).at(0).trimmed();
|
|
INFO_LOG(m_logger) << "Using web socket url '" << m_wsUrl << "' for building " << m_buildingInfo.mseId;
|
|
openWebSocket();
|
|
}
|
|
}
|
|
|
|
void BuildingProcess::onProcessFinished(int exitCode, QProcess::ExitStatus exitStatus)
|
|
{
|
|
// normal exit
|
|
if (exitCode == 0 && exitStatus == QProcess::NormalExit)
|
|
return;
|
|
const char *what = exitStatus == QProcess::NormalExit ? "stopped" : "crashed";
|
|
WARNING_LOG(m_logger) << "building control process for building " << m_buildingInfo.mseId
|
|
<< " " << what << " with exit code " << exitCode << " - restarting in 1 second";
|
|
if (exitCode != 0)
|
|
{
|
|
WARNING_LOG(m_logger) << "stdout: " << m_proc.readAllStandardOutput();
|
|
WARNING_LOG(m_logger) << "stderr: " << m_proc.readAllStandardError();
|
|
}
|
|
closeWebSocket();
|
|
QTimer::singleShot(1000, this, &BuildingProcess::start);
|
|
}
|
|
|
|
void BuildingProcess::onTextMessageReceived(const QString &message)
|
|
{
|
|
TRACE_LOG(m_logger) << "Got message from building control process: " << message;
|
|
BuildingControlUnit::Json::Telegrams::BaseTelegram *tel =
|
|
BuildingControlUnit::Json::Telegrams::BaseTelegram::telegramFromJson(message.toUtf8());
|
|
if (!tel)
|
|
{
|
|
WARNING_LOG(m_logger) << "Can not convert '" << message << "' to a valid telegram!";
|
|
return;
|
|
}
|
|
if (tel->telegramId() == BuildingControlUnit::Json::Telegrams::BsmState::telegramId())
|
|
handleBsmState(static_cast<BuildingControlUnit::Json::Telegrams::BsmState *>(tel));
|
|
else if (tel->telegramId() == BuildingControlUnit::Json::Telegrams::HitResult::telegramId())
|
|
handleHitResult(static_cast<BuildingControlUnit::Json::Telegrams::HitResult *>(tel));
|
|
else if (tel->telegramId() == BuildingControlUnit::Json::Telegrams::RelayState::telegramId())
|
|
handleRelayState(static_cast<BuildingControlUnit::Json::Telegrams::RelayState *>(tel));
|
|
else if (tel->telegramId() == BuildingControlUnit::Json::Telegrams::EffectOverride::telegramId())
|
|
handleEffectOverride(static_cast<BuildingControlUnit::Json::Telegrams::EffectOverride *>(tel));
|
|
else
|
|
WARNING_LOG(m_logger) << "Unhandled incoming telegram with id '" << tel->telegramId() << "'";
|
|
|
|
delete tel;
|
|
}
|
|
|
|
void BuildingProcess::handleBsmState(BuildingControlUnit::Json::Telegrams::BsmState *tel)
|
|
{
|
|
BuildingStateTechnical state;
|
|
state.id(m_buildingInfo.mseId);
|
|
state.assetId(m_buildingInfo.assetId);
|
|
state.structureElementId(m_buildingInfo.structureElementId);
|
|
state.sampleTime(QDateTime::currentMSecsSinceEpoch());
|
|
state.bsmStates().resize(tel->bsmStates.size());
|
|
BsmState s;
|
|
for (int i = 0; i < tel->bsmStates.size(); ++i)
|
|
{
|
|
const BuildingControlUnit::Json::Telegrams::BsmState::BsmStateInfo &info = tel->bsmStates.at(i);
|
|
s.id(info.id);
|
|
s.connected(info.connected);
|
|
s.hostport(info.port);
|
|
s.hostname(info.hostname.toStdString());
|
|
s.versionInfo(info.versionInfo.toStdString());
|
|
state.bsmStates()[i] = s;
|
|
m_bsmStates.insert(info.id, s);
|
|
}
|
|
|
|
m_mainHandler->ddsHandler()->dts()->publish(state);
|
|
}
|
|
|
|
void BuildingProcess::historyState(const BuildingState &state)
|
|
{
|
|
if (state.vulnerabilityState() == ProjectDataManagement::VulnerabilityState::CombatReady
|
|
&& state.damagePercent() == 0
|
|
&& state.originatorParticipantId() == 0
|
|
&& state.contaminationStates().size() == 0) // Criterium for init from Excon
|
|
{
|
|
DEBUG_LOG(m_logger) << "setVulnerabilityState->removeHistoryStateByKey:" << state.id();
|
|
m_historyState.stateHistory().resize(0);
|
|
}
|
|
|
|
HistoryStateItem historyStateItem;
|
|
historyStateItem.aesId(state.aesId());
|
|
historyStateItem.chargeTypeId(state.chargeTypeId());
|
|
historyStateItem.damagePercent(state.damagePercent());
|
|
historyStateItem.damagePercentOld(state.damagePercentOld());
|
|
historyStateItem.originatorParticipantId(state.originatorParticipantId());
|
|
historyStateItem.originatorType() = state.originatorType();
|
|
historyStateItem.time(state.sampleTime());
|
|
historyStateItem.vulnerabilityState() = state.vulnerabilityState();
|
|
historyStateItem.contaminationStates() = state.contaminationStates();
|
|
|
|
m_historyState.stateHistory().push_back(std::move(historyStateItem));
|
|
DEBUG_LOG(m_logger) << "BuildingProcess::historyState contaminationStates:" << state;
|
|
|
|
m_historyState.mseId(state.id());
|
|
DEBUG_LOG(m_logger) << "setVulnerabilityState->removeHistoryStateByKey:" << m_historyState.mseId();
|
|
m_historyState.sampleTime(QDateTime::currentMSecsSinceEpoch());
|
|
m_mainHandler->ddsHandler()->dts()->publish(m_historyState);
|
|
}
|
|
|
|
void BuildingProcess::handleHitResult(BuildingControlUnit::Json::Telegrams::HitResult *tel)
|
|
{
|
|
const BuildingControlUnit::Json::Telegrams::HitResult::HitResultInfo &data = tel->hitResult;
|
|
BuildingState state;
|
|
|
|
DEBUG_LOG(m_logger) << LOGFUNCTION << " data.hitOnRoomId=" << data.hitOnRoomId;
|
|
state.id(m_buildingInfo.mseId);
|
|
|
|
int assetId = m_mainHandler->ddsHandler()->dtcIsm()->getAssetIdFromMountingPointId(m_buildingInfo.mseId, data.sensorId);
|
|
DEBUG_LOG(m_logger) << "handleHitResult assetId=" << assetId;
|
|
state.assetId(assetId);
|
|
//state.structureElementId(m_buildingInfo.structureElementId);
|
|
InfrastructureManagement::StructureElement se;
|
|
m_mainHandler->ddsHandler()->dtcIsm()->getStructureElementInMntPointAssetByAssetId(assetId, se);
|
|
DEBUG_LOG(m_logger) << "handleHitResult structureElementId=" << se.id();
|
|
state.structureElementId(se.id());
|
|
state.sampleTime(QDateTime::currentMSecsSinceEpoch());
|
|
if (data.originatorType == BuildingControlUnit::OriginatorType::DirectHit)
|
|
{
|
|
// direct hit -> originator = equipmentNumber
|
|
state.originatorParticipantId(m_mainHandler->ppmHandler()->equipmentNumberToParticipantId(data.originatorId));
|
|
state.chargeTypeId(data.chargeTypeId);
|
|
state.originatorType(ProjectDataManagement::StateChangeOriginator_def::Participant);
|
|
}
|
|
else if (data.originatorType == BuildingControlUnit::OriginatorType::CesHit)
|
|
{
|
|
// indirect hit -> originator = aesId
|
|
state.aesId(data.originatorId);
|
|
// no need to convert because we sent our chargeTypeId within the hit request
|
|
state.chargeTypeId(data.chargeTypeId);
|
|
state.originatorType(ProjectDataManagement::StateChangeOriginator_def::AreaEffectSimulation);
|
|
}
|
|
else if (data.originatorType == BuildingControlUnit::OriginatorType::OC)// OC
|
|
{
|
|
state.originatorParticipantId(0);
|
|
state.chargeTypeId(data.chargeTypeId);
|
|
state.originatorType(ProjectDataManagement::StateChangeOriginator_def::ObserverController);
|
|
}
|
|
else // ECC
|
|
{
|
|
state.originatorParticipantId(0);
|
|
state.chargeTypeId(data.chargeTypeId);
|
|
state.originatorType(ProjectDataManagement::StateChangeOriginator_def::ExerciseControl);
|
|
}
|
|
state.damagePercent(data.damagePercentNew);
|
|
state.damagePercentOld(data.damagePercentOld);
|
|
state.vulnerabilityState(data.damageState == BuildingControlUnit::DamageState::Destroyed ?
|
|
ProjectDataManagement::VulnerabilityState::CatastrophicKill :
|
|
ProjectDataManagement::VulnerabilityState::CombatReady);
|
|
state.hitOnRoomId(data.hitOnRoomId);
|
|
state.roomStates().reserve(data.rooms.size());
|
|
RoomState s;
|
|
for (const auto &info : data.rooms)
|
|
{
|
|
s.id(m_buildingInfo.subId2RoomId.value(info.roomId));
|
|
s.mountingPointId(info.roomId);
|
|
s.damagePercent(info.damagePercent);
|
|
s.remainingEffectPercent(info.remainingEffectPercent);
|
|
s.fortifyFactor(info.fortifyFactor);
|
|
state.roomStates().push_back(s);
|
|
}
|
|
|
|
ContaminationState cs;
|
|
state.contaminationStates().reserve(data.contaminations.count());
|
|
for (const auto &csi : data.contaminations)
|
|
{
|
|
cs.aesId(csi.aesId);
|
|
cs.rooms().assign(csi.rooms.begin(), csi.rooms.end());
|
|
state.contaminationStates().push_back(cs);
|
|
}
|
|
|
|
|
|
if (m_historyState.mseId() != 0)
|
|
historyState(state);
|
|
else
|
|
{
|
|
// initial - don't publish state
|
|
m_historyState.mseId(m_buildingInfo.mseId);
|
|
}
|
|
|
|
m_mainHandler->ddsHandler()->dts()->publish(state);
|
|
if (data.originatorType == BuildingControlUnit::OriginatorType::DirectHit)
|
|
sendHitLine(state);
|
|
}
|
|
|
|
// [GUEZE-2011]
|
|
// Is run when an EGCU is reconnected to the Building
|
|
void BuildingProcess::handleReconnectEgcu(const QString &segment)
|
|
{
|
|
// Aus der Konfiguration effect_config.xml die Overrides vom Segment nehmen
|
|
// Function Topic ISM::LTS_StructureElementUpdateEffectOverrideRequest schicken
|
|
|
|
DEBUG_LOG(m_logger) << "handleReconnectEgcu segment =" << segment;
|
|
|
|
for (const EgcuInfo &egcu : qAsConst(m_buildingInfo.egcus))
|
|
{
|
|
if (QString::compare(egcu.hostname, segment, Qt::CaseInsensitive) == 0)
|
|
{
|
|
const auto keys = m_effectOverridesReconnect.keys();
|
|
for (const int &relayId : keys)
|
|
{
|
|
DEBUG_LOG(m_logger) << "RelayId=" << relayId
|
|
<< " Override=" << m_effectOverridesReconnect.value(relayId);
|
|
|
|
if (m_effectOverridesReconnect.value(relayId) >= 0)
|
|
{
|
|
// int relayId = 2; // fog (is loaded from effect_config.xml)
|
|
InfrastructureManagement::EffectOverride override = InfrastructureManagement::EffectOverride_def::PermanentOff;
|
|
|
|
int structureElementIdMp = m_mainHandler->ddsHandler()->dtcIsm()->getStructueElementIdFromAssetId(egcu.assetId);
|
|
|
|
DEBUG_LOG(m_logger) << "EGCU: " << egcu.assetName
|
|
<< " assetId=" << egcu.assetId
|
|
<< " hostname='" << egcu.hostname
|
|
<< "' buildingName=" << egcu.buildingName
|
|
<< " mountPointId=" << egcu.mountPointId
|
|
<< " structureElementIdMp=" << structureElementIdMp
|
|
<< " relayId=" << relayId;
|
|
|
|
|
|
InfrastructureManagement::StructureElementUpdateEffectOverrideRequest request;
|
|
request.structureElementId(structureElementIdMp);
|
|
request.effectId(relayId);
|
|
request.effectOverride(override);
|
|
DEBUG_LOG(m_logger) << "Vor structureElementUpdateEffectOverrideRequest";
|
|
int result = m_mainHandler->ismHandler()->ftcIsm()->structureElementUpdateEffectOverrideRequest(request, this);
|
|
DEBUG_LOG(m_logger) << "Nach structureElementUpdateEffectOverrideRequest result=" << result;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void BuildingProcess::handleRelayState(BuildingControlUnit::Json::Telegrams::RelayState *tel)
|
|
{
|
|
RelayState state;
|
|
|
|
DEBUG_LOG(m_logger) << "handleRelayState EGCU:" << tel->segment
|
|
<< " m_buildingInfo.egcus.size()=" << m_buildingInfo.egcus.size()
|
|
<< " stateTime=" << tel->stateTime
|
|
<< " offlineTime=" << tel->offlineTime;
|
|
|
|
// Check, if recconnect EGCU
|
|
if ( tel->offlineTime > 1000)
|
|
{
|
|
handleReconnectEgcu(tel->segment);
|
|
}
|
|
|
|
|
|
for (const EgcuInfo &egcu : qAsConst(m_buildingInfo.egcus))
|
|
{
|
|
if (QString::compare(egcu.hostname,tel->segment, Qt::CaseInsensitive) == 0)
|
|
{
|
|
DEBUG_LOG(m_logger) << "EGCU: " << egcu.assetName
|
|
<< " assetId=" << egcu.assetId
|
|
<< " hostname='" << egcu.hostname
|
|
<< "' buildingName=" << egcu.buildingName;
|
|
state.id(egcu.assetId);
|
|
state.stateTime(tel->stateTime);
|
|
state.offlineTime(tel->offlineTime);
|
|
break;
|
|
}
|
|
}
|
|
|
|
RelayStateItem item;
|
|
for (const auto &info : qAsConst(tel->relayStates))
|
|
{
|
|
item.id(info.id);
|
|
item.state(info.state);
|
|
|
|
state.relayStates().push_back(item);
|
|
}
|
|
|
|
// TODO nur geaenderte Meldungen auf den dds-Bus schicken.
|
|
m_mainHandler->ddsHandler()->dts()->publish(state);
|
|
}
|
|
|
|
void BuildingProcess::handleEffectOverride(BuildingControlUnit::Json::Telegrams::EffectOverride *tel)
|
|
{
|
|
DEBUG_LOG(m_logger) << "BuildingProcess::handleEffectOverride"
|
|
<< " tel->overrides.size=" << tel->overrides.size();
|
|
|
|
InfrastructureManagement::StructureElementUpdateEffectOverrideRequest request;
|
|
for ( int i = 0; i < m_buildingInfo.egcus.size(); i++)
|
|
{
|
|
DEBUG_LOG(m_logger) << "BuildingProcess::handleEffectOverride i=" << i;
|
|
if ( m_buildingInfo.egcus[i].hostname.toLower() == tel->segment)
|
|
{
|
|
int structureElementIdMp = m_mainHandler->ddsHandler()->dtcIsm()->getStructueElementIdFromAssetId( m_buildingInfo.egcus.at(i).assetId);
|
|
|
|
DEBUG_LOG(m_logger) << "BuildingProcess::handleEffectOverride i=" << i
|
|
<< " mountPointId=" << m_buildingInfo.egcus.at(i).mountPointId
|
|
<< " assetId=" << m_buildingInfo.egcus.at(i).assetId
|
|
<< " structureElementId=" << m_buildingInfo.structureElementId
|
|
<< " structureElementIdMp=" << structureElementIdMp;
|
|
|
|
request.structureElementId(structureElementIdMp);
|
|
}
|
|
for ( int j = 0; j < tel->overrides.size(); j++ )
|
|
{
|
|
//request.structureElementId(tel->segment);
|
|
request.effectId(tel->overrides.at(j).id);
|
|
switch (tel->overrides.at(j).effectOverride)
|
|
{
|
|
case -1:
|
|
{
|
|
request.effectOverride(InfrastructureManagement::EffectOverride_def::Automatic);
|
|
break;
|
|
}
|
|
case 0:
|
|
{
|
|
request.effectOverride(InfrastructureManagement::EffectOverride_def::PermanentOff);
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
request.effectOverride(InfrastructureManagement::EffectOverride_def::PermanentOn);
|
|
break;
|
|
}
|
|
}
|
|
DEBUG_LOG(m_logger) << "Send Override Request"
|
|
<< " structureElementId=" << request.structureElementId()
|
|
<< " effectId=" << request.effectId()
|
|
<< " effectOverride=" << request.effectOverride();
|
|
if ( request.structureElementId() > 0)
|
|
m_mainHandler->ddsHandler()->ftcIsm()->structureElementUpdateEffectOverrideRequest(request, this);
|
|
else
|
|
ERROR_LOG(m_logger) << "request.structureElementId() =" << request.structureElementId() << " NOT VALID!!!";
|
|
}
|
|
}
|
|
}
|
|
|
|
bool BuildingProcess::isValidPos(const Core::GeoPosition &pos)
|
|
{
|
|
if (qFuzzyIsNull(pos.lat()) && qFuzzyIsNull(pos.lon()))
|
|
return false;
|
|
return !std::isnan(pos.lat()) && !std::isnan(pos.lon());
|
|
}
|
|
|
|
void BuildingProcess::sendHitLine(const BuildingState &state)
|
|
{
|
|
if (state.originatorParticipantId() <= 0)
|
|
return;
|
|
const ParticipantManagement::ParticipantPosition participantPosition = m_mainHandler->ppmHandler()->participantPosition(state.originatorParticipantId());
|
|
if (!isValidPos(participantPosition.pos()))
|
|
return;
|
|
BuildingHitLineInfo buildingHitLineInfo;
|
|
InfrastructureManagement::MainStructureElement mainStructureElement = m_mainHandler->ismHandler()->mainStructureElement(state.id());
|
|
// Direct Fire
|
|
buildingHitLineInfo.id(m_hitLineId);
|
|
buildingHitLineInfo.buildingId(m_buildingInfo.mseId);
|
|
buildingHitLineInfo.buildingPos(mainStructureElement.geoPosition());
|
|
if (state.hitOnRoomId() > 0)
|
|
{
|
|
for (const auto &se : mainStructureElement.elements())
|
|
{
|
|
if (se.structureElementTypeId() == InfrastructureManagement::StructureElementType::Room &&
|
|
se.mountingPointId() == state.hitOnRoomId())
|
|
{
|
|
buildingHitLineInfo.buildingPos(se.geoPosition());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
buildingHitLineInfo.chargeTypeId(state.chargeTypeId());
|
|
buildingHitLineInfo.originatorParticipantId(state.originatorParticipantId());
|
|
buildingHitLineInfo.originatorPos(participantPosition.pos());
|
|
buildingHitLineInfo.originatorPartyId(participantPosition.partyId());
|
|
buildingHitLineInfo.sampleTime(state.sampleTime());
|
|
buildingHitLineInfo.hitOnRoomId(state.hitOnRoomId());
|
|
buildingHitLineInfo.contaminationStates(state.contaminationStates());
|
|
|
|
m_mainHandler->ddsHandler()->dts()->publish(buildingHitLineInfo);
|
|
|
|
m_hitLineInfoMap.insert(buildingHitLineInfo.id(), buildingHitLineInfo);
|
|
++m_hitLineId;
|
|
}
|
|
|
|
void BuildingProcess::onHitLineInfoTimeout()
|
|
{
|
|
const qint64 tNow = QDateTime::currentMSecsSinceEpoch();
|
|
|
|
auto it = m_hitLineInfoMap.begin();
|
|
while (it != m_hitLineInfoMap.end())
|
|
{
|
|
if (!LtsUtils::isPositionTimeOutdated(tNow, it.value().sampleTime()))
|
|
break;
|
|
m_mainHandler->ddsHandler()->dts()->removeBuildingHitLineInfoByKey(it.value().id());
|
|
|
|
it = m_hitLineInfoMap.erase(it);
|
|
}
|
|
}
|
|
|
|
bool BuildingProcess::writeFile(const QString &fn, const QByteArray &data)
|
|
{
|
|
QFile f(fn);
|
|
if (!f.open(QIODevice::WriteOnly | QIODevice::Truncate))
|
|
{
|
|
WARNING_LOG(m_logger) << "Can not open file '" << fn << "' - error: " << f.errorString();
|
|
return false;
|
|
}
|
|
if (f.write(data) != data.size())
|
|
{
|
|
WARNING_LOG(m_logger) << "Can not write data to file '" << fn << "' - error: " << f.errorString();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static void outputBsmData(QXmlStreamWriter &sw, const BsmInfo &bsm)
|
|
{
|
|
sw.writeStartElement(QStringLiteral("BSM"));
|
|
{
|
|
sw.writeAttribute(QStringLiteral("id"), QString::number(bsm.bsmId));
|
|
sw.writeAttribute(QStringLiteral("hostname"), bsm.hostname);
|
|
sw.writeAttribute(QStringLiteral("port"), QString::number(bsm.port));
|
|
|
|
sw.writeStartElement(QStringLiteral("Position"));
|
|
{
|
|
sw.writeAttribute(QStringLiteral("x"), QString::number(bsm.relPosition.offsetX(), 'f', 10));
|
|
sw.writeAttribute(QStringLiteral("y"), QString::number(bsm.relPosition.offsetY(), 'f', 10));
|
|
sw.writeAttribute(QStringLiteral("z"), QString::number(bsm.relPosition.offsetZ(), 'f', 10));
|
|
}
|
|
sw.writeEndElement();
|
|
sw.writeStartElement(QStringLiteral("Direction"));
|
|
{
|
|
sw.writeAttribute(QStringLiteral("x"), QString::number(bsm.orientation.heave(), 'f', 10));
|
|
sw.writeAttribute(QStringLiteral("y"), QString::number(bsm.orientation.pitch(), 'f', 10));
|
|
sw.writeAttribute(QStringLiteral("z"), QString::number(bsm.orientation.roll(), 'f', 10));
|
|
}
|
|
sw.writeEndElement();
|
|
}
|
|
sw.writeEndElement();
|
|
}
|
|
|
|
static void outputEgcuData(QXmlStreamWriter &sw, const EgcuInfo &egcu)
|
|
{
|
|
sw.writeStartElement(QStringLiteral("EGCU"));
|
|
{
|
|
sw.writeAttribute(QStringLiteral("hostname"), egcu.hostname);
|
|
|
|
sw.writeStartElement(QStringLiteral("rooms"));
|
|
for (int roomId : egcu.roomIds)
|
|
{
|
|
sw.writeStartElement(QStringLiteral("room"));
|
|
sw.writeAttribute(QStringLiteral("id"), QString::number(roomId));
|
|
sw.writeEndElement();
|
|
}
|
|
sw.writeEndElement();
|
|
}
|
|
sw.writeEndElement();
|
|
}
|
|
|
|
QByteArray BuildingProcess::generateBuildingConfigData() const
|
|
{
|
|
QByteArray ret;
|
|
QXmlStreamWriter sw(&ret);
|
|
sw.setAutoFormatting(true);
|
|
sw.setAutoFormattingIndent(2);
|
|
sw.setCodec("UTF-8");
|
|
sw.writeStartDocument(QStringLiteral("1.0"), true);
|
|
sw.writeStartElement(QStringLiteral("BuildingConfiguration"));
|
|
{
|
|
sw.writeTextElement(QStringLiteral("BuildingName"), m_buildingInfo.name);
|
|
sw.writeTextElement(QStringLiteral("ModelId"), QString::number(m_buildingInfo.modelId));
|
|
for (const BsmInfo &bsm : m_buildingInfo.bsms)
|
|
outputBsmData(sw, bsm);
|
|
for (const EgcuInfo &egcu : m_buildingInfo.egcus)
|
|
outputEgcuData(sw, egcu);
|
|
}
|
|
sw.writeEndElement();
|
|
sw.writeEndDocument();
|
|
|
|
return ret;
|
|
}
|
|
|
|
QByteArray BuildingProcess::generateChargesData() const
|
|
{
|
|
const QMap<int, ProjectDataManagement::BuildingChargeEffect> buildingCharges = m_mainHandler->pdmHandler()->buildingChargeEffects();
|
|
const QMap<int, ProjectDataManagement::ChargeType> chargeTypes = m_mainHandler->pdmHandler()->chargeTypes();
|
|
QByteArray ret;
|
|
QString properties = QStringLiteral("TODO fill properties");
|
|
QXmlStreamWriter sw(&ret);
|
|
sw.setAutoFormatting(true);
|
|
sw.setAutoFormattingIndent(2);
|
|
sw.setCodec("UTF-8");
|
|
sw.writeStartDocument(QStringLiteral("1.0"), true);
|
|
sw.writeStartElement(QStringLiteral("Charges"));
|
|
{
|
|
for (const ProjectDataManagement::BuildingChargeEffect &charge : buildingCharges)
|
|
{
|
|
auto it = chargeTypes.find(charge.chargeTypeId());
|
|
if (it == chargeTypes.end())
|
|
{
|
|
WARNING_LOG(m_logger) << "Could not find charge type with id " << charge.chargeTypeId() << " - skipping";
|
|
continue;
|
|
}
|
|
// NOTE: igniterTypeId/IgniterFunction = 0 as long as BuildingChargeEffect does not contain values
|
|
ProjectDataManagement::ChargeTypeProperty chargeTypeProperty = m_mainHandler->ddsHandler()->dtcPdm()->getChargeTypeSpecialProperty(charge.chargeTypeId(),0,0);
|
|
sw.writeStartElement(QStringLiteral("Charge"));
|
|
sw.writeTextElement(QStringLiteral("Id"), QString::number(charge.id()));
|
|
sw.writeTextElement(QStringLiteral("ChargeTypeId"), QString::number(charge.chargeTypeId()));
|
|
sw.writeTextElement(QStringLiteral("DestructiveFactor"), QString::number(charge.destructiveFactor()));
|
|
sw.writeTextElement(QStringLiteral("PenetrationEffect"), QString::number(charge.penetrationFactor()));
|
|
sw.writeTextElement(QStringLiteral("properties"), properties);
|
|
sw.writeTextElement(QStringLiteral("EffectSound"), QString::number(charge.hitSound()));
|
|
sw.writeTextElement(QStringLiteral("DifcueLight"), QString::number(charge.difcueLight()));
|
|
sw.writeTextElement(QStringLiteral("DifcuePyro"), QString::number(charge.difcuePyro()));
|
|
if (chargeTypeProperty == ProjectDataManagement::ChargeTypeProperty_def::None)
|
|
if (charge.destructiveFactor() > 0)
|
|
sw.writeTextElement(QStringLiteral("showHitLine"), QString::number(1));
|
|
else
|
|
sw.writeTextElement(QStringLiteral("showHitLine"), QString::number(0));
|
|
else
|
|
sw.writeTextElement(QStringLiteral("showHitLine"), QString::number(1));
|
|
sw.writeEndElement();
|
|
}
|
|
}
|
|
sw.writeEndElement();
|
|
sw.writeEndDocument();
|
|
|
|
return ret;
|
|
}
|
|
|
|
void BuildingProcess::openWebSocket()
|
|
{
|
|
closeWebSocket();
|
|
m_wsSocket = new QWebSocket;
|
|
connect(m_wsSocket, QOverload<QAbstractSocket::SocketError>::of(&QWebSocket::error),
|
|
this, &BuildingProcess::onWebSocketError);
|
|
connect(m_wsSocket, &QWebSocket::connected,
|
|
this, &BuildingProcess::onWebSocketConnected);
|
|
connect(m_wsSocket, &QWebSocket::disconnected,
|
|
this, &BuildingProcess::onWebSocketDisconnected);
|
|
connect(m_wsSocket, &QWebSocket::textMessageReceived,
|
|
this, &BuildingProcess::onTextMessageReceived);
|
|
WARNING_LOG(m_logger) << "openWebSocket:" << m_wsUrl.toLocal8Bit()
|
|
<< " (buildingId: " << m_buildingInfo.mseId << ") - socket: " << m_wsSocket;
|
|
m_wsSocket->open(QUrl::fromEncoded(m_wsUrl.toLocal8Bit()));
|
|
}
|
|
|
|
void BuildingProcess::closeWebSocket()
|
|
{
|
|
if (m_wsSocket)
|
|
{
|
|
WARNING_LOG(m_logger) << "closeWebSocket (buildingId : " << m_buildingInfo.mseId << ") - socket: " << m_wsSocket
|
|
<< " localPort=" << m_wsSocket->localPort() << ", error: " << ", " << m_wsSocket->errorString();
|
|
m_wsSocket->disconnect(this);
|
|
m_wsSocket->close();
|
|
m_wsSocket->deleteLater();
|
|
m_wsSocket = nullptr;
|
|
}
|
|
m_wsReconnectTimer->stop();
|
|
}
|
|
|
|
void BuildingProcess::onWebSocketError(QAbstractSocket::SocketError error)
|
|
{
|
|
if (!m_wsSocket)
|
|
return;
|
|
WARNING_LOG(m_logger) << "Error connecting to " << m_wsSocket->peerAddress().toString() << ": " << error
|
|
<< " (buildingId: " << m_buildingInfo.mseId << ") - socket: " << m_wsSocket;
|
|
closeWebSocket();
|
|
m_wsReconnectTimer->start(1000);
|
|
}
|
|
|
|
void BuildingProcess::onWebSocketConnected()
|
|
{
|
|
INFO_LOG(m_logger) << "connected to building control process " << m_buildingInfo.mseId << " via websockets localPort="<<m_wsSocket->localPort();
|
|
|
|
QMapIterator<int, QString> i(m_effectStates);
|
|
while (i.hasNext()) {
|
|
i.next();
|
|
|
|
DEBUG_LOG(m_logger) << "setEffectStates websocket send: " << i.value();
|
|
qint64 sendBytesCount = m_wsSocket->sendTextMessage(i.value());
|
|
DEBUG_LOG(m_logger) << "sendBytesCount= " << sendBytesCount;
|
|
}
|
|
m_wsReconnectTimer->stop();
|
|
}
|
|
|
|
void BuildingProcess::onWebSocketDisconnected()
|
|
{
|
|
WARNING_LOG(m_logger) << "Websocket to " << m_wsUrl << " closed - trying to reconnect in 1 sec"
|
|
<< " (buildingId : " << m_buildingInfo.mseId << ") - socket: " << m_wsSocket
|
|
<< " localPort=" << m_wsSocket->localPort();
|
|
closeWebSocket();
|
|
m_wsReconnectTimer->start(1000);
|
|
}
|
|
|
|
} // namespace Buildings
|