Initial commit

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/CMakeLists.txt

@@ -0,0 +1,48 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+# Created by Malte Diers, SLSE, 2016-07-03
+#
+
+SET(aes_charge_administration_gui_SRCS
+  aes_charge_administration_gui_plugin.cpp
+  aes_charge_administration_gui_plugin.h
+  aes_charge_administration_list.cpp
+  aes_charge_administration_list.h
+  aes_charge_administration_model.cpp
+  aes_charge_administration_model.h
+  aes_charge_administration_adler_list.cpp
+  aes_charge_administration_adler_list.h
+  aes_charge_administration_adler_model.cpp
+  aes_charge_administration_adler_model.h
+  aes_charge_edit.h
+  aes_charge_edit.cpp
+  CustomView/aes_charge_administration.h
+  CustomView/aes_charge_administration.cpp
+)
+
+NGL_WRAP_UI(aes_charge_administration_gui_SRCS
+  aes_charge_administration_list.ui
+  aes_charge_edit.ui
+  CustomView/aes_charge_administration.ui
+)
+
+NGL_ADD_LIBRARY(WS AesChargeAdministrationGuiPlugin MODULE ${aes_charge_administration_gui_SRCS})
+NGL_TARGET_LINK_LIBRARIES(AesChargeAdministrationGuiPlugin
+  LtsPrinting
+  AesBaseGui
+  LtsDataView
+  NGLLogger
+  ngltools
+  LtsSession
+  LtsSessionData
+  AesDataPluginInterface
+  PpmGuiComboboxPluginInterface
+  svcPdmCommon
+  Qt5::Widgets
+  LtsWidgets
+  LtsUtilsSettings
+)
+
+NGL_INSTALL_TARGET(AesChargeAdministrationGuiPlugin)

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/CustomView/aes_charge_administration.cpp

@@ -0,0 +1,42 @@
+/**
+  * @RDE_HEADER@
+  * CustomView for AES NContamination
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Mike Wille, SLSE, 2016-04-08
+  */
+
+#include "aes_charge_administration.h"
+#include "ui_aes_charge_administration.h"
+
+#include "aes_charge_administration_model.h"
+
+#include <QDebug>
+
+
+namespace AreaEffectSimulation
+{
+CustomViewChargeAdministration::CustomViewChargeAdministration(QWidget *parent)
+  : AbstractDisplayWidget(parent)
+  , m_ui(new Ui::CustomViewChargeAdministration)
+{
+  m_ui->setupUi(this);
+}
+
+CustomViewChargeAdministration::~CustomViewChargeAdministration()
+{
+  delete m_ui;
+}
+
+bool CustomViewChargeAdministration::init(const QModelIndex &idx)
+{
+  if (!idx.isValid())
+    return false;
+
+  m_ui->lblChargeType->setText(rowData(idx, AreaEffectSimulation::ChargeAdministrationModel::ColTypeName).toString());
+  m_ui->lblCount->setText(rowData(idx, AreaEffectSimulation::ChargeAdministrationModel::ColStock).toString());
+  m_ui->lblPlanned->setText(rowData(idx, AreaEffectSimulation::ChargeAdministrationModel::ColPlanned).toString());
+  return true;
+}
+} // namespace AreaEffectSimulation

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/CustomView/aes_charge_administration.h

@@ -0,0 +1,35 @@
+/**
+  * @RDE_HEADER@
+  * CustomView for AES NContamination
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Mike Wille, SLSE, 2016-04-08
+  */
+#pragma once
+
+#include <QWidget>
+
+#include <Viewer/LtsDataView/abstract_display_widget.h>
+
+
+namespace Ui
+{
+class CustomViewChargeAdministration;
+}
+
+namespace AreaEffectSimulation
+{
+class CustomViewChargeAdministration final : public LtsDataView::AbstractDisplayWidget
+{
+  Q_OBJECT
+public:
+  explicit CustomViewChargeAdministration(QWidget *parent = nullptr);
+  ~CustomViewChargeAdministration();
+  bool init(const QModelIndex &idx) override final;
+
+private:
+  Ui::CustomViewChargeAdministration* m_ui;
+
+};
+} // namespace AreaEffectSimulation

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/CustomView/aes_charge_administration.ui

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>CustomViewChargeAdministration</class>
+ <widget class="QWidget" name="CustomViewChargeAdministration">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>300</width>
+    <height>70</height>
+   </rect>
+  </property>
+  <property name="sizePolicy">
+   <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+    <horstretch>0</horstretch>
+    <verstretch>0</verstretch>
+   </sizepolicy>
+  </property>
+  <property name="windowTitle">
+   <string notr="true"/>
+  </property>
+  <property name="toolTip">
+   <string notr="true"/>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_2">
+     <item>
+      <widget class="QLabel" name="lblChargeType">
+       <property name="font">
+        <font>
+         <weight>75</weight>
+         <bold>true</bold>
+        </font>
+       </property>
+       <property name="toolTip">
+        <string/>
+       </property>
+       <property name="text">
+        <string notr="true">Name</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer_2">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QLabel" name="label">
+       <property name="toolTip">
+        <string/>
+       </property>
+       <property name="text">
+        <string>Amount:</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="lblCount">
+       <property name="toolTip">
+        <string/>
+       </property>
+       <property name="text">
+        <string notr="true">0</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <spacer name="horizontalSpacer">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QLabel" name="label_2">
+       <property name="toolTip">
+        <string/>
+       </property>
+       <property name="text">
+        <string>Already Planned:</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="lblPlanned">
+       <property name="toolTip">
+        <string/>
+       </property>
+       <property name="text">
+        <string notr="true">0</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_administration_adler_list.cpp

