18 files changed, 240 insertions, 126 deletions

diff --git a/examples/davresource/CMakeLists.txt b/examples/davresource/CMakeLists.txt
index 28829d5..7091edc 100644
--- a/examples/davresource/CMakeLists.txt
+++ b/examples/davresource/CMakeLists.txt
@@ -3,10 +3,10 @@ project(sink_resource_dav)
 add_definitions(-DQT_PLUGIN)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
-find_package(KPimKDAV REQUIRED)
+find_package(KPimKDAV2 REQUIRED)
 
 add_library(${PROJECT_NAME} SHARED davresource.cpp)
 qt5_use_modules(${PROJECT_NAME} Core Network)
-target_link_libraries(${PROJECT_NAME} sink KPim::KDAV)
+target_link_libraries(${PROJECT_NAME} sink KPim::KDAV2)
 
 install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${SINK_RESOURCE_PLUGINS_PATH})
diff --git a/examples/davresource/davresource.cpp b/examples/davresource/davresource.cpp
index 50471ed..465220f 100644
--- a/examples/davresource/davresource.cpp
+++ b/examples/davresource/davresource.cpp
@@ -31,19 +31,17 @@
 
 #include "contactpreprocessor.h"
 
-#include <KDAV/DavCollection>
-#include <KDAV/DavCollectionsFetchJob>
-#include <KDAV/DavItem>
-#include <KDAV/DavItemsListJob>
-#include <KDAV/DavItemFetchJob>
-#include <KDAV/EtagCache>
+#include <KDAV2/DavCollection>
+#include <KDAV2/DavCollectionsFetchJob>
+#include <KDAV2/DavItem>
+#include <KDAV2/DavItemsListJob>
+#include <KDAV2/DavItemFetchJob>
+#include <KDAV2/EtagCache>
 
 //This is the resources entity type, and not the domain type
 #define ENTITY_TYPE_CONTACT "contact"
 #define ENTITY_TYPE_ADDRESSBOOK "addressbook"
 
-SINK_DEBUG_AREA("davresource")
-
 using namespace Sink;
 
 static KAsync::Job<void> runJob(KJob *job)
@@ -87,7 +85,7 @@ public:
         return remoteId;
     }
 
-    void synchronizeAddressbooks(const KDAV::DavCollection::List &addressbookList)
+    void synchronizeAddressbooks(const KDAV2::DavCollection::List &addressbookList)
     {
         const QByteArray bufferType = ENTITY_TYPE_ADDRESSBOOK;
         SinkTrace() << "Found addressbooks " << addressbookList.size();
@@ -121,12 +119,12 @@ public:
         return list;
     }
 
-    static QByteArray getRid(const KDAV::DavItem &item)
+    static QByteArray getRid(const KDAV2::DavItem &item)
     {
         return item.url().toDisplayString().toUtf8();
     }
 
-    static QByteArray getRid(const KDAV::DavCollection &item)
+    static QByteArray getRid(const KDAV2::DavCollection &item)
     {
         return item.url().toDisplayString().toUtf8();
     }
