/// <summary>
/// ####### <see cref="Exchange.EmailAddressEntry"/> # ##### <see cref="Exchange.EmailAddressKey"/>
/// ## ####### ############# ######## #########.
/// </summary>
/// <param name="syncContext">######## #############.</param>
/// <param name="contactRemoteId">########## ####### ####.</param>
/// <param name="key">### ###### ######### #####, ## ######## ######## #########
/// <see cref="Exchange.EmailAddressEntry"/>.</param>
public void DeleteContactEmailAddress(SyncContext syncContext, string contactRemoteId,
Exchange.EmailAddressKey key)
{
Exchange.ExtendedPropertyDefinition[] emailAddressProperties =
_emailAddressPropertiesMap.GetExtendedPropertiesByKey(key);
var propertyGroup = new List <Exchange.ExtendedPropertyDefinition>(emailAddressProperties);
var propertySet = new Exchange.PropertySet(Exchange.BasePropertySet.IdOnly, propertyGroup);
Exchange.Item contact;
try {
contact = Exchange.Item.Bind(Service, contactRemoteId, propertySet);
} catch (Exception ex) {
syncContext.LogError(SyncAction.Create, SyncDirection.Download,
"[ExchangeContactSyncProviderImpl.DeleteContactEmailAddress]: Error loading contact with Id: {0}",
ex, contactRemoteId);
return;
}
foreach (Exchange.ExtendedPropertyDefinition prop in emailAddressProperties)
{
contact.RemoveExtendedProperty(prop);
}
try {
contact.Update(Exchange.ConflictResolutionMode.AlwaysOverwrite);
} catch (Exception ex) {
syncContext.LogError(SyncAction.Update, SyncDirection.Upload, string.Format(
"[ExchangeContactSyncProviderImpl.DeleteContactEmailAddress] Error while updating contact with Id:" +
"{0} Error details: {1}", contactRemoteId, ex.Message));
}
}
/// <summary>
/// Loads exchange appointment from exchange, filtered by related <paramref name="activityMetadata"/> to
/// activity unique identifier.
/// </summary>
/// <param name="activityMetadata">Activity instance synchronization metadata.</param>
/// <returns>If appointment with activity id found, returns <see cref="Exchange.Appointment"/> instance.
/// Otherwise returns null.</returns>
private Exchange.Appointment GetAppointmentByLocalIdProperty(SysSyncMetaData activityMetadata)
{
var localId = activityMetadata.LocalId;
var filters = new Exchange.SearchFilter.SearchFilterCollection(Exchange.LogicalOperator.And);
var customPropSetFilter = new Exchange.SearchFilter.IsEqualTo(ExchangeUtilityImpl.LocalIdProperty, localId.ToString());
filters.Add(customPropSetFilter);
foreach (var noteFolder in Folders)
{
Exchange.PropertySet idOnlyPropertySet = new Exchange.PropertySet(Exchange.BasePropertySet.IdOnly);
var itemView = new Exchange.ItemView(1)
{
PropertySet = idOnlyPropertySet
};
IEnumerable <Exchange.Item> itemCollection = GetCalendarItemsByFilter(noteFolder, filters, itemView);
if (itemCollection == null)
{
continue;
}
foreach (Exchange.Item item in itemCollection)
{
Exchange.Appointment appointment = SafeBindItem <Exchange.Appointment>(Service, item.Id);
if (appointment != null)
{
return(appointment);
}
}
}
return(null);
}
public List <ExchangeMailFolder> GetMailboxFolders(string mailServerId, string mailboxName,
string mailboxPassword, string senderEmailAddress, string folderClassName)
{
if (string.IsNullOrEmpty(mailboxPassword))
{
mailboxPassword = GetExistingMailboxPassword(senderEmailAddress, UserConnection);
}
var credentials = new Mail.Credentials {
UserName = mailboxName,
UserPassword = mailboxPassword,
ServerId = Guid.Parse(mailServerId),
UseOAuth = GetSettingsHasOauth(senderEmailAddress, UserConnection)
};
SetServerCertificateValidation();
var exchangeUtility = new ExchangeUtilityImpl();
Exchange.ExchangeService service = exchangeUtility.CreateExchangeService(UserConnection, credentials,
senderEmailAddress, true);
var filterCollection = new Exchange.SearchFilter.SearchFilterCollection(Exchange.LogicalOperator.Or);
var filter = new Exchange.SearchFilter.IsEqualTo(Exchange.FolderSchema.FolderClass, folderClassName);
var nullfilter = new Exchange.SearchFilter.Exists(Exchange.FolderSchema.FolderClass);
filterCollection.Add(filter);
filterCollection.Add(new Exchange.SearchFilter.Not(nullfilter));
string[] selectedFolders = null;
var idPropertySet = new Exchange.PropertySet(Exchange.BasePropertySet.IdOnly);
Exchange.Folder draftFolder = null;
if (folderClassName == ExchangeConsts.NoteFolderClassName)
{
Exchange.Folder inboxFolder = Exchange.Folder.Bind(service, Exchange.WellKnownFolderName.Inbox,
idPropertySet);
if (inboxFolder != null)
{
selectedFolders = new[] { inboxFolder.Id.UniqueId };
}
draftFolder = Exchange.Folder.Bind(service, Exchange.WellKnownFolderName.Drafts, idPropertySet);
}
List <ExchangeMailFolder> folders = exchangeUtility.GetHierarhicalFolderList(service,
Exchange.WellKnownFolderName.MsgFolderRoot, filterCollection, selectedFolders);
if (folders != null && folders.Any())
{
folders[0] = new ExchangeMailFolder {
Id = folders[0].Id,
Name = mailboxName,
ParentId = string.Empty,
Path = string.Empty,
Selected = false
};
if (draftFolder != null)
{
folders.Remove(folders.FirstOrDefault(e => e.Path == draftFolder.Id.UniqueId));
}
}
return(folders);
}
/// <summary>
/// <see cref="ExchangeSyncProvider.GetItemsFromFolders"/>
/// </summary>
protected override List <IRemoteItem> GetItemsFromFolders()
{
List <IRemoteItem> result = new List <IRemoteItem>();
int currentFolderIndex = 0;
if (_currentFolder != null)
{
currentFolderIndex = _folderCollection.FindIndex(x => GetFolderId(x) == GetFolderId(_currentFolder));
}
var numberSkippedFolders = Convert.ToInt32(_isCurrentFolderProcessed) + currentFolderIndex;
foreach (var noteFolder in _folderCollection.Skip(numberSkippedFolders))
{
_isCurrentFolderProcessed = false;
_currentFolder = noteFolder;
var activityFolderIds = new List <Guid>();
if (UserSettings.RootFolderId != Guid.Empty)
{
activityFolderIds.Add(UserSettings.RootFolderId);
}
var folderId = GetFolderId(noteFolder);
if (UserSettings.RemoteFolderUIds.ContainsKey(folderId))
{
activityFolderIds.Add(UserSettings.RemoteFolderUIds[folderId]);
}
Exchange.PropertySet idOnlyPropertySet = new Exchange.PropertySet(Exchange.BasePropertySet.IdOnly);
var itemView = new Exchange.ItemView(PageItemCount)
{
PropertySet = idOnlyPropertySet,
Offset = PageNumber * PageElementsCount
};
Exchange.FindItemsResults <Exchange.Item> itemCollection;
bool isMaxCountElements = false;
bool isMoreAvailable = false;
do
{
itemCollection = GetFolderItemsByFilter(noteFolder, _itemsFilterCollection, itemView);
result.AddRange(GetEmailsFromCollection(itemCollection, activityFolderIds));
isMaxCountElements = (result.Count < PageElementsCount);
isMoreAvailable = GetMoreAvailable(itemCollection);
} while (isMoreAvailable && isMaxCountElements);
if (!isMoreAvailable)
{
_isCurrentFolderProcessed = true;
PageNumber = 0;
}
if (!isMaxCountElements)
{
PageNumber++;
break;
}
}
return(result);
}
/// <summary> Updates extra parameters in exchange appointment item.</summary>
/// <param name="syncValueName">The name of the entity type.</param>
private void UpdateAppointmentExtraParameters(string syncValueName, IRemoteItem syncItem)
{
if (syncValueName == ExchangeConsts.ExchangeAppointmentClassName)
{
var exchangeAppointmentSyncItem = (ExchangeAppointment)syncItem;
var exchangeAppointment = (Exchange.Appointment)exchangeAppointmentSyncItem.Item;
var propertySet = new Exchange.PropertySet(Exchange.AppointmentSchema.ICalUid);
exchangeAppointment.Load(propertySet);
exchangeAppointmentSyncItem.UpdateExtraParameters(exchangeAppointment);
}
;
}
/// <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>
/// <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);
}
private static webServiceData.Appointment searchAppointment(SchedulingInfo schedulingInfo, webServiceData.ExchangeService service)
{
RvLogger.DebugWrite("enter searchAppointment==============");
webServiceData.Mailbox mailBox = new webServiceData.Mailbox(schedulingInfo.delegatorEmailAddr);
webServiceData.FolderId folderID = new webServiceData.FolderId(webServiceData.WellKnownFolderName.Calendar, mailBox);
webServiceData.CalendarFolder folder = webServiceData.CalendarFolder.Bind(service, folderID);
webServiceData.CalendarView view = new webServiceData.CalendarView(schedulingInfo.startDate, schedulingInfo.endDate);
webServiceData.PropertySet propertySet = new webServiceData.PropertySet(webServiceData.BasePropertySet.FirstClassProperties);
view.PropertySet = propertySet;
webServiceData.FindItemsResults<webServiceData.Appointment> results = folder.FindAppointments(view);
RvLogger.DebugWrite("results==============" + (null == results.Items ? "0" : "" + results.Items.Count));
foreach (webServiceData.Item item in results)
{
try
{
webServiceData.Appointment appointment = (webServiceData.Appointment)item;
if (string.IsNullOrEmpty(schedulingInfo.location)) schedulingInfo.location = "";
if (string.IsNullOrEmpty(appointment.Location)) appointment.Location = "";
if (string.IsNullOrEmpty(schedulingInfo.subject)) schedulingInfo.subject = "";
if (string.IsNullOrEmpty(appointment.Subject)) appointment.Subject = "";
if (schedulingInfo.location == appointment.Location
&& appointment.Subject == schedulingInfo.subject
&& 0 == appointment.Start.ToUniversalTime().CompareTo(schedulingInfo.startDate.ToUniversalTime())
&& 0 == appointment.End.ToUniversalTime().CompareTo(schedulingInfo.endDate.ToUniversalTime()))
{
return appointment;
}
}
catch (ScopiaMeetingAddInException ex)
{
throw ex;
}
}
return null;
}
public static List <IEmailMessage> GetIncomingEmails(
string address,
bool loadHtmlBody = false,
CancellationToken cancellationToken = default)
{
Contract.Requires(!String.IsNullOrEmpty(address));
var settings = GetConnectionSettings(address);
List <IEmailMessage> GetEmails()
{
var service = new EWS.ExchangeService(settings.Version)
{
Url = new Uri(settings.Url)
};
if (settings.UseDefaultCredentials)
{
service.UseDefaultCredentials = true;
}
else
{
service.Credentials = new NetworkCredential(settings.UserName, settings.Password, settings.Domain);
}
var mailbox = new EWS.Mailbox(address);
var inboxFolderId = new EWS.FolderId(EWS.WellKnownFolderName.Inbox, mailbox);
var propertySet = new EWS.PropertySet(EWS.BasePropertySet.FirstClassProperties)
{
RequestedBodyType = EWS.BodyType.Text
};
if (loadHtmlBody)
{
propertySet.Add(new EWS.ExtendedPropertyDefinition(ExtendedProperty_HtmlBody, EWS.MapiPropertyType.Binary));
}
propertySet.Add(new EWS.ExtendedPropertyDefinition(ExtendedProperty_ConversationId, EWS.MapiPropertyType.Binary));
var view = new EWS.ItemView(100)
{
OrderBy = { { EWS.ItemSchema.DateTimeReceived, EWS.SortDirection.Ascending } },
PropertySet = propertySet
};
var emails = (from item in service.FindItems(inboxFolderId, view)
let email = item as EWS.EmailMessage
where email != null
select email).ToList();
if (emails.Count > 0)
{
propertySet.Add(EWS.ItemSchema.MimeContent);
service.LoadPropertiesForItems(emails, propertySet);
}
return(emails.ConvertAll(email => {
if (email.ItemClass == "IPM.Note.SMIME")
{
using (var memoryStream = new MemoryStream(email.MimeContent.Content))
{
memoryStream.Position = 0L;
var pkcs7Mime = (ApplicationPkcs7Mime)MimeEntity.Load(memoryStream);
CryptographyContext.Register(typeof(WindowsSecureMimeContext));
pkcs7Mime.Verify(out var mimeEntity);
var multipart = (Multipart)mimeEntity;
var body = multipart.OfType <TextPart>().FirstOrDefault()?.Text;
var message = multipart.OfType <TnefPart>().FirstOrDefault()?.ConvertToMessage();
return new EmailMessage(
email,
body,
message?.Attachments
.OfType <MimePart>()
.Select(mp => {
memoryStream.SetLength(0L);
using (var contentStream = mp.Content.Open())
{
contentStream.CopyTo(memoryStream);
}
return new FileAttachment(
mp.FileName,
memoryStream.ToArray());
})
.ToArray());
}
}
else
{
return (IEmailMessage) new EmailMessage(email);
}
}));
}
var retries = 0;
while (true)
{
try
{
return(GetEmails());
}
catch when(retries < settings.Retries)
{
//await Task.Delay(settings.RetryDelay, cancellationToken);
retries++;
}
}
}
public IEnumerable <IRemoteItem> EnumerateChangesOld(SyncContext context)
{
base.EnumerateChanges(context);
var result = new List <IRemoteItem>();
var folders = new List <Exchange.Folder>();
if (UserSettings.LoadAll)
{
Exchange.Folder rootFolder = Exchange.Folder.Bind(Service, Exchange.WellKnownFolderName.MsgFolderRoot);
var filter = new Exchange.SearchFilter.IsEqualTo(
Exchange.FolderSchema.FolderClass, ExchangeConsts.NoteFolderClassName);
folders.GetAllFoldersByFilter(rootFolder, filter);
}
else
{
folders = SafeBindFolders(Service, UserSettings.RemoteFolderUIds.Keys, context);
}
var itemsFilterCollection = new Exchange.SearchFilter.SearchFilterCollection(Exchange.LogicalOperator.And);
var draftFilter = new Exchange.SearchFilter.IsNotEqualTo(Exchange.ItemSchema.IsDraft, true);
itemsFilterCollection.Add(draftFilter);
DateTime loadEmailsFromDate = LoadEmailsFromDate != DateTime.MinValue
? LoadEmailsFromDate
: UserSettings.LastSyncDate;
if (loadEmailsFromDate != DateTime.MinValue)
{
var localLastSyncDate = GetLastSyncDate(loadEmailsFromDate);
var itemsFilter = new Exchange.SearchFilter.IsGreaterThan(Exchange.ItemSchema.LastModifiedTime,
localLastSyncDate);
_itemsFilterCollection.Add(itemsFilter);
}
FilterDeprecatedFolders(ref folders);
foreach (var noteFolder in folders)
{
var activityFolderIds = new List <Guid>();
if (UserSettings.RootFolderId != Guid.Empty)
{
activityFolderIds.Add(UserSettings.RootFolderId);
}
var folderId = GetFolderId(noteFolder);
if (UserSettings.RemoteFolderUIds.ContainsKey(folderId))
{
activityFolderIds.Add(UserSettings.RemoteFolderUIds[folderId]);
}
Exchange.PropertySet idOnlyPropertySet = new Exchange.PropertySet(Exchange.BasePropertySet.IdOnly);
var itemView = new Exchange.ItemView(PageItemCount)
{
PropertySet = idOnlyPropertySet
};
Exchange.FindItemsResults <Exchange.Item> itemCollection;
do
{
itemCollection = GetFolderItemsByFilter(noteFolder, itemsFilterCollection, itemView);
if (itemCollection == null)
{
break;
}
result.AddRange(GetEmailsFromCollection(itemCollection, activityFolderIds));
} while (itemCollection.MoreAvailable);
}
return(result);
}
