Addressbook support

19 files changed, 222 insertions, 353 deletions

diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index b5275e0..a10f84f 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -62,6 +62,7 @@ set(command_SRCS
     domain/propertyregistry.cpp
     domain/applicationdomaintype.cpp
     domain/contact.cpp
+    domain/addressbook.cpp
     domain/event.cpp
     domain/mail.cpp
     domain/folder.cpp
@@ -101,6 +102,7 @@ generate_flatbuffers(
     commands/inspection
     commands/flush
     domain/contact
+    domain/addressbook
     domain/event
     domain/mail
     domain/folder
diff --git a/common/domain/addressbook.cpp b/common/domain/addressbook.cpp
new file mode 100644
index 0000000..d1a3eaf
--- /dev/null
+++ b/common/domain/addressbook.cpp
@@ -0,0 +1,54 @@
+/*
+ *   Copyright (C) 2017 Christian Mollekopf <chrigi_1@fastaddressbook.fm>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+#include "addressbook.h"
+
+#include <QByteArray>
+#include <QString>
+
+#include "../propertymapper.h"
+#include "../typeindex.h"
+#include "entitybuffer.h"
+#include "entity_generated.h"
+
+#include "addressbook_generated.h"
+
+using namespace Sink::ApplicationDomain;
+
+void TypeImplementation<Addressbook>::configure(TypeIndex &index)
+{
+    index.addProperty<QByteArray>(Addressbook::Parent::name);
+    index.addProperty<QString>(Addressbook::Name::name);
+}
+
+void TypeImplementation<Addressbook>::configure(ReadPropertyMapper<Buffer> &propertyMapper)
+{
+    propertyMapper.addMapping<Addressbook::Parent, Buffer>(&Buffer::parent);
+    propertyMapper.addMapping<Addressbook::Name, Buffer>(&Buffer::name);
+}
+
+void TypeImplementation<Addressbook>::configure(WritePropertyMapper<BufferBuilder> &propertyMapper)
+{
+    propertyMapper.addMapping<Addressbook::Parent>(&BufferBuilder::add_parent);
+    propertyMapper.addMapping<Addressbook::Name>(&BufferBuilder::add_name);
+}
+
+void TypeImplementation<Addressbook>::configure(IndexPropertyMapper &)
+{
+
+}
diff --git a/common/domain/addressbook.fbs b/common/domain/addressbook.fbs
new file mode 100644
index 0000000..c2bda2b
--- /dev/null
+++ b/common/domain/addressbook.fbs
@@ -0,0 +1,9 @@
+namespace Sink.ApplicationDomain.Buffer;
+
+table Addressbook {
+  name:string;
+  parent:string;
+}
+
+root_type Addressbook;
+file_identifier "AKFB";
diff --git a/common/domain/addressbook.h b/common/domain/addressbook.h
new file mode 100644
index 0000000..6475073
--- /dev/null
+++ b/common/domain/addressbook.h
@@ -0,0 +1,51 @@
+/*
+ *   Copyright (C) 2017 Christian Mollekopf <chrigi_1@fastmail.fm>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
+ */
+#pragma once
+
+#include "applicationdomaintype.h"
+
+template<typename T>
+class ReadPropertyMapper;
+template<typename T>
+class WritePropertyMapper;
+class IndexPropertyMapper;
+
+class TypeIndex;
+
+namespace Sink {
+
+namespace ApplicationDomain {
+    namespace Buffer {
+        struct Addressbook;
+        struct AddressbookBuilder;
+    }
+
+template<>
+class TypeImplementation<Sink::ApplicationDomain::Addressbook> {
+public:
+    typedef Sink::ApplicationDomain::Buffer::Addressbook Buffer;
+    typedef Sink::ApplicationDomain::Buffer::AddressbookBuilder BufferBuilder;
+    static void configure(TypeIndex &);
+    static void configure(ReadPropertyMapper<Buffer> &);
+    static void configure(WritePropertyMapper<BufferBuilder> &);
+    static void configure(IndexPropertyMapper &indexPropertyMapper);
+};
+
+}
+}
diff --git a/common/domain/applicationdomaintype.cpp b/common/domain/applicationdomaintype.cpp
index 99f14a1..1efe052 100644
--- a/common/domain/applicationdomaintype.cpp
+++ b/common/domain/applicationdomaintype.cpp
@@ -96,6 +96,15 @@ SINK_REGISTER_PROPERTY(Folder, SpecialPurpose);
 SINK_REGISTER_PROPERTY(Folder, Enabled);
 SINK_REGISTER_PROPERTY(Folder, Parent);
 
+SINK_REGISTER_PROPERTY(Contact, Uid);
+SINK_REGISTER_PROPERTY(Contact, Fn);
+SINK_REGISTER_PROPERTY(Contact, Emails);
+SINK_REGISTER_PROPERTY(Contact, Vcard);
+SINK_REGISTER_PROPERTY(Contact, Addressbook);
+
+SINK_REGISTER_PROPERTY(Addressbook, Name);
+SINK_REGISTER_PROPERTY(Addressbook, Parent);
+
 static const int foo = [] {
     QMetaType::registerEqualsComparator<Reference>();
     QMetaType::registerDebugStreamOperator<Reference>();
@@ -369,6 +378,12 @@ QByteArray getTypeName<Contact>()
 }
 
 template<>
+QByteArray getTypeName<Addressbook>()
+{
+    return "addressbook";
+}
+
+template<>
 QByteArray getTypeName<Event>()
 {
     return "event";
diff --git a/common/domain/applicationdomaintype.h b/common/domain/applicationdomaintype.h
index 3afef75..209f241 100644
--- a/common/domain/applicationdomaintype.h
+++ b/common/domain/applicationdomaintype.h
@@ -312,12 +312,19 @@ struct SINK_EXPORT Entity : public ApplicationDomainType {
     virtual ~Entity() = default;
 };
 
+struct SINK_EXPORT Addressbook : public Entity {
+    SINK_ENTITY(Addressbook);
+    SINK_REFERENCE_PROPERTY(Addressbook, Parent, parent);
+    SINK_PROPERTY(QString, Name, name);
+};
+
 struct SINK_EXPORT Contact : public Entity {
     SINK_ENTITY(Contact);
     SINK_PROPERTY(QString, Uid, uid);
     SINK_PROPERTY(QString, Fn, fn);
     SINK_PROPERTY(QByteArrayList, Emails, emails);
     SINK_PROPERTY(QByteArray, Vcard, vcard);
+    SINK_REFERENCE_PROPERTY(Addressbook, Addressbook, addressbook);
 };
 
 struct SINK_EXPORT Event : public Entity {
@@ -429,6 +436,7 @@ namespace Mail {
 };
 namespace Contact {
     static constexpr const char *contact = "contact";
+    static constexpr const char *addressbook = "addressbook";
     static constexpr const char *storage = "contact.storage";
 };
 };
@@ -454,6 +462,9 @@ template<>
 QByteArray SINK_EXPORT getTypeName<Contact>();
 
 template<>
+QByteArray SINK_EXPORT getTypeName<Addressbook>();
+
+template<>
 QByteArray SINK_EXPORT getTypeName<Event>();
 
 template<>
@@ -503,6 +514,7 @@ class SINK_EXPORT TypeImplementation;
  */
 #define SINK_REGISTER_TYPES() \
     REGISTER_TYPE(Sink::ApplicationDomain::Contact) \
+    REGISTER_TYPE(Sink::ApplicationDomain::Addressbook) \
     REGISTER_TYPE(Sink::ApplicationDomain::Event) \
     REGISTER_TYPE(Sink::ApplicationDomain::Mail) \
     REGISTER_TYPE(Sink::ApplicationDomain::Folder) \
diff --git a/common/domain/applicationdomaintype_p.h b/common/domain/applicationdomaintype_p.h
index 4b06864..a5a6b1d 100644
--- a/common/domain/applicationdomaintype_p.h
+++ b/common/domain/applicationdomaintype_p.h
@@ -33,13 +33,15 @@ struct TypeHelper {
     template <typename R, typename ...Args>
     R operator()(Args && ... args) const {
         if (type == Sink::ApplicationDomain::getTypeName<Sink::ApplicationDomain::Folder>()) {
-            return Func<Sink::ApplicationDomain::Folder>{}(std::forward<Args...>(args...)); 
+            return Func<Sink::ApplicationDomain::Folder>{}(std::forward<Args...>(args...));
         } else if (type == Sink::ApplicationDomain::getTypeName<Sink::ApplicationDomain::Mail>()) {
-            return Func<Sink::ApplicationDomain::Mail>{}(std::forward<Args...>(args...)); 
+            return Func<Sink::ApplicationDomain::Mail>{}(std::forward<Args...>(args...));
         } else if (type == Sink::ApplicationDomain::getTypeName<Sink::ApplicationDomain::Event>()) {
-            return Func<Sink::ApplicationDomain::Event>{}(std::forward<Args...>(args...)); 
+            return Func<Sink::ApplicationDomain::Event>{}(std::forward<Args...>(args...));
         } else if (type == Sink::ApplicationDomain::getTypeName<Sink::ApplicationDomain::Contact>()) {
             return Func<Sink::ApplicationDomain::Contact>{}(std::forward<Args...>(args...));
+        } else if (type == Sink::ApplicationDomain::getTypeName<Sink::ApplicationDomain::Addressbook>()) {
+            return Func<Sink::ApplicationDomain::Addressbook>{}(std::forward<Args...>(args...));
         } else {
             Q_ASSERT(false);
         }
diff --git a/common/domain/contact.cpp b/common/domain/contact.cpp
index ea7cac2..01f9144 100644
--- a/common/domain/contact.cpp
+++ b/common/domain/contact.cpp
@@ -1,5 +1,6 @@
 /*
- * Copyright (C) 2017 Sandro Knauß <knauss@kolabsys.com>
+ *   Copyright (C) 2017 Sandro Knauß <knauss@kolabsys.com>
+ *   Copyright (C) 2017 Christian Mollekopf <mollekopf@kolabsys.com>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
@@ -41,6 +42,7 @@ void TypeImplementation<Contact>::configure(ReadPropertyMapper<Buffer> &property
     propertyMapper.addMapping<Contact::Fn, Buffer>(&Buffer::fn);
     propertyMapper.addMapping<Contact::Emails, Buffer>(&Buffer::emails);
     propertyMapper.addMapping<Contact::Vcard, Buffer>(&Buffer::vcard);
+    propertyMapper.addMapping<Contact::Addressbook, Buffer>(&Buffer::addressbook);
 }
 
 void TypeImplementation<Contact>::configure(WritePropertyMapper<BufferBuilder> &propertyMapper)
@@ -49,6 +51,7 @@ void TypeImplementation<Contact>::configure(WritePropertyMapper<BufferBuilder> &
     propertyMapper.addMapping<Contact::Fn>(&BufferBuilder::add_fn);
     propertyMapper.addMapping<Contact::Emails>(&BufferBuilder::add_emails);
     propertyMapper.addMapping<Contact::Vcard>(&BufferBuilder::add_vcard);
+    propertyMapper.addMapping<Contact::Addressbook>(&BufferBuilder::add_addressbook);
 }
 
 void TypeImplementation<Contact>::configure(IndexPropertyMapper &)
diff --git a/common/domain/contact.fbs b/common/domain/contact.fbs
index 34fb1d6..7d7f797 100644
--- a/common/domain/contact.fbs
+++ b/common/domain/contact.fbs
@@ -3,6 +3,7 @@ namespace Sink.ApplicationDomain.Buffer;
 table Contact {
   uid:string;
   fn:string;
+  addressbook:string;
   emails: [string];
   vcard: string;
 }
diff --git a/common/domain/contact.h b/common/domain/contact.h
index c803a9f..976f16e 100644
--- a/common/domain/contact.h
+++ b/common/domain/contact.h
@@ -1,5 +1,6 @@
 /*
- * Copyright (C) 2017 Sandro Knauß <knauss@kolabsys.com>
+ *   Copyright (C) 2017 Sandro Knauß <knauss@kolabsys.com>
+ *   Copyright (C) 2017 Christian Mollekopf <mollekopf@kolabsys.com>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
diff --git a/common/domain/domaintypes.h b/common/domain/domaintypes.h
index 0abdee7..8e31d48 100644
--- a/common/domain/domaintypes.h
+++ b/common/domain/domaintypes.h
@@ -1,5 +1,6 @@
 
 #include "contact.h"
+#include "addressbook.h"
 #include "mail.h"
 #include "folder.h"
 #include "event.h"
diff --git a/common/domainadaptor.h b/common/domainadaptor.h
index 0377ef4..66ffb88 100644
--- a/common/domainadaptor.h
+++ b/common/domainadaptor.h
@@ -26,10 +26,7 @@
 
 #include "domaintypeadaptorfactoryinterface.h"
 #include "domain/applicationdomaintype.h"
-#include "domain/contact.h"
-#include "domain/event.h"
-#include "domain/mail.h"
-#include "domain/folder.h"
+#include "domain/domaintypes.h"
 #include "bufferadaptor.h"
 #include "entity_generated.h"
 #include "metadata_generated.h"
diff --git a/common/synchronizer.cpp b/common/synchronizer.cpp
index fcdb5b8..8c0d31d 100644
--- a/common/synchronizer.cpp
+++ b/common/synchronizer.cpp
@@ -505,6 +505,12 @@ KAsync::Job<void> Synchronizer::replay(const QByteArray &type, const QByteArray
     } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Mail>()) {
         auto mail = store().readEntity<ApplicationDomain::Mail>(key);
         job = replay(mail, operation, oldRemoteId, modifiedProperties);
+    } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Contact>()) {
+        auto mail = store().readEntity<ApplicationDomain::Contact>(key);
+        job = replay(mail, operation, oldRemoteId, modifiedProperties);
+    } else if (type == ApplicationDomain::getTypeName<ApplicationDomain::Addressbook>()) {
+        auto mail = store().readEntity<ApplicationDomain::Addressbook>(key);
+        job = replay(mail, operation, oldRemoteId, modifiedProperties);
     } else {
         SinkErrorCtx(mLogCtx) << "Replayed unknown type: " << type;
     }
@@ -545,6 +551,11 @@ KAsync::Job<QByteArray> Synchronizer::replay(const ApplicationDomain::Contact &,
     return KAsync::null<QByteArray>();
 }
 
+KAsync::Job<QByteArray> Synchronizer::replay(const ApplicationDomain::Addressbook &, Sink::Operation, const QByteArray &, const QList<QByteArray> &)
+{
+    return KAsync::null<QByteArray>();
+}
+
 KAsync::Job<QByteArray> Synchronizer::replay(const ApplicationDomain::Mail &, Sink::Operation, const QByteArray &, const QList<QByteArray> &)
 {
     return KAsync::null<QByteArray>();
diff --git a/common/synchronizer.h b/common/synchronizer.h
index af042cb..45ec9e7 100644
--- a/common/synchronizer.h
+++ b/common/synchronizer.h
@@ -73,9 +73,9 @@ protected:
 protected:
     ///Implement to write back changes to the server
     virtual KAsync::Job<QByteArray> replay(const Sink::ApplicationDomain::Contact &, Sink::Operation, const QByteArray &oldRemoteId, const QList<QByteArray> &);
+    virtual KAsync::Job<QByteArray> replay(const Sink::ApplicationDomain::Addressbook &, Sink::Operation, const QByteArray &oldRemoteId, const QList<QByteArray> &);
     virtual KAsync::Job<QByteArray> replay(const Sink::ApplicationDomain::Mail &, Sink::Operation, const QByteArray &oldRemoteId, const QList<QByteArray> &);
     virtual KAsync::Job<QByteArray> replay(const Sink::ApplicationDomain::Folder &, Sink::Operation, const QByteArray &oldRemoteId, const QList<QByteArray> &);
-
 protected:
     ///Calls the callback to enqueue the command
     void enqueueCommand(int commandId, const QByteArray &data);
diff --git a/examples/davresource/CMakeLists.txt b/examples/davresource/CMakeLists.txt
index c7899eb..f8cbdb4 100644
--- a/examples/davresource/CMakeLists.txt
+++ b/examples/davresource/CMakeLists.txt
@@ -3,7 +3,6 @@ project(sink_resource_dav)
 add_definitions(-DQT_PLUGIN)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
-find_package(KF5 COMPONENTS REQUIRED Mime)
 find_package(KPimKDAV REQUIRED)
 
 add_library(${PROJECT_NAME} SHARED facade.cpp davresource.cpp domainadaptor.cpp)
@@ -11,8 +10,3 @@ qt5_use_modules(${PROJECT_NAME} Core Network)
 target_link_libraries(${PROJECT_NAME} sink KPim::KDAV)
 
 install(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION ${SINK_RESOURCE_PLUGINS_PATH})
-
-#add_definitions(-DTESTDATAPATH="${CMAKE_CURRENT_SOURCE_DIR}/tests/data")
-
-#add_subdirectory(libmaildir)
-#add_subdirectory(tests)
diff --git a/examples/davresource/davresource.cpp b/examples/davresource/davresource.cpp
index df2c4b4..3d23a04 100644
--- a/examples/davresource/davresource.cpp
+++ b/examples/davresource/davresource.cpp
@@ -21,10 +21,8 @@
 
 #include "facade.h"
 #include "resourceconfig.h"
-#include "index.h"
 #include "log.h"
 #include "definitions.h"
-#include "inspection.h"
 #include "synchronizer.h"
 #include "inspector.h"
 
@@ -40,181 +38,14 @@
 #include <KDAV/DavItemFetchJob>
 #include <KDAV/EtagCache>
 
-#include <QDir>
-#include <QDirIterator>
-
 //This is the resources entity type, and not the domain type
 #define ENTITY_TYPE_CONTACT "contact"
-#define ENTITY_TYPE_ADDRESSBOOK "folder"
+#define ENTITY_TYPE_ADDRESSBOOK "addressbook"
 
 SINK_DEBUG_AREA("davresource")
 
 using namespace Sink;
 
-/*static QString getFilePathFromMimeMessagePath(const QString &mimeMessagePath)
-{
-    auto parts = mimeMessagePath.split('/');
-    const auto key = parts.takeLast();
-    const auto path = parts.join("/") + "/cur/";
-
-    QDir dir(path);
-    const QFileInfoList list = dir.entryInfoList(QStringList() << (key+"*"), QDir::Files);
-    if (list.size() != 1) {
-        SinkWarning() << "Failed to find message " << mimeMessagePath;
-        SinkWarning() << "Failed to find message " << path;
-        return QString();
-    }
-    return list.first().filePath();
-}
-
-class MaildirMailPropertyExtractor : public MailPropertyExtractor
-{
-protected:
-    virtual QString getFilePathFromMimeMessagePath(const QString &mimeMessagePath) const Q_DECL_OVERRIDE
-    {
-        return ::getFilePathFromMimeMessagePath(mimeMessagePath);
-    }
-};
-
-class MaildirMimeMessageMover : public Sink::Preprocessor
-{
-public:
-    MaildirMimeMessageMover(const QByteArray &resourceInstanceIdentifier, const QString &maildirPath) : mResourceInstanceIdentifier(resourceInstanceIdentifier), mMaildirPath(maildirPath) {}
-
-    QString getPath(const QByteArray &folderIdentifier)
-    {
-        if (folderIdentifier.isEmpty()) {
-            return mMaildirPath;
-        }
-        QString folderPath;
-        const auto folder = entityStore().readLatest<ApplicationDomain::Folder>(folderIdentifier);
-        if (mMaildirPath.endsWith(folder.getName())) {
-            folderPath = mMaildirPath;
-        } else {
-            auto folderName = folder.getName();
-            //FIXME handle non toplevel folders
-            folderPath = mMaildirPath + "/" + folderName;
-        }
-        return folderPath;
-    }
-
-    QString moveMessage(const QString &oldPath, const QByteArray &folder)
-    {
-        if (oldPath.startsWith(Sink::temporaryFileLocation())) {
-            const auto path = getPath(folder);
-            KPIM::Contactdir maildir(path, false);
-            if (!maildir.isValid(true)) {
-                SinkWarning() << "Maildir is not existing: " << path;
-            }
-            auto identifier = maildir.addEntryFromPath(oldPath);
-            return path + "/" + identifier;
-        } else {
-            //Handle moves
-            const auto path = getPath(folder);
-            KPIM::Contactdir maildir(path, false);
-            if (!maildir.isValid(true)) {
-                SinkWarning() << "Maildir is not existing: " << path;
-            }
-            auto oldIdentifier = KPIM::Contactdir::getKeyFromFile(oldPath);
-            auto pathParts = oldPath.split('/');
-            pathParts.takeLast();
-            auto oldDirectory = pathParts.join('/');
-            if (oldDirectory == path) {
-                return oldPath;
-            }
-            KPIM::Contactdir oldMaildir(oldDirectory, false);
-            if (!oldMaildir.isValid(false)) {
-                SinkWarning() << "Maildir is not existing: " << path;
-            }
-            auto identifier = oldMaildir.moveEntryTo(oldIdentifier, maildir);
-            return path + "/" + identifier;
-        }
-    }
-
-    void newEntity(Sink::ApplicationDomain::ApplicationDomainType &newEntity) Q_DECL_OVERRIDE
-    {
-        auto mail = newEntity.cast<ApplicationDomain::Contact>();
-        const auto mimeMessage = mail.getMimeMessagePath();
-        if (!mimeMessage.isNull()) {
-            const auto path = moveMessage(mimeMessage, mail.getFolder());
-            auto blob = ApplicationDomain::BLOB{path};
-            blob.isExternal = false;
-            mail.setProperty(ApplicationDomain::Contact::MimeMessage::name, QVariant::fromValue(blob));
-        }
-    }
-
-    void modifiedEntity(const Sink::ApplicationDomain::ApplicationDomainType &oldEntity, Sink::ApplicationDomain::ApplicationDomainType &newEntity) Q_DECL_OVERRIDE
-    {
-        auto newMail = newEntity.cast<ApplicationDomain::Contact>();
-        const ApplicationDomain::Contact oldMail{oldEntity};
-        const auto mimeMessage = newMail.getMimeMessagePath();
-        const auto newFolder = newMail.getFolder();
-        const bool mimeMessageChanged = !mimeMessage.isNull() && mimeMessage != oldMail.getMimeMessagePath();
-        const bool folderChanged = !newFolder.isNull() && newFolder != oldMail.getFolder();
-        if (mimeMessageChanged || folderChanged) {
-            SinkTrace() << "Moving mime message: " << mimeMessageChanged << folderChanged;
-            auto newPath = moveMessage(mimeMessage, newMail.getFolder());
-            if (newPath != oldMail.getMimeMessagePath()) {
-                const auto oldPath = getFilePathFromMimeMessagePath(oldMail.getMimeMessagePath());
-                auto blob = ApplicationDomain::BLOB{newPath};
-                blob.isExternal = false;
-                newMail.setProperty(ApplicationDomain::Contact::MimeMessage::name, QVariant::fromValue(blob));
-                //Remove the olde mime message if there is a new one
-                QFile::remove(oldPath);
-            }
-        }
-
-        auto mimeMessagePath = newMail.getMimeMessagePath();
-        const auto maildirPath = getPath(newMail.getFolder());
-        KPIM::Contactdir maildir(maildirPath, false);
-        const auto file = getFilePathFromMimeMessagePath(mimeMessagePath);
-        QString identifier = KPIM::Contactdir::getKeyFromFile(file);
-
-        //get flags from
-        KPIM::Contactdir::Flags flags;
-        if (!newMail.getUnread()) {
-            flags |= KPIM::Contactdir::Seen;
-        }
-        if (newMail.getImportant()) {
-            flags |= KPIM::Contactdir::Flagged;
-        }
-
-        maildir.changeEntryFlags(identifier, flags);
-    }
-
-    void deletedEntity(const Sink::ApplicationDomain::ApplicationDomainType &oldEntity) Q_DECL_OVERRIDE
-    {
-        const ApplicationDomain::Contact oldMail{oldEntity};
-        const auto filePath = getFilePathFromMimeMessagePath(oldMail.getMimeMessagePath());
-        QFile::remove(filePath);
-    }
-    QByteArray mResourceInstanceIdentifier;
-    QString mMaildirPath;
-};
-
-class FolderPreprocessor : public Sink::Preprocessor
-{
-public:
-    FolderPreprocessor(const QString maildirPath) : mMaildirPath(maildirPath) {}
-
-    void newEntity(Sink::ApplicationDomain::ApplicationDomainType &newEntity) Q_DECL_OVERRIDE
-    {
-        auto folderName = Sink::ApplicationDomain::Folder{newEntity}.getName();
-        const auto path = mMaildirPath + "/" + folderName;
-        KPIM::Contactdir maildir(path, false);
-        maildir.create();
-    }
-
-    void modifiedEntity(const Sink::ApplicationDomain::ApplicationDomainType &oldEntity, Sink::ApplicationDomain::ApplicationDomainType &newEntity) Q_DECL_OVERRIDE
-    {
-    }
-
-    void deletedEntity(const Sink::ApplicationDomain::ApplicationDomainType &oldEntity) Q_DECL_OVERRIDE
-    {
-    }
-    QString mMaildirPath;
-};*/
-
 static KAsync::Job<void> runJob(KJob *job)
 {
     return KAsync::start<void>([job](KAsync::Future<void> &future) {
@@ -240,33 +71,33 @@ public:
 
     }
 
-        QByteArray createAddressbook(const QString &folderName, const QString &folderPath, const QString &parentFolderRid, const QByteArray &icon)
+    QByteArray createAddressbook(const QString &addressbookName, const QString &addressbookPath, const QString &parentAddressbookRid)
     {
-        SinkTrace() << "Creating addressbook: " << folderName << parentFolderRid;
-        const auto remoteId = folderPath.toUtf8();
+        SinkTrace() << "Creating addressbook: " << addressbookName << parentAddressbookRid;
+        const auto remoteId = addressbookPath.toUtf8();
         const auto bufferType = ENTITY_TYPE_ADDRESSBOOK;
-        Sink::ApplicationDomain::Folder folder;
-        folder.setName(folderName);
-        folder.setIcon(icon);
+        Sink::ApplicationDomain::Addressbook addressbook;
+        addressbook.setName(addressbookName);
         QHash<QByteArray, Query::Comparator> mergeCriteria;
 
-        if (!parentFolderRid.isEmpty()) {
-            folder.setParent(syncStore().resolveRemoteId(ENTITY_TYPE_ADDRESSBOOK, parentFolderRid.toUtf8()));
+        if (!parentAddressbookRid.isEmpty()) {
+            addressbook.setParent(syncStore().resolveRemoteId(ENTITY_TYPE_ADDRESSBOOK, parentAddressbookRid.toUtf8()));
         }
-        createOrModify(bufferType, remoteId, folder, mergeCriteria);
+        createOrModify(bufferType, remoteId, addressbook, mergeCriteria);
         return remoteId;
     }
 
-    void synchronizeAddressbooks(const KDAV::DavCollection::List &folderList)
+    void synchronizeAddressbooks(const KDAV::DavCollection::List &addressbookList)
     {
         const QByteArray bufferType = ENTITY_TYPE_ADDRESSBOOK;
-        SinkTrace() << "Found addressbooks " << folderList.size();
+        SinkTrace() << "Found addressbooks " << addressbookList.size();
 
         QVector<QByteArray> ridList;
-        for(const auto &f : folderList) {
-            const auto &rid = f.url().toDisplayString();
-            ridList.append(rid.toUtf8());
-            createAddressbook(f.displayName(), rid, "", "addressbook");
+        for(const auto &f : addressbookList) {
+            const auto &rid = getRid(f);
+            SinkTrace() << "Found addressbook:" << rid;
+            ridList.append(rid);
+            createAddressbook(f.displayName(), rid, "");
         }
 
         scanForRemovals(bufferType,
@@ -284,21 +115,32 @@ public:
             list << Synchronizer::SyncRequest{query};
         } else {
             //We want to synchronize everything
-            list << Synchronizer::SyncRequest{Sink::QueryBase(ApplicationDomain::getTypeName<ApplicationDomain::Folder>())};
+            list << Synchronizer::SyncRequest{Sink::QueryBase(ApplicationDomain::getTypeName<ApplicationDomain::Addressbook>())};
             list << Synchronizer::SyncRequest{Sink::QueryBase(ApplicationDomain::getTypeName<ApplicationDomain::Contact>())};
         }
         return list;
     }
 
+    static QByteArray getRid(const KDAV::DavItem &item)
+    {
+        return item.url().toDisplayString().toUtf8();
+    }
+
+    static QByteArray getRid(const KDAV::DavCollection &item)
+    {
+        return item.url().toDisplayString().toUtf8();
+    }
+
     KAsync::Job<void> synchronizeWithSource(const Sink::QueryBase &query) Q_DECL_OVERRIDE
     {
-        if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Folder>()) {
-            SinkLogCtx(mLogCtx) << "Synchronizing folders:" <<  mResourceUrl.url();
+        if (query.type() == ApplicationDomain::getTypeName<ApplicationDomain::Addressbook>()) {
+            SinkLogCtx(mLogCtx) << "Synchronizing addressbooks:" <<  mResourceUrl.url();
             auto collectionsFetchJob = new KDAV::DavCollectionsFetchJob(mResourceUrl);
             auto job = runJob(collectionsFetchJob).then([this, collectionsFetchJob] (const KAsync::Error &error) {
                 if (error) {
-                    SinkWarningCtx(mLogCtx) << "Failed to synchronize folders." << collectionsFetchJob->errorString();
+                    SinkWarningCtx(mLogCtx) << "Failed to synchronize addressbooks." << collectionsFetchJob->errorString();
                 } else {
+                    SinkWarningCtx(mLogCtx) << "Fetched addressbooks." << collectionsFetchJob->errorString();
                     synchronizeAddressbooks(collectionsFetchJob ->collections());
                 }
             });
@@ -312,7 +154,8 @@ public:
                 return collectionsFetchJob->collections();
             })
             .serialEach([this, ridList](const KDAV::DavCollection &collection) {
-                auto collId = collection.url().toDisplayString().toLatin1();
+                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;
@@ -323,22 +166,23 @@ public:
                     auto colljob = runJob(davItemsListJob).then([davItemsListJob] {
                         return KAsync::value(davItemsListJob->items());
                     })
-                    .serialEach([this, ridList, bufferType, mergeCriteria] (const KDAV::DavItem &item) {
-                        QByteArray rid = item.url().toDisplayString().toUtf8();
+                    .serialEach([=] (const KDAV::DavItem &item) {
+                        QByteArray rid = getRid(item);
                         if (item.etag().toLatin1() != syncStore().readValue(rid + "_etag")){
                             SinkTrace() << "Updating " << rid;
                             auto davItemFetchJob = new KDAV::DavItemFetchJob(item);
                             auto itemjob = runJob(davItemFetchJob)
-                            .then([this, davItemFetchJob, bufferType, mergeCriteria] {
+                            .then([=] {
                                 const auto item = davItemFetchJob->item();
-                                const auto rid = item.url().toDisplayString().toUtf8();
+                                const auto rid = getRid(item);
                                 Sink::ApplicationDomain::Contact contact;
                                 contact.setVcard(item.data());
+                                contact.setAddressbook(addressbookLocalId);
                                 createOrModify(bufferType, rid, contact, mergeCriteria);
                                 return item;
                             })
                             .then([this, ridList] (const KDAV::DavItem &item) {
-                                const auto rid = item.url().toDisplayString().toUtf8();
+                                const auto rid = getRid(item);
                                 syncStore().writeValue(rid + "_etag", item.etag().toLatin1());
                                 ridList->append(rid);
                                 return rid;
@@ -375,43 +219,11 @@ public:
 
 KAsync::Job<QByteArray> replay(const ApplicationDomain::Contact &contact, Sink::Operation operation, const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties) Q_DECL_OVERRIDE
     {
-        /*
-        if (operation == Sink::Operation_Creation) {
-            const auto remoteId = getFilePathFromMimeMessagePath(mail.getMimeMessagePath());
-            SinkTrace() << "Contact created: " << remoteId;
-            return KAsync::value(remoteId.toUtf8());
-        } else if (operation == Sink::Operation_Removal) {
-            SinkTrace() << "Removing a contact " << oldRemoteId;
-            return KAsync::null<QByteArray>();
-        } else if (operation == Sink::Operation_Modification) {
-            SinkTrace() << "Modifying a contact: " << oldRemoteId;
-            const auto remoteId = getFilePathFromMimeMessagePath(mail.getMimeMessagePath());
-            return KAsync::value(remoteId.toUtf8());
-        }*/
         return KAsync::null<QByteArray>();
     }
 
-    KAsync::Job<QByteArray> replay(const ApplicationDomain::Folder &folder, Sink::Operation operation, const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties) Q_DECL_OVERRIDE
+    KAsync::Job<QByteArray> replay(const ApplicationDomain::Addressbook &addressbook, Sink::Operation operation, const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties) Q_DECL_OVERRIDE
     {
-        /*
-        if (operation == Sink::Operation_Creation) {
-            auto folderName = folder.getName();
-            //FIXME handle non toplevel folders
-            auto path = mMaildirPath + "/" + folderName;
-            SinkTrace() << "Creating a new folder: " << path;
-            KPIM::Contactdir maildir(path, false);
-            maildir.create();
-            return KAsync::value(path.toUtf8());
-        } else if (operation == Sink::Operation_Removal) {
-            const auto path = oldRemoteId;
-            SinkTrace() << "Removing a folder: " << path;
-            KPIM::Contactdir maildir(path, false);
-            maildir.remove();
-            return KAsync::null<QByteArray>();
-        } else if (operation == Sink::Operation_Modification) {
-            SinkWarning() << "Folder modifications are not implemented";
-            return KAsync::value(oldRemoteId);
-        }*/
         return KAsync::null<QByteArray>();
     }
 
@@ -419,103 +231,6 @@ public:
     KDAV::DavUrl mResourceUrl;
 };
 
-/*
-class MaildirInspector : public Sink::Inspector {
-public:
-    MaildirInspector(const Sink::ResourceContext &resourceContext)
-        : Sink::Inspector(resourceContext)
-    {
-
-    }
-protected:
-
-    KAsync::Job<void> inspect(int inspectionType, const QByteArray &inspectionId, const QByteArray &domainType, const QByteArray &entityId, const QByteArray &property, const QVariant &expectedValue) Q_DECL_OVERRIDE {
-        auto synchronizationStore = QSharedPointer<Sink::Storage::DataStore>::create(Sink::storageLocation(), mResourceContext.instanceId() + ".synchronization", Sink::Storage::DataStore::ReadOnly);
-        auto synchronizationTransaction = synchronizationStore->createTransaction(Sink::Storage::DataStore::ReadOnly);
-
-        auto mainStore = QSharedPointer<Sink::Storage::DataStore>::create(Sink::storageLocation(), mResourceContext.instanceId(), Sink::Storage::DataStore::ReadOnly);
-        auto transaction = mainStore->createTransaction(Sink::Storage::DataStore::ReadOnly);
-
-        Sink::Storage::EntityStore entityStore(mResourceContext, {"maildirresource"});
-        auto syncStore = QSharedPointer<SynchronizerStore>::create(synchronizationTransaction);
-
-        SinkTrace() << "Inspecting " << inspectionType << domainType << entityId << property << expectedValue;
-
-        if (domainType == ENTITY_TYPE_MAIL) {
-            auto mail = entityStore.readLatest<Sink::ApplicationDomain::Contact>(entityId);
-            const auto filePath = getFilePathFromMimeMessagePath(mail.getMimeMessagePath());
-
-            if (inspectionType == Sink::ResourceControl::Inspection::PropertyInspectionType) {
-                if (property == "unread") {
-                    const auto flags = KPIM::Contactdir::readEntryFlags(filePath.split('/').last());
-                    if (expectedValue.toBool() && (flags & KPIM::Contactdir::Seen)) {
-                        return KAsync::error<void>(1, "Expected unread but couldn't find it.");
-                    }
-                    if (!expectedValue.toBool() && !(flags & KPIM::Contactdir::Seen)) {
-                        return KAsync::error<void>(1, "Expected read but couldn't find it.");
-                    }
-                    return KAsync::null<void>();
-                }
-                if (property == "subject") {
-                    KMime::Message *msg = new KMime::Message;
-                    msg->setHead(KMime::CRLFtoLF(KPIM::Contactdir::readEntryHeadersFromFile(filePath)));
-                    msg->parse();
-
-                    if (msg->subject(true)->asUnicodeString() != expectedValue.toString()) {
-                        return KAsync::error<void>(1, "Subject not as expected: " + msg->subject(true)->asUnicodeString());
-                    }
-                    return KAsync::null<void>();
-                }
-            }
-            if (inspectionType == Sink::ResourceControl::Inspection::ExistenceInspectionType) {
-                if (QFileInfo(filePath).exists() != expectedValue.toBool()) {
-                    return KAsync::error<void>(1, "Wrong file existence: " + filePath);
-                }
-            }
-        }
-        if (domainType == ENTITY_TYPE_FOLDER) {
-            const auto remoteId = syncStore->resolveLocalId(ENTITY_TYPE_FOLDER, entityId);
-            auto folder = entityStore.readLatest<Sink::ApplicationDomain::Folder>(entityId);
-
-            if (inspectionType == Sink::ResourceControl::Inspection::CacheIntegrityInspectionType) {
-                SinkTrace() << "Inspecting cache integrity" << remoteId;
-                if (!QDir(remoteId).exists()) {
-                    return KAsync::error<void>(1, "The directory is not existing: " + remoteId);
-                }
-
-                int expectedCount = 0;
-                Index index("mail.index.folder", transaction);
-                index.lookup(entityId, [&](const QByteArray &sinkId) {
-                        expectedCount++;
-                },
-                [&](const Index::Error &error) {
-                    SinkWarning() << "Error in index: " <<  error.message << property;
-                });
-
-                QDir dir(remoteId + "/cur");
-                const QFileInfoList list = dir.entryInfoList(QDir::Files);
-                if (list.size() != expectedCount) {
-                    for (const auto &fileInfo : list) {
-                        SinkWarning() << "Found in cache: " << fileInfo.fileName();
-                    }
-                    return KAsync::error<void>(1, QString("Wrong number of files; found %1 instead of %2.").arg(list.size()).arg(expectedCount));
-                }
-            }
-            if (inspectionType == Sink::ResourceControl::Inspection::ExistenceInspectionType) {
-                if (!remoteId.endsWith(folder.getName().toUtf8())) {
-                    return KAsync::error<void>(1, "Wrong folder name: " + remoteId);
-                }
-                //TODO we shouldn't use the remoteId here to figure out the path, it could be gone/changed already
-                if (QDir(remoteId).exists() != expectedValue.toBool()) {
-                    return KAsync::error<void>(1, "Wrong folder existence: " + remoteId);
-                }
-            }
-
-        }
-        return KAsync::null<void>();
-    }
-};*/
-
 
 DavResource::DavResource(const Sink::ResourceContext &resourceContext)
     : Sink::GenericResource(resourceContext)
@@ -530,7 +245,6 @@ DavResource::DavResource(const Sink::ResourceContext &resourceContext)
     auto synchronizer = QSharedPointer<ContactSynchronizer>::create(resourceContext);
     synchronizer->mResourceUrl = mResourceUrl;
     setupSynchronizer(synchronizer);
-    //setupInspector(QSharedPointer<MaildirInspector>::create(resourceContext));
 
     setupPreprocessors(ENTITY_TYPE_CONTACT, QVector<Sink::Preprocessor*>() << new ContactPropertyExtractor);
 }
@@ -539,8 +253,8 @@ DavResource::DavResource(const Sink::ResourceContext &resourceContext)
 DavResourceFactory::DavResourceFactory(QObject *parent)
     : Sink::ResourceFactory(parent,
             {Sink::ApplicationDomain::ResourceCapabilities::Contact::contact,
-            Sink::ApplicationDomain::ResourceCapabilities::Mail::folder,
-            "-folder.rename"}
+            Sink::ApplicationDomain::ResourceCapabilities::Contact::addressbook,
+            }
             )
 {
 }
@@ -553,13 +267,13 @@ Sink::Resource *DavResourceFactory::createResource(const ResourceContext &contex
 void DavResourceFactory::registerFacades(const QByteArray &name, Sink::FacadeFactory &factory)
 {
     factory.registerFacade<Sink::ApplicationDomain::Contact, DavResourceContactFacade>(name);
-    factory.registerFacade<Sink::ApplicationDomain::Folder, DavResourceFolderFacade>(name);
+    factory.registerFacade<Sink::ApplicationDomain::Addressbook, DavResourceAddressbookFacade>(name);
 }
 
 void DavResourceFactory::registerAdaptorFactories(const QByteArray &name, Sink::AdaptorFactoryRegistry &registry)
 {
     registry.registerFactory<Sink::ApplicationDomain::Contact, ContactAdaptorFactory>(name);
-    registry.registerFactory<Sink::ApplicationDomain::Folder, AddressbookAdaptorFactory>(name);
+    registry.registerFactory<Sink::ApplicationDomain::Addressbook, AddressbookAdaptorFactory>(name);
 }
 
 void DavResourceFactory::removeDataFromDisk(const QByteArray &instanceIdentifier)
diff --git a/examples/davresource/facade.cpp b/examples/davresource/facade.cpp
index b56815a..8ee1b01 100644
--- a/examples/davresource/facade.cpp
+++ b/examples/davresource/facade.cpp
@@ -34,11 +34,11 @@ DavResourceContactFacade::~DavResourceContactFacade()
 }
 
 
-DavResourceFolderFacade::DavResourceFolderFacade(const Sink::ResourceContext &context)
-    : Sink::GenericFacade<Sink::ApplicationDomain::Folder>(context)
+DavResourceAddressbookFacade::DavResourceAddressbookFacade(const Sink::ResourceContext &context)
+    : Sink::GenericFacade<Sink::ApplicationDomain::Addressbook>(context)
 {
 }
 
-DavResourceFolderFacade::~DavResourceFolderFacade()
+DavResourceAddressbookFacade::~DavResourceAddressbookFacade()
 {
 }
diff --git a/examples/davresource/facade.h b/examples/davresource/facade.h
index 02bd5dc..d520891 100644
--- a/examples/davresource/facade.h
+++ b/examples/davresource/facade.h
@@ -28,9 +28,9 @@ public:
     virtual ~DavResourceContactFacade();
 };
 
-class DavResourceFolderFacade : public Sink::GenericFacade<Sink::ApplicationDomain::Folder>
+class DavResourceAddressbookFacade : public Sink::GenericFacade<Sink::ApplicationDomain::Addressbook>
 {
 public:
-    DavResourceFolderFacade(const Sink::ResourceContext &context);
-    virtual ~DavResourceFolderFacade();
+    DavResourceAddressbookFacade(const Sink::ResourceContext &context);
+    virtual ~DavResourceAddressbookFacade();
 };
diff --git a/sinksh/sinksh_utils.cpp b/sinksh/sinksh_utils.cpp
index 171bb18..3a3484a 100644
--- a/sinksh/sinksh_utils.cpp
+++ b/sinksh/sinksh_utils.cpp
@@ -63,7 +63,9 @@ QList<QByteArray> requestedProperties(const QString &type)
     } else if (type == getTypeName<Event>()) {
         return QList<QByteArray>() << Event::Summary::name;
     } else if (type == getTypeName<Contact>()) {
-        return QList<QByteArray>() << Contact::Fn::name << Contact::Emails::name;
+        return QList<QByteArray>() << Contact::Fn::name << Contact::Emails::name << Contact::Addressbook::name;
+    } else if (type == getTypeName<Addressbook>()) {
+        return QList<QByteArray>() << Addressbook::Name::name << Addressbook::Parent::name;
     } else if (type == getTypeName<SinkResource>()) {
         return QList<QByteArray>() << SinkResource::ResourceType::name << SinkResource::Account::name << SinkResource::Capabilities::name;
     } else if (type == getTypeName<SinkAccount>()) {