1 files changed, 140 insertions, 1 deletions

diff --git a/common/clientapi.cpp b/common/clientapi.cpp
index e7ca99d..824ef19 100644
--- a/common/clientapi.cpp
+++ b/common/clientapi.cpp
@@ -25,6 +25,7 @@
 #include <QEventLoop>
 #include <QAbstractItemModel>
 #include <QDir>
+#include <QUuid>
 #include <functional>
 #include <memory>
 
@@ -204,7 +205,7 @@ KAsync::Job<void> Store::synchronize(const Akonadi2::Query &query)
         Trace() << "Synchronizing " << resource;
         auto resourceAccess = QSharedPointer<Akonadi2::ResourceAccess>::create(resource);
         resourceAccess->open();
-        resourceAccess->synchronizeResource(query.syncOnDemand, query.processAll).then<void>([&future, resourceAccess]() {
+        resourceAccess->synchronizeResource(true, false).then<void>([&future, resourceAccess]() {
             future.setFinished();
         }).exec();
     })
@@ -212,10 +213,148 @@ KAsync::Job<void> Store::synchronize(const Akonadi2::Query &query)
     .template then<void>([](){});
 }
 
+KAsync::Job<void> Store::flushMessageQueue(const QByteArrayList &resourceIdentifier)
+{
+    Trace() << "flushMessageQueue" << resourceIdentifier;
+    return KAsync::iterate(resourceIdentifier)
+    .template each<void, QByteArray>([](const QByteArray &resource, KAsync::Future<void> &future) {
+        Trace() << "Flushing message queue " << resource;
+        auto resourceAccess = QSharedPointer<Akonadi2::ResourceAccess>::create(resource);
+        resourceAccess->open();
+        resourceAccess->synchronizeResource(false, true).then<void>([&future, resourceAccess]() {
+            future.setFinished();
+        }).exec();
+    })
+    //FIXME JOBAPI this is only required because we don't care about the return value of each (and each shouldn't even have a return value)
+    .template then<void>([](){});
+}
+
+KAsync::Job<void> Store::flushReplayQueue(const QByteArrayList &resourceIdentifier)
+{
+    return flushMessageQueue(resourceIdentifier);
+}
+
+template <class DomainType>
+KAsync::Job<DomainType> Store::fetchOne(const Akonadi2::Query &query)
+{
+    return KAsync::start<DomainType>([query](KAsync::Future<DomainType> &future) {
+        //FIXME We could do this more elegantly if composed jobs would have the correct type (In that case we'd simply return the value from then continuation, and could avoid the outer job entirely)
+        fetch<DomainType>(query, 1)
+            .template then<void, QList<typename DomainType::Ptr> >([&future](const QList<typename DomainType::Ptr> &list){
+                future.setValue(*list.first());
+                future.setFinished();
+            }, [&future](int errorCode, const QString &errorMessage) {
+                future.setError(errorCode, errorMessage);
+                future.setFinished();
+            }).exec();
+    });
+}
+
+template <class DomainType>
+KAsync::Job<QList<typename DomainType::Ptr> > Store::fetchAll(const Akonadi2::Query &query)
+{
+    return fetch<DomainType>(query);
+}
+
+template <class DomainType>
+KAsync::Job<QList<typename DomainType::Ptr> > Store::fetch(const Akonadi2::Query &query, int minimumAmount)
+{
+    auto model = loadModel<DomainType>(query);
+    auto list = QSharedPointer<QList<typename DomainType::Ptr> >::create();
+    auto context = QSharedPointer<QObject>::create();
+    return KAsync::start<QList<typename DomainType::Ptr> >([model, list, context, minimumAmount](KAsync::Future<QList<typename DomainType::Ptr> > &future) {
+        if (model->rowCount() >= 1) {
+            for (int i = 0; i < model->rowCount(); i++) {
+                list->append(model->index(i, 0, QModelIndex()).data(Akonadi2::Store::DomainObjectRole).template value<typename DomainType::Ptr>());
+            }
+        } else {
+            QObject::connect(model.data(), &QAbstractItemModel::rowsInserted, context.data(), [model, &future, list](const QModelIndex &index, int start, int end) {
+                for (int i = start; i <= end; i++) {
+                    list->append(model->index(i, 0, QModelIndex()).data(Akonadi2::Store::DomainObjectRole).template value<typename DomainType::Ptr>());
+                }
+            });
+            QObject::connect(model.data(), &QAbstractItemModel::dataChanged, context.data(), [model, &future, list, minimumAmount](const QModelIndex &, const QModelIndex &, const QVector<int> &roles) {
+                if (roles.contains(ModelResult<DomainType, typename DomainType::Ptr>::ChildrenFetchedRole)) {
+                    if (list->size() < minimumAmount) {
+                        future.setError(1, "Not enough values.");
+                    } else {
+                        future.setValue(*list);
+                    }
+                    future.setFinished();
+                }
+            });
+        }
+        if (model->data(QModelIndex(), ModelResult<DomainType, typename DomainType::Ptr>::ChildrenFetchedRole).toBool()) {
+            if (list->size() < minimumAmount) {
+                future.setError(1, "Not enough values.");
+            } else {
+                future.setValue(*list);
+            }
+            future.setFinished();
+        }
+    });
+}
+
+template <class DomainType>
+KAsync::Job<void> Resources::inspect(const Inspection &inspectionCommand)
+{
+    auto resource = inspectionCommand.resourceIdentifier;
+
+    Trace() << "Sending inspection " << resource;
+    auto resourceAccess = QSharedPointer<Akonadi2::ResourceAccess>::create(resource);
+    resourceAccess->open();
+    auto notifier = QSharedPointer<Akonadi2::Notifier>::create(resourceAccess);
+    auto id = QUuid::createUuid().toByteArray();
+    return resourceAccess->sendInspectionCommand(id, ApplicationDomain::getTypeName<DomainType>(), inspectionCommand.entityIdentifier, inspectionCommand.property, inspectionCommand.expectedValue)
+        .template then<void>([resourceAccess, notifier, id](KAsync::Future<void> &future) {
+            notifier->registerHandler([&future, id](const Notification &notification) {
+                if (notification.id == id) {
+                    if (notification.code) {
+                        future.setError(-1, "Inspection returned an error: " + notification.message);
+                    } else {
+                        future.setFinished();
+                    }
+                }
+            });
+        });
+}
+
+class Akonadi2::Notifier::Private {
+public:
+    Private()
+        : context(new QObject)
+    {
+
+    }
+    QList<QSharedPointer<ResourceAccess> > resourceAccess;
+    QList<std::function<void(const Notification &)> > handler;
+    QSharedPointer<QObject> context;
+};
+
+Notifier::Notifier(const QSharedPointer<ResourceAccess> &resourceAccess)
+    : d(new Akonadi2::Notifier::Private)
+{
+    QObject::connect(resourceAccess.data(), &ResourceAccess::notification, d->context.data(), [this](const Notification &notification) {
+        for (const auto &handler : d->handler) {
+            handler(notification);
+        }
+    });
+    d->resourceAccess << resourceAccess;
+}
+
+void Notifier::registerHandler(std::function<void(const Notification &)> handler)
+{
+    d->handler << handler;
+}
+
 #define REGISTER_TYPE(T) template KAsync::Job<void> Store::remove<T>(const T &domainObject); \
     template KAsync::Job<void> Store::create<T>(const T &domainObject); \
     template KAsync::Job<void> Store::modify<T>(const T &domainObject); \
     template QSharedPointer<QAbstractItemModel> Store::loadModel<T>(Query query); \
+    template KAsync::Job<void> Resources::inspect<T>(const Inspection &); \
+    template KAsync::Job<T> Store::fetchOne<T>(const Query &); \
+    template KAsync::Job<QList<T::Ptr> > Store::fetchAll<T>(const Query &); \
+    template KAsync::Job<QList<T::Ptr> > Store::fetch<T>(const Query &, int); \
 
 REGISTER_TYPE(ApplicationDomain::Event);
 REGISTER_TYPE(ApplicationDomain::Mail);