@@ -0,0 +1,117 @@
+/**
+  * @RDE_HEADER@
+  * AreaEffectManangement - Adler Charge Administration Overview Dialog Model
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Astrid Müller, ESZE, 2025-12-19
+  */
+
+#include "aes_charge_administration_adler_list.h"
+#include "ui_aes_charge_administration_list.h"
+#include "aes_charge_administration_adler_model.h"
+#include <LtsWidgets/lts_dialog.h>
+#include <LtsWidgets/lts_combo_box.h>
+#include <LtsSession/lts_session.h>
+#include <LtsUtilsGuiDds/request_helper.h>
+
+#include <Plugins/ParticipantManagement/ppm_gui_combobox_plugin_interface.h>
+#include <Plugins/AreaEffectSimulation/aes_data_plugin_interface.h>
+#include <PluginInterfaces/gui_plugin_interface.h>
+#include <QInputDialog>
+
+#include <LtsPrinting/printing.h>
+#include <QTreeView>
+
+namespace AreaEffectSimulation
+{
+
+ChargeAdministrationAdlerList::ChargeAdministrationAdlerList(QWidget *parent)
+  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
+  , m_model(nullptr)
+  , m_sourceModel(nullptr)
+  , m_session(nullptr)
+  , m_requestHelper(new LtsUtils::RequestHelper(this))
+  , m_ui(new Ui::ChargeAdministrationList)
+  , m_logger(getLogger("ChargeAdministrationAdlerList"))
+{
+  m_ui->setupUi(this);
+
+  connect(m_ui->cbParty, static_cast<void (LtsWidgets::LtsComboBox::*)(int)>(&LtsWidgets::LtsComboBox::currentIndexChanged),
+          this, &ChargeAdministrationAdlerList::onPartyChanged);
+
+  setOnlineHelpFilename(QStringLiteral("Situation-Charge_Administration_Adler"));
+}
+
+ChargeAdministrationAdlerList::~ChargeAdministrationAdlerList()
+{
+  delete m_ui;
+}
+
+void ChargeAdministrationAdlerList::retranslate()
+{
+  translate(m_ui, tr("Charge Administration Adler"));
+}
+
+void ChargeAdministrationAdlerList::tableColumnOrganiserSetting()
+{
+  //LtsColumnOrganiser
+  m_ui->widget->setColumnsOrganiserEnabled(identifier(), true);
+}
+
+void ChargeAdministrationAdlerList::onPartyChanged()
+{
+  m_model->setParty(m_ui->cbParty->currentData().toInt());
+}
+
+bool ChargeAdministrationAdlerList::init(LtsSession::LtsSession *session)
+{
+  if (m_session)
+  {
+    ERROR_LOG(m_logger) << "double init()!";
+    return false;
+  }
+  m_session = session;
+
+  m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &ChargeAdministrationAdlerList::onPrint);
+
+  std::shared_ptr<ParticipantManagement::ForeignGuiComboboxInterface> ppmGuiCbxIfc;
+  if (!m_session->getForeignGuiInterface<ParticipantManagement::ForeignGuiComboboxInterface>(ppmGuiCbxIfc))
+    return false;
+
+  m_sourceModel = new ChargeAdministrationAdlerModel(this);
+
+  if (!m_sourceModel->initModel(m_session))
+    return false;
+
+  m_model = new ChargeAdministrationAdlerSortFilterProxyModel(this);
+  m_model->setSourceModel(m_sourceModel);
+  m_ui->widget->setModel(m_model);
+  m_ui->widget->hideColumn(ChargeAdministrationAdlerModel::ColId, true);
+
+#ifndef LTS_DEBUG
+  bool onlydebugMode =true;
+  m_ui->widget->hideColumn(ChargeAdministrationAdlerModel::ColTypeId, onlydebugMode);
+  m_ui->widget->hideColumn(ChargeAdministrationAdlerModel::ColChanged, onlydebugMode);
+#endif
+
+  m_ui->widget->setSortIndicator(ChargeAdministrationAdlerModel::ColTypeName, Qt::AscendingOrder);
+
+  ppmGuiCbxIfc->fillPartyComboBox(m_ui->cbParty);
+  onPartyChanged();
+
+  return true;
+}
+
+void ChargeAdministrationAdlerList::onPrint()
+{
+  QString header;
+  header += QStringLiteral("<p>");
+  header += tr("Party: %1").arg(m_ui->cbParty->currentText());
+  header += QStringLiteral("<br/>");
+  header += QStringLiteral("</p>");
+
+  LtsPrinting::printView(m_session, this, m_ui->widget->treeView(), header );
+}
+
+} // namespace AreaEffectSimulation

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_administration_adler_list.h

@@ -0,0 +1,60 @@
+/**
+  * @RDE_HEADER@
+  * AreaEffectManangement - Adler Charge Administration Overview Dialog Model
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Astrid Müller, ESZE, 2025-12-19
+  */
+
+#pragma once
+
+#include <LtsWidgets/lts_dialog.h>
+
+
+#include <AreaEffectSimulation/aes_ftc.h>
+#include <AreaEffectSimulation/logger.h>
+
+namespace Ui
+{
+class ChargeAdministrationList;
+}
+
+namespace LtsSession
+{
+class LtsSession;
+}
+namespace LtsUtils
+{
+class RequestHelper;
+}
+
+namespace AreaEffectSimulation
+{
+class ChargeAdministrationAdlerModel;
+class ChargeAdministrationAdlerSortFilterProxyModel;
+
+class ChargeAdministrationAdlerList final : public LtsWidgets::LtsDialog
+{
+  Q_OBJECT
+public:
+  explicit ChargeAdministrationAdlerList(QWidget *parent = nullptr);
+  ~ChargeAdministrationAdlerList();
+
+  bool init(LtsSession::LtsSession *session);
+
+private slots:
+  void onPrint();
+  void onPartyChanged();
+
+private:
+  void retranslate() override;
+  void tableColumnOrganiserSetting() override;
+  ChargeAdministrationAdlerSortFilterProxyModel *m_model;
+  ChargeAdministrationAdlerModel *m_sourceModel;
+  LtsSession::LtsSession         *m_session;
+  LtsUtils::RequestHelper        *m_requestHelper;
+  Ui::ChargeAdministrationList   *m_ui;
+  LOGGER_T                        m_logger;
+};
+}

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_administration_adler_model.cpp

