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