public virtual void Synchronize()
{
if (string.IsNullOrEmpty(SenderEmailAddress))
{
FormatResult(NeedSetUserAddress);
return;
}
if (UserConnection.GetIsFeatureEnabled("EmailIntegrationV2"))
{
var syncSession = ClassFactory.Get <ISyncSession>("Email", new ConstructorArgument("uc", UserConnection),
new ConstructorArgument("senderEmailAddress", SenderEmailAddress));
syncSession.Start();
return;
}
#if NETFRAMEWORK
string resultMessage;
int localChangesCount, remoteChangesCount;
ExchangeUtility.SyncExchangeItems(UserConnection, SenderEmailAddress,
() => ClassFactory.Get <BaseExchangeSyncProvider>("ExchangeEmailSyncProvider",
new ConstructorArgument("userConnection", UserConnection),
new ConstructorArgument("senderEmailAddress", SenderEmailAddress),
new ConstructorArgument("loadEmailsFromDate", LoadEmailsFromDate),
new ConstructorArgument("userSettings", null)),
out resultMessage, out localChangesCount, out remoteChangesCount,
ExchangeUtility.MailSyncProcessName);
if (!string.IsNullOrEmpty(resultMessage))
{
FormatResult(resultMessage);
return;
}
#endif
return;
}
/// <summary>
/// Returns exchange phone number value if specific <paramref name="typeKey"/>.
/// </summary>
/// <param name="typeKey"><see cref="Exchange.PhoneNumberKey"/> instance.</param>
/// <returns>
/// Exchange phone number value.
/// </returns>
/// <remarks>
/// External dependency.
/// </remarks>
protected virtual string GetPhoneNumber(Exchange.PhoneNumberKey typeKey)
{
var phone = ExchangeUtility.SafeGetValue <Exchange.PhoneNumberKey, Exchange.PhoneNumberEntry,
string>(DetailItems, typeKey);
return(phone);
}
protected override bool ContainsValue(Exchange.EmailAddressKey typeKey)
{
Exchange.EmailAddress emailAddress = ExchangeUtility.SafeGetValue <Exchange.EmailAddressKey,
Exchange.EmailAddressEntry, Exchange.EmailAddress>(DetailItems, typeKey);
if (emailAddress == null)
{
return(false);
}
return(!string.IsNullOrEmpty(emailAddress.Address));
}
protected override bool ContainsValue(Exchange.PhysicalAddressKey typeKey)
{
Exchange.PhysicalAddressEntry address = ExchangeUtility.SafeGetValue <Exchange.PhysicalAddressKey,
Exchange.PhysicalAddressEntry, Exchange.PhysicalAddressEntry>(DetailItems, typeKey);
if (address == null)
{
return(false);
}
return(!string.IsNullOrEmpty(address.City + address.CountryOrRegion + address.State + address.Street));
}
protected override void SetLocalItemValue(Entity detailItem, Exchange.EmailAddressKey typeKey)
{
Exchange.EmailAddress emailAddress = ExchangeUtility.SafeGetValue <Exchange.EmailAddressKey,
Exchange.EmailAddressEntry, Exchange.EmailAddress>(DetailItems, typeKey);
if (emailAddress == null)
{
return;
}
detailItem.SetColumnValue("Number", emailAddress.Address);
detailItem.SetColumnValue(DetailItemTypeColumnName, TypesMap[typeKey]);
}
public virtual void Synchronize()
{
LogDebug($"Synchronize exchange activities started for {SenderEmailAddress}");
if (SenderEmailAddress.IsNullOrEmpty())
{
LogDebug($"Synchronize exchange activities error {NeedSetUserAddress}");
FormatResult(NeedSetUserAddress);
return;
}
var helper = new EntitySynchronizerHelper();
helper.ClearEntitySynchronizer(UserConnection);
ExchangeUtility.DeleteEmptyActivityFromActivitySynchronizer(UserConnection, ActivityConsts.TaskTypeUId);
int appointmentLocalChangesCount, appointmentRemoteChangesCount;
string appointmentResultMessage;
LogDebug($"Synchronize exchange appointments started for {SenderEmailAddress}");
ExchangeUtility.SyncExchangeItems(UserConnection, SenderEmailAddress,
() => ClassFactory.Get <BaseExchangeSyncProvider>("ExchangeAppointmentSyncProvider",
new ConstructorArgument("userConnection", UserConnection),
new ConstructorArgument("senderEmailAddress", SenderEmailAddress)),
out appointmentResultMessage, out appointmentLocalChangesCount, out appointmentRemoteChangesCount,
ExchangeUtility.ActivitySyncProcessName);
int taskLocalChangesCount, taskRemoteChangesCount;
string taskResultMessage;
LogDebug($"Synchronize exchange tasks started for {SenderEmailAddress}");
ExchangeUtility.SyncExchangeItems(UserConnection, SenderEmailAddress,
() => ClassFactory.Get <BaseExchangeSyncProvider>("ExchangeTaskSyncProvider",
new ConstructorArgument("userConnection", UserConnection),
new ConstructorArgument("senderEmailAddress", SenderEmailAddress),
new ConstructorArgument("settings", null)),
out taskResultMessage, out taskLocalChangesCount, out taskRemoteChangesCount,
ExchangeUtility.ActivitySyncProcessName);
string resultMessage;
resultMessage = appointmentResultMessage;
if (!string.IsNullOrEmpty(taskResultMessage))
{
resultMessage += "; " + taskResultMessage;
}
if (!string.IsNullOrEmpty(resultMessage))
{
LogDebug($"Exchange activities synchronization result for {SenderEmailAddress}: {resultMessage}");
FormatResult(resultMessage);
return;
}
LogDebug($"Synchronize exchange activities ended for {SenderEmailAddress}");
}
/// <summary>
/// <see cref="ExchangeSyncProvider.EnumerateChanges"/>
/// </summary>
public override IEnumerable <IRemoteItem> EnumerateChanges(SyncContext context)
{
base.EnumerateChanges(context);
var result = new List <IRemoteItem>();
if (!UserSettings.ImportActivities)
{
return(result);
}
var folders = new List <Exchange.Folder>();
Exchange.FolderId trashFolderId = Exchange.Folder.Bind(
Service, Exchange.WellKnownFolderName.DeletedItems, Exchange.BasePropertySet.IdOnly).Id;
if (UserSettings.ImportActivitiesAll)
{
Exchange.Folder rootFolder = Exchange.Folder.Bind(Service, Exchange.WellKnownFolderName.MsgFolderRoot);
folders.GetAllFoldersByFilter(rootFolder);
folders.Add(rootFolder);
}
else
{
folders = SafeBindFolders(Service, UserSettings.RemoteFolderUIds.Keys, context);
}
Exchange.SearchFilter itemsFilter = GetItemsSearchFilters();
SyncItemSchema schema = FindSchemaBySyncValueName(typeof(ExchangeTask).Name);
foreach (Exchange.Folder folder in folders)
{
if (folder.Id.Equals(trashFolderId))
{
continue;
}
var itemView = new Exchange.ItemView(PageItemCount);
Exchange.FindItemsResults <Exchange.Item> itemCollection;
do
{
itemCollection = folder.ReadItems(itemsFilter, itemView);
foreach (Exchange.Item item in itemCollection)
{
Exchange.Task task = ExchangeUtility.SafeBindItem <Exchange.Task>(Service, item.Id);
if (task != null)
{
var remoteItem = new ExchangeTask(schema, task, TimeZone);
result.Add(remoteItem);
}
}
} while (itemCollection.MoreAvailable);
}
return(result);
}
/// <summary>
/// Fills sync item in external storage from sync item in local storage.
/// <paramref name="localItem"/>.
/// </summary>
/// <param name="localItem">Sync item from local storage.</param>
/// <param name="context">Sync context.</param>
public override void FillRemoteItem(SyncContext context, LocalItem localItem)
{
if (localItem.Entities["Activity"][0].State == SyncState.Deleted)
{
Action = SyncAction.Delete;
return;
}
var exchangeTask = (Exchange.Task)Item;
if (Action == SyncAction.None)
{
return;
}
TimeZoneInfo userTimeZone = context.UserConnection.CurrentUser.TimeZone;
var activity = GetEntityInstance <Entity>(context, localItem, "Activity");
if (IsOldActivity(activity.GetTypedColumnValue <DateTime>("DueDate"), context) || GetEntityLockedForSync(activity.PrimaryColumnValue, context))
{
Action = SyncAction.None;
return;
}
exchangeTask.Subject = activity.GetTypedColumnValue <string>("Title");
exchangeTask.StartDate =
TimeZoneInfo.ConvertTimeToUtc(activity.GetTypedColumnValue <DateTime>("StartDate"), userTimeZone).ToLocalTime();
exchangeTask.DueDate =
TimeZoneInfo.ConvertTimeToUtc(activity.GetTypedColumnValue <DateTime>("DueDate"), userTimeZone).ToLocalTime();
exchangeTask.Importance = (Exchange.Importance)ExchangeUtility.GetExchangeImportance(activity.GetTypedColumnValue <Guid>("PriorityId"));
exchangeTask.IsReminderSet = activity.GetTypedColumnValue <bool>("RemindToOwner");
if (exchangeTask.IsReminderSet)
{
var remindToOwnerDate = activity.GetTypedColumnValue <DateTime>("RemindToOwnerDate");
if (remindToOwnerDate != DateTime.MinValue)
{
exchangeTask.ReminderDueBy = TimeZoneInfo.ConvertTimeToUtc(remindToOwnerDate, userTimeZone).ToLocalTime();
}
}
exchangeTask.Body = new MessageBody(BodyType.HTML, activity.GetTypedColumnValue <string>("Notes"));
TaskStatus exchangeStatus = (TaskStatus)ExchangeUtility.GetExchangeTaskStatus(activity.GetTypedColumnValue <Guid>("StatusId"));
if (exchangeStatus == TaskStatus.Completed)
{
SetRemoteCompleteStatusAndDate(exchangeTask);
}
else
{
exchangeTask.Status = exchangeStatus;
}
exchangeTask.SetExtendedProperty(ExchangeUtilityImpl.LocalIdProperty, activity.PrimaryColumnValue.ToString());
}
private void AddAddressDetails(ICollection <ExchangeAddressDetail> exchangeAddrDetails,
Exchange.Contact contact)
{
foreach (KeyValuePair <Exchange.PhysicalAddressKey, Guid> addresstypeMap in
ExchangeAddressDetailsSynchronizer.AddressTypesMap)
{
Exchange.PhysicalAddressEntry address = ExchangeUtility.SafeGetValue <Exchange.PhysicalAddressKey,
Exchange.PhysicalAddressEntry, Exchange.PhysicalAddressEntry>(contact.PhysicalAddresses,
addresstypeMap.Key);
if (address.IsEmpty())
{
exchangeAddrDetails.Add(new ExchangeAddressDetail(address.CountryOrRegion ?? "",
address.State ?? "", address.City ?? ""));
}
}
}
/// <summary>
/// <see cref="ExchangeSyncProvider.LoadSyncItem(SyncItemSchema,string)"/>
/// </summary>
public override IRemoteItem LoadSyncItem(SyncItemSchema schema, string id)
{
ExchangeBase remoteItem = null;
Exchange.EmailMessage fullEmail = ExchangeUtility.SafeBindItem <Exchange.EmailMessage>(Service, new Exchange.ItemId(id));
if (fullEmail != null)
{
remoteItem = new ExchangeEmailMessage(schema, fullEmail, TimeZone);
}
else
{
fullEmail = new Exchange.EmailMessage(Service);
remoteItem = new ExchangeEmailMessage(schema, fullEmail, id, TimeZone)
{
State = SyncState.Deleted
};
}
return(remoteItem);
}
/// <summary>
/// <see cref="ExchangeSyncProvider.LoadSyncItem(SyncItemSchema, string)"/>
/// </summary>
public override IRemoteItem LoadSyncItem(SyncItemSchema schema, string id)
{
ExchangeBase remoteItem;
string itemId = id.Split('_')[0];
Exchange.Contact fullContact = ExchangeUtility.SafeBindItem <Exchange.Contact>(Service, new Exchange.ItemId(itemId));
if (fullContact != null)
{
remoteItem = new ExchangeContact(schema, fullContact, TimeZone);
remoteItem.Action = SyncAction.Update;
}
else
{
fullContact = new Exchange.Contact(Service);
remoteItem = new ExchangeContact(schema, fullContact, id, TimeZone)
{
State = SyncState.Deleted
};
}
return(remoteItem);
}
/// <summary>
/// Gets emails from <see cref="itemCollection"/>
/// </summary>
/// <param name="itemCollection">Finding list items from exchange.</param>
/// <param name="activityFolderIds">List folders uniqueidentifier.</param>
/// <returns></returns>
public virtual IEnumerable <IRemoteItem> GetEmailsFromCollection(Exchange.FindItemsResults <Exchange.Item> itemCollection,
List <Guid> activityFolderIds)
{
SyncItemSchema schema = FindSchemaBySyncValueName(typeof(ExchangeEmailMessage).Name);
foreach (Exchange.Item item in itemCollection)
{
if (item is Exchange.EmailMessage)
{
Exchange.PropertySet properties = new Exchange.PropertySet(Exchange.BasePropertySet.IdOnly);
Exchange.EmailMessage bindEmail = ExchangeUtility.SafeBindItem <Exchange.EmailMessage>(Service, item.Id, properties);
if (bindEmail != null)
{
var remoteItem = new ExchangeEmailMessage(schema, bindEmail, TimeZone)
{
ActivityFolderIds = activityFolderIds
};
yield return(remoteItem);
}
}
}
}
/// <summary>
/// Executes a get request to the ExchangeRate API.
/// </summary>
/// <param name="currency">The request payload passed in by the client.</param>
/// <returns>A double representing the conversion result.</returns>
public object GetCurrency(Currency currency)
{
// Get result from exchangerate API (docs here https://www.exchangerate-api.com/docs/c-sharp-currency-api).
try
{
// Prepare the URl.
string URLString = $"https://v6.exchangerate-api.com/v6/{DotNetConstants.EXCHANGE_RATE_API_KEY}/latest/{currency.SourceCurrency}";
using var webClient = new WebClient();
// Get the json result from the API.
var json = webClient.DownloadString(URLString);
// Convert it into the ExchangeResult object using NewtonSoft.
ExchangeResult result = JsonConvert.DeserializeObject <ExchangeResult>(json);
// Compute the conversion and return the result.
return(ExchangeUtility.Convert(currency, result));
}
catch (Exception ex)
{
return(ex);
}
}
public override IRemoteItem LoadSyncItem(SyncItemSchema schema, string id)
{
ExchangeBase remoteItem;
Exchange.Task task = ExchangeUtility.SafeBindItem <Exchange.Task>(Service, new Exchange.ItemId(id));
if (task != null)
{
remoteItem = new ExchangeTask(schema, task, TimeZone)
{
Action = SyncAction.Update
};
}
else
{
task = new Exchange.Task(Service);
remoteItem = new ExchangeTask(schema, task, id, TimeZone)
{
State = SyncState.Deleted
};
}
return(remoteItem);
}
/// <summary>
/// Initializes Exchange service.
/// </summary>
/// <param name="userConnection">User connection.</param>
/// <returns>New Exchange service instance.</returns>
protected virtual Exchange.ExchangeService InitializeService(UserConnection userConnection)
{
return(ExchangeUtility.CreateExchangeService(userConnection, SenderEmailAddress));
}
/// <summary>
/// Uploads emai attachments job.
/// </summary>
/// <param name="context"><see cref="SyncContext"/> instance.</param>
/// <remarks>External dependency realocation.</remarks>
protected virtual void UploadAttachmentsData(SyncContext context)
{
ExchangeUtility.UploadAttachmentsData(context.UserConnection, UserSettings.SenderEmailAddress);
}
public virtual void Load()
{
ExchangeUtility.UploadAttachmentsData(UserConnection, UserEmailAddress);
}
/// <summary>
/// Checks if contact metadata exists by <paramref name="contactId"/>
/// </summary>
/// <param name="contactId">Contact uniqueidentifier.</param>
/// <param name="userConnection"><see cref="UserConnection"/> instance.</param>
/// <returns>True if contact metadata exists. </returns>
protected virtual bool IsContactMetadataExist(Guid contactId, UserConnection userConnection)
{
return(ExchangeUtility.IsContactMetadataExist(contactId, userConnection));
}
public Exchange.Contact GetFullContact(Exchange.ItemId itemId)
{
return(ExchangeUtility.SafeBindItem <Exchange.Contact>(Service, itemId));
}
private ExchangeService GetExchangeService()
{
return(ExchangeUtility.ConnectToService(_user));
}
/// <summary>
/// Attempts to obtain a copy of this type by value identifier <paramref name="itemId"/>.
/// If the value can not be obtained, the method returns <c>null</c>.
/// </summary>
/// <typeparam name="T">Type, inheritor <see cref="Exchange.Item"/>.</typeparam>
/// <param name="service"><see cref="Exchange.ExchangeService"/> instance.</param>
/// <param name="itemId">Represents the Id of an Exchange item.</param>
/// <returns>An instance of this type, or <c>null</c>.</returns>
public virtual T SafeBindItem <T>(Exchange.ExchangeService service, Exchange.ItemId itemId)
where T : Exchange.Item
{
return(ExchangeUtility.SafeBindItem <T>(Service, itemId));
}
/// <summary>
/// <see cref="ExchangeSyncProvider.EnumerateChanges"/>
/// </summary>
public override IEnumerable <IRemoteItem> EnumerateChanges(SyncContext context)
{
base.EnumerateChanges(context);
FillFoldersList(context);
var result = new List <IRemoteItem>();
if (!UserSettings.ImportActivities)
{
return(result);
}
Exchange.SearchFilter itemsFilter = GetItemsSearchFilters(context);
SyncItemSchema schema = FindSchemaBySyncValueName(typeof(ExchangeAppointment).Name);
var needGetRecurringAppointments = NeedGetRecurringAppointments(context);
Exchange.PropertySet properties = new Exchange.PropertySet(Exchange.BasePropertySet.IdOnly);
properties.AddRange(new[] {
Exchange.ItemSchema.Subject,
Exchange.ItemSchema.LastModifiedTime,
Exchange.AppointmentSchema.Recurrence,
Exchange.AppointmentSchema.IsRecurring,
Exchange.AppointmentSchema.AppointmentType,
Exchange.AppointmentSchema.ICalUid,
Exchange.AppointmentSchema.ICalRecurrenceId,
Exchange.AppointmentSchema.Start
});
foreach (Exchange.Folder folder in Folders)
{
bool hasRecurence = false;
if (!needGetRecurringAppointments)
{
foreach (Exchange.Item item in GetCalendarItems(folder, itemsFilter))
{
Exchange.Appointment appointment = ExchangeUtility.SafeBindItem <Exchange.Appointment>(Service, item.Id, properties);
if (appointment != null)
{
var recurentAppointment = GetExchangeRecurringAppointmentsSupported(context.UserConnection) && appointment.Recurrence != null;
var isRecurringMaster = appointment.AppointmentType == Exchange.AppointmentType.RecurringMaster;
if ((!recurentAppointment || isRecurringMaster) && CheckItemInSyncPeriod(context, appointment))
{
context?.LogInfo(SyncAction.None, SyncDirection.Download, "Adding single or master appoitment {0}", appointment.Subject);
var remoteItem = CreateExchangeAppointment(schema, appointment, TimeZone);
context?.LogInfo(SyncAction.None, SyncDirection.Download, "Created ExchangeAppointment with Id {0}", remoteItem.Id);
if (isRecurringMaster)
{
context?.LogInfo(SyncAction.None, SyncDirection.Download, "Adding master appoitment {0}", appointment.Subject);
remoteItem.Action = SyncAction.CreateRecurringMaster;
}
result.Add(remoteItem);
}
hasRecurence = hasRecurence || recurentAppointment;
}
}
}
if (hasRecurence || needGetRecurringAppointments)
{
foreach (Exchange.Item item in GetAppointmentsForPeriod(context, folder))
{
context?.LogInfo(SyncAction.None, SyncDirection.Download, "Input item - Subject {0}, UniqueId - {1}", item.Subject, item.Id.UniqueId);
Exchange.Appointment appointment = ExchangeUtility.SafeBindItem <Exchange.Appointment>(Service, item.Id, properties);
context?.LogInfo(SyncAction.None, SyncDirection.Download, "Adding recurence appoitment {0}", appointment.Subject);
if (appointment != null)
{
var remoteItem = CreateExchangeAppointment(schema, appointment, TimeZone);
context?.LogInfo(SyncAction.None, SyncDirection.Download, "Created recurence ExchangeAppointment with Id {0}", remoteItem.Id);
result.Add(remoteItem);
}
}
}
}
context?.LogInfo(SyncAction.None, SyncDirection.Download, "loaded {0} items from Exchange", result.Count);
return(result);
}
protected override void SetLocalItemValue(Entity detailItem, Exchange.PhysicalAddressKey typeKey)
{
var localAddr = detailItem as ContactAddress;
if (localAddr == null)
{
return;
}
var contactProvider = Context.RemoteProvider as ExchangeContactSyncProviderImpl;
if (contactProvider == null)
{
return;
}
Exchange.PhysicalAddressEntry exchangeAddr = ExchangeUtility.SafeGetValue <Exchange.PhysicalAddressKey,
Exchange.PhysicalAddressEntry, Exchange.PhysicalAddressEntry>(DetailItems, typeKey);
if (exchangeAddr == null)
{
return;
}
Dictionary <string, AddressDetail> addressesLookupMap = (contactProvider).AddressesLookupMap;
if (addressesLookupMap == null)
{
return;
}
var address = new StringBuilder();
AppendToAddressString(address, exchangeAddr.Street);
localAddr.Zip = exchangeAddr.PostalCode;
localAddr.AddressTypeId = TypesMap[typeKey];
if (!addressesLookupMap.Any())
{
localAddr.Address = address.ToString();
return;
}
string cityName = exchangeAddr.City;
string regionName = exchangeAddr.State;
string countryName = exchangeAddr.CountryOrRegion;
string addressKey = ExchangeContactAddressDetailHelper.GetUniqueKey(exchangeAddr);
AddressDetail mapItem = default(AddressDetail);
if (addressesLookupMap.Keys.Contains(addressKey))
{
mapItem = addressesLookupMap[addressKey];
}
if (mapItem.CityId != Guid.Empty)
{
localAddr.CityId = mapItem.CityId;
}
else
{
localAddr.SetColumnValue("CityId", null);
AppendToAddressString(address, cityName);
}
if (mapItem.RegionId != Guid.Empty)
{
localAddr.RegionId = mapItem.RegionId;
}
else
{
localAddr.SetColumnValue("RegionId", null);
AppendToAddressString(address, regionName);
}
if (mapItem.CountryId != Guid.Empty)
{
localAddr.CountryId = mapItem.CountryId;
}
else
{
localAddr.SetColumnValue("CountryId", null);
AppendToAddressString(address, countryName);
}
localAddr.Address = address.ToString();
}
/// <summary>
/// Creates upload emai attachments job.
/// </summary>
/// <param name="context"><see cref="SyncContext"/> instance.</param>
/// <remarks>External dependency realocation.</remarks>
protected virtual void CreateUploadAttachmentJob(SyncContext context)
{
ExchangeUtility.CreateUploadAttachmentJob(context.UserConnection, UserSettings.SenderEmailAddress);
}
