855 lines
25 KiB
C++
Executable File
855 lines
25 KiB
C++
Executable File
/**
|
|
* Websocket interface for building control unit - telgram definition
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Christian Ehrlicher, SLSE, 2017-01-30
|
|
*/
|
|
|
|
#include "web_socket_telegrams.h"
|
|
#include <QJsonDocument>
|
|
#include <QJsonObject>
|
|
#include <QJsonArray>
|
|
|
|
namespace BuildingControlUnit
|
|
{
|
|
namespace Json
|
|
{
|
|
namespace Telegrams
|
|
{
|
|
|
|
static QString s_aesId() { return QStringLiteral("aesId"); }
|
|
static QString s_bsmStateInfo() { return QStringLiteral("bsmStateInfo"); }
|
|
static QString s_chargeTypeId() { return QStringLiteral("chargeTypeId"); }
|
|
static QString s_connected() { return QStringLiteral("connected"); }
|
|
static QString s_count() { return QStringLiteral("count"); }
|
|
static QString s_properties() { return QStringLiteral("properties"); }
|
|
static QString s_damagePercentNew() { return QStringLiteral("damagePercentNew"); }
|
|
static QString s_damagePercentOld() { return QStringLiteral("damagePercentOld"); }
|
|
static QString s_damagePercent() { return QStringLiteral("damagePercent"); }
|
|
static QString s_damageState() { return QStringLiteral("damageState"); }
|
|
static QString s_data() { return QStringLiteral("data"); }
|
|
static QString s_delay() { return QStringLiteral("delay"); }
|
|
static QString s_deposition1() { return QStringLiteral("deposition1"); }
|
|
static QString s_deposition2() { return QStringLiteral("deposition2"); }
|
|
static QString s_destructiveFactor() { return QStringLiteral("destructiveFactor"); }
|
|
static QString s_effectSoundId() { return QStringLiteral("effectSoundId"); }
|
|
static QString s_effectTime() { return QStringLiteral("effectTime"); }
|
|
static QString s_effectOverride() { return QStringLiteral("effectOverride"); }
|
|
static QString s_effectStates() { return QStringLiteral("effectStates"); }
|
|
static QString s_fortifyFactor() { return QStringLiteral("fortifyFactor"); }
|
|
static QString s_fortifyFactors() { return QStringLiteral("fortifyFactors"); }
|
|
static QString s_hitOnRoomId() { return QStringLiteral("hitOnRoomId"); }
|
|
static QString s_hostname() { return QStringLiteral("hostname"); }
|
|
static QString s_id() { return QStringLiteral("id"); }
|
|
static QString s_numberOfFlashes() { return QStringLiteral("numberOfFlashes"); }
|
|
static QString s_offlineTime() { return QStringLiteral("offlineTime"); }
|
|
static QString s_originatorId() { return QStringLiteral("originatorId"); }
|
|
static QString s_originatorType() { return QStringLiteral("originatorType"); }
|
|
static QString s_pauseBetweenFlashesSec() { return QStringLiteral("pauseBetweenFlashesSec"); }
|
|
static QString s_penetrationFactor() { return QStringLiteral("penetrationFactor"); }
|
|
static QString s_port() { return QStringLiteral("port"); }
|
|
static QString s_pulse() { return QStringLiteral("pulse"); }
|
|
static QString s_relativePosition() { return QStringLiteral("relativePosition"); }
|
|
static QString s_impactPosition() { return QStringLiteral("relativePosition"); }
|
|
static QString s_detonationLocation() { return QStringLiteral("detonationLocation"); }
|
|
static QString s_detonationDistance() { return QStringLiteral("detonationDistance"); }
|
|
static QString s_relayStates() { return QStringLiteral("relayStates"); }
|
|
static QString s_remainingEffectPercent() { return QStringLiteral("remainingEffectPercent"); }
|
|
static QString s_rooms() { return QStringLiteral("rooms"); }
|
|
static QString s_contaminationStates() { return QStringLiteral("contaminationStates"); }
|
|
static QString s_segment() { return QStringLiteral("segment"); }
|
|
static QString s_sensorId() { return QStringLiteral("sensorId"); }
|
|
static QString s_state() { return QStringLiteral("state"); }
|
|
static QString s_relayStateTime() { return QStringLiteral("relayStateTime"); }
|
|
static QString s_timestamp() { return QStringLiteral("timestamp"); }
|
|
static QString s_type() { return QStringLiteral("type"); }
|
|
static QString s_versionInfo() { return QStringLiteral("versionInfo"); }
|
|
static QString s_x() { return QStringLiteral("x"); }
|
|
static QString s_y() { return QStringLiteral("y"); }
|
|
static QString s_z() { return QStringLiteral("z"); }
|
|
|
|
//
|
|
// Helper functions
|
|
//
|
|
static inline double toDouble(const QJsonValue &val, bool &bOk)
|
|
{
|
|
bOk = bOk && val.isDouble();
|
|
return val.toDouble();
|
|
}
|
|
|
|
static inline int toInteger(const QJsonValue &val, bool &bOk)
|
|
{
|
|
bOk = bOk && val.isDouble();
|
|
return qRound(val.toDouble());
|
|
}
|
|
|
|
static inline int64_t toInt64(const QJsonValue &val, bool &bOk)
|
|
{
|
|
bOk = bOk && val.isDouble();
|
|
return qRound64(val.toDouble());
|
|
}
|
|
|
|
static inline bool toBoolean(const QJsonValue &val, bool &bOk)
|
|
{
|
|
bOk = bOk && val.isBool();
|
|
return val.toBool();
|
|
}
|
|
|
|
//
|
|
// BaseTelegram
|
|
//
|
|
QByteArray BaseTelegram::toJsonInternal(const QJsonObject &data) const
|
|
{
|
|
//const QJsonDocument::JsonFormat f = QJsonDocument::Compact;
|
|
const QJsonDocument::JsonFormat f = QJsonDocument::Indented;
|
|
return QJsonDocument(QJsonObject({{s_type(), m_telegramId},
|
|
{s_data(), data}
|
|
})).toJson(f);
|
|
}
|
|
|
|
BaseTelegram *BaseTelegram::telegramFromJson(const QByteArray &jsonMsg)
|
|
{
|
|
const QJsonDocument doc(QJsonDocument::fromJson(jsonMsg));
|
|
const QJsonObject obj = doc.object();
|
|
const QString telId = obj[s_type()].toString();
|
|
const QJsonObject data = obj[s_data()].toObject();
|
|
|
|
if (telId.isEmpty())
|
|
return nullptr;
|
|
|
|
|
|
if (telId == SetDamageState::telegramId()) return SetDamageState::fromJson(data);
|
|
if (telId == SetContaminationState::telegramId()) return SetContaminationState::fromJson(data);
|
|
if (telId == ResetContaminationState::telegramId()) return ResetContaminationState::fromJson(data);
|
|
if (telId == SetEffectStates::telegramId()) return SetEffectStates::fromJson(data);
|
|
if (telId == SetFortifyFactor::telegramId()) return SetFortifyFactor::fromJson(data);
|
|
if (telId == RelayState::telegramId()) return RelayState::fromJson(data);
|
|
if (telId == EffectOverride::telegramId()) return EffectOverride::fromJson(data);
|
|
if (telId == HitResult::telegramId()) return HitResult::fromJson(data);
|
|
if (telId == BsmState::telegramId()) return BsmState::fromJson(data);
|
|
if (telId == BsmTriggerFlashlight::telegramId()) return BsmTriggerFlashlight::fromJson(data);
|
|
if (telId == CentralEffectSimulationHit::telegramId()) return CentralEffectSimulationHit::fromJson(data);
|
|
if (telId == CentralEffectSimulationHit3D::telegramId()) return CentralEffectSimulationHit3D::fromJson(data);
|
|
if (telId == DebugSimulateBSMHit::telegramId()) return DebugSimulateBSMHit::fromJson(data);
|
|
if (telId == GetBsmConfiguration::telegramId()) return GetBsmConfiguration::fromJson(data);
|
|
if (telId == GetBsmBitTimeout::telegramId()) return GetBsmBitTimeout::fromJson(data);
|
|
if (telId == GetBsmTechnicalStatus::telegramId()) return GetBsmTechnicalStatus::fromJson(data);
|
|
if (telId == SwitchRelay::telegramId()) return SwitchRelay::fromJson(data);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
//
|
|
// BaseReport
|
|
//
|
|
QByteArray BaseReport::toJsonInternal(const QJsonObject &_data) const
|
|
{
|
|
QJsonObject data(_data);
|
|
data[s_timestamp()] = timestamp;
|
|
|
|
return BaseTelegram::toJsonInternal(data);
|
|
}
|
|
|
|
void BaseReport::fromJsonInternal(const QJsonObject &data, BaseReport *tele, bool &bOk)
|
|
{
|
|
tele->timestamp = toInt64(data[s_timestamp()], bOk);
|
|
}
|
|
|
|
//
|
|
// BsmTriggerFlashlight
|
|
//
|
|
QByteArray BsmTriggerFlashlight::toJson() const
|
|
{
|
|
return toJsonInternal(
|
|
QJsonObject(
|
|
{
|
|
{s_hostname(), hostname},
|
|
{s_sensorId(), sensorId},
|
|
{s_numberOfFlashes(), numberOfFlashes},
|
|
{s_pauseBetweenFlashesSec(), pauseBetweenFlashesSec},
|
|
}));
|
|
}
|
|
|
|
BsmTriggerFlashlight *BsmTriggerFlashlight::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
BsmTriggerFlashlight ret;
|
|
ret.sensorId = toInteger(data[s_sensorId()], bOk);
|
|
ret.numberOfFlashes = toInteger(data[s_numberOfFlashes()], bOk);
|
|
ret.pauseBetweenFlashesSec = toInteger(data[s_pauseBetweenFlashesSec()], bOk);
|
|
|
|
if (data.contains(s_hostname()))
|
|
{
|
|
ret.hostname = data.value(s_hostname()).toString();
|
|
bOk = !ret.hostname.isEmpty();
|
|
}
|
|
|
|
return bOk ? new BsmTriggerFlashlight(ret) : nullptr;
|
|
}
|
|
|
|
//
|
|
// SetDamageState
|
|
//
|
|
QByteArray SetDamageState::toJson() const
|
|
{
|
|
QJsonObject obj(
|
|
{
|
|
{s_originatorId(), originatorId},
|
|
{s_damageState(), static_cast<int>(damageState)}
|
|
});
|
|
if (!roomIds.isEmpty())
|
|
{
|
|
QJsonArray arr;
|
|
for (int id : roomIds)
|
|
arr += QJsonValue(id);
|
|
obj[s_rooms()] = arr;
|
|
}
|
|
|
|
return toJsonInternal(obj);
|
|
}
|
|
|
|
SetDamageState *SetDamageState::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
SetDamageState ret;
|
|
ret.damageState = static_cast<DamageState>(toInteger(data[s_damageState()], bOk));
|
|
ret.originatorId = toInteger(data[s_originatorId()], bOk);
|
|
const QJsonArray arr = data[s_rooms()].toArray();
|
|
ret.roomIds.reserve(arr.size());
|
|
for (const auto &ele : arr)
|
|
{
|
|
int roomId = toInteger(ele, bOk);
|
|
ret.roomIds.push_back(roomId);
|
|
}
|
|
|
|
return bOk ? new SetDamageState(ret) : nullptr;
|
|
}
|
|
|
|
//
|
|
// SetContaminationState
|
|
//
|
|
SetContaminationState *SetContaminationState::fromJson(const QJsonObject &data)
|
|
{
|
|
SetContaminationState ret;
|
|
const QJsonArray jsArr = data.value(s_contaminationStates()).toArray();
|
|
for (const auto &js : jsArr)
|
|
{
|
|
const QJsonObject &obj = js.toObject();
|
|
BuildingControlUnit::ContaminationState cs;
|
|
cs.aesId = obj[s_aesId()].toInt();
|
|
cs.damagePercentNew = obj[s_damagePercentNew()].toInt();
|
|
|
|
const QJsonArray &roomArr = obj[s_rooms()].toArray();
|
|
cs.rooms.reserve(roomArr.count());
|
|
for (const auto & id : roomArr)
|
|
cs.rooms.push_back(id.toInt());
|
|
|
|
ret.contaminationStates.push_back(cs);
|
|
}
|
|
|
|
return new SetContaminationState(ret);
|
|
}
|
|
|
|
QByteArray SetContaminationState::toJson() const
|
|
{
|
|
QJsonArray contaminationArr;
|
|
for (const auto &cs : contaminationStates )
|
|
{
|
|
QJsonArray roomArr;
|
|
for (const auto & roomId : qAsConst(cs.rooms))
|
|
roomArr.append(QJsonValue(roomId));
|
|
|
|
contaminationArr.append(QJsonObject({ {s_aesId(), cs.aesId},
|
|
{s_damagePercentNew(), cs.damagePercentNew},
|
|
{s_rooms(), roomArr}}));
|
|
}
|
|
QJsonObject obj({{s_contaminationStates(), contaminationArr}});
|
|
return toJsonInternal(obj);
|
|
}
|
|
|
|
//
|
|
// ResetContaminationState
|
|
//
|
|
ResetContaminationState *ResetContaminationState::fromJson(const QJsonObject &data)
|
|
{
|
|
Q_UNUSED(data)
|
|
bool bOk = true;
|
|
ResetContaminationState ret;
|
|
return bOk ? new ResetContaminationState(ret) : nullptr;
|
|
}
|
|
|
|
QByteArray ResetContaminationState::toJson() const
|
|
{
|
|
QJsonObject obj = {};
|
|
return toJsonInternal(obj);
|
|
}
|
|
|
|
//
|
|
// SetEffectStates
|
|
//
|
|
QByteArray SetEffectStates::toJson() const
|
|
{
|
|
QString esTypeStr;
|
|
QJsonObject obj({{s_segment(), segment}});
|
|
QJsonArray arr;
|
|
for (const auto &es : effectStates)
|
|
{
|
|
switch (es.type)
|
|
{
|
|
case (BET_Unset):
|
|
esTypeStr = QStringLiteral("TypeUnknown");
|
|
break;
|
|
case (BET_Relay):
|
|
esTypeStr = QStringLiteral("relayAction");
|
|
break;
|
|
case (BET_BackgroundSound):
|
|
esTypeStr = QStringLiteral("backgroundSoundAction");
|
|
break;
|
|
case (BET_BsmFlash):
|
|
esTypeStr = QStringLiteral("bsmFlashAction");
|
|
break;
|
|
|
|
}
|
|
arr += QJsonObject(
|
|
{
|
|
{s_id(), es.id},
|
|
{s_type(), esTypeStr},
|
|
{s_effectOverride(), es.effectOverride}
|
|
});
|
|
}
|
|
obj[s_effectStates()] = arr;
|
|
|
|
return toJsonInternal(obj);
|
|
}
|
|
|
|
SetEffectStates *SetEffectStates::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
SetEffectStates ret;
|
|
|
|
ret.segment = data[s_segment()].toString();
|
|
|
|
const QJsonArray arr = data[s_effectStates()].toArray();
|
|
ret.effectStates.reserve(arr.size());
|
|
for (const auto &ele : arr)
|
|
{
|
|
const QJsonObject obj = ele.toObject();
|
|
BcuEffectState info;
|
|
info.id = toInteger(obj[s_id()], bOk);
|
|
|
|
QString typeString = obj[s_type()].toString();
|
|
if (typeString == QStringLiteral("relayAction"))
|
|
info.type = BET_Relay;
|
|
else if (typeString == QStringLiteral("backgroundSoundAction"))
|
|
info.type = BET_BackgroundSound;
|
|
else if (typeString == QStringLiteral("bsmFlashAction"))
|
|
info.type = BET_BsmFlash;
|
|
|
|
info.effectOverride = static_cast<BcuEffectOverride>(toInteger(obj[s_effectOverride()], bOk));
|
|
|
|
ret.effectStates += info;
|
|
}
|
|
|
|
return bOk ? new SetEffectStates(ret) : nullptr;
|
|
}
|
|
|
|
//
|
|
// SwitchRelay
|
|
//
|
|
QByteArray SwitchRelay::toJson() const
|
|
{
|
|
QJsonObject obj({{s_segment(), segment},
|
|
{s_id(), switchRelayValues.id},
|
|
{s_state(), switchRelayValues.bcuRelayState},
|
|
{s_count(), switchRelayValues.count},
|
|
{s_pulse(), switchRelayValues.pulse},
|
|
{s_delay(), switchRelayValues.delay}
|
|
});
|
|
return toJsonInternal(obj);
|
|
}
|
|
|
|
SwitchRelay *SwitchRelay::fromJson(const QJsonObject &data)
|
|
{
|
|
SwitchRelay ret;
|
|
|
|
ret.segment = data[s_segment()].toString();
|
|
ret.switchRelayValues.id = data[s_id()].toInt();
|
|
ret.switchRelayValues.bcuRelayState = static_cast <BcuRelayState>(data[s_state()].toInt());
|
|
ret.switchRelayValues.count = data[s_count()].toInt();
|
|
ret.switchRelayValues.pulse = data[s_pulse()].toInt();
|
|
ret.switchRelayValues.delay = data[s_delay()].toInt();
|
|
|
|
return new SwitchRelay(ret);
|
|
}
|
|
|
|
|
|
//
|
|
// SetFortifyFactor
|
|
//
|
|
QByteArray SetFortifyFactor::toJson() const
|
|
{
|
|
QJsonObject obj({{s_originatorId(), originatorId}});
|
|
QJsonArray arr;
|
|
for (const auto &ff : fortifyFactors)
|
|
{
|
|
arr += QJsonObject(
|
|
{
|
|
{s_id(), ff.roomId},
|
|
{s_fortifyFactor(), ff.fortifyFactor}
|
|
});
|
|
}
|
|
obj[s_fortifyFactors()] = arr;
|
|
|
|
return toJsonInternal(obj);
|
|
}
|
|
|
|
SetFortifyFactor *SetFortifyFactor::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
SetFortifyFactor ret;
|
|
ret.originatorId = toInteger(data[s_originatorId()], bOk);
|
|
|
|
const QJsonArray arr = data[s_fortifyFactors()].toArray();
|
|
ret.fortifyFactors.reserve(arr.size());
|
|
for (const auto &ele : arr)
|
|
{
|
|
const QJsonObject obj = ele.toObject();
|
|
FortifyInfo info;
|
|
info.roomId = toInteger(obj[s_id()], bOk);
|
|
info.fortifyFactor = toDouble(obj[s_fortifyFactor()], bOk);
|
|
|
|
ret.fortifyFactors += info;
|
|
}
|
|
|
|
return bOk ? new SetFortifyFactor(ret) : nullptr;
|
|
}
|
|
//
|
|
// RelayStates
|
|
//
|
|
QByteArray RelayState::toJson() const
|
|
{
|
|
QJsonObject obj({{s_segment(), segment}});
|
|
QJsonArray arr;
|
|
for (const auto &es : relayStates)
|
|
{
|
|
arr += QJsonObject(
|
|
{
|
|
{s_id(), es.id},
|
|
{s_state(), es.state},
|
|
});
|
|
}
|
|
obj[s_relayStates()] = arr;
|
|
obj[s_relayStateTime()] = stateTime;
|
|
obj[s_offlineTime()] = offlineTime;
|
|
return toJsonInternal(obj);
|
|
}
|
|
|
|
RelayState *RelayState::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
RelayState ret;
|
|
|
|
ret.segment = data[s_segment()].toString();
|
|
ret.stateTime = data[s_relayStateTime()].toDouble();
|
|
ret.offlineTime = data[s_offlineTime()].toDouble();
|
|
|
|
|
|
const QJsonArray arr = data[s_relayStates()].toArray();
|
|
ret.relayStates.reserve(arr.size());
|
|
for (const auto &ele : arr)
|
|
{
|
|
const QJsonObject obj = ele.toObject();
|
|
RelayStateInfo info;
|
|
info.id = toInteger(obj[s_id()], bOk);
|
|
info.state = toBoolean(obj[s_state()], bOk);
|
|
ret.relayStates += info;
|
|
}
|
|
|
|
return bOk ? new RelayState(ret) : nullptr;
|
|
}
|
|
|
|
QByteArray EffectOverride::toJson() const
|
|
{
|
|
QJsonObject obj({{s_segment(), segment}});
|
|
QJsonArray arr;
|
|
for (const auto &es : overrides)
|
|
{
|
|
arr += QJsonObject(
|
|
{
|
|
{s_id(), es.id},
|
|
{s_effectOverride(), es.effectOverride},
|
|
});
|
|
}
|
|
obj[s_relayStates()] = arr;
|
|
obj[s_relayStateTime()] = stateTime;
|
|
obj[s_offlineTime()] = offlineTime;
|
|
return toJsonInternal(obj);
|
|
}
|
|
|
|
|
|
EffectOverride *EffectOverride::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
EffectOverride ret;
|
|
|
|
ret.segment = data[s_segment()].toString();
|
|
ret.stateTime = data[s_relayStateTime()].toDouble();
|
|
ret.offlineTime = data[s_offlineTime()].toDouble();
|
|
|
|
|
|
const QJsonArray arr = data[s_relayStates()].toArray();
|
|
ret.overrides.reserve(arr.size());
|
|
for (const auto &ele : arr)
|
|
{
|
|
const QJsonObject obj = ele.toObject();
|
|
OverrideInfo info;
|
|
info.id = toInteger(obj[s_id()], bOk);
|
|
info.effectOverride = toInteger(obj[s_effectOverride()], bOk);
|
|
ret.overrides += info;
|
|
}
|
|
|
|
return bOk ? new EffectOverride(ret) : nullptr;
|
|
}
|
|
|
|
|
|
//
|
|
// CentralEffectSimulationHit
|
|
//
|
|
QByteArray CentralEffectSimulationHit::toJson() const
|
|
{
|
|
QJsonObject objPos({{s_x(), relPosition.x},
|
|
{s_y(), relPosition.y},
|
|
{s_z(), relPosition.z}
|
|
});
|
|
return toJsonInternal(
|
|
QJsonObject
|
|
{
|
|
{s_effectTime(), effectTimeMSec},
|
|
{s_chargeTypeId(), chargeTypeId},
|
|
{s_destructiveFactor(), destructiveFactor},
|
|
{s_penetrationFactor(), penetrationFactor},
|
|
{s_aesId(), aesId},
|
|
{s_relativePosition(), objPos},
|
|
{s_properties(), properties}
|
|
});
|
|
}
|
|
|
|
CentralEffectSimulationHit *CentralEffectSimulationHit::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
CentralEffectSimulationHit ret;
|
|
ret.effectTimeMSec = toInt64(data[s_effectTime()], bOk);
|
|
ret.chargeTypeId = toInteger(data[s_chargeTypeId()], bOk);
|
|
ret.destructiveFactor = toInteger(data[s_destructiveFactor()], bOk);
|
|
ret.penetrationFactor = toInteger(data[s_penetrationFactor()], bOk);
|
|
ret.aesId = toInteger(data[s_aesId()], bOk);
|
|
const QJsonObject objPos = data[s_relativePosition()].toObject();
|
|
ret.relPosition.x = toDouble(objPos[s_x()], bOk);
|
|
ret.relPosition.y = toDouble(objPos[s_y()], bOk);
|
|
ret.relPosition.z = toDouble(objPos[s_z()], bOk);
|
|
ret.properties = data[s_properties()].toString();
|
|
|
|
return bOk ? new CentralEffectSimulationHit(ret) : nullptr;
|
|
}
|
|
|
|
//
|
|
// CentralEffectSimulationHit3D
|
|
//
|
|
QByteArray CentralEffectSimulationHit3D::toJson() const
|
|
{
|
|
QJsonObject objImpactPos(
|
|
{{s_x(), impactPosition.x},
|
|
{s_y(), impactPosition.y},
|
|
{s_z(), impactPosition.z}
|
|
});
|
|
QJsonObject objDetonationLocation(
|
|
{{s_x(), detonationLocation.x},
|
|
{s_y(), detonationLocation.y},
|
|
{s_z(), detonationLocation.z}
|
|
});
|
|
return toJsonInternal(
|
|
QJsonObject
|
|
{
|
|
{s_effectTime(), effectTimeMSec},
|
|
{s_chargeTypeId(), chargeTypeId},
|
|
{s_destructiveFactor(), destructiveFactor},
|
|
{s_penetrationFactor(), penetrationFactor},
|
|
{s_aesId(), aesId},
|
|
{s_impactPosition(), objImpactPos},
|
|
{s_detonationLocation(), objDetonationLocation},
|
|
{s_detonationDistance(), detonationDistance},
|
|
{s_properties(), properties}
|
|
});
|
|
}
|
|
|
|
CentralEffectSimulationHit3D *CentralEffectSimulationHit3D::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
CentralEffectSimulationHit3D ret;
|
|
ret.effectTimeMSec = toInt64(data[s_effectTime()], bOk);
|
|
ret.chargeTypeId = toInteger(data[s_chargeTypeId()], bOk);
|
|
ret.destructiveFactor = toInteger(data[s_destructiveFactor()], bOk);
|
|
ret.penetrationFactor = toInteger(data[s_penetrationFactor()], bOk);
|
|
ret.aesId = toInteger(data[s_aesId()], bOk);
|
|
|
|
{
|
|
const QJsonObject objImpactPos = data[s_impactPosition()].toObject();
|
|
ret.impactPosition.x = toDouble(objImpactPos[s_x()], bOk);
|
|
ret.impactPosition.y = toDouble(objImpactPos[s_y()], bOk);
|
|
ret.impactPosition.z = toDouble(objImpactPos[s_z()], bOk);
|
|
}
|
|
{
|
|
const QJsonObject objDetonationLocation = data[s_detonationLocation()].toObject();
|
|
ret.detonationLocation.x = toDouble(objDetonationLocation[s_x()], bOk);
|
|
ret.detonationLocation.y = toDouble(objDetonationLocation[s_y()], bOk);
|
|
ret.detonationLocation.z = toDouble(objDetonationLocation[s_z()], bOk);
|
|
}
|
|
ret.detonationDistance = toDouble(data[s_detonationDistance()], bOk);
|
|
ret.properties = data[s_properties()].toString();
|
|
|
|
return bOk ? new CentralEffectSimulationHit3D(ret) : nullptr;
|
|
}
|
|
|
|
//
|
|
// DebugSimulateBSMHit
|
|
//
|
|
QByteArray DebugSimulateBSMHit::toJson() const
|
|
{
|
|
return toJsonInternal(
|
|
QJsonObject
|
|
{
|
|
{s_effectTime(), effectTimeMSec},
|
|
{s_sensorId(), sensorId},
|
|
{s_originatorId(), originatorId},
|
|
{s_chargeTypeId(), chargeTypeId},
|
|
{s_deposition1(), deposition1},
|
|
{s_deposition2(), deposition2}
|
|
});
|
|
}
|
|
|
|
DebugSimulateBSMHit *DebugSimulateBSMHit::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
DebugSimulateBSMHit ret;
|
|
ret.effectTimeMSec = toInt64(data[s_effectTime()], bOk);
|
|
ret.sensorId = toInteger(data[s_sensorId()], bOk);
|
|
ret.originatorId = toInteger(data[s_originatorId()], bOk);
|
|
ret.chargeTypeId = toInteger(data[s_chargeTypeId()], bOk);
|
|
ret.deposition1 = toInteger(data[s_deposition1()], bOk);
|
|
ret.deposition2 = toInteger(data[s_deposition2()], bOk);
|
|
|
|
return bOk ? new DebugSimulateBSMHit(ret) : nullptr;
|
|
}
|
|
|
|
|
|
//
|
|
// HitResult
|
|
//
|
|
QByteArray HitResult::toJson() const
|
|
{
|
|
QJsonArray arr;
|
|
for (const HitRoomInfo &hri : hitResult.rooms)
|
|
{
|
|
arr += QJsonObject(
|
|
{
|
|
{s_id(), hri.roomId},
|
|
{s_damagePercent(), hri.damagePercent},
|
|
{s_remainingEffectPercent(), hri.remainingEffectPercent},
|
|
{s_fortifyFactor(), hri.fortifyFactor}
|
|
});
|
|
}
|
|
|
|
// Contaminaton states
|
|
QJsonArray csiArr;
|
|
for (const auto &csi : hitResult.contaminations)
|
|
{
|
|
QJsonArray roomIdsArr;
|
|
for (const auto &rId : csi.rooms)
|
|
roomIdsArr.append(QJsonValue(rId));
|
|
|
|
csiArr += QJsonObject({{s_aesId(), csi.aesId},
|
|
{s_rooms(), roomIdsArr}});
|
|
}
|
|
|
|
return toJsonInternal(
|
|
QJsonObject
|
|
{
|
|
{s_sensorId(), hitResult.sensorId},
|
|
{s_originatorId(), hitResult.originatorId},
|
|
{s_originatorType(), static_cast<int>(hitResult.originatorType)},
|
|
{s_chargeTypeId(), hitResult.chargeTypeId},
|
|
{s_damagePercentOld(), hitResult.damagePercentOld},
|
|
{s_damagePercentNew(), hitResult.damagePercentNew},
|
|
{s_effectSoundId(), hitResult.effectSoundId},
|
|
{s_damageState(), static_cast<int>(hitResult.damageState)},
|
|
{s_hitOnRoomId(), hitResult.hitOnRoomId},
|
|
{s_rooms(), arr},
|
|
{s_contaminationStates(), csiArr}
|
|
});
|
|
}
|
|
|
|
HitResult *HitResult::fromJson(const QJsonObject &data)
|
|
{
|
|
HitResult ret;
|
|
|
|
bool bOk = data[s_rooms()].isArray();
|
|
const QJsonArray arr = data[s_rooms()].toArray();
|
|
for (const auto &ele : arr)
|
|
{
|
|
const QJsonObject obj = ele.toObject();
|
|
HitRoomInfo info;
|
|
info.roomId = toInteger(obj[s_id()], bOk);
|
|
info.damagePercent = toInteger(obj[s_damagePercent()], bOk);
|
|
info.remainingEffectPercent = toInteger(obj[s_remainingEffectPercent()], bOk);
|
|
info.fortifyFactor = toDouble(obj[s_fortifyFactor()], bOk);
|
|
|
|
ret.hitResult.rooms += info;
|
|
}
|
|
|
|
ret.hitResult.sensorId = toInteger(data[s_sensorId()], bOk);
|
|
ret.hitResult.originatorId = toInteger(data[s_originatorId()], bOk);
|
|
ret.hitResult.originatorType = static_cast<OriginatorType>(toInteger(data[s_originatorType()], bOk));
|
|
ret.hitResult.chargeTypeId = toInteger(data[s_chargeTypeId()], bOk);
|
|
ret.hitResult.damagePercentOld = toInteger(data[s_damagePercentOld()], bOk);
|
|
ret.hitResult.damagePercentNew = toInteger(data[s_damagePercentNew()], bOk);
|
|
ret.hitResult.effectSoundId = toInteger(data[s_effectSoundId()], bOk);
|
|
ret.hitResult.damageState = static_cast<DamageState>(toInteger(data[s_damageState()], bOk));
|
|
ret.hitResult.hitOnRoomId = toInteger(data[s_hitOnRoomId()], bOk);
|
|
|
|
const QJsonArray contaminationArray = data.value(s_contaminationStates()).toArray();
|
|
for (const auto &index : contaminationArray)
|
|
{
|
|
ContaminationStateInfo csi;
|
|
const QJsonObject &inObj = index.toObject();
|
|
csi.aesId = inObj[s_aesId()].toInt();
|
|
const QJsonArray &idsArr = inObj[s_rooms()].toArray();
|
|
|
|
csi.rooms.reserve(idsArr.count());
|
|
for (const auto &id : idsArr)
|
|
csi.rooms.push_back(id.toInt());
|
|
|
|
ret.hitResult.contaminations += csi;
|
|
}
|
|
|
|
|
|
return bOk ? new HitResult(ret) : nullptr;
|
|
}
|
|
|
|
//
|
|
// BsmState
|
|
//
|
|
QByteArray BsmState::toJson() const
|
|
{
|
|
QJsonArray arr;
|
|
for (const BsmStateInfo &s : bsmStates)
|
|
{
|
|
arr += QJsonObject(
|
|
{
|
|
{s_id(), s.id},
|
|
{s_hostname(), s.hostname},
|
|
{s_port(), s.port},
|
|
{s_connected(), s.connected},
|
|
{s_versionInfo(), s.versionInfo}
|
|
});
|
|
}
|
|
return toJsonInternal(
|
|
QJsonObject
|
|
{
|
|
{s_bsmStateInfo(), arr}
|
|
});
|
|
}
|
|
|
|
BsmState *BsmState::fromJson(const QJsonObject &data)
|
|
{
|
|
BsmState ret;
|
|
|
|
bool bOk = data[s_bsmStateInfo()].isArray();
|
|
const QJsonArray arr = data[s_bsmStateInfo()].toArray();
|
|
BsmStateInfo info;
|
|
for (const auto &ele : arr)
|
|
{
|
|
const QJsonObject obj = ele.toObject();
|
|
info.id = toInt64(obj[s_id()], bOk);
|
|
info.hostname = obj[s_hostname()].toString();
|
|
info.port = toInteger(obj[s_port()], bOk);
|
|
info.connected = toBoolean(obj[s_connected()], bOk);
|
|
info.versionInfo = obj[s_versionInfo()].toString();
|
|
ret.bsmStates += info;
|
|
}
|
|
|
|
fromJsonInternal(data, &ret, bOk);
|
|
return bOk ? new BsmState(ret) : nullptr;
|
|
}
|
|
|
|
//
|
|
// GetBsmConfiguration
|
|
// currently only for request, result can be seen as debug output in the logfile
|
|
//
|
|
QByteArray GetBsmConfiguration::toJson() const
|
|
{
|
|
return toJsonInternal(
|
|
QJsonObject
|
|
{
|
|
{s_sensorId(), sensorId}
|
|
});
|
|
}
|
|
|
|
GetBsmConfiguration *GetBsmConfiguration::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
GetBsmConfiguration ret;
|
|
ret.sensorId = toInteger(data[s_sensorId()], bOk);
|
|
|
|
return bOk ? new GetBsmConfiguration(ret) : nullptr;
|
|
}
|
|
|
|
//
|
|
// GetBsmBitTimeout
|
|
// currently only for request, result can be seen as debug output in the logfile
|
|
//
|
|
QByteArray GetBsmBitTimeout::toJson() const
|
|
{
|
|
return toJsonInternal(
|
|
QJsonObject
|
|
{
|
|
{s_sensorId(), sensorId}
|
|
});
|
|
}
|
|
|
|
GetBsmBitTimeout *GetBsmBitTimeout::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
GetBsmBitTimeout ret;
|
|
ret.sensorId = toInteger(data[s_sensorId()], bOk);
|
|
|
|
return bOk ? new GetBsmBitTimeout(ret) : nullptr;
|
|
}
|
|
|
|
//
|
|
// GetBsmTechnicalStatus
|
|
// currently only for request, result can be seen as debug output in the logfile
|
|
//
|
|
QByteArray GetBsmTechnicalStatus::toJson() const
|
|
{
|
|
return toJsonInternal(
|
|
QJsonObject
|
|
{
|
|
{s_sensorId(), sensorId}
|
|
});
|
|
}
|
|
|
|
GetBsmTechnicalStatus *GetBsmTechnicalStatus::fromJson(const QJsonObject &data)
|
|
{
|
|
bool bOk = true;
|
|
GetBsmTechnicalStatus ret;
|
|
ret.sensorId = toInteger(data[s_sensorId()], bOk);
|
|
|
|
return bOk ? new GetBsmTechnicalStatus(ret) : nullptr;
|
|
}
|
|
|
|
|
|
} // namespace Telegrams
|
|
} // namespace Json
|
|
} // namespace BuildingControlUnit
|