public static async Task <Uri> AddResource(Uri davUri, IWebDavClient webDavClient, OlItemType selectedOutlookFolderType)
{
switch (selectedOutlookFolderType)
{
case OlItemType.olAppointmentItem:
case OlItemType.olTaskItem:
var calDavDataAccess = new CalDavDataAccess(davUri, webDavClient);
using (var addResourceForm = new AddResourceForm(true))
{
addResourceForm.Text = Strings.Get($"Add calendar resource on server");
if (addResourceForm.ShowDialog() == DialogResult.OK)
{
try
{
var newUri = await calDavDataAccess.AddResource(addResourceForm.ResourceName, addResourceForm.UseRandomUri);
MessageBox.Show(Strings.Get($"Added calendar resource '{addResourceForm.ResourceName}' successfully!"), CreateDavResourceCaption, MessageBoxButtons.OK, MessageBoxIcon.Information);
if (!await new CalDavDataAccess(newUri, webDavClient).SetCalendarColorNoThrow(new ArgbColor(addResourceForm.CalendarColor.ToArgb())))
{
MessageBox.Show(Strings.Get($"Can't set the calendar color!'"), CreateDavResourceCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return(newUri);
}
catch (Exception ex)
{
s_logger.Error($"Can't add calendar resource '{addResourceForm.ResourceName}'", ex);
MessageBox.Show(Strings.Get($"Can't add calendar resource '{addResourceForm.ResourceName}'"), CreateDavResourceCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
break;
case OlItemType.olContactItem:
var cardDavDataAccess = new CardDavDataAccess(davUri, webDavClient, string.Empty, contentType => true);
using (var addResourceForm = new AddResourceForm(false))
{
addResourceForm.Text = Strings.Get($"Add addressbook resource on server");
if (addResourceForm.ShowDialog() == DialogResult.OK)
{
try
{
var newUri = await cardDavDataAccess.AddResource(addResourceForm.ResourceName, addResourceForm.UseRandomUri);
MessageBox.Show(Strings.Get($"Added addressbook resource '{addResourceForm.ResourceName}' successfully!"), CreateDavResourceCaption, MessageBoxButtons.OK, MessageBoxIcon.Information);
return(newUri);
}
catch (Exception ex)
{
s_logger.Error($"Can't add addressbook resource '{addResourceForm.ResourceName}'", ex);
MessageBox.Show(Strings.Get($"Can't add addressbook resource '{addResourceForm.ResourceName}'"), CreateDavResourceCaption, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
break;
}
return(davUri);
}
public async Task <ServerResources> GetServerResources(NetworkSettingsViewModel networkSettings, GeneralOptions generalOptions)
{
var trimmedUrl = CalenderUrl.Trim();
var url = new Uri(trimmedUrl.EndsWith("/") ? trimmedUrl : trimmedUrl + "/");
var webDavClient = CreateWebDavClient(networkSettings, generalOptions);
var calDavDataAccess = new CalDavDataAccess(url, webDavClient);
var cardDavDataAccess = new CardDavDataAccess(url, webDavClient);
var resources = await GetUserResources(calDavDataAccess, cardDavDataAccess, true);
return(resources.ContainsResources ? resources : await GetUserResources(calDavDataAccess, cardDavDataAccess, false));
}
public static async Task <TestResult> TestConnection(Uri url, IWebDavClient webDavClient)
{
var calDavDataAccess = new CalDavDataAccess(url, webDavClient);
var cardDavDataAccess = new CardDavDataAccess(url, webDavClient);
// Note: CalDav Calendars can contain Events and Todos. Therefore an calender resource is always a calendar and a task list.
var ressourceType =
(await calDavDataAccess.IsResourceCalender() ? ResourceType.Calendar | ResourceType.TaskList : ResourceType.None) |
(await cardDavDataAccess.IsResourceAddressBook() ? ResourceType.AddressBook : ResourceType.None);
return(new TestResult(
ressourceType,
ressourceType.HasFlag(ResourceType.Calendar) ? await GetCalendarProperties(calDavDataAccess) : CalendarProperties.None,
ressourceType.HasFlag(ResourceType.AddressBook) ? await GetAddressBookProperties(cardDavDataAccess) : AddressBookProperties.None));
}
public static CardDavDataAccess CreateCardDavDataAccess(
string calenderUrl,
string username,
string password,
TimeSpan timeout,
ServerAdapterType serverAdapterType)
{
var productAndVersion = GetProductAndVersion();
var cardDavDataAccess = new CardDavDataAccess(
new Uri(calenderUrl),
new CardDavClient(
() => CreateHttpClient(username, password, timeout, serverAdapterType),
productAndVersion.Item1,
productAndVersion.Item2));
return(cardDavDataAccess);
}
public static async Task <TestResult> TestConnection(Uri url, IWebDavClient webDavClient)
{
var calDavDataAccess = new CalDavDataAccess(url, webDavClient);
var cardDavDataAccess = new CardDavDataAccess(url, webDavClient, string.Empty, contentType => true);
// Note: CalDav Calendars can contain Events and Todos. Therefore an calender resource is always a calendar and a task list.
var ressourceType =
(await calDavDataAccess.IsResourceCalender() ? ResourceType.Calendar | ResourceType.TaskList : ResourceType.None) |
(await cardDavDataAccess.IsResourceAddressBook() ? ResourceType.AddressBook : ResourceType.None);
return(new TestResult(
ressourceType,
ressourceType.HasFlag(ResourceType.Calendar) ? await GetCalendarProperties(calDavDataAccess) : CalendarProperties.None,
ressourceType.HasFlag(ResourceType.AddressBook) ? await GetAddressBookProperties(cardDavDataAccess) : AddressBookProperties.None,
await calDavDataAccess.GetPrivileges(),
await calDavDataAccess.DoesSupportWebDavCollectionSync(),
ressourceType.HasFlag(ResourceType.Calendar) ? await calDavDataAccess.GetCalendarOwnerPropertiesOrNull() : null));
}
public static async Task <TestResult> TestConnection(Uri url, IWebDavClient webDavClient, ResourceType supposedRessourceType)
{
var calDavDataAccess = new CalDavDataAccess(url, webDavClient);
var cardDavDataAccess = new CardDavDataAccess(url, webDavClient);
TestResult result;
switch (supposedRessourceType)
{
case ResourceType.None:
var ressourceType =
(await calDavDataAccess.IsResourceCalender() ? ResourceType.Calendar : ResourceType.None) |
(await cardDavDataAccess.IsResourceAddressBook() ? ResourceType.AddressBook : ResourceType.None);
result = new TestResult(
ressourceType,
ressourceType.HasFlag(ResourceType.Calendar) ? await GetCalendarProperties(calDavDataAccess) : CalendarProperties.None,
ressourceType.HasFlag(ResourceType.AddressBook) ? await GetAddressBookProperties(cardDavDataAccess) : AddressBookProperties.None);
break;
case ResourceType.Calendar:
result = new TestResult(
supposedRessourceType,
CalendarProperties.CalendarAccessSupported |
(await calDavDataAccess.IsWriteable() ? CalendarProperties.IsWriteable : CalendarProperties.None) |
(await calDavDataAccess.DoesSupportCalendarQuery() ? CalendarProperties.SupportsCalendarQuery : CalendarProperties.None),
AddressBookProperties.None);
break;
case ResourceType.AddressBook:
result = new TestResult(
supposedRessourceType,
CalendarProperties.None,
AddressBookProperties.AddressBookAccessSupported |
(await cardDavDataAccess.IsWriteable() ? AddressBookProperties.IsWriteable : AddressBookProperties.None));
break;
default:
throw new ArgumentOutOfRangeException("supposedRessourceType");
}
return(result);
}
public async Task <ServerResources> GetServerResources()
{
var trimmedUrl = CalenderUrl.Trim();
var url = new Uri(trimmedUrl.EndsWith("/") ? trimmedUrl : trimmedUrl + "/");
var webDavClient = _prototypeModel.CreateWebDavClient();
var calDavDataAccess = new CalDavDataAccess(url, webDavClient);
var foundResources = await calDavDataAccess.GetUserResourcesIncludingCalendarProxies(false);
var cardDavDataAccess = new CardDavDataAccess(url, webDavClient, string.Empty, contentType => true);
var foundAddressBooks = await cardDavDataAccess.GetUserAddressBooksNoThrow(true);
var service = await GoogleHttpClientFactory.LoginToGoogleTasksService(EmailAddress, SynchronizerFactory.CreateProxy(_prototypeModel.CreateProxyOptions()));
var taskLists = await service.Tasklists.List().ExecuteAsync();
var taskListsData = taskLists?.Items.Select(i => new TaskListData(i.Id, i.Title, AccessPrivileges.All)).ToArray() ?? new TaskListData[] { };
return(new ServerResources(foundResources.CalendarResources, foundAddressBooks, taskListsData));
}
private async Task <bool> TestAddressBook(CardDavDataAccess cardDavDataAccess, StringBuilder errorMessageBuilder)
{
bool hasError = false;
if (!await cardDavDataAccess.IsAddressBookAccessSupported())
{
errorMessageBuilder.AppendLine("- The specified Url does not support addressbook.");
hasError = true;
}
if (!await cardDavDataAccess.IsWriteable())
{
errorMessageBuilder.AppendLine("- The specified Url is a read-only addressbook.");
hasError = true;
}
if (_folderType != OlItemType.olContactItem)
{
errorMessageBuilder.AppendLine("- The outlook folder is not a address book, or there is no folder selected.");
hasError = true;
}
return(hasError);
}
private static async Task <ServerResources> GetUserResources(CalDavDataAccess calDavDataAccess, CardDavDataAccess cardDavDataAccess, bool useWellKNownUrl)
{
var calDavResources = await calDavDataAccess.GetUserResourcesNoThrow(useWellKNownUrl);
var foundAddressBooks = await cardDavDataAccess.GetUserAddressBooksNoThrow(useWellKNownUrl);
return(new ServerResources(calDavResources.CalendarResources, foundAddressBooks, calDavResources.TaskListResources));
}
private static async Task <ServerResources> GetUserResources(CalDavDataAccess calDavDataAccess, CardDavDataAccess cardDavDataAccess)
{
var calDavResources = await calDavDataAccess.GetUserResourcesNoThrow(true);
if (calDavResources.CalendarResources.Count == 0 && calDavResources.TaskListResources.Count == 0)
{
calDavResources = await calDavDataAccess.GetUserResourcesNoThrow(false);
}
var foundAddressBooks = await cardDavDataAccess.GetUserAddressBooksNoThrow(true);
if (foundAddressBooks.Count == 0)
{
foundAddressBooks = await cardDavDataAccess.GetUserAddressBooksNoThrow(false);
}
return(new ServerResources(calDavResources.CalendarResources, foundAddressBooks, calDavResources.TaskListResources));
}
private static async Task <AddressBookProperties> GetAddressBookProperties(CardDavDataAccess cardDavDataAccess)
{
return
((await cardDavDataAccess.IsAddressBookAccessSupported() ? AddressBookProperties.AddressBookAccessSupported : AddressBookProperties.None) |
(await cardDavDataAccess.IsWriteable() ? AddressBookProperties.IsWriteable : AddressBookProperties.None));
}
private IOutlookSynchronizer CreateContactSynchronizer(Options options, GeneralOptions generalOptions, AvailableSynchronizerComponents componentsToFill)
{
var atypeRepository = new OutlookContactRepository <int> (
_outlookSession,
options.OutlookFolderEntryId,
options.OutlookFolderStoreId,
_daslFilterProvider);
var cardDavDataAccess = new CardDavDataAccess(
new Uri(options.CalenderUrl),
CreateWebDavClient(
options.UserName,
options.GetEffectivePassword(_outlookAccountPasswordProvider),
options.CalenderUrl,
_calDavConnectTimeout,
options.ServerAdapterType,
options.CloseAfterEachRequest,
options.PreemptiveAuthentication,
options.ForceBasicAuthentication,
options.ProxyOptions,
generalOptions.AcceptInvalidCharsInServerResponse));
componentsToFill.CardDavDataAccess = cardDavDataAccess;
IEntityRepository <vCard, WebResourceName, string, int> btypeRepository = new CardDavRepository(
cardDavDataAccess);
var mappingParameters = GetMappingParameters <ContactMappingConfiguration> (options);
var entityMapper = new ContactEntityMapper(mappingParameters);
var entityRelationDataFactory = new OutlookContactRelationDataFactory();
var syncStateFactory = new EntitySyncStateFactory <string, DateTime, ContactItemWrapper, WebResourceName, string, vCard> (
entityMapper,
entityRelationDataFactory,
ExceptionHandler.Instance);
var btypeIdEqualityComparer = WebResourceName.Comparer;
var atypeIdEqulityComparer = EqualityComparer <string> .Default;
var storageDataDirectory = _profileDataDirectoryFactory(options.Id);
var storageDataAccess = new EntityRelationDataAccess <string, DateTime, OutlookContactRelationData, WebResourceName, string> (storageDataDirectory);
var atypeWriteRepository = BatchEntityRepositoryAdapter.Create(atypeRepository);
var btypeWriteRepository = BatchEntityRepositoryAdapter.Create(btypeRepository);
var synchronizer = new Synchronizer <string, DateTime, ContactItemWrapper, WebResourceName, string, vCard, int> (
atypeRepository,
btypeRepository,
atypeWriteRepository,
btypeWriteRepository,
InitialSyncStateCreationStrategyFactory <string, DateTime, ContactItemWrapper, WebResourceName, string, vCard> .Create(
syncStateFactory,
syncStateFactory.Environment,
options.SynchronizationMode,
options.ConflictResolution,
e => new ContactConflictInitialSyncStateCreationStrategyAutomatic(e)),
storageDataAccess,
entityRelationDataFactory,
new InitialContactEntityMatcher(btypeIdEqualityComparer),
atypeIdEqulityComparer,
btypeIdEqualityComparer,
_totalProgressFactory,
ExceptionHandler.Instance,
NullSynchronizationContextFactory.Instance,
EqualityComparer <DateTime> .Default,
EqualityComparer <string> .Default);
return(new OutlookSynchronizer <WebResourceName, string> (synchronizer));
}
private IOutlookSynchronizer CreateContactSynchronizer(Options options, GeneralOptions generalOptions, AvailableSynchronizerComponents componentsToFill)
{
var atypeRepository = new OutlookContactRepository <ICardDavRepositoryLogger> (
_outlookSession,
options.OutlookFolderEntryId,
options.OutlookFolderStoreId,
_daslFilterProvider,
_queryFolderStrategy);
ICardDavDataAccess cardDavDataAccess;
var serverUrl = new Uri(options.CalenderUrl);
IWebDavClient webDavClientOrNullIfFileAccess = null;
if (serverUrl.Scheme == Uri.UriSchemeFile)
{
cardDavDataAccess = new FileSystemDavDataAccess(serverUrl);
}
else
{
webDavClientOrNullIfFileAccess = CreateWebDavClient(
options.UserName,
options.GetEffectivePassword(_outlookAccountPasswordProvider),
options.CalenderUrl,
generalOptions.CalDavConnectTimeout,
options.ServerAdapterType,
options.CloseAfterEachRequest,
options.PreemptiveAuthentication,
options.ForceBasicAuthentication,
options.ProxyOptions,
generalOptions.EnableClientCertificate,
generalOptions.AcceptInvalidCharsInServerResponse);
cardDavDataAccess = new CardDavDataAccess(
serverUrl,
webDavClientOrNullIfFileAccess,
contentType => contentType != "text/x-vlist");
}
componentsToFill.CardDavDataAccess = cardDavDataAccess;
var chunkedExecutor = options.IsChunkedSynchronizationEnabled ? new ChunkedExecutor(options.ChunkSize) : NullChunkedExecutor.Instance;
var cardDavRepository = new CardDavRepository(
cardDavDataAccess,
chunkedExecutor);
var btypeRepository =
new LoggingCardDavRepositoryDecorator(
cardDavRepository);
componentsToFill.CardDavEntityRepository = cardDavRepository;
var mappingParameters = GetMappingParameters <ContactMappingConfiguration> (options);
var entityMapper = new ContactEntityMapper(mappingParameters);
var entityRelationDataFactory = new OutlookContactRelationDataFactory();
var syncStateFactory = new EntitySyncStateFactory <string, DateTime, ContactItemWrapper, WebResourceName, string, vCard, ICardDavRepositoryLogger> (
entityMapper,
entityRelationDataFactory,
ExceptionHandler.Instance);
var btypeIdEqualityComparer = WebResourceName.Comparer;
var atypeIdEqulityComparer = EqualityComparer <string> .Default;
var storageDataDirectory = _profileDataDirectoryFactory(options.Id);
var storageDataAccess = new EntityRelationDataAccess <string, DateTime, OutlookContactRelationData, WebResourceName, string> (storageDataDirectory);
var atypeWriteRepository = BatchEntityRepositoryAdapter.Create(atypeRepository);
var btypeWriteRepository = BatchEntityRepositoryAdapter.Create(btypeRepository);
var synchronizer = new Synchronizer <string, DateTime, ContactItemWrapper, WebResourceName, string, vCard, ICardDavRepositoryLogger> (
atypeRepository,
btypeRepository,
atypeWriteRepository,
btypeWriteRepository,
InitialSyncStateCreationStrategyFactory <string, DateTime, ContactItemWrapper, WebResourceName, string, vCard, ICardDavRepositoryLogger> .Create(
syncStateFactory,
syncStateFactory.Environment,
options.SynchronizationMode,
options.ConflictResolution,
e => new ContactConflictInitialSyncStateCreationStrategyAutomatic(e)),
storageDataAccess,
entityRelationDataFactory,
new InitialContactEntityMatcher(btypeIdEqualityComparer),
atypeIdEqulityComparer,
btypeIdEqualityComparer,
_totalProgressFactory,
EqualityComparer <DateTime> .Default,
EqualityComparer <string> .Default,
syncStateFactory);
if (mappingParameters.MapDistributionLists)
{
CardDavEntityRepository <DistributionList, int, DistributionListSychronizationContext> bDistListRepository;
// TODO: muss auch für das file funktionieren
ICardDavDataAccess distListDataAccess = new CardDavDataAccess(
serverUrl,
webDavClientOrNullIfFileAccess,
contentType => contentType == "text/x-vlist");
componentsToFill.DistListDataAccess = distListDataAccess;
switch (mappingParameters.DistributionListType)
{
case DistributionListType.Sogo:
bDistListRepository = new SogoDistributionListRepository(distListDataAccess, chunkedExecutor);
break;
default:
throw new NotImplementedException($"{nameof(DistributionListType)} '{mappingParameters.DistributionListType}' not implemented.");
}
var distributionListSynchronizer = CreateDistListSynchronizer(options, generalOptions, bDistListRepository);
return(new OutlookSynchronizer <WebResourceName, string>(
new ContactAndDistListSynchronizer(
synchronizer,
distributionListSynchronizer,
new EmailAddressCacheDataAccess(Path.Combine(storageDataDirectory, "emailAddressCache.xml")),
btypeRepository,
storageDataAccess,
atypeRepository,
_outlookSession)));
}
else
{
return(new OutlookSynchronizer <WebResourceName, string>(
new ContextCreatingSynchronizerDecorator <string, DateTime, ContactItemWrapper, WebResourceName, string, vCard, ICardDavRepositoryLogger>(
synchronizer,
new SynchronizationContextFactory <ICardDavRepositoryLogger>(() => NullCardDavRepositoryLogger.Instance))));
}
}
public static async Task TestGoogleConnection(ICurrentOptions currentOptions, ISettingsFaultFinder settingsFaultFinder)
{
if (currentOptions.OutlookFolderType == null)
{
MessageBox.Show("Please select an Outlook folder to specify the item type for this profile", ConnectionTestCaption);
return;
}
var outlookFolderType = currentOptions.OutlookFolderType.Value;
StringBuilder errorMessageBuilder = new StringBuilder();
if (!ValidateGoogleEmailAddress(errorMessageBuilder, currentOptions.EmailAddress))
{
MessageBox.Show(errorMessageBuilder.ToString(), "The Email Address is invalid", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (outlookFolderType == OlItemType.olTaskItem)
{
await TestGoogleTaskConnection(currentOptions, errorMessageBuilder, outlookFolderType);
return;
}
if (!ValidateWebDavUrl(currentOptions.ServerUrl, errorMessageBuilder, false))
{
MessageBox.Show(errorMessageBuilder.ToString(), "The CalDav/CardDav Url is invalid", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
var enteredUri = new Uri(currentOptions.ServerUrl);
var webDavClient = currentOptions.CreateWebDavClient();
Uri autoDiscoveredUrl;
ResourceType autoDiscoveredResourceType;
if (ConnectionTester.RequiresAutoDiscovery(enteredUri))
{
var calDavDataAccess = new CalDavDataAccess(enteredUri, webDavClient);
var foundCaldendars = await calDavDataAccess.GetUserCalendarsNoThrow(false);
var cardDavDataAccess = new CardDavDataAccess(enteredUri, webDavClient);
IReadOnlyList <Tuple <Uri, string> > foundAddressBooks = await cardDavDataAccess.GetUserAddressBooksNoThrow(true);
if (foundCaldendars.Count > 0 || foundAddressBooks.Count > 0)
{
ResourceType initalResourceType;
if (currentOptions.OutlookFolderType == OlItemType.olContactItem)
{
initalResourceType = ResourceType.AddressBook;
}
else if (currentOptions.OutlookFolderType == OlItemType.olTaskItem)
{
initalResourceType = ResourceType.TaskList;
}
else
{
initalResourceType = ResourceType.Calendar;
}
using (SelectResourceForm listCalendarsForm =
new SelectResourceForm(
foundCaldendars,
foundAddressBooks,
new Tuple <string, string>[] {},
initalResourceType))
{
if (listCalendarsForm.ShowDialog() == DialogResult.OK)
{
if (listCalendarsForm.ResourceType == ResourceType.TaskList)
{
autoDiscoveredUrl = null;
currentOptions.ServerUrl = listCalendarsForm.SelectedUrl;
}
else
{
autoDiscoveredUrl = new Uri(enteredUri.GetLeftPart(UriPartial.Authority) + listCalendarsForm.SelectedUrl);
}
autoDiscoveredResourceType = listCalendarsForm.ResourceType;
}
else
{
autoDiscoveredUrl = null;
autoDiscoveredResourceType = ResourceType.None;
}
}
}
else
{
MessageBox.Show("No resources were found via autodiscovery!", ConnectionTestCaption);
autoDiscoveredUrl = null;
autoDiscoveredResourceType = ResourceType.None;
}
}
else
{
var result = await ConnectionTester.TestConnection(enteredUri, webDavClient, ResourceType.None);
if (result.ResourceType != ResourceType.None)
{
settingsFaultFinder.FixSynchronizationMode(result);
}
DisplayTestReport(
result,
currentOptions.SynchronizationMode,
currentOptions.SynchronizationModeDisplayName,
outlookFolderType);
return;
}
if (autoDiscoveredUrl != null)
{
currentOptions.ServerUrl = autoDiscoveredUrl.ToString();
var finalResult =
await ConnectionTester.TestConnection(autoDiscoveredUrl, webDavClient, autoDiscoveredResourceType);
settingsFaultFinder.FixSynchronizationMode(finalResult);
DisplayTestReport(
finalResult,
currentOptions.SynchronizationMode,
currentOptions.SynchronizationModeDisplayName,
outlookFolderType);
}
else if (outlookFolderType == OlItemType.olTaskItem)
{
TestResult result = new TestResult(ResourceType.TaskList, CalendarProperties.None, AddressBookProperties.None);
DisplayTestReport(
result,
currentOptions.SynchronizationMode,
currentOptions.SynchronizationModeDisplayName,
outlookFolderType);
}
}
