Track the entities that this request applies to directly in the

syncrequest

That way we can do the notification emitting in the synchronizer and it
keeps working even if the login already fails (so the synchronizing code
would never be executed).

3 files changed, 13 insertions, 14 deletions

diff --git a/common/synchronizer.cpp b/common/synchronizer.cpp
index ec896ed..329841b 100644
--- a/common/synchronizer.cpp
+++ b/common/synchronizer.cpp
@@ -329,7 +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());
+            emitNotification(Notification::Info, ApplicationDomain::SyncInProgress, {}, {}, request.applicableEntities);
         }).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();
@@ -337,12 +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::Warning, ApplicationDomain::SyncError, {}, {}, request.applicableEntities);
                 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::Info, ApplicationDomain::SyncSuccess, {}, {}, request.applicableEntities);
                 emitNotification(Notification::Status, ApplicationDomain::ConnectedStatus, "Synchronization has ended.", request.requestId);
                 return KAsync::null();
             }
diff --git a/common/synchronizer.h b/common/synchronizer.h
index e3dbddc..751542d 100644
--- a/common/synchronizer.h
+++ b/common/synchronizer.h
@@ -134,7 +134,8 @@ protected:
             : requestId(requestId_),
             requestType(Synchronization),
             options(o),
-            query(q)
+            query(q),
+            applicableEntities(q.ids())
         {
         }
 
@@ -155,6 +156,7 @@ protected:
         RequestType requestType;
         RequestOptions options = NoOptions;
         Sink::QueryBase query;
+        QByteArrayList applicableEntities;
     };
 
     /**
diff --git a/examples/imapresource/imapresource.cpp b/examples/imapresource/imapresource.cpp
index eef0de0..175f75a 100644
--- a/examples/imapresource/imapresource.cpp
+++ b/examples/imapresource/imapresource.cpp
@@ -382,7 +382,11 @@ public:
     {
         QList<Synchronizer::SyncRequest> list;
         if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Mail>()) {
-            list << Synchronizer::SyncRequest{applyMailDefaults(query)};
+            auto request = Synchronizer::SyncRequest{applyMailDefaults(query)};
+            if (query.hasFilter(ApplicationDomain::Mail::Folder::name)) {
+                request.applicableEntities << query.getFilter(ApplicationDomain::Mail::Folder::name).value.toByteArray();
+            }
+            list << request;
         } else if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Folder>()) {
             list << Synchronizer::SyncRequest{query};
         } else {
@@ -556,8 +560,6 @@ public:
                             SinkLog() << "Syncing folder " << folder.path();
                             //Emit notification that the folder is being synced.
                             //The synchronizer can't do that because it has no concept of the folder filter on a mail sync scope meaning that the folder is being synchronized.
-                            const auto folderLocalId = syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, folderRid(folder));
-                            emitNotification(Notification::Info, ApplicationDomain::SyncInProgress, {}, {}, {folderLocalId});
                             QDate dateFilter;
                             auto filter = query.getFilter<ApplicationDomain::Mail::Date>();
                             if (filter.value.canConvert<QDate>()) {
@@ -565,13 +567,8 @@ public:
                                 SinkLog() << " with date-range " << dateFilter;
                             }
                             return synchronizeFolder(imap, folder, dateFilter, syncHeaders)
-                                .then([=](const KAsync::Error &error) {
-                                    if (error) {
-                                        SinkWarning() << "Failed to sync folder: " << folder.path() << "Error: " << error.errorMessage;
-                                        emitNotification(Notification::Info, ApplicationDomain::SyncError, {}, {}, {folderLocalId});
-                                    } else {
-                                        emitNotification(Notification::Info, ApplicationDomain::SyncSuccess, {}, {}, {folderLocalId});
-                                    }
+                                .onError([=](const KAsync::Error &error) {
+                                    SinkWarning() << "Failed to sync folder: " << folder.path() << "Error: " << error.errorMessage;
                                 });
                         });
                     });