Load entities from multiple resources

4 files changed, 117 insertions, 25 deletions

diff --git a/common/clientapi.cpp b/common/clientapi.cpp
index 644d60c..46f7534 100644
--- a/common/clientapi.cpp
+++ b/common/clientapi.cpp
@@ -98,22 +98,24 @@ QSharedPointer<QAbstractItemModel> Store::loadModel(Query query)
         resultProvider->initialResultSetComplete(typename DomainType::Ptr());
         return model;
     }
+    auto aggregatingEmitter = AggregatingResultEmitter<typename DomainType::Ptr>::Ptr::create();
+    model->setEmitter(aggregatingEmitter);
     KAsync::iterate(resources)
-    .template each<void, QByteArray>([query, model](const QByteArray &resource, KAsync::Future<void> &future) {
+    .template each<void, QByteArray>([query, aggregatingEmitter](const QByteArray &resource, KAsync::Future<void> &future) {
         auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceName(resource), resource);
         if (facade) {
-            Trace() << "Trying to fetch from resource";
+            Trace() << "Trying to fetch from resource " << resource;
             auto result = facade->load(query);
-            auto emitter = result.second;
-            //TODO use aggregating emitter instead
-            model->setEmitter(emitter);
-            model->fetchMore(QModelIndex());
+            aggregatingEmitter->addEmitter(result.second);
             result.first.template then<void>([&future](){future.setFinished();}).exec();
         } else {
+            Trace() << "Couldn' find a facade for " << resource;
             //Ignore the error and carry on
             future.setFinished();
         }
     }).exec();
+    //TODO if the aggregatingEmitter is still empty we're done
+    model->fetchMore(QModelIndex());
 
     return model;
 }
diff --git a/common/modelresult.cpp b/common/modelresult.cpp
index d18dba1..690a17e 100644
--- a/common/modelresult.cpp
+++ b/common/modelresult.cpp
@@ -24,6 +24,13 @@
 #include "domain/folder.h"
 #include "log.h"
 
+static  uint qHash(const Akonadi2::ApplicationDomain::ApplicationDomainType &type)
+{
+    Q_ASSERT(!type.resourceInstanceIdentifier().isEmpty());
+    Q_ASSERT(!type.identifier().isEmpty());
+    return qHash(type.resourceInstanceIdentifier() + type.identifier());
+}
+
 template<class T, class Ptr>
 ModelResult<T, Ptr>::ModelResult(const Akonadi2::Query &query, const QList<QByteArray> &propertyColumns)
     :QAbstractItemModel(),