@@ -0,0 +1,270 @@
+/**
+  * @RDE_HEADER@
+  * AreaEffectManangement - Adler Charge Administration Overview Dialog Model
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  *
+  * Created by Astrid Müller, ESZE, 2025-12-19
+  */
+
+#include "aes_charge_administration_adler_model.h"
+#include <Plugins/ProjectDataManagement/pdm_data_plugin_interface.h>
+#include <Plugins/AreaEffectSimulation/aes_data_plugin_interface.h>
+#include <LtsSession/lts_session.h>
+#include <LtsSession/lts_session_data.h>
+#include <LtsUtilsCore/json_object.h>
+#include <ngltools/ngltools_dtg.h>
+#include <ProjectDataManagement/pdm_translation.h>
+#include <LtsUtilsSettings/settings.h>
+
+
+namespace AreaEffectSimulation
+{
+
+//
+// ChargeAdministrationAdlerSortFilterProxyModel
+//
+void ChargeAdministrationAdlerSortFilterProxyModel::setSourceModel(QAbstractItemModel *model)
+{
+  m_sourceModel = qobject_cast<ChargeAdministrationAdlerModel*>(model);
+  LtsWidgets::LtsColumnFilterProxyModel::setSourceModel(model);
+}
+
+bool ChargeAdministrationAdlerSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
+{
+  if (!m_sourceModel || source_parent.isValid() || source_row < 0 || source_row >= m_sourceModel->rowCount())
+    return LtsWidgets::LtsColumnFilterProxyModel::filterAcceptsRow(source_row, source_parent);
+
+  const ChargeAdministrationAdler &item = m_sourceModel->m_vecData.at(source_row);
+  if (item.partyId != m_party)
+    return false;
+  return LtsWidgets::LtsColumnFilterProxyModel::filterAcceptsRow(source_row, source_parent);
+}
+
+int ChargeAdministrationAdlerSortFilterProxyModel::party() const
+{
+  return m_party;
+}
+
+void ChargeAdministrationAdlerSortFilterProxyModel::setParty(int party)
+{
+  m_party = party;
+  invalidateFilter();
+}
+
+//
+// ChargeAdministrationAdlerModel
+//
+ChargeAdministrationAdlerModel::ChargeAdministrationAdlerModel(QObject *parent)
+  : LtsWidgets::LtsAbstractTableModel<ChargeAdministrationAdler>({tr("Id"),
+                                                                 tr("Charge Type Id"),
+                                                                 tr("Changed"),
+                                                                 tr("Charge Type Name"),
+                                                                 tr("Total Stock"),
+                                                                 tr("Gear Class")},
+                                                                 parent)
+  , m_logger(getLogger("ChargeAdministration"))
+{}
+
+bool ChargeAdministrationAdlerModel::initModel(LtsSession::LtsSession *session)
+{
+  if (!session->getDtc<ProjectDataManagement::DataInterface>(m_pdmDtc))
+    return false;
+
+  if (!session->getDtc<ParticipantManagement::DataInterface>(m_ppmDtc))
+    return false;
+
+  m_DynamicParticipantDataMap = m_ppmDtc->dynamicParticipantDatas();
+  QMapIterator<qint32, ParticipantManagement::DynamicParticipantData> iter(m_DynamicParticipantDataMap);
+  while(iter.hasNext())
+  {
+    iter.next();
+    updateParticipantChargeTypeMap(iter.value());
+  }
+
+  QMap<qint32, ParticipantManagement::Party> parties;
+  if (!m_ppmDtc->visibleParties(parties, LtsSessionData::LtsSessionData::getInstance()->getVisibleParties(session->exerciseId())))
+  {
+    DEBUG_LOG (m_logger) << "Could not retrieve visible Parties!";
+    return false;
+  }
+
+  // fill tableView;
+  for (const ParticipantManagement::Party &p : qAsConst(parties))
+  {
+    updateItem(p.id());
+  }
+
+  connect (m_ppmDtc.get(), &ParticipantManagement::Interface::Dtc::dynamicParticipantDataChanged,
+           this, &ChargeAdministrationAdlerModel::onStateChanged);
+  connect (m_ppmDtc.get(), &ParticipantManagement::Interface::Dtc::participantChanged,
+           this, &ChargeAdministrationAdlerModel::onParticipantChanged);
+
+  return true;
+}
+
+void ChargeAdministrationAdlerModel::onStateChanged(const ParticipantManagement::DynamicParticipantData &data, DataModification modType)
+{
+  switch (modType)
+  {
+  case DataModification::eAdded:
+  case DataModification::eModified:
+  {
+    DEBUG_LOG(m_logger) << "+++++++++ DataModification --> " << modType;
+    updateParticipantChargeTypeMap(data);
+    // TableView update
+    updateItem(m_ppmDtc->participant(data.participantId()).partyId());
+    break;
+  }
+  case DataModification::eRemoved:
+  {
+    break;
+  }
+  }
+}
+
+void ChargeAdministrationAdlerModel::onParticipantChanged(const ParticipantManagement::Participant &data,
+                                                          DataModification modType)
+{
+  Q_UNUSED(modType)
+  qint32 typeId = data.typeId();
+  qint32 participantId = data.id();
+
+  // Only inactive participants are of interest (isDeleted() == true)
+  if (!data.isDeleted() || (!m_ppmDtc->isAdlerType(typeId) &&
+      (m_ppmDtc->type(typeId).typeClass().underlying() != ParticipantManagement::TypeClass::Unit)))
+    return;
+
+  if (m_participantChargeTypeMap.contains(participantId))
+  {
+    // remove chargeType from tableView
+    QList<qint32> keys = m_participantChargeTypeMap.value(participantId).chargeTypeTotalStockMap.keys();
+    for ( int key : keys)
+    {
+      int row = findRowForChargeTypeId(key, m_participantChargeTypeMap.value(participantId).partyId);
+      if (row != -1)
+        removeRow(row);
+    }
+    // remove Participant from Map
+    m_participantChargeTypeMap.remove(participantId);
+  }
+
+  // update tableView
+  updateItem(data.partyId());
+}
+
+void ChargeAdministrationAdlerModel::updateParticipantChargeTypeMap(const ParticipantManagement::DynamicParticipantData &data)
+{
+  qint32 participantId = data.participantId();
+  qint64 sampleTime = data.sampleTime();
+  qint32 typeId = m_ppmDtc->participant(participantId).typeId();
+  bool isDeleted = m_ppmDtc->participant(participantId).isDeleted();
+
+  if (isDeleted || (!m_ppmDtc->isAdlerType(typeId) &&
+      (m_ppmDtc->type(typeId).typeClass().underlying() != ParticipantManagement::TypeClass::Unit)))
+    return;
+
+  QMap<qint32, GearData> chargeTypeGearData;
+  for (const ParticipantManagement::GearInformation &ct : data.gear())
+  {
+    if (m_pdmDtc->adlerChargeTypeName(ct.chargeTypeId()).isEmpty())
+      continue;
+
+    GearData gearData;
+    gearData.remain = ct.remain();
+    gearData.lastUpdate = ct.lastUpdate();
+    if (chargeTypeGearData.contains(ct.chargeTypeId()))
+    {
+      gearData.remain += chargeTypeGearData.value(ct.chargeTypeId()).remain;
+    }
+    chargeTypeGearData.insert(ct.chargeTypeId(), gearData);
+  }
+  m_participantChargeTypeMap.insert(participantId,
+                                    ChargeStruct(participantId, m_ppmDtc->participant(participantId).partyId(),
+                                                 sampleTime, chargeTypeGearData));
+}
+
+void ChargeAdministrationAdlerModel::updateItem(int partyId)
+{
+  QMap<qint32, GearData> chargeTypeGearData;
+  qint64 sampleTime=0;
+  ChargeAdministrationAdler item;
+
+  for (const ChargeStruct &participantCharges : qAsConst(m_participantChargeTypeMap))
+  {
+    if (participantCharges.partyId != partyId)
+      continue;
+    DEBUG_LOG(m_logger) << "+++++++++ ParticipantId -> " << participantCharges.participantId << ", sampleTime ->" << sampleTime;
+    for (auto it = participantCharges.chargeTypeTotalStockMap.cbegin(), end = participantCharges.chargeTypeTotalStockMap.cend(); it != end; ++it)
+    {
+      DEBUG_LOG(m_logger) << "+++++++++ chargeRemain ->" << it.key() << ": " << it.value().remain
+                          << it.value().lastUpdate;
+      GearData data;
+      data.lastUpdate = it.value().lastUpdate;
+      data.remain = it.value().remain;
+      if (chargeTypeGearData.contains(it.key()))
+      {
+        data.remain += chargeTypeGearData.value(it.key()).remain;
+      }
+      if (chargeTypeGearData.contains(it.key()))
+        if (chargeTypeGearData.value(it.key()).lastUpdate > data.lastUpdate)
+          data.lastUpdate = chargeTypeGearData.value(it.key()).lastUpdate;
+
+      chargeTypeGearData.insert(it.key(), data);
+    }
+  }
+
+  item.partyId = partyId;
+  for (auto gearData = chargeTypeGearData.cbegin(), end = chargeTypeGearData.cend(); gearData != end; ++gearData)
+  {
+    DEBUG_LOG(m_logger) << "### PartyId " << item.partyId << " insert item -> chargeTypeId: " << gearData.key() << ", amount: " << gearData.value().remain
+                        << ", lastUpdate:" << gearData.value().lastUpdate;
+
+    item.chargeTypeId = gearData.key();
+    item.sampleTime = gearData.value().lastUpdate;
+    item.amount = gearData.value().remain;
+    int row = findRowForChargeTypeId(item.chargeTypeId, item.partyId);
+    if (row < 0)
+      insertRow(item);
+    else
+      setRowData(row, item);
+  }
+}
+
+int ChargeAdministrationAdlerModel::findRowForChargeTypeId(qint32 typeId, qint32 partyId) const
+{
+  for (int i = 0; i < m_vecData.size(); ++i)
+  {
+    if (m_vecData.at(i).chargeTypeId == typeId && m_vecData.at(i).partyId == partyId)
+      return i;
+  }
+  return -1;
+}
+
+QVariant ChargeAdministrationAdlerModel::data(const QModelIndex &index, int role) const
+{
+  if (role != Qt::DisplayRole || !indexIsValid(index))
+    return QVariant();
+
+  const ChargeAdministrationAdler &item = m_vecData.at(index.row());
+
+  switch (index.column())
+  {
+  case ColId:
+    return item.id;
+  case ColTypeId:
+    return item.chargeTypeId;
+  case ColChanged:
+    return QDateTime::fromMSecsSinceEpoch(item.sampleTime);
+  case ColTypeName:
+    return m_pdmDtc->trChargeTypeShortName(item.chargeTypeId, true);
+  case ColStock:
+    return item.amount;
+  case ColGearClass:
+    return ProjectDataManagement::toString(m_pdmDtc->gearClassFromChargeTypeId(item.chargeTypeId));
+  }
+  return QVariant();
+}
+
+} // namespace AreaEffectSimulation

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_administration_adler_model.h

