protected void Page_Load(object sender, System.EventArgs e)
{
if (Session["AUTH"] == null)
{
return;
}
Utils.SettingsPath = AdminPanelUtils.GetWebMailFolder();
#region Convert Settings in settings.xml
WebmailSettings wmsNew = new WebmailSettings().CreateInstance(AdminPanelUtils.GetWebMailDataFolder());
sb.AppendFormat("<font color='black' sise='3' face='verdana'><b>{1}</b>. Start convert settings.xml</font><BR />", "settings.xml", _allOps + 1);
_allOps++;
try
{
wmsNew.SaveWebmailSettings(AdminPanelUtils.GetWebMailDataFolder());
sb.AppendFormat("<font color='grey' sise='3' face='verdana'>- Convert settings successful.</font><BR /><BR />");
}
catch (Exception ex)
{
sb.AppendFormat("<font color='grey' sise='3' face='verdana'>- {0}</font><BR /><BR />", ex.Message);
_errorCounter++;
}
# endregion
public Pop3Storage(Account account) : base(account)
{
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
try
{
Pop3.LicenseKey = settings.LicenseKey;
_pop3Obj = new Pop3();
_pop3Obj.MessageDownloaded += new Pop3MessageDownloadedEventHandler(_pop3Obj_MessageDownloaded);
if (settings.EnableLogging)
{
_pop3Obj.Log.Enabled = true;
string dataFolderPath = Utils.GetDataFolderPath();
if (dataFolderPath != null)
{
_pop3Obj.Log.Filename = Path.Combine(dataFolderPath, Constants.logFilename);
}
}
}
catch (MailBeeException ex)
{
Log.WriteException(ex);
throw new WebMailException(ex.Message);
}
}
public static User CreateUser()
{
WebmailResourceManager resMan = (new WebmailResourceManagerCreator()).CreateResourceManager();
User newUser = null;
DbManagerCreator creator = new DbManagerCreator();
DbManager dbMan = creator.CreateDbManager();
try
{
dbMan.Connect();
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
int LicensesNum = Utils.GetLicensesNum(settings.LicenseKey);
int Users = dbMan.GetUsersCountNotDel();
bool Deleted = ((LicensesNum > 0) && (Users >= LicensesNum)) ? true : false;
if (!Deleted)
{
newUser = dbMan.CreateUser(Deleted);
}
else
{
throw new WebMailException(resMan.GetString("ErrorMaximumUsersLicenseIsExceeded"));
}
}
finally
{
dbMan.Disconnect();
}
return(newUser);
}
public DbManager CreateDbManager(string dataPath)
{
DbManager newManager = null;
WebmailSettings settings = new WebmailSettings().CreateInstance(dataPath);
switch (settings.DbType)
{
case SupportedDatabase.MsAccess:
newManager = new MsAccessDbManager();
break;
case SupportedDatabase.MySql:
newManager = new MySqlDbManager();
break;
case SupportedDatabase.PostgreSql:
newManager = new PostgreSqlDbManager();
break;
default:
newManager = new MsSqlDbManager();
break;
}
return(newManager);
}
public DbManager CreateDbManager()
{
DbManager newManager = null;
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
switch (settings.DbType)
{
case SupportedDatabase.PostgreSql:
newManager = new PostgreSqlDbManager();
break;
case SupportedDatabase.MsAccess:
newManager = new MsAccessDbManager();
break;
case SupportedDatabase.MySql:
newManager = new MySqlDbManager();
break;
default:
newManager = new MsSqlDbManager();
break;
}
return(newManager);
}
protected void Page_Init(object sender, EventArgs e)
{
// if not in cache, create new
WordDictionary = new NetSpell.SpellChecker.Dictionary.WordDictionary();
WordDictionary.EnableUserFile = false;
//getting folder for dictionaries
string dicFolder = Path.Combine(Utils.GetDataFolderPath(), @"dictionary");
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
string defLang = settings.DefaultLanguage;
Account acct = (Account)Session[Constants.sessionAccount];
if (acct != null)
{
defLang = acct.UserOfAccount.Settings.DefaultLanguage;
}
string dictionaryFile = "en-US.dic";
switch (defLang)
{
case "French": dictionaryFile = "fr-FR.dic"; break;
case "German": dictionaryFile = "de-DE.dic"; break;
}
WordDictionary.DictionaryFolder = dicFolder;
WordDictionary.DictionaryFile = dictionaryFile;
//load and initialize the dictionary
WordDictionary.Initialize();
// create spell checker
SpellChecker = new Spelling();
SpellChecker.ShowDialog = false;
SpellChecker.Dictionary = WordDictionary;
}
public static Account LoginAccount(string email, string login, string password)
{
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
return(LoginAccount(email, login, password, settings.IncomingMailServer, settings.IncomingMailProtocol,
settings.IncomingMailPort, settings.OutgoingMailServer, settings.OutgoingMailPort,
settings.ReqSmtpAuth, false, false, ""));
}
protected void SubmitButton_Click(object sender, System.EventArgs e)
{
bool flag = false;
try
{
AdminPanelSettings apSettings = new AdminPanelSettings().Load();
string licenseKeyFromForm = txtLicenseKey.Value ?? string.Empty;
if (string.IsNullOrEmpty(licenseKeyFromForm))
{
apSettings.LicenseKey = licenseKeyFromForm;
flag = false;
}
else
{
try
{
Pop3.LicenseKey = licenseKeyFromForm.Substring(0, 39);
Pop3 pop = new Pop3();
flag = true;
}
catch (Exception error)
{
Log.WriteException(error);
_errorMessage = "License Key is invalid";
GetLicenseUrl.Visible = true;
flag = false;
}
apSettings.LicenseKey = licenseKeyFromForm;
}
if (File.Exists(Path.Combine(AdminPanelUtils.GetWebMailDataFolder(), @"settings\settings.xml")))
{
WebmailSettings settings = new WebmailSettings().CreateInstance(AdminPanelUtils.GetWebMailDataFolder());
settings.LicenseKey = licenseKeyFromForm;
settings.SaveWebmailSettings(AdminPanelUtils.GetWebMailDataFolder());
}
apSettings.Save();
_errorMessage = Constants.mailAdmSaveSuccess;
if (flag == true)
{
Session["LicenseKey"] = txtLicenseKey.Value;
Response.Redirect("install.aspx?mode=db", true);
}
else
{
_errorMessage = "Please specify valid license key.";
}
}
catch (Exception error)
{
Log.WriteException(error);
_errorMessage = Constants.mailAdmSaveUnsuccess;
}
}
private bool Save()
{
Session["TrySqlPassword"] = null;
try
{
WebmailSettings settings = new WebmailSettings().CreateInstance(AdminPanelUtils.GetWebMailDataFolder());
Regex r = new Regex(@"[^a-zA-Z0-9_]");
settings.DbPrefix = r.Replace(DbPrefix.Value, "_");
bool res = true;
if (settings.DbPrefix != DbPrefix.Value)
{
res = false;
}
if (intDbTypeMsAccess.Checked)
{
settings.DbType = SupportedDatabase.MsAccess;
settings.DbPrefix = "";
}
else if (intDbTypeMySql.Checked)
{
settings.DbType = SupportedDatabase.MySql;
}
else
{
settings.DbType = SupportedDatabase.MsSqlServer;
}
settings.DbLogin = txtSqlLogin.Value;
settings.DbPassword = txtSqlPassword.Text;
settings.DbName = txtSqlName.Value;
settings.DbDsn = txtSqlDsn.Value;
settings.DbHost = txtSqlSrc.Value;
settings.DbPathToMdb = txtAccessFile.Value;
settings.DbCustomConnectionString = odbcConnectionString.Value;
settings.UseCustomConnectionString = useCS.Checked;
settings.UseDSN = useDSN.Checked;
settings.SaveWebmailSettings(AdminPanelUtils.GetWebMailDataFolder());
Session.Remove(Constants.sessionDbManager);
Context.Application.Remove(Constants.sessionSettings);
if (!res)
{
_errorMessage = @"<font color=""red"">Only letters, digits and underscore (""_"") allowed.</font>";
}
return(res);
}
catch (Exception error)
{
Log.WriteException(error);
_errorMessage = @"<font color=""red"">" + Constants.mailAdmSaveUnsuccess + ": " + error.Message + "</font>";
return(false);
}
}
public Domain(int id_account, string name, IncomingMailProtocol mail_protocol,
string mail_inc_host, int mail_inc_port, string mail_out_host,
int mail_out_port, bool mail_out_auth)
{
_id = id_account;
_name = name;
_mailProtocol = mail_protocol;
_mailIncHost = mail_inc_host;
_mailIncPort = mail_inc_port;
_mailOutHost = mail_out_host;
_mailOutPort = mail_out_port;
_mailOutAuthentication = mail_out_auth;
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
_url = string.Empty;
_site_name = settings.SiteName;
_settings_mail_protocol = settings.IncomingMailProtocol;
_settings_mail_inc_host = settings.IncomingMailServer;
_settings_mail_inc_port = settings.IncomingMailPort;
_settings_mail_out_host = settings.OutgoingMailServer;
_settings_mail_out_port = settings.OutgoingMailPort;
_settings_mail_out_auth = settings.ReqSmtpAuth;
_allow_direct_mode = settings.AllowDirectMode;
_direct_mode_id_def = settings.DirectModeIsDefault;
_attachment_size_limit = settings.AttachmentSizeLimit;
_allow_attachment_limit = settings.EnableAttachmentSizeLimit;
_mailbox_size_limit = settings.MailboxSizeLimit;
_allow_mailbox_limit = settings.EnableMailboxSizeLimit;
_take_quota = settings.TakeImapQuota;
_allow_new_users_change_settings = settings.AllowUsersChangeEmailSettings;
_allow_auto_reg_on_login = settings.AllowNewUsersRegister;
_allow_users_add_accounts = settings.AllowUsersAddNewAccounts;
_allow_users_change_account_def = settings.AllowUsersChangeAccountsDef;
_def_user_charset = settings.DefaultUserCharset;
_allow_users_change_charset = settings.AllowUsersChangeCharset;
_def_user_timezone = settings.DefaultTimeZone;
_allow_users_change_timezone = settings.AllowUsersChangeTimeZone;
_msgs_per_page = settings.MailsPerPage;
_skin = settings.DefaultSkin;
_allow_users_change_skin = settings.AllowUsersChangeSkin;
_lang = settings.DefaultLanguage;
_allow_users_change_lang = settings.AllowUsersChangeLanguage;
_show_text_labels = settings.ShowTextLabels;
_allow_ajax = settings.AllowAjax;
_allow_editor = settings.AllowDhtmlEditor;
_allow_contacts = settings.AllowContacts;
_allow_calendar = settings.AllowCalendar;
_hide_login_mode = settings.HideLoginMode;
_domain_to_use = settings.DefaultDomainOptional;
_allow_choosing_lang = settings.AllowLanguageOnLogin;
_allow_advanced_login = settings.AllowAdvancedLogin;
_allow_auto_detect_and_correct = settings.AutomaticCorrectLoginSettings;
_viewmode = settings.ViewMode;
_save_mail = SaveMail.Always;
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
WebmailSettings settings = new WebmailSettings().CreateInstance(AdminPanelUtils.GetWebMailDataFolder());
txtWmServerRootPath.Value = settings.WmServerRootPath;
txtWmServerHostName.Value = settings.WmServerHost;
intWmAllowManageXMailAccounts.Checked = settings.WmAllowManageXMailAccounts;
}
}
public static void DeleteFromDb(Account acct)
{
DbManagerCreator creator = new DbManagerCreator();
DbManager dbMan = creator.CreateDbManager();
try
{
dbMan.Connect();
dbMan.DeleteAccount(acct._id);
}
catch (WebMailDatabaseException ex)
{
Log.WriteException(ex);
throw new WebMailDatabaseException((new WebmailResourceManagerCreator()).CreateResourceManager().GetString("PROC_CANT_DEL_ACCT_BY_ID"), ex);
}
finally
{
dbMan.Disconnect();
}
if (acct.MailIncomingProtocol != IncomingMailProtocol.WMServer)
{
FileSystem fs = new FileSystem(acct._email, acct._id, true);
fs.DeleteFolder("");
fs = new FileSystem(acct._email, acct._id, false);
fs.DeleteFolder("");
}
if (acct.MailIncomingProtocol == IncomingMailProtocol.WMServer)
{
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
try
{
if (settings.EnableWmServer && settings.WmAllowManageXMailAccounts)
{
WMServerStorage storage = new WMServerStorage(acct);
storage.DeleteUser(EmailAddress.GetDomainFromEmail(acct.Email), EmailAddress.GetAccountNameFromEmail(acct.MailIncomingLogin));
}
}
catch (Exception ex)
{
Log.WriteException(ex);
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
controlPrefix = this.ClientID;
install _page = Page as install;
_web_step = _page._web_step;
_max_step = _page._max_step;
intDbTypeMsSql_label.Attributes["for"] = intDbTypeMsSql.ClientID;
intDbTypeMySql_label.Attributes["for"] = intDbTypeMySql.ClientID;
intDbTypeMsAccess_label.Attributes["for"] = intDbTypeMsAccess.ClientID;
WebmailSettings settings = new WebmailSettings().CreateInstance(AdminPanelUtils.GetWebMailDataFolder());
if (Session["TrySqlPassword"] == null)
{
Session["TrySqlPassword"] = settings.DbPassword;
}
txtSqlPassword.Attributes.Add("Value", Session["TrySqlPassword"].ToString());
switch (settings.DbType)
{
case SupportedDatabase.MsAccess:
intDbTypeMsAccess.Checked = true;
break;
case SupportedDatabase.MsSqlServer:
intDbTypeMsSql.Checked = true;
break;
case SupportedDatabase.MySql:
intDbTypeMySql.Checked = true;
break;
}
txtSqlLogin.Value = settings.DbLogin;
txtSqlName.Value = settings.DbName;
txtSqlDsn.Value = settings.DbDsn;
txtSqlSrc.Value = settings.DbHost;
txtAccessFile.Value = settings.DbPathToMdb;
odbcConnectionString.Value = settings.DbCustomConnectionString;
useCS.Checked = settings.UseCustomConnectionString;
useDSN.Checked = settings.UseDSN;
DbPrefix.Value = settings.DbPrefix;
}
protected void save_ServerClick(object sender, EventArgs e)
{
try
{
Context.Application.Remove(Constants.sessionSettings);
WebmailSettings settings = new WebmailSettings().CreateInstance(AdminPanelUtils.GetWebMailDataFolder());
settings.WmServerRootPath = txtWmServerRootPath.Value;
settings.WmServerHost = txtWmServerHostName.Value;
settings.WmAllowManageXMailAccounts = intWmAllowManageXMailAccounts.Checked;
if (!settings.EnableWmServer)
{
settings.SaveWebmailSettings(AdminPanelUtils.GetWebMailDataFolder());
AdminPanelUtils.SetPageReportMessage(this.Page, Constants.mailAdmSaveSuccess);
}
else if (txtWmServerRootPath.Value.Length > 0)
{
string fullPath = Path.Combine(txtWmServerRootPath.Value, "domains");
if (!Directory.Exists(fullPath))
{
throw new WebMailIOException(string.Format(@"Server Root Path '{0}' incorrect.", AdminPanelUtils.EncodeHtml(fullPath)));
}
Utils.SettingsPath = AdminPanelUtils.GetWebMailFolder();
WMServerStorage storage = new WMServerStorage(txtWmServerHostName.Value, null);
storage.GetDomainList(); // test command
settings.SaveWebmailSettings(AdminPanelUtils.GetWebMailDataFolder());
this.Context.Application.Remove(Constants.sessionSettings);
AdminPanelUtils.SetPageReportMessage(this.Page, Constants.mailAdmSaveSuccess);
}
else
{
throw new WebMailIOException(@"Server Root Path not set.");
}
}
catch (Exception ex)
{
Log.WriteException(ex);
AdminPanelUtils.SetPageErrorMessage(this.Page, Constants.mailAdmSaveUnsuccess + "<br /> Error:" + ex.Message);
}
}
public WebmailResourceManager CreateResourceManager(string lang)
{
if (lang.Length < 1)
{
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
lang = settings.DefaultLanguage;
}
if (/*this.Context*/ HttpContext.Current.Session[Constants.sessionAccount] != null)
{
Account acct = /*this.Context*/ HttpContext.Current.Session[Constants.sessionAccount] as Account;
if (acct != null)
{
if ((acct.UserOfAccount != null) && (acct.UserOfAccount.Settings != null))
{
lang = acct.UserOfAccount.Settings.DefaultLanguage;
}
}
}
string culture = "";
string langsXml = Path.Combine(Utils.GetDataFolderPath(), @"langs\langs.xml");
if (File.Exists(langsXml))
{
XPathDocument xpathDoc = new XPathDocument(langsXml);
XPathNavigator nav = xpathDoc.CreateNavigator();
XPathNodeIterator langIter = nav.Select(string.Format("langs/lang[Name='{0}']/CultureName", lang));
if (langIter.MoveNext())
{
culture = langIter.Current.Value;
}
else
{
culture = "";
}
}
WebmailResourceManager newManager = new WebmailResourceManager(Path.Combine(Utils.GetDataFolderPath(), @"langs"));
newManager.Culture = new CultureInfo(culture);
return(newManager);
}
private object[] GetIndexesFromPageNumber(int pageNumber)
{
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
int msgPerPage = settings.MailsPerPage;
int msgCount = _pop3Obj.InboxMessageCount;
if ((_account != null) &&
(_account.UserOfAccount != null) &&
(_account.UserOfAccount.Settings != null))
{
msgPerPage = _account.UserOfAccount.Settings.MsgsPerPage;
}
int startIndex = 1;
int length = msgPerPage;
if ((pageNumber * msgPerPage) > msgCount)
{
if (msgCount > msgPerPage)
{
length = msgCount % msgPerPage;
}
else
{
length = msgCount;
}
}
else
{
startIndex = (msgCount - (pageNumber * msgPerPage)) + 1;
}
ArrayList arr = new ArrayList();
for (int i = 0; i < length; i++)
{
if (((startIndex + i) <= _pop3Obj.InboxMessageCount) && ((startIndex + i) > 0))
{
arr.Add(_pop3Obj.GetMessageUidFromIndex(startIndex + i));
}
}
return(arr.ToArray());
}
public void Delete()
{
DbManagerCreator creator = new DbManagerCreator();
DbManager dbMan = creator.CreateDbManager();
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
if (Domain.LoadFromDb(this.Name) != null)
{
try
{
dbMan.Connect();
if (settings.EnableWmServer && this.MailIncomingProtocol == IncomingMailProtocol.WMServer)
{
WMServerStorage storage = new WMServerStorage(null);
try
{
storage.DeleteDomain(this.Name);
dbMan.DeleteDomain(_id);
}
catch (Exception ex)
{
Log.WriteException(ex);
}
}
else
{
dbMan.DeleteDomain(_id);
}
}
catch (Exception ex)
{
Log.WriteException(ex);
}
finally
{
dbMan.Disconnect();
}
}
}
public static DbStorage CreateDatabaseStorage(Account acct, string dataFolderPath)
{
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings(dataFolderPath);
switch (settings.DbType)
{
case SupportedDatabase.MsAccess:
return(new MsAccessStorage(acct));
case SupportedDatabase.MySql:
return(new MySqlStorage(acct));
case SupportedDatabase.MsSqlServer:
return(new MsSqlStorage(acct));
case SupportedDatabase.PostgreSql:
return(new PostgreSqlStorage(acct));
default:
return(null);
}
}
protected void SubmitButton_Click(object sender, System.EventArgs e)
{
if (Save())
{
if (chNotCreate.Checked)
{
if (!create_tables())
{
Response.Redirect("install.aspx?mode=common", true);
}
}
else
{
Response.Redirect("install.aspx?mode=common", true);
}
}
else
{
WebmailSettings settings = new WebmailSettings().CreateInstance(AdminPanelUtils.GetWebMailDataFolder());
DbPrefix.Value = settings.DbPrefix;
}
}
protected void ReadSettingsValues()
{
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
defaultTitle = settings.SiteName;
jsClearDefaultTitle = Utils.EncodeJsSaveString(defaultTitle);
showTextLabels = settings.ShowTextLabels ? "true" : "false";
if (acct == null)
{
defaultSkin = settings.DefaultSkin;
defaultLang = settings.DefaultLanguage;
allowDhtmlEditor = settings.AllowDhtmlEditor ? "true" : "false";
}
else
{
if ((acct.UserOfAccount != null) && (acct.UserOfAccount.Settings != null))
{
if (acct.UserOfAccount.Settings.RTL)
{
_stylesRtl = true;
_rtl = "true";
}
defaultSkin = acct.UserOfAccount.Settings.DefaultSkin;
allowDhtmlEditor = acct.UserOfAccount.Settings.AllowDhtmlEditor ? "true" : "false";
string[] supportedSkins = Utils.GetSupportedSkins((Page != null) ? Page.MapPath("skins") : string.Empty);
if (Utils.GetCurrentSkinIndex(supportedSkins, defaultSkin) < 0)
{
if (supportedSkins.Length > 0)
{
defaultSkin = supportedSkins[0];
}
}
defaultLang = acct.UserOfAccount.Settings.DefaultLanguage;
}
}
}
public bool AddNewXMailDomain()
{
string domainName = textDomainName.Value;
bool result = false;
AdminPanelUtils.SaveState("selectedDomain", null, Page.Session);
XMLayer xmLayer = XMServer.CreateXMLayer();
if (_domainType == "vir")
{
try
{
xmLayer.Login();
// create custom domain
StringBuilder redirect = new StringBuilder("redirect");
if (Request.Params[RedirectionsListDDL.UniqueID] != null)
{
string[] RedirectionsList = Request.Params[RedirectionsListDDL.UniqueID].ToString().Split(',');
for (int i = 0; i < RedirectionsList.Length; i++)
{
redirect.AppendFormat("\t\"{0}\"", RedirectionsList[i]);
}
}
StringBuilder lredirect = new StringBuilder("lredirect");
if (Request.Params[LRedirectionsListDDL.UniqueID] != null)
{
string[] LRedirectionsList = Request.Params[LRedirectionsListDDL.UniqueID].ToString().Split(',');
for (int i = 0; i < LRedirectionsList.Length; i++)
{
lredirect.AppendFormat("\t\"{0}\"", LRedirectionsList[i]);
}
}
string data = string.Format("{0}\r\n{1}\r\n{2}\r\n.\r\n", redirect.ToString(), lredirect.ToString(), AdvancedID.Text);
xmLayer.SetCustomDomainTab(domainName, data);
xmLayer.Logout();
result = true;
}
catch (XMailException error)
{
Log.WriteException(error);
AdminPanelUtils.SetPageErrorMessage(this.Page, (error.InnerException != null ? error.InnerException.Message : error.Message));
}
}
else
{
try
{
xmLayer.Login();
if (!xmLayer.DomainExist(domainName))
{
xmLayer.AddDomain(domainName);
}
xmLayer.Logout();
result = true;
}
catch (XMailException error)
{
Log.WriteException(error);
AdminPanelUtils.SetPageErrorMessage(this.Page, error.Message);
}
// create webmail domain
if (_isWebMailExist && result)
{
WebmailSettings wmSettings = (new WebMailSettingsCreator()).CreateWebMailSettings(AdminPanelUtils.GetWebMailDataFolder());
try
{
Domain dom = Domain.GetDomain(domainName);
if (dom == null)
{
int SmtpPort = wmSettings.XMailSmtpPort;
string SmtpHost = wmSettings.WmServerHost;
int ImapPort = 143;
string ImapHost = wmSettings.WmServerHost;
Domain new_dom = new Domain(0, domainName, IncomingMailProtocol.WMServer, ImapHost, ImapPort, SmtpHost, SmtpPort, false);
new_dom.Global_addr_book = false;
new_dom.Save();
result = true;
}
else
{
result = false;
AdminPanelUtils.SaveState("SessPageErrorMessage", "Such domain already exists.", Page.Session);
}
}
catch (Exception error)
{
result = false;
Log.WriteException(error);
AdminPanelUtils.SetPageErrorMessage(this.Page, (error.InnerException != null ? error.InnerException.Message : error.Message));
}
}
}
if (result == false)
{
try
{
xmLayer.Login();
xmLayer.DeleteDomain(domainName);
xmLayer.Logout();
}
catch (Exception error)
{
Log.WriteException(error);
}
}
return(result);
}
public void Save()
{
DbManagerCreator creator = new DbManagerCreator();
DbManager dbMan = creator.CreateDbManager();
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
if (Domain.LoadFromDb(Name) == null)
{
try
{
dbMan.Connect();
if (settings.EnableWmServer && this.MailIncomingProtocol == IncomingMailProtocol.WMServer)
{
WMServerStorage storage = new WMServerStorage(null);
try
{
storage.AddDomain(Name);
}
catch
{
}
try
{
dbMan.CreateDomain(Name, MailIncomingProtocol, MailIncomingHost, MailIncomingPort, MailOutgoingHost,
MailOutgoingPort, MailOutgoingAuthentication, Url, Site_name,
Settings_mail_protocol, Settings_mail_inc_host,
Settings_mail_inc_port, Settings_mail_out_host,
Settings_mail_out_port, Settings_mail_out_auth,
Allow_direct_mode, Direct_mode_id_def, Attachment_size_limit,
Allow_attachment_limit, Mailbox_size_limit, Allow_mailbox_limit,
Take_quota, Allow_new_users_change_settings, Allow_auto_reg_on_login,
Allow_users_add_accounts, Allow_users_change_account_def,
Def_user_charset, Allow_users_change_charset, Def_user_timezone,
Allow_users_change_timezone, Msgs_per_page, Skin,
Allow_users_change_skin, Lang, Allow_users_change_lang,
Show_text_labels, Allow_ajax, Allow_editor, Allow_contacts,
Allow_calendar, Hide_login_mode,
Domain_to_use, Allow_choosing_lang, Allow_advanced_login,
Allow_auto_detect_and_correct, Global_addr_book, ViewMode, SaveMail);
}
catch (Exception ex)
{
Log.WriteException(ex);
}
}
else
{
dbMan.CreateDomain(Name, MailIncomingProtocol,
MailIncomingHost, MailIncomingPort, MailOutgoingHost,
MailOutgoingPort, MailOutgoingAuthentication, Url, Site_name,
Settings_mail_protocol, Settings_mail_inc_host,
Settings_mail_inc_port, Settings_mail_out_host,
Settings_mail_out_port, Settings_mail_out_auth,
Allow_direct_mode, Direct_mode_id_def, Attachment_size_limit,
Allow_attachment_limit, Mailbox_size_limit, Allow_mailbox_limit,
Take_quota, Allow_new_users_change_settings, Allow_auto_reg_on_login,
Allow_users_add_accounts, Allow_users_change_account_def,
Def_user_charset, Allow_users_change_charset, Def_user_timezone,
Allow_users_change_timezone, Msgs_per_page, Skin,
Allow_users_change_skin, Lang, Allow_users_change_lang,
Show_text_labels, Allow_ajax, Allow_editor, Allow_contacts,
Allow_calendar, Hide_login_mode,
Domain_to_use, Allow_choosing_lang, Allow_advanced_login,
Allow_auto_detect_and_correct, Global_addr_book, ViewMode, SaveMail);
}
}
catch (Exception ex)
{
Log.WriteException(ex);
throw;
}
finally
{
dbMan.Disconnect();
}
}
else
{
try
{
dbMan.Connect();
dbMan.UpdateDomain(ID, Name, MailIncomingProtocol,
MailIncomingHost, MailIncomingPort, MailOutgoingHost,
MailOutgoingPort, MailOutgoingAuthentication, Url, Site_name,
Settings_mail_protocol, Settings_mail_inc_host,
Settings_mail_inc_port, Settings_mail_out_host,
Settings_mail_out_port, Settings_mail_out_auth,
Allow_direct_mode, Direct_mode_id_def, Attachment_size_limit,
Allow_attachment_limit, Mailbox_size_limit, Allow_mailbox_limit,
Take_quota, Allow_new_users_change_settings, Allow_auto_reg_on_login,
Allow_users_add_accounts, Allow_users_change_account_def,
Def_user_charset, Allow_users_change_charset, Def_user_timezone,
Allow_users_change_timezone, Msgs_per_page, Skin,
Allow_users_change_skin, Lang, Allow_users_change_lang,
Show_text_labels, Allow_ajax, Allow_editor, Allow_contacts,
Allow_calendar, Hide_login_mode,
Domain_to_use, Allow_choosing_lang, Allow_advanced_login,
Allow_auto_detect_and_correct, Global_addr_book, ViewMode, SaveMail);
}
catch (Exception ex)
{
Log.WriteException(ex);
throw;
}
finally
{
dbMan.Disconnect();
}
}
}
protected void Page_Load(object sender, System.EventArgs e)
{
string hash = Request.QueryString["hash"] as string;
string screen = Request.QueryString["scr"] as string;
string to = Request.QueryString["to"] as string;
if ((hash != null) && (hash.Length >= 0))
{
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
TempRow row = null;
DbStorage storage = DbStorageCreator.CreateDatabaseStorage(null);
try
{
storage.Connect();
row = storage.GetTempRow(-1, string.Format(@"sessionHash_{0}", hash));
if (row != null)
{
storage.DeleteTempRow(row.ID);
}
else
{
throw new WebMailException("Temp Row Is NULL");
}
}
catch (Exception ex)
{
Log.WriteException(ex);
Response.Redirect(@"../default.aspx", true);
}
finally
{
storage.Disconnect();
}
if (row != null)
{
Account acct = Account.LoadFromDb(row.IDAcct, -1, false);
if (Session[Constants.sessionAccount] == null)
{
Session.Add(Constants.sessionAccount, acct);
}
else
{
Session[Constants.sessionAccount] = acct;
}
if (Session[Constants.sessionUserID] == null)
{
Session.Add(Constants.sessionUserID, acct.IDUser);
}
else
{
Session[Constants.sessionUserID] = acct.IDUser;
}
WMStartPage page = WMStartPage.Mailbox;
try
{
short scrNum = short.Parse(screen);
page = (WMStartPage)scrNum;
} catch {}
switch (page)
{
case WMStartPage.NewMessage:
if (to != null)
{
to = string.Format(@"&to={0}", to);
}
goto default;
case WMStartPage.Settings:
goto default;
case WMStartPage.Contacts:
goto default;
case WMStartPage.Mailbox:
goto default;
case WMStartPage.Calendar:
goto default;
default:
string check = string.Empty;
if (acct.GetMailAtLogin)
{
check = "check=1&";
}
HttpContext.Current.Response.Redirect(string.Format(@"../webmail.aspx?" + check + @"start={0}{1}", (int)page, to));
break;
}
}
}
}
protected bool create_tables()
{
bool errorFlag = false;
WebmailSettings settings = new WebmailSettings().CreateInstance(AdminPanelUtils.GetWebMailDataFolder());
if (settings.DbType == SupportedDatabase.MsAccess)
{
return(false);
}
string prefix = settings.DbPrefix;
string[] dbTablesName = new string[] { };
string[] tablesNames = new string[]
{
/* WebMail Tables */
Constants.TablesNames.a_users,
Constants.TablesNames.awm_accounts,
Constants.TablesNames.awm_addr_book,
Constants.TablesNames.awm_addr_groups,
Constants.TablesNames.awm_addr_groups_contacts,
Constants.TablesNames.awm_columns,
Constants.TablesNames.awm_filters,
Constants.TablesNames.awm_folders,
Constants.TablesNames.awm_folders_tree,
Constants.TablesNames.awm_messages,
Constants.TablesNames.awm_messages_body,
Constants.TablesNames.awm_reads,
Constants.TablesNames.awm_senders,
Constants.TablesNames.awm_settings,
Constants.TablesNames.awm_domains,
Constants.TablesNames.awm_temp,
Constants.TablesNames.awm_subadmin_domains,
Constants.TablesNames.awm_subadmins,
/* Calendar Tables */
Constants.TablesNames.acal_calendars,
Constants.TablesNames.acal_events,
Constants.TablesNames.acal_users_data,
Constants.TablesNames.acal_publications,
Constants.TablesNames.acal_sharing,
Constants.TablesNames.acal_eventrepeats,
Constants.TablesNames.acal_exclusions,
Constants.TablesNames.acal_appointments,
Constants.TablesNames.acal_cron_runs,
Constants.TablesNames.acal_reminders
};
bool isTableExist = false;
Utils.SettingsPath = AdminPanelUtils.GetWebMailFolder();
DbStorage storage = DbStorageCreator.CreateDatabaseStorage(null, AdminPanelUtils.GetWebMailDataFolder());
try
{
storage.Connect();
dbTablesName = storage.GetTablesNames();
}
catch (WebMailDatabaseException error)
{
Log.WriteException(error);
_errorMessage = @"<font color=""red"">" + Constants.mailAdmTablesNotCreated + ": " + error.Message + "</font>";
errorFlag = true;
}
finally
{
storage.Disconnect();
}
for (int i = 0; i < dbTablesName.Length; i++)
{
string dbTable = dbTablesName[i];
foreach (string name in tablesNames)
{
if (string.Compare(dbTable, string.Format("{0}{1}", prefix, name), true, CultureInfo.InvariantCulture) == 0)
{
isTableExist = true;
break;
}
}
if (isTableExist)
{
break;
}
}
if (isTableExist)
{
_errorMessage = @"<font color=""red"">The data tables with """ + prefix + @""" prefix already exist. To proceed, specify another prefix or delete the existing tables.</font>";
errorFlag = true;
}
else
{
try
{
storage.Connect();
foreach (string name in tablesNames)
{
try
{
storage.CreateTable(name, prefix);
}
catch (WebMailDatabaseException error)
{
Log.WriteException(error);
_errorMessage = @"<font color=""red"">" + Constants.mailAdmTablesNotCreated + ": " + error.Message + "</font>";
errorFlag = true;
}
}
}
catch (WebMailDatabaseException error)
{
Log.WriteException(error);
_errorMessage = @"<font color=""red"">" + Constants.mailAdmTablesNotCreated + ": " + error.Message + "</font>";
errorFlag = true;
}
finally
{
storage.Disconnect();
}
if (!errorFlag)
{
_errorMessage = @"<font color=""green"">" + Constants.mailAdmTablesCreated + "</font>";
}
}
return(errorFlag);
}
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);
}
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);
}
protected void Page_Load(object sender, EventArgs e)
{
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
inlineImage = (Request["inline_image"] == "1") ? "true" : "false";
flashUpload = (Request["flash_upload"] == "0") ? false : true;
HttpFileCollection files = Request.Files;
if ((files != null) && (files.Count > 0))
{
HttpPostedFile file = files[0];
if (file != null)
{
name = Utils.EncodeHtml(Path.GetFileName(file.FileName)).Replace(@"'", @"\'");
size = file.ContentLength;
mime_type = Utils.EncodeHtml(file.ContentType);
if ((file.ContentLength < settings.AttachmentSizeLimit) || (settings.EnableAttachmentSizeLimit == false))
{
try
{
byte[] buffer;
using (Stream uploadStream = file.InputStream)
{
buffer = new byte[uploadStream.Length];
long numBytesToRead = uploadStream.Length;
long numBytesRead = 0;
while (numBytesToRead > 0)
{
int n = uploadStream.Read(buffer, (int)numBytesRead, (int)numBytesToRead);
if (n == 0)
{
break;
}
numBytesRead += n;
numBytesToRead -= n;
}
}
if (buffer != null)
{
string tempFolder = Utils.GetTempFolderName(Session);
string filename = Utils.CreateTempFilePath(tempFolder, file.FileName);
tmp_name = Path.GetFileName(filename);
url = String.Format("download-view-attachment.aspx?download=0&temp_filename={0}", tmp_name);
using (FileStream fs = File.Open(filename, FileMode.Create, FileAccess.Write))
{
fs.Write(buffer, 0, buffer.Length);
}
}
}
catch (IOException ex)
{
errorOccured = true;
error = (new WebmailResourceManagerCreator()).CreateResourceManager().GetString("UnknownUploadError");
Log.WriteException(ex);
}
}
else
{
errorOccured = true;
error = (new WebmailResourceManagerCreator()).CreateResourceManager().GetString("FileIsTooBig");
Log.WriteLine("upload", error);
}
}
else
{
errorOccured = true;
error = (new WebmailResourceManagerCreator()).CreateResourceManager().GetString("NoFileUploaded");
Log.WriteLine("upload", error);
}
}
else
{
errorOccured = true;
error = (new WebmailResourceManagerCreator()).CreateResourceManager().GetString("NoFileUploaded");
Log.WriteLine("upload", error);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (File.Exists(Path.Combine(MapPath(""), "VERSION")))
{
_WmVersion = File.ReadAllText(Path.Combine(MapPath(""), "VERSION"));
}
if (!IsPostBack)
{
Log.Write("WebMail Version: " + _WmVersion + "\r\n");
this.Context.Application.Remove(Constants.sessionSettings);
if (Request.QueryString.Get("mode") != null)
{
mode = Request.QueryString.Get("mode");
}
if (mode == "logout")
{
Log.WriteLine("Page_Load", "Session Clear");
Session.Clear();
}
if (Application[Constants.appSettingsDataFolderPath] == null)
{
Application[Constants.appSettingsDataFolderPath] = ConfigurationManager.AppSettings[Constants.appSettingsDataFolderPath];
}
Session.Remove(Constants.sessionAccount);
}
Dictionary <string, string> supportedLangs = new Dictionary <string, string>();
try
{
settings = (new WebMailSettingsCreator()).CreateWebMailSettings(Utils.GetDataFolderPath(), Request.Url.Host);
supportedLangs = Utils.GetSupportedLangs();
if (settings.AllowLanguageOnLogin)
{
foreach (KeyValuePair <string, string> kvp in supportedLangs)
{
_languageOptions += @"<a href=""#"" name=""lng_" + kvp.Key + @""" onclick=""ChangeLang(this); return false;"">" + kvp.Value + @"</a>";
}
_languageClassName = "";
}
}
catch (WebMailDatabaseException)
{
}
catch (WebMailSettingsException)
{
Response.Write(@"
<!DOCTYPE html PUBLIC ""-//W3C//DTD XHTML 1.0 Transitional//EN"" ""http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"" />
<html>
<head>
<meta http-equiv=""Content-Type"" content=""text/html; charset=utf-8"" />
<link rel=""shortcut icon"" href=""favicon.ico"" />
<meta http-equiv=""Content-Script-Type"" content=""text/javascript"" />
<meta http-equiv=""Cache-Control"" content=""private,max-age=1209600"" />
<title>WebMail probably not configured</title>
<link rel=""stylesheet"" href=""skins/AfterLogic/styles.css"" type=""text/css"" />
</head>
<body>
<div align=""center"" id=""content"" class=""wm_content"">
<div class=""wm_logo"" id=""logo"" tabindex=""-1""></div>
<div class=""wm_login_error"">WebMail could not find data folder. Check SettingsPath in Web.config</div>
</div>
<div class=""wm_copyright"" id=""copyright"">
Powered by <a href=""http://www.afterlogic.com/mailbee/webmail-pro.asp"" target=""_blank""> AfterLogic WebMail Pro</a><br>
Copyright © 2002-2010 <a href=""http://www.afterlogic.com"" target=""_blank"">AfterLogic Corporation</a>
</div>
</body>
</html>
");
Response.End();
return;
}
try
{
defaultTitle = Utils.EncodeJsSaveString(settings.SiteName);
defaultSkin = settings.DefaultSkin;
string[] supportedSkins = Utils.GetSupportedSkins((Page != null) ? Page.MapPath("skins") : string.Empty);
if (Utils.GetCurrentSkinIndex(supportedSkins, defaultSkin) < 0)
{
if (supportedSkins.Length > 0)
{
defaultSkin = supportedSkins[0];
}
}
defaultSkin = Utils.EncodeJsSaveString(defaultSkin);
if (Request["lang"] != null && supportedLangs.ContainsKey(Request["lang"]))
{
defaultLang = Request["lang"];
HttpCookie defLangCookie = new HttpCookie("awm_defLang");
defLangCookie.Value = defaultLang;
defLangCookie.Path = HttpContext.Current.Request.ApplicationPath;
Response.AppendCookie(defLangCookie);
}
else if (Request.Cookies["awm_defLang"] != null && supportedLangs.ContainsKey(Request.Cookies["awm_defLang"].Value))
{
defaultLang = Request.Cookies["awm_defLang"].Value;
}
if (string.IsNullOrEmpty(defaultLang))
{
defaultLang = settings.DefaultLanguage;
}
defaultLangName = supportedLangs[defaultLang];
_resMan = (new WebmailResourceManagerCreator()).CreateResourceManager(defaultLang);
if (defaultLang == "Hebrew" || defaultLang == "Arabic")
{
_stylesRtl = true;
_rtl = "true";
}
defaultIncServer = settings.IncomingMailServer;
switch (settings.IncomingMailProtocol)
{
case IncomingMailProtocol.Pop3:
{
defaultIncProtocol = POP3_PROTOCOL;
break;
}
case IncomingMailProtocol.Imap4:
{
defaultIncProtocol = IMAP4_PROTOCOL;
break;
}
case IncomingMailProtocol.WMServer:
{
defaultIncProtocol = WMSERVER_PROTOCOL;
break;
}
}
defaultIncPort = settings.IncomingMailPort;
defaultOutServer = settings.OutgoingMailServer;
defaultOutPort = settings.OutgoingMailPort;
defaultUseSmtpAuth = settings.ReqSmtpAuth;
defaultSignMe = false;
defaultIsAjax = settings.AllowAjax ? "true" : "false";
defaultAllowAdvancedLogin = (settings.AllowAdvancedLogin) ? "true" : "false";
defaultHideLoginMode = (int)settings.HideLoginMode;
defaultDomainOptional = Utils.EncodeJsSaveString(settings.DefaultDomainOptional);
pop3Selected = (defaultIncProtocol == POP3_PROTOCOL) ? @" selected=""selected""" : "";
imap4Selected = (defaultIncProtocol == IMAP4_PROTOCOL) ? @" selected=""selected""" : "";
wmserverSelected = (defaultIncProtocol == WMSERVER_PROTOCOL) ? @" selected=""selected""" : "";
smtpAuthChecked = defaultUseSmtpAuth ? @" checked=""checked""" : "";
signMeChecked = defaultSignMe ? @" checked=""checked""" : "";
//for version without ajax
errorClass = "wm_hide"; //if there is no error
errorDesc = "";
mode = Request["mode"]; //mode = standard|advanced|submit
switch (mode)
{
case "advanced":
DisplayAdvancedMode();
break;
case "submit":
DisplayStandardMode();
globalEmail = Request["email"];
globalLogin = Request["login"];
globalPassword = Request["password"];
globalSignMe = Request["sign_me"];
globalAdvancedLogin = Request["advanced_login"]; //0|1
if (globalAdvancedLogin == "1" || (int)settings.HideLoginMode < 20)
{
if (!Validation.CheckIt(Validation.ValidationTask.Email, globalEmail))
{
errorDesc = _resMan.GetString(Validation.ErrorMessage);
errorClass = "wm_login_error";
break;
}
globalEmail = Validation.Corrected;
}
if (globalAdvancedLogin == "1" || (int)settings.HideLoginMode != 10 && (int)settings.HideLoginMode != 11)
{
if (!Validation.CheckIt(Validation.ValidationTask.Login, globalLogin))
{
errorDesc = _resMan.GetString(Validation.ErrorMessage);
errorClass = "wm_login_error";
break;
}
globalLogin = Validation.Corrected;
}
if (!Validation.CheckIt(Validation.ValidationTask.Password, globalPassword))
{
errorDesc = _resMan.GetString(Validation.ErrorMessage);
errorClass = "wm_login_error";
break;
}
if (globalAdvancedLogin == "1")
{
globalIncServer = Request["inc_server"];
globalIncProtocol = Request["inc_protocol"];
globalIncPort = Request["inc_port"];
globalOutServer = Request["out_server"];
globalOutPort = Request["out_port"];
globalUseSmtpAuth = Request["smtp_auth"];
if (!Validation.CheckIt(Validation.ValidationTask.INServer, globalIncServer, globalAdvancedLogin))
{
errorDesc = _resMan.GetString(Validation.ErrorMessage);
errorClass = "wm_login_error";
break;
}
globalIncServer = Validation.Corrected;
if (!Validation.CheckIt(Validation.ValidationTask.INPort, globalIncPort, globalAdvancedLogin))
{
errorDesc = _resMan.GetString(Validation.ErrorMessage);
errorClass = "wm_login_error";
break;
}
globalIncPort = Validation.Corrected;
if (!Validation.CheckIt(Validation.ValidationTask.OUTServer, globalOutServer, globalAdvancedLogin))
{
errorDesc = _resMan.GetString(Validation.ErrorMessage);
errorClass = "wm_login_error";
break;
}
globalOutServer = Validation.Corrected;
if (!Validation.CheckIt(Validation.ValidationTask.OUTPort, globalOutPort, globalAdvancedLogin))
{
errorDesc = _resMan.GetString(Validation.ErrorMessage);
errorClass = "wm_login_error";
break;
}
globalOutPort = Validation.Corrected;
}
else
{
globalIncServer = settings.IncomingMailServer;
globalIncProtocol = (settings.IncomingMailProtocol == IncomingMailProtocol.Imap4)
? "1" : "0";
globalIncPort = settings.IncomingMailPort.ToString();
globalOutServer = settings.OutgoingMailServer;
globalOutPort = settings.OutgoingMailPort.ToString();
globalUseSmtpAuth = settings.ReqSmtpAuth ? "1" : "0";
}
try
{
bool advancedLogin = (string.Compare(globalAdvancedLogin, "1", true, CultureInfo.InvariantCulture) == 0) ? true : false;
bool signAuto = (string.Compare(globalSignMe, "1", true, CultureInfo.InvariantCulture) == 0) ? true : false;
bool useSmtpAuth = (string.Compare(globalUseSmtpAuth, "1", true, CultureInfo.InvariantCulture) == 0) ? true : false;
string language = Request["language"];
Account acct = Account.LoginAccount(globalEmail, globalLogin, globalPassword,
globalIncServer, (IncomingMailProtocol)Convert.ToInt32(globalIncProtocol),
Convert.ToInt32(globalIncPort), globalOutServer, Convert.ToInt32(globalOutPort),
useSmtpAuth, signAuto, advancedLogin, language);
if (acct != null)
{
if (globalSignMe == "1")
{
HttpCookie idAcctCookie = new HttpCookie("awm_autologin_id");
idAcctCookie.Value = acct.ID.ToString();
idAcctCookie.Path = HttpContext.Current.Request.ApplicationPath;
Response.AppendCookie(idAcctCookie);
string hash = Utils.GetMD5DigestHexString(Utils.EncodePassword(acct.MailIncomingPassword));
HttpCookie autoLoginCookie = new HttpCookie("awm_autologin_data");
autoLoginCookie.Value = hash;
autoLoginCookie.Path = HttpContext.Current.Request.ApplicationPath;
Response.AppendCookie(autoLoginCookie);
}
Session.Add(Constants.sessionAccount, acct);
if (acct.GetMailAtLogin)
{
Response.Redirect("basewebmail.aspx?check=1", false);
}
else
{
Response.Redirect("basewebmail.aspx", false);
}
}
}
catch (Exception message)
{
Log.WriteLine("Page_Load", "Login Account");
Log.WriteException(message);
errorDesc = message.Message;
errorClass = "wm_login_error"; //if the error was occured
}
break;
default:
DisplayStandardMode();
break;
}
//end for version without ajax
string error = Request["error"] ?? string.Empty;
if (error == "1")
{
errorDesc = "The previous session was terminated due to a timeout.";
errorClass = "wm_login_error"; //if the error was occured
}
else
{
HttpCookie idAcctCookie = Request.Cookies["awm_autologin_id"];
HttpCookie autoLoginCookie = Request.Cookies["awm_autologin_data"];
if ((idAcctCookie != null) && (autoLoginCookie != null))
{
int id_acct = -1;
try
{
id_acct = int.Parse(idAcctCookie.Value);
}
catch (Exception ex)
{
Log.WriteLine("Page_Load", "int.Parse");
Log.WriteException(ex);
}
Account acct = Account.LoadFromDb(id_acct, -1, false);
if (acct != null)
{
string encodePassword = Utils.GetMD5DigestHexString(Utils.EncodePassword(acct.MailIncomingPassword));
if (string.Compare(encodePassword, autoLoginCookie.Value, true, CultureInfo.InvariantCulture) == 0)
{
Session.Add(Constants.sessionAccount, acct);
idAcctCookie.Expires = DateTime.Now.AddDays(14);
if (settings.AllowAjax)
{
Response.Redirect("webmail.aspx?check=1", false);
}
else
{
Response.Redirect("basewebmail.aspx?check=1", false);
}
}
}
}
}
}
catch (Exception ex)
{
Log.WriteException(ex);
}
}
protected void Page_Load(object sender, EventArgs e)
{
SetActiveClassNames();
WebMail.Account acct = (WebMail.Account)Session[Constants.sessionAccount];
Skin = acct.UserOfAccount.Settings.DefaultSkin;
if (acct == null)
{
Response.Redirect("default.aspx", true);
}
else
{
try
{
_manager = (new WebmailResourceManagerCreator()).CreateResourceManager();
_CalendarDiv = @"<div class=""wm_accountslist_contacts wm_active_tab"">
<a href=""#"" onclick=""return false;"">" + _manager.GetString("Calendar") + @"</a>
</div>" ;
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
if (settings.AllowContacts)
{
_ContactsDiv = @"<div class=""wm_accountslist_contacts" + contactsActiveClassName + @""">
<a href=""" + _contactsLink + @""">" + _manager.GetString("Contacts") + @"</a>
</div>" ;
}
BaseWebMailActions bwa = new BaseWebMailActions(acct, Page);
AccountCollection Accounts = bwa.GetAccounts(acct.IDUser);
//_accountsCount = Accounts.Length;
if (Accounts.Count > 1)
{
AcctList = @"
<div id=""popup_replace_1"" class=""wm_accountslist_email" + mailActiveClassName + @""">
<a href=""" + _accountsListLink + @""">
" + acct.Email + @"
</a>
</div>
<div class=""wm_accountslist_selection wm_control"" id=""popup_control_1""
onmouseover=""this.className='wm_accountslist_selection_over wm_control';""
onmousedown=""this.className='wm_accountslist_selection_press wm_control';""
onmouseup=""this.className='wm_accountslist_selection_over wm_control';""
onmouseout=""this.className='wm_accountslist_selection wm_control';"">
</div>
" ;
string temp = String.Empty;
for (int i = 0; Accounts.Count > i; i++)
{
if (Accounts[i].ID != acct.ID)
{
temp += @"
<div>
<div id=""" + Accounts[i].ID + @""" onmouseout=""this.className='wm_account_item';"" onmouseover=""this.className='wm_account_item_over';"" onclick=""javascript:ChangeAccount(this.id);"" class=""wm_account_item"">
" + Accounts[i].Email + @"
</div>
</div>
" ;
}
}
temp = @"
<div id=""popup_menu_1"" class=""wm_hide"">
" + temp + @"
</div>
" ;
AcctList = temp + AcctList;
}
else
{
AcctList = @"
<div class=""wm_accountslist_email""" + mailActiveClassName + @">
<a href=""" + _accountsListLink + @""">
" + acct.Email + @"
</a>
</div>
<div class=""wm_accountslist_selection_none""></div>
" ;
}
}
catch (Exception)
{
// ((basewebmail)Page).OutputException(ex);
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (File.Exists(Path.Combine(MapPath(""), "VERSION")))
{
_WmVersion = File.ReadAllText(Path.Combine(MapPath(""), "VERSION"));
}
HMailServer hmailserver = new HMailServer();
if (hmailserver.IsLoaded)
{
hMailServer = "true";
}
acct = (Account)Session[Constants.sessionAccount];
if (acct == null)
{
Response.Redirect("default.aspx?error=1", true);
}
if (File.Exists(Path.Combine(Page.MapPath(""), "cs")))
{
CSType = "true";
}
if (Request.QueryString.Get("check") != null)
{
check = Request.QueryString.Get("check");
}
if (Request.QueryString.Get("start") != null)
{
start = Request.QueryString.Get("start");
}
if (Request.QueryString.Get("to") != null)
{
to = Request.QueryString.Get("to");
}
jsClearStart = Utils.EncodeJsSaveString(start);
jsClearToAddr = Utils.EncodeJsSaveString(to);
_resMan = (new WebmailResourceManagerCreator()).CreateResourceManager();
WebmailSettings settings = (new WebMailSettingsCreator()).CreateWebMailSettings();
if (acct != null)
{
if ((acct.UserOfAccount != null) && (acct.UserOfAccount.Settings != null))
{
if (acct.UserOfAccount.Settings.RTL)
{
_stylesRtl = true;
_rtl = "true";
}
defaultTitle = settings.SiteName;
defaultSkin = acct.UserOfAccount.Settings.DefaultSkin;
string[] supportedSkins = Utils.GetSupportedSkins((Page != null) ? Page.MapPath("skins") : string.Empty);
if (Utils.GetCurrentSkinIndex(supportedSkins, defaultSkin) < 0)
{
if (supportedSkins.Length > 0)
{
defaultSkin = supportedSkins[0];
}
}
defaultLang = acct.UserOfAccount.Settings.DefaultLanguage;
jsClearDefaultTitle = Utils.EncodeJsSaveString(defaultTitle);
jsClearDefaultSkin = Utils.EncodeJsSaveString(defaultSkin);
return;
}
}
defaultTitle = settings.SiteName;
defaultSkin = settings.DefaultSkin;
defaultLang = settings.DefaultLanguage;
jsClearDefaultTitle = Utils.EncodeJsSaveString(defaultTitle);
jsClearDefaultSkin = Utils.EncodeJsSaveString(defaultSkin);
}
