File: SiteMapProvider.cs
Project: ndp\fx\src\xsp\system\Web\System.Web.csproj (System.Web)
//------------------------------------------------------------------------------
// <copyright file="SiteMapProvider.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
 
/*
 * Copyright (c) 2002 Microsoft Corporation
 */
namespace System.Web {
 
    using System;
    using System.Collections;
    using System.Collections.Specialized;
    using System.Configuration.Provider;
    using System.Web.Security;
    using System.Web.UI;
    using System.Web.Util;
    using System.Security.Permissions;
 
    public abstract class SiteMapProvider : ProviderBase {
 
        private bool _securityTrimmingEnabled;
        private bool _enableLocalization;
        private String _resourceKey;
 
        internal const String _securityTrimmingEnabledAttrName = "securityTrimmingEnabled";
        private const string _allRoles = "*";
 
        private SiteMapProvider _rootProvider;
        private SiteMapProvider _parentProvider;
        private object _resolutionTicket = new object();
 
        internal readonly object _lock = new Object();
 
        public virtual SiteMapNode CurrentNode {
            get {
                HttpContext context = HttpContext.Current;
                SiteMapNode result = null;
 
                // First check the SiteMap resolve events.
                result = ResolveSiteMapNode(context);
 
                if (result == null) {
                    result = FindSiteMapNode(context);
                }
 
                return ReturnNodeIfAccessible(result);
            }
        }
 
        public bool EnableLocalization {
            get {
                return _enableLocalization;
            }
            set {
                _enableLocalization = value;
            }
        }
 
        // Parent provider
        public virtual SiteMapProvider ParentProvider {
            get {
                return _parentProvider;
            }
            set {
                _parentProvider = value;
            }
        }
 
        public string ResourceKey {
            get {
                return _resourceKey;
            }
            set {
                _resourceKey = value;
            }
        }
 
        public virtual SiteMapProvider RootProvider {
            get {
                if (_rootProvider == null) {
                    lock (_lock) {
                        if (_rootProvider == null) {
                            Hashtable providers = new Hashtable();
                            SiteMapProvider candidate = this;
 
                            providers.Add(candidate, null);
                            while (candidate.ParentProvider != null) {
                                if (providers.Contains(candidate.ParentProvider))
                                    throw new ProviderException(SR.GetString(SR.SiteMapProvider_Circular_Provider));
 
                                candidate = candidate.ParentProvider;
                                providers.Add(candidate, null);
                            }
 
                            _rootProvider = candidate;
                        }
                    }
                }
 
                return _rootProvider;
            }
        }
 
        public virtual SiteMapNode RootNode {
            get {
                SiteMapNode node = GetRootNodeCore();
                return ReturnNodeIfAccessible(node);
            }
        }
 
        public bool SecurityTrimmingEnabled {
            get {
                return _securityTrimmingEnabled;
            }
        }
 
        public event SiteMapResolveEventHandler SiteMapResolve;
 
        /// <devdoc>
        ///    <para>Add single node to provider.</para>
        /// </devdoc>
        protected virtual void AddNode(SiteMapNode node) {
            AddNode(node, null);
        }
 
        protected internal virtual void AddNode(SiteMapNode node, SiteMapNode parentNode) {
            throw new NotImplementedException();
        }
 
        public virtual SiteMapNode FindSiteMapNode(HttpContext context) {
            if (context == null) {
                return null;
            }
 
            string rawUrl = context.Request.RawUrl;
 
            SiteMapNode result = null;
 
            // First check the RawUrl
            result = FindSiteMapNode(rawUrl);
 
            if (result == null) {
                int queryStringIndex = rawUrl.IndexOf("?", StringComparison.Ordinal);
                if (queryStringIndex != -1) {
                    // check the RawUrl without querystring
                    result = FindSiteMapNode(rawUrl.Substring(0, queryStringIndex));
                }
 
                if (result == null) {
                    Page page = context.CurrentHandler as Page;
                    if (page != null) {
                        // Try without server side query strings
                        string qs = page.ClientQueryString;
                        if (qs.Length > 0) {
                            result = FindSiteMapNode(context.Request.Path + "?" + qs);
                        }
                    }
 
                    if (result == null) {
                        // Check the request path
                        result = FindSiteMapNode(context.Request.Path);
                    }
                }
            }
 
            return result;
        }
 
        public virtual SiteMapNode FindSiteMapNodeFromKey(string key) {
            return FindSiteMapNode(key);
        }
 
        public abstract SiteMapNode FindSiteMapNode(string rawUrl);
 
        public abstract SiteMapNodeCollection GetChildNodes(SiteMapNode node);
 
        public virtual SiteMapNode GetCurrentNodeAndHintAncestorNodes(int upLevel) {
            if (upLevel < -1) {
                throw new ArgumentOutOfRangeException("upLevel");
            }
 
            return CurrentNode;
        }
 
        public virtual SiteMapNode GetCurrentNodeAndHintNeighborhoodNodes(int upLevel, int downLevel) {
            if (upLevel < -1) {
                throw new ArgumentOutOfRangeException("upLevel");
            }
 
            if (downLevel < -1) {
                throw new ArgumentOutOfRangeException("downLevel");
            }
 
            return CurrentNode;
        }
 
        public abstract SiteMapNode GetParentNode(SiteMapNode node);
 
