public Task Delete(Uri entityId, string version)
 {
     using (AutomaticStopwatch.StartDebug(s_logger))
     {
         return(_calDavDataAccess.DeleteEntity(entityId, version));
     }
 }
Esempio n. 2
0
 public async Task Delete(WebResourceName entityId, string version)
 {
     using (AutomaticStopwatch.StartDebug(s_logger))
     {
         await _calDavDataAccess.DeleteEntity(entityId, version);
     }
 }
Esempio n. 3
0
 public bool Delete(Uri entityId)
 {
     using (AutomaticStopwatch.StartDebug(s_logger))
     {
         return(_calDavDataAccess.DeleteEntity(entityId));
     }
 }
Esempio n. 4
0
        public async Task Test_CRUD()
        {
            foreach (var evt in await _calDavDataAccess.GetEventVersions(null))
            {
                await _calDavDataAccess.DeleteEntity(evt.Id, evt.Version);
            }

            var entitiesWithVersion = new List <EntityVersion <WebResourceName, string> >();

            var uids = new List <string>();

            for (int i = 1; i <= 5; i++)
            {
                var iCalendar = CreateEntity(i);
                uids.Add(iCalendar.Events[0].UID);
                entitiesWithVersion.Add(
                    await _calDavDataAccess.CreateEntity(
                        SerializeCalendar(
                            iCalendar), iCalendar.Events[0].UID));
            }

            var queriedEntitesWithVersion = await _calDavDataAccess.GetEventVersions(new DateTimeRange (DateTime.Now.AddDays(150), DateTime.Now.AddDays(450)));

            Assert.That(queriedEntitesWithVersion.Count, Is.EqualTo(3));

            CollectionAssert.IsSubsetOf(
                queriedEntitesWithVersion.Select(e => e.Id),
                entitiesWithVersion.Select(e => e.Id));

            var updatedCalendar = CreateEntity(600);

            updatedCalendar.Events[0].UID = uids[1];
            var updated = await _calDavDataAccess.UpdateEntity(
                entitiesWithVersion[1].Id,
                entitiesWithVersion[1].Version,
                SerializeCalendar (updatedCalendar));

            Assert.That(
                (await _calDavDataAccess.GetEventVersions(new DateTimeRange(DateTime.Now.AddDays(150), DateTime.Now.AddDays(450)))).Count,
                Is.EqualTo(2));

            var updatedRevertedCalendar = CreateEntity(2);

            updatedRevertedCalendar.Events[0].UID = uids[1];
            var updateReverted = await _calDavDataAccess.UpdateEntity(
                updated.Id,
                updated.Version,
                SerializeCalendar (updatedRevertedCalendar));

            Assert.That(
                (await _calDavDataAccess.GetEventVersions(new DateTimeRange(DateTime.Now.AddDays(150), DateTime.Now.AddDays(450)))).Count,
                Is.EqualTo(3));

            await _calDavDataAccess.DeleteEntity(updateReverted.Id, updateReverted.Version);

            Assert.That(
                (await _calDavDataAccess.GetEventVersions(new DateTimeRange(DateTime.Now.AddDays(150), DateTime.Now.AddDays(450)))).Count,
                Is.EqualTo(2));

            var entites = await _calDavDataAccess.GetEntities(entitiesWithVersion.Take (4).Select(e => e.Id));

            if (!DeletedEntitesAreJustMarkedAsDeletedAndStillAvailableViaCalendarMultigetReport)
            {
                Assert.That(entites.Count, Is.EqualTo(3)); // Only 3, the second was deleted

                CollectionAssert.AreEquivalent(
                    entites.Select(e => DeserializeCalendar(e.Entity).Events[0].Summary),
                    new[] { "Event1", "Event3", "Event4" });
            }
            else
            {
                CollectionAssert.AreEquivalent(
                    entites.Select(e => DeserializeCalendar(e.Entity).Events[0].Summary),
                    new[] { "Event1", "Event2", "Event3", "Event4" });
            }
        }