Initial commit

Lts/Plugins/ParticipantManagement/Gui/Common/participant_edit_item.cpp

@@ -0,0 +1,520 @@
+/**
+  * @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