6203fd48c5
quotas were only displayed for the tenant. Quota usage now displayed per organization Added public folders to organization home screen Added Lync to organization home screen Added the ability to hide the theme and locale. This can be hidden by adding the element <HideThemeAndLocale>true</HideThemeAndLocale> to the file SiteSettings.config
944 lines
No EOL
34 KiB
C#
944 lines
No EOL
34 KiB
C#
// Copyright (c) 2012, Outercurve Foundation.
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// - Redistributions of source code must retain the above copyright notice, this
|
|
// list of conditions and the following disclaimer.
|
|
//
|
|
// - Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// - Neither the name of the Outercurve Foundation nor the names of its
|
|
// contributors may be used to endorse or promote products derived from this
|
|
// software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using System.Security.Principal;
|
|
using System.Resources;
|
|
using System.Configuration;
|
|
using System.Collections.Specialized;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Web;
|
|
using System.Web.Compilation;
|
|
using System.Web.Configuration;
|
|
using System.Web.UI;
|
|
using System.Web.Security;
|
|
using System.Web.UI.WebControls;
|
|
using System.Net;
|
|
using System.Net.Mail;
|
|
|
|
using Microsoft.Web.Services3;
|
|
using WebsitePanel.EnterpriseServer;
|
|
using WebsitePanel.WebPortal;
|
|
|
|
namespace WebsitePanel.Portal
|
|
{
|
|
public class PortalUtils
|
|
{
|
|
public const string SharedResourcesFile = "SharedResources.ascx.resx";
|
|
public const string CONFIG_FOLDER = "~/App_Data/";
|
|
public const string SUPPORTED_THEMES_FILE = "SupportedThemes.config";
|
|
public const string SUPPORTED_LOCALES_FILE = "SupportedLocales.config";
|
|
public const string USER_ID_PARAM = "UserID";
|
|
public const string SPACE_ID_PARAM = "SpaceID";
|
|
public const string SEARCH_QUERY_PARAM = "Query";
|
|
|
|
public static string CultureCookieName
|
|
{
|
|
get { return PortalConfiguration.SiteSettings["CultureCookieName"]; }
|
|
}
|
|
|
|
public static string ThemeCookieName
|
|
{
|
|
get { return PortalConfiguration.SiteSettings["ThemeCookieName"]; }
|
|
}
|
|
|
|
public static System.Globalization.CultureInfo CurrentCulture
|
|
{
|
|
get { return GetCurrentCulture(); }
|
|
}
|
|
|
|
public static System.Globalization.CultureInfo CurrentUICulture
|
|
{
|
|
get { return GetCurrentCulture(); }
|
|
}
|
|
|
|
public static string CurrentTheme
|
|
{
|
|
get { return GetCurrentTheme(); }
|
|
}
|
|
|
|
internal static string GetCurrentTheme()
|
|
{
|
|
string theme = (string) HttpContext.Current.Items[ThemeCookieName];
|
|
|
|
if (theme == null)
|
|
{
|
|
HttpCookie cookie = HttpContext.Current.Request.Cookies[ThemeCookieName];
|
|
if (cookie != null)
|
|
{
|
|
theme = cookie.Value;
|
|
|
|
if (!String.IsNullOrEmpty(theme))
|
|
{
|
|
HttpContext.Current.Items[ThemeCookieName] = theme;
|
|
return theme;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string appData = HttpContext.Current.Server.MapPath(CONFIG_FOLDER);
|
|
string path = Path.Combine(appData, SUPPORTED_THEMES_FILE);
|
|
|
|
XmlTextReader reader = new XmlTextReader(path);
|
|
reader.XmlResolver = null;
|
|
reader.WhitespaceHandling = WhitespaceHandling.None;
|
|
reader.MoveToContent();
|
|
if (reader.Name != null)
|
|
{
|
|
while (reader.Read())
|
|
{
|
|
if (reader.NodeType == XmlNodeType.Element)
|
|
{
|
|
if (reader.HasAttributes)
|
|
{
|
|
reader.MoveToFirstAttribute();
|
|
theme = reader.Value;
|
|
return theme;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return String.IsNullOrEmpty(theme) ? "Default" : theme;
|
|
}
|
|
|
|
public static void SetCurrentTheme(string theme)
|
|
{
|
|
// theme
|
|
if (!String.IsNullOrEmpty(theme))
|
|
{
|
|
HttpCookie cookieTheme = new HttpCookie(ThemeCookieName, theme);
|
|
cookieTheme.Expires = DateTime.Now.AddMonths(2);
|
|
HttpContext.Current.Response.Cookies.Add(cookieTheme);
|
|
}
|
|
}
|
|
|
|
internal static System.Globalization.CultureInfo GetCurrentCulture()
|
|
{
|
|
System.Globalization.CultureInfo ci = (System.Globalization.CultureInfo)
|
|
HttpContext.Current.Items[CultureCookieName];
|
|
|
|
if (ci == null)
|
|
{
|
|
HttpCookie localeCrumb = HttpContext.Current.Request.Cookies[CultureCookieName];
|
|
if (localeCrumb != null)
|
|
{
|
|
ci = System.Globalization.CultureInfo.CreateSpecificCulture(localeCrumb.Value);
|
|
|
|
if (ci != null)
|
|
{
|
|
HttpContext.Current.Items[CultureCookieName] = ci;
|
|
return ci;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
return ci;
|
|
|
|
return System.Threading.Thread.CurrentThread.CurrentCulture;
|
|
}
|
|
|
|
public static string AdminEmail
|
|
{
|
|
get { return PortalConfiguration.SiteSettings["AdminEmail"]; }
|
|
}
|
|
|
|
public static string FromEmail
|
|
{
|
|
get { return PortalConfiguration.SiteSettings["FromEmail"]; }
|
|
}
|
|
|
|
public static void SendMail(string from, string to, string bcc, string subject, string body)
|
|
{
|
|
// Command line argument must the the SMTP host.
|
|
SmtpClient client = new SmtpClient();
|
|
|
|
// set SMTP client settings
|
|
client.Host = PortalConfiguration.SiteSettings["SmtpHost"];
|
|
client.Port = Int32.Parse(PortalConfiguration.SiteSettings["SmtpPort"]);
|
|
string smtpUsername = PortalConfiguration.SiteSettings["SmtpUsername"];
|
|
string smtpPassword = PortalConfiguration.SiteSettings["SmtpPassword"];
|
|
if (String.IsNullOrEmpty(smtpUsername))
|
|
{
|
|
client.Credentials = new NetworkCredential(smtpUsername, smtpPassword);
|
|
}
|
|
|
|
// create message
|
|
MailMessage message = new MailMessage(from, to);
|
|
message.Body = body;
|
|
message.BodyEncoding = System.Text.Encoding.UTF8;
|
|
message.IsBodyHtml = false;
|
|
message.Subject = subject;
|
|
message.SubjectEncoding = System.Text.Encoding.UTF8;
|
|
if (!String.IsNullOrEmpty(bcc))
|
|
message.Bcc.Add(bcc);
|
|
|
|
// send message
|
|
try
|
|
{
|
|
client.Send(message);
|
|
}
|
|
finally
|
|
{
|
|
// Clean up.
|
|
message.Dispose();
|
|
}
|
|
}
|
|
|
|
public static void UserSignOut()
|
|
{
|
|
FormsAuthentication.SignOut();
|
|
|
|
if (HttpContext.Current.Session != null)
|
|
{
|
|
HttpContext.Current.Session.Clear();
|
|
HttpContext.Current.Session.Abandon();
|
|
}
|
|
|
|
// Clear authentication cookie
|
|
HttpCookie rFormsCookie = new HttpCookie(FormsAuthentication.FormsCookieName, "");
|
|
rFormsCookie.Expires = DateTime.Now.AddYears(-1);
|
|
HttpContext.Current.Response.Cookies.Add(rFormsCookie);
|
|
|
|
// Clear session cookie
|
|
HttpCookie rSessionCookie = new HttpCookie("ASP.NET_SessionId", "");
|
|
rSessionCookie.Expires = DateTime.Now.AddYears(-1);
|
|
HttpContext.Current.Response.Cookies.Add(rSessionCookie);
|
|
|
|
HttpContext.Current.Response.Redirect(LoginRedirectUrl);
|
|
}
|
|
|
|
public static MenuItem GetSpaceMenuItem(string menuItemKey)
|
|
{
|
|
MenuItem item = new MenuItem();
|
|
item.Value = menuItemKey;
|
|
|
|
menuItemKey = String.Concat("Space", menuItemKey);
|
|
|
|
PortalPage page = PortalConfiguration.Site.Pages[menuItemKey];
|
|
|
|
if (page != null)
|
|
item.NavigateUrl = DefaultPage.GetPageUrl(menuItemKey);
|
|
|
|
return item;
|
|
}
|
|
|
|
private static FormsAuthenticationTicket AuthTicket
|
|
{
|
|
get
|
|
{
|
|
FormsAuthenticationTicket authTicket = (FormsAuthenticationTicket)HttpContext.Current.Items[FormsAuthentication.FormsCookieName];
|
|
|
|
if (authTicket == null)
|
|
{
|
|
// original code
|
|
HttpCookie authCookie = HttpContext.Current.Request.Cookies[FormsAuthentication.FormsCookieName];
|
|
// workaround for cases when AuthTicket is required before round-trip
|
|
if (authCookie == null || String.IsNullOrEmpty(authCookie.Value))
|
|
authCookie = HttpContext.Current.Response.Cookies[FormsAuthentication.FormsCookieName];
|
|
//
|
|
if (authCookie != null)
|
|
{
|
|
authTicket = FormsAuthentication.Decrypt(authCookie.Value);
|
|
HttpContext.Current.Items[FormsAuthentication.FormsCookieName] = authTicket;
|
|
}
|
|
}
|
|
|
|
return authTicket;
|
|
}
|
|
}
|
|
|
|
private static void SetAuthTicket(FormsAuthenticationTicket ticket, bool persistent)
|
|
{
|
|
// issue authentication cookie
|
|
HttpCookie authCookie = new HttpCookie(FormsAuthentication.FormsCookieName);
|
|
authCookie.Domain = FormsAuthentication.CookieDomain;
|
|
authCookie.Secure = FormsAuthentication.RequireSSL;
|
|
authCookie.Path = FormsAuthentication.FormsCookiePath;
|
|
authCookie.Value = FormsAuthentication.Encrypt(ticket);
|
|
authCookie.HttpOnly = true;
|
|
|
|
if (persistent)
|
|
authCookie.Expires = DateTime.Now.AddMonths(1);
|
|
|
|
HttpContext.Current.Response.Cookies.Add(authCookie);
|
|
}
|
|
|
|
public static string ApplicationPath
|
|
{
|
|
get
|
|
{
|
|
if (HttpContext.Current.Request.ApplicationPath == "/")
|
|
return "";
|
|
else
|
|
return HttpContext.Current.Request.ApplicationPath;
|
|
}
|
|
}
|
|
|
|
public static string GetSharedLocalizedString(string moduleName, string resourceKey)
|
|
{
|
|
string className = SharedResourcesFile.Replace(".resx", "");
|
|
|
|
if (!String.IsNullOrEmpty(moduleName))
|
|
className = String.Concat(moduleName, "_", className);
|
|
|
|
return (string)HttpContext.GetGlobalResourceObject(className, resourceKey);
|
|
}
|
|
|
|
public static string GetCurrentPageId()
|
|
{
|
|
return HttpContext.Current.Request["pid"];
|
|
}
|
|
|
|
public static bool PageExists(string pageId)
|
|
{
|
|
return PortalConfiguration.Site.Pages[pageId] != null;
|
|
}
|
|
|
|
public static string GetLocalizedPageName(string pageId)
|
|
{
|
|
return DefaultPage.GetLocalizedPageName(pageId);
|
|
}
|
|
|
|
public static int AuthenticateUser(string username, string password, string ipAddress,
|
|
bool rememberLogin, string preferredLocale, string theme)
|
|
{
|
|
esAuthentication authService = new esAuthentication();
|
|
ConfigureEnterpriseServerProxy(authService, false);
|
|
|
|
try
|
|
{
|
|
int authResult = authService.AuthenticateUser(username, password, ipAddress);
|
|
|
|
if (authResult < 0)
|
|
{
|
|
return authResult;
|
|
}
|
|
else
|
|
{
|
|
UserInfo user = authService.GetUserByUsernamePassword(username, password, ipAddress);
|
|
if (user != null)
|
|
{
|
|
if (IsRoleAllowedToLogin(user.Role))
|
|
{
|
|
// issue authentication ticket
|
|
FormsAuthenticationTicket ticket = CreateAuthTicket(user.Username, user.Password, user.Role, rememberLogin);
|
|
SetAuthTicket(ticket, rememberLogin);
|
|
|
|
CompleteUserLogin(username, rememberLogin, preferredLocale, theme);
|
|
}
|
|
else return BusinessErrorCodes.ERROR_USER_ACCOUNT_ROLE_NOT_ALLOWED;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
private static bool IsRoleAllowedToLogin(UserRole role)
|
|
{
|
|
|
|
string tmp = GetExcludedRolesToLogin();
|
|
|
|
if (tmp == null) tmp = string.Empty;
|
|
|
|
string roleKey = ((UserRole)role).ToString();
|
|
|
|
return !tmp.Contains(roleKey);
|
|
}
|
|
|
|
|
|
public static string GetExcludedRolesToLogin()
|
|
{
|
|
return PortalConfiguration.SiteSettings["ExcludedRolesToLogin"];
|
|
}
|
|
|
|
|
|
|
|
public static bool GetHideThemeAndLocale()
|
|
{
|
|
bool bResult = false;
|
|
|
|
try
|
|
{
|
|
bResult = Convert.ToBoolean(PortalConfiguration.SiteSettings["HideThemeAndLocale"]);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
|
|
}
|
|
|
|
return bResult;
|
|
}
|
|
|
|
|
|
|
|
private static int GetAuthenticationFormsTimeout()
|
|
{
|
|
//default
|
|
int retValue = 30;
|
|
try
|
|
{
|
|
AuthenticationSection authenticationSection = WebConfigurationManager.GetSection("system.web/authentication") as AuthenticationSection;
|
|
if (authenticationSection != null)
|
|
{
|
|
FormsAuthenticationConfiguration fac = authenticationSection.Forms;
|
|
retValue = (int) Math.Truncate(fac.Timeout.TotalMinutes);
|
|
}
|
|
|
|
}
|
|
catch
|
|
{
|
|
return retValue;
|
|
}
|
|
|
|
return retValue;
|
|
}
|
|
|
|
private static FormsAuthenticationTicket CreateAuthTicket(string username, string password,
|
|
UserRole role, bool persistent)
|
|
{
|
|
return new FormsAuthenticationTicket(
|
|
1,
|
|
username,
|
|
DateTime.Now,
|
|
DateTime.Now.AddMinutes(GetAuthenticationFormsTimeout()),
|
|
persistent,
|
|
String.Concat(password, Environment.NewLine, Enum.GetName(typeof(UserRole), role))
|
|
);
|
|
}
|
|
|
|
public static int ChangeUserPassword(int userId, string newPassword)
|
|
{
|
|
// load user account
|
|
esUsers usersService = new esUsers();
|
|
ConfigureEnterpriseServerProxy(usersService, true);
|
|
|
|
try
|
|
{
|
|
UserInfo user = usersService.GetUserById(userId);
|
|
|
|
// change WebsitePanel account password
|
|
int result = usersService.ChangeUserPassword(userId, newPassword);
|
|
if (result < 0)
|
|
return result;
|
|
|
|
// change auth cookie
|
|
if (String.Compare(user.Username, AuthTicket.Name, true) == 0)
|
|
{
|
|
FormsAuthenticationTicket ticket = CreateAuthTicket(user.Username, newPassword, user.Role, AuthTicket.IsPersistent);
|
|
SetAuthTicket(ticket, AuthTicket.IsPersistent);
|
|
}
|
|
return result;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
public static int UpdateUserAccount(UserInfo user)
|
|
{
|
|
return UpdateUserAccount(null, user);
|
|
}
|
|
|
|
public static int UpdateUserAccount(string taskId, UserInfo user)
|
|
{
|
|
esUsers usersService = new esUsers();
|
|
ConfigureEnterpriseServerProxy(usersService, true);
|
|
|
|
try
|
|
{
|
|
// update user in WebsitePanel
|
|
return usersService.UpdateUserTask(taskId, user);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
public static int AddUserAccount(List<string> log, UserInfo user, bool sendLetter)
|
|
{
|
|
esUsers usersService = new esUsers();
|
|
ConfigureEnterpriseServerProxy(usersService, true);
|
|
|
|
try
|
|
{
|
|
// add user to WebsitePanel server
|
|
return usersService.AddUser(user, sendLetter);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
public static int DeleteUserAccount(int userId)
|
|
{
|
|
esUsers usersService = new esUsers();
|
|
ConfigureEnterpriseServerProxy(usersService, true);
|
|
|
|
try
|
|
{
|
|
// add user to WebsitePanel server
|
|
return usersService.DeleteUser(userId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
public static int ChangeUserStatus(int userId, UserStatus status)
|
|
{
|
|
esUsers usersService = new esUsers();
|
|
ConfigureEnterpriseServerProxy(usersService, true);
|
|
|
|
try
|
|
{
|
|
// add user to WebsitePanel server
|
|
return usersService.ChangeUserStatus(userId, status);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
public static UserInfo GetCurrentUser()
|
|
{
|
|
UserInfo user = null;
|
|
|
|
if (AuthTicket != null)
|
|
{
|
|
esUsers usersService = new esUsers();
|
|
ConfigureEnterpriseServerProxy(usersService);
|
|
|
|
user = usersService.GetUserByUsername(AuthTicket.Name);
|
|
}
|
|
|
|
return user;
|
|
}
|
|
|
|
private static void CompleteUserLogin(string username, bool rememberLogin,
|
|
string preferredLocale, string theme)
|
|
{
|
|
// store last successful username in the cookie
|
|
HttpCookie cookie = new HttpCookie("WebsitePanelLogin", username);
|
|
cookie.Expires = DateTime.Now.AddDays(7);
|
|
cookie.Secure = FormsAuthentication.RequireSSL;
|
|
cookie.HttpOnly = true;
|
|
HttpContext.Current.Response.Cookies.Add(cookie);
|
|
|
|
// set language
|
|
SetCurrentLanguage(preferredLocale);
|
|
|
|
// set theme
|
|
SetCurrentTheme(theme);
|
|
|
|
// remember me
|
|
if (rememberLogin)
|
|
HttpContext.Current.Response.Cookies[FormsAuthentication.FormsCookieName].Expires = DateTime.Now.AddMonths(1);
|
|
}
|
|
|
|
public static void SetCurrentLanguage(string preferredLocale)
|
|
{
|
|
if (!String.IsNullOrEmpty(preferredLocale))
|
|
{
|
|
HttpCookie localeCrumb = new HttpCookie(CultureCookieName, preferredLocale);
|
|
localeCrumb.Expires = DateTime.Now.AddMonths(2);
|
|
HttpContext.Current.Response.Cookies.Add(localeCrumb);
|
|
}
|
|
}
|
|
|
|
public static void ConfigureEnterpriseServerProxy(WebServicesClientProtocol proxy)
|
|
{
|
|
ConfigureEnterpriseServerProxy(proxy, true);
|
|
}
|
|
|
|
public static void ConfigureEnterpriseServerProxy(WebServicesClientProtocol proxy, bool applyPolicy)
|
|
{
|
|
// load ES properties
|
|
string serverUrl = PortalConfiguration.SiteSettings["EnterpriseServer"];
|
|
|
|
EnterpriseServerProxyConfigurator cnfg = new EnterpriseServerProxyConfigurator();
|
|
cnfg.EnterpriseServerUrl = serverUrl;
|
|
|
|
// create assertion
|
|
if (applyPolicy)
|
|
{
|
|
if (AuthTicket != null)
|
|
{
|
|
cnfg.Username = AuthTicket.Name;
|
|
cnfg.Password = AuthTicket.UserData.Substring(0, AuthTicket.UserData.IndexOf(Environment.NewLine));
|
|
}
|
|
}
|
|
|
|
cnfg.Configure(proxy);
|
|
}
|
|
|
|
public static XmlNode GetModuleContentNode(WebPortalControlBase module)
|
|
{
|
|
XmlNodeList nodes = module.Module.SelectNodes("Content");
|
|
return nodes.Count > 0 ? nodes[0] : null;
|
|
}
|
|
|
|
public static XmlNodeList GetModuleMenuItems(WebPortalControlBase module)
|
|
{
|
|
return module.Module.SelectNodes("MenuItem");
|
|
}
|
|
|
|
public static string FormatIconImageUrl(string url)
|
|
{
|
|
return url;
|
|
}
|
|
|
|
public static string FormatIconLinkUrl(object url)
|
|
{
|
|
return DefaultPage.GetPageUrl(url.ToString());
|
|
}
|
|
|
|
public static string GetThemedImage(string imageUrl)
|
|
{
|
|
Page page = (Page)HttpContext.Current.Handler;
|
|
return page.ResolveUrl("~/App_Themes/" + page.Theme + "/Images/" + imageUrl);
|
|
}
|
|
|
|
public static string GetThemedIcon(string iconUrl)
|
|
{
|
|
Page page = (Page)HttpContext.Current.Handler;
|
|
return page.ResolveUrl("~/App_Themes/" + page.Theme + "/" + iconUrl);
|
|
}
|
|
|
|
public static void LoadStatesDropDownList(DropDownList list, string countryCode)
|
|
{
|
|
string xmlFilePath = HttpContext.Current.Server.MapPath(CONFIG_FOLDER + "CountryStates.config");
|
|
list.Items.Clear();
|
|
if (File.Exists(xmlFilePath))
|
|
{
|
|
try
|
|
{
|
|
XmlDocument xmlDoc = new XmlDocument();
|
|
xmlDoc.Load(xmlFilePath);
|
|
|
|
List<ListItem> items = new List<ListItem>();
|
|
|
|
XmlNodeList xmlNodes = xmlDoc.SelectNodes("//State[@countryCode='" + countryCode + "']");
|
|
foreach (XmlElement xmlNode in xmlNodes)
|
|
{
|
|
string nodeName = xmlNode.GetAttribute("name");
|
|
string nodeKey = xmlNode.GetAttribute("key");
|
|
|
|
items.Add(new ListItem(nodeName, nodeKey));
|
|
}
|
|
|
|
list.Items.AddRange(items.ToArray());
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void LoadCountriesDropDownList(DropDownList list, string countryToSelect)
|
|
{
|
|
string countriesPath = HttpContext.Current.Server.MapPath(CONFIG_FOLDER + "Countries.config");
|
|
|
|
if (File.Exists(countriesPath))
|
|
{
|
|
try
|
|
{
|
|
XmlDocument xmlCountriesDoc = new XmlDocument();
|
|
xmlCountriesDoc.Load(countriesPath);
|
|
|
|
List<ListItem> items = new List<ListItem>();
|
|
|
|
XmlNodeList xmlCountries = xmlCountriesDoc.SelectNodes("//Country");
|
|
foreach (XmlElement xmlCountry in xmlCountries)
|
|
{
|
|
string countryName = xmlCountry.GetAttribute("name");
|
|
string countryKey = xmlCountry.GetAttribute("key");
|
|
|
|
if (String.Compare(countryKey, countryToSelect) == 0)
|
|
{
|
|
ListItem li = new ListItem(countryName, countryKey);
|
|
li.Selected = true;
|
|
items.Add(li);
|
|
}
|
|
else
|
|
items.Add(new ListItem(countryName, countryKey));
|
|
}
|
|
|
|
list.Items.AddRange(items.ToArray());
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static void LoadCultureDropDownList(DropDownList list)
|
|
{
|
|
string localesPath = HttpContext.Current.Server.MapPath(CONFIG_FOLDER + "SupportedLocales.config");
|
|
|
|
if (File.Exists(localesPath))
|
|
{
|
|
|
|
string localeToSelect = CurrentCulture.Name;
|
|
|
|
try
|
|
{
|
|
XmlDocument xmlLocalesDoc = new XmlDocument();
|
|
xmlLocalesDoc.Load(localesPath);
|
|
|
|
XmlNodeList xmlLocales = xmlLocalesDoc.SelectNodes("//Locale");
|
|
for (int i = 0; i < xmlLocales.Count; i++)
|
|
{
|
|
XmlElement xmlLocale = (XmlElement) xmlLocales[i];
|
|
|
|
string localeName = xmlLocale.GetAttribute("name");
|
|
string localeKey = xmlLocale.GetAttribute("key");
|
|
|
|
list.Items.Add(new ListItem(localeName, localeKey));
|
|
}
|
|
|
|
|
|
HttpCookie localeCrumb = HttpContext.Current.Request.Cookies[CultureCookieName];
|
|
if (localeCrumb != null)
|
|
{
|
|
ListItem item = list.Items.FindByValue(localeToSelect);
|
|
if (item != null)
|
|
item.Selected = true;
|
|
}
|
|
else
|
|
{
|
|
if (list.Items.Count > 0 && list.Items[0] != null)
|
|
{
|
|
SetCurrentLanguage(list.Items[0].Value);
|
|
HttpContext.Current.Response.Redirect(HttpContext.Current.Request.Url.ToString());
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void LoadThemesDropDownList(DropDownList list)
|
|
{
|
|
string localesPath = HttpContext.Current.Server.MapPath(CONFIG_FOLDER + "SupportedThemes.config");
|
|
|
|
if (File.Exists(localesPath))
|
|
{
|
|
string themeToSelect = CurrentTheme;
|
|
|
|
try
|
|
{
|
|
XmlDocument doc = new XmlDocument();
|
|
doc.Load(localesPath);
|
|
|
|
XmlNodeList xmlThemes = doc.SelectNodes("//Theme");
|
|
for (int i = 0; i < xmlThemes.Count; i++)
|
|
{
|
|
XmlElement xmlTheme = (XmlElement)xmlThemes[i];
|
|
string themeName = xmlTheme.GetAttribute("name");
|
|
string themeTitle = xmlTheme.GetAttribute("title");
|
|
|
|
list.Items.Add(new ListItem(themeTitle, themeName));
|
|
|
|
if (String.Compare(themeName, themeToSelect) == 0)
|
|
list.Items[i].Selected = true;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
#region Navigation Routines
|
|
public static string LoginRedirectUrl
|
|
{
|
|
get { return DefaultPage.GetPageUrl(PortalConfiguration.SiteSettings["DefaultPage"]); }
|
|
}
|
|
|
|
public static string GetUserHomePageUrl(int userId)
|
|
{
|
|
string userHomePageId = PortalConfiguration.SiteSettings["UserHomePage"];
|
|
return userId > 0 ? NavigatePageURL(userHomePageId, USER_ID_PARAM, userId.ToString())
|
|
: NavigatePageURL(userHomePageId);
|
|
}
|
|
|
|
public static string GetUserCustomersPageId()
|
|
{
|
|
return PortalConfiguration.SiteSettings["UserCustomersPage"];
|
|
}
|
|
|
|
public static string GetUsersSearchPageId()
|
|
{
|
|
return PortalConfiguration.SiteSettings["UsersSearchPage"];
|
|
}
|
|
|
|
public static string GetSpacesSearchPageId()
|
|
{
|
|
return PortalConfiguration.SiteSettings["SpacesSearchPage"];
|
|
}
|
|
|
|
public static string GetNestedSpacesPageId()
|
|
{
|
|
return PortalConfiguration.SiteSettings["NestedSpacesPage"];
|
|
}
|
|
|
|
public static string GetSpaceHomePageUrl(int spaceId)
|
|
{
|
|
string spaceHomePageId = PortalConfiguration.SiteSettings["SpaceHomePage"];
|
|
return spaceId > -1 ? NavigatePageURL(spaceHomePageId, SPACE_ID_PARAM, spaceId.ToString())
|
|
: NavigatePageURL(spaceHomePageId);
|
|
}
|
|
|
|
public static string GetLoggedUserAccountPageUrl()
|
|
{
|
|
return NavigatePageURL(PortalConfiguration.SiteSettings["LoggedUserAccountPage"]);
|
|
}
|
|
|
|
public static string NavigateURL()
|
|
{
|
|
return NavigateURL(null, null);
|
|
}
|
|
|
|
public static string NavigatePageURL(string pageId)
|
|
{
|
|
return NavigatePageURL(pageId, null, null, new string[] { });
|
|
}
|
|
|
|
public static string NavigateURL(string keyName, string keyValue, params string[] additionalParams)
|
|
{
|
|
return NavigatePageURL(HttpContext.Current.Request[DefaultPage.PAGE_ID_PARAM], keyName, keyValue, additionalParams);
|
|
}
|
|
|
|
public static string NavigatePageURL(string pageId, string keyName, string keyValue, params string[] additionalParams)
|
|
{
|
|
string navigateUrl = DefaultPage.DEFAULT_PAGE;
|
|
|
|
List<string> urlBuilder = new List<string>();
|
|
|
|
// add page id parameter
|
|
if (!String.IsNullOrEmpty(pageId))
|
|
urlBuilder.Add(String.Concat(DefaultPage.PAGE_ID_PARAM, "=", pageId));
|
|
|
|
// add specified key
|
|
if (!String.IsNullOrEmpty(keyName) && !String.IsNullOrEmpty(keyValue))
|
|
urlBuilder.Add(String.Concat(keyName, "=", keyValue));
|
|
|
|
// load additional params
|
|
if (additionalParams != null)
|
|
{
|
|
string controlId = null;
|
|
string moduleDefinitionId = null;
|
|
//
|
|
foreach (string paramStr in additionalParams)
|
|
{
|
|
if (paramStr.StartsWith("ctl=", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
// ensure page exists and avoid unnecessary exceptions throw
|
|
if (PortalConfiguration.Site.Pages.ContainsKey(pageId))
|
|
{
|
|
string[] pair = paramStr.Split('=');
|
|
controlId = pair[1];
|
|
}
|
|
|
|
}
|
|
else if (paramStr.StartsWith("moduleDefId=", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
// ensure page exists and avoid unnecessary exceptions throw
|
|
if (PortalConfiguration.Site.Pages.ContainsKey(pageId))
|
|
{
|
|
string[] pair = paramStr.Split('=');
|
|
moduleDefinitionId = pair[1];
|
|
}
|
|
continue;
|
|
}
|
|
urlBuilder.Add(paramStr);
|
|
}
|
|
if (!String.IsNullOrEmpty(moduleDefinitionId) && !String.IsNullOrEmpty(controlId))
|
|
{
|
|
// 1. Read module controls first information first
|
|
foreach (ModuleDefinition md in PortalConfiguration.ModuleDefinitions.Values)
|
|
{
|
|
if (String.Equals(md.Id, moduleDefinitionId, StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
// 2. Lookup for module control
|
|
foreach (ModuleControl mc in md.Controls.Values)
|
|
{
|
|
// 3. Compare against ctl parameter value
|
|
if (mc.Key.Equals(controlId, StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
// 4. Lookup for module id
|
|
foreach (int pmKey in PortalConfiguration.Site.Modules.Keys)
|
|
{
|
|
PageModule pm = PortalConfiguration.Site.Modules[pmKey];
|
|
if (String.Equals(pm.ModuleDefinitionID, md.Id,
|
|
StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
// 5. Append module id parameter
|
|
urlBuilder.Add("mid=" + pmKey);
|
|
goto End;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
End:
|
|
if (urlBuilder.Count > 0)
|
|
navigateUrl += String.Concat("?", String.Join("&", urlBuilder.ToArray()));
|
|
|
|
return navigateUrl;
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
//
|
|
*/ |