Apply clang-format to Lts/Common and DTC/enum headers

- Formatted all CodeGen module files (9 files)
- Formatted LtsAppDescriptor module files
- Formatted LtsAppManager/AppChooser files
- Applied clang-format to all DTC and enum headers across modules
- Removed coordTransTests from CommonUnitTestsPlaceholder (moved to tests/)

Cosmetic changes only, no functional modifications.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
torstenandCopilot committed 2026-08-19 14:46:29 +02:00
1 parent 1881d68aef
commit d6b6ffce7c
848 files changed
+89305 -100020

No files matched your search

@@ -1,178 +1,161 @@
#include "exm_dialog.h"
#include "ui_exm_dialog.h"
#include "exm_dialog_model.h"
#include "exm_edit_dialog.h"
#include "CustomViews/exm_exercise.h"
#include "exm_dialog_model.h"
#include "exm_edit_dialog.h"
#include "ui_exm_dialog.h"
#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
#include <Plugins/AssetManagement/asm_data_plugin_interface.h>
#include <Plugins/ProjectDataManagement/pdm_data_plugin_interface.h>
#include <Services/FileManagement/flm_ftc.h>
#include <LtsSession/lts_session_data.h>
#include <LtsUtilsSettings/settings.h>
#include <Plugins/AssetManagement/asm_data_plugin_interface.h>
#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
#include <Plugins/ProjectDataManagement/pdm_data_plugin_interface.h>
#include <Services/FileManagement/flm_ftc.h>
namespace ExerciseManagement
{
ExerciseManagementDialog::ExerciseManagementDialog(const QString &menuGroup, QWidget *parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
, m_model(nullptr)
, m_ui(new Ui::ExerciseManagementDialog)
, m_session(nullptr)
, m_ftc(nullptr)
, m_menuGroup(menuGroup)
, m_requestHelper(new LtsUtils::RequestHelper(this))
ExerciseManagementDialog::ExerciseManagementDialog(const QString& menuGroup, QWidget* parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly), m_model(nullptr),
m_ui(new Ui::ExerciseManagementDialog), m_session(nullptr), m_ftc(nullptr), m_menuGroup(menuGroup),
m_requestHelper(new LtsUtils::RequestHelper(this))
{
m_ui->setupUi(this);
setOnlineHelpFilename(QStringLiteral("Administrator-Exercises"));
m_ui->setupUi(this);
setOnlineHelpFilename(QStringLiteral("Administrator-Exercises"));
m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &ExerciseManagementDialog::onAddExercise);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &ExerciseManagementDialog::onEditExercise);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this, &ExerciseManagementDialog::onRemoveExercise);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &ExerciseManagementDialog::onAddExercise);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &ExerciseManagementDialog::onEditExercise);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this, &ExerciseManagementDialog::onRemoveExercise);
connect(m_ui->widget, &LtsDataView::LtsDataView::signalDoubleClicked,
this, &ExerciseManagementDialog::onEditExercise);
connect(m_ui->widget, &LtsDataView::LtsDataView::signalDoubleClicked, this,
&ExerciseManagementDialog::onEditExercise);
}
ExerciseManagementDialog::~ExerciseManagementDialog()
{
delete m_ui;
delete m_ui;
}
void ExerciseManagementDialog::retranslate()
{
translate(m_ui, tr("Exercises"));
translate(m_ui, tr("Exercises"));
}
void ExerciseManagementDialog::tableColumnOrganiserSetting()
{
m_ui->widget->setColumnsOrganiserEnabled(identifier(), true);
m_ui->widget->setColumnsOrganiserEnabled(identifier(), true);
}
bool ExerciseManagementDialog::init(LtsSession::LtsSessionDataDds *session)
bool ExerciseManagementDialog::init(LtsSession::LtsSessionDataDds* session)
{
m_session = session;
std::shared_ptr<ExerciseManagement::Interface::Dtc> dtc;
std::shared_ptr<AssetManagement::Interface::Dtc> asmDtc;
std::shared_ptr<ProjectDataManagement::Interface::Dtc> pdmDtc;
m_session = session;
std::shared_ptr<ExerciseManagement::Interface::Dtc> dtc;
std::shared_ptr<AssetManagement::Interface::Dtc> asmDtc;
std::shared_ptr<ProjectDataManagement::Interface::Dtc> pdmDtc;
if (!m_session->getDtc<ExerciseManagement::DataInterface>(dtc))
return false;
if (!m_session->getFtc<ExerciseManagement::DataInterface>(m_ftc))
return false;
if (!m_session->getDtc<ProjectDataManagement::DataInterface>(pdmDtc))
return false;
if (!m_session->getDtc<AssetManagement::DataInterface>(asmDtc))
return false;
if (!m_session->getDtc<FileManagement::DataInterface>(m_flmDtc))
return false;
if (!m_session->getFtc<FileManagement::DataInterface>(m_flmFtc))
return false;
if (!m_session->getDtc<ExerciseManagement::DataInterface>(dtc))
return false;
if (!m_session->getFtc<ExerciseManagement::DataInterface>(m_ftc))
return false;
if (!m_session->getDtc<ProjectDataManagement::DataInterface>(pdmDtc))
return false;
if (!m_session->getDtc<AssetManagement::DataInterface>(asmDtc))
return false;
if (!m_session->getDtc<FileManagement::DataInterface>(m_flmDtc))
return false;
if (!m_session->getFtc<FileManagement::DataInterface>(m_flmFtc))
return false;
m_flmDtc->enableAll();
m_flmDtc->enableAll();
m_model = new ExerciseManagementDialogModel(this);
m_model->initModel(dtc, m_ftc, asmDtc, pdmDtc, true);
auto proxy = new ExerciseManagementProxyModel(this);
proxy->setSourceModel(m_model);
proxy->setAdminExerciseVisible(false);
proxy->setVisibleExerciseIds({-1});
m_model = new ExerciseManagementDialogModel(this);
m_model->initModel(dtc, m_ftc, asmDtc, pdmDtc, true);
auto proxy = new ExerciseManagementProxyModel(this);
proxy->setSourceModel(m_model);
proxy->setAdminExerciseVisible(false);
proxy->setVisibleExerciseIds({-1});
m_ui->widget->setModel(proxy, [this]() { return new CustomViewExercise(this); });
m_ui->widget->hideColumn(ExerciseManagementDialogModel::Image);
const bool hasLinkedExercises = LtsUtils::ProjectSettings::isFunctionEnabled(QStringLiteral("Exercises"),
QStringLiteral("CanBeLinked"));
const bool hasHlaInterface = LtsUtils::ProjectSettings::isFunctionEnabled(QStringLiteral("Exercises"),
QStringLiteral("HasHlaInterface"));
m_ui->widget->setColumnHidden(ExerciseManagementDialogModel::LinkedId, !hasLinkedExercises);
m_ui->widget->setColumnHidden(ExerciseManagementDialogModel::HasHlaInterface, !hasHlaInterface);
m_ui->widget->setModel(proxy, [this]() { return new CustomViewExercise(this); });
m_ui->widget->hideColumn(ExerciseManagementDialogModel::Image);
const bool hasLinkedExercises =
LtsUtils::ProjectSettings::isFunctionEnabled(QStringLiteral("Exercises"), QStringLiteral("CanBeLinked"));
const bool hasHlaInterface =
LtsUtils::ProjectSettings::isFunctionEnabled(QStringLiteral("Exercises"), QStringLiteral("HasHlaInterface"));
m_ui->widget->setColumnHidden(ExerciseManagementDialogModel::LinkedId, !hasLinkedExercises);
m_ui->widget->setColumnHidden(ExerciseManagementDialogModel::HasHlaInterface, !hasHlaInterface);
connect(m_ui->widget, &LtsDataView::LtsDataView::signalSelectionChanged,
this, &ExerciseManagementDialog::enaDisa);
connect(m_ui->widget, &LtsDataView::LtsDataView::signalSelectionChanged, this, &ExerciseManagementDialog::enaDisa);
enaDisa();
enaDisa();
LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
const bool enableEditPhases = ps->value(QStringLiteral("exm"),
QStringLiteral("enableEditPhases")).toBool();
if (!enableEditPhases)
m_ui->widget->hideColumn(ExerciseManagementDialogModel::ActivePhase);
LtsUtils::ProjectSettings* ps = LtsUtils::ProjectSettings::getInstance();
const bool enableEditPhases = ps->value(QStringLiteral("exm"), QStringLiteral("enableEditPhases")).toBool();
if (!enableEditPhases)
m_ui->widget->hideColumn(ExerciseManagementDialogModel::ActivePhase);
return true;
return true;
}
void ExerciseManagementDialog::enaDisa()
{
QModelIndexList selectedRows = m_ui->widget->selectedRows();
const int cntSelectedRows = selectedRows.size();
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, cntSelectedRows == 1);
const QModelIndex curIdx = m_ui->widget->currentIndex();
const ExerciseManagement::ExerciseState state = m_model->getRowData(curIdx.row()).state();
const bool isRemovable = (state == ExerciseManagement::ExerciseState::Unknown ||
state == ExerciseManagement::ExerciseState::Created ||
state == ExerciseManagement::ExerciseState::Stopped ||
state == ExerciseManagement::ExerciseState::Terminated);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, curIdx.isValid() && isRemovable);
QModelIndexList selectedRows = m_ui->widget->selectedRows();
const int cntSelectedRows = selectedRows.size();
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, cntSelectedRows == 1);
const QModelIndex curIdx = m_ui->widget->currentIndex();
const ExerciseManagement::ExerciseState state = m_model->getRowData(curIdx.row()).state();
const bool isRemovable =
(state == ExerciseManagement::ExerciseState::Unknown || state == ExerciseManagement::ExerciseState::Created ||
state == ExerciseManagement::ExerciseState::Stopped || state == ExerciseManagement::ExerciseState::Terminated);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, curIdx.isValid() && isRemovable);
}
void ExerciseManagementDialog::onAddExercise()
{
ExerciseManagementEditDialog *dialog = new ExerciseManagementEditDialog(this);
dialog->init(m_session, m_menuGroup, -1 );
ExerciseManagementEditDialog* dialog = new ExerciseManagementEditDialog(this);
dialog->init(m_session, m_menuGroup, -1);
addDialog(dialog, m_menuGroup, QStringLiteral("NewExercise"));
addDialog(dialog, m_menuGroup, QStringLiteral("NewExercise"));
}
void ExerciseManagementDialog::onRemoveExercise()
{
const QModelIndex curIdx = m_ui->widget->currentIndex();
if (!curIdx.isValid())
return;
const int exId = m_model->getRowData(curIdx.row()).id();
const int folderId = m_flmDtc->getExerciseFolderId(exId);
const QModelIndex curIdx = m_ui->widget->currentIndex();
if (!curIdx.isValid())
return;
const int exId = m_model->getRowData(curIdx.row()).id();
const int folderId = m_flmDtc->getExerciseFolderId(exId);
if (folderId > 0)
{
Core::RemoveElementRequest req(folderId);
m_requestHelper->startSingleRequest([req, this]()
if (folderId > 0)
{
return m_flmFtc->folderRemoveRequest(req, this);
});
}
Core::RemoveElementRequest req(folderId);
m_requestHelper->startSingleRequest([req, this]() { return m_flmFtc->folderRemoveRequest(req, this); });
}
ExerciseManagement::ExerciseRemoveRequest req(exId, false);
m_requestHelper->startSingleRequest([req, this]()
{
m_ftc->enableExerciseRemove();
return m_ftc->exerciseRemoveRequest(req, this);
});
ExerciseManagement::ExerciseRemoveRequest req(exId, false);
m_requestHelper->startSingleRequest([req, this]() {
m_ftc->enableExerciseRemove();
return m_ftc->exerciseRemoveRequest(req, this);
});
}
void ExerciseManagementDialog::onEditExercise()
{
const QModelIndex idx = m_ui->widget->currentIndex();
const Exercise ex = m_model->getRowData(idx.row());
const QModelIndex idx = m_ui->widget->currentIndex();
const Exercise ex = m_model->getRowData(idx.row());
if (ex.id() <= 0)
return;
DEBUG_LOG(m_logger) << "current EXId: " << ex.id();
if (ex.id() <= 0)
return;
DEBUG_LOG(m_logger) << "current EXId: " << ex.id();
ExerciseManagementEditDialog *dialog = new ExerciseManagementEditDialog(this);
ExerciseManagementEditDialog* dialog = new ExerciseManagementEditDialog(this);
dialog->init(m_session, m_menuGroup, ex.id());
const QString identifier = QStringLiteral("EditExercise%1").arg(ex.id());
dialog->init(m_session, m_menuGroup, ex.id());
const QString identifier = QStringLiteral("EditExercise%1").arg(ex.id());
addDialog(dialog, m_menuGroup, identifier);
addDialog(dialog, m_menuGroup, identifier);
}
}
} // namespace ExerciseManagement
@@ -1,16 +1,15 @@
#pragma once
#include <ExerciseManagement/exm_ftc.h>
#include <ExerciseManagement/exm_dtc.h>
#include <ExerciseManagement/exm_ftc.h>
#include <ExerciseManagement/logger.h>
#include <LtsWidgets/lts_dialog.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <LtsSession/lts_session.h>
#include <FileManagement/flm_dtc.h>
#include <FileManagement/flm_ftc.h>
#include <LtsSession/lts_session.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <LtsWidgets/lts_dialog.h>
namespace Ui
{
@@ -21,41 +20,47 @@ namespace ExerciseManagement
{
class ExerciseManagementDialogModel;
class ExerciseManagementDialog : public LtsWidgets::LtsDialog
, protected ExerciseManagement::Interface::Ftc::ExerciseRemoveReplyHandler
, protected FileManagement::Interface::Ftc::FolderRemoveReplyHandler
class ExerciseManagementDialog : public LtsWidgets::LtsDialog,
protected ExerciseManagement::Interface::Ftc::ExerciseRemoveReplyHandler,
protected FileManagement::Interface::Ftc::FolderRemoveReplyHandler
{
Q_OBJECT
Q_OBJECT
public:
explicit ExerciseManagementDialog(const QString &menuGroup, QWidget *parent = nullptr);
~ExerciseManagementDialog();
public:
explicit ExerciseManagementDialog(const QString& menuGroup, QWidget* parent = nullptr);
~ExerciseManagementDialog();
bool init(LtsSession::LtsSessionDataDds *session);
bool init(LtsSession::LtsSessionDataDds* session);
private slots:
void enaDisa();
void onAddExercise();
void onEditExercise();
void onRemoveExercise();
private slots:
void enaDisa();
void onAddExercise();
void onEditExercise();
void onRemoveExercise();
private:
private:
NGL::INGLLogger& m_logger;
void retranslate() override;
NGL::INGLLogger &m_logger;
void retranslate() override;
void onExerciseRemoveReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
void onFolderRemoveReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
void tableColumnOrganiserSetting() override;
void onExerciseRemoveReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
ExerciseManagementDialogModel *m_model;
Ui::ExerciseManagementDialog *m_ui;
LtsSession::LtsSessionDataDds *m_session;
std::shared_ptr<ExerciseManagement::Interface::Ftc> m_ftc;
std::shared_ptr<FileManagement::Interface::Dtc> m_flmDtc;
std::shared_ptr<FileManagement::Interface::Ftc> m_flmFtc;
QString m_menuGroup;
LtsUtils::RequestHelper *m_requestHelper;
void onFolderRemoveReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
void tableColumnOrganiserSetting() override;
ExerciseManagementDialogModel* m_model;
Ui::ExerciseManagementDialog* m_ui;
LtsSession::LtsSessionDataDds* m_session;
std::shared_ptr<ExerciseManagement::Interface::Ftc> m_ftc;
std::shared_ptr<FileManagement::Interface::Dtc> m_flmDtc;
std::shared_ptr<FileManagement::Interface::Ftc> m_flmFtc;
QString m_menuGroup;
LtsUtils::RequestHelper* m_requestHelper;
};
}
} // namespace ExerciseManagement
@@ -1,309 +1,284 @@
#include "exm_dialog_model.h"
#include <utility>
#include <LtsUtilsCore/dds_vector.h>
#include <ExerciseManagement/exm_translation.h>
#include <LtsUtilsCore/dds_vector.h>
#include <QTimer>
#include <utility>
namespace ExerciseManagement
{
ExerciseManagementDialogModel::ExerciseManagementDialogModel(QObject *parent)
: LtsWidgets::LtsAbstractTableModel<ExerciseManagement::Exercise>({tr("Id"),
tr("Name"),
tr("Training Area"),
tr("Begin"),
tr("End"),
tr("Started"),
tr("Stopped"),
tr("Status"),
tr("Radio Group"),
tr("Active Phase"),
tr("Created"),
tr("Time Zone"),
tr("Forces"),
tr("Description"),
tr("Linked Exercise"),
tr("Transferred"),
tr("HLA"),
tr("Image")},
parent)
, m_exmDtc(nullptr)
, m_asmDtc(nullptr)
, m_pdmDtc(nullptr)
{}
bool ExerciseManagementDialogModel::initModel(const std::shared_ptr<ExerciseManagement::Interface::Dtc> &dtc,
const std::shared_ptr<ExerciseManagement::Interface::Ftc> &ftc,
const std::shared_ptr<AssetManagement::Interface::Dtc> &asmDtc,
const std::shared_ptr<ProjectDataManagement::Interface::Dtc> &pdmDtc,
bool addAdminExercise,
bool preloadExerciseImages)
ExerciseManagementDialogModel::ExerciseManagementDialogModel(QObject* parent)
: LtsWidgets::LtsAbstractTableModel<ExerciseManagement::Exercise>(
{tr("Id"), tr("Name"), tr("Training Area"), tr("Begin"), tr("End"), tr("Started"), tr("Stopped"),
tr("Status"), tr("Radio Group"), tr("Active Phase"), tr("Created"), tr("Time Zone"), tr("Forces"),
tr("Description"), tr("Linked Exercise"), tr("Transferred"), tr("HLA"), tr("Image")},
parent),
m_exmDtc(nullptr), m_asmDtc(nullptr), m_pdmDtc(nullptr)
{
m_exmDtc = dtc;
m_exmFtc = ftc;
m_asmDtc = asmDtc;
m_pdmDtc = pdmDtc;
connect(m_exmDtc.get(), &ExerciseManagement::Interface::Dtc::exerciseChanged,
this, [this, preloadExerciseImages](const ExerciseManagement::Exercise &ex, DataModification mod)
{
onDataChanged(ex, mod);
if (mod != DataModification::eAdded)
return;
if (preloadExerciseImages)
addImagePreload(ex.id());
});
if (addAdminExercise)
{
ExerciseManagement::Exercise adminExercise;
adminExercise.name(tr("Superordinate Config / Administration").toStdString());
adminExercise.id(0);
insertRow(adminExercise);
}
m_exmDtc->exercises([this, preloadExerciseImages](const ExerciseManagement::Exercise &ex)
{
insertRow(ex);
if (preloadExerciseImages)
addImagePreload(ex.id());
});
INFO_LOG(m_logger) << "initModel - #exercises: " << m_vecData.size();
return true;
}
int ExerciseManagementDialogModel::getId(const ExerciseManagement::Exercise &data) const
bool ExerciseManagementDialogModel::initModel(const std::shared_ptr<ExerciseManagement::Interface::Dtc>& dtc,
const std::shared_ptr<ExerciseManagement::Interface::Ftc>& ftc,
const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc,
const std::shared_ptr<ProjectDataManagement::Interface::Dtc>& pdmDtc,
bool addAdminExercise, bool preloadExerciseImages)
{
return data.id();
m_exmDtc = dtc;
m_exmFtc = ftc;
m_asmDtc = asmDtc;
m_pdmDtc = pdmDtc;
connect(m_exmDtc.get(), &ExerciseManagement::Interface::Dtc::exerciseChanged, this,
[this, preloadExerciseImages](const ExerciseManagement::Exercise& ex, DataModification mod) {
onDataChanged(ex, mod);
if (mod != DataModification::eAdded)
return;
if (preloadExerciseImages)
addImagePreload(ex.id());
});
if (addAdminExercise)
{
ExerciseManagement::Exercise adminExercise;
adminExercise.name(tr("Superordinate Config / Administration").toStdString());
adminExercise.id(0);
insertRow(adminExercise);
}
m_exmDtc->exercises([this, preloadExerciseImages](const ExerciseManagement::Exercise& ex) {
insertRow(ex);
if (preloadExerciseImages)
addImagePreload(ex.id());
});
INFO_LOG(m_logger) << "initModel - #exercises: " << m_vecData.size();
return true;
}
void ExerciseManagementDialogModel::addImagePreload(int32_t exId)
int ExerciseManagementDialogModel::getId(const ExerciseManagement::Exercise& data) const
{
if (m_exerciseImages.contains(exId))
return;
m_preloadImages += exId;
if (m_imagePreloadPending)
return;
m_imagePreloadPending = true;
preloadNextImage();
return data.id();
}
void ExerciseManagementDialogModel::addImagePreload(int32_t exId)
{
if (m_exerciseImages.contains(exId))
return;
m_preloadImages += exId;
if (m_imagePreloadPending)
return;
m_imagePreloadPending = true;
preloadNextImage();
}
void ExerciseManagementDialogModel::preloadNextImage()
{
if (m_preloadImages.isEmpty())
return;
if (m_preloadImages.isEmpty())
return;
m_exmFtc->enableGetExerciseImage();
m_exmFtc->getExerciseImageRequest(GetExerciseImageRequest(m_preloadImages.takeFirst(), m_imageSize.height(), m_imageSize.width(), false),
createGetExerciseImageRequester());
m_exmFtc->enableGetExerciseImage();
m_exmFtc->getExerciseImageRequest(
GetExerciseImageRequest(m_preloadImages.takeFirst(), m_imageSize.height(), m_imageSize.width(), false),
createGetExerciseImageRequester());
}
GetExerciseImageRequester *ExerciseManagementDialogModel::createGetExerciseImageRequester()
GetExerciseImageRequester* ExerciseManagementDialogModel::createGetExerciseImageRequester()
{
auto r = GetExerciseImageRequester::createGetExerciseImageRequester();
connect(r, &GetExerciseImageRequester::signalDone,
this, [this, r]()
{
m_imagePreloadPending = false;
auto r = GetExerciseImageRequester::createGetExerciseImageRequester();
connect(r, &GetExerciseImageRequester::signalDone, this, [this, r]() {
m_imagePreloadPending = false;
const GetExerciseImageReply &reply(r->reply());
const GetExerciseImageReply& reply(r->reply());
if (reply.errorString().empty())
{
m_exerciseImages.insert(reply.id(), LtsUtils::toQByteArray(reply.imageData()));
if (reply.errorString().empty())
{
m_exerciseImages.insert(reply.id(), LtsUtils::toQByteArray(reply.imageData()));
QModelIndex idx(findIndexForId(reply.id(), 0));
emit dataChanged(idx, idx, { Qt::DisplayRole });
}
else
{
QString msg(QString::fromStdString(reply.errorString()));
for (const std::string &arg : std::as_const(reply.errorParams()))
msg = msg.arg(QString::fromStdString(arg));
QModelIndex idx(findIndexForId(reply.id(), 0));
emit dataChanged(idx, idx, {Qt::DisplayRole});
}
else
{
QString msg(QString::fromStdString(reply.errorString()));
for (const std::string& arg : std::as_const(reply.errorParams()))
msg = msg.arg(QString::fromStdString(arg));
ERROR_LOG(m_logger) << "image preload failed: " << msg;
}
ERROR_LOG(m_logger) << "image preload failed: " << msg;
}
QTimer::singleShot(1, this, &ExerciseManagementDialogModel::preloadNextImage);
});
QTimer::singleShot(1, this, &ExerciseManagementDialogModel::preloadNextImage);
});
return r;
return r;
}
void ExerciseManagementDialogModel::setImageSizeConstraints(const QSize &size)
void ExerciseManagementDialogModel::setImageSizeConstraints(const QSize& size)
{
m_imageSize = size;
m_imageSize = size;
}
QVariant ExerciseManagementDialogModel::data(const QModelIndex &index, int role) const
QVariant ExerciseManagementDialogModel::data(const QModelIndex& index, int role) const
{
if ((role != Qt::DisplayRole && role != Qt::UserRole && role != Qt::TextColorRole) || !indexIsValid(index))
return QVariant();
const ExerciseManagement::Exercise &ex = m_vecData.at(index.row());
if (role == Qt::DisplayRole)
{
switch (index.column())
{
case ExerciseManagementDialogModel::Columns::Name:
return QString::fromStdString(ex.name());
case ExerciseManagementDialogModel::Columns::TrainingArea:
{
const AssetManagement::TrainingArea ta = m_asmDtc->trainingArea(ex.trainingAreaId());
return QString::fromStdString(ta.name());
}
case ExerciseManagementDialogModel::Columns::Begin:
return QDateTime::fromMSecsSinceEpoch(ex.beginTime());
case ExerciseManagementDialogModel::Columns::End:
return QDateTime::fromMSecsSinceEpoch(ex.endTime());
case ExerciseManagementDialogModel::Columns::Started:
return QDateTime::fromMSecsSinceEpoch(ex.startTime());
case ExerciseManagementDialogModel::Columns::Stopped:
return QDateTime::fromMSecsSinceEpoch(ex.stopTime());
case ExerciseManagementDialogModel::Columns::Status:
return ExerciseManagement::toString(ex.state());
case ExerciseManagementDialogModel::Columns::RadioGroup:
if (ex.radioGroupId().is_set())
return m_pdmDtc->trRadioGroupName(ex.radioGroupId().get());
return QStringLiteral(" - ");
case ExerciseManagementDialogModel::Columns::ActivePhase:
return QString::fromStdString(m_exmDtc->exercisePhase(ex.activePhaseId()).name());
case ExerciseManagementDialogModel::Columns::Created:
return QDateTime::fromMSecsSinceEpoch(ex.created());
case ExerciseManagementDialogModel::Columns::TimeZone:
return (ex.defaultTimeZone() == 0) ? QStringLiteral("-") : QString(QLatin1Char(ex.defaultTimeZone()));
case ExerciseManagementDialogModel::Columns::Forces:
return QString::fromStdString(ex.forces());
case ExerciseManagementDialogModel::Columns::Description:
return QString::fromStdString(ex.description());
case ExerciseManagementDialogModel::Columns::Image:
return m_exerciseImages.value(ex.id());
case ExerciseManagementDialogModel::Columns::Id:
return ex.id();
case ExerciseManagementDialogModel::Columns::LinkedId:
{
if (ex.linkedExerciseId() == 0)
if ((role != Qt::DisplayRole && role != Qt::UserRole && role != Qt::TextColorRole) || !indexIsValid(index))
return QVariant();
const int row = findRowForId(ex.linkedExerciseId());
if (row < 0)
return QStringLiteral("????? - %1").arg(ex.linkedExerciseId());
return QString(QString::fromStdString(m_vecData.at(row).name()) +
QStringLiteral(" (%1)").arg(ex.linkedExerciseId()));
}
case ExerciseManagementDialogModel::Columns::Transferred:
return ex.transferred() ? tr("Yes") : tr("No");
case ExerciseManagementDialogModel::Columns::HasHlaInterface:
return ex.hasHlaInterface() ? tr("Yes") : tr("No");
}
}
else if (role == Qt::UserRole)
{
if (ex.id() == 0)
return 0;
switch (ex.state().underlying())
const ExerciseManagement::Exercise& ex = m_vecData.at(index.row());
if (role == Qt::DisplayRole)
{
case ExerciseState::Unknown: return 6;
case ExerciseState::Created: return 3;
case ExerciseState::Started: return 1;
case ExerciseState::Paused: return 2;
case ExerciseState::Stopped: return 4;
case ExerciseState::Terminated: return 5;
switch (index.column())
{
case ExerciseManagementDialogModel::Columns::Name:
return QString::fromStdString(ex.name());
case ExerciseManagementDialogModel::Columns::TrainingArea: {
const AssetManagement::TrainingArea ta = m_asmDtc->trainingArea(ex.trainingAreaId());
return QString::fromStdString(ta.name());
}
case ExerciseManagementDialogModel::Columns::Begin:
return QDateTime::fromMSecsSinceEpoch(ex.beginTime());
case ExerciseManagementDialogModel::Columns::End:
return QDateTime::fromMSecsSinceEpoch(ex.endTime());
case ExerciseManagementDialogModel::Columns::Started:
return QDateTime::fromMSecsSinceEpoch(ex.startTime());
case ExerciseManagementDialogModel::Columns::Stopped:
return QDateTime::fromMSecsSinceEpoch(ex.stopTime());
case ExerciseManagementDialogModel::Columns::Status:
return ExerciseManagement::toString(ex.state());
case ExerciseManagementDialogModel::Columns::RadioGroup:
if (ex.radioGroupId().is_set())
return m_pdmDtc->trRadioGroupName(ex.radioGroupId().get());
return QStringLiteral(" - ");
case ExerciseManagementDialogModel::Columns::ActivePhase:
return QString::fromStdString(m_exmDtc->exercisePhase(ex.activePhaseId()).name());
case ExerciseManagementDialogModel::Columns::Created:
return QDateTime::fromMSecsSinceEpoch(ex.created());
case ExerciseManagementDialogModel::Columns::TimeZone:
return (ex.defaultTimeZone() == 0) ? QStringLiteral("-") : QString(QLatin1Char(ex.defaultTimeZone()));
case ExerciseManagementDialogModel::Columns::Forces:
return QString::fromStdString(ex.forces());
case ExerciseManagementDialogModel::Columns::Description:
return QString::fromStdString(ex.description());
case ExerciseManagementDialogModel::Columns::Image:
return m_exerciseImages.value(ex.id());
case ExerciseManagementDialogModel::Columns::Id:
return ex.id();
case ExerciseManagementDialogModel::Columns::LinkedId: {
if (ex.linkedExerciseId() == 0)
return QVariant();
const int row = findRowForId(ex.linkedExerciseId());
if (row < 0)
return QStringLiteral("????? - %1").arg(ex.linkedExerciseId());
return QString(QString::fromStdString(m_vecData.at(row).name()) +
QStringLiteral(" (%1)").arg(ex.linkedExerciseId()));
}
case ExerciseManagementDialogModel::Columns::Transferred:
return ex.transferred() ? tr("Yes") : tr("No");
case ExerciseManagementDialogModel::Columns::HasHlaInterface:
return ex.hasHlaInterface() ? tr("Yes") : tr("No");
}
}
return 99;
}
else if (role == Qt::TextColorRole)
{
if (index.column() == ExerciseManagementDialogModel::Columns::Status)
else if (role == Qt::UserRole)
{
switch (ex.state().underlying())
{
case ExerciseState::Unknown: return QColor(Qt::black);
case ExerciseState::Created: return QColor(Qt::cyan);
case ExerciseState::Started: return QColor(Qt::darkGreen);
case ExerciseState::Paused: return QColor(Qt::darkYellow);
case ExerciseState::Stopped: return QColor(Qt::magenta);
case ExerciseState::Terminated: return QColor(Qt::red);
}
if (ex.id() == 0)
return 0;
switch (ex.state().underlying())
{
case ExerciseState::Unknown:
return 6;
case ExerciseState::Created:
return 3;
case ExerciseState::Started:
return 1;
case ExerciseState::Paused:
return 2;
case ExerciseState::Stopped:
return 4;
case ExerciseState::Terminated:
return 5;
}
return 99;
}
}
return QVariant();
else if (role == Qt::TextColorRole)
{
if (index.column() == ExerciseManagementDialogModel::Columns::Status)
{
switch (ex.state().underlying())
{
case ExerciseState::Unknown:
return QColor(Qt::black);
case ExerciseState::Created:
return QColor(Qt::cyan);
case ExerciseState::Started:
return QColor(Qt::darkGreen);
case ExerciseState::Paused:
return QColor(Qt::darkYellow);
case ExerciseState::Stopped:
return QColor(Qt::magenta);
case ExerciseState::Terminated:
return QColor(Qt::red);
}
}
}
return QVariant();
}
void ExerciseManagementProxyModel::setAdminExerciseVisible(bool bAdminVisible)
{
if (m_bAdminVisible == bAdminVisible)
return;
m_bAdminVisible = bAdminVisible;
invalidateFilter();
if (m_bAdminVisible == bAdminVisible)
return;
m_bAdminVisible = bAdminVisible;
invalidateFilter();
}
void ExerciseManagementProxyModel::setVisibleExerciseIds(const QVector<int> &exIds)
void ExerciseManagementProxyModel::setVisibleExerciseIds(const QVector<int>& exIds)
{
if (m_exIds == exIds)
return;
m_exIds = exIds;
invalidateFilter();
if (m_exIds == exIds)
return;
m_exIds = exIds;
invalidateFilter();
}
void ExerciseManagementProxyModel::setVisibleExerciseStates(const QVector<ExerciseState> &visibleStates)
void ExerciseManagementProxyModel::setVisibleExerciseStates(const QVector<ExerciseState>& visibleStates)
{
if (m_visibleStates == visibleStates)
return;
m_visibleStates = visibleStates;
invalidateFilter();
if (m_visibleStates == visibleStates)
return;
m_visibleStates = visibleStates;
invalidateFilter();
}
void ExerciseManagementProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
void ExerciseManagementProxyModel::setSourceModel(QAbstractItemModel* sourceModel)
{
m_sourceModel = qobject_cast<ExerciseManagementDialogModel*>(sourceModel);
LtsWidgets::LtsColumnFilterProxyModel::setSourceModel(sourceModel);
m_sourceModel = qobject_cast<ExerciseManagementDialogModel*>(sourceModel);
LtsWidgets::LtsColumnFilterProxyModel::setSourceModel(sourceModel);
}
bool ExerciseManagementProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
bool ExerciseManagementProxyModel::filterAcceptsRow(int source_row, const QModelIndex& source_parent) const
{
if (!m_sourceModel || source_parent.isValid() || source_row < 0 || source_row >= m_sourceModel->m_vecData.size())
if (!m_sourceModel || source_parent.isValid() || source_row < 0 || source_row >= m_sourceModel->m_vecData.size())
return LtsWidgets::LtsColumnFilterProxyModel::filterAcceptsRow(source_row, source_parent);
const auto& ex = m_sourceModel->m_vecData.at(source_row);
if (ex.id() == 0)
{
if (!m_bAdminVisible)
return false;
return LtsWidgets::LtsColumnFilterProxyModel::filterAcceptsRow(source_row, source_parent);
}
if (!m_exIds.contains(ex.id()) && !m_exIds.contains(-1))
return false;
if (!m_visibleStates.contains(ex.state()) && !m_visibleStates.isEmpty())
return false;
return LtsWidgets::LtsColumnFilterProxyModel::filterAcceptsRow(source_row, source_parent);
const auto &ex = m_sourceModel->m_vecData.at(source_row);
if (ex.id() == 0)
{
if (!m_bAdminVisible)
return false;
return LtsWidgets::LtsColumnFilterProxyModel::filterAcceptsRow(source_row, source_parent);
}
if (!m_exIds.contains(ex.id()) && !m_exIds.contains(-1))
return false;
if (!m_visibleStates.contains(ex.state()) && !m_visibleStates.isEmpty())
return false;
return LtsWidgets::LtsColumnFilterProxyModel::filterAcceptsRow(source_row, source_parent);
}
}
} // namespace ExerciseManagement
@@ -1,148 +1,134 @@
#pragma once
#include <ExerciseManagement/logger.h>
#include <LtsWidgets/lts_abstract_table_model.h>
#include <LtsWidgets/lts_column_filter_proxy_model.h>
#include <AssetManagement/asm_dtc.h>
#include <ExerciseManagement/exm_dtc.h>
#include <ExerciseManagement/exm_ftc.h>
#include <ExerciseManagement/logger.h>
#include <LtsWidgets/lts_abstract_table_model.h>
#include <LtsWidgets/lts_column_filter_proxy_model.h>
#include <ProjectDataManagement/pdm_dtc.h>
namespace ExerciseManagement
{
class AbstractRequester
: public QObject
class AbstractRequester : public QObject
{
Q_OBJECT
public:
AbstractRequester()
: QObject(nullptr)
{}
Q_OBJECT
public:
AbstractRequester() : QObject(nullptr) {}
signals:
void signalDone();
signals:
void signalDone();
};
class GetExerciseImageRequester
: public AbstractRequester
, public ExerciseManagement::Interface::Ftc::GetExerciseImageReplyHandler
class GetExerciseImageRequester : public AbstractRequester,
public ExerciseManagement::Interface::Ftc::GetExerciseImageReplyHandler
{
Q_OBJECT
Q_OBJECT
private:
private:
NGL::INGLLogger& m_logger;
GetExerciseImageRequester() = default;
NGL::INGLLogger &m_logger;
GetExerciseImageRequester() = default;
public:
static GetExerciseImageRequester* createGetExerciseImageRequester()
{
return new GetExerciseImageRequester;
}
public:
static GetExerciseImageRequester *createGetExerciseImageRequester()
{
return new GetExerciseImageRequester;
}
const GetExerciseImageReply& reply() const
{
return m_reply;
}
const GetExerciseImageReply &reply() const
{
return m_reply;
}
void onGetExerciseImageReply(const GetExerciseImageReply& reply) override final
{
m_reply = reply;
emit signalDone();
deleteLater();
}
void onGetExerciseImageReply(const GetExerciseImageReply &reply) override final
{
m_reply = reply;
emit signalDone();
deleteLater();
}
private:
GetExerciseImageReply m_reply;
private:
GetExerciseImageReply m_reply;
};
class ExerciseManagementDialogModel final
: public LtsWidgets::LtsAbstractTableModel<ExerciseManagement::Exercise>
class ExerciseManagementDialogModel final : public LtsWidgets::LtsAbstractTableModel<ExerciseManagement::Exercise>
{
Q_OBJECT
Q_OBJECT
public:
enum Columns
{
Id,
Name,
TrainingArea,
Begin,
End,
Started,
Stopped,
Status,
RadioGroup,
ActivePhase,
Created,
TimeZone,
Forces,
Description,
LinkedId,
Transferred,
HasHlaInterface,
Image
};
public:
enum Columns {
Id,
Name,
TrainingArea,
Begin,
End,
Started,
Stopped,
Status,
RadioGroup,
ActivePhase,
Created,
TimeZone,
Forces,
Description,
LinkedId,
Transferred,
HasHlaInterface,
Image
};
explicit ExerciseManagementDialogModel(QObject *parent = nullptr);
bool initModel(const std::shared_ptr<ExerciseManagement::Interface::Dtc> &dtc,
const std::shared_ptr<ExerciseManagement::Interface::Ftc> &ftc,
const std::shared_ptr<AssetManagement::Interface::Dtc> &asmDtc,
const std::shared_ptr<ProjectDataManagement::Interface::Dtc> &pdmDtc,
bool addAdminExercise = false,
bool preloadExerciseImages = false);
explicit ExerciseManagementDialogModel(QObject* parent = nullptr);
bool initModel(const std::shared_ptr<ExerciseManagement::Interface::Dtc>& dtc,
const std::shared_ptr<ExerciseManagement::Interface::Ftc>& ftc,
const std::shared_ptr<AssetManagement::Interface::Dtc>& asmDtc,
const std::shared_ptr<ProjectDataManagement::Interface::Dtc>& pdmDtc, bool addAdminExercise = false,
bool preloadExerciseImages = false);
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override final;
void addImagePreload(int32_t exId);
void setImageSizeConstraints(const QSize &size);
QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override final;
void addImagePreload(int32_t exId);
void setImageSizeConstraints(const QSize& size);
protected:
int getId(const ExerciseManagement::Exercise &data) const override final;
protected:
int getId(const ExerciseManagement::Exercise& data) const override final;
private slots:
void preloadNextImage();
private slots:
void preloadNextImage();
private:
GetExerciseImageRequester *createGetExerciseImageRequester();
private:
GetExerciseImageRequester* createGetExerciseImageRequester();
std::shared_ptr<ExerciseManagement::Interface::Dtc> m_exmDtc;
std::shared_ptr<ExerciseManagement::Interface::Ftc> m_exmFtc;
std::shared_ptr<AssetManagement::Interface::Dtc> m_asmDtc;
std::shared_ptr<ProjectDataManagement::Interface::Dtc> m_pdmDtc;
QVector<int32_t> m_preloadImages;
QMap<int32_t , QByteArray > m_exerciseImages;
bool m_imagePreloadPending { false };
QSize m_imageSize;
friend class ExerciseManagementProxyModel;
std::shared_ptr<ExerciseManagement::Interface::Dtc> m_exmDtc;
std::shared_ptr<ExerciseManagement::Interface::Ftc> m_exmFtc;
std::shared_ptr<AssetManagement::Interface::Dtc> m_asmDtc;
std::shared_ptr<ProjectDataManagement::Interface::Dtc> m_pdmDtc;
QVector<int32_t> m_preloadImages;
QMap<int32_t, QByteArray> m_exerciseImages;
bool m_imagePreloadPending{false};
QSize m_imageSize;
friend class ExerciseManagementProxyModel;
};
class ExerciseManagementProxyModel final : public LtsWidgets::LtsColumnFilterProxyModel
{
Q_OBJECT
public:
using LtsWidgets::LtsColumnFilterProxyModel::LtsColumnFilterProxyModel;
Q_OBJECT
public:
using LtsWidgets::LtsColumnFilterProxyModel::LtsColumnFilterProxyModel;
void setAdminExerciseVisible(bool bAdminVisible);
void setVisibleExerciseStates(const QVector<ExerciseState> &visibleStates);
void setVisibleExerciseIds(const QVector<int> &exIds);
void setSourceModel(QAbstractItemModel *sourceModel) override;
protected:
bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
private:
ExerciseManagementDialogModel *m_sourceModel = nullptr;
QVector<int> m_exIds;
QVector<ExerciseState> m_visibleStates;
bool m_bAdminVisible = false;
void setAdminExerciseVisible(bool bAdminVisible);
void setVisibleExerciseStates(const QVector<ExerciseState>& visibleStates);
void setVisibleExerciseIds(const QVector<int>& exIds);
void setSourceModel(QAbstractItemModel* sourceModel) override;
protected:
bool filterAcceptsRow(int source_row, const QModelIndex& source_parent) const override;
private:
ExerciseManagementDialogModel* m_sourceModel = nullptr;
QVector<int> m_exIds;
QVector<ExerciseState> m_visibleStates;
bool m_bAdminVisible = false;
};
}
} // namespace ExerciseManagement
File diff suppressed because it is too large. Load diff
@@ -1,23 +1,20 @@
#pragma once
#include <ExerciseManagement/exm_ftc.h>
#include <ExerciseManagement/exm_dtc.h>
#include <ExerciseManagement/exm_ftc.h>
#include <ExerciseManagement/logger.h>
#include <LtsWidgets/lts_dialog.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <FileManagement/flm_translation.h>
#include <LtsSession/lts_session_data_dds.h>
#include <Plugins/OperatorManagement/opm_data_plugin_interface.h>
#include <Plugins/AssetManagement/asm_data_plugin_interface.h>
#include <Plugins/ProjectDataManagement/pdm_data_plugin_interface.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <LtsWidgets/lts_dialog.h>
#include <ParticipantManagement/ppm_data_plugin_interface.h>
#include <Plugins/AssetManagement/asm_data_plugin_interface.h>
#include <Plugins/FileManagement/flm_data_plugin_interface.h>
#include <Plugins/FileManagement/flm_explorer_gui_plugin_interface.h>
#include <FileManagement/flm_translation.h>
#include <Plugins/OperatorManagement/opm_data_plugin_interface.h>
#include <Plugins/ProjectDataManagement/pdm_data_plugin_interface.h>
namespace Ui
{
@@ -29,132 +26,207 @@ namespace ExerciseManagement
namespace JsonKeys
{
inline QString XMLTYPE() { return QStringLiteral("XmlType"); }
inline QString XMLTYPEVALUE() { return FileManagement::toString(FileManagement::XmlType::EXMExerciseDescription); }
inline QString XMLTYPE()
{
return QStringLiteral("XmlType");
}
inline QString XMLTYPEVALUE()
{
return FileManagement::toString(FileManagement::XmlType::EXMExerciseDescription);
}
inline QString PHASES() { return QStringLiteral("phases"); }
inline QString OPERATORS() { return QStringLiteral("operators"); }
inline QString FORCES() { return QStringLiteral("forces"); }
inline QString DESCRIPTION() { return QStringLiteral("description"); }
inline QString PHASES()
{
return QStringLiteral("phases");
}
inline QString OPERATORS()
{
return QStringLiteral("operators");
}
inline QString PID() { return QStringLiteral("phaseId"); }
inline QString PNAME() { return QStringLiteral("phaseName"); }
inline QString PISDELETED() { return QStringLiteral("phaseIsDeleted"); }
inline QString PISUSED() { return QStringLiteral("phaseIsUsed"); }
inline QString PBEGINTIME() { return QStringLiteral("phaseBeginTime"); }
inline QString PENDTIME() { return QStringLiteral("phaseEndTime"); }
inline QString PDESCRIPTION() { return QStringLiteral("phaseDescription"); }
inline QString PEXERCISEID() { return QStringLiteral("phaseExerciseId"); }
}
inline QString FORCES()
{
return QStringLiteral("forces");
}
inline QString DESCRIPTION()
{
return QStringLiteral("description");
}
inline QString PID()
{
return QStringLiteral("phaseId");
}
inline QString PNAME()
{
return QStringLiteral("phaseName");
}
inline QString PISDELETED()
{
return QStringLiteral("phaseIsDeleted");
}
inline QString PISUSED()
{
return QStringLiteral("phaseIsUsed");
}
inline QString PBEGINTIME()
{
return QStringLiteral("phaseBeginTime");
}
inline QString PENDTIME()
{
return QStringLiteral("phaseEndTime");
}
inline QString PDESCRIPTION()
{
return QStringLiteral("phaseDescription");
}
inline QString PEXERCISEID()
{
return QStringLiteral("phaseExerciseId");
}
} // namespace JsonKeys
class ExercisePhaseModel;
class ExercisePhaseProxyModel;
class ExerciseOperatorModel;
class ExerciseManagementEditDialog final : public LtsWidgets::LtsDialog
, protected ExerciseManagement::Interface::Ftc::ExerciseCreateReplyHandler
, protected ExerciseManagement::Interface::Ftc::ExerciseModifyReplyHandler
, protected ExerciseManagement::Interface::Ftc::ExerciseImageModifyReplyHandler
, protected ExerciseManagement::Interface::Ftc::GetExerciseImageReplyHandler
, protected ExerciseManagement::Interface::Ftc::ExercisePhaseRemoveReplyHandler
, protected OperatorManagement::Interface::Ftc::OperatorCreateModifyReplyHandler
, protected FileManagement::Interface::Ftc::FolderModifyReplyHandler
, protected FileManagement::Interface::Ftc::FolderRemoveReplyHandler
class ExerciseManagementEditDialog final
: public LtsWidgets::LtsDialog,
protected ExerciseManagement::Interface::Ftc::ExerciseCreateReplyHandler,
protected ExerciseManagement::Interface::Ftc::ExerciseModifyReplyHandler,
protected ExerciseManagement::Interface::Ftc::ExerciseImageModifyReplyHandler,
protected ExerciseManagement::Interface::Ftc::GetExerciseImageReplyHandler,
protected ExerciseManagement::Interface::Ftc::ExercisePhaseRemoveReplyHandler,
protected OperatorManagement::Interface::Ftc::OperatorCreateModifyReplyHandler,
protected FileManagement::Interface::Ftc::FolderModifyReplyHandler,
protected FileManagement::Interface::Ftc::FolderRemoveReplyHandler
{
Q_OBJECT
Q_OBJECT
public:
explicit ExerciseManagementEditDialog(QWidget *parent = nullptr);
public:
explicit ExerciseManagementEditDialog(QWidget* parent = nullptr);
bool init(LtsSession::LtsSessionDataDds *session,
const QString &menuGroup,
const int exerciseId);
bool init(LtsSession::LtsSessionDataDds* session, const QString& menuGroup, const int exerciseId);
~ExerciseManagementEditDialog();
~ExerciseManagementEditDialog();
protected:
protected:
NGL::INGLLogger& m_logger;
NGL::INGLLogger &m_logger;
void onExerciseCreateReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
void onExerciseModifyReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
void onExerciseImageModifyReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); imageModifyError(); }
void onGetExerciseImageReply(const GetExerciseImageReply &reply) override final;
void onExercisePhaseRemoveReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
void onOperatorCreateModifyReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
void onFolderModifyReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
void onFolderRemoveReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
void onExerciseCreateReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
private slots:
void slotChangeImage();
void enaDisaOperatorsButtons();
void enaDisaPhaseButtons();
void onAddExercisePhase();
void onEditVisibleParties();
void onEditExercisePhase();
void onRemoveExercisePhase();
void onExport();
void onImport();
void onCreateFolders();
void onExerciseChanged(const Exercise &data, DataModification modType);
void onExercisePhaseChanged(const ExercisePhase &data, DataModification modType);
void onContextMenuRequested(const QPoint &position);
void onSelectAllUsers();
void onUnselectAllUsers();
void onTimeZoneChanged();
signals:
void sendData(const ExerciseManagement::Exercise &data);
void onExerciseModifyReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
private:
void retranslate() override;
bool apply() override final;
void onExerciseImageModifyReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
imageModifyError();
}
void enaDisa();
void onGetExerciseImageReply(const GetExerciseImageReply& reply) override final;
void fillStateCbx();
void fillTrainingAreaCbx();
void fillActivePhaseCbx();
void fillRadioGroupCbx();
void fillLinkedExercisesCbx();
void fillAllCbx();
void imageModifyError();
void sendModifiedOperators(int thisExerciseId);
int createFolder(int parentFolderId, const QString &folderName, bool isHidden = false);
bool createFolders(int newExId);
bool createExerciseFolders(int parentFolderId, const QStringList &folderNames);
ExerciseModifyRequest setRequestContent() const;
QByteArray exerciseToJson() const;
ExerciseModifyRequest jsonToExercise(const QByteArray &content) const;
void requestImage();
const QPixmap getPixmap() const;
int getExerciseFolder();
void onExercisePhaseRemoveReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
Ui::ExerciseManagementEditDialog *m_ui{nullptr};
LtsSession::LtsSessionDataDds *m_session{nullptr};
ExercisePhaseModel *m_phaseModel{nullptr};
ExercisePhaseProxyModel *m_phaseProxyModel{nullptr};
ExerciseOperatorModel *m_operatorModel{nullptr};
bool m_pictureChanged{false};
int m_exerciseId{-1};
QVariant m_initialRadioGroupId;
ExerciseState m_currentState;
std::shared_ptr<Interface::Dtc> m_dtc;
std::shared_ptr<Interface::Ftc> m_ftc;
std::shared_ptr<OperatorManagement::Interface::Dtc> m_opmDtc;
std::shared_ptr<AssetManagement::Interface::Dtc> m_asmDtc;
std::shared_ptr<ProjectDataManagement::Interface::Dtc> m_pdmDtc;
std::shared_ptr<ParticipantManagement::Interface::Dtc> m_ppmDtc;
std::shared_ptr<FileManagement::Interface::Dtc> m_flmDtc;
std::shared_ptr<FileManagement::Interface::Ftc> m_flmFtc;
std::shared_ptr<FileManagement::ForeignGuiInterface> m_flmGui;
QString m_menuGroup;
LtsUtils::RequestHelper *m_requestHelper{nullptr};
template<class T>
bool removeElement(std::vector<T> &vec, T elem);
bool hasVisibleParties(const std::vector<OperatorManagement::PartiesByExercise> vpbe) const;
void onOperatorCreateModifyReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
void onFolderModifyReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
void onFolderRemoveReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
private slots:
void slotChangeImage();
void enaDisaOperatorsButtons();
void enaDisaPhaseButtons();
void onAddExercisePhase();
void onEditVisibleParties();
void onEditExercisePhase();
void onRemoveExercisePhase();
void onExport();
void onImport();
void onCreateFolders();
void onExerciseChanged(const Exercise& data, DataModification modType);
void onExercisePhaseChanged(const ExercisePhase& data, DataModification modType);
void onContextMenuRequested(const QPoint& position);
void onSelectAllUsers();
void onUnselectAllUsers();
void onTimeZoneChanged();
signals:
void sendData(const ExerciseManagement::Exercise& data);
private:
void retranslate() override;
bool apply() override final;
void enaDisa();
void fillStateCbx();
void fillTrainingAreaCbx();
void fillActivePhaseCbx();
void fillRadioGroupCbx();
void fillLinkedExercisesCbx();
void fillAllCbx();
void imageModifyError();
void sendModifiedOperators(int thisExerciseId);
int createFolder(int parentFolderId, const QString& folderName, bool isHidden = false);
bool createFolders(int newExId);
bool createExerciseFolders(int parentFolderId, const QStringList& folderNames);
ExerciseModifyRequest setRequestContent() const;
QByteArray exerciseToJson() const;
ExerciseModifyRequest jsonToExercise(const QByteArray& content) const;
void requestImage();
const QPixmap getPixmap() const;
int getExerciseFolder();
Ui::ExerciseManagementEditDialog* m_ui{nullptr};
LtsSession::LtsSessionDataDds* m_session{nullptr};
ExercisePhaseModel* m_phaseModel{nullptr};
ExercisePhaseProxyModel* m_phaseProxyModel{nullptr};
ExerciseOperatorModel* m_operatorModel{nullptr};
bool m_pictureChanged{false};
int m_exerciseId{-1};
QVariant m_initialRadioGroupId;
ExerciseState m_currentState;
std::shared_ptr<Interface::Dtc> m_dtc;
std::shared_ptr<Interface::Ftc> m_ftc;
std::shared_ptr<OperatorManagement::Interface::Dtc> m_opmDtc;
std::shared_ptr<AssetManagement::Interface::Dtc> m_asmDtc;
std::shared_ptr<ProjectDataManagement::Interface::Dtc> m_pdmDtc;
std::shared_ptr<ParticipantManagement::Interface::Dtc> m_ppmDtc;
std::shared_ptr<FileManagement::Interface::Dtc> m_flmDtc;
std::shared_ptr<FileManagement::Interface::Ftc> m_flmFtc;
std::shared_ptr<FileManagement::ForeignGuiInterface> m_flmGui;
QString m_menuGroup;
LtsUtils::RequestHelper* m_requestHelper{nullptr};
template <class T> bool removeElement(std::vector<T>& vec, T elem);
bool hasVisibleParties(const std::vector<OperatorManagement::PartiesByExercise> vpbe) const;
};
}
} // namespace ExerciseManagement
@@ -1,237 +1,232 @@
#include "exm_edit_party_dialog.h"
#include "ui_exm_edit_party_dialog.h"
#include <LtsSession/lts_session.h>
#include <LtsWidgets/lts_frameless_dialog.h>
#include <LtsWidgets/lts_message_dialog.h>
#include <LtsSession/lts_session.h>
#include <ParticipantManagement/Data/ppm_data_plugin.h>
#include <Plugins/ExerciseManagement/Data/exm_data_plugin.h>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QListWidget>
#include <QMenu>
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
namespace ExerciseManagement
{
ExerciseEditPartyDialog::ExerciseEditPartyDialog(const int operatorId,
const int exerciseId,
const QString &menuGroup,
QWidget *parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
, m_operatorId(operatorId)
, m_exerciseId(exerciseId)
, m_visiblePartiesChanged(false)
, m_adlerVisiblePartiesChanged(false)
, m_menuGroup(menuGroup)
, m_visiblePartiesModel(nullptr)
, m_adlerVisiblePartiesModel(nullptr)
, m_opmDtc(nullptr)
, m_opmFtc(nullptr)
, m_ui(new Ui::ExerciseEditPartyDialog)
, m_requestHelper(new LtsUtils::RequestHelper(this))
ExerciseEditPartyDialog::ExerciseEditPartyDialog(const int operatorId, const int exerciseId, const QString& menuGroup,
QWidget* parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel), m_operatorId(operatorId),
m_exerciseId(exerciseId), m_visiblePartiesChanged(false), m_adlerVisiblePartiesChanged(false),
m_menuGroup(menuGroup), m_visiblePartiesModel(nullptr), m_adlerVisiblePartiesModel(nullptr), m_opmDtc(nullptr),
m_opmFtc(nullptr), m_ui(new Ui::ExerciseEditPartyDialog), m_requestHelper(new LtsUtils::RequestHelper(this))
{
setNoTopicLock();
m_ui->setupUi(this);
setOnlineHelpFilename(QStringLiteral("Administrator-Operator-Parties"));
setNoTopicLock();
m_ui->setupUi(this);
setOnlineHelpFilename(QStringLiteral("Administrator-Operator-Parties"));
}
bool ExerciseEditPartyDialog::init(LtsSession::LtsSessionDataDds *session)
bool ExerciseEditPartyDialog::init(LtsSession::LtsSessionDataDds* session)
{
if (!session->getDtc<OperatorManagement::DataInterface>(m_opmDtc))
return false;
if (!session->getFtc<OperatorManagement::DataInterface>(m_opmFtc))
return false;
if (!session->getDtc<OperatorManagement::DataInterface>(m_opmDtc))
return false;
if (!session->getFtc<OperatorManagement::DataInterface>(m_opmFtc))
return false;
m_visiblePartiesModel = new ExerciseEditVisiblePartiesModel(m_operatorId, m_exerciseId, this);
if (!m_visiblePartiesModel->init(session))
return false;
m_visiblePartiesModel = new ExerciseEditVisiblePartiesModel(m_operatorId, m_exerciseId, this);
if (!m_visiblePartiesModel->init(session))
return false;
m_ui->tvVisibleParties->setModel(m_visiblePartiesModel);
m_ui->tvVisibleParties->resizeColumnsToContent();
m_ui->tvVisibleParties->setSortIndicator(ExerciseEditVisiblePartiesModel::Columns::ColId, Qt::SortOrder::AscendingOrder);
m_ui->tvVisibleParties->setSortingEnabled(false);
m_ui->tvVisibleParties->setModel(m_visiblePartiesModel);
m_ui->tvVisibleParties->resizeColumnsToContent();
m_ui->tvVisibleParties->setSortIndicator(ExerciseEditVisiblePartiesModel::Columns::ColId,
Qt::SortOrder::AscendingOrder);
m_ui->tvVisibleParties->setSortingEnabled(false);
m_adlerVisiblePartiesModel = new ExerciseEditAdlerVisiblePartiesModel(m_operatorId, m_exerciseId, this);
if (!m_adlerVisiblePartiesModel->init(session))
return false;
m_adlerVisiblePartiesModel = new ExerciseEditAdlerVisiblePartiesModel(m_operatorId, m_exerciseId, this);
if (!m_adlerVisiblePartiesModel->init(session))
return false;
m_ui->tvAdlerVisibleParties->setModel(m_adlerVisiblePartiesModel);
m_ui->tvAdlerVisibleParties->resizeColumnsToContent();
m_ui->tvAdlerVisibleParties->setSortIndicator(ExerciseEditAdlerVisiblePartiesModel::Columns::ColId, Qt::SortOrder::AscendingOrder);
m_ui->tvAdlerVisibleParties->setSortingEnabled(false);
m_ui->tvAdlerVisibleParties->setModel(m_adlerVisiblePartiesModel);
m_ui->tvAdlerVisibleParties->resizeColumnsToContent();
m_ui->tvAdlerVisibleParties->setSortIndicator(ExerciseEditAdlerVisiblePartiesModel::Columns::ColId,
Qt::SortOrder::AscendingOrder);
m_ui->tvAdlerVisibleParties->setSortingEnabled(false);
#ifndef LTS_DEBUG
m_ui->tvVisibleParties->hideColumn(ExerciseEditVisiblePartiesModel::Columns::ColId);
m_ui->tvAdlerVisibleParties->hideColumn(ExerciseEditVisiblePartiesModel::Columns::ColId);
m_ui->tvVisibleParties->hideColumn(ExerciseEditVisiblePartiesModel::Columns::ColId);
m_ui->tvAdlerVisibleParties->hideColumn(ExerciseEditVisiblePartiesModel::Columns::ColId);
#endif
connect(m_ui->tvVisibleParties, &LtsDataView::LtsDataView::doubleClicked, m_visiblePartiesModel, &ExerciseEditVisiblePartiesModel::switchCheckbox);
connect(m_ui->tvAdlerVisibleParties, &LtsDataView::LtsDataView::doubleClicked, this, &ExerciseEditPartyDialog::onDoubleClicked);
connect(m_ui->tvVisibleParties, &LtsDataView::LtsDataView::doubleClicked, m_visiblePartiesModel,
&ExerciseEditVisiblePartiesModel::switchCheckbox);
connect(m_ui->tvAdlerVisibleParties, &LtsDataView::LtsDataView::doubleClicked, this,
&ExerciseEditPartyDialog::onDoubleClicked);
connect(m_visiblePartiesModel, &ExerciseEditVisiblePartiesModel::dataChanged, this, [this](const QModelIndex &index) {
m_visiblePartiesChanged = true; slotChangesMade(); onSwitchCheckbox(index);});
connect(m_adlerVisiblePartiesModel, &ExerciseEditAdlerVisiblePartiesModel::dataChanged, this, [this]() {
m_adlerVisiblePartiesChanged = true; slotChangesMade();});
connect(m_visiblePartiesModel, &ExerciseEditVisiblePartiesModel::dataChanged, this,
[this](const QModelIndex& index) {
m_visiblePartiesChanged = true;
slotChangesMade();
onSwitchCheckbox(index);
});
connect(m_adlerVisiblePartiesModel, &ExerciseEditAdlerVisiblePartiesModel::dataChanged, this, [this]() {
m_adlerVisiblePartiesChanged = true;
slotChangesMade();
});
#ifdef LTS_DEBUG
m_ui->tvVisibleParties->setContextMenuPolicy(Qt::CustomContextMenu);
connect(m_ui->tvVisibleParties, &LtsDataView::LtsDataView::customContextMenuRequested, this, &ExerciseEditPartyDialog::onContextMenuRequested);
m_ui->tvVisibleParties->setContextMenuPolicy(Qt::CustomContextMenu);
connect(m_ui->tvVisibleParties, &LtsDataView::LtsDataView::customContextMenuRequested, this,
&ExerciseEditPartyDialog::onContextMenuRequested);
#endif
setAdlerVisiblePartiesUncheckable();
return true;
setAdlerVisiblePartiesUncheckable();
return true;
}
bool ExerciseEditPartyDialog::operatorUpdateVisiblePartiesByExercise(const OperatorManagement::OperatorUpdateVisiblePartiesByExerciseRequest &req)
bool ExerciseEditPartyDialog::operatorUpdateVisiblePartiesByExercise(
const OperatorManagement::OperatorUpdateVisiblePartiesByExerciseRequest& req)
{
DEBUG_LOG(m_logger) << Q_FUNC_INFO;
return m_requestHelper->startSingleRequest([this, req]()
{
return m_opmFtc->operatorUpdateVisiblePartiesByExerciseRequest(req, this);
});
DEBUG_LOG(m_logger) << Q_FUNC_INFO;
return m_requestHelper->startSingleRequest(
[this, req]() { return m_opmFtc->operatorUpdateVisiblePartiesByExerciseRequest(req, this); });
}
ExerciseEditPartyDialog::~ExerciseEditPartyDialog()
{
delete m_ui;
delete m_ui;
}
void ExerciseEditPartyDialog::retranslate()
{
translate(m_ui, m_opmDtc->user(m_operatorId), tr("EX:%1 Operator ").arg(m_exerciseId));
translate(m_ui, m_opmDtc->user(m_operatorId), tr("EX:%1 Operator ").arg(m_exerciseId));
}
QByteArray ExerciseEditPartyDialog::adlerVisiblePartiesToJson() const
{
QJsonArray adlerVisiblePartiesArray;
QJsonObject adlerVisiblePartiesObject;
QJsonArray adlerVisiblePartiesArray;
QJsonObject adlerVisiblePartiesObject;
adlerVisiblePartiesArray.append(0);
adlerVisiblePartiesArray.append(1);
adlerVisiblePartiesArray.append(0);
adlerVisiblePartiesArray.append(1);
const QVector<int> &checkedParties = m_adlerVisiblePartiesModel->getCheckedIds();
for (const int id : checkedParties)
adlerVisiblePartiesArray.append(id);
adlerVisiblePartiesObject[QStringLiteral("adlerAllowed")] = adlerVisiblePartiesArray;
const QVector<int>& checkedParties = m_adlerVisiblePartiesModel->getCheckedIds();
for (const int id : checkedParties)
adlerVisiblePartiesArray.append(id);
adlerVisiblePartiesObject[QStringLiteral("adlerAllowed")] = adlerVisiblePartiesArray;
QJsonDocument adlerVisiblePartiesDocument(adlerVisiblePartiesObject);
QJsonDocument adlerVisiblePartiesDocument(adlerVisiblePartiesObject);
return adlerVisiblePartiesDocument.toJson(QJsonDocument::Compact);
return adlerVisiblePartiesDocument.toJson(QJsonDocument::Compact);
}
void ExerciseEditPartyDialog::setAdlerVisiblePartiesUncheckable()
{
const QVector<int> &uncheckedParties = m_visiblePartiesModel->getUncheckedIds();
QVector<int> rowIds;
for (const int id : uncheckedParties)
{
int rowId = m_adlerVisiblePartiesModel->findRowForPartyId(id);
if (rowId < 0)
continue;
rowIds.append(rowId);
}
m_adlerVisiblePartiesModel->setUncheckedPartyIds(rowIds);
const QVector<int>& uncheckedParties = m_visiblePartiesModel->getUncheckedIds();
QVector<int> rowIds;
for (const int id : uncheckedParties)
{
int rowId = m_adlerVisiblePartiesModel->findRowForPartyId(id);
if (rowId < 0)
continue;
rowIds.append(rowId);
}
m_adlerVisiblePartiesModel->setUncheckedPartyIds(rowIds);
}
bool ExerciseEditPartyDialog::apply()
{
DEBUG_LOG(m_logger) << Q_FUNC_INFO;
DEBUG_LOG(m_logger) << Q_FUNC_INFO;
if (m_operatorId <= 0)
return true;
if (m_operatorId <= 0)
return true;
OperatorManagement::OperatorUpdateVisiblePartiesByExerciseRequest req;
req.id(m_operatorId);
req.exerciseId(m_exerciseId);
OperatorManagement::OperatorUpdateVisiblePartiesByExerciseRequest req;
req.id(m_operatorId);
req.exerciseId(m_exerciseId);
if (!m_visiblePartiesChanged && !m_adlerVisiblePartiesChanged)
return false;
if (!m_visiblePartiesChanged && !m_adlerVisiblePartiesChanged)
return false;
QSet<int> visiblePartyIds = m_visiblePartiesModel->getCheckedIds().toList().toSet();
visiblePartyIds.insert(0);
visiblePartyIds.insert(1);
QSet<int> visiblePartyIds = m_visiblePartiesModel->getCheckedIds().toList().toSet();
const QVector<int> hiddenPartyIds = m_visiblePartiesModel->getUncheckedIds();
for (const int visible : visiblePartyIds)
DEBUG_LOG(m_logger) << "visible party: " << visible;
for (const int hidden : hiddenPartyIds)
DEBUG_LOG(m_logger) << "hidden party: " << hidden;
req.hiddenParties().set({});
req.visibleParties().set({});
std::copy(hiddenPartyIds.begin(), hiddenPartyIds.end(), std::back_inserter(req.hiddenParties().get()));
std::copy(visiblePartyIds.begin(), visiblePartyIds.end(), std::back_inserter(req.visibleParties().get()));
visiblePartyIds.insert(0);
visiblePartyIds.insert(1);
req.properties(adlerVisiblePartiesToJson().toStdString());
const QVector<int> hiddenPartyIds = m_visiblePartiesModel->getUncheckedIds();
for (const int visible : visiblePartyIds)
DEBUG_LOG(m_logger) << "visible party: " << visible;
for (const int hidden : hiddenPartyIds)
DEBUG_LOG(m_logger) << "hidden party: " << hidden;
req.hiddenParties().set({});
req.visibleParties().set({});
std::copy(hiddenPartyIds.begin(), hiddenPartyIds.end(), std::back_inserter(req.hiddenParties().get()));
std::copy(visiblePartyIds.begin(), visiblePartyIds.end(), std::back_inserter(req.visibleParties().get()));
DEBUG_LOG(m_logger) << "----------------- opId: " << req.id() << ", exId:" << req.exerciseId() << ", req.hiddenParties.size:" << hiddenPartyIds.size()
<< "adlerVisibleParties: " << req.properties();
req.properties(adlerVisiblePartiesToJson().toStdString());
return operatorUpdateVisiblePartiesByExercise(req);
DEBUG_LOG(m_logger) << "----------------- opId: " << req.id() << ", exId:" << req.exerciseId()
<< ", req.hiddenParties.size:" << hiddenPartyIds.size()
<< "adlerVisibleParties: " << req.properties();
return operatorUpdateVisiblePartiesByExercise(req);
}
void ExerciseEditPartyDialog::onContextMenuRequested(const QPoint &position)
void ExerciseEditPartyDialog::onContextMenuRequested(const QPoint& position)
{
QMenu menu(m_ui->tvVisibleParties);
menu.addAction(tr("Select All"), this, &ExerciseEditPartyDialog::onSelectAllParties);
menu.addAction(tr("Unselect All"), this, &ExerciseEditPartyDialog::onUnselectAllParties);
menu.exec(m_ui->tvVisibleParties->mapToGlobal(position));
QMenu menu(m_ui->tvVisibleParties);
menu.addAction(tr("Select All"), this, &ExerciseEditPartyDialog::onSelectAllParties);
menu.addAction(tr("Unselect All"), this, &ExerciseEditPartyDialog::onUnselectAllParties);
menu.exec(m_ui->tvVisibleParties->mapToGlobal(position));
}
void ExerciseEditPartyDialog::onSelectAllParties()
{
m_visiblePartiesModel->selectAll();
m_visiblePartiesModel->update();
m_visiblePartiesModel->selectAll();
m_visiblePartiesModel->update();
}
void ExerciseEditPartyDialog::onUnselectAllParties()
{
m_visiblePartiesModel->unselectAll();
m_visiblePartiesModel->update();
m_visiblePartiesModel->unselectAll();
m_visiblePartiesModel->update();
}
void ExerciseEditPartyDialog::onSwitchCheckbox(const QModelIndex &index)
void ExerciseEditPartyDialog::onSwitchCheckbox(const QModelIndex& index)
{
if (!index.isValid())
{
return;
}
if (!index.isValid())
{
return;
}
DEBUG_LOG(m_logger) << Q_FUNC_INFO << "index.row():" << index.row();
DEBUG_LOG(m_logger) << Q_FUNC_INFO << "index.row():" << index.row();
const QPair<bool, ParticipantManagement::Party> row = m_visiblePartiesModel->getRowData(index.row());
QPair<bool, ParticipantManagement::Party> rowAdler = m_adlerVisiblePartiesModel->getRowData(index.row());
rowAdler.first = row.first;
setAdlerVisiblePartiesUncheckable();
m_adlerVisiblePartiesModel->setRowData(index.row(), rowAdler);
const QPair<bool, ParticipantManagement::Party> row = m_visiblePartiesModel->getRowData(index.row());
QPair<bool, ParticipantManagement::Party> rowAdler = m_adlerVisiblePartiesModel->getRowData(index.row());
rowAdler.first = row.first;
setAdlerVisiblePartiesUncheckable();
m_adlerVisiblePartiesModel->setRowData(index.row(), rowAdler);
}
void ExerciseEditPartyDialog::onDoubleClicked(const QModelIndex &index)
void ExerciseEditPartyDialog::onDoubleClicked(const QModelIndex& index)
{
if (!index.isValid())
{
return;
}
if (!index.isValid())
{
return;
}
DEBUG_LOG(m_logger) << Q_FUNC_INFO << "index.row():" << index.row();
DEBUG_LOG(m_logger) << Q_FUNC_INFO << "index.row():" << index.row();
bool isChecked = m_visiblePartiesModel->getRowData(index.row()).first;
if (!isChecked)
return;
bool isChecked = m_visiblePartiesModel->getRowData(index.row()).first;
if (!isChecked)
return;
QPair<bool, ParticipantManagement::Party> row = m_adlerVisiblePartiesModel->getRowData(index.row());
row.first = !row.first;
m_adlerVisiblePartiesModel->setRowData(index.row(), row);
QPair<bool, ParticipantManagement::Party> row = m_adlerVisiblePartiesModel->getRowData(index.row());
row.first = !row.first;
m_adlerVisiblePartiesModel->setRowData(index.row(), row);
}
}
} // namespace ExerciseManagement
@@ -1,76 +1,77 @@
#pragma once
#include <OperatorManagement/opm_ftc.h>
#include <OperatorManagement/opm_dtc.h>
#include "exm_edit_adler_visible_parties_model.h"
#include "exm_edit_visible_parties_model.h"
#include <ExerciseManagement/logger.h>
#include "exm_edit_visible_parties_model.h"
#include "exm_edit_adler_visible_parties_model.h"
#include <LtsWidgets/lts_dialog.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <LtsWidgets/lts_dialog.h>
#include <OperatorManagement/opm_dtc.h>
#include <OperatorManagement/opm_ftc.h>
namespace Ui
{
class ExerciseEditPartyDialog;
}
namespace LtsSession {
namespace LtsSession
{
class LtsSession;
}
namespace ExerciseManagement
{
class ExerciseEditPartyDialog : public LtsWidgets::LtsDialog
, protected OperatorManagement::Interface::Ftc::OperatorUpdateVisiblePartiesByExerciseReplyHandler
class ExerciseEditPartyDialog
: public LtsWidgets::LtsDialog,
protected OperatorManagement::Interface::Ftc::OperatorUpdateVisiblePartiesByExerciseReplyHandler
{
Q_OBJECT
Q_OBJECT
public:
explicit ExerciseEditPartyDialog(const int operatorId,
const int exerciseId,
const QString &menuGroup,
QWidget *parent = nullptr);
~ExerciseEditPartyDialog();
public:
explicit ExerciseEditPartyDialog(const int operatorId, const int exerciseId, const QString& menuGroup,
QWidget* parent = nullptr);
~ExerciseEditPartyDialog();
bool init(LtsSession::LtsSessionDataDds *session);
void onOperatorUpdateVisiblePartiesByExerciseReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
bool init(LtsSession::LtsSessionDataDds* session);
private:
void onOperatorUpdateVisiblePartiesByExerciseReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
NGL::INGLLogger &m_logger;
void retranslate() override;
bool apply() override final;
QByteArray adlerVisiblePartiesToJson() const;
void setAdlerVisiblePartiesUncheckable();
private:
NGL::INGLLogger& m_logger;
void retranslate() override;
bool apply() override final;
QByteArray adlerVisiblePartiesToJson() const;
void setAdlerVisiblePartiesUncheckable();
private slots:
void onContextMenuRequested(const QPoint &position);
void onSelectAllParties();
void onUnselectAllParties();
void onSwitchCheckbox(const QModelIndex &index);
void onDoubleClicked(const QModelIndex &index);
private slots:
void onContextMenuRequested(const QPoint& position);
void onSelectAllParties();
void onUnselectAllParties();
void onSwitchCheckbox(const QModelIndex& index);
void onDoubleClicked(const QModelIndex& index);
private:
int m_operatorId;
int m_exerciseId;
bool m_visiblePartiesChanged;
bool m_adlerVisiblePartiesChanged;
QString m_menuGroup;
private:
int m_operatorId;
int m_exerciseId;
bool m_visiblePartiesChanged;
bool m_adlerVisiblePartiesChanged;
QString m_menuGroup;
ExerciseEditVisiblePartiesModel *m_visiblePartiesModel;
ExerciseEditAdlerVisiblePartiesModel *m_adlerVisiblePartiesModel;
std::shared_ptr<OperatorManagement::Interface::Dtc> m_opmDtc;
std::shared_ptr<OperatorManagement::Interface::Ftc> m_opmFtc;
Ui::ExerciseEditPartyDialog *m_ui;
LtsUtils::RequestHelper *m_requestHelper;
ExerciseEditVisiblePartiesModel* m_visiblePartiesModel;
ExerciseEditAdlerVisiblePartiesModel* m_adlerVisiblePartiesModel;
std::shared_ptr<OperatorManagement::Interface::Dtc> m_opmDtc;
std::shared_ptr<OperatorManagement::Interface::Ftc> m_opmFtc;
Ui::ExerciseEditPartyDialog* m_ui;
LtsUtils::RequestHelper* m_requestHelper;
bool operatorUpdateVisiblePartiesByExercise(const OperatorManagement::OperatorUpdateVisiblePartiesByExerciseRequest &req);
bool operatorUpdateVisiblePartiesByExercise(
const OperatorManagement::OperatorUpdateVisiblePartiesByExerciseRequest& req);
};
}
} // namespace ExerciseManagement
@@ -1,16 +1,15 @@
#pragma once
#include <ExerciseManagement/exm_dtc.h>
#include <ExerciseManagement/exm_ftc.h>
#include <ExerciseManagement/logger.h>
#include <LtsSession/lts_session_data_dds.h>
#include <LtsWidgets/lts_dialog.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <FileManagement/flm_dtc.h>
#include <FileManagement/flm_ftc.h>
#include <LtsSession/lts_session_data_dds.h>
#include <LtsUtils/LtsUtilsGui/LtsUtilsGuiDds/request_helper.h>
#include <LtsWidgets/lts_dialog.h>
namespace Ui
{
@@ -19,43 +18,51 @@ class ExerciseManagementPhaseEditDialog;
namespace ExerciseManagement
{
class ExerciseManagementPhaseEditDialog : public LtsWidgets::LtsDialog
, protected ExerciseManagement::Interface::Ftc::ExercisePhaseCreateReplyHandler
, protected ExerciseManagement::Interface::Ftc::ExercisePhaseModifyReplyHandler
, protected FileManagement::Interface::Ftc::FolderModifyReplyHandler
class ExerciseManagementPhaseEditDialog : public LtsWidgets::LtsDialog,
protected ExerciseManagement::Interface::Ftc::ExercisePhaseCreateReplyHandler,
protected ExerciseManagement::Interface::Ftc::ExercisePhaseModifyReplyHandler,
protected FileManagement::Interface::Ftc::FolderModifyReplyHandler
{
Q_OBJECT
Q_OBJECT
public:
explicit ExerciseManagementPhaseEditDialog(QWidget *parent = nullptr);
public:
explicit ExerciseManagementPhaseEditDialog(QWidget* parent = nullptr);
bool init(LtsSession::LtsSessionDataDds *session,
const int exerciseId,
const int phaseId);
bool init(LtsSession::LtsSessionDataDds* session, const int exerciseId, const int phaseId);
~ExerciseManagementPhaseEditDialog();
~ExerciseManagementPhaseEditDialog();
void onExercisePhaseCreateReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
void onExercisePhaseModifyReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
void onFolderModifyReply(const Core::FunctionReplyObject &replyObject) override final { m_requestHelper->requestReply(replyObject); }
void onExercisePhaseCreateReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
signals:
void sendData(const ExerciseManagement::ExercisePhase &data);
void onExercisePhaseModifyReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
private:
void onFolderModifyReply(const Core::FunctionReplyObject& replyObject) override final
{
m_requestHelper->requestReply(replyObject);
}
NGL::INGLLogger &m_logger;
void retranslate() override;
bool apply() override final;
signals:
void sendData(const ExerciseManagement::ExercisePhase& data);
Ui::ExerciseManagementPhaseEditDialog *m_ui{nullptr};
LtsSession::LtsSessionDataDds *m_session{nullptr};
int m_exercisePhaseId{-1};
int m_exerciseId{-1};
std::shared_ptr<Interface::Dtc> m_dtc;
std::shared_ptr<Interface::Ftc> m_ftc;
std::shared_ptr<FileManagement::Interface::Dtc> m_flmDtc;
std::shared_ptr<FileManagement::Interface::Ftc> m_flmFtc;
LtsUtils::RequestHelper *m_requestHelper{nullptr};
private:
NGL::INGLLogger& m_logger;
void retranslate() override;
bool apply() override final;
Ui::ExerciseManagementPhaseEditDialog* m_ui{nullptr};
LtsSession::LtsSessionDataDds* m_session{nullptr};
int m_exercisePhaseId{-1};
int m_exerciseId{-1};
std::shared_ptr<Interface::Dtc> m_dtc;
std::shared_ptr<Interface::Ftc> m_ftc;
std::shared_ptr<FileManagement::Interface::Dtc> m_flmDtc;
std::shared_ptr<FileManagement::Interface::Ftc> m_flmFtc;
LtsUtils::RequestHelper* m_requestHelper{nullptr};
};
}
} // namespace ExerciseManagement
@@ -1,146 +1,140 @@
#include "exm_operator_edit.h"
#include "ui_exm_operator_edit.h"
#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
#include <QMenu>
namespace ExerciseManagement
{
ExerciseManagementOperatorEdit::ExerciseManagementOperatorEdit(const QString &menuGroup, QWidget *parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel)
, m_ui(new Ui::ExerciseManagementOperatorEdit)
, m_opmDtc(nullptr)
, m_session(nullptr)
, m_operatorModel(nullptr)
, m_menuGroup(menuGroup)
, m_exercise()
, m_requestHelper(new LtsUtils::RequestHelper(this))
ExerciseManagementOperatorEdit::ExerciseManagementOperatorEdit(const QString& menuGroup, QWidget* parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::OkApplyCancel),
m_ui(new Ui::ExerciseManagementOperatorEdit), m_opmDtc(nullptr), m_session(nullptr), m_operatorModel(nullptr),
m_menuGroup(menuGroup), m_exercise(), m_requestHelper(new LtsUtils::RequestHelper(this))
{
m_ui->setupUi(this);
m_ui->setupUi(this);
#ifdef LTS_DEBUG
m_ui->dvOperators->setContextMenuPolicy(Qt::CustomContextMenu);
connect(m_ui->dvOperators, &LtsDataView::LtsDataView::customContextMenuRequested, this, &ExerciseManagementOperatorEdit::onContextMenuRequested);
m_ui->dvOperators->setContextMenuPolicy(Qt::CustomContextMenu);
connect(m_ui->dvOperators, &LtsDataView::LtsDataView::customContextMenuRequested, this,
&ExerciseManagementOperatorEdit::onContextMenuRequested);
#endif
setOnlineHelpFilename(QStringLiteral("Situation-Operators"));
setOnlineHelpFilename(QStringLiteral("Situation-Operators"));
}
ExerciseManagementOperatorEdit::~ExerciseManagementOperatorEdit()
{
delete m_ui;
delete m_ui;
}
bool ExerciseManagementOperatorEdit::init(LtsSession::LtsSessionDataDds *session)
bool ExerciseManagementOperatorEdit::init(LtsSession::LtsSessionDataDds* session)
{
m_session = session;
m_session = session;
if (!m_session->getDtc<OperatorManagement::DataInterface>(m_opmDtc))
return false;
if (!m_session->getDtc<OperatorManagement::DataInterface>(m_opmDtc))
return false;
std::shared_ptr<Interface::Dtc> dtc;
if (!m_session->getDtc<ExerciseManagement::DataInterface>(dtc))
return false;
std::shared_ptr<Interface::Dtc> dtc;
if (!m_session->getDtc<ExerciseManagement::DataInterface>(dtc))
return false;
m_exercise = dtc->exercise(m_session->exerciseId());
m_operatorModel = new ExerciseOperatorModel(m_session, m_exercise.id(), this);
m_ui->dvOperators->setModel(m_operatorModel);
m_ui->dvOperators->seamless();
connect(m_operatorModel, &ExerciseOperatorModel::dataChanged, this, &ExerciseManagementOperatorEdit::slotChangesMade);
m_exercise = dtc->exercise(m_session->exerciseId());
m_operatorModel = new ExerciseOperatorModel(m_session, m_exercise.id(), this);
m_ui->dvOperators->setModel(m_operatorModel);
m_ui->dvOperators->seamless();
connect(m_operatorModel, &ExerciseOperatorModel::dataChanged, this,
&ExerciseManagementOperatorEdit::slotChangesMade);
return true;
return true;
}
void ExerciseManagementOperatorEdit::onContextMenuRequested(const QPoint &position)
void ExerciseManagementOperatorEdit::onContextMenuRequested(const QPoint& position)
{
QMenu menu(m_ui->dvOperators);
menu.addAction(tr("Select All"), this, &ExerciseManagementOperatorEdit::onSelectAllUsers);
menu.addAction(tr("Unselect All"), this, &ExerciseManagementOperatorEdit::onUnselectAllUsers);
menu.exec(m_ui->dvOperators->mapToGlobal(position));
QMenu menu(m_ui->dvOperators);
menu.addAction(tr("Select All"), this, &ExerciseManagementOperatorEdit::onSelectAllUsers);
menu.addAction(tr("Unselect All"), this, &ExerciseManagementOperatorEdit::onUnselectAllUsers);
menu.exec(m_ui->dvOperators->mapToGlobal(position));
}
void ExerciseManagementOperatorEdit::onSelectAllUsers()
{
m_operatorModel->selectAll();
m_operatorModel->update();
m_operatorModel->selectAll();
m_operatorModel->update();
}
void ExerciseManagementOperatorEdit::onUnselectAllUsers()
{
m_operatorModel->unselectAll();
m_operatorModel->update();
m_operatorModel->unselectAll();
m_operatorModel->update();
}
void ExerciseManagementOperatorEdit::retranslate()
{
translate(m_ui, m_exercise, tr("Exercise Operators"));
translate(m_ui, m_exercise, tr("Exercise Operators"));
}
bool ExerciseManagementOperatorEdit::apply()
{
if (m_exercise.id() > 0)
{
sendModifiedOperators(m_exercise.id());
return true;
}
if (m_exercise.id() > 0)
{
sendModifiedOperators(m_exercise.id());
return true;
}
return false;
return false;
}
template<class T>
bool ExerciseManagementOperatorEdit::removeElement(std::vector<T> &vec, T elem)
template <class T> bool ExerciseManagementOperatorEdit::removeElement(std::vector<T>& vec, T elem)
{
for (auto it = vec.begin(); it != vec.end(); ++it)
{
if (*it == elem)
for (auto it = vec.begin(); it != vec.end(); ++it)
{
vec.erase(it);
return true;
if (*it == elem)
{
vec.erase(it);
return true;
}
}
}
return false;
return false;
}
void ExerciseManagementOperatorEdit::sendModifiedOperators(int thisExerciseId)
{
std::shared_ptr<OperatorManagement::Interface::Ftc> opmFtc;
if (!m_session->getFtc<OperatorManagement::DataInterface>(opmFtc))
{
ERROR_LOG(m_logger) << "Cannot change add/remove Operators to/from Exercise as the OPM-FTC could not be fetched." ;
return;
}
for (int row = 0; row < m_operatorModel->rowCount(); ++row)
{
const auto rowData = m_operatorModel->getRowData(row);
bool found = false;
OperatorManagement::User user = m_opmDtc->user(rowData.second.id());
for (auto ex : user.exerciseIds())
if (ex == thisExerciseId)
found = true;
if (found == rowData.first)
continue;
if (rowData.first)
user.exerciseIds().resize(user.exerciseIds().size() + 1, thisExerciseId);
else
removeElement(user.exerciseIds(), thisExerciseId);
OperatorManagement::OperatorCreateModifyRequest req;
req.id(user.id());
req.visibleExercises() = user.exerciseIds();
req.visiblePartiesByExercise() = user.visiblePartiesByExercise();
m_requestHelper->startSingleRequest([this, req, opmFtc]()
std::shared_ptr<OperatorManagement::Interface::Ftc> opmFtc;
if (!m_session->getFtc<OperatorManagement::DataInterface>(opmFtc))
{
return opmFtc->operatorCreateModifyRequest(req, this);
});
}
ERROR_LOG(m_logger)
<< "Cannot change add/remove Operators to/from Exercise as the OPM-FTC could not be fetched.";
return;
}
for (int row = 0; row < m_operatorModel->rowCount(); ++row)
{
const auto rowData = m_operatorModel->getRowData(row);
bool found = false;
OperatorManagement::User user = m_opmDtc->user(rowData.second.id());
for (auto ex : user.exerciseIds())
if (ex == thisExerciseId)
found = true;
if (found == rowData.first)
continue;
if (rowData.first)
user.exerciseIds().resize(user.exerciseIds().size() + 1, thisExerciseId);
else
removeElement(user.exerciseIds(), thisExerciseId);
OperatorManagement::OperatorCreateModifyRequest req;
req.id(user.id());
req.visibleExercises() = user.exerciseIds();
req.visiblePartiesByExercise() = user.visiblePartiesByExercise();
m_requestHelper->startSingleRequest(
[this, req, opmFtc]() { return opmFtc->operatorCreateModifyRequest(req, this); });
}
}
}
} // namespace ExerciseManagement
@@ -1,135 +1,124 @@
#include "exm_phase_edit.h"
#include "ui_exm_phase_edit.h"
#include "exm_phase_model.h"
#include "exm_edit_phase_dialog.h"
#include "exm_phase_model.h"
#include "ui_exm_phase_edit.h"
#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
namespace ExerciseManagement
{
ExerciseManagementPhaseEdit::ExerciseManagementPhaseEdit(const QString &menuGroup, QWidget *parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
, m_ui(new Ui::ExerciseManagementPhaseEdit)
, m_dtc(nullptr)
, m_ftc(nullptr)
, m_flmDtc(nullptr)
, m_flmFtc(nullptr)
, m_session(nullptr)
, m_phaseModel(nullptr)
, m_menuGroup(menuGroup)
, m_exercise()
, m_requestHelper(new LtsUtils::RequestHelper(this))
ExerciseManagementPhaseEdit::ExerciseManagementPhaseEdit(const QString& menuGroup, QWidget* parent)
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly),
m_ui(new Ui::ExerciseManagementPhaseEdit), m_dtc(nullptr), m_ftc(nullptr), m_flmDtc(nullptr), m_flmFtc(nullptr),
m_session(nullptr), m_phaseModel(nullptr), m_menuGroup(menuGroup), m_exercise(),
m_requestHelper(new LtsUtils::RequestHelper(this))
{
m_ui->setupUi(this);
m_ui->setupUi(this);
setOnlineHelpFilename(QStringLiteral("Situation-Exercise_Phases"));
setOnlineHelpFilename(QStringLiteral("Situation-Exercise_Phases"));
}
ExerciseManagementPhaseEdit::~ExerciseManagementPhaseEdit()
{
delete m_ui;
delete m_ui;
}
bool ExerciseManagementPhaseEdit::init(LtsSession::LtsSessionDataDds *session)
bool ExerciseManagementPhaseEdit::init(LtsSession::LtsSessionDataDds* session)
{
m_session = session;
m_session = session;
if (!m_session->getDtc<ExerciseManagement::DataInterface>(m_dtc))
return false;
if (!m_session->getFtc<ExerciseManagement::DataInterface>(m_ftc))
return false;
if (!m_session->getDtc<FileManagement::DataInterface>(m_flmDtc))
return false;
if (!m_session->getFtc<FileManagement::DataInterface>(m_flmFtc))
return false;
if (!m_session->getDtc<ExerciseManagement::DataInterface>(m_dtc))
return false;
if (!m_session->getFtc<ExerciseManagement::DataInterface>(m_ftc))
return false;
if (!m_session->getDtc<FileManagement::DataInterface>(m_flmDtc))
return false;
if (!m_session->getFtc<FileManagement::DataInterface>(m_flmFtc))
return false;
m_exercise = m_dtc->exercise(m_session->exerciseId());
m_exercise = m_dtc->exercise(m_session->exerciseId());
m_phaseModel = new ExercisePhaseModel(this);
m_phaseModel->initModel(m_exercise.id(), m_dtc);
m_phaseModel = new ExercisePhaseModel(this);
m_phaseModel->initModel(m_exercise.id(), m_dtc);
m_ui->dvPhases->setModel(m_phaseModel);
m_ui->dvPhases->hideColumn(3);
m_ui->dvPhases->hideColumn(4);
m_ui->dvPhases->seamless();
m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &ExerciseManagementPhaseEdit::onAddExercisePhase);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &ExerciseManagementPhaseEdit::onEditExercisePhase);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this, &ExerciseManagementPhaseEdit::onRemoveExercisePhase);
m_ui->dvPhases->setModel(m_phaseModel);
m_ui->dvPhases->hideColumn(3);
m_ui->dvPhases->hideColumn(4);
m_ui->dvPhases->seamless();
m_buttonBox->connectButton(LtsWidgets::DialogButton::Add, this, &ExerciseManagementPhaseEdit::onAddExercisePhase);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Edit, this, &ExerciseManagementPhaseEdit::onEditExercisePhase);
m_buttonBox->connectButton(LtsWidgets::DialogButton::Remove, this,
&ExerciseManagementPhaseEdit::onRemoveExercisePhase);
connect(m_ui->dvPhases, &LtsDataView::LtsDataView::signalDoubleClicked,
this, &ExerciseManagementPhaseEdit::onEditExercisePhase);
connect(m_ui->dvPhases, &LtsDataView::LtsDataView::signalSelectionChanged,
this, &ExerciseManagementPhaseEdit::enaDisaPhaseButtons);
enaDisaPhaseButtons();
connect(m_ui->dvPhases, &LtsDataView::LtsDataView::signalDoubleClicked, this,
&ExerciseManagementPhaseEdit::onEditExercisePhase);
connect(m_ui->dvPhases, &LtsDataView::LtsDataView::signalSelectionChanged, this,
&ExerciseManagementPhaseEdit::enaDisaPhaseButtons);
enaDisaPhaseButtons();
return true;
return true;
}
void ExerciseManagementPhaseEdit::enaDisaPhaseButtons()
{
QModelIndexList selectedRows = m_ui->dvPhases->selectedRows();
const int cntSelectedRows = selectedRows.size();
QModelIndexList selectedRows = m_ui->dvPhases->selectedRows();
const int cntSelectedRows = selectedRows.size();
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, cntSelectedRows == 1);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, cntSelectedRows == 1);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Edit, cntSelectedRows == 1);
m_buttonBox->setButtonEnabled(LtsWidgets::DialogButton::Remove, cntSelectedRows == 1);
}
void ExerciseManagementPhaseEdit::onAddExercisePhase()
{
ExerciseManagementPhaseEditDialog *dialog = new ExerciseManagementPhaseEditDialog(this);
dialog->init(m_session, m_exercise.id(), -1 );
ExerciseManagementPhaseEditDialog* dialog = new ExerciseManagementPhaseEditDialog(this);
dialog->init(m_session, m_exercise.id(), -1);
addDialog(dialog, m_menuGroup, QLatin1String("NewExercisePhase"), LtsWidgets::LayoutArea::eDialogTab);
addDialog(dialog, m_menuGroup, QLatin1String("NewExercisePhase"), LtsWidgets::LayoutArea::eDialogTab);
}
void ExerciseManagementPhaseEdit::onEditExercisePhase()
{
const QModelIndex idx = m_ui->dvPhases->currentIndex();
const ExercisePhase exPhase = m_phaseModel->getRowData(idx.row());
const QModelIndex idx = m_ui->dvPhases->currentIndex();
const ExercisePhase exPhase = m_phaseModel->getRowData(idx.row());
if (exPhase.id() <= 0)
return;
DEBUG_LOG(m_logger) << "current exPhase Id: " << exPhase.id();
if (exPhase.id() <= 0)
return;
DEBUG_LOG(m_logger) << "current exPhase Id: " << exPhase.id();
ExerciseManagementPhaseEditDialog *dialog = new ExerciseManagementPhaseEditDialog(this);
ExerciseManagementPhaseEditDialog* dialog = new ExerciseManagementPhaseEditDialog(this);
dialog->init(m_session, m_exercise.id(), exPhase.id());
const QString identifier = QLatin1String("EditExercisePhase") + QString::number(exPhase.id());
dialog->init(m_session, m_exercise.id(), exPhase.id());
const QString identifier = QLatin1String("EditExercisePhase") + QString::number(exPhase.id());
addDialog(dialog, m_menuGroup, identifier, LtsWidgets::LayoutArea::eDialogTab);
addDialog(dialog, m_menuGroup, identifier, LtsWidgets::LayoutArea::eDialogTab);
}
void ExerciseManagementPhaseEdit::onRemoveExercisePhase()
{
const int phId = m_phaseModel->getRowData(m_ui->dvPhases->currentIndex().row()).id();
int exeFolderId = m_flmDtc->getExerciseFolderId(m_exercise.id());
const int folderId = m_flmDtc->getPhaseFolderId(exeFolderId, phId);
const int phId = m_phaseModel->getRowData(m_ui->dvPhases->currentIndex().row()).id();
int exeFolderId = m_flmDtc->getExerciseFolderId(m_exercise.id());
const int folderId = m_flmDtc->getPhaseFolderId(exeFolderId, phId);
if (folderId > 0)
{
Core::RemoveElementRequest req(folderId);
m_requestHelper->startSingleRequest([req, this]()
if (folderId > 0)
{
return m_flmFtc->folderRemoveRequest(req, this);
});
}
Core::RemoveElementRequest req(folderId);
m_requestHelper->startSingleRequest([req, this]() { return m_flmFtc->folderRemoveRequest(req, this); });
}
Core::RemoveElementRequest req(m_phaseModel->getRowData(m_ui->dvPhases->currentIndex().row()).id());
m_requestHelper->startSingleRequest([req, this]()
{
m_ftc->enableExercisePhaseRemove();
return m_ftc->exercisePhaseRemoveRequest(req, this);
});
Core::RemoveElementRequest req(m_phaseModel->getRowData(m_ui->dvPhases->currentIndex().row()).id());
m_requestHelper->startSingleRequest([req, this]() {
m_ftc->enableExercisePhaseRemove();
return m_ftc->exercisePhaseRemoveRequest(req, this);
});
}
void ExerciseManagementPhaseEdit::retranslate()
{
translate(m_ui, tr("Exercise Phases"));
translate(m_ui, tr("Exercise Phases"));
}
}
} // namespace ExerciseManagement
@@ -1,97 +1,82 @@
#include "exm_phase_model.h"
namespace ExerciseManagement
{
ExercisePhaseModel::ExercisePhaseModel(QObject *parent)
: LtsWidgets::LtsAbstractTableModel<ExerciseManagement::ExercisePhase>({tr("Phase"),
tr("Start"),
tr("End"),
tr("Description"),
tr("Exercise-Id")},
parent)
, m_exmDtc(nullptr)
{}
bool ExercisePhaseModel::initModel(int exerciseId, const std::shared_ptr<ExerciseManagement::Interface::Dtc> &dtc)
ExercisePhaseModel::ExercisePhaseModel(QObject* parent)
: LtsWidgets::LtsAbstractTableModel<ExerciseManagement::ExercisePhase>(
{tr("Phase"), tr("Start"), tr("End"), tr("Description"), tr("Exercise-Id")}, parent),
m_exmDtc(nullptr)
{
m_exerciseId = exerciseId;
m_exmDtc = dtc;
connect(m_exmDtc.get(), &ExerciseManagement::Interface::Dtc::exercisePhaseChanged,
this, &ExercisePhaseModel::onDataChanged);
m_exmDtc->exercisePhases([this](const ExercisePhase &item) { insertRow(item); });
INFO_LOG(m_logger) << "initModel - #exercise phases: " << m_vecData.size();
return true;
}
QVariant ExercisePhaseModel::data(const QModelIndex &index, int role) const
bool ExercisePhaseModel::initModel(int exerciseId, const std::shared_ptr<ExerciseManagement::Interface::Dtc>& dtc)
{
if (!index.isValid() || role != Qt::DisplayRole || index.row() >= m_vecData.size())
return QVariant();
m_exerciseId = exerciseId;
m_exmDtc = dtc;
if (role == Qt::DisplayRole)
{
const ExerciseManagement::ExercisePhase &exPhase = m_vecData.at(index.row());
connect(m_exmDtc.get(), &ExerciseManagement::Interface::Dtc::exercisePhaseChanged, this,
&ExercisePhaseModel::onDataChanged);
switch (index.column())
m_exmDtc->exercisePhases([this](const ExercisePhase& item) { insertRow(item); });
INFO_LOG(m_logger) << "initModel - #exercise phases: " << m_vecData.size();
return true;
}
QVariant ExercisePhaseModel::data(const QModelIndex& index, int role) const
{
if (!index.isValid() || role != Qt::DisplayRole || index.row() >= m_vecData.size())
return QVariant();
if (role == Qt::DisplayRole)
{
case Name:
return QString::fromStdString(exPhase.name());
case Start:
return QDateTime::fromMSecsSinceEpoch(exPhase.beginTime());
case End:
return QDateTime::fromMSecsSinceEpoch(exPhase.endTime());
case Description:
return QString::fromStdString(exPhase.description());
case ExerciseId:
return (exPhase.exerciseId());
const ExerciseManagement::ExercisePhase& exPhase = m_vecData.at(index.row());
switch (index.column())
{
case Name:
return QString::fromStdString(exPhase.name());
case Start:
return QDateTime::fromMSecsSinceEpoch(exPhase.beginTime());
case End:
return QDateTime::fromMSecsSinceEpoch(exPhase.endTime());
case Description:
return QString::fromStdString(exPhase.description());
case ExerciseId:
return (exPhase.exerciseId());
}
}
}
return QVariant();
return QVariant();
}
void ExercisePhaseProxyModel::setSourceModel(QAbstractItemModel *sourceModel)
void ExercisePhaseProxyModel::setSourceModel(QAbstractItemModel* sourceModel)
{
m_sourceModel = qobject_cast<ExercisePhaseModel*>(sourceModel);
LtsWidgets::LtsColumnFilterProxyModel::setSourceModel(sourceModel);
m_sourceModel = qobject_cast<ExercisePhaseModel*>(sourceModel);
LtsWidgets::LtsColumnFilterProxyModel::setSourceModel(sourceModel);
}
bool ExercisePhaseProxyModel::lessThan(const QModelIndex &source_left, const QModelIndex &source_right) const
bool ExercisePhaseProxyModel::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())
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 ExercisePhaseModel::Start:
return dataLeft.beginTime() < dataRight.beginTime();
case ExercisePhaseModel::End:
return dataLeft.endTime() < dataRight.endTime();
case ExercisePhaseModel::Name:
case ExercisePhaseModel::Description:
case ExercisePhaseModel::ExerciseId:
break;
}
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 ExercisePhaseModel::Start:
return dataLeft.beginTime() < dataRight.beginTime();
case ExercisePhaseModel::End:
return dataLeft.endTime() < dataRight.endTime();
case ExercisePhaseModel::Name:
case ExercisePhaseModel::Description:
case ExercisePhaseModel::ExerciseId:
break;
}
return LtsWidgets::LtsColumnFilterProxyModel::lessThan(source_left, source_right);
}
}
} // namespace ExerciseManagement
@@ -1,65 +1,56 @@
#pragma once
#include <LtsWidgets/lts_abstract_table_model.h>
#include <LtsWidgets/lts_column_filter_proxy_model.h>
#include <ExerciseManagement/exm_dtc.h>
#include <ExerciseManagement/logger.h>
#include <LtsWidgets/lts_abstract_table_model.h>
#include <LtsWidgets/lts_column_filter_proxy_model.h>
namespace ExerciseManagement
{
class ExercisePhaseModel final : public LtsWidgets::LtsAbstractTableModel<ExerciseManagement::ExercisePhase>
{
Q_OBJECT
Q_OBJECT
public:
enum Columns
{
Name,
Start,
End,
Description,
ExerciseId
};
explicit ExercisePhaseModel(QObject *parent = nullptr);
public:
enum Columns { Name, Start, End, Description, ExerciseId };
bool initModel(int exerciseId, const std::shared_ptr<ExerciseManagement::Interface::Dtc> &dtc);
explicit ExercisePhaseModel(QObject* parent = nullptr);
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override final;
bool initModel(int exerciseId, const std::shared_ptr<ExerciseManagement::Interface::Dtc>& dtc);
protected:
QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override final;
NGL::INGLLogger &m_logger;
bool isFiltered(const ExercisePhase &data, DataModification modType) const override
{
if (data.exerciseId() != m_exerciseId)
return true;
return LtsWidgets::LtsAbstractTableModel<ExerciseManagement::ExercisePhase>::isFiltered(data, modType);
}
private:
int m_exerciseId{0};
protected:
NGL::INGLLogger& m_logger;
std::shared_ptr<ExerciseManagement::Interface::Dtc> m_exmDtc;
friend class ExercisePhaseProxyModel;
bool isFiltered(const ExercisePhase& data, DataModification modType) const override
{
if (data.exerciseId() != m_exerciseId)
return true;
return LtsWidgets::LtsAbstractTableModel<ExerciseManagement::ExercisePhase>::isFiltered(data, modType);
}
private:
int m_exerciseId{0};
std::shared_ptr<ExerciseManagement::Interface::Dtc> m_exmDtc;
friend class ExercisePhaseProxyModel;
};
class ExercisePhaseProxyModel 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:
ExercisePhaseModel *m_sourceModel = nullptr;
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:
ExercisePhaseModel* m_sourceModel = nullptr;
};
}
} // namespace ExerciseManagement