Prepared new query based synchronization API

3 files changed, 149 insertions, 42 deletions

diff --git a/examples/imapresource/imapresource.cpp b/examples/imapresource/imapresource.cpp
index d5a59b9..302d681 100644
--- a/examples/imapresource/imapresource.cpp
+++ b/examples/imapresource/imapresource.cpp
@@ -272,41 +272,102 @@ public:
 
     }
 
-    KAsync::Job<void> synchronizeWithSource(const Sink::QueryBase &query) Q_DECL_OVERRIDE
+    QList<Synchronizer::SyncRequest> getSyncRequests(const Sink::QueryBase &query) Q_DECL_OVERRIDE
     {
-        SinkLog() << " Synchronizing";
-        return KAsync::start<void>([this]() {
-            SinkTrace() << "Connecting to:" << mServer << mPort;
-            SinkTrace() << "as:" << mUser;
-            auto imap = QSharedPointer<ImapServerProxy>::create(mServer, mPort);
+        QList<Synchronizer::SyncRequest> list;
+        if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Mail>()) {
+            list << Synchronizer::SyncRequest{query};
+        } else if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Folder>()) {
+            list << Synchronizer::SyncRequest{query};
+        } else {
+            list << Synchronizer::SyncRequest{Sink::QueryBase(ApplicationDomain::getTypeName<ApplicationDomain::Folder>())};
+            list << Synchronizer::SyncRequest{Sink::QueryBase(ApplicationDomain::getTypeName<ApplicationDomain::Mail>())};
+        }
+        return list;
+    }
 
