/// <summary>
/// Gets the Typed Results of the query with caching
/// </summary>
/// <returns>The Typed Results.</returns>
public InfoDataSet <BaseInfo> GetTypedResult()
{
if (CacheMinutes == -1)
{
// Check cache settings
CacheMinutes = CacheHelper.CacheMinutes(SiteContext.CurrentSiteName);
}
if (string.IsNullOrWhiteSpace(CacheItemName))
{
CacheItemName = string.Join("|", CacheItemNameParts);
}
if (!EnvironmentHelper.PreviewEnabled && CacheMinutes > 0 && !string.IsNullOrWhiteSpace(CacheItemName))
{
return(CacheHelper.Cache <InfoDataSet <BaseInfo> >(cs =>
{
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency(CacheDependencies);
}
return TypedResult;
}, new CacheSettings(CacheMinutes, CacheItemName, "ObjectQuery_TypedResult", CacheItemNameParts)));
}
else
{
return(TypedResult);
}
}
/// <summary>
/// Gets the Typed Results of the query with caching
/// </summary>
/// <returns>The Typed Results.</returns>
public InfoDataSet <TreeNode> GetTypedResult()
{
if (CacheMinutes == -1)
{
// Check cache settings
CacheMinutes = CacheHelper.CacheMinutes(SiteContext.CurrentSiteName);
}
if (string.IsNullOrWhiteSpace(CacheItemName))
{
CacheItemName = string.Join("|", CacheItemNameParts);
}
if (!EnvironmentHelper.PreviewEnabled && CacheMinutes > 0 && !string.IsNullOrWhiteSpace(CacheItemName))
{
return(CacheHelper.Cache <InfoDataSet <TreeNode> >(cs =>
{
if (cs.Cached)
{
if (CacheDependencies != null)
{
CacheDependencyParts.AddRange(CacheDependencies);
}
cs.CacheDependency = CacheHelper.GetCacheDependency(CacheDependencyParts.Distinct().ToArray());
}
return TypedResult;
}, new CacheSettings(CacheMinutes, CacheItemName, "TreeNode_TypedResult", CacheItemNameParts)));
}
else
{
return(TypedResult);
}
}
/// <summary>
/// Gets the Results (DataSet) of the results, caching if applicable
/// </summary>
/// <returns>The DataSet of the results</returns>
public DataSet GetCachedResult()
{
if (CacheMinutes == -1)
{
// Check cache settings
CacheMinutes = CacheHelper.CacheMinutes(SiteContext.CurrentSiteName);
}
if (string.IsNullOrWhiteSpace(CacheItemName))
{
CacheItemName = string.Join("|", CacheItemNameParts);
}
if (CacheMinutes > 0 && !string.IsNullOrWhiteSpace(CacheItemName))
{
return(CacheHelper.Cache <DataSet>(cs =>
{
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency(CacheDependencies);
}
return Result;
}, new CacheSettings(CacheMinutes, CacheItemName, "ObjectQuery_Result", CacheItemNameParts)));
}
else
{
return(Result);
}
}
public List <SocialIcon> GetAllSocialIcons(string siteName = null)
{
var socialLinks = new List <SocialIcon>();
if (siteName == null)
{
siteName = SiteContext.CurrentSiteName;
}
using (var cs = new CachedSection <List <SocialIcon> >(ref socialLinks, CacheHelper.CacheMinutes(siteName), true, _projectCacheKey))
{
if (cs.LoadData)
{
socialLinks = SocialIconProvider.GetSocialIcons().OnSite(siteName).ToList();
var cacheDependencies = new List <string>
{
$"nodes|{siteName}|{SocialIcon.CLASS_NAME}|all"
};
cs.Data = socialLinks;
cs.CacheDependency = CacheHelper.GetCacheDependency(cacheDependencies);
}
}
return(socialLinks);
}
public static string GetContent(string manifestKey, string prefix = "")
{
var distServerPath = HttpContext.Current.Server.MapPath(DistPath);
if (string.IsNullOrEmpty(distServerPath) || !Directory.Exists(distServerPath))
{
return(null);
}
var result = string.Empty;
using (var cs = new CachedSection <string>(ref result, CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), true,
$"AssetsCache_{manifestKey}_{ManifestHash}"))
{
if (cs.LoadData)
{
var fullPath = GetFullPathFromManifest(manifestKey);
if (!string.IsNullOrEmpty(fullPath))
{
var processedValue = fullPath.Replace($"{DistPath}/", string.Empty);
var fullFilePath = distServerPath + "\\" + prefix + processedValue;
if (File.Exists(fullFilePath))
{
result = File.ReadAllText(fullFilePath);
}
cs.Data = result;
}
}
}
return(result);
}
/// <summary>
/// Gets the RelativeURL from the Node Alias Path
/// </summary>
/// <param name="NodeAliasPath">The Node Alias Path</param>
/// <returns></returns>
public static string NodeAliasPathToUrl(string NodeAliasPath)
{
return(CacheHelper.Cache <string>(cs =>
{
// get proper Url path for the given document
var DocQuery = DocumentHelper.GetDocuments()
.Path(NodeAliasPath)
.CombineWithDefaultCulture(true)
.OnCurrentSite()
.TopN(1);
if (LocalizationContext.CurrentCulture != null)
{
DocQuery.Culture(LocalizationContext.CurrentCulture.CultureCode);
}
var TreeNode = DocQuery.FirstOrDefault();
if (TreeNode != null)
{
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency(new string[]
{
"cms.document|byid|" + TreeNode.DocumentID,
"cms.class|byname|" + TreeNode.ClassName
});
}
return TreeNode.RelativeURL;
}
else
{
return null;
}
}, new CacheSettings(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), "PartialWidgetGetUrlFromPath", NodeAliasPath, SiteContext.CurrentSiteName, LocalizationContext.CurrentCulture?.CultureCode)));
}
public List <Project> GetAllProjects(string siteName = null)
{
var result = new List <Project>();
if (siteName == null)
{
siteName = SiteContext.CurrentSiteName;
}
using (var cs = new CachedSection <List <Project> >(ref result, CacheHelper.CacheMinutes(siteName), true, _projectCacheKey))
{
if (cs.LoadData)
{
result = ProjectProvider.GetProjects().OnSite(siteName).ToList();
var cacheDependencies = new List <string>
{
$"nodes|{siteName}|{Project.CLASS_NAME}|all"
};
cs.Data = result;
cs.CacheDependency = CacheHelper.GetCacheDependency(cacheDependencies);
}
}
return(result);
}
private static string[] GetPageTypesWithSeoUrlClassNames()
{
const string cacheKey = "deleteboilerplate|pagetypeswithseourlclassnames|all";
var result = new string[0];
var siteName = SiteContext.CurrentSiteName;
using (var cs = new CachedSection <string[]>(ref result, CacheHelper.CacheMinutes(siteName), true, cacheKey))
{
if (cs.LoadData)
{
// All page types with SeoUrl column
result = DataClassInfoProvider.GetClasses()
.Where(dataClass =>
dataClass.ClassIsDocumentType &&
dataClass.ClassSearchSettingsInfos.Any(x => x.Name.Equals(Constants.DynamicRouting.SeoUrlFieldName)))
.Select(x => x.ClassName)
.ToArray();
var cacheDependencies = new List <string>
{
"cms.class|all",
"cms.documenttype|all"
};
cs.Data = result;
cs.CacheDependency = CacheHelper.GetCacheDependency(cacheDependencies);
}
}
return(result);
}
public static object GetNewPageLink(EvaluationContext context, params object[] parameters)
{
try
{
if (parameters.Length >= 2)
{
string ClassName = ValidationHelper.GetString(parameters[0], "");
string ParentNodeAlias = ValidationHelper.GetString(parameters[1], "");
string Culture = ValidationHelper.GetString(parameters.Length > 2 ? parameters[2] : "en-US", "en-US");
if (!string.IsNullOrWhiteSpace(ClassName) && !string.IsNullOrWhiteSpace(ParentNodeAlias))
{
return(CacheHelper.Cache <string>(cs =>
{
int ClassID = DataClassInfoProvider.GetDataClassInfo(ClassName).ClassID;
int NodeID = new DocumentQuery().Path(ParentNodeAlias, PathTypeEnum.Single).FirstOrDefault().NodeID;
return URLHelper.ResolveUrl(string.Format("~/CMSModules/Content/CMSDesk/Edit/Edit.aspx?action=new&classid={0}&parentnodeid={1}&parentculture={2}", ClassID, NodeID, Culture));
}, new CacheSettings(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), ClassName, ParentNodeAlias, Culture)));
}
}
}
catch (Exception ex)
{
EventLogProvider.LogException("RelationshipMacros", "GetNewPageLinkError", ex);
}
return("#");
}
/// <summary>
/// Gets the TreeNode for the corresponding path, can be either the NodeAliasPath or a URL Alias
/// </summary>
/// <param name="Path"></param>
/// <returns></returns>
public static TreeNode GetNodeByAliasPath(string Path, string ClassName = null, string CultureCode = null)
{
return(CacheHelper.Cache <TreeNode>(cs =>
{
List <string> CacheDependencies = new List <string>();
TreeNode FoundNode = DocumentQueryHelper.RepeaterQuery(Path: Path, ClassNames: ClassName, CultureCode: CultureCode).GetTypedResult().Items.FirstOrDefault();
if (FoundNode == null)
{
// Check Url Aliases
var FoundNodeByAlias = DocumentAliasInfoProvider.GetDocumentAliasesWithNodesDataQuery().WhereEquals("AliasUrlPath", Path).Or().Where(string.Format("'{0}' like AliasWildCardRule", SqlHelper.EscapeQuotes(Path))).FirstOrDefault();
if (FoundNodeByAlias != null && FoundNodeByAlias.AliasNodeID > 0)
{
CacheDependencies.Add("cms.documentalias|all");
CacheDependencies.Add(string.Format("node|{0}|{1}", SiteContext.CurrentSiteName, Path));
FoundNode = DocumentQueryHelper.RepeaterQuery(NodeID: FoundNodeByAlias.AliasNodeID, ClassNames: ClassName, CultureCode: (!string.IsNullOrWhiteSpace(FoundNodeByAlias.AliasCulture) ? FoundNodeByAlias.AliasCulture : CultureCode)).GetTypedResult().Items.FirstOrDefault();
}
}
if (FoundNode != null)
{
CacheDependencies.Add("documentid|" + FoundNode.DocumentID);
}
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency(CacheDependencies.ToArray());
}
return FoundNode;
}, new CacheSettings(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), Path, ClassName, CultureCode)));
}
/// <summary>
/// Mimics the Repeater with Custom Query, including caching
/// </summary>
/// <param name="QueryName">The Query Name</param>
/// <param name="OrderBy">Order By</param>
/// <param name="SelectTopN">TopN</param>
/// <param name="WhereCondition">Where Condition</param>
/// <param name="Columns">Columns</param>
/// <param name="QueryParameters">Query Parameters to pass to query.</param>
/// <param name="CacheItemName">Unique identifier for the cache, REQUIRED for caching.</param>
/// <param name="CacheMinutes">Optional Cache Minutes, will use site's default cache minutes if not provided.</param>
/// <param name="CacheDependencies">Cache Dependencies</param>
/// <returns></returns>
public static DataSet ExecuteQuery(
string QueryName,
string OrderBy = null,
int SelectTopN = -1,
string WhereCondition = null,
string Columns = null,
QueryDataParameters QueryParameters = null,
string CacheItemName = null,
int CacheMinutes = -1,
string[] CacheDependencies = null)
{
List <object> CacheItemNameParts = new List <object>();
if (CacheMinutes == -1)
{
// Check cache settings
CacheMinutes = CacheHelper.CacheMinutes(SiteContext.CurrentSiteName);
}
if (CacheMinutes > 0 && !string.IsNullOrWhiteSpace(CacheItemName))
{
// Fill up the CacheItemNameParts
if (QueryParameters != null)
{
foreach (DataParameter QueryParam in QueryParameters)
{
CacheItemNameParts.Add(string.Format("{0}|{1}", QueryParam.Name, QueryParam.Value));
}
}
if (!string.IsNullOrWhiteSpace(WhereCondition))
{
CacheItemNameParts.Add(WhereCondition);
}
if (!string.IsNullOrWhiteSpace(OrderBy))
{
CacheItemNameParts.Add(OrderBy);
}
if (!string.IsNullOrWhiteSpace(Columns))
{
CacheItemNameParts.Add(Columns);
}
if (SelectTopN > -1)
{
CacheItemNameParts.Add(SelectTopN);
}
return(CacheHelper.Cache <DataSet>(cs =>
{
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency(CacheDependencies);
}
return ConnectionHelper.ExecuteQuery(QueryName, QueryParameters, WhereCondition, OrderBy, SelectTopN, Columns);
}, new CacheSettings(CacheMinutes, CacheItemName, "Result", QueryName, CacheItemNameParts)));
}
else
{
return(ConnectionHelper.ExecuteQuery(QueryName, QueryParameters, WhereCondition, OrderBy, SelectTopN, Columns));
}
}
/// <summary>
/// Uses the given IPrincipleUser to get the current user.
/// </summary>
/// <param name="User"></param>
/// <returns></returns>
public static UserInfo AuthenticatedUser(IPrincipal User)
{
string Username = (User != null && User.Identity != null ? User.Identity.Name : "public");
return(CacheHelper.Cache <UserInfo>(cs =>
{
return UserInfoProvider.GetUserInfo(Username);
}, new CacheSettings(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), "AuthenticatedUser", Username)));
}
/// <summary>
/// Gets the Typed Results, populating the "Children" of the Nodes with their children.
/// </summary>
/// <returns>The TreeNodes (top level) with Children populated with their child elements.</returns>
public InfoDataSet <TreeNode> GetHierarchicalTypedResult()
{
if (CacheMinutes == -1)
{
// Check cache settings
CacheMinutes = CacheHelper.CacheMinutes(SiteContext.CurrentSiteName);
}
if (string.IsNullOrWhiteSpace(CacheItemName))
{
CacheItemName = string.Join("|", CacheItemNameParts);
}
if (!EnvironmentHelper.PreviewEnabled && CacheMinutes > 0 && !string.IsNullOrWhiteSpace(CacheItemName))
{
return(CacheHelper.Cache <InfoDataSet <TreeNode> >(cs =>
{
Dictionary <int, TreeNode> ParentNodeIDToTreeNode = new Dictionary <int, TreeNode>();
List <TreeNode> CompiledNodes = new List <TreeNode>();
if (cs.Cached)
{
if (CacheDependencies != null)
{
CacheDependencyParts.AddRange(CacheDependencies);
}
cs.CacheDependency = CacheHelper.GetCacheDependency(CacheDependencyParts.Distinct().ToArray());
}
// Populate the Children of the TypedResults
foreach (TreeNode Node in TypedResult)
{
// Make sure Children only contain the children found in the typed results.
Node.Children.MakeEmpty();
ParentNodeIDToTreeNode.Add(Node.NodeID, Node);
// If no parent exists, add to top level
if (!ParentNodeIDToTreeNode.ContainsKey(Node.NodeParentID))
{
CompiledNodes.Add(Node);
}
else
{
// Otherwise, add to the parent element.
ParentNodeIDToTreeNode[Node.NodeParentID].Children.Add(Node);
}
}
return new InfoDataSet <TreeNode>(CompiledNodes.ToArray());
}, new CacheSettings(CacheMinutes, CacheItemName, "TreeNode_TypedResult", CacheItemNameParts)));
}
else
{
return(TypedResult);
}
}
/// <summary>
/// Determines if the current relationship is an AdHoc relationship based on the UI Property RelationshipName
/// </summary>
/// <returns>True if the current relationship is an ad hoc relationship</returns>
private static bool IsAdHocRelationship()
{
string RelationshipName = ValidationHelper.GetString(UIContext.Current.Data.GetValue("RelationshipName"), "");
return(CacheHelper.Cache <bool>(cs =>
{
RelationshipNameInfo relationshipObj = RelationshipNameInfoProvider.GetRelationshipNameInfo(RelationshipName);
if (relationshipObj != null && cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency("cms.relationshipname|byid|" + relationshipObj.RelationshipNameId);
}
return relationshipObj != null ? relationshipObj.RelationshipNameIsAdHoc : false;
}, new CacheSettings(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), "RelationshipMacro", "IsAdHocRelationship", RelationshipName)));
}
public IEnumerable <TaxonomyType> GetAllTaxonomyTypes()
{
var cacheKey = $"{_baseCacheKey}|types|all";
var result = new List <TaxonomyType>();
var siteName = SiteContext.CurrentSiteName;
using (var cs = new CachedSection <List <TaxonomyType> >(ref result, CacheHelper.CacheMinutes(siteName), true, cacheKey))
{
if (cs.LoadData)
{
result = TaxonomyTypeProvider.GetTaxonomyTypes().AllCultures()
.Published()
.OnSite(siteName)
.OrderBy("NodeOrder")
.ToList();
var taxonomyItems = TaxonomyItemProvider.GetTaxonomyItems().AllCultures()
.Published()
.OnSite(siteName)
.OrderBy("NodeOrder")
.ToList();
foreach (var taxonomyType in result)
{
taxonomyType.TaxonomyItems =
taxonomyItems.Where(x => x.NodeParentID == taxonomyType.NodeID).ToList();
foreach (var taxonomyItem in taxonomyType.TaxonomyItems)
{
taxonomyItem.TaxonomyType = taxonomyType;
}
}
var cacheDependencies = new List <string>
{
$"nodes|{siteName}|{TaxonomyType.CLASS_NAME}|all",
$"nodes|{siteName}|{TaxonomyItem.CLASS_NAME}|all"
};
cs.Data = result;
cs.CacheDependency = CacheHelper.GetCacheDependency(cacheDependencies);
}
}
return(result);
}
/// <summary>
/// Gets the TreeNode for the corresponding path, can be either the NodeAliasPath or a URL Alias
/// </summary>
/// <param name="Path"></param>
/// <returns></returns>
public static TreeNode GetNodeByAliasPath(string Path, string ClassName = null, string CultureCode = null)
{
return(CacheHelper.Cache <TreeNode>(cs =>
{
List <string> CacheDependencies = new List <string>();
TreeNode FoundNode = DocumentQueryHelper.RepeaterQuery(Path: Path, ClassNames: ClassName, CultureCode: CultureCode).GetTypedResult().Items.FirstOrDefault();
if (FoundNode != null)
{
CacheDependencies.Add("documentid|" + FoundNode.DocumentID);
}
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency(CacheDependencies.ToArray());
}
return FoundNode;
}, new CacheSettings((EnvironmentHelper.PreviewEnabled ? 0 : CacheHelper.CacheMinutes(SiteContext.CurrentSiteName)), Path, ClassName, CultureCode, SiteContext.CurrentSiteName)));
}
/// <summary>
/// Selects line randomly.
/// </summary>
/// <param name="random">Random generator</param>
/// <param name="questions">Questions</param>
/// <returns>Lines</returns>
private string[] SelectLine(Random random, string questions)
{
ArrayList lines = null;
// Get current culture
string culture = ValidationHelper.GetString(ViewState["CultureCode"], LocalizationContext.PreferredCultureCode);
string sitename = SiteContext.CurrentSiteName;
// Get or generate cache item name
string useCacheItemName = CacheHelper.BaseCacheKey + "|" + RequestContext.CurrentURL + "|" + ClientID + "|" + culture + "|" + UseTextOrImageCaptcha;
// Try to get data from cache
if (CacheHelper.CacheMinutes(sitename) == 0)
{
// No caching
CacheHelper.Remove(useCacheItemName);
lines = GetLines(random, culture, questions);
}
else
{
object value = null;
// Try to retrieve data from the cache
if (!CacheHelper.TryGetItem(useCacheItemName, out value))
{
lines = GetLines(random, culture, questions);
if ((lines != null) && (lines.Count > 0))
{
CacheHelper.Add(useCacheItemName, lines, null, DateTime.Now.AddMinutes(CacheHelper.CacheMinutes(sitename)), Cache.NoSlidingExpiration);
}
}
else
{
lines = (ArrayList)CacheHelper.GetItem(useCacheItemName);
}
}
if ((lines != null) && (lines.Count > 0))
{
// Split selected line a return result.
int selectedLine = random.Next(lines.Count);
return(lines[selectedLine].ToString().Split(';'));
}
return(null);
}
/// <summary>
/// Can override this to implement your own custom logic to get the UserInfo of the current user. Use httpContext.User
/// </summary>
/// <param name="httpContext">The HttpContext of the request</param>
/// <returns>The UserInfo, should return the Public user if they are not logged in.</returns>
public virtual UserInfo GetCurrentUser(HttpContextBase httpContext)
{
// return EnvironmentHelper.AuthenticatedUser(httpContext.User);
// This logic is the same as my EnvironmentHelper.AuthenticatedUser(httpContext.User), added so does not depend on my classes.
string Username = DataHelper.GetNotEmpty((httpContext.User != null && httpContext.User.Identity != null ? httpContext.User.Identity.Name : "public"), "public");
return(CacheHelper.Cache <UserInfo>(cs =>
{
UserInfo UserObj = UserInfoProvider.GetUserInfo(Username);
if (UserObj == null)
{
UserObj = UserInfoProvider.GetUserInfo("public");
}
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency("cms.user|byid|" + UserObj.UserID);
}
return UserObj;
}, new CacheSettings(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), "AuthenticatedUser", Username)));
}
/// <summary>
/// Gets the current Tree Node based on the NodeID parameter passed to UI elements
/// </summary>
/// <returns>The Tree Node that the current page belongs to</returns>
private static TreeNode CurrentNode()
{
int NodeID = QueryHelper.GetInteger("NodeID", -1);
string Culture = QueryHelper.GetString("culture", "en-US");
if (NodeID > 0)
{
return(CacheHelper.Cache <TreeNode>(cs =>
{
TreeNode currentNode = new DocumentQuery().WhereEquals("NodeID", NodeID).Culture(Culture).CombineWithDefaultCulture(true).FirstOrDefault();
if (currentNode != null && cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency("nodeid|" + NodeID);
}
return currentNode;
}, new CacheSettings(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), "RelationshipMacro", "CurrentNode", NodeID, Culture)));
}
else
{
return(null);
}
}
private MacroResolver GetNodeMacroResolver(int NodeID, string ClassName)
{
string Culture = URLHelper.GetQueryValue(Request.RawUrl, "culture");
return(CacheHelper.Cache <MacroResolver>(cs =>
{
MacroResolver resolver = MacroResolver.GetInstance();
List <string> Columns = new List <string>();
if (!string.IsNullOrWhiteSpace(ToolTipFormat))
{
Columns.AddRange(DataHelper.GetNotEmpty(MacroProcessor.GetMacros(ToolTipFormat, true), "NodeName").Split(';'));
}
if (!string.IsNullOrWhiteSpace(DisplayNameFormat))
{
Columns.AddRange(DataHelper.GetNotEmpty(MacroProcessor.GetMacros(DisplayNameFormat, true), "NodeName").Split(';'));
}
// Get data for this node and render it out
DataSet FullData = new DocumentQuery(ClassName)
.WhereEquals("NodeID", NodeID)
.Columns(Columns)
.Culture(Culture)
.CombineWithDefaultCulture(true).Result;
foreach (DataColumn item in FullData.Tables[0].Columns)
{
resolver.SetNamedSourceData(item.ColumnName, FullData.Tables[0].Rows[0][item.ColumnName]);
}
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency("nodeid|" + NodeID);
}
return resolver;
}, new CacheSettings(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), "RelationshipTree_GetNodeMacroResolver", NodeID, Culture, ToolTipFormat, DisplayNameFormat)));
}
public static object GetNewPageLink(EvaluationContext context, params object[] parameters)
{
try
{
if (parameters.Length >= 2)
{
string ClassName = ValidationHelper.GetString(parameters[0], "");
string ParentNodeAlias = ValidationHelper.GetString(parameters[1], "");
string Culture = ValidationHelper.GetString(parameters.Length > 2 ? parameters[2] : "en-US", "en-US");
string SiteName = ValidationHelper.GetString(parameters.Length > 3 ? parameters[3] : SiteContext.CurrentSiteName, SiteContext.CurrentSiteName);
string SiteDomain = "";
if (SiteName.Equals("#currentsite", StringComparison.InvariantCultureIgnoreCase))
{
SiteName = SiteContext.CurrentSiteName;
}
if (!string.IsNullOrWhiteSpace(SiteName) && !SiteName.Equals(SiteContext.CurrentSiteName, StringComparison.InvariantCultureIgnoreCase))
{
SiteDomain = (System.Web.HttpContext.Current.Request.IsSecureConnection ? "https://" : "http://") + SiteInfo.Provider.Get(SiteName).DomainName.Trim('/');
}
if (!string.IsNullOrWhiteSpace(ClassName) && !string.IsNullOrWhiteSpace(ParentNodeAlias))
{
return(CacheHelper.Cache <string>(cs =>
{
int ClassID = DataClassInfoProvider.GetDataClassInfo(ClassName).ClassID;
int NodeID = new DocumentQuery().Path(ParentNodeAlias, PathTypeEnum.Single).FirstOrDefault().NodeID;
return SiteDomain + URLHelper.ResolveUrl(string.Format("~/CMSModules/Content/CMSDesk/Edit/Edit.aspx?action=new&classid={0}&parentnodeid={1}&parentculture={2}", ClassID, NodeID, Culture));
}, new CacheSettings(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), ClassName, ParentNodeAlias, Culture, SiteName)));
}
}
}
catch (Exception ex)
{
Service.Resolve <IEventLogService>().LogException("RelationshipMacros", "GetNewPageLinkError", ex);
}
return("#");
}
public List <NavigationLink> GetAllNavigationLinks(string siteName = null)
{
var navigationLinks = new List <NavigationLink>();
if (siteName == null)
{
siteName = SiteContext.CurrentSiteName;
}
using (var cs = new CachedSection <List <NavigationLink> >(ref navigationLinks, CacheHelper.CacheMinutes(siteName), true, _projectCacheKey))
{
if (cs.LoadData)
{
navigationLinks = NavigationLinkProvider.GetNavigationLinks().OnSite(siteName).ToList();
var cacheDependencies = new List <string>
{
$"nodes|{siteName}|{NavigationLink.CLASS_NAME}|all"
};
cs.Data = navigationLinks;
cs.CacheDependency = CacheHelper.GetCacheDependency(cacheDependencies);
}
}
return(navigationLinks);
}
private static CacheSettings CreateCacheSettings(string cacheKey)
{
return(new CacheSettings(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), cacheKey));
}
/// <summary>
/// Sets in the Viewbag the CurrentDocument (TreeNode), CurrentSite (SiteInfo), and CurrentCulture (CultureInfo)
/// </summary>
/// <param name="DocumentID">The Document ID</param>
/// <param name="CultureCode">The culture if you wish it to not be based on the found Document's</param>
/// <param name="SiteName">The SiteName if you wish it to not be based on the Document's</param>
public void SetContext(int DocumentID, string CultureCode = null, string SiteName = null)
{
TreeNode DocumentNodeForClass = new DocumentQuery().WhereEquals("DocumentID", DocumentID).FirstOrDefault();
TreeNode DocumentContext = null;
if (DocumentNodeForClass != null)
{
// Set Page Builder Context
HttpContext.Kentico().PageBuilder().Initialize(DocumentID);
CacheableDocumentQuery RepeaterQuery = new CacheableDocumentQuery(DocumentNodeForClass.ClassName);
RepeaterQuery.WhereEquals("DocumentID", DocumentID);
RepeaterQuery.CacheItemNameParts.Add("documentid|" + DocumentID);
if (EnvironmentHelper.PreviewEnabled)
{
RepeaterQuery.LatestVersion(true);
RepeaterQuery.Published(false);
}
else
{
RepeaterQuery.PublishedVersion(true);
}
DocumentContext = RepeaterQuery.GetTypedResult().Items.FirstOrDefault();
}
if (DocumentContext != null)
{
ViewBag.CurrentDocument = DocumentContext;
if (string.IsNullOrWhiteSpace(SiteName))
{
SiteName = DocumentContext.NodeSiteName;
}
if (string.IsNullOrWhiteSpace(CultureCode))
{
CultureCode = DocumentContext.DocumentCulture;
}
}
if (!string.IsNullOrWhiteSpace(SiteName))
{
ViewBag.CurrentSite = CacheHelper.Cache <SiteInfo>(cs =>
{
SiteInfo SiteObj = SiteInfoProvider.GetSiteInfo(SiteName);
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency("cms.site|byid|" + SiteObj.SiteID);
}
return(SiteObj);
}, new CacheSettings(CacheHelper.CacheMinutes(SiteName), "GetSiteInfo", SiteName));
}
if (!string.IsNullOrWhiteSpace(CultureCode))
{
ViewBag.CurrentCulture = CacheHelper.Cache <CultureInfo>(cs =>
{
CultureInfo CultureObj = CultureInfoProvider.GetCultureInfo(CultureCode);
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency(CultureInfo.TYPEINFO.ObjectClassName + "|byid|" + CultureObj.CultureID);
}
return(CultureObj);
}, new CacheSettings(CacheHelper.CacheMinutes(SiteName), "GetCultureInfo", CultureCode));;
}
}
/// <summary>
/// Gets the default content cache minutes set for the current site.
/// </summary>
private static int GetCacheMinutes()
{
return(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName));
}
/// <summary>
/// Checks Roles, Users, Resource Names, and Page ACL depending on configuration
/// </summary>
/// <param name="httpContext">The Route Context</param>
/// <returns>If the request is authorized.</returns>
protected override bool AuthorizeCore(HttpContextBase httpContext)
{
AuthorizingEventArgs AuthorizingArgs = new AuthorizingEventArgs()
{
CurrentUser = GetCurrentUser(httpContext),
FoundPage = GetTreeNode(httpContext),
Authorized = false
};
bool IsAuthorized = false;
// Start event, allow user to overwrite FoundPage
using (var KenticoAuthorizeAuthorizingTaskHandler = AuthorizeEvents.Authorizing.StartEvent(AuthorizingArgs))
{
if (!AuthorizingArgs.SkipDefaultValidation)
{
AuthorizingArgs.Authorized = CacheHelper.Cache(cs =>
{
bool Authorized = false;
List <string> CacheDependencies = new List <string>();
// Will remain true only if no other higher priority authorization items were specified
bool OnlyAuthenticatedCheck = true;
// Roles
if (!Authorized && !string.IsNullOrWhiteSpace(Roles))
{
OnlyAuthenticatedCheck = false;
CacheDependencies.Add("cms.role|all");
CacheDependencies.Add("cms.userrole|all");
CacheDependencies.Add("cms.membershiprole|all");
CacheDependencies.Add("cms.membershipuser|all");
foreach (string Role in Roles.Split(";,|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries))
{
if (AuthorizingArgs.CurrentUser.IsInRole(Role, SiteContext.CurrentSiteName, true, true))
{
Authorized = true;
break;
}
}
}
// Users
if (!Authorized && !string.IsNullOrWhiteSpace(Users))
{
OnlyAuthenticatedCheck = false;
foreach (string User in Users.Split(";,|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries))
{
if (User.ToLower().Trim() == AuthorizingArgs.CurrentUser.UserName.ToLower().Trim())
{
Authorized = true;
break;
}
}
}
// Explicit Permissions
if (!Authorized && !string.IsNullOrWhiteSpace(ResourceAndPermissionNames))
{
OnlyAuthenticatedCheck = false;
CacheDependencies.Add("cms.role|all");
CacheDependencies.Add("cms.userrole|all");
CacheDependencies.Add("cms.membershiprole|all");
CacheDependencies.Add("cms.membershipuser|all");
CacheDependencies.Add("cms.permission|all");
CacheDependencies.Add("cms.rolepermission|all");
foreach (string ResourcePermissionName in ResourceAndPermissionNames.Split(";,|".ToCharArray(), StringSplitOptions.RemoveEmptyEntries))
{
string[] StringParts = ResourcePermissionName.Split('.');
string PermissionName = StringParts.Last();
string ResourceName = string.Join(".", StringParts.Take(StringParts.Length - 1));
if (UserSecurityHelper.IsAuthorizedPerResource(ResourceName, PermissionName, SiteContext.CurrentSiteName, AuthorizingArgs.CurrentUser))
{
Authorized = true;
break;
}
}
}
// Check page level security
if (!Authorized && CheckPageACL)
{
if (AuthorizingArgs.FoundPage != null)
{
OnlyAuthenticatedCheck = false;
CacheDependencies.Add("cms.role|all");
CacheDependencies.Add("cms.userrole|all");
CacheDependencies.Add("cms.membershiprole|all");
CacheDependencies.Add("cms.membershipuser|all");
CacheDependencies.Add("nodeid|" + AuthorizingArgs.FoundPage.NodeID);
CacheDependencies.Add("cms.acl|all");
CacheDependencies.Add("cms.aclitem|all");
if (TreeSecurityProvider.IsAuthorizedPerNode(AuthorizingArgs.FoundPage, NodePermissionToCheck, AuthorizingArgs.CurrentUser) != AuthorizationResultEnum.Denied)
{
Authorized = true;
}
}
}
// If there were no other authentication properties, check if this is purely an "just requires authentication" area
if (OnlyAuthenticatedCheck && (!UserAuthenticationRequired || !AuthorizingArgs.CurrentUser.IsPublic()))
{
Authorized = true;
}
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency(CacheDependencies.Distinct().ToArray());
}
return(Authorized);
}, new CacheSettings(CacheAuthenticationResults ? CacheHelper.CacheMinutes(SiteContext.CurrentSiteName) : 0, "AuthorizeCore", AuthorizingArgs.CurrentUser.UserID, (AuthorizingArgs.FoundPage != null ? AuthorizingArgs.FoundPage.DocumentID : -1), SiteContext.CurrentSiteName, Users, Roles, ResourceAndPermissionNames, CheckPageACL, NodePermissionToCheck, CustomUnauthorizedRedirect, UserAuthenticationRequired));
}
IsAuthorized = AuthorizingArgs.Authorized;
}
return(IsAuthorized);
}
protected void OnTabCreated(object sender, TabCreatedEventArgs e)
{
if (e.Tab == null)
{
return;
}
var tab = e.Tab;
var element = e.UIElement;
PageTemplateInfo UITemplate = PageTemplateInfoProvider.GetPageTemplateInfo(e.UIElement.ElementPageTemplateID);
var manager = DocumentManager;
var node = manager.Node;
bool splitViewSupported = PortalContext.ViewMode != ViewModeEnum.EditLive;
string elementName = element.ElementName.ToLowerCSafe();
if (UITemplate.CodeName.ToLower().Contains("editrelationship"))
{
XmlDocument properties = new XmlDocument();
properties.LoadXml(e.UIElement.ElementProperties);
XmlNode LeftSideMacro = properties.SelectSingleNode("/Data[1]/IsLeftSideMacro[1]");
XmlNode RightSideMacro = properties.SelectSingleNode("/Data[1]/IsRightSideMacro[1]");
XmlNode AutoHide = properties.SelectSingleNode("/Data[1]/AutoHide[1]");
if (AutoHide != null && ValidationHelper.GetBoolean(AutoHide.InnerText, false) && LeftSideMacro != null && RightSideMacro != null)
{
MacroResolver pageResolver = MacroResolver.GetInstance();
// Get current node's class, then full document so it has related data.
int NodeID = ValidationHelper.GetInteger(URLHelper.GetQueryValue(RequestContext.RawURL, "nodeid"), 1);
string Culture = DataHelper.GetNotEmpty(URLHelper.GetQueryValue(RequestContext.RawURL, "culture"), "en-US");
TreeNode CurrentDocument = CacheHelper.Cache <TreeNode>(cs =>
{
TreeNode Document = new DocumentQuery().WhereEquals("NodeID", NodeID).Columns("ClassName").FirstOrDefault();
Document = new DocumentQuery(Document.ClassName).WhereEquals("NodeID", NodeID).Culture(Culture).FirstOrDefault();
if (cs.Cached)
{
cs.CacheDependency = CacheHelper.GetCacheDependency(new string[] { string.Format("node|{0}|{1}|{2}", Document.NodeSiteName, Document.NodeAliasPath, Culture,
PageTemplateInfo.OBJECT_TYPE + "|byid|" + e.UIElement.ElementPageTemplateID) });
}
return(Document);
}, new CacheSettings(CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), NodeID, Culture, e.UIElement.ElementPageTemplateID));
pageResolver.SetNamedSourceData("CurrentDocument", CurrentDocument);
if (!(ValidationHelper.GetBoolean(pageResolver.ResolveMacros(LeftSideMacro.InnerText), true) || ValidationHelper.GetBoolean(pageResolver.ResolveMacros(RightSideMacro.InnerText), true)))
{
e.Tab = null;
}
}
}
if (DocumentUIHelper.IsElementHiddenForNode(element, node))
{
e.Tab = null;
return;
}
// Ensure split view mode
if (splitViewSupported && PortalUIHelper.DisplaySplitMode)
{
tab.RedirectUrl = DocumentUIHelper.GetSplitViewUrl(tab.RedirectUrl);
}
}
public List <NavigationLink> GetNavigationLinksByPath(string path)
{
var cacheKey = $"{_projectCacheKey}|{path}";
var navigationLinks = new List <NavigationLink>();
using (var cs = new CachedSection <List <NavigationLink> >(ref navigationLinks, CacheHelper.CacheMinutes(SiteContext.CurrentSiteName), true, cacheKey))
{
if (cs.LoadData)
{
var result = NavigationLinkProvider.GetNavigationLinks()
.Path(path)
.OnSite(SiteContext.CurrentSiteName)
.ToList();
var associatedPagePaths = DocumentHelper.GetDocuments()
.Columns("NodeGUID,NodeAliasPath")
.WhereIn("NodeGUID", result.Select(x => x.AssociatedPage).ToList())
.ToList();
foreach (var navigationLink in result)
{
navigationLink.AssociatedPagePath =
associatedPagePaths.FirstOrDefault(x => x.NodeGUID == navigationLink.AssociatedPage)
?.NodeAliasPath;
navigationLink.ChildLinks = result.Where(x => x.NodeParentID == navigationLink.NodeID)
.OrderBy(x => x.NodeOrder)
.ToList();
foreach (var childLink in navigationLink.ChildLinks)
{
childLink.ParentLink = navigationLink;
}
}
navigationLinks = result.Where(x => x.ParentLink == default(NavigationLink)).ToList();
var cacheDependencies = new List <string>
{
$"nodes|{SiteContext.CurrentSiteName}|{NavigationLink.CLASS_NAME}|all"
};
cs.Data = navigationLinks;
cs.CacheDependency = CacheHelper.GetCacheDependency(cacheDependencies);
}
}
return(navigationLinks);
}
public IDictionary <Guid, TaxonomyItem> GetAllTaxonomyItems()
{
var cacheKey = $"{_baseCacheKey}|items|all";
var siteName = SiteContext.CurrentSiteName;
var result = new Dictionary <Guid, TaxonomyItem>();
using (var cs = new CachedSection <Dictionary <Guid, TaxonomyItem> >(ref result, CacheHelper.CacheMinutes(siteName), true, cacheKey))
{
if (cs.LoadData)
{
result = GetAllTaxonomyTypes().SelectMany(x => x.TaxonomyItems)
.ToDictionary(k => k.NodeGUID, v => v);
var cacheDependencies = new List <string>
{
$"nodes|{siteName}|{TaxonomyType.CLASS_NAME}|all",
$"nodes|{siteName}|{TaxonomyItem.CLASS_NAME}|all"
};
cs.Data = result;
cs.CacheDependency = CacheHelper.GetCacheDependency(cacheDependencies);
}
}
return(result);
}