@@ -0,0 +1,115 @@
+/**
+  * @RDE_HEADER@
+  * AreaEffectManangement - Adler Charge Administration Overview Dialog Model
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  *
+  * Created by Astrid Müller, ESZE, 2025-12-19
+  */
+
+#pragma once
+#include <LtsWidgets/lts_abstract_table_model.h>
+#include <LtsWidgets/lts_column_filter_proxy_model.h>
+#include <AreaEffectSimulation/aes_dtc.h>
+#include <AreaEffectSimulation/logger.h>
+#include <ProjectDataManagement/pdm.hpp>
+#include <Plugins/ParticipantManagement/ppm_data_plugin_interface.h>
+
+namespace LtsSession
+{
+class LtsSession;
+}
+
+namespace ProjectDataManagement {
+namespace Interface {
+class Dtc;
+}
+}
+
+namespace AreaEffectSimulation
+{
+struct ChargeAdministrationAdler
+{
+  qint32 id;
+  qint32 chargeTypeId;
+  qint32 partyId;
+  qint32 amount;
+  qint64 sampleTime;
+};
+
+class ChargeAdministrationAdlerModel : public LtsWidgets::LtsAbstractTableModel<ChargeAdministrationAdler>
+{
+  Q_OBJECT
+
+public:
+  enum Columns
+  {
+    ColId,
+    ColTypeId,
+    ColChanged,
+    ColTypeName,
+    ColStock,
+    ColGearClass
+  };
+
+  explicit ChargeAdministrationAdlerModel(QObject *parent = nullptr);
+
+  bool initModel(LtsSession::LtsSession *session);
+  QVariant data(const QModelIndex &, int role = Qt::DisplayRole) const override final;
+
+private slots:
+  void onStateChanged(const ParticipantManagement::DynamicParticipantData &data, DataModification modType);
+  void onParticipantChanged(const ParticipantManagement::Participant &data, DataModification modType);
+
+private:
+  struct GearData {
+    qint32 remain;
+    qint64 lastUpdate;
+  };
+  struct ChargeStruct
+  {
+    qint32 participantId;
+    qint32 partyId;
+    qint64 sampleTime;
+    QMap<qint32, GearData> chargeTypeTotalStockMap; // QMap<chargeTypeId, GearData>
+    ChargeStruct() {};
+    ChargeStruct(qint32 _participantId, qint32 _partyId, qint64 _sampleTime, QMap<qint32, GearData> _chargeTypeTotalStock)
+      : participantId(_participantId), partyId(_partyId), sampleTime(_sampleTime), chargeTypeTotalStockMap(_chargeTypeTotalStock) {}
+  };
+
+  void updateParticipantChargeTypeMap(const ParticipantManagement::DynamicParticipantData &data);
+  void updateItem(int partyId);
+
+  std::shared_ptr<ParticipantManagement::Interface::Dtc>      m_ppmDtc;
+  std::shared_ptr<ProjectDataManagement::Interface::Dtc>      m_pdmDtc;
+  QMap<qint32, ParticipantManagement::DynamicParticipantData> m_DynamicParticipantDataMap;
+  QMap<qint32, ChargeStruct>                                  m_participantChargeTypeMap;
+  LOGGER_T                                                    m_logger;
+
+  friend class ChargeAdministrationAdlerSortFilterProxyModel;
+  int findRowForChargeTypeId(qint32 typeId, qint32 partyId) const;
+};
+
+class ChargeAdministrationAdlerSortFilterProxyModel final : public LtsWidgets::LtsColumnFilterProxyModel
+{
+  Q_OBJECT
+
+public:
+  using LtsWidgets::LtsColumnFilterProxyModel::LtsColumnFilterProxyModel;
+
+  void setSourceModel(QAbstractItemModel *model) override;
+  int party() const;
+
+public slots:
+  void setParty(int party);
+
+protected:
+  bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
+
+private:
+  ChargeAdministrationAdlerModel *m_sourceModel = nullptr;
+  int m_party = 0;
+};
+
+} //namespace AreaEffectSimulation

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_administration_gui_plugin.cpp

@@ -0,0 +1,74 @@
+/**
+  * @RDE_HEADER@
+  * GUI Plugin for AreaEffectSimulation - NContaminations
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Patric Karwat, SLSE, 2016-07-07
+  */
+
+#include "aes_charge_administration_gui_plugin.h"
+#include "aes_charge_administration_list.h"
+#include "aes_charge_administration_adler_list.h"
+
+#include <AreaEffectSimulation/aes_operator_rights.h>
+#include <LtsUtilsSettings/settings.h>
+#include <LtsSession/lts_session.h>
+
+namespace AreaEffectSimulation
+{
+
+std::shared_ptr<GuiPluginBase::Interface> GuiPlugin::createGuiInterface(LtsSession::LtsSession *session)
+{
+  return std::make_shared<InterfaceImpl>(session);
+}
+
+InterfaceImpl::InterfaceImpl(LtsSession::LtsSession *session)
+  : AesBaseInterface(session, getLogger("Plugins.Gui.ChargeAdministration"))
+{}
+
+QVector<LtsWidgets::PluginData> InterfaceImpl::getActions()
+{
+  QVector<LtsWidgets::PluginData> ret;
+
+  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
+  const bool enableChargeAdministration = ps->value(QStringLiteral("aes"),
+                                                    QStringLiteral("enableChargeAdministration")).toBool();
+
+  if (enableChargeAdministration && m_session->app() != LtsAppDescriptor::App::OC)
+  {
+    // Charge Administration
+    ret.append(LtsWidgets::PluginData(menuGroup(),
+                                      tr("Charge Administration"),
+                                      QLatin1String("aesShowChargeAdministration"),
+                                      QIcon(QLatin1String("icon:mortar_ammunition_administration.svg")),
+                                      [this](QWidget *parent) { return onShowChargeAdministrationListDialog(parent);},
+               OperatorRights::ChargeAdministrationShow,
+               LtsWidgets::ExercisePart::eExecution));
+    // Charge Administration Adler
+    ret.append(LtsWidgets::PluginData(menuGroup(),
+                                      tr("Charge Administration Adler"),
+                                      QLatin1String("aesShowChargeAdministrationAdler"),
+                                      QIcon(QLatin1String("icon:mortar_ammunition_administration.svg")),
+                                      [this](QWidget *parent) { return onShowChargeAdministrationAdlerListDialog(parent);},
+               OperatorRights::ChargeAdministrationShow,
+               LtsWidgets::ExercisePart::eExecution));
+  }
+  return ret;
+}
+
+LtsWidgets::LtsDialog *InterfaceImpl::onShowChargeAdministrationListDialog(QWidget *parent)
+{
+  ChargeAdministrationList *dialog = new ChargeAdministrationList(parent);
+  dialog->init(m_session);
+  return dialog;
+}
+
+LtsWidgets::LtsDialog *InterfaceImpl::onShowChargeAdministrationAdlerListDialog(QWidget *parent)
+{
+  ChargeAdministrationAdlerList *dialog = new ChargeAdministrationAdlerList(parent);
+  dialog->init(m_session);
+  return dialog;
+}
+
+} // namespace AreaEffectSimulation

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_administration_gui_plugin.h

