private Folder GetTopLevelFolder(string folderName)
{
FindFoldersResults findFolderResults = _service.FindFolders(WellKnownFolderName.MsgFolderRoot, new FolderView(int.MaxValue));
foreach (Folder folder in findFolderResults.Where(folder => folderName.Equals(folder.DisplayName, StringComparison.InvariantCultureIgnoreCase)))
return folder;
throw new Exception("Top Level Folder not found: " + folderName);
}
/// <summary>
/// Sucht im PublicRoot einen Ordner mit dem Namen aus der Config Datei (zb. "Arges Intern").
/// </summary>
/// <returns>Das Ordnerobjekt des Ordners mit dem richtigen Namen. Wird benutzt um den Ordner per Id zu binden.</returns>
public Folder getPublicFolder()
{
var PublicRoot = Folder.Bind(service, WellKnownFolderName.PublicFoldersRoot);
SearchFilter.IsEqualTo filter = new SearchFilter.IsEqualTo(FolderSchema.DisplayName, ContactFolderName);
FindFoldersResults FindPublicContactFolder = service.FindFolders(PublicRoot.Id, filter, new FolderView(1));
return(FindPublicContactFolder.Folders[0]);
}
/// <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.ToString(), RestEnvironment.OutlookBeta);
FolderView folderView = new FolderView(10);
FindFoldersResults findFoldersResults = null;
switch (this.ParameterSetName)
{
case "FolderName":
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)
{
this.WriteObject(new PSObject(folder));
}
}while (findFoldersResults.MoreAvailable);
break;
case "FolderId":
do
{
findFoldersResults = exchangeService.FindFolders(this.FolderRoot, folderView);
folderView.Offset += folderView.PageSize;
foreach (MailFolder folder in findFoldersResults)
{
if (folder.Id == this.FolderId.ToString())
{
this.WriteObject(new PSObject(folder));
}
}
}while (findFoldersResults.MoreAvailable);
break;
default:
do
{
findFoldersResults = exchangeService.FindFolders(this.FolderRoot, folderView);
folderView.Offset += folderView.PageSize;
foreach (MailFolder folder in findFoldersResults)
{
this.WriteObject(new PSObject(folder));
}
}while (findFoldersResults.MoreAvailable);
break;
}
}
private Folder FindImHistoryFolder()
{
FolderView folderView = new FolderView(_pageSize, 0);
folderView.PropertySet = new PropertySet(BasePropertySet.IdOnly);
folderView.PropertySet.Add(FolderSchema.DisplayName);
folderView.PropertySet.Add(FolderSchema.ChildFolderCount);
folderView.Traversal = FolderTraversal.Shallow;
Folder imHistoryFolder = null;
FindFoldersResults findFolderResults;
bool foundImHistoryFolder = false;
do
{
findFolderResults = _exchangeService.FindFolders(WellKnownFolderName.MsgFolderRoot, folderView);
foreach (Folder folder in findFolderResults)
{
if (folder.DisplayName.ToLower() == "conversation history")
{
imHistoryFolder = folder;
foundImHistoryFolder = true;
}
}
folderView.Offset += _pageSize;
} while (findFolderResults.MoreAvailable && !foundImHistoryFolder);
return(imHistoryFolder);
}
public Folder GetFolder(string displayName)
{
FolderView folderView = new FolderView(int.MaxValue)
{
Traversal = FolderTraversal.Shallow
};
if (displayName == "Inbox")
{
this.txtLog.Text += "EWS API: Folder.Bind\r\nLocation:..\\EWS\\EWS\\Form1.cs(60)\r\n\r\n";
return(Folder.Bind(service, WellKnownFolderName.Inbox));
}
else
{
SearchFilter.ContainsSubstring filter = new SearchFilter.ContainsSubstring(FolderSchema.DisplayName,
displayName, ContainmentMode.FullString, ComparisonMode.IgnoreCase);
FindFoldersResults findFoldersResults = service.FindFolders(WellKnownFolderName.Inbox, filter, new FolderView(int.MaxValue)
{
Traversal = FolderTraversal.Deep
});
this.txtLog.Text += "EWS API: FindFolders\r\nLocation:..\\EWS\\EWS\\Form1.cs(64)\r\n\r\n";
if (findFoldersResults.Count() > 0)
{
return(findFoldersResults.First());
}
else
{
return(null);
}
}
}
static void ListTopLevelFolders(ExchangeService service, int moffset)
{
int mPageSize = 5;
// Create a view with a page size of 5.
FolderView view = new FolderView(mPageSize, moffset, OffsetBasePoint.Beginning);
// Identify the properties to return in the results set.
view.PropertySet = new PropertySet(BasePropertySet.IdOnly);
view.PropertySet.Add(FolderSchema.DisplayName);
view.PropertySet.Add(FolderSchema.ChildFolderCount);
// Unlike FindItem searches, folder searches can be deep traversals.
view.Traversal = FolderTraversal.Shallow;
// Send the request to search the mailbox and get the results.
FindFoldersResults findFolderResults = service.FindFolders(WellKnownFolderName.MsgFolderRoot, view);
//FindFoldersResults findFolderResults = service.FindFolders(WellKnownFolderName.Calendar, view);
// Process each item.
foreach (Folder myFolder in findFolderResults.Folders)
{
if (myFolder is SearchFolder)
{
Console.WriteLine("Search folder: " + (myFolder as SearchFolder).DisplayName);
}
else if (myFolder is ContactsFolder)
{
Console.WriteLine("Contacts folder: " + (myFolder as ContactsFolder).DisplayName);
}
else if (myFolder is TasksFolder)
{
Console.WriteLine("Tasks folder: " + (myFolder as TasksFolder).DisplayName);
}
else if (myFolder is CalendarFolder)
{
Console.WriteLine("Calendar folder: " + (myFolder as CalendarFolder).DisplayName);
}
else
{
// Handle a generic folder.
Console.WriteLine("Folder: " + myFolder.DisplayName);
}
}
// Determine whether there are more folders to return.
if (findFolderResults.MoreAvailable)
{
// Make recursive calls with offsets set for the FolderView to get the remaining folders in the result set.
moffset = moffset + mPageSize;
ListTopLevelFolders(service, moffset);
}
else
{
Console.WriteLine("More Available: " + findFolderResults.MoreAvailable);
}
}
public string DeleteSubfolder(string EmailAddress, string EmailPassword, string FolderName)
{
try
{
//Establishing connection to the Exchange server
Connection conn = new Connection();
ExchangeService service = conn.InitializeConnection(EmailAddress, EmailPassword);
FolderName = FolderName.ToLower();
Folder folder = null;
FindFoldersResults Subfolders = service.FindFolders(WellKnownFolderName.Inbox, new FolderView(int.MaxValue));
foreach (var subfolder in Subfolders.Folders)
{
if (FolderName == subfolder.DisplayName.ToLower())
{
FolderId deleteFolderID = subfolder.Id;
folder = Folder.Bind(service, deleteFolderID);
folder.Delete(DeleteMode.HardDelete);
break;
}
}
if (folder is null)
{
return("Failed");
}
return("Success");
}
catch (Exception ex)
{
return("Failed: " + ex.ToString());
}
}
/// <summary>
/// Find folders.
/// </summary>
/// <param name="exchangeService">Exchange service.</param>
/// <returns></returns>
public static async Task FindFolders(ExchangeService exchangeService)
{
// TODO: Finish test.
FindMailFolderResults findMailFolderResults =
await exchangeService.FindFolders(WellKnownFolderName.MsgFolderRoot, new MailFolderView());
MailFolderView folderView = new MailFolderView();
folderView.PropertySet.Add(MailFolderObjectSchema.TotalItemCount);
ExtendedPropertyDefinition extendedPropertyDefinition1 = new ExtendedPropertyDefinition(MapiPropertyType.Long, 0x340F);
folderView.PropertySet.Add(extendedPropertyDefinition1);
SearchFilter searchfilter = new SearchFilter.IsEqualTo(MailFolderObjectSchema.DisplayName, "Inbox");
findMailFolderResults = await exchangeService.FindFolders("MsgFolderRoot", searchfilter, folderView);
}
/// <summary>
/// Gets text body of the specific email from MS Exchange Server by Email Subject
/// </summary>
/// <param name="microsoftUsername"></param>
/// <param name="microsoftPassword"></param>
/// <param name="microsoftDomainName"></param>
/// <param name="emailAddress"></param>
/// <param name="emailSubject"></param>
public string GetTextEmailBodyByEmailSubjectFromExchangeServer(string microsoftUsername, string microsoftPassword, string microsoftDomainName, string emailAddress, string emailFolderName, string emailSubject)
{
var textEmailBody = string.Empty;
ExchangeService exchangeService = null;
try
{
exchangeService = new ExchangeService();
exchangeService.Credentials = new NetworkCredential(microsoftUsername, microsoftPassword, microsoftDomainName);
exchangeService.AutodiscoverUrl(emailAddress);
var folderView = new FolderView(1);
var itemView = new ItemView(1);
itemView.OrderBy.Add(ItemSchema.DateTimeReceived, SortDirection.Ascending);
itemView.PropertySet = new PropertySet(BasePropertySet.IdOnly, ItemSchema.Subject, ItemSchema.DateTimeReceived);
var folders = exchangeService.FindFolders(emailFolderName.ToLower().Equals("inbox") ? WellKnownFolderName.MsgFolderRoot : WellKnownFolderName.Inbox, new SearchFilter.SearchFilterCollection(LogicalOperator.Or, new SearchFilter.IsEqualTo(FolderSchema.DisplayName, emailFolderName)), folderView);
var folderId = folders.FirstOrDefault().Id;
var findResults = exchangeService.FindItems(folderId, new SearchFilter.SearchFilterCollection(LogicalOperator.Or, new SearchFilter.ContainsSubstring(ItemSchema.Subject, emailSubject)), itemView);
foreach (Item item in findResults.Items)
{
var propSet = new PropertySet(BasePropertySet.IdOnly, EmailMessageSchema.Body, ItemSchema.TextBody);
var message = EmailMessage.Bind(exchangeService, item.Id, propSet);
textEmailBody = message.TextBody.Text;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(textEmailBody);
}
static FolderId FindPublicFolder(ExchangeService myService, FolderId baseFolderId,
string folderName)
{
// We will search using paging. We will use page size 10
FolderView folderView = new FolderView(10, 0);
folderView.OffsetBasePoint = OffsetBasePoint.Beginning;
// we will need only DisplayName and Id of every folder
// se we'll reduce the property set to the properties
folderView.PropertySet = new PropertySet(FolderSchema.DisplayName,
FolderSchema.Id);
FindFoldersResults folderResults;
do
{
folderResults = myService.FindFolders(baseFolderId, folderView);
foreach (Folder folder in folderResults)
{
if (String.Compare(folder.DisplayName, folderName, StringComparison.OrdinalIgnoreCase) == 0)
{
return(folder.Id);
}
}
if (folderResults.NextPageOffset.HasValue)
{
// go to the next page
folderView.Offset = folderResults.NextPageOffset.Value;
}
}while (folderResults.MoreAvailable);
return(null);
}
public IEnumerable <PublicFolderModel> GetAllFolders(string username, string password, string email, IEnumerable <KeyValuePair <string, string> > toDelete = null)
{
ExchangeService service = GetEWSService(username, password, email);
var fv = new FolderView(2500);
fv.PropertySet = GetPropertySet();
//fv.Traversal = FolderTraversal.Deep;
var w = new MAPI();
//fv.Traversal = FolderTraversal.Shallow;
//new FolderId("AQEuAAADGkRzkKpmEc2byACqAC/EWgMAbN4R9X4ytEC8CYU/2LnSxQACFO0hvgAAAA==")
//WellKnownFolderName.PublicFoldersRoot
var fList = new List <PublicFolderModel>();
var folders = service.FindFolders(WellKnownFolderName.PublicFoldersRoot, fv);
foreach (var item in folders.Folders)
{
fList.Add(ParseFolder(item, toDelete));
//item.TryGetProperty(EWSProperties.Pr_Folder_Path, out string path);
fList.AddRange(GetFolder(item, fv, toDelete).ToList());
}
// e.TryGetProperty(EWSProperties.PR_Display_name, out string displayName);
var t = fList.Count(e => e.NumberOfRules > 0);
return(fList);
}
/// <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);
}
private Folder GetFolder(List <string> path)
{
FolderId parentId = new FolderId(WellKnownFolderName.Inbox, _options.Email);
// First get the INBOX
Echo("Binding to INBOX", true);
Folder fInbox = Folder.Bind(_service, parentId);
if (null != path && 0 < path.Count)
{
Folder result = null;
foreach (string sPath in path)
{
Echo(string.Format("Binding to folder [{0}]", sPath), true);
result = _service.FindFolders(parentId, new SearchFilter.IsEqualTo(FolderSchema.DisplayName, sPath), new FolderView(1)).FirstOrDefault();
parentId = result.Id;
}
// Return the folder
return(result);
}
// Just return the INBOX
return(fInbox);
}
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 List <Item> GetIndoxFormItem(SearchFilter searchFilter, ItemView options = null)
{
List <Item> items = new List <Item>();
List <Folder> folderIds = new List <Folder>();
FolderView folderView = new FolderView(int.MaxValue);
FindFoldersResults findFolderResults = _exchangeService.FindFolders(WellKnownFolderName.Inbox, folderView);
if (findFolderResults != null && findFolderResults.TotalCount > 0)
{
FindItemsResults <Item> parents = Find(searchFilter, options);
foreach (Item item in parents)
{
items.Add(item);
}
Folder folder = findFolderResults.Folders[0];
FindItemsResults <Item> childrends = _exchangeService.FindItems(folder.Id, searchFilter, options);
foreach (Item item in childrends)
{
items.Add(item);
}
}
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>
/// Fecthing mails from a folder of mailbox.
/// It will fetch without any filter
/// </summary>
/// <param name="service"></param>
/// <param name="FolderName"></param>
/// <param name="numberOfMails"></param>
/// <param name="mailboxName"></param>
/// <param name="onlyUnreadMails"></param>
/// <returns></returns>
static System.Collections.ObjectModel.Collection <Item> ReadMailFromFolder(ExchangeService service, String FolderName, Int32 numberOfMails, String mailboxName, bool onlyUnreadMails)
{
FolderView view = new FolderView(10000);
view.PropertySet = new PropertySet(BasePropertySet.IdOnly);
view.PropertySet.Add(FolderSchema.DisplayName);
view.Traversal = FolderTraversal.Deep;
Mailbox mailbox = new Mailbox(mailboxName);
FindFoldersResults findFolderResults = service.FindFolders(new FolderId(WellKnownFolderName.MsgFolderRoot, mailbox), view);
foreach (Folder folder in findFolderResults)
{
//For Folder filter
if (folder.DisplayName == FolderName)
{
ItemView itemView = new ItemView(numberOfMails);
if (onlyUnreadMails)
{
SearchFilter searchFilter = new SearchFilter.SearchFilterCollection(LogicalOperator.And, new SearchFilter.IsEqualTo(EmailMessageSchema.IsRead, false));
return((service.FindItems(folder.Id, searchFilter, itemView)).Items);
}
else
{
return((service.FindItems(folder.Id, itemView)).Items);
}
}
}
throw new Exception("Folder is not found");
}
private void DoWork()
{
ExchangeService exchangeService = new ExchangeService(ExchangeVersion.Exchange2013);
if (this.verbose)
{
exchangeService.TraceEnabled = true;
exchangeService.TraceFlags = TraceFlags.All;
}
exchangeService.Url = new Uri(this.endpoint);
exchangeService.Credentials = new OAuthCredentials(this.token);
exchangeService.UserAgent = Constants.UserAgent;
exchangeService.ClientRequestId = Guid.NewGuid().ToString();
exchangeService.ReturnClientRequestId = true;
//exchangeService.ImpersonatedUserId = new ImpersonatedUserId(ConnectingIdType.SmtpAddress, mailbox);
//exchangeService.HttpHeaders.Add("X-AnchorMailbox", mailbox);
Console.WriteLine("Doing EWS Soap API call");
Console.WriteLine("");
exchangeService.FindFolders(WellKnownFolderName.Inbox, new FolderView(10));
Console.WriteLine("");
Console.WriteLine("SUCCESS: EWS Soap API call");
Console.WriteLine("");
}
/// <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);
}
/// <summary>
/// GetMailBoxSize method - recursion through all email folders and calculate the size of all folders.
/// </summary>
/// <returns></returns>
private double GetMailBoxSize()
{
var offset = 0;
const int pagesize = 12;
long size = 0;
FindFoldersResults folders;
do
{
folders = serv.FindFolders(WellKnownFolderName.MsgFolderRoot,
new FolderView(pagesize, offset, OffsetBasePoint.Beginning)
{
Traversal = FolderTraversal.Deep,
PropertySet =
new PropertySet(BasePropertySet.IdOnly, PidTagMessageSizeExtended,
FolderSchema.DisplayName)
});
foreach (var folder in folders)
{
long folderSize;
if (folder.TryGetProperty(PidTagMessageSizeExtended, out folderSize))
{
size += folderSize;
}
}
offset += pagesize;
} while (folders.MoreAvailable);
double value = size / 1048576;
return(value);
}
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);
}
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);
}
public void ConnectToMailbox(string mailbox)
{
if (HandlerStatus.Uninitialized != handlerStatus)
{
throw new InvalidProgramException("The ExchangeMonitor has already been connected.");
}
this.mailbox = mailbox;
ServicePointManager.ServerCertificateValidationCallback = CertificateValidationCallBack;
exchangeService = new ExchangeService(ExchangeVersion.Exchange2010)
{
Credentials = useCustomCreds
? new NetworkCredential(customUsername, customPassword, customDomain)
: new NetworkCredential(),
UseDefaultCredentials = !useCustomCreds,
KeepAlive = true,
Timeout = int.MaxValue
};
logger.InfoFormat("Connecting to mailbox [{0}]...", mailbox);
exchangeService.AutodiscoverUrl(mailbox, RedirectionUrlValidationCallback);
if (mailboxFolder.IsNullOrEmpty())
{
folderId = new FolderId(WellKnownFolderName.Inbox, new Mailbox(mailbox));
}
else
{
var folderView = new FolderView(100)
{
PropertySet = new PropertySet(BasePropertySet.IdOnly)
{
FolderSchema.DisplayName
},
Traversal = FolderTraversal.Shallow
};
var findFolder = new Func <FolderId, string, FolderId>(
(parentFolder, searchFolderName) =>
{
var results = exchangeService.FindFolders(parentFolder, folderView);
return(results.First(folder => folder.DisplayName.Equals(searchFolderName)).Id);
});
var folderPaths = mailboxFolder.Replace("\\", "/").Split(
new[] { "/" },
StringSplitOptions.RemoveEmptyEntries);
var recurseFolderId = new FolderId(WellKnownFolderName.MsgFolderRoot, new Mailbox(mailbox));
recurseFolderId = folderPaths.Aggregate(
recurseFolderId,
(current, folderPath) => findFolder(current, folderPath));
folderId = recurseFolderId;
}
logger.InfoFormat("Folder ID set as [{0} - {1}].", this.mailbox, mailboxFolder);
handlerStatus = HandlerStatus.Idle;
mailboxConnectionTimeStamp = DateTime.Now;
}
public void MoveProcessedMessage(EmailMessage message, ExchangeService serviceInfo)
{
ExchangeService service = serviceInfo;
FindFoldersResults folderResults = service.FindFolders(WellKnownFolderName.Inbox, new FolderView(int.MaxValue));
message.IsRead = true;
message.Update(ConflictResolutionMode.AlwaysOverwrite);
message.Move(folderResults.Folders[0].Id);
}
static FindFoldersResults GetFolders()
{
var folderView = new FolderView(100);
folderView.PropertySet = new PropertySet(
BasePropertySet.IdOnly, FolderSchema.DisplayName, FolderSchema.UnreadCount);
folderView.Traversal = FolderTraversal.Deep;
return(exchange.FindFolders(WellKnownFolderName.MsgFolderRoot, folderView));
}
public async Task Test_FindFoldersWithDefaultMailFolderView()
{
ExchangeService service = this.GetExchangeServiceWithUrlValidator(
new Uri("https://graph.microsoft.com/v1.0/Users/[email protected]/MailFolders/Inbox/ChildFolders?$top=10&$skip=0"));
await service.FindFolders(
WellKnownFolderName.Inbox,
new MailFolderView());
}
public void ArchiveMessage(EmailMessage message)
{
FindFoldersResults ArchiveFolder = service.FindFolders(WellKnownFolderName.MsgFolderRoot, new SearchFilter.IsEqualTo(FolderSchema.DisplayName, "Archive"), new FolderView(1));
if (ArchiveFolder.Folders.Count == 1)
{
message.Move(ArchiveFolder.Folders[0].Id);
}
}
protected override void ValidateInboxContainsFolder(string folderName)
{
var folder = exchangeService.FindFolders(
WellKnownFolderName.Inbox,
new SearchFilter.IsEqualTo(FolderSchema.DisplayName, folderName),
new FolderView(1)).FirstOrDefault();
folder.Should().NotBeNull();
}
//gavdcodeend 03
static void CallEWSTest(ExchangeService ExchService)
{
FindFoldersResults allFolders = ExchService.FindFolders(WellKnownFolderName.MsgFolderRoot,
new FolderView(10));
foreach (Folder oneFolder in allFolders)
{
Console.WriteLine(oneFolder.DisplayName);
}
}
/// <summary>
/// Comprobar que la conexiona al servidor de correos es correcta
/// </summary>
/// <returns></returns>
public bool conectado()
{
try
{
if (exchange is object)
{
var findFolderResults = exchange.FindFolders(WellKnownFolderName.Root, new SearchFilter.IsGreaterThan(FolderSchema.TotalCount, 0), new FolderView(1));
return(findFolderResults is object);
}
else
{
return(false);
}
}
catch (Exception ex)
{
return(false);
}
}
/// <summary>
/// Return the FolderID of a sub-folder within a given parent folder.
/// </summary>
/// <param name="WebService">Exchange Web Service instance to use</param>
/// <param name="BaseFolderId">FolderID of the prent folder</param>
/// <param name="FolderName">Name of the folder to find</param>
/// <returns>FolderID of the matching folder (or null if not found)</returns>
public static FolderId FindFolder(ExchangeService WebService, FolderId BaseFolderId, string FolderName)
{
// Retrieve a list of folders (paged by 10)
FolderView folderView = new FolderView(10, 0);
// Set base point of offset.
folderView.OffsetBasePoint = OffsetBasePoint.Beginning;
// Set the properties that will be loaded on returned items (display namme & folder ID)
folderView.PropertySet = new PropertySet(FolderSchema.DisplayName, FolderSchema.Id);
FindFoldersResults folderResults;
do
{
// Get the folder at the base level.
folderResults = WebService.FindFolders(BaseFolderId, folderView);
// Iterate over the folders, until we find one that matches what we're looking for.
foreach (Folder folder in folderResults)
{
// Found it - return
if (String.Compare(folder.DisplayName, FolderName, StringComparison.OrdinalIgnoreCase) == 0)
{
return folder.Id;
}
}
// If there's more folders, get them ...
if (folderResults.NextPageOffset.HasValue)
{
folderView.Offset = folderResults.NextPageOffset.Value;
}
}
while (folderResults.MoreAvailable);
// If we got here, we didn't find it, so return null.
return null;
}
/// <summary>
/// This function gets the mail item by the extended property
/// </summary>
/// <param name="service"></param>
/// <param name="folderId"></param>
/// <param name="msgFolderRootId"></param>
/// <param name="outlookMsgId"></param>
/// <param name="isIn"></param>
/// <returns></returns>
public object GetMailItemByExtendedProperty(ref ExchangeService service, FolderId folderId,
FolderId msgFolderRootId, string outlookMsgId, bool isIn)
{
EmailMessage message = null;
//Folder view
var viewFolders = new FolderView(int.MaxValue)
{
Traversal = FolderTraversal.Deep,
PropertySet = new PropertySet(BasePropertySet.IdOnly)
};
//email view
var viewEmails = new ItemView(int.MaxValue) { PropertySet = new PropertySet(BasePropertySet.IdOnly) };
//email filter
SearchFilter emailFilter =
new SearchFilter.IsEqualTo(
isIn
? MailboxExtendedPropertyDefinitionInbox
: MailboxExtendedPropertyDefinitionSent, outlookMsgId);
//search item in default folder
var findResults = service.FindItems(msgFolderRootId, emailFilter, viewEmails);
//check
if ((findResults != null) && findResults.TotalCount > 0 && findResults.FirstOrDefault() is EmailMessage)
{
//we found the email in default folder
message = (EmailMessage)findResults.First();
}
else
{
//find in all folders
var allFolders = service.FindFolders(msgFolderRootId, viewFolders);
foreach (var folder in allFolders.Folders)
{
//search
findResults = service.FindItems(folder.Id, emailFilter, viewEmails);
//check
if ((findResults != null) && findResults.TotalCount > 0 &&
findResults.FirstOrDefault() is EmailMessage)
{
//we found the email in somewhere
message = (EmailMessage)findResults.First();
break;
}
}
}
if (message != null)
{
//create property set and load necessary properties
var propertySet = new PropertySet(EmailMessageSchema.ToRecipients, EmailMessageSchema.Sender,
ItemSchema.Subject, ItemSchema.Body,
ItemSchema.DateTimeReceived, ItemSchema.DateTimeSent, ItemSchema.HasAttachments,
ItemSchema.Attachments) { RequestedBodyType = BodyType.HTML };
//load properties
service.LoadPropertiesForItems(findResults, propertySet);
}
return message;
}
private static Folder GetSourceFolder(ExchangeService service, string email)
{
// Use the following search filter to get all mail in the Inbox with the word "extended" in the subject line.
SearchFilter searchCriteria = new SearchFilter.SearchFilterCollection(LogicalOperator.And,
//Search for Folder DisplayName that matches mailbox email address:
new SearchFilter.ContainsSubstring(FolderSchema.DisplayName, email.ToLower()));
FolderView fv = new FolderView(100);
fv.PropertySet = new PropertySet(BasePropertySet.IdOnly, FolderSchema.DisplayName, FolderSchema.TotalCount);
// Find the search folder named "MailModder".
FindFoldersResults findResults = service.FindFolders(
WellKnownFolderName.Inbox,
searchCriteria,
fv);
//Return root of inbox by default:
//Folder returnFolder = Folder.Bind(service, WellKnownFolderName.Inbox);
foreach (Folder searchFolder in findResults)
{
if (searchFolder.DisplayName.Contains(email.ToLower()))
{
logger.Debug("Found source folder for email: " + email + ". Using folder: " + searchFolder.DisplayName + searchFolder.TotalCount);
return searchFolder;
}
}
logger.Debug("Error getting commissioner source folder; returning global instead for: " + email);
return GetGlobalFolder(service);
}
public static Folder GetGlobalFolder(ExchangeService service)
{
FolderView fv = new FolderView(50);
fv.PropertySet = new PropertySet(BasePropertySet.IdOnly, FolderSchema.DisplayName, FolderSchema.TotalCount);
SearchFilter folderSearch = new SearchFilter.ContainsSubstring(FolderSchema.DisplayName, Parameters.GlobalSearchFolder);
var findFoldersResults = service.FindFolders(WellKnownFolderName.SearchFolders, folderSearch, fv);
Folder targetFolder = new Folder(service);
foreach (Folder folder in findFoldersResults)
{
if (folder.DisplayName.ToLower() == Parameters.GlobalSearchFolder.ToLower())
{
targetFolder = folder;
}
}
return targetFolder;
}
private static Folder GetSourceFolder(ExchangeService service, EmailAddress email)
{
log4net.Config.XmlConfigurator.Configure();
// Use the following search filter to get all mail in the Inbox with the word "extended" in the subject line.
SearchFilter searchCriteria = new SearchFilter.SearchFilterCollection(LogicalOperator.And,
//Search for Folder DisplayName that matches mailbox email address:
new SearchFilter.IsEqualTo(FolderSchema.DisplayName, email.Address));
// Find the search folder named "MailModder".
FindFoldersResults findResults = service.FindFolders(
WellKnownFolderName.Inbox,
searchCriteria,
new FolderView(50));
//Return root of inbox by default:
Folder returnFolder = Folder.Bind(service, WellKnownFolderName.Inbox);
foreach (Folder searchFolder in findResults.Folders)
{
if (searchFolder.DisplayName == email.Address)
{
returnFolder = searchFolder;
}
}
return returnFolder;
}
static void Main(string[] args)
{
Thread t = null;
var reqType = new RequestType();
try
{
if (args[0].Contains("poll"))
{
reqType = RequestType.Poll;
Console.WriteLine("\n\tTrying to connect to Exchange server.");
t = new Thread(ShowProgress);
t.Start();
}
else if (args[0].Contains("send"))
reqType = RequestType.Send;
else
{
Console.WriteLine("\n\tAccepted arguments are 'poll' or 'send'");
Environment.Exit(1);
}
}
catch
{
Console.WriteLine("\n\tYou have not provided any argument. Give either 'poll' or 'send' as argument.");
Environment.Exit(1);
}
ExchangeService service = new ExchangeService();
service.Credentials = new WebCredentials("<username>", "<password>", "<domain>");
service.AutodiscoverUrl("<full email address>", RedirectionUrlValidationCallback);
if (reqType == RequestType.Poll)
{
if (t != null)
t.Abort();
Console.WriteLine("\n\n\tConnected. Polling for a matching email started. Hit Ctrl+C to quit.");
while (true)
{
Thread.Sleep(10000);
FolderView folderView = new FolderView(int.MaxValue);
FindFoldersResults findFolderResults = service.FindFolders(WellKnownFolderName.Inbox, folderView);
foreach (Folder folder in findFolderResults)
{
if (folder.DisplayName == "<Folder name>" && folder.UnreadCount > 0)
{
SearchFilter sf = new SearchFilter.SearchFilterCollection(LogicalOperator.And, new SearchFilter.IsEqualTo(EmailMessageSchema.IsRead, false));
ItemView view = new ItemView(1);
// Fire the query for the unread items.
// This method call results in a FindItem call to EWS.
FindItemsResults<Item> findResults = service.FindItems(folder.Id, sf, view);
var email = (EmailMessage)findResults.Items[0];
EmailMessage message = EmailMessage.Bind(service, email.Id, new PropertySet(BasePropertySet.FirstClassProperties, ItemSchema.Attachments));
mailFrom = message.From.Address;
//Console.WriteLine("Name:" + email.From.Name);
string subject = email.Subject;
Console.WriteLine("\n\tEmail received from : " + mailFrom + " with subject \"" + subject + " at " + DateTime.Now);
folder.MarkAllItemsAsRead(true);
//Perform the action you want. Example : Go to the desired URL
var client = new WebClient();
try{
client.OpenRead("http://google.com");
}
catch(Exception e){}
}
}
}
}
else if (reqType == RequestType.Send)
{
SendEmailWithReport(service, "<To email address>");
}
}
