/// <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 virtual string GenerateKey() { var context = mvcContextFactory.CreateHttpContext(); var builder = new StringBuilder(); builder.Append("sitemap://"); builder.Append(context.Request.Url.DnsSafeHost); builder.Append("/"); return(builder.ToString()); }
protected virtual string GetImplicitResourceString(string attributeName, string implicitResourceKey, string classKey) { if (attributeName == null) { throw new ArgumentNullException("attributeName"); } string globalResourceObject = null; if (!string.IsNullOrEmpty(implicitResourceKey)) { var httpContext = mvcContextFactory.CreateHttpContext(); try { globalResourceObject = httpContext.GetGlobalResourceObject(classKey, implicitResourceKey + "." + attributeName) as string; } catch { } } return(globalResourceObject); }
// methods - ISiteMapCacheKeyGenerator Members public virtual string GenerateKey() { var context = mvcContextFactory.CreateHttpContext(); var builder = new StringBuilder(); builder.Append("sitemap://"); builder.Append(context.Request.Url.DnsSafeHost); builder.Append("/?sessionId="); builder.Append(context.Session.SessionID); LogUtility.Logger.Debug($"key = {builder.ToString()}"); return(builder.ToString()); }
public string ResolveServerUrl(string serverUrl, bool forceHttps) { // Is it already an absolute Url? if (serverUrl.IndexOf("://") > -1) { return(serverUrl); } // Start by fixing up the Url an Application relative Url string newUrl = ResolveUrl(serverUrl); // Due to URL rewriting, cloud computing (i.e. Azure) // and web farms, etc., we have to be VERY careful about what // we consider the incoming URL. We want to see the URL as it would // appear on the public-facing side of the hosting web site. // HttpRequest.Url gives us the internal URL in a cloud environment, // So we use a variable that (at least from what I can tell) gives us // the public URL: Uri originalUri = null; var httpContext = mvcContextFactory.CreateHttpContext(); if (httpContext.Request.Headers["Host"] != null) { string scheme = httpContext.Request.Headers["HTTP_X_FORWARDED_PROTO"] ?? httpContext.Request.Url.Scheme; originalUri = new Uri(scheme + Uri.SchemeDelimiter + httpContext.Request.Headers["Host"]); } else { originalUri = httpContext.Request.Url; } newUrl = (forceHttps ? "https" : originalUri.Scheme) + "://" + originalUri.Authority + newUrl; if (newUrl.EndsWith("//")) { newUrl = newUrl.Substring(0, newUrl.Length - 2); } // Strip off the application root newUrl = new Uri(newUrl).GetLeftPart(UriPartial.Authority); return(newUrl); }
/// <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) { // Clickable? Always accessible. if (node.Clickable == false) { return(true); } var httpContext = mvcContextFactory.CreateHttpContext(); // Is it an external Url? if (node.HasExternalUrl(httpContext)) { return(true); } return(this.VerifyNode(siteMap, node, httpContext)); }
/// <summary> /// Retrieves a <see cref="T:MvcSiteMapProvider.ISiteMapNode"/> object that represents the currently requested page using the current <see cref="T:System.Web.HttpContext"/> object. /// </summary> /// <returns> /// A <see cref="T:MvcSiteMapProvider.ISiteMapNode"/> that represents the currently requested page; otherwise, null, if no corresponding <see cref="T:MvcSiteMapProvider.ISiteMapNode"/> can be found in the <see cref="T:MvcSiteMapProvider.SiteMapNode"/> or if the page context is null. /// </returns> public virtual ISiteMapNode FindSiteMapNodeFromCurrentContext() { var httpContext = mvcContextFactory.CreateHttpContext(); return(FindSiteMapNode(httpContext)); }