@@ -0,0 +1,49 @@
+/**
+  * @RDE_HEADER@
+  * Gui Plugin for AreaEffectSimulation - NContamniations
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Patric Karwat, SLSE, 2016-07-07
+  */
+
+#pragma once
+
+#include <Plugins/AreaEffectSimulation/Gui/Base/aes_base_gui_plugin.h>
+
+namespace AreaEffectSimulation
+{
+
+class GuiPlugin final : public AesBaseGuiPlugin
+{
+  Q_PLUGIN_METADATA(IID "gui:3:aes.chargeadministration")
+  Q_OBJECT
+
+public:
+  GuiPlugin() = default;
+  ~GuiPlugin() = default;
+
+  QString pluginName() override { return QStringLiteral("AreaEffectSimuationChargeAdministrationGui"); }
+  std::shared_ptr<GuiPluginBase::Interface> createGuiInterface(LtsSession::LtsSession *session) override;
+  bool availableInPartition(IDL::PartitionType partition) const override
+  {
+    return partition == IDL::PartitionType::Exercise;
+  }
+};
+
+class InterfaceImpl final : public AesBaseInterface
+{
+  Q_OBJECT
+
+public:
+  explicit InterfaceImpl(LtsSession::LtsSession *session);
+
+  QVector<LtsWidgets::PluginData> getActions() override;
+
+private:
+  LtsWidgets::LtsDialog *onShowChargeAdministrationListDialog(QWidget *parent);
+  LtsWidgets::LtsDialog *onShowChargeAdministrationAdlerListDialog(QWidget *parent);
+
+};
+
+} // namespace AreaEffectSimulation

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_administration_list.cpp

