Beispiel #1
0
        public override void DeleteFolder(Folder fld)
        {
            FolderCollection childFolders = _dbMan.SelectFolderChilds(fld.ID);

            foreach (Folder f in childFolders)
            {
                DeleteFolderAndRelatedMessages(f);
            }
            DeleteFolderAndRelatedMessages(fld);
        }
Beispiel #2
0
 public static void SortTree(FolderCollection foldersTree, IComparer comparer)
 {
     Sort(foldersTree, comparer);
     foreach (Folder fld in foldersTree)
     {
         if ((fld.SubFolders != null) && (fld.SubFolders.Count > 0))
         {
             SortTree(fld.SubFolders, comparer);
         }
     }
 }
Beispiel #3
0
 public void CreateFoldersTree(FolderCollection fc)
 {
     foreach (Folder f in fc)
     {
         string delimiter = ((f.ImapFolder != null) && (f.ImapFolder.Delimiter != null)) ? f.ImapFolder.Delimiter : @"\";
         CreateFolder(f.GetFullPath(delimiter));
         if (f.SubFolders.Count > 0)
         {
             CreateFoldersTree(f.SubFolders);
         }
     }
 }
        protected void AutoCheckMailForAccount(Account acct)
        {
            if (acct != null)
            {
                try
                {
                    DbStorage              dbs     = DbStorageCreator.CreateDatabaseStorage(acct);
                    MailProcessor          mp      = new MailProcessor(dbs);
                    WebmailResourceManager _resMan = (new WebmailResourceManagerCreator()).CreateResourceManager();
                    try
                    {
                        mp.MessageDownloaded += new DownloadedMessageHandler(mp_MessageDownloaded);
                        mp.Connect();

                        FolderCollection fc1 = dbs.GetFolders();
                        FolderCollection fc2 = new FolderCollection();
                        foreach (Folder fld in fc1)
                        {
                            if (fld.Type == FolderType.Inbox)
                            {
                                fc2.Add(fld);
                            }
                        }
                        Dictionary <long, string> updatedFolders = mp.Synchronize(fc2);
                        string strFolders = "";
                        foreach (KeyValuePair <long, string> kvp in updatedFolders)
                        {
                            strFolders += "{id: " + kvp.Key.ToString() + ", fullName: '" + kvp.Value + "'}, ";
                        }
                        Response.Write(@"<script type=""text/javascript"">parent.SetUpdatedFolders([" + strFolders.TrimEnd(new char[2] {
                            ',', ' '
                        }) + "], false);</script>");
                    }
                    finally
                    {
                        mp.MessageDownloaded -= new DownloadedMessageHandler(mp_MessageDownloaded);
                        mp.Disconnect();
                    }
                }
                catch (WebMailException ex)
                {
                    Log.WriteException(ex);
                    errorDesc = Utils.EncodeJsSaveString(ex.Message);
                    if (Type == 1 || Type == 2)
                    {
                        Session.Add(Constants.sessionErrorText, errorDesc);
                    }
                }
            }
        }
Beispiel #5
0
 public static void CreateFolderListFromTree(ref FolderCollection resultList, FolderCollection folderTree)
 {
     if (folderTree != null)
     {
         foreach (Folder f in folderTree)
         {
             resultList.Add(f);
             if (f.SubFolders.Count > 0)
             {
                 CreateFolderListFromTree(ref resultList, f.SubFolders);
             }
         }
     }
 }
Beispiel #6
0
 public static void Sort(FolderCollection foldersList, IComparer comparer)
 {
     for (int i = 0; i < foldersList.Count; i++)
     {
         for (int j = 0; j < foldersList.Count; j++)
         {
             int compareResult = foldersList[j].CompareTo(foldersList[i]);
             if (compareResult > 0)
             {
                 Folder temp = foldersList[j];
                 foldersList[j] = foldersList[i];
                 foldersList[i] = temp;
             }
         }
     }
 }
Beispiel #7
0
        public static FolderCollection CreateDatabaseFolderTreeFromList(FolderCollection folderList)
        {
            FolderCollection result = new FolderCollection();

            if (folderList != null)
            {
                foreach (Folder listFolder in folderList)
                {
                    if (!AddDatabaseFolderNodeToTree(listFolder, result))
                    {
                        result.Add(listFolder);
                    }
                }
            }

            return(result);
        }
Beispiel #8
0
        public Folder()
        {
            _id_folder  = -1;
            _id_acct    = -1;
            _id_parent  = -1;
            _type       = FolderType.Custom;
            _name       = "My Folder";
            _full_path  = "";
            _sync_type  = FolderSyncType.AllHeadersOnly;
            _hide       = false;
            _fld_order  = 0;
            _imapFolder = null;
            _subFolders = new FolderCollection();

            _updateName     = null;
            _updateFullPath = null;
            _size           = _messageCount = _unreadMessageCount = 0;
        }
