qt5-legatus-legacy/Lts/Plugins/ParticipantManagement/Gui/Common/participant_edit_item.cpp

/**
  * @RDE_HEADER@
  * HMI Plugin for ParticipantManagement - Participant Edit Item Dialog
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Patric Karwat, SLSE, 2016-10-17
  */

#include "participant_edit_item.h"
#include "ui_participant_edit_item_widget_base.h"
#include <ParticipantManagement/ppm_translation.h>
#include <QStandardItemModel>

namespace ParticipantManagement
{
//
// ParticipantEditItemWidget
//
ParticipantEditItemWidget::ParticipantEditItemWidget(bool asSupportService,
                                                     LtsSession::LtsSession *session,
                                                     QWidget *parent)
  : ParticipantEditItemWidgetBase(asSupportService, session, parent)
  , m_isOrgChart(false)
{  
  connect(m_ui->tbAssignment, &QToolButton::clicked, this, &ParticipantEditItemWidget::onTbAssignmentClicked);
  connect(m_ui->cbExternal, &QCheckBox::clicked, this, &ParticipantEditItemWidget::setAssignmentButton);
  connect(m_ui->sbEquipNr, QOverload<int>::of(&QSpinBox::valueChanged), this, &ParticipantEditItemWidget::onEqNoChanged);
  m_ui->tbAssignment->setCheckable(false);
  m_ui->tbAssignment->setAutoRaise(false);
}

bool ParticipantEditItemWidget::init(const QModelIndex &workingIndex,
                                     int partyId,
                                     const std::shared_ptr<ParticipantManagement::Interface::Dtc> &dtc,
                                     const std::shared_ptr<ForeignGuiComboboxInterface> &ppmGuiCbxIfc,
                                     const std::shared_ptr<AdvancedSymbology::ForeignDataInterface> &asb,
                                     const ParticipantManagement::ParticipantData &data,
                                     bool isOrgChart,
                                     const bool addItem,
                                     const QVector<int> &usedEquipmentNumbers)
{
  m_isOrgChart = isOrgChart;
  m_editData = data;
  m_currentAssignState = data.assignState();
  m_partyId = partyId;
  m_bEditMode = m_editData.typeId() > 0;
  m_workingIndex = workingIndex;
  m_alreadyAddedEquipmentNumbers = usedEquipmentNumbers;

  return ParticipantEditItemWidgetBase::init(dtc, ppmGuiCbxIfc, asb, addItem);
}

void ParticipantEditItemWidget::setFiringUnitRestrictions(ParticipantEditModel *model, bool isEdit, const FiringUnitValidator::FiringUnitRestrictions &restrictions, FiringUnitValidator *firingUnitValidator, const int &unitGearClassType)
{
  if (!firingUnitValidator || !model)
    return;

  if (restrictions.testFlag(FiringUnitValidator::NO_TYPE_CHANGE_ALLOWED))
  {
    m_ui->cbTypeClass->setDisabled(true);
    m_ui->cbType->setDisabled(true);

    if (isEdit) // if we are in edit mode (and not add), type and typeclass are already set where as want them to be
      return;

    const Type allowedType = firingUnitValidator->getAllowedType(model, m_workingIndex);

    if (allowedType == Type())
      return;

    m_ui->cbTypeClass->setCurrentIndex(m_ui->cbTypeClass->findData(allowedType.typeClass().underlying()));
    m_ui->cbType->setCurrentIndex(m_ui->cbType->findData(allowedType.id()));

    return;
  }

  if (restrictions.testFlag(FiringUnitValidator::ONLY_SAME_GEAR_CLASS_ARTILLERY_ALLOWED))
  {
    if (isEdit)
      return;

    const QVector<Type> allowedTypes = firingUnitValidator->artilleryParticipantTypes();

    m_ui->cbTypeClass->setDisabled(true);
    m_ui->cbTypeClass->setCurrentIndex(m_ui->cbTypeClass->findData(allowedTypes.at(0).typeClass().underlying()));

    m_ui->cbType->clear();

    std::function<bool(Type)> funcIsSameGearType = [=](const Type &t)
    {
      if (m_isAdler)
        return m_dtc->isAdlerType(t.id()) && (firingUnitValidator->getGearClassType(t.id()) == unitGearClassType);
      return firingUnitValidator->getGearClassType(t.id()) == unitGearClassType;
    };
    QVector<Type>::ConstIterator typeIterator = std::find_if(allowedTypes.begin(), allowedTypes.end(), funcIsSameGearType);

    if(typeIterator != allowedTypes.end())
    {
      m_ui->cbType->setDisabled(true);
      m_ui->cbType->addItem(ParticipantManagement::trTypeName(typeIterator->name()), typeIterator->id());
    }
    else
    {
      for (const Type &currentType : allowedTypes)
        m_ui->cbType->addItem(ParticipantManagement::trTypeName(currentType.name()), currentType.id());
      m_ui->cbType->model()->sort(0);
    }

    m_ui->cbType->setCurrentIndex(0);

    return;
  }

  if (isEdit && restrictions.testFlag(FiringUnitValidator::NO_FIRING_UNIT_TYPE_ALLOWED))
  {
    m_disabledTypeIds.unite(firingUnitValidator->firingUnitTypeIds());

    QStandardItemModel *cbTypeModel = qobject_cast<QStandardItemModel *>(m_ui->cbType->model());

    if (cbTypeModel == nullptr)
      return;

    for (int row = 0; row < m_ui->cbType->count(); ++row)
    {
      QStandardItem *item = cbTypeModel->item(row);
      int typeId = item->data(Qt::UserRole).toInt();

      if (!m_disabledTypeIds.contains(typeId))
        continue;

      item->setFlags(Qt::NoItemFlags);
    }
  }

  if (restrictions.testFlag(FiringUnitValidator::NO_ARTILLERY_PARTICIPANTS_ALLOWED))
  {
    m_disabledTypeIds.unite(firingUnitValidator->artilleryParticipantTypeIds());

    QStandardItemModel *cbTypeModel = qobject_cast<QStandardItemModel *>(m_ui->cbType->model());

    if (cbTypeModel == nullptr)
      return;

    for (int row = 0; row < m_ui->cbType->count(); ++row)
    {
      QStandardItem *item = cbTypeModel->item(row);
      int typeId = item->data(Qt::UserRole).toInt();

      if (!m_disabledTypeIds.contains(typeId))
        continue;

      item->setFlags(Qt::NoItemFlags);
    }
  }
}

void ParticipantEditItemWidget::setData()
{
  m_ui->leDesignator->setText(QString::fromStdString(m_editData.designator()));
  m_ui->leTactIdent->setText(QString::fromStdString(m_editData.tacticalIdentifier()));
  m_ui->leInfo->setText(QString::fromStdString(m_editData.info()));
  m_ui->leSign->setText(QString::fromStdString(m_editData.identification()));
  m_ui->cbExternal->setChecked(m_editData.externalId() > 0);
  m_ui->leVerein->setText(QString::fromStdString(m_editData.name()));

  Type type = m_dtc->type(m_editData.typeId());
  m_ui->cbTypeClass->setCurrentIndex(m_ui->cbTypeClass->findData(type.typeClass().underlying()));
  m_ui->cbType->setCurrentIndex(m_ui->cbType->findData(type.id()));

  //set assingment first
  setAssignmentButton();

  if (isUnitType(m_editData.typeId()))
  {
    m_ui->cbTypeClass->setEnabled(false);
    m_ui->sbEquipNr->setEnabled(false);
    m_ui->tbAssignment->setEnabled(false); //units never get equipments and never reset

    bool showVerein = m_dtc->isAdlerType(m_editData.typeId());
    m_ui->lblVerein->setVisible(showVerein);
    m_ui->leVerein->setVisible(showVerein);
  }
  else
  {
    const bool isEquipped = m_editData.equipmentNumber().is_set() && m_editData.equipmentNumber().get() > 0;
    m_ui->cbTypeClass->setEnabled(!isEquipped);
    m_ui->cbType->setEnabled(!isEquipped);
    m_ui->sbEquipNr->setEnabled(m_editData.typeId() > 0);
  }

  if (m_editData.equipmentNumber().is_set())
    m_ui->sbEquipNr->setValue(m_editData.equipmentNumber().get());
  onChangeSymbol(QString::fromStdString(m_editData.symbol()));

  // Saab Participants
  if (m_editData.externalId() > 0)
  {
    m_ui->leTactIdent->setEnabled(false); // Set from OrbatImport or via HLA
    m_ui->sbEquipNr->setEnabled(false); // EqNo cannot be changed on Saab Players
    m_ui->tbAssignment->setEnabled(false);
    //    m_ui->leSign->setEnabled(); // I let it changeable at the moment...
  }

}

void ParticipantEditItemWidget::setDesignatorData()
{
  m_ui->leDesignator->setText(QString::fromStdString(m_editData.designator()));
  m_ui->leTactIdent->setText(QString::fromStdString(m_editData.tacticalIdentifier()));
}

void ParticipantEditItemWidget::onAddItem()
{
  ParticipantManagement::ParticipantData newParticipantData;
  if (!collectParticipantData(newParticipantData))
    return;

  if (newParticipantData.equipmentNumber().is_set())
    m_alreadyAddedEquipmentNumbers.append(newParticipantData.equipmentNumber().get());

  DEBUG_LOG(m_logger) << "add item: " << newParticipantData;
  if (m_workingIndex.isValid() || m_isOrgChart)
    emit addItem(m_workingIndex, newParticipantData);
  m_ui->leSign->clear();
  m_ui->leInfo->clear();
}

bool ParticipantEditItemWidget::onEditItem()
{
  ParticipantManagement::ParticipantData newParticipantData(m_editData);
  if (!collectParticipantData(newParticipantData))
    return false;
  m_editData = newParticipantData;
  m_currentAssignState = newParticipantData.assignState();

  DEBUG_LOG(m_logger) << "edit item: " << m_editData;
  if (m_workingIndex.isValid() || m_isOrgChart)
    emit updateItem(m_workingIndex, m_editData);
  emit readyToClose();
  return true;
}

bool ParticipantEditItemWidget::collectParticipantData(ParticipantManagement::ParticipantData &data)
{
  const int newEquipmentNumber = m_ui->sbEquipNr->value();

  data.designator(m_ui->leDesignator->text().toStdString());
  data.tacticalIdentifier(m_ui->leTactIdent->text().toStdString());
  data.symbol(m_sidc.toStdString());
  data.typeId(m_ui->cbType->currentData().toInt());
  data.partyId(m_partyId);
  data.identification(m_ui->leSign->text().toStdString());
  data.info(m_ui->leInfo->text().toStdString());
  data.assignState(m_currentAssignState);

  // Verein is listed in name
  data.name(m_ui->leVerein->text().toStdString());

  if (newEquipmentNumber > 0)
  {
    if (newEquipmentNumber < m_typeMinimum)
    {
      m_ui->lbMinMaxEquipNr->setText(QStringLiteral("<span style=\"color:#aa0000;\">%1</span>").arg(m_ui->lbMinMaxEquipNr->text()));
      return false;
    }
    if (m_editData.equipmentNumber() != newEquipmentNumber)
    {
      int exerciseId = 0;
      if (!m_dtc->isEquipmentExerciseMappingEnabled())
      {
        m_dtc->enableEquipmentExerciseMapping();
        m_dtc->waitForHistoricalDataEquipmentExerciseMapping(3000);
      }
      if (m_dtc->isEquipmentNumberInUse(newEquipmentNumber, exerciseId) || m_alreadyAddedEquipmentNumbers.contains(newEquipmentNumber))
      {
        if (m_session->exerciseId() == exerciseId)
        {
          LtsWidgets::LtsMessageDialog::showMessage(this,
                                                    tr("The equipment number is already used by another participant"),
                                                    tr("Equipment Number already in use"));
          return false;
        }
        if (m_session->exerciseState() != LtsWidgets::ExcState::eCreated)
        {
          LtsWidgets::LtsMessageDialog::showMessage(this,
                                                    tr("The equipment number is already used by another participant in another exercise"),
                                                    tr("Equipment Number already in use"));
          return false;
        }
      }
    }
    data.equipmentNumber(newEquipmentNumber);
    data.externalId(m_ui->cbExternal->isChecked() ? newEquipmentNumber : 0);
    m_ui->sbEquipNr->setValue(newEquipmentNumber + 1);
  }
  else
  {
    data.equipmentNumber().reset();
    data.externalId(0);
  }
  return true;
}

void ParticipantEditItemWidget::onTbAssignmentClicked()
{
  switch (m_currentAssignState.underlying())
  {
  case ParticipantManagement::ParticipantAssignState::AssignedWms:
    m_currentAssignState = ParticipantManagement::ParticipantAssignState::HandoutExcon;
    m_ui->sbEquipNr->setValue(0);
    break;
  case ParticipantManagement::ParticipantAssignState::HandoutWms:
    m_currentAssignState = ParticipantManagement::ParticipantAssignState::ExconWmsOverruled;
    m_ui->sbEquipNr->setValue(0);
    break;
  case ParticipantManagement::ParticipantAssignState::HandoutExcon:
  case ParticipantManagement::ParticipantAssignState::ExconWmsOverruled:
    m_currentAssignState = ParticipantManagement::ParticipantAssignState::NotAssigned;
    m_ui->sbEquipNr->setValue(0);
    break;
  case ParticipantManagement::ParticipantAssignState::NotAssigned:
    if (m_editData.assignState() == ParticipantManagement::ParticipantAssignState::ExconWmsOverruled ||
        m_editData.assignState() == ParticipantManagement::ParticipantAssignState::HandoutWms)
      m_currentAssignState = ParticipantManagement::ParticipantAssignState::ExconWmsOverruled;
    else
      m_currentAssignState = ParticipantManagement::ParticipantAssignState::HandoutExcon;
    break;
  }
  setAssignmentButton();
}

void ParticipantEditItemWidget::onEqNoChanged()
{
  if (m_currentAssignState == ParticipantManagement::ParticipantAssignState::NotAssigned &&
      m_ui->sbEquipNr->value() != 0)
  {
    onTbAssignmentClicked();
    return;
  }

  if (m_editData.assignState() == ParticipantManagement::ParticipantAssignState::AssignedWms)
  {
    if (m_editData.equipmentNumber().is_set() && m_editData.equipmentNumber().get() == m_ui->sbEquipNr->value())
      m_currentAssignState = ParticipantManagement::ParticipantAssignState::AssignedWms;
    else
      m_currentAssignState = ParticipantManagement::ParticipantAssignState::HandoutExcon;
  }
  else if (m_editData.assignState() == ParticipantManagement::ParticipantAssignState::HandoutWms)
  {
    if (m_editData.equipmentNumber().is_set() && m_editData.equipmentNumber().get() == m_ui->sbEquipNr->value())
      m_currentAssignState = ParticipantManagement::ParticipantAssignState::HandoutWms;
    else
      m_currentAssignState = ParticipantManagement::ParticipantAssignState::ExconWmsOverruled;
  }
  setAssignmentButton();
}

void ParticipantEditItemWidget::setAssignmentButton()
{
  switch (m_currentAssignState.underlying())
  {
  case ParticipantManagement::ParticipantAssignState::AssignedWms:
  case ParticipantManagement::ParticipantAssignState::HandoutWms:
  {
    if (m_editData.assignState().underlying() == ParticipantManagement::ParticipantAssignState::AssignedWms)
      m_ui->tbAssignment->setText(tr("WH(A)"));
    else
      m_ui->tbAssignment->setText(tr("WH(H)"));

    //can't override warehouse settings
    break;
  }
  case ParticipantManagement::ParticipantAssignState::HandoutExcon:
  {
    m_ui->tbAssignment->setText(tr("EXC"));
    break;
  }
  case ParticipantManagement::ParticipantAssignState::ExconWmsOverruled:
  {
    m_ui->tbAssignment->setText(tr("EXC(+)"));
    break;
  }
  case ParticipantManagement::ParticipantAssignState::NotAssigned:
  {
    m_ui->tbAssignment->setText(QStringLiteral("-"));
    break;
  }
  }

  // Saab Participants: Can be taken down, but need to uncheck "External" first.
  if (m_editData.externalId() > 0 && m_ui->cbExternal->isChecked())
  {
    m_ui->tbAssignment->setEnabled(false);
    m_ui->sbEquipNr->setEnabled(false);
    return;
  }
  m_ui->tbAssignment->setEnabled(true);
  m_ui->sbEquipNr->setEnabled(true);

}

//
// ParticipantEditItem
//
ParticipantEditItem::ParticipantEditItem(bool asSupportService,
                                         LtsSession::LtsSession *session,
                                         QWidget *parent)
  : LtsWidgets::LtsFramelessDialog(parent, LtsWidgets::Behaviour::Modal)
  , m_editItemWidget(new ParticipantEditItemWidget(asSupportService, session, parent))
  , m_buttonBox(new LtsWidgets::LtsDialogButtonBox(this))

{
  //HACK as close is not allowed directly
  setWindowTitle(tr("Edit Participant"));
  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, this, &ParticipantEditItem::close);
  connect(m_editItemWidget, &ParticipantEditItemWidget::readyToClose, this, &ParticipantEditItem::close);

