Add Todo support in caldav synchronizer

1 files changed, 51 insertions, 29 deletions

diff --git a/examples/caldavresource/caldavresource.cpp b/examples/caldavresource/caldavresource.cpp
index cdd224f..e28fbc5 100644
--- a/examples/caldavresource/caldavresource.cpp
+++ b/examples/caldavresource/caldavresource.cpp
@@ -78,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;
@@ -112,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";