Initial commit

Lts/Services/ProjectDataManagement/CMakeLists.txt

@@ -0,0 +1,166 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+#
+
+INCLUDE(MacroRTIDDSGen)
+INCLUDE(MacroCodeGenIdl)
+
+SET(xml_FILE pdm_service.xml)
+
+#
+# --- Library svcPdmCommon --------------------------------------------------------------------------------
+#
+SET(SRCS_common
+  pdm_export.h
+  pdm_to_string.cpp
+  pdm_to_string.h
+  logger.cpp
+  logger.h
+)
+
+# Generate pdm_enums.idl / pdm.idl
+CODEGEN_IDL_SVC(SRCS_common ${xml_FILE})
+
+# Generate pdm_db.h
+CODEGEN_DATABASE_STRUCTS(SRCS_common ${xml_FILE})
+# Generate pdm_db_impl.cpp/.h,
+CODEGEN_DATABASE_SQL(SRCS_common ${xml_FILE})
+
+# Generate *.cpp/*.hpp from idl
+RTIDDSGEN(SRCS_common pdm_enums.idl)
+RTIDDSGEN(SRCS_common pdm.idl)
+
+# Generate pdm_dt[s,c]_types.h, pdm_ft[s,c]_types.h
+CODEGEN_TOPIC_TYPEDEFS(SRCS_common ${xml_FILE})
+# generate pdm_[d|f]tc.h
+CODEGEN_CLIENT_TOPICS_IFC(SRCS_common ${xml_FILE})
+
+NGL_ADD_LIBRARY(AAR SV WS HLA svcPdmCommon SHARED  ${SRCS_common})
+NGL_TARGET_INCLUDE_DIRECTORIES(svcPdmCommon
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../
+    ${CMAKE_CURRENT_BINARY_DIR}/../
+)
+NGL_TARGET_LINK_LIBRARIES(svcPdmCommon
+  PRIVATE
+    RTI::nddscpp2
+  PUBLIC
+    Qt5::Core
+    ddscore
+    NGLLogger
+    LtsUtilsCore
+    ngldb
+)
+NGL_INSTALL_TARGET(svcPdmCommon)
+
+#
+# --- Library svcPdmClient --------------------------------------------------------------------------------
+#
+SET(SRCS_client
+  pdm_export.h
+  pdm_dtc_impl_custom.cpp
+  pdm_dtc_impl_custom.h
+)
+# generate pdm_ftc_impl.[cpp|h]
+CODEGEN_CLIENT_TOPICS_IMPL(SRCS_client ${xml_FILE})
+
+NGL_ADD_LIBRARY(WS AAR SV HLA svcPdmClient SHARED ${SRCS_client})
+NGL_TARGET_INCLUDE_DIRECTORIES(svcPdmClient
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../
+    ${CMAKE_CURRENT_BINARY_DIR}/../
+)
+
+NGL_TARGET_LINK_LIBRARIES(svcPdmClient
+  PRIVATE
+    RTI::nddscpp2
+    ddsconnector
+  PUBLIC
+    svcPdmCommon
+    ddsftc
+)
+NGL_INSTALL_TARGET(svcPdmClient)
+
+#
+# --- Library svcPdmServer --------------------------------------------------------------------------------
+#
+SET(SRCS_server
+  pdm_export.h
+)
+# generate pdm_[d|f]ts.h, pdm_[d|f]ts_impl.[cpp|h]
+CODEGEN_SERVER_TOPICS(SRCS_server ${xml_FILE})
+
+NGL_ADD_LIBRARY(WS AAR SV svcPdmServer SHARED ${SRCS_server})
+NGL_TARGET_INCLUDE_DIRECTORIES(svcPdmServer
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/../
+    ${CMAKE_CURRENT_BINARY_DIR}/../
+)
+
+NGL_TARGET_LINK_LIBRARIES(svcPdmServer
+  PRIVATE
+    RTI::nddscpp2
+    ddsconnector
+    ddsfts
+  PUBLIC
+    svcPdmCommon
+    ngldb
+)
+NGL_INSTALL_TARGET(svcPdmServer)
+
+#
+# --- Topic Type Plugin --------------------------------------------------------------
+#
+CREATE_TOPIC_TYPE_PLUGIN(${xml_FILE})
+
+#
+# --- Executable svcProjectDataManagement (sPDM) -------------------------------------------------
+#
+LIST(APPEND SRCS_exe
+  convert_db_to_dds.h
+  dds_handler.cpp
+  dds_handler.h
+  main.cpp
+  main_handler.cpp
+  main_handler.h
+  settings.cpp
+  settings.h
+  static_data_publisher.h
+  translation.cpp
+  translation.h
+  chargetype_rename.cpp
+  chargetype_rename.h
+  static_pvsan_import.cpp
+  static_pvsan_import.h
+
+  ${xml_FILE}
+)
+
+# Generate pdm.sql, pdm.xml
+CODEGEN_SQL(SRCS_exe ${xml_FILE})
+
+NGL_ADD_SVC_ICON(SRCS_exe)
+NGL_ADD_EXECUTABLE(AAR SV svcProjectDataManagement ${SRCS_exe})
+NGL_TARGET_LINK_LIBRARIES(svcProjectDataManagement
+  Qt5::Core
+  svcCoreClient
+  svcPdmCommon
+  svcPdmServer
+  ddsconnector
+  nglsettings
+  ProjectConfig
+  LtsCommandLineParser
+  LtsWebSocketServer
+  NGLLogger
+  nglcoreapplication
+  ngltools
+)
+NGL_INSTALL_TARGET(svcProjectDataManagement)
+NGL_INSTALL(AAR SV FILES log4cxx_pdm.props DESTINATION bin)
+NGL_ADD_TARGET_LINK(svcProjectDataManagement sPDM)
+
+# Uncomment if necessary
+#ADD_SUBDIRECTORY(UnitTests)
+ADD_SUBDIRECTORY(ModuleTests)

Lts/Services/ProjectDataManagement/ModuleTests/CMakeLists.txt

@@ -0,0 +1,35 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+#
+
+SET(SRCS_DT_TEST
+  pdm_tests.cpp
+)
+SET(HDRS_DT_TEST
+  pdm_tests.h
+)
+
+IF(BUILD_TESTING)
+ IF(TARGET svcPdmClient)
+
+   # Testing DataTopic Functionality (DTC)
+   ADD_EXECUTABLE(pdmTests ${SRCS_DT_TEST} ${HDRS_DT_TEST})
+   TARGET_LINK_LIBRARIES(pdmTests
+     Qt5::Core
+     Qt5::Test
+     RTI::nddscpp2
+     svcPdmClient
+     LtsCommandLineParser
+     ddsconnector
+     nglcoreapplication
+   )
+
+   IF(NOT BUILD_RPM)
+     NGL_INSTALL(AAR SV TARGETS pdmTests DESTINATION bin/test)
+     NGL_INSTALL(AAR SV FILES ../log4cxx_pdm.props DESTINATION bin/test)
+   ENDIF()
+ ENDIF()
+ENDIF()
+

Lts/Services/ProjectDataManagement/ModuleTests/pdm_tests.cpp