Beispiel #9
0
 protected static bool AddDatabaseFolderNodeToTree(Folder fld, FolderCollection folderList)
 {
     if ((folderList != null) && (fld != null))
     {
         foreach (Folder listFolder in folderList)
         {
             if (listFolder.ID == fld.IDParent)
             {
                 listFolder.SubFolders.Add(fld);
                 return(true);
             }
             bool added = AddDatabaseFolderNodeToTree(fld, listFolder.SubFolders);
             if (added)
             {
                 return(true);
             }
         }
     }
     return(false);
 }
Beispiel #10
0
 public static void Sort(FolderCollection foldersList)
 {
     Sort(foldersList, new FolderOrderer());
 }
Beispiel #11
0
        public Account CreateAccount(bool def_acct, bool deleted, string email, IncomingMailProtocol mail_protocol,
                                     string mail_inc_host, string mail_inc_login, string mail_inc_pass, int mail_inc_port,
                                     string mail_out_host, string mail_out_login, string mail_out_pass, int mail_out_port,
                                     bool mail_out_auth, string friendly_nm, bool use_friendly_nm, DefaultOrder def_order,
                                     bool getmail_at_login, MailMode mail_mode, short mails_on_server_days, string signature,
                                     SignatureType signature_type, SignatureOptions signature_opt, string delimiter, long mailbox_size,
                                     FolderSyncType inboxSyncType, bool advanced_login, int id_domain, bool mailing_list, int imap_quota, string Namespace)
        {
            WebmailResourceManager resMan = (new WebmailResourceManagerCreator()).CreateResourceManager();

            //----- validate incoming data -----
            if ((email == null) || (email.Trim().Length == 0))
            {
                if (advanced_login)
                {
                    throw new WebMailException(resMan.GetString("WarningEmailFieldBlank"));
                }
            }
            Regex r = new Regex(@"[\w!#\$%\^\{}`~&'\+-=_\.]+@[\w-\.]+");
            Match m = r.Match(email);

            if (!m.Success)
            {
                throw new WebMailException("WarningCorrectEmail");
            }
            if ((mail_inc_login == null) || (mail_inc_login.Trim().Length == 0))
            {
                if (advanced_login)
                {
                    throw new WebMailException(resMan.GetString("WarningLoginFieldBlank"));
                }
            }
            if (mail_inc_login.IndexOfAny(new char[] { '"', '/', '\\', '*', '?', '<', '>', '|', ':' }) >= 0)
            {
                throw new WebMailException(resMan.GetString("WarningCorrectLogin"));
            }
            if (string.IsNullOrEmpty(mail_inc_pass))
            {
                throw new WebMailException(resMan.GetString("WarningPassBlank"));
            }
            if ((mail_inc_host == null) || (mail_inc_host.Trim().Length == 0))
            {
                throw new WebMailException(resMan.GetString("WarningIncServerBlank"));
            }
            r = new Regex(@"[^(\w-\.)]+");
            m = r.Match(mail_inc_host);
            if (m.Success)
            {
                if (advanced_login)
                {
                    throw new WebMailException(resMan.GetString("WarningCorrectIncServer"));
                }
            }
            if ((mail_inc_port < 0) || (mail_inc_port > 65535))
            {
                if (advanced_login)
                {
                    throw new WebMailException(resMan.GetString("WarningIncPortNumber"));
                }
            }
            if ((mail_out_host == null) || (mail_out_host.Trim().Length == 0))
            {
                if (advanced_login)
                {
                    throw new WebMailException(resMan.GetString("WarningOutServerBlank"));
                }
            }
            r = new Regex(@"[^(\w-\.)]+");
            m = r.Match(mail_out_host);
            if (m.Success)
            {
                if (advanced_login)
                {
                    throw new WebMailException(resMan.GetString("WarningCorrectOutServer"));
                }
            }
            if ((mail_out_port < 0) || (mail_out_port > 65535))
            {
                if (advanced_login)
                {
                    throw new WebMailException(resMan.GetString("WarningOutPortNumber"));
                }
            }
            //------ end validate incoming data --------


            WebmailSettings  settings   = (new WebMailSettingsCreator()).CreateWebMailSettings();
            Account          newAccount = null;
            DbManagerCreator creator    = new DbManagerCreator();
            DbManager        dbMan      = creator.CreateDbManager();

            try
            {
                dbMan.Connect();

                if (settings.EnableWmServer && mail_protocol == IncomingMailProtocol.WMServer)
                {
                    string          emailDomain  = EmailAddress.GetDomainFromEmail(email);
                    string          emailUser    = EmailAddress.GetAccountNameFromEmail(email);
                    WMServerStorage storage      = new WMServerStorage(null);
                    string[]        domains      = storage.GetDomainList();
                    bool            domainExists = false;

                    foreach (string domain in domains)
                    {
                        if (string.Compare(emailDomain, domain, true, CultureInfo.InvariantCulture) == 0)
                        {
                            Domain dom = Domain.GetDomain(emailDomain);
                            if (dom != null)
                            {
                                id_domain = dom.ID;
                            }

                            WMServerUser[] users             = storage.GetUserList(emailDomain);
                            bool           userExists        = false;
                            bool           mailingListExists = false;
                            foreach (WMServerUser user in users)
                            {
                                if (string.Compare(emailUser, user.Name, true, CultureInfo.InvariantCulture) == 0)
                                {
                                    if (string.Compare("U", user.Type, true, CultureInfo.InvariantCulture) == 0)
                                    {
                                        userExists = true;
                                    }
                                    else
                                    {
                                        mailingListExists = true;
                                    }
                                    break;
                                }
                            }
                            if (!userExists && !mailing_list || !mailingListExists && mailing_list)
                            {
                                if (!mailingListExists)
                                {
                                    storage.AddUser(emailDomain, emailUser, mail_inc_pass);
                                }
                                else
                                {
                                    throw new WebMailException(resMan.GetString("ErrorPOP3IMAP4Auth"));
                                }
                            }
                            domainExists = true;
                            break;
                        }
                    }

                    if (!domainExists)
                    {
                        throw new WebMailException(resMan.GetString("ErrorDomainExist"));
                    }
                }

                if (mail_protocol == IncomingMailProtocol.WMServer)
                {
                    delimiter = ".";
                }

                newAccount = dbMan.CreateAccount(_id, def_acct, deleted, email, mail_protocol, mail_inc_host,
                                                 mail_inc_login, mail_inc_pass, mail_inc_port, mail_out_host, mail_out_login, mail_out_pass,
                                                 mail_out_port, mail_out_auth, friendly_nm, use_friendly_nm, def_order, getmail_at_login,
                                                 mail_mode, mails_on_server_days, signature, signature_type, signature_opt, delimiter,
                                                 mailbox_size, id_domain, mailing_list, imap_quota, Namespace);
                newAccount.UserOfAccount = this;

                dbMan.DbAccount = newAccount;
                FileSystem fs = new FileSystem(email, newAccount.ID, true);
                if (mail_protocol != IncomingMailProtocol.WMServer)
                {
                    fs.CreateAccount();
                }

                if (mail_protocol == IncomingMailProtocol.Pop3)
                {
                    if (settings.AllowDirectMode && settings.DirectModeIsDefault)
                    {
                        inboxSyncType = FolderSyncType.DirectMode;
                    }

                    // -- this fix for gmail pop3 --
                    if (mail_inc_host == "pop.gmail.com")
                    {
                        inboxSyncType = FolderSyncType.AllEntireMessages;
                    }
                    // -----------------------------

                    if (!settings.StoreMailsInDb)
                    {
                        fs.CreateFolder(Constants.FolderNames.Inbox);
                    }
                    dbMan.CreateFolder(newAccount.ID, -1, FolderType.Inbox, Constants.FolderNames.Inbox, Constants.FolderNames.Inbox, inboxSyncType, false, 0);

                    if (!settings.StoreMailsInDb)
                    {
                        fs.CreateFolder(Constants.FolderNames.SentItems);
                    }
                    dbMan.CreateFolder(newAccount.ID, -1, FolderType.SentItems, Constants.FolderNames.SentItems, Constants.FolderNames.SentItems, FolderSyncType.DontSync, false, 1);

                    if (!settings.StoreMailsInDb)
                    {
                        fs.CreateFolder(Constants.FolderNames.Drafts);
                    }
                    dbMan.CreateFolder(newAccount.ID, -1, FolderType.Drafts, Constants.FolderNames.Drafts, Constants.FolderNames.Drafts, FolderSyncType.DontSync, false, 2);

                    if (!settings.StoreMailsInDb)
                    {
                        fs.CreateFolder(Constants.FolderNames.Spam);
                    }
                    dbMan.CreateFolder(newAccount.ID, -1, FolderType.Spam, Constants.FolderNames.Spam, Constants.FolderNames.Spam, FolderSyncType.DontSync, false, 3);

                    if (!settings.StoreMailsInDb)
                    {
                        fs.CreateFolder(Constants.FolderNames.Trash);
                    }
                    dbMan.CreateFolder(newAccount.ID, -1, FolderType.Trash, Constants.FolderNames.Trash, Constants.FolderNames.Trash, FolderSyncType.DontSync, false, 4);
                }
                else if (mail_protocol == IncomingMailProtocol.WMServer)
                {
                    MailServerStorage wmServerStorage = MailServerStorageCreator.CreateMailServerStorage(newAccount);
                    try
                    {
                        wmServerStorage.Connect();
                        FolderCollection fc = wmServerStorage.GetFolders();

                        Folder fld = fc[FolderType.SentItems];
                        if (fld == null)
                        {
                            string       fullPath = newAccount.Delimiter + Constants.FolderNames.SentItems;
                            const string name     = Constants.FolderNames.SentItems;
                            if (!settings.StoreMailsInDb)
                            {
                                fs.CreateFolder(Constants.FolderNames.SentItems);
                            }
                            fld = new Folder(newAccount.ID, -1, fullPath, name);
                            wmServerStorage.CreateFolder(fld);
                            dbMan.CreateFolder(newAccount.ID, -1, FolderType.SentItems, name, fullPath, FolderSyncType.AllHeadersOnly, false, 1);
                        }

                        fld = fc[FolderType.Drafts];
                        if (fld == null)
                        {
                            string       fullPath = newAccount.Delimiter + Constants.FolderNames.Drafts;
                            const string name     = Constants.FolderNames.Drafts;
                            if (!settings.StoreMailsInDb)
                            {
                                fs.CreateFolder(Constants.FolderNames.Drafts);
                            }
                            fld = new Folder(newAccount.ID, -1, fullPath, name);
                            wmServerStorage.CreateFolder(fld);
                            dbMan.CreateFolder(newAccount.ID, -1, FolderType.Drafts, name, fullPath, FolderSyncType.AllHeadersOnly, false, 2);
                        }

                        fld = fc[FolderType.Spam];
                        if (fld == null)
                        {
                            string       fullPath = newAccount.Delimiter + Constants.FolderNames.Spam;
                            const string name     = Constants.FolderNames.Spam;
                            if (!settings.StoreMailsInDb)
                            {
                                fs.CreateFolder(Constants.FolderNames.Spam);
                            }
                            fld = new Folder(newAccount.ID, -1, fullPath, name);
                            wmServerStorage.CreateFolder(fld);
                            dbMan.CreateFolder(newAccount.ID, -1, FolderType.Spam, name, fullPath, FolderSyncType.AllHeadersOnly, false, 3);
                        }

                        fld = fc[FolderType.Trash];
                        if (fld == null)
                        {
                            string       fullPath = newAccount.Delimiter + Constants.FolderNames.Trash;
                            const string name     = Constants.FolderNames.Trash;
                            if (!settings.StoreMailsInDb)
                            {
                                fs.CreateFolder(Constants.FolderNames.Trash);
                            }
                            fld = new Folder(newAccount.ID, -1, fullPath, name);
                            wmServerStorage.CreateFolder(fld);
                            dbMan.CreateFolder(newAccount.ID, -1, FolderType.Trash, name, fullPath, FolderSyncType.AllHeadersOnly, false, 4);
                        }

                        fld = fc[FolderType.Quarantine];
                        if (fld == null)
                        {
                            string       fullPath = newAccount.Delimiter + Constants.FolderNames.Quarantine;
                            const string name     = Constants.FolderNames.Quarantine;
                            if (!settings.StoreMailsInDb)
                            {
                                fs.CreateFolder(Constants.FolderNames.Quarantine);
                            }
                            fld = new Folder(newAccount.ID, -1, fullPath, name);
                            wmServerStorage.CreateFolder(fld);
                            dbMan.CreateFolder(newAccount.ID, -1, FolderType.Quarantine, name, fullPath, FolderSyncType.AllHeadersOnly, false, 5);
                        }

                        dbMan.CreateFoldersTree(fc);
                    }
                    catch (Exception ex)
                    {
                        Log.WriteException(ex);
                        throw new WebMailException(ex);
                    }
                }
                else if (mail_protocol == IncomingMailProtocol.Imap4)
                {
                    MailServerStorage imapStorage = MailServerStorageCreator.CreateMailServerStorage(newAccount);
                    try
                    {
                        imapStorage.Connect();
                        FolderCollection fc  = imapStorage.GetFolders();
                        Folder           fld = fc[FolderType.Inbox];
                        if (fld != null)
                        {
                            fld.SyncType = FolderSyncType.DirectMode;
                        }

//                        if (settings.AllowDirectMode && settings.DirectModeIsDefault)
//                        {
                        fc.ReSetSyncTypeToDirectMode();
//                        }

                        fld = fc[FolderType.Drafts];
                        if (fld == null)
                        {
                            if (!settings.StoreMailsInDb)
                            {
                                fs.CreateFolder(Constants.FolderNames.Drafts);
                            }
                            dbMan.CreateFolder(newAccount.ID, -1, FolderType.Drafts, Constants.FolderNames.Drafts, Constants.FolderNames.Drafts, FolderSyncType.DontSync, false, 2);
                        }

                        fld = fc[FolderType.SentItems];
                        if (fld == null)
                        {
                            if (!settings.StoreMailsInDb)
                            {
                                fs.CreateFolder(Constants.FolderNames.SentItems);
                            }
                            dbMan.CreateFolder(newAccount.ID, -1, FolderType.SentItems, Constants.FolderNames.SentItems, Constants.FolderNames.SentItems, FolderSyncType.DontSync, false, 1);
                        }

                        fld = fc[FolderType.Spam];
                        if (fld == null)
                        {
                            if (!settings.StoreMailsInDb)
                            {
                                fs.CreateFolder(Constants.FolderNames.Spam);
                            }
                            dbMan.CreateFolder(newAccount.ID, -1, FolderType.Spam, Constants.FolderNames.Spam, Constants.FolderNames.Spam, FolderSyncType.DontSync, false, 3);
                        }

                        fld = fc[FolderType.Trash];
                        if (fld == null && settings.Imap4DeleteLikePop3)
                        {
                            if (!settings.StoreMailsInDb)
                            {
                                fs.CreateFolder(Constants.FolderNames.Trash);
                            }
                            dbMan.CreateFolder(newAccount.ID, -1, FolderType.Trash, Constants.FolderNames.Trash, Constants.FolderNames.Trash, FolderSyncType.DontSync, false, 4);
                        }

                        newAccount.Delimiter = (fc.Count > 0) ? fc[0].ImapFolder.Delimiter : newAccount.Delimiter;

                        if (!settings.StoreMailsInDb)
                        {
                            fs.CreateFoldersTree(fc);
                        }
                        dbMan.CreateFoldersTree(fc);
                    }
                    catch (Exception ex)
                    {
                        Log.WriteException(ex);
                        throw new WebMailException(ex);
                    }
                    finally
                    {
                        imapStorage.Disconnect();
                    }
                }
            }
            catch (IOException ex)
            {
                Log.WriteException(ex);
                throw new WebMailException(ex);
            }
            catch (UnauthorizedAccessException ex)
            {
                Log.WriteException(ex);
                throw new WebMailException(ex);
            }
            catch (WebMailException ex)
            {
                Log.WriteException(ex);
                if (newAccount != null)
                {
                    if (dbMan.IsConnected)
                    {
                        dbMan.DeleteAccount(newAccount.ID);
                    }
                    else
                    {
                        dbMan.Connect();
                        dbMan.DeleteAccount(newAccount.ID);
                    }
                }
                throw;
            }
            finally
            {
                dbMan.Disconnect();
            }
            return(newAccount);
        }
