public static List <string> SyncOutlookToCalDav_CalDavIsEmpty(
IEntityRelationDataAccess <string, DateTime, WebResourceName, string> entityRelationDataAccess = null,
Action <Options> optionsModifier = null)
{
var calDavEvents = new List <string>();
ICalDavDataAccess calDavDataAccess = MockRepository.GenerateMock <ICalDavDataAccess>();
calDavDataAccess
.Expect(r => r.GetEventVersions(null))
.IgnoreArguments()
.Return(Task.FromResult <IReadOnlyList <EntityVersion <WebResourceName, string> > > (
new EntityVersion <WebResourceName, string>[] { }));
calDavDataAccess
.Expect(r => r.CreateEntity(null, Guid.NewGuid().ToString()))
.IgnoreArguments()
.Return(Task.FromResult(
EntityVersion.Create(new WebResourceName("http://bla.com"), "blubb")))
.WhenCalled(a => calDavEvents.Add((string)a.Arguments[0]));
var synchronizer = CreateEventSynchronizer(
SynchronizationMode.ReplicateOutlookIntoServer,
calDavDataAccess,
entityRelationDataAccess,
optionsModifier);
WaitForTask(synchronizer.SynchronizeNoThrow(NullSynchronizationLogger.Instance));
return(calDavEvents);
}
public DuplicateEventCleaner(
OutlookEventRepository outlookRepository,
IEntityRepository <WebResourceName, string, IICalendar, IEventSynchronizationContext> btypeRepository,
IEntityRelationDataAccess <AppointmentId, DateTime, WebResourceName, string> entityRelationDataAccess,
IEqualityComparer <AppointmentId> idComparer)
{
if (outlookRepository == null)
{
throw new ArgumentNullException(nameof(outlookRepository));
}
if (btypeRepository == null)
{
throw new ArgumentNullException(nameof(btypeRepository));
}
if (entityRelationDataAccess == null)
{
throw new ArgumentNullException(nameof(entityRelationDataAccess));
}
if (idComparer == null)
{
throw new ArgumentNullException(nameof(idComparer));
}
_outlookRepository = outlookRepository;
_btypeRepository = btypeRepository;
_entityRelationDataAccess = entityRelationDataAccess;
_hashesById = new Dictionary <AppointmentId, int>(idComparer);
}
public EventSynchronizationContextFactory(
OutlookEventRepository outlookRepository,
IEntityRepository <WebResourceName, string, IICalendar, IEventSynchronizationContext> btypeRepository,
IEntityRelationDataAccess <AppointmentId, DateTime, WebResourceName, string> entityRelationDataAccess,
bool cleanupDuplicateEvents,
IEqualityComparer <AppointmentId> idComparer)
{
if (outlookRepository == null)
{
throw new ArgumentNullException(nameof(outlookRepository));
}
if (btypeRepository == null)
{
throw new ArgumentNullException(nameof(btypeRepository));
}
if (entityRelationDataAccess == null)
{
throw new ArgumentNullException(nameof(entityRelationDataAccess));
}
if (idComparer == null)
{
throw new ArgumentNullException(nameof(idComparer));
}
_outlookRepository = outlookRepository;
_btypeRepository = btypeRepository;
_entityRelationDataAccess = entityRelationDataAccess;
_cleanupDuplicateEvents = cleanupDuplicateEvents;
_idComparer = idComparer;
}
public Synchronizer(
IReadOnlyEntityRepository <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TContext> atypeRepository,
IReadOnlyEntityRepository <TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> btypeRepository,
IBatchWriteOnlyEntityRepository <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TContext> atypeWriteRepository,
IBatchWriteOnlyEntityRepository <TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> btypeWriteRepository,
IInitialSyncStateCreationStrategy <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> initialSyncStateCreationStrategy,
IEntityRelationDataAccess <TAtypeEntityId, TAtypeEntityVersion, TBtypeEntityId, TBtypeEntityVersion> entityRelationDataAccess,
IEntityRelationDataFactory <TAtypeEntityId, TAtypeEntityVersion, TBtypeEntityId, TBtypeEntityVersion> entityRelationDataFactory,
IInitialEntityMatcher <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity> initialEntityMatcher,
IEqualityComparer <TAtypeEntityId> atypeIdComparer, IEqualityComparer <TBtypeEntityId> btypeIdComparer,
ITotalProgressFactory totalProgressFactory,
IEqualityComparer <TAtypeEntityVersion> atypeVersionComparer,
IEqualityComparer <TBtypeEntityVersion> btypeVersionComparer, IEntitySyncStateFactory <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> syncStateFactory,
ISynchronizationInterceptorFactory <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> synchronizationInterceptorFactory = null)
{
_initialSyncStateCreationStrategy = initialSyncStateCreationStrategy;
_totalProgressFactory = totalProgressFactory;
_atypeIdComparer = atypeIdComparer;
_btypeIdComparer = btypeIdComparer;
_atypeVersionComparer = atypeVersionComparer;
_btypeVersionComparer = btypeVersionComparer;
_syncStateFactory = syncStateFactory;
_synchronizationInterceptorFactory = synchronizationInterceptorFactory ?? NullSynchronizationInterceptorFactory <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> .Instance;
_atypeWriteRepository = atypeWriteRepository;
_btypeWriteRepository = btypeWriteRepository;
_atypeRepository = atypeRepository;
_btypeRepository = btypeRepository;
_entityRelationDataAccess = entityRelationDataAccess;
_entityRelationDataFactory = entityRelationDataFactory;
_initialEntityMatcher = initialEntityMatcher;
}
public Synchronizer(
IReadOnlyEntityRepository <TAtypeEntity, TAtypeEntityId, TAtypeEntityVersion, TContext> atypeRepository,
IReadOnlyEntityRepository <TBtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TContext> btypeRepository,
IBatchWriteOnlyEntityRepository <TAtypeEntity, TAtypeEntityId, TAtypeEntityVersion, TContext> atypeWriteRepository,
IBatchWriteOnlyEntityRepository <TBtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TContext> btypeWriteRepository,
IInitialSyncStateCreationStrategy <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity> initialSyncStateCreationStrategy,
IEntityRelationDataAccess <TAtypeEntityId, TAtypeEntityVersion, TBtypeEntityId, TBtypeEntityVersion> entityRelationDataAccess,
IEntityRelationDataFactory <TAtypeEntityId, TAtypeEntityVersion, TBtypeEntityId, TBtypeEntityVersion> entityRelationDataFactory,
IInitialEntityMatcher <TAtypeEntity, TAtypeEntityId, TAtypeEntityVersion, TBtypeEntity, TBtypeEntityId, TBtypeEntityVersion> initialEntityMatcher,
IEqualityComparer <TAtypeEntityId> atypeIdComparer, IEqualityComparer <TBtypeEntityId> btypeIdComparer,
ITotalProgressFactory totalProgressFactory,
IExceptionLogger exceptionLogger,
ISynchronizationContextFactory <TContext> contextFactory,
IEqualityComparer <TAtypeEntityVersion> atypeVersionComparer,
IEqualityComparer <TBtypeEntityVersion> btypeVersionComparer)
{
_initialSyncStateCreationStrategy = initialSyncStateCreationStrategy;
_totalProgressFactory = totalProgressFactory;
_atypeIdComparer = atypeIdComparer;
_btypeIdComparer = btypeIdComparer;
_exceptionLogger = exceptionLogger;
_contextFactory = contextFactory;
_atypeVersionComparer = atypeVersionComparer;
_btypeVersionComparer = btypeVersionComparer;
_atypeWriteRepository = atypeWriteRepository;
_btypeWriteRepository = btypeWriteRepository;
_atypeRepository = atypeRepository;
_btypeRepository = btypeRepository;
_entityRelationDataAccess = entityRelationDataAccess;
_entityRelationDataFactory = entityRelationDataFactory;
_initialEntityMatcher = initialEntityMatcher;
}
public static IOutlookSynchronizer CreateEventSynchronizer(
SynchronizationMode mode,
ICalDavDataAccess calDavDataAccess,
IEntityRelationDataAccess <string, DateTime, WebResourceName, string> entityRelationDataAccess = null,
Action <Options> optionsModifier = null)
{
var options = new Options()
{
ConflictResolution = ConflictResolution.Automatic,
EmailAddress = "*****@*****.**",
IgnoreSynchronizationTimeRange = true,
OutlookFolderEntryId = s_outlookFolderEntryId,
OutlookFolderStoreId = s_outlookFolderStoreId,
SynchronizationMode = mode,
CalenderUrl = "http://invalidurl.net"
};
if (optionsModifier != null)
{
optionsModifier(options);
}
return(s_synchronizerFactory.CreateEventSynchronizer(
options,
calDavDataAccess,
entityRelationDataAccess ?? MockRepository.GenerateStub <IEntityRelationDataAccess <string, DateTime, WebResourceName, string> >()));
}
public static IOutlookSynchronizer CreateEventSynchronizer (
SynchronizationMode mode,
ICalDavDataAccess calDavDataAccess,
IEntityRelationDataAccess<string, DateTime, Uri, string> entityRelationDataAccess = null,
Action<Options> optionsModifier = null)
{
var options = new Options()
{
ConflictResolution = ConflictResolution.Automatic,
EmailAddress = "*****@*****.**",
IgnoreSynchronizationTimeRange = true,
OutlookFolderEntryId = s_outlookFolderEntryId,
OutlookFolderStoreId = s_outlookFolderStoreId,
SynchronizationMode = mode,
CalenderUrl = "http://invalidurl.net"
};
if (optionsModifier != null)
optionsModifier (options);
return s_synchronizerFactory.CreateEventSynchronizer (
options,
calDavDataAccess,
entityRelationDataAccess ?? MockRepository.GenerateStub<IEntityRelationDataAccess<string, DateTime, Uri, string>>());
}
/// <remarks>
/// Public because it is being used by integration tests
/// </remarks>
public ISynchronizer CreateEventSynchronizer(
Options options,
ICalDavDataAccess calDavDataAccess,
IEntityRelationDataAccess <string, DateTime, Uri, string> entityRelationDataAccess)
{
var dateTimeRangeProvider =
options.IgnoreSynchronizationTimeRange ?
NullDateTimeRangeProvider.Instance :
new DateTimeRangeProvider(options.DaysToSynchronizeInThePast, options.DaysToSynchronizeInTheFuture);
var atypeRepository = new OutlookEventRepository(
_outlookSession,
options.OutlookFolderEntryId,
options.OutlookFolderStoreId,
dateTimeRangeProvider);
IEntityRepository <IICalendar, Uri, string> btypeRepository = new CalDavRepository(
calDavDataAccess,
new iCalendarSerializer(),
CalDavRepository.EntityType.Event,
dateTimeRangeProvider);
var entityMapper = new EventEntityMapper(
_outlookEmailAddress, new Uri("mailto:" + options.EmailAddress),
_outlookSession.Application.TimeZones.CurrentTimeZone.ID,
_outlookSession.Application.Version);
var outlookEventRelationDataFactory = new OutlookEventRelationDataFactory();
var syncStateFactory = new EntitySyncStateFactory <string, DateTime, AppointmentItemWrapper, Uri, string, IICalendar> (
entityMapper,
atypeRepository,
btypeRepository,
outlookEventRelationDataFactory,
ExceptionHandler.Instance
);
var btypeIdEqualityComparer = EqualityComparer <Uri> .Default;
var atypeIdEqualityComparer = EqualityComparer <string> .Default;
return(new Synchronizer <string, DateTime, AppointmentItemWrapper, Uri, string, IICalendar> (
atypeRepository,
btypeRepository,
InitialEventSyncStateCreationStrategyFactory.Create(
syncStateFactory,
syncStateFactory.Environment,
options.SynchronizationMode,
options.ConflictResolution),
entityRelationDataAccess,
outlookEventRelationDataFactory,
new InitialEventEntityMatcher(btypeIdEqualityComparer),
atypeIdEqualityComparer,
btypeIdEqualityComparer,
_totalProgressFactory,
ExceptionHandler.Instance));
}
public DuplicateEventCleaner (
OutlookEventRepository outlookRepository,
IEntityRepository<WebResourceName, string, IICalendar, IEventSynchronizationContext> btypeRepository,
IEntityRelationDataAccess<AppointmentId, DateTime, WebResourceName, string> entityRelationDataAccess,
IEqualityComparer<AppointmentId> idComparer)
{
if (outlookRepository == null)
throw new ArgumentNullException (nameof (outlookRepository));
if (btypeRepository == null)
throw new ArgumentNullException (nameof (btypeRepository));
if (entityRelationDataAccess == null)
throw new ArgumentNullException (nameof (entityRelationDataAccess));
if (idComparer == null) throw new ArgumentNullException(nameof(idComparer));
_outlookRepository = outlookRepository;
_btypeRepository = btypeRepository;
_entityRelationDataAccess = entityRelationDataAccess;
_hashesById = new Dictionary<AppointmentId, int>(idComparer);
}
public ContactAndDistListSynchronizer(
IPartialSynchronizer <string, DateTime, WebResourceName, string, ICardDavRepositoryLogger> contactSynchronizer,
ISynchronizer <DistributionListSychronizationContext> distributionListSynchronizer,
EmailAddressCacheDataAccess emailAddressCacheDataAccess,
LoggingCardDavRepositoryDecorator cardDavDataAccess,
IEntityRelationDataAccess <string, DateTime, WebResourceName, string> contactEntityRelationDataAccess,
IReadOnlyEntityRepository <string, DateTime, ContactItemWrapper, ICardDavRepositoryLogger> outlookContactRepository,
NameSpace outlookSession)
{
if (contactSynchronizer == null)
{
throw new ArgumentNullException(nameof(contactSynchronizer));
}
if (distributionListSynchronizer == null)
{
throw new ArgumentNullException(nameof(distributionListSynchronizer));
}
if (cardDavDataAccess == null)
{
throw new ArgumentNullException(nameof(cardDavDataAccess));
}
if (contactEntityRelationDataAccess == null)
{
throw new ArgumentNullException(nameof(contactEntityRelationDataAccess));
}
if (outlookContactRepository == null)
{
throw new ArgumentNullException(nameof(outlookContactRepository));
}
if (outlookSession == null)
{
throw new ArgumentNullException(nameof(outlookSession));
}
_contactSynchronizer = contactSynchronizer;
_distributionListSynchronizer = distributionListSynchronizer;
_emailAddressCacheDataAccess = emailAddressCacheDataAccess;
_cardDavDataAccess = cardDavDataAccess;
_contactEntityRelationDataAccess = contactEntityRelationDataAccess;
_outlookContactRepository = outlookContactRepository;
_outlookSession = outlookSession;
}
public void Setup()
{
_entityRelationData = new List <EntityRelationData>();
_localRepository = new TestRepository("l");
_serverRepository = new TestRepository("s");
_entityRelationDataFactory = new EntityRelationDataFactory();
_factory = new EntitySyncStateFactory <Identifier, int, string, Identifier, int, string, int> (
new Mapper(),
_entityRelationDataFactory,
MockRepository.GenerateMock <IExceptionLogger>()
);
_entityRelationDataAccess = MockRepository.GenerateStub <IEntityRelationDataAccess <Identifier, int, Identifier, int> >();
_entityRelationDataAccess.Stub(d => d.LoadEntityRelationData()).WhenCalled(a => a.ReturnValue = _entityRelationData.ToArray());
_entityRelationDataAccess
.Stub(d => d.SaveEntityRelationData(null))
.IgnoreArguments()
.WhenCalled(a => { _entityRelationData = ((List <IEntityRelationData <Identifier, int, Identifier, int> >)a.Arguments[0]).Cast <EntityRelationData>().ToList(); });
}
public void Setup ()
{
_entityRelationData = new List<EntityRelationData>();
_localRepository = new TestRepository ("l");
_serverRepository = new TestRepository ("s");
_entityRelationDataFactory = new EntityRelationDataFactory();
_factory = new EntitySyncStateFactory<Identifier, int, string, Identifier, int, string> (
new Mapper(),
_entityRelationDataFactory,
MockRepository.GenerateMock<IExceptionLogger>()
);
_entityRelationDataAccess = MockRepository.GenerateStub<IEntityRelationDataAccess<Identifier, int, Identifier, int>>();
_entityRelationDataAccess.Stub (d => d.LoadEntityRelationData()).WhenCalled (a => a.ReturnValue = _entityRelationData.ToArray());
_entityRelationDataAccess
.Stub (d => d.SaveEntityRelationData (null))
.IgnoreArguments()
.WhenCalled (a => { _entityRelationData = ((List<IEntityRelationData<Identifier, int, Identifier, int>>) a.Arguments[0]).Cast<EntityRelationData>().ToList(); });
}
public EventSynchronizationContext(NameSpace outlookSession, IEntityRelationDataAccess <string, DateTime, Uri, string> storageDataAccess, Options options, string outlookEmailAddress, TimeSpan connectTimeout, TimeSpan readWriteTimeout, bool disableCertValidation, bool useSsl3, bool useTls12, IEqualityComparer <Uri> btypeIdEqualityComparer)
{
if (outlookSession == null)
{
throw new ArgumentNullException("outlookSession");
}
SynchronizationMode = options.SynchronizationMode;
From = DateTime.Now.AddDays(-options.DaysToSynchronizeInThePast);
To = DateTime.Now.AddDays(options.DaysToSynchronizeInTheFuture);
_entityRelationDataFactory = new OutlookEventRelationDataFactory();
_entityMapper = new EventEntityMapper(outlookEmailAddress, new Uri("mailto:" + options.EmailAddress), outlookSession.Application.TimeZones.CurrentTimeZone.ID, outlookSession.Application.Version);
_atypeRepository = new OutlookEventRepository(outlookSession, options.OutlookFolderEntryId, options.OutlookFolderStoreId);
_btypeRepository = new CalDavRepository(
new CalDavDataAccess(
new Uri(options.CalenderUrl),
new CalDavWebClient(
options.UserName,
options.Password,
connectTimeout,
readWriteTimeout,
disableCertValidation,
useSsl3,
useTls12)
),
new iCalendarSerializer(),
CalDavRepository.EntityType.Event);
if (StringComparer.InvariantCultureIgnoreCase.Compare(new Uri(options.CalenderUrl).Host, "www.google.com") == 0)
{
_btypeRepository = new EntityRepositoryDeleteCreateInstaedOfUpdateWrapper <IICalendar, Uri, string> (_btypeRepository);
}
_storageDataAccess = storageDataAccess;
InitialEntityMatcher = new InitialEventEntityMatcher(btypeIdEqualityComparer);
}
public DuplicateEventCleaner(
OutlookEventRepository outlookRepository,
IEntityRepository <IICalendar, WebResourceName, string, IEventSynchronizationContext> btypeRepository,
IEntityRelationDataAccess <string, DateTime, WebResourceName, string> entityRelationDataAccess)
{
if (outlookRepository == null)
{
throw new ArgumentNullException(nameof(outlookRepository));
}
if (btypeRepository == null)
{
throw new ArgumentNullException(nameof(btypeRepository));
}
if (entityRelationDataAccess == null)
{
throw new ArgumentNullException(nameof(entityRelationDataAccess));
}
_outlookRepository = outlookRepository;
_btypeRepository = btypeRepository;
_entityRelationDataAccess = entityRelationDataAccess;
}
public TaskSynchronizationContext(NameSpace outlookSession, IEntityRelationDataAccess <string, DateTime, Uri, string> storageDataAccess, Options options, TimeSpan connectTimeout, TimeSpan readWriteTimeout, bool disableCertValidation, bool useSsl3, bool useTls12, IEqualityComparer <Uri> btypeIdEqualityComparer)
{
if (outlookSession == null)
{
throw new ArgumentNullException("outlookSession");
}
SynchronizationMode = options.SynchronizationMode;
From = DateTime.Now.AddDays(-options.DaysToSynchronizeInThePast);
To = DateTime.Now.AddDays(options.DaysToSynchronizeInTheFuture);
_entityRelationDataFactory = new OutlookEventRelationDataFactory();
_entityMapper = new TaskMapper(outlookSession.Application.TimeZones.CurrentTimeZone.ID);
var calendarFolder = (Folder)outlookSession.GetFolderFromID(options.OutlookFolderEntryId, options.OutlookFolderStoreId);
_atypeRepository = new OutlookTaskRepository(calendarFolder, outlookSession);
_btypeRepository = new CalDavRepository(
new CalDavDataAccess(
new Uri(options.CalenderUrl),
new CalDavWebClient(
options.UserName,
options.Password,
connectTimeout,
readWriteTimeout,
disableCertValidation,
useSsl3,
useTls12)
),
new iCalendarSerializer(),
CalDavRepository.EntityType.Todo);
_storageDataAccess = storageDataAccess;
InitialEntityMatcher = new InitialTaskEntityMatcher(btypeIdEqualityComparer);
}
public static void SyncCalDavToOutlook(string eventData, IEntityRelationDataAccess <string, DateTime, WebResourceName, string> entityRelationDataAccess)
{
var calDavDataAccess = MockRepository.GenerateMock <ICalDavDataAccess>();
var entityUri = new WebResourceName("/e1");
calDavDataAccess
.Expect(r => r.GetEventVersions(null))
.IgnoreArguments()
.Return(Task.FromResult <IReadOnlyList <EntityVersion <WebResourceName, string> > > (
new[] { EntityVersion.Create(entityUri, "v1") }));
calDavDataAccess
.Expect(r => r.GetEntities(Arg <ICollection <WebResourceName> > .List.Equal(new[] { entityUri })))
.Return(Task.FromResult <IReadOnlyList <EntityWithId <WebResourceName, string> > > (
new[] { EntityWithId.Create(entityUri, eventData) }));
var synchronizer = OutlookTestContext.CreateEventSynchronizer(
SynchronizationMode.ReplicateServerIntoOutlook,
calDavDataAccess,
entityRelationDataAccess);
WaitForTask(synchronizer.SynchronizeNoThrow(NullSynchronizationLogger.Instance));
}
/// <remarks>
/// Public because it is being used by integration tests
/// </remarks>
public IOutlookSynchronizer CreateEventSynchronizer(
Options options,
ICalDavDataAccess calDavDataAccess,
IEntityRelationDataAccess <string, DateTime, WebResourceName, string> entityRelationDataAccess)
{
var dateTimeRangeProvider =
options.IgnoreSynchronizationTimeRange ?
NullDateTimeRangeProvider.Instance :
new DateTimeRangeProvider(options.DaysToSynchronizeInThePast, options.DaysToSynchronizeInTheFuture);
var mappingParameters = GetMappingParameters <EventMappingConfiguration> (options);
var atypeRepository = new OutlookEventRepository(
_outlookSession,
options.OutlookFolderEntryId,
options.OutlookFolderStoreId,
dateTimeRangeProvider,
mappingParameters,
_daslFilterProvider);
IEntityRepository <IICalendar, WebResourceName, string, int> btypeRepository = new CalDavRepository(
calDavDataAccess,
new iCalendarSerializer(),
CalDavRepository.EntityType.Event,
dateTimeRangeProvider,
options.ServerAdapterType == ServerAdapterType.WebDavHttpClientBasedWithGoogleOAuth);
var entityMapper = new EventEntityMapper(
_outlookEmailAddress, new Uri("mailto:" + options.EmailAddress),
_outlookSession.Application.TimeZones.CurrentTimeZone.ID,
_outlookSession.Application.Version,
mappingParameters);
var outlookEventRelationDataFactory = new OutlookEventRelationDataFactory();
var syncStateFactory = new EntitySyncStateFactory <string, DateTime, AppointmentItemWrapper, WebResourceName, string, IICalendar> (
entityMapper,
outlookEventRelationDataFactory,
ExceptionHandler.Instance
);
var btypeIdEqualityComparer = WebResourceName.Comparer;
var atypeIdEqualityComparer = EqualityComparer <string> .Default;
var aTypeWriteRepository = BatchEntityRepositoryAdapter.Create(atypeRepository);
var bTypeWriteRepository = BatchEntityRepositoryAdapter.Create(btypeRepository);
var synchronizer = new Synchronizer <string, DateTime, AppointmentItemWrapper, WebResourceName, string, IICalendar, int> (
atypeRepository,
btypeRepository,
aTypeWriteRepository,
bTypeWriteRepository,
InitialSyncStateCreationStrategyFactory <string, DateTime, AppointmentItemWrapper, WebResourceName, string, IICalendar> .Create(
syncStateFactory,
syncStateFactory.Environment,
options.SynchronizationMode,
options.ConflictResolution,
e => new EventConflictInitialSyncStateCreationStrategyAutomatic(e)),
entityRelationDataAccess,
outlookEventRelationDataFactory,
new InitialEventEntityMatcher(btypeIdEqualityComparer),
atypeIdEqualityComparer,
btypeIdEqualityComparer,
_totalProgressFactory,
ExceptionHandler.Instance,
NullSynchronizationContextFactory.Instance,
EqualityComparer <DateTime> .Default,
EqualityComparer <string> .Default);
return(new OutlookSynchronizer <WebResourceName, string> (synchronizer));
}
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.GetEventVersions (null))
.IgnoreArguments()
.Return (Task.FromResult<IReadOnlyList<EntityVersion<Uri, string>>> (
new[] { EntityVersion.Create (entityUri, "v1") }));
calDavDataAccess
.Expect (r => r.GetEntities (Arg<ICollection<Uri>>.List.Equal (new[] { entityUri })))
.Return (Task.FromResult<IReadOnlyList<EntityWithId<Uri, string>>> (
new[] { EntityWithId.Create (entityUri, existingEventData) }));
calDavDataAccess
.Expect (r => r.UpdateEntity (
new Uri ("http://bla.com"),
null,
null))
.IgnoreArguments()
.Return (Task.FromResult<EntityVersion<Uri, string>> (
EntityVersion.Create (new Uri ("http://bla.com"), "blubb")))
.WhenCalled (a => { roundTrippedData = (string) a.Arguments[2]; });
var synchronizer = OutlookTestContext.CreateEventSynchronizer (
SynchronizationMode.ReplicateOutlookIntoServer,
calDavDataAccess,
entityRelationDataAccess);
WaitForTask (synchronizer.Synchronize());
return roundTrippedData;
}
public static List<string> SyncOutlookToCalDav_CalDavIsEmpty (
IEntityRelationDataAccess<string, DateTime, Uri, string> entityRelationDataAccess = null,
Action<Options> optionsModifier = null)
{
var calDavEvents = new List<string>();
ICalDavDataAccess calDavDataAccess = MockRepository.GenerateMock<ICalDavDataAccess>();
calDavDataAccess
.Expect (r => r.GetEventVersions (null))
.IgnoreArguments()
.Return (Task.FromResult<IReadOnlyList<EntityVersion<Uri, string>>> (
new EntityVersion<Uri, string>[] { }));
calDavDataAccess
.Expect (r => r.CreateEntity (null, Guid.NewGuid().ToString()))
.IgnoreArguments()
.Return (Task.FromResult (
EntityVersion.Create (new Uri ("http://bla.com"), "blubb")))
.WhenCalled (a => calDavEvents.Add ((string) a.Arguments[0]));
var synchronizer = CreateEventSynchronizer (
SynchronizationMode.ReplicateOutlookIntoServer,
calDavDataAccess,
entityRelationDataAccess,
optionsModifier);
WaitForTask (synchronizer.Synchronize());
return calDavEvents;
}
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.GetEventVersions (null))
.IgnoreArguments()
.Return (Task.FromResult<IReadOnlyList<EntityVersion<Uri, string>>> (
new[] { EntityVersion.Create (entityUri, "v1") }));
calDavDataAccess
.Expect (r => r.GetEntities (Arg<ICollection<Uri>>.List.Equal (new[] { entityUri })))
.Return (Task.FromResult<IReadOnlyList<EntityWithId<Uri, string>>> (
new[] { EntityWithId.Create (entityUri, eventData) }));
var synchronizer = OutlookTestContext.CreateEventSynchronizer (
SynchronizationMode.ReplicateServerIntoOutlook,
calDavDataAccess,
entityRelationDataAccess);
WaitForTask (synchronizer.Synchronize());
}
/// <remarks>
/// Public because it is being used by integration tests
/// </remarks>
public async Task <IOutlookSynchronizer> CreateEventSynchronizer(
Options options,
ICalDavDataAccess calDavDataAccess,
IEntityRelationDataAccess <AppointmentId, DateTime, WebResourceName, string> entityRelationDataAccess)
{
var dateTimeRangeProvider =
options.IgnoreSynchronizationTimeRange ?
NullDateTimeRangeProvider.Instance :
new DateTimeRangeProvider(options.DaysToSynchronizeInThePast, options.DaysToSynchronizeInTheFuture);
var mappingParameters = GetMappingParameters <EventMappingConfiguration> (options);
var atypeRepository = new OutlookEventRepository(
_outlookSession,
options.OutlookFolderEntryId,
options.OutlookFolderStoreId,
dateTimeRangeProvider,
mappingParameters,
_daslFilterProvider);
IEntityRepository <WebResourceName, string, IICalendar, IEventSynchronizationContext> btypeRepository = new CalDavRepository <IEventSynchronizationContext> (
calDavDataAccess,
new iCalendarSerializer(),
CalDavRepository.EntityType.Event,
dateTimeRangeProvider,
options.ServerAdapterType == ServerAdapterType.WebDavHttpClientBasedWithGoogleOAuth,
options.IsChunkedSynchronizationEnabled ? new ChunkedExecutor(options.ChunkSize) : NullChunkedExecutor.Instance);
var timeZoneCache = new TimeZoneCache(CreateHttpClient(options.ProxyOptions), mappingParameters.IncludeHistoricalData, _globalTimeZoneCache);
ITimeZone configuredEventTimeZoneOrNull;
if (mappingParameters.UseIanaTz)
{
configuredEventTimeZoneOrNull = await timeZoneCache.GetByTzIdOrNull(mappingParameters.EventTz);
}
else
{
configuredEventTimeZoneOrNull = null;
}
var entityMapper = new EventEntityMapper(
_outlookEmailAddress, new Uri("mailto:" + options.EmailAddress),
_outlookSession.Application.TimeZones.CurrentTimeZone.ID,
_outlookSession.Application.Version,
timeZoneCache,
mappingParameters,
configuredEventTimeZoneOrNull);
var outlookEventRelationDataFactory = new OutlookEventRelationDataFactory();
var syncStateFactory = new EntitySyncStateFactory <AppointmentId, DateTime, AppointmentItemWrapper, WebResourceName, string, IICalendar> (
entityMapper,
outlookEventRelationDataFactory,
ExceptionHandler.Instance
);
var btypeIdEqualityComparer = WebResourceName.Comparer;
var atypeIdEqualityComparer = AppointmentId.Comparer;
var aTypeWriteRepository = BatchEntityRepositoryAdapter.Create(atypeRepository);
var bTypeWriteRepository = BatchEntityRepositoryAdapter.Create(btypeRepository);
var synchronizer = new Synchronizer <AppointmentId, DateTime, AppointmentItemWrapper, WebResourceName, string, IICalendar, IEventSynchronizationContext> (
atypeRepository,
btypeRepository,
aTypeWriteRepository,
bTypeWriteRepository,
InitialSyncStateCreationStrategyFactory <AppointmentId, DateTime, AppointmentItemWrapper, WebResourceName, string, IICalendar> .Create(
syncStateFactory,
syncStateFactory.Environment,
options.SynchronizationMode,
options.ConflictResolution,
e => new EventConflictInitialSyncStateCreationStrategyAutomatic(e)),
entityRelationDataAccess,
outlookEventRelationDataFactory,
new InitialEventEntityMatcher(btypeIdEqualityComparer),
atypeIdEqualityComparer,
btypeIdEqualityComparer,
_totalProgressFactory,
ExceptionHandler.Instance,
new EventSynchronizationContextFactory(atypeRepository, btypeRepository, entityRelationDataAccess, mappingParameters.CleanupDuplicateEvents, atypeIdEqualityComparer),
EqualityComparer <DateTime> .Default,
EqualityComparer <string> .Default,
syncStateFactory,
new EventSynchronizationInterceptorFactory());
return(new OutlookEventSynchronizer <WebResourceName, string> (synchronizer));
}
public Synchronizer(
IReadOnlyEntityRepository <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TContext> atypeRepository,
IReadOnlyEntityRepository <TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> btypeRepository,
IBatchWriteOnlyEntityRepository <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TContext> atypeWriteRepository,
IBatchWriteOnlyEntityRepository <TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> btypeWriteRepository,
IInitialSyncStateCreationStrategy <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> initialSyncStateCreationStrategy,
IEntityRelationDataAccess <TAtypeEntityId, TAtypeEntityVersion, TBtypeEntityId, TBtypeEntityVersion> entityRelationDataAccess,
IEntityRelationDataFactory <TAtypeEntityId, TAtypeEntityVersion, TBtypeEntityId, TBtypeEntityVersion> entityRelationDataFactory,
IInitialEntityMatcher <TAtypeEntityId, TAtypeEntityVersion, TAMatchData, TBtypeEntityId, TBtypeEntityVersion, TBMatchData> initialEntityMatcher,
IEqualityComparer <TAtypeEntityId> atypeIdComparer, IEqualityComparer <TBtypeEntityId> btypeIdComparer,
ITotalProgressFactory totalProgressFactory,
IEqualityComparer <TAtypeEntityVersion> atypeVersionComparer,
IEqualityComparer <TBtypeEntityVersion> btypeVersionComparer, IEntitySyncStateFactory <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> syncStateFactory,
IExceptionHandlingStrategy exceptionHandlingStrategy,
IMatchDataFactory <TAtypeEntity, TAMatchData> aMatchDataFactory,
IMatchDataFactory <TBtypeEntity, TBMatchData> bMatchDataFactory,
int?chunkSize,
IChunkedExecutor chunkedExecutor,
IFullEntitySynchronizationLoggerFactory <TAtypeEntity, TBtypeEntity> fullEntitySynchronizationLoggerFactory,
IStateAwareEntityRepository <TAtypeEntityId, TAtypeEntityVersion, TContext, TAtypeStateToken> atypeStateAwareEntityRepository,
IStateAwareEntityRepository <TBtypeEntityId, TBtypeEntityVersion, TContext, TBtypeStateToken> btypeStateAwareEntityRepository,
IStateTokenDataAccess <TAtypeStateToken, TBtypeStateToken> stateTokenDataAccess,
ISynchronizationInterceptorFactory <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> synchronizationInterceptorFactoryOrNull = null)
{
if (atypeRepository == null)
{
throw new ArgumentNullException(nameof(atypeRepository));
}
if (btypeRepository == null)
{
throw new ArgumentNullException(nameof(btypeRepository));
}
if (atypeWriteRepository == null)
{
throw new ArgumentNullException(nameof(atypeWriteRepository));
}
if (btypeWriteRepository == null)
{
throw new ArgumentNullException(nameof(btypeWriteRepository));
}
if (initialSyncStateCreationStrategy == null)
{
throw new ArgumentNullException(nameof(initialSyncStateCreationStrategy));
}
if (entityRelationDataAccess == null)
{
throw new ArgumentNullException(nameof(entityRelationDataAccess));
}
if (entityRelationDataFactory == null)
{
throw new ArgumentNullException(nameof(entityRelationDataFactory));
}
if (initialEntityMatcher == null)
{
throw new ArgumentNullException(nameof(initialEntityMatcher));
}
if (atypeIdComparer == null)
{
throw new ArgumentNullException(nameof(atypeIdComparer));
}
if (btypeIdComparer == null)
{
throw new ArgumentNullException(nameof(btypeIdComparer));
}
if (totalProgressFactory == null)
{
throw new ArgumentNullException(nameof(totalProgressFactory));
}
if (atypeVersionComparer == null)
{
throw new ArgumentNullException(nameof(atypeVersionComparer));
}
if (btypeVersionComparer == null)
{
throw new ArgumentNullException(nameof(btypeVersionComparer));
}
if (syncStateFactory == null)
{
throw new ArgumentNullException(nameof(syncStateFactory));
}
if (exceptionHandlingStrategy == null)
{
throw new ArgumentNullException(nameof(exceptionHandlingStrategy));
}
if (aMatchDataFactory == null)
{
throw new ArgumentNullException(nameof(aMatchDataFactory));
}
if (bMatchDataFactory == null)
{
throw new ArgumentNullException(nameof(bMatchDataFactory));
}
if (fullEntitySynchronizationLoggerFactory == null)
{
throw new ArgumentNullException(nameof(fullEntitySynchronizationLoggerFactory));
}
if (atypeStateAwareEntityRepository == null)
{
throw new ArgumentNullException(nameof(atypeStateAwareEntityRepository));
}
if (btypeStateAwareEntityRepository == null)
{
throw new ArgumentNullException(nameof(btypeStateAwareEntityRepository));
}
if (stateTokenDataAccess == null)
{
throw new ArgumentNullException(nameof(stateTokenDataAccess));
}
_chunkSize = chunkSize;
_chunkedExecutor = chunkedExecutor;
_fullEntitySynchronizationLoggerFactory = fullEntitySynchronizationLoggerFactory;
_atypeStateAwareEntityRepository = atypeStateAwareEntityRepository;
_btypeStateAwareEntityRepository = btypeStateAwareEntityRepository;
_stateTokenDataAccess = stateTokenDataAccess;
_initialSyncStateCreationStrategy = initialSyncStateCreationStrategy;
_totalProgressFactory = totalProgressFactory;
_atypeIdComparer = atypeIdComparer;
_btypeIdComparer = btypeIdComparer;
_atypeVersionComparer = atypeVersionComparer;
_btypeVersionComparer = btypeVersionComparer;
_syncStateFactory = syncStateFactory;
_exceptionHandlingStrategy = exceptionHandlingStrategy;
_aMatchDataFactory = aMatchDataFactory;
_bMatchDataFactory = bMatchDataFactory;
_synchronizationInterceptorFactory = synchronizationInterceptorFactoryOrNull ?? NullSynchronizationInterceptorFactory <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext> .Instance;
_atypeWriteRepository = atypeWriteRepository;
_btypeWriteRepository = btypeWriteRepository;
_atypeRepository = atypeRepository;
_btypeRepository = btypeRepository;
_entityRelationDataAccess = entityRelationDataAccess;
_entityRelationDataFactory = entityRelationDataFactory;
_initialEntityMatcher = initialEntityMatcher;
_entitySyncStateChunkCreator = new EntitySyncStateChunkCreator <TAtypeEntityId, TAtypeEntityVersion, TAtypeEntity, TBtypeEntityId, TBtypeEntityVersion, TBtypeEntity, TContext>(chunkSize);
}
public static string SyncOutlookToCalDav_EventsExistsInCalDav(string existingEventData, IEntityRelationDataAccess <string, DateTime, WebResourceName, string> entityRelationDataAccess = null)
{
string roundTrippedData = null;
ICalDavDataAccess calDavDataAccess = MockRepository.GenerateMock <ICalDavDataAccess>();
var entityUri = new WebResourceName("/e1");
calDavDataAccess
.Expect(r => r.GetEventVersions(null))
.IgnoreArguments()
.Return(Task.FromResult <IReadOnlyList <EntityVersion <WebResourceName, string> > > (
new[] { EntityVersion.Create(entityUri, "v1") }));
calDavDataAccess
.Expect(r => r.GetEntities(Arg <ICollection <WebResourceName> > .List.Equal(new[] { entityUri })))
.Return(Task.FromResult <IReadOnlyList <EntityWithId <WebResourceName, string> > > (
new[] { EntityWithId.Create(entityUri, existingEventData) }));
calDavDataAccess
.Expect(r => r.TryUpdateEntity(
new WebResourceName("http://bla.com"),
null,
null))
.IgnoreArguments()
.Return(Task.FromResult <EntityVersion <WebResourceName, string> > (
EntityVersion.Create(new WebResourceName("http://bla.com"), "blubb")))
.WhenCalled(a => { roundTrippedData = (string)a.Arguments[2]; });
var synchronizer = OutlookTestContext.CreateEventSynchronizer(
SynchronizationMode.ReplicateOutlookIntoServer,
calDavDataAccess,
entityRelationDataAccess);
WaitForTask(synchronizer.SynchronizeNoThrow(NullSynchronizationLogger.Instance));
return(roundTrippedData);
}
/// <remarks>
/// Public because it is being used by integration tests
/// </remarks>
public OutlookSynchronizer CreateEventSynchronizer (
Options options,
ICalDavDataAccess calDavDataAccess,
IEntityRelationDataAccess<string, DateTime, Uri, string> entityRelationDataAccess)
{
var dateTimeRangeProvider =
options.IgnoreSynchronizationTimeRange ?
NullDateTimeRangeProvider.Instance :
new DateTimeRangeProvider (options.DaysToSynchronizeInThePast, options.DaysToSynchronizeInTheFuture);
var atypeRepository = new OutlookEventRepository (
_outlookSession,
options.OutlookFolderEntryId,
options.OutlookFolderStoreId,
dateTimeRangeProvider);
IEntityRepository<IICalendar, Uri, string> btypeRepository = new CalDavRepository (
calDavDataAccess,
new iCalendarSerializer(),
CalDavRepository.EntityType.Event,
dateTimeRangeProvider);
var entityMapper = new EventEntityMapper (
_outlookEmailAddress, new Uri ("mailto:" + options.EmailAddress),
_outlookSession.Application.TimeZones.CurrentTimeZone.ID,
_outlookSession.Application.Version);
var outlookEventRelationDataFactory = new OutlookEventRelationDataFactory();
var syncStateFactory = new EntitySyncStateFactory<string, DateTime, AppointmentItemWrapper, Uri, string, IICalendar> (
entityMapper,
atypeRepository,
btypeRepository,
outlookEventRelationDataFactory,
ExceptionHandler.Instance
);
var btypeIdEqualityComparer = EqualityComparer<Uri>.Default;
var atypeIdEqualityComparer = EqualityComparer<string>.Default;
var synchronizer = new Synchronizer<string, DateTime, AppointmentItemWrapper, Uri, string, IICalendar> (
atypeRepository,
btypeRepository,
InitialEventSyncStateCreationStrategyFactory.Create (
syncStateFactory,
syncStateFactory.Environment,
options.SynchronizationMode,
options.ConflictResolution),
entityRelationDataAccess,
outlookEventRelationDataFactory,
new InitialEventEntityMatcher (btypeIdEqualityComparer),
atypeIdEqualityComparer,
btypeIdEqualityComparer,
_totalProgressFactory,
ExceptionHandler.Instance);
return new OutlookSynchronizer (synchronizer, atypeRepository);
}
