Initial commit

Lts/Plugins/ServiceMonitor/Gui/EquipmentErrorRegistration/CMakeLists.txt

@@ -0,0 +1,34 @@
+#
+# $Id$
+# $HeadURL$
+# $Author$
+# Created by Christian Roeskens, NLSE, 2018-05-02
+#
+
+SET(smo_equipment_error_registration_gui_SRCS
+  smo_equipment_error_registration_dialog.cpp
+  smo_equipment_error_registration_dialog.h
+  smo_equipment_error_registration_model.cpp
+  smo_equipment_error_registration_model.h
+  smo_equipment_error_registration_gui_plugin.cpp
+  smo_equipment_error_registration_gui_plugin.h
+)
+
+NGL_WRAP_UI(smo_equipment_error_registration_gui_SRCS
+  smo_equipment_error_registration_dialog.ui
+)
+
+NGL_ADD_LIBRARY(WS SmoEquipmentErrorRegistrationGuiPlugin MODULE ${smo_equipment_error_registration_gui_SRCS})
+NGL_TARGET_LINK_LIBRARIES(SmoEquipmentErrorRegistrationGuiPlugin
+  ExmDataPluginInterface
+  LtsDataView
+  LtsPrinting
+  LtsSession
+  LtsUtilsSettings
+  ngltools
+  SmoCommon
+  svcSmoDummy
+  TlnDataPluginInterface
+)
+
+NGL_INSTALL_TARGET(SmoEquipmentErrorRegistrationGuiPlugin)

Lts/Plugins/ServiceMonitor/Gui/EquipmentErrorRegistration/smo_equipment_error_registration_dialog.cpp

@@ -0,0 +1,84 @@
+/**
+  * @RDE_HEADER@
+  * Handgrande and mine search dialog
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Roeskens, NLSE, 2018-05-02
+  */
+
+#include "smo_equipment_error_registration_dialog.h"
+#include "ui_smo_equipment_error_registration_dialog.h"
+
+#include "smo_equipment_error_registration_model.h"
+
+#include <Plugins/Timeline/tln_data_plugin_interface.h>
+#include <Plugins/ParticipantManagement/Data/ppm_data_plugin.h>
+#include <Common/logger.h>
+
+#include <LtsPrinting/printing.h>
+#include <QTreeView>
+
+namespace ServiceMonitor
+{
+
+EquipmentErrorRegistrationDialog::EquipmentErrorRegistrationDialog(QWidget *parent)
+  : LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
+  , m_session(nullptr)
+  , m_ui(new Ui::EquipmentErrorRegistrationDialog)
+  , m_logger(getLogger("EquipmentErrorRegistrationDialog"))
+{
+  m_ui->setupUi(this);
+  m_buttonBox->connectButton(LtsWidgets::DialogButton::Print, this, &EquipmentErrorRegistrationDialog::onPrint);
+
+  setOnlineHelpFilename(QStringLiteral("Situation-Registration_Equipment_Failure"));
+}
+
+EquipmentErrorRegistrationDialog::~EquipmentErrorRegistrationDialog()
+{
+  delete m_ui;
+}
+
+bool EquipmentErrorRegistrationDialog::init(LtsSession::LtsSession *session,
+                                  const std::shared_ptr<TimeLineManagement::ForeignDataInterface> &eemForeign,
+                                  const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc)
+{
+  m_session = session;
+
+  auto model = new EquipmentErrorRegistrationModel(this);
+  connect(model, &EquipmentErrorRegistrationModel::chunksUpdated,
+          this, &EquipmentErrorRegistrationDialog::onChunksUpdated);
+  model->initModel(m_session, eemForeign, exmDtc);
+
+  auto proxy = new EquipmentErrorRegistrationProxyModel(this);
+  proxy->setSourceModel(model);
+  m_ui->dvList->setModel(proxy);
+
+  return true;
+}
+
+void EquipmentErrorRegistrationDialog::onChunksUpdated(int chunksReceived, int chunksRequested)
+{
+  m_ui->pbLoading->setValue(chunksReceived);
+  m_ui->pbLoading->setMaximum(chunksRequested);
+  m_ui->pbLoading->setVisible(chunksReceived != chunksRequested);
+  m_ui->lblLoading->setVisible(chunksReceived != chunksRequested);
+}
+
+void EquipmentErrorRegistrationDialog::onPrint()
+{
+  LtsPrinting::printView(m_session, this, m_ui->dvList->treeView() );
+}
+
+void EquipmentErrorRegistrationDialog::retranslate()
+{
+  translate(m_ui, tr("Equipment Error Registration"));
+}
+
+void EquipmentErrorRegistrationDialog::tableColumnOrganiserSetting()
+{
+  //LtsColumnOrganiser
+  m_ui->dvList->setColumnsOrganiserEnabled(identifier(), true);
+}
+
+}

