private Task <IReadOnlyList <EntityWithVersion <Uri, IICalendar> > > ParallelDeserialize(IReadOnlyList <EntityWithVersion <Uri, string> > serializedEntities)
{
return(Task.Factory.StartNew(() =>
{
var result = new List <EntityWithVersion <Uri, IICalendar> >();
Parallel.ForEach(
serializedEntities,
() => Tuple.Create(new iCalendarSerializer(), new List <Tuple <Uri, IICalendar> >()),
(serialized, loopState, threadLocal) =>
{
IICalendar calendar;
if (TryDeserializeCalendar(serialized.Entity, out calendar, serialized.Id, threadLocal.Item1))
{
threadLocal.Item2.Add(Tuple.Create(serialized.Id, calendar));
}
return threadLocal;
},
threadLocal =>
{
lock (result)
{
foreach (var calendar in threadLocal.Item2)
{
result.Add(EntityWithVersion.Create(calendar.Item1, calendar.Item2));
}
}
});
IReadOnlyList <EntityWithVersion <Uri, IICalendar> > readOnlyResult = result;
return readOnlyResult;
}));
}
private IReadOnlyList <EntityWithVersion <Uri, vCard> > ParallelDeserialize(IReadOnlyList <EntityWithVersion <Uri, string> > serializedEntities)
{
var result = new List <EntityWithVersion <Uri, vCard> >();
Parallel.ForEach(
serializedEntities,
() => Tuple.Create(new vCardStandardReader(), new List <Tuple <Uri, vCard> >()),
(serialized, loopState, threadLocal) =>
{
vCard vcard;
if (TryDeserialize(serialized.Entity, out vcard, serialized.Id, threadLocal.Item1))
{
threadLocal.Item2.Add(Tuple.Create(serialized.Id, vcard));
}
return(threadLocal);
},
threadLocal =>
{
lock (result)
{
foreach (var calendar in threadLocal.Item2)
{
result.Add(EntityWithVersion.Create(calendar.Item1, calendar.Item2));
}
}
});
return(result);
}
public static string SyncOutlookToCalDav_EventsExistsInCalDav(string existingEventData, IEntityRelationDataAccess <string, DateTime, Uri, string> entityRelationDataAccess = null)
{
string roundTrippedData = null;
ICalDavDataAccess calDavDataAccess = MockRepository.GenerateMock <ICalDavDataAccess>();
var entityUri = new Uri("/e1", UriKind.Relative);
calDavDataAccess
.Expect(r => r.GetEvents(null))
.IgnoreArguments()
.Return(Task.FromResult <IReadOnlyList <EntityIdWithVersion <Uri, string> > > (
new[] { EntityIdWithVersion.Create(entityUri, "v1") }));
calDavDataAccess
.Expect(r => r.GetEntities(Arg <ICollection <Uri> > .List.Equal(new[] { entityUri })))
.Return(Task.FromResult <IReadOnlyList <EntityWithVersion <Uri, string> > > (
new[] { EntityWithVersion.Create(entityUri, existingEventData) }));
calDavDataAccess
.Expect(r => r.UpdateEntity(new Uri("http://bla.com"), null))
.IgnoreArguments()
.Return(Task.FromResult <EntityIdWithVersion <Uri, string> > (
EntityIdWithVersion.Create(new Uri("http://bla.com"), "blubb")))
.WhenCalled(a => { roundTrippedData = (string)a.Arguments[1]; });
ISynchronizer synchronizer = OutlookTestContext.CreateEventSynchronizer(
SynchronizationMode.ReplicateOutlookIntoServer,
calDavDataAccess,
entityRelationDataAccess);
WaitForTask(synchronizer.Synchronize());
return(roundTrippedData);
}
public void Synchronize_GetVersionsAndGetReturnDuplicateEntries_RemovesDuplicates()
{
var builder = new SynchronizerBuilder();
builder.AtypeIdComparer = StringComparer.InvariantCultureIgnoreCase;
builder.AtypeRepository
.Expect(r => r.GetVersions(DateTime.Now, DateTime.Now))
.IgnoreArguments()
.Return(new[] { EntityIdWithVersion.Create("A1", "v1"), EntityIdWithVersion.Create("a1", "v3") });
builder.BtypeRepository
.Expect(r => r.GetVersions(DateTime.Now, DateTime.Now))
.IgnoreArguments()
.Return(new[] { EntityIdWithVersion.Create("b1", "v2") });
Task <IReadOnlyList <EntityWithVersion <string, string> > > aTypeLoadTask = new Task <IReadOnlyList <EntityWithVersion <string, string> > > (
() => new List <EntityWithVersion <string, string> > {
EntityWithVersion.Create("A1", "AAAA"), EntityWithVersion.Create("a1", "____")
});
aTypeLoadTask.RunSynchronously();
builder.AtypeRepository
.Expect(r => r.Get(Arg <ICollection <string> > .Matches(c => c.Count == 1 && c.First() == "A1")))
.Return(aTypeLoadTask);
Task <IReadOnlyList <EntityWithVersion <string, string> > > bTypeLoadTask = new Task <IReadOnlyList <EntityWithVersion <string, string> > > (
() => new List <EntityWithVersion <string, string> > {
EntityWithVersion.Create("b1", "BBBB"),
});
bTypeLoadTask.RunSynchronously();
builder.BtypeRepository
.Expect(r => r.Get(Arg <ICollection <string> > .Matches(c => c.Count == 1 && c.First() == "b1")))
.Return(bTypeLoadTask);
var knownData = new EntityRelationDataString("A1", "v1", "b1", "v2");
builder.InitialEntityMatcher
.Expect(m => m.FindMatchingEntities(null, null, null, null, null))
.IgnoreArguments()
.Return(new List <IEntityRelationData <string, string, string, string> > {
knownData
});
builder.InitialSyncStateCreationStrategy
.Expect(s => s.CreateFor_Unchanged_Unchanged(knownData))
.Return(new DoNothing <string, string, string, string, string, string> (knownData));
var synchronizer = builder.Build();
synchronizer.Synchronize().Wait();
builder.SynchronizerContext.AssertWasCalled(
c => c.SaveEntityRelationData(Arg <List <IEntityRelationData <string, string, string, string> > > .Matches(l => l.Count == 1 && l[0] == knownData)));
}
#pragma warning disable 1998
public async Task <IReadOnlyList <EntityWithVersion <string, GenericComObjectWrapper <ContactItem> > > > Get(ICollection <string> ids)
#pragma warning restore 1998
{
return(ids
.Select(id => EntityWithVersion.Create(
id,
GenericComObjectWrapper.Create(
(ContactItem)_mapiNameSpace.GetItemFromID(id, _folderStoreId))))
.ToArray());
}
#pragma warning disable 1998
public async Task <IReadOnlyList <EntityWithVersion <string, AppointmentItemWrapper> > > Get(ICollection <string> ids)
#pragma warning restore 1998
{
return(ids
.Select(id => EntityWithVersion.Create(
id,
new AppointmentItemWrapper(
(AppointmentItem)_mapiNameSpace.GetItemFromID(id, _folderStoreId),
entryId => (AppointmentItem)_mapiNameSpace.GetItemFromID(entryId, _folderStoreId))))
.ToArray());
}
#pragma warning disable 1998
public async Task <IReadOnlyList <EntityWithVersion <string, TaskItemWrapper> > > Get(ICollection <string> ids)
#pragma warning restore 1998
{
var storeId = _taskFolder.StoreID;
return(ids
.Select(id => EntityWithVersion.Create(
id,
new TaskItemWrapper(
(TaskItem)_mapiNameSpace.GetItemFromID(id, storeId),
entryId => (TaskItem)_mapiNameSpace.GetItemFromID(entryId, storeId))))
.ToArray());
}
public IReadOnlyList <EntityWithVersion <Uri, string> > GetEntities(IEnumerable <Uri> eventUrls)
{
var requestBody = @"<?xml version=""1.0""?>
<C:calendar-multiget xmlns:C=""urn:ietf:params:xml:ns:caldav"" xmlns:D=""DAV:"">
<D:prop>
<D:getetag/>
<D:displayname/>
<C:calendar-data/>
</D:prop>
" + String.Join(Environment.NewLine, eventUrls.Select(u => string.Format("<D:href>{0}</D:href>", u))) + @"
</C:calendar-multiget>";
var responseXml = _calDavWebClient.ExecuteCalDavRequestAndReadResponse(
_calendarUrl,
request =>
{
request.Method = "REPORT";
request.ContentType = "text/xml; charset=UTF-8";
request.Headers.Add("Depth", "1");
request.ServicePoint.Expect100Continue = false;
request.Headers.Add(HttpRequestHeader.AcceptCharset, "utf-8");
},
requestBody
);
XmlNodeList responseNodes = responseXml.XmlDocument.SelectNodes("/D:multistatus/D:response", responseXml.XmlNamespaceManager);
var entities = new List <EntityWithVersion <Uri, string> >();
if (responseNodes == null)
{
return(entities);
}
// ReSharper disable once LoopCanBeConvertedToQuery
// ReSharper disable once PossibleNullReferenceException
foreach (XmlElement responseElement in responseNodes)
{
var urlNode = responseElement.SelectSingleNode("D:href", responseXml.XmlNamespaceManager);
var dataNode = responseElement.SelectSingleNode("D:propstat/D:prop/C:calendar-data", responseXml.XmlNamespaceManager);
if (urlNode != null && dataNode != null)
{
entities.Add(EntityWithVersion.Create(UriHelper.UnescapeRelativeUri(_calendarUrl, urlNode.InnerText), dataNode.InnerText));
}
}
return(entities);
}
public async Task <IReadOnlyList <EntityWithVersion <Uri, string> > > GetEntities(IEnumerable <Uri> urls)
{
var requestBody = @" <?xml version=""1.0"" encoding=""utf-8"" ?>
<C:addressbook-multiget xmlns:D=""DAV:"" xmlns:C=""urn:ietf:params:xml:ns:carddav"">
<D:prop>
<D:getetag/>
<C:address-data/>
</D:prop>
" + String.Join(Environment.NewLine, urls.Select(u => string.Format("<D:href>{0}</D:href>", u))) + @"
</C:addressbook-multiget>
";
var responseXml = await _webDavClient.ExecuteWebDavRequestAndReadResponse(
_serverUrl,
request =>
{
request.Method = new System.Net.Http.HttpMethod("REPORT");
request.Headers.Add("Depth", "1");
//request.Headers.Add (HttpRequestHeader.AcceptCharset, "utf-8");
},
"application/xml",
requestBody
);
XmlNodeList responseNodes = responseXml.XmlDocument.SelectNodes("/D:multistatus/D:response", responseXml.XmlNamespaceManager);
var entities = new List <EntityWithVersion <Uri, string> >();
if (responseNodes == null)
{
return(entities);
}
// ReSharper disable once LoopCanBeConvertedToQuery
// ReSharper disable once PossibleNullReferenceException
foreach (XmlElement responseElement in responseNodes)
{
var urlNode = responseElement.SelectSingleNode("D:href", responseXml.XmlNamespaceManager);
var dataNode = responseElement.SelectSingleNode("D:propstat/D:prop/A:address-data", responseXml.XmlNamespaceManager);
if (urlNode != null && dataNode != null)
{
entities.Add(EntityWithVersion.Create(UriHelper.UnescapeRelativeUri(_serverUrl, urlNode.InnerText), dataNode.InnerText));
}
}
return(entities);
}
public static void SyncCalDavToOutlook(string eventData, IEntityRelationDataAccess <string, DateTime, Uri, string> entityRelationDataAccess)
{
var calDavDataAccess = MockRepository.GenerateMock <ICalDavDataAccess>();
var entityUri = new Uri("/e1", UriKind.Relative);
calDavDataAccess
.Expect(r => r.GetEvents(null))
.IgnoreArguments()
.Return(Task.FromResult <IReadOnlyList <EntityIdWithVersion <Uri, string> > > (
new[] { EntityIdWithVersion.Create(entityUri, "v1") }));
calDavDataAccess
.Expect(r => r.GetEntities(Arg <ICollection <Uri> > .List.Equal(new[] { entityUri })))
.Return(Task.FromResult <IReadOnlyList <EntityWithVersion <Uri, string> > > (
new[] { EntityWithVersion.Create(entityUri, eventData) }));
var synchronizer = OutlookTestContext.CreateEventSynchronizer(
SynchronizationMode.ReplicateServerIntoOutlook,
calDavDataAccess,
entityRelationDataAccess);
WaitForTask(synchronizer.Synchronize());
}
// ReSharper disable once CSharpWarnings::CS1998
public async Task <IReadOnlyList <EntityWithVersion <string, string> > > Get(ICollection <string> ids)
{
return(ids.Select(id => EntityWithVersion.Create(id, EntityVersionAndContentById[id].Item2)).ToArray());
}
public Task <IReadOnlyList <EntityWithVersion <Identifier, string> > > Get(ICollection <Identifier> ids)
{
return(Task.FromResult <IReadOnlyList <EntityWithVersion <Identifier, string> > > (
ids.Select(id => EntityWithVersion.Create(id, EntityVersionAndContentById[id].Item2)).ToArray()));
}
