Files
mono/mcs/class/referencesource/System.Web.DynamicData/DynamicData/DynamicDataRoute.cs
T
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

201 lines
7.7 KiB
C#

using System.Web.Routing;
using System.Diagnostics;
namespace System.Web.DynamicData {
/// <summary>
/// Route used by Dynamic Data
/// </summary>
public class DynamicDataRoute : Route {
internal const string ActionToken = "Action";
internal const string TableToken = "Table";
internal const string ModelToken = "__Model";
private MetaModel _model;
private volatile bool _initialized;
private object _initializationLock = new object();
/// <summary>
/// Construct a DynamicDataRoute
/// </summary>
/// <param name="url">url passed to the base ctor</param>
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings",
Justification = "This is a URL template with special characters, not just a regular valid URL.")]
public DynamicDataRoute(string url)
: base(url, new DynamicDataRouteHandler()) {
}
/// <summary>
/// Name of the table that this route applies to. Can be omitted.
/// </summary>
public string Table { get; set; }
/// <summary>
/// Action that this route applies to. Can be omitted.
/// </summary>
public string Action { get; set; }
/// <summary>
/// The ViewName is the name of the page used to handle the request. If omitted, it defaults to the Action name.
/// </summary>
public string ViewName { get; set; }
/// <summary>
/// The MetaModel that this route applies to
/// </summary>
public MetaModel Model {
get { return _model ?? MetaModel.Default; }
set { _model = value; }
}
// Make sure that if the Table or Action properties were used, they get added to
// the Defaults dictionary
private void EnsureRouteInitialize() {
if (!_initialized) {
lock (_initializationLock) {
if (!_initialized) {
// Give the model to the handler
Debug.Assert(Model != null);
RouteHandler.Model = Model;
// If neither was specified, we don't need to do anything
if (Table == null && Action == null)
return;
// If we don't already have a Defaults dictionary, create one
if (Defaults == null)
Defaults = new RouteValueDictionary();
if (Table != null) {
// Try to get the table just to cause a failure if it doesn't exist
var metaTable = Model.GetTable(Table);
Defaults[TableToken] = Table;
}
if (Action != null)
Defaults[ActionToken] = Action;
_initialized = true;
}
}
}
}
/// <summary>
/// See base class documentation
/// </summary>
public override RouteData GetRouteData(HttpContextBase httpContext) {
EnsureRouteInitialize();
// Try to get the route data for this route
RouteData routeData = base.GetRouteData(httpContext);
// If not, we're done
if (routeData == null) {
return null;
}
// Add all the query string values to the RouteData
//
AddQueryStringParamsToRouteData(httpContext, routeData);
// Check if the route values match an existing table and if they can be served by a scaffolded or custom page
if (!VerifyRouteValues(routeData.Values))
return null;
return routeData;
}
internal static void AddQueryStringParamsToRouteData(HttpContextBase httpContext, RouteData routeData) {
foreach (string key in httpContext.Request.QueryString) {
// Don't overwrite existing items
if (!routeData.Values.ContainsKey(key)) {
routeData.Values[key] = httpContext.Request.QueryString[key];
}
}
}
/// <summary>
/// See base class documentation
/// </summary>
public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values) {
EnsureRouteInitialize();
// Check if the route values include a MetaModel
object modelObject;
if (values.TryGetValue(ModelToken, out modelObject)) {
var model = modelObject as MetaModel;
if (model != null) {
// If it's different from the one for this route, fail the route matching
if (modelObject != Model)
return null;
// It has the right model, so we want to continue. But we first need to
// remove this token so it doesn't affect the path
values.Remove(ModelToken);
}
}
// Call the base to try to generate a path from this route
VirtualPathData virtualPathData = base.GetVirtualPath(requestContext, values);
// If not, we're done
if (virtualPathData == null)
return null;
// Check if the route values match an existing table and if they can be served by a scaffolded or custom page
if (VerifyRouteValues(values)) {
return virtualPathData;
}
else {
return null;
}
}
private bool VerifyRouteValues(RouteValueDictionary values) {
// Get the MetaTable and action. If either is missing, return false to skip this route
object tableNameObject, actionObject;
if (!values.TryGetValue(TableToken, out tableNameObject) || !values.TryGetValue(ActionToken, out actionObject)) {
return false;
}
MetaTable table;
// If no table by such name is available, return false to move on to next route.
if (!Model.TryGetTable((string)tableNameObject, out table)) {
return false;
}
// Check if n Page can be accessed for the table/action (either scaffold or custom).
// If not, return false so that this route is not used and the search goes on.
return RouteHandler.CreateHandler(this, table, (string)actionObject) != null;
}
/// <summary>
/// Extract the MetaTable from the RouteData. Fails if it can't find it
/// </summary>
/// <param name="routeData">The route data</param>
/// <returns>The found MetaTable</returns>
public MetaTable GetTableFromRouteData(RouteData routeData) {
string tableName = routeData.GetRequiredString(TableToken);
return Model.GetTable(tableName);
}
/// <summary>
/// Extract the Action from the RouteData. Fails if it can't find it
/// </summary>
/// <param name="routeData">The route data</param>
/// <returns>The found Action</returns>
public string GetActionFromRouteData(RouteData routeData) {
return routeData.GetRequiredString(ActionToken);
}
/// <summary>
/// Strongly typed version of Route.RouteHandler for convenience
/// </summary>
public new DynamicDataRouteHandler RouteHandler {
get { return (DynamicDataRouteHandler)base.RouteHandler; }
set { base.RouteHandler = value; }
}
}
}