Lts/Plugins/ServiceMonitor/Gui/EquipmentErrorRegistration/smo_equipment_error_registration_dialog.h

@@ -0,0 +1,58 @@
+/**
+  * @RDE_HEADER@
+  * Handgrande and mine search dialog
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Roeskens, NLSE, 2018-05-02
+  */
+#pragma once
+
+#include <LtsWidgets/lts_dialog.h>
+#include <LtsSession/lts_session.h>
+
+namespace TimeLineManagement
+{
+class ForeignDataInterface;
+}
+namespace ExerciseManagement
+{
+namespace Interface
+{
+class Dtc;
+}
+}
+
+namespace Ui
+{
+class EquipmentErrorRegistrationDialog;
+}
+
+namespace ServiceMonitor
+{
+class EquipmentErrorRegistrationDialog : public LtsWidgets::LtsDialog
+{
+  Q_OBJECT
+public:
+  explicit EquipmentErrorRegistrationDialog(QWidget *parent = nullptr);
+  ~EquipmentErrorRegistrationDialog();
+
+  bool init(LtsSession::LtsSession *session,
+            const std::shared_ptr<TimeLineManagement::ForeignDataInterface> &eemForeign,
+            const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc);
+
+public slots:
+  void onChunksUpdated(int chunksReceived, int chunksRequested);
+  void onPrint();
+
+private:
+  void retranslate() override;
+  void tableColumnOrganiserSetting() override;
+
+  LtsSession::LtsSession *m_session;
+
+  Ui::EquipmentErrorRegistrationDialog *m_ui;
+
+  NGL::INGLLogger &m_logger;
+};
+}

Lts/Plugins/ServiceMonitor/Gui/EquipmentErrorRegistration/smo_equipment_error_registration_dialog.ui

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>EquipmentErrorRegistrationDialog</class>
+ <widget class="QWidget" name="EquipmentErrorRegistrationDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string notr="true">Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="0" column="0">
+    <widget class="QLabel" name="lblLoading">
+     <property name="text">
+      <string>Loading:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="0" colspan="2">
+    <widget class="LtsDataView::LtsDataView" name="dvList" native="true"/>
+   </item>
+   <item row="0" column="1">
+    <widget class="QProgressBar" name="pbLoading">
+     <property name="value">
+      <number>24</number>
+     </property>
+     <property name="format">
+      <string notr="true">%p%</string>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>LtsDataView::LtsDataView</class>
+   <extends>QWidget</extends>
+   <header>LtsDataView/lts_data_view.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

Lts/Plugins/ServiceMonitor/Gui/EquipmentErrorRegistration/smo_equipment_error_registration_gui_plugin.cpp

