From de9e304c724b5de421a231bcc449a6f3dd0eb48b Mon Sep 17 00:00:00 2001 From: Minijackson Date: Mon, 30 Apr 2018 13:48:50 +0200 Subject: Add replay of events --- examples/caldavresource/caldavresource.cpp | 71 ++++++++ examples/caldavresource/tests/caldavtest.cpp | 250 +++++++++++++++++++++++---- examples/webdavcommon/webdav.cpp | 83 ++++++++- examples/webdavcommon/webdav.h | 39 +++++ 4 files changed, 408 insertions(+), 35 deletions(-) (limited to 'examples') diff --git a/examples/caldavresource/caldavresource.cpp b/examples/caldavresource/caldavresource.cpp index 6bf1a27..3fbd624 100644 --- a/examples/caldavresource/caldavresource.cpp +++ b/examples/caldavresource/caldavresource.cpp @@ -107,6 +107,77 @@ protected: { return syncStore().resolveRemoteId(ENTITY_TYPE_CALENDAR, resourceID(calendar)); } + + KAsync::Job replay(const Event &event, Sink::Operation operation, + const QByteArray &oldRemoteId, const QList &changedProperties) Q_DECL_OVERRIDE + { + SinkLog() << "Replaying event"; + + //auto incidence = KCalCore::ICalFormat().readIncidence(rawIcal); + + KDAV2::DavItem item; + + switch (operation) { + case Sink::Operation_Creation: { + SinkLog() << "Replaying creation"; + + auto rawIcal = event.getIcal(); + if(rawIcal == "") { + return KAsync::error("No ICal in event for creation replay"); + } + + auto collectionId = syncStore().resolveLocalId(ENTITY_TYPE_CALENDAR, event.getCalendar()); + + item.setData(rawIcal); + item.setContentType("text/calendar"); + item.setUrl(urlOf(collectionId, event.getUid())); + + return createItem(item).then([item] { return resourceID(item); }); + } + case Sink::Operation_Removal: { + // We only need the URL in the DAV item for removal + item.setUrl(urlOf(oldRemoteId)); + + return removeItem(item).then([oldRemoteId] { return oldRemoteId; }); + } + case Sink::Operation_Modification: + SinkLog() << "Replaying modification"; + + auto rawIcal = event.getIcal(); + if(rawIcal == "") { + return KAsync::error("No ICal in event for modification replay"); + } + + item.setData(rawIcal); + item.setContentType("text/calendar"); + item.setUrl(urlOf(oldRemoteId)); + + // 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; }); + } + } + + KAsync::Job replay(const Calendar &calendar, Sink::Operation operation, + const QByteArray &oldRemoteId, const QList &changedProperties) Q_DECL_OVERRIDE + { + + // TODO: add the URL to list of attributes, can't do nothing otherwise + switch (operation) { + case Sink::Operation_Creation: + SinkLog() << "Replaying calendar creation"; + break; + case Sink::Operation_Removal: + SinkLog() << "Replaying calendar removal"; + break; + case Sink::Operation_Modification: + SinkLog() << "Replaying calendar modification"; + break; + } + + return KAsync::null(); + } }; CalDavResource::CalDavResource(const Sink::ResourceContext &context) diff --git a/examples/caldavresource/tests/caldavtest.cpp b/examples/caldavresource/tests/caldavtest.cpp index 584e288..35ab033 100644 --- a/examples/caldavresource/tests/caldavtest.cpp +++ b/examples/caldavresource/tests/caldavtest.cpp @@ -1,5 +1,14 @@ #include +#include +#include +#include +#include +#include + +#include +#include + #include "../caldavresource.h" #include "common/resourcecontrol.h" @@ -8,6 +17,8 @@ #include "common/test.h" #include "tests/testutils.h" +#include + using Sink::ApplicationDomain::Calendar; using Sink::ApplicationDomain::DummyResource; using Sink::ApplicationDomain::Event; @@ -20,16 +31,17 @@ class CalDavTest : public QObject SinkResource createResource() { auto resource = Sink::ApplicationDomain::CalDavResource::create("account1"); - resource.setProperty("server", "http://localhost/dav/calendars/users/doe"); - resource.setProperty("username", "doe"); - Sink::SecretStore::instance().insert(resource.identifier(), "doe"); + resource.setProperty("server", "http://localhost:5232"); + resource.setProperty("username", "test1"); + Sink::SecretStore::instance().insert(resource.identifier(), "test1"); resource.setProperty("testmode", true); return resource; } - QByteArray mResourceInstanceIdentifier; + QString addedEventUid; + private slots: void initTestCase() @@ -51,34 +63,208 @@ private slots: VERIFYEXEC(Sink::ResourceControl::start(mResourceInstanceIdentifier)); } - // void testSyncCal() - // { - // VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier))); - // // Check in the logs that it doesn't synchronize events again because same CTag - // VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier))); - // } - - // void testSyncCalEmpty() - // { - // VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier))); - - // auto eventJob = - // Sink::Store::fetchAll(Sink::Query().request()).then([](const QList &events) { - // QCOMPARE(events.size(), 14); - // }); - // VERIFYEXEC(eventJob); - - // auto calendarJob = - // Sink::Store::fetchAll(Sink::Query().request()).then([](const QList &calendars) { - // QCOMPARE(calendars.size(), 2); - // for (const auto &calendar : calendars) { - // QVERIFY(calendar->getName() == "Calendar" || calendar->getName() == "Tasks"); - // } - // }); - // VERIFYEXEC(calendarJob); - - // SinkLog() << "Finished"; - // } + void testSyncCal() + { + VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier))); + // Check in the logs that it doesn't synchronize events again because same CTag + VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier))); + } + + void testSyncCalEmpty() + { + VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier))); + VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier)); + + auto eventJob = Sink::Store::fetchAll(Sink::Query().request()) + .then([](const QList &events) { QCOMPARE(events.size(), 1); }); + VERIFYEXEC(eventJob); + + auto calendarJob = Sink::Store::fetchAll(Sink::Query().request()) + .then([](const QList &calendars) { + QCOMPARE(calendars.size(), 1); + for (const auto &calendar : calendars) { + QVERIFY(calendar->getName() == "MyCalendar"); + } + }); + VERIFYEXEC(calendarJob); + + SinkLog() << "Finished"; + } + + void testAddEvent() + { + VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier))); + VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier)); + + auto job = Sink::Store::fetchOne({}).exec(); + job.waitForFinished(); + QVERIFY2(!job.errorCode(), "Fetching Calendar failed"); + auto calendar = job.value(); + + auto event = QSharedPointer::create(); + event->setSummary("Hello"); + event->setDtStart(QDateTime::currentDateTime()); + event->setDtEnd(QDateTime::currentDateTime().addSecs(3600)); + event->setCreated(QDateTime::currentDateTime()); + addedEventUid = QUuid::createUuid().toString(); + event->setUid(addedEventUid); + + auto ical = KCalCore::ICalFormat().toICalString(event); + Event sinkEvent(mResourceInstanceIdentifier); + sinkEvent.setIcal(ical.toUtf8()); + sinkEvent.setCalendar(calendar); + + SinkLog() << "Adding event"; + VERIFYEXEC(Sink::Store::create(sinkEvent)); + VERIFYEXEC(Sink::ResourceControl::flushReplayQueue(mResourceInstanceIdentifier)); + + auto verifyEventCountJob = + Sink::Store::fetchAll(Sink::Query().request()).then([](const QList &events) { + QCOMPARE(events.size(), 2); + }); + VERIFYEXEC(verifyEventCountJob); + + auto verifyEventJob = + Sink::Store::fetchOne(Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid))) + .then([](const Event &event) { QCOMPARE(event.getSummary(), "Hello"); }); + VERIFYEXEC(verifyEventJob); + } + + void testModifyEvent() + { + VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier))); + VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier)); + + auto job = Sink::Store::fetchOne( + Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid))) + .exec(); + job.waitForFinished(); + QVERIFY2(!job.errorCode(), "Fetching Event failed"); + auto event = job.value(); + + auto incidence = KCalCore::ICalFormat().readIncidence(event.getIcal()); + auto calevent = incidence.dynamicCast(); + QVERIFY2(calevent, "Cannot convert to KCalCore event"); + + calevent->setSummary("Hello World!"); + auto dummy = QSharedPointer(calevent); + auto newical = KCalCore::ICalFormat().toICalString(dummy); + + event.setIcal(newical.toUtf8()); + + VERIFYEXEC(Sink::Store::modify(event)); + + VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier))); + VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier)); + + auto verifyEventCountJob = Sink::Store::fetchAll({}).then( + [](const QList &events) { QCOMPARE(events.size(), 2); }); + VERIFYEXEC(verifyEventCountJob); + + auto verifyEventJob = + Sink::Store::fetchOne(Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid))) + .then([](const Event &event) { QCOMPARE(event.getSummary(), "Hello World!"); }); + VERIFYEXEC(verifyEventJob); + } + + void testSneakyModifyEvent() + { + VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier))); + VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier)); + + // Change the item without sink's knowledge + { + qWarning() << 1; + auto collection = ([]() -> KDAV2::DavCollection { + KDAV2::DavUrl davurl({ "http://test1:test1@localhost:5232" }, KDAV2::CalDav); + KDAV2::DavCollectionsFetchJob collectionsJob(davurl); + collectionsJob.exec(); + Q_ASSERT(collectionsJob.error() == 0); + return collectionsJob.collections()[0]; + })(); + + auto itemList = ([&collection]() -> KDAV2::DavItem::List { + auto cache = std::make_shared(); + KDAV2::DavItemsListJob itemsListJob(collection.url(), cache); + itemsListJob.exec(); + Q_ASSERT(itemsListJob.error() == 0); + return itemsListJob.items(); + })(); + auto hollowDavItemIt = + std::find_if(itemList.begin(), itemList.end(), [this](const KDAV2::DavItem &item) { + return item.url().url().path().endsWith(addedEventUid); + }); + + auto davitem = ([this, &collection, &hollowDavItemIt]() -> KDAV2::DavItem { + QString itemUrl = collection.url().url().toEncoded() + addedEventUid; + KDAV2::DavItemFetchJob itemFetchJob(*hollowDavItemIt); + itemFetchJob.exec(); + Q_ASSERT(itemFetchJob.error() == 0); + return itemFetchJob.item(); + })(); + + qWarning() << 3; + auto incidence = KCalCore::ICalFormat().readIncidence(davitem.data()); + auto calevent = incidence.dynamicCast(); + QVERIFY2(calevent, "Cannot convert to KCalCore event"); + + qWarning() << 4; + calevent->setSummary("Manual Hello World!"); + auto newical = KCalCore::ICalFormat().toICalString(calevent); + + qWarning() << 5; + davitem.setData(newical.toUtf8()); + KDAV2::DavItemModifyJob itemModifyJob(davitem); + itemModifyJob.exec(); + QVERIFY2(itemModifyJob.error() == 0, "Cannot modify item"); + + qWarning() << 6; + } + + // Try to change the item with sink + { + auto job = Sink::Store::fetchOne( + Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid))) + .exec(); + job.waitForFinished(); + QVERIFY2(!job.errorCode(), "Fetching Event failed"); + auto event = job.value(); + + auto incidence = KCalCore::ICalFormat().readIncidence(event.getIcal()); + auto calevent = incidence.dynamicCast(); + QVERIFY2(calevent, "Cannot convert to KCalCore event"); + + calevent->setSummary("Sink Hello World!"); + auto dummy = QSharedPointer(calevent); + auto newical = KCalCore::ICalFormat().toICalString(dummy); + + event.setIcal(newical.toUtf8()); + + // TODO: make that fail + VERIFYEXEC(Sink::Store::modify(event)); + VERIFYEXEC(Sink::ResourceControl::flushReplayQueue(mResourceInstanceIdentifier)); + } + } + + void testRemoveEvent() + { + VERIFYEXEC(Sink::Store::synchronize(Sink::Query().resourceFilter(mResourceInstanceIdentifier))); + VERIFYEXEC(Sink::ResourceControl::flushMessageQueue(mResourceInstanceIdentifier)); + + auto job = Sink::Store::fetchOne( + Sink::Query().filter("uid", Sink::Query::Comparator(addedEventUid))) + .exec(); + job.waitForFinished(); + QVERIFY2(!job.errorCode(), "Fetching Event failed"); + auto event = job.value(); + + VERIFYEXEC(Sink::Store::remove(event)); + VERIFYEXEC(Sink::ResourceControl::flushReplayQueue(mResourceInstanceIdentifier)); + + auto verifyEventCountJob = Sink::Store::fetchAll({}).then( + [](const QList &events) { QCOMPARE(events.size(), 1); }); + VERIFYEXEC(verifyEventCountJob); + } }; QTEST_MAIN(CalDavTest) diff --git a/examples/webdavcommon/webdav.cpp b/examples/webdavcommon/webdav.cpp index ad1af35..f97a866 100644 --- a/examples/webdavcommon/webdav.cpp +++ b/examples/webdavcommon/webdav.cpp @@ -22,8 +22,13 @@ #include "applicationdomaintype.h" #include "resourceconfig.h" +#include +#include #include +#include +#include #include +#include #include #include @@ -180,7 +185,6 @@ KAsync::Job WebDavSynchronizer::synchronizeCollection(const KDAV2::DavColl auto localRid = collectionLocalResourceID(collection); - // The ETag cache is useless here, since `sinkStore()` IS the cache. auto cache = std::make_shared(); auto davItemsListJob = new KDAV2::DavItemsListJob(collection.url(), std::move(cache)); @@ -234,14 +238,87 @@ KAsync::Job WebDavSynchronizer::synchronizeItem(const KDAV2::DavItem &item }); } +KAsync::Job WebDavSynchronizer::createItem(const KDAV2::DavItem &item) +{ + auto job = new KDAV2::DavItemCreateJob(item); + return runJob(job).then([] { + SinkLog() << "Done creating item"; + }); +} + +KAsync::Job WebDavSynchronizer::removeItem(const KDAV2::DavItem &item) +{ + auto job = new KDAV2::DavItemDeleteJob(item); + return runJob(job).then([] { + SinkLog() << "Done removing item"; + }); +} + +KAsync::Job WebDavSynchronizer::modifyItem(const KDAV2::DavItem &item) +{ + auto job = new KDAV2::DavItemModifyJob(item); + return runJob(job).then([] { + SinkLog() << "Done modifying item"; + }); +} + +/* +KAsync::Job WebDavSynchronizer::createCollection(const KDAV2::DavCollection &collection) +{ + auto job = new KDAV2::DavCollectionCreateJob(collection); + return runJob(job); +} +*/ + +KAsync::Job WebDavSynchronizer::removeCollection(const KDAV2::DavUrl &url) +{ + auto job = new KDAV2::DavCollectionDeleteJob(url); + return runJob(job); +} + +KAsync::Job WebDavSynchronizer::modifyCollection(const KDAV2::DavUrl &url) +{ + auto job = new KDAV2::DavCollectionModifyJob(url); + return runJob(job); +} + +/* +KAsync::Job WebDavSynchronizer::replay(const Contact &, Sink::Operation operation, + const QByteArray &oldRemoteId, const QList &changedProperties) +{ + return replayItem(Sink::ApplicationDomain::getTypeName(), operation, oldRemoteId, +changedProperties); +} + +KAsync::Job WebDavSynchronizer::replay(const Addressbook &, Sink::Operation operation, + const QByteArray &oldRemoteId, const QList &changedProperties) +{ + return replayCollection(Sink::ApplicationDomain::getTypeName(), operation, + oldRemoteId, changedProperties); +} +*/ + QByteArray WebDavSynchronizer::resourceID(const KDAV2::DavCollection &collection) { - return collection.url().toDisplayString().toUtf8(); + return collection.url().url().toEncoded(); } QByteArray WebDavSynchronizer::resourceID(const KDAV2::DavItem &item) { - return item.url().toDisplayString().toUtf8(); + return item.url().url().toEncoded(); +} + +KDAV2::DavUrl WebDavSynchronizer::urlOf(const QByteArray &remoteId) +{ + auto url = QUrl::fromEncoded(remoteId); + auto davurl = serverUrl(); + davurl.setUrl(url); + return davurl; +} + +KDAV2::DavUrl WebDavSynchronizer::urlOf(const QByteArray &collectionRemoteId, const QString &itemPath) +{ + return urlOf(collectionRemoteId + "/" + itemPath.toUtf8()); } bool WebDavSynchronizer::unchanged(const KDAV2::DavCollection &collection) diff --git a/examples/webdavcommon/webdav.h b/examples/webdavcommon/webdav.h index 3a4977c..ecb6a81 100644 --- a/examples/webdavcommon/webdav.h +++ b/examples/webdavcommon/webdav.h @@ -35,6 +35,32 @@ public: KAsync::Job synchronizeWithSource(const Sink::QueryBase &query) Q_DECL_OVERRIDE; protected: + + /** + * Called in a child synchronizer, when replaying a creation of an item. + */ + KAsync::Job createItem(const KDAV2::DavItem &); + + /** + * Called in a child synchronizer, when replaying a removal of an item. + */ + KAsync::Job removeItem(const KDAV2::DavItem &); + + /** + * Called in a child synchronizer, when replaying a modification of an item. + * + * The item to modify is chosen according to the given item's URL. + * The job will fail if the ETag does not match. + */ + KAsync::Job modifyItem(const KDAV2::DavItem &); + + /** + * See comments of the *Item version above + */ + KAsync::Job createCollection(const KDAV2::DavUrl &); + KAsync::Job removeCollection(const KDAV2::DavUrl &); + KAsync::Job modifyCollection(const KDAV2::DavUrl &); + /** * Called with the list of discovered collections. It's purpose should be * adding the said collections to the store. @@ -63,6 +89,19 @@ protected: static QByteArray resourceID(const KDAV2::DavCollection &); static QByteArray resourceID(const KDAV2::DavItem &); + /** + * Used to get the url of an item / collection with the given remote ID + */ + KDAV2::DavUrl urlOf(const QByteArray &remoteId); + + /** + * Used to get the url of an item / collection with the given remote ID, + * and append `itemPath` to the path of the URI. + * + * Useful when adding a new item to a collection + */ + KDAV2::DavUrl urlOf(const QByteArray &collectionRemoteId, const QString &itemPath); + bool unchanged(const KDAV2::DavCollection &); bool unchanged(const KDAV2::DavItem &); -- cgit v1.2.3