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