private static void Convert (NameSpace outlookSession, Options options, Func<Options, string> cacheFileGetter, Action<Options> cacheDeleter)
{
OlItemType defaultItemType;
using (var outlookFolderWrapper = GenericComObjectWrapper.Create((Folder)outlookSession.GetFolderFromID(options.OutlookFolderEntryId, options.OutlookFolderStoreId)))
{
defaultItemType = outlookFolderWrapper.Inner.DefaultItemType;
}
if (defaultItemType == OlItemType.olTaskItem)
{
var fileName = cacheFileGetter(options);
XDocument document = XDocument.Load(fileName);
if (document.Root?.Name.LocalName == "ArrayOfOutlookEventRelationData")
{
document.Root.Name = "ArrayOfTaskRelationData";
foreach (var node in document.Descendants().Where(n => n.Name == "OutlookEventRelationData"))
{
node.Name = "TaskRelationData";
}
document.Save(fileName);
}
}
}
public IOutlookSynchronizer CreateSynchronizer (Options options)
{
OlItemType defaultItemType;
string folderName;
using (var outlookFolderWrapper = GenericComObjectWrapper.Create ((Folder) _outlookSession.GetFolderFromID (options.OutlookFolderEntryId, options.OutlookFolderStoreId)))
{
defaultItemType = outlookFolderWrapper.Inner.DefaultItemType;
folderName = outlookFolderWrapper.Inner.Name;
}
switch (defaultItemType)
{
case OlItemType.olAppointmentItem:
return CreateEventSynchronizer (options);
case OlItemType.olTaskItem:
return CreateTaskSynchronizer (options);
case OlItemType.olContactItem:
return CreateContactSynchronizer (options);
default:
throw new NotSupportedException (
string.Format (
"The folder '{0}' contains an item type ('{1}'), whis is not supported for synchronization",
folderName,
defaultItemType));
}
}
public void FillOptions(CalDavSynchronizer.Contracts.Options options)
{
options.CloseAfterEachRequest = _closeConnectionAfterEachRequest;
options.PreemptiveAuthentication = _preemptiveAuthentication;
options.ForceBasicAuthentication = _forceBasicAuthentication;
options.ProxyOptions = CreateProxyOptions();
}
private static void Convert(NameSpace outlookSession, Options options, Func<Options,string> cacheFileGetter, Action<Options> cacheDeleter)
{
OlItemType defaultItemType;
using (var outlookFolderWrapper = GenericComObjectWrapper.Create ((Folder) outlookSession.GetFolderFromID (options.OutlookFolderEntryId, options.OutlookFolderStoreId)))
{
defaultItemType = outlookFolderWrapper.Inner.DefaultItemType;
}
if (defaultItemType == OlItemType.olAppointmentItem)
{
var fileName = cacheFileGetter(options);
XDocument document = XDocument.Load (fileName);
var aTypeNodes = document.Descendants ().Where (n => n.Name == "AtypeId");
foreach (var atypeNode in aTypeNodes)
{
var entryId = atypeNode.Value;
string globalAppointmentId;
using (var appointmentWrapper = GenericComObjectWrapper.Create ((AppointmentItem) outlookSession.GetItemFromID (entryId, options.OutlookFolderStoreId)))
{
globalAppointmentId = appointmentWrapper.Inner.GlobalAppointmentID;
}
atypeNode.RemoveAll ();
atypeNode.Add (new XElement ("EntryId", entryId));
atypeNode.Add (new XElement ("GlobalAppointmentId", globalAppointmentId));
}
document.Save (fileName);
}
}
public void UpdateOptions (Options options)
{
_profileName = options.Name;
_synchronizer = _synchronizerFactory.CreateSynchronizer (options);
_interval = TimeSpan.FromMinutes (options.SynchronizationIntervalInMinutes);
_inactive = options.Inactive;
}
public static ISynchronizer 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>>());
}
public void SaveOptions (Options[] options)
{
if (!Directory.Exists (Path.GetDirectoryName (_optionsFilePath)))
Directory.CreateDirectory (Path.GetDirectoryName (_optionsFilePath));
File.WriteAllText (_optionsFilePath, Serializer<Options[]>.Serialize (options));
}
public void FillOptions(CalDavSynchronizer.Contracts.Options options)
{
options.MappingConfiguration = new EventMappingConfiguration
{
CategoryShortcutKey = _categoryShortcutKey,
CreateEventsInUTC = _createEventsInUtc,
UseIanaTz = _useIanaTz,
EventTz = _eventTz,
IncludeHistoricalData = _includeHistoricalData,
UseGlobalAppointmentID = _useGlobalAppointmentID,
EventCategory = _eventCategory,
EventCategoryColor = _eventCategoryColor,
InvertEventCategoryFilter = _invertEventCategoryFilter,
MapAttendees = _mapAttendees,
MapBody = _mapBody,
MapClassConfidentialToSensitivityPrivate = _mapClassConfidentialToSensitivityPrivate,
MapReminder = _mapReminder,
MapSensitivityPrivateToClassConfidential = _mapSensitivityPrivateToClassConfidential,
MapClassPublicToSensitivityPrivate = _mapClassPublicToSensitivityPrivate,
ScheduleAgentClient = _scheduleAgentClient,
SendNoAppointmentNotifications = _sendNoAppointmentNotifications,
UseEventCategoryColorAndMapFromCalendarColor = _useEventCategoryColorAndMapFromCalendarColor,
CleanupDuplicateEvents = _cleanupDuplicateEvents
};
}
public void FillOptions(CalDavSynchronizer.Contracts.Options options)
{
var taskMappingConfiguration = options.GetOrCreateMappingConfiguration <TaskMappingConfiguration>();
FillOptions(taskMappingConfiguration);
_customPropertyMappingViewModel.FillOptions(taskMappingConfiguration);
}
private IOptionsViewModel Create (CalDavSynchronizer.Contracts.Options options, GeneralOptions generalOptions)
{
Func<ISettingsFaultFinder, ICurrentOptions, IServerSettingsViewModel> serverSettingsVM;
if (IsGoogleProfile(options))
{
serverSettingsVM = CreateGoogleServerSettingsViewModel;
}
else if (IsSwisscomProfile(options))
{
serverSettingsVM = CreateSwisscomServerSettingsViewModel;
}
else
{
serverSettingsVM = new Func<ISettingsFaultFinder, ICurrentOptions, IServerSettingsViewModel>(CreateServerSettingsViewModel);
}
var optionsViewModel = new GenericOptionsViewModel (
_optionsViewModelParent,
generalOptions,
_outlookAccountPasswordProvider,
serverSettingsVM,
CreateMappingConfigurationViewModelFactory, _optionTasks);
optionsViewModel.SetOptions (options);
return optionsViewModel;
}
protected override void SetOptionsOverride(CalDavSynchronizer.Contracts.Options options)
{
MappingConfigurationViewModel = options.MappingConfiguration?.CreateConfigurationViewModel(_mappingConfigurationViewModelFactory);
CoerceMappingConfiguration();
MappingConfigurationViewModel?.SetOptions(options);
}
public void FillOptions(CalDavSynchronizer.Contracts.Options options)
{
options.CalenderUrl = _calenderUrl;
options.UserName = _emailAddress;
options.Password = new SecureString();
options.EmailAddress = _emailAddress;
options.UseAccountPassword = false;
options.ServerAdapterType = _serverAdapterType;
}
public void FillOptions(CalDavSynchronizer.Contracts.Options options)
{
options.MappingConfiguration = new ContactMappingConfiguration
{
MapBirthday = _mapBirthday,
MapContactPhoto = _mapContactPhoto,
FixPhoneNumberFormat = _fixPhoneNumberFormat
};
}
public void SetUp ()
{
_synchronizerFactory = MockRepository.GenerateStub<ISynchronizerFactory>();
_synchronizationProfileRunner = new SynchronizationProfileRunner (_synchronizerFactory);
var options = new Options();
_stubSynchronizer = new StubSynchronizer();
_synchronizerFactory.Expect (f => f.CreateSynchronizer (options)).Return (_stubSynchronizer);
_synchronizationProfileRunner.UpdateOptions (options);
}
public static bool EditOptions(NameSpace session, Options[] options, out Options[] changedOptions)
{
changedOptions = null;
var form = new OptionsForm (session);
form.OptionsList = options;
var shouldSave = form.ShowDialog() == DialogResult.OK;
if (shouldSave)
changedOptions = form.OptionsList;
return shouldSave;
}
public void FillOptions(CalDavSynchronizer.Contracts.Options options)
{
options.MappingConfiguration = new TaskMappingConfiguration
{
MapBody = _mapBody,
MapPriority = _mapPriority,
MapRecurringTasks = _mapRecurringTasks,
MapReminder = _mapReminder
};
}
public IOptionsDisplayControl Create (Options options)
{
if (!_displayAllProfilesAsGeneric)
{
if (options.DisplayType == OptionsDisplayType.Google || options.ServerAdapterType == ServerAdapterType.GoogleOAuth)
return new GoogleOptionsDisplayControl (_session, _profileDataDirectoryFactory, _fixInvalidSettings);
}
return new OptionsDisplayControl (_session, _profileDataDirectoryFactory, _fixInvalidSettings);
}
public void UpdateOptions (Options options)
{
_pendingOutlookItems.Clear();
_fullSyncPending = false;
_profileName = options.Name;
_synchronizer = _synchronizerFactory.CreateSynchronizer (options);
_interval = TimeSpan.FromMinutes (options.SynchronizationIntervalInMinutes);
_inactive = options.Inactive;
_changeTriggeredSynchronizationEnabled = options.EnableChangeTriggeredSynchronization;
}
private TabPage AddTabPage (Options options)
{
var optionsControl = new OptionsDisplayControl (_session);
var tabPage = new TabPage (options.Name);
_tabControl.TabPages.Add (tabPage);
optionsControl.DeletionRequested += delegate { _tabControl.TabPages.Remove (tabPage); };
optionsControl.HeaderChanged += delegate (object sender, HeaderEventArgs e)
{
tabPage.Text = e.Name;
switch (e.FolderItemType)
{
case OlItemType.olAppointmentItem:
if (e.IsInactive)
tabPage.ImageKey = "AppointmentDisabled";
else
tabPage.ImageKey = "Appointment";
break;
case OlItemType.olTaskItem:
if (e.IsInactive)
tabPage.ImageKey = "TaskDisabled";
else
tabPage.ImageKey = "Task";
break;
case OlItemType.olContactItem:
if (e.IsInactive)
tabPage.ImageKey = "ContactDisabled";
else
tabPage.ImageKey = "Contact";
break;
default:
tabPage.ImageKey = null;
break;
}
};
optionsControl.CopyRequested += delegate
{
var newOptions = optionsControl.Options;
newOptions.Name += " (Copy)";
newOptions.Id = Guid.NewGuid();
var newPage = AddTabPage (newOptions);
_tabControl.SelectedTab = newPage;
};
optionsControl.Options = options;
tabPage.Controls.Add (optionsControl);
optionsControl.Dock = DockStyle.Fill;
return tabPage;
}
public Contracts.Options[] GetOptionsCollection()
{
var optionsCollection = new List <CalDavSynchronizer.Contracts.Options>();
foreach (var viewModel in _options)
{
var options = new CalDavSynchronizer.Contracts.Options();
viewModel.FillOptions(options);
optionsCollection.Add(options);
}
return(optionsCollection.ToArray());
}
public void SetOptions(CalDavSynchronizer.Contracts.Options options)
{
var proxyOptions = options.ProxyOptions ?? new ProxyOptions();
CloseConnectionAfterEachRequest = options.CloseAfterEachRequest;
PreemptiveAuthentication = options.PreemptiveAuthentication;
ProxyUseDefault = proxyOptions.ProxyUseDefault;
ProxyUseManual = proxyOptions.ProxyUseManual;
ProxyUrl = proxyOptions.ProxyUrl;
ProxyUserName = proxyOptions.ProxyUserName;
ProxyPassword = proxyOptions.ProxyPassword;
}
public void SetOptions(CalDavSynchronizer.Contracts.Options options)
{
EmailAddress = options.EmailAddress;
if (!string.IsNullOrEmpty(options.CalenderUrl))
{
CalenderUrl = options.CalenderUrl;
}
else
{
CalenderUrl = OptionTasks.GoogleDavBaseUrl;
}
_serverAdapterType = options.ServerAdapterType;
}
public void RequestCopy(OptionsViewModelBase viewModel)
{
var options = new CalDavSynchronizer.Contracts.Options();
viewModel.FillOptions(options);
options.Id = Guid.NewGuid();
options.Name += " (Copy)";
var index = _options.IndexOf(viewModel) + 1;
foreach (var vm in _optionsViewModelFactory.Create(new[] { options }, _fixInvalidSettings))
{
_options.Insert(index, vm);
}
}
public static bool EditOptions (
NameSpace session,
Options[] options,
out Options[] changedOptions,
Func<Guid, string> profileDataDirectoryFactory,
bool fixInvalidSettings)
{
var form = new OptionsForm (session,profileDataDirectoryFactory, fixInvalidSettings);
form.OptionsList = options;
var shouldSave = form.ShowDialog() == DialogResult.OK;
changedOptions = form.OptionsList;
return shouldSave;
}
private IOptionsViewModel Create(CalDavSynchronizer.Contracts.Options options, GeneralOptions generalOptions)
{
var optionsViewModel = new GenericOptionsViewModel(
_session,
_optionsViewModelParent,
generalOptions,
_outlookAccountPasswordProvider,
IsGoogleProfile(options)
? CreateGoogleServerSettingsViewModel
: new Func <ISettingsFaultFinder, ICurrentOptions, IServerSettingsViewModel> (CreateServerSettingsViewModel),
CreateMappingConfigurationViewModelFactory);
optionsViewModel.SetOptions(options);
return(optionsViewModel);
}
public void FillOptions(CalDavSynchronizer.Contracts.Options options)
{
foreach (var section in Sections)
{
section.FillOptions(options);
}
foreach (var subViewModel in SubOptions)
{
subViewModel.FillOptions(options);
}
options.Inactive = !IsActive;
options.Name = Name;
options.Id = Id;
}
public static Options CreateDefault (string outlookFolderEntryId, string outlookFolderStoreId)
{
var options = new Options();
options.OutlookFolderEntryId = outlookFolderEntryId;
options.OutlookFolderStoreId = outlookFolderStoreId;
options.ConflictResolution = ConflictResolution.Automatic;
options.DaysToSynchronizeInTheFuture = 180;
options.DaysToSynchronizeInThePast = 60;
options.SynchronizationIntervalInMinutes = 30;
options.SynchronizationMode = SynchronizationMode.MergeInBothDirections;
options.Name = "<New Profile>";
options.Id = Guid.NewGuid();
options.Inactive = false;
options.ProxyOptions = new ProxyOptions() { ProxyUseDefault = true };
return options;
}
public void SetOptions(CalDavSynchronizer.Contracts.Options options)
{
foreach (var section in Sections)
{
section.SetOptions(options);
}
foreach (var subViewModel in SubOptions)
{
subViewModel.SetOptions(options);
}
IsActive = !options.Inactive;
Name = options.Name;
Id = options.Id;
SetOptionsOverride(options);
}
public static bool EditOptions (NameSpace session, Options[] options, out Options[] changedOptions, bool checkForNewerVersions, out bool changedCheckForNewerVersions)
{
changedCheckForNewerVersions = false;
changedOptions = null;
var form = new OptionsForm (session);
form.OptionsList = options;
form._checkForNewerVersionsCheckBox.Checked = checkForNewerVersions;
var shouldSave = form.ShowDialog() == DialogResult.OK;
if (shouldSave)
{
changedOptions = form.OptionsList;
changedCheckForNewerVersions = form._checkForNewerVersionsCheckBox.Checked;
}
return shouldSave;
}
public static void Convert (
NameSpace outlookSession,
Options[] options,
Func<Options, string> cacheFileGetter,
Action<Options> cacheDeleter)
{
foreach (var option in options)
{
try
{
Convert(outlookSession, option, cacheFileGetter, cacheDeleter);
}
catch (System.Exception x)
{
s_logger.Error ($"Error during conversion for profile '{option.Name}'. Deleting caches", x);
cacheDeleter(option);
}
}
}
public void SetOptions (Options[] options)
{
Dictionary<Guid, SynchronizationWorker> workersById = new Dictionary<Guid, SynchronizationWorker>();
foreach (var option in options)
{
try
{
SynchronizationWorker worker;
if (!_workersById.TryGetValue (option.Id, out worker))
worker = new SynchronizationWorker (_synchronizerFactory);
worker.UpdateOptions (option);
workersById.Add (option.Id, worker);
}
catch (Exception x)
{
ExceptionHandler.Instance.LogException (x, s_logger);
}
}
_workersById = workersById;
}
private void PrepareForImport(Options[] options, Action<string> logger)
{
var folderIdsByName = new Dictionary<string, List<Tuple<string, string>>>();
AddFoldersRecusive(_session.Folders, folderIdsByName);
foreach (var profile in options)
{
var ids = folderIdsByName.GetOrAdd(profile.OutlookFolderEntryId).FirstOrDefault();
if (ids != null)
{
profile.OutlookFolderEntryId = ids.Item1;
profile.OutlookFolderStoreId = ids.Item2;
profile.OutlookFolderAccountName = _optionTasks.GetFolderAccountNameOrNull(profile.OutlookFolderStoreId);
}
else
{
logger($"Warning: did not find Folder '{profile.OutlookFolderEntryId}'");
profile.OutlookFolderEntryId = null;
profile.OutlookFolderStoreId = null;
profile.OutlookFolderAccountName = null;
}
}
}
public void PrepareForExport(Options[] profiles, Action<string> logger)
{
logger("Processing profiles.");
foreach (var profile in profiles)
{
logger($"'{profile.Name}'");
try
{
using (var outlookFolderWrapper = GenericComObjectWrapper.Create((Folder) _session.GetFolderFromID(profile.OutlookFolderEntryId, profile.OutlookFolderStoreId)))
{
profile.OutlookFolderEntryId = outlookFolderWrapper.Inner.Name;
}
}
catch (System.Exception)
{
logger ($"WARNING profile '{profile.Name}', references an outlook folder that doesn't exist.");
profile.OutlookFolderEntryId = "<ERROR>";
}
profile.OutlookFolderStoreId = null;
}
logger ("Processing profiles done.");
}
public void SetOptions (Options[] options, bool checkIfOnline)
{
Dictionary<Guid, SynchronizationProfileRunner> workersById = new Dictionary<Guid, SynchronizationProfileRunner>();
foreach (var option in options)
{
try
{
SynchronizationProfileRunner profileRunner;
if (!_runnersById.TryGetValue (option.Id, out profileRunner))
{
profileRunner = new SynchronizationProfileRunner (
_synchronizerFactory,
_synchronizationReportRepository);
}
profileRunner.UpdateOptions (option, checkIfOnline);
workersById.Add (option.Id, profileRunner);
}
catch (Exception x)
{
ExceptionHandler.Instance.LogException (x, s_logger);
}
}
_runnersById = workersById;
}
public void SetOptions (Options value)
{
numberOfDaysInThePast.Text = value.DaysToSynchronizeInThePast.ToString();
numberOfDaysInTheFuture.Text = value.DaysToSynchronizeInTheFuture.ToString();
_synchronizationModeComboBox.SelectedValue = value.SynchronizationMode;
_conflictResolutionComboBox.SelectedValue = value.ConflictResolution;
_enableTimeRangeFilteringCheckBox.Checked = !value.IgnoreSynchronizationTimeRange;
_syncIntervalComboBox.SelectedValue = value.SynchronizationIntervalInMinutes;
UpdateConflictResolutionComboBoxEnabled();
UpdateTimeRangeFilteringGroupBoxEnabled();
}
public void SetOptions (Options value)
{
_synchronizeImmediatelyAfterOutlookItemChangeCheckBox.Checked = value.EnableChangeTriggeredSynchronization;
UpdateFolder (value.OutlookFolderEntryId, value.OutlookFolderStoreId);
}
public void FillOptions (Options optionsToFill)
{
optionsToFill.OutlookFolderEntryId = _folderEntryId;
optionsToFill.OutlookFolderStoreId = _folderStoreId;
optionsToFill.EnableChangeTriggeredSynchronization = _synchronizeImmediatelyAfterOutlookItemChangeCheckBox.Checked;
}
protected virtual void SetOptionsOverride(CalDavSynchronizer.Contracts.Options options)
{
}
public async Task UpdateOptions (Options options, GeneralOptions generalOptions)
{
if (options == null)
throw new ArgumentNullException (nameof (options));
if (generalOptions == null)
throw new ArgumentNullException (nameof (generalOptions));
_pendingOutlookItems.Clear();
_fullSyncPending = false;
_profileName = options.Name;
_profileId = options.Id;
_proxyOptions = options.ProxyOptions;
_synchronizer = options.Inactive ? NullOutlookSynchronizer.Instance : await _synchronizerFactory.CreateSynchronizer (options, generalOptions);
_interval = TimeSpan.FromMinutes (options.SynchronizationIntervalInMinutes);
_inactive = options.Inactive;
_checkIfOnline = generalOptions.CheckIfOnline;
if (_folderChangeWatcher != null)
{
_folderChangeWatcher.ItemSavedOrDeleted -= FolderChangeWatcher_ItemSavedOrDeleted;
_folderChangeWatcher.Dispose();
_folderChangeWatcher = null;
}
if (!_inactive && options.EnableChangeTriggeredSynchronization)
{
_folderChangeWatcher =
_folderChangeWatcherFactory.Create (options.OutlookFolderEntryId, options.OutlookFolderStoreId);
_folderChangeWatcher.ItemSavedOrDeleted += FolderChangeWatcher_ItemSavedOrDeleted;
}
}
private OutlookSynchronizer CreateTaskSynchronizer (Options options)
{
// TODO: dispose folder like it is done for events
var calendarFolder = (Folder) _outlookSession.GetFolderFromID (options.OutlookFolderEntryId, options.OutlookFolderStoreId);
var atypeRepository = new OutlookTaskRepository (calendarFolder, _outlookSession);
var btypeRepository = new CalDavRepository (
new CalDavDataAccess (
new Uri (options.CalenderUrl),
CreateWebDavClient (
options.UserName,
options.Password,
_calDavConnectTimeout,
options.ServerAdapterType,
options.CloseAfterEachRequest,
options.ProxyOptions)),
new iCalendarSerializer(),
CalDavRepository.EntityType.Todo,
NullDateTimeRangeProvider.Instance);
var outlookEventRelationDataFactory = new OutlookEventRelationDataFactory();
var syncStateFactory = new EntitySyncStateFactory<string, DateTime, TaskItemWrapper, Uri, string, IICalendar> (
new TaskMapper (_outlookSession.Application.TimeZones.CurrentTimeZone.ID),
atypeRepository,
btypeRepository,
outlookEventRelationDataFactory,
ExceptionHandler.Instance);
var storageDataDirectory = _profileDataDirectoryFactory (options.Id);
var btypeIdEqualityComparer = EqualityComparer<Uri>.Default;
var atypeIdEqualityComparer = EqualityComparer<string>.Default;
var synchronizer = new Synchronizer<string, DateTime, TaskItemWrapper, Uri, string, IICalendar> (
atypeRepository,
btypeRepository,
InitialTaskSyncStateCreationStrategyFactory.Create (
syncStateFactory,
syncStateFactory.Environment,
options.SynchronizationMode,
options.ConflictResolution),
new EntityRelationDataAccess<string, DateTime, OutlookEventRelationData, Uri, string> (storageDataDirectory),
outlookEventRelationDataFactory,
new InitialTaskEntityMatcher (btypeIdEqualityComparer),
atypeIdEqualityComparer,
btypeIdEqualityComparer,
_totalProgressFactory,
ExceptionHandler.Instance);
return new OutlookSynchronizer (synchronizer, atypeRepository);
}
/// <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);
}
private OutlookSynchronizer CreateContactSynchronizer (Options options)
{
var atypeRepository = new OutlookContactRepository (
_outlookSession,
options.OutlookFolderEntryId,
options.OutlookFolderStoreId);
IEntityRepository<vCard, Uri, string> btypeRepository = new CardDavRepository (
new CardDavDataAccess (
new Uri (options.CalenderUrl),
CreateWebDavClient (
options.UserName,
options.Password,
_calDavConnectTimeout,
options.ServerAdapterType,
options.CloseAfterEachRequest,
options.ProxyOptions)));
var entityRelationDataFactory = new OutlookContactRelationDataFactory();
var syncStateFactory = new EntitySyncStateFactory<string, DateTime, ContactItemWrapper, Uri, string, vCard> (
new ContactEntityMapper(),
atypeRepository,
btypeRepository,
entityRelationDataFactory,
ExceptionHandler.Instance);
var btypeIdEqualityComparer = EqualityComparer<Uri>.Default;
var atypeIdEqulityComparer = EqualityComparer<string>.Default;
var storageDataDirectory = _profileDataDirectoryFactory (options.Id);
var storageDataAccess = new EntityRelationDataAccess<string, DateTime, OutlookContactRelationData, Uri, string> (storageDataDirectory);
var synchronizer = new Synchronizer<string, DateTime, ContactItemWrapper, Uri, string, vCard> (
atypeRepository,
btypeRepository,
InitialContactSyncStateCreationStrategyFactory.Create (
syncStateFactory,
syncStateFactory.Environment,
options.SynchronizationMode,
options.ConflictResolution),
storageDataAccess,
entityRelationDataFactory,
new InitialContactEntityMatcher (btypeIdEqualityComparer),
atypeIdEqulityComparer,
btypeIdEqualityComparer,
_totalProgressFactory,
ExceptionHandler.Instance);
return new OutlookSynchronizer (synchronizer, atypeRepository);
}
private void DeleteEntityChachesForChangedProfiles (Options[] oldOptions, Options[] newOptions)
{
var profilesForCacheDeletion =
oldOptions
.Concat (newOptions)
.GroupBy (o => o.Id)
.Where (g => g.GroupBy (o => new { o.OutlookFolderStoreId, o.OutlookFolderEntryId, o.CalenderUrl }).Count() > 1)
.Select (g => new { Id = g.Key, Name = g.First().Name })
.ToArray();
foreach (var profile in profilesForCacheDeletion)
{
try
{
s_logger.InfoFormat ("Deleting cache for profile '{0}' ('{1}')", profile.Id, profile.Name);
var profileDataDirectory = GetProfileDataDirectory (profile.Id);
if (Directory.Exists (profileDataDirectory))
Directory.Delete (profileDataDirectory, true);
}
catch (Exception x)
{
s_logger.Error (null, x);
}
}
}
public void SetOptions(CalDavSynchronizer.Contracts.Options options)
{
SetOptions(options.MappingConfiguration as TaskMappingConfiguration ?? new TaskMappingConfiguration());
}
public static IWebDavClient CreateWebDavClient (Options options, TimeSpan timeout)
{
return CreateWebDavClient (
options.UserName,
options.Password,
timeout,
options.ServerAdapterType,
options.CloseAfterEachRequest,
options.ProxyOptions);
}
private OutlookSynchronizer CreateEventSynchronizer (Options options)
{
var calDavDataAccess = new CalDavDataAccess (
new Uri (options.CalenderUrl),
CreateWebDavClient (options, _calDavConnectTimeout));
var storageDataDirectory = _profileDataDirectoryFactory (options.Id);
var entityRelationDataAccess = new EntityRelationDataAccess<string, DateTime, OutlookEventRelationData, Uri, string> (storageDataDirectory);
return CreateEventSynchronizer (options, calDavDataAccess, entityRelationDataAccess);
}
public void FillOptions (Options optionsToFill)
{
optionsToFill.DaysToSynchronizeInThePast = int.Parse (numberOfDaysInThePast.Text);
optionsToFill.DaysToSynchronizeInTheFuture = int.Parse (numberOfDaysInTheFuture.Text);
optionsToFill.SynchronizationMode = (SynchronizationMode) _synchronizationModeComboBox.SelectedValue;
optionsToFill.ConflictResolution = (ConflictResolution) (_conflictResolutionComboBox.SelectedValue ?? ConflictResolution.Manual);
optionsToFill.SynchronizationIntervalInMinutes = (int) _syncIntervalComboBox.SelectedValue;
optionsToFill.IgnoreSynchronizationTimeRange = !_enableTimeRangeFilteringCheckBox.Checked;
}
