Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web.DynamicData/DynamicData/DynamicDataRouteHandler.cs

@@ -0,0 +1,226 @@
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.Web.Compilation;
+using System.Web.Hosting;
+using System.Web.Routing;
+using System.Web.UI;
+
+namespace System.Web.DynamicData {
+    /// <summary>
+    /// Route handler used for Dynamic Data
+    /// </summary>
+    public class DynamicDataRouteHandler : IRouteHandler {
+
+        private static object s_requestContextKey = new object();
+        private static object s_metaTableKey = new object();
+
+        private object _requestItemsKey = new object();
+
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public DynamicDataRouteHandler() {
+            VirtualPathProvider = HostingEnvironment.VirtualPathProvider;
+            CreateHandlerCallback = delegate(string s) {
+                return (Page)BuildManager.CreateInstanceFromVirtualPath(s, typeof(Page));
+            };
+        }
+
+        /// <summary>
+        /// The MetaModel that the handler is associated with
+        /// </summary>
+        public MetaModel Model { get; internal set; }
+
+        // the following properties are for mocking purposes
+        internal VirtualPathProvider VirtualPathProvider { get; set; }
+        private HttpContextBase _context;
+        internal HttpContextBase HttpContext {
+            get {
+                return _context ?? new HttpContextWrapper(System.Web.HttpContext.Current);
+            }
+            set { _context = value; }
+        }
+        internal Func<string, IHttpHandler> CreateHandlerCallback { get; set; }
+
+        /// <summary>
+        /// Create a handler to process a Dynamic Data request
+        /// </summary>
+        /// <param name="route">The Route that was matched</param>
+        /// <param name="table">The MetaTable found in the route</param>
+        /// <param name="action">The Action found in the route</param>
+        /// <returns></returns>
+        public virtual IHttpHandler CreateHandler(DynamicDataRoute route, MetaTable table, string action) {
+            // First, get the path to the page (could be custom, shared, or null)
+            string virtualPath = GetPageVirtualPath(route, table, action);
+
+            if (virtualPath != null) {
+                // Gets called only for custom pages that we know exist or templates that may or may not
+                // exist. This method will throw if virtualPath does not exist, which is fine for templates
+                // but is not fine for custom pages.
+                return CreateHandlerCallback(virtualPath);
+            } else {
+                // This should only occur in the event that scaffolding is disabled and the custom page
+                // virtual path does not exist.
+                return null;
+            }
+        }
+
+        private string GetPageVirtualPath(DynamicDataRoute route, MetaTable table, string action) {
+            long cacheKey = Misc.CombineHashCodes(table, route.ViewName ?? action);
+
+            Dictionary<long, string> virtualPathCache = GetVirtualPathCache();
+
+            string virtualPath;
+            if (!virtualPathCache.TryGetValue(cacheKey, out virtualPath)) {
+                virtualPath = GetPageVirtualPathNoCache(route, table, action);
+                lock (virtualPathCache) {
+                    virtualPathCache[cacheKey] = virtualPath;
+                }
+            }
+            return virtualPath;
+        }
+
+        private Dictionary<long, string> GetVirtualPathCache() {
+            var httpContext = HttpContext;
+            Dictionary<long, string> virtualPathCache = (Dictionary<long, string>)httpContext.Items[_requestItemsKey];
+            if (virtualPathCache == null) {
+                virtualPathCache = new Dictionary<long, string>();
+                httpContext.Items[_requestItemsKey] = virtualPathCache;
+            }
+            return virtualPathCache;
+        }
+
+        private string GetPageVirtualPathNoCache(DynamicDataRoute route, MetaTable table, string action) {
+            // The view name defaults to the action
+            string viewName = route.ViewName ?? action;
+
+            // First, get the path to the custom page
+            string customPageVirtualPath = GetCustomPageVirtualPath(table, viewName);
+
+            if (VirtualPathProvider.FileExists(customPageVirtualPath)) {
+                return customPageVirtualPath;
+            } else {
+                if (table.Scaffold) {
+                    // If it doesn't exist, try the scaffolded page, but only if scaffolding is enabled on this table
+                    return GetScaffoldPageVirtualPath(table, viewName);
+                } else {
+                    // If scaffolding is disabled, null the path so BuildManager doesn't get called.
+                    return null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Build the path to a custom page. By default, it looks like ~/DynamicData/CustomPages/[tablename]/[viewname].aspx
+        /// </summary>
+        /// <param name="table">The MetaTable that the page is for</param>
+        /// <param name="viewName">The view name</param>
+        /// <returns></returns>
+        protected virtual string GetCustomPageVirtualPath(MetaTable table, string viewName) {
+            string pathPattern = "{0}CustomPages/{1}/{2}.aspx";
+            return String.Format(CultureInfo.InvariantCulture, pathPattern, Model.DynamicDataFolderVirtualPath, table.Name, viewName);
+        }
+
+        /// <summary>
+        /// Build the path to a page template. By default, it looks like ~/DynamicData/PageTemplates/[tablename]/[viewname].aspx
+        /// </summary>
+        /// <param name="table">The MetaTable that the page is for</param>
+        /// <param name="viewName">The view name</param>
+        /// <returns></returns>
+        protected virtual string GetScaffoldPageVirtualPath(MetaTable table, string viewName) {
+            string pathPattern = "{0}PageTemplates/{1}.aspx";
+            return String.Format(CultureInfo.InvariantCulture, pathPattern, Model.DynamicDataFolderVirtualPath, viewName);
+        }
+
+        /// <summary>
+        /// Return the RequestContext for this request. A new one is created if needed (can happen if the current request
+        /// is not a Dynamic Data request)
+        /// </summary>
+        /// <param name="httpContext">The current HttpContext</param>
+        /// <returns>The RequestContext</returns>
+        public static RequestContext GetRequestContext(HttpContext httpContext) {
+            if (httpContext == null) {
+                throw new ArgumentNullException("httpContext");
+            }
+
+            return GetRequestContext(new HttpContextWrapper(httpContext));
+        }
+
+        internal static RequestContext GetRequestContext(HttpContextBase httpContext) {
+            Debug.Assert(httpContext != null);
+
+            // Look for the RequestContext in the HttpContext
+            var requestContext = httpContext.Items[s_requestContextKey] as RequestContext;
+
+            // If the current request didn't go through the routing engine (e.g. normal page),
+            // there won't be a RequestContext.  If so, create a new one and save it
+            if (requestContext == null) {
+                var routeData = new RouteData();
+                requestContext = new RequestContext(httpContext, routeData);
+
+                // Add the query string params to the route data.  This allows non routed pages to support filtering.
+                DynamicDataRoute.AddQueryStringParamsToRouteData(httpContext, routeData);
+
+                httpContext.Items[s_requestContextKey] = requestContext;
+            }
+
+            return requestContext;
+        }
+
+        /// <summary>
+        /// The MetaTable associated with the current HttpRequest. Can be null for non-Dynamic Data requests.
+        /// </summary>
+        /// <param name="httpContext">The current HttpContext</param>
+        public static MetaTable GetRequestMetaTable(HttpContext httpContext) {
+            if (httpContext == null) {
+                throw new ArgumentNullException("httpContext");
+            }
+
+            return GetRequestMetaTable(new HttpContextWrapper(httpContext));
+        }
+
+        internal static MetaTable GetRequestMetaTable(HttpContextBase httpContext) {
+            Debug.Assert(httpContext != null);
+
+            return (MetaTable)httpContext.Items[s_metaTableKey];
+        }
+
+        /// <summary>
+        /// Set the MetaTable associated with the current HttpRequest.  Normally, this is set automatically from the
+        /// route, but this method is useful to set the table when used outside of routing.
+        /// </summary>
+        public static void SetRequestMetaTable(HttpContext httpContext, MetaTable table) {
+            SetRequestMetaTable(new HttpContextWrapper(httpContext), table);
+        }
+
+        internal static void SetRequestMetaTable(HttpContextBase httpContext, MetaTable table) {
+            Debug.Assert(httpContext != null);
+
+            httpContext.Items[s_metaTableKey] = table;
+        }
+
+        #region IRouteHandler Members
+        IHttpHandler IRouteHandler.GetHttpHandler(RequestContext requestContext) {
+            // Save the RequestContext
+            Debug.Assert(requestContext.HttpContext.Items[s_requestContextKey] == null);
+            requestContext.HttpContext.Items[s_requestContextKey] = requestContext;
+
+            // Get the dynamic route
+            var route = (DynamicDataRoute)requestContext.RouteData.Route;
+
+            // Get the Model from the route
+            MetaModel model = route.Model;
+
+            // Get the MetaTable and save it in the HttpContext
+            MetaTable table = route.GetTableFromRouteData(requestContext.RouteData);
+            requestContext.HttpContext.Items[s_metaTableKey] = table;
+
+            // Get the action from the request context
+            string action = route.GetActionFromRouteData(requestContext.RouteData);
+
+            return CreateHandler(route, table, action);
+        }
+        #endregion
+    }
+}