/// <summary>
/// Method for verify if the message match the filter criteria.
/// </summary>
/// <param name="mailMessage">The mail message object.</param>
/// <returns>The bool value indicating if the message is filtered or not.</returns>
public bool IsMessageFiltered(MailMessage mailMessage)
{
bool ret = false;
// verify the from field.
if (!ret && !this.From.Equals(string.Empty))
{
if (!mailMessage.From.Contains(this.From))
{
ret = true;
}
}
// verify the to field.
if (!ret && !this.To.Equals(string.Empty))
{
if (!mailMessage.To.Contains(this.To))
{
ret = true;
}
}
// verify the subject field.
if (!ret && !this.Subject.Equals(string.Empty))
{
if (!mailMessage.Subject.Contains(this.Subject))
{
ret = true;
}
}
// verify the message body field.
if (!ret && !this.Message.Equals(string.Empty))
{
Facade facade = Facade.GetInstance();
string mailbox = MainForm.GetInstance().GetSelectedMailbox();
string body = facade.GetMessageBodyString(mailMessage, mailbox);
if (!body.Contains(this.Message))
{
ret = true;
}
}
// verify the message sent date.
if (!ret && !this.DateFrom.Equals(string.Empty) || !this.DateTo.Equals(string.Empty))
{
DateTime dtFrom = DateTime.MinValue;
DateTime dtTo = DateTime.MaxValue;
DateTime.TryParse(this.DateFrom, out dtFrom);
DateTime.TryParse(this.DateTo, out dtTo);
if (mailMessage.SentDate < dtFrom || mailMessage.SentDate > dtTo)
{
ret = true;
}
}
return ret;
}
void MessageStore_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (String.IsNullOrEmpty(e.PropertyName) || (e.PropertyName == "SelectedMessage"))
{
this.Message = _store.SelectedMessage;
}
}
private void MessageView_Load(object sender, EventArgs e)
{
// Set Dock Stlye
this.Dock = DockStyle.Fill;
// Set loaded flag
_loaded = true;
// Load the Message (if not in design mode)
if (null == this.Site)
{
_store = Facade.GetInstance().GetMessageStore();
if ((null != _store) && (null != _store.SelectedMessage))
{
// Hook change notification
_store.PropertyChanged += new PropertyChangedEventHandler(MessageStore_PropertyChanged);
// Get Current
this.Message = _store.SelectedMessage;
}
}
else if ((null != this.Parent) && (this.Parent.Site != null) && (this.Parent.Site.DesignMode == true))
{
this.webBrowser1.Visible = false;
}
// Set parent padding
if (null != this.Parent)
{
this.Parent.Padding = new Padding(0, 3, 3, 3);
}
}
/// <summary>
/// Get a mail message basend on message identifier.
/// </summary>
/// <param name="mailbox">The mailbox for retrieve the message.</param>
/// <param name="mailMessage">The mail message.</param>
/// <returns>The ActiveUp.Net.Mail.Message object.</returns>
public ActiveUp.Net.Mail.Message GetMessage(string mailbox, MailMessage mailMessage)
{
ActiveUp.Net.Mail.Message ret = null;
ActiveUp.Net.Mail.Message message = null;
Mailbox inbox = this._imap4Client.SelectMailbox(mailbox);
Fetch fetch = inbox.Fetch;
int messageCount = inbox.MessageCount;
int upIndex = mailMessage.BaseIndex;
int downIndex = mailMessage.BaseIndex;
// search up and down.
while (downIndex > 0 || upIndex <= messageCount)
{
if (downIndex > 0 && downIndex <= messageCount)
{
message = fetch.MessageObject(downIndex);
if (message.MessageId != null && message.MessageId.Equals(mailMessage.Id))
{
ret = message;
break;
}
}
if (upIndex <= messageCount && upIndex > 0)
{
message = fetch.MessageObject(upIndex);
if (message.MessageId != null && message.MessageId.Equals(mailMessage.Id))
{
ret = message;
break;
}
}
downIndex--;
upIndex++;
}
return ret;
}
/// <summary>
/// Method for retrieve the mail messages for IMAP4 protocol.
/// </summary>
/// <param name="mailbox">The mailbox for retrieve messages.</param>
/// <param name="beginIndex">The begin index for retrieve the messages.</param>
/// <param name="increment">The increment for begin index for retrieve the messages.</param>
/// <returns>The mail messages.</returns>
public BindingList<MailMessage> RetrieveMessages(string mailbox, int beginIndex, int increment)
{
BindingList<MailMessage> ret = new BindingList<MailMessage>();
MailMessage mailMessage;
Header header;
Mailbox inbox = this._imap4Client.SelectMailbox(mailbox);
Fetch fetch = inbox.Fetch;
int messageCount = inbox.MessageCount;
for (int i = beginIndex; i <= beginIndex + increment; i++)
{
if (i <= messageCount)
{
header = fetch.HeaderObject(i);
mailMessage = new MailMessage();
mailMessage.FillMessage(header);
mailMessage.BaseIndex = i;
ret.Add(mailMessage);
}
}
return ret;
}
/// <summary>
/// Get a mail message basend on message identifier.
/// </summary>
/// <param name="mailMessage">The mail message.</param>
/// <returns>The ActiveUp.Net.Mail.Message object.</returns>
public ActiveUp.Net.Mail.Message GetMessage(MailMessage mailMessage)
{
ActiveUp.Net.Mail.Message ret = null;
ActiveUp.Net.Mail.Message message = null;
int messageCount = this._pop3Client.MessageCount;
int upIndex = mailMessage.BaseIndex;
int downIndex = mailMessage.BaseIndex;
// search up and down.
while (downIndex > 0 || upIndex <= messageCount)
{
if (downIndex > 0 && downIndex <= messageCount)
{
message = this._pop3Client.RetrieveMessageObject(downIndex);
if (message.MessageId != null && message.MessageId.Equals(mailMessage.Id))
{
ret = message;
break;
}
}
if (upIndex <= messageCount && upIndex > 0)
{
message = this._pop3Client.RetrieveMessageObject(upIndex);
if (message.MessageId != null && message.MessageId.Equals(mailMessage.Id))
{
ret = message;
break;
}
}
downIndex--;
upIndex++;
}
return ret;
}
/// <summary>
/// Method for retrieve the mail messages for POP3 protocol.
/// </summary>
/// <param name="beginIndex">The begin index for retrieve the message.</param>
/// <param name="increment">The increment for begin index for retrieve messages.</param>
/// <returns>The mail messages.</returns>
public BindingList<MailMessage> RetrieveMessages(int beginIndex, int increment)
{
BindingList<MailMessage> ret = new BindingList<MailMessage>();
MailMessage mailMessage;
Header header;
int messageCount = this._pop3Client.MessageCount;
for (int i = beginIndex; i <= beginIndex + increment; i++)
{
if (i <= messageCount)
{
header = this._pop3Client.RetrieveHeaderObject(i);
mailMessage = new MailMessage();
mailMessage.FillMessage(header);
mailMessage.BaseIndex = i;
ret.Add(mailMessage);
}
}
return ret;
}
/// <summary>
/// Get a mail message basend on message identifier.
/// </summary>
/// <param name="mailMessage">The mail message.</param>
/// <param name="mailbox">The mailbox for get the message.</param>
/// <returns>The ActiveUp.Net.Mail.Message object.</returns>
public ActiveUp.Net.Mail.Message GetMessage(MailMessage mailMessage, string mailbox)
{
ActiveUp.Net.Mail.Message ret = null;
AccountSettings.AccountInfo accountInfo = this.GetDefaultAccountInfo();
if (accountInfo != null)
{
if (accountInfo.MailAccountType == AccountType.POP3)
{
ret = this._pop3Controller.GetMessage(mailMessage);
}
else if (accountInfo.MailAccountType == AccountType.IMAP)
{
ret = this._imap4Controller.GetMessage(mailbox, mailMessage);
}
}
return ret;
}
/// <summary>
/// Method for load messages.
/// </summary>
/// <param name="messageListType">The Message List Type.</param>
public void LoadMessages(MessageListType messageListType)
{
Facade facade = Facade.GetInstance();
string selectedFolder = string.Empty;
if (messageListType == MessageListType.Inbox ||
messageListType == MessageListType.Unread ||
messageListType == MessageListType.Read)
{
// Attach to Message Store
this._store = facade.GetMessageStore();
}
else if (messageListType == MessageListType.SentItems)
{
// Attach to Message Store Sent items
this._store = facade.GetMessageStoreSent();
}
else if (messageListType == MessageListType.DeletedItems)
{
// Attach to Message Store Sent items
this._store = facade.GetMessageStoreDelete();
}
else if (messageListType == MessageListType.Custom)
{
// Attach to Message Store Sent items
this._store = facade.GetMessageStoreCustom();
selectedFolder = MainForm.GetInstance().GetSelectedFolder();
}
else
{
this._store = new MessageStore();
}
// Reset DataSource
this.messageBS.DataSource = this._store.Messages;
this.dataGridView.DataSource = this.messageBS;
this.dataGridView.CurrentCell = null;
CurrencyManager cm = (CurrencyManager)this.dataGridView.BindingContext[this.dataGridView.DataSource];
cm.SuspendBinding();
foreach (DataGridViewRow row in this.dataGridView.Rows)
{
MailMessage mailMessage = (MailMessage)row.DataBoundItem;
if (messageListType == MessageListType.Unread && mailMessage.Read)
{
row.Visible = false;
}
else if (messageListType == MessageListType.Read && !mailMessage.Read)
{
row.Visible = false;
}
else if (messageListType == MessageListType.Custom &&
!mailMessage.ParentFolder.Equals(selectedFolder))
{
row.Visible = false;
}
else
{
row.Visible = true;
}
}
cm.ResumeBinding();
if (this.messageBS.Count > 0)
{
this.dataGridView.Sort(this.dataGridView.Columns[2], ListSortDirection.Descending);
}
MainForm mainForm = this.ParentForm as MainForm;
mainForm.LoadSelectedMessage(this._store);
this.Invalidate(true);
}
/// <summary>
/// Method used for send a message.
/// </summary>
/// <param name="recipient">The recipients email.</param>
/// <param name="subject">The message subject.</param>
/// <param name="body">The message body.</param>
/// <param name="attachments">The message attachements.</param>
public void SendMessage(string recipient, string subject, string body, string[] attachments)
{
AccountSettings.AccountInfo accountInfo = this.GetDefaultAccountInfo();
if (accountInfo != null)
{
ActiveUp.Net.Mail.Message message = this._smtpController.SendMessage(accountInfo,
recipient, subject, body, attachments);
if (message != null)
{
MailMessage mailMessage = new MailMessage();
mailMessage.SentDate = DateTime.Now;
mailMessage.From = accountInfo.EmailAddress;
mailMessage.To = recipient;
mailMessage.Subject = subject;
mailMessage.Read = true;
mailMessage.Id = message.MessageId;
this.CreateMessageBodyFile(mailMessage, message, Constants.SentItems);
this._storeSent.Messages.Add(mailMessage);
this.SaveMailMessages(Constants.SentItems, this._storeSent.Messages);
}
}
}
/// <summary>
/// Method for delete message.
/// </summary>
/// <param name="messageIdentifier">The mail message.</param>
/// <param name="mailbox">The mailbox.</param>
public void DeleteMessage(MailMessage mailMessage, string mailbox)
{
AccountSettings.AccountInfo accountInfo = this.GetDefaultAccountInfo();
if (accountInfo != null)
{
try
{
if (accountInfo.MailAccountType == AccountType.POP3)
{
this._pop3Controller.DeleteMessage(mailMessage.Id);
}
else if (accountInfo.MailAccountType == AccountType.IMAP)
{
this._imap4Controller.DeleteMessage(mailMessage.Id, mailbox);
}
}
catch (Exception)
{
}
// add to delete items.
if (!mailbox.Equals(Constants.DeletedItems))
{
this._storeDelete.Messages.Add(mailMessage);
this.SaveMailMessages(Constants.DeletedItems, this._storeDelete.Messages);
}
}
}
/// <summary>
/// Method for the the stream message body.
/// </summary>
/// <param name="mailMessage">The mail message.</param>
/// <param name="mailbox">The mailbox.</param>
/// <returns>The IO stream with the message body.</returns>
public Stream GetMessageBodyStream(MailMessage mailMessage, string mailbox)
{
Stream ret = null;
// load the message file and set path here if it's null.
if (!File.Exists(mailMessage.Path))
{
this.CreateMessageBodyFile(mailMessage, mailbox);
}
// load the current stream.
if (File.Exists(mailMessage.Path))
{
ret = File.OpenRead(mailMessage.Path);
}
return ret;
}
/// <summary>
/// Method for the the stream message body.
/// </summary>
/// <param name="mailMessage">The mail message.</param>
/// <param name="mailbox">The mailbox.</param>
/// <returns>The string with the message body.</returns>
public string GetMessageBodyString(MailMessage mailMessage, string mailbox)
{
string ret = string.Empty;
Stream stream = this.GetMessageBodyStream(mailMessage, mailbox);
if (stream != null)
{
StreamReader reader = new StreamReader(stream);
ret = reader.ReadToEnd();
}
return ret;
}
/// <summary>
/// Create the message body ".eml" file.
/// </summary>
/// <param name="mailMessage">The mail message object.</param>
/// <param name="message">ActiveUp.Net.Mail.Message message</param>
/// <param name="mailbox">The mailbox.</param>
public void CreateMessageBodyFile(MailMessage mailMessage, ActiveUp.Net.Mail.Message message,
string mailbox)
{
// verify if the messages directory exist, if not create it.
string directory = Constants.Messages;
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
// create the file with the message.
string fileName = string.Concat(mailMessage.Id, ".eml");
string path = System.IO.Path.Combine(directory, fileName);
if (!File.Exists(path))
{
if (message == null)
{
message = this.GetMessage(mailMessage, mailbox);
}
if (message != null)
{
FileStream fileStream = File.Create(path);
StreamWriter sw = new StreamWriter(fileStream);
sw.Write(message.BodyText.Text);
sw.Close();
}
}
mailMessage.Path = path;
}
/// <summary>
/// Create the message body ".eml" file.
/// </summary>
/// <param name="mailMessage">The mail message object.</param>
/// <param name="mailbox">The mailbox.</param>
public void CreateMessageBodyFile(MailMessage mailMessage, string mailbox)
{
this.CreateMessageBodyFile(mailMessage, null, mailbox);
}
/// <summary>
/// Method used for load the messages store.
/// </summary>
/// <param name="mailbox">The mail box name.</param>
/// <param name="messageStore">The message store object for fill.</param>
public void LoadMessageStore(string mailbox, MessageStore messageStore)
{
// Create the data connector.
messageStore.Messages = new SortableBindingList<MailMessage>();
// Load data from Inbox (XML file).
Assembly assembly = this.GetType().Assembly;
MailMessage message;
DataSet ds = new DataSet();
DataView view;
int unread = 0;
string resourceName = string.Concat(this.GetType().Namespace, ".Mail.Inbox.xsd");
ds.ReadXmlSchema(assembly.GetManifestResourceStream(resourceName));
string inboxPath = Path.Combine(Constants.Messages, mailbox + ".xml");
string directory = Constants.Messages;
if (Directory.Exists(directory) && File.Exists(inboxPath))
{
ds.ReadXml(inboxPath);
view = ds.Tables[0].DefaultView;
foreach (DataRowView row in view)
{
// Creat the message
message = new MailMessage();
message.Id = row["Id"] as string;
message.Cc = row["CC"] as string;
message.From = row["From"] as string;
message.To = row["To"] as string;
message.SentDate = (DateTime)row["SentDate"];
message.Subject = row["Subject"] as string;
message.Path = row["Path"] as string;
message.Read = (bool)row["Read"];
message.BaseIndex = (int)row["BaseIndex"];
message.ParentFolder = (string)row["ParentFolder"];
// Add the message
messageStore.Messages.Add(message);
// Update count
if (!message.Read)
{
unread++;
}
}
messageStore.UnreadCount = unread;
//// Select first message
//if (messageStore.Messages.Count > 0)
//{
// messageStore.SelectedMessage = (messageStore.Messages[0] as MailMessage);
//}
}
}
