4 files changed, 57 insertions, 111 deletions

diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp
index 0cc30e5..7341675 100644
--- a/common/datastorequery.cpp
+++ b/common/datastorequery.cpp
@@ -409,9 +409,6 @@ void DataStoreQuery::setupQuery()
 {
     auto baseFilters = mQuery.getBaseFilters();
     for (const auto &k : baseFilters.keys()) {
-        if (k == ApplicationDomain::Entity::Resource::name) {
-            continue;
-        }
         const auto comparator = baseFilters.value(k);
         if (comparator.value.canConvert<Query>()) {
             SinkTrace() << "Executing subquery for property: " << k;
@@ -446,9 +443,6 @@ void DataStoreQuery::setupQuery()
         auto filter = Filter::Ptr::create(baseSet, this);
         //For incremental queries the remaining filters are not sufficient
         for (const auto &f : mQuery.getBaseFilters().keys()) {
-            if (f == ApplicationDomain::Entity::Resource::name) {
-                continue;
-            }
             filter->propertyFilter.insert(f, mQuery.getFilter(f));
         }
         baseSet = filter;
@@ -459,7 +453,7 @@ void DataStoreQuery::setupQuery()
     /* } */
 
     //Setup the rest of the filter stages on top of the base set
-    for (const auto &stage : mQuery.filterStages.mid(1)) {
+    for (const auto &stage : mQuery.getFilterStages()) {
         if (auto filter = stage.dynamicCast<Query::Filter>()) {
             auto f = Filter::Ptr::create(baseSet, this);
             f->propertyFilter = filter->propertyFilter;
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index 1c8b45a..7332bfb 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -242,7 +242,6 @@ struct SINK_EXPORT Entity : public ApplicationDomainType {
     typedef QSharedPointer<Entity> Ptr;
     using ApplicationDomainType::ApplicationDomainType;
     virtual ~Entity();
-    SINK_REFERENCE_PROPERTY(SinkResource, Resource, resource);
 };
 
 struct SINK_EXPORT Event : public Entity {
diff --git a/common/query.h b/common/query.h
index 82b04f7..ae307a2 100644
--- a/common/query.h
+++ b/common/query.h
@@ -59,46 +59,6 @@ public:
         Comparators comparator;
     };
 
-    static Query ResourceFilter(const QByteArray &identifier)
-    {
-        Query query;
-        query.resources.append(identifier);
-        return query;
-    }
-
-    static Query ResourceFilter(const QByteArrayList &identifier)
-    {
-        Query query;
-        query.resources = identifier;
-        return query;
-    }
-
-    static Query ResourceFilter(const ApplicationDomain::SinkResource &entity)
-    {
-        return ResourceFilter(entity.identifier());
-    }
-
-    static Query IdentityFilter(const QByteArray &identifier)
-    {
-        Q_ASSERT(!identifier.isEmpty());
-        Query query;
-        query.filter(identifier);
-        return query;
-    }
-
-    static Query IdentityFilter(const QByteArrayList &identifier)
-    {
-        Query query;
-        query.filter(identifier);
-        return query;
-    }
-
-    static Query IdentityFilter(const ApplicationDomain::Entity &entity)
-    {
-        auto query = IdentityFilter(entity.identifier());
-        query.resources << entity.resourceInstanceIdentifier();
-        return query;
-    }
 
     template <typename T>
     Query &request()
@@ -124,16 +84,13 @@ public:
     Query(const ApplicationDomain::Entity &value) : limit(0), liveQuery(false), synchronousQuery(false)
     {
         filter(value.identifier());
-        filter(ApplicationDomain::SinkResource(value.resourceInstanceIdentifier()));
+        resourceFilter(value.resourceInstanceIdentifier());
     }
 
-
     Query(Flags flags = Flags()) : limit(0), liveQuery(false), synchronousQuery(false)
     {
     }
 
-    QByteArrayList resources;
-    QByteArrayList accounts;
     QByteArrayList requestedProperties;
     QByteArray parentProperty;
     QByteArray sortProperty;
@@ -147,7 +104,10 @@ public:
         virtual ~FilterStage(){};
     };
 
-    QList<QSharedPointer<FilterStage>> filterStages;
+    QList<QSharedPointer<FilterStage>> getFilterStages()
+    {
+        return mFilterStages;
+    }
 
     /*
     * Filters
@@ -178,69 +138,45 @@ public:
 
     Query &filter(const QByteArray &id)
     {
-        if (filterStages.isEmpty()) {
-            filterStages << QSharedPointer<Filter>::create();
-        }
-        filterStages.first().staticCast<Filter>()->ids << id;
+        mBaseFilterStage.ids << id;
         return *this;
     }
 
     Query &filter(const QByteArrayList &ids)
     {
-        if (filterStages.isEmpty()) {
-            filterStages << QSharedPointer<Filter>::create();
-        }
-        filterStages.first().staticCast<Filter>()->ids << ids;
+        mBaseFilterStage.ids << ids;
         return *this;
     }
 
     Query &filter(const QByteArray &property, const Comparator &comparator)
     {
-        if (filterStages.isEmpty()) {
-            filterStages << QSharedPointer<Filter>::create();
-        }
-        filterStages.first().staticCast<Filter>()->propertyFilter.insert(property, comparator);
+        mBaseFilterStage.propertyFilter.insert(property, comparator);
         return *this;
     }
 
     Comparator getFilter(const QByteArray &property) const
     {
-        if (filterStages.isEmpty()) {
-            return Comparator();
-        }
-        return filterStages.first().staticCast<Filter>()->propertyFilter.value(property);
+        return mBaseFilterStage.propertyFilter.value(property);
     }
 
     bool hasFilter(const QByteArray &property) const
     {
-        if (filterStages.isEmpty()) {
-            return false;
-        }
-        return filterStages.first().staticCast<Filter>()->propertyFilter.contains(property);
+        return mBaseFilterStage.propertyFilter.contains(property);
     }
 
     void setBaseFilters(const QHash<QByteArray, Comparator> &filter)
     {
-        if (filterStages.isEmpty()) {
-            filterStages << QSharedPointer<Filter>::create();
-        }
-        filterStages.first().staticCast<Filter>()->propertyFilter = filter;
+        mBaseFilterStage.propertyFilter = filter;
     }
 
     QHash<QByteArray, Comparator> getBaseFilters() const
     {
-        if (filterStages.isEmpty()) {
-            return QHash<QByteArray, Comparator>();
-        }
-        return filterStages.first().staticCast<Filter>()->propertyFilter;
+        return mBaseFilterStage.propertyFilter;
     }
 
     QByteArrayList ids() const
     {
-        if (filterStages.isEmpty()) {
-            return QByteArrayList();
-        }
-        return filterStages.first().staticCast<Filter>()->ids;
+        return mBaseFilterStage.ids;
     }
 
     template <typename T>
@@ -257,18 +193,42 @@ public:
         return filter(T::name, QVariant::fromValue(q));
     }
 
-    Query &filter(const ApplicationDomain::SinkResource &resource)
+    Filter getResourceFilter() const
+    {
+        return mResourceFilter;
+    }
+
+    Query &resourceFilter(const QByteArray &id)
     {
-        resources << resource.identifier();
+        mResourceFilter.ids << id;
         return *this;
     }
 
-    Query &filter(const ApplicationDomain::SinkAccount &account)
+    template <typename T>
+    Query &resourceFilter(const ApplicationDomain::ApplicationDomainType &entity)
     {
-        accounts << account.identifier();
+        mResourceFilter.propertyFilter.insert(T::name, Comparator(entity.identifier()));
         return *this;
     }
 
+    Query &resourceFilter(const QByteArray &name, const Comparator &comparator)
+    {
+        mResourceFilter.propertyFilter.insert(name, comparator);
+        return *this;
+    }
+
+    template <typename T>
+    Query &resourceContainsFilter(const QVariant &value)
+    {
+        return resourceFilter(T::name, Comparator(value, Comparator::Contains));
+    }
+
+    template <typename T>
+    Query &resourceFilter(const QVariant &value)
+    {
+        return resourceFilter(T::name, value);
+    }
+
     class Reduce : public FilterStage {
     public:
 
@@ -318,7 +278,7 @@ public:
     Reduce &reduce(const Reduce::Selector &s)
     {
         auto reduction = QSharedPointer<Reduce>::create(T::name, s);
-        filterStages << reduction;
+        mFilterStages << reduction;
         return *reduction;
     }
 
@@ -345,7 +305,7 @@ public:
     void bloom()
     {
         auto bloom = QSharedPointer<Bloom>::create(T::name);
-        filterStages << bloom;
+        mFilterStages << bloom;
     }
 
     //Query fixtures
@@ -357,7 +317,7 @@ public:
     {
         Sink::Query query;
         if (!mail.resourceInstanceIdentifier().isEmpty()) {
-            query.filter(ApplicationDomain::SinkResource(mail.resourceInstanceIdentifier()));
+            query.resourceFilter(mail.resourceInstanceIdentifier());
         }
         query.filter(mail.identifier());
         query.sort<ApplicationDomain::Mail::Date>();
@@ -372,7 +332,7 @@ public:
     {
         Sink::Query query;
         if (!folder.resourceInstanceIdentifier().isEmpty()) {
-            query.filter(ApplicationDomain::SinkResource(folder.resourceInstanceIdentifier()));
+            query.resourceFilter(folder.resourceInstanceIdentifier());
         }
         query.filter<ApplicationDomain::Mail::Folder>(folder);
         query.sort<ApplicationDomain::Mail::Date>();
@@ -380,7 +340,10 @@ public:
         return query;
     }
 
-
+private:
+    Filter mResourceFilter;
+    Filter mBaseFilterStage;
+    QList<QSharedPointer<FilterStage>> mFilterStages;
 };
 
 }
diff --git a/common/store.cpp b/common/store.cpp
index c015ef6..0ecdcd2 100644
--- a/common/store.cpp
+++ b/common/store.cpp
@@ -59,25 +59,15 @@ QString Store::getTemporaryFilePath()
  */
 static QMap<QByteArray, QByteArray> getResources(const Sink::Query &query, const QByteArray &type = QByteArray())
 {
-    const QList<QByteArray> resourceFilter = query.resources;
-    const QList<QByteArray> accountFilter = query.accounts;
+    const QList<QByteArray> resourceFilter = query.getResourceFilter().ids;
 
-    auto resourceComparator = query.getFilter(Sink::ApplicationDomain::Entity::Resource::name);
 
     const auto filterResource = [&](const QByteArray &res) {
         const auto configuration = ResourceConfig::getConfiguration(res);
-        if (!accountFilter.isEmpty() && !accountFilter.contains(configuration.value(ApplicationDomain::SinkResource::Account::name).toByteArray())) {
-            return true;
-        }
-        //Subquery for the resource
-        if (resourceComparator.value.canConvert<Query>()) {
-            const auto subquery = resourceComparator.value.value<Query>();
-            const auto baseFilters = subquery.getBaseFilters();
-            for (const auto &filterProperty : baseFilters.keys()) {
-                const auto filter = baseFilters.value(filterProperty);
-                if (!filter.matches(configuration.value(filterProperty))) {
-                    return true;
-                }
+        for (const auto &filterProperty : query.getResourceFilter().propertyFilter.keys()) {
+            const auto filter = query.getResourceFilter().propertyFilter.value(filterProperty);
+            if (!filter.matches(configuration.value(filterProperty))) {
+                return true;
             }
         }
         return false;
@@ -159,7 +149,7 @@ QSharedPointer<QAbstractItemModel> Store::loadModel(Query query)
     auto aggregatingEmitter = AggregatingResultEmitter<typename DomainType::Ptr>::Ptr::create();
     model->setEmitter(aggregatingEmitter);
 
-    if (query.liveQuery && query.resources.isEmpty() && !ApplicationDomain::isGlobalType(ApplicationDomain::getTypeName<DomainType>())) {
+    if (query.liveQuery && query.getResourceFilter().ids.isEmpty() && !ApplicationDomain::isGlobalType(ApplicationDomain::getTypeName<DomainType>())) {
         SinkTrace() << "Listening for new resources";
         auto facade = FacadeFactory::instance().getFacade<ApplicationDomain::SinkResource>("", "");
         Q_ASSERT(facade);
@@ -267,8 +257,8 @@ KAsync::Job<void> Store::removeDataFromDisk(const QByteArray &identifier)
 
 KAsync::Job<void> Store::synchronize(const Sink::Query &query)
 {
-    SinkTrace() << "synchronize" << query.resources;
     auto resources = getResources(query).keys();
+    SinkTrace() << "synchronize" << resources;
     //FIXME only necessary because each doesn't propagate errors
     auto errorFlag = new bool;
     return KAsync::value(resources)