/// <summary>
/// Creates the contact with categories.
/// </summary>
/// <param name="exchangeService">The exchange service.</param>
public static async Task CreateContactWithCategories(ExchangeService exchangeService)
{
string displayName = Guid.NewGuid().ToString();
Contact contact = new Contact(exchangeService);
contact.DisplayName = displayName;
contact.Department = "Dept";
contact.GivenName = "First Name";
contact.EmailAddresses.Add(new TypedEmailAddress()
{
Address = "*****@*****.**"
});
contact.Categories = new List <string>()
{
"MyContactCategory"
};
await contact.SaveAsync();
SearchFilter searchFilter = new SearchFilter.IsEqualTo(
ContactObjectSchema.DisplayName,
displayName);
ContactView contactView = new ContactView(10);
contactView.PropertySet.Add(ContactObjectSchema.Categories);
FindItemResults <Contact> contacts = await exchangeService.FindItems <Contact>(contactView, searchFilter);
Assert.AreEqual(
"MyContactCategory",
contacts.Items[0].Categories[0]);
await contacts.Items[0].DeleteAsync();
}
/// <summary>
/// CRUD operation for Outlook categories.
/// </summary>
/// <param name="exchangeService"></param>
/// <returns></returns>
public static async Task CreateReadUpdateOutlookCategory(ExchangeService exchangeService)
{
string displayName = Guid.NewGuid().ToString();
OutlookCategory category = new OutlookCategory(exchangeService);
category.Color = CategoryColor.Preset18;
category.DisplayName = displayName;
await category.SaveAsync();
FindItemResults <OutlookCategory> categories = await exchangeService.FindItems(
new OutlookCategoryView(),
null);
bool found = false;
foreach (OutlookCategory outlookCategory in categories)
{
if (outlookCategory.DisplayName == displayName)
{
found = true;
}
}
Assert.IsTrue(found);
await category.DeleteAsync();
}
/// <summary>
/// CRUD operation for event.
/// </summary>
/// <param name="exchangeServiceA"></param>
/// <param name="exchangeServiceB"></param>
/// <returns></returns>
public static async Task CreateReadUpdateDeleteEvent(ExchangeService exchangeServiceA, ExchangeService exchangeServiceB)
{
string subject = Guid.NewGuid().ToString();
Event calendarEvent = new Event(exchangeServiceA);
calendarEvent.Body = new ItemBody()
{
Content = "test",
ContentType = BodyType.Html
};
calendarEvent.Subject = subject;
calendarEvent.Start = new DateTimeTimeZone()
{
DateTime = DateTimeHelper.GetFormattedDateTime().ToString("yyyy-MM-ddThh:mm:ss"),
TimeZone = "Central European Standard Time"
};
calendarEvent.End = new DateTimeTimeZone()
{
DateTime = DateTimeHelper.GetFormattedDateTime(5).ToString("yyyy-MM-ddThh:mm:ss"),
TimeZone = "Central European Standard Time"
};
calendarEvent.Attendees = new List <Attendee>()
{
new Attendee()
{
EmailAddress = new EmailAddress()
{
Address = AppConfig.MailboxB
}
}
};
await calendarEvent.SaveAsync();
DateTime created = DateTime.Now;
Thread.Sleep(8000); // allow item to be delivered to mailbox b
SearchFilter subjectFilter = new SearchFilter.IsEqualTo(
EventObjectSchema.Subject,
subject);
FindItemResults <Event> items = await exchangeServiceB.FindItems <Event>(new EventView(), subjectFilter);
Assert.AreEqual(
1,
items.TotalCount);
Event meeting = (Event)items.Items[0];
await meeting.Decline(
"no comment",
true);
await calendarEvent.DeleteAsync();
}
/// <summary>
/// Find message call.
/// </summary>
public static async Task FindMessage(ExchangeService exchangeService)
{
string folderName = "TestFindItemFolder";
await FunctionalTestHelpers.DeleteFolderIfExist(
folderName,
exchangeService,
WellKnownFolderName.MsgFolderRoot);
MailFolder folder = await FunctionalTestHelpers.CreateFolder(
folderName,
exchangeService,
WellKnownFolderName.MsgFolderRoot);
for (int i = 0; i < 9; i++)
{
await FunctionalTestHelpers.CreateMessage(
1,
folder,
exchangeService);
}
for (int i = 0; i < 10; i++)
{
await FunctionalTestHelpers.CreateMessage(
i,
folder,
exchangeService);
}
// there are 10 "Test msg 1" and 9 others. Expecting to see
// sync 5 times.
SearchFilter subjectFilter = new SearchFilter.IsEqualTo(
MessageObjectSchema.Subject,
"Test msg 1");
MessageView mv = new MessageView(2);
FindItemResults <Message> items = null;
int counter = 0;
do
{
items = await exchangeService.FindItems(
folder.Id,
mv,
subjectFilter);
mv.Offset += mv.PageSize;
counter++;
} while (items.MoreAvailable);
Assert.AreEqual(
6,
counter);
}
/// <summary>
/// Find event items.
/// </summary>
/// <param name="exchangeService">Exchange service.</param>
/// <returns></returns>
public static async Task FindEventItems(ExchangeService exchangeService)
{
ExtendedPropertyDefinition prop = new ExtendedPropertyDefinition(
MapiPropertyType.String,
0x001A);
ViewBase itemView = new EventView();
itemView.PropertySet.Add(prop);
FindItemResults <Event> events = await exchangeService.FindItems <Event>(itemView);
}
/// <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>
/// Create, read, update, delete message.
/// </summary>
/// <param name="exchangeService">Exchange service.</param>
/// <returns></returns>
public static async Task CreateReadUpdateDeleteMessage(ExchangeService exchangeService)
{
string folderName = "TestCrudItems";
await FunctionalTestHelpers.DeleteFolderIfExist(
folderName,
exchangeService,
WellKnownFolderName.MsgFolderRoot);
MailFolder mailFolder = await FunctionalTestHelpers.CreateFolder(
folderName,
exchangeService,
WellKnownFolderName.MsgFolderRoot);
for (int i = 0; i < 10; i++)
{
Message msg = new Message(exchangeService);
msg.Subject = Guid.NewGuid().ToString();
msg.Body = new ItemBody()
{
ContentType = BodyType.Html,
Content = $"body {Guid.NewGuid().ToString()}"
};
await msg.SaveAsync(mailFolder);
}
FindItemResults <Message> items = await exchangeService.FindItems(mailFolder.Id, new MessageView(12));
Assert.AreEqual(
10,
items.TotalCount);
foreach (Message item in items)
{
item.Subject = $"Changed subject - {item.Subject}";
await item.UpdateAsync();
}
items = await exchangeService.FindItems(mailFolder.Id, new MessageView(12));
foreach (Message item in items)
{
Assert.IsTrue(
item.Subject.StartsWith("Changed subject -"));
await item.DeleteAsync();
}
}
/// <summary>
/// CRUD operations for contact.
/// </summary>
/// <param name="exchangeService"></param>
public static async Task CreateReadUpdateDeleteContact(ExchangeService exchangeService)
{
string displayName = Guid.NewGuid().ToString();
Contact contact = new Contact(exchangeService);
contact.DisplayName = displayName;
contact.Department = "Dept";
contact.GivenName = "First Name";
contact.EmailAddresses.Add(new TypedEmailAddress()
{
Address = "*****@*****.**"
});
await contact.SaveAsync();
SearchFilter searchFilter = new SearchFilter.IsEqualTo(
ContactObjectSchema.DisplayName,
displayName);
ContactView contactView = new ContactView(10);
FindItemResults <Contact> contacts = await exchangeService.FindItems <Contact>(contactView, searchFilter);
Assert.AreEqual(
1,
contacts.TotalCount);
contact.AssistantName = "Contact Assistant";
await contact.UpdateAsync();
contacts = await exchangeService.FindItems <Contact>(contactView, searchFilter);
Assert.AreEqual(
1,
contacts.TotalCount);
Assert.AreEqual(
"Contact Assistant",
contacts.Items[0].AssistantName);
await contact.DeleteAsync();
contacts = await exchangeService.FindItems <Contact>(contactView, searchFilter);
Assert.AreEqual(
0,
contacts.TotalCount);
}
/// <summary>
/// Get mail with single extended property.
/// </summary>
public static async Task GetMessageWithSingleExtendedProperties(ExchangeService exchangeService)
{
MessageView messageView = new MessageView(1);
messageView.PropertySet.Add(new ExtendedPropertyDefinition(
MapiPropertyType.String,
0x0C1F));
messageView.PropertySet.Add(MessageObjectSchema.HasAttachments);
FindItemResults <Message> findItemResults = await exchangeService.FindItems(
WellKnownFolderName.Inbox,
messageView);
foreach (Message message in findItemResults)
{
Assert.AreEqual(
1,
message.SingleValueExtendedProperties.Count);
}
messageView.Offset += messageView.PageSize;
messageView.PropertySet.Add(
new ExtendedPropertyDefinition(MapiPropertyType.String,
0x0037));
findItemResults = await exchangeService.FindItems(
WellKnownFolderName.Inbox,
messageView);
foreach (Message item in findItemResults)
{
Assert.AreEqual(
2,
item.SingleValueExtendedProperties.Count);
}
}
/// <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>
/// Sync messages
/// </summary>
public static async Task SyncMessages(ExchangeService exchangeService)
{
string folderName = "TempSyncFolder";
await FunctionalTestHelpers.DeleteFolderIfExist(
folderName,
exchangeService,
WellKnownFolderName.MsgFolderRoot);
MailFolder folder = await FunctionalTestHelpers.CreateFolder(
folderName,
exchangeService,
WellKnownFolderName.MsgFolderRoot);
for (int i = 0; i < 10; i++)
{
await FunctionalTestHelpers.CreateMessage(
i,
folder,
exchangeService);
}
string syncState = null;
MessagePropertySet propertySet = new MessagePropertySet();
propertySet.Add(MessageObjectSchema.ToRecipients);
ChangeCollection <MessageChange> syncCollection;
int counter = 0;
int numberOfMessages = 0;
do
{
syncCollection = await exchangeService.SyncFolderItems(
folder.Id,
propertySet,
syncState);
syncState = syncCollection.SyncState;
numberOfMessages += syncCollection.TotalCount;
counter++;
foreach (MessageChange itemChange in syncCollection.Items)
{
Assert.IsTrue(
itemChange.ChangeType == ChangeType.Created);
}
} while (syncCollection.MoreAvailable || counter == 4);
Assert.IsFalse(syncCollection.MoreAvailable);
Assert.AreEqual(10, numberOfMessages);
FindItemResults <Message> items = await exchangeService.FindItems(folder.Id, new MessageView(4));
for (int i = 0; i < items.TotalCount; i++)
{
Message msg = items.Items[i];
if (i < 2)
{
msg.IsRead = false;
await msg.UpdateAsync();
}
else
{
await msg.DeleteAsync();
}
}
syncCollection = await exchangeService.SyncFolderItems(
folder.Id,
propertySet,
syncState);
Assert.IsFalse(syncCollection.MoreAvailable);
Assert.IsTrue(
syncCollection.TotalCount == 4);
int changes = syncCollection.Items.Count(i => i.ChangeType == ChangeType.Deleted);
Assert.AreEqual(
2,
changes);
changes = syncCollection.Items.Count(i => i.ChangeType == ChangeType.Updated);
Assert.IsTrue(changes == 2);
await folder.DeleteAsync();
}
/// <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();
}
}
/// <summary>
/// MessageRule CRUD operation.
/// </summary>
/// <param name="exchangeService"></param>
/// <returns></returns>
public static async Task CreateReadUpdateDeleteMessageRule(ExchangeService exchangeService)
{
string ruleName = Guid.NewGuid().ToString();
MessageRule rule = new MessageRule(exchangeService);
rule.DisplayName = ruleName;
rule.Sequence = 1;
rule.IsEnabled = true;
rule.Conditions = new MessageRulePredicates()
{
SenderContains = new List <string>()
{
"testUser"
}
};
rule.Actions = new MessageRuleActions()
{
ForwardTo = new List <Recipient>()
{
new Recipient()
{
EmailAddress = new EmailAddress()
{
Address = "*****@*****.**"
}
}
},
StopProcessingRules = true
};
await rule.SaveAsync();
SearchFilter searchFilter = new SearchFilter.IsEqualTo(
MessageRuleObjectSchema.DisplayName,
ruleName);
FindItemResults <MessageRule> rules = await exchangeService.FindItems(
new MessageRuleView(),
searchFilter);
Assert.AreEqual(
1,
rules.TotalCount);
Assert.IsTrue(rules.Items[0].IsEnabled);
rule.IsEnabled = false;
await rule.UpdateAsync();
rules = await exchangeService.FindItems(
new MessageRuleView(),
searchFilter);
Assert.AreEqual(
1,
rules.TotalCount);
Assert.IsFalse(rules.Items[0].IsEnabled);
await rule.DeleteAsync();
}
/// <summary>
/// Creates the do not forward event.
/// </summary>
/// <param name="exchangeServiceA">The exchange service a.</param>
/// <param name="exchangeServiceB">The exchange service b.</param>
public static async Task CreateDoNotForwardEvent(ExchangeService exchangeServiceA, ExchangeService exchangeServiceB)
{
string subject = Guid.NewGuid().ToString();
Event calendarEvent = new Event(exchangeServiceA);
calendarEvent.Body = new ItemBody()
{
Content = "test",
ContentType = BodyType.Html
};
calendarEvent.Subject = subject;
calendarEvent.Start = new DateTimeTimeZone()
{
DateTime = DateTimeHelper.GetFormattedDateTime().ToString("yyyy-MM-ddThh:mm:ss"),
TimeZone = "Central European Standard Time"
};
calendarEvent.End = new DateTimeTimeZone()
{
DateTime = DateTimeHelper.GetFormattedDateTime(5).ToString("yyyy-MM-ddThh:mm:ss"),
TimeZone = "Central European Standard Time"
};
calendarEvent.Attendees = new List <Attendee>()
{
new Attendee()
{
EmailAddress = new EmailAddress()
{
Address = AppConfig.MailboxB
}
}
};
ExtendedPropertyDefinition doNotForwardExt = new ExtendedPropertyDefinition(MapiPropertyType.Boolean,
"DoNotForward",
new Guid("00020329-0000-0000-C000-000000000046"));
SingleValueLegacyExtendedProperty doNotForward = doNotForwardExt;
doNotForward.Value = "true";
calendarEvent.SingleValueExtendedProperties.Add(doNotForward);
await calendarEvent.SaveAsync();
Thread.Sleep(8000); // allow item to be delivered to mailbox b
SearchFilter subjectFilter = new SearchFilter.IsEqualTo(
EventObjectSchema.Subject,
subject);
EventView view = new EventView();
view.PropertySet.Expand(doNotForwardExt);
FindItemResults <Event> items = await exchangeServiceB.FindItems <Event>(view, subjectFilter);
Assert.AreEqual(
1,
items.TotalCount);
Assert.AreEqual(
doNotForward.Id,
items.Items[0].SingleValueExtendedProperties[0].Id);
Assert.AreEqual(
doNotForward.Value,
items.Items[0].SingleValueExtendedProperties[0].Value);
}
/// <summary>
/// Find message items.
/// </summary>
/// <param name="exchangeService"></param>
/// <returns></returns>
public static async Task FindContactItems(ExchangeService exchangeService)
{
ViewBase itemView = new ContactView(7);
FindItemResults <Contact> messages = await exchangeService.FindItems <Contact>(itemView);
}
