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

/**
  * @RDE_HEADER@
  * ExerciseManangement - Exercise Phase Edit Dialog
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Philipp Dassow, SLS1, 2017-04-12
  */

#include "exm_edit_phase_dialog.h"
#include "ui_exm_edit_phase_dialog.h"
#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
#include <Plugins/FileManagement/flm_data_plugin_interface.h>
#include <LtsSession/lts_session_data.h>

namespace ExerciseManagement
{
ExerciseManagementPhaseEditDialog::ExerciseManagementPhaseEditDialog(QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
  , m_ui(new Ui::ExerciseManagementPhaseEditDialog)
  , m_requestHelper(new LtsUtils::RequestHelper(this))
  , m_logger(getLogger("ExerciseManangementPhaseEditDialog"))
{
  m_ui->setupUi(this);

  m_uiRequirements->addRequirement( { m_ui->lblName,        [this]() { return (!m_ui->leName->text().isEmpty()); } } );
  m_uiRequirements->addRequirement( { m_ui->lblStart,       [this]() { return (!m_ui->dtStart->isEmpty()); } } );
  m_uiRequirements->addRequirement( { m_ui->lblEnd,         [this]() { return (!m_ui->dtEnd->isEmpty()); } } );
}

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

bool ExerciseManagementPhaseEditDialog::init(LtsSession::LtsSessionDataDds *session,
                                             const int exerciseId,
                                             const int phaseId)
{
  m_session = session;
  m_exerciseId = exerciseId;
  m_exercisePhaseId = phaseId;
  if (!m_session->getDtc<ExerciseManagement::DataInterface>(m_dtc))
    return false;
  if (!m_session->getFtc<ExerciseManagement::DataInterface>(m_ftc))
    return false;
  if (!m_session->getDtc<FileManagement::DataInterface>(m_flmDtc))
    return false;
  if (!m_session->getFtc<FileManagement::DataInterface>(m_flmFtc))
    return false;

  ExerciseManagement::ExercisePhase data = m_dtc->exercisePhase(phaseId);

  m_ui->leName->setText(QString::fromUtf8(data.name().c_str()));
  m_ui->pteDescription->setPlainText(QString::fromStdString(data.description()));
  m_ui->dtStart->setMsecsSinceEpoch(data.beginTime());
  m_ui->dtEnd->setMsecsSinceEpoch(data.endTime());
  m_ui->dtStart->setRetrieveCurrentTimeCallback([this]() { return m_session->partitionTime(); });
  m_ui->dtEnd->setRetrieveCurrentTimeCallback([this]() { return m_session->partitionTime(); });

  // new phase for exerciseId
  if (m_exercisePhaseId <= 0)
  {
    m_ui->dtStart->setMsecsSinceEpoch(m_dtc->exercise(exerciseId).beginTime());
    m_ui->dtEnd->setMsecsSinceEpoch(m_dtc->exercise(exerciseId).endTime());
  }

  setOnlineHelpFilename(QStringLiteral("Situation-Exercise_Phases"));

  return true;
}

void ExerciseManagementPhaseEditDialog::retranslate()
{
  translate(m_ui,
            m_dtc->exercisePhase(m_exercisePhaseId),
            tr("Phase"));
}

bool ExerciseManagementPhaseEditDialog::apply()
{
  if (m_exercisePhaseId > 0)
  {
    m_requestHelper->addRequest([this]()
    {
      // Update Data of Existing Phase
      std::string name  = m_ui->leName->text().toStdString();
      std::string description  = m_ui->pteDescription->toPlainText().toStdString();
      qint64      start = m_ui->dtStart->msecsSinceEpoch();
      qint64      end   = m_ui->dtEnd->msecsSinceEpoch();

      ExercisePhaseModifyRequest req;
      req.name(name);
      req.description(description);
      req.beginTime(start);
      req.endTime(end);
      req.exerciseId(m_exerciseId);
      req.id(m_exercisePhaseId);
      m_ftc->enableExercisePhaseModify();
      return m_ftc->exercisePhaseModifyRequest(req, this);
    });
  }
  else
  {
    // Add New Phase
    m_requestHelper->startSingleRequest([this]()
    {
      std::string name  = m_ui->leName->text().toStdString();
      std::string description  = m_ui->pteDescription->toPlainText().toStdString();
      qint64      start = m_ui->dtStart->msecsSinceEpoch();
      qint64      end   = m_ui->dtEnd->msecsSinceEpoch();

      m_ftc->enableExercisePhaseCreate();
      return m_ftc->exercisePhaseCreateRequest(ExercisePhaseCreateRequest(name, description, start, end, m_exerciseId), this);
    });

    int phaseId = m_requestHelper->getRepliedId();
    if (phaseId > 0)
    {
      const QString folderName = QStringLiteral("Phase Documents");
      int exeFolderId = m_flmDtc->getExerciseFolderId(m_exerciseId);
      int folderPhaseDocsId = m_flmDtc->findFolder(exeFolderId, folderName);

      FileManagement::FolderModifyRequest req;
      req.name(m_flmDtc->getPhaseFolderName(phaseId).toStdString());
      req.isEditable(false);
      req.isHidden(false);
      req.parentId(folderPhaseDocsId);
      req.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());

      m_requestHelper->startSingleRequest([this, req]()
      {
        return m_flmFtc->folderModifyRequest(req, this);
      });
    }

    // TODO: check if something has changed (constraints manager / ui requirements should also check for changes)
  }

  // do nothing on failure - rh's message is enough
  return m_requestHelper->startRequests(); // return success or failure
}

} // namespace ExerciseManagement