12 files changed, 87 insertions, 73 deletions

diff --git a/common/configstore.cpp b/common/configstore.cpp
index 9a68662..ff5ba3d 100644
--- a/common/configstore.cpp
+++ b/common/configstore.cpp
@@ -31,8 +31,9 @@ static QSharedPointer<QSettings> getConfig(const QByteArray &identifier)
     return QSharedPointer<QSettings>::create(Sink::configLocation() + "/" + identifier + ".ini", QSettings::IniFormat);
 }
 
-ConfigStore::ConfigStore(const QByteArray &identifier)
+ConfigStore::ConfigStore(const QByteArray &identifier, const QByteArray &typeName)
     : mIdentifier(identifier),
+    mTypeName(typeName),
     mConfig(getConfig(identifier))
 {
 
@@ -43,7 +44,7 @@ QMap<QByteArray, QByteArray> ConfigStore::getEntries()
     QMap<QByteArray, QByteArray> resources;
     for (const auto &identifier : mConfig->childGroups()) {
         mConfig->beginGroup(identifier);
-        const auto type = mConfig->value("type").toByteArray();
+        const auto type = mConfig->value(mTypeName).toByteArray();
         resources.insert(identifier.toLatin1(), type);
         mConfig->endGroup();
     }
@@ -54,7 +55,7 @@ void ConfigStore::add(const QByteArray &identifier, const QByteArray &type)
 {
     SinkTrace() << "Adding " << identifier;
     mConfig->beginGroup(QString::fromLatin1(identifier));
-    mConfig->setValue("type", type);
+    mConfig->setValue(mTypeName, type);
     mConfig->endGroup();
     mConfig->sync();
 }
diff --git a/common/configstore.h b/common/configstore.h
index 2f51f63..514bc01 100644
--- a/common/configstore.h
+++ b/common/configstore.h
@@ -30,7 +30,7 @@
 class SINK_EXPORT ConfigStore
 {
 public:
-    ConfigStore(const QByteArray &identifier);
+    ConfigStore(const QByteArray &identifier, const QByteArray &typeName);
 
     /**
      * Returns all entries with their type.
@@ -64,5 +64,6 @@ public:
 
 private:
     QByteArray mIdentifier;
+    QByteArray mTypeName;
     QSharedPointer<QSettings> mConfig;
 };
diff --git a/common/domain/applicationdomaintype.cpp b/common/domain/applicationdomaintype.cpp
index 2f7c32b..5474708 100644
--- a/common/domain/applicationdomaintype.cpp
+++ b/common/domain/applicationdomaintype.cpp
@@ -254,9 +254,9 @@ Identity::~Identity()
 SinkResource DummyResource::create(const QByteArray &account)
 {
     auto &&resource = ApplicationDomainType::createEntity<SinkResource>();
-    resource.setProperty("type", "sink.dummy");
-    resource.setProperty("account", account);
-    resource.setProperty("capabilities", QVariant::fromValue(QByteArrayList() << ResourceCapabilities::Mail::storage << "-folder.rename"));
+    resource.setResourceType("sink.dummy");
+    resource.setAccount(account);
+    resource.setCapabilities(QByteArrayList() << ResourceCapabilities::Mail::storage << "-folder.rename");
     // resource.setProperty("capabilities", QVariant::fromValue(QByteArrayList() << ResourceCapabilities::Mail::storage << ResourceCapabilities::Mail::drafts << "-folder.rename" << ResourceCapabilities::Mail::trash));
     return resource;
 }
@@ -264,27 +264,27 @@ SinkResource DummyResource::create(const QByteArray &account)
 SinkResource MaildirResource::create(const QByteArray &account)
 {
     auto &&resource = ApplicationDomainType::createEntity<SinkResource>();
-    resource.setProperty("type", "sink.maildir");
-    resource.setProperty("account", account);
-    resource.setProperty("capabilities", QVariant::fromValue(QByteArrayList() << ResourceCapabilities::Mail::storage << ResourceCapabilities::Mail::drafts << "-folder.rename" << ResourceCapabilities::Mail::trash));
+    resource.setResourceType("sink.maildir");
+    resource.setAccount(account);
+    resource.setCapabilities(QByteArrayList() << ResourceCapabilities::Mail::storage << ResourceCapabilities::Mail::drafts << "-folder.rename" << ResourceCapabilities::Mail::trash);
     return resource;
 }
 
 SinkResource MailtransportResource::create(const QByteArray &account)
 {
     auto &&resource = ApplicationDomainType::createEntity<SinkResource>();
-    resource.setProperty("type", "sink.mailtransport");
-    resource.setProperty("account", account);
-    resource.setProperty("capabilities", QVariant::fromValue(QByteArrayList() << ResourceCapabilities::Mail::transport));
+    resource.setResourceType("sink.mailtransport");
+    resource.setAccount(account);
+    resource.setCapabilities(QByteArrayList() << ResourceCapabilities::Mail::transport);
     return resource;
 }
 
 SinkResource ImapResource::create(const QByteArray &account)
 {
     auto &&resource = ApplicationDomainType::createEntity<SinkResource>();
-    resource.setProperty("type", "sink.imap");
-    resource.setProperty("account", account);
-    resource.setProperty("capabilities", QVariant::fromValue(QByteArrayList() << ResourceCapabilities::Mail::storage << ResourceCapabilities::Mail::drafts << ResourceCapabilities::Mail::folderhierarchy << ResourceCapabilities::Mail::trash));
+    resource.setResourceType("sink.imap");
+    resource.setAccount(account);
+    resource.setCapabilities(QByteArrayList() << ResourceCapabilities::Mail::storage << ResourceCapabilities::Mail::drafts << ResourceCapabilities::Mail::folderhierarchy << ResourceCapabilities::Mail::trash);
     return resource;
 }
 
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index c824251..8b96758 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -295,7 +295,7 @@ struct SINK_EXPORT SinkResource : public ApplicationDomainType {
     virtual ~SinkResource();
 
     SINK_REFERENCE_PROPERTY(SinkAccount, Account, account);
-    SINK_PROPERTY(QString, ResourceType, resourceType);
+    SINK_PROPERTY(QByteArray, ResourceType, resourceType);
     SINK_PROPERTY(QByteArrayList, Capabilities, capabilities);
     SINK_STATUS_PROPERTY(int, Status, status);
     SINK_STATUS_PROPERTY(ApplicationDomain::Error, Error, error);
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index 364616c..e509292 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -199,6 +199,10 @@ KAsync::Job<void> ResourceAccess::Private::initializeSocket()
                         if (Sink::Test::testModeEnabled()) {
                             args << "--test";
                         }
+                        if (resourceName.isEmpty()) {
+                            SinkWarning() << "No resource type given";
+                            return KAsync::error();
+                        }
                         args << resourceInstanceIdentifier << resourceName;
                         qint64 pid = 0;
                         if (QProcess::startDetached("sink_synchronizer", args, QDir::homePath(), &pid)) {
diff --git a/common/resourceconfig.cpp b/common/resourceconfig.cpp
index 39f9ddb..68ac0bc 100644
--- a/common/resourceconfig.cpp
+++ b/common/resourceconfig.cpp
@@ -23,6 +23,7 @@
 #include <QFile>
 #include <log.h>
 #include <definitions.h>
+#include <applicationdomaintype.h>
 
 static QSharedPointer<QSettings> getConfig(const QByteArray &identifier)
 {
@@ -43,7 +44,7 @@ void ResourceConfig::addResource(const QByteArray &identifier, const QByteArray
 {
     auto settings = getConfig("resources");
     settings->beginGroup(QString::fromLatin1(identifier));
-    settings->setValue("type", type);
+    settings->setValue(Sink::ApplicationDomain::SinkResource::ResourceType::name, type);
     settings->endGroup();
     settings->sync();
 }
@@ -64,7 +65,7 @@ QMap<QByteArray, QByteArray> ResourceConfig::getResources()
     auto settings = getConfig("resources");
     for (const auto &identifier : settings->childGroups()) {
         settings->beginGroup(identifier);
-        const auto type = settings->value("type").toByteArray();
+        const auto type = settings->value(Sink::ApplicationDomain::SinkResource::ResourceType::name).toByteArray();
         resources.insert(identifier.toLatin1(), type);
         settings->endGroup();
     }
diff --git a/common/resourcefacade.cpp b/common/resourcefacade.cpp
index 391b1d1..aee5706 100644
--- a/common/resourcefacade.cpp
+++ b/common/resourcefacade.cpp
@@ -37,7 +37,7 @@ template <typename DomainType>
 static typename DomainType::Ptr readFromConfig(ConfigStore &configStore, const QByteArray &id, const QByteArray &type)
 {
     auto object = DomainType::Ptr::create(id);
-    object->setProperty("type", type);
+    object->setProperty(ApplicationDomain::SinkResource::ResourceType::name, type);
     const auto configurationValues = configStore.get(id);
     for (auto it = configurationValues.constBegin(); it != configurationValues.constEnd(); it++) {
         object->setProperty(it.key(), it.value());
@@ -48,7 +48,7 @@ static typename DomainType::Ptr readFromConfig(ConfigStore &configStore, const Q
 static bool matchesFilter(const QHash<QByteArray, Query::Comparator> &filter, const QMap<QByteArray, QVariant> &properties)
 {
     for (const auto &filterProperty : filter.keys()) {
-        if (filterProperty == "type") {
+        if (filterProperty == ApplicationDomain::SinkResource::ResourceType::name) {
             continue;
         }
         if (!filter.value(filterProperty).matches(properties.value(filterProperty))) {
@@ -59,8 +59,8 @@ static bool matchesFilter(const QHash<QByteArray, Query::Comparator> &filter, co
 }
 
 template<typename DomainType>
-LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query, const QByteArray &identifier, ConfigNotifier &configNotifier)
-    : mResultProvider(new ResultProvider<typename DomainType::Ptr>), mConfigStore(identifier), mGuard(new QObject)
+LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query, const QByteArray &identifier, const QByteArray &typeName, ConfigNotifier &configNotifier)
+    : mResultProvider(new ResultProvider<typename DomainType::Ptr>), mConfigStore(identifier, typeName), mGuard(new QObject)
 {
     QObject *guard = new QObject;
     mResultProvider->setFetcher([this, query, guard, &configNotifier](const QSharedPointer<DomainType> &) {
@@ -68,7 +68,7 @@ LocalStorageQueryRunner<DomainType>::LocalStorageQueryRunner(const Query &query,
         for (const auto &res : entries.keys()) {
             const auto type = entries.value(res);
 
-            if (query.hasFilter("type") && query.getFilter("type").value.toByteArray() != type) {
+            if (query.hasFilter(ApplicationDomain::SinkResource::ResourceType::name) && query.getFilter(ApplicationDomain::SinkResource::ResourceType::name).value.toByteArray() != type) {
                 SinkTrace() << "Skipping due to type.";
                 continue;
             }
@@ -154,7 +154,7 @@ typename Sink::ResultEmitter<typename DomainType::Ptr>::Ptr LocalStorageQueryRun
 
 
 template <typename DomainType>
-LocalStorageFacade<DomainType>::LocalStorageFacade(const QByteArray &identifier) : StoreFacade<DomainType>(), mIdentifier(identifier)
+LocalStorageFacade<DomainType>::LocalStorageFacade(const QByteArray &identifier, const QByteArray &typeName) : StoreFacade<DomainType>(), mIdentifier(identifier), mTypeName(typeName)
 {
 }
 
@@ -167,15 +167,16 @@ template <typename DomainType>
 KAsync::Job<void> LocalStorageFacade<DomainType>::create(const DomainType &domainObject)
 {
     auto configStoreIdentifier = mIdentifier;
-    return KAsync::syncStart<void>([domainObject, configStoreIdentifier]() {
-        const QByteArray type = domainObject.getProperty("type").toByteArray();
+    auto typeName = mTypeName;
+    return KAsync::syncStart<void>([domainObject, configStoreIdentifier, typeName]() {
+        const QByteArray type = domainObject.getProperty(typeName).toByteArray();
         const QByteArray providedIdentifier = domainObject.identifier().isEmpty() ? domainObject.getProperty("identifier").toByteArray() : domainObject.identifier();
         const QByteArray identifier = providedIdentifier.isEmpty() ? ResourceConfig::newIdentifier(type) : providedIdentifier;
-        auto configStore = ConfigStore(configStoreIdentifier);
+        auto configStore = ConfigStore(configStoreIdentifier, typeName);
         configStore.add(identifier, type);
         auto changedProperties = domainObject.changedProperties();
         changedProperties.removeOne("identifier");
-        changedProperties.removeOne("type");
+        changedProperties.removeOne(typeName);
         if (!changedProperties.isEmpty()) {
             // We have some configuration values
             QMap<QByteArray, QVariant> configurationValues;
@@ -192,7 +193,8 @@ template <typename DomainType>
 KAsync::Job<void> LocalStorageFacade<DomainType>::modify(const DomainType &domainObject)
 {
     auto configStoreIdentifier = mIdentifier;
-    return KAsync::syncStart<void>([domainObject, configStoreIdentifier]() {
+    auto typeName = mTypeName;
+    return KAsync::syncStart<void>([domainObject, configStoreIdentifier, typeName]() {
         const QByteArray identifier = domainObject.identifier();
         if (identifier.isEmpty()) {
             SinkWarning() << "We need an \"identifier\" property to identify the entity to configure.";
@@ -200,8 +202,8 @@ KAsync::Job<void> LocalStorageFacade<DomainType>::modify(const DomainType &domai
         }
         auto changedProperties = domainObject.changedProperties();
         changedProperties.removeOne("identifier");
-        changedProperties.removeOne("type");
-        auto configStore = ConfigStore(configStoreIdentifier);
+        changedProperties.removeOne(typeName);
+        auto configStore = ConfigStore(configStoreIdentifier, typeName);
         if (!changedProperties.isEmpty()) {
             // We have some configuration values
             QMap<QByteArray, QVariant> configurationValues;
@@ -220,14 +222,15 @@ template <typename DomainType>
 KAsync::Job<void> LocalStorageFacade<DomainType>::remove(const DomainType &domainObject)
 {
     auto configStoreIdentifier = mIdentifier;
-    return KAsync::syncStart<void>([domainObject, configStoreIdentifier]() {
+    auto typeName = mTypeName;
+    return KAsync::syncStart<void>([domainObject, configStoreIdentifier, typeName]() {
         const QByteArray identifier = domainObject.identifier();
         if (identifier.isEmpty()) {
             SinkWarning() << "We need an \"identifier\" property to identify the entity to configure";
             return;
         }
         SinkTrace() << "Removing: " << identifier;
-        auto configStore = ConfigStore(configStoreIdentifier);
+        auto configStore = ConfigStore(configStoreIdentifier, typeName);
         configStore.remove(identifier);
         sConfigNotifier.remove(QSharedPointer<DomainType>::create(domainObject));
     });
@@ -236,11 +239,11 @@ KAsync::Job<void> LocalStorageFacade<DomainType>::remove(const DomainType &domai
 template <typename DomainType>
 QPair<KAsync::Job<void>, typename ResultEmitter<typename DomainType::Ptr>::Ptr> LocalStorageFacade<DomainType>::load(const Query &query)
 {
-    auto runner = new LocalStorageQueryRunner<DomainType>(query, mIdentifier, sConfigNotifier);
+    auto runner = new LocalStorageQueryRunner<DomainType>(query, mIdentifier, mTypeName, sConfigNotifier);
     return qMakePair(KAsync::null<void>(), runner->emitter());
 }
 
-ResourceFacade::ResourceFacade() : LocalStorageFacade<Sink::ApplicationDomain::SinkResource>("resources")
+ResourceFacade::ResourceFacade() : LocalStorageFacade<Sink::ApplicationDomain::SinkResource>("resources", Sink::ApplicationDomain::SinkResource::ResourceType::name)
 {
 }
 
@@ -256,7 +259,7 @@ KAsync::Job<void> ResourceFacade::remove(const Sink::ApplicationDomain::SinkReso
 
 QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain::SinkResource::Ptr>::Ptr> ResourceFacade::load(const Sink::Query &query)
 {
-    auto runner = new LocalStorageQueryRunner<ApplicationDomain::SinkResource>(query, mIdentifier, sConfigNotifier);
+    auto runner = new LocalStorageQueryRunner<ApplicationDomain::SinkResource>(query, mIdentifier, mTypeName, sConfigNotifier);
     auto monitoredResources = QSharedPointer<QSet<QByteArray>>::create();
     runner->setStatusUpdater([runner, monitoredResources](ApplicationDomain::SinkResource &resource) {
         auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource.identifier(), ResourceConfig::getResourceType(resource.identifier()));
@@ -276,7 +279,7 @@ QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain
 }
 
 
-AccountFacade::AccountFacade() : LocalStorageFacade<Sink::ApplicationDomain::SinkAccount>("accounts")
+AccountFacade::AccountFacade() : LocalStorageFacade<Sink::ApplicationDomain::SinkAccount>("accounts", "type")
 {
 }
 
@@ -286,7 +289,7 @@ AccountFacade::~AccountFacade()
 
 QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain::SinkAccount::Ptr>::Ptr> AccountFacade::load(const Sink::Query &query)
 {
-    auto runner = new LocalStorageQueryRunner<ApplicationDomain::SinkAccount>(query, mIdentifier, sConfigNotifier);
+    auto runner = new LocalStorageQueryRunner<ApplicationDomain::SinkAccount>(query, mIdentifier, mTypeName, sConfigNotifier);
     auto monitoredResources = QSharedPointer<QSet<QByteArray>>::create();
     runner->setStatusUpdater([runner, monitoredResources](ApplicationDomain::SinkAccount &account) {
         Query query;
@@ -333,7 +336,7 @@ QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain
     return qMakePair(KAsync::null<void>(), runner->emitter());
 }
 
-IdentityFacade::IdentityFacade() : LocalStorageFacade<Sink::ApplicationDomain::Identity>("identities")
+IdentityFacade::IdentityFacade() : LocalStorageFacade<Sink::ApplicationDomain::Identity>("identities", "type")
 {
 }
 
diff --git a/common/resourcefacade.h b/common/resourcefacade.h
index b87a396..d259d4f 100644
--- a/common/resourcefacade.h
+++ b/common/resourcefacade.h
@@ -59,7 +59,7 @@ template <typename DomainType>
 class LocalStorageQueryRunner
 {
 public:
-    LocalStorageQueryRunner(const Sink::Query &query, const QByteArray &identifier, ConfigNotifier &configNotifier);
+    LocalStorageQueryRunner(const Sink::Query &query, const QByteArray &identifier, const QByteArray &typeName, ConfigNotifier &configNotifier);
     typename Sink::ResultEmitter<typename DomainType::Ptr>::Ptr emitter();
     void setStatusUpdater(const std::function<void(DomainType &)> &);
     void statusChanged(const QByteArray &identifier);
@@ -77,7 +77,7 @@ template <typename DomainType>
 class LocalStorageFacade : public Sink::StoreFacade<DomainType>
 {
 public:
-    LocalStorageFacade(const QByteArray &instanceIdentifier);
+    LocalStorageFacade(const QByteArray &instanceIdentifier, const QByteArray &typeName);
     virtual ~LocalStorageFacade();
     virtual KAsync::Job<void> create(const DomainType &resource) Q_DECL_OVERRIDE;
     virtual KAsync::Job<void> modify(const DomainType &resource) Q_DECL_OVERRIDE;
@@ -86,6 +86,7 @@ public:
 
 protected:
     QByteArray mIdentifier;
+    QByteArray mTypeName;
     static ConfigNotifier sConfigNotifier;
 };
 
diff --git a/common/store.cpp b/common/store.cpp
index c01d220..f5a7774 100644
--- a/common/store.cpp
+++ b/common/store.cpp
@@ -360,7 +360,7 @@ QList<DomainType> Store::read(const Sink::Query &q)
     });
     for (const auto &resourceInstanceIdentifier : resources.keys()) {
         const auto resourceType = resources.value(resourceInstanceIdentifier);
-        SinkTrace() << "Looking for " << resourceType << resourceInstanceIdentifier;
+        SinkTrace() << "Querying resource:  " << resourceType << resourceInstanceIdentifier;
         auto facade = FacadeFactory::instance().getFacade<DomainType>(resourceType, resourceInstanceIdentifier);
         if (facade) {
             SinkTrace() << "Trying to fetch from resource " << resourceInstanceIdentifier;
diff --git a/sinksh/syntax_modules/sink_create.cpp b/sinksh/syntax_modules/sink_create.cpp
index 1411b2e..4fedff4 100644
--- a/sinksh/syntax_modules/sink_create.cpp
+++ b/sinksh/syntax_modules/sink_create.cpp
@@ -91,7 +91,7 @@ bool resource(const QStringList &args, State &state)
     auto identifier = map.take("identifier").toLatin1();
 
     auto object = ApplicationDomain::ApplicationDomainType::createEntity<ApplicationDomain::SinkResource>("", identifier);
-    object.setResourceType(resourceType);
+    object.setResourceType(resourceType.toLatin1());
 
     for (auto i = map.begin(); i != map.end(); ++i) {
         object.setProperty(i.key().toLatin1(), i.value());
diff --git a/tests/accountstest.cpp b/tests/accountstest.cpp
index e0a99c2..260602c 100644
--- a/tests/accountstest.cpp
+++ b/tests/accountstest.cpp
@@ -22,8 +22,8 @@ private slots:
 
     void init()
     {
-        ConfigStore("accounts").clear();
-        ConfigStore("resources").clear();
+        ConfigStore("accounts", "type").clear();
+        ConfigStore("resources", Sink::ApplicationDomain::SinkResource::ResourceType::name).clear();
     }
 
     void testLoad()
@@ -34,17 +34,17 @@ private slots:
         QString accountName("name");
         QString accountIcon("icon");
         auto account = ApplicationDomainType::createEntity<SinkAccount>();
-        account.setProperty("type", "maildir");
-        account.setProperty("name", accountName);
-        account.setProperty("icon", accountIcon);
+        account.setAccountType("maildir");
+        account.setName(accountName);
+        account.setIcon(accountIcon);
         Store::create(account).exec().waitForFinished();
 
         Store::fetchAll<SinkAccount>(Query()).syncThen<void, QList<SinkAccount::Ptr>>([&](const QList<SinkAccount::Ptr> &accounts) {
             QCOMPARE(accounts.size(), 1);
             auto account = accounts.first();
-            QCOMPARE(account->getProperty("type").toString(), QString("maildir"));
-            QCOMPARE(account->getProperty("name").toString(), accountName);
-            QCOMPARE(account->getProperty("icon").toString(), accountIcon);
+            QCOMPARE(account->getAccountType(), QString("maildir"));
+            QCOMPARE(account->getName(), accountName);
+            QCOMPARE(account->getIcon(), accountIcon);
         })
         .exec().waitForFinished();
 
@@ -52,8 +52,8 @@ private slots:
         QString smtpUsername("smtpUsername");
         QString smtpPassword("smtpPassword");
         auto resource = ApplicationDomainType::createEntity<SinkResource>();
-        resource.setProperty("type", "sink.mailtransport");
-        resource.setProperty("account", account.identifier());
+        resource.setResourceType("sink.mailtransport");
+        resource.setAccount(account);
         resource.setProperty("server", smtpServer);
         resource.setProperty("username", smtpUsername);
         resource.setProperty("password", smtpPassword);
@@ -63,7 +63,7 @@ private slots:
         Store::fetchAll<SinkResource>(Query()).syncThen<void, QList<SinkResource::Ptr>>([&](const QList<SinkResource::Ptr> &resources) {
             QCOMPARE(resources.size(), 1);
             auto resource = resources.first();
-            QCOMPARE(resource->getProperty("type").toString(), QString("sink.mailtransport"));
+            QCOMPARE(resource->getResourceType(), QByteArray("sink.mailtransport"));
             QCOMPARE(resource->getProperty("server").toString(), smtpServer);
         })
         .exec().waitForFinished();
diff --git a/tests/resourceconfigtest.cpp b/tests/resourceconfigtest.cpp
index 70a37f0..c06b0fb 100644
--- a/tests/resourceconfigtest.cpp
+++ b/tests/resourceconfigtest.cpp
@@ -11,6 +11,9 @@
 #include "test.h"
 #include "testutils.h"
 
+using namespace Sink;
+using namespace Sink::ApplicationDomain;
+
 /**
  * Test of the resource configuration.
  */
@@ -31,43 +34,43 @@ private slots:
         ResourceConfig::clear();
         Sink::FacadeFactory::instance().registerStaticFacades();
 
-        Sink::ApplicationDomain::SinkResource res("", "dummyresource.identifier1", 0, QSharedPointer<Sink::ApplicationDomain::MemoryBufferAdaptor>::create());
+        SinkResource res("", "dummyresource.identifier1", 0, QSharedPointer<MemoryBufferAdaptor>::create());
         res.setProperty("identifier", "dummyresource.identifier1");
-        res.setProperty("type", "dummyresource");
+        res.setProperty(SinkResource::ResourceType::name, "dummyresource");
 
         Sink::Store::create(res).exec().waitForFinished();
         {
             Sink::Query query;
-            query.filter("type", Sink::Query::Comparator("dummyresource"));
-            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::SinkResource>(query);
+            query.filter<SinkResource::ResourceType>("dummyresource");
+            auto model = Sink::Store::loadModel<SinkResource>(query);
             QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
         }
 
         Sink::Store::remove(res).exec().waitForFinished();
         {
             Sink::Query query;
-            query.filter("type", Sink::Query::Comparator("dummyresource"));
-            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::SinkResource>(query);
+            query.filter<SinkResource::ResourceType>("dummyresource");
+            auto model = Sink::Store::loadModel<SinkResource>(query);
             QTRY_VERIFY(model->data(QModelIndex(), Sink::Store::ChildrenFetchedRole).toBool());
             QCOMPARE(model->rowCount(QModelIndex()), 0);
         }
     }
 
-    void testLoadResourceByCapabiity()
+    void testLoadResourceByCapability()
     {
         ResourceConfig::clear();
         Sink::FacadeFactory::instance().registerStaticFacades();
 
-        Sink::ApplicationDomain::SinkResource res("", "dummyresource.identifier1", 0, QSharedPointer<Sink::ApplicationDomain::MemoryBufferAdaptor>::create());
+        SinkResource res("", "dummyresource.identifier1", 0, QSharedPointer<MemoryBufferAdaptor>::create());
         res.setProperty("identifier", "dummyresource.identifier1");
-        res.setProperty("type", "dummyresource");
-        res.setProperty("capabilities", QVariant::fromValue(QByteArrayList() << "foo"));
+        res.setResourceType("dummyresource");
+        res.setCapabilities(QByteArrayList() << "foo");
 
         Sink::Store::create(res).exec().waitForFinished();
         {
             Sink::Query query;
-            query.filter("type", Sink::Query::Comparator("dummyresource"));
-            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::SinkResource>(Sink::Query::CapabilityFilter("foo"));
+            query.filter<SinkResource::ResourceType>("dummyresource");
+            auto model = Sink::Store::loadModel<SinkResource>(Query().containsFilter<SinkResource::Capabilities>("foo"));
             QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
         }
 
@@ -79,20 +82,20 @@ private slots:
         ResourceConfig::clear();
         Sink::FacadeFactory::instance().registerStaticFacades();
 
-        auto res = Sink::ApplicationDomain::DummyResource::create("");
+        auto res = DummyResource::create("");
         VERIFYEXEC(Sink::Store::create(res));
         {
             Sink::Query query;
             query.liveQuery = true;
-            query.request<Sink::ApplicationDomain::SinkResource::Status>();
-            auto model = Sink::Store::loadModel<Sink::ApplicationDomain::SinkResource>(query);
+            query.request<SinkResource::Status>();
+            auto model = Sink::Store::loadModel<SinkResource>(query);
             QTRY_COMPARE(model->rowCount(QModelIndex()), 1);
-            auto resource = model->data(model->index(0, 0, QModelIndex()), Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::SinkResource::Ptr>();
-            QCOMPARE(resource->getStatus(), static_cast<int>(Sink::ApplicationDomain::OfflineStatus));
+            auto resource = model->data(model->index(0, 0, QModelIndex()), Sink::Store::DomainObjectRole).value<SinkResource::Ptr>();
+            QCOMPARE(resource->getStatus(), static_cast<int>(OfflineStatus));
 
             //Synchronize to connect
             VERIFYEXEC(Sink::Store::synchronize(query));
-            QTRY_COMPARE(model->data(model->index(0, 0, QModelIndex()), Sink::Store::DomainObjectRole).value<Sink::ApplicationDomain::SinkResource::Ptr>()->getStatus(), static_cast<int>(Sink::ApplicationDomain::ConnectedStatus));
+            QTRY_COMPARE(model->data(model->index(0, 0, QModelIndex()), Sink::Store::DomainObjectRole).value<SinkResource::Ptr>()->getStatus(), static_cast<int>(ConnectedStatus));
         }
 
         VERIFYEXEC(Sink::Store::remove(res));