  //connect to other signals
  connect(m_editItemWidget, &ParticipantEditItemWidget::addItem, this, &ParticipantEditItem::addItem);
  connect(m_editItemWidget, &ParticipantEditItemWidget::updateItem, this, &ParticipantEditItem::updateItem);

  //hide ok and aplly
  m_buttonBox->getButton(LtsWidgets::DialogButton::Apply)->hide();
  m_buttonBox->getButton(LtsWidgets::DialogButton::Ok)->hide();
}


bool ParticipantEditItem::init(const QModelIndex &workingIndex,
                               int partyId,
                               const std::shared_ptr<Interface::Dtc> &dtc,
                               const std::shared_ptr<ForeignGuiComboboxInterface> &ppmGuiCbxIfc,
                               const std::shared_ptr<AdvancedSymbology::ForeignDataInterface> &asb,
                               const ParticipantData &data,
                               const bool addItem,
                               const QVector<int> &usedEquipmentNumbers)
{
  const bool isOrgChart = false;


  if (!m_editItemWidget->init(workingIndex, partyId, dtc, ppmGuiCbxIfc, asb, data, isOrgChart, addItem, usedEquipmentNumbers))
    return false;

  QVBoxLayout *layout = new QVBoxLayout;
  layout->addWidget(m_editItemWidget);
  layout->addWidget(m_buttonBox);
  setLayout(layout);

  if (data.typeId() > 0)
  {
    m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, m_editItemWidget, &ParticipantEditItemWidget::onEditItem);
    m_buttonBox->getButton(LtsWidgets::DialogButton::Edit)->setText(tr("Apply"));
  }
  else
  {
    m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, m_editItemWidget, &ParticipantEditItemWidget::onAddItem);
  }

  return true;
}