@@ -0,0 +1,86 @@
+/**
+  * @RDE_HEADER@
+  * Handgrande and mine search GUI plugin
+  * $Id: smo_equipment_error_registration_plugin.cpp 47083 2019-06-05 06:56:30Z karwat $
+  * $HeadURL: svn://slssvn/TDS/branches/product/devel/trunk/Lts/Plugins/ServiceMonitor/Gui/EquipmentErrorRegistration/smo_equipment_error_registration_plugin.cpp $
+  * $Author: karwat $
+  * Created by Christian Roeskens, NLSE, 2018-05-02
+  */
+
+#include "smo_equipment_error_registration_gui_plugin.h"
+#include "smo_equipment_error_registration_dialog.h"
+
+#include <LtsSession/lts_session.h>
+#include <ServiceMonitor/smo_operator_rights.h>
+#include <LtsUtilsSettings/settings.h>
+#include <Common/logger.h>
+
+namespace ServiceMonitor
+{
+
+std::shared_ptr<GuiPluginBase::Interface> GuiPlugin::createGuiInterface(LtsSession::LtsSession *session)
+{
+  return std::make_shared<InterfaceImpl>(session);
+}
+
+
+InterfaceImpl::InterfaceImpl(LtsSession::LtsSession *session)
+  : GuiPluginBase::Interface(session, getLogger("AppStarter"))
+  , m_eemForeign(nullptr)
+  , m_exmDtc(nullptr)
+{}
+
+bool InterfaceImpl::fetchInterfaces()
+{
+  //foreign
+  if (!m_session->getForeignDataInterface<TimeLineManagement::DataInterface>(m_eemForeign))
+    return false;
+  if (!m_session->getDtc<ExerciseManagement::DataInterface>(m_exmDtc))
+    return false;
+
+  return true;
+}
+
+
+void InterfaceImpl::clearInterfaces()
+{
+  m_eemForeign = nullptr;
+  m_exmDtc = nullptr;
+}
+
+
+QVector<LtsWidgets::PluginData> InterfaceImpl::getActions()
+{
+  QVector<LtsWidgets::PluginData> ret;
+
+  LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
+  const bool enableEquipmentErrorRegistration = ps->value(QStringLiteral("smo"),
+                                                          QStringLiteral("enableEquipmentErrorRegistration")).toBool();
+
+  // TBC Rechte ....
+  if (enableEquipmentErrorRegistration)
+  {
+    LtsWidgets::PluginData plData;
+    plData.layoutArea    = LtsWidgets::LayoutArea::eDialogTab;
+    plData.menuGroup  = menuGroup();
+    plData.menuText   = tr("Equipment Error Registration");
+    plData.identifier = QLatin1String("smoEquipmentErrorRegistration");
+    plData.menuIcon   = QIcon(QLatin1String("icon:player_equipment_fault.svg"));
+    plData.operatorRight = OperatorRights::HandgrenadeMineSearchShow;
+    plData.exercisePart  = LtsWidgets::ExercisePart::eAfterAction;
+    plData.createWidgetFunc = [this](QWidget * parent)
+    {
+      return onEquipmentErrorRegistrationDialog(parent);
+    };
+    ret.append(plData);
+  }
+  return ret;
+}
+
+LtsWidgets::LtsDialog *InterfaceImpl::onEquipmentErrorRegistrationDialog(QWidget *parent)
+{
+  return LtsWidgets::initDialog(new EquipmentErrorRegistrationDialog(parent),
+                                m_session, m_eemForeign, m_exmDtc);
+}
+
+}

Lts/Plugins/ServiceMonitor/Gui/EquipmentErrorRegistration/smo_equipment_error_registration_gui_plugin.h

