/// <summary>
/// Create folder
/// </summary>
/// <param name="folderName"></param>
/// <param name="exchangeService"></param>
/// <returns></returns>
internal static async Task<MailFolder> CreateFolder(string folderName, ExchangeService exchangeService, WellKnownFolderName folderRoot)
{
MailFolder folder = new MailFolder(exchangeService);
folder.DisplayName = folderName;
MailFolder mailFolderRoot = await exchangeService.GetAsync<MailFolder>(
new EntityPath(
folderRoot.ToString(),
typeof(MailFolder)));
await folder.SaveAsync(mailFolderRoot);
return folder;
}
/// <summary>
/// Basic CRUD operations test.
/// </summary>
/// <param name="exchangeService"></param>
public static async Task CreateReadUpdateDeleteMailFolder(ExchangeService exchangeService)
{
MailFolder inbox = await exchangeService.GetAsync <MailFolder>(
new EntityPath(WellKnownFolderName.Inbox.ToString(),
typeof(MailFolder)));
foreach (MailFolder folder in await exchangeService.FindFolders(inbox.Id, new MailFolderView(10, 0)))
{
await folder.DeleteAsync();
}
MailFolder folder1 = new MailFolder(exchangeService)
{
DisplayName = "MyTestFolder1"
};
Assert.IsNull(folder1.Id);
await folder1.SaveAsync(inbox);
Assert.IsNotNull(folder1.Id);
MailFolder folder2 = new MailFolder(exchangeService);
folder2.DisplayName = "MyTestFolder2";
Assert.IsNull(folder2.Id);
await folder2.SaveAsync(inbox);
Assert.IsNotNull(folder2.Id);
folder2 = await folder2.Move(folder1.Id);
folder1.DisplayName = "NewDisplayName";
await folder1.UpdateAsync();
Assert.AreEqual(
"NewDisplayName",
folder1.DisplayName);
Assert.AreEqual(
folder1.Id,
folder2.ParentFolderId);
await folder2.DeleteAsync();
Assert.IsNull(folder2.DisplayName);
Assert.IsNull(folder2.Id);
await folder1.DeleteAsync();
Assert.IsNull(folder1.DisplayName);
Assert.IsNull(folder1.Id);
}
public async Task Test_GetAsyncMailFolder()
{
ExchangeService exchangeService = this.GetExchangeServiceWithUrlValidatorAndConfiguredResponse(
new Uri("https://graph.microsoft.com/v1.0/Users/[email protected]/MailFolders/Inbox"),
"{ \"DisplayName\": \"Inbox\", \"Id\": \"abcd\" }");
MailFolder mailFolder = await exchangeService.GetAsync <MailFolder>(new EntityPath("Inbox", typeof(MailFolder)));
Assert.AreEqual(
"abcd",
mailFolder.Id);
Assert.IsFalse(mailFolder.IsNew);
}
/// <summary>
/// Find message items.
/// </summary>
/// <param name="exchangeService"></param>
/// <returns></returns>
public static async Task FindMessageItems(ExchangeService exchangeService)
{
MailFolder inboxFolder = await exchangeService.GetAsync <MailFolder>(
new EntityPath(
WellKnownFolderName.DeletedItems.ToString(),
typeof(MailFolder)));
SearchFilter searchFilter = new SearchFilter.IsEqualTo(
MessageObjectSchema.ParentFolderId,
inboxFolder.Id);
ViewBase itemView = new MessageView(7);
FindItemResults <Message> messages = await exchangeService.FindItems <Message>(itemView, searchFilter);
}
/// <summary>
/// Test mail folder sync.
/// </summary>
/// <param name="exchangeService"></param>
public static async Task SyncMailFolders(ExchangeService exchangeService)
{
string folder1Name = "TempSyncFolder1";
string folder2Name = "TempSyncFolder2";
MailFolder msgFolderRoot = await exchangeService.GetAsync <MailFolder>(
new EntityPath(
WellKnownFolderName.MsgFolderRoot.ToString(),
typeof(MailFolder)));
FindMailFolderResults findFolders = await exchangeService.FindFolders(
WellKnownFolderName.MsgFolderRoot,
new MailFolderView(30, 0));
foreach (MailFolder mailFolder in findFolders)
{
if (mailFolder.DisplayName == folder1Name ||
mailFolder.DisplayName == folder2Name)
{
await mailFolder.DeleteAsync();
}
}
string syncState = null;
int counter = 0;
ChangeCollection <MailFolderChange> sync;
do
{
sync = await exchangeService.SyncFolderHierarchy(null, syncState);
syncState = sync.SyncState;
counter++;
} while (sync.MoreAvailable || counter == 4);
Assert.IsFalse(sync.MoreAvailable);
MailFolder folder1 = new MailFolder(exchangeService);
folder1.DisplayName = folder1Name;
await folder1.SaveAsync(msgFolderRoot);
MailFolder folder2 = new MailFolder(exchangeService);
folder2.DisplayName = folder2Name;
await folder2.SaveAsync(msgFolderRoot);
sync = await exchangeService.SyncFolderHierarchy(null, syncState);
syncState = sync.SyncState;
Assert.AreEqual(
2,
sync.TotalCount);
foreach (MailFolderChange change in sync)
{
Assert.IsTrue(change.ChangeType == ChangeType.Created);
}
await folder1.DeleteAsync();
await folder2.DeleteAsync();
sync = await exchangeService.SyncFolderHierarchy(null, syncState);
Assert.IsTrue(sync.TotalCount == 2);
foreach (MailFolderChange change in sync)
{
Assert.IsTrue(change.ChangeType == ChangeType.Deleted);
}
}
/// <summary>
/// Send message from mailbox a to mailbox b
/// </summary>
public static async Task SendMessageFromMailboxAToMailboxB(ExchangeService exchangeServiceA, ExchangeService exchangeServiceB)
{
string messageSubject = Guid.NewGuid().ToString();
Message message = new Message(exchangeServiceA)
{
Subject = messageSubject,
Body = new ItemBody()
{
Content = "Test message",
ContentType = BodyType.Html
}
};
message.ToRecipients = new List <Recipient>
{
new Recipient()
{
EmailAddress = new EmailAddress()
{
Address = AppConfig.MailboxB
}
}
};
MailFolder draftFolder = await exchangeServiceA.GetAsync <MailFolder>(
new EntityPath(WellKnownFolderName.Drafts.ToString(),
typeof(MailFolder)));
await message.SaveAsync(draftFolder);
await message.Send();
Thread.Sleep(6000); // allow some time for email to be delivered
MessageView messageView = new MessageView(10);
SearchFilter subjectFilter = new SearchFilter.IsEqualTo(
MessageObjectSchema.Subject,
messageSubject);
FindItemResults <Message> mailboxBMessages = await exchangeServiceB.FindItems(
"Inbox",
messageView,
subjectFilter);
Assert.AreEqual(1, mailboxBMessages.TotalCount);
Message msg = mailboxBMessages.Items[0];
await msg.Reply("this is my reply");
Thread.Sleep(8000); // allow some time for email to be delivered
subjectFilter = new SearchFilter.IsEqualTo(
MessageObjectSchema.Subject,
$"Re: {messageSubject}");
FindItemResults <Message> mailboxAMessages = await exchangeServiceA.FindItems(
"Inbox",
messageView,
subjectFilter);
Assert.IsTrue(mailboxAMessages.TotalCount == 1);
await mailboxAMessages.Items[0].DeleteAsync();
}
/// <summary>
/// Sends the message with extended property.
/// </summary>
/// <param name="exchangeServiceA">The exchange service a.</param>
/// <param name="exchangeServiceB">The exchange service b.</param>
public static async Task SendMessageWithExtendedProperty(ExchangeService exchangeServiceA, ExchangeService exchangeServiceB)
{
string messageSubject = Guid.NewGuid().ToString();
Message message = new Message(exchangeServiceA)
{
Subject = messageSubject,
Body = new ItemBody()
{
Content = "Test message",
ContentType = BodyType.Html
}
};
message.ToRecipients = new List <Recipient>
{
new Recipient()
{
EmailAddress = new EmailAddress()
{
Address = AppConfig.MailboxB
}
}
};
ExtendedPropertyDefinition extendedPropertyDefinition = new ExtendedPropertyDefinition(
MapiPropertyType.String,
"MyIdProp",
Guid.NewGuid());
string testValue = Guid.NewGuid().ToString();
SingleValueLegacyExtendedProperty singleValueLegacyExtendedProperty = (SingleValueLegacyExtendedProperty)extendedPropertyDefinition;
singleValueLegacyExtendedProperty.Value = testValue;
message.SingleValueExtendedProperties.Add(singleValueLegacyExtendedProperty);
MailFolder draftFolder = await exchangeServiceA.GetAsync <MailFolder>(
new EntityPath(WellKnownFolderName.Drafts.ToString(),
typeof(MailFolder)));
await message.SaveAsync(draftFolder);
await message.Send();
Thread.Sleep(6000); // allow some time for email to be delivered
MessageView messageView = new MessageView(10);
messageView.PropertySet.Expand(extendedPropertyDefinition);
SearchFilter subjectFilter = new SearchFilter.IsEqualTo(
MessageObjectSchema.Subject,
messageSubject);
FindItemResults <Message> mailboxBMessages = await exchangeServiceB.FindItems(
"Inbox",
messageView,
subjectFilter);
Assert.AreEqual(
1,
mailboxBMessages.TotalCount);
Assert.AreEqual(
testValue,
mailboxBMessages.Items[0].SingleValueExtendedProperties[0].Value);
}
/// <summary>
/// CRUD operation against extended properties.
/// </summary>
/// <param name="exchangeService">Exchange service.</param>
public static async Task CreateReadUpdateDeleteExtendedProperties(ExchangeService exchangeService)
{
const string extendedPropertyGuid = "4d557659-9e3f-405e-8f6d-86d2d9d5c630";
string subject = Guid.NewGuid().ToString();
MailFolder inbox = await exchangeService.GetAsync <MailFolder>(new EntityPath("Inbox", typeof(MailFolder)));
Message msg = new Message(exchangeService);
msg.Subject = subject;
msg.SingleValueExtendedProperties.Add(new SingleValueLegacyExtendedProperty()
{
Id = $"String {extendedPropertyGuid} Name Blah",
Value = "BlahValue"
});
msg.MultiValueExtendedProperties.Add(new MultiValueLegacyExtendedProperty()
{
Id = $"StringArray {extendedPropertyGuid} Name BlahArray",
Value = new List <string>()
{
"A",
"B",
"C"
}
});
await msg.SaveAsync(inbox);
MessageView msgView = new MessageView(1);
msgView.PropertySet.Add(new ExtendedPropertyDefinition(
MapiPropertyType.String,
"Blah",
new Guid(extendedPropertyGuid)));
msgView.PropertySet.Add(new ExtendedPropertyDefinition(
MapiPropertyType.StringArray,
"BlahArray",
new Guid(extendedPropertyGuid)));
SearchFilter filter = new SearchFilter.IsEqualTo(
MessageObjectSchema.Subject,
subject);
FindItemResults <Message> findItemsResults = await exchangeService.FindItems(
WellKnownFolderName.Inbox.ToString(),
msgView,
filter);
foreach (Message item in findItemsResults)
{
msg = (Message)item;
Assert.AreEqual(
1,
msg.SingleValueExtendedProperties.Count);
Assert.AreEqual(
1,
msg.MultiValueExtendedProperties.Count);
await msg.DeleteAsync();
}
}