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

/**
* @RDE_HEADER@
* ExerciseManagement - Exercise Edit Party Dialog
* $Id$
* $HeadURL$
* $Author$
* Created by Christian Ehrlicher, SLSE, 2016-02-29
*/

#include "exm_edit_party_dialog.h"
#include "ui_exm_edit_party_dialog.h"

#include <LtsWidgets/lts_frameless_dialog.h>
#include <LtsWidgets/lts_message_dialog.h>
#include <LtsSession/lts_session.h>

#include <Plugins/ParticipantManagement/Data/ppm_data_plugin.h>
#include <Plugins/ExerciseManagement/Data/exm_data_plugin.h>

#include <QListWidget>
#include <QMenu>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>

namespace ExerciseManagement
{
ExerciseEditPartyDialog::ExerciseEditPartyDialog(const int operatorId,
                                                 const int exerciseId,
                                                 const QString &menuGroup,
                                                 QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
  , m_operatorId(operatorId)
  , m_exerciseId(exerciseId)
  , m_visiblePartiesChanged(false)
  , m_adlerVisiblePartiesChanged(false)
  , m_menuGroup(menuGroup)
  , m_visiblePartiesModel(nullptr)
  , m_adlerVisiblePartiesModel(nullptr)
  , m_opmDtc(nullptr)
  , m_opmFtc(nullptr)
  , m_ui(new Ui::ExerciseEditPartyDialog)
  , m_logger(getLogger("exerciseEditPartyDialog"))
  , m_requestHelper(new LtsUtils::RequestHelper(this))
{
  setNoTopicLock();
  m_ui->setupUi(this);
  setOnlineHelpFilename(QStringLiteral("Administrator-Operator-Parties"));
}

bool ExerciseEditPartyDialog::init(LtsSession::LtsSessionDataDds *session)
{
  if (!session->getDtc<OperatorManagement::DataInterface>(m_opmDtc))
    return false;
  if (!session->getFtc<OperatorManagement::DataInterface>(m_opmFtc))
    return false;

  m_visiblePartiesModel = new ExerciseEditVisiblePartiesModel(m_operatorId, m_exerciseId, this);
  if (!m_visiblePartiesModel->init(session))
    return false;

  m_ui->tvVisibleParties->setModel(m_visiblePartiesModel);
  m_ui->tvVisibleParties->resizeColumnsToContent();
  m_ui->tvVisibleParties->setSortIndicator(ExerciseEditVisiblePartiesModel::Columns::ColId, Qt::SortOrder::AscendingOrder);
  m_ui->tvVisibleParties->setSortingEnabled(false);

  m_adlerVisiblePartiesModel = new ExerciseEditAdlerVisiblePartiesModel(m_operatorId, m_exerciseId, this);
  if (!m_adlerVisiblePartiesModel->init(session))
    return false;

  m_ui->tvAdlerVisibleParties->setModel(m_adlerVisiblePartiesModel);
  m_ui->tvAdlerVisibleParties->resizeColumnsToContent();
  m_ui->tvAdlerVisibleParties->setSortIndicator(ExerciseEditAdlerVisiblePartiesModel::Columns::ColId, Qt::SortOrder::AscendingOrder);
  m_ui->tvAdlerVisibleParties->setSortingEnabled(false);

#ifndef LTS_DEBUG
  m_ui->tvVisibleParties->hideColumn(ExerciseEditVisiblePartiesModel::Columns::ColId);
  m_ui->tvAdlerVisibleParties->hideColumn(ExerciseEditVisiblePartiesModel::Columns::ColId);
#endif

  connect(m_ui->tvVisibleParties, &LtsDataView::LtsDataView::doubleClicked, m_visiblePartiesModel, &ExerciseEditVisiblePartiesModel::switchCheckbox);
  connect(m_ui->tvAdlerVisibleParties, &LtsDataView::LtsDataView::doubleClicked, this, &ExerciseEditPartyDialog::onDoubleClicked);

  connect(m_visiblePartiesModel, &ExerciseEditVisiblePartiesModel::dataChanged, this, [this](const QModelIndex &index) {
    m_visiblePartiesChanged = true; slotChangesMade(); onSwitchCheckbox(index);});
  connect(m_adlerVisiblePartiesModel, &ExerciseEditAdlerVisiblePartiesModel::dataChanged, this, [this]() {
    m_adlerVisiblePartiesChanged = true; slotChangesMade();});

#ifdef LTS_DEBUG
  m_ui->tvVisibleParties->setContextMenuPolicy(Qt::CustomContextMenu);
  connect(m_ui->tvVisibleParties, &LtsDataView::LtsDataView::customContextMenuRequested, this, &ExerciseEditPartyDialog::onContextMenuRequested);
#endif

  setAdlerVisiblePartiesUncheckable();
  return true;
}

bool ExerciseEditPartyDialog::operatorUpdateVisiblePartiesByExercise(const OperatorManagement::OperatorUpdateVisiblePartiesByExerciseRequest &req)
{
  DEBUG_LOG(m_logger) << LOGFUNCTION;
  return m_requestHelper->startSingleRequest([this, req]()
  {
    return m_opmFtc->operatorUpdateVisiblePartiesByExerciseRequest(req, this);
  });
}

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

void ExerciseEditPartyDialog::retranslate()
{
  translate(m_ui, m_opmDtc->user(m_operatorId), tr("EX:%1 Operator ").arg(m_exerciseId));
}

QByteArray ExerciseEditPartyDialog::adlerVisiblePartiesToJson() const
{
  QJsonArray adlerVisiblePartiesArray;
  QJsonObject adlerVisiblePartiesObject;

  // pool and support are in the list (always available);
  adlerVisiblePartiesArray.append(0); // pool
  adlerVisiblePartiesArray.append(1); // O/C Service;

  const QVector<int> &checkedParties = m_adlerVisiblePartiesModel->getCheckedIds();
  for (const int id : checkedParties)
    adlerVisiblePartiesArray.append(id);
  adlerVisiblePartiesObject[QStringLiteral("adlerAllowed")] = adlerVisiblePartiesArray;

  QJsonDocument adlerVisiblePartiesDocument(adlerVisiblePartiesObject);

  return adlerVisiblePartiesDocument.toJson(QJsonDocument::Compact);
}

void ExerciseEditPartyDialog::setAdlerVisiblePartiesUncheckable()
{
  const QVector<int> &uncheckedParties = m_visiblePartiesModel->getUncheckedIds();
  QVector<int> rowIds;
  for (const int id : uncheckedParties)
  {
    int rowId = m_adlerVisiblePartiesModel->findRowForPartyId(id);
    if (rowId < 0)
      continue;
    rowIds.append(rowId);
  }
  m_adlerVisiblePartiesModel->setUncheckedPartyIds(rowIds);
}

//Private Slots
bool ExerciseEditPartyDialog::apply()
{
  DEBUG_LOG(m_logger) << LOGFUNCTION;

  if (m_operatorId <= 0) // user not exists
    return true;

  //updateData
  OperatorManagement::OperatorUpdateVisiblePartiesByExerciseRequest req;
  req.id(m_operatorId);
  req.exerciseId(m_exerciseId);

  if (!m_visiblePartiesChanged && !m_adlerVisiblePartiesChanged)
    return false;

  QSet<int> visiblePartyIds = m_visiblePartiesModel->getCheckedIds().toList().toSet();
  // check if pool and support are in the list (always available);
  visiblePartyIds.insert(0); // pool
  visiblePartyIds.insert(1); // O/C Service;

  const QVector<int> hiddenPartyIds = m_visiblePartiesModel->getUncheckedIds();
  for (const int visible : visiblePartyIds)
    DEBUG_LOG(m_logger) << "visible party: " << visible;
  for (const int hidden : hiddenPartyIds)
    DEBUG_LOG(m_logger) << "hidden party: " << hidden;
  req.hiddenParties().set({});
  req.visibleParties().set({});
  std::copy(hiddenPartyIds.begin(), hiddenPartyIds.end(), std::back_inserter(req.hiddenParties().get()));
  std::copy(visiblePartyIds.begin(), visiblePartyIds.end(), std::back_inserter(req.visibleParties().get()));

  req.properties(adlerVisiblePartiesToJson().toStdString());

  DEBUG_LOG(m_logger) << "----------------- opId: " << req.id() << ", exId:" << req.exerciseId() << ", req.hiddenParties.size:" << hiddenPartyIds.size()
                      << "adlerVisibleParties: " << req.properties();

  return operatorUpdateVisiblePartiesByExercise(req);
}

void ExerciseEditPartyDialog::onContextMenuRequested(const QPoint &position)
{
  QMenu menu(m_ui->tvVisibleParties);
  menu.addAction(tr("Select All"), this, &ExerciseEditPartyDialog::onSelectAllParties);
  menu.addAction(tr("Unselect All"), this, &ExerciseEditPartyDialog::onUnselectAllParties);
  menu.exec(m_ui->tvVisibleParties->mapToGlobal(position));
}

void ExerciseEditPartyDialog::onSelectAllParties()
{
  m_visiblePartiesModel->selectAll();
  m_visiblePartiesModel->update();
}

void ExerciseEditPartyDialog::onUnselectAllParties()
{
  m_visiblePartiesModel->unselectAll();
  m_visiblePartiesModel->update();
}

void ExerciseEditPartyDialog::onSwitchCheckbox(const QModelIndex &index)
{
  if (!index.isValid())
  {
    return;
  }

  DEBUG_LOG(m_logger) <<  LOGFUNCTION << "index.row():" << index.row();

  const QPair<bool, ParticipantManagement::Party> row = m_visiblePartiesModel->getRowData(index.row());
  QPair<bool, ParticipantManagement::Party> rowAdler = m_adlerVisiblePartiesModel->getRowData(index.row());
  rowAdler.first = row.first;
  setAdlerVisiblePartiesUncheckable();
  m_adlerVisiblePartiesModel->setRowData(index.row(), rowAdler);
}

void ExerciseEditPartyDialog::onDoubleClicked(const QModelIndex &index)
{
  if (!index.isValid())
  {
    return;
  }

  DEBUG_LOG(m_logger) <<  LOGFUNCTION << "index.row():" << index.row();

  // if the party is not checked, you can not get this one for ADLER
  bool isChecked = m_visiblePartiesModel->getRowData(index.row()).first;
  if (!isChecked)
    return;

  QPair<bool, ParticipantManagement::Party> row = m_adlerVisiblePartiesModel->getRowData(index.row());
  row.first = !row.first;
  m_adlerVisiblePartiesModel->setRowData(index.row(), row);
}

}