245 lines
11 KiB
C++
Executable File
245 lines
11 KiB
C++
Executable File
/**
|
|
* Publish static data (pdm, asm, ism) for THP
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Hanna E. Rathje, SLSE, 2016-01-13
|
|
*/
|
|
|
|
#include "static_publisher.h"
|
|
#include <QCryptographicHash>
|
|
#include <QJsonDocument>
|
|
#include <QTimer>
|
|
|
|
#include <DDS/DTS/generic_dts_impl.h>
|
|
|
|
#include <AssetManagement/asm_db.h>
|
|
#include <AssetManagement/convert_db_to_dds.h>
|
|
#include <ExerciseManagement/exm_db.h>
|
|
#include <ExerciseManagement/convert_db_to_dds.h>
|
|
#include <FileManagement/flm_db.h>
|
|
#include <FileManagement/convert_db_to_dds.h>
|
|
#include <InfrastructureManagement/ism_db.h>
|
|
#include <InfrastructureManagement/convert_db_to_dds.h>
|
|
#include <ParticipantManagement/ppm_db.h>
|
|
#include <ParticipantManagement/convert_db_to_dds.h>
|
|
#include <ProjectDataManagement/pdm_db.h>
|
|
#include <ProjectDataManagement/convert_db_to_dds.h>
|
|
|
|
|
|
namespace SituationReplay
|
|
{
|
|
StaticPublisher::StaticPublisher(const std::shared_ptr<DdsHandler> &ddsInterface,
|
|
const QSqlDatabase &db)
|
|
: m_ddsInterface(ddsInterface)
|
|
, m_db(db)
|
|
{
|
|
auto ddsConnector = ddsInterface->ddsReplay();
|
|
m_asmTrainingArea.reset(ddsConnector->createDTS<DTS::TrainingAreaImpl>());
|
|
m_exmExercise.reset(ddsConnector->createDTS<DTS::ExerciseImpl>());
|
|
m_exmExercisePhase.reset(ddsConnector->createDTS<DTS::ExercisePhaseImpl>());
|
|
m_flmFileContent.reset(ddsConnector->createDTS<DTS::FileContentImpl>());
|
|
m_flmFileTypeInfo.reset(ddsConnector->createDTS<DTS::FileTypeInfoImpl>());
|
|
m_flmFolder.reset(ddsConnector->createDTS<DTS::FolderImpl>());
|
|
|
|
m_ismMainFootprint.reset(ddsConnector->createDTS<DTS::MainFootprintImpl>());
|
|
m_ismMainStructureElement.reset(ddsConnector->createDTS<DTS::MainStructureElementImpl>());
|
|
|
|
m_ppmType.reset(ddsConnector->createDTS<DTS::TypeImpl>());
|
|
|
|
m_pdmCanComponentString.reset(ddsConnector->createDTS<DTS::CanComponentStringImpl>());
|
|
m_pdmChargeType.reset(ddsConnector->createDTS<DTS::ChargeTypeImpl>());
|
|
m_pdmFirePurpose.reset(ddsConnector->createDTS<DTS::FirePurposeImpl>());
|
|
m_pdmGearType.reset(ddsConnector->createDTS<DTS::GearTypeImpl>());
|
|
m_ppmGearTypeChargeType.reset(ddsConnector->createDTS<DTS::GearTypeChargeTypeImpl>());
|
|
m_pdmIgniterType.reset(ddsConnector->createDTS<DTS::IgniterTypeImpl>());
|
|
m_pdmIgniterFunction.reset(ddsConnector->createDTS<DTS::IgniterFunctionImpl>());
|
|
m_pdmChargeTypeIgniterTypeIgniterFunction.reset(ddsConnector->createDTS<DTS::ChargeTypeIgniterTypeIgniterFunctionImpl>());
|
|
m_pdmLoadType.reset(ddsConnector->createDTS<DTS::LoadTypeImpl>());
|
|
m_pdmChargeTypeLoadType.reset(ddsConnector->createDTS<DTS::ChargeTypeLoadTypeImpl>());
|
|
|
|
m_pdmLanguageHmi.reset(ddsConnector->createDTS<DTS::LanguageHmiImpl>());
|
|
m_pdmTranslationBlob.reset(ddsConnector->createDTS<DTS::TranslationBlobImpl>());
|
|
m_pdmVulnerabilityKind.reset(ddsConnector->createDTS<DTS::VulnerabilityKindImpl>());
|
|
|
|
QTimer::singleShot(0, this, &StaticPublisher::publishData);
|
|
}
|
|
|
|
StaticPublisher::~StaticPublisher()
|
|
{
|
|
m_asmTrainingArea = nullptr;
|
|
m_exmExercise = nullptr;
|
|
m_exmExercisePhase = nullptr;
|
|
m_flmFileContent = nullptr;
|
|
m_flmFileTypeInfo = nullptr;
|
|
m_flmFolder = nullptr;
|
|
|
|
m_ismMainFootprint = nullptr;
|
|
m_ismMainStructureElement = nullptr;
|
|
|
|
m_ppmType = nullptr;
|
|
|
|
m_pdmCanComponentString = nullptr;
|
|
m_pdmChargeType = nullptr;
|
|
m_pdmFirePurpose = nullptr;
|
|
m_pdmGearType = nullptr;
|
|
m_ppmGearTypeChargeType = nullptr;
|
|
m_pdmIgniterType = nullptr;
|
|
m_pdmIgniterFunction = nullptr;
|
|
m_pdmLoadType = nullptr;
|
|
m_pdmChargeTypeIgniterTypeIgniterFunction = nullptr;
|
|
m_pdmChargeTypeLoadType = nullptr;
|
|
m_pdmLanguageHmi = nullptr;
|
|
m_pdmTranslationBlob = nullptr;
|
|
m_pdmVulnerabilityKind = nullptr;
|
|
|
|
m_ddsInterface = nullptr;
|
|
}
|
|
|
|
void StaticPublisher::publishData()
|
|
{
|
|
{
|
|
auto db = AssetManagement::DatabaseInterface::create(0);
|
|
db->init(m_db);
|
|
db->select([this](const AssetManagement::Database::AsmTrainingArea &data) { m_asmTrainingArea->write(AssetManagement::Database::convert(data)); });
|
|
}
|
|
{
|
|
auto db = ExerciseManagement::DatabaseInterface::create(0);
|
|
db->init(m_db);
|
|
db->select([this](const ExerciseManagement::Database::ExmExercise &data) { m_exmExercise->write(ExerciseManagement::Database::convert(data)); });
|
|
db->select([this](const ExerciseManagement::Database::ExmExercisePhase &data) { m_exmExercisePhase->write(ExerciseManagement::Database::convert(data)); });
|
|
}
|
|
{
|
|
auto db = FileManagement::DatabaseInterface::create(0);
|
|
db->init(m_db);
|
|
db->select([this](const FileManagement::Database::FlmFileContent &data) { m_flmFileContent->write(FileManagement::Database::convert(data)); emit fileContentAvailable(data); });
|
|
db->select([this](const FileManagement::Database::FlmFileTypeInfo &data) { m_flmFileTypeInfo->write(FileManagement::Database::convert(data)); });
|
|
db->select([this](const FileManagement::Database::FlmFolder &data) { m_flmFolder->write(FileManagement::Database::convert(data)); });
|
|
}
|
|
{
|
|
auto db = InfrastructureManagement::DatabaseInterface::create(0);
|
|
db->init(m_db);
|
|
publishMainStructureElement(db);
|
|
}
|
|
{
|
|
auto db = ParticipantManagement::DatabaseInterface::create(0);
|
|
db->init(m_db);
|
|
db->select([this](const ParticipantManagement::Database::PpmType &data) { m_ppmType->write(ParticipantManagement::Database::convert(data)); });
|
|
}
|
|
{
|
|
auto db = ProjectDataManagement::DatabaseInterface::create(0);
|
|
db->init(m_db);
|
|
db->select([this](const ProjectDataManagement::Database::PdmCanComponentString &data) { m_pdmCanComponentString->write(ProjectDataManagement::Database::convert(data)); });
|
|
db->select([this](const ProjectDataManagement::Database::PdmChargeType &data) { m_pdmChargeType->write(ProjectDataManagement::Database::convert(data)); });
|
|
db->select([this](const ProjectDataManagement::Database::PdmFirePurpose &data) { m_pdmFirePurpose->write(ProjectDataManagement::Database::convert(data)); });
|
|
db->select([this](const ProjectDataManagement::Database::PdmGearType &data) { m_pdmGearType->write(ProjectDataManagement::Database::convert(data)); });
|
|
db->select([this](const ProjectDataManagement::Database::PdmGearTypeChargeType &data) { m_ppmGearTypeChargeType->write(ProjectDataManagement::Database::convert(data)); });
|
|
db->select([this](const ProjectDataManagement::Database::PdmIgniterType &data) { m_pdmIgniterType->write(ProjectDataManagement::Database::convert(data)); });
|
|
db->select([this](const ProjectDataManagement::Database::PdmIgniterFunction &data) { m_pdmIgniterFunction->write(ProjectDataManagement::Database::convert(data)); });
|
|
db->select([this](const ProjectDataManagement::Database::PdmChargeTypeIgniterTypeIgniterFunction &data) { m_pdmChargeTypeIgniterTypeIgniterFunction->write(ProjectDataManagement::Database::convert(data)); });
|
|
db->select([this](const ProjectDataManagement::Database::PdmLanguage &data) { m_pdmLanguageHmi->write(ProjectDataManagement::Database::convert(data)); });
|
|
publishTranslationBlob(db);
|
|
db->select([this](const ProjectDataManagement::Database::PdmVulnerabilityKind &data) { m_pdmVulnerabilityKind->write(ProjectDataManagement::Database::convert(data)); });
|
|
}
|
|
m_db = QSqlDatabase();
|
|
}
|
|
|
|
void StaticPublisher::publishMainStructureElement(const std::shared_ptr<InfrastructureManagement::DatabaseInterface> &db)
|
|
{
|
|
// read all MSE from database
|
|
QHash<qint64, InfrastructureManagement::Database::IsmMainStructureElement> mainStructureElements;
|
|
if (!db->select([&mainStructureElements] (const InfrastructureManagement::Database::IsmMainStructureElement &data) { mainStructureElements[data.id] = data;}))
|
|
return;
|
|
|
|
// read all SE from database
|
|
QHash<qint64, QVector<InfrastructureManagement::Database::IsmStructureElement>> structureElements;
|
|
if (!db->select([&structureElements](const InfrastructureManagement::Database::IsmStructureElement &data) { structureElements[data.mainStructureElementId].push_back(data);}))
|
|
return;
|
|
|
|
QHash<qint64, qint64> seId2mseId;
|
|
for (const auto &mse : qAsConst(mainStructureElements))
|
|
{
|
|
auto mseDds = InfrastructureManagement::Database::convert(mse);
|
|
auto itContSe = structureElements.constFind(mse.id);
|
|
if (itContSe == structureElements.constEnd())
|
|
continue;
|
|
for (const auto &se : itContSe.value())
|
|
{
|
|
// currently only the building, not floors, rooms or mounting points needed
|
|
// DEDÖÖM we need rooms and floors and every thing else!
|
|
//if (se.structureElementTypeId != InfrastructureManagement::StructureElementType_def::Building)
|
|
// continue;
|
|
mseDds.elements().push_back(InfrastructureManagement::Database::convert(se));
|
|
seId2mseId[se.id] = mseDds.id();
|
|
// break;
|
|
}
|
|
if (mseDds.elements().size() > 0)
|
|
m_ismMainStructureElement->write(mseDds);
|
|
}
|
|
|
|
QHash<int, QMap<int, InfrastructureManagement::Database::IsmStructureElementFootprint>> footprintSorted;
|
|
auto cb = [&footprintSorted](const InfrastructureManagement::Database::IsmStructureElementFootprint &fp)
|
|
{
|
|
footprintSorted[fp.structureElementId][fp.indexNo] = fp;
|
|
};
|
|
|
|
if (!db->select(cb))
|
|
return;
|
|
|
|
InfrastructureManagement::MainFootprint mf;
|
|
InfrastructureManagement::FootprintElement elem;
|
|
for (const QMap<int, InfrastructureManagement::Database::IsmStructureElementFootprint> &cont : qAsConst(footprintSorted))
|
|
{
|
|
if (cont.empty())
|
|
continue;
|
|
const int structureElementId = cont.first().structureElementId;
|
|
const int mainStructureElementId = seId2mseId.value(structureElementId);
|
|
if (!mainStructureElementId)
|
|
continue;
|
|
|
|
mf.id(mainStructureElementId);
|
|
mf.structureElementId(structureElementId);
|
|
mf.name(mainStructureElements.value(mainStructureElementId).name.toStdString());
|
|
mf.elements().clear();
|
|
mf.elements().reserve(cont.size());
|
|
for (const auto &pos : cont)
|
|
{
|
|
elem.id(pos.id);
|
|
elem.relPosition(Core::RelativePosition(pos.relPosition.x(),
|
|
pos.relPosition.y(),
|
|
pos.relPosition.z()));
|
|
mf.elements().push_back(elem);
|
|
}
|
|
m_ismMainFootprint->write(mf);
|
|
}
|
|
}
|
|
|
|
void StaticPublisher::publishTranslationBlob(const std::shared_ptr<ProjectDataManagement::DatabaseInterface> &db)
|
|
{
|
|
QJsonArray arr;
|
|
const auto cb = [&arr](const ProjectDataManagement::Database::PdmTranslation &data)
|
|
{
|
|
arr += QJsonObject({{QStringLiteral("isoCode"), data.isoCode},
|
|
{QStringLiteral("context"), data.context},
|
|
{QStringLiteral("key"), data.key},
|
|
{QStringLiteral("disambiguation"), data.disambiguation},
|
|
{QStringLiteral("translation"), data.translation}
|
|
});
|
|
};
|
|
|
|
if (!db->select(cb))
|
|
return;
|
|
|
|
const QJsonObject jObj{ {QStringLiteral("translations"), arr} };
|
|
const QByteArray data = QJsonDocument(jObj).toBinaryData();
|
|
const QByteArray compressed = qCompress(data, 9);
|
|
const QByteArray md5Sum = QCryptographicHash::hash(compressed, QCryptographicHash::Md5).toHex();
|
|
|
|
m_pdmTranslationBlob->write(ProjectDataManagement::TranslationBlob(
|
|
1,
|
|
LtsUtils::convert<std::vector<uint8_t>>(compressed),
|
|
md5Sum.data()));
|
|
}
|
|
|
|
}
|