        public virtual SiteMapNode GetParentNodeRelativeToCurrentNodeAndHintDownFromParent (
            int walkupLevels, int relativeDepthFromWalkup) {
 
            if (walkupLevels < 0) {
                throw new ArgumentOutOfRangeException("walkupLevels");
            }
 
            if (relativeDepthFromWalkup < 0) {
                throw new ArgumentOutOfRangeException("relativeDepthFromWalkup");
            }
 
            // First get current nodes and hints about its ancestors.
            SiteMapNode currentNode = GetCurrentNodeAndHintAncestorNodes(walkupLevels);
 
            // Simply return if the currentNode is null.
            if (currentNode == null) {
                return null;
            }
 
            // Find the target node by walk up the parent tree.
            SiteMapNode targetNode = GetParentNodesInternal(currentNode, walkupLevels);
 
            if (targetNode == null) {
                return null;
            }
 
            // Get hints about its lower neighborhood nodes.
            HintNeighborhoodNodes(targetNode, 0, relativeDepthFromWalkup);
 
            return targetNode;
        }
 
        public virtual SiteMapNode GetParentNodeRelativeToNodeAndHintDownFromParent(
            SiteMapNode node, int walkupLevels, int relativeDepthFromWalkup) {
 
            if (walkupLevels < 0) {
                throw new ArgumentOutOfRangeException("walkupLevels");
            }
 
            if (relativeDepthFromWalkup < 0) {
                throw new ArgumentOutOfRangeException("relativeDepthFromWalkup");
            }
 
            if (node == null) {
                throw new ArgumentNullException("node");
            }
 
            // First get hints about ancestor nodes;
            HintAncestorNodes(node, walkupLevels);
 
            // walk up the parent node until the target node is found.
            SiteMapNode ancestorNode = GetParentNodesInternal(node, walkupLevels);
 
            if (ancestorNode == null) {
                return null;
            }
 
            // Get hints about its neighthood nodes
            HintNeighborhoodNodes(ancestorNode, 0, relativeDepthFromWalkup);
 
            return ancestorNode;
        }
 
        private SiteMapNode GetParentNodesInternal(SiteMapNode node, int walkupLevels) {
            Debug.Assert(node != null);
            if (walkupLevels <= 0) {
                return node;
            }
 
            do {
                node = node.ParentNode;
                walkupLevels--;
            } while (node != null && walkupLevels != 0);
 
            return node;
        }
 
        /*
         * A reference node that must be returned by all sitemap providers, this is
         * required for the parent provider to keep track of the relations between
         * two providers.
         * For example, the parent provider uses this method to keep track of the parent
         * node of child provider's root node.
         */
        protected internal abstract SiteMapNode GetRootNodeCore();
 
        protected static SiteMapNode GetRootNodeCoreFromProvider(SiteMapProvider provider) {
            return provider.GetRootNodeCore();
        }
 
        public virtual void HintAncestorNodes(SiteMapNode node, int upLevel) {
            if (node == null) {
                throw new ArgumentNullException("node");
            }
 
            if (upLevel < -1) {
                throw new ArgumentOutOfRangeException("upLevel");
            }
        }
 
        public virtual void HintNeighborhoodNodes(SiteMapNode node, int upLevel, int downLevel) {
            if (node == null) {
                throw new ArgumentNullException("node");
            }
 
            if (upLevel < -1) {
                throw new ArgumentOutOfRangeException("upLevel");
            }
 
            if (downLevel < -1) {
                throw new ArgumentOutOfRangeException("downLevel");
            }
        }
 
        public override void Initialize(string name, NameValueCollection attributes) {
            if (attributes != null) {
                if (string.IsNullOrEmpty(attributes["description"])) {
                    attributes.Remove("description");
                    attributes.Add("description", this.GetType().Name);
                }
 
                ProviderUtil.GetAndRemoveBooleanAttribute(attributes, _securityTrimmingEnabledAttrName, Name, ref _securityTrimmingEnabled);
            }
 
            base.Initialize(name, attributes);
        }
 
        public virtual bool IsAccessibleToUser(HttpContext context, SiteMapNode node) {
            if (node == null) {
                throw new ArgumentNullException("node");
            }
 
            if (context == null) {
                throw new ArgumentNullException("context");
            }
 
            if (!SecurityTrimmingEnabled) {
                return true;
            }
 
            if (node.Roles != null) {
                foreach (string role in node.Roles) {
                    // Grant access if one of the roles is a "*".
                    if (role == _allRoles || 
                        context.User != null && context.User.IsInRole(role)) {
                        return true;
                    }
                }
            }
 
            VirtualPath virtualPath = node.VirtualPath;
            if (virtualPath == null ||
                !virtualPath.IsWithinAppRoot) {
 
                return false;
            }
 
            return System.Web.UI.Util.IsUserAllowedToPath(context, virtualPath);
        }
 
        protected internal virtual void RemoveNode(SiteMapNode node) {
            throw new NotImplementedException();
        }
 
        protected SiteMapNode ResolveSiteMapNode(HttpContext context) {
            SiteMapResolveEventHandler eventHandler = SiteMapResolve;
            if (eventHandler == null)
                return null;
 
            if (!context.Items.Contains(_resolutionTicket)) {
                context.Items.Add(_resolutionTicket, true);
 
                try {
                    Delegate[] ds = eventHandler.GetInvocationList();
                    int len = ds.Length;
                    for (int i = 0; i < len; i++) {
                        SiteMapNode ret = ((SiteMapResolveEventHandler)ds[i])(this, new SiteMapResolveEventArgs(context, this));
                        if (ret != null) {
                            return ret;
                        }
                    }
                } finally {
                    context.Items.Remove(_resolutionTicket);
                }
            }
 
 
            return null;
        }
 
        internal SiteMapNode ReturnNodeIfAccessible(SiteMapNode node) {
            if (node != null && node.IsAccessibleToUser(HttpContext.Current)) {
                return node;
            }
 
            return null;
        }
    }
}