public async Task <List <EwsItemIdentifier> > EnumerateFolderContentAsync(EwsFolderIdentifier identifier, EwsItemType itemType = EwsItemType.Task)
{
var parameter = new EnumerateFolderContentParameter {
FolderIdentifier = identifier
};
var command = new EnumerateFolderContentCommand(parameter, this.settings);
var result = await command.Execute();
var identifiers = result.Data.ItemIdentifiers;
if (itemType == EwsItemType.Item)
{
// remove from the returned item identifiers those that are in the 'Deleted Items' folders
if (identifiers != null && cachedFolderIdentifiersResult != null && cachedFolderIdentifiersResult.DeletedItemsFolderIdentifier != null && identifier != cachedFolderIdentifiersResult.DeletedItemsFolderIdentifier)
{
int countBefore = identifiers.Count;
identifiers = identifiers.Where(id => id.ParentFolderId != cachedFolderIdentifiersResult.DeletedItemsFolderIdentifier.Id).ToList();
if (identifiers.Count != countBefore)
{
LogService.Log("EwsSyncServer", $"Removed {countBefore - identifiers.Count} identifiers that are in the 'Delete Folder' folder");
}
}
}
return(identifiers);
}
public async Task <EwsTask> GetTask(string subject, EwsFolderIdentifier folderIdentifier)
{
var itemIdentifiers = await this.EnumerateFolderContentAsync(folderIdentifier, EwsItemType.Task);
var tasks = await this.DownloadFolderContentAsync(itemIdentifiers, EwsItemType.Task);
var task = tasks.FirstOrDefault(t => t.Subject == subject);
return(task);
}
public async Task <FindFolderResult> GetSubFoldersAsync(EwsFolderIdentifier identifier)
{
var parameter = new FindFolderParameter {
ParentFolderIdentifier = identifier
};
var command = new FindFolderCommand(parameter, this.settings);
var result = await command.Execute();
return(result.Data);
}
public static string GetXmlForFolderIdentifier(EwsFolderIdentifier identifier)
{
const string template = "<t:{0} Id='{1}' />";
if (identifier.IsDistinguishedFolderId)
{
return(string.Format(template, "DistinguishedFolderId", identifier.Id));
}
else
{
return(string.Format(template, "FolderId", identifier.Id));
}
}
public async Task <CreateEmailResult> CreateEmailAsync(EwsFolderIdentifier folderIdentifier, string subject, string body, string recipient)
{
var parameter = new CreateEmailParameter(folderIdentifier)
{
Subject = subject, Body = body, Recipient = recipient
};
var command = new CreateEmailCommand(parameter, this.settings);
var result = await command.Execute();
return(result.Data);
}
public CreateItemsParameter(IEnumerable <EwsTask> tasks, EwsFolderIdentifier parentFolder)
{
if (tasks == null)
{
throw new ArgumentNullException("tasks");
}
if (parentFolder == null)
{
throw new ArgumentNullException("parentFolder");
}
this.Tasks = new List <EwsTask>(tasks);
this.ParentFolder = parentFolder;
}
protected override void ParseResponseCore(List <EwsResponseMessage> responseMessages)
{
var identifiers = new List <EwsFolderIdentifier>();
foreach (var responseMessage in responseMessages.Select(m => m.Content))
{
foreach (var folder in responseMessage.XGetChildrenOf("Folders"))
{
string id = folder.XGetChildNodeAttributeValue <string>("FolderId", "Id");
string changeKey = folder.XGetChildNodeAttributeValue <string>("FolderId", "ChangeKey");
string displayName = folder.XGetChildValue <string>("DisplayName");
int totalCount = folder.XGetChildValue <int>("TotalCount");
int childFolderCount = folder.XGetChildValue <int>("ChildFolderCount");
int unreadCount = folder.XGetChildValue <int>("UnreadCount");
identifiers.Add(new EwsFolderIdentifier(id, changeKey, displayName, totalCount, childFolderCount, unreadCount));
}
}
if (identifiers.Count == 0)
{
throw new CommandResponseException("No folder identifiers were found");
}
this.TaskFolderIdentifier = identifiers[0];
if (identifiers.Count > 0)
{
this.DeletedItemsFolderIdentifier = identifiers[1];
}
if (identifiers.Count > 1)
{
this.DraftItemsFolderIdentifier = identifiers[2];
}
if (identifiers.Count > 2)
{
this.InboxFolderIdentifier = identifiers[3];
}
}
public async Task <EwsTask> CreateFlaggedItem(string subject)
{
// setup
var createResult = await this.server.CreateEmailAsync(EwsKnownFolderIdentifiers.Inbox, subject, "world", "*****@*****.**");
Assert.IsNotNull(createResult);
this.searchFolderIdentifier = await this.service.EnsureSearchFolderAsync(this.server);
Assert.IsNotNull(this.searchFolderIdentifier);
var ewsTask = new EwsTask
{
Type = EwsItemType.Item,
Id = createResult.Identifiers[0].Id,
ChangeKey = createResult.Identifiers[0].ChangeKey,
ParentFolderId = createResult.Identifiers[0].ParentFolderId,
ParentFolderChangeKey = createResult.Identifiers[0].ParentFolderChangeKey,
DueDate = DateTime.Now.Date,
Categories = new[] { "cat1", "cat2 " },
Changes = EwsFields.DueDate | EwsFields.Categories
};
// act
var updateResult = await this.server.UpdateItemAsync(ewsTask);
// check
Assert.IsNotNull(updateResult);
Assert.AreEqual(1, updateResult.Identifiers.Count);
Assert.AreEqual(ewsTask.Id, updateResult.Identifiers[0].Id);
ewsTask.ChangeKey = updateResult.Identifiers[0].ChangeKey;
return(ewsTask);
}
public CreateEmailParameter(EwsFolderIdentifier parentFolder)
{
this.ParentFolder = parentFolder;
}
public async Task <CreateFolderResult> CreateFoldersAsync(IEnumerable <string> names, EwsFolderIdentifier identifier)
{
var parameter = new CreateFolderParameter {
ParentFolderIdentifier = identifier
};
parameter.Names.AddRange(names);
var command = new CreateFolderCommand(parameter, this.settings);
var result = await command.Execute();
return(result.Data);
}
public async Task <CreateItemsResult> CreateItemAsync(IEnumerable <EwsTask> tasks, EwsFolderIdentifier parentFolder = null)
{
if (parentFolder == null)
{
parentFolder = EwsKnownFolderIdentifiers.Tasks;
}
var command = new CreateItemsCommand(new CreateItemsParameter(tasks, parentFolder), this.settings);
var result = await command.Execute();
return(result.Data);
}
public async Task <CreateItemsResult> CreateItemAsync(EwsTask task, EwsFolderIdentifier parentFolder = null)
{
return(await this.CreateItemAsync(new[] { task }, parentFolder));
}
private async Task PushLocalChanges(ExchangeChangeSet changeSet, EwsSyncServer server, List <ExchangeMapId> mapId, EwsFolderIdentifier folder)
{
// send local add content
if (changeSet.AddedTasks.Count > 0)
{
var ewsTasks = changeSet.AddedTasks.Select(exchangeTask => exchangeTask.BuildEwsTask()).ToList();
var createItemResult = await server.CreateItemAsync(ewsTasks, folder);
if (changeSet.AddedTasks.Count == createItemResult.Identifiers.Count)
{
for (int i = 0; i < createItemResult.Identifiers.Count; i++)
{
var identifier = createItemResult.Identifiers[i];
if (identifier.IsValid)
{
mapId.Add(new ExchangeMapId {
LocalId = changeSet.AddedTasks[i].LocalId, ExchangeId = identifier.GetFullId()
});
}
else
{
LogService.Log("EwsSyncService", "Error while creating task: " + changeSet.AddedTasks[i].Subject + " error: " + identifier.ErrorMessage);
}
}
}
else
{
LogService.Log("EwsSyncService", string.Format("Request to create {0} items but result only has {1} items", changeSet.AddedTasks.Count, createItemResult.Identifiers.Count));
}
}
// send local modification content
if (changeSet.ModifiedTasks.Count > 0)
{
var ewsTasks = changeSet.ModifiedTasks.Select(exchangeTask => exchangeTask.BuildEwsTask()).ToList();
var updateItemResult = await server.UpdateItemsAsync(ewsTasks);
// todo ews: we don't update change key here... not optimal because then we're going to ask
// the server to enumerate items, we will find different change keys for update items and so
// we're going to download them again from the server
}
// send local delete content
if (changeSet.DeletedTasks.Count > 0)
{
var ewsIdentifiers = new List <EwsItemIdentifier>();
foreach (var deletedAsset in changeSet.DeletedTasks)
{
ewsIdentifiers.Add(deletedAsset.Id.GetEwsItemIdentifier());
}
await server.DeleteItemsAsync(ewsIdentifiers);
}
}
private async Task <List <EwsItemIdentifier> > ApplyRemoteChanges(ExchangeChangeSet changeSet, EwsSyncServer server, List <ExchangeMapId> mapId, EwsFolderIdentifier folderIdentifier, EwsItemType ewsItemType)
{
// enumerate remote content
var remoteIdentifiers = await server.EnumerateFolderContentAsync(folderIdentifier, ewsItemType);
var editedItems = new List <EwsItemIdentifier>();
var newItems = new List <EwsItemIdentifier>();
// check for remote identifiers that have a new change key (ie. updated elements in Exchange)
foreach (var task in this.workbook.Tasks.Where(t => t.SyncId != null))
{
// check if we can find this task that exists in the workbook in the remote identifiers
var remoteId = remoteIdentifiers.FirstOrDefault(i => i.Id == task.SyncId.GetId());
// we find this task in the remote identifiers, check if the change key has changed since last sync
if (remoteId != null && remoteId.ChangeKey != task.SyncId.GetEwsItemIdentifier().ChangeKey)
{
// local item found on server with a different ChangeKey because it was updated => update
editedItems.Add(new EwsItemIdentifier(remoteId.Id, remoteId.ChangeKey));
}
}
// check for remote identifiers that we don't have in the workbook and that were not added during this sync operation
foreach (var identifier in remoteIdentifiers.Where(i => mapId.All(id => id.ExchangeId != null && id.ExchangeId.GetId() != i.Id)))
{
var task = this.workbook.Tasks.Where(t => t.SyncId != null).FirstOrDefault(t => t.SyncId.GetId() == identifier.Id);
if (task == null)
{
// item found on server but not locally => new item
newItems.Add(identifier);
}
}
var items = new List <EwsItemIdentifier>();
items.AddRange(editedItems);
items.AddRange(newItems);
var ewsTasks = await server.DownloadFolderContentAsync(items, ewsItemType);
foreach (var ewsTask in ewsTasks)
{
if (editedItems.Any(i => i.Id == ewsTask.Id))
{
changeSet.ModifiedTasks.Add(ewsTask.BuildExchangeTask());
}
else if (newItems.Any(i => i.Id == ewsTask.Id))
{
changeSet.AddedTasks.Add(ewsTask.BuildExchangeTask());
}
else
{
throw new NotSupportedException();
}
}
return(remoteIdentifiers);
}