@@ -135,7 +133,7 @@ public:
     {
         if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Addressbook>()) {
             SinkLogCtx(mLogCtx) << "Synchronizing addressbooks:" <<  mResourceUrl.url();
-            auto collectionsFetchJob = new KDAV::DavCollectionsFetchJob(mResourceUrl);
+            auto collectionsFetchJob = new KDAV2::DavCollectionsFetchJob(mResourceUrl);
             auto job = runJob(collectionsFetchJob).then([this, collectionsFetchJob] (const KAsync::Error &error) {
                 if (error) {
                     SinkWarningCtx(mLogCtx) << "Failed to synchronize addressbooks." << collectionsFetchJob->errorString();
@@ -147,29 +145,29 @@ public:
         } else if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Contact>()) {
             SinkLogCtx(mLogCtx) << "Synchronizing contacts.";
             auto ridList = QSharedPointer<QByteArrayList>::create();
-            auto collectionsFetchJob = new KDAV::DavCollectionsFetchJob(mResourceUrl);
+            auto collectionsFetchJob = new KDAV2::DavCollectionsFetchJob(mResourceUrl);
             auto job = runJob(collectionsFetchJob).then([this, collectionsFetchJob] {
                 synchronizeAddressbooks(collectionsFetchJob ->collections());
                 return collectionsFetchJob->collections();
             })
-            .serialEach([this, ridList](const KDAV::DavCollection &collection) {
+            .serialEach([this, ridList](const KDAV2::DavCollection &collection) {
                 auto collId = getRid(collection);
                 const auto addressbookLocalId = syncStore().resolveRemoteId(ENTITY_TYPE_ADDRESSBOOK, collId);
                 auto ctag = collection.CTag().toLatin1();
                 if (ctag != syncStore().readValue(collId + "_ctagXX")) {
                     SinkTraceCtx(mLogCtx) << "Syncing " << collId;
-                    auto cache = std::shared_ptr<KDAV::EtagCache>(new KDAV::EtagCache());
-                    auto davItemsListJob = new KDAV::DavItemsListJob(collection.url(), cache);
+                    auto cache = std::shared_ptr<KDAV2::EtagCache>(new KDAV2::EtagCache());
+                    auto davItemsListJob = new KDAV2::DavItemsListJob(collection.url(), cache);
                     const QByteArray bufferType = ENTITY_TYPE_CONTACT;
                     QHash<QByteArray, Query::Comparator> mergeCriteria;
                     auto colljob = runJob(davItemsListJob).then([davItemsListJob] {
                         return KAsync::value(davItemsListJob->items());
                     })
-                    .serialEach([=] (const KDAV::DavItem &item) {
+                    .serialEach([=] (const KDAV2::DavItem &item) {
                         QByteArray rid = getRid(item);
                         if (item.etag().toLatin1() != syncStore().readValue(rid + "_etag")){
                             SinkTrace() << "Updating " << rid;
-                            auto davItemFetchJob = new KDAV::DavItemFetchJob(item);
+                            auto davItemFetchJob = new KDAV2::DavItemFetchJob(item);
                             auto itemjob = runJob(davItemFetchJob)
                             .then([=] {
                                 const auto item = davItemFetchJob->item();
@@ -180,7 +178,7 @@ public:
                                 createOrModify(bufferType, rid, contact, mergeCriteria);
                                 return item;
                             })
-                            .then([this, ridList] (const KDAV::DavItem &item) {
+                            .then([this, ridList] (const KDAV2::DavItem &item) {
                                 const auto rid = getRid(item);
                                 syncStore().writeValue(rid + "_etag", item.etag().toLatin1());
                                 ridList->append(rid);
@@ -227,24 +225,19 @@ KAsync::Job<QByteArray> replay(const ApplicationDomain::Contact &contact, Sink::
     }
 
 public:
-    KDAV::DavUrl mResourceUrl;
+    KDAV2::DavUrl mResourceUrl;
 };
 
 
 DavResource::DavResource(const Sink::ResourceContext &resourceContext)
     : Sink::GenericResource(resourceContext)
 {
-    /*
-     * Fork KIO slaves (used in kdav), instead of starting them via klauncher.
-     * Otherwise we have yet another runtime dependency that will i.e. not work in the docker container.
-     */
-    qputenv("KDE_FORK_SLAVES", "TRUE");
     auto config = ResourceConfig::getConfiguration(resourceContext.instanceId());
     auto resourceUrl = QUrl::fromUserInput(config.value("server").toString());
     resourceUrl.setUserName(config.value("username").toString());
     resourceUrl.setPassword(config.value("password").toString());
 
-    mResourceUrl = KDAV::DavUrl(resourceUrl, KDAV::CardDav);
+    mResourceUrl = KDAV2::DavUrl(resourceUrl, KDAV2::CardDav);
 
     auto synchronizer = QSharedPointer<ContactSynchronizer>::create(resourceContext);
     synchronizer->mResourceUrl = mResourceUrl;
@@ -271,7 +264,7 @@ Sink::Resource *DavResourceFactory::createResource(const ResourceContext &contex
 void DavResourceFactory::registerFacades(const QByteArray &name, Sink::FacadeFactory &factory)
 {
     factory.registerFacade<ApplicationDomain::Contact, DefaultFacade<ApplicationDomain::Contact>>(name);
-    factory.registerFacade<ApplicationDomain::Addressbook, DefaultFacade<ApplicationDomain::Contact>>(name);
+    factory.registerFacade<ApplicationDomain::Addressbook, DefaultFacade<ApplicationDomain::Addressbook>>(name);
 }
 
 void DavResourceFactory::registerAdaptorFactories(const QByteArray &name, Sink::AdaptorFactoryRegistry &registry)
diff --git a/examples/davresource/davresource.h b/examples/davresource/davresource.h
index 1ce66ea..db175a4 100644
--- a/examples/davresource/davresource.h
+++ b/examples/davresource/davresource.h
@@ -21,7 +21,7 @@
 
 #include "common/genericresource.h"
 
-#include <KDAV/DavUrl>
+#include <KDAV2/DavUrl>
 #include <KAsync/Async>
 
 #include <flatbuffers/flatbuffers.h>
@@ -48,7 +48,7 @@ public:
 private:
     QStringList listAvailableFolders();
 
-    KDAV::DavUrl mResourceUrl;
+    KDAV2::DavUrl mResourceUrl;
 };
 
 class DavResourceFactory : public Sink::ResourceFactory
diff --git a/examples/dummyresource/domainadaptor.cpp b/examples/dummyresource/domainadaptor.cpp
index dcc08c7..e7a20da 100644
--- a/examples/dummyresource/domainadaptor.cpp
+++ b/examples/dummyresource/domainadaptor.cpp
@@ -28,9 +28,6 @@ using namespace flatbuffers;
 DummyEventAdaptorFactory::DummyEventAdaptorFactory()
     : DomainTypeAdaptorFactory()
 {
-    //TODO turn this into initializeReadPropertyMapper as well?
-    mResourceMapper->addMapping<Sink::ApplicationDomain::Event::Summary, DummyEvent>(&DummyEvent::summary);
-    mResourceWriteMapper->addMapping<Sink::ApplicationDomain::Event::Summary>(&DummyEventBuilder::add_summary);
 }
 
 DummyMailAdaptorFactory::DummyMailAdaptorFactory()
diff --git a/examples/dummyresource/domainadaptor.h b/examples/dummyresource/domainadaptor.h
index e7098e9..3faaa63 100644
--- a/examples/dummyresource/domainadaptor.h
+++ b/examples/dummyresource/domainadaptor.h
@@ -22,25 +22,23 @@
 #include "event_generated.h"
 #include "mail_generated.h"
 #include "folder_generated.h"
-#include "dummy_generated.h"
-#include "dummycalendar_generated.h"
 #include "entity_generated.h"
 
-class DummyEventAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Event, DummyCalendar::DummyEvent, DummyCalendar::DummyEventBuilder>
+class DummyEventAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Event>
 {
 public:
     DummyEventAdaptorFactory();
     virtual ~DummyEventAdaptorFactory() {};
 };
 
-class DummyMailAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Mail, Sink::ApplicationDomain::Buffer::Dummy, Sink::ApplicationDomain::Buffer::DummyBuilder>
+class DummyMailAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Mail>
 {
 public:
     DummyMailAdaptorFactory();
     virtual ~DummyMailAdaptorFactory() {};
 };
 
-class DummyFolderAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Folder, Sink::ApplicationDomain::Buffer::Dummy, Sink::ApplicationDomain::Buffer::DummyBuilder>
+class DummyFolderAdaptorFactory : public DomainTypeAdaptorFactory<Sink::ApplicationDomain::Folder>
 {
 public:
     DummyFolderAdaptorFactory();
diff --git a/examples/dummyresource/resourcefactory.cpp b/examples/dummyresource/resourcefactory.cpp
index c1f536e..dffdfc9 100644
--- a/examples/dummyresource/resourcefactory.cpp
+++ b/examples/dummyresource/resourcefactory.cpp
@@ -42,8 +42,6 @@
 #define ENTITY_TYPE_MAIL "mail"
 #define ENTITY_TYPE_FOLDER "folder"
 
-SINK_DEBUG_AREA("dummyresource")
-
 using namespace Sink;
 
 class DummySynchronizer : public Sink::Synchronizer {
diff --git a/examples/imapresource/CMakeLists.txt b/examples/imapresource/CMakeLists.txt
index 46a8b08..5d2d38b 100644
--- a/examples/imapresource/CMakeLists.txt
+++ b/examples/imapresource/CMakeLists.txt
@@ -4,7 +4,7 @@ add_definitions(-DQT_PLUGIN)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
 find_package(KF5 COMPONENTS REQUIRED Mime)
-find_package(KIMAP2 0.0.1 REQUIRED)
+find_package(KIMAP2 0.2 REQUIRED)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
diff --git a/examples/imapresource/imapresource.cpp b/examples/imapresource/imapresource.cpp
index 0579dae..81c808b 100644
--- a/examples/imapresource/imapresource.cpp
+++ b/examples/imapresource/imapresource.cpp
@@ -46,8 +46,6 @@
 #define ENTITY_TYPE_MAIL "mail"
 #define ENTITY_TYPE_FOLDER "folder"
 
-SINK_DEBUG_AREA("imapresource")
-
 Q_DECLARE_METATYPE(QSharedPointer<Imap::ImapServerProxy>)
 
 using namespace Imap;
@@ -87,6 +85,25 @@ static QByteArray parentRid(const Imap::Folder &folder)
     return folder.parentPath().toUtf8();
 }
 
+static QByteArray getSpecialPurposeType(const QByteArrayList &flags)
+{
+    if (Imap::flagsContain(Imap::FolderFlags::Trash, flags)) {
+        return ApplicationDomain::SpecialPurpose::Mail::trash;
+    }
+    if (Imap::flagsContain(Imap::FolderFlags::Drafts, flags)) {
+        return ApplicationDomain::SpecialPurpose::Mail::drafts;
+    }
+    if (Imap::flagsContain(Imap::FolderFlags::Sent, flags)) {
+        return ApplicationDomain::SpecialPurpose::Mail::sent;
+    }
+    return {};
+}
+
+static bool hasSpecialPurposeFlag(const QByteArrayList &flags)
+{
+    return !getSpecialPurposeType(flags).isEmpty();
+}
+
 
 class ImapSynchronizer : public Sink::Synchronizer {
     Q_OBJECT
@@ -100,22 +117,29 @@ public:
     QByteArray createFolder(const Imap::Folder &f)
     {
         const auto parentFolderRid = parentRid(f);
-        SinkTraceCtx(mLogCtx) << "Creating folder: " << f.name() << parentFolderRid;
+        bool isToplevel = parentFolderRid.isEmpty();
+
+        SinkTraceCtx(mLogCtx) << "Creating folder: " << f.name() << parentFolderRid << f.flags;
 
         const auto remoteId = folderRid(f);
         Sink::ApplicationDomain::Folder folder;
         folder.setName(f.name());
         folder.setIcon("folder");
         folder.setEnabled(f.subscribed);
-        QHash<QByteArray, Query::Comparator> mergeCriteria;
-        if (SpecialPurpose::isSpecialPurposeFolderName(f.name()) && parentFolderRid.isEmpty()) {
-            auto type = SpecialPurpose::getSpecialPurposeType(f.name());
-            folder.setSpecialPurpose(QByteArrayList() << type);
-            mergeCriteria.insert(ApplicationDomain::Folder::SpecialPurpose::name, Query::Comparator(type, Query::Comparator::Contains));
+        auto specialPurpose = [&] {
+            if (hasSpecialPurposeFlag(f.flags)) {
+                return getSpecialPurposeType(f.flags);
+            } else if (SpecialPurpose::isSpecialPurposeFolderName(f.name()) && isToplevel) {
+                return SpecialPurpose::getSpecialPurposeType(f.name());
+            }
+            return QByteArray{};
+        }();
+        if (!specialPurpose.isEmpty()) {
+            folder.setSpecialPurpose(QByteArrayList() << specialPurpose);
         }
 
-        if (!parentFolderRid.isEmpty()) {
-            folder.setParent(syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, parentFolderRid));
+        if (!isToplevel) {
+            folder.setParent(syncStore().resolveRemoteId(ApplicationDomain::Folder::name, parentFolderRid));
         }
         createOrModify(ApplicationDomain::getTypeName<ApplicationDomain::Folder>(), remoteId, folder);
         return remoteId;
@@ -160,22 +184,20 @@ public:
         return flags;
     }
 
-    void synchronizeMails(const QByteArray &folderRid, const Message &message)
+    void synchronizeMails(const QByteArray &folderRid, const QByteArray &folderLocalId, const Message &message)
     {
         auto time = QSharedPointer<QTime>::create();
         time->start();
         SinkTraceCtx(mLogCtx) << "Importing new mail." << folderRid;
 
-        const auto folderLocalId = syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, folderRid);
-
         const auto remoteId = assembleMailRid(folderLocalId, message.uid);
 
         Q_ASSERT(message.msg);
-        SinkTraceCtx(mLogCtx) << "Found a mail " << remoteId << message.msg->subject(true)->asUnicodeString() << message.flags;
+        SinkTraceCtx(mLogCtx) << "Found a mail " << remoteId << message.flags;
 
         auto mail = Sink::ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
         mail.setFolder(folderLocalId);
-        mail.setMimeMessage(message.msg->encodedContent());
+        mail.setMimeMessage(message.msg->encodedContent(true));
         mail.setExtractedFullPayloadAvailable(message.fullPayload);
         setFlags(mail, message.flags);
 
@@ -291,14 +313,15 @@ public:
                 SinkTraceCtx(mLogCtx) << "Uids to fetch: " << filteredAndSorted;
 
                 bool headersOnly = false;
+                const auto folderLocalId = syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, folderRemoteId);
                 return imap->fetchMessages(folder, filteredAndSorted, headersOnly, [=](const Message &m) {
                     if (*maxUid < m.uid) {
                         *maxUid = m.uid;
                     }
-                    synchronizeMails(folderRemoteId, m);
+                    synchronizeMails(folderRemoteId, folderLocalId, m);
                 },
-                [this, maxUid, folder](int progress, int total) {
-                    SinkLog() << "Progress: " << progress << " out of " << total;
+                [=](int progress, int total) {
+                    reportProgress(progress, total, QByteArrayList{} << folderLocalId);
                     //commit every 10 messages
                     if ((progress % 10) == 0) {
                         commit();
@@ -335,11 +358,12 @@ public:
                     SinkLogCtx(mLogCtx) << "Fetching headers for: " << toFetch;
 
                     bool headersOnly = true;
+                    const auto folderLocalId = syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, folderRemoteId);
                     return imap->fetchMessages(folder, toFetch, headersOnly, [=](const Message &m) {
-                        synchronizeMails(folderRemoteId, m);
+                        synchronizeMails(folderRemoteId, folderLocalId, m);
                     },
                     [=](int progress, int total) {
-                        SinkLogCtx(mLogCtx) << "Progress: " << progress << " out of " << total;
+                        reportProgress(progress, total, QByteArrayList{} << folderLocalId);
                         //commit every 100 messages
                         if ((progress % 100) == 0) {
                             commit();
@@ -466,7 +490,7 @@ public:
             //Otherwise fetch full payload for daterange
             auto folderList = QSharedPointer<QVector<Folder>>::create();
             return  imap->fetchFolders([folderList](const Folder &folder) {
-                if (!folder.noselect) {
+                if (!folder.noselect && folder.subscribed) {
                     *folderList << folder;
                 }
             })
@@ -480,12 +504,16 @@ public:
     KAsync::Error getError(const KAsync::Error &error)
     {
         if (error) {
-            if (error.errorCode == Imap::CouldNotConnectError) {
-                return {ApplicationDomain::ConnectionError, error.errorMessage};
-            } else if (error.errorCode == Imap::SslHandshakeError) {
-                return {ApplicationDomain::LoginError, error.errorMessage};
+            switch(error.errorCode) {
+                case Imap::CouldNotConnectError:
+                    return {ApplicationDomain::ConnectionError, error.errorMessage};
+                case Imap::SslHandshakeError:
+                    return {ApplicationDomain::LoginError, error.errorMessage};
+                case Imap::HostNotFoundError:
+                    return {ApplicationDomain::NoServerError, error.errorMessage};
+                default:
+                    return {ApplicationDomain::UnknownError, error.errorMessage};
             }
-            return {ApplicationDomain::UnknownError, error.errorMessage};
         }
         return {};
     }
@@ -539,11 +567,12 @@ public:
                     }
                     SinkLog() << "Fetching messages: " << toFetch << folderRemoteId;
                     bool headersOnly = false;
+                    const auto folderLocalId = syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, folderRemoteId);
                     return imap->fetchMessages(Folder{folderRemoteId}, toFetch, headersOnly, [=](const Message &m) {
-                        synchronizeMails(folderRemoteId, m);
+                        synchronizeMails(folderRemoteId, folderLocalId, m);
                     },
                     [=](int progress, int total) {
-                        reportProgress(progress, total);
+                        reportProgress(progress, total, QByteArrayList{} << folderLocalId);
                         //commit every 100 messages
                         if ((progress % 100) == 0) {
                             commit();
@@ -554,10 +583,7 @@ public:
                     bool syncHeaders = query.hasFilter<ApplicationDomain::Mail::Folder>();
                     //FIXME If we were able to to flush in between we could just query the local store for the folder list.
                     return getFolderList(imap, query)
-                    .then([=] (const QVector<Folder> &folders) {
-                        //Synchronize folders
-                        return KAsync::value(folders)
-                        .serialEach<void>([=](const Folder &folder) {
+                        .serialEach([=](const Folder &folder) {
                             SinkLog() << "Syncing folder " << folder.path();
                             //Emit notification that the folder is being synced.
                             //The synchronizer can't do that because it has no concept of the folder filter on a mail sync scope meaning that the folder is being synchronized.
@@ -572,7 +598,6 @@ public:
                                     SinkWarning() << "Failed to sync folder: " << folder.path() << "Error: " << error.errorMessage;
                                 });
                         });
-                    });
                 }
             })
             .then([=] (const KAsync::Error &error) {
@@ -582,6 +607,15 @@ public:
         }
         return KAsync::error<void>("Nothing to do");
     }
+    static QByteArray ensureCRLF(const QByteArray &data) {
+        auto index = data.indexOf('\n');
+        if (index > 0 && data.at(index - 1) == '\r') { //First line is LF-only terminated
+            //Convert back and forth in case there's a mix. We don't want to expand CRLF into CRCRLF.
+            return KMime::LFtoCRLF(KMime::CRLFtoLF(data));
+        } else {
+            return data;
+        }
+    }
 
     KAsync::Job<QByteArray> replay(const ApplicationDomain::Mail &mail, Sink::Operation operation, const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties) Q_DECL_OVERRIDE
     {
@@ -589,10 +623,10 @@ public:
         auto login = imap->login(mUser, mPassword);
         KAsync::Job<QByteArray> job = KAsync::null<QByteArray>();
         if (operation == Sink::Operation_Creation) {
-            QString mailbox = syncStore().resolveLocalId(ENTITY_TYPE_FOLDER, mail.getFolder());
-            QByteArray content = KMime::LFtoCRLF(mail.getMimeMessage());
-            auto flags = getFlags(mail);
-            QDateTime internalDate = mail.getDate();
+            const QString mailbox = syncStore().resolveLocalId(ENTITY_TYPE_FOLDER, mail.getFolder());
+            const auto content = ensureCRLF(mail.getMimeMessage());
+            const auto flags = getFlags(mail);
+            const QDateTime internalDate = mail.getDate();
             job = login.then(imap->append(mailbox, content, flags, internalDate))
                 .addToContext(imap)
                 .then([mail](qint64 uid) {
@@ -623,11 +657,11 @@ public:
             const bool messageMoved = changedProperties.contains(ApplicationDomain::Mail::Folder::name);
             const bool messageChanged = changedProperties.contains(ApplicationDomain::Mail::MimeMessage::name);
             if (messageChanged || messageMoved) {
-                SinkTrace() << "Replacing message.";
                 const auto folderId = folderIdFromMailRid(oldRemoteId);
                 const QString oldMailbox = syncStore().resolveLocalId(ENTITY_TYPE_FOLDER, folderId);
-                QByteArray content = KMime::LFtoCRLF(mail.getMimeMessage());
-                QDateTime internalDate = mail.getDate();
+                const auto content = ensureCRLF(mail.getMimeMessage());
+                const QDateTime internalDate = mail.getDate();
+                SinkTrace() << "Replacing message. Old mailbox: " << oldMailbox << "New mailbox: " << mailbox << "Flags: " << flags << "Content: " << content;
                 KIMAP2::ImapSet set;
                 set.add(uid);
                 job = login.then(imap->append(mailbox, content, flags, internalDate))
@@ -655,7 +689,7 @@ public:
                 if (error) {
                     SinkWarning() << "Error during changereplay: " << error.errorMessage;
                     return imap->logout()
-                        .then(KAsync::error<QByteArray>(error));
+                        .then(KAsync::error<QByteArray>(getError(error)));
                 }
                 return imap->logout()
                     .then(KAsync::value(remoteId));
@@ -664,6 +698,12 @@ public:
 
     KAsync::Job<QByteArray> replay(const ApplicationDomain::Folder &folder, Sink::Operation operation, const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties) Q_DECL_OVERRIDE
     {
+        if (operation != Sink::Operation_Creation) {
+            if(oldRemoteId.isEmpty()) {
+                Q_ASSERT(false);
+                return KAsync::error<QByteArray>("Tried to replay modification without old remoteId.");
+            }
+        }
         auto imap = QSharedPointer<ImapServerProxy>::create(mServer, mPort, &mSessionCache);
         auto login = imap->login(mUser, mPassword);
         if (operation == Sink::Operation_Creation) {
@@ -793,6 +833,10 @@ protected:
                 .then(imap->select(folderRemoteId))
                 .then([](Imap::SelectResult){})
                 .then(imap->fetch(set, scope, [imap, messageByUid](const Imap::Message &message) {
+                    //We avoid parsing normally, so we have to do it explicitly here
+                    if (message.msg) {
+                        message.msg->parse();
+                    }
                     messageByUid->insert(message.uid, message);
                 }));
 
diff --git a/examples/imapresource/imapserverproxy.cpp b/examples/imapresource/imapserverproxy.cpp
index 0cc43b8..538105c 100644
--- a/examples/imapresource/imapserverproxy.cpp
+++ b/examples/imapresource/imapserverproxy.cpp
@@ -37,8 +37,6 @@
 #include "log.h"
 #include "test.h"
 
-SINK_DEBUG_AREA("imapserverproxy")
-
 using namespace Imap;
 
 const char* Imap::Flags::Seen = "\\Seen";
@@ -57,6 +55,7 @@ const char* Imap::FolderFlags::Trash = "\\Trash";
 const char* Imap::FolderFlags::Archive = "\\Archive";
 const char* Imap::FolderFlags::Junk = "\\Junk";
 const char* Imap::FolderFlags::Flagged = "\\Flagged";
+const char* Imap::FolderFlags::Drafts = "\\Drafts";
 
 const char* Imap::Capabilities::Namespace = "NAMESPACE";
 const char* Imap::Capabilities::Uidplus = "UIDPLUS";
@@ -98,17 +97,25 @@ static KAsync::Job<void> runJob(KJob *job)
     });
 }
 
-ImapServerProxy::ImapServerProxy(const QString &serverUrl, int port, SessionCache *sessionCache) : mSession(new KIMAP2::Session(serverUrl, qint16(port))), mSessionCache(sessionCache)
+KIMAP2::Session *createNewSession(const QString &serverUrl, int port)
 {
-    QObject::connect(mSession, &KIMAP2::Session::sslErrors, [this](const QList<QSslError> &errors) {
+    auto newSession = new KIMAP2::Session(serverUrl, qint16(port));
+    if (Sink::Test::testModeEnabled()) {
+        newSession->setTimeout(1);
+    } else {
+        newSession->setTimeout(40);
+    }
+    QObject::connect(newSession, &KIMAP2::Session::sslErrors, [=](const QList<QSslError> &errors) {
         SinkLog() << "Received ssl error: " << errors;
-        mSession->ignoreErrors(errors);
+        newSession->ignoreErrors(errors);
     });
+    return newSession;
+}
 
-    if (Sink::Test::testModeEnabled()) {
-        mSession->setTimeout(1);
-    } else {
-        mSession->setTimeout(40);
+ImapServerProxy::ImapServerProxy(const QString &serverUrl, int port, SessionCache *sessionCache) : mSessionCache(sessionCache), mSession(nullptr)
+{
+    if (!mSessionCache || mSessionCache->isEmpty()) {
+        mSession = createNewSession(serverUrl, port);
     }
 }
 
@@ -161,12 +168,16 @@ KAsync::Job<void> ImapServerProxy::login(const QString &username, const QString
         // SinkTrace() << "Found user namespaces: " << mNamespaces.user;
     }).then([=] (const KAsync::Error &error) {
         if (error) {
-            if (error.errorCode == KIMAP2::LoginJob::ErrorCode::ERR_COULD_NOT_CONNECT) {
+            switch (error.errorCode) {
+            case KIMAP2::LoginJob::ErrorCode::ERR_HOST_NOT_FOUND:
+                return KAsync::error(HostNotFoundError, "Host not found: " + error.errorMessage);
+            case KIMAP2::LoginJob::ErrorCode::ERR_COULD_NOT_CONNECT:
                 return KAsync::error(CouldNotConnectError, "Failed to connect: " + error.errorMessage);
-            } else if (error.errorCode == KIMAP2::LoginJob::ErrorCode::ERR_SSL_HANDSHAKE_FAILED) {
+            case KIMAP2::LoginJob::ErrorCode::ERR_SSL_HANDSHAKE_FAILED:
                 return KAsync::error(SslHandshakeError, "Ssl handshake failed: " + error.errorMessage);
+            default:
+                return KAsync::error(error);
             }
-            return KAsync::error(error);
         }
         return KAsync::null();
     });
@@ -188,6 +199,12 @@ KAsync::Job<void> ImapServerProxy::logout()
     }
 }
 
+bool ImapServerProxy::isGmail() const
+{
+    //Magic capability that only gmail has
+    return mCapabilities.contains("X-GM-EXT-1");
+}
+
 KAsync::Job<SelectResult> ImapServerProxy::select(const QString &mailbox)
 {
     auto select = new KIMAP2::SelectJob(mSession);
@@ -297,6 +314,7 @@ KAsync::Job<void> ImapServerProxy::fetch(const KIMAP2::ImapSet &set, KIMAP2::Fet
     fetch->setSequenceSet(set);
     fetch->setUidBased(true);
     fetch->setScope(scope);
+    fetch->setAvoidParsing(true);
     QObject::connect(fetch, &KIMAP2::FetchJob::resultReceived, callback);
     return runJob(fetch);
 }
@@ -437,18 +455,60 @@ QString ImapServerProxy::getNamespace(const QString &name)
     return ns.name;
 }
 
+static bool caseInsensitiveContains(const QByteArray &f, const QByteArrayList &list) {
+    return list.contains(f) || list.contains(f.toLower());
+}
+
+bool Imap::flagsContain(const QByteArray &f, const QByteArrayList &flags)
+{
+    return caseInsensitiveContains(f, flags);
+}
+
+static void reportFolder(const Folder &f, QSharedPointer<QSet<QString>> reportedList, std::function<void(const Folder &)> callback) {
+    if (!reportedList->contains(f.path())) {
+        reportedList->insert(f.path());
+        auto c = f;
+        c.noselect = true;
+        callback(c);
+        if (!f.parentPath().isEmpty()){
+            reportFolder(f.parentFolder(), reportedList, callback);
+        }
+    }
+}
+
 KAsync::Job<void> ImapServerProxy::fetchFolders(std::function<void(const Folder &)> callback)
 {
     SinkTrace() << "Fetching folders";
     auto subscribedList = QSharedPointer<QSet<QString>>::create() ;
+    auto reportedList = QSharedPointer<QSet<QString>>::create() ;
     return list(KIMAP2::ListJob::NoOption, [=](const KIMAP2::MailBoxDescriptor &mailbox, const QList<QByteArray> &){
         *subscribedList << mailbox.name;
     }).then(list(KIMAP2::ListJob::IncludeUnsubscribed, [=](const KIMAP2::MailBoxDescriptor &mailbox, const QList<QByteArray> &flags) {
-        bool noselect = flags.contains(QByteArray(FolderFlags::Noselect).toLower()) || flags.contains(QByteArray(FolderFlags::Noselect));
+        bool noselect = caseInsensitiveContains(FolderFlags::Noselect, flags);
         bool subscribed = subscribedList->contains(mailbox.name);
+        if (isGmail()) {
+            bool inbox = mailbox.name.toLower() == "inbox";
+            bool sent = caseInsensitiveContains(FolderFlags::Sent, flags);
+            bool drafts = caseInsensitiveContains(FolderFlags::Drafts, flags);
+            bool trash = caseInsensitiveContains(FolderFlags::Trash, flags);
+            /**
+             * Because gmail duplicates messages all over the place we only support a few selected folders for now that should be mostly exclusive.
+             */
+            if (!(inbox || sent || drafts || trash)) {
+                return;
+            }
+        }
         SinkLog() << "Found mailbox: " << mailbox.name << flags << FolderFlags::Noselect << noselect  << " sub: " << subscribed;
         auto ns = getNamespace(mailbox.name);
-        callback(Folder{mailbox.name, ns, mailbox.separator, noselect, subscribed, flags});
+        auto folder = Folder{mailbox.name, ns, mailbox.separator, noselect, subscribed, flags};
+
+        //call callback for parents if that didn't already happen.
+        //This is necessary because we can have missing bits in the hierarchy in IMAP, but this will not work in sink because we'd end up with an incomplete tree.
+        if (!folder.parentPath().isEmpty() && !reportedList->contains(folder.parentPath())) {
+            reportFolder(folder.parentFolder(), reportedList, callback);
+        }
+        reportedList->insert(folder.path());
+        callback(folder);
     }));
 }
 
diff --git a/examples/imapresource/imapserverproxy.h b/examples/imapresource/imapserverproxy.h
index 872f032..82f4f58 100644
--- a/examples/imapresource/imapserverproxy.h
+++ b/examples/imapresource/imapserverproxy.h
@@ -31,6 +31,7 @@ namespace Imap {
 
 enum ErrorCode {
     NoError,
+    HostNotFoundError,
     CouldNotConnectError,
     SslHandshakeError
 };
@@ -60,6 +61,7 @@ namespace FolderFlags
     extern const char* Junk;
     extern const char* Flagged;
     extern const char* All;
+    extern const char* Drafts;
 }
 
 namespace Capabilities
@@ -78,6 +80,8 @@ struct Message {
     bool fullPayload;
 };
 
+bool flagsContain(const QByteArray &f, const QByteArrayList &flags);
+
 struct Folder {
     Folder() = default;
     Folder(const QString &path, const QString &ns, const QChar &separator, bool noselect_, bool subscribed_, const QByteArrayList &flags_)
@@ -114,6 +118,15 @@ struct Folder {
         return parentPath;
     }
 
+    Folder parentFolder() const
+    {
+        Folder parent;
+        parent.mPath = parentPath();
+        parent.mNamespace = mNamespace;
+        parent.mSeparator = mSeparator;
+        return parent;
+    }
+
     QString name() const
     {
         auto pathParts = mPath.split(mSeparator);
@@ -218,18 +231,18 @@ public:
                 return session;
             }
         }
-        return CachedSession{};
+        return {};
+    }
+
+    bool isEmpty() const
+    {
+        return mSessions.isEmpty();
     }
 private:
     QList<CachedSession> mSessions;
 };
 
 class ImapServerProxy {
-    KIMAP2::Session *mSession;
-    QStringList mCapabilities;
-    Namespaces mNamespaces;
-
-
 public:
     ImapServerProxy(const QString &serverUrl, int port, SessionCache *sessionCache = nullptr);
 
@@ -279,9 +292,14 @@ public:
     KAsync::Job<QVector<qint64>> fetchUids(const Folder &folder);
 
 private:
+    bool isGmail() const;
+
     QString getNamespace(const QString &name);
     QObject mGuard;
     SessionCache *mSessionCache;
+    KIMAP2::Session *mSession;
+    QStringList mCapabilities;
+    Namespaces mNamespaces;
 };
 
 }
diff --git a/examples/imapresource/tests/imapmailsyncbenchmark.cpp b/examples/imapresource/tests/imapmailsyncbenchmark.cpp
index a53c148..814e325 100644
--- a/examples/imapresource/tests/imapmailsyncbenchmark.cpp
+++ b/examples/imapresource/tests/imapmailsyncbenchmark.cpp
@@ -31,8 +31,6 @@
 using namespace Sink;
 using namespace Sink::ApplicationDomain;
 
-SINK_DEBUG_AREA("ImapMailSyncBenchmark")
-
 /**
  * Test of complete system using the imap resource.
  *
diff --git a/examples/imapresource/tests/imapserverproxytest.cpp b/examples/imapresource/tests/imapserverproxytest.cpp
index 476066d..271b3d9 100644
--- a/examples/imapresource/tests/imapserverproxytest.cpp
+++ b/examples/imapresource/tests/imapserverproxytest.cpp
@@ -12,8 +12,6 @@
 
 using namespace Imap;
 
-// SINK_DEBUG_AREA("imapserverproxytest")
-
 /**
  */
 class ImapServerProxyTest : public QObject
diff --git a/examples/imapresource/tests/populatemailbox.sh b/examples/imapresource/tests/populatemailbox.sh
index a435df7..800e2e7 100644
--- a/examples/imapresource/tests/populatemailbox.sh
+++ b/examples/imapresource/tests/populatemailbox.sh
@@ -1,12 +1,23 @@
 #!/bin/bash
 
 sudo echo "sam user.doe.* cyrus c" | cyradm --auth PLAIN -u cyrus -w admin localhost
+#Delete all mailboxes
 sudo echo "dm user.doe.*" | cyradm --auth PLAIN -u cyrus -w admin localhost
+#Create mailboxes
 sudo echo "cm user.doe.test" | cyradm --auth PLAIN -u cyrus -w admin localhost
 sudo echo "cm user.doe.Drafts" | cyradm --auth PLAIN -u cyrus -w admin localhost
 sudo echo "cm user.doe.Trash" | cyradm --auth PLAIN -u cyrus -w admin localhost
+
+#Set acls so we can create in INBOX
 sudo echo "sam user.doe cyrus c" | cyradm --auth PLAIN -u cyrus -w admin localhost
 
+#Subscribe to mailboxes
+sudo echo "sub INBOX" | cyradm --auth PLAIN -u doe -w doe localhost
+sudo echo "sub INBOX.test" | cyradm --auth PLAIN -u doe -w doe localhost
+sudo echo "sub INBOX.Drafts" | cyradm --auth PLAIN -u doe -w doe localhost
+sudo echo "sub INBOX.Trash" | cyradm --auth PLAIN -u doe -w doe localhost
+
+#Create a bunch of test messages in the test folder
 # for i in `seq 1 5000`;
 # do
 #     # sudo cp /work/source/Sink/examples/imapresource/tests/data/1365777830.R28.localhost.localdomain\:2\,S /var/spool/imap/d/user/doe/test/$i.
diff --git a/examples/imapresource/tests/resetmailbox.sh b/examples/imapresource/tests/resetmailbox.sh
index 6ed198e..63d3478 100644
--- a/examples/imapresource/tests/resetmailbox.sh
+++ b/examples/imapresource/tests/resetmailbox.sh
@@ -3,8 +3,11 @@
 sudo echo "sam user.doe.* cyrus c" | cyradm --auth PLAIN -u cyrus -w admin localhost
 sudo echo "dm user.doe.*" | cyradm --auth PLAIN -u cyrus -w admin localhost
 sudo echo "cm user.doe.test" | cyradm --auth PLAIN -u cyrus -w admin localhost
+sudo echo "subscribe INBOX.test" | cyradm --auth PLAIN -u doe -w doe localhost
 sudo echo "cm user.doe.Drafts" | cyradm --auth PLAIN -u cyrus -w admin localhost
+sudo echo "subscribe INBOX.Drafts" | cyradm --auth PLAIN -u doe -w doe localhost
 sudo echo "cm user.doe.Trash" | cyradm --auth PLAIN -u cyrus -w admin localhost
+sudo echo "subscribe INBOX.Trash" | cyradm --auth PLAIN -u doe -w doe localhost
 sudo echo "sam user.doe cyrus c" | cyradm --auth PLAIN -u cyrus -w admin localhost
 sudo cp /work/source/Sink/examples/imapresource/tests/data/1365777830.R28.localhost.localdomain\:2\,S /var/spool/imap/d/user/doe/test/1.
 sudo chown cyrus:mail /var/spool/imap/d/user/doe/test/1.
diff --git a/examples/maildirresource/maildirresource.cpp b/examples/maildirresource/maildirresource.cpp
index 40bab37..b406f63 100644
--- a/examples/maildirresource/maildirresource.cpp
+++ b/examples/maildirresource/maildirresource.cpp
@@ -43,8 +43,6 @@
 #define ENTITY_TYPE_MAIL "mail"
 #define ENTITY_TYPE_FOLDER "folder"
 
-SINK_DEBUG_AREA("maildirresource")
-
 using namespace Sink;
 
 static QString getFilePathFromMimeMessagePath(const QString &mimeMessagePath)
@@ -555,18 +553,20 @@ MaildirResource::MaildirResource(const Sink::ResourceContext &resourceContext)
     setupPreprocessors(ENTITY_TYPE_FOLDER, QVector<Sink::Preprocessor*>() << new FolderPreprocessor(mMaildirPath));
 
     KPIM::Maildir dir(mMaildirPath, true);
-    SinkTrace() << "Started maildir resource for maildir: " << mMaildirPath;
-    {
-        auto draftsFolder = dir.addSubFolder("Drafts");
-        auto remoteId = synchronizer->createFolder(draftsFolder, "folder", QByteArrayList() << "drafts");
-        auto draftsFolderLocalId = synchronizer->syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, remoteId);
-    }
-    {
-        auto trashFolder = dir.addSubFolder("Trash");
-        auto remoteId = synchronizer->createFolder(trashFolder, "folder", QByteArrayList() << "trash");
-        auto trashFolderLocalId = synchronizer->syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, remoteId);
+    if (dir.isValid(false)) {
+        {
+            auto draftsFolder = dir.addSubFolder("Drafts");
+            auto remoteId = synchronizer->createFolder(draftsFolder, "folder", QByteArrayList() << "drafts");
+            auto draftsFolderLocalId = synchronizer->syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, remoteId);
+        }
+        {
+            auto trashFolder = dir.addSubFolder("Trash");
+            auto remoteId = synchronizer->createFolder(trashFolder, "folder", QByteArrayList() << "trash");
+            auto trashFolderLocalId = synchronizer->syncStore().resolveRemoteId(ENTITY_TYPE_FOLDER, remoteId);
+        }
+        synchronizer->commit();
     }
-    synchronizer->commit();
+    SinkTrace() << "Started maildir resource for maildir: " << mMaildirPath;
 }
 
 
diff --git a/examples/mailtransportresource/mailtransport.cpp b/examples/mailtransportresource/mailtransport.cpp
index 84c1556..afe0257 100644
--- a/examples/mailtransportresource/mailtransport.cpp
+++ b/examples/mailtransportresource/mailtransport.cpp
@@ -23,8 +23,6 @@
 #include <QDebug>
 #include <common/log.h>
 
-SINK_DEBUG_AREA("mailtransport")
-
 extern "C" {
 
 #include <stdio.h>
diff --git a/examples/mailtransportresource/mailtransportresource.cpp b/examples/mailtransportresource/mailtransportresource.cpp
index c73219f..3d6f8e4 100644
--- a/examples/mailtransportresource/mailtransportresource.cpp
+++ b/examples/mailtransportresource/mailtransportresource.cpp
@@ -39,8 +39,6 @@
 
 #define ENTITY_TYPE_MAIL "mail"
 
-SINK_DEBUG_AREA("mailtransportresource")
-
 using namespace Sink;
 
 class MailtransportPreprocessor : public Sink::Preprocessor
diff --git a/examples/mailtransportresource/tests/mailtransporttest.cpp b/examples/mailtransportresource/tests/mailtransporttest.cpp
index e4cc447..2a831ed 100644
--- a/examples/mailtransportresource/tests/mailtransporttest.cpp
+++ b/examples/mailtransportresource/tests/mailtransporttest.cpp
@@ -64,7 +64,7 @@ private slots:
         message->assemble();
 
         auto mail = ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
-        mail.setMimeMessage(message->encodedContent());
+        mail.setMimeMessage(message->encodedContent(true));
 
         VERIFYEXEC(Store::create(mail));
         VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));
@@ -92,7 +92,7 @@ private slots:
         message->assemble();
 
         auto mail = ApplicationDomain::Mail::create(mResourceInstanceIdentifier);
-        mail.setMimeMessage(message->encodedContent());
+        mail.setMimeMessage(message->encodedContent(true));
 
         VERIFYEXEC(Store::create(mail));
         VERIFYEXEC(ResourceControl::flushMessageQueue(QByteArrayList() << mResourceInstanceIdentifier));