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