Beispiel #12
0
 public static void SortTree(FolderCollection foldersTree)
 {
     SortTree(foldersTree, new FolderOrderer());
 }
Beispiel #13
0
 public virtual WebMailMessageCollection SearchMessages(string condition, FolderCollection folders, bool inHeadersOnly)
 {
     return(_dbMan.SearchMessages(condition, folders, inHeadersOnly));
 }
Beispiel #14
0
 public virtual WebMailMessageCollection SearchMessages(int page, string condition, FolderCollection folders, bool inHeadersOnly, out int searchMessagesCount)
 {
     return(_dbMan.SearchMessages(page, condition, folders, inHeadersOnly, out searchMessagesCount));
 }
Beispiel #15
0
        public override Dictionary <long, string> Synchronize(FolderCollection foldersTree)
        {
            DbStorage        dbStorage = DbStorageCreator.CreateDatabaseStorage(_account);
            FolderCollection folders   = new FolderCollection();

            FolderCollection.CreateFolderListFromTree(ref folders, foldersTree);
            ArrayList pop3Uids             = new ArrayList();
            bool      downloadErrorOccured = false;

            Folder fld = folders[FolderType.Inbox];

            if (fld != null)
            {
                if (fld.SyncType == FolderSyncType.DirectMode)
                {
                    if (!_updatedFolders.ContainsKey(fld.ID))
                    {
                        _updatedFolders.Add(fld.ID, fld.FullPath);
                    }
                    return(_updatedFolders);
                }
                if (fld.SyncType == FolderSyncType.DontSync)
                {
                    return(_updatedFolders);
                }

                try
                {
                    dbStorage.Connect();

                    // get new messages start index
                    string[]  pop3DbUids     = dbStorage.GetUids();
                    string[]  pop3ServerUids = _pop3Obj.GetMessageUids();
                    ArrayList dbUidsToDelete = new ArrayList();
                    ArrayList pop3ServerIndexesToDownload = new ArrayList();

                    foreach (string pop3DbUid in pop3DbUids)
                    {
                        if (Array.IndexOf(pop3ServerUids, pop3DbUid) == -1)
                        {
                            dbUidsToDelete.Add(pop3DbUid);
                        }
                    }

                    foreach (string pop3ServerUid in pop3ServerUids)
                    {
                        if (Array.IndexOf(pop3DbUids, pop3ServerUid) == -1)
                        {
                            pop3ServerIndexesToDownload.Add(_pop3Obj.GetMessageIndexFromUid(pop3ServerUid));
                        }
                    }

                    if ((_account.MailMode == MailMode.KeepMessagesOnServer) ||
                        (_account.MailMode == MailMode.KeepMessagesOnServerAndDeleteMessageWhenItsRemovedFromTrash))
                    {
                        object[] serverUidsToDelete = dbStorage.GetOldMessagesUids(_account.MailsOnServerDays);
                        // delete from server
                        if (serverUidsToDelete.Length > 0)
                        {
                            DeleteMessages(serverUidsToDelete, fld);
                        }
                    }
                    // retrieve new messages
                    GetNewMessagesFromServerAndSaveToDb(dbStorage, fld, (int[])pop3ServerIndexesToDownload.ToArray(typeof(int)), out downloadErrorOccured, ref pop3Uids);

                    if ((fld.SyncType == FolderSyncType.NewEntireMessages) ||
                        (fld.SyncType == FolderSyncType.NewHeadersOnly))
                    {
                        return(_updatedFolders);
                    }
                    // delete messages from db
                    if (dbUidsToDelete.Count > 0)
                    {
                        WebMailMessageCollection msgsToDelete = dbStorage.LoadMessagesByUids((string[])dbUidsToDelete.ToArray(typeof(string)), fld, false);
                        dbStorage.DeleteMessages(msgsToDelete.ToIDsCollection(), fld);
                        if (!_updatedFolders.ContainsKey(fld.ID))
                        {
                            _updatedFolders.Add(fld.ID, fld.FullPath);
                        }
                    }
                }
                finally
                {
                    if (!downloadErrorOccured)
                    {
                        // get all uids and save it to db
                        pop3Uids = ArrayList.Adapter(_pop3Obj.GetMessageUids());
                        dbStorage.ReplaceUids(pop3Uids.ToArray());
                    }
                    else
                    {
                        dbStorage.SaveUids(pop3Uids.ToArray());
                    }
                    dbStorage.Disconnect();
                }
            }
            return(_updatedFolders);
        }