@@ -0,0 +1,194 @@
+/**
+ * @RDE_HEADER@
+ * ContaminationManangement - NContamination Overview Dialog
+ * $Id$
+ * $HeadURL$
+ * $Author$
+ * Created by Patric Karwat, SLSE, 2016-07-07
+ */
+
+#include "aes_charge_administration_list.h"
+#include "CustomView/aes_charge_administration.h"
+#include "aes_charge_administration_model.h"
+#include "aes_charge_edit.h"
+#include "ui_aes_charge_administration_list.h"
+#include <LtsSession/lts_session.h>
+#include <LtsUtilsGuiDds/request_helper.h>
+#include <LtsWidgets/lts_combo_box.h>
+#include <LtsWidgets/lts_dialog.h>
+
+#include <QInputDialog>
+#include <PluginInterfaces/gui_plugin_interface.h>
+#include <Plugins/AreaEffectSimulation/aes_data_plugin_interface.h>
+#include <Plugins/ParticipantManagement/ppm_gui_combobox_plugin_interface.h>
+
+#include <QTreeView>
+#include <LtsPrinting/printing.h>
+
+namespace AreaEffectSimulation
+{
+
+ChargeAdministrationList::ChargeAdministrationList(QWidget *parent)
+    : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
+    , m_model(nullptr)
+    , m_sourceModel(nullptr)
+    , m_session(nullptr)
+    , m_ftc(nullptr)
+    , m_requestHelper(new LtsUtils::RequestHelper(this))
+    , m_ui(new Ui::ChargeAdministrationList)
+    , m_logger(getLogger("ChargeAdministrationList"))
+{
+  m_ui->setupUi(this);
+
+  connect(m_ui->cbParty,
+          static_cast<void (LtsWidgets::LtsComboBox::*)(int)>(&LtsWidgets::LtsComboBox::currentIndexChanged),
+          this,
+          &ChargeAdministrationList::onPartyChanged);
+
+  setOnlineHelpFilename(QStringLiteral("Situation-Charge_Administration"));
+}
+
+ChargeAdministrationList::~ChargeAdministrationList() { delete m_ui; }
+
+void ChargeAdministrationList::retranslate() { translate(m_ui, tr("Charge Administration")); }
+
+void ChargeAdministrationList::enaDisa()
+{
+  LtsWidgets::ExerciseStates allowedStates = LtsWidgets::ExerciseState::eCreated | LtsWidgets::ExerciseState::eStarted | LtsWidgets::ExerciseState::ePaused;
+  bool bIsAllowedInState = allowedStates.testFlag(m_session->exerciseState());
+
+  m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, bIsAllowedInState && m_ui->widget->selectedRows().count() > 0);
+  m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, bIsAllowedInState && m_ui->widget->selectedRows().count() > 0);
+}
+
+void ChargeAdministrationList::onPartyChanged() { m_model->setParty(m_ui->cbParty->currentData().toInt()); }
+
+void ChargeAdministrationList::onChargeAdministrationModifyReply(const Core::FunctionReplyObject &replyObject) { m_requestHelper->requestReply(replyObject); }
+
+void ChargeAdministrationList::tableColumnOrganiserSetting()
+{
+  // LtsColumnOrganiser
+  m_ui->widget->setColumnsOrganiserEnabled(identifier(), true);
+}
+
+bool ChargeAdministrationList::init(LtsSession::LtsSession *session)
+{
+  if (m_session)
+  {
+    ERROR_LOG(m_logger) << "double init()!";
+    return false;
+  }
+  m_session = session;
+
+  if (m_session->app() != LtsAppDescriptor::App::OC)
+  {
+    m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &ChargeAdministrationList::onEditCharge);
+    connect(m_ui->widget, &LtsDataView::LtsDataView::signalDoubleClicked, this, &ChargeAdministrationList::onEditCharge);
+    connect(m_ui->widget, &LtsDataView::LtsDataView::signalEnterPressed, this, &ChargeAdministrationList::onEditCharge);
+  }
+
+  m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &ChargeAdministrationList::onPrint);
+
+  // FIXME: keine ifcs ausserhalb des GUI Plugins holen ...
+  // std::shared_ptr<ParticipantManagement::ForeignGuiComboboxInterface> ppmGuiCbxIfc;
+
+  if (!m_session->getFtc<AreaEffectSimulation::DataInterface>(m_ftc))
+    return false;
+
+  std::shared_ptr<ParticipantManagement::ForeignGuiComboboxInterface> ppmGuiCbxIfc;
+  if (!m_session->getForeignGuiInterface<ParticipantManagement::ForeignGuiComboboxInterface>(ppmGuiCbxIfc))
+    return false;
+
+  m_sourceModel = new ChargeAdministrationModel(this);
+
+  QVector<ChargeAdministrationModifyRequest> reqs;
+  if (!m_sourceModel->initModel(m_session, reqs))
+    return false;
+
+  if (!reqs.isEmpty())
+  {
+    for (const ChargeAdministrationModifyRequest &req : qAsConst(reqs))
+    {
+      m_requestHelper->addRequest([this, req]() { return m_ftc->chargeAdministrationModifyRequest(req, this); });
+    }
+    m_requestHelper->startRequests();
+  }
+
+  m_model = new ChargeAdministrationSortFilterProxyModel(this);
+  m_model->setSourceModel(m_sourceModel);
+  m_ui->widget->setModel(m_model, [this]() { return new CustomViewChargeAdministration(this); });
+
+  connect(m_ui->widget, &LtsDataView::LtsDataView::signalSelectionChanged, this, &ChargeAdministrationList::enaDisa);
+
+#ifndef LTS_DEBUG
+  bool onlydebugMode = true;
+  m_ui->widget->hideColumn(ChargeAdministrationModel::ColId, onlydebugMode);
+  m_ui->widget->hideColumn(ChargeAdministrationModel::ColTypeId, onlydebugMode);
+  m_ui->widget->hideColumn(ChargeAdministrationModel::ColChanged, onlydebugMode);
+#endif
+
+  // Todo: setColumnHidden(MineAreasModel::BcColumns::ColPlayer);
+
+  m_ui->widget->setSortIndicator(ChargeAdministrationModel::ColTypeName, Qt::AscendingOrder);
+
+  enaDisa();
+
+  ppmGuiCbxIfc->fillPartyComboBox(m_ui->cbParty);
+  onPartyChanged();
+
+  return true;
+}
+
+void ChargeAdministrationList::onPrint()
+{
+  QString header;
+  header += QStringLiteral("<p>");
+  header += tr("Party: %1").arg(m_ui->cbParty->currentText());
+  header += QStringLiteral("<br/>");
+  header += QStringLiteral("</p>");
+
+  LtsPrinting::printView(m_session, this, m_ui->widget->treeView(), header);
+}
+
+void ChargeAdministrationList::onEditCharge()
+{
+  ChargeAdministration item = m_sourceModel->getRowData(m_ui->widget->currentIndex().row());
+
+  if (item.id() < 0)
+    return;
+
+  ProjectDataManagement::ChargeType ct = m_sourceModel->chargeType(item.chargeTypeId());
+
+  const QModelIndex temp = m_ui->widget->currentIndex();
+
+  const QModelIndex mi = temp.sibling(temp.row(), ChargeAdministrationModel::ColTypeName);
+  auto ce = new ChargeEdit(ct.id(), m_sourceModel->data(mi).toString(), item.amount(), this);
+  connect(ce, &ChargeEdit::newStock, this, &ChargeAdministrationList::onChargeEditFinished);
+  connect(ce, &ChargeEdit::newStock, ce, &ChargeEdit::deleteLater);
+  ce->show();
+}
+
+void ChargeAdministrationList::onChargeEditFinished(int chargeId, int newStock)
+{
+  ChargeAdministration item = m_sourceModel->getRowData(m_ui->widget->currentIndex().row());
+
+  if (item.chargeTypeId() != chargeId) // sanity
+    return;
+
+  if (item.amount() == newStock)
+    return;
+  item.amount(newStock);
+
+  bool amountChangedByOperator = true;
+  const ChargeAdministrationModifyRequest req(item.id(),
+                                              item.chargeTypeId(),
+                                              item.partyId(),
+                                              item.effectSourceId(),
+                                              item.amount(),
+                                              amountChangedByOperator); // relativeAmount
+
+  m_requestHelper->addRequest([this, req]() { return m_ftc->chargeAdministrationModifyRequest(req, this); });
+  m_requestHelper->startRequests();
+}
+
+} // namespace AreaEffectSimulation

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_administration_list.h

@@ -0,0 +1,66 @@
+/**
+  * @RDE_HEADER@
+  * AreaEffectSimulation - Contamination Overview Dialog
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Patric Karwat, SLSE, 2016-07-07
+  */
+
+#pragma once
+
+#include <LtsWidgets/lts_dialog.h>
+
+
+#include <AreaEffectSimulation/aes_ftc.h>
+#include <AreaEffectSimulation/logger.h>
+
+namespace Ui
+{
+class ChargeAdministrationList;
+}
+
+namespace LtsSession
+{
+class LtsSession;
+}
+namespace LtsUtils {
+class RequestHelper;
+}
+
+namespace AreaEffectSimulation
+{
+class ChargeAdministrationModel;
+class ChargeAdministrationSortFilterProxyModel;
+
+class ChargeAdministrationList final : public LtsWidgets::LtsDialog
+    , protected AreaEffectSimulation::Interface::Ftc::ChargeAdministrationModifyReplyHandler
+{
+  Q_OBJECT
+public:
+  explicit ChargeAdministrationList(QWidget *parent = nullptr);
+  ~ChargeAdministrationList();
+
+  bool init(LtsSession::LtsSession *session);
+private slots:
+  void onPrint();
+  void onEditCharge();
+  void enaDisa();
+  void onPartyChanged();
+  void onChargeEditFinished(int chargeId, int newStock);
+
+private:
+  void retranslate() override;
+  void onChargeAdministrationModifyReply(const Core::FunctionReplyObject &replyObject) override;
+  void tableColumnOrganiserSetting() override;
+  ChargeAdministrationSortFilterProxyModel *m_model;
+  ChargeAdministrationModel *m_sourceModel;  
+  LtsSession::LtsSession       *m_session;
+  std::shared_ptr<AreaEffectSimulation::Interface::Ftc> m_ftc;
+  LtsUtils::RequestHelper      *m_requestHelper;
+  Ui::ChargeAdministrationList *m_ui;
+  LOGGER_T                      m_logger;
+// QVector<LtsWidgets::ColumnOrganiserInfo> m_columnOrganiserInfo;
+  QMap<int, int> m_columnVisualOrder; // key: logicalindex, value: visualIndex
+};
+}

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_administration_list.ui

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ChargeAdministrationList</class>
+ <widget class="QWidget" name="ChargeAdministrationList">
+  <property name="windowTitle">
+   <string notr="true">Charge Administration List</string>
+  </property>
+  <property name="toolTip">
+   <string/>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="0">
+    <widget class="QLabel" name="label">
+     <property name="text">
+      <string>Party:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="1">
+    <widget class="LtsWidgets::LtsComboBox" name="cbParty">
+     <property name="const" stdset="0">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="2">
+    <spacer name="horizontalSpacer">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>278</width>
+       <height>20</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item row="1" column="0" colspan="3">
+    <widget class="LtsDataView::LtsDataView" name="widget">
+     <property name="toolTip">
+      <string/>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>LtsWidgets::LtsComboBox</class>
+   <extends>QComboBox</extends>
+   <header>LtsWidgets/lts_combo_box.h</header>
+  </customwidget>
+  <customwidget>
+   <class>LtsDataView::LtsDataView</class>
+   <extends>QWidget</extends>
+   <header>LtsDataView/lts_data_view.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_administration_model.cpp

