2074 lines
80 KiB
C++
Executable File
2074 lines
80 KiB
C++
Executable File
/**
|
|
* @RDE_HEADER@
|
|
* FileManagement - FileExplorer dialog
|
|
* $Id$
|
|
* $HeadURL$
|
|
* $Author$
|
|
* Created by Iuliana Ojog, SLSE, 2017-05-11
|
|
*/
|
|
|
|
#include "flm_dialog.h"
|
|
#include "ui_flm_dialog.h"
|
|
|
|
#include "flm_dialog_model_folder.h"
|
|
#include "flm_dialog_model_file.h"
|
|
#include "flm_edit_folder.h"
|
|
#include "flm_edit_file_content.h"
|
|
#include "flm_preview_file_dialog.h"
|
|
#include "flm_office_integration.h"
|
|
#include <FileManagement/flm_translation.h>
|
|
#include <FileManagement/flm_operator_rights.h>
|
|
#include <PluginInterfaces/gui_plugin_interface.h>
|
|
#include <Plugins/FileManagement/flm_data_plugin_interface.h>
|
|
#include <Plugins/FileManagement/flm_combobox_gui_plugin_interface.h>
|
|
#include <Plugins/FileManagement/flm_explorer_gui_plugin_interface.h>
|
|
#include <Plugins/OperatorManagement/opm_data_plugin_interface.h>
|
|
#include <Plugins/ExerciseManagement/exm_data_plugin_interface.h>
|
|
#include <Plugins/ParticipantManagement/ppm_data_plugin_interface.h>
|
|
|
|
#include <LtsSession/lts_session_data.h>
|
|
|
|
#include <LtsDataView/lts_data_view.h>
|
|
#include <LtsSession/lts_session_data.h>
|
|
#include <LtsUtilsCore/dds_vector.h>
|
|
#include <LtsUtilsSettings/settings.h>
|
|
#include <LtsWidgets/lts_base_layout_widget.h>
|
|
#include <nglwidgets/ngltreeitem.h>
|
|
#include <ngltools/ngltools_filesystem.h>
|
|
|
|
#include <QFileDialog>
|
|
#include <QFileInfo>
|
|
#include <QMenu>
|
|
|
|
namespace FileManagement
|
|
{
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
// FileManagementDialogWidget
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
FileManagementDialogWidget::FileManagementDialogWidget(QWidget *parent)
|
|
: QWidget(parent)
|
|
, m_ui(new Ui::FileManagementDialogWidget)
|
|
, m_requestHelper(new LtsUtils::RequestHelper(this))
|
|
, m_logger(getLogger("FileManagementDialog"))
|
|
{
|
|
m_ui->setupUi(this);
|
|
if (LtsSessionData::LtsSessionData::getInstance()->isTablet())
|
|
m_ui->leFile->setFocusPolicy(Qt::ClickFocus);
|
|
m_ui->widgetFiles->setToolButtonsVisible(false);
|
|
m_ui->widgetFiles->setColumnCountVisible(false);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
FileManagementDialogWidget::~FileManagementDialogWidget()
|
|
{
|
|
delete m_getContent;
|
|
delete m_ui;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
FileManagementDialogTab::~FileManagementDialogTab()
|
|
{
|
|
delete m_editItemWidget;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
FileManagementDialog::~FileManagementDialog()
|
|
{
|
|
delete m_editItemWidget;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogTab::retranslate()
|
|
{
|
|
if (m_dialogMode == FileDialogMode::Admin)
|
|
translate(m_editItemWidget->m_ui, tr("Manage Library"));
|
|
else
|
|
translate(m_editItemWidget->m_ui, tr("Organize Library"));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
bool FileManagementDialogWidget::init(LtsSession::LtsSession *session,
|
|
FileDialogMode dlgMode,
|
|
const QVector<FileType> &fileTypes,
|
|
int folderId,
|
|
const QString &xmlType)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Start init FileManagementDialogWidget";
|
|
if (!session)
|
|
{
|
|
ERROR_LOG(m_logger) << "Failed to init FileManagementDialogWidget";
|
|
return false;
|
|
}
|
|
|
|
m_session = session;
|
|
|
|
if (!session->getDtc<FileManagement::DataInterface>(m_dtc))
|
|
return false;
|
|
if (!session->getFtc<FileManagement::DataInterface>(m_ftc))
|
|
return false;
|
|
if (!session->getDtc<OperatorManagement::DataInterface>(m_opmDtc))
|
|
return false;
|
|
if (!session->getDtc<ExerciseManagement::DataInterface>(m_exmDtc))
|
|
return false;
|
|
if (!session->getDtc<ParticipantManagement::DataInterface>(m_ppmDtc))
|
|
return false;
|
|
if (!session->getForeignGuiInterface<FileManagement::ForeignGuiComboboxInterface>(m_flmGuiCbxIfc))
|
|
return false;
|
|
|
|
m_dialogMode = dlgMode;
|
|
m_fileTypes = fileTypes;
|
|
m_selectedFolderId = folderId;
|
|
m_xmlType = xmlType;
|
|
|
|
m_isAdminMode = (m_dialogMode == FileDialogMode::Admin);
|
|
|
|
m_dtc->enableFolder();
|
|
m_dtc->waitForHistoricalDataFolder();
|
|
m_dtc->enableFileContent();
|
|
m_dtc->waitForHistoricalDataFileContent();
|
|
m_opmDtc->enableUser();
|
|
m_opmDtc->waitForHistoricalDataUser();
|
|
m_exmDtc->enableExercise();
|
|
m_exmDtc->waitForHistoricalDataExercise();
|
|
m_exmDtc->enableExercisePhase();
|
|
m_exmDtc->waitForHistoricalDataExercisePhase();
|
|
m_ppmDtc->enableParty();
|
|
m_ppmDtc->waitForHistoricalDataParty();
|
|
|
|
m_getContent = new FileManagement::GetFileContent(m_ftc, this);
|
|
|
|
// DDS connects
|
|
connect(m_dtc.get(), &FileManagement::Interface::Dtc::folderChanged, this, &FileManagement::FileManagementDialogWidget::onFolderChanged);
|
|
connect(m_dtc.get(), &FileManagement::Interface::Dtc::fileContentChanged, this, &FileManagement::FileManagementDialogWidget::onFileChanged);
|
|
|
|
// model folder
|
|
QVariant data;
|
|
FileManagement::Folder dummyFolder;
|
|
data.setValue(dummyFolder);
|
|
NGLTreeItem *rootItem = new NGLTreeItem(data, QIcon());
|
|
|
|
m_modelFolder = new DialogModelFolder(this, rootItem,
|
|
QStringList()
|
|
<< tr("Name"));
|
|
// << tr("Operator") << tr("Id") << tr("Path") << tr("Parent") << tr("Editable"));
|
|
|
|
DEBUG_LOG(m_logger) << "Start init model folder";
|
|
m_modelFolder->init(m_session, m_isAdminMode);
|
|
int opId = LtsSessionData::LtsSessionData::getInstance()->getOperatorId();
|
|
if (m_dialogMode == FileDialogMode::Admin) // no filter on operator folders for admin
|
|
opId = 0;
|
|
m_proxyModelFolder = new DialogModelProxyFolder(this);
|
|
m_proxyModelFolder->setOperatorId(opId);
|
|
m_proxyModelFolder->setSourceModel(m_modelFolder);
|
|
m_proxyModelFolder->sort(DialogModelFolder::Columns::NAME, Qt::AscendingOrder);
|
|
|
|
// model file
|
|
m_modelFile = new DialogModelFile(this);
|
|
|
|
DEBUG_LOG(m_logger) << "Start init model file content";
|
|
// initial all valid, not-deleted files
|
|
auto predicate = [this](const FileManagement::FileContent &fc, const QString &xmlType)
|
|
{
|
|
if (!m_isAdminMode && fc.isHidden())
|
|
return false;
|
|
|
|
return (!fc.isDeleted() && fc.fileStatus() == FileManagement::FileStatus::Valid &&
|
|
(xmlType.isEmpty() || fc.properties().find(xmlType.toStdString()) != std::string::npos));
|
|
};
|
|
m_modelFile->initModel(m_session, xmlType, predicate);
|
|
|
|
// UI
|
|
m_ui->tvFolder->setModel(m_proxyModelFolder);
|
|
m_ui->tvFolder->expandAll();
|
|
m_ui->tvFolder->setExpanded(m_proxyModelFolder->index(0, 0), true);
|
|
|
|
m_proxyModelFile = new DialogFileProxyModel(this);
|
|
m_proxyModelFile->setSourceModel(m_modelFile);
|
|
m_ui->widgetFiles->setModel(m_proxyModelFile);
|
|
|
|
m_ui->widgetFiles->hideColumn(FOLDER);
|
|
#ifndef LTS_DEBUG
|
|
m_ui->widgetFiles->hideColumn(FILEID);
|
|
#endif
|
|
|
|
LtsUtils::ProjectSettings *ps = LtsUtils::ProjectSettings::getInstance();
|
|
const bool enableEditPhases = ps->value(QStringLiteral("exm"),
|
|
QStringLiteral("enableEditPhases")).toBool();
|
|
if (!enableEditPhases)
|
|
{
|
|
m_ui->widgetFiles->hideColumn(PHASE);
|
|
}
|
|
|
|
// double click data view files / select file
|
|
if (m_dialogMode == FileDialogMode::OpenFile || m_dialogMode == FileDialogMode::SaveFile)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Init dialog for open/save modal dialog";
|
|
|
|
// double click to select
|
|
connect(m_ui->widgetFiles, &LtsDataView::LtsDataView::signalDoubleClicked, this, &FileManagementDialogWidget::onSelectFile);
|
|
}
|
|
else
|
|
{
|
|
if (!LtsSessionData::LtsSessionData::getInstance()->isTablet())
|
|
{
|
|
// double click tree view folders
|
|
connect(m_ui->tvFolder, &QTreeView::doubleClicked, this, &FileManagementDialogWidget::onEditFolder);
|
|
|
|
// double click to edit file metadata
|
|
connect(m_ui->widgetFiles, &LtsDataView::LtsDataView::signalDoubleClicked, this, &FileManagementDialogWidget::onEditFile);
|
|
}
|
|
// ContextMenu Folder actions
|
|
m_ui->tvFolder->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
connect(m_ui->tvFolder, &QTreeView::customContextMenuRequested, this, &FileManagementDialogWidget::folderContextMenuRequested);
|
|
|
|
// ContextMenu File actions
|
|
m_ui->widgetFiles->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
connect(m_ui->widgetFiles, &LtsDataView::LtsDataView::customContextMenuRequested, this, &FileManagementDialogWidget::fileContextMenuRequested);
|
|
}
|
|
|
|
m_actionAddFolder = new QAction(QIcon(QLatin1String("icon:add.svg")), tr("Add Folder"), this);
|
|
connect(m_actionAddFolder, &QAction::triggered, this, &FileManagementDialogWidget::onAddFolder);
|
|
|
|
m_actionRenameFolder = new QAction(QIcon(QLatin1String("icon:edit.svg")), tr("Rename Folder"), this);
|
|
connect(m_actionRenameFolder, &QAction::triggered, this, &FileManagementDialogWidget::onEditFolder);
|
|
|
|
m_actionRemoveFolder = new QAction(QIcon(QLatin1String("icon:remove.svg")), tr("Remove Folder"), this);
|
|
connect(m_actionRemoveFolder, &QAction::triggered, this, &FileManagementDialogWidget::onRemoveFolder);
|
|
|
|
m_actionRefreshFolders = new QAction(QIcon(QLatin1String("icon:restart.svg")), tr("Refresh Folders"), this);
|
|
connect(m_actionRefreshFolders, &QAction::triggered, this, &FileManagementDialogWidget::onRefreshFolders);
|
|
|
|
m_actionCopyFolder = new QAction(QIcon(QLatin1String(":icons/16x16/edit-copy.png")), tr("Copy Folder"), this);
|
|
connect(m_actionCopyFolder, &QAction::triggered, this, &FileManagementDialogWidget::onCopyFolder);
|
|
|
|
m_actionCutFolder = new QAction(QIcon(QLatin1String("icon:edit-cut.svg")), tr("Cut Folder"), this);
|
|
connect(m_actionCutFolder, &QAction::triggered, this, &FileManagementDialogWidget::onCutFolder);
|
|
|
|
m_actionPasteFolder = new QAction(QIcon(QLatin1String(":icons/16x16/edit-paste.png")), tr("Paste Folder"), this);
|
|
connect(m_actionPasteFolder, &QAction::triggered, this, &FileManagementDialogWidget::onPasteFolder);
|
|
|
|
m_actionImportFile = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("Import File"), this);
|
|
connect(m_actionImportFile, &QAction::triggered, this, &FileManagementDialogWidget::onImportFile);
|
|
|
|
m_actionNewOfficeExcel = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New Excel File"), this);
|
|
connect(m_actionNewOfficeExcel, &QAction::triggered, this, &FileManagementDialogWidget::onNewOfficeExcel);
|
|
|
|
m_actionNewOfficeWord = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New Word File"), this);
|
|
connect(m_actionNewOfficeWord, &QAction::triggered, this, &FileManagementDialogWidget::onNewOfficeWord);
|
|
|
|
m_actionNewOfficePowerPoint = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New PowerPoint File"), this);
|
|
connect(m_actionNewOfficePowerPoint, &QAction::triggered, this, &FileManagementDialogWidget::onNewOfficePowerPoint);
|
|
|
|
m_actionNewLibreOfficeWrite = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New LibreOffice-Writer File"), this);
|
|
connect(m_actionNewLibreOfficeWrite, &QAction::triggered, this, &FileManagementDialogWidget::onNewLibreOfficeWrite);
|
|
|
|
m_actionNewLibreOfficeCalc = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New LibreOffice-Calc File"), this);
|
|
connect(m_actionNewLibreOfficeCalc, &QAction::triggered, this, &FileManagementDialogWidget::onNewLibreOfficeCalc);
|
|
|
|
m_actionNewLibreOfficePresent = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New LibreOffice-Impress File"), this);
|
|
connect(m_actionNewLibreOfficePresent, &QAction::triggered, this, &FileManagementDialogWidget::onNewLibreOfficePresent);
|
|
|
|
m_actionNewFromTemplate = new QAction(QIcon(QLatin1String("icon:document-new.svg")), tr("New from Template"), this);
|
|
connect(m_actionNewFromTemplate, &QAction::triggered, this, &FileManagementDialogWidget::onNewFileFromTemplate);
|
|
|
|
|
|
m_actionEditFile = new QAction(QIcon(QLatin1String("icon:document-edit.svg")), tr("Edit Properties"), this);
|
|
connect(m_actionEditFile, &QAction::triggered, this, &FileManagementDialogWidget::onEditFile);
|
|
|
|
m_actionDeleteFile = new QAction(QIcon(QLatin1String("icon:document-remove.svg")), tr("Delete File"), this);
|
|
connect(m_actionDeleteFile, &QAction::triggered, this, &FileManagementDialogWidget::onDeleteFile);
|
|
|
|
m_actionPreviewFile = new QAction(QIcon(QLatin1String("icon:document-preview.svg")), tr("Preview File"), this);
|
|
connect(m_actionPreviewFile, &QAction::triggered, this, &FileManagementDialogWidget::onPreviewFile);
|
|
|
|
m_actionCopyFile = new QAction(QIcon(QLatin1String(":icons/16x16/edit-copy.png")), tr("Copy File"), this);
|
|
connect(m_actionCopyFile, &QAction::triggered, this, &FileManagementDialogWidget::onCopyFile);
|
|
|
|
m_actionCutFile = new QAction(QIcon(QLatin1String(":icons/16x16/edit-cut.png")), tr("Cut File"), this);
|
|
connect(m_actionCutFile, &QAction::triggered, this, &FileManagementDialogWidget::onCutFile);
|
|
|
|
m_actionPasteFile = new QAction(QIcon(QLatin1String(":icons/16x16/edit-paste.png")), tr("Paste File"), this);
|
|
connect(m_actionPasteFile, &QAction::triggered, this, &FileManagementDialogWidget::onPasteFile);
|
|
|
|
m_actionExportFile = new QAction(QIcon(QLatin1String(":icons/16x16/document-save.png")), tr("Export File"), this);
|
|
connect(m_actionExportFile, &QAction::triggered, this, &FileManagementDialogWidget::onExportFile);
|
|
|
|
m_actionRemoveFile = new QAction(QIcon(QLatin1String(":icons/16x16/edit-delete.png")), tr("Remove File"), this);
|
|
connect(m_actionRemoveFile, &QAction::triggered, this, &FileManagementDialogWidget::onRemoveFile);
|
|
|
|
m_actionRestoreFile = new QAction(QIcon(QLatin1String(":icons/16x16/edit-undo.png")), tr("Restore File"), this);
|
|
connect(m_actionRestoreFile, &QAction::triggered, this, &FileManagementDialogWidget::onRestoreFile);
|
|
|
|
// SelectionModel Folder
|
|
QItemSelectionModel *selectionModelFolder = m_ui->tvFolder->selectionModel();
|
|
connect(selectionModelFolder, &QItemSelectionModel::selectionChanged, this, &FileManagementDialogWidget::onFolderSelectionChanged);
|
|
|
|
// initial folder selection
|
|
selectFolder();
|
|
|
|
// selection changed File
|
|
connect(m_ui->widgetFiles, &LtsDataView::LtsDataView::signalSelectionChanged, this, &FileManagementDialogWidget::enaDisa);
|
|
|
|
// enable filename edit
|
|
if (m_dialogMode == FileDialogMode::SaveFile)
|
|
{
|
|
DEBUG_LOG(m_logger) << "DialogMode Save";
|
|
m_ui->leFile->setEnabled(true);
|
|
connect(m_ui->leFile, &QLineEdit::textChanged, this, &FileManagementDialogWidget::saveFileName);
|
|
}
|
|
|
|
if (m_fileTypes.isEmpty() || m_fileTypes.contains(FileManagement::FileType::Unknown)) // no filtering
|
|
m_ui->lblFilter->setVisible(false);
|
|
else
|
|
{
|
|
QString labelFilter = tr("Filtering:") + QStringLiteral(" <b>");
|
|
QStringList types;
|
|
types.reserve(m_fileTypes.size());
|
|
for (auto &ft : m_fileTypes)
|
|
types << toString(ft);
|
|
labelFilter += types.join(QStringLiteral(", "));
|
|
labelFilter += QStringLiteral("</b>");
|
|
m_ui->lblFilter->setText(labelFilter);
|
|
}
|
|
|
|
enaDisa();
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::saveFileName(const QString &name)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Saving: " << name;
|
|
|
|
m_fileName = name;
|
|
m_selectedFileContent = m_modelFile->findFileFromName(name);
|
|
|
|
emit enableButtons();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
QModelIndex FileManagementDialogWidget::selectedIndexViewFolder() const
|
|
{
|
|
QItemSelectionModel *selectionModel = m_ui->tvFolder->selectionModel();
|
|
QModelIndexList indexL = selectionModel->selectedRows(0);
|
|
if (indexL.size() == 0)
|
|
return {};
|
|
return m_proxyModelFolder->mapToSource(indexL.at(0));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::enaDisa()
|
|
{
|
|
bool userHasRightsToEditFolder;
|
|
bool userHasRightsToEditFiles;
|
|
bool userhasAdminRights = LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::FileManagementFileAdmin);
|
|
if (userhasAdminRights)
|
|
{
|
|
userHasRightsToEditFolder = true;
|
|
userHasRightsToEditFiles = true;
|
|
}
|
|
else
|
|
{
|
|
userHasRightsToEditFolder = LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::FileManagementFoldersEdit);
|
|
userHasRightsToEditFiles = LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::FileManagementFilesEdit);
|
|
}
|
|
|
|
// folders
|
|
bool enableAddFolder = false;
|
|
bool enableEditFolder = false;
|
|
bool enableRemoveFolder = false;
|
|
|
|
m_actionCutFolder->setEnabled(false);
|
|
m_actionPasteFolder->setEnabled(false);
|
|
m_actionCopyFolder->setEnabled(false);
|
|
|
|
// files
|
|
bool enableImportFile = false;
|
|
bool enableNewFile = false;
|
|
bool enableNewFileFromTemplate = false;
|
|
bool enableEditFile = false;
|
|
bool enableDeleteFile = false;
|
|
bool enablePreviewFile = false;
|
|
bool enableExportFile = false;
|
|
bool enableRemoveFile = false;
|
|
bool enableRestoreFile = false;
|
|
bool isOffice = false;
|
|
|
|
m_actionCutFile->setEnabled(false);
|
|
m_actionPasteFile->setEnabled(false);
|
|
m_actionCopyFile->setEnabled(false);
|
|
|
|
QModelIndex idxFolder = selectedIndexViewFolder();
|
|
|
|
if (idxFolder.isValid())
|
|
{
|
|
m_selectedFolderId = m_modelFolder->getFolder(idxFolder).id();
|
|
|
|
const auto fldPath = m_dtc->folder(m_selectedFolderId).path();
|
|
// [GUEZE-3142]
|
|
// User can add new Exercise folder; User can only rename / remove folder he created;
|
|
// Admin User operatorId = 99 can remove folder created by users.
|
|
// if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::ExerciseDocuments))
|
|
// enableAddFolder = false; // not possible to add folders under Exercise
|
|
// else
|
|
enableAddFolder = true;
|
|
|
|
if (isFolderRemovable(idxFolder))
|
|
{
|
|
enableEditFolder = true;
|
|
enableRemoveFolder = true;
|
|
}
|
|
|
|
QString folderName = m_modelFolder->getFolderName(m_modelFolder->getFolder(idxFolder));
|
|
m_ui->lblSelectedFolder->setText(folderName);
|
|
|
|
m_actionCopyFolder->setEnabled(true && userHasRightsToEditFolder);
|
|
m_actionCutFolder->setEnabled(enableRemoveFolder && userHasRightsToEditFolder);
|
|
if (m_copyFolder.id() > 0)
|
|
m_actionPasteFolder->setEnabled(true && userHasRightsToEditFolder);
|
|
|
|
enableImportFile = true;
|
|
enableNewFile = true;
|
|
}
|
|
else
|
|
{
|
|
m_ui->lblSelectedFolder->setText(tr("None"));
|
|
m_selectedFolderId = 0;
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "enableRemoveFolder=" << enableRemoveFolder;
|
|
DEBUG_LOG(m_logger) << "enableEditFolder=" << enableEditFolder;
|
|
DEBUG_LOG(m_logger) << "userHasRightsToEditFolder=" << userHasRightsToEditFolder;
|
|
|
|
m_actionAddFolder->setEnabled(enableAddFolder && userHasRightsToEditFolder);
|
|
m_actionRemoveFolder->setEnabled(enableRemoveFolder && userHasRightsToEditFolder);
|
|
m_actionRenameFolder->setEnabled(enableEditFolder && userHasRightsToEditFolder);
|
|
|
|
m_actionRefreshFolders->setEnabled(true);
|
|
|
|
// files
|
|
QModelIndex idxFile = m_ui->widgetFiles->currentIndex();
|
|
if (idxFile.isValid())
|
|
{
|
|
FileManagement::FileContent data = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());
|
|
enableEditFile = true;
|
|
if (data.isTemplate() || data.isUsedBy())
|
|
enableDeleteFile = false;
|
|
else
|
|
enableDeleteFile = true;
|
|
|
|
if (data.fileStatus() == FileManagement::FileStatus::Deleted)
|
|
{
|
|
enableDeleteFile = false;
|
|
enableRestoreFile = true;
|
|
}
|
|
else
|
|
{
|
|
#ifndef LTS_DEBUG
|
|
if (data.fileType() != FileManagement::FileType::Xml
|
|
&& data.fileType() != FileManagement::FileType::OperatorDefinedSymbol
|
|
&& data.fileType() != FileManagement::FileType::OperatorFavourite
|
|
&& data.fileType() != FileManagement::FileType::EvaluationSchema
|
|
&& data.fileType() != FileManagement::FileType::TacticalPlan)
|
|
#endif
|
|
enablePreviewFile = true;
|
|
isOffice = (data.fileType() == FileManagement::FileType::OpenOfficeDocument ||
|
|
data.fileType() == FileManagement::FileType::OpenOfficeSpreadsheet ||
|
|
data.fileType() == FileManagement::FileType::OpenOfficePresentation ||
|
|
data.fileType() == FileManagement::FileType::MSOfficeDocument ||
|
|
data.fileType() == FileManagement::FileType::MSOfficeDocument97 ||
|
|
data.fileType() == FileManagement::FileType::MSOfficeSpreadsheet ||
|
|
data.fileType() == FileManagement::FileType::MSOfficeSpreadsheet97 ||
|
|
data.fileType() == FileManagement::FileType::MSOfficePresentation ||
|
|
data.fileType() == FileManagement::FileType::MSOfficePresentation97);
|
|
enableRestoreFile = false;
|
|
if (data.isTemplate())
|
|
enableNewFileFromTemplate = true;
|
|
}
|
|
m_selectedFileContent = data;
|
|
m_fileName = QString::fromStdString(data.name());
|
|
m_ui->leFile->setText(m_fileName);
|
|
|
|
enableExportFile = true; // export file always enabled, needed in AHTC
|
|
if (m_dialogMode != FileDialogMode::Admin)
|
|
{
|
|
enableRemoveFile = false;
|
|
enableRestoreFile = false;
|
|
}
|
|
else
|
|
{
|
|
if (data.isTemplate() || data.isUsedBy())
|
|
enableRemoveFile = false;
|
|
else
|
|
enableRemoveFile = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
enableExportFile = false;
|
|
m_selectedFileContent = FileManagement::FileContent();
|
|
if (m_dialogMode != FileDialogMode::SaveFile)
|
|
{
|
|
m_fileName.clear();
|
|
m_ui->leFile->setText(m_fileName);
|
|
}
|
|
}
|
|
|
|
m_actionImportFile->setEnabled(enableImportFile && userHasRightsToEditFiles);
|
|
m_actionNewOfficeWord->setEnabled(enableNewFile && userHasRightsToEditFiles);
|
|
m_actionNewOfficeExcel->setEnabled(enableNewFile && userHasRightsToEditFiles);
|
|
m_actionNewOfficePowerPoint->setEnabled(enableNewFile && userHasRightsToEditFiles);
|
|
m_actionNewLibreOfficeWrite->setEnabled(enableNewFile && userHasRightsToEditFiles);
|
|
m_actionNewLibreOfficeCalc->setEnabled(enableNewFile && userHasRightsToEditFiles);
|
|
m_actionNewLibreOfficePresent->setEnabled(enableNewFile && userHasRightsToEditFiles);
|
|
m_actionNewFromTemplate->setEnabled(enableNewFileFromTemplate && userHasRightsToEditFiles);
|
|
m_actionEditFile->setEnabled(enableEditFile && userHasRightsToEditFiles);
|
|
m_actionDeleteFile->setEnabled(enableDeleteFile && userHasRightsToEditFiles);
|
|
|
|
m_actionPreviewFile->setData(QVariant(isOffice));
|
|
m_actionPreviewFile->setEnabled(enablePreviewFile);
|
|
|
|
m_actionExportFile->setEnabled(enableExportFile && userHasRightsToEditFiles);
|
|
m_actionRemoveFile->setEnabled(enableRemoveFile && userhasAdminRights);
|
|
m_actionRestoreFile->setEnabled(enableRestoreFile && userhasAdminRights);
|
|
|
|
m_actionCopyFile->setEnabled(enableEditFile && userHasRightsToEditFiles);
|
|
m_actionCutFile->setEnabled(enableDeleteFile && userHasRightsToEditFiles);
|
|
if (m_copyFile.id() > 0) // copy - paste
|
|
m_actionPasteFile->setEnabled(true && userHasRightsToEditFiles);
|
|
|
|
emit enableButtons();
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
bool FileManagementDialogWidget::isFolderRemovable(const QModelIndex &idx) const
|
|
{
|
|
DEBUG_LOG(m_logger) << "isFolderRemovable index = " << idx.row();
|
|
|
|
if (!idx.isValid())
|
|
return false;
|
|
|
|
if (!m_modelFolder->isRowRemovable(m_modelFolder->privateData(idx)))
|
|
return false;
|
|
|
|
// not allowed to delete the main folders
|
|
if (m_modelFolder->privateData(idx)->data().value<FileManagement::Folder>().id() == FileManagement::MainFolder::GlobalDocuments ||
|
|
m_modelFolder->privateData(idx)->data().value<FileManagement::Folder>().id() == FileManagement::MainFolder::ExerciseDocuments ||
|
|
m_modelFolder->privateData(idx)->data().value<FileManagement::Folder>().id() == FileManagement::MainFolder::UserDocuments)
|
|
return false;
|
|
|
|
// Organisator id 99 can remove any folder, another operator can remove only own folders, regardless of child folders owners
|
|
int opId = LtsSessionData::LtsSessionData::getInstance()->getOperatorId();
|
|
bool userhasAdminRights = LtsSessionData::LtsSessionData::getInstance()->hasOperatorRight(OperatorRights::FileManagementFileAdmin);
|
|
if (!userhasAdminRights && opId != 99 && m_modelFolder->privateData(idx)->data().value<FileManagement::Folder>().operatorId() != opId)
|
|
return false;
|
|
|
|
// check if subfolders are removable too
|
|
const auto children = m_modelFolder->privateData(idx)->children();
|
|
for (const auto child : children)
|
|
if (!m_modelFolder->isRowRemovable(child))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onReject()
|
|
{
|
|
m_selectedFileContent = FileManagement::FileContent();
|
|
m_selectedFolderId = -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onAddFolder()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onAddFolder";
|
|
|
|
QModelIndex selIndex = selectedIndexViewFolder();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
|
|
if (m_selectedFolderId > 0) // valid selection
|
|
{
|
|
FolderEditDialog *dialog = new FolderEditDialog(this);
|
|
if (!dialog->init(selIndex, 0, m_selectedFolderId, m_dtc, m_ftc, m_isAdminMode))
|
|
{
|
|
delete dialog;
|
|
return;
|
|
}
|
|
|
|
QObject::connect(dialog, &FolderEditDialog::rejected, dialog, &FolderEditDialog::deleteLater);
|
|
|
|
dialog->show();
|
|
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onPasteFolder()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onPasteFolder";
|
|
|
|
QModelIndex selIndex = selectedIndexViewFolder();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
|
|
if (m_selectedFolderId > 0) // valid selection
|
|
{
|
|
FolderEditDialog *dialog = new FolderEditDialog(this);
|
|
if (!dialog->init(selIndex, 0, m_selectedFolderId, m_dtc, m_ftc, m_isAdminMode, m_copyFolder))
|
|
{
|
|
delete dialog;
|
|
return;
|
|
}
|
|
|
|
QObject::connect(dialog, &FolderEditDialog::rejected, dialog, &FolderEditDialog::deleteLater);
|
|
dialog->show();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onPasteFile()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onPasteFile";
|
|
|
|
if (m_selectedFolderId > 0 && m_copyFile.id() > 0)
|
|
{
|
|
m_copyFile.id(0); // we need new id
|
|
if (m_selectedFolderId == m_copyFile.folderId() && m_copyFile.name() == m_selectedFileContent.name()) // we need new name if we paste in same folder
|
|
{
|
|
QString newName = QString::fromStdString(m_copyFile.name()) + tr(" (Copy)");
|
|
m_copyFile.name(newName.toStdString());
|
|
}
|
|
m_copyFile.folderId(m_selectedFolderId);
|
|
|
|
// reset exercise id and phase id
|
|
int exId = 0;
|
|
int phId = 0;
|
|
m_copyFile.exerciseId();
|
|
m_copyFile.phaseId();
|
|
|
|
// change category regardless of original category
|
|
const auto fldPath = m_dtc->folder(m_selectedFolderId).path();
|
|
|
|
if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::UserDocuments))
|
|
m_copyFile.fileCategory(FileManagement::FileCategory::User);
|
|
else if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::ExerciseDocuments))
|
|
{
|
|
m_copyFile.fileCategory(FileManagement::FileCategory::Exercise);
|
|
|
|
if (fldPath.size() >= 2) // means we are in a specific exercise folder
|
|
{
|
|
exId = m_dtc->getExerciseId(fldPath.at(1));
|
|
if (exId > 0 && fldPath.size() >= 4) // we got an exercise Id and we are in a phase sub-folder
|
|
phId = m_dtc->getExerciseId(fldPath.at(3));
|
|
}
|
|
else // using current exercise id and phase id
|
|
{
|
|
if (m_session->exerciseId() > 0)
|
|
{
|
|
exId = m_session->exerciseId();
|
|
if (m_session->exerciseData()->phId > 0)
|
|
phId = m_session->exerciseData()->phId;
|
|
}
|
|
}
|
|
|
|
if (exId > 0)
|
|
m_copyFile.exerciseId(exId);
|
|
if (phId > 0)
|
|
m_copyFile.phaseId(phId);
|
|
|
|
}
|
|
else
|
|
m_copyFile.fileCategory(FileManagement::FileCategory::Global); // global
|
|
|
|
FileContentEditDialog *dialog = new FileContentEditDialog(this);
|
|
QString folderName = m_modelFolder->getFolderName(m_dtc->folder(m_selectedFolderId));
|
|
|
|
if (!dialog->init(m_session, QModelIndex(), m_isAdminMode, folderName, m_copyFile, m_content))
|
|
{
|
|
delete dialog;
|
|
return;
|
|
}
|
|
|
|
QObject::connect(dialog, &FolderEditDialog::rejected, dialog, &FolderEditDialog::deleteLater);
|
|
|
|
dialog->show();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onRemoveFolder()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onRemoveFolder id = " << m_selectedFolderId;
|
|
|
|
QModelIndex selIndex = selectedIndexViewFolder();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
|
|
if (LtsWidgets::LtsMessageDialog::showMessage(this, tr("Yes - remove folder, subfolders and all files contained.<br>"
|
|
"No - do not remove folder.<br>"),
|
|
tr("Do you really want to remove folder and all files contained?"),
|
|
LtsWidgets::Behaviour::Modal,
|
|
LtsWidgets::Button::Yes | LtsWidgets::Button::No) != LtsWidgets::Button::Yes)
|
|
{
|
|
return; // do nothing if not confirmed by user
|
|
}
|
|
|
|
// check if folder and all subfolders are removable
|
|
if (isFolderRemovable(selIndex))
|
|
{
|
|
DEBUG_LOG(m_logger) << "Removing folder id = " << m_selectedFolderId;
|
|
|
|
Core::RemoveElementRequest req(m_selectedFolderId);
|
|
m_requestHelper->startSingleRequest([req, this]()
|
|
{
|
|
return m_ftc->folderRemoveRequest(req, this);
|
|
});
|
|
if (m_requestHelper->failed())
|
|
ERROR_LOG(m_logger) << "Failed to remove folder id = " << m_selectedFolderId;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::removeCurrentRowFolder()
|
|
{
|
|
DEBUG_LOG(m_logger) << "removeCurrentRowFolder";
|
|
|
|
QModelIndex selIndex = selectedIndexViewFolder();
|
|
NGLTreeItem *item = m_modelFolder->privateData(selIndex);
|
|
FileManagement::Folder fld = item->data().value<FileManagement::Folder>();
|
|
bool isRootFolder = (fld.id() == 0);
|
|
|
|
DEBUG_LOG(m_logger) << "isRootFolder = " << isRootFolder;
|
|
|
|
if (!selIndex.isValid() || isRootFolder)
|
|
return;
|
|
|
|
m_modelFolder->onDeleteRow(selIndex, true);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
QString FileManagementDialogWidget::getTemplateFile(const QString &fileName)
|
|
{
|
|
return NGL::findFile(NGL::FileType::ConfigFile, fileName);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onRefreshFolders()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onRefreshFolders";
|
|
|
|
m_modelFolder->initModel(m_session->exerciseId(), m_isAdminMode);
|
|
m_ui->tvFolder->expandAll();
|
|
m_ui->tvFolder->selectionModel()->clearSelection();
|
|
|
|
enaDisa();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onCopyFolder()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onCopyFolder";
|
|
|
|
QModelIndex selIndex = selectedIndexViewFolder();
|
|
NGLTreeItem *item = m_modelFolder->privateData(selIndex);
|
|
m_copyFolder = item->data().value<FileManagement::Folder>();
|
|
m_copyFolder.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());
|
|
|
|
enaDisa();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onCopyFile()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onCopyFile";
|
|
|
|
m_copyFile = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());
|
|
|
|
m_getContent->getContent(m_copyFile.id(), m_content);
|
|
|
|
enaDisa();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onCutFolder()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onCutFolder";
|
|
|
|
QModelIndex selIndex = selectedIndexViewFolder();
|
|
NGLTreeItem *item = m_modelFolder->privateData(selIndex);
|
|
m_copyFolder = item->data().value<FileManagement::Folder>();
|
|
|
|
// TODO: only after a succesful Paste??
|
|
onRemoveFolder();
|
|
|
|
enaDisa();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onCutFile()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onCutFile";
|
|
|
|
m_copyFile = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());
|
|
|
|
m_getContent->getContent(m_copyFile.id(), m_content);
|
|
|
|
onDeleteFile();
|
|
|
|
enaDisa();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onEditFolder()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onEditFolder Id = " << m_selectedFolderId;
|
|
|
|
if (!m_actionRenameFolder->isEnabled())
|
|
return;
|
|
|
|
QModelIndex selIndex = selectedIndexViewFolder();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
|
|
if (m_selectedFolderId > 0) // valid selection
|
|
{
|
|
FileManagement::Folder data = m_modelFolder->privateData(selIndex)->data().value<FileManagement::Folder>();
|
|
|
|
FolderEditDialog *dialog = new FolderEditDialog(this);
|
|
if (!dialog->init(selIndex, m_selectedFolderId, 0, m_dtc, m_ftc, m_isAdminMode, data))
|
|
{
|
|
delete dialog;
|
|
return;
|
|
}
|
|
|
|
dialog->setAttribute(Qt::WA_DeleteOnClose);
|
|
|
|
dialog->show();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onRemoveFile()
|
|
{
|
|
const QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
|
|
if (LtsWidgets::LtsMessageDialog::showMessage(this, tr("Yes - remove file.<br>"
|
|
"No - do not remove file.<br>"),
|
|
tr("Do you really want to remove this file?"),
|
|
LtsWidgets::Behaviour::Modal,
|
|
LtsWidgets::Button::Yes | LtsWidgets::Button::No) != LtsWidgets::Button::Yes)
|
|
{
|
|
return; // do nothing if not confirmed by user
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "onRemoveFile";
|
|
|
|
FileManagement::FileContent data = m_modelFile->getRowData(selIndex.row());
|
|
Core::RemoveElementRequest req(data.id());
|
|
m_requestHelper->startSingleRequest([req, this]()
|
|
{
|
|
return m_ftc->fileContentRemoveRequest(req, this);
|
|
});
|
|
|
|
if (m_requestHelper->failed())
|
|
ERROR_LOG(m_logger) << "Failed to remove file content";
|
|
else
|
|
reInitModelFile();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onDeleteFile()
|
|
{
|
|
QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
|
|
DEBUG_LOG(m_logger) << "onDeleteFile";
|
|
|
|
m_requestHelper->startSingleRequest([this]()
|
|
{
|
|
FileManagement::FileContent data = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());
|
|
|
|
if (data.fileStatus() == FileManagement::FileStatus::Deleted)
|
|
return int64_t(0);
|
|
|
|
DEBUG_LOG(m_logger) << "Deleting file id = " << data.id();
|
|
|
|
FileManagement::FileContentChangeStatusRequest req;
|
|
req.id(data.id());
|
|
|
|
req.fileStatus(FileManagement::FileStatus::Deleted);
|
|
req.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());
|
|
req.lastModified(QDateTime::currentMSecsSinceEpoch());
|
|
|
|
return m_ftc->fileContentChangeStatusRequest(FileContentChangeStatusRequest(req), this);
|
|
});
|
|
|
|
if (m_requestHelper->failed())
|
|
ERROR_LOG(m_logger) << "Failed to change status file content";
|
|
else
|
|
reInitModelFile();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::reInitModelFile(bool restoreSelected)
|
|
{
|
|
int selectedFileId = 0;
|
|
if (restoreSelected)
|
|
{
|
|
QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
|
|
if (selIndex.isValid())
|
|
{
|
|
selectedFileId = m_modelFile->getRowData(selIndex.row()).id();
|
|
ERROR_LOG(m_logger) << "Selected file id = " << selectedFileId;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_ui->widgetFiles->setCurrentIndex(QModelIndex());
|
|
}
|
|
|
|
auto predicate = [this](const FileManagement::FileContent & fc, const QString &xmlType)
|
|
{
|
|
return showFile(fc, xmlType);
|
|
};
|
|
|
|
m_modelFile->initModel(m_session, m_xmlType, predicate);
|
|
|
|
if (restoreSelected && selectedFileId > 0)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Restoring selection on file " << selectedFileId;
|
|
QModelIndex idx = m_modelFile->findIndexForId(selectedFileId);
|
|
if (idx.isValid())
|
|
m_ui->widgetFiles->setCurrentIndex(idx);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onRestoreFile()
|
|
{
|
|
QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
|
|
DEBUG_LOG(m_logger) << "onRestoreFile";
|
|
|
|
m_requestHelper->startSingleRequest([this]()
|
|
{
|
|
FileManagement::FileContent data = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());
|
|
|
|
if (data.fileStatus() == FileManagement::FileStatus::Valid)
|
|
return int64_t(0);
|
|
|
|
DEBUG_LOG(m_logger) << "Deleting file id = " << data.id();
|
|
|
|
FileManagement::FileContentChangeStatusRequest req;
|
|
req.id(data.id());
|
|
|
|
req.fileStatus(FileManagement::FileStatus::Valid);
|
|
req.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());
|
|
req.lastModified(QDateTime::currentMSecsSinceEpoch());
|
|
|
|
return m_ftc->fileContentChangeStatusRequest(FileContentChangeStatusRequest(req), this);
|
|
});
|
|
|
|
if (m_requestHelper->failed())
|
|
ERROR_LOG(m_logger) << "Failed to change status file content";
|
|
else
|
|
reInitModelFile();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onEditFile()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onEditFileContent";
|
|
|
|
if (!m_actionEditFile->isEnabled())
|
|
return;
|
|
|
|
QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
|
|
if (!selIndex.isValid())
|
|
return;
|
|
|
|
FileManagement::FileContent data = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());
|
|
DEBUG_LOG(m_logger) << "onEditFileContent Id = " << data.id();
|
|
|
|
m_getContent->getContent(data.id(), m_content);
|
|
|
|
FileContentEditDialog *dialog = new FileContentEditDialog(this);
|
|
QString folderName = m_modelFolder->getFolderName(m_dtc->folder(data.folderId()));
|
|
|
|
if (!dialog->init(m_session, selIndex, m_isAdminMode, folderName, data, m_content))
|
|
{
|
|
delete dialog;
|
|
return;
|
|
}
|
|
|
|
dialog->setAttribute(Qt::WA_DeleteOnClose);
|
|
|
|
QObject::connect(dialog, &FileContentEditDialog::rejected, dialog, &FolderEditDialog::deleteLater);
|
|
|
|
dialog->show();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onImportFile()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onImportFile";
|
|
|
|
// open dialog
|
|
const QStringList filter(
|
|
{
|
|
tr("PDF Files (*.pdf)"),
|
|
tr("Images (*.jpg *.jpeg *.png)"),
|
|
tr("XML Files (*.xml)"),
|
|
tr("TXT Files (*.txt)"),
|
|
tr("MSOffice Word Documents (*.doc *.dot *.docx *dotx *.docm *.dotm)"),
|
|
tr("MSOffice Excel Documents (*.xls *.xlt *.xlm *.xlsx *.xlst *.xltm *.xltx)"),
|
|
tr("MSOffice PowerPoint Documents (*.ppt *.pot *.pps *.pptx *.pptm *.potx *.potm)"),
|
|
tr("OpenOffice Documents (*.odt *.ods *.odp)"),
|
|
#ifdef Q_OS_WIN
|
|
tr("All (*.*)")
|
|
#else
|
|
tr("All (*)")
|
|
#endif
|
|
});
|
|
// static so it's saved for next time
|
|
static QString defaultPath = QDir::homePath() + QStringLiteral("/scanner/");
|
|
QString fileName = QFileDialog::getOpenFileName(this,
|
|
tr("Load file to library"),
|
|
defaultPath,
|
|
filter.join(QStringLiteral(";;")));
|
|
if (fileName.isEmpty())
|
|
return;
|
|
|
|
QFileInfo fileInfo(fileName);
|
|
if (!fileInfo.isReadable())
|
|
{
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("An error occurred while loading the file.\n"
|
|
"The loaded file is not readable."));
|
|
return;
|
|
}
|
|
|
|
defaultPath = fileInfo.path();
|
|
QString fileExt = fileInfo.suffix();
|
|
|
|
QFile file(fileName);
|
|
if (!file.open(QIODevice::ReadOnly))
|
|
{
|
|
ERROR_LOG(m_logger) << "Cannot read file " << fileName;
|
|
return;
|
|
}
|
|
QByteArray fileContent = file.readAll();
|
|
|
|
// metadata, fill in the default values & the content
|
|
FileManagement::FileContent data = FileContent();
|
|
data.folderId(m_selectedFolderId);
|
|
data.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());
|
|
data.name(fileInfo.baseName().toStdString());
|
|
data.fileStatus(FileManagement::FileStatus::Valid);
|
|
|
|
int exId = 0;
|
|
int phId = 0;
|
|
if (m_session->exerciseId() > 0)
|
|
{
|
|
exId = m_session->exerciseId();
|
|
if (m_session->exerciseData()->phId > 0)
|
|
phId = m_session->exerciseData()->phId;
|
|
}
|
|
|
|
const auto fldPath = m_dtc->folder(m_selectedFolderId).path();
|
|
if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::UserDocuments))
|
|
data.fileCategory(FileManagement::FileCategory::User);
|
|
else if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::ExerciseDocuments))
|
|
{
|
|
data.fileCategory(FileManagement::FileCategory::Exercise);
|
|
if (fldPath.size() >= 2) // means we are in a specific exercise folder
|
|
{
|
|
exId = m_dtc->getExerciseId(fldPath.at(1));
|
|
if (exId > 0 && fldPath.size() >= 4) // we got an exercise Id and we are in a phase sub-folder
|
|
phId = m_dtc->getExerciseId(fldPath.at(3));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
data.fileCategory(FileManagement::FileCategory::Global); // global
|
|
exId = 0;
|
|
phId = 0;
|
|
}
|
|
|
|
DEBUG_LOG(m_logger) << "Exercise id = " << exId << ", phase Id = " << phId;
|
|
|
|
if (exId > 0)
|
|
data.exerciseId(exId);
|
|
if (phId > 0)
|
|
data.phaseId(phId);
|
|
|
|
data.fileType(getFileType(fileExt)); // match from file extension to file type
|
|
|
|
// create dialog
|
|
FileContentEditDialog *dialog = new FileContentEditDialog(this);
|
|
QString folderName = m_modelFolder->getFolderName(m_dtc->folder(data.folderId()));
|
|
|
|
// init & show dialog to modify the meta data
|
|
if (!dialog->init(m_session, QModelIndex(), m_isAdminMode, folderName, data, LtsUtils::convert<std::vector<uint8_t>>(fileContent)))
|
|
{
|
|
delete dialog;
|
|
return;
|
|
}
|
|
|
|
dialog->setAttribute(Qt::WA_DeleteOnClose);
|
|
|
|
QObject::connect(dialog, &FileContentEditDialog::rejected, dialog, &FileContentEditDialog::deleteLater);
|
|
|
|
dialog->show();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::createNewOfficeFile(const QString &fileName)
|
|
{
|
|
if (fileName.isEmpty())
|
|
return;
|
|
|
|
const QString absFilePath = getTemplateFile(fileName);
|
|
if (absFilePath.isEmpty())
|
|
{
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("An error occurred while loading the file.\n"
|
|
"Can not find template file '%1'.").arg(fileName));
|
|
return;
|
|
}
|
|
|
|
QFileInfo fileInfo(absFilePath);
|
|
if (!fileInfo.isReadable())
|
|
{
|
|
LtsWidgets::LtsMessageDialog::showMessage(this, tr("An error occurred while loading the file.\n"
|
|
"The file to load is not readable (%1).").arg(absFilePath));
|
|
return;
|
|
}
|
|
|
|
QFile file(absFilePath);
|
|
if (!file.open(QIODevice::ReadOnly))
|
|
{
|
|
ERROR_LOG(m_logger) << "Cannot read file " << absFilePath;
|
|
return;
|
|
}
|
|
QByteArray fileContent = file.readAll();
|
|
|
|
// metadata, fill in the default values & the content
|
|
FileManagement::FileContent data;
|
|
data.folderId(m_selectedFolderId);
|
|
data.operatorId(LtsSessionData::LtsSessionData::getInstance()->getOperatorId());
|
|
data.name(tr("<please fill in file name>").toStdString());
|
|
data.fileStatus(FileManagement::FileStatus::Valid);
|
|
|
|
int exId = 0;
|
|
int phId = 0;
|
|
if (m_session->exerciseId() > 0)
|
|
{
|
|
exId = m_session->exerciseId();
|
|
if (m_session->exerciseData()->phId > 0)
|
|
phId = m_session->exerciseData()->phId;
|
|
}
|
|
|
|
const auto fldPath = m_dtc->folder(m_selectedFolderId).path();
|
|
if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::UserDocuments))
|
|
data.fileCategory(FileManagement::FileCategory::User);
|
|
else if (LtsUtils::isInVector(fldPath, FileManagement::MainFolder::ExerciseDocuments))
|
|
{
|
|
data.fileCategory(FileManagement::FileCategory::Exercise);
|
|
if (fldPath.size() >= 2) // means we are in a specific exercise folder
|
|
{
|
|
exId = m_dtc->getExerciseId(fldPath.at(1));
|
|
if (exId > 0 && fldPath.size() >= 4) // we got an exercise Id and we are in a phase sub-folder
|
|
phId = m_dtc->getExerciseId(fldPath.at(3));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
data.fileCategory(FileManagement::FileCategory::Global); // global
|
|
exId = 0;
|
|
phId = 0;
|
|
}
|
|
|
|
if (exId > 0)
|
|
data.exerciseId(exId);
|
|
if (phId > 0)
|
|
data.phaseId(phId);
|
|
|
|
data.fileType(getFileType(fileInfo.suffix())); // match from file extension to file type
|
|
|
|
// create dialog
|
|
FileContentEditDialog *dialog = new FileContentEditDialog(this);
|
|
QString folderName = m_modelFolder->getFolderName(m_dtc->folder(data.folderId()));
|
|
|
|
// init & show dialog to modify the meta data
|
|
if (!dialog->init(m_session, QModelIndex(), m_isAdminMode, folderName, data, LtsUtils::convert<std::vector<uint8_t>>(fileContent)))
|
|
{
|
|
delete dialog;
|
|
return;
|
|
}
|
|
|
|
dialog->setAttribute(Qt::WA_DeleteOnClose);
|
|
|
|
QObject::connect(dialog, &FileContentEditDialog::rejected, dialog, &FileContentEditDialog::deleteLater);
|
|
|
|
dialog->show();
|
|
|
|
/* do not start here Office, only after dialog was accepted
|
|
OfficeIntegration *projWindow = new OfficeIntegration(data, this);
|
|
projWindow->openOfficeWindow();
|
|
*/
|
|
return;
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onNewOfficeWord()
|
|
{
|
|
createNewOfficeFile(QLatin1String("Default.docx"));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onNewOfficeExcel()
|
|
{
|
|
createNewOfficeFile(QLatin1String("Default.xlsx"));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onNewOfficePowerPoint()
|
|
{
|
|
createNewOfficeFile(QLatin1String("Default.pptx"));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onNewLibreOfficeWrite()
|
|
{
|
|
createNewOfficeFile(QLatin1String("Default.odt"));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onNewLibreOfficeCalc()
|
|
{
|
|
createNewOfficeFile(QLatin1String("Default.ods"));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onNewLibreOfficePresent()
|
|
{
|
|
createNewOfficeFile(QLatin1String("Default.odp"));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onNewFileFromTemplate()
|
|
{
|
|
// possible only when a template is selected
|
|
onCopyFile();
|
|
m_copyFile.isTemplate(false);
|
|
m_copyFile.isUsedBy(false);
|
|
m_copyFile.name(tr("<please fill in file name>").toStdString());
|
|
onPasteFile();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onFolderSelectionChanged()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onFolderSelectionChanged";
|
|
enaDisa();
|
|
|
|
reInitModelFile();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::folderContextMenuRequested(const QPoint &position)
|
|
{
|
|
QModelIndex selIndex = selectedIndexViewFolder();
|
|
if (!selIndex.isValid() || LtsSessionData::LtsSessionData::getInstance()->isTablet())
|
|
return;
|
|
enaDisa();
|
|
|
|
QMenu menu(m_ui->tvFolder);
|
|
menu.addAction(m_actionAddFolder);
|
|
menu.addAction(m_actionRenameFolder);
|
|
menu.addAction(m_actionRemoveFolder);
|
|
menu.addSeparator();
|
|
menu.addAction(m_actionCutFolder);
|
|
menu.addAction(m_actionCopyFolder);
|
|
menu.addAction(m_actionPasteFolder);
|
|
menu.addSeparator();
|
|
menu.addAction(m_actionRefreshFolders);
|
|
menu.addSeparator();
|
|
menu.exec(m_ui->tvFolder->viewport()->mapToGlobal(position));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::fileContextMenuRequested(const QPoint &position)
|
|
{
|
|
enaDisa();
|
|
|
|
QMenu menu(m_ui->widgetFiles);
|
|
if (!LtsSessionData::LtsSessionData::getInstance()->isTablet())
|
|
{
|
|
menu.addAction(m_actionImportFile);
|
|
menu.addAction(m_actionEditFile);
|
|
menu.addAction(m_actionDeleteFile);
|
|
menu.addSeparator();
|
|
}
|
|
menu.addAction(m_actionPreviewFile);
|
|
if (!LtsSessionData::LtsSessionData::getInstance()->isTablet())
|
|
{
|
|
menu.addSeparator();
|
|
menu.addAction(m_actionCutFile);
|
|
menu.addAction(m_actionCopyFile);
|
|
menu.addAction(m_actionPasteFile);
|
|
menu.addAction(m_actionExportFile);
|
|
|
|
if (m_dialogMode == FileDialogMode::Admin)
|
|
{
|
|
menu.addSeparator();
|
|
menu.addAction(m_actionRemoveFile);
|
|
menu.addAction(m_actionRestoreFile);
|
|
}
|
|
|
|
menu.addSeparator();
|
|
QMenu *newFileMenu = menu.addMenu(tr("New File"));
|
|
|
|
const bool bUseMSOffice = LtsUtils::ProjectSettings::getInstance()->value(QStringLiteral("Office"), QStringLiteral("Type")).toString() == QStringLiteral("MSOffice");
|
|
if (bUseMSOffice)
|
|
{
|
|
newFileMenu->addAction(m_actionNewOfficeWord);
|
|
newFileMenu->addAction(m_actionNewOfficeExcel);
|
|
newFileMenu->addAction(m_actionNewOfficePowerPoint);
|
|
}
|
|
else
|
|
{
|
|
newFileMenu->addAction(m_actionNewLibreOfficeWrite);
|
|
newFileMenu->addAction(m_actionNewLibreOfficeCalc);
|
|
newFileMenu->addAction(m_actionNewLibreOfficePresent);
|
|
}
|
|
newFileMenu->addAction(m_actionNewFromTemplate);
|
|
}
|
|
menu.exec(m_ui->widgetFiles->mapToGlobal(position));
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onFolderChanged(const FileManagement::Folder &data, DataModification modType)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onFolderChanged: folder name = " << data.name();
|
|
/*
|
|
// old version without re-init model
|
|
if (modType == DataModification::eAdded)
|
|
{
|
|
int row = 0;
|
|
m_modelFolder->onInsertRow(row, selectedIndexViewFolder(), data);
|
|
// so it does not make the update below when updating path
|
|
m_selectedFolderId = 0;
|
|
}
|
|
if (modType == DataModification::eModified && m_selectedFolderId > 0)
|
|
m_modelFolder->onUpdateRow(selectedIndexViewFolder(), data);
|
|
if (modType == DataModification::eRemoved)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Folder removed = " << data.name();
|
|
}
|
|
*/
|
|
Q_UNUSED(data);
|
|
Q_UNUSED(modType);
|
|
|
|
m_modelFolder->initModel(m_session->exerciseId(), m_isAdminMode);
|
|
m_ui->tvFolder->expandAll();
|
|
m_ui->tvFolder->setExpanded(m_proxyModelFolder->index(0, 0), true);
|
|
// select last selected folder
|
|
selectFolder();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
FileManagement::FileType FileManagementDialogWidget::getFileType(const QString &fileExt)
|
|
{
|
|
FileManagement::FileType type = FileManagement::FileType::Unknown;
|
|
auto ext = fileExt.toLower().toStdString();
|
|
if (fileExt.toLower() == QStringLiteral("jpeg")) ext = "jpg";
|
|
std::function<bool(const FileManagement::FileTypeInfo &fti)> cb = [&type, &ext](const FileManagement::FileTypeInfo & fti)
|
|
{
|
|
if (fti.extension() == ext)
|
|
{
|
|
// assuming is 1-1 relationship between type and typeInfo and typeInfo.id is same with type.id
|
|
type = static_cast<FileType::type>(fti.id());
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
m_dtc->fileTypeInfos(cb);
|
|
return type;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onPreviewFile()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onPreviewFile";
|
|
|
|
QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
|
|
if (!selIndex.isValid())
|
|
{
|
|
ERROR_LOG(m_logger) << "No valid selected file for preview!";
|
|
return;
|
|
}
|
|
|
|
FileManagement::FileContent data = m_modelFile->getRowData(m_ui->widgetFiles->currentIndex().row());
|
|
|
|
FileManagement::FileType ft = data.fileType();
|
|
|
|
switch (ft.underlying())
|
|
{
|
|
case FileManagement::FileType::Jpg:
|
|
case FileManagement::FileType::Png:
|
|
case FileManagement::FileType::Text:
|
|
case FileManagement::FileType::Xml:
|
|
case FileManagement::FileType::Pdf:
|
|
case FileManagement::FileType::OperatorFavourite:
|
|
case FileManagement::FileType::TacticalPlan:
|
|
case FileManagement::FileType::EvaluationSchema:
|
|
case FileManagement::FileType::AdlerJson:
|
|
{
|
|
// create dialog
|
|
FileContentPreviewDialog *dialog = new FileContentPreviewDialog(m_session, m_ftc, this);
|
|
if (!dialog->init(data))
|
|
{
|
|
delete dialog;
|
|
return;
|
|
}
|
|
dialog->setAttribute(Qt::WA_DeleteOnClose);
|
|
QObject::connect(dialog, &FileContentPreviewDialog::rejected, dialog, &FolderEditDialog::deleteLater);
|
|
dialog->show();
|
|
break;
|
|
}
|
|
case FileManagement::FileType::MSOfficeDocument:
|
|
case FileManagement::FileType::MSOfficeDocument97:
|
|
case FileManagement::FileType::MSOfficePresentation:
|
|
case FileManagement::FileType::MSOfficePresentation97:
|
|
case FileManagement::FileType::MSOfficeSpreadsheet:
|
|
case FileManagement::FileType::MSOfficeSpreadsheet97:
|
|
case FileManagement::FileType::OpenOfficeDocument:
|
|
case FileManagement::FileType::OpenOfficePresentation:
|
|
case FileManagement::FileType::OpenOfficeSpreadsheet:
|
|
{
|
|
OfficeIntegration *projWindow = new OfficeIntegration(data, this);
|
|
if (!projWindow->openOfficeWindow())
|
|
new LtsWidgets::LtsMessageDialogNew(this, tr("Can not open Office: %1").arg(projWindow->errorString()));
|
|
break;
|
|
}
|
|
case FileManagement::FileType::OperatorDefinedSymbol:
|
|
new LtsWidgets::LtsMessageDialogNew(this, tr("Not yet implemented"));
|
|
break;
|
|
case FileManagement::FileType::Unknown:
|
|
new LtsWidgets::LtsMessageDialogNew(this, tr("Unknown file type! Preview not available."));
|
|
break;
|
|
}
|
|
|
|
}
|
|
QString FileManagementDialogWidget::getFileTypeStr(FileManagement::FileType fileType)
|
|
{
|
|
switch (fileType.underlying())
|
|
{
|
|
case FileManagement::FileType::Png:
|
|
return(QStringLiteral(".png"));
|
|
case FileManagement::FileType::Jpg:
|
|
return(QStringLiteral(".jpg"));
|
|
case FileManagement::FileType::Text:
|
|
return(QStringLiteral(".txt"));
|
|
case FileManagement::FileType::EvaluationSchema:
|
|
case FileManagement::FileType::Xml:
|
|
return(QStringLiteral(".xml"));
|
|
case FileManagement::FileType::TacticalPlan:
|
|
return(QStringLiteral(".TacticalPlan"));
|
|
case FileManagement::FileType::OperatorFavourite:
|
|
return(QStringLiteral(".OperatorFavourite"));
|
|
case FileManagement::FileType::Pdf:
|
|
return(QStringLiteral(".pdf"));
|
|
case FileManagement::FileType::OperatorDefinedSymbol:
|
|
return(QStringLiteral(".OperatorDefinedSymbol"));
|
|
case FileManagement::FileType::MSOfficeDocument:
|
|
return(QStringLiteral(".docx"));
|
|
case FileManagement::FileType::MSOfficeDocument97:
|
|
return(QStringLiteral(".doc"));
|
|
case FileManagement::FileType::MSOfficePresentation:
|
|
return(QStringLiteral(".pptx"));
|
|
case FileManagement::FileType::MSOfficePresentation97:
|
|
return(QStringLiteral(".ppt"));
|
|
case FileManagement::FileType::MSOfficeSpreadsheet:
|
|
return(QStringLiteral(".xlsx"));
|
|
case FileManagement::FileType::MSOfficeSpreadsheet97:
|
|
return(QStringLiteral(".xls"));
|
|
case FileManagement::FileType::OpenOfficeDocument:
|
|
return(QStringLiteral(".odt"));
|
|
case FileManagement::FileType::OpenOfficePresentation:
|
|
return(QStringLiteral(".odp"));
|
|
case FileManagement::FileType::OpenOfficeSpreadsheet:
|
|
return(QStringLiteral(".ods"));
|
|
case FileManagement::FileType::AdlerJson:
|
|
return(QStringLiteral(".ajs"));
|
|
case FileManagement::FileType::Unknown:
|
|
return(QStringLiteral(".Unknown"));
|
|
}
|
|
return(QStringLiteral(".Unknown"));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onExportFile()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onExportFile(): fileName = " << m_fileName;
|
|
|
|
// static so it's saved for next time
|
|
static QString defaultPath = QDir::homePath() + QStringLiteral("/scanner/");
|
|
DEBUG_LOG(m_logger) << "onExportFile(): old path = " << defaultPath;
|
|
|
|
QString folderName = QFileDialog::getExistingDirectory(this,
|
|
tr("Save file from library to local Workstation"),
|
|
defaultPath,
|
|
QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
|
|
DEBUG_LOG(m_logger) << "onExportFile(): folderName = " << folderName;
|
|
if (folderName.isEmpty())
|
|
{
|
|
DEBUG_LOG(m_logger) << "onExportFile(): folderName.isEmpty()";
|
|
return;
|
|
}
|
|
|
|
m_getContent->getContent(m_selectedFileContent.id(), m_content);
|
|
DEBUG_LOG(m_logger) << "onExportFile(): Save File to '" << folderName << "/" << m_fileName << "'"
|
|
<< " fileType = " << m_selectedFileContent.fileType()
|
|
<< " getFileTypeStr = " << getFileTypeStr(m_selectedFileContent.fileType())
|
|
<< " exportFileName = " << m_selectedFileContent.exportFileName()
|
|
<< " m_content.size = " << m_content.size();
|
|
|
|
QString completeFileName = m_fileName;
|
|
completeFileName.append(getFileTypeStr(m_selectedFileContent.fileType()));
|
|
|
|
QFile file;
|
|
QDir::setCurrent(folderName);
|
|
file.setFileName(completeFileName);
|
|
|
|
if (file.exists())
|
|
{
|
|
DEBUG_LOG(m_logger) << "onExportFile(): File already exists (" << completeFileName << ") in folder " << folderName;
|
|
if (LtsWidgets::LtsMessageDialog::showMessage(this, tr("Yes - overwrite file.<br>"
|
|
"No - do not overwrite file.<br>"),
|
|
tr("Do you want to overwrite the existing file?"),
|
|
LtsWidgets::Behaviour::Modal,
|
|
LtsWidgets::Button::Yes | LtsWidgets::Button::No) != LtsWidgets::Button::Yes)
|
|
{
|
|
DEBUG_LOG(m_logger) << "onExportFile(): File exists, will not be overwritten (" << completeFileName << ") in folder " << folderName;
|
|
return;
|
|
}
|
|
}
|
|
|
|
file.open(QIODevice::WriteOnly);
|
|
file.write(LtsUtils::toQByteArray(m_content));
|
|
file.close();
|
|
|
|
DEBUG_LOG(m_logger) << "onExportFile(): Exported file " << completeFileName << " in folder " << folderName;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onSelectFile()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onSelectFile";
|
|
|
|
QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
|
|
|
|
if (!selIndex.isValid())
|
|
return;
|
|
|
|
m_selectedFileContent = m_modelFile->getRowData(selIndex.row());
|
|
|
|
DEBUG_LOG(m_logger) << "Selected file content id = " << m_selectedFileContent.id();
|
|
emit accepted();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onChooseFileName()
|
|
{
|
|
DEBUG_LOG(m_logger) << "onChooseFileName";
|
|
|
|
if ((FileDialogMode::SaveFile == m_dialogMode) && (!m_fileName.isEmpty()))
|
|
{
|
|
DEBUG_LOG(m_logger) << "Choosen file name = " << m_fileName;
|
|
emit accepted();
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::onFileChanged(const FileManagement::FileContent &data, DataModification modType)
|
|
{
|
|
bool condition = showFile(data, m_xmlType);
|
|
DEBUG_LOG(m_logger) << "onFileChanged file name = " << data.name() << ", condition = " << condition << ", modType = " << modType;
|
|
|
|
bool reInit = false;
|
|
int row = 0;
|
|
|
|
QModelIndex selIndex = m_ui->widgetFiles->currentIndex();
|
|
if (selIndex.isValid())
|
|
row = selIndex.row();
|
|
|
|
switch (modType)
|
|
{
|
|
case DataModification::eRemoved:
|
|
m_modelFile->removeRow(row);
|
|
reInit = true;
|
|
break;
|
|
case DataModification::eAdded:
|
|
if (condition)
|
|
m_modelFile->insertRow(data);
|
|
else
|
|
reInit = true;
|
|
break;
|
|
case DataModification::eModified:
|
|
if (condition)
|
|
{
|
|
// modified the selected file
|
|
if (data.id() == m_modelFile->getRowData(row).id())
|
|
m_modelFile->setRowData(row, data);
|
|
else
|
|
reInit = true;
|
|
}
|
|
else
|
|
reInit = true;
|
|
break;
|
|
}
|
|
if (reInit)
|
|
reInitModelFile(true);
|
|
enaDisa();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
bool FileManagementDialogWidget::showFile(const FileManagement::FileContent &fc, const QString &xmlType)
|
|
{
|
|
if (fc.isDeleted())
|
|
{
|
|
DEBUG_LOG(m_logger) << "is deleted: " << fc.name().c_str();
|
|
return false;
|
|
}
|
|
|
|
if (fc.folderId() != m_selectedFolderId)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Folder id does not match: " << fc.name().c_str();
|
|
return false;
|
|
}
|
|
|
|
if (!m_fileTypes.isEmpty() && !m_fileTypes.contains(fc.fileType()))
|
|
{
|
|
DEBUG_LOG(m_logger) << "file type does not match: " << fc.name().c_str();
|
|
return false;
|
|
}
|
|
|
|
if (m_dialogMode != FileDialogMode::Admin)
|
|
{
|
|
if (fc.fileStatus() != FileManagement::FileStatus::Valid)
|
|
{
|
|
DEBUG_LOG(m_logger) << "file status is not valid: " << fc.name().c_str();
|
|
return false;
|
|
}
|
|
|
|
// get folder selected
|
|
const QModelIndex selIndex = selectedIndexViewFolder();
|
|
const NGLTreeItem *item = m_modelFolder->privateData(selIndex);
|
|
const FileManagement::Folder fld = item->data().value<FileManagement::Folder>();
|
|
const QVector<int> fldPath = LtsUtils::convert<QVector<int>>(fld.path());
|
|
|
|
// filter in USER DOCUMENTS folder and subfolders
|
|
if (fldPath.contains(FileManagement::MainFolder::UserDocuments))
|
|
{
|
|
const int operatorId = LtsSessionData::LtsSessionData::getInstance()->getOperatorId();
|
|
// filter on OperatorId
|
|
DEBUG_LOG(m_logger) << "Filtering files on OperatorId = " << operatorId;
|
|
if (fc.operatorId() != operatorId)
|
|
{
|
|
DEBUG_LOG(m_logger) << "operator id does not match: " << fc.name().c_str();
|
|
return false;
|
|
}
|
|
DEBUG_LOG(m_logger) << "Filtering files on User Category";
|
|
if (fc.fileCategory() != FileManagement::FileCategory::User)
|
|
{
|
|
DEBUG_LOG(m_logger) << "User category does not match: " << fc.name().c_str();
|
|
// filter on User Category not needed anymore, to be able to load also Exercise files saved via "Save to Library" under "User Documents" folder
|
|
// return false;
|
|
}
|
|
// additionally, in Exercise Library filter on exercise Id, if given
|
|
if (m_session->exerciseId() > 0)
|
|
{
|
|
if (fc.exerciseId().is_set() && fc.exerciseId().get() != m_session->exerciseId())
|
|
{
|
|
DEBUG_LOG(m_logger) << "exercise does not match: " << fc.name().c_str() << " is: " << fc.exerciseId()
|
|
<< " should be " << m_session->exerciseId();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// filter in EXERCISE DOCUMENTS folder and subfolders
|
|
if (fldPath.contains(FileManagement::MainFolder::ExerciseDocuments))
|
|
{
|
|
// filter on Category = Exercise
|
|
DEBUG_LOG(m_logger) << "Filtering files on Exercise Category";
|
|
if (fc.fileCategory() != FileManagement::FileCategory::Exercise)
|
|
{
|
|
DEBUG_LOG(m_logger) << "exercise category does not match: " << fc.name().c_str();
|
|
return false;
|
|
}
|
|
if (m_session->exerciseId() > 0)
|
|
{
|
|
// filter on exact exerciseId
|
|
DEBUG_LOG(m_logger) << "Filtering files on Exercise Category and exerciseId = " << m_session->exerciseId();
|
|
if (fc.exerciseId().is_set() && fc.exerciseId().get() != m_session->exerciseId())
|
|
{
|
|
DEBUG_LOG(m_logger) << "exercise does not match: " << fc.name().c_str() << " is: " << fc.exerciseId()
|
|
<< " should be " << m_session->exerciseId();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// filter on XmlType
|
|
if (fc.fileType() == FileType::Xml && !xmlType.isEmpty() && fc.properties().size() > 0)
|
|
{
|
|
const QString &prop = QString::fromStdString(fc.properties());
|
|
if (!prop.contains(xmlType, Qt::CaseSensitive))
|
|
{
|
|
DEBUG_LOG(m_logger) << "XmlType not found " << xmlType;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogWidget::selectFolder()
|
|
{
|
|
QModelIndex idx;
|
|
QItemSelectionModel *selectionModelFolder = m_ui->tvFolder->selectionModel();
|
|
if (m_selectedFolderId > 0)
|
|
idx = m_proxyModelFolder->mapFromSource(m_modelFolder->getIndex(m_selectedFolderId));
|
|
if (idx.isValid())
|
|
selectionModelFolder->setCurrentIndex(idx, QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
|
|
else
|
|
selectionModelFolder->setCurrentIndex(m_modelFolder->index(0, 0), QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
// mapping buttons folders (left side):
|
|
// Print | Import | Export |
|
|
//----------------------------------------
|
|
// AddFolder | EditFolder | RemoveFolder |
|
|
|
|
// mapping buttons files (right side):
|
|
// Load | Save | Add | Edit | Show | Remove | Hide |
|
|
// --------------------------------------------------------------------------------------
|
|
// RestoreFile| ExportFile | ImportFile | Properties| Preview | RemoveFile | DeleteFile |
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
FileManagementDialogTab::FileManagementDialogTab(const QString &menuGroup, QWidget *parent)
|
|
: LtsWidgets::LtsDialog(parent, LtsWidgets::ButtonCombination::CloseOnly)
|
|
, m_editItemWidget(new FileManagementDialogWidget(this))
|
|
, m_logger(getLogger("FileManagementDialog"))
|
|
{
|
|
|
|
if (menuGroup == tr("Document Library"))
|
|
// Admin-Document Library->Manage Library
|
|
setOnlineHelpFilename(QStringLiteral("Administrator-Library_Management"));
|
|
if (menuGroup == tr("Exercise Documents"))
|
|
// Situation.Extras->Excercise Documents->Organise Library
|
|
setOnlineHelpFilename(QStringLiteral("Situation-Library_Organisation"));
|
|
DEBUG_LOG(m_logger) << "Ctor FileManagementDialogTab";
|
|
|
|
LtsWidgets::DialogButton btnAddFolder = LtsWidgets::DialogButton::Print;
|
|
LtsWidgets::DialogButton btnEditFolder = LtsWidgets::DialogButton::Import;
|
|
LtsWidgets::DialogButton btnRemoveFolder = LtsWidgets::DialogButton::Export;
|
|
|
|
LtsWidgets::DialogButton btnExportFile = LtsWidgets::DialogButton::Save;
|
|
LtsWidgets::DialogButton btnImportFile = LtsWidgets::DialogButton::Add;
|
|
LtsWidgets::DialogButton btnEditFile = LtsWidgets::DialogButton::Edit;
|
|
LtsWidgets::DialogButton btnPreviewFile = LtsWidgets::DialogButton::Show;
|
|
LtsWidgets::DialogButton btnRemoveFile = LtsWidgets::DialogButton::Remove;
|
|
LtsWidgets::DialogButton btnDeleteFile = LtsWidgets::DialogButton::Hide;
|
|
LtsWidgets::DialogButton btnRestoreFile = LtsWidgets::DialogButton::Load;
|
|
|
|
if (!LtsSessionData::LtsSessionData::getInstance()->isTablet())
|
|
{
|
|
m_buttonBox->connectButton(btnAddFolder, m_editItemWidget, &FileManagementDialogWidget::onAddFolder);
|
|
m_buttonBox->setText(btnAddFolder, tr("Add Folder"));
|
|
m_buttonBox->setToolTip(btnAddFolder, tr("Add new folder to library"));
|
|
m_buttonBox->setButtonEnabled(btnAddFolder, false);
|
|
m_buttonBox->setButtonVisible(btnAddFolder, true);
|
|
|
|
m_buttonBox->connectButton(btnEditFolder, m_editItemWidget, &FileManagementDialogWidget::onEditFolder);
|
|
m_buttonBox->setText(btnEditFolder, tr("Rename Folder"));
|
|
m_buttonBox->setToolTip(btnEditFolder, tr("Rename folder"));
|
|
m_buttonBox->setButtonEnabled(btnEditFolder, false);
|
|
m_buttonBox->setButtonVisible(btnEditFolder, true);
|
|
|
|
m_buttonBox->connectButton(btnRemoveFolder, m_editItemWidget, &FileManagementDialogWidget::onRemoveFolder);
|
|
m_buttonBox->setText(btnRemoveFolder, tr("Remove Folder"));
|
|
m_buttonBox->setToolTip(btnRemoveFolder, tr("Remove folder from library"));
|
|
m_buttonBox->setButtonEnabled(btnRemoveFolder, false);
|
|
m_buttonBox->setButtonVisible(btnRemoveFolder, true);
|
|
|
|
m_buttonBox->connectButton(btnExportFile, m_editItemWidget, &FileManagementDialogWidget::onExportFile);
|
|
m_buttonBox->setText(btnExportFile, tr("Export File"));
|
|
m_buttonBox->setToolTip(btnExportFile, tr("Export file to file system"));
|
|
m_buttonBox->setButtonEnabled(btnExportFile, false);
|
|
m_buttonBox->setButtonVisible(btnExportFile, true);
|
|
|
|
m_buttonBox->connectButton(btnImportFile, m_editItemWidget, &FileManagementDialogWidget::onImportFile);
|
|
m_buttonBox->setText(btnImportFile, tr("Import File"));
|
|
m_buttonBox->setToolTip(btnImportFile, tr("Import file to library"));
|
|
m_buttonBox->setButtonEnabled(btnImportFile, true);
|
|
m_buttonBox->setButtonVisible(btnImportFile, true);
|
|
|
|
m_buttonBox->connectButton(btnEditFile, m_editItemWidget, &FileManagementDialogWidget::onEditFile);
|
|
m_buttonBox->setText(btnEditFile, tr("Properties"));
|
|
m_buttonBox->setToolTip(btnEditFile, tr("Edit file properties"));
|
|
m_buttonBox->setButtonEnabled(btnEditFile, false);
|
|
m_buttonBox->setButtonVisible(btnEditFile, true);
|
|
|
|
|
|
m_buttonBox->connectButton(btnRemoveFile, m_editItemWidget, &FileManagementDialogWidget::onRemoveFile);
|
|
|
|
m_buttonBox->setText(btnRemoveFile, tr("Remove File"));
|
|
m_buttonBox->setToolTip(btnRemoveFile, tr("Remove file from library"));
|
|
m_buttonBox->setButtonEnabled(btnRemoveFile, false);
|
|
m_buttonBox->setButtonVisible(btnRemoveFile, true);
|
|
|
|
m_buttonBox->connectButton(btnDeleteFile, m_editItemWidget, &FileManagementDialogWidget::onDeleteFile);
|
|
m_buttonBox->setText(btnDeleteFile, tr("Delete File"));
|
|
m_buttonBox->setToolTip(btnDeleteFile, tr("Delete file from library"));
|
|
m_buttonBox->setButtonEnabled(btnDeleteFile, false);
|
|
m_buttonBox->setButtonVisible(btnDeleteFile, true);
|
|
|
|
m_buttonBox->connectButton(btnRestoreFile, m_editItemWidget, &FileManagementDialogWidget::onRestoreFile);
|
|
m_buttonBox->setText(btnRestoreFile, tr("Restore File"));
|
|
m_buttonBox->setToolTip(btnRestoreFile, tr("Restore file to library"));
|
|
m_buttonBox->setButtonEnabled(btnRestoreFile, false);
|
|
m_buttonBox->setButtonVisible(btnRestoreFile, true);
|
|
}
|
|
m_buttonBox->connectButton(btnPreviewFile, m_editItemWidget, &FileManagementDialogWidget::onPreviewFile);
|
|
m_buttonBox->setText(btnPreviewFile, tr("Preview File"));
|
|
m_buttonBox->setToolTip(btnPreviewFile, tr("Preview / Edit file"));
|
|
m_buttonBox->setButtonEnabled(btnPreviewFile, false);
|
|
m_buttonBox->setButtonVisible(btnPreviewFile, true);
|
|
|
|
m_editItemWidget->m_ui->lblFolder->setText(tr("Selected Folder:"));
|
|
m_editItemWidget->m_ui->lblFile->setText(tr("Selected File:"));
|
|
|
|
connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, m_editItemWidget, &FileManagementDialogWidget::onReject);
|
|
connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, this, &FileManagementDialogTab::close);
|
|
|
|
//hide ok and apply
|
|
m_buttonBox->getButton(LtsWidgets::DialogButton::Apply)->hide();
|
|
m_buttonBox->getButton(LtsWidgets::DialogButton::Ok)->hide();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
FileManagementDialog::FileManagementDialog(QWidget *parent)
|
|
: LtsWidgets::LtsFramelessDialog(parent, LtsWidgets::Behaviour::Modal)
|
|
, m_editItemWidget(new FileManagementDialogWidget(this))
|
|
, m_buttonBox(new LtsWidgets::LtsDialogButtonBox(this))
|
|
, m_dialogMode(FileDialogMode::OpenFile)
|
|
, m_logger(getLogger("FileManagementDialog"))
|
|
{
|
|
DEBUG_LOG(m_logger) << "Ctor FileManagementDialog";
|
|
|
|
LtsWidgets::DialogButton btnAddFolder = LtsWidgets::DialogButton::Print;
|
|
LtsWidgets::DialogButton btnSelectFile = LtsWidgets::DialogButton::Load;
|
|
|
|
m_buttonBox->connectButton(btnAddFolder, m_editItemWidget, &FileManagementDialogWidget::onAddFolder);
|
|
m_buttonBox->setText(btnAddFolder, tr("Add Folder"));
|
|
m_buttonBox->setToolTip(btnAddFolder, tr("Add new folder to library"));
|
|
m_buttonBox->setButtonEnabled(btnAddFolder, false);
|
|
m_buttonBox->setButtonVisible(btnAddFolder, true);
|
|
|
|
m_buttonBox->setText(btnSelectFile, tr("Select File"));
|
|
m_buttonBox->setToolTip(btnSelectFile, tr("Select file from library"));
|
|
m_buttonBox->setButtonEnabled(btnSelectFile, false);
|
|
m_buttonBox->setButtonVisible(btnSelectFile, true);
|
|
|
|
connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, m_editItemWidget, &FileManagementDialogWidget::onReject);
|
|
connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, this, &FileManagementDialog::close);
|
|
|
|
//hide ok and apply
|
|
m_buttonBox->getButton(LtsWidgets::DialogButton::Apply)->hide();
|
|
m_buttonBox->getButton(LtsWidgets::DialogButton::Ok)->hide();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
bool FileManagementDialogTab::init(LtsSession::LtsSession *session,
|
|
FileDialogMode dlgMode,
|
|
const QVector<FileType> &fileTypes,
|
|
const int &folderId,
|
|
const QString &buttonName)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Start init FileManagementDialogTab";
|
|
|
|
if (!m_editItemWidget->init(session, dlgMode, fileTypes, folderId))
|
|
{
|
|
ERROR_LOG(m_logger) << "Init FileManagementDialogTab failed!";
|
|
return false;
|
|
}
|
|
|
|
m_dialogMode = dlgMode;
|
|
|
|
QVBoxLayout *layout = new QVBoxLayout(this);
|
|
layout->addWidget(m_editItemWidget);
|
|
layout->setMargin(0);
|
|
|
|
if (!buttonName.isEmpty())
|
|
{
|
|
m_buttonBox->setText(LtsWidgets::DialogButton::Load, buttonName);
|
|
m_buttonBox->setToolTip(LtsWidgets::DialogButton::Load, buttonName);
|
|
}
|
|
else if (m_dialogMode == FileDialogMode::SaveFile)
|
|
{
|
|
m_buttonBox->setText(LtsWidgets::DialogButton::Load, tr("Save"));
|
|
m_buttonBox->setToolTip(LtsWidgets::DialogButton::Load, tr("Save"));
|
|
}
|
|
|
|
if (m_dialogMode != FileDialogMode::Admin)
|
|
{
|
|
m_buttonBox->setButtonVisible(LtsWidgets::DialogButton::Remove, false); // remove file
|
|
//m_buttonBox->setButtonVisible(LtsWidgets::DialogButton::Save, false); // export file
|
|
m_buttonBox->setButtonVisible(LtsWidgets::DialogButton::Load, false); // restore file
|
|
}
|
|
|
|
connect(m_editItemWidget, &FileManagementDialogWidget::enableButtons, this, &FileManagementDialogTab::enaDisa);
|
|
connect(m_editItemWidget, &FileManagementDialogWidget::accepted, this, &FileManagementDialogTab::accepted);
|
|
|
|
m_editItemWidget->m_ui->leFile->setVisible(false);
|
|
m_editItemWidget->m_ui->lblFile->setVisible(false);
|
|
m_editItemWidget->m_ui->lblFilter->setVisible(false);
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
bool FileManagementDialog::init(LtsSession::LtsSession *session,
|
|
FileDialogMode dlgMode,
|
|
const QVector<FileType> &fileTypes,
|
|
int folderId,
|
|
const QString &xmlType)
|
|
{
|
|
DEBUG_LOG(m_logger) << "Start init FileManagementDialog";
|
|
DEBUG_LOG(m_logger) << "Initial folder to select: " << folderId;
|
|
|
|
if (!m_editItemWidget->init(session, dlgMode, fileTypes, folderId, xmlType))
|
|
{
|
|
ERROR_LOG(m_logger) << "Init FileManagementDialogWidget failed!";
|
|
return false;
|
|
}
|
|
|
|
m_dialogMode = dlgMode;
|
|
|
|
QVBoxLayout *layout = new QVBoxLayout(this);
|
|
layout->addWidget(m_editItemWidget);
|
|
layout->addWidget(m_buttonBox);
|
|
|
|
if (m_dialogMode == FileDialogMode::SaveFile)
|
|
{
|
|
m_buttonBox->setText(LtsWidgets::DialogButton::Load, tr("Save"));
|
|
m_buttonBox->setToolTip(LtsWidgets::DialogButton::Load, tr("Save"));
|
|
m_buttonBox->connectButton(LtsWidgets::DialogButton::Load, m_editItemWidget, &FileManagementDialogWidget::onChooseFileName);
|
|
}
|
|
else if (m_dialogMode == FileDialogMode::OpenFile)
|
|
m_buttonBox->connectButton(LtsWidgets::DialogButton::Load, m_editItemWidget, &FileManagementDialogWidget::onSelectFile);
|
|
|
|
connect(m_editItemWidget, &FileManagementDialogWidget::enableButtons, this, &FileManagementDialog::enaDisa);
|
|
|
|
connect(m_buttonBox->getButton(LtsWidgets::DialogButton::Close), &QPushButton::clicked, this, &FileManagementDialog::reject);
|
|
connect(m_editItemWidget, &FileManagementDialogWidget::accepted, this, &FileManagementDialog::accept);
|
|
|
|
enaDisa();
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialog::accept()
|
|
{
|
|
emit fileSelected(getSelectedFileId(), getSelectedFolderId(), getFileName());
|
|
LtsWidgets::LtsFramelessDialog::accept();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialog::enaDisa()
|
|
{
|
|
DEBUG_LOG(m_logger) << "FileManagementDialog::enaDisa()";
|
|
|
|
LtsWidgets::DialogButton btnAddFolder = LtsWidgets::DialogButton::Print;
|
|
m_buttonBox->setButtonEnabled(btnAddFolder, false);
|
|
|
|
QModelIndex idxFolder = m_editItemWidget->m_ui->tvFolder->currentIndex();
|
|
if (m_dialogMode == FileDialogMode::SaveFile && idxFolder.isValid())
|
|
m_buttonBox->setButtonEnabled(btnAddFolder, true);
|
|
|
|
LtsWidgets::DialogButton btnSelectFile = LtsWidgets::DialogButton::Load;
|
|
m_buttonBox->setButtonEnabled(btnSelectFile, false);
|
|
|
|
QModelIndex idxFile = m_editItemWidget->m_ui->widgetFiles->currentIndex();
|
|
if (m_dialogMode == FileDialogMode::OpenFile && idxFile.isValid())
|
|
m_buttonBox->setButtonEnabled(btnSelectFile, true);
|
|
|
|
DEBUG_LOG(m_logger) << "DialogMode: " << (int)m_dialogMode;
|
|
DEBUG_LOG(m_logger) << "FileName: " << m_editItemWidget->m_fileName;
|
|
|
|
if (m_dialogMode == FileDialogMode::SaveFile && !m_editItemWidget->m_fileName.isEmpty())
|
|
m_buttonBox->setButtonEnabled(btnSelectFile, true);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------------------------------------
|
|
void FileManagementDialogTab::enaDisa()
|
|
{
|
|
DEBUG_LOG(m_logger) << "FileManagementDialogTab::enaDisa()";
|
|
|
|
LtsWidgets::DialogButton btnAddFolder = LtsWidgets::DialogButton::Print;
|
|
LtsWidgets::DialogButton btnEditFolder = LtsWidgets::DialogButton::Import;
|
|
LtsWidgets::DialogButton btnRemoveFolder = LtsWidgets::DialogButton::Export;
|
|
|
|
LtsWidgets::DialogButton btnExportFile = LtsWidgets::DialogButton::Save;
|
|
LtsWidgets::DialogButton btnImportFile = LtsWidgets::DialogButton::Add;
|
|
LtsWidgets::DialogButton btnEditFile = LtsWidgets::DialogButton::Edit;
|
|
LtsWidgets::DialogButton btnPreviewFile = LtsWidgets::DialogButton::Show;
|
|
LtsWidgets::DialogButton btnRemoveFile = LtsWidgets::DialogButton::Remove;
|
|
LtsWidgets::DialogButton btnDeleteFile = LtsWidgets::DialogButton::Hide;
|
|
LtsWidgets::DialogButton btnRestoreFile = LtsWidgets::DialogButton::Load;
|
|
|
|
m_buttonBox->setButtonEnabled(btnAddFolder, m_editItemWidget->m_actionAddFolder->isEnabled());
|
|
m_buttonBox->setButtonEnabled(btnEditFolder, m_editItemWidget->m_actionRenameFolder->isEnabled());
|
|
m_buttonBox->setButtonEnabled(btnRemoveFolder, m_editItemWidget->m_actionRemoveFolder->isEnabled());
|
|
|
|
if (m_editItemWidget->m_actionPreviewFile->data().toBool()) // isOffice
|
|
{
|
|
m_buttonBox->setText(btnPreviewFile, tr("Edit File"));
|
|
m_editItemWidget->m_actionPreviewFile->setText(tr("Edit File"));
|
|
}
|
|
else
|
|
{
|
|
m_buttonBox->setText(btnPreviewFile, tr("Preview File"));
|
|
m_editItemWidget->m_actionPreviewFile->setText(tr("Preview File"));
|
|
}
|
|
|
|
m_buttonBox->setButtonEnabled(btnExportFile, m_editItemWidget->m_actionExportFile->isEnabled());
|
|
m_buttonBox->setButtonEnabled(btnImportFile, m_editItemWidget->m_actionImportFile->isEnabled());
|
|
m_buttonBox->setButtonEnabled(btnEditFile, m_editItemWidget->m_actionEditFile->isEnabled());
|
|
m_buttonBox->setButtonEnabled(btnPreviewFile, m_editItemWidget->m_actionPreviewFile->isEnabled());
|
|
m_buttonBox->setButtonEnabled(btnRemoveFile, m_editItemWidget->m_actionRemoveFile->isEnabled());
|
|
m_buttonBox->setButtonEnabled(btnDeleteFile, m_editItemWidget->m_actionDeleteFile->isEnabled());
|
|
m_buttonBox->setButtonEnabled(btnRestoreFile, m_editItemWidget->m_actionRestoreFile->isEnabled());
|
|
}
|
|
|
|
} // namespace FileManagement
|