Beispiel #16
0
 public virtual Dictionary <long, string> Synchronize(FolderCollection foldersTree)
 {
     return(_updatedFolders);
 }
Beispiel #17
0
        public static Account LoginAccount(string email, string login, string password, string incomingMailServer,
                                           IncomingMailProtocol incomingMailProtocol, int incomingPort, string outgoingMailServer,
                                           int outgoingMailPort, bool useSmtpAuthentication, bool signAutomatically, bool advanced_login,
                                           string language)
        {
            WebmailSettings settings  = (new WebMailSettingsCreator()).CreateWebMailSettings();
            string          tempLogin = login;

            if (!advanced_login)
            {
                switch (settings.HideLoginMode)
                {
                case LoginMode.HideLoginFieldLoginIsAccount:
                    login     = EmailAddress.Parse(email).GetAccountName();
                    tempLogin = null;
                    break;

                case LoginMode.HideLoginFieldLoginIsEmail:
                    login     = email;
                    tempLogin = null;
                    break;

                case LoginMode.HideEmailField:
                case LoginMode.HideEmailFieldDisplayDomainAfterLogin:
                    email = string.Format("{0}@{1}", login, settings.DefaultDomainOptional);
                    break;

                case LoginMode.HideEmailFieldLoginIsLoginAndDomain:
                case LoginMode.HideEmailFieldDisplayDomainAfterLoginAndLoginIsLoginAndDomain:
                    email     = string.Format("{0}@{1}", login, settings.DefaultDomainOptional);
                    login     = email;
                    tempLogin = email;
                    break;
                }
            }

            WebmailResourceManager resMan = (new WebmailResourceManagerCreator()).CreateResourceManager();

            string domainName = EmailAddress.GetDomainFromEmail(email);
            Domain domain     = LoadDomainFromDb(domainName);

/*
 *                      if (domain != null && (domain.MailIncomingProtocol == IncomingMailProtocol.WMServer ||
 *                              incomingMailProtocol == IncomingMailProtocol.WMServer) && settings.EnableWmServer)
 *                      {
 *                              tempLogin = EmailAddress.GetAccountNameFromEmail(tempLogin);
 *                              if (tempLogin != null && tempLogin != EmailAddress.GetAccountNameFromEmail(email))
 *                              {
 *                                      throw new WebMailException(resMan.GetString("ErrorPOP3IMAP4Auth"));
 *                              }
 *                      }
 */
            Account result = LoadFromDb(email, tempLogin, null);

            if (result == null)
            {
                if (!settings.AllowNewUsersRegister)
                {
                    throw new WebMailException(resMan.GetString("ErrorPOP3IMAP4Auth"));
                }
                if (domain != null)
                {
                    if (settings.AllowNewUsersRegister && domain.MailIncomingProtocol == IncomingMailProtocol.WMServer)
                    {
                        throw new WebMailException(resMan.GetString("ErrorPOP3IMAP4Auth"));
                    }
                }

                Account acct = new Account();
                if (domain != null && (domain.MailIncomingProtocol != IncomingMailProtocol.WMServer || settings.EnableWmServer))
                {
                    acct.Email = email;
                    if (domain.MailIncomingProtocol == IncomingMailProtocol.WMServer)
                    {
                        acct.MailIncomingLogin = EmailAddress.GetAccountNameFromEmail(email);
                    }
                    else
                    {
                        acct.MailIncomingLogin = login;
                    }
                    acct.MailIncomingPassword       = password;
                    acct.MailIncomingHost           = domain.MailIncomingHost;
                    acct.MailIncomingPort           = domain.MailIncomingPort;
                    acct.MailIncomingProtocol       = domain.MailIncomingProtocol;
                    acct.MailOutgoingHost           = domain.MailOutgoingHost;
                    acct.MailOutgoingPort           = domain.MailOutgoingPort;
                    acct.MailOutgoingAuthentication = domain.MailOutgoingAuthentication;
                    acct.IDDomain = domain.ID;
                }
                else
                {
                    acct.Email                      = email;
                    acct.MailIncomingLogin          = login;
                    acct.MailIncomingPassword       = password;
                    acct.MailIncomingHost           = incomingMailServer;
                    acct.MailIncomingPort           = incomingPort;
                    acct.MailIncomingProtocol       = incomingMailProtocol;
                    acct.MailOutgoingHost           = outgoingMailServer;
                    acct.MailOutgoingPort           = outgoingMailPort;
                    acct.MailOutgoingAuthentication = useSmtpAuthentication;
                    acct.IDDomain                   = 0;
                }

                bool isWmServer = (acct.MailIncomingProtocol == IncomingMailProtocol.WMServer);
                bool isIMAP4    = (acct.MailIncomingProtocol == IncomingMailProtocol.Imap4);
                if (!isWmServer)
                {
                    MailServerStorage mss = MailServerStorageCreator.CreateMailServerStorage(acct);
                    try
                    {
                        mss.Connect();
                    }
                    finally
                    {
                        if (mss.IsConnected())
                        {
                            mss.Disconnect();
                        }
                    }
                }
                User usr = null;
                try
                {
                    usr = User.CreateUser();
                    FolderSyncType syncType = Folder.DefaultInboxSyncType;
                    if (settings.DirectModeIsDefault)
                    {
                        syncType = FolderSyncType.DirectMode;
                    }
                    if (isWmServer)
                    {
                        syncType = FolderSyncType.AllHeadersOnly;
                    }
                    if (isIMAP4)
                    {
                        syncType = FolderSyncType.DirectMode;
                    }

                    result = usr.CreateAccount(acct, syncType, advanced_login);
                }
                catch (WebMailException)
                {
                    if (null != usr)
                    {
                        User.DeleteUserSettings(usr.ID);
                    }
                    throw;
                }
            }
            else
            {
                if (result.UserOfAccount.Deleted)
                {
                    throw new WebMailException((new WebmailResourceManagerCreator()).CreateResourceManager().GetString("ErrorMaximumUsersLicenseIsExceeded"));
                }

                if (result.Deleted)
                {
                    throw new WebMailException("Your account is inactive, please contact the system administrator on this.");
                }

                if (string.Compare(result.MailIncomingPassword, password, false, CultureInfo.InvariantCulture) != 0)
                {
                    result.MailIncomingPassword = password;
                    MailServerStorage mss = MailServerStorageCreator.CreateMailServerStorage(result);
                    try
                    {
                        mss.Connect();
                    }
                    finally
                    {
                        if (mss.IsConnected())
                        {
                            mss.Disconnect();
                        }
                    }
                }

                if (result.DefaultAccount == false)
                {
                    DbManagerCreator creator = new DbManagerCreator();
                    DbManager        dbMan   = creator.CreateDbManager();
                    int nonDefaultCount;
                    try
                    {
                        dbMan.Connect();
                        nonDefaultCount = dbMan.GetNotDefaultAccountCount(email, login, password);
                    }
                    finally
                    {
                        dbMan.Disconnect();
                    }
                    if (nonDefaultCount > 1)
                    {
                        throw new WebMailException((new WebmailResourceManagerCreator()).CreateResourceManager().GetString("PROC_CANT_LOG_NONDEF"));
                    }
                }
            }
            if ((result != null) && (result.UserOfAccount != null) && (result.UserOfAccount.Settings != null))
            {
                result.UserOfAccount.Settings.LastLogin = DateTime.Now;
                result.UserOfAccount.Settings.LoginsCount++;
                if (!string.IsNullOrEmpty(language) && settings.AllowLanguageOnLogin)
                {
                    result.UserOfAccount.Settings.DefaultLanguage = language;
                }

                if (result.MailIncomingProtocol == IncomingMailProtocol.Imap4)
                {
                    ImapStorage imapStorage = new ImapStorage(result);
                    try
                    {
                        imapStorage.Connect();
                        result.Namespace = imapStorage.GetNamespace();

                        if (settings.TakeImapQuota)
                        {
                            if (imapStorage.IsQuotaSupported())
                            {
                                if (result.Imap_quota != 0)
                                {
                                    result.Imap_quota = 1;
                                    result.UserOfAccount.Settings.MailboxLimit = imapStorage.GetMailStorageSize();
                                }
                            }
                            else
                            {
                                result.Imap_quota = -1;
                            }
                        }
                    }
                    finally
                    {
                        imapStorage.Disconnect();
                    }
                }

                result.Update(true);
            }

            // Create Trash Folder if Trash not found in the list
            if (result != null && result.MailIncomingProtocol == IncomingMailProtocol.WMServer)
            {
                MailServerStorage wmServerStorage = MailServerStorageCreator.CreateMailServerStorage(result);

                try
                {
                    wmServerStorage.Connect();
                    FolderCollection fc = wmServerStorage.GetFolders();

                    FileSystem fs  = new FileSystem(result.Email, result.ID, true);
                    Folder     fld = fc[FolderType.Trash];
                    if (fld == null)
                    {
                        string       fullPath = result.Delimiter + Constants.FolderNames.Trash;
                        const string name     = Constants.FolderNames.Trash;
                        if (!settings.StoreMailsInDb)
                        {
                            fs.CreateFolder(Constants.FolderNames.Trash);
                        }
                        fld = new Folder(result.ID, -1, fullPath, name);
                        wmServerStorage.CreateFolder(fld);

                        DbManagerCreator creator = new DbManagerCreator();
                        DbManager        dbMan   = creator.CreateDbManager();
                        try
                        {
                            dbMan.Connect();
                            dbMan.CreateFolder(result.ID, -1, FolderType.Trash, name, fullPath, FolderSyncType.AllHeadersOnly, false, 3);
                        }
                        finally
                        {
                            dbMan.Disconnect();
                        }
                    }
                }
                catch { }
            }

            return(result);
        }