@@ -0,0 +1,179 @@
+/**
+ * @RDE_HEADER@
+ * AreaEffectManangement - N Contamination Overview Dialog Model
+ * $Id$
+ * $HeadURL$
+ * $Author$
+ *
+ * Created by Malte Diers, SLSE, 2017-02-21
+ */
+
+#include "aes_charge_administration_model.h"
+#include <LtsSession/lts_session.h>
+#include <LtsSession/lts_session_data.h>
+#include <LtsUtilsCore/json_object.h>
+#include <LtsUtilsSettings/settings.h>
+#include <Plugins/AreaEffectSimulation/aes_data_plugin_interface.h>
+#include <Plugins/ParticipantManagement/ppm_data_plugin_interface.h>
+#include <Plugins/ProjectDataManagement/pdm_data_plugin_interface.h>
+#include <ProjectDataManagement/pdm_translation.h>
+#include <ngltools/ngltools_dtg.h>
+
+namespace AreaEffectSimulation
+{
+
+//
+// ChargeAdministrationSortFilterProxyModel
+//
+
+void ChargeAdministrationSortFilterProxyModel::setSourceModel(QAbstractItemModel *model)
+{
+  m_sourceModel = qobject_cast<ChargeAdministrationModel *>(model);
+  LtsWidgets::LtsColumnFilterProxyModel::setSourceModel(model);
+}
+
+bool ChargeAdministrationSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
+{
+  if (!m_sourceModel || source_parent.isValid() || source_row < 0 || source_row >= m_sourceModel->rowCount())
+    return LtsWidgets::LtsColumnFilterProxyModel::filterAcceptsRow(source_row, source_parent);
+
+  const ChargeAdministration &item = m_sourceModel->m_vecData.at(source_row);
+  if (item.partyId() != m_party)
+    return false;
+  return LtsWidgets::LtsColumnFilterProxyModel::filterAcceptsRow(source_row, source_parent);
+}
+
+int ChargeAdministrationSortFilterProxyModel::party() const { return m_party; }
+
+void ChargeAdministrationSortFilterProxyModel::setParty(int party)
+{
+  m_party = party;
+  invalidateFilter();
+}
+
+//
+// ChargeAdministrationModel
+//
+ChargeAdministrationModel::ChargeAdministrationModel(QObject *parent)
+    : LtsWidgets::LtsAbstractTableModel<ChargeAdministration>({tr("Id"),
+                                                               tr("Charge Type Id"),
+                                                               tr("Changed"),
+                                                               tr("Charge Type Name"),
+                                                               tr("Total Stock"),
+                                                               tr("Planned"),
+                                                               tr("Available"),
+                                                               tr("Used"),
+                                                               tr("Gear Class")},
+                                                              parent)
+    , m_logger(getLogger("ChargeAdministration"))
+{
+}
+
+bool ChargeAdministrationModel::initModel(LtsSession::LtsSession *session, QVector<ChargeAdministrationModifyRequest> &reqs)
+{
+  if (m_aesDtc)
+  {
+    ERROR_LOG(m_logger) << "double init()!";
+    return false;
+  }
+
+  if (!session->getDtc<AreaEffectSimulation::DataInterface>(m_aesDtc))
+    return false;
+
+  std::shared_ptr<ParticipantManagement::Interface::Dtc> ppmDtc;
+
+  if (!session->getDtc<ProjectDataManagement::DataInterface>(m_pdmDtc))
+    return false;
+
+  if (!session->getDtc<ParticipantManagement::DataInterface>(ppmDtc))
+    return false;
+
+  m_chargeTypeMap = m_pdmDtc->chargeTypes();
+
+  connect(m_aesDtc.get(), &Interface::Dtc::chargeAdministrationChanged, this, &ChargeAdministrationModel::onChargeAdministrationChanged);
+
+  QVector<QPair<int, int>> chargesInserted;
+  auto cb = [this, &chargesInserted](const ChargeAdministration &item)
+  {
+    // skip ADLER charges
+    const int chargeTypeId = item.chargeTypeId();
+    if (m_pdmDtc->isAdlerChargeType(chargeTypeId))
+      return;
+
+    insertRow(item);
+    chargesInserted.append(qMakePair<int, int>(item.chargeTypeId(), item.partyId()));
+  };
+  m_aesDtc->chargeAdministrations(cb);
+
+  QMap<qint32, ParticipantManagement::Party> parties;
+  if (!ppmDtc->visibleParties(parties, LtsSessionData::LtsSessionData::getInstance()->getVisibleParties(session->exerciseId())))
+  {
+    ERROR_LOG(m_logger) << "Could not retrieve visible Parties!";
+    return false;
+  }
+
+  QVector<ProjectDataManagement::ChargeType> chargesForGearClass
+      = m_pdmDtc->chargesForGearClass(ProjectDataManagement::GearClass_def::Artillery) + m_pdmDtc->chargesForGearClass(ProjectDataManagement::GearClass_def::Mortar);
+
+  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
+  const bool enableRocket = ps->value(QStringLiteral("aes"), QStringLiteral("enableRocket"), false).toBool();
+  if (enableRocket)
+    chargesForGearClass += m_pdmDtc->chargesForGearClass(ProjectDataManagement::GearClass_def::Rocket);
+  for (const ParticipantManagement::Party &p : qAsConst(parties))
+  {
+    for (const ProjectDataManagement::ChargeType &ct : qAsConst(chargesForGearClass))
+    {
+      if (chargesInserted.contains(qMakePair(ct.id(), p.id())) || isDummy(ct) || m_pdmDtc->isAdlerChargeType(ct.id()))
+        continue;
+
+      reqs << ChargeAdministrationModifyRequest(0, ct.id(), p.id(), ProjectDataManagement::EffectSource::ES_Internal, 0, true); // amountChangedByOperator=true
+    }
+  }
+  return true;
+}
+
+bool ChargeAdministrationModel::isDummy(const ProjectDataManagement::ChargeType &ct)
+{
+  return LtsUtils::JsonObject::fromJson(ct.properties()).valueOr<bool>("isDummy", false);
+}
+
+QVariant ChargeAdministrationModel::data(const QModelIndex &index, int role) const
+{
+  if (role != Qt::DisplayRole || !indexIsValid(index))
+    return QVariant();
+
+  const ChargeAdministration &item = m_vecData.at(index.row());
+
+  switch (index.column())
+  {
+    case ColId:
+      return item.id();
+    case ColTypeId:
+      return item.chargeTypeId();
+    case ColChanged:
+      return QDateTime::fromMSecsSinceEpoch(item.sampleTime());
+    case ColTypeName:
+      return m_pdmDtc->trChargeTypeShortName(item.chargeTypeId(), true);
+    case ColStock:
+      return item.amount();
+    case ColAvailable:
+      return item.amount() - item.planned();
+    case ColPlanned:
+      return item.planned();
+    case ColUsed:
+      return item.used();
+    case ColGearClass:
+      return ProjectDataManagement::toString(m_pdmDtc->gearClassFromChargeTypeId(item.chargeTypeId()));
+  }
+  return QVariant();
+}
+
+void ChargeAdministrationModel::onChargeAdministrationChanged(const ChargeAdministration &data, DataModification modType)
+{
+  // skip ADLER charges
+  if (m_pdmDtc->isAdlerChargeType(data.chargeTypeId()))
+    return;
+  onDataChanged(data, modType);
+}
+
+} // namespace AreaEffectSimulation

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_administration_model.h

