SchemaRelationshipEditor.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: yes (from src/SchemaEditor/SchemaRelationshipEditor.cpp to
// apps/SchemaEditor/SchemaRelationshipEditor.cpp).
 
#include <QMessageBox>
#include "dbe/SchemaKernelWrapper.hpp"
#include "dbe/SchemaRelationshipEditor.hpp"
#include "ui_SchemaRelationshipEditor.h"
 
using namespace dunedaq::oks;
 
dbse::SchemaRelationshipEditor::~SchemaRelationshipEditor() = default;
 
dbse::SchemaRelationshipEditor::SchemaRelationshipEditor(OksClass* Class,
                                                         OksRelationship* Relationship,
                                                         QWidget* parent)
  : QWidget(parent)
  , ui(new Ui::SchemaRelationshipEditor)
  , SchemaRelationship(Relationship)
  , SchemaClass(Class)
  , UsedNew(false)
  , GraphScene(false)
{
  QWidget::setAttribute(Qt::WA_DeleteOnClose);
 
  m_writable = KernelWrapper::GetInstance().IsFileWritable(Class->get_file()->get_full_file_name());
 
  ui->setupUi(this);
  auto title = SchemaClass->get_name() + "::" + SchemaRelationship->get_name();
  setWindowTitle(QString("Relationship Editor : %1").arg(title.c_str()));
  InitialSettings();
  SetController();
}
 
dbse::SchemaRelationshipEditor::SchemaRelationshipEditor(OksClass* Class, QWidget* parent)
  : QWidget(parent)
  , ui(new Ui::SchemaRelationshipEditor)
  , SchemaRelationship(nullptr)
  , SchemaClass(Class)
  , UsedNew(true)
  , GraphScene(false)
{
  QWidget::setAttribute(Qt::WA_DeleteOnClose);
  ui->setupUi(this);
  m_writable = true;
  setWindowTitle(QString("Relationship Editor : %1  New Relationship").arg(SchemaClass->get_name().c_str()));
  InitialSettings();
  SetController();
}
 
dbse::SchemaRelationshipEditor::SchemaRelationshipEditor(OksClass* Class, QString ClassType, QWidget* parent)
  : QWidget(parent)
  , ui(new Ui::SchemaRelationshipEditor)
  , SchemaRelationship(nullptr)
  , SchemaClass(Class)
  , UsedNew(true)
  , GraphScene(true)
{
  QWidget::setAttribute(Qt::WA_DeleteOnClose);
  m_writable = true;
  ui->setupUi(this);
  setWindowTitle(QString("Relationship Editor : %1  New Relationship").arg(SchemaClass->get_name().c_str()));
  InitialSettings();
  SetController();
  ui->RelationshipTypeComboBox->setCurrentIndex(ui->RelationshipTypeComboBox->findData(ClassType, Qt::DisplayRole));
}
void
dbse::SchemaRelationshipEditor::ClassUpdated(QString ClassName)
{
  if (!UsedNew && ClassName.toStdString() == SchemaClass->get_name()) {
    if (SchemaClass->find_direct_relationship(SchemaRelationship->get_name()) == nullptr) {
      QWidget::close();
    } else {
      FillInfo();
    }
  }
}
 
void
dbse::SchemaRelationshipEditor::FillInfo()
{
  auto name = SchemaClass->get_name() + "::" + SchemaRelationship->get_name();
  setObjectName(QString::fromStdString(name));
  ui->RelationshipNameLineEdit->setText(QString::fromStdString(SchemaRelationship->get_name()));
  ui->RelationshipTypeComboBox->setCurrentIndex(
    ui->RelationshipTypeComboBox->findData(QString::fromStdString(SchemaRelationship->get_type()), Qt::DisplayRole));
  ui->RelationshipDescriptionTextEdit->setPlainText(QString::fromStdString(SchemaRelationship->get_description()));
 
  if (SchemaRelationship->get_is_composite()) {
    ui->IsCompositeCombo->setCurrentIndex(0);
  } else {
    ui->IsCompositeCombo->setCurrentIndex(1);
  }
 
  if (SchemaRelationship->get_is_exclusive()) {
    ui->IsExclusiveCombo->setCurrentIndex(0);
  } else {
    ui->IsExclusiveCombo->setCurrentIndex(1);
  }
 
  if (SchemaRelationship->get_is_dependent()) {
    ui->IsDependentCombo->setCurrentIndex(0);
  } else {
    ui->IsDependentCombo->setCurrentIndex(1);
  }
 
  if (SchemaRelationship->get_low_cardinality_constraint() == OksRelationship::CardinalityConstraint::Zero)
    ui->LowCcCombo->setCurrentIndex(0);
  else if (SchemaRelationship->get_low_cardinality_constraint() == OksRelationship::CardinalityConstraint::One) {
    ui->LowCcCombo->setCurrentIndex(1);
  } else {
    ui->LowCcCombo->setCurrentIndex(2);
  }
 
  if (SchemaRelationship->get_high_cardinality_constraint() == OksRelationship::CardinalityConstraint::Zero)
    ui->HighCcCombo->setCurrentIndex(0);
  else if (SchemaRelationship->get_high_cardinality_constraint() == OksRelationship::CardinalityConstraint::One) {
    ui->HighCcCombo->setCurrentIndex(1);
  } else {
    ui->HighCcCombo->setCurrentIndex(2);
  }
}
 
void
dbse::SchemaRelationshipEditor::keyPressEvent(QKeyEvent* event)
{
  if (event->key() == Qt::Key_Escape) {
    close();
  }
  QWidget::keyPressEvent(event);
}
 
void
dbse::SchemaRelationshipEditor::InitialSettings()
{
  QStringList ClassList;
  KernelWrapper::GetInstance().GetClassListString(ClassList);
  ui->RelationshipTypeComboBox->addItems(ClassList);
  auto name = SchemaClass->get_name() + "::";
  setObjectName(QString::fromStdString(name));
 
  if (!m_writable) {
    ui->RelationshipTypeComboBox->setEnabled(false);
    ui->IsCompositeCombo->setEnabled(false);
    ui->IsExclusiveCombo->setEnabled(false);
    ui->IsDependentCombo->setEnabled(false);
    ui->LowCcCombo->setEnabled(false);
    ui->HighCcCombo->setEnabled(false);
    ui->RelationshipDescriptionTextEdit->setEnabled(false);
    ui->RelationshipNameLineEdit->setEnabled(false);
  }
 
  if (!UsedNew) {
    FillInfo();
  }
}
 
void
dbse::SchemaRelationshipEditor::SetController()
{
  if (m_writable) {
    connect(ui->buttonBox, SIGNAL(accepted()), this, SLOT(ProxySlot()));
  } else {
    connect(ui->buttonBox, SIGNAL(accepted()), this, SLOT(close()));
  }
  connect(ui->buttonBox, SIGNAL(rejected()), this, SLOT(close()));
  connect(&KernelWrapper::GetInstance(), SIGNAL(ClassCreated(QString)), this, SLOT(UpdateClassCombo()));
  connect(&KernelWrapper::GetInstance(), SIGNAL(ClassUpdated(QString)), this, SLOT(ClassUpdated(QString)));
}
 
void
dbse::SchemaRelationshipEditor::ParseToSave()
{
  bool changed = false;
  QString RelationshipName = ui->RelationshipNameLineEdit->text();
  QString RelationshipType = ui->RelationshipTypeComboBox->currentText();
  QString RelationshipDescription = ui->RelationshipDescriptionTextEdit->toPlainText();
 
  bool IsComposite;
 
  if (ui->IsCompositeCombo->currentIndex() == 0) {
    IsComposite = true;
  } else {
    IsComposite = false;
  }
 
  bool IsExclusive;
 
  if (ui->IsExclusiveCombo->currentIndex() == 0) {
    IsExclusive = true;
  } else {
    IsExclusive = false;
  }
 
  bool IsDependent;
 
  if (ui->IsDependentCombo->currentIndex() == 0) {
    IsDependent = true;
  } else {
    IsDependent = false;
  }
 
  OksRelationship::CardinalityConstraint RelationshipHighCardinality;
  OksRelationship::CardinalityConstraint RelationshipLowCardinality;
 
  if (ui->HighCcCombo->currentIndex() == 0)
    RelationshipHighCardinality = OksRelationship::CardinalityConstraint::Zero;
  else if (ui->HighCcCombo->currentIndex() == 1)
    RelationshipHighCardinality = OksRelationship::CardinalityConstraint::One;
  else {
    RelationshipHighCardinality = OksRelationship::CardinalityConstraint::Many;
  }
 
  if (ui->LowCcCombo->currentIndex() == 0)
    RelationshipLowCardinality = OksRelationship::CardinalityConstraint::Zero;
  else if (ui->LowCcCombo->currentIndex() == 1)
    RelationshipLowCardinality = OksRelationship::CardinalityConstraint::One;
  else {
    RelationshipLowCardinality = OksRelationship::CardinalityConstraint::Many;
  }
 
  if (RelationshipName != QString::fromStdString(SchemaRelationship->get_name())) {
    KernelWrapper::GetInstance().PushSetNameRelationshipCommand(
      SchemaClass, SchemaRelationship, RelationshipName.toStdString());
    changed = true;
  }
 
  if (RelationshipType != QString::fromStdString(SchemaRelationship->get_type())) {
    KernelWrapper::GetInstance().PushSetClassTypeRelationshipCommand(
      SchemaClass, SchemaRelationship, RelationshipType.toStdString());
    changed = true;
  }
 
  if (RelationshipDescription != QString::fromStdString(SchemaRelationship->get_description())) {
    KernelWrapper::GetInstance().PushSetDescriptionRelationshipCommand(
      SchemaClass, SchemaRelationship, RelationshipDescription.toStdString());
    changed = true;
  }
 
  if (SchemaRelationship->get_is_composite() != IsComposite) {
    KernelWrapper::GetInstance().PushSetIsCompositeRelationshipCommand(SchemaClass, SchemaRelationship, IsComposite);
    changed = true;
  }
 
  if (SchemaRelationship->get_is_exclusive() != IsExclusive) {
    KernelWrapper::GetInstance().PushSetIsExclusiveRelationshipCommand(SchemaClass, SchemaRelationship, IsExclusive);
    changed = true;
  }
 
  if (SchemaRelationship->get_is_dependent() != IsDependent) {
    KernelWrapper::GetInstance().PushSetIsDependentRelationshipCommand(SchemaClass, SchemaRelationship, IsDependent);
    changed = true;
  }
 
  if (RelationshipHighCardinality != SchemaRelationship->get_high_cardinality_constraint()) {
    KernelWrapper::GetInstance().PushSetHighCcRelationshipCommand(
      SchemaClass, SchemaRelationship, RelationshipHighCardinality);
    changed = true;
  }
 
  if (RelationshipLowCardinality != SchemaRelationship->get_low_cardinality_constraint()) {
    KernelWrapper::GetInstance().PushSetLowCcRelationshipCommand(
      SchemaClass, SchemaRelationship, RelationshipLowCardinality);
    changed = true;
  }
 
  if (changed) {
    emit RebuildModel();
  }
 
  close();
}
 
void
dbse::SchemaRelationshipEditor::ParseToCreate()
{
  if (ui->RelationshipNameLineEdit->text().isEmpty()) {
    QMessageBox::warning(0, "Schema editor", QString("Please Provide a name for the relationship !"));
    return;
  }
 
  QString RelationshipName = ui->RelationshipNameLineEdit->text();
  QString RelationshipType = ui->RelationshipTypeComboBox->currentText();
  QString RelationshipDescription = ui->RelationshipDescriptionTextEdit->toPlainText();
 
  bool IsComposite;
 
  if (ui->IsCompositeCombo->currentIndex() == 0) {
    IsComposite = true;
  } else {
    IsComposite = false;
  }
 
  bool IsExclusive;
 
  if (ui->IsExclusiveCombo->currentIndex() == 0) {
    IsExclusive = true;
  } else {
    IsExclusive = false;
  }
 
  bool IsDependent;
 
  if (ui->IsDependentCombo->currentIndex() == 0) {
    IsDependent = true;
  } else {
    IsDependent = false;
  }
 
  OksRelationship::CardinalityConstraint RelationshipHighCardinality;
  OksRelationship::CardinalityConstraint RelationshipLowCardinality;
 
  if (ui->HighCcCombo->currentIndex() == 0)
    RelationshipHighCardinality = OksRelationship::CardinalityConstraint::Zero;
  else if (ui->HighCcCombo->currentIndex() == 1)
    RelationshipHighCardinality = OksRelationship::CardinalityConstraint::One;
  else {
    RelationshipHighCardinality = OksRelationship::CardinalityConstraint::Many;
  }
 
  if (ui->LowCcCombo->currentIndex() == 0)
    RelationshipLowCardinality = OksRelationship::CardinalityConstraint::Zero;
  else if (ui->LowCcCombo->currentIndex() == 1)
    RelationshipLowCardinality = OksRelationship::CardinalityConstraint::One;
  else {
    RelationshipLowCardinality = OksRelationship::CardinalityConstraint::Many;
  }
 
  KernelWrapper::GetInstance().PushAddRelationship(SchemaClass,
                                                   RelationshipName.toStdString(),
                                                   RelationshipDescription.toStdString(),
                                                   RelationshipType.toStdString(),
                                                   IsComposite,
                                                   IsExclusive,
                                                   IsDependent,
                                                   RelationshipLowCardinality,
                                                   RelationshipHighCardinality);
  emit RebuildModel();
 
  if (GraphScene)
    emit MakeGraphConnection(
      QString::fromStdString(SchemaClass->get_name()), ui->RelationshipTypeComboBox->currentText(), RelationshipName);
 
  close();
}
 
void
dbse::SchemaRelationshipEditor::ProxySlot()
{
  if (UsedNew) {
    ParseToCreate();
  } else {
    ParseToSave();
  }
}
 
void
dbse::SchemaRelationshipEditor::UpdateClassCombo()
{
  QStringList ClassList;
  KernelWrapper::GetInstance().GetClassListString(ClassList);
  ui->RelationshipTypeComboBox->clear();
  ui->RelationshipTypeComboBox->addItems(ClassList);
  ui->RelationshipTypeComboBox->setCurrentIndex(
    ui->RelationshipTypeComboBox->findData(QString::fromStdString(SchemaRelationship->get_type()), Qt::DisplayRole));
}