mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
201 lines
7.7 KiB
C#
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; }
|
|
}
|
|
}
|
|
}
|