@@ -0,0 +1,94 @@
+/**
+  * @RDE_HEADER@
+  * HMI Plugin for AreaEffectSimulation - Contaminations Overview Dialog Model
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  *
+  * Created by Malte Diers, SLSE, 2017-02-20
+  */
+
+#pragma once
+#include <LtsWidgets/lts_abstract_table_model.h>
+#include <LtsWidgets/lts_column_filter_proxy_model.h>
+#include <AreaEffectSimulation/aes_dtc.h>
+#include <AreaEffectSimulation/logger.h>
+#include <ProjectDataManagement/pdm.hpp>
+
+namespace LtsSession
+{
+class LtsSession;
+}
+
+namespace ProjectDataManagement {
+namespace Interface {
+class Dtc;
+}
+}
+
+namespace AreaEffectSimulation
+{
+
+class ChargeAdministrationModel : public LtsWidgets::LtsAbstractTableModel<ChargeAdministration>
+{
+  Q_OBJECT
+
+public:
+  enum Columns
+  {
+    ColId,
+    ColTypeId,
+    ColChanged,
+    ColTypeName,
+    ColStock,
+    ColPlanned,
+    ColAvailable,
+    ColUsed,
+    ColGearClass
+  };
+
+  explicit ChargeAdministrationModel(QObject *parent = nullptr);
+
+  bool initModel(LtsSession::LtsSession *session, QVector<ChargeAdministrationModifyRequest> &reqs);
+  QVariant data(const QModelIndex &, int role = Qt::DisplayRole) const override final;
+
+  ProjectDataManagement::ChargeType chargeType(int id) const { return m_chargeTypeMap.value(id); }
+
+private slots:
+  void onChargeAdministrationChanged(const AreaEffectSimulation::ChargeAdministration &data, DataModification modType);
+
+private:
+  bool isDummy(const ProjectDataManagement::ChargeType &ct);
+
+private:
+  std::shared_ptr<AreaEffectSimulation::Interface::Dtc>    m_aesDtc;
+  std::shared_ptr<ProjectDataManagement::Interface::Dtc>   m_pdmDtc;
+  QMap<qint32, ProjectDataManagement::ChargeType> m_chargeTypeMap;
+  LOGGER_T   m_logger;
+
+  friend class ChargeAdministrationSortFilterProxyModel;
+};
+
+class ChargeAdministrationSortFilterProxyModel final : public LtsWidgets::LtsColumnFilterProxyModel
+{
+  Q_OBJECT
+
+public:
+  using LtsWidgets::LtsColumnFilterProxyModel::LtsColumnFilterProxyModel;
+
+  void setSourceModel(QAbstractItemModel *model) override;
+  int party() const;
+
+public slots:
+  void setParty(int party);
+
+protected:
+  bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
+
+private:
+  ChargeAdministrationModel *m_sourceModel = nullptr;
+  int m_party = 0;
+};
+
+
+} //namespace AreaEffectSimulation

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_edit.cpp

@@ -0,0 +1,47 @@
+/**
+  * @RDE_HEADER@
+  * ContaminationManangement - ChargeEdit Dlg
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Patric Karwat, SLSE, 2019-05-17
+  */
+
+#include "aes_charge_edit.h"
+#include "ui_aes_charge_edit.h"
+
+namespace AreaEffectSimulation
+{
+
+ChargeEdit::ChargeEdit(int chargeId, const QString &charge, int oldStock, QWidget *parent)
+  : LtsWidgets::LtsFramelessDialog(parent, LtsWidgets::Behaviour::Modal)
+  , m_chargeId(chargeId)
+  , m_oldStock(oldStock)
+  , m_buttonBox(new LtsWidgets::LtsDialogButtonBox(this))
+  , m_ui(new Ui::ChargeEdit)
+{
+  m_ui->setupUi(this);
+  m_ui->verticalLayout->addWidget(m_buttonBox);
+
+  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked,
+          this, &ChargeEdit::onSendStock);
+  connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Ok), &QPushButton::clicked,
+          this, &ChargeEdit::onSendStock);
+  m_ui->spStock->setValue(oldStock);
+  m_ui->lblCharge->setText(charge);
+}
+
+ChargeEdit::~ChargeEdit()
+{
+  delete m_ui;
+}
+
+void ChargeEdit::onSendStock()
+{
+  if (sender() == m_buttonBox->getButton(LtsWidgets::DialogButton::Close))
+    emit newStock(m_chargeId, m_oldStock);
+  else
+    emit newStock(m_chargeId, m_ui->spStock->value());
+}
+
+} // namespace AreaEffectSimulation

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_edit.h

@@ -0,0 +1,42 @@
+/**
+  * @RDE_HEADER@
+  * AreaEffectSimulation - ChargeEdit Dlg
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Patric Karwat, SLSE, 2019-05-17
+  */
+
+#pragma once
+
+#include <LtsWidgets/lts_frameless_dialog.h>
+#include <LtsWidgets/lts_dialog_button_box.h>
+
+namespace Ui
+{
+class ChargeEdit;
+}
+
+namespace AreaEffectSimulation
+{
+
+class ChargeEdit : public LtsWidgets::LtsFramelessDialog
+{
+  Q_OBJECT
+public:
+  explicit ChargeEdit(int chargeId, const QString &charge, int oldStock, QWidget *parent = nullptr);
+  ~ChargeEdit();
+
+private slots:
+  void onSendStock();
+
+signals:
+  void newStock(int chargeId, int newStock);
+private:
+  int m_chargeId;
+  int m_oldStock;
+  LtsWidgets::LtsDialogButtonBox *m_buttonBox;
+  Ui::ChargeEdit *m_ui;
+
+};
+}

Lts/Plugins/AreaEffectSimulation/Gui/ChargeAdministration/aes_charge_edit.ui

@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ChargeEdit</class>
+ <widget class="QWidget" name="ChargeEdit">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>193</width>
+    <height>58</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string notr="true">Charge Administration List</string>
+  </property>
+  <property name="toolTip">
+   <string/>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QLabel" name="label">
+       <property name="text">
+        <string>New Stock for:</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QLabel" name="lblCharge">
+       <property name="text">
+        <string notr="true">&lt;CHARGE&gt;</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QSpinBox" name="spStock">
+     <property name="maximum">
+      <number>9999999</number>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>