private async void Update()
{
IMailFolder inbo = await Task.Run(() => EmailAsync(login, pass));
lbMail.Content = tbLogin.Text;
inbo.Open(FolderAccess.ReadOnly);
progress.Maximum = inbo.Count;
lbMail.Content = login;
spLog.Visibility = Visibility.Collapsed;
gridMainPage.Visibility = Visibility.Visible;
try
{
for (int i = inbo.Count - 1; i >= 0; i--)
{
var message = await inbo.GetMessageAsync(i);
letters.Add(new Letter
{
Sender = message.From.Mailboxes.First().Name,
Date = message.Date.DateTime.ToString(),
Subject = message.Subject,
Text = message.TextBody
}
);
progress.Value++;
}
}
catch { }
await imap.DisconnectAsync(true);
}
public FileResult Download(uint Uid, string Name) //retuns file from message attachments
{
IMailFolder folder = (IMailFolder)Session["folder"];
UniqueId uid = new UniqueId(Uid);
var task = folder.GetMessageAsync(uid);
var attachments = task.Result.Attachments;
foreach (MimeEntity attachment in attachments)
{
if (attachment.ContentDisposition.FileName == Name)
{
MemoryStream stream = new MemoryStream();
string fileType = attachment.ContentType.MimeType;
if (attachment is MessagePart)
{
var part = (MessagePart)attachment;
part.Message.WriteTo(stream);
}
else
{
var part = (MimePart)attachment;
part.Content.DecodeTo(stream);
}
byte[] file = stream.ToArray();
return(File(file, fileType, Name));
}
}
return(null);
}
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 virtual async Task <MimeMessageUId> GetMessage(UniqueId uniqueId)
{
_mailFolder = await AuthenticateAsync();
await _mailFolder.OpenAsync(FolderAccess.ReadOnly);
return(new MimeMessageUId(await _mailFolder.GetMessageAsync(uniqueId), uniqueId));
}
public virtual async Task <MimeMessageUId> GetMessageUid(UniqueId uniqueId)
{
var mime = await _mailFolder.GetMessageAsync(uniqueId);
if (mime != null)
{
return(new MimeMessageUId(mime, uniqueId));
}
return(null);
}
public static async Task<(MimeMessage?, UniqueId)> GetMessageOrDefaultAsync(this IMailFolder folder, UniqueId id, MimeMessage? defaultValue = null)
{
try
{
return (await folder.GetMessageAsync(id), id);
} catch (MessageNotFoundException)
{
return (null, UniqueId.Invalid);
}
}
/// <summary>
/// Asynchronously retrieve all messages using the specified mailbox folder.
/// </summary>
/// <param name="folder">The mailbox folder used to retrieve the messages.</param>
/// <param name="cancellationToken">The token used to cancel an ongoing async operation.</param>
/// <returns></returns>
public static async Task <IList <MimeMessage> > GetMessagesAsync(this IMailFolder folder, CancellationToken cancellationToken = default(CancellationToken))
{
var list = new List <MimeMessage>();
for (int i = 0; i < folder.Count; i++)
{
var message = await folder.GetMessageAsync(i, cancellationToken);
list.Add(message);
}
return(list);
}
public async Task <ActionResult> OpenMail(uint Uid, bool seen = true)
{
IMailFolder folder = (IMailFolder)Session["folder"];
UniqueId uid = new UniqueId(Uid);
MimeMessage message = await folder.GetMessageAsync(uid);
if (!seen)
{
await folder.AddFlagsAsync(new UniqueId(Uid), MessageFlags.Seen, true);
}
Mail mail = await Task.Run(() => new Mail(uid, message));
return(PartialView(mail));
}
public virtual async Task <List <MimeMessageUId> > GetMessageUids(IList <UniqueId> uniqueIds)
{
_mailFolder = await AuthenticateAsync();
_mailFolder.Open(FolderAccess.ReadOnly);
var list = new List <MimeMessageUId>();
foreach (var uid in uniqueIds)
{
list.Add(new MimeMessageUId(await _mailFolder.GetMessageAsync(uid), uid));
}
return(list);
}
private async Task searchMessages(IMailFolder inbox)
{
//Create a list to store messages that match the search criteria.
List <MimeMessage> matchingMessages = new List <MimeMessage>();
foreach (var summary in await inbox.FetchAsync(0, -1, MessageSummaryItems.Full | MessageSummaryItems.UniqueId))
{
foreach (var term in _subjectSearchTerms)
{
if (summary.Envelope.Subject != null)
{
if (summary.Envelope.Subject.ToLower().Contains(term.ToLower()))
{
var message = await inbox.GetMessageAsync(summary.UniqueId);
matchingMessages.Add(message);
}
}
}
foreach (var term in _bodySearchTerms)
{
if (summary.TextBody != null)
{
if (summary.TextBody.ToString().ToLower().Contains(term.ToLower()))
{
var message = await inbox.GetMessageAsync(summary.UniqueId);
matchingMessages.Add(message);
}
}
}
}
await sendToDatabase(matchingMessages);
}
public async void RefreshAsync()
{
IMailFolder inbox = await Task.Run(() => EmailAsync(login, passwd));
inbox.Open(FolderAccess.ReadOnly);
progress.Visibility = Visibility.Visible;
progress.Maximum = inbox.Count;
try
{
for (int i = inbox.Count - 1; i >= 0; i--)
{
MimeMessage message = await inbox.GetMessageAsync(i);
userMessages.Add(new UserMessage {
Date = message.Date, Name = message.From.Mailboxes.First().Name, Subj = message.Subject, Text = message.TextBody
});
progress.Value++;
}
progress.Value = 0;
progress.Visibility = Visibility.Hidden;
}
catch { }
await imap.DisconnectAsync(true);
}
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);
}
}