public static Task FindTaskBySubject(ExchangeService service, string Subject)
{
// Specify the folder to search, and limit the properties returned in the result.
TasksFolder tasksfolder = TasksFolder.Bind(service,
WellKnownFolderName.Tasks,
new PropertySet(BasePropertySet.IdOnly, FolderSchema.TotalCount));
// Set the number of items to the smaller of the number of items in the Contacts folder or 1000.
int numItems = tasksfolder.TotalCount < 1000 ? tasksfolder.TotalCount : 1000;
// Instantiate the item view with the number of items to retrieve from the contacts folder.
ItemView view = new ItemView(numItems);
// To keep the request smaller, send only the display name.
view.PropertySet = new PropertySet(BasePropertySet.IdOnly, TaskSchema.Subject);
// Create a searchfilter to check the subject of the tasks.
SearchFilter.IsEqualTo filter = new SearchFilter.IsEqualTo(TaskSchema.Subject, Subject);
// Retrieve the items in the Tasks folder with the properties you selected.
FindItemsResults <Item> taskItems = service.FindItems(WellKnownFolderName.Tasks, filter, view);
// If the subject of the task matches only one item, return that task item.
if (taskItems.Count() == 1)
{
return((Task)taskItems.Items[0]);
}
// No tasks, or more than one, were found.
else
{
return(null);
}
}
/// <summary>
/// Search for an item in an exchange mail box
/// </summary>
/// <param name="service">Service instance</param>
/// <param name="id">Unique item id</param>
/// <returns>Item instance if exists</returns>
public Item GetItem(ExchangeService service, Guid id)
{
// Create search filter
var filter = new SearchFilter.IsEqualTo(ExchangeExtendedProperty.SimplicIdDefinition, id.ToString());
var itemView = new ItemView(1);
var folders = new[]
{
WellKnownFolderName.Root,
WellKnownFolderName.Calendar,
WellKnownFolderName.Contacts,
WellKnownFolderName.Notes,
WellKnownFolderName.PublicFoldersRoot,
WellKnownFolderName.Tasks
};
// Search entry
foreach (var folder in folders)
{
var result = service.FindItems(folder, filter, itemView);
if (result.Any())
{
var itemInstance = result.FirstOrDefault();
if (itemInstance != null)
{
return(itemInstance);
}
}
}
return(null);
}
public void CreateMeeting(AppointmentModel data)
{
try
{
ExchangeService service = new ExchangeService(ExchangeVersion.Exchange2010_SP1);
SearchFilter sfSearchFilter = new SearchFilter.IsEqualTo(EmailMessageSchema.IsRead, false);
service.UseDefaultCredentials = true;
service.AutodiscoverUrl(Session.UserData.email, adAutoDiscoCallBack);
Appointment meeting = new Appointment(service);
meeting.Subject = data.Subject;
meeting.Body = new EmailTemplate().MeetingMeghivo(data.interview.projekt_megnevezes, data.interview.date_start + " " + data.interview.time_start + " - " + data.interview.time_end, data.interview.helyszin, data.interview.jelolt_megnevezes);
DateTime date_start = DateHandler.GenerateFromString(data.Start, data.Time_start);
DateTime date_end = DateHandler.GenerateFromString(data.Start, data.Time_end);
meeting.Start = date_start;
meeting.End = date_end;
meeting.Location = data.Location;
foreach (var attendee in data.Attendees)
{
meeting.RequiredAttendees.Add(attendee);
}
meeting.ReminderMinutesBeforeStart = 30;
meeting.Save(SendInvitationsMode.SendToAllAndSaveCopy);
Item item = Item.Bind(service, meeting.Id, new PropertySet(ItemSchema.Subject));
}
catch (Exception e)
{
MessageBox.Show("Sikertelen létrehozás! \n\n Error: \n" + e);
}
}
/// <summary>
/// Provides a record-by-record processing functionality for the cmdlet.
/// </summary>
protected override void ProcessRecord()
{
// Create the Exchange Service Object and auth with bearer token
ExchangeService exchangeService = new ExchangeService(new AuthenticationProvider(), this.SmtpAddress, RestEnvironment.OutlookBeta);
MailFolder mailFolder = new MailFolder(exchangeService)
{
DisplayName = this.FolderName
};
mailFolder.Save(this.FolderRoot);
FolderView folderView = new FolderView(10);
FindFoldersResults findFoldersResults = null;
do
{
// Find the new folder and output the result
SearchFilter searchFilter = new SearchFilter.IsEqualTo(MailFolderObjectSchema.DisplayName, mailFolder.DisplayName);
findFoldersResults = exchangeService.FindFolders(this.FolderRoot, searchFilter, folderView);
folderView.Offset += folderView.PageSize;
foreach (MailFolder folder in findFoldersResults)
{
this.WriteObject(new PSObject(folder));
}
}while (findFoldersResults.MoreAvailable);
}
/// <summary>
/// Sync folder hierarchy.
/// </summary>
/// <param name="exchangeService">Exchange service.</param>
/// <returns></returns>
public static async Task SyncFolderHierarchy(ExchangeService exchangeService)
{
ChangeCollection <MailFolderChange> folderChange = null;
string syncState = null;
do
{
folderChange = await exchangeService.SyncFolderHierarchy(null, syncState);
syncState = folderChange.SyncState;
foreach (MailFolderChange mailFolderChange in folderChange.Items)
{
Assert.AreEqual(
ChangeType.Created,
mailFolderChange.ChangeType);
}
} while (folderChange.MoreAvailable);
SearchFilter inbox = new SearchFilter.IsEqualTo(MailFolderObjectSchema.DisplayName, "Inbox");
FindMailFolderResults result =
await exchangeService.FindFolders(WellKnownFolderName.MsgFolderRoot, inbox, new MailFolderView());
MailFolder mf = new MailFolder(exchangeService);
mf.DisplayName = "kakakoko";
await mf.SaveAsync(result.MailFolders[0]);
do
{
folderChange = await exchangeService.SyncFolderHierarchy(null, syncState);
syncState = folderChange.SyncState;
Assert.AreEqual(
1,
folderChange.TotalCount);
Assert.AreEqual(
ChangeType.Created,
folderChange.Items[0].ChangeType);
} while (folderChange.MoreAvailable);
await mf.DeleteAsync();
do
{
folderChange = await exchangeService.SyncFolderHierarchy(null, syncState);
syncState = folderChange.SyncState;
Assert.AreEqual(
1,
folderChange.TotalCount);
Assert.AreEqual(
ChangeType.Deleted,
folderChange.Items[0].ChangeType);
} while (folderChange.MoreAvailable);
}
private FindItemsResults <Item> TimedFindItemsAllItemsSearch(string conversationId, ExchangeService exchangeService = null)
{
if (exchangeService == null)
{
exchangeService = _service;
}
ItemView view = new ItemView(100, 0, OffsetBasePoint.Beginning);
view.PropertySet = new PropertySet(BasePropertySet.IdOnly, EmailMessageSchema.ConversationId);
view.Traversal = ItemTraversal.Shallow;
SearchFilter searchFilter = new SearchFilter.IsEqualTo(EmailMessageSchema.ConversationId, conversationId);
SleepIfThrottled();
FindItemsResults <Item> results = null;
long startTicks = DateTime.Now.Ticks;
try
{
results = exchangeService.FindItems(AllItemsFolderId(exchangeService), searchFilter, view);
}
catch (Exception ex)
{
Throttled(ex);
}
finally
{
long endTicks = DateTime.Now.Ticks;
_stats.AddStat("FindItemsAllItemsSearch", endTicks - startTicks);
}
return(results);
}
private bool UnreadAutopsyRequestExist()
{
bool result = false;
ServicePointManager.ServerCertificateValidationCallback = CertificateValidationCallBack;
ExchangeService service = new ExchangeService(ExchangeVersion.Exchange2007_SP1);
service.Credentials = new WebCredentials("ypiilab\\histology", "Let'sMakeSlides");
service.TraceEnabled = true;
service.TraceFlags = TraceFlags.All;
service.AutodiscoverUrl("*****@*****.**", RedirectionUrlValidationCallback);
SearchFilter searchFilter = new SearchFilter.IsEqualTo(EmailMessageSchema.IsRead, false);
List <SearchFilter> searchFilterCollection = new List <SearchFilter>();
searchFilterCollection.Add(searchFilter);
ItemView view = new ItemView(50);
view.PropertySet = new PropertySet(BasePropertySet.IdOnly, ItemSchema.Subject, ItemSchema.DateTimeReceived);
view.OrderBy.Add(ItemSchema.DateTimeReceived, SortDirection.Descending);
view.Traversal = ItemTraversal.Shallow;
FindItemsResults <Item> findResults = service.FindItems(WellKnownFolderName.Inbox, searchFilter, view);
if (findResults.Items.Count > 0)
{
result = true;
}
return(result);
}
public List <CalendarEvent> GetEvents(string calendarName, DateTime fromDate, DateTime toDate)
{
ExchangeService service = new ExchangeService(ExchangeVersion.Exchange2010);
service.Credentials = new WebCredentials(_username, _password);
service.Url = new Uri(_exchangeUrl);
var folderView = new FolderView(100);
folderView.PropertySet = new PropertySet(BasePropertySet.IdOnly);
folderView.PropertySet.Add(FolderSchema.DisplayName);
folderView.Traversal = FolderTraversal.Deep;
var searchFilter = new SearchFilter.IsEqualTo(FolderSchema.FolderClass, "IPF.Appointment");
var foldersResults = service.FindFolders(WellKnownFolderName.Root, searchFilter, folderView);
var calendar = foldersResults.Where(f => f.DisplayName == calendarName).Cast <CalendarFolder>().FirstOrDefault();
if (calendar == null)
{
return(new List <CalendarEvent>());
}
var cView = new CalendarView(fromDate, toDate, 50);
cView.PropertySet = new PropertySet(ItemSchema.Subject, AppointmentSchema.Start, AppointmentSchema.End, ItemSchema.Id);
var appointments = calendar.FindAppointments(cView).ToList();
return(appointments.Select(x => new CalendarEvent
{
Id = x.Id.UniqueId,
DateFrom = x.Start,
DateTo = x.End,
Duration = Convert.ToDecimal((x.End - x.Start).TotalHours),
Subject = x.Subject
}).ToList());
}
public IEnumerable <EmailMessageItem> GetUnreadMessages()
{
LoginToExchangeService();
var searchFilter = new SearchFilter.IsEqualTo(EmailMessageSchema.IsRead, false);
var view = new ItemView(50)
{
PropertySet = new PropertySet(BasePropertySet.FirstClassProperties, ItemSchema.Subject, ItemSchema.DateTimeReceived),
Traversal = ItemTraversal.Shallow
};
view.OrderBy.Add(ItemSchema.DateTimeReceived, SortDirection.Descending);
var messages = _exchangeService.FindItems(WellKnownFolderName.Inbox, searchFilter, view).Items
.OfType <EmailMessage>()
.Select(n => new EmailMessageItem
{
MessageId = n.Id.UniqueId,
Subject = n.Subject.Trim()
})
.Where(n => new Regex(_settingsService.SubjectRegexFilter).IsMatch(n.Subject))
.ToList();
return(messages);
}
public static FolderId FindFolder(Microsoft.Exchange.WebServices.Data.ExchangeService service)
{
var resultid = new FolderId("0");
var responseview = new FolderView(1);
var filter = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, "sync-adressen");
var folderresponse = service.FindFolders(WellKnownFolderName.PublicFoldersRoot, filter, responseview);
if (folderresponse.Count() == 1)
{
var responseview2 = new FolderView(1);
var filter2 = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, "sync-contacten");
var folderresponse2 = service.FindFolders(folderresponse.First().Id, filter2, responseview2);
if (folderresponse2.Count() == 1)
{
var responseview3 = new FolderView(1);
var filter3 = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, "syncContacts");
var folderresponse3 = service.FindFolders(folderresponse2.First().Id, filter3, responseview3);
if (folderresponse3.Count() == 1)
{
resultid = folderresponse3.First().Id;
}
}
}
return(resultid);
}
/// <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>
/// Check if there's the duplicate appointment basing the Subject.
/// </summary>
private static Boolean HaveDuplicateAppointment(ExchangeService service, String appointmentSubject)
{
if (service == null || String.IsNullOrWhiteSpace(appointmentSubject))
{
return(true);
}
SearchFilter.RelationalFilter searchFilter =
new SearchFilter.IsEqualTo(FolderSchema.DisplayName, "Calendar");
Folder calendar = GetFolder(service, searchFilter);
const Int32 pageSize = 10;
ItemView itemView = new ItemView(pageSize);
PropertySet propertySet = new PropertySet(BasePropertySet.IdOnly);
itemView.PropertySet = propertySet;
searchFilter = new SearchFilter.IsEqualTo(AppointmentSchema.Subject, appointmentSubject);
FindItemsResults <Item> findResults = calendar.FindItems(searchFilter, itemView);
if (findResults.TotalCount > 0)
{
return(true);
}
return(false);
}
public static Contact FindContactByDisplayName(ExchangeService service, string DisplayName)
{
// Get the number of items in the Contacts folder. To keep the response smaller, request only the TotalCount property.
ContactsFolder contactsfolder = ContactsFolder.Bind(service,
WellKnownFolderName.Contacts,
new PropertySet(BasePropertySet.IdOnly, FolderSchema.TotalCount));
// Set the number of items to the smaller of the number of items in the Contacts folder or 1000
int numItems = contactsfolder.TotalCount < 1000 ? contactsfolder.TotalCount : 1000;
// Instantiate the item view with the number of items to retrieve from the Contacts folder.
ItemView view = new ItemView(numItems);
// To keep the request smaller, send only the display name.
view.PropertySet = new PropertySet(BasePropertySet.IdOnly, ContactSchema.DisplayName);
//Create a searchfilter.
SearchFilter.IsEqualTo filter = new SearchFilter.IsEqualTo(ContactSchema.DisplayName, DisplayName);
// Retrieve the items in the Contacts folder with the properties you've selected.
FindItemsResults <Item> contactItems = service.FindItems(WellKnownFolderName.Contacts, filter, view);
if (contactItems.Count() == 1) //Only one contact was found
{
return((Contact)contactItems.Items[0]);
}
else //No contacts, or more than one contact with the same DisplayName, were found.
{
return(null);
}
}
private Folder GetOrCreateFolderCore(string folderName, FolderId parentFolder, Func <Folder> creator)
{
SearchFilter filter = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, folderName);
FolderView view = new FolderView(1);
FindFoldersResults findFoldersResults = this.InvokeServiceCall <FindFoldersResults>(() => this.Service.FindFolders(parentFolder, filter, view));
if (findFoldersResults.Folders.Count == 0)
{
Folder folder = creator();
folder.DisplayName = folderName;
try
{
this.InvokeServiceCall(delegate()
{
folder.Save(parentFolder);
});
}
catch (DataSourceOperationException ex)
{
ServiceResponseException ex2 = ex.InnerException as ServiceResponseException;
if (ex2 == null || ex2.ErrorCode != 107)
{
throw;
}
}
findFoldersResults = this.InvokeServiceCall <FindFoldersResults>(() => this.Service.FindFolders(parentFolder, filter, view));
}
return(findFoldersResults.Folders[0]);
}
public async Task <string> GetAppointMentUrl(string id)
{
try
{
var calendarFolder = await CalendarFolder.Bind(this._exchangeService, WellKnownFolderName.Calendar,
new PropertySet());
var searchFilter = new SearchFilter.IsEqualTo(ItemSchema.Id, id);
var appointments = await calendarFolder.FindItems(searchFilter, new ItemView(1));
var list = new List <AppointMentDto>();
var appointment = appointments.First() as Appointment;
if (appointment == null)
{
return("");
}
await appointment.Load(new PropertySet(
ItemSchema.Id,
AppointmentSchema.JoinOnlineMeetingUrl));
return(appointment.JoinOnlineMeetingUrl);
}
catch (Exception e)
{
return("");
}
}
private CalendarFolder FindNamedCalendarFolder(string name, string email, string password)
{
CalendarFolder calendar;
try
{
FolderView view = new FolderView(100);
view.PropertySet = new PropertySet(BasePropertySet.IdOnly);
view.PropertySet.Add(FolderSchema.DisplayName);
view.Traversal = FolderTraversal.Deep;
SearchFilter sfSearchFilter = new SearchFilter.IsEqualTo(FolderSchema.FolderClass, "IPF.Appointment");
FindFoldersResults findFolderResults = Service(email, password).FindFolders(WellKnownFolderName.Root, sfSearchFilter, view);
calendar = findFolderResults.Where(f => f.DisplayName.ToUpper().Equals(name.ToUpper())).Cast <CalendarFolder>().FirstOrDefault();
if (calendar != null)
{
return(calendar);
}
else
{
return(CalendarFolder.Bind(Service(email, password), WellKnownFolderName.Calendar, new PropertySet()));
}
}
catch
{
throw;
}
}
/// <summary>
/// 获取邮件列表
/// </summary>
/// <param name="isRead">已读true/未读false</param>
/// <param name="count">数量</param>
/// <param name="config"></param>
/// <returns>邮件列表</returns>
public static List <EmailMessage> GetEmailList(bool isRead, int count, ExchangeAdminConfig config)
{
InitializeEws(config);
List <EmailMessage> emails = new List <EmailMessage>();
//创建过滤器
SearchFilter sf = new SearchFilter.IsEqualTo(EmailMessageSchema.IsRead, isRead);
FindItemsResults <Item> findResults = null;
try
{
findResults = Service.FindItems(WellKnownFolderName.Inbox, sf, new ItemView(count));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
if (findResults != null)
{
foreach (Item item in findResults.Items)
{
EmailMessage email = EmailMessage.Bind(Service, item.Id);
emails.Add(email);
}
}
return(emails);
}
protected override void ProcessRecord()
{
FindFoldersResults results;
if (!FolderName.ToLower().Equals("inbox"))
{
SearchFilter folderFilter = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, FolderName);
FolderView view = new FolderView(int.MaxValue);
view.PropertySet = new PropertySet(BasePropertySet.IdOnly);
view.PropertySet.Add(FolderSchema.DisplayName);
view.Traversal = FolderTraversal.Deep;
results = mailboxConnection.FindFolders(WellKnownFolderName.MsgFolderRoot, folderFilter, view);
}
else
{
FolderId folderID = new FolderId(WellKnownFolderName.Inbox);
SearchFilter folderFilter = new SearchFilter.IsEqualTo(FolderSchema.Id, folderID);
FolderView view = new FolderView(int.MaxValue);
view.PropertySet = new PropertySet(BasePropertySet.IdOnly);
view.PropertySet.Add(FolderSchema.DisplayName);
view.Traversal = FolderTraversal.Deep;
results = mailboxConnection.FindFolders(WellKnownFolderName.MsgFolderRoot, folderFilter, view);
}
foreach (Folder folder in results)
{
WriteObject(folder);
}
}
// Resolve folder name to Folder object - the folder is expected to be immediately under the mailbox root
public static Folder FindFolderByName(string folderName, ExchangeService service)
{
Logger.DebugFormat("Looking for folder named '{0}'", folderName);
// Look for the folder under the mailbox root
//var rootFolder = Folder.Bind(service, WellKnownFolderName.MsgFolderRoot);
FolderId SharedMailbox = new FolderId(WellKnownFolderName.Inbox, "*****@*****.**");
var rootFolder = Folder.Bind(service, SharedMailbox, PropertySet.IdOnly);
// Folder name should be equal to 'folderName'
var folderFilter = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, folderName);
// No need to look for more than one folder (can't have more than one folder with the exact same name)
var findFoldersResults = rootFolder.FindFolders(folderFilter, new FolderView(1));
if (!findFoldersResults.Any())
{
Logger.InfoFormat("Couldn't find folder {0}", folderName);
return(null);
}
Logger.DebugFormat("Found folder {0} ({1} matching folder items)", folderName, findFoldersResults.Count());
var folder = findFoldersResults.First();
return(folder);
}
private void ReceiveEmailFromServer(ExchangeService service)
{
try
{
//创建过滤器, 条件为邮件未读.
ItemView view = new ItemView(999);
view.PropertySet = new PropertySet(BasePropertySet.FirstClassProperties, EmailMessageSchema.IsRead);
SearchFilter filter = new SearchFilter.IsEqualTo(EmailMessageSchema.IsRead, false);
FindItemsResults <Item> findResults = service.FindItems(WellKnownFolderName.Inbox,
filter,
view);
foreach (Item item in findResults.Items)
{
EmailMessage email = EmailMessage.Bind(service, item.Id);
if (!email.IsRead)
{
LoggerHelper.Logger.Info(email.Body);
//标记为已读
email.IsRead = true;
//将对邮件的改动提交到服务器
email.Update(ConflictResolutionMode.AlwaysOverwrite);
Object _lock = new Object();
lock (_lock)
{
DownLoadEmail(email.Subject, email.Body, ((System.Net.NetworkCredential)((Microsoft.Exchange.WebServices.Data.WebCredentials)service.Credentials).Credentials).UserName);
}
}
}
}
catch (Exception ex)
{
LoggerHelper.Logger.Error(ex, "ReceiveEmailFromServer Error");
}
}
public Folder GetVpnFolder(ExchangeService client, string inboxSubFolderNameWithVpnEmails = null)
{
var defaultFolder = Folder.Bind(client, WellKnownFolderName.Inbox);
if (string.IsNullOrEmpty(inboxSubFolderNameWithVpnEmails))
{
return(defaultFolder);
}
// https://stackoverflow.com/questions/7912584/exchange-web-service-folderid-for-a-not-well-known-folder-name
// var folderIdVpn = new FolderId(InboxSubFolderNameWithVpnEmails);
var folderView = new FolderView(pageSize: 5);
folderView.Traversal = FolderTraversal.Deep; // Allows search in nested folders.
var searchFilterVpnFolder = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, inboxSubFolderNameWithVpnEmails);
var vpnFolders = client.FindFolders(WellKnownFolderName.Inbox, searchFilterVpnFolder, folderView);
Folder vpnFolder = null;
if (vpnFolders.TotalCount > 0)
{
//var vpnFolderId = vpnFolders.Folders.Single().Id;
var vpnFolderId = vpnFolders.Folders.FirstOrDefault()?.Id;
vpnFolder = Folder.Bind(client, vpnFolderId);
}
else
{
vpnFolder = defaultFolder;
}
return(vpnFolder);
}
private static IEnumerable <Item> GetConversationItemsSingleConversation(ExchangeService service, FolderId folderId, ConversationId conversationId)
{
var conversationIdProperty = new ExtendedPropertyDefinition(0x3013, MapiPropertyType.Binary);
var cidBinary = Convert.FromBase64String(conversationId.UniqueId);
var cidGuid = new byte[16];
Array.Copy(cidBinary, 43, cidGuid, 0, 16);
var conversationIdValue = Convert.ToBase64String(cidGuid);
var itempropertyset = new PropertySet(BasePropertySet.FirstClassProperties)
{
RequestedBodyType = BodyType.Text
};
var itemview = new ItemView(100)
{
PropertySet = itempropertyset
};
// {
// PropertySet = new PropertySet(
// BasePropertySet.IdOnly,
// ItemSchema.DateTimeReceived,
// ItemSchema.LastModifiedName,
// ItemSchema.DisplayTo,
// ItemSchema.DisplayCc,
// ItemSchema.Subject)
// };
var conversationFilter = new SearchFilter.IsEqualTo(conversationIdProperty, conversationIdValue);
var items = service.FindItems(folderId, conversationFilter, itemview);
return(items);
}
/// <summary>
/// Provides a record-by-record processing functionality for the cmdlet.
/// </summary>
protected override void ProcessRecord()
{
// Create the Exchange Service Object and auth with bearer token
ExchangeService exchangeService = new ExchangeService(new AuthenticationProvider(), this.SmtpAddress, RestEnvironment.OutlookBeta);
FolderView folderView = new FolderView(10);
FindFoldersResults findFoldersResults = null;
do
{
SearchFilter searchFilter = new SearchFilter.IsEqualTo(MailFolderObjectSchema.DisplayName, this.FolderName);
findFoldersResults = exchangeService.FindFolders(this.FolderRoot, searchFilter, folderView);
folderView.Offset += folderView.PageSize;
foreach (MailFolder folder in findFoldersResults)
{
if (!this.Force && !this.ShouldContinue(string.Format("This is a hard delete operation. Are you sure you want to delete mail folder {0}?", this.FolderName), "Hard Delete Folder", true, ref this.yesToAll, ref this.noToAll))
{
return;
}
// Hard delete the folder
folder.Delete();
}
}while (findFoldersResults.MoreAvailable);
}
/// <summary>
/// gets mail content for the passed in mailid.
/// </summary>
/// <param name="mailId"></param>
/// <returns></returns>
public byte[] GetEmailContent(string mailId)
{
string mailGraphUrl = $"{generalSettings.GraphUrl}/v1.0/me/messages/{mailId}";
string jsonResponse = MakeGetRequestForString(mailGraphUrl);
var mail = JsonConvert.DeserializeObject <MailMessage>(jsonResponse);
var bytes = (dynamic)null;
ExchangeService service = new ExchangeService(ExchangeVersion.Exchange2013);
string accessToken = spoAuthorization.GetExchangeAccessToken();
service.Credentials = new OAuthCredentials(accessToken);
service.UseDefaultCredentials = false;
service.Url = new Uri(generalSettings.ExchangeServiceURL.ToString());
service.PreAuthenticate = true;
service.SendClientLatencies = true;
service.EnableScpLookup = false;
mailId = mail.Id.Replace("_", "+");
PropertySet propSet = new PropertySet(BasePropertySet.FirstClassProperties);
Folder folder = Folder.Bind(service, WellKnownFolderName.Inbox, propSet);
SearchFilter filter = new SearchFilter.IsEqualTo(ItemSchema.Id, mailId);
FindItemsResults <Item> findResults = service.FindItems(WellKnownFolderName.Inbox, filter, new ItemView(1));
foreach (var item in findResults)
{
item.Load(new PropertySet(EmailMessageSchema.MimeContent));
return(item?.MimeContent?.Content);
}
return(bytes);
}
/// <summary>
/// CRUD task operations.
/// </summary>
/// <param name="exchangeService">Exchange service.</param>
public static void CreateUpdateReadDeleteTasks(ExchangeService exchangeService)
{
FolderId tasksFolderId = new TaskFolderId("me");
string subject = Guid.NewGuid().ToString();
Task task = new Task(exchangeService);
task.Body = new ItemBody()
{
ContentType = BodyType.HTML,
Content = "This is test task."
};
task.Subject = subject;
task.AssignedTo = AppConfig.MailboxB;
task.Importance = Importance.High;
task.DueDateTime = new DateTimeTimeZone()
{
DateTime = DateTime.Now.AddDays(2),
TimeZone = "UTC"
};
task.Save(tasksFolderId);
Assert.IsNotNull(task.Id);
task.Importance = Importance.Low;
task.DueDateTime = new DateTimeTimeZone()
{
DateTime = DateTime.Now.AddDays(5),
TimeZone = "UTC"
};
task.Update();
Assert.AreEqual(
Importance.Low,
task.Importance);
SearchFilter searchFilter = new SearchFilter.IsEqualTo(
TaskObjectSchema.Subject,
subject);
FindItemsResults <Item> tasks = exchangeService.FindItems(
tasksFolderId,
searchFilter,
new TaskView(10));
Assert.AreEqual(
1,
tasks.TotalCount);
IList <Task> completedTasks = task.Complete();
Assert.AreEqual(
1,
completedTasks.Count);
task.Delete();
Assert.IsNull(task.Id);
}
public MailboxDiscoverySearch FindByLegacySearchObjectIdentity(string legacySearchObjectIdentity)
{
Util.ThrowOnNullOrEmptyArgument(legacySearchObjectIdentity, "legacySearchObjectIdentity");
SearchFilter filter = new SearchFilter.IsEqualTo(MailboxDiscoverySearchSchema.LegacySearchObjectIdentity.StorePropertyDefinition, legacySearchObjectIdentity);
IEnumerable <MailboxDiscoverySearch> source = this.InternalFindPaged <MailboxDiscoverySearch>(filter, null, false, null, 1, new ProviderPropertyDefinition[0]);
return(source.FirstOrDefault <MailboxDiscoverySearch>());
}
static Dictionary <string, Folder> GetSharedCalendarFolders(ExchangeService service, String searchIn = "My Calendars")
{
Dictionary <String, Folder> rtList = new Dictionary <string, Folder>();
FolderId rfRootFolderid = new FolderId(WellKnownFolderName.Root);//, mbMailboxname
FolderView fvFolderView = new FolderView(1000);
SearchFilter sfSearchFilter = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, "Common Views");
FindFoldersResults ffoldres = service.FindFolders(rfRootFolderid, sfSearchFilter, fvFolderView);
if (ffoldres.Folders.Count == 1)
{
PropertySet psPropset = new PropertySet(BasePropertySet.FirstClassProperties);
ExtendedPropertyDefinition PidTagWlinkAddressBookEID = new ExtendedPropertyDefinition(0x6854, MapiPropertyType.Binary);
ExtendedPropertyDefinition PidTagWlinkFolderType = new ExtendedPropertyDefinition(0x684F, MapiPropertyType.Binary);
ExtendedPropertyDefinition PidTagWlinkGroupName = new ExtendedPropertyDefinition(0x6851, MapiPropertyType.String);
psPropset.Add(PidTagWlinkAddressBookEID);
psPropset.Add(PidTagWlinkFolderType);
ItemView iv = new ItemView(1000);
iv.PropertySet = psPropset;
iv.Traversal = ItemTraversal.Associated;
SearchFilter cntSearch = new SearchFilter.IsEqualTo(PidTagWlinkGroupName, searchIn);
FindItemsResults <Item> fiResults = ffoldres.Folders[0].FindItems(cntSearch, iv);
foreach (Item itItem in fiResults.Items)
{
try {
object GroupName = null;
object WlinkAddressBookEID = null;
if (itItem.TryGetProperty(PidTagWlinkAddressBookEID, out WlinkAddressBookEID))
{
byte[] ssStoreID = (byte[])WlinkAddressBookEID;
int leLegDnStart = 0;
String lnLegDN = "";
for (int ssArraynum = (ssStoreID.Length - 2); ssArraynum != 0; ssArraynum--)
{
if (ssStoreID[ssArraynum] == 0)
{
leLegDnStart = ssArraynum;
lnLegDN = System.Text.Encoding.ASCII.GetString(ssStoreID, leLegDnStart + 1, (ssStoreID.Length - (leLegDnStart + 2)));
ssArraynum = 1;
}
}
NameResolutionCollection ncCol = service.ResolveName(lnLegDN, ResolveNameSearchLocation.DirectoryOnly, true);
if (ncCol.Count > 0)
{
FolderId SharedCalendarId = new FolderId(WellKnownFolderName.Calendar, ncCol[0].Mailbox.Address);
Folder SharedCalendaFolder = Folder.Bind(service, SharedCalendarId);
rtList.Add(ncCol[0].Mailbox.Address, SharedCalendaFolder);
}
}
} catch (Exception exception) {
Console.WriteLine(exception.Message);
}
}
}
return(rtList);
}
/// <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();
}
//根据发件人过滤
public static SearchFilter filterBYSender(string senderAddress)
{
EmailAddress sender = new EmailAddress(senderAddress);
SearchFilter senderFilter =
new SearchFilter.IsEqualTo(EmailMessageSchema.Sender, sender);
return(senderFilter);
}
//根据收件人过滤
public static SearchFilter filterByReciver(string fromAddress)
{
EmailAddress emailAddress = new EmailAddress(fromAddress);
SearchFilter senderFilter =
new SearchFilter.IsEqualTo(EmailMessageSchema.ReceivedBy, emailAddress);
return(senderFilter);
}
