public Feature GetFeature(FeatureEnum featureEnum, FeatureEnum parentFeatureEnum = FeatureEnum.none)
{
var featureRequired = _featuresInUse[(int)featureEnum];
if (featureRequired == null)
{
featureRequired = new Feature()
{
Name = featureEnum.ToString(), ID = (short)featureEnum, CreationTime = DateTime.Now, LastUsageTime = DateTime.Now
};
_featuresInUse[(int)featureEnum] = featureRequired;
}
if (parentFeatureEnum != FeatureEnum.none)
{
Feature parent = _featuresInUse[(int)parentFeatureEnum];
if (parent == null)
{
parent = new Feature()
{
Name = parentFeatureEnum.ToString(), ID = (short)parentFeatureEnum, CreationTime = DateTime.Now, LastUsageTime = DateTime.Now
};
_featuresInUse[(int)parentFeatureEnum] = parent;
}
featureRequired.ParentFeature = parent;
}
return(featureRequired);
}
protected void Page_Load(object sender, EventArgs e)
{
this.CurrentMaster.Title.TitleText = GetString("Header.Development");
this.CurrentMaster.Title.TitleImage = GetImageUrl("CMSModules/CMS_Development/module.png");
ArrayList parametersRow = new ArrayList();
ArrayList al = FillCollectionWithModules(DevelopmentItems, "ShowInDevelopment = 1", true, true);
// Display description overview for default development items
foreach (object[] itemProperties in al)
{
FeatureEnum feature = (FeatureEnum)itemProperties[5];
bool showItem = (feature == FeatureEnum.Unknown) ? true : LicenseHelper.IsFeatureAvailableInUI(feature);
if (showItem)
{
object[] row = new object[5];
// Start filling arraylist
row[0] = itemProperties[4].ToString(); // Image
row[1] = GetString(itemProperties[1].ToString()); // Name
row[2] = itemProperties[0].ToString(); // Link
row[3] = GetString(itemProperties[2].ToString()); // Description
row[4] = ValidationHelper.GetCodeName(row[1]);
parametersRow.Add(row);
}
}
// Initialize guide
Guide.Columns = 3;
Guide.Parameters = parametersRow;
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
FeatureEnum feature = (FeatureEnum)value;
string path = "";
switch (feature)
{
case FeatureEnum.BatteryEndurance:
path = App.Current.Resources.GetValue <string>("BatteryPath");
break;
case FeatureEnum.Bluetooth:
path = App.Current.Resources.GetValue <string>("BluetoothPath");
break;
case FeatureEnum.RandomSpec:
path = App.Current.Resources.GetValue <string>("SpeakerPath");
break;
case FeatureEnum.UnderwaterEndurance:
path = App.Current.Resources.GetValue <string>("WaterDropPath");
break;
}
return(path);
}
/// <summary>
/// GetFeatureSettings
/// </summary>
/// <param name="feature"></param>
/// <returns></returns>
public List <FeatureSettingModel> GetFeatureSettings(FeatureEnum feature)
{
List <FeatureSettingModel> featureSettings = new List <FeatureSettingModel>();
ServiceResponse <List <FeatureSettingDC> > featureSettingsResponse = _securityProxy.Execute(opt => opt.GetFeatureSettings((int)feature));
if (featureSettingsResponse.Status == ResponseStatus.Success)
{
foreach (FeatureSettingDC featureSetting in featureSettingsResponse.Result)
{
featureSettings.Add(Mapper.Map <FeatureSettingDC, FeatureSettingModel>(featureSetting));
}
}
else
{
HandleError(featureSettingsResponse.Status, featureSettingsResponse.ResponseMessage);
}
return(featureSettings);
}
/// <summary>
/// GetContextForFeature
/// </summary>
/// <param name="feature"></param>
/// <returns></returns>
private ContextEnum GetContextForFeature(FeatureEnum feature)
{
if (feature == FeatureEnum.Blog)
{
return(ContextEnum.Blog);
}
else if (feature == FeatureEnum.ContentPage)
{
return(ContextEnum.ContentPage);
}
else if (feature == FeatureEnum.DocumentLibrary)
{
return(ContextEnum.Document);
}
else
{
return(ContextEnum.None);
}
}
public Feature GetClientFeature(string applicationName)
{
string feature = String.Empty;
if (applicationName.Contains(FeatureUsageCollector.FeatureTag))
{
feature = applicationName.Split('#')[1];
}
FeatureEnum featureEnum = FeatureEnum.none;
if (feature.Equals(FeatureEnum.aspnet_session.ToString()))
{
featureEnum = FeatureEnum.aspnet_session;
}
else if (feature.Equals(FeatureEnum.aspnetcore_session.ToString()))
{
featureEnum = FeatureEnum.aspnetcore_session;
}
else if (feature.Equals(FeatureEnum.efcore.ToString()))
{
featureEnum = FeatureEnum.efcore;
}
else if (feature.Equals(FeatureEnum.efcore61.ToString()))
{
featureEnum = FeatureEnum.efcore61;
}
else if (feature.Equals(FeatureEnum.hibernate.ToString()))
{
featureEnum = FeatureEnum.hibernate;
}
else if (feature.Equals(FeatureEnum.outputcache_provider.ToString()))
{
featureEnum = FeatureEnum.outputcache_provider;
}
else if (feature.Equals(FeatureEnum.view_state.ToString()))
{
featureEnum = FeatureEnum.view_state;
}
return(GetFeature(featureEnum));
}
/// <summary>
/// Gets the limit of objects for given license and feature.
/// </summary>
/// <param name="license">License</param>
/// <param name="feature">Feature</param>
public static int GetLimit(LicenseKeyInfo license, FeatureEnum feature)
{
if (license == null)
{
return(0);
}
// If feature not available, no objects allowed
if (!LicenseKeyInfoProvider.IsFeatureAvailable(license, feature))
{
return(0);
}
// Get version limit
int limit = LicenseKeyInfoProvider.VersionLimitations(license, feature);
if (limit == 0)
{
return(int.MaxValue);
}
return(limit);
}
/// <summary>
/// SavePermissionsToViewBag
/// </summary>
/// <param name="userPermissions"></param>
private bool SavePermissionsToViewBag(FeatureEnum feature)
{
try
{
List <UserFeaturePermissionModel> userPermissions = SecurityClientProcessor.GetUserFeaturePermissions(Convert.ToInt32(feature));
List <PermissionEnum> permissions = new List <PermissionEnum>();
foreach (UserFeaturePermissionModel userFeaturePermission in userPermissions)
{
permissions.Add((PermissionEnum)userFeaturePermission.PermissionId);
}
ViewBag.UserPermissions = permissions;
if (!(permissions.Contains(PermissionEnum.ViewContent) || permissions.Contains(PermissionEnum.ViewAnomynousContent)))
{
return(false);
}
}
catch (Exception ex)
{
HandleError(ex);
}
return(true);
}
/// <summary>
/// Checks the license for selected objects.
/// </summary>
public static string CheckLicenses(SiteImportSettings settings)
{
string result = null;
object[,] checkFeatures = new object[, ] {
{ FeatureEnum.Unknown, "", false },
{ FeatureEnum.BizForms, FormObjectType.BIZFORM, true },
{ FeatureEnum.Forums, PredefinedObjectType.FORUM, true },
{ FeatureEnum.Newsletters, PredefinedObjectType.NEWSLETTER, true },
{ FeatureEnum.Subscribers, PredefinedObjectType.NEWSLETTERUSERSUBSCRIBER + ";" + PredefinedObjectType.NEWSLETTERROLESUBSCRIBER + ";" + PredefinedObjectType.NEWSLETTERSUBSCRIBER, true },
{ FeatureEnum.Staging, SynchronizationObjectType.STAGINGSERVER, true },
{ FeatureEnum.Ecommerce, PredefinedObjectType.SKU, false },
{ FeatureEnum.Polls, PredefinedObjectType.POLL, false },
{ FeatureEnum.Webfarm, WebFarmObjectType.WEBFARMSERVER, false },
{ FeatureEnum.SiteMembers, SiteObjectType.USER, false },
{ FeatureEnum.WorkflowVersioning, PredefinedObjectType.WORKFLOW, false }
};
// Get imported licenses
DataSet ds = ImportProvider.LoadObjects(settings, LicenseObjectType.LICENSEKEY, false);
string domain = string.IsNullOrEmpty(settings.SiteDomain) ? URLHelper.GetCurrentDomain().ToLower() : URLHelper.RemovePort(settings.SiteDomain).ToLower();
// Remove application path
int slashIndex = domain.IndexOf("/");
if (slashIndex > -1)
{
domain = domain.Substring(0, slashIndex);
}
bool anyDomain = ((domain == "localhost") || (domain == "127.0.0.1"));
// Check all features
for (int i = 0; i <= checkFeatures.GetUpperBound(0); i++)
{
string[] objectTypes = ((string)checkFeatures[i, 1]).Split(';');
bool siteObject = (bool)checkFeatures[i, 2];
string objectType = objectTypes[0];
// Check objects
int count = (objectType != "") ? 0 : 1;
for (int j = 0; j < objectTypes.Length; ++j)
{
objectType = objectTypes[j];
if (objectType != "")
{
ArrayList codenames = settings.GetSelectedObjects(objectType, siteObject);
count += (codenames == null) ? 0 : codenames.Count;
}
}
// Check a special case for Workflows
if (objectType.Equals(PredefinedObjectType.WORKFLOW))
{
// Check workflows
bool includeWorkflowScopes = ValidationHelper.GetBoolean(settings.GetSettings(ImportExportHelper.SETTINGS_WORKFLOW_SCOPES), false);
if (includeWorkflowScopes)
{
// Check if there are any workflow scopes in the imported package and if there are, increase the count.
DataSet dsScopes = ImportProvider.LoadObjects(settings, PredefinedObjectType.WORKFLOWSCOPE, true);
if (!DataHelper.DataSourceIsEmpty(dsScopes))
{
count++;
}
}
}
if (count > 0)
{
FeatureEnum feature = (FeatureEnum)checkFeatures[i, 0];
// Get best available license from DB
LicenseKeyInfo bestLicense = LicenseKeyInfoProvider.GetLicenseKeyInfo(domain, feature);
if ((bestLicense != null) && (bestLicense.ValidationResult != LicenseValidationEnum.Valid))
{
bestLicense = null;
}
// Check new licenses
LicenseKeyInfo bestSelected = null;
if (!DataHelper.DataSourceIsEmpty(ds))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
LicenseKeyInfo lki = new LicenseKeyInfo(dr);
// Use license only if selected
if ((settings.IsSelected(LicenseObjectType.LICENSEKEY, lki.Domain, false)) && (anyDomain || (lki.Domain.ToLower() == domain)) && LicenseKeyInfoProvider.IsBetterLicense(lki, bestSelected, feature))
{
bestSelected = lki;
if (bestSelected.Domain.ToLower() == domain)
{
break;
}
}
}
}
// Check the license
if (feature == FeatureEnum.Unknown)
{
if ((bestLicense == null) && (bestSelected == null))
{
return(ResHelper.GetString("Import.NoLicense"));
}
}
else
{
// Check the limit
int limit = GetLimit(bestLicense, feature);
// Use a database license if it is better than the one which is being imported
if (LicenseKeyInfoProvider.IsBetterLicense(bestLicense, bestSelected, feature))
{
bestSelected = bestLicense;
}
int selectedLimit = GetLimit(bestSelected, feature);
if (bestSelected != null)
{
if (bestSelected.ValidationResult == LicenseValidationEnum.Valid)
{
if (!anyDomain || (bestSelected.Domain.ToLower() == domain))
{
limit = selectedLimit;
}
else
{
// If selected better, take the selected
if (selectedLimit > limit)
{
limit = selectedLimit;
}
}
}
else
{
if (!anyDomain || (bestSelected.Domain.ToLower() == domain))
{
limit = 0;
}
}
}
if (limit < count)
{
if (limit <= 0)
{
result += String.Format(ResHelper.GetString("Import.LimitZero"), ResHelper.GetString("ObjectTasks." + objectType.Replace(".", "_")));
}
else
{
result += String.Format(ResHelper.GetString("Import.LimitExceeded"), ResHelper.GetString("ObjectTasks." + objectType.Replace(".", "_")), limit);
}
// If better license
if ((bestLicense != null) && (bestSelected != null) && LicenseKeyInfoProvider.IsBetterLicense(bestLicense, bestSelected, feature))
{
result += " " + ResHelper.GetString("Import.BetterLicenseExists");
}
result += "<br />";
}
}
}
}
return(result);
}
/// <summary>
/// GetFeatureSettings
/// </summary>
/// <param name="feature"></param>
/// <returns></returns>
public List<FeatureSettingModel> GetFeatureSettings(FeatureEnum feature)
{
List<FeatureSettingModel> featureSettings = new List<FeatureSettingModel>();
ServiceResponse<List<FeatureSettingDC>> featureSettingsResponse = _securityProxy.Execute(opt => opt.GetFeatureSettings((int)feature));
if (featureSettingsResponse.Status == ResponseStatus.Success)
{
foreach (FeatureSettingDC featureSetting in featureSettingsResponse.Result)
{
featureSettings.Add(Mapper.Map<FeatureSettingDC, FeatureSettingModel>(featureSetting));
}
}
else
{
HandleError(featureSettingsResponse.Status, featureSettingsResponse.ResponseMessage);
}
return featureSettings;
}
/// <summary>
/// Checks the license based on feature and perform action based on given arguments.
/// </summary>
/// <param name="feature">Feature to check</param>
/// <param name="domain">Domain to check. If null, function tries to get domain from HttpContext</param>
/// <param name="throwError">Indicates whether throw error after false check</param>
/// <returns>
/// True if not changed through <see cref="LicenseServiceFake.HasLicence"/> property.
/// </returns>
public bool CheckLicense(FeatureEnum feature, string domain = null, bool throwError = true)
{
return(HasLicence);
}
/// <summary>
/// GetUserFeaturePermission
/// </summary>
/// <returns></returns>
public List<PermissionEnum> GetUserFeaturePermissions(int userId, FeatureEnum featureId)
{
List<PermissionEnum> userPermissions = new List<PermissionEnum>();
SiteFeature feature = eCollabroDbContext.Repository<SiteFeature>().Query().Filter(qry => qry.SiteId.Equals(UserContextDetails.SiteId) && qry.FeatureId.Equals((int)featureId)).Get().FirstOrDefault();
if (feature != null) // else feature not assigned to Site
{
#region Feature Assigned to Site
// Anomynous Content Access
userPermissions.Add(PermissionEnum.ViewAnomynousContent);
if (UserContextDetails.ImpersonateViewRights)
{
userPermissions.Add(PermissionEnum.ViewContent);
}
if (UserContextDetails.UserId == 0)
return userPermissions;
// check Site Collection Admin Or Site Admin
if (CheckSiteCollectionAdmin(UserContextDetails.UserId) || CheckSiteAdmin(UserContextDetails.UserId, UserContextDetails.SiteId))
{
foreach (PermissionEnum val in Enum.GetValues(typeof(PermissionEnum)))
{
if (!userPermissions.Contains(val))
{
userPermissions.Add(val);
}
}// Add All // no need to check further permission
}
else
{
List<UserRole> roles = eCollabroDbContext.Repository<UserRole>().Query().Filter(qry => qry.SiteId.Equals(UserContextDetails.SiteId) && qry.UserId.Equals(userId)).Get().ToList();
// get all role features for user roles on site
List<int> userRoleIds = roles.Select(slc => slc.RoleId).ToList();
List<RoleFeature> roleFeatures = eCollabroDbContext.Repository<RoleFeature>().Query().Include(inc => inc.RoleFeaturePermissions).Filter(qry => qry.FeatureId.Equals((int)featureId) && userRoleIds.Contains(qry.RoleId)).Get().ToList();
foreach (RoleFeature roleFeature in roleFeatures)
{
foreach (RoleFeaturePermission roleFeaturePermission in roleFeature.RoleFeaturePermissions)
{
if (!userPermissions.Contains((PermissionEnum)roleFeaturePermission.PermissionId))
{
userPermissions.Add((PermissionEnum)roleFeaturePermission.PermissionId);
}
}
}
}
#endregion
}
else
{
throw new BusinessException(_coreValidationResourceManager.GetString(CoreValidationMessagesConstants.FeatureNotAssignedToSite), CoreValidationMessagesConstants.FeatureNotAssignedToSite);
}
return userPermissions;
}
/// <summary>
/// GetSiteFeatureSettings
/// </summary>
/// <param name="siteId"></param>
/// <returns></returns>
public List<SiteContentSettingResult> GetSiteFeatureSettings(FeatureEnum feature)
{
int featureId = Convert.ToInt32(feature);
List<SiteContentSettingResult> featuresContentSettings = eCollabroDbContext.ExtendedRepository().SecurityRepository.GetFeaturesContentSettings(UserContextDetails.SiteId).Where(qry => qry.FeatureId.Equals(featureId)).ToList();
return featuresContentSettings;
}
/// <summary>
/// SavePermissionsToViewBag
/// </summary>
/// <param name="userPermissions"></param>
private bool SavePermissionsToViewBag(FeatureEnum feature)
{
try
{
List<UserFeaturePermissionModel> userPermissions = SecurityClientProcessor.GetUserFeaturePermissions(Convert.ToInt32(feature));
List<PermissionEnum> permissions = new List<PermissionEnum>();
foreach (UserFeaturePermissionModel userFeaturePermission in userPermissions)
{
permissions.Add((PermissionEnum)userFeaturePermission.PermissionId);
}
ViewBag.UserPermissions = permissions;
if (!(permissions.Contains(PermissionEnum.ViewContent) || permissions.Contains(PermissionEnum.ViewAnomynousContent)))
return false;
}
catch (Exception ex)
{
HandleError(ex);
}
return true;
}
/**
* Validates the request for telstar logistics
*/
public static string VerifyTelstarRequest(TelstarRequest telstarRequest)
{
//Check company
CompanyEnum company;
try
{
company = (CompanyEnum)Enum.Parse(typeof(CompanyEnum), telstarRequest.Company);
}
catch (Exception)
{
return("Invalid company");
}
//Check company secret
string secretError = IsCompanySecretValid(company, telstarRequest.SecretCompanyCode);
if (secretError != null)
{
return(secretError);
}
//Check valid cities
CityEnum cityFrom;
CityEnum cityTo;
try
{
cityFrom = (CityEnum)Enum.Parse(typeof(CityEnum), telstarRequest.CityFrom);
cityTo = (CityEnum)Enum.Parse(typeof(CityEnum), telstarRequest.CityTo);
}
catch (Exception)
{
return("Invalid city");
}
//Check identical cities
if (cityFrom == cityTo)
{
return("CityFrom cannot be equal to CityTo");
}
//Check if cities are directly connected
string citiesDirectError = IsCitiesDirect(cityFrom, cityTo);
if (citiesDirectError != null)
{
return(citiesDirectError);
}
//Check weight
string weightError = IsNumberValid(telstarRequest.Weight);
if (weightError != null)
{
return(weightError);
}
if (telstarRequest.Weight > 40)
{
return("Weight cannot be more than 40");
}
//Check width
string widthError = IsNumberValid(telstarRequest.Width);
if (widthError != null)
{
return(widthError);
}
//Check length
string lengthError = IsNumberValid(telstarRequest.Length);
if (lengthError != null)
{
return(lengthError);
}
//Check height
string heightError = IsNumberValid(telstarRequest.Height);
if (heightError != null)
{
return(heightError);
}
//Check features
List <FeatureEnum> features = new List <FeatureEnum>();
bool refSeen = false;
bool animalSeen = false;
bool cautioslySeen = false;
string errorMsg = "Cannot transport refrigerated, animals and cautiosly in one delivery";
foreach (string feature in telstarRequest.Features)
{
try {
FeatureEnum f = (FeatureEnum)Enum.Parse(typeof(FeatureEnum), feature);
features.Add(f);
if (f == FeatureEnum.WEAPONS)
{
return("Weapons are not allowed");
}
if (f == FeatureEnum.REFIGERATED)
{
refSeen = true;
if (animalSeen || cautioslySeen)
{
return(errorMsg);
}
}
if (f == FeatureEnum.LIVE_ANIMALS)
{
animalSeen = true;
if (refSeen || cautioslySeen)
{
return(errorMsg);
}
}
if (f == FeatureEnum.CAUTIOUSLY)
{
cautioslySeen = true;
if (animalSeen || refSeen)
{
return(errorMsg);
}
}
}
catch (Exception) {
return("Invalid feature: " + feature);
}
}
return(null);
}
/// <summary>
/// Gets the limit of objects for given license and feature.
/// </summary>
/// <param name="license">License</param>
/// <param name="feature">Feature</param>
public static int GetLimit(LicenseKeyInfo license, FeatureEnum feature)
{
if (license == null)
{
return 0;
}
// If feature not available, no objects allowed
if (!LicenseKeyInfoProvider.IsFeatureAvailable(license, feature))
{
return 0;
}
// Get version limit
int limit = LicenseKeyInfoProvider.VersionLimitations(license, feature);
if (limit == 0)
{
return int.MaxValue;
}
return limit;
}
protected void Page_Load(object sender, EventArgs e)
{
ScriptHelper.RegisterJQuery(this.Page);
if (CultureHelper.IsUICultureRTL())
{
treeElem.LineImagesFolder = GetImageUrl("RTL/Design/Controls/Tree", false, false);
}
else
{
treeElem.LineImagesFolder = GetImageUrl("Design/Controls/Tree", false, false);
}
this.treeElem.ImageSet = TreeViewImageSet.Custom;
this.treeElem.ExpandImageToolTip = GetString("General.Expand");
this.treeElem.CollapseImageToolTip = GetString("General.Collapse");
// Fill in the tree
treeElem.Nodes.Clear();
String imagesUrl = GetImageUrl("CMSModules/CMS_SystemDevelopment/", false, true);
TreeNode rootNode = new TreeNode();
rootNode.Text = "<span class=\"ContentTreeSelectedItem\" name=\"treeNode\" onclick=\"ShowDesktopContent('development.aspx', this); \"><img src=\"" + GetImageUrl("General/DefaultRoot.png") + "\" style=\"border:none;height:10px;width:1px;\" /><span class=\"Name\">" + GetString("Development.Root") + "</span></span>";
rootNode.Expanded = true;
rootNode.NavigateUrl = "#";
treeElem.Nodes.Add(rootNode);
TreeNode newNode = null;
ArrayList al = FillCollectionWithModules(DevelopmentItems, "ShowInDevelopment = 1", true, true);
// Display default development items
foreach (object[] itemProperties in al)
{
FeatureEnum feature = (FeatureEnum)itemProperties[5];
// Check whether the notification module is loaded
if ((feature == FeatureEnum.Notifications) && !ModuleEntry.IsModuleLoaded(ModuleEntry.NOTIFICATIONS))
{
continue;
}
bool showItem = (feature == FeatureEnum.Unknown) ? true : LicenseHelper.IsFeatureAvailableInUI(feature);
if (showItem)
{
string codeName = ValidationHelper.GetCodeName(itemProperties[1]);
newNode = new TreeNode();
newNode.Text = "<span id=\"node_" + codeName + "\" name=\"treeNode\" class=\"ContentTreeItem\" onclick=\"ShowDesktopContent(" + ScriptHelper.GetString(itemProperties[0].ToString()) + ", this); \"><img class=\"TreeItemImage\" src=\"" + itemProperties[3].ToString() + "\" alt=\"\" /><span class=\"Name\">" + HTMLHelper.HTMLEncode(GetString(itemProperties[1].ToString())) + "</span></span>";
newNode.NavigateUrl = "#";
rootNode.ChildNodes.Add(newNode);
}
}
// Handle 'System development' section displaying
if (SettingsKeyProvider.DevelopmentMode)
{
newNode = new TreeNode();
newNode.Text = "<span class=\"ContentTreeItem\"\"><img class=\"TreeItemImage\" src=\"" + imagesUrl + "sysdev.png" + "\" alt=\"\" /><span class=\"Name\">" + GetString("Development.SysDev") + "</span></span>";
TreeNode newSubNode = new TreeNode();
newSubNode.Text = "<span class=\"ContentTreeItem\" onclick=\"ShowDesktopContent('../../CMSModules/Settings/Development/CustomSettings/Default.aspx?treeroot=settings', this); \"><img class=\"TreeItemImage\" src=\"" + imagesUrl + "settings.png" + "\" alt=\"\" /><span class=\"Name\">" + GetString("Development.SysDev.Settings") + "</span></span>";
newSubNode.NavigateUrl = "#";
newNode.ChildNodes.Add(newSubNode);
newSubNode = new TreeNode();
newSubNode.Text = "<span class=\"ContentTreeItem\" onclick=\"ShowDesktopContent('../../CMSModules/SystemDevelopment/Development/Classes/Class_List.aspx', this); \"><img class=\"TreeItemImage\" src=\"" + imagesUrl + "classes.png" + "\" alt=\"\" /><span class=\"Name\">" + GetString("Development.SysDev.Classes") + "</span></span>";
newSubNode.NavigateUrl = "#";
newNode.ChildNodes.Add(newSubNode);
newSubNode = new TreeNode();
newSubNode.Text = "<span class=\"ContentTreeItem\" onclick=\"ShowDesktopContent('../../CMSModules/SystemDevelopment/Development/Resources/UICulture_StringsDefault_List.aspx', this); \"><img class=\"TreeItemImage\" src=\"" + imagesUrl + "resources.png" + "\" alt=\"\" /><span class=\"Name\">" + GetString("Development.SysDev.Resources") + "</span></span>";
newSubNode.NavigateUrl = "#";
newNode.ChildNodes.Add(newSubNode);
rootNode.ChildNodes.Add(newNode);
}
}
public string CmdEnum8(FeatureEnum feature)
{
return($"{feature}");
}
public bool IsFeatureAvailable(FeatureEnum feature, string domain = null)
{
return(HasLicence);
}
