public SaveResult saveAttachment(IMailFolder folder, IMessageSummary summary, BodyPartBasic attachment) { var result = SaveResult.Error; var entity = folder.GetBodyPart(summary.UniqueId, attachment); if (entity is MimePart) { var part = (MimePart)entity; var log = logAttachment(summary.UniqueId, part.FileName, part.ContentType); if (isIgnoreableAttachment(part.ContentType, part.FileName)) { log("Ignoring attachment"); result = SaveResult.Ignore; } else if (IsMimeTypeAcceptable(part.ContentType)) { log("MIME type ok"); result = downloader.downloadAttachment( part.Content, this.fileNamer(folder)(part)(summary) ); } else { log("MIME type bad"); } } return(result); }
/// <summary> /// Initializes a new instance of the <see cref="MailKit.MessageSummaryFetchedEventArgs"/> class. /// </summary> /// <remarks> /// Creates a new <see cref="MessageSummaryFetchedEventArgs"/> /// </remarks> /// <param name="message">The message summary.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="message"/> is <c>null</c>. /// </exception> public MessageSummaryFetchedEventArgs (IMessageSummary message) { if (message == null) throw new ArgumentNullException (nameof (message)); Message = message; }
/// <summary> /// Get text body of mail from cache or server and update cache if available /// </summary> /// <param name="summary">Mail summary</param> /// <param name="inbox">Mailbox that contains mail</param> /// <returns>Body text</returns> private string GetBodyText(IMessageSummary summary, IMailFolder inbox) { //Get from cache var cachedText = CacheService?.GetCachedMail(summary.UniqueId.Id); if (cachedText != null) { return(cachedText.BodyText); } //Download from server var bodyText = ""; if (summary.TextBody != null) { var text = (TextPart)inbox.GetBodyPart(summary.UniqueId, summary.TextBody); bodyText = text.Text.Trim(); } else if (summary.HtmlBody != null) { //TODO: Read html body bodyText = ""; } //Update cache CacheService?.UpdateCachedMailPart(summary.UniqueId.Id, "BodyText", bodyText); return(bodyText); }
public async Task LogEmailRemoved(IMessageSummary email) { using (var context = new MailModelContainer()) { var selectedEmail = context.Emails.Include(e => e.EmailLogs).FirstOrDefault( x => _config.Id == x.ImapMailBoxConfigurationId && x.EnvelopeID.Equals(email.Envelope.MessageId)); if (selectedEmail == null) return; if (selectedEmail.EmailLogs.Any(x => x.Action.Contains("Sent") && x.Action.ToLower().Contains("moved") || x.Action.Contains("Removed"))) { return; } await LogEmailChanged(email, "", "Removed"); selectedEmail.Minutes = (int) (DateTime.Now.ToUniversalTime() - selectedEmail.TimeReceived.ToUniversalTime()).TotalMinutes; selectedEmail.InQueue = false; await context.SaveChangesAsync(); } }
public MessageInfo (IMessageSummary summary) { Summary = summary; if (summary.Flags.HasValue) Flags = summary.Flags.Value; }
public List <string> DownloadThenSaveAttachments(IMessageSummary message, string directory, Action <Exception> onException) { if (!CreateDirectoryIfNeeded(directory, onException)) { return(null); } var output = new List <string>(); DoOnLock(() => { foreach (var attachment in message.Attachments) { MimeEntity entity = null; try { entity = CurrentFolder.GetBodyPart(message.UniqueId, attachment); } catch (Exception e) { _config.Tracer?.TraceError($"Failed to save attachment an attachment - {e}", $"{this}"); onException?.Invoke(e); } if (entity == null) { continue; } var path = PersistMimeEntity(entity, directory, onException); if (!string.IsNullOrEmpty(path)) { output.Add(path); } } }); return(output); }
private SaveResult saveEmailAttachments(IMailFolder folder, IMessageSummary summary) { if (summary.Body is BodyPartMultipart body) { var attachmentBox = new AttachmentBox(body); attachmentBox.fill(); var attachments = attachmentBox.attachmentList; var results = attachments .Select(attachment => saveAttachment( folder, summary, attachment )).ToArray(); if (!results.Contains(SaveResult.Error) && results.Contains(SaveResult.Ok)) { return(SaveResult.Ok); } else if (results.Contains(SaveResult.Error)) { return(SaveResult.Error); } } return(SaveResult.Ignore); }
SentEmail GetSentEmailFromSummary(IMessageSummary item) { var fromAddresses = new List <string>(); foreach (var address in item.Envelope.From) { fromAddresses.Add(((MailboxAddress)address).Address); } var toAddresses = new List <string>(); foreach (var address in item.Envelope.To) { toAddresses.Add(((MailboxAddress)address).Address); } var sentEmail = new SentEmail { Id = item.Envelope.MessageId, SentTime = item.Date.UtcDateTime, From = string.Join(";", fromAddresses), To = string.Join(";", toAddresses), Subject = item.Envelope.Subject, UniqueId = item.UniqueId, PreviewText = HtmlUtility.ConvertToPlainText(item.PreviewText), IsRead = item.Flags.Value.HasFlag(MessageFlags.Seen) }; return(sentEmail); }
private void StoreLocal(IMessageSummary msg, IMailFolder folder) { using (var tx = new TransferContext(conn, false)) { string mid = msg.Headers[HeaderId.MessageId]; if (mid != null) { tx.Messages.Add(new ImapMigration.Message { Url = DestinationServer.Url, MessageID = mid }); tx.SaveChanges(); return; } tx.Messages.Add(new ImapMigration.Message { Folder = folder.FullName, Hash = GetHash(msg), Url = DestinationServer.Url }); tx.SaveChanges(); } }
static string DatePart(IMessageSummary summary, string dateFormat, Func <IMessageSummary, string> missingDateLabel) { DateTimeOffset?maybeDate = summary.Envelope.Date; return(maybeDate.HasValue ? maybeDate.Value.ToString(dateFormat) : missingDateLabel(summary)); }
public NewMailEventArgs(IMessageSummary messageSummary, IMailActuator mailActuator, ITracer tracer) { MessageSummary = messageSummary; MailActuator = mailActuator; ToDelete = false; MoveToSubfolder = null; _tracer = tracer; }
private async Task FilterMessage(IMessageSummary msgSummary) { //to move all filtered emails at once and prevent multiple individual calls to movemessage //dictionary key is the filter name, list of message summaries to move to the filter's folder var emailsToMove = new Dictionary<string, List<IMessageSummary>>(); try { foreach (var filter in _emailFilters) { //check subject contains if (!string.IsNullOrEmpty(filter.SubjectContains)) { if (string.IsNullOrEmpty(msgSummary.Envelope.Subject) || !msgSummary.Envelope.Subject.ToLower().Contains(filter.SubjectContains.ToLower())) continue; } //check sender's address if (!string.IsNullOrEmpty(filter.SentFromContains)) { if (!msgSummary.Envelope.From[0].ToString().ToLower().Contains(filter.SentFromContains)) continue; } if (filter.ForwardThis) { //get the message var theMessage = await _attachedMailBox.GetMessage(msgSummary.UniqueId.Id); if (theMessage == null) return; //forward the message if (!await _attachedMailBox.SendMail(theMessage, msgSummary.UniqueId.Id, filter.ForwardToAddress, false)) { return; } } //move the message //await _attachedMailBox.MoveMessage(msgSummary, filter.MoveToFolder, "Filter: " + filter.FilterName); if (emailsToMove.ContainsKey(filter.MoveToFolder)) { emailsToMove[filter.MoveToFolder].Add(msgSummary); } else { var summaryList = new List<IMessageSummary> {msgSummary}; emailsToMove.Add(filter.MoveToFolder, summaryList); } } await _attachedMailBox.MoveMessage(emailsToMove); } catch (Exception ex) { Trace.WriteLine($"{_attachedMailBox.MailBoxName} EmailFilterer exception: {ex.Message}"); } }
/// <summary> /// Initializes a new instance of the <see cref="MailKit.MessageThread"/> class. /// </summary> /// <remarks> /// Creates a new message thread node. /// </remarks> /// <param name="message">The message summary.</param> public MessageThread(IMessageSummary message) { Children = new List <MessageThread> (); if (message != null && message.UniqueId.IsValid) { UniqueId = message.UniqueId; } Message = message; }
private string GetHash(IMessageSummary msg) { string all = string.Join("\r\n", msg.Headers.Select(x => x.Field + ": " + x.Value)); var h = hash.ComputeHash(System.Text.Encoding.UTF8.GetBytes(all)); var hs = string.Join("", h.Select(x => x.ToString("x2"))); return(hs); }
/// <summary> /// Initializes a new instance of the <see cref="MailKit.MessageSummaryFetchedEventArgs"/> class. /// </summary> /// <remarks> /// Creates a new <see cref="MessageSummaryFetchedEventArgs"/> /// </remarks> /// <param name="message">The message summary.</param> /// <exception cref="System.ArgumentNullException"> /// <paramref name="message"/> is <c>null</c>. /// </exception> public MessageSummaryFetchedEventArgs(IMessageSummary message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } Message = message; }
public MessageInfo(IMessageSummary summary) { Summary = summary; if (summary.Flags.HasValue) { Flags = summary.Flags.Value; } }
public override Tuple <ModuleResult, MimeMessage> Execute(IMessageSummary summary, MimeMessage message) { var tags = new HashSet <string>(); tags.Add(_config.TagName); Context.Imap.Inbox.AddFlags(summary.UniqueId, MessageFlags.None, tags, false); return(new Tuple <ModuleResult, MimeMessage>(ModuleResult.Continue, message)); }
public override Tuple <ModuleResult, MimeMessage> Execute(IMessageSummary summary, MimeMessage message) { if (_config.Negate ^ summary.Keywords.Contains(_config.TagName)) { return(new Tuple <ModuleResult, MimeMessage>(ModuleResult.Continue, message)); } else { return(new Tuple <ModuleResult, MimeMessage>(ModuleResult.Stop, message)); } }
public override Tuple <ModuleResult, MimeMessage> Execute(IMessageSummary summary, MimeMessage message) { if (InRange(message.Date)) { return(new Tuple <ModuleResult, MimeMessage>(ModuleResult.Continue, message)); } else { return(new Tuple <ModuleResult, MimeMessage>(ModuleResult.Stop, message)); } }
public override Tuple <ModuleResult, MimeMessage> Execute(IMessageSummary summary, MimeMessage message) { if (message.Headers .Any(h => h.Field == _config.Field && Regex.IsMatch(h.Value, _config.ValuePattern))) { return(new Tuple <ModuleResult, MimeMessage>(ModuleResult.Continue, message)); } else { return(new Tuple <ModuleResult, MimeMessage>(ModuleResult.Stop, message)); } }
private ListStructure CreateAttachmentStructuresFromAttachments(IMessageSummary message, IMailFolder folder, IEnumerable <BodyPartBasic> attachments) { ListStructure attachmentsList = new ListStructure(); foreach (var attachment in attachments) { AttachmentModel attachmentModel = new AttachmentModel(attachment, folder, message); AttachmentStructure temp = new AttachmentStructure(attachmentModel); attachmentsList.AddItem(temp); } return(attachmentsList); }
private Email MapMessageSummaryToDto(IMessageSummary summary, Email email, ResolutionContext context) { email = new Email(); var envelope = summary.Envelope; email.From = context.Mapper.Map <EmailAddress[]>(envelope.From?.Select(i => i)); email.To = context.Mapper.Map <EmailAddress[]>(envelope.To?.Select(i => i)); email.Cc = context.Mapper.Map <EmailAddress[]>(envelope.Cc?.Select(i => i)); email.Bcc = context.Mapper.Map <EmailAddress[]>(envelope.Bcc?.Select(i => i)); email.Subject = envelope.Subject; return(email); }
public override Tuple <ModuleResult, MimeMessage> Execute(IMessageSummary summary, MimeMessage message) { try { var topic = _discourse.GetTopic(_config.TopicId); _discourse.Post(topic, message.TextBody); } catch (Exception exception) { Context.Logger.Error("Could not post on discourse\n" + exception.ToString()); } return(new Tuple <ModuleResult, MimeMessage>(ModuleResult.Continue, message)); }
public ActionResult MailModifyAdvanced(string uniqueId, SpecialFolder specialFolder) { MailRepository mailRepository = Session["MailRepository"] as MailRepository; IMessageSummary getMessageInfo = mailRepository.GetMessageInfo(uniqueId, specialFolder); ViewBag.getMessageInfo = getMessageInfo; if (!getMessageInfo.Flags.Value.HasFlag(MessageFlags.Seen)) { MailAddFlags(uniqueId, MessageFlags.Seen); } return(View("~/Views/ControlPanel/MailAdvanced/MailModifyAdvanced.cshtml", mailRepository.GetMessage(uniqueId, specialFolder))); }
public bool checkOpen(IMessageSummary info) { bool isopen; if (info.Flags.Value.HasFlag(MessageFlags.Seen)) { isopen = true; } else { isopen = false; } return(isopen); }
private bool MessageExists(IMessageSummary msg, IMailFolder folder, IMailFolder dest) { // check if message exists on dest... string mid = msg.Headers[HeaderId.MessageId]; // check if exists locally only.... if (MessageExistsLocally(mid, msg, folder)) { return(true); } if (!CheckIfMessageExists) { return(false); } SearchQuery query = null; if (mid != null) { query = SearchQuery.HeaderContains("Message-ID", mid); } else { mid = msg.Headers[HeaderId.ResentMessageId]; if (mid != null) { query = SearchQuery.HeaderContains("Resent-Message-ID", mid); } else { Console.WriteLine($"No message id found for {msg.Headers[HeaderId.Subject]}"); } } if (query != null) { var ids = dest.Search(query); if (ids.Count == 1) { //Console.WriteLine("Message exists at destination"); return(true); } } return(false); }
/// <summary> /// Manda email reporteando error /// </summary> /// <param name="summary"></param> /// <param name="attachments"></param> /// <param name="info"></param> private void ReportMessage(IMessageSummary summary, IEnumerable <BodyPartBasic> attachments, string info) { try { var builder = new BodyBuilder() { TextBody = info }; send(summary, attachments, builder); } catch (Exception) { throw; } }
public void RenderMailMessage(IMailFolder mailFolder, IMessageSummary messageInfo) { if (!mailFolder.IsOpen) { mailFolder.Open(FolderAccess.ReadWrite); } MailRender mailRender = new MailRender(); mailRender.RenderAsync(mailFolder, messageInfo.UniqueId, messageInfo.Body) .ContinueWith((t) => { UpdateWebBrowser(this, t.Result); }); }
public void Process(IMessageSummary summary, MimeMessage message) { foreach (var filter in _filters) { var result = filter.Execute(summary, message); if (result.Item1 == ModuleResult.Stop) { return; } else { message = result.Item2; } } }
public async Task<bool> LogEmailReceived(IMessageSummary summary) { if (string.IsNullOrEmpty(summary.Envelope.MessageId)) return false; using (var context = new MailModelContainer()) { //if it's already in the DB we're not going to log it received if (context.Emails.Any(x => x.EnvelopeID.Equals(summary.Envelope.MessageId))) return false; //generate new Email and EmailLogs var email = new Email() { BodyText = "", EnvelopeID = summary.Envelope.MessageId, InQueue = true, MarkedAsRead = false, Minutes = (int) (DateTime.Now.ToUniversalTime() - summary.Date.ToUniversalTime()).TotalMinutes, Sender = summary.Envelope.From.ToString(), Subject = string.IsNullOrEmpty(summary.Envelope.Subject) ? "" :summary.Envelope.Subject, TimeReceived = summary.InternalDate?.LocalDateTime ?? summary.Date.LocalDateTime, TimeSent = summary.Date.LocalDateTime, ImapMailBoxConfigurationId = _config.Id }; var el = new EmailLog(); el.Action = "Received"; el.TimeActionTaken = DateTime.Now.ToLocalTime(); el.TakenBy = ""; el.Email = email; email.EmailLogs.Add(el); try { context.Emails.Add(email); await context.SaveChangesAsync(); } catch (DbEntityValidationException ex) { throw ex; } } return true; }
/// <summary> /// Cuando un documento no se puede cargar (Por x razón) este método se encargará /// de reenviar dicho documento a otro correo /// </summary> /// <param name="doc"></param> /// <param name="respuestaCarga"></param> private void ReportMessage(IMessageSummary summary, IEnumerable <BodyPartBasic> attachments, MensajeWCFOfDocumentoElectronico respuestaCarga) { try { var builder = new BodyBuilder() { TextBody = String.Format("El intento de carga de documento adjunto al mensage {0} ha fallado! motivo: {1}", summary.UniqueId.ToString(), respuestaCarga.MensajeHumano ) }; send(summary, attachments, builder); } catch (Exception) { throw; } }
private void CopyMessage(IMessageSummary msg, IMailFolder folder, IMailFolder dest) { if (MessageExists(msg, folder, dest)) { return; } var m = folder.GetMessage(msg.UniqueId); //string rd = msg.Headers[HeaderId.Received]; try { dest.Append(m, msg.Flags == null ? MessageFlags.None : msg.Flags.Value, msg.InternalDate ?? (DateTimeOffset.Now)); } catch (Exception ex) { /*if (!ex.Message.Contains("Message too large.")) { * throw; * }*/ // failed... string failedFolder = "failed\\" + folder.FullName.Replace(folder.DirectorySeparator, '-'); string failed = failedFolder + "\\" + DateTime.UtcNow.Ticks + ".msg"; string reason = failed + ".reason.txt"; string dir = System.IO.Path.GetDirectoryName(failed); if (!System.IO.Directory.Exists(dir)) { System.IO.Directory.CreateDirectory(dir); } using (var fs = System.IO.File.OpenWrite(failed)) { m.WriteTo(fs); } System.IO.File.WriteAllText(reason, ex.ToString()); } StoreLocal(msg, folder); }
public void DownloadThenDoForEachAttachments(IMessageSummary message, Action <string, byte[]> attachmentHandler, Action <Exception> onException) { DoOnLock(() => { foreach (var attachment in message.Attachments) { try { var entity = CurrentFolder.GetBodyPart(message.UniqueId, attachment); if (entity != null) { DoWithMimeEntity(entity, attachmentHandler, onException); } } catch (Exception e) { _config.Tracer?.TraceError($"Failed to get an attachment - {e}", $"{this}"); onException?.Invoke(e); } } }); }
public string DownloadBody(IMessageSummary mail) { string output = null; DoOnLock(() => { // download the 'text/plain' body part, .Text is a convenience property that decodes the content and converts the result to a string for us if (mail.TextBody != null) { output = (CurrentFolder.GetBodyPart(mail.UniqueId, mail.TextBody) as TextPart)?.Text; } if (string.IsNullOrEmpty(output) && mail.HtmlBody != null) { output = (CurrentFolder.GetBodyPart(mail.UniqueId, mail.HtmlBody) as TextPart)?.Text; } }); return(output); }
public override async Task<bool> Notify(IMessageSummary summary, NotificationType notificationType, string mailBoxName) { string response; if (HttpMethod == WebRequestMethods.Http.Post) { using (var client = new HttpClient()) { var summ = new NotificationSummary(summary, notificationType) {MailBoxName = mailBoxName}; try { var result = await client.PostAsJsonAsync(Url, summ, Util.GetCancellationToken(10000)); } catch (Exception) { } } } if (HttpMethod == WebRequestMethods.Http.Get) { using (var client = new WebClient()) { var data = MessageSummaryToListKeyValuePair.Convert(summary); var ub = new UriBuilder(Url); ub.Query = HttpUtility.UrlEncode( string.Join("&", data.Select(x => string.Format("{0}={1}", x.Key, x.Value)))); try { response = client.DownloadString(ub.Uri); } catch (WebException ex) { return false; } } } return true; }
public Mail(IMessageSummary fetch, HeaderList headers) { int shift = 5; Uid = fetch.UniqueId; Seen = fetch.Flags > 0; Subject = headers["subject"]; From = headers["from"]; int cut = headers["date"].Length; if (headers["date"].Contains("+")) { cut = headers["date"].IndexOf('+') + shift; } else if (headers["date"].Contains("-")) { cut = headers["date"].IndexOf('-') + shift; } Date = Convert.ToDateTime(headers["date"].Substring(0, cut)); }
public override async Task<bool> Notify(IMessageSummary summary, NotificationType notificationType, string mailBoxName) { var sb = new StringBuilder(); sb.AppendLine("***** " + DateTime.Now + " : Action Happened *****"); sb.AppendLine("Notification Type: " + notificationType); sb.AppendLine("Subject: " + summary.Envelope.Subject); sb.AppendLine("Time: " + summary.Envelope.Date); sb.AppendLine("Sender: " + summary.Envelope.From[0]); sb.AppendLine(summary.Date.GetType().Name + " : " + summary.Date); sb.AppendLine("---"); try { File.AppendAllText(FilePath, sb.ToString()); } catch (Exception ex) { return false; } return true; }
static IList<IMessageSummary> AsReadOnly (ICollection<IMessageSummary> collection) { var array = new IMessageSummary[collection.Count]; collection.CopyTo (array, 0); return new ReadOnlyCollection<IMessageSummary> (array); }
public abstract Task<bool> Notify(IMessageSummary summary, NotificationType notificationType, string mailBoxName);
public async Task LogEmailBackInQueue(IMessageSummary email) { using (var ctx = new MailModelContainer()) { var emails = ctx.Emails.Where( x => x.ImapMailBoxConfigurationId == _config.Id && x.EnvelopeID.Equals(email.Envelope.MessageId)); foreach (var em in emails) { em.InQueue = true; } await ctx.SaveChangesAsync(); } }
public async Task LogEmailSeen(IMessageSummary message) { using (var Context = new MailModelContainer()) { var selectedEmail = Context.Emails.Where(x => x.ImapMailBoxConfigurationId == _config.Id); var result = selectedEmail.FirstOrDefault(x => x.EnvelopeID.Equals(message.Envelope.MessageId)); if (result == null || result.MarkedAsRead) return; result.MarkedAsRead = true; await Context.SaveChangesAsync(); await LogEmailChanged(message, "Unknown", "Marked Read"); } }
public async Task LogEmailChanged(IMessageSummary email, string actionTakenBy, string action) { using (var context = new MailModelContainer()) { var selectedEmails = context.Emails.Include(x => x.EmailLogs).Where( x => _config.Id == x.ImapMailBoxConfigurationId && x.EnvelopeID.Equals(email.Envelope.MessageId)); var newLogs = new List<EmailLog>(); foreach (var em in selectedEmails) { var el = new EmailLog { Action = action, TimeActionTaken = DateTime.Now.ToLocalTime(), Email = em, TakenBy = actionTakenBy }; newLogs.Add(el); } context.EmailLogs.AddRange(newLogs); await context.SaveChangesAsync(); } }
/// <summary> /// Initializes a new instance of the <see cref="MailKit.MessageSummaryFetchedEventArgs"/> class. /// </summary> /// <remarks> /// Creates a new <see cref="MessageSummaryFetchedEventArgs"/> /// </remarks> /// <param name="message">The message summary.</param> public MessageSummaryFetchedEventArgs (IMessageSummary message) { Message = message; }
public async Task MoveMessage(IMessageSummary summary, string moveToFolder, string actionTakenBy) { await MoveMessage(summary.UniqueId.Id, summary.Envelope.MessageId, moveToFolder, actionTakenBy); }
public NotificationSummary(IMessageSummary sum, NotificationType notificationType) : this(new Summary(sum), notificationType) { }
/// <summary> /// Raise the message summary fetched event. /// </summary> /// <remarks> /// <para>Raises the message summary fetched event.</para> /// <para>When multiple message summaries are being fetched from a remote folder, /// it is possible that the connection will drop or some other exception will /// occur, causing the Fetch method to fail, requiring the client to request the /// same set of message summaries again after it reconnects. This is obviously /// inefficient. To alleviate this potential problem, this event will be emitted /// as soon as the <see cref="IMailFolder"/> successfully retrieves the complete /// <see cref="IMessageSummary"/> for each requested message.</para> /// <para>Note: The Fetch methods will return a list of all message summaries /// that any information was retrieved for, regardless of whether or not all of /// the requested items were fetched, therefore there may be a discrepency between /// the number of times this event is emitetd and the number of summary items /// returned from the Fetch method.</para> /// </remarks> /// <param name="message">The message summary.</param> protected virtual void OnMessageSummaryFetched (IMessageSummary message) { var handler = MessageSummaryFetched; if (handler != null) handler (this, new MessageSummaryFetchedEventArgs (message)); }