@@ -0,0 +1,205 @@
+/**
+  * @RDE_HEADER@
+  * SRP Data Topic test executable
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "pdm_tests.h"
+
+#include <nglapplication/nglcoreapplication.h>
+#include <LtsCommandLineParser/LtsCommandLineParser.h>
+#include <QTimer>
+
+#include <ProjectDataManagement/pdm_dtc.h>
+
+//---------------------------------------------------------------------------------
+namespace ProjectDataManagement
+{
+PdmTests::PdmTests(QObject *parent)
+  : QObject(parent)
+  , m_id(0)
+  , m_testId(0)
+  , m_bTestsSuccessful(true)
+  , m_logger(getLogger("Test"))
+{
+ qRegisterMetaType<Core::FunctionReply>("Core::FunctionReply");
+}
+
+//---------------------------------------------------------------------------------
+PdmTests::~PdmTests()
+{}
+
+//---------------------------------------------------------------------------------
+bool PdmTests::init(int domainId, int testId)
+{
+  DEBUG_LOG(m_logger) << "init begin";
+  m_testId = testId;
+
+  // initialize DDS
+  m_ddsConnector.reset(new DDSConnector::DdsConnector(domainId, IDL::PartitionType::Global, 0));
+  if (!m_ddsConnector->init())
+    return false;
+  DEBUG_LOG(m_logger) << "DdsHandler(" << domainId << ") for partition: " << m_ddsConnector->getDefaultPartition();
+  m_ddsConnector->initPublisherSubscriber();
+
+  DEBUG_LOG(m_logger) << "create dtc";
+  m_dtc = ProjectDataManagement::Interface::Dtc::create(m_ddsConnector);
+  DEBUG_LOG(m_logger) << "create ftc";
+  m_ftc = ProjectDataManagement::Interface::Ftc::create(m_ddsConnector);
+  bool bRet = m_dtc->enableAll() && m_ftc->enableAll();
+  DEBUG_LOG(m_logger) << "init end - bRet = " << bRet;
+
+  return bRet;
+}
+
+//---------------------------------------------------------------------------------
+void PdmTests::startTest()
+{
+  INFO_LOG(m_logger) << "startTest";
+  if (m_testId == 0)
+  {
+    QTimer::singleShot(1000, this, &PdmTests::tryGetAllVulnerabilityKinds);
+    QTimer::singleShot(2000, this, &PdmTests::tryGetAllBiteComponentTexts);
+  }
+  else if (m_testId == 1)
+  {
+    QTimer::singleShot(1000, this, &PdmTests::tryGetAllVulnerabilityKinds);
+  }
+  else if (m_testId == 2)
+  {
+    QTimer::singleShot(1000, this, &PdmTests::tryGetAllBiteComponentTexts);
+  }
+  else
+  {
+    ERROR_LOG(m_logger) << "Unknown test case!";
+    failExit();
+  }
+  QTimer::singleShot(5000, qApp, &QCoreApplication::quit);
+}
+
+
+//---------------------------------------------------------------------------------
+void PdmTests::tryGetAllVulnerabilityKinds()
+{
+  INFO_LOG(m_logger) << "trying to get all ProjectDataManagements";
+  const QMap<qint32, ProjectDataManagement::VulnerabilityKind> map = m_dtc->vulnerabilityKinds();
+  if (map.isEmpty())
+  {
+    ERROR_LOG(m_logger) << "Error requesting vulnerability kinds data";
+    failExit();
+  }
+  else
+  {
+    INFO_LOG(m_logger) << "Amount of vulnerability kinds = " << map.size();
+    m_id = map.firstKey();
+    for(auto it = map.begin(); it != map.end(); ++it)
+    {
+      const ProjectDataManagement::VulnerabilityClass &vc = it.value().vulnerabilityClassId();
+      INFO_LOG(m_logger) << "VulnerabilityKind(" << it.key() << ") : " << it.value().name()
+                         << ", translation " << m_dtc->trVulnerabilityKindName(it.key(), vc);
+    }
+  }
+
+  QTimer::singleShot(10, this, &PdmTests::tryGetVulnerabilityKind);
+}
+
+//---------------------------------------------------------------------------------
+void PdmTests::tryGetVulnerabilityKind()
+{
+  INFO_LOG(m_logger) << "trying get itemData for Vulnerability kind " << m_id;
+  ProjectDataManagement::VulnerabilityKind data = m_dtc->vulnerabilityKind(m_id);
+
+  if (data.taVulnerabilityKind() <= 0)
+  {
+    ERROR_LOG(m_logger) << "Error receiving data for id " << m_id;
+    failExit();
+  }
+  else
+  {
+    const ProjectDataManagement::VulnerabilityClass &vc = data.vulnerabilityClassId();
+    INFO_LOG(m_logger) << "## VulnerabilityKind: (" << data.taVulnerabilityKind() << "), name: " << data.name()
+                       << ", translation " << m_dtc->trVulnerabilityKindName(m_id, vc);
+    QTimer::singleShot(0, qApp, &QCoreApplication::quit);
+  }
+}
+
+
+//---------------------------------------------------------------------------------
+void PdmTests::tryGetAllBiteComponentTexts()
+{
+  INFO_LOG(m_logger) << "trying to get all Bite Component Texts";
+  const QMap<qint32, ProjectDataManagement::BiteComponentText> map = m_dtc->biteComponentTexts();
+  if (map.isEmpty())
+  {
+    ERROR_LOG(m_logger) << "Error requesting bite components text data";
+    failExit();
+  }
+  else
+  {
+    INFO_LOG(m_logger) << "Amount of bite component texts = " << map.size();
+    m_id = map.firstKey();
+    for(auto it = map.begin(); it != map.end(); ++it)
+      INFO_LOG(m_logger) << "BiteComponent(" << it.key() << ") : " << it.value().name()
+                         << ", translation " << m_dtc->trBiteComponentTextName(it.key());
+  }
+}
+
+
+// ------------------------------------------------------------------------------
+void PdmTests::failExit()
+{
+  m_bTestsSuccessful = false;
+  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
+}
+
+} // end namespace
+
+// ------------------------------------------------------------------
+class CmdLineParser : public LtsCommandLineParser::LtsCommandLineParser
+{
+public:
+  CmdLineParser()
+    : LtsCommandLineParser()
+  {
+    addOption({ QStringList() << QLatin1String("t") << QLatin1String("testId")
+                , QLatin1String("TestId.")
+                , QLatin1String("Default: 0 (all tests)")
+                , QLatin1String("0")
+              });
+  }
+  int testId() const     { return isSet(QLatin1String("t")) ? value(QLatin1String("t")).toInt() : 0; }
+};
+
+// ------------------------------------------------------------------
+int main(int argc, char **argv)
+{
+  NGLCoreApplication app(argc, argv);
+  app.createLogger("PDM", "log4cxx_pdm.props");
+
+  int iRet = -1;
+  CmdLineParser   options;
+  if (!options.init())
+    return -1;
+
+  std::unique_ptr<ProjectDataManagement::PdmTests> pdmTests(new ProjectDataManagement::PdmTests);
+
+  if(!pdmTests->init(options.domainId(), options.testId()))
+    return iRet;
+
+  QTimer::singleShot(0, pdmTests.get(), &ProjectDataManagement::PdmTests::startTest);
+
+  STARTUP_LOG(app.baseLogger());
+
+  app.exec();
+  iRet = pdmTests->testsSuccessful() ? 0 : 1;
+  fprintf(stderr, "%d\n", iRet);
+
+  DEBUG_LOG(app.baseLogger()) << "** TEST result = " << iRet;
+
+  SHUTDOWN_LOG(app.baseLogger());
+
+  return iRet;
+}
+

Lts/Services/ProjectDataManagement/ModuleTests/pdm_tests.h

@@ -0,0 +1,50 @@
+/**
+  * @RDE_HEADER@
+  * SRP Data Topic test executable
+  *
+  * ModuleTests to get data from Service ProjectDataManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <ProjectDataManagement/pdm_dtc.h>
+#include <ProjectDataManagement/pdm_ftc.h>
+#include <ProjectDataManagement/logger.h>
+#include <DDS/DDSConnector/dds_connector.h>
+
+namespace ProjectDataManagement
+{
+class PdmTests : public QObject
+{
+  Q_OBJECT
+public:
+  explicit PdmTests(QObject *parent = nullptr);
+  ~PdmTests();
+
+  bool init(int domainId, int testId);
+  bool testsSuccessful() const { return m_bTestsSuccessful; }
+
+public Q_SLOTS:
+  void startTest();
+protected Q_SLOTS:
+  void tryGetAllVulnerabilityKinds();
+  void tryGetVulnerabilityKind();
+  void tryGetAllBiteComponentTexts();
+protected:
+  void failExit();
+
+private:
+  std::shared_ptr<DDSConnector::DdsConnector>      m_ddsConnector;
+  std::shared_ptr<ProjectDataManagement::Interface::Dtc> m_dtc;
+  std::shared_ptr<ProjectDataManagement::Interface::Ftc> m_ftc;
+  qint32           m_id;
+  int              m_testId;
+  bool             m_bTestsSuccessful;
+  LOGGER_T         m_logger;
+
+};
+
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/chargetype_rename.cpp

@@ -0,0 +1,70 @@
+/**
+  * Load/Publish db-translations
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "chargetype_rename.h"
+#include "dds_handler.h"
+#include "convert_db_to_dds.h"
+
+namespace ProjectDataManagement
+{
+
+ChargeTypeRename::ChargeTypeRename(const std::shared_ptr<DdsHandler> &dds, const std::shared_ptr<DatabaseInterface> &db)
+  : Interface::Fts::UpdateChargeNamesRequestHandler(dds->fts())
+  , Interface::Fts::UpdateChargeTypeRequestHandler(dds->fts())
+  , m_dds(dds)
+  , m_db(db)
+  , m_logger(getLogger("ChargeTypeRename"))
+{
+}
+
+void ChargeTypeRename::onUpdateChargeNamesRequest(const rti::core::SampleIdentity &cookie, const UpdateChargeNamesRequest &request)
+{
+  Core::FunctionReplyObject fro(request.id());
+  if (request.id() <= 0)
+  {
+    fro = Core::FunctionReplyObject(request.id(), tr_lts("dds", "Name update on ChargeType, but no Charge Type Id given"));
+    m_dds->fts()->updateChargeNamesReply(cookie, fro);
+    return;
+  }
+  Database::PdmChargeType ct;
+  if (!m_db->selectPdmChargeType(request.id(), ct))
+  {
+    fro = Core::FunctionReplyObject(request.id(), tr_lts("dds", "Name update on ChargeType, Charge Type could not be fetched from DB"));
+    m_dds->fts()->updateChargeNamesReply(cookie, fro);
+    return;
+  }
+  ct.name = QString::fromStdString(request.name());
+  ct.shortName = QString::fromStdString(request.shortName());
+
+  if (!m_db->update(ct))
+  {
+    fro = Core::FunctionReplyObject(request.id(), tr_lts("dds", "Name update on ChargeType, Cannot update DB (select worked before)"));
+    m_dds->fts()->updateChargeNamesReply(cookie, fro);
+    return;
+  }
+
+  m_dds->fts()->updateChargeNamesReply(cookie, Core::FunctionReplyObject(ct.id));
+
+  m_dds->dts()->publish(Database::convert(ct));
+}
+
+void ChargeTypeRename::onUpdateChargeTypeRequest(const rti::core::SampleIdentity &cookie, const ChargeType &request)
+{
+  Database::PdmChargeType ct;
+  ct.disEntity = QString::fromStdString(request.disEntity());
+  ct.id = request.id();
+  ct.name = QString::fromStdString(request.name());
+  ct.predefinedName = QString::fromStdString(request.predefinedName());
+  ct.properties = QString::fromStdString(request.properties());
+  ct.shortName = QString::fromStdString(request.shortName());
+  m_db->update(ct);
+  m_dds->fts()->updateChargeTypeReply(cookie, Core::FunctionReplyObject(ct.id));
+  m_dds->dts()->publish(request);
+}
+
+
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/chargetype_rename.h

@@ -0,0 +1,43 @@
+/**
+  * Handle Charge Type Renaming
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <ProjectDataManagement/pdm_fts.h>
+#include <QObject>
+
+#include "logger.h"
+
+namespace ProjectDataManagement
+{
+class DdsHandler;
+class DatabaseInterface;
+
+class ChargeTypeRename
+    : public QObject
+    , protected Interface::Fts::UpdateChargeNamesRequestHandler
+    , protected Interface::Fts::UpdateChargeTypeRequestHandler
+
+{
+public:
+  ChargeTypeRename(const std::shared_ptr<DdsHandler> &dds,
+              const std::shared_ptr<DatabaseInterface> &db);
+  ~ChargeTypeRename() = default;
+
+private:
+  void onUpdateChargeNamesRequest(const rti::core::SampleIdentity &cookie,
+                                  const UpdateChargeNamesRequest &request) override;
+//  void onSuppressVisibilityRequest(const rti::core::SampleIdentity &cookie,
+//                                   const SuppressVisibilityRequest &request) override;
+  void onUpdateChargeTypeRequest(const rti::core::SampleIdentity &cookie,
+                                 const ChargeType &request) override;
+private:
+  std::shared_ptr<DdsHandler> m_dds;
+  std::shared_ptr<DatabaseInterface> m_db;
+  NGL::INGLLogger &m_logger;
+};
+}

Lts/Services/ProjectDataManagement/convert_db_to_dds.h

@@ -0,0 +1,355 @@
+/**
+  * Convert db structures to dds structures
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2017-07-20
+  */
+#pragma once
+
+#include <ProjectDataManagement/pdm_db.h>
+#include <ProjectDataManagement/pdm.hpp>
+
+
+namespace ProjectDataManagement
+{
+namespace Database
+{
+inline BuildingChargeEffect convert(const PdmBuildingChargeEffect &data)
+{
+  BuildingChargeEffect ddsData;
+  ddsData.id(data.id);
+  ddsData.chargeTypeId(data.chargeTypeId);
+  ddsData.destructiveFactor(data.destructiveFactor);
+  ddsData.penetrationFactor(data.penetrationFactor);
+  ddsData.hitSound(data.hitSound);
+  ddsData.difcueLight(data.difcueLight);
+  ddsData.difcuePyro(data.difcuePyro);
+
+  return ddsData;
+}
+
+inline ChargeType convert(const PdmChargeType &data)
+{
+  ChargeType ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.shortName(data.shortName.toStdString());
+  ddsData.predefinedName(data.predefinedName.toStdString());
+  ddsData.properties(data.properties.toStdString());
+  ddsData.legacyId(data.chargeLegacyId);
+  if (!data.disEntity.isEmpty())
+    ddsData.disEntity(data.disEntity.toStdString());
+
+  return ddsData;
+}
+
+inline SanitationMaterial convert(const PdmSanitationMaterial &data)
+{
+  SanitationMaterial ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.description(data.description.toStdString());
+  ddsData.version(data.version.toStdString());
+  return ddsData;
+}
+
+inline SanitationProcedure convert(const PdmSanitationProcedures &data)
+{
+  SanitationProcedure ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.longName(data.longName.toStdString());
+  ddsData.type(data.type.toStdString());
+  ddsData.typeId(data.typeId);
+  ddsData.minimumQualification(data.minimumQualification);
+  ddsData.dataCode(data.dataCode);
+  ddsData.version(data.version.toStdString());
+
+  return ddsData;
+}
+
+inline SanitationInjury convert(const PdmSanitationInjury &data)
+{
+  SanitationInjury ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.kind(data.kind);
+  ddsData.place1(data.place1);
+  ddsData.place2(data.place2);
+  ddsData.vbg(data.vbg);
+
+  return ddsData;
+}
+
+inline SanitationInjuryKind convert(const PdmSanitationInjuryKind &data)
+{
+  SanitationInjuryKind ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.version(data.version.toStdString());
+  return ddsData;
+}
+
+inline SanitationInjuryPlace1 convert(const PdmSanitationInjuryPlace1 &data)
+{
+  SanitationInjuryPlace1 ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.version(data.version.toStdString());
+  return ddsData;
+}
+
+inline SanitationInjuryPlace2 convert(const PdmSanitationInjuryPlace2 &data)
+{
+  SanitationInjuryPlace2 ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.version(data.version.toStdString());
+  return ddsData;
+}
+
+
+inline GearTypeChargeType convert(const PdmGearTypeChargeType &data)
+{
+  GearTypeChargeType ddsData;
+  ddsData.id(data.id);
+  ddsData.gearTypeId(data.gearTypeId);
+  ddsData.chargeTypeId(data.chargeTypeId);
+  ddsData.maxRange(data.maxRange);
+  ddsData.properties(data.properties.toStdString());
+
+  return ddsData;
+}
+
+inline GearType convert(const PdmGearType &data)
+{
+  GearType ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.gearClassId(data.gearClassId);
+  ddsData.tasCode(data.tasCode);
+  ddsData.properties(data.properties.toStdString());
+
+  return ddsData;
+}
+
+inline IgniterType convert(const PdmIgniterType &data)
+{
+  IgniterType ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.shortName(data.shortName.toStdString());
+  ddsData.properties(data.properties.toStdString());
+
+  return ddsData;
+}
+
+inline IgniterFunction convert(const PdmIgniterFunction &data)
+{
+  IgniterFunction ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.shortName(data.shortName.toStdString());
+  ddsData.properties(data.properties.toStdString());
+
+  return ddsData;
+}
+
+inline LoadType convert(const PdmLoadType &data)
+{
+  LoadType ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.shortName(data.shortName.toStdString());
+  ddsData.properties(data.properties.toStdString());
+
+  return ddsData;
+}
+
+inline ChargeTypeIgniterTypeIgniterFunction convert(const PdmChargeTypeIgniterTypeIgniterFunction &data)
+{
+  ChargeTypeIgniterTypeIgniterFunction ddsData;
+  ddsData.id(data.id);
+  ddsData.chargeTypeId(data.chargeTypeId);
+  ddsData.igniterTypeId(data.igniterTypeId);
+  ddsData.igniterFunctionId(data.igniterFunctionId);
+  ddsData.igniterFunctionBaseId(data.igniterFunctionBaseId);
+  ddsData.impactArea(data.impactArea.toStdString());
+  ddsData.impactRadius(data.impactRadius);
+  ddsData.hazardDistance(data.hazardDistance);
+  ddsData.chargeLegacyId(data.chargeLegacyId);
+  ddsData.properties(data.properties.toStdString());
+
+  return ddsData;
+}
+
+inline ChargeTypeLoadType convert(const PdmChargeTypeLoadType &data)
+{
+  ChargeTypeLoadType ddsData;
+  ddsData.id(data.id);
+  ddsData.chargeTypeId(data.chargeTypeId);
+  ddsData.loadTypeId(data.loadTypeId);
+  ddsData.numbers(data.numbers());
+  ddsData.properties(data.properties.toStdString());
+
+  return ddsData;
+}
+
+inline LanguageHmi convert(const PdmLanguage &data)
+{
+  LanguageHmi ddsData;
+  ddsData.id(data.id);
+  ddsData.dbLocale(data.dbLocale.toStdString());
+  ddsData.name(data.name.toStdString());
+  ddsData.isoCode(data.isoCode.toStdString());
+
+  return ddsData;
+}
+
+inline LanguageXdu convert(const PdmLanguageXdu &data)
+{
+  LanguageXdu ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.isoCode(data.isoCode.toStdString());
+
+  return ddsData;
+}
+
+inline RadioGroup convert(const PdmRadioGroup &data)
+{
+  RadioGroup ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.issi(data.issi);
+  ddsData.group_issi1(data.groupIssi1);
+  ddsData.group_issi2(data.groupIssi2);
+  ddsData.base_group(data.baseGroup);
+  ddsData.radioHostname(data.radioHostname.toStdString());
+  ddsData.radioPort(data.radioPort);
+  ddsData.radioBackupHostname(data.radioBackupHostname.toStdString());
+  ddsData.radioBackupPort(data.radioBackupPort);
+
+  return ddsData;
+}
+
+inline VulnerabilityKind convert(const PdmVulnerabilityKind &data)
+{
+  VulnerabilityKind ddsData;
+  ddsData.id(data.taVulnerabilityKind); // in db there is no id anymore, IO 2021-03-10
+  ddsData.playerTypeClassId(data.playerTypeClassId);
+  ddsData.taVulnerabilityKind(data.taVulnerabilityKind);
+  ddsData.vulnerabilityClassId(data.vulnerabilityClassId);
+  ddsData.name(data.name.toStdString());
+
+  return ddsData;
+}
+
+inline FirePurpose convert(const PdmFirePurpose &data)
+{
+  FirePurpose ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.description(data.description.toStdString());
+  ddsData.properties(data.properties.toStdString());
+
+  return ddsData;
+}
+
+inline NuclearPreset convert(const PdmNuclearPreset &data)
+{
+  NuclearPreset ddsData;
+  ddsData.id(data.id);
+  ddsData.name(data.name.toStdString());
+  ddsData.detonationValue(data.detonationValue);
+  ddsData.impactRadius(data.impactRadius);
+  ddsData.borderLengthInner(data.borderLengthInner);
+  ddsData.borderLengthOuter(data.borderLengthOuter);
+
+  return ddsData;
+}
+
+inline CanComponentString convert(const PdmCanComponentString &data)
+{
+  CanComponentString ddsData;
+  ddsData.id(data.id);
+  ddsData.bitMask(data.bitMask);
+  ddsData.canDeviceId(data.canDeviceId);
+  ddsData.subDeviceId(data.subDeviceId);
+  ddsData.name(data.name.toStdString());
+
+  return ddsData;
+}
+
+inline BiteComponentText convert(const PdmBiteComponentText &data)
+{
+  BiteComponentText ddsData;
+  ddsData.id(data.id);
+  ddsData.canDeviceId(data.canDeviceId);
+  ddsData.subDeviceId(data.subDeviceId);
+  ddsData.errorNumber(data.errorNumber);
+  ddsData.name(data.name.toStdString());
+
+  return ddsData;
+}
+
+inline EquipmentSystemEventFilter convert(const PdmEquipmentSystemEventFilter &data)
+{
+  EquipmentSystemEventFilter ddsData;
+  ddsData.id(data.id);
+  ddsData.equipmentFunctionId(data.equipmentFunctionalId);
+  ddsData.subDeviceId(data.subDeviceId);
+  ddsData.deviceSpecificCode(data.deviceSpecificCode);
+
+  return ddsData;
+}
+
+inline EventFilterHgrMineSearch convert(const PdmEventFilterHgrMineSearch &data)
+{
+  EventFilterHgrMineSearch ddsData;
+  ddsData.id(data.id);
+  ddsData.chargeTypeId(data.chargeTypeId);
+  ddsData.hgrMineSearchFilterType(data.hgrMineSearchFilterTypeId);
+
+  return ddsData;
+}
+
+inline TargetType convert(const PdmTargetType &data)
+ {
+   TargetType ddsData;
+
+   ddsData.id(data.id);
+   ddsData.name(data.name.toStdString());
+   ddsData.abbreviation(data.abbreviation.toStdString());
+   ddsData.properties(data.properties.toStdString());
+
+   return ddsData;
+ }
+
+inline TargetSubType convert(const PdmTargetSubType &data)
+ {
+   TargetSubType ddsData;
+
+   ddsData.id(data.id);
+   ddsData.name(data.name.toStdString());
+   ddsData.abbreviation(data.abbreviation.toStdString());
+   ddsData.properties(data.properties.toStdString());
+
+   return ddsData;
+ }
+inline TargetTypeTargetSubType convert(const PdmTargetTypeTargetSubType &data)
+ {
+   TargetTypeTargetSubType ddsData;
+
+   ddsData.id(data.id);
+   ddsData.targetTypeId(data.targetTypeId);
+   ddsData.targetSubTypeId(data.targetSubtypeId);
+   ddsData.properties(data.properties.toStdString());
+
+   return ddsData;
+ }
+
+
+} // namespace Database
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/dds_handler.cpp

@@ -0,0 +1,49 @@
+/**
+  * DdsHandler for DDS
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hanna E. Rathje, SLSE, 2015-09-02
+  */
+
+#include "dds_handler.h"
+
+#include <DDS/Core/pacemaker.h>
+
+namespace ProjectDataManagement
+{
+
+DdsHandler::DdsHandler(int domainId)
+  : m_ddsConnector(std::make_shared<DDSConnector::DdsConnector>(domainId, IDL::PartitionType::Any))
+  , m_logger(getLogger("DdsHandler"))
+{
+  DEBUG_LOG(m_logger) << "DdsHandler(" << domainId << ") for partition: " << m_ddsConnector->getDefaultPartition();
+}
+
+bool DdsHandler::init(const QStringList &qosFileList)
+{
+  if (!m_ddsConnector->init(qosFileList))
+  {
+    ERROR_LOG(m_logger) << "Error initializing dds connections - aborting";
+    return false;
+  }
+
+  m_ddsConnector->initPublisherSubscriber();
+  m_ddsConnector->enableBatchedWriter(false);
+
+  // Pacemaker
+  m_pacemaker = std::make_shared<Core::Pacemaker>(m_ddsConnector);
+  m_topicLockMaster = std::make_shared<Core::TopicLockMaster>(m_ddsConnector);
+
+  m_ddsDts = ProjectDataManagement::Interface::Dts::create(m_ddsConnector);
+  bool bRet = m_ddsDts->enableAll();
+  INFO_LOG(m_logger) << "Dts initialised";
+
+  m_ddsFts = ProjectDataManagement::Interface::Fts::create(m_ddsConnector);
+  bRet &= m_ddsFts->enableAll();
+  INFO_LOG(m_logger) << "Fts initialised";
+
+  return bRet;
+}
+
+} // Namespace PDM

Lts/Services/ProjectDataManagement/dds_handler.h

@@ -0,0 +1,49 @@
+/**
+  * DdsHandler for DDS
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hanna E. Rathje, SLSE, 2015-09-02
+  */
+#pragma once
+
+#include <DDS/DDSConnector/dds_connector.h>
+#include <DDS/Core/topic_lock_master.h>
+#include <ProjectDataManagement/pdm_dts.h>
+#include <ProjectDataManagement/pdm_fts.h>
+
+#include "logger.h"
+
+namespace Core
+{
+class Pacemaker;
+}
+
+namespace ProjectDataManagement
+{
+class DdsHandler final
+{
+public:
+  explicit DdsHandler(int domainId);
+  ~DdsHandler() = default;
+
+  bool init(const QStringList &qosFileList = QStringList());
+
+  std::shared_ptr<Core::Pacemaker> pacemaker() const {return m_pacemaker; }
+  std::shared_ptr<Core::TopicLockMaster> topicLockMaster() const { return m_topicLockMaster; }
+
+  std::shared_ptr<ProjectDataManagement::Interface::Dts> dts() const { return m_ddsDts; }
+  std::shared_ptr<ProjectDataManagement::Interface::Fts> fts() const { return m_ddsFts; }
+  std::shared_ptr<DDSConnector::DdsConnector>            dds() const { return m_ddsConnector; }
+
+private:
+  std::shared_ptr<DDSConnector::DdsConnector>            m_ddsConnector;
+  std::shared_ptr<Core::Pacemaker>                       m_pacemaker;
+  std::shared_ptr<Core::TopicLockMaster>                 m_topicLockMaster;
+  std::shared_ptr<ProjectDataManagement::Interface::Dts> m_ddsDts;
+  std::shared_ptr<ProjectDataManagement::Interface::Fts> m_ddsFts;
+
+  NGL::INGLLogger          &m_logger;
+};
+
+}

Lts/Services/ProjectDataManagement/log4cxx_pdm.props

@@ -0,0 +1,82 @@
+log4j.reset=true
+log4j.rootLogger=WARN, file
+
+# Service: ProjectDataManagement
+###########################################################
+
+#log4j.logger.PDM=DEBUG
+#log4j.logger.PDM.main=WARN
+#log4j.logger.PDM.DdsHandler=INFO
+#log4j.logger.PDM.ProjectData=INFO
+#log4j.logger.PDM.Translation=INFO
+#log4j.logger.PDM.Test=DEBUG
+
+# File
+###########################################################
+log4j.appender.file=Lts::RollingFileAppender
+log4j.appender.file.MaxFileSize=1MB
+log4j.appender.file.MaxBackupIndex=9
+log4j.appender.file.layout=org.apache.log4j.PatternLayout
+log4j.appender.file.layout.ConversionPattern=%d %-5p %c |#| %m (%.50F:%L) %n
+
+
+# Appnd_Console
+###########################################################
+log4j.appender.stdout=org.apache.log4j.ConsoleAppender
+log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
+log4j.appender.stdout.layout.ConversionPattern= %d %p %c %c{1} - %m (%-.30F:%L) %n
+
+
+# Appnd_Syslog
+###########################################################
+log4j.appender.syslog=org.apache.log4j.SyslogAppender
+log4j.appender.syslog.Threshold=ERROR
+log4j.appender.syslog.SysLogHost=localhost
+log4j.appender.syslog.Facility=LOCAL7
+log4j.appender.syslog.layout=org.apache.log4j.PatternLayout
+log4j.appender.syslog.layout.ConversionPattern= %-4r %-5p %c %x - %m
+log4j.appender.syslog.LevelRangeFilter.AcceptOnMatch=true
+log4j.appender.syslog.LevelRangeFilter.LevelMin=INFO
+log4j.appender.syslog.LevelRangeFilter.LevelMax=FATAL
+
+
+###########################################################
+###########################################################
+###########################################################
+# 1) Available Levels in LOG4CXX Version 0.10.0:
+# TRACE,
+# DEBUG,
+# INFO,
+# WARN,
+# ERROR
+# FATAL
+#
+# d = date/time
+# p = priority (Level)
+# c = category/channel
+# m = message
+# F = file
+# L = line
+# n = platform dependent line separator character or characters.
+# ....
+#
+# Examples for console:
+# a)
+# %d %p %c #%m# (%.50F:%L)%n
+# date/time
+#    priority
+#       category/channel
+#          #message#
+#                (Maximal 50Character des Filename von rechts:Line)
+#                       line separator
+#
+# b)
+# %d (%.15F:%L) %-5p %c |#| %m%n
+# date/time
+#    (Maximal 15Character des Filename von rechts:Line)
+#               priority, Right pad with spaces if the priority name is less than 5 characters long.
+#                    category/channel
+#                           message
+#                             line separator
+#
+# Examples for files:

Lts/Services/ProjectDataManagement/logger.cpp

@@ -0,0 +1,37 @@
+/**
+  * @RDE_HEADER@
+  * Building Config - logging facility
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "logger.h"
+
+#include <NGLLogger/NGLLoggerBootstrap.h>
+
+namespace ProjectDataManagement
+{
+
+LOGGER_T getLogger(const char *name)
+{
+  static const char ns[] = "PDM.";
+  std::string loggerName;
+  const size_t len = strlen(name);
+  loggerName.reserve(sizeof(ns) + len);
+  loggerName.append(ns, sizeof(ns) - 1);
+  loggerName.append(name, len);
+
+  try
+  {
+    return NGL::NGLLoggerBootstrap::getNGLRootLogger().
+           getNGLLogger(loggerName);
+  }
+  catch (const std::exception &ex)
+  {
+    fprintf(stderr, "Error retrieving logger: %s", ex.what());
+    abort();
+  }
+}
+
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/logger.h

@@ -0,0 +1,23 @@
+/**
+  * @RDE_HEADER@
+  * Logging for ProjectDataManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+
+#include <NGLLogger/INGLLogger.h>
+#include "pdm_export.h"
+
+namespace ProjectDataManagement
+{
+using LOGGER_T = NGL::INGLLogger &;
+
+PDM_COMMON_EXPORT LOGGER_T getLogger(const char *name);
+inline LOGGER_T getLogger(const QString &loggerName)
+{
+  return getLogger(loggerName.toUtf8().constData());
+}
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/main.cpp

@@ -0,0 +1,42 @@
+/**
+  * @RDE_HEADER@
+  * main for ProjectDataManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include <nglapplication/nglcoreapplication.h>
+#include <LtsCommandLineParser/LtsCommandLineParser.h>
+
+#include "main_handler.h"
+#include "logger.h"
+#include "settings.h"
+
+int main(int argc, char **argv)
+{
+  NGLCoreApplication app(argc, argv);
+
+  LtsCommandLineParser::LtsCommandLineParser options;
+  if (!options.init())
+    return -1;
+  app.createLogger("PDM", options.exerciseId());
+
+  ProjectDataManagement::Settings::setIniFile(options.iniFile());
+
+  int iRet = -3;
+  {
+    std::unique_ptr<ProjectDataManagement::MainHandler> mainHandler(new ProjectDataManagement::MainHandler);
+
+    if (!mainHandler->init(options.domainId()))
+      return iRet;
+
+    STARTUP_LOG(app.baseLogger());
+
+    iRet = app.exec();
+
+    SHUTDOWN_LOG(app.baseLogger());
+  }
+
+  return iRet;
+}

Lts/Services/ProjectDataManagement/main_handler.cpp

@@ -0,0 +1,99 @@
+/**
+  * MainHandler for ProjectDataManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "main_handler.h"
+#include "settings.h"
+#include <QSettings>
+
+#include "convert_db_to_dds.h"
+
+#include <DDS/DDSConnector/dds_connector.h>
+#include <DDS/Core/pacemaker.h>
+#include <ngldb/db_service_handler.h>
+#include "static_pvsan_import.h"
+
+using namespace ProjectDataManagement;
+
+MainHandler::MainHandler()
+  : m_logger(getLogger("MainHandler"))
+{}
+
+MainHandler::~MainHandler()
+{
+  m_translation = nullptr;
+  m_chargeTypeRename = nullptr;
+  m_dbHandler = nullptr;
+  m_ddsHandler = nullptr;
+}
+
+
+bool MainHandler::init(int domainId)
+{
+  // initialize database
+  m_dbHandler = std::make_shared<DbHandler>();
+  if (!m_dbHandler->init(0, Settings::settings()))
+  {
+    ERROR_LOG(m_logger) << "Initialisation DbHandler failed.";
+    return false;
+  }
+
+  // initialize DDS
+  m_ddsHandler =  std::make_shared<DdsHandler>(domainId);
+  if (!m_ddsHandler->init())
+  {
+    ERROR_LOG(m_logger) << "Initialisation DdsHandler failed.";
+    return false;
+  }
+
+  if(Settings::settings()->settings()->value(QLatin1String("TrainingAreaBase/UsePvSan"), false).toBool())
+  {
+    DEBUG_LOG(m_logger) << "Has PvSan so do the import";
+    PvSanImport(db(), m_logger);
+  }
+
+  // initialize the specific handler
+  if (!publishData<Database::PdmBiteComponentText>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmBuildingChargeEffect>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmCanComponentString>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmChargeType>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmSanitationMaterial>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmFirePurpose>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmGearType>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmGearTypeChargeType>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmIgniterType>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmIgniterFunction>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmLoadType>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmChargeTypeIgniterTypeIgniterFunction>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmChargeTypeLoadType>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmTargetType>    (db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmTargetSubType>    (db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmTargetTypeTargetSubType>    (db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmLanguage>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmLanguageXdu>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmNuclearPreset>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmRadioGroup>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmVulnerabilityKind>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmEquipmentSystemEventFilter>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmSanitationProcedures>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmSanitationInjury>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmSanitationInjuryKind>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmSanitationInjuryPlace1>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmSanitationInjuryPlace2>(db(), m_ddsHandler->dts(), m_logger) ||
+      !publishData<Database::PdmEventFilterHgrMineSearch>(db(), m_ddsHandler->dts(), m_logger))
+    return false;
+
+  m_translation = std::make_shared<Translation>(m_ddsHandler, db());
+  m_chargeTypeRename = std::make_shared<ChargeTypeRename>(m_ddsHandler, db());
+
+  m_ddsHandler->pacemaker()->setNewState(Core::RunningState::Running);
+  return true;
+}
+
+std::shared_ptr<DatabaseInterface> MainHandler::db() const
+{
+  return m_dbHandler->db();
+}

Lts/Services/ProjectDataManagement/main_handler.h

@@ -0,0 +1,42 @@
+/**
+  * MainHandler for ProjectDataManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+#pragma once
+
+#include <memory>
+#include "dds_handler.h"
+#include "pdm_db.h"
+#include "logger.h"
+#include "static_data_publisher.h"
+#include "translation.h"
+#include "chargetype_rename.h"
+
+namespace NGLDB
+{
+template <typename DB> class DbServiceHandler;
+}
+namespace ProjectDataManagement
+{
+using DbHandler = NGLDB::DbServiceHandler<DatabaseInterface>;
+
+class MainHandler final
+{
+public:
+  MainHandler();
+  ~MainHandler();
+
+  bool init(int domainId);
+  std::shared_ptr<DatabaseInterface> db() const;
+
+private:
+  std::shared_ptr<DdsHandler>  m_ddsHandler;
+  std::shared_ptr<DbHandler>   m_dbHandler;
+  std::shared_ptr<Translation> m_translation;
+  std::shared_ptr<ChargeTypeRename> m_chargeTypeRename;
+  NGL::INGLLogger             &m_logger;
+
+};
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/pdm_dtc_impl_custom.h

@@ -0,0 +1,278 @@
+/**
+ * @RDE_HEADER@
+ * PDM Custom functions (extends pdmm_dtc_impl.cpp/.h)
+ * $Id$
+ * $HeadURL$
+ * $Author$
+ * Created by Iuliana Ojog, SLSE, 2016-11-26
+ */
+#pragma once
+
+#include <QHash>
+#include <QJsonObject>
+#include <QVector>
+#include <ProjectDataManagement/pdm_dtc_impl.h>
+
+//-------------------------------------------------------------------------------------------------------------
+namespace ProjectDataManagement
+{
+namespace Interface
+{
+class DtcImplCustom final : public Interface::DtcImpl
+{
+
+  enum UleisClassOffset
+  {
+    None = 0,
+    Grandparent = 0,
+    ShortTimeChild1 = 1500,
+    ShortTimeChild2 = 1600,
+    ShortTimeChild3 = 1700,
+    ShortTimeChild4 = 1800,
+    ShortTimeChild5 = 1900,
+
+    DirectImpactGrandparent = 2000,
+    TopAttackGrandparent = 2000,
+    DirectImpactChild = 3000,
+    TopAttackChild = 3000,
+    BurstOfFireParent = 4000,
+    BurstOfFireChild = 5000,
+    AirBurstParent = 6000,
+    AirBurstChild = 7000,
+    UnarmedParent = 8000,
+    UnarmedChild = 9000,
+    FireAndForgetParent = 12000,
+    FireAndForgetChild = 13000,
+    ShortTimeScanningParent = 22000,
+    ShortTimeScanningChild = 23000
+  };
+
+  Q_OBJECT
+  public:
+  explicit DtcImplCustom(const std::shared_ptr<DDSConnector::DdsConnector> &ddsConnector);
+
+  // custom procs, body must be implemented by user
+  // Might need a "baseChargesForGearClass" later on...
+  QVector<ProjectDataManagement::ChargeType> chargesForGearClass(GearClass gearClass) override;
+  QVector<ProjectDataManagement::IgniterType> ignitersForChargeType(int chargeTypeId) override;
+  QVector<ProjectDataManagement::ChargeTypeIgniterTypeIgniterFunction> igniterFunctionsForChargeTypeIgniterType(int chargeTypeId, int igniterTypeId) override;
+  QVector<ProjectDataManagement::LoadType> loadsForChargeType(int chargeTypeId) override;
+  QVector<TargetSubType> targetSubTypesForTargetType(int targetType) override;
+
+  double expansionFactor(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  double impactRadius(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  double impactEdgeLength(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isDryFire(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  int mineClass(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool canBeThrown(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool canBeCreated(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isIed(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isReactivatable(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isSmart(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  int maxEffectShows(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isSmoke(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isVisible(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isIndirect(int chargeTypeId) override;
+  int searchRadius(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool showHitline(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  int remainingTasCode(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  int secondaryRemainingTasCode(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  int segments(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isLine(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isFromMineLayer(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isMineLaying(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  QJsonObject mineLayingPattern(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  int height(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isLaserGuidable(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isUasDroppable(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isJamming(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  QVector<int> spacing(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  VolatilityType volatilityTypeId(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  int hazardDistance(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  QVector<CasEffect> casEffects(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  GearClass gearClassFromChargeTypeId(int chargeTypeId) override;
+  QVector<int> gearTypeIdFromChargeTypeId(int chargeTypeId) override;
+  int chargeTypeIdFromLegacyId(GearClass gearClass, int legacyId) override;
+  bool isGmlrs(int chargeTypeId) override;
+  bool isDm72(int chargeTypeId) override;
+  bool isRocket(int chargeTypeId) override;
+
+  ChargeTypeIgniterTypeIgniterFunction getChargeTypeIgniterTypeIgniterFunction(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  ChargeTypeLoadType getChargeTypeLoadType(int chargeTypeId, int loadTypeId) override;
+
+  bool canRestock(int gearTypeId) override;
+  bool canSetDefaults(int gearTypeId) override;
+  int maxCharges(int gearTypeId) override;
+  int cadence(int gearTypeId) override;
+  int getAdlerWeaponSystemId(int gearTypeId) override;
+  int factoryDefault(int gearTypeId, int chargeTypeId) override;
+  int maxCharge(int gearTypeId, int chargeTypeId) override;
+  bool isAtMine(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  bool isApMine(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  double getLethalRadius(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  double getNonLethalRadius(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  double getMaxRange(int chargeTypeId, int gearTypeId) override;
+  ProjectDataManagement::BuildingChargeEffect getBuildingChargeEffectByChargeTypeId(int chargeTypeId) override;
+  bool isVirtuallyFireable(int chargeTypeId) override;
+  bool isAdlerChargeType(int chargeTypeId) override;
+  int getAmountFireMarkers(int firePurposeId) override;
+  bool getWithDurationFirePurpose(int firePurposeId) override;
+
+  // get Adler names/ids
+  int getTargetTypeIdFromAdlerTargetType(const QString &typ) override;
+  int getTargetSubTypeIdFromAdlerTargetSubType(const QString &subTyp) override;
+  int getChargeTypeIdFromAdlerCharges(const QString &geschosssorte) override;
+  int getIgniterTypeIdFromAdlerIgniter(const QString &zuender) override;
+  int getIgniterFunctionIdFromAdlerIgniterFunction(const QString &zuenderFunktion) override;
+  int getLoadTypeIdFromAdlerLoad(const QString &ladung) override;
+  QString adlerTargetTypeName(int targetTypeId) override;
+  QString adlerTargetSubTypeName(int targetSubTypeId) override;
+  QString adlerChargeTypeName(int chargeTypeId) override;
+  QString adlerIgniterTypeName(int igniterTypeId) override;
+  QString adlerIgniterFunctionName(int igniterFunctionId) override;
+  QString adlerLoadTypeName(int loadTypeId) override;
+
+  QString trBiteComponentTextName(int biteComponentId) override;
+  QString trCanComponentStringName(int canComponentId) override;
+  QString trChargeTypeShortName(int chargeTypeId, bool omitBaseSuffix = false) override;
+  QString trChargeTypeName(int chargeTypeId, bool omitBaseSuffix = false) override;
+  QString trFirePurposeName(int firePurposeId) override;
+  QString trGearTypeName(int gearTypeId) override;
+  QString trIgniterTypeName(int igniterTypeId) override;
+  QString trIgniterTypeShortName(int igniterTypeId) override;
+  QString trIgniterFunctionName(int igniterFunctionId) override;
+  QString trIgniterFunctionShortName(int igniterFunctionId) override;
+  QString trLoadTypeName(int loadTypeId) override;
+  QString trLoadTypeShortName(int loadTypeId) override;
+  QString trTargetTypeName(int targetTypeId) override;
+  QString trTargetSubTypeName(int targetSubTypeId) override;
+  QString trLanguageHmiName(int languageHmiId) override;
+  QString trLanguageXduName(int languageXduId) override;
+  QString trNuclearPresetName(int nucularPresetId) override; // "'Nucular'. It's pronounced 'Nucular'!"
+  QString trRadioGroupName(int radioGroupId) override;
+  QString trVulnerabilityKindName(int vulnerabilityKindId, VulnerabilityClass vulnerabilityClassId) override;
+  QString trSanitationMaterialName(int sanitationMaterialId) override;
+
+  QStringList chargeNames(std::vector<int> &chargeIds) override;
+  int getAvailableChargeTypeId(int chargeTypeId /*, bool *bOk = nullptr*/) override;
+  ChargeTypeProperty getChargeTypeSpecialProperty(int chargeTypeId, int igniterTypeId, int igniterFunctionId) override;
+  QVector<SanitationProcedure> getSanitationProcedures(qint64 procedures) override;
+  QStringList sanitationProceduresList(qint64 procedures) override;
+
+  private:
+  struct ChargeTypeIgniterTypeIgniterFunctionProps
+  {
+    int chargeTypeId = 0;
+    int igniterTypeId = 0;
+    int igniterFunctionId = 0;
+    IgniterFunctionBase igniterFunctionBase = IgniterFunctionBase::IfbImpact;
+    int chargeLegacyId = 0;
+    double expansionFactor = 0;
+    double impactRadius = 0;
+    double impactEdgeLength = 0;
+    VolatilityType volatilityTypeId = VolatilityType::Unknown;
+    int searchRadius = 0;
+    bool isSmart = false;
+    bool isDryFire = false;
+    bool isDus = false;
+    int mineClass = 0;
+    bool canBeThrown = false;
+    bool canBeCreated = true;
+    bool isIed = false;
+    bool isFromMineLayer = false;
+    bool isMineLaying = false;
+    QJsonObject mineLayingPattern;
+    bool isReactivatable = false;
+    bool isSmoke = false;
+    int maxEffectShows = 1;
+    bool isVisible = true;
+    bool isLRF = false;
+    bool isLTD = false;
+    bool isAP = false;
+    bool isAT = false;
+    bool isConcrete = false;
+    bool showHitline = true;
+    int remainingTasCode = 0;
+    int secondaryRemainingTasCode = 0;
+    int segments = 0;
+    bool isLine = false;
+    QVector<int> spacing;
+    int height = 0;
+    int hazardDistance = 0;
+    bool isLaserGuidable;
+    bool isUasDroppable;
+    bool isJamming;
+    bool isVirtuallyFireable = false;
+    QVector<CasEffect> casEffects;
+    bool isAdlerChargeType;
+    QString adlerChargeTypeName;
+    QString adlerIgniterTypeName;
+    QString adlerIgniterFunctionName;
+  };
+
+  struct ChargeTypeLoadTypeProps
+  {
+    int chargeTypeId = 0;
+    int loadTypeId = 0;
+    QString adlerLoadTypeName;
+  };
+
+  struct GearTypeProps
+  {
+    bool canRestock = false;
+    bool canSetDefaults = false;
+    int maxCharges = -1;
+    int adlerWeaponSystemId = -1;
+    int cadence = -1;
+  };
+
+  struct GearTypeChargeTypeProps
+  {
+    int factoryDefault = 0;
+    int maxCharge = 0;
+  };
+
+  QString translate(const std::function<PdmBaseName(DtcImplCustom &, qint32)> &getItem, const std::function<QString(const std::string &)> &pdmTranslate, qint32 id);
+  QString translateShortChargeType(const std::function<QString(const std::string &)> &pdmTranslate, qint32 id);
+  QString translateShortIgniterType(const std::function<QString(const std::string &)> &pdmTranslate, qint32 id);
+  QString translateShortIgniterFunction(const std::function<QString(const std::string &)> &pdmTranslate, qint32 id);
+  QString translateShortLoadType(const std::function<QString(const std::string &)> &pdmTranslate, qint32 id);
+
+  void onChargeTypeChanged(const ChargeType &ct);
+  void fillChargeTypeIgniterTypeIgniterFunctionProps();
+  void fillChargeTypeLoadTypeProps();
+  void onIgniterTypeChanged(const IgniterType &ignType);
+  void onIgniterFunctionChanged(const IgniterFunction &ignFunc);
+  void onChargeTypeIgniterTypeIgniterFunctionChanged(const ChargeTypeIgniterTypeIgniterFunction &ctitif);
+
+  ChargeTypeIgniterTypeIgniterFunctionProps chargeTypeIgniterTypeIgniterFunctionProps(int chargeTypeId, int igniterTypeId, int igniterFunctionId);
+  DtcImplCustom::ChargeTypeLoadTypeProps chargeTypeLoadTypeProps(int chargeTypeId, int loadTypeId);
+
+  QString suffix(int chargeTypeId, bool omitBaseSuffix = false);
+  static QString offsetName(UleisClassOffset o);
+
+  void onGearTypeChanged(const GearType &gt);
+  GearTypeProps gearTypeProps(int gearTypeId);
+
+  void onGearTypeChargeTypeChanged(const GearTypeChargeType &gtct);
+  GearTypeChargeTypeProps gearTypeChargeTypeProps(int gearTypeChargeTypeId);
+
+  void setProps(ChargeTypeIgniterTypeIgniterFunctionProps &props, QJsonObject obj);
+  void setProps(ChargeTypeLoadTypeProps &props, QJsonObject obj);
+
+  QJsonObject propertiesToJson(const std::string &properties);
+  void mergeProperties(QHash<int, ChargeTypeIgniterTypeIgniterFunctionProps>::iterator &it,
+                       const QJsonObject &ifProps,
+                       const QJsonObject &ctProps,
+                       const QJsonObject &ctitifProps,
+                       const QJsonObject &itProps);
+
+  private:
+  QHash<int, ChargeTypeIgniterTypeIgniterFunctionProps> m_ctItIfProps;
+  QHash<int, ChargeTypeLoadTypeProps> m_ctLtProps;
+  QHash<int, GearTypeProps> m_gtProps;
+  QHash<int, GearTypeChargeTypeProps> m_gtctProps;
+  QString indirectString(bool isIndirect) const;
+};
+} // namespace Interface
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/pdm_export.h

@@ -0,0 +1,52 @@
+/**
+  * Export definitions
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Hanna E. Rathje, SLSE, 2015-08-04
+  */
+#pragma once
+
+#include <QtCore/qglobal.h>
+
+#ifndef PDM_COMMON_EXPORT
+# ifdef BUILD_STATIC_LIBRARIES
+#  define PDM_COMMON_EXPORT
+# else
+#  if defined(MAKE_SVCPDMCOMMON_LIB)
+#   define PDM_COMMON_EXPORT Q_DECL_EXPORT
+#   ifndef WIN32
+#     ifdef NDDSUSERDllExport
+#      undef NDDSUSERDllExport
+#     endif
+#     define NDDSUSERDllExport Q_DECL_EXPORT
+#   endif
+#  else
+#   define PDM_COMMON_EXPORT Q_DECL_IMPORT
+#  endif
+# endif
+#endif
+
+#ifndef PDM_CLIENT_EXPORT
+# ifdef BUILD_STATIC_LIBRARIES
+#  define PDM_CLIENT_EXPORT
+# else
+#  if defined(MAKE_SVCPDMCLIENT_LIB)
+#   define PDM_CLIENT_EXPORT Q_DECL_EXPORT
+#  else
+#   define PDM_CLIENT_EXPORT Q_DECL_IMPORT
+#  endif
+# endif
+#endif
+
+#ifndef PDM_SERVER_EXPORT
+# ifdef BUILD_STATIC_LIBRARIES
+#  define PDM_SERVER_EXPORT
+# else
+#  if defined(MAKE_SVCPDMSERVER_LIB)
+#   define PDM_SERVER_EXPORT Q_DECL_EXPORT
+#  else
+#   define PDM_SERVER_EXPORT Q_DECL_IMPORT
+#  endif
+# endif
+#endif

Lts/Services/ProjectDataManagement/pdm_to_string.cpp

@@ -0,0 +1,132 @@
+/**
+* @RDE_HEADER@
+* Convert DSS enumerations to translatable strings
+* $Id$
+* $HeadURL$
+* $Author$
+*/
+
+
+#include "pdm_to_string.h"
+#include "pdm_translation.h"
+#include <QCoreApplication>
+
+namespace ProjectDataManagement
+{
+//
+// VulnerabilityState + VulnerabilityClass
+//
+static QString toStringBuilding(VulnerabilityState vs)
+{
+  switch (vs.underlying())
+  {
+#ifdef ETS_MODE
+  case VulnerabilityState_def::CombatReady: return QCoreApplication::translate("ProjectDataManagement", "Ready", "VulnerabilityStateBuilding");
+  case VulnerabilityState_def::CatastrophicKill: return QCoreApplication::translate("ProjectDataManagement", "Damaged", "VulnerabilityStateBuilding");
+#else
+  case VulnerabilityState_def::CombatReady: return QCoreApplication::translate("ProjectDataManagement", "Combat Ready", "VulnerabilityStateBuilding");
+  case VulnerabilityState_def::CatastrophicKill: return QCoreApplication::translate("ProjectDataManagement", "CatastrophicKill", "VulnerabilityStateBuilding");
+#endif
+  default: break;
+  }
+  return QCoreApplication::translate("ProjectDataManagement", "Unknown (%1)", "VulnerabilityState").arg(vs.underlying());
+}
+
+static QString toStringVehicle(VulnerabilityState vs)
+{
+  switch (vs.underlying())
+  {
+#ifdef ETS_MODE
+  case VulnerabilityState_def::CombatReady: return QCoreApplication::translate("ProjectDataManagement", "Ready / OK", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::LightDamage: return QCoreApplication::translate("ProjectDataManagement", "Communication Damage", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::HeavyDamage: return QCoreApplication::translate("ProjectDataManagement", "Main Function Damage", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::MobilityKill: return QCoreApplication::translate("ProjectDataManagement", "Mobility Lost", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::CatastrophicKill: return QCoreApplication::translate("ProjectDataManagement", "Fully Damaged", "VulnerabilityStateVehicle");
+  default:
+    break;
+#else
+  case VulnerabilityState_def::LightDamage: return QCoreApplication::translate("ProjectDataManagement", "Comms Damaged", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::MediumDamage: return QCoreApplication::translate("ProjectDataManagement", "Veh Body Damaged", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::HeavyDamage: return QCoreApplication::translate("ProjectDataManagement", "Main Funct Damaged", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::MobilityKill: return QCoreApplication::translate("ProjectDataManagement", "Mobility Kill", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::VisibleMobilityKill: return QCoreApplication::translate("ProjectDataManagement", "Visible Mobility Kill", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::WeaponSystemDamage: return QCoreApplication::translate("ProjectDataManagement", "Wpn / Turret Damaged", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::VisibleWeaponSystemDamage: return QCoreApplication::translate("ProjectDataManagement", "Visible Wpn / Turret Damaged", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::CatastrophicKill: return QCoreApplication::translate("ProjectDataManagement", "Catastrophic Kill", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::CombatReady:
+  case VulnerabilityState_def::NoChange:
+  case VulnerabilityState_def::TemporarySeverance:
+  case VulnerabilityState_def::NearMiss:
+  case VulnerabilityState_def::HitWithNoEffect:
+  case VulnerabilityState_def::VulnerabilityBitsChanged:
+  case VulnerabilityState_def::NContamination:
+  case VulnerabilityState_def::BContamination:
+  case VulnerabilityState_def::CContamination:
+  case VulnerabilityState_def::NotReady:  // Internal
+  case VulnerabilityState_def::Reserved:  // Internal
+    break;  // use common translation from toString()
+#endif
+  }
+  // Fallback
+  return toString(vs);
+}
+
+static QString toStringSoldier(VulnerabilityState vs)
+{
+  switch (vs.underlying())
+  {
+#ifdef ETS_MODE
+  case VulnerabilityState_def::CombatReady: return QCoreApplication::translate("ProjectDataManagement", "Ready / OK", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::LightDamage: return QCoreApplication::translate("ProjectDataManagement", "lightly injured", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::MediumDamage: return QCoreApplication::translate("ProjectDataManagement", "moderatly injured", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::HeavyDamage: return QCoreApplication::translate("ProjectDataManagement", "seriously injured", "VulnerabilityStateVehicle");
+  case VulnerabilityState_def::CatastrophicKill: return QCoreApplication::translate("ProjectDataManagement", "dead", "VulnerabilityStateVehicle");
+  default:
+    break;
+#else
+  case VulnerabilityState_def::LightDamage: return QCoreApplication::translate("ProjectDataManagement", "Wounded Walking", "VulnerabilityStateSoldier");
+  case VulnerabilityState_def::MediumDamage: return QCoreApplication::translate("ProjectDataManagement", "Wounded Sitting", "VulnerabilityStateSoldier");
+  case VulnerabilityState_def::HeavyDamage: return QCoreApplication::translate("ProjectDataManagement", "Wounded Laying", "VulnerabilityStateSoldier");
+  case VulnerabilityState_def::CatastrophicKill: return QCoreApplication::translate("ProjectDataManagement", "Catastrophic Kill / Killed", "VulnerabilityStateSoldier");
+  case VulnerabilityState_def::WeaponSystemDamage: return QCoreApplication::translate("ProjectDataManagement", "Weapon Damage", "VulnerabilityStateSoldier");
+  case VulnerabilityState_def::VisibleWeaponSystemDamage: return QCoreApplication::translate("ProjectDataManagement", "Visible Weapon Damage", "VulnerabilityStateSoldier");
+  case VulnerabilityState_def::CombatReady:
+  case VulnerabilityState_def::TemporarySeverance:
+  case VulnerabilityState_def::NearMiss:
+  case VulnerabilityState_def::HitWithNoEffect:
+  case VulnerabilityState_def::VulnerabilityBitsChanged:
+  case VulnerabilityState_def::NContamination:
+  case VulnerabilityState_def::BContamination:
+  case VulnerabilityState_def::CContamination:
+  case VulnerabilityState_def::NoChange:
+    break;  // use common translation from toString()
+  // those should not happen ...
+  case VulnerabilityState_def::MobilityKill:
+  case VulnerabilityState_def::VisibleMobilityKill:
+  case VulnerabilityState_def::NotReady:  // Internal
+  case VulnerabilityState_def::Reserved:  // Internal
+    break;
+#endif
+  }
+  return toString(vs);
+}
+
+QString toString(VulnerabilityState vs, VulnerabilityClass vc)
+{
+  switch (vc.underlying())
+  {
+  case VulnerabilityClass_def::Unknown:
+  case VulnerabilityClass_def::WtdDamages:
+  case VulnerabilityClass_def::WtdInjuries:
+    return toString(vs);
+  case VulnerabilityClass_def::BuildingDamages:
+    return toStringBuilding(vs);
+  case VulnerabilityClass_def::VehicleDamages:
+    return toStringVehicle(vs);
+  case VulnerabilityClass_def::SoldierInjuries:
+    return toStringSoldier(vs);
+  }
+  return QCoreApplication::translate("ProjectDataManagement", "Unknown (%1)", "VulnerabilityState").arg(vs.underlying());
+}
+
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/pdm_to_string.h

@@ -0,0 +1,18 @@
+/**
+* @RDE_HEADER@
+* Convert DSS enumerations to translatable strings
+* $Id$
+* $HeadURL$
+* $Author$
+*/
+
+#include <ProjectDataManagement/pdm_translation.h>
+#include <QCoreApplication>
+
+namespace ProjectDataManagement
+{
+//
+// VulnerabilityState + VulnerabilityClass
+//
+PDM_COMMON_EXPORT QString toString(VulnerabilityState vs, VulnerabilityClass vc);
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/settings.cpp

@@ -0,0 +1,42 @@
+/**
+  * Settings for ProjectDataManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "settings.h"
+
+#include <QtCore/QSettings>
+#include <nglsettings/nglsettings_settings.h>
+#include <ngltools/ngltools_filesystem.h>
+
+namespace ProjectDataManagement
+{
+class NGLSettingsClass : public NGL::Settings
+{
+public:
+  NGLSettingsClass()
+    : NGL::Settings(s_iniFile.isEmpty() ? NGL::findProjectConfigFile() : s_iniFile)
+  {}
+  static void setIniFile(const QString &fn)
+  {
+    s_iniFile = fn;
+  }
+  static QString s_iniFile;
+};
+QString NGLSettingsClass::s_iniFile;
+Q_GLOBAL_STATIC(NGLSettingsClass, s)
+
+//-----------------------------------------------------------------------------
+NGL::Settings *Settings::settings()
+{
+  return s();
+}
+//-----------------------------------------------------------------------------
+void Settings::setIniFile(const QString &ini)
+{
+  NGLSettingsClass::setIniFile(ini);
+}
+
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/settings.h

@@ -0,0 +1,25 @@
+/**
+  * Settings for ProjectDataManagement
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#pragma once
+#include <QString>
+
+namespace NGL
+{
+class Settings;
+}
+
+namespace ProjectDataManagement
+{
+namespace Settings
+{
+//!< The real NGL::Settings - object
+NGL::Settings *settings();
+void setIniFile(const QString &ini);
+}
+
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/static_data_publisher.h

@@ -0,0 +1,38 @@
+/**
+  * Handler to publish (project) static data to dds
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2017-07-20
+  */
+
+#pragma once
+
+#include "dds_handler.h"
+#include "pdm_db.h"
+#include "logger.h"
+
+namespace ProjectDataManagement
+{
+
+template <typename DB>
+bool publishData(const std::shared_ptr<DatabaseInterface> &db,
+                 const std::shared_ptr<ProjectDataManagement::Interface::Dts> &dts,
+                 NGL::INGLLogger &logger)
+{
+  const auto cb = [dts](const DB & data)
+  {
+    dts->publish(convert(data));
+  };
+
+  // read from db
+  if (!db->select(cb))
+  {
+    ERROR_LOG(logger) << "Error reading data from database!";
+    return false;
+  }
+
+  return true;
+}
+
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/static_pvsan_import.cpp

@@ -0,0 +1,657 @@
+#include "static_pvsan_import.h"
+
+#include <QFile>
+#include <QTextStream>
+#include <QDir>
+#include <QSet>
+#include <ngltools/ngltools_filesystem.h>
+#include <ngldb/dbtransaction.h>
+#include <ngldb/nsqlquery.h>
+
+namespace ProjectDataManagement {
+
+PvSanImport::PvSanImport(const std::shared_ptr<DatabaseInterface> &db,
+                         NGL::INGLLogger &logger):
+  m_version(QStringLiteral("-")),
+  m_db(db),
+  m_logger(logger)
+{
+  publishDataPvSan();
+}
+
+bool PvSanImport::publishDataPvSan()
+{
+
+  QVector<QString> procedures;
+  QVector<QString> injuries;
+  QVector<QString> material;
+  QVector<QString> kind;
+  QVector<QString> place1;
+  QVector<QString> place2;
+
+  //b->removePdmTranslation()
+  if (!readFile(procedures, material, injuries, kind, place1, place2))
+  {
+    ERROR_LOG(m_logger) << "Can't read pvsan file";
+    return false;
+  }
+
+  if(!addProcedures(procedures))
+    return false;
+
+  if(!addMaterial(material))
+    return false;
+
+  if(!addInjuryPlaces(kind, place1, place2))
+    return false;
+
+  if(!addInjuries(injuries))
+    return false;
+
+// X    X   A    A    B    B    C    C   D    D     E    E    M    M    0    0
+//0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
+//0000 0001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000
+  return true;
+}
+
+qint64 PvSanImport::getCode(const QString &type, int typeId)
+{
+  qint64 check = 1ULL;
+
+  qint64 multiplayer = 1ULL;
+
+  switch (type.at(0).unicode())
+  {
+  case 'x':
+    multiplayer = multiplayer<<(55 + typeId);
+    break;
+  case 'A':
+    multiplayer = multiplayer<<(47 + typeId);
+    break;
+  case 'B':
+    multiplayer = multiplayer<<(39+ typeId);
+    break;
+  case 'C':
+    multiplayer = multiplayer<<(31+ typeId);
+    break;
+  case 'D':
+    multiplayer = multiplayer<<(23+ typeId);
+    break;
+  case 'E':
+    multiplayer = multiplayer<<(15+ typeId);
+    break;
+  case 'M':
+    multiplayer = multiplayer<<(7+ typeId);
+    break;
+  default:
+    multiplayer = typeId;
+    break;
+
+  };
+  check = multiplayer;
+  return check;
+}
+
+bool PvSanImport::readFile(QVector<QString> &procedures, QVector<QString> &material,
+                           QVector<QString> &injuries, QVector<QString> &kind,
+                           QVector<QString> &place1, QVector<QString> &place2 )
+{
+  QString vbkFile = NGL::findFile(NGL::FileType::ConfigFile, QStringLiteral("vbk.csv"));
+  QFile csvFile(vbkFile);
+  DEBUG_LOG(m_logger) << "Start reading File " << vbkFile;
+
+  if (!csvFile.exists())
+    return false;
+  if(!csvFile.open(QIODevice::ReadOnly))
+    return false;
+  DEBUG_LOG(m_logger) << "Opened File";
+
+  bool skip = true;
+  QTextStream in(&csvFile);
+  in.setCodec("latin1");
+
+  //version
+  while (!in.atEnd())
+  {
+    QString line = in.readLine();
+    if (!line.startsWith(QStringLiteral("Version")))
+      continue;
+
+   // ERROR_LOG(m_logger) << line;
+    QStringList versionSplit = line.split(QStringLiteral(";"));
+    if (versionSplit.size() > 1)
+      m_version = versionSplit.at(1);
+    break;
+  }
+  skip = true;
+
+  //injuries
+  while (!in.atEnd())
+  {
+    QString line = in.readLine();
+    if (skip && !line.startsWith(QStringLiteral("VBA-Index")))
+      continue;
+    else if (skip)
+    {
+      //read one more line
+      line = in.readLine();
+      skip = false;
+    }
+
+    //now we read all lines until the end
+    if (!line.isEmpty())
+      injuries.append(line);
+    else
+      break;
+  }
+  skip = true;
+  in.seek(0);
+
+  //Material
+  while (!in.atEnd())
+  {
+    const QString line = in.readLine();
+    if (skip && !line.startsWith(QStringLiteral("sanmat")))
+      continue;
+    else if (skip)
+    {
+      //read one more line
+      in.readLine();
+      skip = false;
+      continue;
+    }
+    //ERROR_LOG(m_logger) << line;
+
+    //now we read all lines until the end
+    if (!line.isEmpty())
+      material.append(line);
+    else
+      break;
+  }
+  skip = true;
+  in.seek(0);
+
+  //procedures
+  while (!in.atEnd())
+  {
+    const QString line = in.readLine();
+    if (skip && !line.startsWith(QStringLiteral("massnahmen.csv")))
+      continue;
+    else if (skip)
+    {
+      //read one more line
+      in.readLine();
+      skip = false;
+      continue;
+    }
+
+    //now we read all lines until the end
+    if (!line.isEmpty())
+      procedures.append(line);
+    else
+      break;
+  }
+
+  skip = true;
+  in.seek(0);
+
+  //kind
+  while (!in.atEnd())
+  {
+    const QString line = in.readLine();
+    if (skip && !line.startsWith(QStringLiteral("verwundungstyp")))
+      continue;
+    else if (skip)
+    {
+      //read one more line
+      in.readLine();
+      skip = false;
+      continue;
+    }
+
+    //now we read all lines until the end
+    if (!line.isEmpty())
+      kind.append(line);
+    else
+      break;
+  }
+  skip = true;
+  in.seek(0);
+
+  //palce1
+  while (!in.atEnd())
+  {
+    const QString line = in.readLine();
+    if (skip && !line.startsWith(QStringLiteral("ort1")))
+      continue;
+    else if (skip)
+    {
+      //read one more line
+      in.readLine();
+      skip = false;
+      continue;
+    }
+
+    //now we read all lines until the end
+    if (!line.isEmpty())
+      place1.append(line);
+    else
+      break;
+  }
+  skip = true;
+  in.seek(0);
+
+  //place2
+  while (!in.atEnd())
+  {
+    const QString line = in.readLine();
+    if (skip && !line.startsWith(QStringLiteral("ort2")))
+      continue;
+    else if (skip)
+    {
+      //read one more line
+      in.readLine();
+      skip = false;
+      continue;
+    }
+
+    //now we read all lines until the end
+    if (!line.isEmpty())
+      place2.append(line);
+    else
+      break;
+  }
+
+  csvFile.close();
+
+//  ERROR_LOG(m_logger) << "read " << procedures.size() << " procedures from file";
+//  ERROR_LOG(m_logger) << "read " << material.size() << " materials from file";
+//  ERROR_LOG(m_logger) << "read " << injuries.size() << " injuries from file";
+//  ERROR_LOG(m_logger) << "read " << kind.size() << " kinds from file";
+//  ERROR_LOG(m_logger) << "read " << place1.size() << " place1 from file";
+//  ERROR_LOG(m_logger) << "read " << place2.size() << " place2 from file";
+
+
+  return true;
+}
+
+bool PvSanImport::addProcedures(const QVector<QString> &procedures)
+{
+  if(procedures.isEmpty())
+    return false;
+
+  //check for DatabaseEntry with ID 1 and it's version
+  Database::PdmSanitationProcedures procTemp;
+
+  if (m_db->selectPdmSanitationProcedures(1, procTemp) && procTemp.version == m_version)
+    return true;
+
+  QString myContext=QStringLiteral("SanitationProcedure");
+  //remove from DB
+  m_db->truncatePdmSanitationProcedures();
+
+  QVector<Database::PdmTranslation> translations;
+  m_db->select(translations);
+  QSet<quint64> idsToRemove;
+  for (const auto &tr : qAsConst(translations))
+  {
+    if (tr.context == myContext)
+      idsToRemove.insert(tr.id);
+  }
+
+  for (quint64 id : idsToRemove )
+  {
+    m_db->removePdmTranslation(id);
+  }
+
+  //insert into db
+  Database::PdmSanitationProcedures pros;
+  pros.id= 0;
+  pros.type = QStringLiteral("-");
+  pros.name = QStringLiteral("Keine");
+  pros.typeId = 0;
+  pros.longName = QStringLiteral("Keine");
+  pros.dataCode = 0;
+
+  m_db->insert(pros);
+
+
+  Database::PdmTranslation trans;
+  trans.key = pros.name;
+  trans.disambiguation = QStringLiteral("name");
+  trans.context = myContext;
+  trans.translation = QStringLiteral("None");
+  trans.isoCode = QStringLiteral("en_GB");
+  m_db->insert(trans);
+  trans.id = 0;
+  trans.isoCode = QStringLiteral("en_US");
+  m_db->insert(trans);
+  trans.id = 0;
+  trans.translation = pros.name;
+  trans.isoCode = QStringLiteral("de_DE");
+  m_db->insert(trans);
+
+  for (const QString &entry: procedures)
+  {
+
+   QStringList measure = entry.split(QStringLiteral(";"));
+  // ERROR_LOG(m_logger) << entry << " size of split: " << measure.size();
+   if (measure.size() < 34 )
+     continue;
+   Database::PdmSanitationProcedures pros;
+   pros.id = measure.at(0).toInt();
+   pros.name = measure.at(3);
+   pros.longName = measure.at(4);
+   pros.type = measure.at(1);
+   pros.typeId = measure.at(2).toInt();
+   pros.minimumQualification = measure.at(34).toInt()  == 0 ? 3 : measure.at(34).toInt();
+   pros.version = m_version;
+
+   pros.dataCode = getCode(pros.type, pros.typeId);
+   if(m_db->insert(pros))
+   {
+     Database::PdmTranslation trans;
+     trans.key = measure.at(3);
+     trans.disambiguation = QStringLiteral("name");
+     trans.context = myContext;
+     trans.translation = measure.at(5);
+     trans.isoCode = QStringLiteral("en_US");
+     m_db->insert(trans);
+     trans.id = 0;
+     trans.isoCode = QStringLiteral("en_GB");
+     m_db->insert(trans);
+     trans.id = 0;
+     trans.translation = measure.at(3);
+     trans.isoCode = QStringLiteral("de_DE");
+     m_db->insert(trans);
+
+     //long name:
+     trans.id = 0;
+     trans.key = measure.at(4);
+     trans.disambiguation = QStringLiteral("long_name");
+
+     trans.translation = measure.at(4);
+     trans.isoCode = QStringLiteral("de_DE");
+     m_db->insert(trans);
+     trans.id = 0;
+     trans.translation = measure.at(6);
+     trans.isoCode = QStringLiteral("en_US");
+     m_db->insert(trans);
+     trans.id = 0;
+     trans.isoCode = QStringLiteral("en_GB");
+     m_db->insert(trans);
+   }
+  }
+  return true;
+}
+
+bool PvSanImport::addMaterial(const QVector<QString> &material)
+{
+  if(material.isEmpty())
+    return false;
+  //check for DatabaseEntry with ID 1 and it's version
+  Database::PdmSanitationMaterial matTemp;
+
+  //remove from DB only if version differs
+  if (m_db->selectPdmSanitationMaterial(1, matTemp) && matTemp.version == m_version)
+    return true;
+
+  //m_db->truncatePdmSanitationMaterial();
+  DBTransaction trans(m_db->database());
+  NSqlQuery q(m_db->database());
+
+  QString stmt = QStringLiteral("DELETE FROM pdm_sanitation_material");
+
+  q.prepare(stmt);
+
+  DEBUG_LOG(m_logger) << "Statement: " << stmt;
+
+  if (!q.exec())
+  {
+    WARNING_LOG(m_logger) << "Could not delete sanitation materials";
+    return false;
+  }
+
+  trans.commit();
+
+  QString myContext = QStringLiteral("SanitationMaterial");
+  QVector<Database::PdmTranslation> translations;
+  m_db->select(translations);
+  QSet<quint64> idsToRemove;
+  for (const auto &tr : qAsConst(translations))
+  {
+    if (tr.context == myContext)
+      idsToRemove.insert(tr.id);
+  }
+
+  for (quint64 id : idsToRemove )
+  {
+    m_db->removePdmTranslation(id);
+  }
+
+  //insert into db
+  for (const QString &entry: material)
+  {
+   QStringList material = entry.split(QStringLiteral(";"));
+   if (material.size() < 3 )
+     continue;
+   Database::PdmSanitationMaterial mat;
+   mat.id = material.at(0).toInt();
+   mat.name = material.at(1);
+   mat.version = m_version;
+
+   if(m_db->insert(mat))
+   {
+     Database::PdmTranslation trans;
+     trans.key = material.at(1);
+     trans.disambiguation = QStringLiteral("name");
+     trans.context = myContext;
+     trans.translation = material.at(2);
+     trans.isoCode = QStringLiteral("en_US");
+     m_db->insert(trans);
+     trans.id = 0;
+     trans.isoCode = QStringLiteral("en_GB");
+     m_db->insert(trans);
+     trans.id = 0;
+     trans.translation = material.at(1);
+     trans.isoCode = QStringLiteral("de_DE");
+     m_db->insert(trans);
+   }
+  }
+  return true;
+}
+
+bool PvSanImport::addInjuryPlaces(const QVector<QString> &kind, const QVector<QString> &place1, const QVector<QString> &place2)
+{
+  if (kind.isEmpty() || place1.isEmpty() || place2.isEmpty())
+    return false;
+
+  //check for DatabaseEntry with ID 1 and it's version
+  Database::PdmSanitationInjuryKind kindTemp;
+
+  if (m_db->selectPdmSanitationInjuryKind(1, kindTemp) && kindTemp.version == m_version)
+    return true;
+
+  QString myContext = QStringLiteral("SanitationInjuryKind");
+  Database::PdmTranslation trans;
+
+  //remove from DB
+  m_db->truncatePdmSanitationInjuryKind();
+
+  QVector<Database::PdmTranslation> translations;
+  m_db->select(translations);
+  QSet<quint64> idsToRemove;
+  for (const auto &tr : qAsConst(translations))
+  {
+    if (tr.context == myContext)
+      idsToRemove.insert(tr.id);
+  }
+
+  for (quint64 id : idsToRemove )
+  {
+    m_db->removePdmTranslation(id);
+  }
+
+  //insert into db
+  trans.context = myContext;
+  Database::PdmSanitationInjuryKind injuryKindDb;
+  for (const QString &kd : qAsConst(kind))
+ {
+    QStringList kde = kd.split(QStringLiteral(";"));
+    if (kde.size() < 3 )
+      continue;
+    injuryKindDb.id = kde.at(0).toInt();
+    injuryKindDb.name = kde.at(1);
+    injuryKindDb.version = m_version;
+    if(m_db->insert(injuryKindDb))
+    {
+      //Add Translation
+      trans.id = 0;
+      trans.key = injuryKindDb.name;
+      trans.disambiguation = QStringLiteral("name");
+      trans.translation = kde.at(2);
+      trans.isoCode = QStringLiteral("en_US");
+      m_db->insert(trans);
+      trans.id = 0;
+      trans.isoCode = QStringLiteral("en_GB");
+      m_db->insert(trans);
+      trans.id = 0;
+      trans.translation = injuryKindDb.name;
+      trans.isoCode = QStringLiteral("de_DE");
+      m_db->insert(trans);
+    }
+ }
+  //Place1
+  //remove from DB
+  myContext = QStringLiteral("SanitationInjuryPlace1");
+  m_db->truncatePdmSanitationInjuryPlace1();
+  idsToRemove.clear();
+  for (const auto &tr : qAsConst(translations))
+  {
+    if (tr.context == myContext)
+      idsToRemove.insert(tr.id);
+  }
+
+  for (quint64 id : idsToRemove )
+  {
+    m_db->removePdmTranslation(id);
+  }
+
+  //insert into db
+  trans.context = myContext;
+  Database::PdmSanitationInjuryPlace1 placeDb;
+  for (const QString &place : qAsConst(place1))
+ {
+    QStringList pl = place.split(QStringLiteral(";"));
+    if (pl.size() < 3 )
+      continue;
+    placeDb.id = pl.at(0).toInt();
+    placeDb.name = pl.at(1);
+    placeDb.version = m_version;
+    if(m_db->insert(placeDb))
+    {
+      //Add Translation
+      trans.id = 0;
+      trans.key = placeDb.name;
+      trans.disambiguation = QStringLiteral("name");
+      trans.translation = pl.at(2);
+      trans.isoCode = QStringLiteral("en_US");
+      m_db->insert(trans);
+      trans.id = 0;
+      trans.isoCode = QStringLiteral("en_GB");
+      m_db->insert(trans);
+      trans.id = 0;
+      trans.translation = placeDb.name;
+      trans.isoCode = QStringLiteral("de_DE");
+      m_db->insert(trans);
+    }
+ }
+
+  //Place2
+  //remove from DB
+  myContext = QStringLiteral("SanitationInjuryPlace2");
+  m_db->truncatePdmSanitationInjuryPlace2();
+  idsToRemove.clear();
+  for (const auto &tr : qAsConst(translations))
+  {
+    if (tr.context == myContext)
+      idsToRemove.insert(tr.id);
+  }
+
+  for (quint64 id : idsToRemove )
+  {
+    m_db->removePdmTranslation(id);
+  }
+
+  //insert into db
+  trans.context = myContext;
+  Database::PdmSanitationInjuryPlace2 place2Db;
+  for (const QString &place : qAsConst(place2))
+ {
+    QStringList pl = place.split(QStringLiteral(";"));
+    if (pl.size() < 3 )
+      continue;
+    place2Db.id = pl.at(0).toInt();
+    place2Db.name = pl.at(1);
+    place2Db.version = m_version;
+
+    if(m_db->insert(place2Db))
+    {
+      //Add Translation
+      trans.id = 0;
+      trans.key = place2Db.name;
+      trans.disambiguation = QStringLiteral("name");
+      trans.translation = pl.at(2);
+      trans.isoCode = QStringLiteral("en_US");
+      m_db->insert(trans);
+      trans.id = 0;
+      trans.isoCode = QStringLiteral("en_GB");
+      m_db->insert(trans);
+      trans.id = 0;
+      trans.translation = place2Db.name;
+      trans.isoCode = QStringLiteral("de_DE");
+      m_db->insert(trans);
+    }
+ }
+
+  return true;
+}
+
+bool PvSanImport::addInjuries(const QVector<QString> &injuries)
+{
+
+  if(injuries.isEmpty())
+    return false;
+  //check for DatabaseEntry with ID 1 and it's version
+  QString myContext = QStringLiteral("SanitationInjury");
+  Database::PdmTranslation trans;
+
+  //remove from DB
+  m_db->truncatePdmSanitationInjury();
+
+  //insert into db
+  trans.context = myContext;
+  Database::PdmSanitationInjury injuryDb;
+  int id = 1;
+  for (const QString &injury : qAsConst(injuries))
+ {
+    QStringList kde = injury.split(QStringLiteral(";"));
+    if (kde.size() <  29 )
+      continue;
+    if (kde.at(1).toInt() < 1)
+      continue;
+    injuryDb.id = id++;
+    injuryDb.kind = kde.at(1).toInt();
+    injuryDb.place1 = kde.at(2).toInt();
+    injuryDb.place2 = kde.at(3).toInt();
+    injuryDb.vbg = kde.at(4).toInt();
+    injuryDb.name = kde.at(28) + QStringLiteral(" ") + kde.at(29);
+    m_db->insert(injuryDb);
+ }
+
+
+  return true;
+}
+
+
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/static_pvsan_import.h

@@ -0,0 +1,43 @@
+/**
+  * Handler to publish (project) static data to dds
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Ehrlicher, SLSE, 2017-07-20
+  */
+
+#pragma once
+
+#include "pdm_db.h"
+
+#include "logger.h"
+#include <string>
+#include <QString>
+
+namespace ProjectDataManagement
+{
+class PvSanImport
+{
+public:
+ PvSanImport(const std::shared_ptr<DatabaseInterface> &db,
+            NGL::INGLLogger &logger);
+private:
+qint64 getCode(const QString &type, int typeId);
+
+bool publishDataPvSan();
+
+
+bool readFile(QVector<QString> &procedures, QVector<QString> &material,
+              QVector<QString> &injuries, QVector<QString> &kind,
+              QVector<QString> &place1, QVector<QString> &place2);
+
+bool addProcedures(const QVector<QString> &procedures);
+bool addMaterial(const QVector<QString> &material);
+bool addInjuryPlaces(const QVector<QString> &kind, const QVector<QString> &place1, const QVector<QString> &place2);
+bool addInjuries(const QVector<QString> &injuries);
+
+QString m_version;
+const std::shared_ptr<DatabaseInterface> &m_db;
+NGL::INGLLogger &m_logger;
+};
+} // namespace ProjectDataManagement

Lts/Services/ProjectDataManagement/translation.cpp

@@ -0,0 +1,136 @@
+/**
+  * Load/Publish db-translations
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+
+#include "translation.h"
+#include "dds_handler.h"
+#include <QTimer>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QCryptographicHash>
+#include <LtsUtilsCore/dds_vector.h>
+
+namespace ProjectDataManagement
+{
+static const int s_translationBlobId = 1;
+
+Translation::Translation(const std::shared_ptr<DdsHandler> &dds, const std::shared_ptr<DatabaseInterface> &db)
+  : Interface::Fts::InsertUpdateTranslationRequestHandler(dds->fts())
+  , m_dds(dds)
+  , m_db(db)
+  , m_logger(getLogger("Translation"))
+{
+  DEBUG_LOG(m_logger) << "Translation ctor";
+  m_publishTimer.setInterval(1000);
+  m_publishTimer.setSingleShot(true);
+  m_publishTimer.setTimerType(Qt::VeryCoarseTimer);
+  connect(&m_publishTimer, &QTimer::timeout, this, &Translation::publishData);
+
+  QTimer::singleShot(1000, this, &Translation::collectAndPublishData);
+}
+
+Translation::~Translation()
+{
+  m_dds->dts()->removeTranslationBlobByKey(s_translationBlobId);
+}
+
+void Translation::collectAndPublishData()
+{
+  DEBUG_LOG(m_logger) << "Collecting translation data";
+  m_jsonData.clear();
+  const auto cb = [this](const Database::PdmTranslation &data)
+  {
+    this->addToJson(data);
+  };
+
+  if (!m_db->select(cb))
+  {
+    WARNING_LOG(m_logger) << "Error fetching translations from db";
+    return;
+  }
+
+  publishData();
+
+  DEBUG_LOG(m_logger) << "Collecting translation data - finished";
+}
+
+void Translation::publishData()
+{
+  QJsonArray arr;
+  for (const QJsonObject &obj : qAsConst(m_jsonData))
+    arr += obj;
+
+  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();
+
+  INFO_LOG(m_logger) << "Created translation blob with " << arr.size() << " elements, size: " << compressed.size()
+                     << " (uncompressed: " << data.size() << "), md5Sum: " << md5Sum;
+  m_dds->dts()->publish(ProjectDataManagement::TranslationBlob(s_translationBlobId,
+                                                               LtsUtils::convert<std::vector<uint8_t>>(compressed),
+                                                               md5Sum.data()));
+}
+
+static inline QJsonObject toJsonObject(const Database::PdmTranslation &data)
+{
+  return QJsonObject({{QStringLiteral("isoCode"), data.isoCode},
+                      {QStringLiteral("context"), data.context},
+                      {QStringLiteral("key"), data.key},
+                      {QStringLiteral("disambiguation"), data.disambiguation},
+                      {QStringLiteral("translation"), data.translation}
+                     });
+}
+
+void Translation::addToJson(const Database::PdmTranslation &data)
+{
+  m_jsonData[data.id] = toJsonObject(data);
+}
+
+void Translation::onInsertUpdateTranslationRequest(const rti::core::SampleIdentity &cookie,
+                                                   const InsertUpdateTranslationRequest &request)
+{
+  Database::PdmTranslation te;
+  te.isoCode = QString::fromStdString(request.isoCode());
+  te.context = QString::fromStdString(request.ctx());
+  te.key = QString::fromStdString(request.key());
+  te.disambiguation = QString::fromStdString(request.disambiguation());
+  te.translation = QString::fromStdString(request.translation());
+
+  // not fast but also not really needed ...
+  te.id = -1;
+  auto end = m_jsonData.end();
+  for (auto it = m_jsonData.begin(); it != end; ++it)
+  {
+    const QJsonObject &obj = it.value();
+    if (obj.value(QStringLiteral("isoCode")).toString() == te.isoCode &&
+        obj.value(QStringLiteral("context")).toString() == te.context &&
+        obj.value(QStringLiteral("key")).toString() == te.key &&
+        obj.value(QStringLiteral("disambiguation")).toString() == te.disambiguation)
+    {
+      te.id = it.key();
+      break;
+    }
+  }
+
+  const bool bRet = (te.id > 0) ? m_db->insert(te) : m_db->update(te);
+  Core::FunctionReplyObject fro(te.id);
+  if (bRet)
+  {
+    addToJson(te);
+    m_publishTimer.start();
+  }
+  else
+  {
+    fro = Core::FunctionReplyObject(te.id, tr_lts("dds", "Can not insert/update translation element"));
+    WARNING_LOG(m_logger) << fro();
+  }
+  m_dds->fts()->insertUpdateTranslationReply(cookie, fro);
+}
+
+
+}

Lts/Services/ProjectDataManagement/translation.h

@@ -0,0 +1,43 @@
+/**
+  * Load/Publish db-translations
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  */
+#pragma once
+
+#include <ProjectDataManagement/pdm_db.h>
+#include <ProjectDataManagement/pdm_dts.h>
+#include <ProjectDataManagement/pdm_fts.h>
+
+#include <QObject>
+#include <QJsonObject>
+#include <QTimer>
+#include "logger.h"
+
+namespace ProjectDataManagement
+{
+class DdsHandler;
+class Translation : public QObject,
+    protected Interface::Fts::InsertUpdateTranslationRequestHandler
+{
+public:
+  Translation(const std::shared_ptr<DdsHandler> &dds,
+              const std::shared_ptr<ProjectDataManagement::DatabaseInterface> &db);
+  ~Translation();
+
+protected Q_SLOTS:
+  void collectAndPublishData();
+  void publishData();
+private:
+  void addToJson(const Database::PdmTranslation &data);
+  void onInsertUpdateTranslationRequest(const rti::core::SampleIdentity &cookie,
+                                        const InsertUpdateTranslationRequest &request) override;
+private:
+  QHash<int, QJsonObject> m_jsonData;
+  std::shared_ptr<DdsHandler> m_dds;
+  std::shared_ptr<ProjectDataManagement::DatabaseInterface> m_db;
+  QTimer m_publishTimer;
+  NGL::INGLLogger &m_logger;
+};
+}