4 files changed, 131 insertions, 29 deletions

diff --git a/dummyresource/dummycalendar.fbs b/dummyresource/dummycalendar.fbs
index 5a217b5..643c9b2 100644
--- a/dummyresource/dummycalendar.fbs
+++ b/dummyresource/dummycalendar.fbs
@@ -6,6 +6,7 @@ table DummyEvent {
   summary:string;
   description:string;
   attachment:[ubyte];
+  remoteId:string;
 }
 
 root_type DummyEvent;
diff --git a/dummyresource/facade.cpp b/dummyresource/facade.cpp
index 0d47010..c2871bb 100644
--- a/dummyresource/facade.cpp
+++ b/dummyresource/facade.cpp
@@ -23,6 +23,7 @@
 #include <functional>
 
 #include "common/resourceaccess.h"
+#include "common/commands.h"
 #include "dummycalendar_generated.h"
 
 using namespace DummyCalendar;
@@ -30,7 +31,7 @@ using namespace flatbuffers;
 
 DummyResourceFacade::DummyResourceFacade()
     : Akonadi2::StoreFacade<Akonadi2::Domain::Event>(),
-    mResourceAccess(/* new ResourceAccess("dummyresource") */)
+    mResourceAccess(new Akonadi2::ResourceAccess("org.kde.dummy"))
 {
     // connect(mResourceAccess.data(), &ResourceAccess::ready, this, onReadyChanged);
 }
@@ -95,11 +96,8 @@ public:
     QSharedPointer<Akonadi2::Storage> storage;
 };
 
-void DummyResourceFacade::load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback)
+static std::function<bool(const std::string &key, DummyEvent const *buffer)> prepareQuery(const Akonadi2::Query &query)
 {
-    qDebug() << "load called";
-    auto storage = QSharedPointer<Akonadi2::Storage>::create(Akonadi2::Store::storageLocation(), "dummyresource");
-
     //Compose some functions to make query matching fast.
     //This way we can process the query once, and convert all values into something that can be compared quickly
     std::function<bool(const std::string &key, DummyEvent const *buffer)> preparedQuery;
@@ -125,21 +123,48 @@ void DummyResourceFacade::load(const Akonadi2::Query &query, const std::function
             return true;
         };
     }
+    return preparedQuery;
+}
 
-    //Because we have no indexes yet, we always do a full scan
-    storage->scan("", [=](void *keyValue, int keySize, void *dataValue, int dataSize) -> bool {
-        //TODO read second buffer as well
-        auto eventBuffer = GetDummyEvent(dataValue);
-        if (preparedQuery && preparedQuery(std::string(static_cast<char*>(keyValue), keySize), eventBuffer)) {
-            //TODO read the revision from the generic portion of the buffer
-            auto event = QSharedPointer<DummyEventAdaptor>::create("dummyresource", QString::fromUtf8(static_cast<char*>(keyValue), keySize), 0);
-            event->buffer = eventBuffer;
-            event->storage = storage;
-            resultCallback(event);
-        }
-        return true;
+void DummyResourceFacade::synchronizeResource(const std::function<void()> &continuation)
+{
+    //TODO check if a sync is necessary
+    //TODO Only sync what was requested
+    //TODO timeout
+    mResourceAccess->open();
+    mResourceAccess->synchronizeResource(continuation);
+}
+
+void DummyResourceFacade::load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback, const std::function<void()> &completeCallback)
+{
+    qDebug() << "load called";
+
+    synchronizeResource([=]() {
+        //Now that the sync is complete we can execute the query
+        const auto preparedQuery = prepareQuery(query);
+
+        auto storage = QSharedPointer<Akonadi2::Storage>::create(Akonadi2::Store::storageLocation(), "org.kde.dummy");
+
+        qDebug() << "executing query";
+        //We start a transaction explicitly that we'll leave open so the values can be read.
+        //The transaction will be closed automatically once the storage object is destroyed.
+        storage->startTransaction(Akonadi2::Storage::ReadOnly);
+        //Because we have no indexes yet, we always do a full scan
+        storage->scan("", [=](void *keyValue, int keySize, void *dataValue, int dataSize) -> bool {
+            //TODO read the three buffers
+            qDebug() << QString::fromStdString(std::string(static_cast<char*>(keyValue), keySize));
+            auto eventBuffer = GetDummyEvent(dataValue);
+            if (preparedQuery && preparedQuery(std::string(static_cast<char*>(keyValue), keySize), eventBuffer)) {
+                //TODO set proper revision
+                qint64 revision = 0;
+                auto event = QSharedPointer<DummyEventAdaptor>::create("org.kde.dummy", QString::fromUtf8(static_cast<char*>(keyValue), keySize), revision);
+                event->buffer = eventBuffer;
+                event->storage = storage;
+                resultCallback(event);
+            }
+            return true;
+        });
+        completeCallback();
     });
 }
 
-//TODO call in plugin loader
-// Akonadi2::FacadeFactory::instance().registerFacade<Akonadi2::Domain::Event, DummyResourceFacade>("dummyresource", [facade](){ return new DummyResourceFacade(facade); });
diff --git a/dummyresource/facade.h b/dummyresource/facade.h
index f179c06..c76e62c 100644
--- a/dummyresource/facade.h
+++ b/dummyresource/facade.h
@@ -22,7 +22,9 @@
 #include "common/clientapi.h"
 #include "common/storage.h"
 
-class ResourceAccess;
+namespace Akonadi2 {
+    class ResourceAccess;
+}
 
 class DummyResourceFacade : public Akonadi2::StoreFacade<Akonadi2::Domain::Event>
 {
@@ -32,8 +34,9 @@ public:
     virtual void create(const Akonadi2::Domain::Event &domainObject);
     virtual void modify(const Akonadi2::Domain::Event &domainObject);
     virtual void remove(const Akonadi2::Domain::Event &domainObject);
-    virtual void load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback);
+    virtual void load(const Akonadi2::Query &query, const std::function<void(const Akonadi2::Domain::Event::Ptr &)> &resultCallback, const std::function<void()> &completeCallback);
 
 private:
-    QSharedPointer<ResourceAccess> mResourceAccess;
+    void synchronizeResource(const std::function<void()> &continuation);
+    QSharedPointer<Akonadi2::ResourceAccess> mResourceAccess;
 };