-            return imap->login(mUser, mPassword)
-            .addToContext(imap)
-            .onError([](const KAsync::Error &error) {
-                SinkWarning() << "Login failed.";
-            })
-            .then<QVector<Folder>>([this, imap]() {
-                auto folderList = QSharedPointer<QVector<Folder>>::create();
-                SinkLog() << "Login was successful";
-                return  imap->fetchFolders([folderList](const Folder &folder) {
-                    *folderList << folder;
-                })
-                .onError([](const KAsync::Error &error) {
-                    SinkWarning() << "Folder list sync failed.";
+    KAsync::Job<void> login(QSharedPointer<ImapServerProxy> imap)
+    {
+        SinkTrace() << "Connecting to:" << mServer << mPort;
+        SinkTrace() << "as:" << mUser;
+        return imap->login(mUser, mPassword)
+        .addToContext(imap)
+        .onError([](const KAsync::Error &error) {
+            SinkWarning() << "Login failed.";
+        });
+    }
+
+    KAsync::Job<void> synchronizeWithSource(const Sink::QueryBase &query) Q_DECL_OVERRIDE
+    {
+        if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Folder>()) {
+            return KAsync::start<void>([this]() {
+                auto imap = QSharedPointer<ImapServerProxy>::create(mServer, mPort);
+                auto job = login(imap);
+                job = job.then<QVector<Folder>>([this, imap]() {
+                    auto folderList = QSharedPointer<QVector<Folder>>::create();
+                    return  imap->fetchFolders([folderList](const Folder &folder) {
+                        *folderList << folder;
+                    })
+                    .onError([](const KAsync::Error &error) {
+                        SinkWarning() << "Folder list sync failed.";
+                    })
+                    .syncThen<QVector<Folder>>([this, folderList]() {
+                        synchronizeFolders(*folderList);
+                        commit();
+                        return *folderList;
+                    });
+                });
+                return job;
+            });
+        } else if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Mail>()) {
+            //TODO
+            //if we have a folder filter:
+            //* execute the folder query and resolve the results to the remote identifier
+            //* query only those folders
+            //if we have a date filter:
+            //* apply the date filter to the fetch
+            //if we have no folder filter:
+            //* fetch list of folders from server directly and sync (because we have no guarantee that the folder sync was already processed by the pipeline).
+            return KAsync::start<void>([this, query]() {
+                auto imap = QSharedPointer<ImapServerProxy>::create(mServer, mPort);
+                auto job = login(imap);
+                job = job.then<QVector<Folder>>([this, imap, query]() {
+                    SinkLog() << "Login was successful";
+                    //FIXME If we were able to to flush in between we could just query the local store for the folder list.
+                    //
+                    if (query.hasFilter<ApplicationDomain::Mail::Folder>()) {
+                        QVector<Folder> folders;
+                        auto folderFilter = query.getFilter<ApplicationDomain::Mail::Folder>();
+                        auto localIds = resolveFilter(folderFilter);
+                        auto folderRemoteIds = syncStore().resolveLocalIds(ApplicationDomain::getTypeName<ApplicationDomain::Folder>(), localIds);
+                        for (const auto &r : folderRemoteIds) {
+                            folders << Folder{r};
+                        }
+                        return KAsync::value(folders);
+                    } else {
+                        auto folderList = QSharedPointer<QVector<Folder>>::create();
+                        return  imap->fetchFolders([folderList](const Folder &folder) {
+                            *folderList << folder;
+                        })
+                        .onError([](const KAsync::Error &error) {
+                            SinkWarning() << "Folder list sync failed.";
+                        })
+                        .syncThen<QVector<Folder>>([this, folderList]() {
+                            return *folderList;
+                        });
+                    }
                 })
-                .syncThen<QVector<Folder>>([this, folderList]() {
-                    synchronizeFolders(*folderList);
-                    commit();
-                    return *folderList;
+                .serialEach<void>([this, imap](const Folder &folder) {
+                    if (folder.noselect) {
+                        return KAsync::null<void>();
+                    }
+                    return synchronizeFolder(imap, folder);
                 });
-            })
-            .serialEach<void>([this, imap](const Folder &folder) {
-                if (folder.noselect) {
-                    return KAsync::null<void>();
-                }
-                return synchronizeFolder(imap, folder);
+
+                return job;
             });
-        });
+        }
+        return KAsync::error<void>("Nothing to do");
     }
 
 public:
diff --git a/examples/imapresource/imapserverproxy.h b/examples/imapresource/imapserverproxy.h
index 8b39f23..6e6626e 100644
--- a/examples/imapresource/imapserverproxy.h
+++ b/examples/imapresource/imapserverproxy.h
@@ -58,6 +58,20 @@ struct Message {
 };
 
 struct Folder {
+    Folder() = default;
+    Folder(QList<QString> pathParts_, const QString &path_, const QChar &separator_, bool noselect_)
+        : pathParts(pathParts_),
+        path(path_),
+        separator(separator_),
+        noselect(noselect_)
+    {
+    }
+
+    Folder(const QString &path_)
+        : path(path_)
+    {
+    }
+
     QString normalizedPath() const
     {
         return pathParts.join('/');
@@ -73,7 +87,7 @@ struct Folder {
     QList<QString> pathParts;
     QString path;
     QChar separator;
-    bool noselect;
+    bool noselect = false;
 };
 
 struct SelectResult {
diff --git a/examples/maildirresource/maildirresource.cpp b/examples/maildirresource/maildirresource.cpp
index 820ec2f..fc77315 100644
--- a/examples/maildirresource/maildirresource.cpp
+++ b/examples/maildirresource/maildirresource.cpp
@@ -330,25 +330,57 @@ public:
         SinkLog() << "Synchronized " << count << " mails in " << listingPath << Sink::Log::TraceTime(elapsed) << " " << elapsed/qMax(count, 1) << " [ms/mail]";
     }
 
+    QList<Synchronizer::SyncRequest> getSyncRequests(const Sink::QueryBase &query) Q_DECL_OVERRIDE
+    {
+        QList<Synchronizer::SyncRequest> list;
+        if (!query.type().isEmpty()) {
+            //We want to synchronize something specific
+            list << Synchronizer::SyncRequest{query};
+        } else {
+            //We want to synchronize everything
+            list << Synchronizer::SyncRequest{Sink::QueryBase(ApplicationDomain::getTypeName<ApplicationDomain::Folder>())};
+            //FIXME we can't process the second synchronization before the pipeline of the first one is processed, otherwise we can't execute a query on the local data.
+            /* list << Synchronizer::SyncRequest{Flush}; */
+            list << Synchronizer::SyncRequest{Sink::QueryBase(ApplicationDomain::getTypeName<ApplicationDomain::Mail>())};
+        }
+        return list;
+    }
+
     KAsync::Job<void> synchronizeWithSource(const Sink::QueryBase &query) Q_DECL_OVERRIDE
     {
-        SinkLog() << " Synchronizing";
-        return KAsync::start<void>([this]() {
+        auto job = KAsync::start<void>([this] {
             KPIM::Maildir maildir(mMaildirPath, true);
             if (!maildir.isValid(false)) {
                 return KAsync::error<void>(1, "Maildir path doesn't point to a valid maildir: " + mMaildirPath);
             }
-            synchronizeFolders();
-            //The next sync needs the folders available
-            commit();
-            for (const auto &folder : listAvailableFolders()) {
-                synchronizeMails(folder);
-                //Don't let the transaction grow too much
-                commit();
-            }
-            SinkLog() << "Done Synchronizing";
             return KAsync::null<void>();
         });
+
+        if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Folder>()) {
+            job = job.syncThen<void>([this] {
+                synchronizeFolders();
+            });
+        } else if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Mail>()) {
+            job = job.syncThen<void>([this, query] {
+                QStringList folders;
+                if (query.hasFilter<ApplicationDomain::Mail::Folder>()) {
+                    auto folderFilter = query.getFilter<ApplicationDomain::Mail::Folder>();
+                    auto localIds = resolveFilter(folderFilter);
+                    auto folderRemoteIds = syncStore().resolveLocalIds(ApplicationDomain::getTypeName<ApplicationDomain::Folder>(), localIds);
+                    for (const auto &r : folderRemoteIds) {
+                        folders << r;
+                    }
+                } else {
+                    folders = listAvailableFolders();
+                }
+                for (const auto &folder : folders) {
+                    synchronizeMails(folder);
+                    //Don't let the transaction grow too much
+                    commit();
+                }
+            });
+        }
+        return job;
     }
 
 public: