|
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
}
}
|