Beispiel #18
0
        public static FolderCollection CreateImapFolderTreeFromList(MailBee.ImapMail.FolderCollection folderList,
                                                                    MailBee.ImapMail.FolderCollection subscribedFolderList)
        {
            FolderCollection result = new FolderCollection();

            if (folderList != null)
            {
                int nestingLevel = 0;
                int addedCount   = 0;
                while (folderList.Count > addedCount)
                {
                    for (int i = 0; i < folderList.Count; i++)
                    {
                        MailBee.ImapMail.Folder fld = folderList[i];
                        if (fld.NestingLevel == nestingLevel)
                        {
                            bool hide      = true;
                            int  subsCount = subscribedFolderList.Count;
                            for (int j = 0; j < subsCount; j++)
                            {
                                if (fld.Name == subscribedFolderList[j].Name)
                                {
                                    hide = false;
                                    subscribedFolderList.RemoveAt(j);
                                    subsCount--;
                                    break;
                                }
                            }
                            if (nestingLevel == 0)
                            {
                                result.Add(new Folder(fld, hide));
                            }
                            else
                            {
                                foreach (Folder resultFolder in result)
                                {
                                    if (string.Compare(string.Format("{0}{1}{2}", resultFolder.ImapFolder.Name, resultFolder.ImapFolder.Delimiter, fld.ShortName), fld.Name, true, CultureInfo.InvariantCulture) == 0)
                                    {
                                        resultFolder.SubFolders.Add(new Folder(fld, hide));
                                        break;
                                    }

                                    foreach (Folder resultFolder2 in resultFolder.SubFolders)
                                    {
                                        if (string.Compare(string.Format("{0}{1}{2}", resultFolder2.ImapFolder.Name, resultFolder2.ImapFolder.Delimiter, fld.ShortName), fld.Name, true, CultureInfo.InvariantCulture) == 0)
                                        {
                                            resultFolder2.SubFolders.Add(new Folder(fld, hide));
                                            break;
                                        }

                                        foreach (Folder resultFolder3 in resultFolder2.SubFolders)
                                        {
                                            if (string.Compare(string.Format("{0}{1}{2}", resultFolder3.ImapFolder.Name, resultFolder3.ImapFolder.Delimiter, fld.ShortName), fld.Name, true, CultureInfo.InvariantCulture) == 0)
                                            {
                                                resultFolder3.SubFolders.Add(new Folder(fld, hide));
                                                break;
                                            }

                                            foreach (Folder resultFolder4 in resultFolder3.SubFolders)
                                            {
                                                if (string.Compare(string.Format("{0}{1}{2}", resultFolder4.ImapFolder.Name, resultFolder4.ImapFolder.Delimiter, fld.ShortName), fld.Name, true, CultureInfo.InvariantCulture) == 0)
                                                {
                                                    resultFolder4.SubFolders.Add(new Folder(fld, hide));
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            addedCount++;
                        }
                    }
                    nestingLevel++;
                }
            }

            return(result);
        }