@@ -44,9 +51,9 @@ template<class T, class Ptr>
 qint64 ModelResult<T, Ptr>::parentId(const Ptr &value)
 {
     if (!mQuery.parentProperty.isEmpty()) {
-        const auto property = value->getProperty(mQuery.parentProperty).toByteArray();
-        if (!property.isEmpty()) {
-            return qHash(property);
+        const auto identifier = value->getProperty(mQuery.parentProperty).toByteArray();
+        if (!identifier.isEmpty()) {
+            return qHash(T(value->resourceInstanceIdentifier(), identifier, 0, QSharedPointer<Akonadi2::ApplicationDomain::BufferAdaptor>()));
         }
     }
     return 0;
@@ -152,7 +159,7 @@ void ModelResult<T, Ptr>::fetchMore(const QModelIndex &parent)
 template<class T, class Ptr>
 void ModelResult<T, Ptr>::add(const Ptr &value)
 {
-    const auto childId = qHash(value->identifier());
+    const auto childId = qHash(*value);
     const auto id = parentId(value);
     //Ignore updates we get before the initial fetch is done
     if (!mEntityChildrenFetched.contains(id)) {
@@ -184,11 +191,11 @@ void ModelResult<T, Ptr>::add(const Ptr &value)
 template<class T, class Ptr>
 void ModelResult<T, Ptr>::remove(const Ptr &value)
 {
-    auto childId = qHash(value->identifier());
+    auto childId = qHash(*value);
     auto id = parentId(value);
     auto parent = createIndexFromId(id);
     // qDebug() << "Removed entity" << childId;
-    auto index = mTree[id].indexOf(qHash(value->identifier()));
+    auto index = mTree[id].indexOf(childId);
     beginRemoveRows(parent, index, index);
     mEntities.remove(childId);
     mTree[id].removeAll(childId);
@@ -202,7 +209,7 @@ void ModelResult<T, Ptr>::fetchEntities(const QModelIndex &parent)
 {
     const auto id = getIdentifier(parent);
     mEntityChildrenFetched.insert(id);
-    Trace() << "Loading child entities";
+    Trace() << "Loading child entities of parent " << id;
     if (loadEntities) {
         loadEntities(parent.data(DomainObjectRole).template value<Ptr>());
     } else {
@@ -220,7 +227,7 @@ void ModelResult<T, Ptr>::setFetcher(const std::function<void(const Ptr &parent)
 template<class T, class Ptr>
 void ModelResult<T, Ptr>::setEmitter(const typename Akonadi2::ResultEmitter<Ptr>::Ptr &emitter)
 {
-    setFetcher(emitter->mFetcher);
+    setFetcher([this](const Ptr &parent) {mEmitter->fetch(parent);});
     emitter->onAdded([this](const Ptr &value) {
         this->add(value);
     });
@@ -231,7 +238,7 @@ void ModelResult<T, Ptr>::setEmitter(const typename Akonadi2::ResultEmitter<Ptr>
         this->remove(value);
     });
     emitter->onInitialResultSetComplete([this](const Ptr &parent) {
-        const qint64 parentId = parent ? qHash(parent->identifier()) : 0;
+        const qint64 parentId = parent ? qHash(*parent) : 0;
         const auto parentIndex = createIndexFromId(parentId);
         mEntityChildrenFetchComplete.insert(parentId);
         emit dataChanged(parentIndex, parentIndex, QVector<int>() << ChildrenFetchedRole);
@@ -248,7 +255,7 @@ bool ModelResult<T, Ptr>::childrenFetched(const QModelIndex &index) const
 template<class T, class Ptr>
 void ModelResult<T, Ptr>::modify(const Ptr &value)
 {
-    auto childId = qHash(value->identifier());
+    auto childId = qHash(*value);
     auto id = parentId(value);
     //Ignore updates we get before the initial fetch is done
     if (!mEntityChildrenFetched.contains(id)) {
diff --git a/common/resultprovider.h b/common/resultprovider.h
index d50f3f6..d94ad44 100644
--- a/common/resultprovider.h
+++ b/common/resultprovider.h
@@ -235,6 +235,11 @@ class ResultEmitter {
 public:
     typedef QSharedPointer<ResultEmitter<DomainType> > Ptr;
 
+    virtual ~ResultEmitter()
+    {
+
+    }
+
     void onAdded(const std::function<void(const DomainType&)> &handler)
     {
         addHandler = handler;
@@ -306,7 +311,12 @@ public:
         mFetcher = fetcher;
     }
 
-    std::function<void(const DomainType &parent)> mFetcher;
+    virtual void fetch(const DomainType &parent)
+    {
+        if (mFetcher) {
+            mFetcher(parent);
+        }
+    }
 
 private:
     friend class ResultProvider<DomainType>;
@@ -317,8 +327,51 @@ private:
     std::function<void(const DomainType&)> initialResultSetCompleteHandler;
     std::function<void(void)> completeHandler;
     std::function<void(void)> clearHandler;
+
+    std::function<void(const DomainType &parent)> mFetcher;
     ThreadBoundary mThreadBoundary;
 };
 
+template<class DomainType>
+class AggregatingResultEmitter : public ResultEmitter<DomainType> {
+public:
+    typedef QSharedPointer<AggregatingResultEmitter<DomainType> > Ptr;
+
+    void addEmitter(const typename ResultEmitter<DomainType>::Ptr &emitter)
+    {
+        emitter->onAdded([this](const DomainType &value) {
+            this->add(value);
+        });
+        emitter->onModified([this](const DomainType &value) {
+            this->modify(value);
+        });
+        emitter->onRemoved([this](const DomainType &value) {
+            this->remove(value);
+        });
+        emitter->onInitialResultSetComplete([this](const DomainType &value) {
+            this->initialResultSetComplete(value);
+        });
+        emitter->onComplete([this]() {
+            this->complete();
+        });
+        emitter->onClear([this]() {
+            this->clear();
+        });
+        mEmitter << emitter;
+    }
+
+    void fetch(const DomainType &parent) Q_DECL_OVERRIDE
+    {
+        for (const auto &emitter : mEmitter) {
+            emitter->fetch(parent);
+        }
+    }
+
+private:
+    QList<typename ResultEmitter<DomainType>::Ptr> mEmitter;
+};
+
+
+
 }
 
diff --git a/tests/clientapitest.cpp b/tests/clientapitest.cpp
index 8f956ab..5777e68 100644
--- a/tests/clientapitest.cpp
+++ b/tests/clientapitest.cpp
@@ -13,12 +13,18 @@ template <typename T>
 class DummyResourceFacade : public Akonadi2::StoreFacade<T>
 {
 public:
-    static std::shared_ptr<DummyResourceFacade<T> > registerFacade()
+    static std::shared_ptr<DummyResourceFacade<T> > registerFacade(const QByteArray &instanceIdentifier = QByteArray())
     {
+        static QMap<QByteArray, std::shared_ptr<DummyResourceFacade<T> > > map;
         auto facade = std::make_shared<DummyResourceFacade<T> >();
+        map.insert(instanceIdentifier, facade);
+        bool alwaysReturnFacade = instanceIdentifier.isEmpty();
         Akonadi2::FacadeFactory::instance().registerFacade<T, DummyResourceFacade<T> >("dummyresource",
-            [facade](const QByteArray &instanceIdentifier) {
-                return facade;
+            [alwaysReturnFacade](const QByteArray &instanceIdentifier) {
+                if (alwaysReturnFacade) {
+                    return map.value(QByteArray());
+                }
+                return map.value(instanceIdentifier);
             }
         );
         return facade;
@@ -38,10 +44,17 @@ public:
         auto emitter = resultProvider->emitter();
 
         resultProvider->setFetcher([query, resultProvider, this](const typename T::Ptr &parent) {
-            Trace() << "Running the fetcher";
+            if (parent) {
+                Trace() << "Running the fetcher " << parent->identifier();
+            } else {
+                Trace() << "Running the fetcher.";
+            }
+            Trace() << "-------------------------.";
             for (const auto &res : results) {
-                qDebug() << "Parent filter " << query.propertyFilter.value("parent").toByteArray() << res->identifier();
-                if (!query.propertyFilter.contains("parent") || query.propertyFilter.value("parent").toByteArray() == res->getProperty("parent").toByteArray()) {
+                qDebug() << "Parent filter " << query.propertyFilter.value("parent").toByteArray() << res->identifier() << res->getProperty("parent").toByteArray();
+                auto parentProperty = res->getProperty("parent").toByteArray();
+                if ((!parent && parentProperty.isEmpty()) || (parent && parentProperty == parent->identifier()) || query.parentProperty.isEmpty()) {
+                    qDebug() << "Found a hit" << res->identifier();
                     resultProvider->add(res);
                 }
             }
@@ -180,8 +193,8 @@ private Q_SLOTS:
     void testModelNestedLive()
     {
         auto facade = DummyResourceFacade<Akonadi2::ApplicationDomain::Folder>::registerFacade();
-        auto folder =  QSharedPointer<Akonadi2::ApplicationDomain::Folder>::create("resource", "id", 0, QSharedPointer<Akonadi2::ApplicationDomain::MemoryBufferAdaptor>::create());
-        auto subfolder = QSharedPointer<Akonadi2::ApplicationDomain::Folder>::create("resource", "subId", 0, QSharedPointer<Akonadi2::ApplicationDomain::MemoryBufferAdaptor>::create());
+        auto folder =  QSharedPointer<Akonadi2::ApplicationDomain::Folder>::create("dummyresource.instance1", "id", 0, QSharedPointer<Akonadi2::ApplicationDomain::MemoryBufferAdaptor>::create());
+        auto subfolder = QSharedPointer<Akonadi2::ApplicationDomain::Folder>::create("dummyresource.instance1", "subId", 0, QSharedPointer<Akonadi2::ApplicationDomain::MemoryBufferAdaptor>::create());
         subfolder->setProperty("parent", "id");
         facade->results << folder << subfolder;
         ResourceConfig::addResource("dummyresource.instance1", "dummyresource");
@@ -230,6 +243,23 @@ private Q_SLOTS:
         //TODO: A modification can also be a move
     }
 
+    void testLoadMultiResource()
+    {
+        auto facade1 = DummyResourceFacade<Akonadi2::ApplicationDomain::Event>::registerFacade("dummyresource.instance1");
+        facade1->results << QSharedPointer<Akonadi2::ApplicationDomain::Event>::create("resource1", "id", 0, QSharedPointer<Akonadi2::ApplicationDomain::MemoryBufferAdaptor>::create());
+        auto facade2 = DummyResourceFacade<Akonadi2::ApplicationDomain::Event>::registerFacade("dummyresource.instance2");
+        facade2->results << QSharedPointer<Akonadi2::ApplicationDomain::Event>::create("resource2", "id", 0, QSharedPointer<Akonadi2::ApplicationDomain::MemoryBufferAdaptor>::create());
+        ResourceConfig::addResource("dummyresource.instance1", "dummyresource");
+        ResourceConfig::addResource("dummyresource.instance2", "dummyresource");
+
+        Akonadi2::Query query;
+        query.liveQuery = false;
+
+        auto model = Akonadi2::Store::loadModel<Akonadi2::ApplicationDomain::Event>(query);
+        QTRY_VERIFY(model->data(QModelIndex(), Akonadi2::Store::ChildrenFetchedRole).toBool());
+        QCOMPARE(model->rowCount(QModelIndex()), 2);
+    }
+
 
 };