1 files changed, 107 insertions, 12 deletions

diff --git a/common/modelresult.cpp b/common/modelresult.cpp
index f935419..b12216b 100644
--- a/common/modelresult.cpp
+++ b/common/modelresult.cpp
@@ -24,12 +24,20 @@
 #include <QPointer>
 
 #include "log.h"
+#include "notifier.h"
+#include "notification.h"
+
+using namespace Sink;
+
+static uint getInternalIdentifer(const QByteArray &resourceId, const QByteArray &entityId)
+{
+    return qHash(resourceId + entityId);
+}
 
 static uint qHash(const Sink::ApplicationDomain::ApplicationDomainType &type)
 {
-    // Q_ASSERT(!type.resourceInstanceIdentifier().isEmpty());
     Q_ASSERT(!type.identifier().isEmpty());
-    return qHash(type.resourceInstanceIdentifier() + type.identifier());
+    return getInternalIdentifer(type.resourceInstanceIdentifier(), type.identifier());
 }
 
 static qint64 getIdentifier(const QModelIndex &idx)
@@ -44,6 +52,86 @@ template <class T, class Ptr>
 ModelResult<T, Ptr>::ModelResult(const Sink::Query &query, const QList<QByteArray> &propertyColumns, const Sink::Log::Context &ctx)
     : QAbstractItemModel(), mLogCtx(ctx.subContext("modelresult")), mPropertyColumns(propertyColumns), mQuery(query)
 {
+    if (query.flags().testFlag(Sink::Query::UpdateStatus)) {
+        Sink::Query resourceQuery;
+        resourceQuery.setFilter(query.getResourceFilter());
+        mNotifier.reset(new Sink::Notifier{resourceQuery});
+        mNotifier->registerHandler([this](const Notification &notification) {
+            switch (notification.type) {
+                case Notification::Status:
+                case Notification::Warning:
+                case Notification::Error:
+                case Notification::Info:
+                case Notification::Progress:
+                    //These are the notifications we care about
+                    break;
+                default:
+                    //We're not interested
+                    return;
+            };
+            if (notification.resource.isEmpty() || notification.entities.isEmpty()) {
+                return;
+            }
+
+            QVector<qint64> idList;
+            for (const auto &entity : notification.entities) {
+                auto id = getInternalIdentifer(notification.resource, entity);
+                if (mEntities.contains(id)) {
+                    idList << id;
+                }
+            }
+
+            if (idList.isEmpty()) {
+                //We don't have this entity in our model
+                return;
+            }
+            const int newStatus = [&] {
+                if (notification.type == Notification::Warning || notification.type == Notification::Error) {
+                    return ApplicationDomain::SyncStatus::SyncError;
+                }
+                if (notification.type == Notification::Info) {
+                    switch (notification.code) {
+                        case ApplicationDomain::SyncInProgress:
+                            return ApplicationDomain::SyncInProgress;
+                        case ApplicationDomain::SyncSuccess:
+                            return ApplicationDomain::SyncSuccess;
+                        case ApplicationDomain::SyncError:
+                            return ApplicationDomain::SyncError;
+                        case ApplicationDomain::NoSyncStatus:
+                            break;
+                    }
+                    return ApplicationDomain::NoSyncStatus;
+                }
+                if (notification.type == Notification::Progress) {
+                    return ApplicationDomain::SyncStatus::SyncInProgress;
+                }
+                return ApplicationDomain::NoSyncStatus;
+            }();
+
+            for (const auto id : idList) {
+                const auto oldStatus = mEntityStatus.value(id);
+                QVector<int> changedRoles;
+                if (oldStatus != newStatus) {
+                    SinkTraceCtx(mLogCtx) << "Status changed for entity:" << newStatus << ", id: " << id;
+                    mEntityStatus.insert(id, newStatus);
+                    changedRoles << StatusRole;
+                }
+
+                if (notification.type == Notification::Progress) {
+                    changedRoles << ProgressRole;
+                } else if (notification.type == Notification::Warning || notification.type == Notification::Error) {
+                    changedRoles << WarningRole;
+                }
+
+                if (!changedRoles.isEmpty()) {
+                    const auto idx = createIndexFromId(id);
+                    SinkTraceCtx(mLogCtx) << "Index changed:" << idx << changedRoles;
+                    //We don't emit the changedRoles because the consuming model likely remaps the role anyways and would then need to translate dataChanged signals as well.
+                    emit dataChanged(idx, idx);
+                }
+            }
+        });
+    }
 }
 
 template <class T, class Ptr>
@@ -60,7 +148,7 @@ qint64 ModelResult<T, Ptr>::parentId(const Ptr &value)
     if (!mQuery.parentProperty().isEmpty()) {
         const auto identifier = value->getProperty(mQuery.parentProperty()).toByteArray();
         if (!identifier.isEmpty()) {
-            return qHash(T(value->resourceInstanceIdentifier(), identifier, 0, QSharedPointer<Sink::ApplicationDomain::BufferAdaptor>()));
+            return getInternalIdentifer(value->resourceInstanceIdentifier(), identifier);
         }
     }
     return 0;
@@ -106,6 +194,13 @@ QVariant ModelResult<T, Ptr>::data(const QModelIndex &index, int role) const
     if (role == ChildrenFetchedRole) {
         return childrenFetched(index);
     }
+    if (role == StatusRole) {
+        auto it = mEntityStatus.constFind(index.internalId());
+        if (it != mEntityStatus.constEnd()) {
+            return *it;
+        }
+        return {};
+    }
     if (role == Qt::DisplayRole && index.isValid()) {
         if (index.column() < mPropertyColumns.size()) {
             Q_ASSERT(mEntities.contains(index.internalId()));
@@ -296,15 +391,15 @@ void ModelResult<T, Ptr>::setEmitter(const typename Sink::ResultEmitter<Ptr>::Pt
     emitter->onInitialResultSetComplete([this, guard](const Ptr &parent, bool fetchedAll) {
         SinkTraceCtx(mLogCtx) << "Initial result set complete. Fetched all: " << fetchedAll;
         Q_ASSERT(guard);
-        threadBoundary.callInMainThread([=]() {
-            const qint64 parentId = parent ? qHash(*parent) : 0;
-            const auto parentIndex = createIndexFromId(parentId);
-            mEntityChildrenFetchComplete.insert(parentId);
-            if (fetchedAll) {
-                mEntityAllChildrenFetched.insert(parentId);
-            }
-            emit dataChanged(parentIndex, parentIndex, QVector<int>() << ChildrenFetchedRole);
-        });
+        Q_ASSERT(QThread::currentThread() == this->thread());
+
+        const qint64 parentId = parent ? qHash(*parent) : 0;
+        const auto parentIndex = createIndexFromId(parentId);
+        mEntityChildrenFetchComplete.insert(parentId);
+        if (fetchedAll) {
+            mEntityAllChildrenFetched.insert(parentId);
+        }
+        emit dataChanged(parentIndex, parentIndex, QVector<int>() << ChildrenFetchedRole);
     });
     mEmitter = emitter;
 }