GIT_REPOSITORIES/LPP/Users/mperrinel/SciQLop-fork Commit - r1257:3d32d6e4f598

Add init of DisplayedEvent. Add save on EventProduct modif

perrinel -

r1257:3d32d6e4f598

parent child

Context file:

r1257:3d32d6e4f598

gui/src/Catalogue/CatalogueExplorer.cpp +4 -1

             #include "Catalogue/CatalogueExplorer.h"
             #include "ui_CatalogueExplorer.h"
             #include <Catalogue/CatalogueActionManager.h>
             #include <Catalogue/CatalogueController.h>
             #include <SqpApplication.h>
             #include <Visualization/VisualizationWidget.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             struct CatalogueExplorer::CatalogueExplorerPrivate {
                 CatalogueActionManager m_ActionManager;
             };
             CatalogueExplorer::CatalogueExplorer(QWidget *parent)
                     : QDialog(parent, Qt::Dialog | Qt::WindowMinMaxButtonsHint | Qt::WindowCloseButtonHint),
                       ui(new Ui::CatalogueExplorer),
                       impl{spimpl::make_unique_impl<CatalogueExplorerPrivate>()}
             {
                 ui->setupUi(this);
                 impl->m_ActionManager.installSelectionZoneActions();
                 connect(ui->catalogues, &CatalogueSideBarWidget::catalogueSelected, [this](auto catalogues) {
                     if (catalogues.count() == 1) {
                         ui->inspector->setCatalogue(catalogues.first());
                     }
                     else {
                         ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                     }
                     ui->events->populateWithCatalogues(catalogues);
                 });
                 connect(ui->catalogues, &CatalogueSideBarWidget::databaseSelected, [this](auto databases) {
                     ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                 });
                 connect(ui->catalogues, &CatalogueSideBarWidget::trashSelected,
                         [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
                 connect(ui->catalogues, &CatalogueSideBarWidget::allEventsSelected, [this]() {
                     ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                     ui->events->populateWithAllEvents();
                 });
                 connect(ui->catalogues, &CatalogueSideBarWidget::selectionCleared,
                         [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
                 connect(ui->events, &CatalogueEventsWidget::eventsSelected, [this](auto events) {
                     if (events.count() == 1) {
                         ui->inspector->setEvent(events.first());
                     }
                     else {
                         ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                     }
                 });
                 connect(ui->events, &CatalogueEventsWidget::eventProductsSelected, [this](auto eventProducts) {
                     if (eventProducts.count() == 1) {
                         ui->inspector->setEventProduct(eventProducts.first().first,
                                                        eventProducts.first().second);
                     }
                     else {
                         ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty);
                     }
                 });
                 connect(ui->events, &CatalogueEventsWidget::selectionCleared,
                         [this]() { ui->inspector->showPage(CatalogueInspectorWidget::Page::Empty); });
                 connect(ui->inspector, &CatalogueInspectorWidget::catalogueUpdated, [this](auto catalogue) {
                     sqpApp->catalogueController().updateCatalogue(catalogue);
                     ui->catalogues->setCatalogueChanges(catalogue, true);
                 });
                 connect(ui->inspector, &CatalogueInspectorWidget::eventUpdated, [this](auto event) {
                     sqpApp->catalogueController().updateEvent(event);
                     ui->events->setEventChanges(event, true);
                 });
                 connect(ui->inspector, &CatalogueInspectorWidget::eventProductUpdated,
-                        [this](auto event, auto eventProduct) { ui->events->setEventChanges(event, true); });
+                        [this](auto event, auto eventProduct) {
+                            sqpApp->catalogueController().updateEventProduct(eventProduct);
+                            ui->events->setEventChanges(event, true);
+                        });
             }
             CatalogueExplorer::~CatalogueExplorer()
             {
                 delete ui;
             }
             void CatalogueExplorer::setVisualizationWidget(VisualizationWidget *visualization)
             {
                 ui->events->setVisualizationWidget(visualization);
             }

gui/src/Catalogue/CatalogueInspectorWidget.cpp +33 -3

             #include "Catalogue/CatalogueInspectorWidget.h"
             #include "ui_CatalogueInspectorWidget.h"
             #include <Common/DateUtils.h>
             #include <DBCatalogue.h>
             #include <DBEvent.h>
             #include <DBEventProduct.h>
             #include <DBTag.h>
             struct CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate {
                 std::shared_ptr<DBCatalogue> m_DisplayedCatalogue = nullptr;
                 std::shared_ptr<DBEvent> m_DisplayedEvent = nullptr;
                 std::shared_ptr<DBEventProduct> m_DisplayedEventProduct = nullptr;
                 void connectCatalogueUpdateSignals(CatalogueInspectorWidget *inspector,
                                                    Ui::CatalogueInspectorWidget *ui);
                 void connectEventUpdateSignals(CatalogueInspectorWidget *inspector,
                                                Ui::CatalogueInspectorWidget *ui);
             };
             CatalogueInspectorWidget::CatalogueInspectorWidget(QWidget *parent)
                     : QWidget(parent),
                       ui(new Ui::CatalogueInspectorWidget),
                       impl{spimpl::make_unique_impl<CatalogueInspectorWidgetPrivate>()}
             {
                 ui->setupUi(this);
                 showPage(Page::Empty);
                 impl->connectCatalogueUpdateSignals(this, ui);
                 impl->connectEventUpdateSignals(this, ui);
             }
             CatalogueInspectorWidget::~CatalogueInspectorWidget()
             {
                 delete ui;
             }
             void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectCatalogueUpdateSignals(
                 CatalogueInspectorWidget *inspector, Ui::CatalogueInspectorWidget *ui)
             {
                 connect(ui->leCatalogueName, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leCatalogueName->text() != m_DisplayedCatalogue->getName()) {
                         m_DisplayedCatalogue->setName(ui->leCatalogueName->text());
                         emit inspector->catalogueUpdated(m_DisplayedCatalogue);
                     }
                 });
                 connect(ui->leCatalogueAuthor, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leCatalogueAuthor->text() != m_DisplayedCatalogue->getAuthor()) {
                         m_DisplayedCatalogue->setAuthor(ui->leCatalogueAuthor->text());
                         emit inspector->catalogueUpdated(m_DisplayedCatalogue);
                     }
                 });
             }
             void CatalogueInspectorWidget::CatalogueInspectorWidgetPrivate::connectEventUpdateSignals(
                 CatalogueInspectorWidget *inspector, Ui::CatalogueInspectorWidget *ui)
             {
                 connect(ui->leEventName, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leEventName->text() != m_DisplayedEvent->getName()) {
                         m_DisplayedEvent->setName(ui->leEventName->text());
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->leEventTags, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     auto tags = ui->leEventTags->text().split(QRegExp("\\s+"));
                     std::list<QString> tagNames;
                     for (auto tag : tags) {
                         tagNames.push_back(tag);
                     }
                     if (m_DisplayedEvent->getTagsNames() != tagNames) {
                         m_DisplayedEvent->setTagsNames(tagNames);
                         emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->leEventProduct, &QLineEdit::editingFinished, [ui, inspector, this]() {
                     if (ui->leEventProduct->text() != m_DisplayedEventProduct->getProductId()) {
+                        auto oldProductId = m_DisplayedEventProduct->getProductId();
                         m_DisplayedEventProduct->setProductId(ui->leEventProduct->text());
-                        emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+                        auto eventProducts = m_DisplayedEvent->getEventProducts();
+                        for (auto &eventProduct : eventProducts) {
+                            if (eventProduct.getProductId() == oldProductId) {
+                                eventProduct.setProductId(m_DisplayedEventProduct->getProductId());
+                            }
+                        }
+                        m_DisplayedEvent->setEventProducts(eventProducts);
+                        emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->dateTimeEventTStart, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
                     auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTStart->dateTime());
                     if (time != m_DisplayedEventProduct->getTStart()) {
                         m_DisplayedEventProduct->setTStart(time);
-                        emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+                        auto eventProducts = m_DisplayedEvent->getEventProducts();
+                        for (auto &eventProduct : eventProducts) {
+                            if (eventProduct.getProductId() == m_DisplayedEventProduct->getProductId()) {
+                                eventProduct.setTStart(m_DisplayedEventProduct->getTStart());
+                            }
+                        }
+                        m_DisplayedEvent->setEventProducts(eventProducts);
+                        emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
                 connect(ui->dateTimeEventTEnd, &QDateTimeEdit::editingFinished, [ui, inspector, this]() {
                     auto time = DateUtils::secondsSinceEpoch(ui->dateTimeEventTEnd->dateTime());
                     if (time != m_DisplayedEventProduct->getTEnd()) {
                         m_DisplayedEventProduct->setTEnd(time);
-                        emit inspector->eventProductUpdated(m_DisplayedEvent, m_DisplayedEventProduct);
+                        auto eventProducts = m_DisplayedEvent->getEventProducts();
+                        for (auto &eventProduct : eventProducts) {
+                            if (eventProduct.getProductId() == m_DisplayedEventProduct->getProductId()) {
+                                eventProduct.setTEnd(m_DisplayedEventProduct->getTEnd());
+                            }
+                        }
+                        m_DisplayedEvent->setEventProducts(eventProducts);
+                        emit inspector->eventUpdated(m_DisplayedEvent);
                     }
                 });
             }
             void CatalogueInspectorWidget::showPage(CatalogueInspectorWidget::Page page)
             {
                 ui->stackedWidget->setCurrentIndex(static_cast<int>(page));
             }
             CatalogueInspectorWidget::Page CatalogueInspectorWidget::currentPage() const
             {
                 return static_cast<Page>(ui->stackedWidget->currentIndex());
             }
             void CatalogueInspectorWidget::setEvent(const std::shared_ptr<DBEvent> &event)
             {
                 impl->m_DisplayedEvent = event;
                 blockSignals(true);
                 showPage(Page::EventProperties);
                 ui->leEventName->setEnabled(true);
                 ui->leEventName->setText(event->getName());
                 ui->leEventProduct->setEnabled(false);
                 ui->leEventProduct->setText(
                     QString::number(event->getEventProducts().size()).append(" product(s)"));
                 QString tagList;
                 auto tags = event->getTagsNames();
                 for (auto tag : tags) {
                     tagList += tag;
                     tagList += ' ';
                 }
                 ui->leEventTags->setEnabled(true);
                 ui->leEventTags->setText(tagList);
                 ui->dateTimeEventTStart->setEnabled(false);
                 ui->dateTimeEventTEnd->setEnabled(false);
                 ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(event->getTStart()));
                 ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(event->getTEnd()));
                 blockSignals(false);
             }
             void CatalogueInspectorWidget::setEventProduct(const std::shared_ptr<DBEvent> &event,
                                                            const std::shared_ptr<DBEventProduct> &eventProduct)
             {
+                impl->m_DisplayedEvent = event;
                 impl->m_DisplayedEventProduct = eventProduct;
                 blockSignals(true);
                 showPage(Page::EventProperties);
                 ui->leEventName->setEnabled(false);
                 ui->leEventName->setText(event->getName());
                 ui->leEventProduct->setEnabled(true);
                 ui->leEventProduct->setText(eventProduct->getProductId());
                 ui->leEventTags->setEnabled(false);
                 ui->leEventTags->clear();
                 ui->dateTimeEventTStart->setEnabled(true);
                 ui->dateTimeEventTEnd->setEnabled(true);
                 ui->dateTimeEventTStart->setDateTime(DateUtils::dateTime(eventProduct->getTStart()));
                 ui->dateTimeEventTEnd->setDateTime(DateUtils::dateTime(eventProduct->getTEnd()));
                 blockSignals(false);
             }
             void CatalogueInspectorWidget::setCatalogue(const std::shared_ptr<DBCatalogue> &catalogue)
             {
                 impl->m_DisplayedCatalogue = catalogue;
                 blockSignals(true);
                 showPage(Page::CatalogueProperties);
                 ui->leCatalogueName->setText(catalogue->getName());
                 ui->leCatalogueAuthor->setText(catalogue->getAuthor());
                 blockSignals(false);
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages