Merge commit 'ebdb89b8bb482bbb5ecd544c3d38bef35fc7d820'v0.4.0

24 files changed, 271 insertions, 104 deletions

diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 001a412..8421fc2 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -116,13 +116,13 @@ SET_TARGET_PROPERTIES(${PROJECT_NAME}
     EXPORT_NAME ${PROJECT_NAME}
 )
 
-qt5_use_modules(${PROJECT_NAME} LINK_PUBLIC Network)
-qt5_use_modules(${PROJECT_NAME} LINK_PRIVATE Gui)
 target_link_libraries(${PROJECT_NAME}
 PUBLIC
     KAsync
+    Qt5::Network
 PRIVATE
     ${storage_LIBS}
+    Qt5::Gui
     KF5::Mime
     KF5::Contacts
 )
diff --git a/common/asyncutils.h b/common/asyncutils.h
index 67b5928..c80af30 100644
--- a/common/asyncutils.h
+++ b/common/asyncutils.h
@@ -31,12 +31,12 @@ KAsync::Job<T> run(const std::function<T()> &f, bool runAsync = true)
         return KAsync::start<T>([f](KAsync::Future<T> &future) {
             auto result = QtConcurrent::run(f);
             auto watcher = new QFutureWatcher<T>;
-            watcher->setFuture(result);
             QObject::connect(watcher, &QFutureWatcher<T>::finished, watcher, [&future, watcher]() {
                 future.setValue(watcher->future().result());
                 delete watcher;
                 future.setFinished();
             });
+            watcher->setFuture(result);
         });
     } else {
         return KAsync::start<T>([f]() {
diff --git a/common/definitions.cpp b/common/definitions.cpp
index 17977bc..ee18d52 100644
--- a/common/definitions.cpp
+++ b/common/definitions.cpp
@@ -39,11 +39,17 @@ QString Sink::storageLocation()
     return dataLocation() + "/storage";
 }
 
+static QString sinkLocation(QStandardPaths::StandardLocation location)
+{
+    return QStandardPaths::writableLocation(location) + "/sink";
+}
+
 QString Sink::dataLocation()
 {
-    static QString location;
+    static QString location = sinkLocation(QStandardPaths::GenericDataLocation);
+    //Warning: This is not threadsafe, but clearLocationCache is only ever used in testcode. The initialization above is required to make at least the initialization threadsafe (relies on C++11 threadsafe initialization).
     if (rereadDataLocation) {
-        location = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + "/sink";
+        location = sinkLocation(QStandardPaths::GenericDataLocation);
         rereadDataLocation = false;
     }
     return location;
@@ -51,9 +57,10 @@ QString Sink::dataLocation()
 
 QString Sink::configLocation()
 {
-    static QString location;
+    static QString location = sinkLocation(QStandardPaths::GenericConfigLocation);
+    //Warning: This is not threadsafe, but clearLocationCache is only ever used in testcode. The initialization above is required to make at least the initialization threadsafe (relies on C++11 threadsafe initialization).
     if (rereadConfigLocation) {
-        location = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) + "/sink";
+        location = sinkLocation(QStandardPaths::GenericConfigLocation);
         rereadConfigLocation = false;
     }
     return location;
@@ -61,8 +68,9 @@ QString Sink::configLocation()
 
 QString Sink::temporaryFileLocation()
 {
-    static QString location;
+    static QString location = dataLocation() + "/temporaryFiles";
     static bool dirCreated = false;
+    //Warning: This is not threadsafe, but clearLocationCache is only ever used in testcode. The initialization above is required to make at least the initialization threadsafe (relies on C++11 threadsafe initialization).
     if (rereadTemporaryFileLocation) {
         location = dataLocation() + "/temporaryFiles";
         dirCreated = QDir{}.mkpath(location);
diff --git a/common/definitions.h b/common/definitions.h
index ce9e794..7ef215b 100644
--- a/common/definitions.h
+++ b/common/definitions.h
@@ -25,10 +25,16 @@
 #include <QByteArray>
 
 namespace Sink {
-void SINK_EXPORT clearLocationCache();
 QString SINK_EXPORT storageLocation();
 QString SINK_EXPORT dataLocation();
 QString SINK_EXPORT configLocation();
 QString SINK_EXPORT temporaryFileLocation();
 QString SINK_EXPORT resourceStorageLocation(const QByteArray &resourceInstanceIdentifier);
+
+/**
+ * Clear the location cache and lookup locations again.
+ *
+ * Warning: Calling this results in non-threadsafe initialization, only use it in test-code.
+ */
+void SINK_EXPORT clearLocationCache();
 }
diff --git a/common/domain/applicationdomaintype.cpp b/common/domain/applicationdomaintype.cpp
index 3718f77..ee70c35 100644
--- a/common/domain/applicationdomaintype.cpp
+++ b/common/domain/applicationdomaintype.cpp
@@ -34,7 +34,13 @@ QDebug Sink::ApplicationDomain::operator<< (QDebug d, const Sink::ApplicationDom
 QDebug Sink::ApplicationDomain::operator<< (QDebug d, const Sink::ApplicationDomain::ApplicationDomainType &type)
 {
     d << "ApplicationDomainType(\n";
-    auto properties = type.mAdaptor->availableProperties();
+    auto properties = [&] {
+        if (!type.changedProperties().isEmpty()) {
+            return type.changedProperties();
+        } else {
+            return type.mAdaptor->availableProperties();
+        }
+    }();
     std::sort(properties.begin(), properties.end());
     d << " " << "Id: " << "\t" << type.identifier() << "\n";
     d << " " << "Resource: " << "\t" << type.resourceInstanceIdentifier() << "\n";
@@ -216,8 +222,13 @@ QVariant ApplicationDomainType::getProperty(const QByteArray &key) const
 void ApplicationDomainType::setProperty(const QByteArray &key, const QVariant &value)
 {
     Q_ASSERT(mAdaptor);
-    mChangeSet->insert(key);
-    mAdaptor->setProperty(key, value);
+    auto existing = mAdaptor->getProperty(key);
+    if (existing.isValid() && existing == value) {
+        SinkTrace() << "Tried to set property that is still the same: " << key << value;
+    } else {
+        mChangeSet->insert(key);
+        mAdaptor->setProperty(key, value);
+    }
 }
 
 void ApplicationDomainType::setResource(const QByteArray &identifier)
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index 602d54c..f7fd07e 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -101,6 +101,7 @@ enum SINK_EXPORT ErrorCode {
     LoginError,
     ConfigurationError,
     TransmissionError,
+    ConnectionLostError,
 };
 
 enum SINK_EXPORT SuccessCode {
@@ -118,12 +119,14 @@ enum SINK_EXPORT SyncStatus {
  * The status of an account or resource.
  *
  * It is set as follows:
- * * By default the status is offline.
+ * * By default the status is no status.
+ * * If a connection to the server failed the status is Offline.
  * * If a connection to the server could be established the status is Connected.
  * * If an error occurred that keeps the resource from operating (so non transient), the resource enters the error state.
  * * If a long running operation is started the resource goes to the busy state (and return to the previous state after that).
  */
 enum SINK_EXPORT Status {
+    NoStatus,
     OfflineStatus,
     ConnectedStatus,
     BusyStatus,
@@ -270,7 +273,17 @@ public:
     bool hasProperty(const QByteArray &key) const;
 
     QVariant getProperty(const QByteArray &key) const;
+
+    /**
+     * Set a property and record a changed property
+     *
+     * If the propery is available and did not change the call will be ignored.
+     */
     void setProperty(const QByteArray &key, const QVariant &value);
+
+    /**
+     * Convenience method to set a reference property.
+     */
     void setProperty(const QByteArray &key, const ApplicationDomainType &value);
 
     QByteArray getBlobProperty(const QByteArray &key) const;
diff --git a/common/domain/applicationdomaintype_p.h b/common/domain/applicationdomaintype_p.h
index a5a6b1d..a60df38 100644
--- a/common/domain/applicationdomaintype_p.h
+++ b/common/domain/applicationdomaintype_p.h
@@ -45,5 +45,7 @@ struct TypeHelper {
         } else {
             Q_ASSERT(false);
         }
+        //Silence compiler warning
+        return Func<Sink::ApplicationDomain::Mail>{}(std::forward<Args...>(args...));
     }
 };
diff --git a/common/log.cpp b/common/log.cpp
index 5dfb872..bfc9d5e 100644
--- a/common/log.cpp
+++ b/common/log.cpp
@@ -10,7 +10,6 @@
 #include <QMutexLocker>
 #include <iostream>
 #include <unistd.h>
-#include <memory>
 #include <atomic>
 #include <definitions.h>
 #include <QThreadStorage>
@@ -27,10 +26,13 @@ static QSettings &config()
     return *sSettings.localData();
 }
 
-static QByteArray sPrimaryComponent;
+Q_GLOBAL_STATIC(QByteArray, sPrimaryComponent);
+
 void Sink::Log::setPrimaryComponent(const QString &component)
 {
-    sPrimaryComponent = component.toUtf8();
+    if (!sPrimaryComponent.isDestroyed()) {
+        *sPrimaryComponent = component.toUtf8();
+    }
 }
 
 class DebugStream : public QIODevice
@@ -267,16 +269,21 @@ public:
     QSet<QString> mDebugAreas;
 };
 
-static auto sDebugAreaCollector = std::unique_ptr<DebugAreaCollector>(new DebugAreaCollector);
+Q_GLOBAL_STATIC(DebugAreaCollector, sDebugAreaCollector);
 
 QSet<QString> Sink::Log::debugAreas()
 {
-    return sDebugAreaCollector->debugAreas();
+    if (!sDebugAreaCollector.isDestroyed()) {
+        return sDebugAreaCollector->debugAreas();
+    }
+    return {};
 }
 
 static void collectDebugArea(const QString &debugArea)
 {
-    sDebugAreaCollector->add(debugArea);
+    if (!sDebugAreaCollector.isDestroyed()) {
+        sDebugAreaCollector->add(debugArea);
+    }
 }
 
 static bool containsItemStartingWith(const QByteArray &pattern, const QByteArrayList &list)
@@ -318,13 +325,17 @@ static QByteArray getFileName(const char *file)
 
 static QString assembleDebugArea(const char *debugArea, const char *debugComponent, const char *file)
 {
-    if (sPrimaryComponent.isEmpty()) {
-        sPrimaryComponent = getProgramName();
+    if (!sPrimaryComponent.isDestroyed() && sPrimaryComponent->isEmpty()) {
+        *sPrimaryComponent = getProgramName();
+    }
+    if (!sPrimaryComponent.isDestroyed()) {
+        //Using stringbuilder for fewer allocations
+        return QLatin1String{*sPrimaryComponent} % QLatin1String{"."} %
+            (debugComponent ? (QLatin1String{debugComponent} + QLatin1String{"."}) : QLatin1String{""}) %
+            (debugArea ? QLatin1String{debugArea} : QLatin1String{getFileName(file)});
+    } else {
+        return {};
     }
-    //Using stringbuilder for fewer allocations
-    return QLatin1String{sPrimaryComponent} % QLatin1String{"."} %
-        (debugComponent ? (QLatin1String{debugComponent} + QLatin1String{"."}) : QLatin1String{""}) %
-        (debugArea ? QLatin1String{debugArea} : QLatin1String{getFileName(file)});
 }
 
 static bool isFiltered(DebugLevel debugLevel, const QByteArray &fullDebugArea)
@@ -346,14 +357,19 @@ bool Sink::Log::isFiltered(DebugLevel debugLevel, const char *debugArea, const c
     return isFiltered(debugLevel, assembleDebugArea(debugArea, debugComponent, file).toLatin1());
 }
 
+Q_GLOBAL_STATIC(NullStream, sNullStream);
+Q_GLOBAL_STATIC(DebugStream, sDebugStream);
+
 QDebug Sink::Log::debugStream(DebugLevel debugLevel, int line, const char *file, const char *function, const char *debugArea, const char *debugComponent)
 {
     const auto fullDebugArea = assembleDebugArea(debugArea, debugComponent, file);
     collectDebugArea(fullDebugArea);
 
-    static NullStream nullstream;
     if (isFiltered(debugLevel, fullDebugArea.toLatin1())) {
-        return QDebug(&nullstream);
+        if (!sNullStream.isDestroyed()) {
+            return QDebug(sNullStream);
+        }
+        return QDebug{QtDebugMsg};
     }
 
     QString prefix;
@@ -418,8 +434,10 @@ QDebug Sink::Log::debugStream(DebugLevel debugLevel, int line, const char *file,
     }
     output += ":";
 
-    static DebugStream stream;
-    QDebug debug(&stream);
+    if (sDebugStream.isDestroyed()) {
+        return QDebug{QtDebugMsg};
+    }
+    QDebug debug(sDebugStream);
 
     debug.noquote().nospace() << output;
 
diff --git a/common/mail/threadindexer.cpp b/common/mail/threadindexer.cpp
index 4171d85..1401fc8 100644
--- a/common/mail/threadindexer.cpp
+++ b/common/mail/threadindexer.cpp
@@ -34,9 +34,37 @@ void ThreadIndexer::updateThreadingIndex(const QByteArray &identifier, const App
 
     QVector<QByteArray> thread;
 
-    //a child already registered our thread.
+    //check if a child already registered our thread.
     thread = index().secondaryLookup<Mail::MessageId, Mail::ThreadId>(messageId);
 
+    if (!thread.isEmpty()) {
+        //A child already registered our thread so we merge the childs thread
+        //* check if we have a parent thread, if not just continue as usual
+        //* get all messages that have the same threadid as the child
+        //* switch all to the parents thread
+        auto parentThread = index().secondaryLookup<Mail::MessageId, Mail::ThreadId>(parentMessageId);
+        if (!parentThread.isEmpty()) {
+            auto childThreadId = thread.first();
+            auto parentThreadId = parentThread.first();
+            SinkTrace() << "Merging child thread: " << childThreadId << " into parent thread: " << parentThreadId;
+
+            //Ensure this mail ends up in the correct thread
+            index().unindex<Mail::MessageId, Mail::ThreadId>(messageId, childThreadId, transaction);
+            //We have to copy the id here, otherwise it doesn't survive the subsequent writes
+            thread = QVector<QByteArray>() << QByteArray{parentThreadId.data(), parentThreadId.size()};
+
+            //Merge all child messages into the correct thread
+            auto childThreadMessageIds = index().secondaryLookup<Mail::ThreadId, Mail::MessageId>(childThreadId);
+            for (const auto &msgId : childThreadMessageIds) {
+                SinkTrace() << "Merging child message: " << msgId;
+                index().unindex<Mail::MessageId, Mail::ThreadId>(msgId, childThreadId, transaction);
+                index().unindex<Mail::ThreadId, Mail::MessageId>(childThreadId, msgId, transaction);
+                index().index<Mail::MessageId, Mail::ThreadId>(msgId, parentThreadId, transaction);
+                index().index<Mail::ThreadId, Mail::MessageId>(parentThreadId, msgId, transaction);
+            }
+        }
+    }
+
     //If parent is already available, add to thread of parent
     if (thread.isEmpty() && parentMessageId.isValid()) {
         thread = index().secondaryLookup<Mail::MessageId, Mail::ThreadId>(parentMessageId);
diff --git a/common/mailpreprocessor.cpp b/common/mailpreprocessor.cpp
index 5c54fbc..253e8b4 100644
--- a/common/mailpreprocessor.cpp
+++ b/common/mailpreprocessor.cpp
@@ -104,9 +104,6 @@ static void updatedIndexedProperties(Sink::ApplicationDomain::Mail &mail, KMime:
     mail.setExtractedBcc(getContactList(msg->bcc(true)));
     mail.setExtractedDate(msg->date(true)->dateTime());
 
-    //The rest should never change, unless we didn't have the headers available initially.
-    auto messageId = msg->messageID(true)->identifier();
-
     //Ensure the mssageId is unique.
     //If there already is one with the same id we'd have to assign a new message id, which probably doesn't make any sense.
 
@@ -125,12 +122,21 @@ static void updatedIndexedProperties(Sink::ApplicationDomain::Mail &mail, KMime:
             parentMessageId = inReplyTo.first();
         }
     }
+
+    //The rest should never change, unless we didn't have the headers available initially.
+    auto messageId = msg->messageID(true)->identifier();
     if (messageId.isEmpty()) {
-        auto tmp = KMime::Message::Ptr::create();
-        auto header = tmp->messageID(true);
-        header->generate("kube.kde.org");
-        messageId = header->as7BitString();
-        SinkWarning() << "Message id is empty, generating one: " << messageId;
+        //reuse an existing messageis (on modification)
+        auto existing = mail.getMessageId();
+        if (existing.isEmpty()) {
+            auto tmp = KMime::Message::Ptr::create();
+            auto header = tmp->messageID(true);
+            header->generate("kube.kde.org");
+            messageId = header->as7BitString();
+            SinkWarning() << "Message id is empty, generating one: " << messageId;
+        } else {
+            messageId = existing;
+        }
     }
 
     mail.setExtractedMessageId(messageId);
diff --git a/common/modelresult.cpp b/common/modelresult.cpp
index 58703ab..95f4643 100644
--- a/common/modelresult.cpp
+++ b/common/modelresult.cpp
@@ -298,16 +298,16 @@ void ModelResult<T, Ptr>::add(const Ptr &value)
     auto parent = createIndexFromId(id);
     SinkTraceCtx(mLogCtx) << "Added entity " << childId <<  "id: " << value->identifier() << "parent: " << id;
     const auto keys = mTree[id];
-    int index = 0;
-    for (; index < keys.size(); index++) {
-        if (childId < keys.at(index)) {
+    int idx = 0;
+    for (; idx < keys.size(); idx++) {
+        if (childId < keys.at(idx)) {
             break;
         }
     }
     // SinkTraceCtx(mLogCtx) << "Inserting rows " << index << parent;
-    beginInsertRows(parent, index, index);
+    beginInsertRows(parent, idx, idx);
     mEntities.insert(childId, value);
-    mTree[id].insert(index, childId);
+    mTree[id].insert(idx, childId);
     mParents.insert(childId, id);
     endInsertRows();
     // SinkTraceCtx(mLogCtx) << "Inserted rows " << mTree[id].size();
diff --git a/common/notification.cpp b/common/notification.cpp
index da31e20..20bc654 100644
--- a/common/notification.cpp
+++ b/common/notification.cpp
@@ -48,7 +48,7 @@ static QByteArray name(int type)
 
 QDebug operator<<(QDebug dbg, const Sink::Notification &n)
 {
-    dbg << "Notification(Type:" << name(n.type) << "Id, :" << n.id  << ", Code:";
+    dbg << "Notification(Type:" << name(n.type) << ", Id:" << n.id  << ", Code:";
     dbg << n.code;
     dbg << ", Message:" << n.message << ", Entities:" << n.entities << ")";
     return dbg.space();
diff --git a/common/notifier.cpp b/common/notifier.cpp
index 1af65e9..1b7cbdb 100644
--- a/common/notifier.cpp
+++ b/common/notifier.cpp
@@ -49,6 +49,7 @@ public:
 
     QList<QSharedPointer<ResourceAccess>> resourceAccess;
     QList<std::function<void(const Notification &)>> handler;
+    QSharedPointer<Sink::ResultEmitter<QSharedPointer<Sink::ApplicationDomain::SinkResource> > > mResourceEmitter;
     QObject context;
 };
 
@@ -91,6 +92,9 @@ Notifier::Notifier(const Sink::Query &resourceQuery) : d(new Sink::Notifier::Pri
         SinkTraceCtx(resourceCtx) << "Resource query complete";
     });
     emitter->fetch({});
+    if (resourceQuery.liveQuery()) {
+        d->mResourceEmitter = emitter;
+    }
     result.first.exec();
 }
 
diff --git a/common/resource.cpp b/common/resource.cpp
index 32a92ca..804f0bf 100644
--- a/common/resource.cpp
+++ b/common/resource.cpp
@@ -56,10 +56,10 @@ class ResourceFactory::Private
 {
 public:
     QByteArrayList capabilities;
-    static QHash<QString, QPointer<ResourceFactory>> s_loadedFactories;
 };
 
-QHash<QString, QPointer<ResourceFactory>> ResourceFactory::Private::s_loadedFactories;
+typedef QHash<QString, QPointer<ResourceFactory>> FactoryRegistry;
+Q_GLOBAL_STATIC(FactoryRegistry, s_loadedFactories);
 
 ResourceFactory::ResourceFactory(QObject *parent, const QByteArrayList &capabilities) : QObject(parent), d(new ResourceFactory::Private)
 {
@@ -73,7 +73,7 @@ ResourceFactory::~ResourceFactory()
 
 ResourceFactory *ResourceFactory::load(const QByteArray &resourceName)
 {
-    ResourceFactory *factory = Private::s_loadedFactories.value(resourceName);
+    ResourceFactory *factory = s_loadedFactories->value(resourceName);
     if (factory) {
         return factory;
     }
@@ -96,7 +96,7 @@ ResourceFactory *ResourceFactory::load(const QByteArray &resourceName)
                     if (object) {
                         factory = qobject_cast<ResourceFactory *>(object);
                         if (factory) {
-                            Private::s_loadedFactories.insert(resourceName, factory);
+                            s_loadedFactories->insert(resourceName, factory);
                             //TODO: Instead of always loading both facades and adaptorfactories into the respective singletons, we could also leave this up to the caller. (ResourceFactory::loadFacades(...))
                             factory->registerFacades(resourceName, FacadeFactory::instance());
                             factory->registerAdaptorFactories(resourceName, AdaptorFactoryRegistry::instance());
diff --git a/common/resourceaccess.cpp b/common/resourceaccess.cpp
index 808d892..35fa46c 100644
--- a/common/resourceaccess.cpp
+++ b/common/resourceaccess.cpp
@@ -232,7 +232,7 @@ KAsync::Job<void> ResourceAccess::Private::initializeSocket()
 ResourceAccess::ResourceAccess(const QByteArray &resourceInstanceIdentifier, const QByteArray &resourceType)
     : ResourceAccessInterface(), d(new Private(resourceType, resourceInstanceIdentifier, this))
 {
-    mResourceStatus = Sink::ApplicationDomain::OfflineStatus;
+    mResourceStatus = Sink::ApplicationDomain::NoStatus;
     SinkTrace() << "Starting access";
 }
 
diff --git a/common/resourcefacade.cpp b/common/resourcefacade.cpp
index dab6aed..0687bbc 100644
--- a/common/resourcefacade.cpp
+++ b/common/resourcefacade.cpp
@@ -24,6 +24,7 @@
 #include "store.h"
 #include "resourceaccess.h"
 #include "resource.h"
+#include "facadefactory.h"
 
 using namespace Sink;
 
@@ -358,27 +359,50 @@ QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain
     auto ctx = parentCtx.subContext("accounts");
     auto runner = new LocalStorageQueryRunner<ApplicationDomain::SinkAccount>(query, mIdentifier, mTypeName, sConfigNotifier, ctx);
     auto monitoredResources = QSharedPointer<QSet<QByteArray>>::create();
-    runner->setStatusUpdater([runner, monitoredResources, ctx](ApplicationDomain::SinkAccount &account) {
-        Query query;
+    auto monitorResource = [monitoredResources, runner, ctx] (const QByteArray &accountIdentifier, const ApplicationDomain::SinkResource &resource, const ResourceAccess::Ptr &resourceAccess) {
+        if (!monitoredResources->contains(resource.identifier())) {
+            auto ret = QObject::connect(resourceAccess.data(), &ResourceAccess::notification, runner->guard(), [resource, runner, resourceAccess, accountIdentifier, ctx](const Notification &notification) {
+                SinkTraceCtx(ctx) << "Received notification in facade: " << notification.type;
+                if (notification.type == Notification::Status) {
+                    runner->statusChanged(accountIdentifier);
+                }
+            });
+            Q_ASSERT(ret);
+            monitoredResources->insert(resource.identifier());
+        }
+    };
+    runner->setStatusUpdater([this, runner, monitoredResources, ctx, monitorResource](ApplicationDomain::SinkAccount &account) {
+        Query query{Query::LiveQuery};
         query.filter<ApplicationDomain::SinkResource::Account>(account.identifier());
         query.request<ApplicationDomain::SinkResource::Account>()
              .request<ApplicationDomain::SinkResource::Capabilities>();
         const auto resources = Store::read<ApplicationDomain::SinkResource>(query);
         SinkTraceCtx(ctx) << "Found resource belonging to the account " << account.identifier() << " : " << resources;
         auto accountIdentifier = account.identifier();
+
+        //Monitor for new resources so they can be monitored as well
+        if (!runner->mResourceEmitter.contains(accountIdentifier)) {
+            auto facade = Sink::FacadeFactory::instance().getFacade<ApplicationDomain::SinkResource>();
+            Q_ASSERT(facade);
+
+            auto emitter = facade->load(query, ctx).second;
+            emitter->onAdded([=](const ApplicationDomain::SinkResource::Ptr &resource) {
+                auto resourceAccess = Sink::ResourceAccessFactory::instance().getAccess(resource->identifier(), ResourceConfig::getResourceType(resource->identifier()));
+                monitorResource(accountIdentifier, *resource, resourceAccess);
+            });
+            emitter->onModified([](const ApplicationDomain::SinkResource::Ptr &) {});
+            emitter->onRemoved([](const ApplicationDomain::SinkResource::Ptr &) {});
+            emitter->onInitialResultSetComplete([](const ApplicationDomain::SinkResource::Ptr &, bool) {});
+            emitter->onComplete([]() {});
+            emitter->fetch({});
+            runner->mResourceEmitter[accountIdentifier] = emitter;
+        }
+
         QList<int> states;
+        //Gather all resources and ensure they are monitored
         for (const auto &resource : resources) {
             auto resourceAccess = ResourceAccessFactory::instance().getAccess(resource.identifier(), ResourceConfig::getResourceType(resource.identifier()));
-            if (!monitoredResources->contains(resource.identifier())) {
-                auto ret = QObject::connect(resourceAccess.data(), &ResourceAccess::notification, runner->guard(), [resource, runner, resourceAccess, accountIdentifier, ctx](const Notification &notification) {
-                    SinkTraceCtx(ctx) << "Received notification in facade: " << notification.type;
-                    if (notification.type == Notification::Status) {
-                        runner->statusChanged(accountIdentifier);
-                    }
-                });
-                Q_ASSERT(ret);
-                monitoredResources->insert(resource.identifier());
-            }
+            monitorResource(accountIdentifier, resource, resourceAccess);
             states << resourceAccess->getResourceStatus();
         }
         const auto status = [&] {
@@ -391,7 +415,10 @@ QPair<KAsync::Job<void>, typename Sink::ResultEmitter<typename ApplicationDomain
             if (states.contains(ApplicationDomain::OfflineStatus)) {
                 return ApplicationDomain::OfflineStatus;
             }
-            return ApplicationDomain::ConnectedStatus;
+            if (states.contains(ApplicationDomain::ConnectedStatus)) {
+                return ApplicationDomain::ConnectedStatus;
+            }
+            return ApplicationDomain::NoStatus;
         }();
         account.setStatusStatus(status);
     });
diff --git a/common/resourcefacade.h b/common/resourcefacade.h
index 76fadce..36049c4 100644
--- a/common/resourcefacade.h
+++ b/common/resourcefacade.h
@@ -65,6 +65,7 @@ public:
     void setStatusUpdater(const std::function<void(DomainType &)> &);
     void statusChanged(const QByteArray &identifier);
     QObject *guard() const;
+    QMap<QByteArray, QSharedPointer<Sink::ResultEmitter<QSharedPointer<Sink::ApplicationDomain::SinkResource> > > > mResourceEmitter;
 
 private:
     void updateStatus(DomainType &entity);
diff --git a/common/storage.h b/common/storage.h
index 8c129df..c39b904 100644
--- a/common/storage.h
+++ b/common/storage.h
@@ -198,9 +198,9 @@ public:
     static QByteArray getTypeFromRevision(const Transaction &, qint64 revision);
     static void recordRevision(Transaction &, qint64 revision, const QByteArray &uid, const QByteArray &type);
     static void removeRevision(Transaction &, qint64 revision);
-    static void recordUid(DataStore::Transaction &transaction, const QByteArray &uid);
-    static void removeUid(DataStore::Transaction &transaction, const QByteArray &uid);
-    static void getUids(const Transaction &, const std::function<void(const QByteArray &uid)> &);
+    static void recordUid(DataStore::Transaction &transaction, const QByteArray &uid, const QByteArray &type);
+    static void removeUid(DataStore::Transaction &transaction, const QByteArray &uid, const QByteArray &type);
+    static void getUids(const QByteArray &type, const Transaction &, const std::function<void(const QByteArray &uid)> &);
 
     bool exists() const;
 
diff --git a/common/storage/entitystore.cpp b/common/storage/entitystore.cpp
index 22e5ae3..5514e31 100644
--- a/common/storage/entitystore.cpp
+++ b/common/storage/entitystore.cpp
@@ -267,7 +267,7 @@ bool EntityStore::add(const QByteArray &type, ApplicationDomain::ApplicationDoma
             [&](const DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Failed to write entity" << entity.identifier() << newRevision; });
     DataStore::setMaxRevision(d->transaction, newRevision);
     DataStore::recordRevision(d->transaction, newRevision, entity.identifier(), type);
-    DataStore::recordUid(d->transaction, entity.identifier());
+    DataStore::recordUid(d->transaction, entity.identifier(), type);
     SinkTraceCtx(d->logCtx) << "Wrote entity: " << entity.identifier() << type << newRevision;
     return true;
 }
@@ -379,7 +379,7 @@ bool EntityStore::remove(const QByteArray &type, const Sink::ApplicationDomain::
             [&](const DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Failed to write entity" << uid << newRevision; });
     DataStore::setMaxRevision(d->transaction, newRevision);
     DataStore::recordRevision(d->transaction, newRevision, uid, type);
-    DataStore::removeUid(d->transaction, uid);
+    DataStore::removeUid(d->transaction, uid, type);
     return true;
 }
 
@@ -516,9 +516,8 @@ void EntityStore::readLatest(const QByteArray &type, const QByteArray &uid, cons
 {
     auto db = DataStore::mainDatabase(d->getTransaction(), type);
     db.findLatest(uid,
-        [=](const QByteArray &key, const QByteArray &value) -> bool {
+        [=](const QByteArray &key, const QByteArray &value) {
             callback(DataStore::uidFromKey(key), Sink::EntityBuffer(value.data(), value.size()));
-            return false;
         },
         [&](const DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Error during query: " << error.message << uid; });
 }
@@ -639,7 +638,7 @@ ApplicationDomain::ApplicationDomainType EntityStore::readPrevious(const QByteAr
 
 void EntityStore::readAllUids(const QByteArray &type, const std::function<void(const QByteArray &uid)> callback)
 {
-    DataStore::getUids(d->getTransaction(), callback);
+    DataStore::getUids(type, d->getTransaction(), callback);
 }
 
 bool EntityStore::contains(const QByteArray &type, const QByteArray &uid)
@@ -653,7 +652,7 @@ bool EntityStore::exists(const QByteArray &type, const QByteArray &uid)
     bool alreadyRemoved = false;
     DataStore::mainDatabase(d->transaction, type)
         .findLatest(uid,
-            [&found, &alreadyRemoved](const QByteArray &key, const QByteArray &data) -> bool {
+            [&found, &alreadyRemoved](const QByteArray &key, const QByteArray &data) {
                 auto entity = GetEntity(data.data());
                 if (entity && entity->metadata()) {
                     auto metadata = GetMetadata(entity->metadata()->Data());
@@ -662,7 +661,6 @@ bool EntityStore::exists(const QByteArray &type, const QByteArray &uid)
                         alreadyRemoved = true;
                     }
                 }
-                return false;
             },
             [&](const DataStore::Error &error) { SinkWarningCtx(d->logCtx) << "Failed to read old revision from storage: " << error.message; });
     if (!found) {
diff --git a/common/storage_common.cpp b/common/storage_common.cpp
index 8603787..630dae9 100644
--- a/common/storage_common.cpp
+++ b/common/storage_common.cpp
@@ -156,19 +156,19 @@ void DataStore::removeRevision(DataStore::Transaction &transaction, qint64 revis
     transaction.openDatabase("revisionType").remove(QByteArray::number(revision));
 }
 
-void DataStore::recordUid(DataStore::Transaction &transaction, const QByteArray &uid)
+void DataStore::recordUid(DataStore::Transaction &transaction, const QByteArray &uid, const QByteArray &type)
 {
-    transaction.openDatabase("uids").write(uid, "");
+    transaction.openDatabase(type + "uids").write(uid, "");
 }
 
-void DataStore::removeUid(DataStore::Transaction &transaction, const QByteArray &uid)
+void DataStore::removeUid(DataStore::Transaction &transaction, const QByteArray &uid, const QByteArray &type)
 {
-    transaction.openDatabase("uids").remove(uid);
+    transaction.openDatabase(type + "uids").remove(uid);
 }
 
-void DataStore::getUids(const Transaction &transaction, const std::function<void(const QByteArray &uid)> &callback)
+void DataStore::getUids(const QByteArray &type, const Transaction &transaction, const std::function<void(const QByteArray &uid)> &callback)
 {
-    transaction.openDatabase("uids").scan("", [&] (const QByteArray &key, const QByteArray &) {
+    transaction.openDatabase(type + "uids").scan("", [&] (const QByteArray &key, const QByteArray &) {
         callback(key);
         return true;
     });
diff --git a/common/storage_lmdb.cpp b/common/storage_lmdb.cpp
index f7999d1..58e3a9a 100644
--- a/common/storage_lmdb.cpp
+++ b/common/storage_lmdb.cpp
@@ -406,7 +406,7 @@ int DataStore::NamedDatabase::scan(const QByteArray &k, const std::function<bool
     mdb_cursor_close(cursor);
 
     if (rc) {
-        Error error(d->name.toLatin1() + d->db, getErrorCode(rc), QByteArray("Key: ") + k + " : " + QByteArray(mdb_strerror(rc)));
+        Error error(d->name.toLatin1() + d->db, getErrorCode(rc), QByteArray("Error during scan. Key: ") + k + " : " + QByteArray(mdb_strerror(rc)));
         errorHandler ? errorHandler(error) : d->defaultErrorHandler(error);
     }
 
@@ -420,6 +420,11 @@ void DataStore::NamedDatabase::findLatest(const QByteArray &k, const std::functi
         // Not an error. We rely on this to read nothing from non-existing databases.
         return;
     }
+    if (k.isEmpty()) {
+        Error error(d->name.toLatin1() + d->db, GenericError, QByteArray("Can't use findLatest with empty key."));
+        errorHandler ? errorHandler(error) : d->defaultErrorHandler(error);
+        return;
+    }
 
     int rc;
     MDB_val key;
@@ -441,25 +446,23 @@ void DataStore::NamedDatabase::findLatest(const QByteArray &k, const std::functi
     if ((rc = mdb_cursor_get(cursor, &key, &data, op)) == 0) {
         // The first lookup will find a key that is equal or greather than our key
         if (QByteArray::fromRawData((char *)key.mv_data, key.mv_size).startsWith(k)) {
-            bool advanced = false;
+            //Read next value until we no longer match
             while (QByteArray::fromRawData((char *)key.mv_data, key.mv_size).startsWith(k)) {
-                advanced = true;
                 MDB_cursor_op nextOp = MDB_NEXT;
                 rc = mdb_cursor_get(cursor, &key, &data, nextOp);
                 if (rc) {
                     break;
                 }
             }
-            if (advanced) {
-                MDB_cursor_op prefOp = MDB_PREV;
-                // We read past the end above, just take the last value
-                if (rc == MDB_NOTFOUND) {
-                    prefOp = MDB_LAST;
-                }
-                rc = mdb_cursor_get(cursor, &key, &data, prefOp);
-                foundValue = true;
-                resultHandler(QByteArray::fromRawData((char *)key.mv_data, key.mv_size), QByteArray::fromRawData((char *)data.mv_data, data.mv_size));
+            //Now read the previous value, and that's the latest one
+            MDB_cursor_op prefOp = MDB_PREV;
+            // We read past the end above, just take the last value
+            if (rc == MDB_NOTFOUND) {
+                prefOp = MDB_LAST;
             }
+            rc = mdb_cursor_get(cursor, &key, &data, prefOp);
+            foundValue = true;
+            resultHandler(QByteArray::fromRawData((char *)key.mv_data, key.mv_size), QByteArray::fromRawData((char *)data.mv_data, data.mv_size));
         }
     }
 
@@ -471,10 +474,10 @@ void DataStore::NamedDatabase::findLatest(const QByteArray &k, const std::functi
     mdb_cursor_close(cursor);
 
     if (rc) {
-        Error error(d->name.toLatin1(), getErrorCode(rc), QByteArray("Key: ") + k + " : " + QByteArray(mdb_strerror(rc)));
+        Error error(d->name.toLatin1(), getErrorCode(rc), QByteArray("Error during find latest. Key: ") + k + " : " + QByteArray(mdb_strerror(rc)));
         errorHandler ? errorHandler(error) : d->defaultErrorHandler(error);
     } else if (!foundValue) {
-        Error error(d->name.toLatin1(), 1, QByteArray("Key: ") + k + " : No value found");
+        Error error(d->name.toLatin1(), 1, QByteArray("Error during find latest. Key: ") + k + " : No value found");
         errorHandler ? errorHandler(error) : d->defaultErrorHandler(error);
     }
 
diff --git a/common/store.cpp b/common/store.cpp
index 4735113..1701a43 100644
--- a/common/store.cpp
+++ b/common/store.cpp
@@ -36,10 +36,34 @@
 #include "storage.h"
 #include "log.h"
 
+#define ASSERT_ENUMS_MATCH(A, B) Q_STATIC_ASSERT_X(static_cast<int>(A) == static_cast<int>(B), "The enum values must match");
+
+//Ensure the copied enum matches
+typedef ModelResult<Sink::ApplicationDomain::Mail, Sink::ApplicationDomain::Mail::Ptr> MailModelResult;
+ASSERT_ENUMS_MATCH(Sink::Store::DomainObjectBaseRole, MailModelResult::DomainObjectBaseRole)
+ASSERT_ENUMS_MATCH(Sink::Store::ChildrenFetchedRole, MailModelResult::ChildrenFetchedRole)
+ASSERT_ENUMS_MATCH(Sink::Store::DomainObjectRole, MailModelResult::DomainObjectRole)
+ASSERT_ENUMS_MATCH(Sink::Store::StatusRole, MailModelResult::StatusRole)
+ASSERT_ENUMS_MATCH(Sink::Store::WarningRole, MailModelResult::WarningRole)
+ASSERT_ENUMS_MATCH(Sink::Store::ProgressRole, MailModelResult::ProgressRole)
+
 Q_DECLARE_METATYPE(QSharedPointer<Sink::ResultEmitter<Sink::ApplicationDomain::SinkResource::Ptr>>)
 Q_DECLARE_METATYPE(QSharedPointer<Sink::ResourceAccessInterface>);
 Q_DECLARE_METATYPE(std::shared_ptr<void>);
 
+
+static bool sanityCheckQuery(const Sink::Query &query)
+{
+    for (const auto &id : query.ids()) {
+        if (id.isEmpty()) {
+            SinkError() << "Empty id in query.";
+            return false;
+        }
+    }
+    return true;
+}
+
+
 namespace Sink {
 
 QString Store::storageLocation()
@@ -138,6 +162,7 @@ static Log::Context getQueryContext(const Sink::Query &query, const QByteArray &
 template <class DomainType>
 QSharedPointer<QAbstractItemModel> Store::loadModel(const Query &query)
 {
+    Q_ASSERT(sanityCheckQuery(query));
     auto ctx = getQueryContext(query, ApplicationDomain::getTypeName<DomainType>());
     auto model = QSharedPointer<ModelResult<DomainType, typename DomainType::Ptr>>::create(query, query.requestedProperties, ctx);
 
@@ -189,6 +214,10 @@ KAsync::Job<void> Store::create(const DomainType &domainObject)
 template <class DomainType>
 KAsync::Job<void> Store::modify(const DomainType &domainObject)
 {
+    if (domainObject.changedProperties().isEmpty()) {
+        SinkLog() << "Nothing to modify: " << domainObject.identifier();
+        return KAsync::null();
+    }
     SinkLog() << "Modify: " << domainObject;
     // Potentially move to separate thread as well
     auto facade = getFacade<DomainType>(domainObject.resourceInstanceIdentifier());
@@ -198,6 +227,10 @@ KAsync::Job<void> Store::modify(const DomainType &domainObject)
 template <class DomainType>
 KAsync::Job<void> Store::modify(const Query &query, const DomainType &domainObject)
 {
+    if (domainObject.changedProperties().isEmpty()) {
+        SinkLog() << "Nothing to modify: " << domainObject.identifier();
+        return KAsync::null();
+    }
     SinkLog() << "Modify: " << query << domainObject;
     return fetchAll<DomainType>(query)
         .each([=] (const typename DomainType::Ptr &entity) {
@@ -311,9 +344,14 @@ KAsync::Job<void> Store::synchronize(const Sink::Query &query)
 
 KAsync::Job<void> Store::synchronize(const Sink::SyncScope &scope)
 {
+    auto resourceFilter = scope.getResourceFilter();
+    //Filter resources by type by default
+    if (!resourceFilter.propertyFilter.contains(ApplicationDomain::SinkResource::Capabilities::name) && !scope.type().isEmpty()) {
+        resourceFilter.propertyFilter.insert(ApplicationDomain::SinkResource::Capabilities::name, Query::Comparator{scope.type(), Query::Comparator::Contains});
+    }
     Sink::Query query;
-    query.setFilter(scope.getResourceFilter());
-    SinkLog() << "Synchronizing: " << query;
+    query.setFilter(resourceFilter);
+    SinkLog() << "Synchronizing all resource matching: " << query;
     return fetchAll<ApplicationDomain::SinkResource>(query)
         .template each([scope](const ApplicationDomain::SinkResource::Ptr &resource) -> KAsync::Job<void> {
             return synchronize(resource->identifier(), scope);
@@ -337,6 +375,7 @@ KAsync::Job<QList<typename DomainType::Ptr>> Store::fetchAll(const Sink::Query &
 template <class DomainType>
 KAsync::Job<QList<typename DomainType::Ptr>> Store::fetch(const Sink::Query &query, int minimumAmount)
 {
+    Q_ASSERT(sanityCheckQuery(query));
     auto model = loadModel<DomainType>(query);
     auto list = QSharedPointer<QList<typename DomainType::Ptr>>::create();
     auto context = QSharedPointer<QObject>::create();
@@ -388,6 +427,7 @@ DomainType Store::readOne(const Sink::Query &query)
 template <class DomainType>
 QList<DomainType> Store::read(const Sink::Query &query_)
 {
+    Q_ASSERT(sanityCheckQuery(query_));
     auto query = query_;
     query.setFlags(Query::SynchronousQuery);
 
diff --git a/common/store.h b/common/store.h
index 34e14df..3ad547e 100644
--- a/common/store.h
+++ b/common/store.h
@@ -75,12 +75,15 @@ KAsync::Job<void> SINK_EXPORT create(const DomainType &domainObject);
  * Modify an entity.
  *
  * This includes moving etc. since these are also simple settings on a property.
+ * Note that the modification will be dropped if there is no changedProperty on the domain object.
  */
 template <class DomainType>
 KAsync::Job<void> SINK_EXPORT modify(const DomainType &domainObject);
 
 /**
  * Modify a set of entities identified by @param query.
+ * 
+ * Note that the modification will be dropped if there is no changedProperty on the domain object.
  */
 template <class DomainType>
 KAsync::Job<void> SINK_EXPORT modify(const Query &query, const DomainType &domainObject);
diff --git a/common/synchronizer.cpp b/common/synchronizer.cpp
index 3b32e68..46d3980 100644
--- a/common/synchronizer.cpp
+++ b/common/synchronizer.cpp
@@ -40,7 +40,7 @@ Synchronizer::Synchronizer(const Sink::ResourceContext &context)
     mSyncStorage(Sink::storageLocation(), mResourceContext.instanceId() + ".synchronization", Sink::Storage::DataStore::DataStore::ReadWrite),
     mSyncInProgress(false)
 {
-    mCurrentState.push(ApplicationDomain::Status::OfflineStatus);
+    mCurrentState.push(ApplicationDomain::Status::NoStatus);
     SinkTraceCtx(mLogCtx) << "Starting synchronizer: " << mResourceContext.resourceType << mResourceContext.instanceId();
 }
 
@@ -344,8 +344,11 @@ void Synchronizer::setStatusFromResult(const KAsync::Error &error, const QString
         } else if (error.errorCode == ApplicationDomain::LoginError) {
             //If we failed to login altough we could connect that indicates a problem with our setup.
             setStatus(ApplicationDomain::ErrorStatus, s, requestId);
+        } else if (error.errorCode == ApplicationDomain::ConnectionLostError) {
+            //We've lost the connection so we assume the connection to the server broke.
+            setStatus(ApplicationDomain::OfflineStatus, s, requestId);
         }
-        //We don't know what kind of error this was, so we assume it's transient and don't change ou status.
+        //We don't know what kind of error this was, so we assume it's transient and don't change our status.
     } else {
         //An operation against the server worked, so we're probably online.
         setStatus(ApplicationDomain::ConnectedStatus, s, requestId);
@@ -593,17 +596,13 @@ KAsync::Job<void> Synchronizer::replay(const QByteArray &type, const QByteArray
     KAsync::Job<QByteArray> job = KAsync::null<QByteArray>();
     //TODO This requires supporting every domain type here as well. Can we solve this better so we can do the dispatch somewhere centrally?
     if (type == ApplicationDomain::getTypeName<ApplicationDomain::Folder>()) {
-        auto folder = store().readEntity<ApplicationDomain::Folder>(key);
-        job = replay(folder, operation, oldRemoteId, modifiedProperties);
+        job = replay(store().readEntity<ApplicationDomain::Folder>(key), operation, oldRemoteId, modifiedProperties);
     } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Mail>()) {
-        auto mail = store().readEntity<ApplicationDomain::Mail>(key);
-        job = replay(mail, operation, oldRemoteId, modifiedProperties);
+        job = replay(store().readEntity<ApplicationDomain::Mail>(key), operation, oldRemoteId, modifiedProperties);
     } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Contact>()) {
-        auto mail = store().readEntity<ApplicationDomain::Contact>(key);
-        job = replay(mail, operation, oldRemoteId, modifiedProperties);
+        job = replay(store().readEntity<ApplicationDomain::Contact>(key), operation, oldRemoteId, modifiedProperties);
     } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Addressbook>()) {
-        auto mail = store().readEntity<ApplicationDomain::Addressbook>(key);
-        job = replay(mail, operation, oldRemoteId, modifiedProperties);
+        job = replay(store().readEntity<ApplicationDomain::Addressbook>(key), operation, oldRemoteId, modifiedProperties);
     } else {
         SinkErrorCtx(mLogCtx) << "Replayed unknown type: " << type;
     }