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