253 lines
9.5 KiB
C++
Executable File
253 lines
9.5 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* Building State Store
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Gerlinde Rudolphus, SLSA, 2017-01-15
|
|
*/
|
|
#include "vwm_state_store.h"
|
|
#include <logger.h>
|
|
#include <QJsonDocument>
|
|
#include <QJsonObject>
|
|
#include <QJsonArray>
|
|
#include <QString>
|
|
#include <QFile>
|
|
#include <QStandardPaths>
|
|
#include <QDir>
|
|
|
|
|
|
namespace BuildingControlUnit
|
|
{
|
|
namespace VWM
|
|
{
|
|
namespace StateStore
|
|
{
|
|
static NGL::INGLLogger &logger()
|
|
{
|
|
return BuildingControlUnit::getLogger("VWM.StateStore");
|
|
}
|
|
|
|
static QJsonObject writeBuilding(const Building &building)
|
|
{
|
|
const QMap<int, Room> &rooms = building.rooms();
|
|
QJsonArray arrRooms;
|
|
for (auto it = rooms.begin(); it != rooms.end(); ++it)
|
|
{
|
|
QJsonArray arrOw;
|
|
const Room &room = it.value();
|
|
for (auto itW = room.outerWalls().begin(); itW != room.outerWalls().end(); ++itW)
|
|
{
|
|
QJsonArray arrEz;
|
|
const OuterWall &ow = (*itW);
|
|
for (auto itE = ow.exclusionZones().begin(); itE != ow.exclusionZones().end(); ++itE)
|
|
{
|
|
const ExclusionZone &ez = (*itE);
|
|
arrEz.append(QJsonObject({{QStringLiteral("ExclusionZoneProtection"), ez.protection()}}));
|
|
}
|
|
arrOw.append(QJsonObject({{QStringLiteral("OuterWallProtection"), ow.protection()},
|
|
{QStringLiteral("Ez"), arrEz}
|
|
}));
|
|
}
|
|
arrRooms.append(QJsonObject({{QStringLiteral("OuterWalls"), arrOw},
|
|
{QStringLiteral("room"), room.id()},
|
|
{QStringLiteral("fortifyFactor"), room.fortifyFactor()},
|
|
{QStringLiteral("remainingEffect"), room.remainingEffect()}}));
|
|
}
|
|
|
|
const QMap<QString, QString> &egcuProperties = building.segmentPropertyMap();
|
|
QJsonArray arrEgcuProperties;
|
|
for (auto it = egcuProperties.begin(); it != egcuProperties.end(); ++it)
|
|
{
|
|
arrEgcuProperties.append(QJsonObject({{QStringLiteral("Hostname"), it.key()},
|
|
{QStringLiteral("Properties"), it.value()}
|
|
}));
|
|
}
|
|
return QJsonObject({{QStringLiteral("BuildingName"), building.name()},
|
|
{QStringLiteral("Rooms"), arrRooms},
|
|
{QStringLiteral("SegmentProperties"), arrEgcuProperties},
|
|
{QStringLiteral("BuildingProperties"), building.buildingProperties()}});
|
|
}
|
|
|
|
static inline QJsonObject writeHitResult(const HitResult &hitResult)
|
|
{
|
|
return QJsonObject({{QStringLiteral("sensorId"), hitResult.sensorId},
|
|
{QStringLiteral("originatorId"), hitResult.originatorId},
|
|
{QStringLiteral("originatorType"),static_cast<int>(hitResult.originatorType)},
|
|
{QStringLiteral("chargeTypeId"), hitResult.chargeTypeId},
|
|
{QStringLiteral("damagePercentOld"), hitResult.damagePercentOld},
|
|
{QStringLiteral("damagePercentNew"), hitResult.damagePercentNew},
|
|
{QStringLiteral("effectSoundId"), hitResult.effectSoundId},
|
|
{QStringLiteral("effectTimeMSec"), hitResult.effectTimeMSec}});
|
|
}
|
|
|
|
static inline QJsonArray writeContaminationStates(const QMap<int, ContaminationState> & contaminationStates )
|
|
{
|
|
QJsonArray contaminationArr;
|
|
for (const auto &value : contaminationStates.values() )
|
|
{
|
|
QJsonArray roomArr;
|
|
for (const auto & roomId : qAsConst(value.rooms))
|
|
roomArr.append(QJsonValue(roomId));
|
|
|
|
contaminationArr.append(QJsonObject({ {QStringLiteral("aesId") , value.aesId},
|
|
{QStringLiteral("rooms"), roomArr}}));
|
|
}
|
|
|
|
return contaminationArr;
|
|
}
|
|
|
|
static void readEz(const QJsonObject &json, int ezIndex, OuterWall &outerWall)
|
|
{
|
|
if (ezIndex >= outerWall.exclusionZones().size())
|
|
return;
|
|
|
|
double protection = json[QStringLiteral("ExclusionZoneProtection")].toDouble();
|
|
outerWall.exclusionZones()[ezIndex].setProtection(protection);
|
|
}
|
|
|
|
static void readOw(const QJsonObject &json, OuterWall &outerWall)
|
|
{
|
|
int outerWallProtection = static_cast<int>( json[QStringLiteral("OuterWallProtection")].toDouble());
|
|
outerWall.setProtection(outerWallProtection);
|
|
QJsonArray ezArray = json[QStringLiteral("Ez")].toArray();
|
|
for (int ezIndex = 0; ezIndex < ezArray.size(); ++ezIndex)
|
|
{
|
|
QJsonObject ezObject = ezArray[ezIndex].toObject();
|
|
readEz(ezObject, ezIndex, outerWall);
|
|
}
|
|
}
|
|
|
|
static void readRoom(const QJsonObject &json, Building &building)
|
|
{
|
|
//QMap<int, Room> rooms = building.rooms();
|
|
int id = json[QStringLiteral("room")].toInt();
|
|
auto room = building.rooms().find(id);
|
|
if (room == building.rooms().end())
|
|
return;
|
|
|
|
room.value().setRemainingEffect(json[QStringLiteral("remainingEffect")].toDouble());
|
|
room.value().setFortifyFactor(json[QStringLiteral("fortifyFactor")].toDouble());
|
|
QJsonArray owArray = json[QStringLiteral("OuterWalls")].toArray();
|
|
for (int owIndex = 0; owIndex < owArray.size(); ++owIndex)
|
|
{
|
|
if (owIndex >= room.value().outerWalls().size())
|
|
break;
|
|
QJsonObject owObject = owArray[owIndex].toObject();
|
|
if (room.value().outerWalls().size() > owIndex)
|
|
readOw(owObject, room.value().outerWalls()[owIndex]);
|
|
|
|
}
|
|
}
|
|
|
|
static void readBuilding(const QJsonObject &json, Building &building)
|
|
{
|
|
//QString name = json[QStringLiteral("BuildingName")].toString();
|
|
QJsonArray roomArray = json[QStringLiteral("Rooms")].toArray();
|
|
for (int roomIndex = 0; roomIndex < roomArray.size(); ++roomIndex)
|
|
{
|
|
QJsonObject roomObject = roomArray[roomIndex].toObject();
|
|
readRoom(roomObject, building);
|
|
}
|
|
building.clearSegmentProperties();
|
|
QJsonArray segmentArray = json[QStringLiteral("SegmentProperties")].toArray();
|
|
for (int segmentIndex = 0; segmentIndex < segmentArray.size(); ++segmentIndex)
|
|
{
|
|
QJsonObject segmentObject = segmentArray[segmentIndex].toObject();
|
|
QString hostname = segmentObject[QStringLiteral("Hostname")].toString();
|
|
QString properties = segmentObject[QStringLiteral("Properties")].toString();
|
|
building.setSegmentProperties(hostname,properties);
|
|
}
|
|
building.setBuildingProperties(json[QStringLiteral("BuildingProperties")].toString());
|
|
}
|
|
|
|
static void readHitResult(const QJsonObject &json, HitResult &hitResult)
|
|
{
|
|
hitResult.sensorId = json.value(QStringLiteral("sensorId")).toInt();
|
|
hitResult.originatorId = json.value(QStringLiteral("originatorId")).toInt();
|
|
hitResult.originatorType = static_cast<OriginatorType>(json.value(QStringLiteral("originatorType")).toInt());
|
|
hitResult.chargeTypeId = json.value(QStringLiteral("chargeTypeId")).toInt();
|
|
hitResult.damagePercentOld = json.value(QStringLiteral("damagePercentOld")).toInt();
|
|
hitResult.damagePercentNew = json.value(QStringLiteral("damagePercentNew")).toInt();
|
|
hitResult.effectSoundId = json.value(QStringLiteral("effectSoundId")).toInt();
|
|
hitResult.effectTimeMSec = json.value(QStringLiteral("effectTimeMSec")).toDouble();
|
|
}
|
|
|
|
static void readContaminationStates(const QJsonArray &jsArr, QMap<int, ContaminationState> &contaminationStates)
|
|
{
|
|
for (auto index : jsArr)
|
|
{
|
|
const QJsonObject &inObj = index.toObject();
|
|
ContaminationState contStates;
|
|
contStates.aesId = inObj[QStringLiteral("aesId")].toInt();
|
|
const QJsonArray &idsArr = inObj[QStringLiteral("rooms")].toArray();
|
|
|
|
contStates.rooms.reserve(idsArr.count());
|
|
for (const auto & id : idsArr)
|
|
contStates.rooms.push_back(id.toInt());
|
|
|
|
contaminationStates.insert(contStates.aesId, contStates);
|
|
}
|
|
}
|
|
|
|
static QString getStateFilename(const QString &name)
|
|
{
|
|
// Linux: QStandardPaths::CacheLocation -> ~/.cache/BuildingControlUnit
|
|
const QString folder = QStandardPaths::writableLocation(QStandardPaths::CacheLocation) + QLatin1Char('/');
|
|
if (!QDir(folder).exists())
|
|
QDir().mkpath(folder);
|
|
return folder + name;
|
|
}
|
|
|
|
bool saveState(const Building &building, const HitResult &hitResult,const QMap <int, ContaminationState> &contaminationStates)
|
|
{
|
|
DEBUG_LOG(logger()) << "**********************";
|
|
DEBUG_LOG(logger()) << "*** SAVE STATE *** "<< getStateFilename(building.name());
|
|
DEBUG_LOG(logger()) << "**********************";
|
|
QFile saveFile(getStateFilename(building.name()));
|
|
|
|
|
|
if (!saveFile.open(QIODevice::WriteOnly))
|
|
{
|
|
WARNING_LOG(logger()) << "Couldn't open State file. " << getStateFilename(building.name());
|
|
return false;
|
|
}
|
|
|
|
QJsonObject saveObject;
|
|
saveObject[QStringLiteral("Building")] = writeBuilding(building);
|
|
saveObject[QStringLiteral("HitResult")] = writeHitResult(hitResult);
|
|
saveObject[QStringLiteral("contaminationStates")] = writeContaminationStates(contaminationStates);
|
|
|
|
const QJsonDocument saveDoc(saveObject);
|
|
saveFile.write(saveDoc.toJson());
|
|
|
|
return true;
|
|
|
|
}
|
|
bool loadState(Building &building, HitResult &hitResult, QMap <int, ContaminationState> &contaminationStates)
|
|
{
|
|
DEBUG_LOG(logger()) << "**********************";
|
|
DEBUG_LOG(logger()) << "*** LOAD STATE *** "<< getStateFilename(building.name());
|
|
DEBUG_LOG(logger()) << "**********************";
|
|
QFile loadFile(getStateFilename(building.name()));
|
|
|
|
if (!loadFile.open(QIODevice::ReadOnly))
|
|
{
|
|
WARNING_LOG(logger()) << "Couldn't open State file. " << getStateFilename(building.name());
|
|
return false;
|
|
}
|
|
|
|
QByteArray saveData = loadFile.readAll();
|
|
|
|
QJsonDocument loadDoc(QJsonDocument::fromJson(saveData));
|
|
|
|
readBuilding(loadDoc.object().value(QStringLiteral("Building")).toObject(), building);
|
|
readHitResult(loadDoc.object().value(QStringLiteral("HitResult")).toObject(), hitResult);
|
|
readContaminationStates(loadDoc.object().value(QStringLiteral("contaminationStates")).toArray(), contaminationStates);
|
|
|
|
return true;
|
|
}
|
|
} // namespace StateStore
|
|
} // namespace VWM
|
|
} // namespace BuildingControlUnit
|