void ParticipantEditItem::setFiringUnitRestrictions(ParticipantEditModel *model, bool isEdit, const FiringUnitValidator::FiringUnitRestrictions &restrictions, FiringUnitValidator *firingUnitValidator, const int unitGearClassType)
{
  if (restrictions == FiringUnitValidator::NO_RESTRICTION)
    return;

  if (restrictions.testFlag(FiringUnitValidator::IS_AT_MAX_CAPACITY))
    m_buttonBox->getButton(LtsWidgets::DialogButton::Add)->setDisabled(true);

  if (m_editItemWidget)
    m_editItemWidget->setFiringUnitRestrictions(model, isEdit, restrictions, firingUnitValidator, unitGearClassType);
}

//
// ParticipantEditItemTab
//
ParticipantEditItemTab::ParticipantEditItemTab(bool asSupportService,
                                               LtsSession::LtsSession *session,
                                               QWidget *parent)
  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
  , m_editItemWidget(new ParticipantEditItemWidget(asSupportService, session, this))
{
  connect(m_editItemWidget, &ParticipantEditItemWidget::updateItem, this, &ParticipantEditItemTab::updateItem);
  connect(m_editItemWidget, &ParticipantEditItemWidget::readyToClose, this, [this]()
  {
    m_buttonBox->getButton(LtsWidgets::DialogButton::Close)->click();
  });
}

void ParticipantEditItemTab::retranslate()
{
  // lupdate doesn't like translate(tr("foo")) ...
  const QString txt(tr("Participant Item Edit"));
  translate(txt);
}

bool ParticipantEditItemTab::init(const std::shared_ptr<Interface::Dtc> &dtc,
                                  const std::shared_ptr<ForeignGuiComboboxInterface> &ppmGuiCbxIfc,
                                  const std::shared_ptr<AdvancedSymbology::ForeignDataInterface> &asb,
                                  const ParticipantData &data,
                                  bool isOrgChart)
{
  if (!m_editItemWidget->init(QModelIndex(), data.partyId(), dtc, ppmGuiCbxIfc, asb, data, isOrgChart))
    return false;

  QVBoxLayout *layout = new QVBoxLayout;
  layout->addWidget(m_editItemWidget);
  setLayout(layout);

  m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, m_editItemWidget, &ParticipantEditItemWidget::onEditItem);
  m_buttonBox->setText(LtsWidgets::DialogButton::Edit, tr("Apply"));
  return true;
}

bool ParticipantEditItemTab::apply()
{
  return m_editItemWidget->onEditItem();
}

} //namespace ParticipantManagement