public virtual async Task MarkAsRead(IList <UniqueId> uids) { if (_mailFolder == null) { _mailFolder = await AuthenticateAsync(); } await _mailFolder.OpenAsync(FolderAccess.ReadWrite); await _mailFolder.SetFlagsAsync(uids, MessageFlags.Seen, false); }
public async Task <List <MimeMessage> > GetMessages(IMailFolder sourceFolder, SearchQuery query, CancellationToken ct) { return(await PolicyWrapper.WrapRetryOnNotConnected(async() => { await sourceFolder.OpenAsync(FolderAccess.ReadOnly).ConfigureAwait(false); var uids = (await sourceFolder.SearchAsync(query).ConfigureAwait(false)) .Take(10); // TODO Only for test for better performance var messages = new List <MimeMessage>(); foreach (var uid in uids) { if (ct.IsCancellationRequested) { break; } try { var msg = await sourceFolder.GetMessageAsync(uid).ConfigureAwait(false); messages.Add(msg); } catch (FolderNotOpenException) { break; } } return messages; }, EnsureConnected).ConfigureAwait(false)); }
private async Task <(MimeMessage, UniqueId)> CreateEmptyStorageMessageAsync(IMailFolder folder, string messageId, Action <MimeMessage>?initializationCallback) { var resultMessage = new MimeMessage(new Header(HeaderId.MessageId, messageId)); resultMessage.From.Add(new MailboxAddress(Constants.AppName, Constants.AppFakeEmail)); resultMessage.To.Add(new MailboxAddress(Constants.AppName, Constants.AppFakeEmail)); resultMessage.Date = new DateTime(2000, 01, 01); resultMessage.Subject = Constants.MetadataMessageSubjectPrefix; resultMessage.Body = new Multipart(); // gives caller the chance to further initialize the message if (initializationCallback != null) { initializationCallback(resultMessage); } // note: this creates the message on the server AND receives it again - this could be optimized if made more context aware await folder.OpenAsync(FolderAccess.ReadWrite); logger.Verbose("Creating storage message in folder {FolderPath}", folder.FullName); var newId = await folder.AppendAsync(resultMessage, MessageFlags.Seen); if (!newId.HasValue) { throw new TeasmCompanionException("Cannot create storage message"); } resultMessage = await folder.GetMessageAsync(newId.Value); logger.Debug("Created storage message in folder {FolderPath} with {@ID}", folder.FullName, newId); return(resultMessage, newId.Value); }
public async void OpenFolder(IMailFolder folder) { if (this.folder == folder) { return; } if (this.folder != null) { this.folder.MessageFlagsChanged -= MessageFlagsChanged_TaskThread; this.folder.MessageExpunged -= MessageExpunged_TaskThread; this.folder.MessagesArrived -= MessagesArrived_TaskThread; } // Note: because we are using the *Async() methods, these events will fire // in another thread so we'll have to proxy them back to the main thread. folder.MessageFlagsChanged += MessageFlagsChanged_TaskThread; folder.MessageExpunged += MessageExpunged_TaskThread; this.folder = folder; if (folder.IsOpen) { LoadMessages(); return; } await folder.OpenAsync(FolderAccess.ReadOnly); LoadMessages(); }
public async void OpenFolder (IMailFolder folder) { if (this.folder == folder) return; if (this.folder != null) { this.folder.MessageFlagsChanged -= MessageFlagsChanged_TaskThread; this.folder.MessageExpunged -= MessageExpunged_TaskThread; this.folder.MessagesArrived -= MessagesArrived_TaskThread; } // Note: because we are using the *Async() methods, these events will fire // in another thread so we'll have to proxy them back to the main thread. folder.MessageFlagsChanged += MessageFlagsChanged_TaskThread; folder.MessageExpunged += MessageExpunged_TaskThread; this.folder = folder; if (folder.IsOpen) { LoadMessages (); return; } await folder.OpenAsync (FolderAccess.ReadOnly); LoadMessages (); }
public static async Task<(UniqueId, IMailFolder?)> FindIdByMessageIdHeader(this IMailFolder folder, string? messageIdHeaderValue, bool recursive, bool skipParent, bool onlyImmediateChildren = false) { if (messageIdHeaderValue == null) { return (UniqueId.Invalid, null); } await folder.OpenAsync(FolderAccess.ReadOnly); if (!skipParent) { var hit = (await folder.SearchAsync(SearchQuery.HeaderContains("Message-ID", messageIdHeaderValue))).FirstOrDefault(); // sometimes there are more than one if the companion got terminated; ignore this, think later about handling this if (hit.IsValid) return (hit, folder); } var subfolders = await folder.GetSubfoldersAsync(false); foreach (var subFolder in subfolders) { var hit2 = await subFolder.FindIdByMessageIdHeader(messageIdHeaderValue, recursive && onlyImmediateChildren, false, onlyImmediateChildren); if (hit2.Item1.IsValid) { return hit2; } } return (UniqueId.Invalid, null); }
public virtual async Task <MimeMessageUId> GetMessage(UniqueId uniqueId) { _mailFolder = await AuthenticateAsync(); await _mailFolder.OpenAsync(FolderAccess.ReadOnly); return(new MimeMessageUId(await _mailFolder.GetMessageAsync(uniqueId), uniqueId)); }
public async Task <int> GetMaxPages() { IMailFolder folder = (IMailFolder)Session["folder"]; if (!folder.IsOpen) { await folder.OpenAsync(FolderAccess.ReadWrite); } int maxPages = Convert.ToInt32(Math.Ceiling((float)folder.Count / mailsOnPage)); return(maxPages); }
public async Task Attachment(MailWindow inboxPage, User user, ConfigModel conf, string Atch, string destination) { using (ImapClient client = new ImapClient()) { await client.ConnectAsync(conf.ImapServer, conf.ImapPort); client.Authenticate(user.Mail, user.Password); IMailFolder Folder = client.GetFolder(ListMessages.fold); await Folder.OpenAsync(FolderAccess.ReadWrite); IList <IMessageSummary> atc = Folder.Fetch(new[] { LastOpenId }, MessageSummaryItems.Body); var multipart = (BodyPartMultipart)atc.First().Body; var attachment = multipart.BodyParts.OfType <BodyPartBasic>().FirstOrDefault(x => x.FileName == Atch); TransferProgress progress = new TransferProgress(); Downloads FileDownload = new Downloads(); FileDownload.Show(); var file = Folder.GetBodyPart(LastOpenId, attachment, default, progress);
public async Task OpenText(Message m, OpenMessage Page, User user, ConfigModel conf) { using (ImapClient client = new ImapClient()) { List <string> atc = new List <string>(); await client.ConnectAsync(conf.ImapServer, conf.ImapPort); client.Authenticate(user.Mail, user.Password); IMailFolder Folder = client.GetFolder(ListMessages.fold); await Folder.OpenAsync(FolderAccess.ReadWrite); IList <IMessageSummary> msg = Folder.Fetch(new[] { m.ID }, MessageSummaryItems.UniqueId | MessageSummaryItems.BodyStructure | MessageSummaryItems.Envelope); LastOpenId = msg.First().UniqueId; var bodyHTML = (TextPart)Folder.GetBodyPart(msg.First().UniqueId, msg.First().HtmlBody); Page.Dispatcher.Invoke(() => { Page.Attachments.Children.Clear(); }); Folder.SetFlags(m.ID, MessageFlags.Seen, true); m.MessageColor = new SolidColorBrush(Colors.White); foreach (BodyPartBasic attachment in msg.First().Attachments) { Button bt = new Button { Content = attachment.FileName, }; Page.Dispatcher.Invoke(() => { bt.Click += new RoutedEventHandler(new MailWindow(user, conf).OpenAttachment); Page.Attachments.Children.Add(bt); }); } if (m != null) { Page.Dispatcher.Invoke(() => { Page.Info.Text = ($"Subject: {msg.First().Envelope.Subject} \n\rFrom {msg.First().Envelope.From} at {msg.First().Envelope.Date} to {msg.First().Envelope.To}"); Page.Body.NavigateToString("<html><head><meta charset='UTF-8'></head>" + bodyHTML.Text + "</html>"); Page.MailBody.Visibility = 0; }); } client.Disconnect(true); } }
public async Task ReadFolder() { if (!serverFolder.IsOpen) { try { await serverFolder.OpenAsync(FolderAccess.ReadWrite); } catch (Exception ex) { } serverFolder.MessageFlagsChanged += ServerFolder_MessageFlagsChanged; serverFolder.CountChanged += ServerFolder_CountChanged; serverFolder.UnreadChanged += ServerFolder_UnreadChanged; } await serverFolder.StatusAsync(StatusItems.Unread | StatusItems.Count); }
async Task LoadMessagesAsync(Task task) { await task; messages.Clear(); Nodes.Clear(); map.Clear(); if (!folder.IsOpen) { await folder.OpenAsync(FolderAccess.ReadOnly); } if (folder.Count > 0) { var summaries = await folder.FetchAsync(0, -1, request); AddMessageSummaries(summaries); } folder.CountChanged += CountChanged; }
public async void OpenFolder(IMailFolder pFolder) { if (this.lFolder == pFolder) { return; } if (this.lFolder != null) { } this.lFolder = pFolder; if (pFolder.IsOpen) { LoadMessages(); return; } await pFolder.OpenAsync(FolderAccess.ReadWrite); LoadMessages(); }
public virtual async Task <IList <UniqueId> > GetUIds(ImapFilter filter = null) { _mailFolder = await AuthenticateAsync(); await _mailFolder.OpenAsync(FolderAccess.ReadOnly); if (filter == null) { _lastRetrievedUIds = await _mailFolder.SearchAsync(new SearchQuery()); } else { _lastRetrievedUIds = await _mailFolder.SearchAsync(filter.ToSearchQuery()); } if (_lastRetrievedUIds == null) { _lastRetrievedUIds = new List <UniqueId>(); } return(_lastRetrievedUIds); }
private static async Task RunAsync(MailSortConfig config) { var rules = GetRules(config.ConfigFile).ToList(); if (rules.Count == 0) { throw new Exception("No rules found. Please define rules first."); } IEnumerable <Tuple <Func <MimeMessage, bool>, string> > predicatesAndTargetFolders = rules.Where(r => !r.IsCombinationRule) .Select(r => Tuple.Create(BuildPredicate(GetCombinedRules(r, new Queue <MailSortRule>(new[] { r }), rules)), r.TargetFolder)).ToList(); using var imapClient = new ImapClient(); await imapClient.ConnectAsync(config.Host, config.UseSsl?EncryptedImapPort : ImapPort, config.UseSsl).ConfigureAwait(false); await imapClient.AuthenticateAsync(config.Username, config.Password).ConfigureAwait(false); var inbox = imapClient.Inbox; await inbox.OpenAsync(FolderAccess.ReadWrite).ConfigureAwait(false); var summaries = await inbox.FetchAsync(0, -1, MessageSummaryItems.UniqueId | MessageSummaryItems.InternalDate | MessageSummaryItems.Flags); foreach (var summary in summaries) { if (summary.Flags !.Value.HasFlag(MessageFlags.Deleted)) { continue; } var message = await inbox.GetMessageAsync(summary.UniqueId).ConfigureAwait(false); var tuple = predicatesAndTargetFolders.FirstOrDefault(t => t.Item1(message)); if (tuple == null) { continue; } IMailFolder destinationFolder = null !; try { destinationFolder = await imapClient.GetFolderAsync(tuple.Item2).ConfigureAwait(false); } catch (FolderNotFoundException) { var folders = await imapClient.GetFoldersAsync(imapClient.PersonalNamespaces[0]).ConfigureAwait(false); Console.WriteLine($"The folder '{tuple.Item2}' was not found. The following folders are available: {string.Join(", ", folders.Select(f => f.Name))}"); Environment.Exit(1); } await destinationFolder.OpenAsync(FolderAccess.ReadWrite).ConfigureAwait(false); await destinationFolder.AppendAsync(message, summary.Flags !.Value, summary.InternalDate !.Value).ConfigureAwait(false); await destinationFolder.CloseAsync().ConfigureAwait(false); await inbox.OpenAsync(FolderAccess.ReadWrite).ConfigureAwait(false); await inbox.AddFlagsAsync(summary.UniqueId, MessageFlags.Deleted, true).ConfigureAwait(false); } await inbox.CloseAsync(true).ConfigureAwait(false); }
private async Task SyncMailFolder(EmailConfiguration emailConfiguration, IMailFolder mailFolder, EmailType emailType) { try { //await _cqLogger.LogToFile($"Start syncing {mailFolder.Name} folder from {emailConfiguration.Email}", _level); await mailFolder.OpenAsync(FolderAccess.ReadOnly); //await _cqLogger.LogToFile($"{emailConfiguration.Email} => {mailFolder.Name} is open", _level); #region load completely IList <UniqueId> uids = mailFolder.Search(SearchQuery.All); //await _cqLogger.LogToFile($"{uids.Count} mail is found in {mailFolder.Name} ({emailConfiguration.Email})", _level); int counter = 1; foreach (var uid in uids) { try { //await _cqLogger.LogToFile($"fetching {counter++} email with id {uid} ({emailConfiguration.Email} => {mailFolder.Name})", _level); if (await _emailRepository.ExistenceCheckByUniqueId(uid.ToString(), emailConfiguration.Id)) { //await _cqLogger.LogToFile($"email id {uid} is found in {emailConfiguration.Email}", _level); continue; } var message = await mailFolder.GetMessageAsync(uid); var attachments = await EmailAssistantExtensions.GetAllAttachments(message, emailConfiguration.Email, _pathToSaveFiles); var emailMessage = EmailAssistantExtensions.CreateNew(message, emailConfiguration.Id, uid.ToString(), emailType, EmailStatus.Received); var lstMailAddresses = EmailAssistantExtensions.ExtractAllMailAddresses(message); foreach (var mail in lstMailAddresses) { long contactId = 0; var contact = await _contactRepository.GetByEmail(mail.Name); if (contact == null) { var name = mail.Name.GetName(); var newContact = new Contact { MailAddress = mail.Name, Name = name }; contactId = await _contactRepository.InsertAsync(newContact); } else { contactId = contact.Id; } if (emailMessage.Id < 1) { await _emailRepository.InsertAsync(emailMessage); } var emailContact = new EmailContact { ContactId = contactId, EmailId = emailMessage.Id, RelationType = mail.Type }; await _emailContactRepository.InsertAsync(emailContact); } foreach (var attachment in attachments) { attachment.EmailId = emailMessage.Id; await _attachmentRepository.InsertAsync(attachment); } } catch (Exception e) { await _cqLogger.LogToFile(e.ToString(), _level); } } #endregion } catch (Exception e) { await _cqLogger.LogToFile(e.ToString(), _level); } }
public static async Task <List <MeasuredData> > ReceiveEmailAsync(DateTime?dateTime) { List <MeasuredData> measuredDatas = new List <MeasuredData>(); try { using (ImapClient client = new ImapClient()) { await client.ConnectAsync("imap.gmail.com", 993, true); await client.AuthenticateAsync(FromEmail, Password); IMailFolder inbox = client.Inbox; await inbox.OpenAsync(FolderAccess.ReadOnly); dynamic query; if (dateTime == null) { query = SearchQuery.FromContains("balpisystem"); } else { query = SearchQuery.DeliveredAfter(DateTime.Parse(dateTime.Value.AddHours(-24).ToString())) //Message sending time .And(SearchQuery.FromContains("balpisystem")); } foreach (var uid in await inbox.SearchAsync(query)) { try { List <string> text = new List <string>(); var message = await inbox.GetMessageAsync(uid); var html = new HtmlAgilityPack.HtmlDocument(); html.LoadHtml(message.HtmlBody); html.DocumentNode.SelectNodes("//span/text()").ToList().ForEach(x => text.Add(x.InnerHtml.Replace("\t", ""))); var value = text[text.FindIndex(x => x.Contains("Значение")) + 1]; var date = text[text.FindIndex(x => x.Contains("среднего")) + 1]; date = date.Substring(0, date.IndexOf("Central") - 1); var dateTimeServer = DateTime.ParseExact(date, "M/d/yyyy h:mm:ss tt", CultureInfo.InvariantCulture); if (dateTimeServer > dateTime || dateTime == null) { int MeasuredParameterId = 9, PollutionSourceId = 5; bool Averaged = true; measuredDatas.Add(new MeasuredData { Value = Convert.ToDecimal(value.Replace(".", CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator)), DateTime = dateTimeServer, MeasuredParameterId = MeasuredParameterId, PollutionSourceId = PollutionSourceId, Averaged = Averaged }); } } catch { } } await client.DisconnectAsync(true); } return(measuredDatas); } catch (Exception ex) { return(measuredDatas); } }