Initial commit

Lts/Plugins/AlarmManagement/Gui/ConfigAlarm/alm_dialog.cpp

@@ -0,0 +1,317 @@
+/**
+  * @RDE_HEADER@
+  * Beschreibung des Dialogs
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Mike Wille, SLSE, 2017-11-01
+  */
+
+#include "alm_dialog.h"
+#include "ui_alm_dialog.h"
+#include "alm_history.h"
+#include <Plugins/AlarmManagement/Gui/Common/alm_config_alarm_model.h>
+#include <Plugins/AlarmManagement/Gui/Common/alm_history_alarm_model.h>
+
+#include <LtsSession/lts_session_data.h>
+#include <LtsWidgets/lts_dialog.h>
+#include <ProjectDataManagement/pdm_enums.hpp>
+#include <LtsUtilsSettings/settings.h>
+
+namespace AlarmManagement
+{
+
+AlarmDialog::AlarmDialog(QWidget *parent)
+  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
+  , m_configAlarmModel(nullptr)
+  , m_dtc(nullptr)
+  , m_ftc(nullptr)
+  , m_ui(new Ui::AlarmDialog)
+  , m_requestHelper(new LtsUtils::RequestHelper(this))
+  , m_operatorId(-1)
+  , m_logger(getLogger("AlarmDialog"))
+{
+  AlarmCheckBox alarmCheckBox;
+  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
+
+  const bool enableNuclearContaminations = ps->value(QLatin1String("aes"),
+                                        QLatin1String("enableNuclearContaminations")).toBool();
+  const bool enableDangerAreas = ps->value(QLatin1String("aes"),
+                                        QLatin1String("enableDangerAreas")).toBool();
+  const bool enableMineAreas = ps->value(QLatin1String("aes"),
+                                        QLatin1String("enableMineAreas")).toBool();
+
+  m_ui->setupUi(this);
+
+  if (!enableNuclearContaminations)
+  {
+    m_ui->lblNAgentEntry->hide();
+    m_ui->cbxNMarker->hide();
+    m_ui->cbxNMessage->hide();
+  }
+
+  if (!enableDangerAreas)
+  {
+    m_ui->lblDangerAreaEntry->hide();
+    m_ui->cbxDanerAreaMarker->hide();
+    m_ui->cbxDangerAreaMessage->hide();
+  }
+  if (!enableMineAreas)
+  {
+    m_ui->lblMineAreaEntry->hide();
+    m_ui->cbxMineAreaEntryMarker->hide();
+    m_ui->cbxMineAreaEntryMessage->hide();
+    m_ui->lblMineAreaHit->hide();
+    m_ui->cbxMineAreaHitMarker->hide();
+    m_ui->cbxMineAreaHitMessage->hide();
+  }
+
+  alarmCheckBox.name = QLatin1String("NuclearAgentEntry");
+  alarmCheckBox.checkboxMarker = m_ui->cbxNMarker;
+  alarmCheckBox.checkboxWindow = m_ui->cbxNMessage;
+  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::EnterNuclear;
+  m_checkBoxes.append(alarmCheckBox);
+
+  alarmCheckBox.name = QLatin1String("DangerAreasEntry");
+  alarmCheckBox.checkboxMarker = m_ui->cbxDanerAreaMarker;
+  alarmCheckBox.checkboxWindow = m_ui->cbxDangerAreaMessage;
+  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::EnterDangerArea;
+  m_checkBoxes.append(alarmCheckBox);
+
+  alarmCheckBox.name = QLatin1String("MineAreaEntry");
+  alarmCheckBox.checkboxMarker = m_ui->cbxMineAreaEntryMarker;
+  alarmCheckBox.checkboxWindow = m_ui->cbxMineAreaEntryMessage;
+  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::EnterMineArea;
+  m_checkBoxes.append(alarmCheckBox);
+
+  alarmCheckBox.name = QLatin1String("MineAreaHit");
+  alarmCheckBox.checkboxMarker = m_ui->cbxMineAreaHitMarker;
+  alarmCheckBox.checkboxWindow = m_ui->cbxMineAreaHitMessage;
+  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::HitMine;
+  m_checkBoxes.append(alarmCheckBox);
+
+  alarmCheckBox.name = QLatin1String("DirectFire");
+  alarmCheckBox.checkboxMarker = m_ui->cbxDirectFireMarker;
+  alarmCheckBox.checkboxWindow = m_ui->cbxDirectFireMessage;
+  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::Hit;
+  m_checkBoxes.append(alarmCheckBox);
+
+  alarmCheckBox.name = QLatin1String("IndirectFire");
+  alarmCheckBox.checkboxMarker = m_ui->cbxIndirectFireMarker;
+  alarmCheckBox.checkboxWindow = m_ui->cbxIndirectFireMessage;
+  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::HitEffectSimulation;
+  m_checkBoxes.append(alarmCheckBox);
+
+  alarmCheckBox.name = QLatin1String("CrossLocalBorderlines");
+  alarmCheckBox.checkboxMarker = m_ui->cbxLocalBorderMarker;
+  alarmCheckBox.checkboxWindow = m_ui->cbxLocalBorderMessage;
+  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::CrossLocalBorderline;
+  m_checkBoxes.append(alarmCheckBox);
+
+  alarmCheckBox.name = QLatin1String("CrossGlobalBorderlines");
+  alarmCheckBox.checkboxMarker = m_ui->cbxGlobalBorderMarker;
+  alarmCheckBox.checkboxWindow = m_ui->cbxGlobalBorderMessage;
+  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::CrossGlobalBorderline;
+  m_checkBoxes.append(alarmCheckBox);
+
+  alarmCheckBox.name = QLatin1String("AirSupport");
+  alarmCheckBox.checkboxMarker = m_ui->cbxAirSupportMarker;
+  alarmCheckBox.checkboxWindow = m_ui->cbxAirSupportMessage;
+  alarmCheckBox.eventTypeId = ProjectDataManagement::EventType::AirSupport;
+  m_checkBoxes.append(alarmCheckBox);
+
+  setOnlineHelpFilename(QLatin1String("Situation-Configure_Global_Alarms"));
+}
+
+AlarmDialog::~AlarmDialog()
+{
+  delete m_ui;
+}
+
+bool AlarmDialog::init(const std::shared_ptr<AlarmManagement::Interface::Ftc> &ftc,
+                       const std::shared_ptr<AlarmManagement::Interface::Dtc> &dtc,
+                       const std::shared_ptr<ParticipantManagement::Interface::Dtc> &ppmDtc,
+                       AlarmHistoryModel *alarmHistoryModel)
+{
+  if (!ftc)
+    return false;
+  if (!dtc)
+    return false;
+  if (!ppmDtc)
+    return false;
+
+  m_operatorId = LtsSessionData::LtsSessionData::getInstance()->getOperatorId();
+
+  m_ftc = ftc;
+  m_dtc = dtc;
+
+  connect(m_dtc.get(), &AlarmManagement::Interface::Dtc::alarmConfigChanged,
+          this, &AlarmDialog::onAlarmConfigChanged);
+  m_dtc->enableAlarmConfig();
+
+  auto cbConfig = [this](const AlarmManagement::AlarmConfig & c)
+  {
+    onAlarmConfigChanged(c, DataModification::eAdded);
+  };
+  m_dtc->alarmConfigs(cbConfig);
+
+  delete m_configAlarmModel;
+  m_configAlarmModel = new AlarmManagement::ConfigAlarmModel(this);
+  bool global = true;
+  m_configAlarmModel->initModel(m_dtc, ppmDtc, alarmHistoryModel, global);
+
+  INFO_LOG(m_logger) << "AlarmDialog::init";
+  return true;
+}
+
+void AlarmDialog::retranslate()
+{
+  translate(m_ui, tr("Configure Global Alarms"));
+}
+
+void AlarmDialog::onAlarmConfigChanged(const AlarmManagement::AlarmConfig &data, DataModification modType)
+{
+  bool setMarker = data.setMarker();
+  bool messageWindow = data.messageWindow();
+  if (modType == DataModification::eRemoved)
+    return;
+
+  DEBUG_LOG(m_logger) << "************** onAlarmConfigChanged "
+                      << " id=" << data.id()
+                      << " operatorId=" << data.operatorId()
+                      << " m_operatorId=" << m_operatorId
+                      << " participantId=" << data.participantId()
+                      << " eventTypeId=" << data.eventTypeId()
+                      << " messageWindow=" << messageWindow
+                      << " setMarker=" << setMarker;
+  if (data.global() == false)
+    return;
+
+  if (data.operatorId() == m_operatorId)
+  {
+    DEBUG_LOG(m_logger) << "************** onAlarmConfig zuweisen ";
+    switch (data.eventTypeId().underlying())
+    {
+    case ProjectDataManagement::EventType_def::EnterNuclear:
+    {
+      DEBUG_LOG(m_logger) << "EnterNuclear zuweisen ";
+      m_ui->cbxNMarker->setChecked(setMarker);
+      m_ui->cbxNMessage->setChecked(messageWindow);
+      break;
+    }
+    case ProjectDataManagement::EventType_def::EnterDangerArea:
+    {
+      DEBUG_LOG(m_logger) << "EnterDangerArea zuweisen ";
+      m_ui->cbxDanerAreaMarker->setChecked(setMarker);
+      m_ui->cbxDangerAreaMessage->setChecked(messageWindow);
+      break;
+    }
+    case ProjectDataManagement::EventType_def::EnterMineArea:
+    {
+      DEBUG_LOG(m_logger) << "EnterMineArea zuweisen ";
+      m_ui->cbxMineAreaEntryMarker->setChecked(setMarker);
+      m_ui->cbxMineAreaEntryMessage->setChecked(messageWindow);
+      break;
+    }
+    case ProjectDataManagement::EventType_def::HitMine:
+    {
+      DEBUG_LOG(m_logger) << "HitMine zuweisen ";
+      m_ui->cbxMineAreaHitMarker->setChecked(setMarker);
+      m_ui->cbxMineAreaHitMessage->setChecked(messageWindow);
+      break;
+    }
+
+    case ProjectDataManagement::EventType_def::Hit:
+    {
+      DEBUG_LOG(m_logger) << "Hit zuweisen ";
+      m_ui->cbxDirectFireMarker->setChecked(setMarker);
+      m_ui->cbxDirectFireMessage->setChecked(messageWindow);
+      break;
+    }
+    case ProjectDataManagement::EventType_def::HitEffectSimulation:
+    {
+      DEBUG_LOG(m_logger) << "HitEffectSimulation zuweisen ";
+      m_ui->cbxIndirectFireMarker->setChecked(setMarker);
+      m_ui->cbxIndirectFireMessage->setChecked(messageWindow);
+      break;
+    }
+
+    case ProjectDataManagement::EventType_def::CrossLocalBorderline:
+    {
+      DEBUG_LOG(m_logger) << "CrossLocalBorderline zuweisen ";
+      m_ui->cbxLocalBorderMarker->setChecked(setMarker);
+      m_ui->cbxLocalBorderMessage->setChecked(messageWindow);
+      break;
+    }
+    case ProjectDataManagement::EventType_def::CrossGlobalBorderline:
+    {
+      DEBUG_LOG(m_logger) << "CrossGlobalBorderline zuweisen ";
+      m_ui->cbxGlobalBorderMarker->setChecked(setMarker);
+      m_ui->cbxGlobalBorderMessage->setChecked(messageWindow);
+      break;
+    }
+    case ProjectDataManagement::EventType_def::AirSupport:
+    {
+      DEBUG_LOG(m_logger) << "AirSupport zuweisen ";
+      m_ui->cbxAirSupportMarker->setChecked(setMarker);
+      m_ui->cbxAirSupportMessage->setChecked(messageWindow);
+      break;
+    }
+    default:
+      ERROR_LOG(m_logger) << "Not possible to set with Operator App!!!";
+      break;
+    }
+  }
+
+} // end of onOperatorChanged
+
+
+std::vector<AlarmManagement::AlarmAction> AlarmDialog::getCheckedValues() const
+{
+  AlarmManagement::AlarmAction alarmActionDds;
+  std::vector<AlarmManagement::AlarmAction> ret;
+  ret.clear();
+  ret.reserve(m_checkBoxes.size());
+  for (const AlarmCheckBox &item : qAsConst(m_checkBoxes))
+  {
+    alarmActionDds.eventTypeId(item.eventTypeId);
+    if (item.checkboxMarker->isChecked())
+    {
+      alarmActionDds.setMarker(true);
+      DEBUG_LOG(m_logger) << item.name << " setMarker = true";
+    }
+    else
+    {
+      alarmActionDds.setMarker(false);
+      DEBUG_LOG(m_logger) << item.name << " setMarker = false";
+    }
+    if (item.checkboxWindow->isChecked())
+    {
+      alarmActionDds.messageWindow(true);
+      DEBUG_LOG(m_logger) << item.name << " messageWindow = true";
+    }
+    else
+    {
+      alarmActionDds.messageWindow(false);
+      DEBUG_LOG(m_logger) << item.name << " messageWindow = false";
+    }
+    if (alarmActionDds.setMarker() || alarmActionDds.messageWindow())
+      ret.push_back(alarmActionDds);
+  }
+  return ret;
+}
+
+bool AlarmDialog::apply()
+{
+  std::vector<int32_t> participantIds;
+  participantIds.push_back(0); // Global Event
+  bool globalEvent = true;
+  bool remove = false;
+  const ConfigureAlarmsRequest req(getCheckedValues(), m_operatorId, participantIds, globalEvent, remove);
+
+  return m_requestHelper->startSingleRequest([req, this]()
+  {
+    return m_ftc->configureAlarmsRequest(req, this);
+  });
+} // end of apply
+} // namespace AlarmManagement