1 files changed, 69 insertions, 36 deletions

diff --git a/examples/caldavresource/caldavresource.cpp b/examples/caldavresource/caldavresource.cpp
index d9f8c69..d33f625 100644
--- a/examples/caldavresource/caldavresource.cpp
+++ b/examples/caldavresource/caldavresource.cpp
@@ -25,25 +25,29 @@
 #include "applicationdomaintype.h"
 #include "domainadaptor.h"
 #include "eventpreprocessor.h"
+#include "todopreprocessor.h"
 #include "facade.h"
 #include "facadefactory.h"
 
 #include <KCalCore/ICalFormat>
 
 #define ENTITY_TYPE_EVENT "event"
+#define ENTITY_TYPE_TODO "todo"
 #define ENTITY_TYPE_CALENDAR "calendar"
 
 using Sink::ApplicationDomain::getTypeName;
 
-class EventSynchronizer : public WebDavSynchronizer
+class CalDAVSynchronizer : public WebDavSynchronizer
 {
     using Event = Sink::ApplicationDomain::Event;
+    using Todo = Sink::ApplicationDomain::Todo;
     using Calendar = Sink::ApplicationDomain::Calendar;
 
 public:
-    explicit EventSynchronizer(const Sink::ResourceContext &context)
+    explicit CalDAVSynchronizer(const Sink::ResourceContext &context)
         : WebDavSynchronizer(context, KDAV2::CalDav, getTypeName<Calendar>(), getTypeName<Event>())
-    {}
+    {
+    }
 
 protected:
     void updateLocalCollections(KDAV2::DavCollection::List calendarList) Q_DECL_OVERRIDE
@@ -74,21 +78,27 @@ protected:
 
         switch (incidence->type()) {
             case Type::TypeEvent: {
-                auto remoteEvent = dynamic_cast<const KCalCore::Event &>(*incidence);
-
                 Event localEvent;
                 localEvent.setIcal(ical);
                 localEvent.setCalendar(calendarLocalId);
 
-                SinkTrace() << "Found an event:" << localEvent.getSummary() << "with id:" << rid;
+                SinkTrace() << "Found an event with id:" << rid;
 
                 createOrModify(ENTITY_TYPE_EVENT, rid, localEvent,
                     /* mergeCriteria = */ QHash<QByteArray, Sink::Query::Comparator>{});
                 break;
             }
-            case Type::TypeTodo:
-                SinkWarning() << "Unimplemented add of a 'Todo' item in the Store";
+            case Type::TypeTodo: {
+                Todo localTodo;
+                localTodo.setIcal(ical);
+                localTodo.setCalendar(calendarLocalId);
+
+                SinkTrace() << "Found a Todo with id:" << rid;
+
+                createOrModify(ENTITY_TYPE_TODO, rid, localTodo,
+                    /* mergeCriteria = */ QHash<QByteArray, Sink::Query::Comparator>{});
                 break;
+            }
             case Type::TypeJournal:
                 SinkWarning() << "Unimplemented add of a 'Journal' item in the Store";
                 break;
@@ -108,58 +118,74 @@ protected:
         return syncStore().resolveRemoteId(ENTITY_TYPE_CALENDAR, resourceID(calendar));
     }
 
-    KAsync::Job<QByteArray> replay(const Event &event, Sink::Operation operation,
-        const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties) Q_DECL_OVERRIDE
+    template<typename Item>
+    KAsync::Job<QByteArray> replayItem(const Item &localItem, Sink::Operation operation,
+        const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties,
+        const QByteArray &entityType)
     {
-        SinkLog() << "Replaying event";
+        SinkLog() << "Replaying" << entityType;
 
-        KDAV2::DavItem item;
+        KDAV2::DavItem remoteItem;
 
         switch (operation) {
             case Sink::Operation_Creation: {
-                auto rawIcal = event.getIcal();
-                if(rawIcal == "") {
-                    return KAsync::error<QByteArray>("No ICal in event for creation replay");
+                auto rawIcal = localItem.getIcal();
+                if (rawIcal == "") {
+                    return KAsync::error<QByteArray>("No ICal in item for creation replay");
                 }
 
-                auto collectionId = syncStore().resolveLocalId(ENTITY_TYPE_CALENDAR, event.getCalendar());
+                auto collectionId = syncStore().resolveLocalId(ENTITY_TYPE_CALENDAR, localItem.getCalendar());
 
-                item.setData(rawIcal);
-                item.setContentType("text/calendar");
-                item.setUrl(urlOf(collectionId, event.getUid()));
+                remoteItem.setData(rawIcal);
+                remoteItem.setContentType("text/calendar");
+                remoteItem.setUrl(urlOf(collectionId, localItem.getUid()));
 
-                SinkLog() << "Creating event:" << event.getSummary();
-                return createItem(item).then([item] { return resourceID(item); });
+                SinkLog() << "Creating" << entityType << ":" << localItem.getSummary();
+                return createItem(remoteItem).then([remoteItem] { return resourceID(remoteItem); });
             }
             case Sink::Operation_Removal: {
                 // We only need the URL in the DAV item for removal
-                item.setUrl(urlOf(oldRemoteId));
+                remoteItem.setUrl(urlOf(oldRemoteId));
 
-                SinkLog() << "Removing event:" << oldRemoteId;
-                return removeItem(item).then([] { return QByteArray{}; });
+                SinkLog() << "Removing" << entityType << ":" << oldRemoteId;
+                return removeItem(remoteItem).then([] { return QByteArray{}; });
             }
             case Sink::Operation_Modification:
-                auto rawIcal = event.getIcal();
-                if(rawIcal == "") {
-                    return KAsync::error<QByteArray>("No ICal in event for modification replay");
+                auto rawIcal = localItem.getIcal();
+                if (rawIcal == "") {
+                    return KAsync::error<QByteArray>("No ICal in item for modification replay");
                 }
 
-                item.setData(rawIcal);
-                item.setContentType("text/calendar");
-                item.setUrl(urlOf(oldRemoteId));
+                remoteItem.setData(rawIcal);
+                remoteItem.setContentType("text/calendar");
+                remoteItem.setUrl(urlOf(oldRemoteId));
 
-                SinkLog() << "Modifying event:" << event.getSummary();
+                SinkLog() << "Modifying" << entityType << ":" << localItem.getSummary();
 
                 // It would be nice to check that the URL of the item hasn't
                 // changed and move he item if it did, but since the URL is
                 // pretty much arbitrary, whoe does that anyway?
-                return modifyItem(item).then([oldRemoteId] { return oldRemoteId; });
+                return modifyItem(remoteItem).then([oldRemoteId] { return oldRemoteId; });
         }
     }
 
+    KAsync::Job<QByteArray> replay(const Event &event, Sink::Operation operation,
+        const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties) Q_DECL_OVERRIDE
+    {
+        return replayItem(event, operation, oldRemoteId, changedProperties, ENTITY_TYPE_EVENT);
+    }
+
+    KAsync::Job<QByteArray> replay(const Todo &todo, Sink::Operation operation,
+        const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties) Q_DECL_OVERRIDE
+    {
+        return replayItem(todo, operation, oldRemoteId, changedProperties, ENTITY_TYPE_TODO);
+    }
+
     KAsync::Job<QByteArray> replay(const Calendar &calendar, Sink::Operation operation,
         const QByteArray &oldRemoteId, const QList<QByteArray> &changedProperties) Q_DECL_OVERRIDE
     {
+        SinkLog() << "Replaying calendar";
+
         switch (operation) {
             case Sink::Operation_Creation:
                 SinkWarning() << "Unimplemented replay of calendar creation";
@@ -180,19 +206,23 @@ protected:
 CalDavResource::CalDavResource(const Sink::ResourceContext &context)
     : Sink::GenericResource(context)
 {
-    auto synchronizer = QSharedPointer<EventSynchronizer>::create(context);
+    auto synchronizer = QSharedPointer<CalDAVSynchronizer>::create(context);
     setupSynchronizer(synchronizer);
 
-    setupPreprocessors(ENTITY_TYPE_EVENT, QVector<Sink::Preprocessor*>() << new EventPropertyExtractor);
+    setupPreprocessors(ENTITY_TYPE_EVENT, QVector<Sink::Preprocessor *>() << new EventPropertyExtractor);
+    setupPreprocessors(ENTITY_TYPE_TODO, QVector<Sink::Preprocessor *>() << new TodoPropertyExtractor);
 }
 
 CalDavResourceFactory::CalDavResourceFactory(QObject *parent)
     : Sink::ResourceFactory(parent, {
-                                        Sink::ApplicationDomain::ResourceCapabilities::Event::event,
                                         Sink::ApplicationDomain::ResourceCapabilities::Event::calendar,
+                                        Sink::ApplicationDomain::ResourceCapabilities::Event::event,
                                         Sink::ApplicationDomain::ResourceCapabilities::Event::storage,
+                                        Sink::ApplicationDomain::ResourceCapabilities::Todo::todo,
+                                        Sink::ApplicationDomain::ResourceCapabilities::Todo::storage,
                                     })
-{}
+{
+}
 
 Sink::Resource *CalDavResourceFactory::createResource(const Sink::ResourceContext &context)
 {
@@ -201,10 +231,12 @@ Sink::Resource *CalDavResourceFactory::createResource(const Sink::ResourceContex
 
 using Sink::ApplicationDomain::Calendar;
 using Sink::ApplicationDomain::Event;
+using Sink::ApplicationDomain::Todo;
 
 void CalDavResourceFactory::registerFacades(const QByteArray &resourceName, Sink::FacadeFactory &factory)
 {
     factory.registerFacade<Event, Sink::DefaultFacade<Event>>(resourceName);
+    factory.registerFacade<Todo, Sink::DefaultFacade<Todo>>(resourceName);
     factory.registerFacade<Calendar, Sink::DefaultFacade<Calendar>>(resourceName);
 }
 
@@ -213,6 +245,7 @@ void CalDavResourceFactory::registerAdaptorFactories(
     const QByteArray &resourceName, Sink::AdaptorFactoryRegistry &registry)
 {
     registry.registerFactory<Event, DefaultAdaptorFactory<Event>>(resourceName);
+    registry.registerFactory<Todo, DefaultAdaptorFactory<Todo>>(resourceName);
     registry.registerFactory<Calendar, DefaultAdaptorFactory<Calendar>>(resourceName);
 }