12 files changed, 161 insertions, 30 deletions

diff --git a/common/commands/notification.fbs b/common/commands/notification.fbs
index c82fad3..517111c 100644
--- a/common/commands/notification.fbs
+++ b/common/commands/notification.fbs
@@ -2,9 +2,10 @@ namespace Sink.Commands;
 
 table Notification {
     type: int = 0; //See notification.h
-    identifier: string; //An identifier that links back to the something related to the notification (e.g. an entity id or a command id)
+    identifier: string; //An identifier that links back to the something related to the notification (e.g. a command id)
     message: string;
     code: int = 0; //See notification.h
+    entities: [string]; //A list of entities this applies to
 }
 
 root_type Notification;
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index ef38d58..6fd2b90 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -93,7 +93,7 @@
 namespace Sink {
 namespace ApplicationDomain {
 
-enum ErrorCode {
+enum SINK_EXPORT ErrorCode {
     NoError = 0,
     UnknownError,
     NoServerError,
@@ -101,10 +101,33 @@ enum ErrorCode {
     TransmissionError,
 };
 
-enum SuccessCode {
+enum SINK_EXPORT SuccessCode {
     TransmissionSuccess
 };
 
+enum SINK_EXPORT SyncStatus {
+    NoSyncStatus,
+    SyncInProgress,
+    SyncError,
+    SyncSuccess
+};
+
+/**
+ * The status of an account or resource.
+ *
+ * It is set as follows:
+ * * By default the status is offline.
+ * * If a connection to the server could be established the status is Connected.
+ * * If an error occurred that keeps the resource from operating (so non transient), the resource enters the error state.
+ * * If a long running operation is started the resource goes to the busy state (and return to the previous state after that).
+ */
+enum SINK_EXPORT Status {
+    OfflineStatus,
+    ConnectedStatus,
+    BusyStatus,
+    ErrorStatus
+};
+
 struct SINK_EXPORT Error {
 
 };
@@ -113,6 +136,11 @@ struct SINK_EXPORT Progress {
 
 };
 
+/**
+ * Internal type.
+ *
+ * Represents a BLOB property.
+ */
 struct BLOB {
     BLOB() = default;
     BLOB(const BLOB &) = default;
@@ -410,22 +438,6 @@ struct SINK_EXPORT Mail : public Entity {
 
 SINK_EXPORT QDebug operator<< (QDebug d, const Mail::Contact &c);
 
-/**
- * The status of an account or resource.
- *
- * It is set as follows:
- * * By default the status is offline.
- * * If a connection to the server could be established the status is Connected.
- * * If an error occurred that keeps the resource from operating (so non transient), the resource enters the error state.
- * * If a long running operation is started the resource goes to the busy state (and return to the previous state after that).
- */
-enum SINK_EXPORT Status {
-    OfflineStatus,
-    ConnectedStatus,
-    BusyStatus,
-    ErrorStatus
-};
-
 struct SINK_EXPORT Identity : public ApplicationDomainType {
     static constexpr const char *name = "identity";
     typedef QSharedPointer<Identity> Ptr;
diff --git a/common/listener.cpp b/common/listener.cpp
index f18fe1d..96806ad 100644
--- a/common/listener.cpp
+++ b/common/listener.cpp
@@ -25,6 +25,7 @@
 #include "common/definitions.h"
 #include "common/resourcecontext.h"
 #include "common/adaptorfactoryregistry.h"
+#include "common/bufferutils.h"
 
 // commands
 #include "common/commandcompletion_generated.h"
@@ -406,11 +407,13 @@ void Listener::notify(const Sink::Notification &notification)
 {
     auto messageString = m_fbb.CreateString(notification.message.toUtf8().constData(), notification.message.toUtf8().size());
     auto idString = m_fbb.CreateString(notification.id.constData(), notification.id.size());
+    auto entities = Sink::BufferUtils::toVector(m_fbb, notification.entities);
     Sink::Commands::NotificationBuilder builder(m_fbb);
     builder.add_type(notification.type);
     builder.add_code(notification.code);
     builder.add_identifier(idString);
     builder.add_message(messageString);
+    builder.add_entities(entities);
     auto command = builder.Finish();
     Sink::Commands::FinishNotificationBuffer(m_fbb, command);
     for (Client &client : m_connections) {
diff --git a/common/modelresult.cpp b/common/modelresult.cpp
index 904766d..3edbec7 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,79 @@ 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)) {
+        mNotifier.reset(new Sink::Notifier{query});
+        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) {
+                    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;
+                }
+
+                const auto idx = createIndexFromId(id);
+                emit dataChanged(idx, idx, changedRoles);
+            }
+        });
+    }
 }
 
 template <class T, class Ptr>
@@ -60,7 +141,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 +187,9 @@ QVariant ModelResult<T, Ptr>::data(const QModelIndex &index, int role) const
     if (role == ChildrenFetchedRole) {
         return childrenFetched(index);
     }
+    if (role == StatusRole) {
+        return mEntityStatus.value(index.internalId());
+    }
     if (role == Qt::DisplayRole && index.isValid()) {
         if (index.column() < mPropertyColumns.size()) {
             Q_ASSERT(mEntities.contains(index.internalId()));
diff --git a/common/modelresult.h b/common/modelresult.h
index f30a8e1..cc263cf 100644
--- a/common/modelresult.h
+++ b/common/modelresult.h
@@ -30,15 +30,23 @@
 #include "resultprovider.h"
 #include "threadboundary.h"
 
+namespace Sink {
+class Notifier;
+}
+
 template <class T, class Ptr>
 class ModelResult : public QAbstractItemModel
 {
 public:
+    //Update the copy in store.h as well if you modify this
     enum Roles
     {
         DomainObjectRole = Qt::UserRole + 1,
         ChildrenFetchedRole,
-        DomainObjectBaseRole
+        DomainObjectBaseRole,
+        StatusRole, //ApplicationDomain::SyncStatus
+        WarningRole, //ApplicationDomain::Warning, only if status == warning || status == error
+        ProgressRole //ApplicationDomain::Progress
     };
 
     ModelResult(const Sink::Query &query, const QList<QByteArray> &propertyColumns, const Sink::Log::Context &);
@@ -77,9 +85,11 @@ private:
     QSet<qint64 /* entity id */> mEntityChildrenFetched;
     QSet<qint64 /* entity id */> mEntityChildrenFetchComplete;
     QSet<qint64 /* entity id */> mEntityAllChildrenFetched;
+    QMap<qint64 /* entity id */, int /* Status */> mEntityStatus;
     QList<QByteArray> mPropertyColumns;
     Sink::Query mQuery;
     std::function<void(const Ptr &)> loadEntities;
     typename Sink::ResultEmitter<Ptr>::Ptr mEmitter;
     async::ThreadBoundary threadBoundary;
+    QScopedPointer<Sink::Notifier> mNotifier;
 };
diff --git a/common/notification.cpp b/common/notification.cpp
index b399d50..806d04a 100644
--- a/common/notification.cpp
+++ b/common/notification.cpp
@@ -21,6 +21,6 @@
 
 QDebug operator<<(QDebug dbg, const Sink::Notification &n)
 {
-    dbg << "Notification(Id: " << n.id << ", Type: " << n.type  << ", Code: " << n.code << ", Message: " << n.message << ")";
+    dbg << "Notification(Type: " << n.type << "Id, : " << n.id  << ", Code: " << n.code << ", Message: " << n.message << ", Entities: " << n.entities << ")";
     return dbg.space();
 }
diff --git a/common/notification.h b/common/notification.h
index 4b52274..f5379fd 100644
--- a/common/notification.h
+++ b/common/notification.h
@@ -51,6 +51,7 @@ public:
     };
 
     QByteArray id;
+    QByteArrayList entities;
     int type = 0;
     QString message;
     //A return code. Zero typically indicates success.
diff --git a/common/query.h b/common/query.h
index 49c8d5e..5b37cdd 100644
--- a/common/query.h
+++ b/common/query.h
@@ -300,7 +300,9 @@ public:
         /** Leave the query running and continuously update the result set. */
         LiveQuery = 1,
         /** Run the query synchronously. */
-        SynchronousQuery = 2
+        SynchronousQuery = 2,
+        /** Include status updates via notifications */
+        UpdateStatus = 4
     };
     Q_DECLARE_FLAGS(Flags, Flag)
 
@@ -410,6 +412,11 @@ public:
         mFlags = flags;
     }
 
+    Flags flags() const
+    {
+        return mFlags;
+    }
+
     bool liveQuery() const
     {
         return mFlags.testFlag(LiveQuery);
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index e48b624..9f4f14c 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -547,6 +547,7 @@ static Sink::Notification getNotification(const Sink::Commands::Notification *bu
     }
     n.type = buffer->type();
     n.code = buffer->code();
+    n.entities = BufferUtils::fromVector(*buffer->entities());
     return n;
 }
 
@@ -608,13 +609,17 @@ bool ResourceAccess::processMessageBuffer()
                     mResourceStatus = buffer->code();
                     SinkTrace() << "Updated status: " << mResourceStatus;
                     [[clang::fallthrough]];
+                case Sink::Notification::Info:
+                    [[clang::fallthrough]];
                 case Sink::Notification::Warning:
                     [[clang::fallthrough]];
+                case Sink::Notification::Error:
+                    [[clang::fallthrough]];
                 case Sink::Notification::FlushCompletion:
                     [[clang::fallthrough]];
                 case Sink::Notification::Progress: {
                     auto n = getNotification(buffer);
-                    SinkTrace() << "Received notification: Type:" << n.type  << "Message: " << n.message << "Code: " << n.code;
+                    SinkTrace() << "Received notification: " << n;
                     n.resource = d->resourceInstanceIdentifier;
                     emit notification(n);
                 } break;
diff --git a/common/store.h b/common/store.h
index 86e4d20..fae76e5 100644
--- a/common/store.h
+++ b/common/store.h
@@ -48,11 +48,15 @@ QString SINK_EXPORT storageLocation();
  */
 QString SINK_EXPORT getTemporaryFilePath();
 
+// Must be the same as in ModelResult
 enum Roles
 {
-    DomainObjectRole = Qt::UserRole + 1, // Must be the same as in ModelResult
+    DomainObjectRole = Qt::UserRole + 1,
     ChildrenFetchedRole,
-    DomainObjectBaseRole
+    DomainObjectBaseRole,
+    StatusRole, //ApplicationDomain::SyncStatus
+    WarningRole, //ApplicationDomain::Warning, only if status == warning || status == error
+    ProgressRole //ApplicationDomain::Progress
 };
 
 /**
diff --git a/common/synchronizer.cpp b/common/synchronizer.cpp
index 4ed6e3a..ec896ed 100644
--- a/common/synchronizer.cpp
+++ b/common/synchronizer.cpp
@@ -292,13 +292,14 @@ void Synchronizer::flushComplete(const QByteArray &flushId)
     }
 }
 
-void Synchronizer::emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id)
+void Synchronizer::emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id, const QByteArrayList &entities)
 {
     Sink::Notification n;
     n.id = id;
     n.type = type;
     n.message = message;
     n.code = code;
+    n.entities = entities;
     emit notify(n);
 }
 
@@ -328,6 +329,7 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
         return KAsync::start([this, request] {
             SinkLogCtx(mLogCtx) << "Synchronizing: " << request.query;
             emitNotification(Notification::Status, ApplicationDomain::BusyStatus, "Synchronization has started.", request.requestId);
+            emitNotification(Notification::Info, ApplicationDomain::SyncInProgress, {}, {}, request.query.ids());
         }).then(synchronizeWithSource(request.query)).then([this] {
             //Commit after every request, so implementations only have to commit more if they add a lot of data.
             commit();
@@ -335,10 +337,12 @@ KAsync::Job<void> Synchronizer::processRequest(const SyncRequest &request)
             if (error) {
                 //Emit notification with error
                 SinkWarningCtx(mLogCtx) << "Synchronization failed: " << error.errorMessage;
+                emitNotification(Notification::Warning, ApplicationDomain::SyncError, {}, {}, request.query.ids());
                 emitNotification(Notification::Status, ApplicationDomain::ErrorStatus, "Synchronization has ended.", request.requestId);
                 return KAsync::error(error);
             } else {
                 SinkLogCtx(mLogCtx) << "Done Synchronizing";
+                emitNotification(Notification::Info, ApplicationDomain::SyncSuccess, {}, {}, request.query.ids());
                 emitNotification(Notification::Status, ApplicationDomain::ConnectedStatus, "Synchronization has ended.", request.requestId);
                 return KAsync::null();
             }
diff --git a/common/synchronizer.h b/common/synchronizer.h
index 28fe645..e3dbddc 100644
--- a/common/synchronizer.h
+++ b/common/synchronizer.h
@@ -180,7 +180,7 @@ protected:
      */
     virtual void mergeIntoQueue(const Synchronizer::SyncRequest &request, QList<Synchronizer::SyncRequest> &queue);
 
-    void emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id = QByteArray{});
+    void emitNotification(Notification::NoticationType type, int code, const QString &message, const QByteArray &id = QByteArray{}, const QByteArrayList &entiteis = QByteArrayList{});
 
 protected:
     Sink::Log::Context mLogCtx;