CatalogueEventsModel.cpp
484 lines
| 15.7 KiB
| text/x-c
|
CppLexer
r1149 | #include "Catalogue/CatalogueEventsModel.h" | |||
r1230 | #include <Catalogue/CatalogueController.h> | |||
r1149 | #include <Common/DateUtils.h> | |||
#include <Common/MimeTypesDef.h> | ||||
#include <DBEvent.h> | ||||
#include <DBEventProduct.h> | ||||
#include <DBTag.h> | ||||
#include <Data/SqpRange.h> | ||||
#include <SqpApplication.h> | ||||
#include <Time/TimeController.h> | ||||
#include <list> | ||||
#include <unordered_map> | ||||
#include <QHash> | ||||
#include <QMimeData> | ||||
r1162 | Q_LOGGING_CATEGORY(LOG_CatalogueEventsModel, "CatalogueEventsModel") | |||
r1149 | const auto EVENT_ITEM_TYPE = 1; | |||
const auto EVENT_PRODUCT_ITEM_TYPE = 2; | ||||
r1150 | struct CatalogueEventsModel::CatalogueEventsModelPrivate { | |||
r1149 | QVector<std::shared_ptr<DBEvent> > m_Events; | |||
std::unordered_map<DBEvent *, QVector<std::shared_ptr<DBEventProduct> > > m_EventProducts; | ||||
r1308 | QVector<std::shared_ptr<DBCatalogue> > m_SourceCatalogue; | |||
r1149 | ||||
QStringList columnNames() | ||||
{ | ||||
r1162 | return QStringList{tr("Event"), tr("TStart"), tr("TEnd"), | |||
tr("Tags"), tr("Product"), tr("")}; | ||||
} | ||||
QVariant sortData(int col, const std::shared_ptr<DBEvent> &event) const | ||||
{ | ||||
if (col == (int)CatalogueEventsModel::Column::Validation) { | ||||
r1237 | auto hasChanges = sqpApp->catalogueController().eventHasChanges(event); | |||
return hasChanges ? true : QVariant(); | ||||
r1162 | } | |||
return eventData(col, event); | ||||
r1149 | } | |||
QVariant eventData(int col, const std::shared_ptr<DBEvent> &event) const | ||||
{ | ||||
switch (static_cast<Column>(col)) { | ||||
r1162 | case CatalogueEventsModel::Column::Name: | |||
r1149 | return event->getName(); | |||
r1162 | case CatalogueEventsModel::Column::TStart: | |||
r1315 | return nbEventProducts(event) > 0 | |||
? DateUtils::dateTime(event->getTStart()) | ||||
.toString(DATETIME_FORMAT_ONE_LINE) | ||||
: QVariant{}; | ||||
r1162 | case CatalogueEventsModel::Column::TEnd: | |||
r1315 | return nbEventProducts(event) > 0 | |||
? DateUtils::dateTime(event->getTEnd()) | ||||
.toString(DATETIME_FORMAT_ONE_LINE) | ||||
: QVariant{}; | ||||
r1310 | case CatalogueEventsModel::Column::Product: { | |||
auto eventProducts = event->getEventProducts(); | ||||
QStringList eventProductList; | ||||
for (auto evtProduct : eventProducts) { | ||||
eventProductList << evtProduct.getProductId(); | ||||
} | ||||
return eventProductList.join(";"); | ||||
} | ||||
r1162 | case CatalogueEventsModel::Column::Tags: { | |||
r1149 | QString tagList; | |||
auto tags = event->getTags(); | ||||
for (auto tag : tags) { | ||||
tagList += tag.getName(); | ||||
tagList += ' '; | ||||
} | ||||
return tagList; | ||||
} | ||||
r1162 | case CatalogueEventsModel::Column::Validation: | |||
return QVariant(); | ||||
r1149 | default: | |||
break; | ||||
} | ||||
Q_ASSERT(false); | ||||
return QStringLiteral("Unknown Data"); | ||||
} | ||||
void parseEventProduct(const std::shared_ptr<DBEvent> &event) | ||||
{ | ||||
for (auto product : event->getEventProducts()) { | ||||
m_EventProducts[event.get()].append(std::make_shared<DBEventProduct>(product)); | ||||
} | ||||
} | ||||
r1161 | int nbEventProducts(const std::shared_ptr<DBEvent> &event) const | |||
{ | ||||
auto eventProductsIt = m_EventProducts.find(event.get()); | ||||
if (eventProductsIt != m_EventProducts.cend()) { | ||||
return m_EventProducts.at(event.get()).count(); | ||||
} | ||||
else { | ||||
return 0; | ||||
} | ||||
} | ||||
r1149 | QVariant eventProductData(int col, const std::shared_ptr<DBEventProduct> &eventProduct) const | |||
{ | ||||
switch (static_cast<Column>(col)) { | ||||
r1162 | case CatalogueEventsModel::Column::Name: | |||
r1149 | return eventProduct->getProductId(); | |||
r1162 | case CatalogueEventsModel::Column::TStart: | |||
r1315 | return DateUtils::dateTime(eventProduct->getTStart()) | |||
.toString(DATETIME_FORMAT_ONE_LINE); | ||||
r1162 | case CatalogueEventsModel::Column::TEnd: | |||
r1315 | return DateUtils::dateTime(eventProduct->getTEnd()) | |||
.toString(DATETIME_FORMAT_ONE_LINE); | ||||
r1162 | case CatalogueEventsModel::Column::Product: | |||
r1149 | return eventProduct->getProductId(); | |||
r1162 | case CatalogueEventsModel::Column::Tags: | |||
r1149 | return QString(); | |||
r1162 | case CatalogueEventsModel::Column::Validation: | |||
return QVariant(); | ||||
r1149 | default: | |||
break; | ||||
} | ||||
Q_ASSERT(false); | ||||
return QStringLiteral("Unknown Data"); | ||||
} | ||||
r1233 | ||||
void refreshChildrenOfIndex(CatalogueEventsModel *model, const QModelIndex &index) const | ||||
{ | ||||
auto childCount = model->rowCount(index); | ||||
auto colCount = model->columnCount(); | ||||
emit model->dataChanged(model->index(0, 0, index), | ||||
model->index(childCount, colCount, index)); | ||||
} | ||||
r1149 | }; | |||
CatalogueEventsModel::CatalogueEventsModel(QObject *parent) | ||||
r1150 | : QAbstractItemModel(parent), impl{spimpl::make_unique_impl<CatalogueEventsModelPrivate>()} | |||
r1149 | { | |||
} | ||||
r1308 | void CatalogueEventsModel::setSourceCatalogues( | |||
const QVector<std::shared_ptr<DBCatalogue> > &catalogues) | ||||
{ | ||||
impl->m_SourceCatalogue = catalogues; | ||||
} | ||||
r1149 | void CatalogueEventsModel::setEvents(const QVector<std::shared_ptr<DBEvent> > &events) | |||
{ | ||||
beginResetModel(); | ||||
impl->m_Events = events; | ||||
r1150 | impl->m_EventProducts.clear(); | |||
r1149 | for (auto event : events) { | |||
impl->parseEventProduct(event); | ||||
} | ||||
endResetModel(); | ||||
} | ||||
r1150 | std::shared_ptr<DBEvent> CatalogueEventsModel::getEvent(const QModelIndex &index) const | |||
{ | ||||
if (itemTypeOf(index) == CatalogueEventsModel::ItemType::Event) { | ||||
return impl->m_Events.value(index.row()); | ||||
} | ||||
else { | ||||
return nullptr; | ||||
} | ||||
} | ||||
std::shared_ptr<DBEvent> CatalogueEventsModel::getParentEvent(const QModelIndex &index) const | ||||
r1149 | { | |||
r1150 | if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) { | |||
return getEvent(index.parent()); | ||||
} | ||||
else { | ||||
return nullptr; | ||||
} | ||||
} | ||||
std::shared_ptr<DBEventProduct> | ||||
CatalogueEventsModel::getEventProduct(const QModelIndex &index) const | ||||
{ | ||||
if (itemTypeOf(index) == CatalogueEventsModel::ItemType::EventProduct) { | ||||
auto event = static_cast<DBEvent *>(index.internalPointer()); | ||||
return impl->m_EventProducts.at(event).value(index.row()); | ||||
} | ||||
else { | ||||
return nullptr; | ||||
} | ||||
r1149 | } | |||
void CatalogueEventsModel::addEvent(const std::shared_ptr<DBEvent> &event) | ||||
{ | ||||
r1233 | beginInsertRows(QModelIndex(), impl->m_Events.count(), impl->m_Events.count()); | |||
r1149 | impl->m_Events.append(event); | |||
impl->parseEventProduct(event); | ||||
endInsertRows(); | ||||
r1233 | ||||
// Also refreshes its children event products | ||||
auto eventIndex = index(impl->m_Events.count(), 0); | ||||
impl->refreshChildrenOfIndex(this, eventIndex); | ||||
r1149 | } | |||
void CatalogueEventsModel::removeEvent(const std::shared_ptr<DBEvent> &event) | ||||
{ | ||||
auto index = impl->m_Events.indexOf(event); | ||||
if (index >= 0) { | ||||
beginRemoveRows(QModelIndex(), index, index); | ||||
impl->m_Events.removeAt(index); | ||||
impl->m_EventProducts.erase(event.get()); | ||||
endRemoveRows(); | ||||
} | ||||
} | ||||
r1162 | QVector<std::shared_ptr<DBEvent> > CatalogueEventsModel::events() const | |||
{ | ||||
return impl->m_Events; | ||||
} | ||||
r1245 | void CatalogueEventsModel::refreshEvent(const std::shared_ptr<DBEvent> &event, | |||
bool refreshEventProducts) | ||||
r1149 | { | |||
r1162 | auto eventIndex = indexOf(event); | |||
if (eventIndex.isValid()) { | ||||
r1245 | if (refreshEventProducts) { | |||
// Reparse the associated event products | ||||
auto nbEventProducts = impl->nbEventProducts(event); | ||||
auto newNbOfEventProducts = event->getEventProducts().size(); | ||||
if (newNbOfEventProducts < nbEventProducts) { | ||||
beginRemoveRows(eventIndex, newNbOfEventProducts, nbEventProducts - 1); | ||||
impl->m_EventProducts.erase(event.get()); | ||||
impl->parseEventProduct(event); | ||||
endRemoveRows(); | ||||
} | ||||
else if (newNbOfEventProducts > nbEventProducts) { | ||||
beginInsertRows(eventIndex, nbEventProducts, newNbOfEventProducts - 1); | ||||
impl->m_EventProducts.erase(event.get()); | ||||
impl->parseEventProduct(event); | ||||
endInsertRows(); | ||||
} | ||||
else { // newNbOfEventProducts == nbEventProducts | ||||
impl->m_EventProducts.erase(event.get()); | ||||
impl->parseEventProduct(event); | ||||
} | ||||
} | ||||
r1162 | // Refreshes the event line | |||
r1150 | auto colCount = columnCount(); | |||
r1162 | emit dataChanged(eventIndex, index(eventIndex.row(), colCount)); | |||
r1150 | ||||
r1162 | // Also refreshes its children event products | |||
r1233 | impl->refreshChildrenOfIndex(this, eventIndex); | |||
r1149 | } | |||
r1162 | else { | |||
qCWarning(LOG_CatalogueEventsModel()) << "refreshEvent: event not found."; | ||||
} | ||||
} | ||||
QModelIndex CatalogueEventsModel::indexOf(const std::shared_ptr<DBEvent> &event) const | ||||
{ | ||||
auto row = impl->m_Events.indexOf(event); | ||||
if (row >= 0) { | ||||
return index(row, 0); | ||||
} | ||||
return QModelIndex(); | ||||
} | ||||
r1149 | QModelIndex CatalogueEventsModel::index(int row, int column, const QModelIndex &parent) const | |||
{ | ||||
if (!hasIndex(row, column, parent)) { | ||||
return QModelIndex(); | ||||
} | ||||
r1150 | switch (itemTypeOf(parent)) { | |||
case CatalogueEventsModel::ItemType::Root: | ||||
r1149 | return createIndex(row, column); | |||
r1150 | case CatalogueEventsModel::ItemType::Event: { | |||
auto event = getEvent(parent); | ||||
r1149 | return createIndex(row, column, event.get()); | |||
} | ||||
r1150 | case CatalogueEventsModel::ItemType::EventProduct: | |||
r1149 | break; | |||
default: | ||||
break; | ||||
} | ||||
return QModelIndex(); | ||||
} | ||||
QModelIndex CatalogueEventsModel::parent(const QModelIndex &index) const | ||||
{ | ||||
r1150 | switch (itemTypeOf(index)) { | |||
case CatalogueEventsModel::ItemType::EventProduct: { | ||||
r1149 | auto parentEvent = static_cast<DBEvent *>(index.internalPointer()); | |||
auto it | ||||
= std::find_if(impl->m_Events.cbegin(), impl->m_Events.cend(), | ||||
[parentEvent](auto event) { return event.get() == parentEvent; }); | ||||
if (it != impl->m_Events.cend()) { | ||||
return createIndex(it - impl->m_Events.cbegin(), 0); | ||||
} | ||||
else { | ||||
return QModelIndex(); | ||||
} | ||||
} | ||||
r1150 | case CatalogueEventsModel::ItemType::Root: | |||
r1149 | break; | |||
r1150 | case CatalogueEventsModel::ItemType::Event: | |||
r1149 | break; | |||
default: | ||||
break; | ||||
} | ||||
return QModelIndex(); | ||||
} | ||||
int CatalogueEventsModel::rowCount(const QModelIndex &parent) const | ||||
{ | ||||
if (parent.column() > 0) { | ||||
return 0; | ||||
} | ||||
r1150 | switch (itemTypeOf(parent)) { | |||
case CatalogueEventsModel::ItemType::Root: | ||||
r1149 | return impl->m_Events.count(); | |||
r1150 | case CatalogueEventsModel::ItemType::Event: { | |||
auto event = getEvent(parent); | ||||
r1149 | return impl->m_EventProducts[event.get()].count(); | |||
} | ||||
r1150 | case CatalogueEventsModel::ItemType::EventProduct: | |||
r1149 | break; | |||
default: | ||||
break; | ||||
} | ||||
return 0; | ||||
} | ||||
int CatalogueEventsModel::columnCount(const QModelIndex &parent) const | ||||
{ | ||||
r1162 | return static_cast<int>(CatalogueEventsModel::Column::NbColumn); | |||
r1149 | } | |||
Qt::ItemFlags CatalogueEventsModel::flags(const QModelIndex &index) const | ||||
{ | ||||
return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled; | ||||
} | ||||
QVariant CatalogueEventsModel::data(const QModelIndex &index, int role) const | ||||
{ | ||||
if (index.isValid()) { | ||||
r1150 | auto type = itemTypeOf(index); | |||
if (type == CatalogueEventsModel::ItemType::Event) { | ||||
auto event = getEvent(index); | ||||
r1149 | switch (role) { | |||
case Qt::DisplayRole: | ||||
return impl->eventData(index.column(), event); | ||||
break; | ||||
} | ||||
} | ||||
r1150 | else if (type == CatalogueEventsModel::ItemType::EventProduct) { | |||
auto product = getEventProduct(index); | ||||
r1149 | switch (role) { | |||
case Qt::DisplayRole: | ||||
return impl->eventProductData(index.column(), product); | ||||
break; | ||||
} | ||||
} | ||||
} | ||||
return QVariant{}; | ||||
} | ||||
QVariant CatalogueEventsModel::headerData(int section, Qt::Orientation orientation, int role) const | ||||
{ | ||||
if (orientation == Qt::Horizontal && role == Qt::DisplayRole) { | ||||
return impl->columnNames().value(section); | ||||
} | ||||
return QVariant(); | ||||
} | ||||
void CatalogueEventsModel::sort(int column, Qt::SortOrder order) | ||||
{ | ||||
r1233 | beginResetModel(); | |||
r1149 | std::sort(impl->m_Events.begin(), impl->m_Events.end(), | |||
[this, column, order](auto e1, auto e2) { | ||||
r1162 | auto data1 = impl->sortData(column, e1); | |||
auto data2 = impl->sortData(column, e2); | ||||
r1149 | ||||
auto result = data1.toString() < data2.toString(); | ||||
return order == Qt::AscendingOrder ? result : !result; | ||||
}); | ||||
r1233 | endResetModel(); | |||
r1162 | emit modelSorted(); | |||
r1149 | } | |||
Qt::DropActions CatalogueEventsModel::supportedDragActions() const | ||||
{ | ||||
r1308 | return Qt::CopyAction | Qt::MoveAction; | |||
r1149 | } | |||
QStringList CatalogueEventsModel::mimeTypes() const | ||||
{ | ||||
r1308 | return {MIME_TYPE_EVENT_LIST, MIME_TYPE_SOURCE_CATALOGUE_LIST, MIME_TYPE_TIME_RANGE}; | |||
r1149 | } | |||
QMimeData *CatalogueEventsModel::mimeData(const QModelIndexList &indexes) const | ||||
{ | ||||
auto mimeData = new QMimeData; | ||||
r1151 | bool isFirst = true; | |||
r1149 | QVector<std::shared_ptr<DBEvent> > eventList; | |||
r1151 | QVector<std::shared_ptr<DBEventProduct> > eventProductList; | |||
r1149 | ||||
SqpRange firstTimeRange; | ||||
for (const auto &index : indexes) { | ||||
if (index.column() == 0) { // only the first column | ||||
r1151 | auto type = itemTypeOf(index); | |||
if (type == ItemType::Event) { | ||||
auto event = getEvent(index); | ||||
eventList << event; | ||||
if (isFirst) { | ||||
isFirst = false; | ||||
r1152 | firstTimeRange.m_TStart = event->getTStart(); | |||
firstTimeRange.m_TEnd = event->getTEnd(); | ||||
r1151 | } | |||
} | ||||
else if (type == ItemType::EventProduct) { | ||||
auto product = getEventProduct(index); | ||||
eventProductList << product; | ||||
if (isFirst) { | ||||
isFirst = false; | ||||
firstTimeRange.m_TStart = product->getTStart(); | ||||
firstTimeRange.m_TEnd = product->getTEnd(); | ||||
} | ||||
} | ||||
r1149 | } | |||
} | ||||
r1230 | if (!eventList.isEmpty() && eventProductList.isEmpty()) { | |||
auto eventsEncodedData = sqpApp->catalogueController().mimeDataForEvents(eventList); | ||||
mimeData->setData(MIME_TYPE_EVENT_LIST, eventsEncodedData); | ||||
r1308 | ||||
auto sourceCataloguesEncodedData | ||||
= sqpApp->catalogueController().mimeDataForCatalogues(impl->m_SourceCatalogue); | ||||
mimeData->setData(MIME_TYPE_SOURCE_CATALOGUE_LIST, sourceCataloguesEncodedData); | ||||
r1230 | } | |||
r1149 | ||||
r1151 | if (eventList.count() + eventProductList.count() == 1) { | |||
r1149 | // No time range MIME data if multiple events are dragged | |||
auto timeEncodedData = TimeController::mimeDataForTimeRange(firstTimeRange); | ||||
mimeData->setData(MIME_TYPE_TIME_RANGE, timeEncodedData); | ||||
} | ||||
return mimeData; | ||||
} | ||||
r1150 | ||||
CatalogueEventsModel::ItemType CatalogueEventsModel::itemTypeOf(const QModelIndex &index) const | ||||
{ | ||||
if (!index.isValid()) { | ||||
return ItemType::Root; | ||||
} | ||||
else if (index.internalPointer() == nullptr) { | ||||
return ItemType::Event; | ||||
} | ||||
else { | ||||
return ItemType::EventProduct; | ||||
} | ||||
} | ||||