protected override void OnInit(EventArgs e)
{
base.OnInit(e);
mCategoryId = QueryHelper.GetInteger("categoryid", 0);
mTreeRoot = QueryHelper.GetText("treeroot", "customsettings");
mWholeSettings = mTreeRoot == "settings";
mRootName = mWholeSettings ? "CMS.Settings" : "CMS.CustomSettings";
if (mCategoryId > 0)
{
mCategoryInfo = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(mCategoryId);
}
else
{
mCategoryInfo = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName(mRootName);
}
if (mCategoryInfo != null)
{
mCategoryId = mCategoryInfo.CategoryID;
}
// Intialize the control
SetupControl();
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
mCategoryId = QueryHelper.GetInteger("categoryid", 0);
mTreeRoot = QueryHelper.GetText("treeroot", "customsettings");
mWholeSettings = mTreeRoot == "settings";
mRootName = mWholeSettings ? "CMS.Settings" : "CMS.CustomSettings";
if (mCategoryId > 0)
{
mCategoryInfo = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(mCategoryId);
}
else
{
mCategoryInfo = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName(mRootName);
}
if (mCategoryInfo != null)
{
mCategoryId = mCategoryInfo.CategoryID;
}
// Intialize the control
SetupControl();
}
/// <summary>
/// Gets path containing display names of all predecessors of given category and name of category itself.
/// </summary>
/// <param name="child">Category to get path from</param>
/// <returns>String containing path to given Category</returns>
private string GetCategoryPathNames(SettingsCategoryInfo child)
{
// Convert IDPath to be suitable for IN-clause of SQL query
string inClause = child.CategoryIDPath.Remove(0, 1).Replace('/', ',');
StringBuilder sb = new StringBuilder("");
if (!string.IsNullOrEmpty(inClause))
{
// Get display names of all categories from path, order by nesting level
DataSet ds = SettingsCategoryInfoProvider.GetSettingsCategories(string.Format("CategoryID IN ({0}) AND CategoryLevel > 0", inClause), "CategoryLevel", -1, "CategoryDisplayName");
if (!DataHelper.DataSourceIsEmpty(ds))
{
foreach (DataRow row in ds.Tables[0].Rows)
{
// No slash before first name
if (sb.Length > 0)
{
sb.Append(" / ");
}
sb.Append(ValidationHelper.GetString(row["CategoryDisplayName"], ""));
}
}
}
return(sb.ToString());
}
/// <summary>
/// Gets and bulk updates settings categories. Called when the "Get and bulk update categories" button is pressed.
/// Expects the CreateSettingsCategory method to be run first.
/// </summary>
private bool GetAndBulkUpdateSettingsCategories()
{
// Prepare the parameters
string where = "CategoryName LIKE 'MyNew%' AND CategoryIsGroup = 0";
// Get the settings categories
DataSet categories = SettingsCategoryInfoProvider.GetSettingsCategories(where, null);
if (!DataHelper.DataSourceIsEmpty(categories))
{
// Loop through the individual items
foreach (DataRow categoryDr in categories.Tables[0].Rows)
{
// Create object from DataRow
SettingsCategoryInfo modifyCategory = new SettingsCategoryInfo(categoryDr);
// Update the property
modifyCategory.CategoryDisplayName = modifyCategory.CategoryDisplayName.ToUpper();
// Update the settings category
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(modifyCategory);
}
return(true);
}
return(false);
}
/// <summary>
/// Creates settings group. Called when the "Create group" button is pressed.
/// Expects the CreateSettingsCategory method to be run first.
/// </summary>
private bool CreateSettingsGroup()
{
// Get the settings category
SettingsCategoryInfo settingsCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName("MyNewSettingsCategory");
if (settingsCategory != null)
{
// Create new settings group object
SettingsCategoryInfo newGroup = new SettingsCategoryInfo();
// Set the properties
newGroup.CategoryDisplayName = "My New Settings Group";
newGroup.CategoryName = "MyNewSettingsGroup";
newGroup.CategoryOrder = 0;
newGroup.CategoryParentID = settingsCategory.CategoryID;
newGroup.CategoryIsGroup = true;
newGroup.CategoryIsCustom = true;
// Create the settings group
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(newGroup);
return(true);
}
return(false);
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
string[,] breadcrumbs = new string[2, 4];
breadcrumbs[0, 2] = "_parent";
breadcrumbs[1, 1] = "";
// Set bradcrumbs for editing
if (skeEditKey.SettingsKeyObj != null)
{
SettingsCategoryInfo sci = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(skeEditKey.SettingsKeyObj.KeyCategoryID);
breadcrumbs[0, 0] = sci.CategoryDisplayName;
breadcrumbs[0, 1] = ResolveUrl("CustomSettingsCategory_Default.aspx?treeroot=" + mTreeRoot + "&categoryid=" + sci.CategoryParentID + "&siteid=" + mSiteId);
breadcrumbs[1, 0] = skeEditKey.SettingsKeyObj.KeyDisplayName;
}
// Set bradcrumbs for creating new key
else
{
if (mParentGroup != null)
{
SettingsCategoryInfo parentCat = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName(mParentGroup);
if (parentCat != null)
{
breadcrumbs[0, 0] = parentCat.CategoryDisplayName;
breadcrumbs[0, 1] = ResolveUrl("CustomSettingsCategory_Default.aspx?treeroot=" + mTreeRoot + "&categoryid=" + parentCat.CategoryParentID + "&siteid=" + mSiteId);
breadcrumbs[1, 0] = GetString("Development.CustomSettings.NewKey");
}
}
}
CurrentMaster.Title.Breadcrumbs = breadcrumbs;
}
/// <summary>
/// Creates settings key. Called when the "Create key" button is pressed.
/// </summary>
private bool CreateSettingsKey()
{
// Get the settings group
SettingsCategoryInfo settingsGroup = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName("MyNewSettingsGroup");
if (settingsGroup != null)
{
// Create new settings key object
SettingsKeyInfo newKey = new SettingsKeyInfo();
// Set the properties
newKey.KeyDisplayName = "My new key";
newKey.KeyName = "MyNewKey";
newKey.KeyDescription = "My new key description";
newKey.KeyType = "string";
newKey.KeyValue = "My new value";
newKey.KeyCategoryID = settingsGroup.CategoryID;
newKey.KeyDefaultValue = null;
// Set Site ID for site specific settings key (for global settings key is default value 0).
newKey.SiteID = CMSContext.CurrentSiteID;
// Create the settings key
SettingsKeyProvider.SetValue(newKey);
return(true);
}
return(false);
}
/// <summary>
/// Gets and bulk updates settings groups. Called when the "Get and bulk update groups" button is pressed.
/// Expects the CreateSettingsGroup method to be run first.
/// </summary>
private bool GetAndBulkUpdateSettingsGroups()
{
// Prepare the parameters
string where = "CategoryName LIKE 'MyNew%' AND CategoryIsGroup = 1";
string orderBy = "CategoryName";
// Get the data
DataSet groups = SettingsCategoryInfoProvider.GetSettingsCategories(where, orderBy);
if (!DataHelper.DataSourceIsEmpty(groups))
{
// Loop through the individual items
foreach (DataRow groupDr in groups.Tables[0].Rows)
{
// Create object from DataRow
SettingsCategoryInfo modifyGroup = new SettingsCategoryInfo(groupDr);
// Update the property
modifyGroup.CategoryDisplayName = modifyGroup.CategoryDisplayName.ToUpper();
// Update settings group
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(modifyGroup);
}
return(true);
}
return(false);
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
// Get query string parameters
int siteId = QueryHelper.GetInteger("siteid", 0);
int categoryId = QueryHelper.GetInteger("categoryid", 0);
string searchForText = QueryHelper.GetString("search", "");
bool searchInDescription = QueryHelper.GetBoolean("description", false);
// Get category
SettingsCategoryInfo category = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(categoryId);
// Either category or search text needs to be set
if ((category == null) && (!string.IsNullOrEmpty(searchForText)))
{
return;
}
// Get site
SiteInfo site = SiteInfoProvider.GetSiteInfo(siteId);
// Export settings
Export(category, searchForText, searchInDescription, site);
}
/// <summary>
/// Creates settings category. Called when the "Create category" button is pressed.
/// </summary>
private bool CreateSettingsCategory()
{
// Get parent category ID
SettingsCategoryInfo parentCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName("CMS.CustomSettings");
if (parentCategory != null)
{
// Create new settings category object
SettingsCategoryInfo newCategory = new SettingsCategoryInfo();
// Set the properties
newCategory.CategoryDisplayName = "My New Settings Category";
newCategory.CategoryName = "MyNewSettingsCategory";
newCategory.CategoryOrder = 0;
newCategory.CategoryParentID = parentCategory.CategoryID;
newCategory.CategoryIsGroup = false;
newCategory.CategoryIsCustom = true;
// Create settings category
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(newCategory);
return(true);
}
return(false);
}
/// <summary>
/// Creates SettingsGroup panel for a specified category.
/// </summary>
/// <param name="category">Non-group category</param>
protected CMSUserControl CreatePanelForCategory(SettingsCategoryInfo category)
{
if (category == null)
{
return(null);
}
// Create new Category bar and initialize it
SettingsGroup group = Page.LoadUserControl("~/CMSModules/Modules/Controls/Settings/Category/SettingsGroup.ascx") as SettingsGroup;
if (group != null)
{
group.Category = category;
group.ModuleID = ModuleID;
group.ActionPerformed += group_ActionPerformed;
group.OnNewKey += group_OnNewKey;
group.OnKeyAction += group_OnKeyAction;
ResourceInfo resource = ResourceInfoProvider.GetResourceInfo(ModuleID);
group.AllowEdit = (resource != null) && ((resource.ResourceIsInDevelopment && (resource.ResourceID == category.CategoryResourceID)) || SystemContext.DevelopmentMode);
}
return(group);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!RequestHelper.IsPostBack())
{
treeSettings.SelectPath = "/";
int categoryId = QueryHelper.GetInteger("categoryid", -1);
SettingsCategoryInfo category = SettingsCategoryInfo.Provider.Get(categoryId);
// Select requested category
if (category != null)
{
treeSettings.SelectPath = category.CategoryIDPath;
treeSettings.CategoryID = category.CategoryID;
treeSettings.ParentID = category.CategoryParentID;
treeSettings.CategoryModuleID = category.CategoryResourceID;
treeSettings.Value = category.CategoryID + "|" + category.CategoryParentID;
}
else
{
// Select root
SettingsCategoryInfo rootCat = treeSettings.RootCategory;
if (rootCat != null)
{
treeSettings.CategoryID = rootCat.CategoryID;
treeSettings.ParentID = rootCat.CategoryParentID;
treeSettings.Value = rootCat.CategoryID + "|" + rootCat.CategoryParentID;
}
}
}
}
public static ScopeNode BuildSettingsCategoryNode(
string displayName,
string formViewDescriptionDisplayName,
SettingsCategoryInfo settingsCategoryInfo,
Nullable <int> imageIndex,
Nullable <int> selectedImageIndex,
bool hideExpandIcon)
{
ScopeNode result = new ScopeNode(hideExpandIcon)
{
DisplayName = displayName
};
ValidateMandatoryNodeFields(result);
result.ViewDescriptions.Add(new FormViewDescription() //Tells the snap-in how to construct a form and what control to to add it to.
{
DisplayName = formViewDescriptionDisplayName,
ViewType = typeof(SettingsFormViewWindows), //The Type of the form to instantiate.
ControlType = typeof(SettingsControlWindows), //The Type of the control to instantiate and place onto the form.
Tag = settingsCategoryInfo, //Informs the SettingsControl which CATEGORY of settings to display i.e. i.e. the properties of the Settings class which have an attribute with the same Category name set.
});
result.ViewDescriptions.DefaultIndex = 0;
SetImageIndices(result, imageIndex, selectedImageIndex);
return(result);
}
protected void Page_Load(object sender, EventArgs e)
{
ScriptHelper.RegisterJQuery(Page);
// URL for tree selection
string script = "var categoryURL = '" + ResolveUrl("keys.aspx") + "';\n";
script += "var doNotReloadContent = false;\n";
// Get selected site id
mSiteId = ValidationHelper.GetInteger(siteSelector.Value, 0);
TreeViewCategories.SiteID = mSiteId;
TreeViewCategories.RootIsClickable = true;
int categoryId = 0;
if (Request.Params["selectedCategoryId"] != null)
{
// Selected category
categoryId = ValidationHelper.GetInteger(Request.Params["selectedCategoryId"], 0);
}
else
{
// First request to Settings
categoryId = SettingsCategoryInfoProvider.GetRootSettingsCategoryInfo().CategoryID;
}
bool reload = QueryHelper.GetBoolean("reload", true);
// Select category
SettingsCategoryInfo sci = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(categoryId);
if (sci != null)
{
// Stop reloading of right frame, if explicitly set
if (!reload)
{
script += "doNotReloadContent = true;";
}
script += SelectAtferLoad(sci.CategoryIDPath, sci.CategoryName, sci.CategoryID, sci.CategoryParentID);
}
ScriptHelper.RegisterStartupScript(Page, typeof(string), "SelectCat", ScriptHelper.GetScript(script));
// Style site selector
siteSelector.DropDownSingleSelect.CssClass = "";
siteSelector.DropDownSingleSelect.Attributes.Add("style", "width: 100%");
lblSite.Text = GetString("general.site") + ResHelper.Colon;
// Set site selector
siteSelector.DropDownSingleSelect.AutoPostBack = true;
siteSelector.AllowAll = false;
siteSelector.UniSelector.SpecialFields = new string[1, 2] {
{ GetString("general.global"), "0" }
};
siteSelector.OnlyRunningSites = false;
}
protected void Page_Load(object sender, EventArgs e)
{
// Get query strings
mCategoryId = QueryHelper.GetInteger("categoryid", 0);
mSiteId = QueryHelper.GetInteger("siteid", 0);
// Assign category id, site id
SettingsGroupViewer.CategoryID = mCategoryId;
SettingsGroupViewer.SiteID = mSiteId;
if (SettingsGroupViewer.SettingsCategoryInfo == null)
{
// Get root category info
SettingsCategoryInfo sci = SettingsCategoryInfoProvider.GetRootSettingsCategoryInfo();
SettingsGroupViewer.CategoryID = sci.CategoryID;
}
// Get search text if exist
string search = QueryHelper.GetString("search", String.Empty).Trim();
// If root selected show search controls
if ((SettingsKeyProvider.DevelopmentMode) && (SettingsGroupViewer.CategoryName == "CMS.Settings"))
{
pnlSearch.Visible = true;
lblNoSettings.ResourceString = "Development.Settings.SearchSettings";
if (!string.IsNullOrEmpty(search))
{
// Set searched values
if (!URLHelper.IsPostback())
{
txtSearch.Text = search;
chkDescription.Checked = QueryHelper.GetBoolean("description", true);
}
}
RegisterSearchScript();
}
// Set master title
CurrentMaster.Title.TitleText = HTMLHelper.HTMLEncode(ResHelper.LocalizeString(SettingsGroupViewer.SettingsCategoryInfo.CategoryDisplayName));
CurrentMaster.Title.TitleImage = GetImageUrlForHeader(SettingsGroupViewer.SettingsCategoryInfo.CategoryName);
CurrentMaster.Title.HelpTopicName = GetHelpTopicName();
// Check, if there are any groups
DataSet ds = SettingsCategoryInfoProvider.GetSettingsCategories("CategoryIsGroup = 1 AND CategoryParentID = " + mCategoryId, null, -1, "CategoryID");
if ((!DataHelper.DataSourceIsEmpty(ds)) || (!string.IsNullOrEmpty(search)))
{
CurrentMaster.HeaderActions.Actions = GetHeaderActions();
CurrentMaster.HeaderActions.ActionPerformed += HeaderActions_ActionPerformed;
}
else
{
lblNoSettings.Visible = true;
}
ScriptHelper.RegisterSaveShortcut(this, "save", false);
}
/// <summary>
/// Deletes settings category. Called when the "Delete category" button is pressed.
/// Expects the CreateSettingsCategory method to be run first.
/// </summary>
private bool DeleteSettingsCategory()
{
// Get the settings category
SettingsCategoryInfo deleteCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName("MyNewSettingsCategory");
// Delete the settings category
SettingsCategoryInfoProvider.DeleteSettingsCategoryInfo(deleteCategory);
return(deleteCategory != null);
}
/// <summary>
/// Deletes settings group. Called when the "Delete group" button is pressed.
/// Expects the CreateSettingsGroup method to be run first.
/// </summary>
private bool DeleteSettingsGroup()
{
// Get the settings group
SettingsCategoryInfo deleteGroup = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName("MyNewSettingsGroup");
// Delete the settings group
SettingsCategoryInfoProvider.DeleteSettingsCategoryInfo(deleteGroup);
return(deleteGroup != null);
}
/// <summary>
/// Handles the whole category actions.
/// </summary>
/// <param name="sender">Sender of event</param>
/// <param name="e">Event arguments</param>
protected void grpEdit_ActionPerformed(object sender, CommandEventArgs e)
{
int categoryId = ValidationHelper.GetInteger(e.CommandArgument, 0);
switch (e.CommandName.ToLowerCSafe())
{
case ("edit"):
// Redirect to category edit page
SettingsCategoryInfo sci = SettingsCategoryInfo.Provider.Get(categoryId);
if (sci != null)
{
URLHelper.Redirect(URLHelper.AppendQuery(UIContextHelper.GetElementUrl(ModuleName.CMS, "Modules.Settings.EditCategory", false), "isgroup=1&categoryid=" + categoryId + "&moduleid=" + moduleId));
}
break;
case ("delete"):
try
{
SettingsCategoryInfo settingGroup = SettingsCategoryInfo.Provider.Get(categoryId);
if (settingGroup != null)
{
// Register refresh tree script
StringBuilder sb = new StringBuilder();
sb.Append("if (window.parent != null) {");
sb.Append("if (window.parent.parent.frames['settingstree'] != null) {");
sb.Append("window.parent.parent.frames['settingstree'].location = '" + ResolveUrl("~/CMSModules/Modules/Pages/Settings/Tree.aspx") + "?categoryid=" + settingGroup.CategoryParentID + "&moduleid=" + moduleId + "&reloadtreeselect=1';");
sb.Append("}");
sb.Append("if (window.parent.frames['settingstree'] != null) {");
sb.Append("window.parent.frames['settingstree'].location = '" + ResolveUrl("~/CMSModules/Modules/Pages/Settings/Tree.aspx") + "?categoryid=" + settingGroup.CategoryParentID + "&moduleid=" + moduleId + "&reloadtreeselect=1';");
sb.Append("}");
sb.Append("}");
ScriptHelper.RegisterClientScriptBlock(this, typeof(string), "treeGroupRefresh", ScriptHelper.GetScript(sb.ToString()));
SettingsCategoryInfo.Provider.Delete(settingGroup);
}
}
catch
{
ShowError(GetString("settings.group.deleteerror"));
}
grpEdit.ReloadData();
break;
case ("moveup"):
SettingsCategoryInfoProvider.MoveCategoryUp(categoryId);
grpEdit.ReloadData();
break;
case ("movedown"):
SettingsCategoryInfoProvider.MoveCategoryDown(categoryId);
grpEdit.ReloadData();
break;
}
}
/// <summary>
/// Initialization of controls.
/// </summary>
private void InitControls()
{
// Init validations
rfvKeyDisplayName.ErrorMessage = ResHelper.GetString("general.requiresdisplayname");
rfvKeyName.ErrorMessage = ResHelper.GetString("general.requirescodename");
// Display of LoadGeneration table row
trLoadGeneration.Visible = SystemContext.DevelopmentMode;
// Set the root category
if (RootCategoryID > 0)
{
drpCategory.RootCategoryId = RootCategoryID;
}
// Enable only groups which belong to selected module
drpCategory.EnabledCondition = "{% " + (!SystemContext.DevelopmentMode ? "(CategoryResourceID == " + ModuleID + ") && " : String.Empty) + "(CategoryIsGroup)%}";
// If category specified programmatically
if (mSelectedGroupId >= 0)
{
// Set category selector value
if (!RequestHelper.IsPostBack())
{
drpCategory.SelectedCategory = mSelectedGroupId;
}
// Hide category selector
trCategory.Visible = false;
}
else
{
// Set category selector value
if (!URLHelper.IsPostback() && (SettingsKeyObj != null) && (SettingsKeyObj.KeyCategoryID > 0))
{
drpCategory.SelectedCategory = SettingsKeyObj.KeyCategoryID;
}
}
if (!URLHelper.IsPostback())
{
LoadKeyTypes();
}
// Disable editing for keys not assigned to current module
if (SettingsKeyObj != null)
{
SettingsCategoryInfo parentCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(SettingsKeyObj.KeyCategoryID);
ResourceInfo resource = ResourceInfoProvider.GetResourceInfo(ModuleID);
plnEdit.Enabled = btnOk.Enabled = (resource != null) && (((parentCategory != null) && (parentCategory.CategoryResourceID == resource.ResourceId) && resource.ResourceIsInDevelopment) || SystemContext.DevelopmentMode);
}
ucControlSettings.BasicForm.EnsureMessagesPlaceholder(MessagesPlaceHolder);
}
/// <summary>
/// Get path to the given settings category.
/// </summary>
/// <param name="settingsKeyCategoryInfo">The key that path is generated for</param>
/// <returns>Path to the given settings category</returns>
private IEnumerable <SettingsCategoryInfo> GetCategoryPath(SettingsCategoryInfo settingsKeyCategoryInfo)
{
var sci = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(settingsKeyCategoryInfo.CategoryParentID);
while (sci != null)
{
yield return(sci);
sci = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(sci.CategoryParentID);
}
}
protected void Page_Load(object sender, EventArgs e)
{
//Get parameters
mKeyName = QueryHelper.GetString("keyname", "");
mSiteId = QueryHelper.GetInteger("siteid", -1);
mParentGroup = QueryHelper.GetString("parentgroup", null);
mTreeRoot = QueryHelper.GetText("treeroot", "customsettings");
skeEditKey.IsCustomSetting = mTreeRoot.EqualsCSafe("customsettings", true);
skeEditKey.OnSaved += new EventHandler(skeEditKey_OnSaved);
if (skeEditKey.IsCustomSetting)
{
SettingsCategoryInfo root = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName("CMS.CustomSettings");
if (root != null)
{
skeEditKey.RootCategoryID = root.CategoryID;
}
}
// Set up editing mode
if ((mSiteId >= 0) && !string.IsNullOrEmpty(mKeyName))
{
mEditedKey = SettingsKeyProvider.GetSettingsKeyInfo(mKeyName, mSiteId);
// Set id of key
if (mEditedKey != null)
{
skeEditKey.SettingsKeyID = mEditedKey.KeyID;
}
}
// Set up creating mode
else
{
if (mParentGroup != null)
{
SettingsCategoryInfo parentCat = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName(mParentGroup);
if (parentCat != null)
{
skeEditKey.SelectedGroupID = parentCat.CategoryID;
}
}
}
// Check if there is something right created to edit.
if (ViewState["newId"] != null)
{
skeEditKey.SettingsKeyID = ValidationHelper.GetInteger(ViewState["newId"], 0);
}
skeEditKey.TreeRefreshUrl = "~/CMSModules/Settings/Development/CustomSettings/CustomSettings_Menu.aspx?treeroot=" + mTreeRoot + "&";
skeEditKey.HeaderRefreshUrl = "~/CMSModules/Settings/Development/CustomSettings/CustomSettingsCategory_Tabs.aspx?selectedtab=keys&treeroot=" + mTreeRoot + "&";
}
/// <summary>
/// Raised after menu action (new, delete, up or down) has been taken.
/// </summary>
protected void menuElem_AfterAction(string actionName, object actionArgument)
{
string[] split = actionArgument.ToString().Split('|');
int categoryId = ValidationHelper.GetInteger(split[0], 0);
SettingsCategoryInfo category = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(categoryId);
if (category != null)
{
treeSettings.SelectPath = category.CategoryIDPath;
treeSettings.SelectedItem = category.CategoryName;
switch (actionName.ToLower())
{
case "delete":
treeSettings.ExpandPath = category.CategoryIDPath + "/";
// Reload header and content after save
StringBuilder sb = new StringBuilder();
sb.Append("if (window.parent != null) {");
sb.Append("if (window.parent.frames['customsettingsmain'] != null) {");
sb.Append("window.parent.frames['customsettingsmain'].location = '" + ResolveUrl("CustomSettingsCategory_Default.aspx") + "?categoryid=" + categoryId + "';");
sb.Append("}");
sb.Append("}");
this.ltlScript.Text += ScriptHelper.GetScript(sb.ToString());
treeSettings.ExpandPath = category.CategoryIDPath + "/";
// Update menu actions parameters
this.menuElem.Value = category.CategoryID + "|" + category.CategoryParentID;
break;
case "moveup":
if (split.Length == 2)
{
this.ltlScript.Text += ScriptHelper.GetScript("window.tabIndex = " + split[1] + ";");
}
break;
case "movedown":
if (split.Length == 2)
{
this.ltlScript.Text += ScriptHelper.GetScript("window.tabIndex = " + split[1] + ";");
}
break;
}
this.ltlScript.Text += ScriptHelper.GetScript("SelectNode(" + ScriptHelper.GetString(category.CategoryName) + ");");
this.ltlScript.Text += ScriptHelper.GetScript("var postParentId = " + category.CategoryParentID + ";");
// Load data
treeSettings.ReloadData();
}
}
private IEnumerable <SettingsCategoryInfo> GetGroups(SettingsCategoryInfo category)
{
if (IsSearchTextValid)
{
var groups = SettingsCategoryInfoProvider.GetSettingsCategories("CategoryIsGroup = 1", "CategoryName");
return(groups);
}
else
{
var groups = SettingsCategoryInfoProvider.GetChildSettingsCategories(category.CategoryName, Where);
return(groups.Where(c => c.CategoryIsGroup));
}
}
private IEnumerable <SettingsCategoryInfo> GetGroups(SettingsCategoryInfo category, bool isSearch)
{
if (isSearch)
{
var groups = SettingsCategoryInfoProvider.GetSettingsCategories("CategoryIsGroup = 1", "CategoryName");
return(groups);
}
else
{
var groups = SettingsCategoryInfoProvider.GetChildSettingsCategories(category.CategoryID);
return(groups.Cast <SettingsCategoryInfo>().Where(c => c.CategoryIsGroup).OrderBy(c => c.CategoryOrder));
}
}
/// <summary>
/// Generate info text for given setting key
/// </summary>
/// <param name="ski">Setting key object</param>
private String GenerateInfoText(SettingsKeyInfo ski)
{
// Get setting's group
SettingsCategoryInfo sci = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(ski.KeyCategoryID);
// Get resource name from group
ResourceInfo ri = ResourceInfoProvider.GetResourceInfo(sci.CategoryResourceID);
string resourceName = ResHelper.LocalizeString(ri.ResourceDisplayName);
string path = string.Join(" -> ", GetCategoryPath(sci).Reverse().Select(s => ResHelper.LocalizeString(s.CategoryDisplayName)));
return(String.Format(GetString("ui.moduledisabled.general"), resourceName, path, ResHelper.GetString(ski.KeyDisplayName)));
}
public void CreateCategory(Category category)
{
var parentCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName(category.CategoryParentName);
var newCategory = new SettingsCategoryInfo
{
CategoryDisplayName = category.DisplayName,
CategoryName = category.Name,
CategoryParentID = parentCategory.CategoryID,
CategoryIsGroup = false,
CategoryIsCustom = true,
CategoryResourceID = parentCategory.CategoryResourceID
};
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(newCategory);
}
public void CreateGroup(Group group)
{
var parentCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName(group.Category.Name);
var newGroup = new SettingsCategoryInfo
{
CategoryDisplayName = group.DisplayName,
CategoryName = Guid.NewGuid().ToString(),
CategoryParentID = parentCategory.CategoryID,
CategoryIsGroup = true,
CategoryIsCustom = true,
CategoryResourceID = parentCategory.CategoryResourceID
};
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(newGroup);
}
protected void btnDeleteElem_Click(object sender, EventArgs e)
{
GetHiddenValues();
if ((ElementID > 0) && (ParentID > 0))
{
SettingsCategoryInfo categoryObj = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(ElementID);
if (categoryObj.CategoryName != "CMS.CustomSettings")
{
SettingsCategoryInfoProvider.DeleteSettingsCategoryInfo(categoryObj);
if (AfterAction != null)
{
AfterAction("delete", ParentID);
}
}
}
}
/// <summary>
/// Registers calling the SelectNode script for selected category.
/// </summary>
/// <param name="category">Category to select</param>
private void RegisterSelectNodeScript(SettingsCategoryInfo category)
{
if (category == null)
{
return;
}
string script = "SelectNode('" + category.CategoryName + "'); ";
if (!String.IsNullOrEmpty(JavaScriptHandler))
{
script += "if (" + JavaScriptHandler + ") { " + JavaScriptHandler + "('" + category.CategoryName + "'," + category.CategoryID + "," + SiteID + ", " + category.CategoryParentID + ", " + category.CategoryResourceID + "); }";
}
ScriptHelper.RegisterStartupScript(Page, typeof(string), "refreshAfterAction", ScriptHelper.GetScript(script));
}
/// <summary>
/// Populate the list with sample data
/// </summary>
/// <param name="users">array of user data to add to the list</param>
public void RefreshData()
{
lstvSettings.Items.Clear();
SettingsCategoryInfo settingsCategoryInfo = _settingsFormView.ViewDescriptionTag as SettingsCategoryInfo; //Provides the settings and the category in the settings to be used to populate the list view.
if (settingsCategoryInfo == null)
{
throw new NullReferenceException(string.Format(
"Expected a {0} in the tag of the {1}, but none was supplied.",
typeof(SettingsCategoryInfo).FullName,
typeof(SettingsFormViewWindows).FullName));
}
foreach (SettingItem s in settingsCategoryInfo.Settings.GetSettingsByCategory(settingsCategoryInfo, this))
{
lstvSettings.Items.Add(s.ListViewItem);
}
}
private IEnumerable <SettingsKeyInfo> GetKeys(SettingsCategoryInfo group, bool isSite, string searchText, bool searchInDescription)
{
bool isSearch = !string.IsNullOrEmpty(searchText);
IEnumerable <SettingsKeyInfo> keys = SettingsKeyInfoProvider.GetSettingsKeys(group.CategoryID).OrderBy("KeyOrder", "KeyDisplayName");
if (isSearch)
{
keys = keys.Where(k => SettingsKeyInfoProvider.SearchSettingsKey(k, searchText, searchInDescription));
}
if (isSite)
{
keys = keys.Where(k => !k.KeyIsGlobal);
}
return(keys);
}
/// <summary>
/// Reloads data.
/// </summary>
public void ReloadData()
{
// Get data
DataSet ds = SettingsCategoryInfoProvider.GetChildSettingsCategories(CategoryName, "CategoryIsGroup = 1");
Controls.Clear();
if (!DataHelper.DataSourceIsEmpty(ds))
{
DataRowCollection rows = ds.Tables[0].Rows;
foreach (DataRow row in rows)
{
// Create new panel with info about subcategory
var sci = new SettingsCategoryInfo(row);
CMSUserControl catPanel = CreatePanelForCategory(sci);
catPanel.ID = ControlsHelper.GetUniqueID(this, "CategoryPanel_" + ValidationHelper.GetIdentifier(sci.CategoryName));
Controls.Add(catPanel);
}
}
}
/// <summary>
/// Creates SettingsGroup panel for a specified category.
/// </summary>
/// <param name="category">Non-group category</param>
protected CMSUserControl CreatePanelForCategory(SettingsCategoryInfo category)
{
if (category == null)
{
return null;
}
// Create new Category bar and initialize it
SettingsGroup group = Page.LoadUserControl("~/CMSModules/Modules/Controls/Settings/Category/SettingsGroup.ascx") as SettingsGroup;
if (group != null)
{
group.Category = category;
group.ModuleID = ModuleID;
group.ActionPerformed += group_ActionPerformed;
group.OnNewKey += group_OnNewKey;
group.OnKeyAction += group_OnKeyAction;
ResourceInfo resource = ResourceInfoProvider.GetResourceInfo(ModuleID);
group.AllowEdit = (resource != null) && ((resource.ResourceIsInDevelopment && (resource.ResourceId == category.CategoryResourceID)) || SystemContext.DevelopmentMode);
}
return group;
}
/// <summary>
/// Gets and bulk updates settings groups. Called when the "Get and bulk update groups" button is pressed.
/// Expects the CreateSettingsGroup method to be run first.
/// </summary>
private bool GetAndBulkUpdateSettingsGroups()
{
// Prepare the parameters
string where = "CategoryName LIKE 'MyNew%' AND CategoryIsGroup = 1";
string orderBy = "CategoryName";
// Get the data
DataSet groups = SettingsCategoryInfoProvider.GetSettingsCategories(where, orderBy);
if (!DataHelper.DataSourceIsEmpty(groups))
{
// Loop through the individual items
foreach (DataRow groupDr in groups.Tables[0].Rows)
{
// Create object from DataRow
SettingsCategoryInfo modifyGroup = new SettingsCategoryInfo(groupDr);
// Update the property
modifyGroup.CategoryDisplayName = modifyGroup.CategoryDisplayName.ToUpper();
// Update settings group
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(modifyGroup);
}
return true;
}
return false;
}
/// <summary>
/// Gets and bulk updates settings categories. Called when the "Get and bulk update categories" button is pressed.
/// Expects the CreateSettingsCategory method to be run first.
/// </summary>
private bool GetAndBulkUpdateSettingsCategories()
{
// Prepare the parameters
string where = "CategoryName LIKE 'MyNew%' AND CategoryIsGroup = 0";
// Get the settings categories
DataSet categories = SettingsCategoryInfoProvider.GetSettingsCategories(where, null);
if (!DataHelper.DataSourceIsEmpty(categories))
{
// Loop through the individual items
foreach (DataRow categoryDr in categories.Tables[0].Rows)
{
// Create object from DataRow
SettingsCategoryInfo modifyCategory = new SettingsCategoryInfo(categoryDr);
// Update the property
modifyCategory.CategoryDisplayName = modifyCategory.CategoryDisplayName.ToUpper();
// Update the settings category
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(modifyCategory);
}
return true;
}
return false;
}
/// <summary>
/// Creates settings group. Called when the "Create group" button is pressed.
/// Expects the CreateSettingsCategory method to be run first.
/// </summary>
private bool CreateSettingsGroup()
{
// Get the settings category
SettingsCategoryInfo settingsCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName("MyNewSettingsCategory");
if (settingsCategory != null)
{
// Create new settings group object
SettingsCategoryInfo newGroup = new SettingsCategoryInfo();
// Set the properties
newGroup.CategoryDisplayName = "My New Settings Group";
newGroup.CategoryName = "MyNewSettingsGroup";
newGroup.CategoryOrder = 0;
newGroup.CategoryParentID = settingsCategory.CategoryID;
newGroup.CategoryIsGroup = true;
newGroup.CategoryIsCustom = true;
// Create the settings group
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(newGroup);
return true;
}
return false;
}
private IEnumerable<SettingsKeyInfo> GetKeys(SettingsCategoryInfo group, bool isSite, string searchText, bool searchInDescription)
{
bool isSearch = !string.IsNullOrEmpty(searchText);
IEnumerable<SettingsKeyInfo> keys = SettingsKeyInfoProvider.GetSettingsKeys(group.CategoryID).OrderBy("KeyOrder", "KeyDisplayName");
if (isSearch)
{
keys = keys.Where(k => SettingsKeyInfoProvider.SearchSettingsKey(k, searchText, searchInDescription));
}
if (isSite)
{
keys = keys.Where(k => !k.KeyIsGlobal);
}
return keys;
}
private IEnumerable<SettingsCategoryInfo> GetGroups(SettingsCategoryInfo category)
{
if (IsSearchTextValid)
{
var groups = SettingsCategoryInfoProvider.GetSettingsCategories("CategoryIsGroup = 1", "CategoryName");
return groups;
}
else
{
var groups = SettingsCategoryInfoProvider.GetChildSettingsCategories(category.CategoryName, Where);
return groups.Cast<SettingsCategoryInfo>().Where(c => c.CategoryIsGroup);
}
}
/// <summary>
/// Registers calling the SelectNode script for selected category.
/// </summary>
/// <param name="category">Category to select</param>
private void RegisterSelectNodeScript(SettingsCategoryInfo category)
{
if (category == null)
{
return;
}
string script = "SelectNode('" + category.CategoryName + "'); ";
if (!String.IsNullOrEmpty(JavaScriptHandler))
{
script += "if (" + JavaScriptHandler + ") { " + JavaScriptHandler + "('" + category.CategoryName + "'," + category.CategoryID + "," + SiteID + ", " + category.CategoryParentID + ", " + category.CategoryResourceID + "); }";
}
ScriptHelper.RegisterStartupScript(Page, typeof(string), "refreshAfterAction", ScriptHelper.GetScript(script));
}
/// <summary>
/// Raised after menu action (new, delete, up or down) has been taken.
/// </summary>
protected void AfterAction(string actionName, int categoryId, int tabIndex = 0)
{
SettingsCategoryInfo category = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(categoryId);
if ((category.CategoryResourceID != ModuleID) && !SystemContext.DevelopmentMode)
{
// If parent doesn't belong to current module, try find first module category
DataSet ds = SettingsCategoryInfoProvider.GetSettingsCategories("CategoryResourceID = " + ModuleID, "CategoryLevel, CategoryOrder", 1);
if (!DataHelper.DataSourceIsEmpty(ds))
{
category = new SettingsCategoryInfo(ds.Tables[0].Rows[0]);
}
}
SelectPath = category.CategoryIDPath;
SelectedItem = category.CategoryName;
string scriptAction = String.Empty;
switch (actionName.ToLowerCSafe())
{
case "delete":
ExpandPath = category.CategoryIDPath + "/";
// Update menu actions parameters
Value = category.CategoryID + "|" + category.CategoryParentID;
break;
case "moveup":
scriptAction = "window.tabIndex = " + tabIndex + ";";
break;
case "movedown":
scriptAction = "window.tabIndex = " + tabIndex + ";";
break;
}
RegisterSelectNodeScript(category);
scriptAction += "var postParentId = " + category.CategoryParentID + ";";
ScriptHelper.RegisterStartupScript(this, typeof(string), "afterActionScript", ScriptHelper.GetScript(scriptAction));
// Load data
ReloadData();
}
/// <summary>
/// Handles OnClick event of btnOk.
/// </summary>
/// <param name="sender">Asp Button instance</param>
/// <param name="e">EventArgs instance</param>
protected void btnOk_Click(object sender, EventArgs e)
{
if (IsValid())
{
// Get category by name
SettingsCategoryInfo categoryObj = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName(txtCategoryName.Text.Trim());
// If name is unique OR ids are same
if ((categoryObj == null) || (categoryObj.CategoryID == mSettingsCategoryId))
{
SettingsCategoryInfo sci = SettingsCategoryObj;
if (sci == null)
{
sci = new SettingsCategoryInfo();
sci.CategoryOrder = mCategoryOrder;
}
if (sci.CategoryParentID != drpCategory.SelectedCategory)
{
// When parent has been changed set the order for the category as the last possible order
sci.CategoryOrder = SettingsCategoryInfoProvider.GetLastSettingsCategoryOrder(drpCategory.SelectedCategory) + 1;
}
sci.CategoryName = txtCategoryName.Text.Trim();
sci.CategoryDisplayName = txtCategoryDisplayName.Text.Trim();
sci.CategoryIconPath = txtIconPath.Text.Trim();
sci.CategoryParentID = drpCategory.SelectedCategory;
sci.CategoryIsGroup = mIsGroupEdit;
sci.CategoryIsCustom = mIsCustom || chkIsCustom.Checked;
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(sci);
SettingsCategoryObj = sci;
RaiseOnSaved();
// Set the info message
if (ContentRefreshUrl == null)
{
lblInfo.Text = GetString("general.changessaved");
}
// Reload header and content after save
int categoryIdToShow = sci.CategoryIsGroup ? sci.CategoryParentID : sci.CategoryID;
StringBuilder sb = new StringBuilder();
sb.Append("if (window.parent != null) {");
if (HeaderRefreshUrl != null)
{
sb.Append("if (window.parent.parent.frames['customsettingscategorytabs'] != null) {");
sb.Append("window.parent.parent.frames['customsettingscategorytabs'].location = '" + ResolveUrl(HeaderRefreshUrl) + "categoryid=" + categoryIdToShow + "';");
sb.Append("}");
sb.Append("if (window.parent.frames['customsettingscategorytabs'] != null) {");
sb.Append("window.parent.frames['customsettingscategorytabs'].location = '" + ResolveUrl(HeaderRefreshUrl) + "categoryid=" + categoryIdToShow + "';");
sb.Append("}");
}
if (TreeRefreshUrl != null)
{
sb.Append("if (window.parent.parent.frames['customsettingstree'] != null) {");
sb.Append("window.parent.parent.frames['customsettingstree'].location = '" + ResolveUrl(TreeRefreshUrl) + "categoryid=" + categoryIdToShow + "';");
sb.Append("}");
sb.Append("if (window.parent.frames['customsettingstree'] != null) {");
sb.Append("window.parent.frames['customsettingstree'].location = '" + ResolveUrl(TreeRefreshUrl) + "categoryid=" + categoryIdToShow + "';");
sb.Append("}");
}
if (ContentRefreshUrl != null)
{
sb.Append("window.location = '" + ResolveUrl(ContentRefreshUrl) + "categoryid=" + sci.CategoryID + "';");
}
sb.Append("}");
ltlScript.Text = ScriptHelper.GetScript(sb.ToString());
}
else
{
lblError.Text = GetString("general.codenameexists");
}
}
}
/// <summary>
/// Gets <c>CategoryPanel</c> instance for the input settings group.
/// </summary>
/// <param name="group"><c>SettingsCategoryInfo</c> instance representing settings group</param>
/// <param name="groupNo">Number representing index of the proccesing settings group</param>
/// <returns><c>CategoryPanel</c> object.</returns>
private CategoryPanel GetCategoryPanel(SettingsCategoryInfo group, int groupNo)
{
CategoryPanel p = new CategoryPanel();
p.ID = string.Format(@"CategoryPanel{0}", groupNo);
p.DisplayActions = false;
p.AllowCollapsing = false;
if ((!string.IsNullOrEmpty(mSearchText)) && (mSearchText.Length >= mSearchLimit))
{
p.Text = HTMLHelper.HTMLEncode(ResHelper.LocalizeString(GetCategoryNames(group.CategoryIDPath)));
}
else
{
p.Text = HTMLHelper.HTMLEncode(ResHelper.LocalizeString(group.CategoryDisplayName));
}
return p;
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
int categoryId = QueryHelper.GetInteger("categoryid", -1);
// Find category
if (categoryId >= 0)
{
mCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(categoryId);
}
// Use root category for Settings if category not found or specified
if ((categoryId == -1) || (mCategory == null))
{
mCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName("CMS.Settings");
}
// Set edited object
EditedObject = mCategory;
if (mCategory.CategoryParentID != 0)
{
grpEdit.CategoryName = mCategory.CategoryName;
grpEdit.ModuleID = moduleId;
grpEdit.ActionPerformed += grpEdit_ActionPerformed;
grpEdit.OnNewKey += grpEdit_OnNewKey;
grpEdit.OnKeyAction += grpEdit_OnKeyAction;
// Read data
grpEdit.ReloadData();
}
if (!Resource.ResourceIsInDevelopment && !SystemContext.DevelopmentMode)
{
// Show information about installed module
ShowInformation(GetString("settingcategory.installedmodule"));
}
else if ((mCategory.CategoryID == categoryId) && (mCategory.CategoryParentID == 0))
{
// Show information about creating module categories and groups
ShowInformation(GetString("settingcategory.createmodulecategory"));
}
}
private IEnumerable<SettingsCategoryInfo> GetGroups(SettingsCategoryInfo category, bool isSearch)
{
if (isSearch)
{
var groups = SettingsCategoryInfoProvider.GetSettingsCategories("CategoryIsGroup = 1", "CategoryName");
return groups;
}
else
{
var groups = SettingsCategoryInfoProvider.GetChildSettingsCategories(category.CategoryID);
return groups.Cast<SettingsCategoryInfo>().Where(c => c.CategoryIsGroup).OrderBy(c => c.CategoryOrder);
}
}
/// <summary>
/// Gets all groups for the current SettingsCategoryInfo.
/// </summary>
/// <returns><c>IEnumerable</c> of <c>SettingsCategoryInfo</c>.</returns>
private IEnumerable<SettingsCategoryInfo> GetGroups()
{
if (SettingsCategoryInfo != null)
{
DataSet groupsSet = null;
if ((!string.IsNullOrEmpty(mSearchText)) && (mSearchText.Length >= mSearchLimit))
{
groupsSet = SettingsCategoryInfoProvider.GetSettingsCategories("CategoryIsGroup = 1", "CategoryName");
}
else
{
groupsSet = SettingsCategoryInfoProvider.GetChildSettingsCategories(SettingsCategoryInfo.CategoryName, Where);
}
if (!DataHelper.DataSourceIsEmpty(groupsSet))
{
DataTable groupTable = groupsSet.Tables[0];
foreach (DataRow groupRow in groupTable.Rows)
{
SettingsCategoryInfo sci = new SettingsCategoryInfo(groupRow);
if (sci.CategoryIsGroup)
{
yield return sci;
}
}
}
}
}
/// <summary>
/// Get path to the given settings category.
/// </summary>
/// <param name="settingsKeyCategoryInfo">The key that path is generated for</param>
/// <returns>Path to the given settings category</returns>
private IEnumerable<SettingsCategoryInfo> GetCategoryPath(SettingsCategoryInfo settingsKeyCategoryInfo)
{
var sci = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(settingsKeyCategoryInfo.CategoryParentID);
while (sci != null)
{
yield return sci;
sci = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(sci.CategoryParentID);
}
}
/// <summary>
/// Creates settings category. Called when the "Create category" button is pressed.
/// </summary>
private bool CreateSettingsCategory()
{
// Get parent category ID
SettingsCategoryInfo parentCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName("CMS.Settings");
if (parentCategory != null)
{
// Create new settings category object
SettingsCategoryInfo newCategory = new SettingsCategoryInfo();
// Set the properties
newCategory.CategoryDisplayName = "My New Settings Category";
newCategory.CategoryName = "MyNewSettingsCategory";
newCategory.CategoryOrder = 0;
newCategory.CategoryParentID = parentCategory.CategoryID;
newCategory.CategoryIsGroup = false;
newCategory.CategoryIsCustom = true;
// Create settings category
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(newCategory);
return true;
}
return false;
}
/// <summary>
/// Gets path containing display names of all predecessors of given category and name of category itself.
/// </summary>
/// <param name="child">Category to get path from</param>
/// <returns>String containing path to given Category</returns>
private string GetCategoryPathNames(SettingsCategoryInfo child)
{
// Convert IDPath to be suitable for IN-clause of SQL query
string inClause = child.CategoryIDPath.Remove(0, 1).Replace('/', ',');
StringBuilder sb = new StringBuilder("");
if (!string.IsNullOrEmpty(inClause))
{
// Get display names of all categories from path, order by nesting level
DataSet ds = SettingsCategoryInfoProvider.GetSettingsCategories(string.Format("CategoryID IN ({0}) AND CategoryLevel > 0", inClause), "CategoryLevel", -1, "CategoryDisplayName");
if (!DataHelper.DataSourceIsEmpty(ds))
{
foreach (DataRow row in ds.Tables[0].Rows)
{
// No slash before first name
if (sb.Length > 0)
{
sb.Append(" / ");
}
sb.Append(SqlHelperClass.GetString(row["CategoryDisplayName"], ""));
}
}
}
return sb.ToString();
}
/// <summary>
/// Handles OnClick event of btnOk.
/// </summary>
/// <param name="sender">Asp Button instance</param>
/// <param name="e">EventArgs instance</param>
protected void btnOk_Click(object sender, EventArgs e)
{
if (IsValid())
{
// Get category by name
SettingsCategoryInfo categoryObj = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName(txtCategoryName.Text.Trim());
// If name is unique OR ids are same
if ((categoryObj == null) || (categoryObj.CategoryID == SettingsCategoryID))
{
SettingsCategoryInfo sci = SettingsCategoryObj;
if (sci == null)
{
sci = new SettingsCategoryInfo();
sci.CategoryOrder = CategoryOrder;
}
if (sci.CategoryParentID != drpCategory.SelectedCategory)
{
// When parent has been changed set the order for the category as the last possible order
sci.CategoryOrder = SettingsCategoryInfoProvider.GetLastSettingsCategoryOrder(drpCategory.SelectedCategory) + 1;
}
sci.CategoryName = txtCategoryName.Text.Trim();
sci.CategoryDisplayName = txtCategoryDisplayName.Text.Trim();
sci.CategoryIconPath = txtIconPath.Text.Trim();
sci.CategoryParentID = SelectedParentCategory;
sci.CategoryIsGroup = IsGroupEdit;
sci.CategoryResourceID = ValidationHelper.GetInteger(ucSelectModule.Value, ModuleID);
SettingsCategoryInfoProvider.SetSettingsCategoryInfo(sci);
SettingsCategoryObj = sci;
RaiseOnSaved();
// Set the info message
if (ContentRefreshUrl == null)
{
ShowChangesSaved();
}
// Reload header and content after save
int categoryIdToShow = sci.CategoryIsGroup ? sci.CategoryParentID : sci.CategoryID;
StringBuilder sb = new StringBuilder();
sb.Append("if (window.parent != null) {");
if (!String.IsNullOrEmpty(TreeRefreshUrl))
{
sb.AppendFormat(@"if (window.parent.parent.frames['settingstree'] != null) {{
window.parent.parent.frames['settingstree'].location = '{0}&categoryid={1}';
}}
if (window.parent.frames['settingstree'] != null) {{
window.parent.frames['settingstree'].location = '{0}&categoryid={1}';
}}", ResolveUrl(TreeRefreshUrl), categoryIdToShow);
}
if (!String.IsNullOrEmpty(ContentRefreshUrl))
{
sb.AppendFormat("window.location = '{0}&categoryid={1}';", ResolveUrl(ContentRefreshUrl), sci.CategoryID);
}
sb.Append("}");
ltlScript.Text = ScriptHelper.GetScript(sb.ToString());
}
else
{
ShowError(GetString("general.codenameexists"));
}
}
}
protected TreeNode Tree_OnNodeCreated(DataRow itemData, TreeNode defaultNode)
{
if (itemData != null)
{
if (MembershipContext.AuthenticatedUser != null)
{
SettingsCategoryInfo category = new SettingsCategoryInfo(itemData);
string currentIdPath = category.CategoryIDPath;
defaultNode.Expanded = category.CategoryParentID == 0 ? true : defaultNode.Expanded;
if (!String.IsNullOrEmpty(mExpandedPaths) || (ModuleID > 0))
{
bool selected = false;
foreach (string idPath in mExpandedPaths.Split(';'))
{
if (idPath == currentIdPath)
{
// End node
defaultNode.Expanded = true;
defaultNode.Text = defaultNode.Text.Replace("##NAMECSSCLASS##", "highlighted ");
selected = true;
break;
}
if (currentIdPath.StartsWith(idPath) && (ModuleID == category.CategoryResourceID))
{
// Child node
defaultNode.Expanded = true;
defaultNode.Text = defaultNode.Text.Replace("##NAMECSSCLASS##", "");
selected = true;
break;
}
if (idPath.StartsWith(currentIdPath))
{
// Parent node
defaultNode.Expanded = true;
defaultNode.Text = defaultNode.Text.Replace("##NAMECSSCLASS##", "highlighted" + (SystemContext.DevelopmentMode ? "" : " disabled"));
selected = true;
break;
}
}
if (!defaultNode.Expanded.Value || String.IsNullOrEmpty(mExpandedPaths) || !selected)
{
// Nodes which doesn't belong to selected module have no current module's group
defaultNode.Text = defaultNode.Text.Replace("##NAMECSSCLASS##", SystemContext.DevelopmentMode ? "" : "disabled");
}
}
else
{
// Keep everything same as before and remove css class macro
defaultNode.Text = defaultNode.Text.Replace("##NAMECSSCLASS##", "");
if (RootCategory.CategoryIDPath == currentIdPath)
{
// Expand root node
defaultNode.Expanded = true;
}
}
defaultNode.Text = defaultNode.Text.Replace("##NODECUSTOMNAME##", HTMLHelper.HTMLEncode(ResHelper.LocalizeString(category.CategoryDisplayName)));
defaultNode.Text = defaultNode.Text.Replace("##NODECODENAME##", HTMLHelper.HTMLEncode(category.CategoryName));
defaultNode.Text = defaultNode.Text.Replace("##SITEID##", SiteID.ToString());
defaultNode.Text = defaultNode.Text.Replace("##PARENTID##", category.CategoryParentID.ToString());
defaultNode.Text = defaultNode.Text.Replace("##RESOURCEID##", category.CategoryResourceID.ToString());
if (OnNodeCreated != null)
{
return OnNodeCreated(category, defaultNode);
}
return defaultNode;
}
}
return null;
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
int categoryId = QueryHelper.GetInteger("categoryid", -1);
// Get root of tree
mTreeRoot = QueryHelper.GetString("treeroot", "customsettings");
// Get site id
mSiteId = QueryHelper.GetInteger("siteid", 0);
// Find category
if (categoryId >= 0)
{
mCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfo(categoryId);
}
// Use root category for CustomSettings or Settings if category not found or specified
if((categoryId == -1) || (mCategory == null))
{
switch (mTreeRoot)
{
case ("customsettings"):
grpEdit.CategoryName = "CMS.CustomSettings";
break;
case ("settings"):
default:
grpEdit.CategoryName = "CMS.Settings";
break;
}
mCategory = SettingsCategoryInfoProvider.GetSettingsCategoryInfoByName(grpEdit.CategoryName);
}
grpEdit.CategoryName = mCategory.CategoryName;
grpEdit.SiteID = mSiteId;
grpEdit.ActionPerformed += new CommandEventHandler(grpEdit_ActionPerformed);
grpEdit.OnNewKey += new CommandEventHandler(grpEdit_OnNewKey);
grpEdit.OnKeyAction += new OnActionEventHandler(grpEdit_OnKeyAction);
// Read data
grpEdit.ReloadData();
}
/// <summary>
/// Gets <c>CategoryPanel</c> instance for the input settings group.
/// </summary>
/// <param name="group"><c>SettingsCategoryInfo</c> instance representing settings group</param>
/// <param name="groupNo">Number representing index of the processing settings group</param>
private CategoryPanel GetCategoryPanel(SettingsCategoryInfo group, int groupNo)
{
string title;
if (IsSearchTextValid)
{
var categories = SettingsCategoryInfoProvider.GetCategoriesOnPath(group.CategoryIDPath);
var categoryNames = categories.Cast<SettingsCategoryInfo>().Select(c =>
{
var displayName = HTMLHelper.HTMLEncode(ResHelper.LocalizeString(c.CategoryDisplayName));
if (c.CategoryIsGroup)
{
return displayName;
}
var url = string.Format("~/CMSModules/Settings/Pages/Categories.aspx?selectedCategoryId={0}&selectedSiteId={1}", c.CategoryID, SiteID);
url = ResolveUrl(url);
var name = string.Format("<a href=\"\" onclick=\"selectCategory('{0}');\">{1}</a>", url, displayName);
return name;
});
title = categoryNames.Join(" > ");
}
else
{
title = HTMLHelper.HTMLEncode(ResHelper.LocalizeString(group.CategoryDisplayName));
}
var panel = new CategoryPanel
{
ID = string.Format(@"CategoryPanel{0}", groupNo),
DisplayRightPanel = false,
AllowCollapsing = false,
Text = title,
RenderAs = HtmlTextWriterTag.Div
};
return panel;
}
/// <summary>
/// Reloads data.
/// </summary>
public void ReloadData()
{
CMSUserControl catPanel;
// Get data
DataSet ds = SettingsCategoryInfoProvider.GetChildSettingsCategories(mCategoryName, "CategoryIsGroup = 1");
Controls.Clear();
if (!DataHelper.DataSourceIsEmpty(ds))
{
DataRowCollection rows = ds.Tables[0].Rows;
foreach (DataRow row in rows)
{
// Create new panel with info about subcategory
SettingsCategoryInfo sci = new SettingsCategoryInfo(row);
catPanel = CreatePanelForCategory(sci);
catPanel.ID = "CategoryPanel_" + sci.CategoryName.Replace(".", "_");
Controls.Add(catPanel);
}
}
}
/// <summary>
/// Creates SettingsGroup panel for a specified category.
/// </summary>
/// <param name="category">Non-group category</param>
protected CMSUserControl CreatePanelForCategory(SettingsCategoryInfo category)
{
if (category == null)
{
return null;
}
// Create new Category bar and initialize it
SettingsGroup group = Page.LoadUserControl("~/CMSModules/Settings/Controls/SettingsGroup.ascx") as SettingsGroup;
group.Category = category;
group.SiteID = mSiteId;
group.ActionPerformed += new CommandEventHandler(group_ActionPerformed);
group.OnNewKey += new CommandEventHandler(group_OnNewKey);
group.OnKeyAction += new OnActionEventHandler(group_OnKeyAction);
return group;
}
/// <summary>
/// Builds the export file and writes it to the response.
/// </summary>
/// <param name="category">Settings category</param>
/// <param name="searchText">Text to search for</param>
/// <param name="searchInDescription">True, if key description should be included in the search</param>
/// <param name="site">Site</param>
private void Export(SettingsCategoryInfo category, string searchText, bool searchInDescription, SiteInfo site = null)
{
var isSearch = !string.IsNullOrEmpty(searchText);
var isSite = site != null;
var siteName = isSite ? TranslationHelper.GetCodeNameFromDB(SiteInfo.OBJECT_TYPE, site.SiteID, "SiteName") : null;
var sb = new StringBuilder();
// Append file title
if (isSite)
{
sb.Append("Settings for site \"", site.DisplayName, "\"");
}
else
{
sb.Append("Global settings");
}
sb.Append(", ");
if (isSearch)
{
sb.Append("search text \"", searchText, "\"");
}
else
{
string categoryNames = ResHelper.LocalizeString(FormatCategoryPathNames(category.CategoryIDPath));
sb.Append("category \"", categoryNames, "\"");
}
sb.AppendLine();
sb.AppendLine();
// Get groups
var groups = GetGroups(category, isSearch);
// Append groups and keys
foreach (var group in groups)
{
// Get keys
var keys = GetKeys(group, isSite, searchText, searchInDescription).ToArray();
if (!keys.Any())
{
// Skip empty groups
continue;
}
// Get formatted keys
string keysFormatted = FormatKeys(keys, siteName);
if (string.IsNullOrEmpty(keysFormatted))
{
// Skip empty groups
continue;
}
// Append group title
sb.AppendLine();
if (isSearch)
{
string categoryNames = ResHelper.LocalizeString(FormatCategoryPathNames(group.CategoryIDPath));
sb.Append(categoryNames);
}
else
{
string groupDisplayNameLocalized = ResHelper.LocalizeString(group.CategoryDisplayName);
sb.Append(groupDisplayNameLocalized);
}
sb.AppendLine();
sb.Append("--------------------------------------------------");
sb.AppendLine();
sb.AppendLine();
// Append group keys
sb.Append(keysFormatted);
}
// Write to response
var fileName = string.Format("{0}_{1}.txt", (site == null ? "Global" : site.DisplayName), ValidationHelper.GetIdentifier(category.CategoryName, "_"));
Response.AddHeader("Content-disposition", string.Format("attachment; filename=\"{0}\"", HTTPHelper.GetDispositionFilename(fileName)));
Response.ContentType = "text/plain";
Response.Write(sb.ToString());
RequestHelper.EndResponse();
}