diff --git a/dummyresource/resourcefactory.cpp b/dummyresource/resourcefactory.cpp
index bd85b4f..2c43981 100644
--- a/dummyresource/resourcefactory.cpp
+++ b/dummyresource/resourcefactory.cpp
@@ -20,22 +20,95 @@
 #include "resourcefactory.h"
 #include "facade.h"
 #include "dummycalendar_generated.h"
+#include <QUuid>
+
+static std::string createEvent()
+{
+    static const size_t attachmentSize = 1024*2; // 2KB
+    static uint8_t rawData[attachmentSize];
+    static flatbuffers::FlatBufferBuilder fbb;
+    fbb.Clear();
+    {
+        auto summary = fbb.CreateString("summary");
+        auto data = fbb.CreateUninitializedVector<uint8_t>(attachmentSize);
+        DummyCalendar::DummyEventBuilder eventBuilder(fbb);
+        eventBuilder.add_summary(summary);
+        eventBuilder.add_attachment(data);
+        auto eventLocation = eventBuilder.Finish();
+        DummyCalendar::FinishDummyEventBuffer(fbb, eventLocation);
+        memcpy((void*)DummyCalendar::GetDummyEvent(fbb.GetBufferPointer())->attachment()->Data(), rawData, attachmentSize);
+    }
+
+    return std::string(reinterpret_cast<const char *>(fbb.GetBufferPointer()), fbb.GetSize());
+}
+
+QMap<QString, QString> populate()
+{
+    QMap<QString, QString> content;
+    for (int i = 0; i < 2; i++) {
+        auto event = createEvent();
+        content.insert(QString("key%1").arg(i), QString::fromStdString(event));
+    }
+    return content;
+}
+
+static QMap<QString, QString> s_dataSource = populate();
 
 DummyResource::DummyResource()
     : Akonadi2::Resource()
 {
+}
 
+void findByRemoteId(QSharedPointer<Akonadi2::Storage> storage, const QString &rid, std::function<void(void *keyValue, int keySize, void *dataValue, int dataSize)> callback)
+{
+    //TODO lookup in rid index instead of doing a full scan
+    const std::string ridString = rid.toStdString();
+    storage->scan("", [&](void *keyValue, int keySize, void *dataValue, int dataSize) -> bool {
+        auto eventBuffer = DummyCalendar::GetDummyEvent(dataValue);
+        if (std::string(eventBuffer->remoteId()->c_str(), eventBuffer->remoteId()->size()) == ridString) {
+            callback(keyValue, keySize, dataValue, dataSize);
+        }
+        return true;
+    });
 }
 
 void DummyResource::synchronizeWithSource(Akonadi2::Pipeline *pipeline)
 {
-    // TODO actually populate the storage with new items
-    auto builder = DummyCalendar::DummyEventBuilder(m_fbb);
-    builder .add_summary(m_fbb.CreateString("summary summary!"));
-    auto buffer = builder.Finish();
-    DummyCalendar::FinishDummyEventBuffer(m_fbb, buffer);
-    pipeline->newEntity("fakekey", m_fbb);
-    m_fbb.Clear();
+    //TODO use a read-only transaction during the complete sync to sync against a defined revision
+    
+    qDebug() << "synchronize with source";
+
+    auto storage = QSharedPointer<Akonadi2::Storage>::create(Akonadi2::Store::storageLocation(), "org.kde.dummy");
+    for (auto it = s_dataSource.constBegin(); it != s_dataSource.constEnd(); it++) {
+        bool isNew = true;
+        if (storage->exists()) {
+            findByRemoteId(storage, it.key(), [&](void *keyValue, int keySize, void *dataValue, int dataSize) {
+                isNew = false;
+            });
+        }
+
+        if (isNew) {
+            //TODO: perhaps it would be more convenient to populate the domain types?
+            //Resource specific parts are not accessible that way, but then we would only have to implement the property mapping in one place
+            const QByteArray data = it.value().toUtf8();
+            auto eventBuffer = DummyCalendar::GetDummyEvent(data.data());
+
+            //Map the source format to the buffer format (which happens to be an exact copy here)
+            auto builder = DummyCalendar::DummyEventBuilder(m_fbb);
+            builder.add_summary(m_fbb.CreateString(eventBuffer->summary()->c_str()));
+            auto buffer = builder.Finish();
+            DummyCalendar::FinishDummyEventBuffer(m_fbb, buffer);
+
+            //TODO toRFC4122 would probably be more efficient, but results in non-printable keys.
+            const auto key = QUuid::createUuid().toString().toUtf8();
+            //TODO can we really just start populating the buffer and pass the buffer builder?
+            qDebug() << "new event";
+            pipeline->newEntity(key, m_fbb);
+        } else { //modification
+            //TODO diff and create modification if necessary
+        }
+    }
+    //TODO find items to remove
 }
 
 void DummyResource::processCommand(int commandId, const QByteArray &data, uint size, Akonadi2::Pipeline *pipeline)