CreateDatabaseWidget.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS dbe source for the DUNE DAQ project.
// Fork baseline commit: dbe-02-12-17 (2022-05-12).
// Renamed since fork: no.

#include <QFileDialog>
#include <QMessageBox>
#include "dbe/CreateDatabaseWidget.hpp"
#include "dbe/StyleUtility.hpp"
#include "conffwk/ConfigObject.hpp"
#include "conffwk/Configuration.hpp"
#include "conffwk/Schema.hpp"
#include "dbe/Exceptions.hpp"
#include "dbe/FileInfo.hpp"
#include "dbe/messenger.hpp"
 
using namespace dunedaq::conffwk;
 
dbe::CreateDatabaseWidget::CreateDatabaseWidget(QWidget* parent, bool Include, const QString& CreateDir)
  : QWidget(parent)
  , DirToCreate(CreateDir)
  , CreateToInclude(Include)
{
  setupUi(this);
 
  connect(SchemaButton, SIGNAL(clicked()), this, SLOT(DefineSchema()), Qt::UniqueConnection);
  connect(SelectButton, SIGNAL(clicked()), this, SLOT(DefineDatabaseFile()), Qt::UniqueConnection);
 
  if (!CreateToInclude) {
    connect(CreateDatabaseButton, SIGNAL(clicked()), this, SLOT(CreateDatabaseFileLoad()), Qt::UniqueConnection);
    connect(
      CreateNoLoadDatabaseButton, SIGNAL(clicked()), this, SLOT(CreateDatabaseFileNoLoad()), Qt::UniqueConnection);
  } else {
    connect(CreateDatabaseButton, SIGNAL(clicked()), this, SLOT(CreateDatabaseFileInclude()), Qt::UniqueConnection);
    CreateDatabaseButton->setText("Create Database File");
    CreateNoLoadDatabaseButton->hide();
  }
 
  m_instructions->setText("Select schema files and define new database file. Database must contain at least one schema "
                          "file, other includes may be added later via a File info window.");
  CreateDatabaseButton->setDisabled(true);
  CreateNoLoadDatabaseButton->setDisabled(true);
 
  DatabaseName->setReadOnly(true);
}
 
void
dbe::CreateDatabaseWidget::DefineSchema()
{
  auto fd =
    new QFileDialog(this, tr("Select Schema File"), FileInfo::get_schema_path(), tr("XML schema files (*.schema.xml)"));
  fd->setFileMode(QFileDialog::ExistingFile);
  fd->setViewMode(QFileDialog::Detail);
  fd->setAcceptMode(QFileDialog::AcceptOpen);
  fd->setSidebarUrls(FileInfo::get_path_urls());
  if (!(fd->exec() == QDialog::Accepted)) {
    return;
  }
  FileInfo::set_schema_path(fd->directory().path());
 
  auto files = fd->selectedFiles();
  for (auto file : files) {
    QFileInfo SchemaFile = QFileInfo(file);
    if (!SchemaFile.isFile()) {
      m_instructions->setPalette(StyleUtility::AlertStatusBarPallete);
      m_instructions->setText(QString("The file is not accessible. Check before usage"));
    } else {
      if (SchemaFile.fileName().contains("schema")) {
        schema_list->addItem(FileInfo::prune_path(file));
      } else {
        m_instructions->setPalette(StyleUtility::AlertStatusBarPallete);
        m_instructions->setText(QString("The file %1 is not a schema file").arg(SchemaFile.absoluteFilePath()));
      }
    }
  }
 
  if (schema_list->count() > 0 && !DatabaseName->text().isEmpty()) {
    CreateDatabaseButton->setEnabled(true);
    CreateNoLoadDatabaseButton->setEnabled(true);
  }
}
 
void
dbe::CreateDatabaseWidget::DefineDatabaseFile()
{
  QString Dir;
 
  QString path = FileInfo::get_data_path().append("/NewDatabaseFile.data.xml");
 
  auto fd = new QFileDialog(this, tr("Select new DB File"), path, tr("XML data files (*.data.xml)"));
  fd->setFileMode(QFileDialog::AnyFile);
  fd->setViewMode(QFileDialog::Detail);
  fd->setAcceptMode(QFileDialog::AcceptSave);
  fd->setSidebarUrls(FileInfo::get_path_urls());
  if (!(fd->exec() == QDialog::Accepted)) {
    return;
  }
  FileInfo::set_data_path(fd->directory().path());
  auto files = fd->selectedFiles();
 
  DatabaseFile = QFileInfo(files.at(0));
 
  DatabaseName->setText(DatabaseFile.absoluteFilePath());
 
  if (schema_list->count() > 0) {
    CreateDatabaseButton->setEnabled(true);
    CreateNoLoadDatabaseButton->setEnabled(true);
  }
}
 
std::list<std::string>
dbe::CreateDatabaseWidget::get_includes()
{
  std::list<std::string> includes;
 
  for (int row = 0; row < schema_list->count(); ++row) {
    auto item = schema_list->item(row)->text();
    includes.push_back(item.toStdString());
  }
  return includes;
}
 
bool
dbe::CreateDatabaseWidget::create_database_file(std::string extra_text)
{
  Configuration db("oksconflibs");
  try {
    const std::string DatabaseName = DatabaseFile.absoluteFilePath().toStdString();
    db.create(DatabaseName, get_includes());
    db.commit();
  } catch (dunedaq::conffwk::Exception const& ex) {
    FAIL("Database creation failure", dbe::config::errors::parse(ex).c_str());
    return false;
  }
 
  QMessageBox::information(
    0, tr("DBE"), QString::fromStdString("The Database was created.\n" + extra_text), QMessageBox::Ok);
  return true;
}
void
dbe::CreateDatabaseWidget::CreateDatabaseFileLoad()
{
  if (create_database_file("Now the DB will be loaded into the Editor!\n")) {
    emit CanLoadDatabase(DatabaseFile.absoluteFilePath());
    close();
  }
}
 
void
dbe::CreateDatabaseWidget::CreateDatabaseFileNoLoad()
{
  if (create_database_file("")) {
    close();
  }
}
 
void
dbe::CreateDatabaseWidget::CreateDatabaseFileInclude()
{
  if (create_database_file("")) {
    emit CanIncludeDatabase(DatabaseFile.absoluteFilePath());
    close();
  }
}