/// <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); }