qt5-legatus-legacy/Lts/Plugins/ExerciseManagement/Gui/ExerciseEdit/exm_state_edit.cpp

/**
  * @RDE_HEADER@
  * ExerciseManangement - State Edit Dialog
  * $Id: exm_edit_dialog.h 41137 2018-04-20 08:50:55Z schroeder_m $
  * $HeadURL: svn://slssvn/TDS/branches/product/devel/trunk/Lts/Plugins/ExerciseManagement/Gui/ExerciseEdit/exm_edit_dialog.h $
  * $Author: schroeder_m $
  * Created by Malte Schröder, SLSE, 2018-04-20
  */

#include "exm_state_edit.h"
#include "ui_exm_state_edit.h"

#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
#include <LtsWidgets/lts_message_dialog.h>
#include <LtsUtilsSettings/settings.h>

namespace ExerciseManagement
{
ExerciseManagementStateEdit::ExerciseManagementStateEdit(const QString &menuGroup, QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
  , m_ui(new Ui::ExerciseManagementStateEdit)
  , m_dtc(nullptr)
  , m_ftc(nullptr)
  , m_session(nullptr)
  , m_menuGroup(menuGroup)
  , m_exercise()
  , m_currentState(ExerciseState::Unknown)
  , m_requestHelper(new LtsUtils::RequestHelper(this))
  , m_logger(getLogger("ExerciseManagementStateEdit"))
{
  m_ui->setupUi(this);

  m_ui->cbState->setMinimumWidth(150);
  m_ui->cbActivePhase->setMinimumWidth(150);

  m_uiRequirements->addRequirement( { m_ui->lblState,        [this]() { return (m_ui->cbState->currentData().isValid()); } } );
  m_uiRequirements->addRequirement( { m_ui->lblActivePhase,  [this]() { return (m_ui->cbActivePhase->currentData().isValid()); } } );

  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
  const bool enableEditPhases = ps->value(QStringLiteral("exm"),
                                          QStringLiteral("enableEditPhases")).toBool();
  m_ui->lblActivePhase->setVisible(enableEditPhases);
  m_ui->cbActivePhase->setVisible(enableEditPhases);

  setOnlineHelpFilename(QStringLiteral("Situation-Exercise_State"));
}

ExerciseManagementStateEdit::~ExerciseManagementStateEdit()
{
  delete m_ui;
}

bool ExerciseManagementStateEdit::init(LtsSession::LtsSessionDataDds *session)
{
  m_session = session;

  if (!m_session->getDtc<ExerciseManagement::DataInterface>(m_dtc))
    return false;
  if (!m_session->getFtc<ExerciseManagement::DataInterface>(m_ftc))
    return false;

  m_exercise = m_dtc->exercise(m_session->exerciseId());
  m_currentState = m_exercise.state();

  // combobox fill
  fillStateCbx();
  fillActivePhaseCbx();

  // state cbx
  m_ui->cbState->setEnabled(m_ui->cbState->count() > 1);

  if (m_currentState == ExerciseState::Stopped || m_currentState == ExerciseState::Terminated)
  {
    m_ui->cbActivePhase->setEnabled(false);
  }

  // active phase cbx
  connect(m_dtc.get(), &Interface::Dtc::exercisePhaseChanged, this, &ExerciseManagementStateEdit::onExercisePhaseChanged);
  m_ui->cbActivePhase->setCurrentIndex(m_ui->cbActivePhase->findData(QVariant(m_exercise.activePhaseId())));

  return true;
}

void ExerciseManagementStateEdit::fillStateCbx()
{
  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
  const bool enableExerciseTerminatedToStopped = ps->value(QStringLiteral("exm"),
                                          QStringLiteral("enableExerciseTerminatedToStopped")).toBool();


  // exercise states
  m_ui->cbState->clear();
  switch (m_currentState.underlying())
  {
  case ExerciseState::Created:
    m_ui->cbState->addItem(tr("Created"), ExerciseState::Created);
    m_ui->cbState->addItem(tr("Start"), ExerciseState::Started);
    break;
  case ExerciseState::Started:
    m_ui->cbState->addItem(tr("Started"), ExerciseState::Started);
    m_ui->cbState->addItem(tr("Pause"), ExerciseState::Paused);
    m_ui->cbState->addItem(tr("Stop"), ExerciseState::Stopped);
    break;
  case ExerciseState::Paused:
    m_ui->cbState->addItem(tr("Paused"), ExerciseState::Paused);
    m_ui->cbState->addItem(tr("Resume"), ExerciseState::Started);
    m_ui->cbState->addItem(tr("Stop"), ExerciseState::Stopped);
    break;
  case ExerciseState::Stopped:
    m_ui->cbState->addItem(tr("Stopped"), ExerciseState::Stopped);
    break;
  case ExerciseState::Terminated:
    m_ui->cbState->addItem(tr("Terminated"), ExerciseState::Terminated);
    if (enableExerciseTerminatedToStopped)
      m_ui->cbState->addItem(tr("Stopped"), ExerciseState::Stopped);
    break;
  case ExerciseState::Unknown:
    m_ui->cbState->addItem(tr("Unknown"), ExerciseState::Unknown);
    break;
  }
}

void ExerciseManagementStateEdit::fillActivePhaseCbx()
{
  // active phase
  int curIdxActPh = m_ui->cbActivePhase->currentIndex();
  m_ui->cbActivePhase->clear();

  auto cb = [this](const ExerciseManagement::ExercisePhase &phase)
  {
    if (m_exercise.id() == phase.exerciseId())
      m_ui->cbActivePhase->addItem(QString::fromStdString(phase.name()), QVariant(phase.id()));
  };
  m_dtc->exercisePhases(cb);
  m_ui->cbActivePhase->setEnabled(m_ui->cbActivePhase->count() > 1);

  if (curIdxActPh >= 0)
    m_ui->cbActivePhase->setCurrentIndex(curIdxActPh);
}

void ExerciseManagementStateEdit::onExercisePhaseChanged(const ExerciseManagement::ExercisePhase &data, DataModification modType)
{
  Q_UNUSED(modType)
  if (data.exerciseId() == m_exercise.id())
    fillActivePhaseCbx();
}

void ExerciseManagementStateEdit::retranslate()
{
  translate(m_ui, m_exercise, tr("Exercise State"));
}

bool ExerciseManagementStateEdit::apply()
{
  ExerciseState exState = static_cast<ExerciseState::type>(m_ui->cbState->currentData().toInt());
  if (exState.underlying() == ExerciseState_def::Stopped &&
      LtsWidgets::LtsMessageDialog::showMessage(this,
                                                tr("Are you sure you want to stop the exercise?"),
                                                tr("Stop Exercise"),
                                                LtsWidgets::Behaviour::Modal,
                                                LtsWidgets::Button::Yes | LtsWidgets::Button::No)
      == LtsWidgets::Button::No)
  {
    m_ui->cbState->setCurrentIndex(m_ui->cbState->findData(m_currentState.underlying()));
    return true;
  }

  if (m_exercise.id() > 0)
  {
    ExerciseModifyRequest request;
    // Update Data of Existing Exercise
    request.id(m_exercise.id());
    request.beginTime(m_exercise.beginTime());
    request.endTime(m_exercise.endTime());
    request.startTime(m_exercise.startTime());
    request.stopTime(m_exercise.stopTime());
    request.name(m_exercise.name());
    request.sendToWMS(m_exercise.sendToWMS());
    request.linkedExerciseId(m_exercise.linkedExerciseId());
    request.trainingAreaId(m_exercise.trainingAreaId());
    request.radioGroupId(m_exercise.radioGroupId());
    request.symbolFillTypeId(m_exercise.symbolFillTypeId());
    request.activePhaseId(m_ui->cbActivePhase->currentData().toInt());
    request.defaultTimeZone(m_exercise.defaultTimeZone());
    request.forces(m_exercise.forces());
    request.description(m_exercise.description());
    request.newState(static_cast<ExerciseState::type>(m_ui->cbState->currentData().toInt()));

    if(!m_requestHelper->startSingleRequest(
         [this, request]() {
         m_ftc->enableExerciseModify();
         return m_ftc->exerciseModifyRequest(request, this); })
       )
      return false;
  }

  init(m_session);
  return true;
}
}