@@ -0,0 +1,61 @@
+/**
+  * @RDE_HEADER@
+  * Handgrande and mine search GUI plugin
+  * $Id: smo_equipment_error_registration_plugin.h 46393 2019-04-02 12:38:53Z hjl $
+  * $HeadURL: svn://slssvn/TDS/branches/product/devel/trunk/Lts/Plugins/ServiceMonitor/Gui/EquipmentErrorRegistration/smo_equipment_error_registration_plugin.h $
+  * $Author: hjl $
+  * Created by Christian Roeskens, NLSE, 2018-05-02
+  */
+
+#pragma once
+
+#include <Plugins/ServiceMonitor/smo_hgr_and_mine_search_gui_plugin_interface.h>
+
+#include <PluginInterfaces/gui_plugin_interface.h>
+#include <Common/ProjectConfig/project_defines.h>
+
+#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
+#include <Plugins/Timeline/tln_data_plugin_interface.h>
+
+namespace ServiceMonitor
+{
+
+class GuiPlugin final : public QObject, public GuiPluginBase::Plugin
+{
+  Q_PLUGIN_METADATA(IID "gui:3:smo.eer")
+  Q_INTERFACES(GuiPluginBase::Plugin)
+
+  Q_OBJECT
+
+public:
+  explicit GuiPlugin() = default;
+  ~GuiPlugin() = default;
+
+  QString pluginName() override  { return QStringLiteral("ServiceMonitorEquipmentErrorRegistrationGui"); }
+  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 QObject, public GuiPluginBase::Interface
+{
+  Q_OBJECT
+public:
+  explicit InterfaceImpl(LtsSession::LtsSession *session);
+
+  bool fetchInterfaces() override;
+  void clearInterfaces() override;
+  QVector<LtsWidgets::PluginData> getActions() override;
+  QString menuGroup() const override { return tr("Service Monitors"); }
+
+private:
+  LtsWidgets::LtsDialog *onEquipmentErrorRegistrationDialog(QWidget *parent);
+
+  std::shared_ptr<TimeLineManagement::ForeignDataInterface>m_eemForeign;
+  std::shared_ptr<ExerciseManagement::Interface::Dtc>      m_exmDtc;
+};
+
+} // namespace ServiceMonitor

Lts/Plugins/ServiceMonitor/Gui/EquipmentErrorRegistration/smo_equipment_error_registration_model.cpp

@@ -0,0 +1,181 @@
+/**
+  * @RDE_HEADER@
+  * Handgrande and mine search model
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Roeskens, NLSE, 2018-05-02
+  */
+
+#include "smo_equipment_error_registration_model.h"
+
+#include <ngltools/ngltools_dtg.h>
+
+#include <Common/logger.h>
+
+#include <QByteArray>
+#include <QJsonValue>
+#include <QJsonObject>
+#include <QJsonDocument>
+
+namespace ServiceMonitor
+{
+//###############################################################################
+
+EquipmentErrorRegistrationModel::EquipmentErrorRegistrationModel(QObject *parent)
+  : LtsWidgets::LtsAbstractTableModel<EquipmentErrorRegistrationEntry>({tr("Sender"),
+                                                                        tr("Timestamp"),
+                                                                        tr("Fault Equipment Number"),
+                                                                        tr("Device"),
+                                                                        tr("Text")},
+                                                                       parent)
+  , m_eemForeign(nullptr)
+  , m_exmDtc(nullptr)
+  , m_chunksRequested(0)
+  , m_chunksReceived(0)
+  , m_session(nullptr)
+  , m_logger(getLogger("EquipmentErrorRegistrationModel"))
+{
+}
+
+bool EquipmentErrorRegistrationModel::initModel(LtsSession::LtsSession *session,
+                                      const std::shared_ptr<TimeLineManagement::ForeignDataInterface> &eemForeign,
+                                      const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc)
+{
+  m_session = session;
+
+  m_eemForeign = eemForeign;
+  m_exmDtc     = exmDtc;
+
+  if (!m_exmDtc->enableExercise())
+  {
+    ERROR_LOG(m_logger) << " Could not enable Exercise Data-Topic in EXM DTC!";
+    return false;
+  }
+
+  connect(m_eemForeign.get(), &TimeLineManagement::ForeignDataInterface::requestedDataAvailable,
+          this, &EquipmentErrorRegistrationModel::onRequestedDataAvailable);
+
+  connect(m_eemForeign.get(), &TimeLineManagement::ForeignDataInterface::liveEvent,
+          this, &EquipmentErrorRegistrationModel::onLiveEvent);
+
+  doEventRequests();
+
+  emit chunksUpdated(m_chunksReceived, m_chunksRequested);
+
+  return true;
+}
+
+QVariant EquipmentErrorRegistrationModel::data(const QModelIndex &index, int role) const
+{
+  if (role == Qt::DisplayRole && indexIsValid(index))
+  {
+    const EquipmentErrorRegistrationEntry &entry = m_vecData.at(index.row());
+
+    switch (index.column())
+    {
+    case EquipmentNumber:
+      return entry.equipmentNumber;
+    case SampleTime:
+      return QDateTime::fromMSecsSinceEpoch(entry.sampleTime);
+    case Participant:
+      return entry.participant;
+    case Device:
+      return entry.device;
+    case Text:
+      return entry.text;
+    }
+  }
+
+  return QVariant();
+}
+
+void EquipmentErrorRegistrationModel::doEventRequests()
+{
+  ExerciseManagement::Exercise ex = m_exmDtc->exercise(m_session->partitionId());
+  int64_t startTime = ex.beginTime();
+  const int64_t endTime = ex.stopTime() > 0 ? ex.stopTime() : m_session->partitionTime();
+
+  while (startTime < endTime)
+  {
+    int64_t reqEnd = ((startTime + 24 * 60 * 60 * 1000) > endTime ? endTime : startTime + 24 * 60 * 60 * 1000);
+
+    m_requests += m_eemForeign->requestData(startTime, reqEnd, {ProjectDataManagement::EventType_def::EquipmentErrorReport});
+
+    // set new start
+    startTime += (24 * 60 * 60 * 1000) + 1;
+  }
+  m_chunksRequested += m_requests.size();
+}
+
+static inline EquipmentErrorRegistrationEntry event2Entry(const ExerciseEventManagement::Event &event)
+{
+  EquipmentErrorRegistrationEntry entry;
+  const QJsonObject obj = QJsonDocument::fromJson(QByteArray::fromRawData(event.properties().c_str(),
+                                                                          event.properties().size())).object();
+  entry.equipmentNumber = event.equipmentNumber();
+  entry.sampleTime = event.sampleTime();
+  entry.participant = obj[QStringLiteral("participant")].toString();
+  entry.device = obj[QStringLiteral("device")].toString();
+  entry.text = obj[QStringLiteral("text")].toString();
+
+  return entry;
+}
+
+void EquipmentErrorRegistrationModel::onRequestedDataAvailable(TimeLineManagement::TimelineDataProviderInterface *request)
+{
+  auto it = m_requests.find(request);
+  if (it == m_requests.end())
+    return;
+  m_requests.erase(it);
+
+  m_chunksReceived++;
+
+  const QVector<ExerciseEventManagement::Event> &events = request->eventData();
+  for (const auto &event : events)
+    insertRow(event2Entry(event));
+
+  emit chunksUpdated(m_chunksReceived, m_chunksRequested);
+}
+
+void EquipmentErrorRegistrationModel::onLiveEvent(const ExerciseEventManagement::Event &ev)
+{
+  if (ev.eventTypeId() != ProjectDataManagement::EventType_def::EquipmentErrorReport)
+    return;
+  INFO_LOG(m_logger) << "Event EquipmentNumber=" << ev.equipmentNumber();
+  insertRow(event2Entry(ev));
+
+  emit chunksUpdated(m_chunksReceived, m_chunksRequested);
+}
+
+//
+// EquipmentErrorRegistrationProxyModel
+//
+void EquipmentErrorRegistrationProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
+{
+  m_sourceModel = qobject_cast<EquipmentErrorRegistrationModel*>(sourceModel);
+  LtsWidgets::LtsColumnFilterProxyModel::setSourceModel(sourceModel);
+}
+
+bool EquipmentErrorRegistrationProxyModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
+{
+  if (!m_sourceModel ||
+      source_left.column() != source_right.column() ||
+      !source_left.isValid() ||
+      !source_right.isValid())
+    return LtsWidgets::LtsColumnFilterProxyModel::lessThan(source_left, source_right);
+  const auto &dataLeft = m_sourceModel->m_vecData.at(source_left.row());
+  const auto dataRight = m_sourceModel->m_vecData.at(source_right.row());
+  switch (source_left.column())
+  {
+  case EquipmentErrorRegistrationModel::SampleTime:
+    return dataLeft.sampleTime < dataRight.sampleTime;
+  case EquipmentErrorRegistrationModel::EquipmentNumber:
+  case EquipmentErrorRegistrationModel::Participant:
+  case EquipmentErrorRegistrationModel::Device:
+  case EquipmentErrorRegistrationModel::Text:
+    break;
+  }
+  return LtsWidgets::LtsColumnFilterProxyModel::lessThan(source_left, source_right);
+}
+}

Lts/Plugins/ServiceMonitor/Gui/EquipmentErrorRegistration/smo_equipment_error_registration_model.h

@@ -0,0 +1,92 @@
+/**
+  * @RDE_HEADER@
+  * Handgrande and mine search model
+  * $Id$
+  * $HeadURL$
+  * $Author$
+  * Created by Christian Roeskens, NLSE, 2018-05-02
+  */
+
+#pragma once
+
+#include <Plugins/ExerciseManagement/Data/exm_data_plugin.h>
+#include <Plugins/ParticipantManagement/Data/ppm_data_plugin.h>
+#include <Plugins/ProjectDataManagement/Data/pdm_data_plugin.h>
+#include <Plugins/Timeline/tln_data_plugin_interface.h>
+
+#include <LtsSession/lts_session.h>
+#include <LtsWidgets/lts_abstract_table_model.h>
+#include <LtsWidgets/lts_column_filter_proxy_model.h>
+#include <QSet>
+
+namespace ServiceMonitor
+{
+
+struct EquipmentErrorRegistrationEntry
+{
+  int32_t equipmentNumber = -1;
+  int64_t sampleTime = -1;
+  QString participant;
+  QString device;
+  QString text;
+};
+
+//###############################################################################
+
+class EquipmentErrorRegistrationModel final
+  : public LtsWidgets::LtsAbstractTableModel<EquipmentErrorRegistrationEntry>
+{
+  Q_OBJECT
+public:
+  enum Columns
+  {
+    EquipmentNumber,
+    SampleTime,
+    Participant,
+    Device,
+    Text
+  };
+  explicit EquipmentErrorRegistrationModel(QObject *parent = nullptr);
+
+  bool initModel(LtsSession::LtsSession *session,
+                 const std::shared_ptr<TimeLineManagement::ForeignDataInterface> &eemForeign,
+                 const std::shared_ptr<ExerciseManagement::Interface::Dtc> &exmDtc);
+
+  QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+
+signals:
+  void chunksUpdated(int chunksReceived, int chunksRequested);
+
+private:
+  void onRequestedDataAvailable(TimeLineManagement::TimelineDataProviderInterface *request);
+  void onLiveEvent(const ExerciseEventManagement::Event &ev);
+
+  void doEventRequests();
+
+  std::shared_ptr<TimeLineManagement::ForeignDataInterface> m_eemForeign;
+  std::shared_ptr<ExerciseManagement::Interface::Dtc> m_exmDtc;
+
+  int m_chunksRequested;
+  int m_chunksReceived;
+  QSet<TimeLineManagement::TimelineDataProviderInterface*> m_requests;
+
+  LtsSession::LtsSession *m_session;
+
+  NGL::INGLLogger &m_logger;
+
+  friend class EquipmentErrorRegistrationProxyModel;
+};
+
+class EquipmentErrorRegistrationProxyModel final : public LtsWidgets::LtsColumnFilterProxyModel
+{
+  Q_OBJECT
+
+public:
+  using LtsWidgets::LtsColumnFilterProxyModel::LtsColumnFilterProxyModel;
+  void setSourceModel(QAbstractItemModel *sourceModel) override;
+protected:
+  bool lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const override;
+private:
+  EquipmentErrorRegistrationModel *m_sourceModel = nullptr;
+};
+}