public static void Initialize(NameSpace mapiNameSpace)
{
s_mapiNameSpace = mapiNameSpace;
const string testerServerEmailAddress = "*****@*****.**";
if (mapiNameSpace == null)
{
throw new ArgumentNullException("mapiNameSpace");
}
_entityMapper = new EventEntityMapper(mapiNameSpace.CurrentUser.Address, new Uri("mailto:" + testerServerEmailAddress), mapiNameSpace.Application.TimeZones.CurrentTimeZone.ID, mapiNameSpace.Application.Version);
s_outlookFolderEntryId = ConfigurationManager.AppSettings[string.Format("{0}.OutlookFolderEntryId", Environment.MachineName)];
s_outlookFolderStoreId = ConfigurationManager.AppSettings[string.Format("{0}.OutlookFolderStoreId", Environment.MachineName)];
_outlookRepository = new OutlookEventRepository(mapiNameSpace, s_outlookFolderEntryId, s_outlookFolderStoreId, NullDateTimeRangeProvider.Instance);
s_synchronizerFactory = new SynchronizerFactory(
@"a:\invalid path",
NullTotalProgressFactory.Instance,
s_mapiNameSpace,
TimeSpan.Zero,
TimeSpan.Zero);
s_outlookEventRepository = new OutlookEventRepository(
s_mapiNameSpace,
s_outlookFolderEntryId,
s_outlookFolderStoreId,
NullDateTimeRangeProvider.Instance);
}
public static AppointmentItemWrapper CreateNewAppointment()
{
using (var folderWrapper = GenericComObjectWrapper.Create((Folder)s_mapiNameSpace.GetFolderFromID(s_outlookFolderEntryId, s_outlookFolderStoreId)))
{
return(OutlookEventRepository.CreateNewAppointmentForTesting(folderWrapper.Inner, s_mapiNameSpace));
}
}
public static void Initialize (NameSpace mapiNameSpace)
{
s_mapiNameSpace = mapiNameSpace;
const string testerServerEmailAddress = "*****@*****.**";
if (mapiNameSpace == null)
throw new ArgumentNullException ("mapiNameSpace");
_entityMapper = new EventEntityMapper (
mapiNameSpace.CurrentUser.Address,
new Uri ("mailto:" + testerServerEmailAddress),
mapiNameSpace.Application.TimeZones.CurrentTimeZone.ID,
mapiNameSpace.Application.Version,
new EventMappingConfiguration());
s_outlookFolderEntryId = ConfigurationManager.AppSettings[string.Format ("{0}.OutlookFolderEntryId", Environment.MachineName)];
s_outlookFolderStoreId = ConfigurationManager.AppSettings[string.Format ("{0}.OutlookFolderStoreId", Environment.MachineName)];
_outlookRepository = new OutlookEventRepository (mapiNameSpace, s_outlookFolderEntryId, s_outlookFolderStoreId, NullDateTimeRangeProvider.Instance);
s_synchronizerFactory = new SynchronizerFactory (
_ => @"a:\invalid path",
NullTotalProgressFactory.Instance,
s_mapiNameSpace,
TimeSpan.Zero,
TimeSpan.Zero);
s_outlookEventRepository = new OutlookEventRepository (
s_mapiNameSpace,
s_outlookFolderEntryId,
s_outlookFolderStoreId,
NullDateTimeRangeProvider.Instance);
}
/// <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 static void Initialize(NameSpace mapiNameSpace)
{
s_mapiNameSpace = mapiNameSpace;
const string testerServerEmailAddress = "*****@*****.**";
if (mapiNameSpace == null)
throw new ArgumentNullException ("mapiNameSpace");
_entityMapper = new EventEntityMapper (mapiNameSpace.CurrentUser.Address, new Uri ("mailto:" + testerServerEmailAddress), mapiNameSpace.Application.TimeZones.CurrentTimeZone.ID, mapiNameSpace.Application.Version);
s_outlookFolderEntryId = ConfigurationManager.AppSettings[string.Format ("{0}.OutlookFolderEntryId", Environment.MachineName)];
s_outlookFolderStoreId = ConfigurationManager.AppSettings[string.Format ("{0}.OutlookFolderStoreId", Environment.MachineName)];
_outlookRepository = new OutlookEventRepository (mapiNameSpace, s_outlookFolderEntryId, s_outlookFolderStoreId);
}
public Task <IReadOnlyList <EntityVersion <string, DateTime> > > GetAllVersions(IEnumerable <string> idsOfknownEntities, int context)
{
List <EntityVersion <string, DateTime> > tasks;
Func <TaskItem, EntityVersion <string, DateTime> > selector = a => new EntityVersion <string, DateTime>(a.EntryID, a.LastModificationTime);
using (var taskFolderWrapper = CreateFolderWrapper())
{
bool isInstantSearchEnabled = false;
try
{
using (var store = GenericComObjectWrapper.Create(taskFolderWrapper.Inner.Store))
{
if (store.Inner != null)
{
isInstantSearchEnabled = store.Inner.IsInstantSearchEnabled;
}
}
}
catch (COMException)
{
s_logger.Info("Can't access IsInstantSearchEnabled property of store, defaulting to false.");
}
var filterBuilder = new StringBuilder(_daslFilterProvider.GetTaskFilter(isInstantSearchEnabled));
if (_configuration.UseTaskCategoryAsFilter)
{
OutlookEventRepository.AddCategoryFilter(filterBuilder, _configuration.TaskCategory, _configuration.InvertTaskCategoryFilter);
}
s_logger.InfoFormat("Using Outlook DASL filter: {0}", filterBuilder.ToString());
tasks = QueryFolder(_mapiNameSpace, taskFolderWrapper, filterBuilder, selector);
}
if (_configuration.UseTaskCategoryAsFilter)
{
var knownEntitesThatWereFilteredOut = idsOfknownEntities.Except(tasks.Select(e => e.Id));
tasks.AddRange(
knownEntitesThatWereFilteredOut
.Select(id => _mapiNameSpace.GetEntryOrNull <TaskItem>(id, _folderId, _folderStoreId))
.Where(i => i != null)
.ToSafeEnumerable()
.Select(selector));
}
return(Task.FromResult <IReadOnlyList <EntityVersion <string, DateTime> > > (tasks));
}
public Task <IEnumerable <EntityVersion <string, DateTime> > > GetAllVersions(IEnumerable <string> idsOfknownEntities, int context, IGetVersionsLogger logger)
{
List <EntityVersion <string, DateTime> > tasks;
using (var taskFolderWrapper = CreateFolderWrapper())
{
bool isInstantSearchEnabled = false;
try
{
using (var store = GenericComObjectWrapper.Create(taskFolderWrapper.Inner.Store))
{
if (store.Inner != null)
{
isInstantSearchEnabled = store.Inner.IsInstantSearchEnabled;
}
}
}
catch (COMException)
{
s_logger.Info("Can't access IsInstantSearchEnabled property of store, defaulting to false.");
}
var filterBuilder = new StringBuilder(_daslFilterProvider.GetTaskFilter(isInstantSearchEnabled));
if (_configuration.UseTaskCategoryAsFilter)
{
OutlookEventRepository.AddCategoryFilter(filterBuilder, _configuration.TaskCategory, _configuration.InvertTaskCategoryFilter, _configuration.IncludeEmptyTaskCategoryFilter);
}
s_logger.DebugFormat("Using Outlook DASL filter: {0}", filterBuilder.ToString());
tasks = _queryFolderStrategy.QueryTaskFolder(_session, taskFolderWrapper.Inner, filterBuilder.ToString(), logger);
}
if (_configuration.IsCategoryFilterSticky && _configuration.UseTaskCategoryAsFilter)
{
var knownEntitesThatWereFilteredOut = idsOfknownEntities.Except(tasks.Select(e => e.Id));
tasks.AddRange(
knownEntitesThatWereFilteredOut
.Select(id => _session.GetTaskItemOrNull(id, _folderId, _folderStoreId))
.Where(i => i != null)
.ToSafeEnumerable()
.Select(t => new EntityVersion <string, DateTime> (t.EntryID, t.LastModificationTime.ToUniversalTime())));
}
return(Task.FromResult <IEnumerable <EntityVersion <string, DateTime> > > (tasks));
}
public static void Initialize(NameSpace mapiNameSpace)
{
s_mapiNameSpace = mapiNameSpace;
const string testerServerEmailAddress = "*****@*****.**";
if (mapiNameSpace == null)
{
throw new ArgumentNullException("mapiNameSpace");
}
_entityMapper = new EventEntityMapper(mapiNameSpace.CurrentUser.Address, new Uri("mailto:" + testerServerEmailAddress), mapiNameSpace.Application.TimeZones.CurrentTimeZone.ID, mapiNameSpace.Application.Version);
s_outlookFolderEntryId = ConfigurationManager.AppSettings[string.Format("{0}.OutlookFolderEntryId", Environment.MachineName)];
s_outlookFolderStoreId = ConfigurationManager.AppSettings[string.Format("{0}.OutlookFolderStoreId", Environment.MachineName)];
_outlookRepository = new OutlookEventRepository(mapiNameSpace, s_outlookFolderEntryId, s_outlookFolderStoreId);
}
public static void Initialize(NameSpace mapiNameSpace)
{
s_mapiNameSpace = mapiNameSpace;
const string testerServerEmailAddress = "*****@*****.**";
if (mapiNameSpace == null)
{
throw new ArgumentNullException("mapiNameSpace");
}
var globalTimeZoneCache = new GlobalTimeZoneCache();
var eventMappingConfiguration = new EventMappingConfiguration();
s_entityMapper = new EventEntityMapper(
mapiNameSpace.CurrentUser.Address,
new Uri("mailto:" + testerServerEmailAddress),
mapiNameSpace.Application.TimeZones.CurrentTimeZone.ID,
mapiNameSpace.Application.Version,
new TimeZoneCache(null, false, globalTimeZoneCache),
eventMappingConfiguration,
null);
s_outlookFolderEntryId = ConfigurationManager.AppSettings[string.Format("{0}.OutlookFolderEntryId", Environment.MachineName)];
s_outlookFolderStoreId = ConfigurationManager.AppSettings[string.Format("{0}.OutlookFolderStoreId", Environment.MachineName)];
var daslFilterProvider = new DaslFilterProvider(false);
s_synchronizerFactory = new SynchronizerFactory(
_ => @"a:\invalid path",
NullTotalProgressFactory.Instance,
s_mapiNameSpace,
daslFilterProvider,
new OutlookAccountPasswordProvider(mapiNameSpace.CurrentProfileName, mapiNameSpace.Application.Version),
globalTimeZoneCache,
QueryOutlookFolderByRequestingItemStrategy.Instance);
s_outlookEventRepository = new OutlookEventRepository(
s_mapiNameSpace,
s_outlookFolderEntryId,
s_outlookFolderStoreId,
NullDateTimeRangeProvider.Instance,
eventMappingConfiguration,
daslFilterProvider,
QueryOutlookFolderByRequestingItemStrategy.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);
}
private void SwitchTaskCategories(ChangedOptions changedOption, string oldCategory, string newCategory)
{
using (var taskFolderWrapper = GenericComObjectWrapper.Create(
(Folder)_session.GetFolderFromID(changedOption.New.OutlookFolderEntryId, changedOption.New.OutlookFolderStoreId)))
{
s_logger.Info($"Switching category of items in folder '{taskFolderWrapper.Inner.Name}' from '{oldCategory}' to '{newCategory}', due to changes in profile '{changedOption.New.Name}' (OptionId:'{changedOption.New.Id}' FolderId:'{changedOption.New.OutlookFolderEntryId}' StoreId:'{changedOption.New.OutlookFolderStoreId}')");
var isInstantSearchEnabled = false;
try
{
using (var store = GenericComObjectWrapper.Create(taskFolderWrapper.Inner.Store))
{
if (store.Inner != null)
{
isInstantSearchEnabled = store.Inner.IsInstantSearchEnabled;
}
}
}
catch (COMException)
{
s_logger.Info("Can't access IsInstantSearchEnabled property of store, defaulting to false.");
}
var filterBuilder = new StringBuilder(_daslFilterProvider.GetTaskFilter(isInstantSearchEnabled));
OutlookEventRepository.AddCategoryFilter(filterBuilder, oldCategory, false, false);
var taskIds = _queryFolderStrategyWrapper.QueryTaskFolder(_session, taskFolderWrapper.Inner, filterBuilder.ToString()).Select(e => e.Id);
// todo concat Ids from cache
foreach (var taskId in taskIds)
{
try
{
SwitchTaskCategories(changedOption, oldCategory, newCategory, taskId);
}
catch (Exception x)
{
s_logger.Error(null, x);
}
}
}
}
private void SwitchEventCategories(ChangedOptions changedOption, string oldCategory, string newCategory)
{
using (var calendarFolderWrapper = GenericComObjectWrapper.Create(
(Folder)_session.GetFolderFromID(changedOption.New.OutlookFolderEntryId, changedOption.New.OutlookFolderStoreId)))
{
bool isInstantSearchEnabled = false;
try
{
using (var store = GenericComObjectWrapper.Create(calendarFolderWrapper.Inner.Store))
{
if (store.Inner != null)
{
isInstantSearchEnabled = store.Inner.IsInstantSearchEnabled;
}
}
}
catch (COMException)
{
s_logger.Info("Can't access IsInstantSearchEnabled property of store, defaulting to false.");
}
var filterBuilder = new StringBuilder(_daslFilterProvider.GetAppointmentFilter(isInstantSearchEnabled));
OutlookEventRepository.AddCategoryFilter(filterBuilder, oldCategory, false);
var eventIds = OutlookEventRepository.QueryFolder(_session, calendarFolderWrapper, filterBuilder).Select(e => e.Id);
// todo concat Ids from cache
foreach (var eventId in eventIds)
{
try
{
SwitchEventCategories(changedOption, oldCategory, newCategory, eventId);
}
catch (Exception x)
{
s_logger.Error(null, x);
}
}
}
}
private void SwitchCategories(ChangedOptions changedOption, string oldCategory, string newCategory)
{
using (var calendarFolderWrapper = GenericComObjectWrapper.Create(
(Folder)_session.GetFolderFromID(changedOption.New.OutlookFolderEntryId, changedOption.New.OutlookFolderStoreId)))
{
var filterBuilder = new StringBuilder(OutlookEventRepository.PR_MESSAGE_CLASS_DASLFILTER);
OutlookEventRepository.AddCategoryFilter(filterBuilder, oldCategory);
var eventIds = OutlookEventRepository.QueryFolder(_session, calendarFolderWrapper, filterBuilder).Select(e => e.Id);
// todo concat Ids from cache
foreach (var eventId in eventIds)
{
try
{
SwitchCategories(changedOption, oldCategory, newCategory, eventId);
}
catch (Exception x)
{
s_logger.Error(null, x);
}
}
}
}
/// <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));
}
/// <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));
}
/// <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);
}
public static AppointmentItemWrapper GetOutlookEvent(string id)
{
return(OutlookEventRepository.GetOutlookEventForTesting(id, s_mapiNameSpace, s_outlookFolderStoreId));
}
public static void Initialize (NameSpace mapiNameSpace)
{
s_mapiNameSpace = mapiNameSpace;
const string testerServerEmailAddress = "*****@*****.**";
if (mapiNameSpace == null)
throw new ArgumentNullException ("mapiNameSpace");
var globalTimeZoneCache = new GlobalTimeZoneCache();
var eventMappingConfiguration = new EventMappingConfiguration();
s_entityMapper = new EventEntityMapper (
mapiNameSpace.CurrentUser.Address,
new Uri ("mailto:" + testerServerEmailAddress),
mapiNameSpace.Application.TimeZones.CurrentTimeZone.ID,
mapiNameSpace.Application.Version,
new TimeZoneCache (null, false, globalTimeZoneCache),
eventMappingConfiguration,
null);
s_outlookFolderEntryId = ConfigurationManager.AppSettings[string.Format ("{0}.OutlookFolderEntryId", Environment.MachineName)];
s_outlookFolderStoreId = ConfigurationManager.AppSettings[string.Format ("{0}.OutlookFolderStoreId", Environment.MachineName)];
var daslFilterProvider = new DaslFilterProvider (false);
s_synchronizerFactory = new SynchronizerFactory (
_ => @"a:\invalid path",
NullTotalProgressFactory.Instance,
s_mapiNameSpace,
daslFilterProvider,
new OutlookAccountPasswordProvider (mapiNameSpace.CurrentProfileName, mapiNameSpace.Application.Version),
globalTimeZoneCache);
s_outlookEventRepository = new OutlookEventRepository (
s_mapiNameSpace,
s_outlookFolderEntryId,
s_outlookFolderStoreId,
NullDateTimeRangeProvider.Instance,
eventMappingConfiguration,
daslFilterProvider);
}
