public WriteNewMessageNotification(Account currentAccount, string subject, string textBody, string htmlBody, Dictionary<string, string> savedAttachments, Dictionary<string, string> cidAttachments) { CurrentAccount = currentAccount; Subject = "FW: " + subject; TextBody = textBody; HtmlBody = htmlBody; SavedAttachments = savedAttachments; CidAttachments = cidAttachments; }
public AccountViewModel(Account account) { if (account == null) { throw new ArgumentNullException("account", "AccountViewModel constructor was expecting an Account object; received null."); } Account = account; MailboxViewModelTree = ConstructMailboxViewModelTree(Account.Mailboxes.ToList()); Account.PropertyChanged += HandleModelPropertyChanged; Account.Mailboxes.CollectionChanged += HandleMailboxListChanged; }
public bool DeleteAccount(Account account) { string error; bool success = DatabaseManager.DeleteAccount(account, out error); if (!success) { Error = error; return false; } Accounts.Remove(account); GlobalEventAggregator.Instance.GetEvent<AccountDeletedEvent>().Publish(account.AccountName); return true; }
// Returns true if successfully added the account. False, otherwise. public bool AddAccount(Account account) { string error; bool success = DatabaseManager.InsertAccount(account, out error); if (success) { Accounts.Add(account); BeginSyncMailboxList(account); GlobalEventAggregator.Instance.GetEvent<NewAccountAddedEvent>().Publish(account); } else { Error = error; } return success; }
// Updates the mailbox tree in the specified account with ones from the server. // Also updates the database to reflect the change. private void BeginSyncMailboxList(Account account) { Task.Factory.StartNew(() => { List<Mailbox> localMailboxes = DatabaseManager.GetMailboxes(account.AccountName); ImapClient imapClient = new ImapClient(account); if (imapClient.Connect()) { List<Mailbox> serverMailboxes = imapClient.ListMailboxes(); var comparer = new CompareMailbox(); var localNotServer = localMailboxes.Except(serverMailboxes, comparer).ToList(); var serverNotLocal = serverMailboxes.Except(localMailboxes, comparer).ToList(); if (localNotServer.Count > 0 || serverNotLocal.Count > 0) { account.Mailboxes.Clear(); account.Mailboxes.AddRange(serverMailboxes); if (localNotServer.Count > 0) { DatabaseManager.DeleteMailboxes(localNotServer); } if (serverNotLocal.Count > 0) { DatabaseManager.InsertMailboxes(serverNotLocal); } } imapClient.Disconnect(); } while (!Common.Globals.BootStrapperLoaded) { // We don't want to fire this event before the subscribers are ready. // There must be a better way to handle these sort of things. Thread.Sleep(50); } GlobalEventAggregator.Instance.GetEvent<MailboxListSyncFinishedEvent>().Publish(account); }); }
private void HandleAccountSelection(Account selectedAccount) { this.selectedAccount = selectedAccount; }
private void HandleAccountAdded(Account obj) { RaiseCanExecuteChanged(); }
public SmtpClient(Account account, OutgoingEmail email) { Account = account; NewEmail = email; }
public SmtpClient(Account account) { Account = account; }
public WriteNewMessageNotification(Account currentAccount) { CurrentAccount = currentAccount; }
private void HandleNewAccountAddedEvent(Account newAccount) { if (newAccount == null) { throw new ArgumentNullException("newAccount"); } AccountViewModel newAccountViewModel = new AccountViewModel(newAccount); Application.Current.Dispatcher.Invoke(() => { AccountViewModels.Add(newAccountViewModel); }); }
public ImapClient(Account account) { Account = account; }
private void SyncExistingMessageHeaders(Account account, string mailboxName, ImapClient imapClientOnSelectedStatus, int firstUid, int lastUid) { Trace.WriteLine("SyncExistingMessageHeaders: Mailbox(" + mailboxName + "), UIDs(" + firstUid + ", " + lastUid + ")"); // Decrement this at every exit point. openSyncOps.AddOrUpdate(account.AccountName, 1, (k, v) => v + 1); // Delete all messages that have been deleted from server. List<int> serverUids = new List<int>(); bool searchSuccess = imapClientOnSelectedStatus.SearchUids("ALL", serverUids); if (searchSuccess) { List<string> keysToDelete = new List<string>(); foreach (KeyValuePair<string, Message> entry in MessagesDico) { Message msg = entry.Value; if (msg.AccountName == account.AccountName && msg.MailboxPath == mailboxName && !serverUids.Contains(msg.Uid)) { keysToDelete.Add(entry.Key); } } List<Message> msgsDeleted = new List<Message>(); foreach (string key in keysToDelete) { Message msg = MessagesDico[key]; MessagesDico.Remove(key); OnMessageRemoved(msg); msgsDeleted.Add(msg); } DatabaseManager.DeleteMessages(msgsDeleted); } // Now synchronize the remaining messages. int messagesCount = lastUid - firstUid + 1; int downloadChunk = this.downloadChunkSize; int startUid = lastUid - downloadChunk + 1; int endUid = lastUid; while (endUid >= firstUid) { int abort = 0; if (abortLatches.TryGetValue(account.AccountName, out abort) && abort == 1) { Trace.WriteLine("Aborting sync..."); openSyncOps.AddOrUpdate(account.AccountName, 0, (k, v) => v - 1); return; } if (startUid < firstUid) { startUid = firstUid; } List<Message> serverMsgs = imapClientOnSelectedStatus.FetchHeaders(startUid, endUid - startUid + 1, true); if (serverMsgs.Count > 0) { List<Message> messagesAdded = new List<Message>(); foreach (Message serverMsg in serverMsgs) { Message localMsg; if (MessagesDico.TryGetValue(serverMsg.UniqueKeyString, out localMsg)) { // A local copy exists. Update its flags. if (localMsg.FlagString != serverMsg.FlagString) { localMsg.FlagString = serverMsg.FlagString; OnMessageModified(localMsg); } } else { MessagesDico.Add(serverMsg.UniqueKeyString, serverMsg); OnMessageAdded(serverMsg); messagesAdded.Add(serverMsg); } } DatabaseManager.StoreMessages(messagesAdded); } endUid = startUid - 1; startUid = endUid - downloadChunk + 1; } openSyncOps.AddOrUpdate(account.AccountName, 0, (k, v) => v - 1); }
private void SyncNewMessageHeaders(Account account, string mailboxName, ImapClient imapClientOnSelectedStatus, int firstUid, int lastUid) { Trace.WriteLine("SyncNewMessageHeaders: Mailbox(" + mailboxName + "), UIDs(" + firstUid + ", " + lastUid + ")"); // Decrement this at every exit point. openSyncOps.AddOrUpdate(account.AccountName, 1, (k, v) => v + 1); int messagesCount = lastUid - firstUid + 1; int downloadChunk = this.downloadChunkSize; int startUid = lastUid - downloadChunk + 1; int endUid = lastUid; while (endUid >= firstUid) { int abort = 0; if (abortLatches.TryGetValue(account.AccountName, out abort) && abort == 1) { Trace.WriteLine("Aborting sync..."); openSyncOps.AddOrUpdate(account.AccountName, 0, (k, v) => v - 1); return; } if (startUid < firstUid) { startUid = firstUid; } List<Message> msgs = imapClientOnSelectedStatus.FetchHeaders(startUid, endUid - startUid + 1, true); if (msgs.Count > 0) { foreach (Message msg in msgs) { if (!MessagesDico.ContainsKey(msg.UniqueKeyString)) { MessagesDico.Add(msg.UniqueKeyString, msg); OnMessageAdded(msg); } } DatabaseManager.StoreMessages(msgs); } endUid = startUid - 1; startUid = endUid - downloadChunk + 1; } openSyncOps.AddOrUpdate(account.AccountName, 0, (k, v) => v - 1); }
private void SyncMessage(Account account, string mailboxName) { int abort = 0; if (abortLatches.TryGetValue(account.AccountName, out abort) && abort == 1) { // Abort sync. return; } ImapClient imapClient = new ImapClient(account); if (!imapClient.Connect()) { Trace.WriteLine(imapClient.Error); return; } ExamineResult status; bool readOnly = true; if (!imapClient.SelectMailbox(mailboxName, readOnly, out status)) { Debug.WriteLine("MessageManager.SyncMessage(): Unable to select mailbox " + mailboxName + ".\n" + imapClient.Error); imapClient.Disconnect(); return; } int localLargestUid = DatabaseManager.GetMaxUid(account.AccountName, mailboxName); // Download the recent message headers that have never been downloaded yet. int serverLargestUid = status.UidNext - 1; if (serverLargestUid > localLargestUid) { SyncNewMessageHeaders(account, mailboxName, imapClient, localLargestUid + 1, serverLargestUid); } // Sync changes to the existing message headers (flags, etc.). if (localLargestUid > 0) { SyncExistingMessageHeaders(account, mailboxName, imapClient, 1, localLargestUid); } imapClient.Disconnect(); }
// Syncs messages one mailbox at a time. private async void SyncMessagesMultipleMailboxes(Account account, List<string> mailboxNames) { foreach (string mailboxName in mailboxNames) { await Task.Run(() => { SyncMessage(account, mailboxName); }); } }
private void BeginSyncMessages(Account account) { Trace.WriteLine("BeginSyncMessages: " + account.AccountName); abortLatches.AddOrUpdate(account.AccountName, 0, (k, v) => v = 0); List<Mailbox> mailboxes = DatabaseManager.GetMailboxes(account.AccountName); for (int i = mailboxes.Count - 1; i >= 0; --i) { if (mailboxes[i].Flags.Contains(@"\Noselect")) { mailboxes.RemoveAt(i); } } // Sync inbox immediately from a separate thread. foreach (Mailbox mailbox in mailboxes) { if (mailbox.MailboxName.ToLower() == "inbox") { Task.Run(() => { SyncMessage(account, mailbox.DirectoryPath); }); BeginMonitor(account, mailbox.DirectoryPath); mailboxes.Remove(mailbox); break; } } // Sync the other mailboxes one at a time. List<string> mailboxNames = new List<string>(); foreach (Mailbox mbox in mailboxes) { mailboxNames.Add(mbox.DirectoryPath); } SyncMessagesMultipleMailboxes(account, mailboxNames); }
private void Submit() { if (AccountValidated) { Account account = new Account(); account.AccountName = EmailAddress; account.EmailAddress = EmailAddress; account.ImapLoginName = LoginName; account.ImapLoginPassword = LoginPassword; account.ImapServerName = ImapServerName; account.ImapPortNumber = Convert.ToInt32(ImapPortString); account.SmtpLoginName = LoginName; account.SmtpLoginPassword = LoginPassword; account.SmtpServerName = SmtpServerName; account.SmtpPortNumber = Convert.ToInt32(SmtpPortString); AccountManager accountManager = AccountManager.Instance; bool success = accountManager.AddAccount(account); if (success) { FinishInteraction(); } else { Message = accountManager.Error; } } }
private void BeginMonitor(Account account, string mailboxName) { Trace.WriteLine("BeginMonitor " + account.AccountName); ImapClient imapClient = new ImapClient(account); if (!imapClient.Connect()) { Debug.WriteLine(imapClient.Error); return; } imapClient.NewMessageAtServer += HandleNewMessageAtServer; imapClient.MessageDeletedAtServer += HandleMessageDeletedAtServer; imapClient.MessageSeenAtServer += HandleMessageSeenAtServer; imapClient.MessageUnseenAtServer += HandleMessageUnseenAtServer; imapClient.BeginMonitor(mailboxName); }
private void HandleMailboxListSyncFinished(Account account) { // Don't change selection if an item is already selected. if (SelectedTreeViewItem != null) { return; } // Select the first mailbox. foreach (AccountViewModel accountVm in AccountViewModels) { if (accountVm.Account.AccountName == account.AccountName) { Application.Current.Dispatcher.Invoke(() => { if (accountVm.MailboxViewModelTree.Count > 0) { accountVm.MailboxViewModelTree[0].IsSelected = true; } }); break; } } }
public NewAccountValidator(Account account) { Account = account; }
private void HandleMailboxListSyncFinished(Account account) { BeginSyncMessages(account); }
private void ValidateConnection() { int imapPortNumber = -1; int smtpPortNumber = -1; string numberPattern = @"^\d+$"; Regex numberChecker = new Regex(numberPattern); if (numberChecker.IsMatch(ImapPortString)) { imapPortNumber = Convert.ToInt32(ImapPortString); if (imapPortNumber >= 0 && imapPortNumber <= 65536) { ImapPortStringValidated = true; } } if (numberChecker.IsMatch(SmtpPortString)) { smtpPortNumber = Convert.ToInt32(SmtpPortString); if (smtpPortNumber >= 0 && smtpPortNumber <= 65536) { SmtpPortStringValidated = true; } } if (AllInputValidated) { Account tempAccount = new Account() { ImapServerName = ImapServerName, ImapPortNumber = imapPortNumber, ImapLoginName = LoginName, ImapLoginPassword = LoginPassword, SmtpServerName = SmtpServerName, SmtpPortNumber = smtpPortNumber, SmtpLoginName = LoginName, SmtpLoginPassword = LoginPassword }; NewAccountValidator validator = new NewAccountValidator(tempAccount); if (validator.Validate()) { AccountValidated = true; Message = "Validated"; } else { AccountValidated = false; ValidationFailed = true; Message = validator.Error; } } }
public MessageContentViewNotification(Account account, Mailbox mailbox, Message message) { SelectedAccount = account; SelectedMailbox = mailbox; SelectedMessage = message; }