/// <summary>
/// Determines whether node is accessible to user.
/// </summary>
/// <param name="siteMap">The site map.</param>
/// <param name="node">The node.</param>
/// <returns>
/// <c>true</c> if accessible to user; otherwise, <c>false</c>.
/// </returns>
public bool IsAccessibleToUser(ISiteMap siteMap, ISiteMapNode node)
{
// If we have roles assigned, check them against the roles defined in the sitemap
if (node.Roles != null && node.Roles.Count > 0)
{
var context = mvcContextFactory.CreateHttpContext();
// if there is an authenticated user and the role allows anyone authenticated ("*"), show it
if ((context.User.Identity.IsAuthenticated) && node.Roles.Contains("*"))
{
return true;
}
// if there is no user, but the role allows unauthenticated users ("?"), show it
if ((!context.User.Identity.IsAuthenticated) && node.Roles.Contains("?"))
{
return true;
}
// if the user is in one of the listed roles, show it
if (node.Roles.OfType<string>().Any(role => context.User.IsInRole(role)))
{
return true;
}
// if we got this far, deny showing
return false;
}
// Everything seems OK...
return true;
}
public XmlSiteMapResult(
int page,
ISiteMapNode rootNode,
IEnumerable<string> siteMapCacheKeys,
string baseUrl,
string siteMapUrlTemplate,
ISiteMapLoader siteMapLoader,
IUrlPath urlPath,
ICultureContextFactory cultureContextFactory)
{
if (siteMapLoader == null)
throw new ArgumentNullException("siteMapLoader");
if (urlPath == null)
throw new ArgumentNullException("urlPath");
if (cultureContextFactory == null)
throw new ArgumentNullException("cultureContextFactory");
this.Ns = "http://www.sitemaps.org/schemas/sitemap/0.9";
this.Page = page;
this.RootNode = rootNode;
this.SiteMapCacheKeys = siteMapCacheKeys;
this.BaseUrl = baseUrl;
this.SiteMapUrlTemplate = siteMapUrlTemplate;
this.siteMapLoader = siteMapLoader;
this.urlPath = urlPath;
this.cultureContextFactory = cultureContextFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="SiteMapNodeModel"/> class.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="sourceMetadata">The source metadata provided by the HtmlHelper.</param>
/// <param name="maxDepth">The max depth.</param>
/// <param name="drillDownToCurrent">Should the model exceed the maxDepth to reach the current node</param>
/// <param name="startingNodeInChildLevel">Renders startingNode in child level if set to <c>true</c>.</param>
public SiteMapNodeModel(ISiteMapNode node, IDictionary<string, object> sourceMetadata, int maxDepth, bool drillDownToCurrent, bool startingNodeInChildLevel, bool visibilityAffectsDescendants)
{
if (node == null)
throw new ArgumentNullException("node");
if (sourceMetadata == null)
throw new ArgumentNullException("sourceMetadata");
if (maxDepth < 0)
throw new ArgumentOutOfRangeException("maxDepth");
this.node = node;
this.maxDepth = maxDepth;
this.startingNodeInChildLevel = startingNodeInChildLevel;
this.drillDownToCurrent = drillDownToCurrent;
this.SourceMetadata = sourceMetadata;
Key = node.Key;
Area = node.Area;
Controller = node.Controller;
Action = node.Action;
Title = node.Title;
Description = node.Description;
TargetFrame = node.TargetFrame;
ImageUrl = node.ImageUrl;
Url = node.Url;
CanonicalUrl = node.CanonicalUrl;
MetaRobotsContent = node.GetMetaRobotsContentString();
IsCurrentNode = (node == node.SiteMap.CurrentNode);
IsInCurrentPath = node.IsInCurrentPath();
IsRootNode = (node == node.SiteMap.RootNode);
IsClickable = node.Clickable;
VisibilityAffectsDescendants = visibilityAffectsDescendants;
RouteValues = node.RouteValues;
Attributes = node.Attributes;
}
public override IEnumerable<DynamicNode> GetDynamicNodeCollection(ISiteMapNode nodes)
{
var returnValue = new List<DynamicNode>();
// 向BLL層取得選單
foreach (var item in PermissionService.GetMenu())
{
DynamicNode node = new DynamicNode();
// 選單名稱
node.Title = item.Name;
// 有無父類別，沒有的話則傳空字串
node.ParentKey = item.ParentID == 0 ? "" : item.ParentID.ToString();
// 唯一值
node.Key = item.MenuID.ToString();
// MVC的View
node.Action = item.Action;
// MVC的Controller
node.Controller = item.Controller;
// 選單所分配的腳色，逗號分隔
node.Roles = item.Roles.Split(',').Where(c => !string.IsNullOrEmpty(c)).ToList();
//
node.RouteValues.Add("id", item.MenuID);
returnValue.Add(node);
}
// Return
return returnValue;
}
public SiteMapNodeUrlKey(
ISiteMapNode node,
IUrlPath urlPath
)
: base(urlPath)
{
if (node == null)
throw new ArgumentNullException("node");
this.node = node;
// Host name in absolute URL overrides this one.
this.hostName = node.HostName;
// Fixes #322 - If using a custom URL resolver, we need to account for the case that
// the URL will be provided by the resolver instead of specified explicitly.
if (!string.IsNullOrEmpty(node.UnresolvedUrl))
{
this.SetUrlValues(node.UnresolvedUrl);
}
else if (!node.UsesDefaultUrlResolver())
{
// For a custom URL resolver, if the unresolved URL property
// is not set use the one returned from the URL resolver.
// This ensures URLs that are unidentifiable by MVC can still
// be matched by URL.
this.SetUrlValues(node.Url);
}
}
public void Execute(ISiteMapNode node)
{
foreach (var visitor in this.siteMapNodeVisitors)
{
visitor.Execute(node);
}
}
protected virtual void AddDescendantNodes(
ISiteMap siteMap,
ISiteMapNode currentNode,
IList<ISiteMapNodeToParentRelation> sourceNodes,
ILookup<string, ISiteMapNodeToParentRelation> sourceNodesByParent,
HashSet<string> nodesAlreadyAdded)
{
if (sourceNodes.Count == 0)
{
return;
}
var children = sourceNodesByParent[currentNode.Key].OrderBy(x => x.Node.Order).ToArray();
if (children.Count() == 0)
{
return;
}
foreach (var child in children)
{
if (sourceNodes.Count == 0)
{
return;
}
this.AddAndTrackNode(siteMap, child, currentNode, sourceNodes, nodesAlreadyAdded);
if (sourceNodes.Count == 0)
{
return;
}
this.AddDescendantNodes(siteMap, child.Node, sourceNodes, sourceNodesByParent, nodesAlreadyAdded);
}
}
public override IEnumerable<DynamicNode> GetDynamicNodeCollection(ISiteMapNode node)
{
var categories = _unitOfWork.CategoryRepository.Get().ToList();// categoryBuilder.Build();
foreach (var category in categories.Where(i=>i.ParentCategory==null))
{
var dynamicNode = new DynamicNode();
dynamicNode.Title = category.Name;
dynamicNode.Key = category.Id.ToString();
dynamicNode.RouteValues.Add("id",category.Id);
var category1 = category;
foreach (var childCategory in categories.Where(c=>c.ParentCategory==category1))
{
var childDynamicNode = new DynamicNode();
childDynamicNode.Title = childCategory.Name;
childDynamicNode.ParentKey = category.Id.ToString();
childDynamicNode.Key = childCategory.Id.ToString();
childDynamicNode.RouteValues.Add("id",childCategory.Id);
/* foreach (var productItem in productItems.Where(i=>i.CategoryId==childCategory.Id))
{
var productDynamicNode = new DynamicNode();
productDynamicNode.Title = productItem.Name;
productDynamicNode.ParentKey = childCategory.Id;
productDynamicNode.Key = productItem.Id;
productDynamicNode.RouteValues.Add("id", productItem.Id);
yield return productDynamicNode;
}*/
yield return childDynamicNode;
}
yield return dynamicNode;
}
}
protected virtual HttpContextBase CreateHttpContext(ISiteMapNode node, TextWriter writer)
{
var currentHttpContext = this.mvcContextFactory.CreateHttpContext();
// Create a URI with the home page and no query string values.
var uri = new Uri(currentHttpContext.Request.Url, "/");
return this.mvcContextFactory.CreateHttpContext(node, uri, writer);
}
/// <summary>
/// Resolves the URL.
/// </summary>
/// <param name="node">The MVC site map node.</param>
/// <param name="area">The area.</param>
/// <param name="controller">The controller.</param>
/// <param name="action">The action.</param>
/// <param name="routeValues">The route values.</param>
/// <returns>The resolved URL.</returns>
public override string ResolveUrl(ISiteMapNode node, string area, string controller, string action, IDictionary<string, object> routeValues)
{
if (!string.IsNullOrEmpty(node.UnresolvedUrl))
{
return this.ResolveVirtualPath(node);
}
return this.ResolveRouteUrl(node, area, controller, action, routeValues);
}
public override bool IsVisible(ISiteMapNode node, IDictionary<string, object> sourceMetadata)
{
return visability(node, sourceMetadata) & rights(node, sourceMetadata) & module(node, sourceMetadata);
}
public override bool IsVisible(ISiteMapNode node, IDictionary<string, object> sourceMetadata)
{
if (!node.HasChildNodes && !node.Clickable)
{
return false;
}
return true;
}
/// <summary>
/// Determines whether the node is visible.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="sourceMetadata">The source metadata.</param>
/// <returns>
/// <c>true</c> if the specified node is visible; otherwise, <c>false</c>.
/// </returns>
public override bool IsVisible(ISiteMapNode node, IDictionary<string, object> sourceMetadata)
{
// Is a visibility attribute specified?
string visibility = string.Empty;
if (node.Attributes.ContainsKey("visibility"))
{
visibility = node.Attributes["visibility"].GetType().Equals(typeof(string)) ? node.Attributes["visibility"].ToString() : string.Empty;
}
if (string.IsNullOrEmpty(visibility))
{
return true;
}
visibility = visibility.Trim();
string name = string.Empty;
string htmlHelper = string.Empty;
if (sourceMetadata.ContainsKey("name"))
{
name = Convert.ToString(sourceMetadata["name"]);
}
if (sourceMetadata.ContainsKey("HtmlHelper"))
{
htmlHelper = Convert.ToString(sourceMetadata["HtmlHelper"]);
}
// Check for the source HtmlHelper or given name. If neither are configured,
// then always visible.
if (string.IsNullOrEmpty(name) && string.IsNullOrEmpty(htmlHelper))
{
return true;
}
// Chop off the namespace
htmlHelper = htmlHelper.Substring(htmlHelper.LastIndexOf(".") + 1);
// Get the keywords
var visibilityKeywords = visibility.Split(new[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
// All set. Now parse the visibility variable.
foreach (string visibilityKeyword in visibilityKeywords)
{
if (visibilityKeyword == htmlHelper || visibilityKeyword == name || visibilityKeyword == "*")
{
return true;
}
else if (visibilityKeyword == "IfSelected" && node.IsInCurrentPath())
{
return true;
}
else if (visibilityKeyword == "!" + htmlHelper || visibilityKeyword == "!" + name || visibilityKeyword == "!*")
{
return false;
}
}
// Still nothing? Then it's OK!
return true;
}
/// <summary>
/// Adds the dynamic nodes for node.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="parentNode">The parent node.</param>
public IEnumerable<ISiteMapNode> BuildDynamicNodesFor(ISiteMap siteMap, ISiteMapNode node, ISiteMapNode parentNode)
{
// List of dynamic nodes that have been created
var createdDynamicNodes = new List<ISiteMapNode>();
if (!node.HasDynamicNodeProvider)
{
return createdDynamicNodes;
}
// Build dynamic nodes
foreach (var dynamicNode in node.GetDynamicNodeCollection())
{
string key = dynamicNode.Key;
if (string.IsNullOrEmpty(key))
{
key = nodeKeyGenerator.GenerateKey(
parentNode == null ? "" : parentNode.Key,
Guid.NewGuid().ToString(),
node.Url,
node.Title,
node.Area,
node.Controller,
node.Action,
node.HttpMethod,
node.Clickable);
}
// Create a new node
var newNode = siteMapNodeFactory.CreateDynamic(siteMap, key, node.ResourceKey);
// Copy the values from the original node to the new one
node.CopyTo(newNode);
// Copy any values that were set in the dynamic node and overwrite the new node.
dynamicNode.SafeCopyTo(newNode);
// If the dynamic node has a parent key set, use that as the parent. Otherwise use the parentNode.
if (!string.IsNullOrEmpty(dynamicNode.ParentKey))
{
var parent = siteMap.FindSiteMapNodeFromKey(dynamicNode.ParentKey);
if (parent != null)
{
siteMap.AddNode(newNode, parent);
createdDynamicNodes.Add(newNode);
}
}
else
{
siteMap.AddNode(newNode, parentNode);
createdDynamicNodes.Add(newNode);
}
}
// Done!
return createdDynamicNodes;
}
public ISiteMapNode BuildSiteMap(ISiteMap siteMap, ISiteMapNode rootNode)
{
ISiteMapNode result = rootNode;
foreach (var builder in this.siteMapBuilders)
{
result = builder.BuildSiteMap(siteMap, result);
}
return result;
}
/// <summary>
/// Gets the dynamic nodes for node.
/// </summary>
/// <param name="node">The SiteMap node.</param>
/// <param name="defaultParentKey">The key of the parent node.</param>
public virtual IEnumerable<ISiteMapNodeToParentRelation> BuildDynamicNodes(ISiteMapNode node, string defaultParentKey)
{
var result = new List<ISiteMapNodeToParentRelation>();
if (!node.HasDynamicNodeProvider)
{
return result;
}
// Get the dynamic nodes using the request's culture context.
// NOTE: In version 5, we need to use the invariant context and pass a reference to it
// into the dynamic node provider. This would be a breaking change, so for now we are
// swapping the context back to the state of the current request. This way, the end user
// still can opt to change to invariant culture, but in the reverse situation there would
// be no way to identify the culture of the current request without a reference to the
// cultureContext object.
IEnumerable<DynamicNode> dynamicNodes;
using (var originalCultureContext = this.cultureContextFactory.Create(this.cultureContext.OriginalCulture, this.cultureContext.OriginalUICulture))
{
dynamicNodes = node.GetDynamicNodeCollection();
}
// Build dynamic nodes
foreach (var dynamicNode in dynamicNodes)
{
// If the dynamic node has a parent key set, use that as the parent. Otherwise use the parentNode.
var parentKey = !string.IsNullOrEmpty(dynamicNode.ParentKey) ? dynamicNode.ParentKey : defaultParentKey;
var key = dynamicNode.Key;
if (string.IsNullOrEmpty(key))
{
key = this.siteMapNodeCreator.GenerateSiteMapNodeKey(
parentKey,
Guid.NewGuid().ToString(),
node.Url,
node.Title,
node.Area,
node.Controller,
node.Action,
node.HttpMethod,
node.Clickable);
}
// Create a new node
var nodeParentMap = this.siteMapNodeCreator.CreateDynamicSiteMapNode(key, parentKey, node.DynamicNodeProvider, node.ResourceKey);
var newNode = nodeParentMap.Node;
// Copy the values from the original node to the new one
node.CopyTo(newNode);
// Copy any values that were set in the dynamic node and overwrite the new node.
dynamicNode.SafeCopyTo(newNode);
result.Add(nodeParentMap);
}
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="SiteMapHttpContext"/> class.
/// </summary>
/// <param name="httpContext">The object that this wrapper class provides access to.</param>
/// <param name="node">The site map node to fake node access context for or <c>null</c>.</param>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="httpContext"/> is null.
/// </exception>
public SiteMapHttpContext(HttpContext httpContext, ISiteMapNode node, Uri uri)
: base(httpContext)
{
this.httpContext = httpContext;
this.node = node;
if(node != null) {
nodeUri = uri ?? new Uri(HttpContext.Current.Request.Url, node.Url);
}
}
protected virtual string ResolveVirtualPath(ISiteMapNode node)
{
var url = node.UnresolvedUrl;
if (!urlPath.IsAbsoluteUrl(url))
{
return urlPath.MakeVirtualPathAppAbsolute(urlPath.Combine(urlPath.AppDomainAppVirtualPath, url));
}
return url;
}
/// <summary>
/// Initializes a new instance of the <see cref="SiteMapHttpRequest"/> class.
/// </summary>
/// <param name="httpRequest">The object that this wrapper class provides access to.</param>
/// <param name="node">The site map node to fake node access context for or <c>null</c>.</param>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="httpRequest"/> is null.
/// </exception>
public SiteMapHttpRequest(HttpRequest httpRequest, ISiteMapNode node, RequestContext requestContext, Uri nodeUri)
: base(httpRequest, requestContext)
{
this.node = node;
this.currentRequest = new HttpRequest(
filename: string.Empty,
url: nodeUri.ToString(),
queryString: string.IsNullOrEmpty(nodeUri.Query) ? string.Empty : nodeUri.Query.Substring(1));
}
/// <summary>
/// Adds the MvcCodeRouting.RouteContext DataToken necessary for interoperability
/// with the MvcCodeRouting library https://github.com/maxtoroq/MvcCodeRouting
/// </summary>
/// <param name="routeData">The route data.</param>
/// <param name="node">The current site map node.</param>
internal static void SetMvcCodeRoutingContext(this RouteData routeData, ISiteMapNode node)
{
if (routeData == null)
return;
var controllerType = node.SiteMap.ResolveControllerType(node.Area, node.Controller);
var mvcCodeRoutingRouteContext = GetMvcCodeRoutingRouteContext(controllerType, node.Controller);
routeData.DataTokens["MvcCodeRouting.RouteContext"] = mvcCodeRoutingRouteContext;
}
/// <summary>
/// Determines whether the node is visible.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="sourceMetadata">The source metadata.</param>
/// <returns>
/// <c>true</c> if the specified node is visible; otherwise, <c>false</c>.
/// </returns>
public override bool IsVisible(ISiteMapNode node, IDictionary<string, object> sourceMetadata)
{
// Convert to MvcSiteMapNode
var mvcNode = node as MvcSiteMapProvider.SiteMapNode;
if (mvcNode != null)
{
var menu = String.Empty;
if (sourceMetadata != null && sourceMetadata.ContainsKey("name"))
menu = sourceMetadata["name"].ToString();
// Is a visibility attribute specified?
var visibility = GetValue(mvcNode, "visibility");
if (mvcNode.Attributes.ContainsKey("permissions"))
{
if (!CustomerSession.IsRegistered)
return false;
var allPermissions =
GetValue(mvcNode, "permissions").Split(',').Select(x => new Permission {PermissionId = x});
if (
allPermissions.Any(
permission => !SecurityService.CheckMemberPermission(StoreHelper.CustomerSession.CustomerId, permission)))
{
return false;
}
}
if (!string.IsNullOrEmpty(visibility))
{
visibility = visibility.Trim();
// All set. Now parse the visibility variable.
if (visibility.Split(new[] {',', ';'})
.TakeWhile(visibilityKeyword => visibilityKeyword != menu && visibilityKeyword != "*")
.Any(visibilityKeyword => visibilityKeyword == "!" + menu || visibilityKeyword == "!*"))
{
return false;
}
}
var stores = GetValue(mvcNode, "stores");
if (!string.IsNullOrEmpty(stores))
{
if(!stores.Trim().Split(new[] {',', ';'}, StringSplitOptions.RemoveEmptyEntries)
.Any(store => store.Equals(CustomerSession.StoreId, StringComparison.OrdinalIgnoreCase)))
{
return false;
}
}
}
// Still nothing? Then it's OK!
return true;
}
public virtual ISiteMapNode BuildSiteMap(ISiteMap siteMap, ISiteMapNode rootNode)
{
if (rootNode == null)
{
throw new ArgumentNullException("rootNode", Resources.Messages.VisitingSiteMapBuilderRequiresRootNode);
}
VisitNodes(rootNode);
return rootNode;
}
public override IEnumerable<DynamicNode> GetDynamicNodeCollection(ISiteMapNode node)
{
var result = new List<DynamicNode>();
result.Add(new DynamicNode()
{
ParentKey = "Org",
Title = node.Title
});
return result;
}
public override IEnumerable<DynamicNode> GetDynamicNodeCollection(ISiteMapNode node)
{
return new List<DynamicNode>
{
new DynamicNode
{
Action = "DisplayItem",
PreservedRouteParameters = new[] {Constants.Language, Constants.Store, Constants.Category, Constants.Item},
}
};
}
/// <summary>
/// Gets the dynamic node collection.
/// </summary>
/// <param name="node">The current node.</param>
/// <returns>
/// A dynamic node collection represented as a <see cref="IEnumerable<MvcSiteMapProvider.Extensibility.DynamicNode>"/> instance
/// </returns>
public override IEnumerable<DynamicNode> GetDynamicNodeCollection(ISiteMapNode node)
{
// Create a node for each genre
foreach (var genre in storeDB.Genres)
{
DynamicNode dynamicNode = new DynamicNode("Genre_" + genre.Name, genre.Name);
dynamicNode.RouteValues.Add("genre", genre.Name);
yield return dynamicNode;
}
}
public override bool IsVisible(ISiteMapNode node, IDictionary<string, object> sourceMetadata)
{
// Optimization - return quickly if clickable.
if (node.Clickable)
{
return true;
}
var childNodes = node.ChildNodes;
return childNodes == null || childNodes.Any(c => c.IsVisible(sourceMetadata));
}
public virtual ISiteMapNode BuildSiteMap(ISiteMap siteMap, ISiteMapNode rootNode)
{
var xml = xmlSource.GetXml();
if (xml != null)
{
rootNode = LoadSiteMapFromXml(siteMap, xml);
}
// Done!
return rootNode;
}
public override IEnumerable<DynamicNode> GetDynamicNodeCollection(ISiteMapNode node)
{
var Departments = DepartmentGetter.GetDepartments();
foreach (Department dep in Departments)
{
DynamicNode dynamicNode = new DynamicNode { Title = dep.Name };
dynamicNode.RouteValues.Add("acronym", dep.Acronym);
yield return dynamicNode;
}
}
protected virtual void AddAndTrackNode(
ISiteMap siteMap,
ISiteMapNodeToParentRelation nodeParentMap,
ISiteMapNode parentNode,
IList<ISiteMapNodeToParentRelation> sourceNodes,
HashSet<string> nodesAlreadyAdded)
{
siteMap.AddNode(nodeParentMap.Node, parentNode);
nodesAlreadyAdded.Add(nodeParentMap.Node.Key);
sourceNodes.Remove(nodeParentMap);
}
/// <summary>
/// Determines whether node is accessible to user.
/// </summary>
/// <param name="siteMap">The site map.</param>
/// <param name="node">The node.</param>
/// <returns>
/// <c>true</c> if accessible to user; otherwise, <c>false</c>.
/// </returns>
public virtual bool IsAccessibleToUser(ISiteMap siteMap, ISiteMapNode node)
{
foreach (var module in aclModules)
{
var authorized = module.IsAccessibleToUser(siteMap, node);
if (authorized == false)
return false;
}
// Convention throughout the provider: if the IAclModule can not authenticate a user, true is returned.
return true;
}
public ISiteMapNodeCollection GetChildNodes(ISiteMapNode node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
ISiteMapNodeCollection collection = null;
if (this.childNodeCollectionTable.ContainsKey(node))
{
collection = this.childNodeCollectionTable[node];
}
if (collection == null)
{
ISiteMapNode keyNode = null;
if (this.keyTable.ContainsKey(node.Key))
{
keyNode = this.keyTable[node.Key];
}
if (keyNode != null && this.childNodeCollectionTable.ContainsKey(keyNode))
{
collection = this.childNodeCollectionTable[keyNode];
}
}
if (collection == null)
{
return(new FakeSiteMapNodeCollection());
}
if (!this.SecurityTrimmingEnabled)
{
return(new FakeSiteMapNodeCollection(collection));
}
var secureCollection = new FakeSiteMapNodeCollection();
foreach (ISiteMapNode secureNode in collection)
{
if (secureNode.IsAccessibleToUser())
{
secureCollection.Add(secureNode);
}
}
return(secureCollection);
}
/// <summary>
/// Retrieves a Boolean value indicating whether the specified <see cref="T:MvcSiteMapProvider.SiteMapNode"/> object can be viewed by the user in the specified context.
/// </summary>
/// <param name="node">The <see cref="T:MvcSiteMapProvider.SiteMapNode"/> that is requested by the user.</param>
/// <returns>
/// true if security trimming is enabled and <paramref name="node"/> can be viewed by the user or security trimming is not enabled; otherwise, false.
/// </returns>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="node"/> is null.
/// </exception>
public virtual bool IsAccessibleToUser(ISiteMapNode node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
// If the sitemap is still being constructed, always
// make all nodes accessible regardless of security trimming.
if (!IsReadOnly)
{
return(true);
}
if (!SecurityTrimmingEnabled)
{
return(true);
}
return(pluginProvider.AclModule.IsAccessibleToUser(this, node));
}
public override IEnumerable <DynamicNode> GetDynamicNodeCollection(ISiteMapNode node)
{
var filmsDN = new List <DynamicNode>();
foreach (var film in db.Films)
{
DynamicNode dn = new DynamicNode()
{
Title = film.Title,
Key = "Film_" + film.FilmId,
ParentKey = "Category_" + film.CategoryId
};
dn.RouteValues.Add("id", film.FilmId);
filmsDN.Add(dn);
}
return(filmsDN);
}
protected virtual bool VerifyNode(ISiteMap siteMap, ISiteMapNode node, HttpContextBase httpContext)
{
var routes = this.FindRoutesForNode(node, httpContext);
if (routes == null)
{
return(true); // Static URLs will sometimes have no route data, therefore return true.
}
// Time to delve into the AuthorizeAttribute defined on the node.
// Let's start by getting all metadata for the controller...
var controllerType = siteMap.ResolveControllerType(routes.GetAreaName(), routes.GetOptionalString("controller"));
if (controllerType == null)
{
return(true);
}
return(this.VerifyController(node, routes, controllerType));
}
/// <summary>
/// Generates flat list of SiteMapNode from SiteMap hierarchy.
/// </summary>
/// <param name="startingNode">The starting node.</param>
/// <param name="url">The URL.</param>
/// <returns>A flat list of SiteMapNode.</returns>
protected virtual IEnumerable <ISiteMapNode> FlattenHierarchy(ISiteMapNode startingNode, string url)
{
// Mvc node
var mvcNode = startingNode;
// Render current node?
if (mvcNode == null || mvcNode.Clickable)
{
yield return(startingNode);
}
if (startingNode.HasChildNodes)
{
// Make sure all child nodes are accessible prior to rendering them...
var shouldRender = true;
foreach (ISiteMapNode node in startingNode.ChildNodes)
{
// Check visibility
if (node != null)
{
shouldRender = node.IsVisible(SourceMetadata);
}
// Check ACL
if (!node.IsAccessibleToUser())
{
shouldRender = false;
break;
}
// Render child nodes?
if (shouldRender)
{
if (node.IsAccessibleToUser())
{
foreach (var childNode in FlattenHierarchy(node, url))
{
yield return(childNode);
}
}
}
}
}
}
protected virtual RequestContext CreateRequestContext(ISiteMapNode node, TextWriter writer)
{
var realRequestContext = this.mvcContextFactory.CreateRequestContext();
// For interop with MvcCodeRouting, we need to build a data token with the appropriate value.
realRequestContext.RouteData.SetMvcCodeRoutingContext(node);
if (!node.IncludeAmbientValuesInUrl)
{
var httpContext = this.CreateHttpContext(node, writer);
var fakeRequestContext = this.mvcContextFactory.CreateRequestContext(httpContext);
fakeRequestContext.RouteData.MergeDataTokens(realRequestContext.RouteData.DataTokens);
fakeRequestContext.RouteData.Route = realRequestContext.RouteData.Route;
fakeRequestContext.RouteData.RouteHandler = realRequestContext.RouteData.RouteHandler;
return(fakeRequestContext);
}
return(realRequestContext);
}
public override IEnumerable <DynamicNode> GetDynamicNodeCollection(ISiteMapNode node)
{
// BlogEntities would be your entity framework context class
// or repository.
using (var entities = new BlogEntities())
{
// Create a node for each blog
foreach (var blogPost in entities.Blog)
{
DynamicNode dynamicNode = new DynamicNode();
dynamicNode.Title = blogPost.Title;
dynamicNode.ParentKey = "Blog";
dynamicNode.Key = "BlogPost_" + blogPost.Id;
dynamicNode.RouteValues.Add("id", blogPost.Id);
dynamicNode.RouteValues.Add("seoName", blogPost.SeoName);
yield return(dynamicNode);
}
}
}
public override IEnumerable <DynamicNode> GetDynamicNodeCollection(ISiteMapNode nodes)
{
var returnValue = new List <DynamicNode>();
using (EPSContext context = new EPSContext())
{
var LoginUserID = HttpContext.Current.Session["UserID"].ToString();
int UserRole = Convert.ToInt32(HttpContext.Current.Session["UserRole"].ToString());
var query = from rm in context.ROLEFUNCMAPPINGS
where rm.RId == UserRole
join f in context.FUNCS on rm.FId equals f.FId into memu
from x in memu.DefaultIfEmpty()
select new
{
PId = x.PId,
FId = x.FId,
FuncName = x.FuncName,
Controller = x.Controller,
Action = x.Action,
Url = x.Url,
ShowOrder = x.ShowOrder
};
var SysMenus = query.OrderBy(c => c.ShowOrder).ToList();
foreach (var menu in SysMenus)
{
DynamicNode Node = new DynamicNode()
{
Title = menu.FuncName,
ParentKey = menu.PId > 0 ? menu.PId.ToString():"",
Key = menu.FId.ToString(),
Controller = menu.Controller,
Action = menu.Action,
Url = menu.Url
};
returnValue.Add(Node);
}
}
return(returnValue);
}
public override IEnumerable <DynamicNode> GetDynamicNodeCollection(ISiteMapNode node)
{
foreach (var server in serverManager.Servers.Values)
{
IList <SenkaData> playerList = server.GetFullPlayerList();
foreach (var player in playerList)
{
DynamicNode dynamicNode = new DynamicNode();
dynamicNode.Title = player.PlayerName;
dynamicNode.Description = string.Format("{0} ({1})の戦果データ。", player.PlayerName, server.Name);
dynamicNode.ChangeFrequency = ChangeFrequency.Daily;
dynamicNode.UpdatePriority = UpdatePriority.Absolute_040; //Below Normal
dynamicNode.RouteValues.Add("playerID", player.PlayerID);
dynamicNode.ParentKey = "Server" + server.ID.ToString();
yield return(dynamicNode);
}
}
}
private void ProcessTreeNodes(ISiteMap siteMap, ISiteMapNode rootNode, SiteMapPageTree tree)
{
var parentNode = rootNode;
foreach (var page in tree.ChildPages)
{
var childNode = GetSiteMapNodeFromTreeNode(siteMap, page);
siteMap.AddNode(childNode, parentNode);
// Process next level
ProcessTreeNodes(siteMap, childNode, page);
}
foreach (var product in tree.Products)
{
var productNode = GetSiteMapNodeFromProductInfo(siteMap, product);
siteMap.AddNode(productNode, parentNode);
}
}
public virtual HttpContextBase CreateHttpContext(ISiteMapNode node, Uri uri, TextWriter writer)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (writer == null)
{
throw new ArgumentNullException("writer");
}
var request = new HttpRequest(
filename: string.Empty,
url: uri.ToString(),
queryString: string.IsNullOrEmpty(uri.Query) ? string.Empty : uri.Query.Substring(1));
var response = new HttpResponse(writer);
var httpContext = new HttpContext(request, response);
return(new SiteMapHttpContext(httpContext, node, uri));
}
protected virtual string ResolveRouteUrl(ISiteMapNode node, string area, string controller, string action, IDictionary <string, object> routeValues)
{
string result = string.Empty;
// Create a TextWriter with null stream as a backing stream
// which doesn't consume resources
using (var nullWriter = new StreamWriter(Stream.Null))
{
var requestContext = this.CreateRequestContext(node, nullWriter);
result = this.ResolveRouteUrl(node, area, controller, action, routeValues, requestContext);
}
if (string.IsNullOrEmpty(result))
{
// fixes #115 - UrlResolver should not throw exception.
result = "#";
}
return(result);
}
public virtual void RemoveNode(ISiteMapNode node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
lock (this.synclock)
{
// Remove the parent node relationship
ISiteMapNode parentNode = null;
if (this.parentNodeTable.ContainsKey(node))
{
parentNode = this.parentNodeTable[node];
this.parentNodeTable.Remove(node);
}
// Remove the child node relationship
if (parentNode != null)
{
var nodes = this.childNodeCollectionTable[parentNode];
if ((nodes != null) && nodes.Contains(node))
{
nodes.Remove(node);
}
}
// Remove the URL
var url = this.siteMapChildStateFactory.CreateUrlKey(node);
if (this.urlTable.ContainsKey(url))
{
this.urlTable.Remove(url);
}
// Remove the key
string key = node.Key;
if (this.keyTable.ContainsKey(key))
{
this.keyTable.Remove(key);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SiteMapNodeModel"/> class.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="sourceMetadata">The source metadata provided by the HtmlHelper.</param>
/// <param name="maxDepth">The max depth.</param>
/// <param name="drillDownToCurrent">Should the model exceed the maxDepth to reach the current node</param>
/// <param name="startingNodeInChildLevel">Renders startingNode in child level if set to <c>true</c>.</param>
public SiteMapNodeModel(ISiteMapNode node, IDictionary <string, object> sourceMetadata, int maxDepth, bool drillDownToCurrent, bool startingNodeInChildLevel, bool visibilityAffectsDescendants)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (sourceMetadata == null)
{
throw new ArgumentNullException("sourceMetadata");
}
if (maxDepth < 0)
{
throw new ArgumentOutOfRangeException("maxDepth");
}
this.node = node;
this.maxDepth = maxDepth;
this.startingNodeInChildLevel = startingNodeInChildLevel;
this.drillDownToCurrent = drillDownToCurrent;
this.SourceMetadata = sourceMetadata;
Key = node.Key;
Area = node.Area;
Controller = node.Controller;
Action = node.Action;
Title = node.Title;
Description = node.Description;
TargetFrame = node.TargetFrame;
ImageUrl = node.ImageUrl;
Url = node.Url;
CanonicalUrl = node.CanonicalUrl;
MetaRobotsContent = node.GetMetaRobotsContentString();
IsCurrentNode = (node.Equals(node.SiteMap.CurrentNode));
IsInCurrentPath = node.IsInCurrentPath();
IsRootNode = (node.Equals(node.SiteMap.RootNode));
IsClickable = node.Clickable;
VisibilityAffectsDescendants = visibilityAffectsDescendants;
RouteValues = node.RouteValues;
Attributes = node.Attributes;
Order = node.Order;
}
/// <summary>
///
/// </summary>
/// <param name="helper"></param>
/// <param name="siteMapPermission"></param>
/// <param name="maxLevel"></param>
/// <returns></returns>
public static IList <MainMenu> GetUserMenus(this HtmlHelper helper,
SiteMapPermission siteMapPermission, int maxLevel)
{
ISiteMapNode node = helper.MvcSiteMap().SiteMap.RootNode;
var result = new List <MainMenu>();
for (int i = 0; i < node.ChildNodes.Count; i++)
{
ISiteMapNode childNode = node.ChildNodes[i];
if (Match(siteMapPermission, childNode))
{
var mainMenu = new MainMenu
{
Current = childNode,
};
SubMenuMatch(helper, siteMapPermission, mainMenu, maxLevel, 0);
result.Add(mainMenu);
}
}
return(result);
}
public override IEnumerable <DynamicNode> GetDynamicNodeCollection(ISiteMapNode node)
{
//throw new NotImplementedException();
var filmsDN = new List <DynamicNode>();
foreach (var film in db.Films)
{
DynamicNode dn = new DynamicNode()
{
Title = film.Title,
Key = "Film_" + film.FilmID,
ParentKey = "Category_" + film.CategoryID
};
dn.RouteValues.Add("id", film.FilmID); //nazwa arg i jej wartosc
filmsDN.Add(dn);
}
return(filmsDN);
}
public override bool IsAccessibleToUser(ISiteMapNode node)
{
var key = this.GetCacheKey("IsAccessibleToUser_" + node.Key);
var result = this.requestCache.GetValue <bool?>(key);
if (result == null)
{
// Fix for #272 - Change the context of the URL cache to ensure
// that the AclModule doesn't prevent manually setting route values
// from having any effect on the URL. This setting takes effect in
// the RequestCacheableSiteMapNode.Url property.
var urlContextKey = this.GetUrlContextKey();
this.requestCache.SetValue <string>(urlContextKey, "AclModule");
result = base.IsAccessibleToUser(node);
this.requestCache.SetValue <bool>(key, (bool)result);
// Restore the URL context.
this.requestCache.SetValue <string>(urlContextKey, string.Empty);
}
return((bool)result);
}
public virtual HttpContextBase CreateHttpContext(ISiteMapNode node, Uri uri, TextWriter writer)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (writer == null)
{
throw new ArgumentNullException("writer");
}
var request = new HttpRequest(string.Empty, uri.ToString(), uri.Query);
var response = new HttpResponse(writer);
var httpContext = new HttpContext(request, response);
return(new SiteMapHttpContext(httpContext, node));
}
protected virtual RouteData FindRoutesForNode(ISiteMapNode node, HttpContextBase httpContext)
{
RouteData routeData = null;
// Create a Uri for the current node. If we have an absolute URL,
// it will be used instead of the baseUri.
var nodeUri = new Uri(httpContext.Request.Url, node.Url);
// Create a TextWriter with null stream as a backing stream
// which doesn't consume resources
using (var nullWriter = new StreamWriter(Stream.Null))
{
// Create a new HTTP context using the node's URL instead of the current one.
var nodeHttpContext = this.mvcContextFactory.CreateHttpContext(node, nodeUri, nullWriter);
// Find routes for the sitemap node's URL using the new HTTP context
routeData = node.GetRouteData(nodeHttpContext);
}
return(routeData);
}
public XmlSiteMapResult(
int page,
ISiteMapNode rootNode,
IEnumerable <string> siteMapCacheKeys,
string baseUrl,
string siteMapUrlTemplate,
ISiteMapLoader siteMapLoader)
{
if (siteMapLoader == null)
{
throw new ArgumentNullException("siteMapLoader");
}
this.Ns = "http://www.sitemaps.org/schemas/sitemap/0.9";
this.Page = page;
this.RootNode = rootNode;
this.SiteMapCacheKeys = siteMapCacheKeys;
this.BaseUrl = baseUrl;
this.SiteMapUrlTemplate = siteMapUrlTemplate;
this.siteMapLoader = siteMapLoader;
}
/// <summary>
/// Determines whether the node is visible.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="sourceMetadata">The source metadata.</param>
/// <returns>
/// <c>true</c> if the specified node is visible; otherwise, <c>false</c>.
/// </returns>
public override bool IsVisible(ISiteMapNode node, IDictionary <string, object> sourceMetadata)
{
// Is a visibility attribute specified?
string visibility = string.Empty;
if (node.Attributes.ContainsKey("visibility"))
{
visibility = node.Attributes["visibility"].GetType().Equals(typeof(string)) ? node.Attributes["visibility"].ToString() : string.Empty;
}
if (string.IsNullOrEmpty(visibility))
{
return(true);
}
visibility = visibility.Trim();
// Check for the source HtmlHelper
if (sourceMetadata["HtmlHelper"] == null)
{
return(true);
}
string htmlHelper = sourceMetadata["HtmlHelper"].ToString();
htmlHelper = htmlHelper.Substring(htmlHelper.LastIndexOf(".") + 1);
// All set. Now parse the visibility variable.
foreach (string visibilityKeyword in visibility.Split(new[] { ',', ';' }))
{
if (visibilityKeyword == htmlHelper || visibilityKeyword == "*")
{
return(true);
}
else if (visibilityKeyword == "!" + htmlHelper || visibilityKeyword == "!*")
{
return(false);
}
}
// Still nothing? Then it's OK!
return(true);
}
/// <summary>
/// Determines whether the node is visible.
/// </summary>
/// <param name="node">The node.</param>
/// <param name="sourceMetadata">The source metadata.</param>
/// <returns>
/// <c>true</c> if the specified node is visible; otherwise, <c>false</c>.
/// </returns>
/// <exception cref="System.ArgumentNullException">node</exception>
public bool IsVisible(ISiteMapNode node, IDictionary <string, object> sourceMetadata)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
sessionStateProvider = new SessionStateProvider();
session = new SessionStateService(sessionStateProvider);
//TODO: Uncomment below before deployment to prod.
var isUserLoggedIn = (session.GetSessionValue(SessionKey.UserIsAuthenticated) ?? "").ToString().AsBoolean();
if (!isUserLoggedIn && (node.Title != "Home"))
{
return(false);
}
IRoleCollection roles = node.Roles;
//if no role is associated to node - allow it to show
if (!roles.Any())
{
return(true);
}
var roleCollection = ((string[])session.GetSessionValue(SessionKey.UserRoles) ?? new[] { "" }).ToList();
var roleCollectionToUpper = roleCollection.Select(role => role.ToUpper()).ToList();
var isGranted = false;
foreach (var role in roles)
{
isGranted = roleCollectionToUpper.Contains(role.ToUpper());
if (isGranted)
{
break;
}
}
return(isGranted);
}
/// <summary>
/// Finds the controller action node.
/// </summary>
/// <param name="rootNode">The root node.</param>
/// <param name="values">The values.</param>
/// <param name="route">The route.</param>
/// <returns>
/// A controller action node represented as a <see cref="SiteMapNode"/> instance
/// </returns>
protected virtual ISiteMapNode FindSiteMapNodeFromControllerAction(ISiteMapNode rootNode, IDictionary <string, object> values, RouteBase route)
{
if (rootNode != null)
{
// Get all child nodes
var childNodes = GetChildNodes(rootNode);
var routes = mvcContextFactory.GetRoutes();
// Search current level
foreach (ISiteMapNode node in childNodes)
{
// Look at the route property
if (!string.IsNullOrEmpty(node.Route))
{
if (routes[node.Route] == route)
{
// This looks a bit weird, but if i set up a node to a general route ie /Controller/Action/ID
// I need to check that the values are the same so that it doesn't swallow all of the nodes that also use that same general route
if (node.MatchesRoute(values))
{
return(node);
}
}
}
else if (node.MatchesRoute(values))
{
return(node);
}
// Search next level
var siteMapNode = FindSiteMapNodeFromControllerAction(node, values, route);
if (siteMapNode != null)
{
return(siteMapNode);
}
}
}
return(null);
}
//przeciążenie metody
public override IEnumerable <DynamicNode> GetDynamicNodeCollection(ISiteMapNode nodee)
{
//deklaracja zmniennej
var returnValue = new List <DynamicNode>();
//do listy dodaję produkty iteruję po wszystkich produktach
//pobieram wszystkie produkty
foreach (Kategoria kategoria in db.Kategorie)
{ //Dla każdego produktu tworzę DynamicNodeProvider(deklaruję dynamicnodeprovider)
DynamicNode node = new DynamicNode();
//ustawiamy mu wartość Title nazwę produktu
node.Title = kategoria.nazwa_kat;
//ustawiam klucz dla noda
node.Key = "Kategoria_" + kategoria.id_kategoria;
node.RouteValues.Add("nazwaKategori", kategoria.nazwa_kat);
//przekazanie node do listy
returnValue.Add(node);
}
//generuje dynamicznie linki (na koniec zwracam liste)
return(returnValue);
}
public override IEnumerable <DynamicNode> GetDynamicNodeCollection(ISiteMapNode node)
{
foreach (var server in serverManager.Servers.Values)
{
DynamicNode dynamicNode = new DynamicNode();
if (server.Enabled)
{
dynamicNode.Description = string.Format("「{0}」の最新の戦果ランキングです。", server.Name);
}
else
{
dynamicNode.Description = "このサーバの情報今はありません。";
}
dynamicNode.Title = "ランキング";
dynamicNode.ChangeFrequency = ChangeFrequency.Hourly;
dynamicNode.UpdatePriority = UpdatePriority.High;
dynamicNode.RouteValues.Add("serverID", server.ID);
dynamicNode.ParentKey = "Server" + server.ID.ToString();
yield return(dynamicNode);
}
}
protected virtual bool VerifyController(ISiteMapNode node, RouteData routes, Type controllerType)
{
// Get controller factory
var controllerFactory = controllerBuilder.GetControllerFactory();
// Create controller context
bool factoryBuiltController = false;
var controllerContext = this.CreateControllerContext(node, routes, controllerType, controllerFactory, out factoryBuiltController);
try
{
return(this.VerifyControllerAttributes(routes, controllerType, controllerContext));
}
finally
{
// Release controller
if (factoryBuiltController)
{
controllerFactory.ReleaseController(controllerContext.Controller);
}
}
}
/// <summary>
/// Resolves the URL.
/// </summary>
/// <param name="node">The MVC site map node.</param>
/// <param name="area">The area.</param>
/// <param name="controller">The controller.</param>
/// <param name="action">The action.</param>
/// <param name="routeValues">The route values.</param>
/// <returns>The resolved URL.</returns>
public override string ResolveUrl(ISiteMapNode node, string area, string controller, string action, IDictionary <string, object> routeValues)
{
if (!String.IsNullOrEmpty(node.UnresolvedUrl))
{
if (node.UnresolvedUrl.StartsWith("~"))
{
return(VirtualPathUtility.ToAbsolute(node.UnresolvedUrl));
}
else
{
return(node.UnresolvedUrl);
}
}
var urlHelper = mvcContextFactory.CreateUrlHelper();
string returnValue;
var routeValueDictionary = new RouteValueDictionary(routeValues);
if (!string.IsNullOrEmpty(node.Route))
{
routeValueDictionary.Remove("route");
returnValue = urlHelper.RouteUrl(node.Route, routeValueDictionary);
}
else
{
returnValue = urlHelper.Action(action, controller, routeValueDictionary);
}
if (string.IsNullOrEmpty(returnValue))
{
// fixes #115 - UrlResolver should not throw exception.
return(VirtualPathUtility.ToAbsolute("~/") + Guid.NewGuid().ToString());
}
else
{
return(returnValue);
}
}
public void AddNode(ISiteMapNode node, ISiteMapNode parentNode)
{
// Avoid issue with url table not clearing correctly.
if (this.FindSiteMapNode(node.Url) != null)
{
this.RemoveNode(node);
}
// Add the node
try
{
AddNodeInternal(node, parentNode);
}
catch
{
if (parentNode != null)
{
this.RemoveNode(parentNode);
}
AddNodeInternal(node, parentNode);
}
}
/// <summary>
/// Ensures all routedata elements are included on the node whenever the mvc action is invoked.
/// This allows the MVC site map to have route values preserved for breadcrumb trails.
/// </summary>
/// <param name="filterContext">The current filter context.</param>
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
ISiteMapNode node = null;
var siteMap = SiteMaps.Current;
if (Target != AttributeTarget.ParentNode)
{
node = siteMap.CurrentNode;
}
else
{
node = siteMap.CurrentNode.ParentNode;
}
if (node != null)
{
foreach (var routeitem in filterContext.RouteData.Values)
{
node.RouteValues[routeitem.Key] = routeitem.Value;
}
}
}
/// <summary>
/// Generates flat list of SiteMapNode from SiteMap hierarchy.
/// </summary>
/// <param name="startingNode">The starting node.</param>
/// <param name="context">The controller context.</param>
/// <param name="visibilityAffectsDescendants">A boolean indicating whether visibility of the current node should affect the visibility of descendant nodes.</param>
/// <returns>A flat list of SiteMapNode.</returns>
protected virtual IEnumerable <ISiteMapNode> FlattenHierarchy(ISiteMapNode startingNode, ControllerContext context, bool visibilityAffectsDescendants)
{
// Inaccessible - don't process current node or any descendant nodes.
if (startingNode.IsAccessibleToUser() && (visibilityAffectsDescendants ? startingNode.IsVisible(SourceMetadata) : true))
{
if (this.ShouldNodeRender(startingNode, context))
{
yield return(startingNode);
}
if (startingNode.HasChildNodes)
{
// Make sure all child nodes are accessible prior to rendering them...
foreach (ISiteMapNode node in startingNode.ChildNodes)
{
foreach (var childNode in FlattenHierarchy(node, context, visibilityAffectsDescendants))
{
yield return(childNode);
}
}
}
}
}
