public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
if (IsValidRequest(context.Context))
{
return _target.GetVirtualPath(context);
}
return null;
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// We return null here because we're not responsible for generating the url, the route is.
return null;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app,
ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole(minLevel: LogLevel.Verbose);
app.UseIISPlatformHandler();
var routeBuilder = new RouteBuilder();
routeBuilder.ServiceProvider = app.ApplicationServices;
routeBuilder.Routes.Add(new TemplateRoute(
new HelloRouter(),
"hello/{name:alpha}",
app.ApplicationServices.GetService<IInlineConstraintResolver>()));
var endpoint1 = new DelegateRouter(async (context) =>
await context
.HttpContext
.Response
.WriteAsync("Hello world! Route Values: " +
string.Join("", context.RouteData.Values)));
routeBuilder.DefaultHandler = endpoint1;
routeBuilder.MapRoute(
"Track Package Route",
"package/{operation:regex(track|create|detonate)}/{id:int}");
app.UseRouter(routeBuilder.Build());
// demonstrate link generation
var trackingRouteCollection = new RouteCollection();
trackingRouteCollection.Add(routeBuilder.Routes[1]); // "Track Package Route"
app.Run(async (context) =>
{
var dictionary = new RouteValueDictionary
{
{"operation","create" },
{"id",123}
};
var vpc = new VirtualPathContext(context,
null, dictionary, "Track Package Route");
context.Response.ContentType = "text/html";
await context.Response.WriteAsync("Menu<hr/>");
await context.Response.WriteAsync(@"<a href='" +
trackingRouteCollection.GetVirtualPath(vpc).VirtualPath +
"'>Create Package 123</a><br/>");
});
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
if (IsValidRequest(context.Context))
{
foreach (var route in _routes)
{
var result = route.GetVirtualPath(context);
if(result != null)
{
return result;
}
}
}
return null;
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
EnsureServices(context.Context);
// The contract of this method is to check that the values coming in from the route are valid;
// that they match an existing action, setting IsBound = true if the values are OK.
context.IsBound = _actionSelector.HasValidAction(context);
// We return null here because we're not responsible for generating the url, the route is.
return null;
}
private static HtmlString createPostBackLink(IHtmlHelper helper,
string text,
string actionName,
string controller)
{
var vpc = new VirtualPathContext(
helper.ViewContext.HttpContext,
null,
(new RouteValueDictionary {
{ "controller", controller },
{ "action", actionName } })
);
var actionUrl = helper.ViewContext.RouteData.Routers[0].GetVirtualPath(vpc);
return new HtmlString(String.Format(@"<a href=""#"" class=""btn btn-default"" onclick=""wizard.WizardSubmit('{0}')"">{1}</a>",
actionUrl, text));
}
public virtual string GetVirtualPath(VirtualPathContext context)
{
if (!string.IsNullOrEmpty(context.RouteName))
{
INamedRouter matchedNamedRoute;
_namedRoutes.TryGetValue(context.RouteName, out matchedNamedRoute);
var virtualPath = matchedNamedRoute != null?matchedNamedRoute.GetVirtualPath(context) : null;
foreach (var unnamedRoute in _unnamedRoutes)
{
var tempVirtualPath = unnamedRoute.GetVirtualPath(context);
if (tempVirtualPath != null)
{
if (virtualPath != null)
{
// There was already a previous route which matched the name.
throw new InvalidOperationException(
Resources.FormatNamedRoutes_AmbiguousRoutesFound(context.RouteName));
}
virtualPath = tempVirtualPath;
}
}
return(virtualPath);
}
else
{
for (var i = 0; i < Count; i++)
{
var route = this[i];
var path = route.GetVirtualPath(context);
if (path != null)
{
return(path);
}
}
}
return(null);
}
public bool HasValidAction(VirtualPathContext context)
{
return true;
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
return null;
}
/// <inheritdoc />
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
var route = GetInnerRoute();
return route.GetVirtualPath(context);
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
return new VirtualPathData(this, "");
}
/// <summary>
/// Generates the absolute path of the url for the specified route values by
/// using the specified route name.
/// </summary>
/// <param name="routeName">The name of the route that is used to generate the URL.</param>
/// <param name="values">A dictionary that contains the parameters for a route.</param>
/// <returns>The absolute path of the URL.</returns>
protected virtual string GeneratePathFromRoute(string routeName, RouteValueDictionary values)
{
var context = new VirtualPathContext(HttpContext, AmbientValues, values, routeName);
var pathData = Router.GetVirtualPath(context);
if (pathData == null)
{
return null;
}
// VirtualPathData.VirtualPath returns string.Empty for null.
Debug.Assert(pathData.VirtualPath != null);
var pathBase = HttpContext.Request.PathBase;
if (!pathBase.HasValue)
{
if (pathData.VirtualPath.Length == 0)
{
return "/";
}
else if (!pathData.VirtualPath.StartsWith("/", StringComparison.Ordinal))
{
return "/" + pathData.VirtualPath;
}
else
{
return pathData.VirtualPath;
}
}
else
{
if (pathData.VirtualPath.Length == 0)
{
return pathBase;
}
else
{
var builder = new StringBuilder(
pathBase.Value,
pathBase.Value.Length + pathData.VirtualPath.Length);
if (pathBase.Value.EndsWith("/", StringComparison.Ordinal))
{
builder.Length--;
}
if (!pathData.VirtualPath.StartsWith("/", StringComparison.Ordinal))
{
builder.Append("/");
}
builder.Append(pathData.VirtualPath);
return builder.ToString();
}
}
}
/// <summary>
/// Generates the absolute path of the url for the specified route values by
/// using the specified route name.
/// </summary>
/// <param name="routeName">The name of the route that is used to generate the URL.</param>
/// <param name="values">A dictionary that contains the parameters for a route.</param>
/// <returns>The absolute path of the URL.</returns>
protected virtual string GeneratePathFromRoute(string routeName, IDictionary<string, object> values)
{
var context = new VirtualPathContext(_httpContext, _ambientValues, values, routeName);
var pathData = _router.GetVirtualPath(context);
if (pathData == null)
{
return null;
}
// VirtualPathData.VirtualPath returns string.Empty for null.
Debug.Assert(pathData.VirtualPath != null);
var fullPath = _httpContext.Request.PathBase.Add(pathData.VirtualPath).Value;
if (fullPath.Length == 0)
{
return "/";
}
else
{
return fullPath;
}
}
// This method attempts to ensure that the route that's about to generate a link will generate a link
// to an existing action. This method is called by a route (through MvcApplication) prior to generating
// any link - this gives WebFX a chance to 'veto' the values provided by a route.
//
// This method does not take httpmethod or dynamic action constraints into account.
public virtual bool HasValidAction(VirtualPathContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (context.ProvidedValues == null)
{
// We need the route's values to be able to double check our work.
return false;
}
var tree = _decisionTreeProvider.DecisionTree;
var matchingRouteConstraints = tree.Select(context.ProvidedValues);
return matchingRouteConstraints.Count > 0;
}
private VirtualPathData GenerateVirtualPath(VirtualPathContext context, AttributeRouteLinkGenerationEntry entry)
{
// In attribute the context includes the values that are used to select this entry - typically
// these will be the standard 'action', 'controller' and maybe 'area' tokens. However, we don't
// want to pass these to the link generation code, or else they will end up as query parameters.
//
// So, we need to exclude from here any values that are 'required link values', but aren't
// parameters in the template.
//
// Ex:
// template: api/Products/{action}
// required values: { id = "5", action = "Buy", Controller = "CoolProducts" }
//
// result: { id = "5", action = "Buy" }
var inputValues = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
foreach (var kvp in context.Values)
{
if (entry.RequiredLinkValues.ContainsKey(kvp.Key))
{
var parameter = entry.Template.Parameters
.FirstOrDefault(p => string.Equals(p.Name, kvp.Key, StringComparison.OrdinalIgnoreCase));
if (parameter == null)
{
continue;
}
}
inputValues.Add(kvp.Key, kvp.Value);
}
var bindingResult = entry.Binder.GetValues(context.AmbientValues, inputValues);
if (bindingResult == null)
{
// A required parameter in the template didn't get a value.
return null;
}
var matched = RouteConstraintMatcher.Match(
entry.Constraints,
bindingResult.CombinedValues,
context.Context,
this,
RouteDirection.UrlGeneration,
_constraintLogger);
if (!matched)
{
// A constraint rejected this link.
return null;
}
// These values are used to signal to the next route what we would produce if we round-tripped
// (generate a link and then parse). In MVC the 'next route' is typically the MvcRouteHandler.
var providedValues = new Dictionary<string, object>(
bindingResult.AcceptedValues,
StringComparer.OrdinalIgnoreCase);
providedValues.Add(AttributeRouting.RouteGroupKey, entry.RouteGroup);
var childContext = new VirtualPathContext(context.Context, context.AmbientValues, context.Values)
{
ProvidedValues = providedValues,
};
var pathData = _next.GetVirtualPath(childContext);
if (pathData != null)
{
// If path is non-null then the target router short-circuited, we don't expect this
// in typical MVC scenarios.
return pathData;
}
else if (!childContext.IsBound)
{
// The target router has rejected these values. We don't expect this in typical MVC scenarios.
return null;
}
var path = entry.Binder.BindValues(bindingResult.AcceptedValues);
if (path == null)
{
return null;
}
return new VirtualPathData(this, path);
}
private VirtualPathData GetVirtualPath(VirtualPathContext context, List<IRouter> routes)
{
for (var i = 0; i < routes.Count; i++)
{
var route = routes[i];
var pathData = route.GetVirtualPath(context);
if (pathData != null)
{
return pathData;
}
}
return null;
}
public virtual VirtualPathData GetVirtualPath(VirtualPathContext context)
{
EnsureOptions(context.HttpContext);
if (!string.IsNullOrEmpty(context.RouteName))
{
VirtualPathData namedRoutePathData = null;
INamedRouter matchedNamedRoute;
if (_namedRoutes.TryGetValue(context.RouteName, out matchedNamedRoute))
{
namedRoutePathData = matchedNamedRoute.GetVirtualPath(context);
}
var pathData = GetVirtualPath(context, _unnamedRoutes);
// If the named route and one of the unnamed routes also matches, then we have an ambiguity.
if (namedRoutePathData != null && pathData != null)
{
var message = Resources.FormatNamedRoutes_AmbiguousRoutesFound(context.RouteName);
throw new InvalidOperationException(message);
}
return NormalizeVirtualPath(namedRoutePathData ?? pathData);
}
else
{
return NormalizeVirtualPath(GetVirtualPath(context, _routes));
}
}
private string GeneratePathFromRoute(string routeName, IDictionary<string, object> values)
{
var context = new VirtualPathContext(_httpContext, _ambientValues, values, routeName);
var path = _router.GetVirtualPath(context);
if (path == null)
{
return null;
}
// See Routing Issue#31
if (path.Length > 0 && path[0] != '/')
{
path = "/" + path;
}
var fullPath = _httpContext.Request.PathBase.Add(new PathString(path)).Value;
if (fullPath.Length == 0)
{
return "/";
}
else
{
return fullPath;
}
}
public VirtualPathData GetVirtualPath(VirtualPathContext context) {
foreach(var parameter in _matcher.Template.Parameters) {
context.Values.Remove(parameter.Name);
}
return _innerRoute.GetVirtualPath(context);
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
context.IsBound = true;
return null;
}
public string GetVirtualPath(VirtualPathContext context)
{
return("");
}
/// <inheritdoc />
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
var router = GetTreeRouter();
return router.GetVirtualPath(context);
}
private VirtualPathData GetVirtualPathForNamedRoute(VirtualPathContext context)
{
AttributeRouteLinkGenerationEntry entry;
if (_namedEntries.TryGetValue(context.RouteName, out entry))
{
var path = GenerateVirtualPath(context, entry);
if (path != null)
{
context.IsBound = true;
return path;
}
}
return null;
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
return(new VirtualPathData(this, ""));
}
private bool ContextHasSameValue(VirtualPathContext context, string key, object value)
{
object providedValue;
if (!context.Values.TryGetValue(key, out providedValue))
{
// If the required value is an 'empty' route value, then ignore ambient values.
// This handles a case where we're generating a link to an action like:
// { area = "", controller = "Home", action = "Index" }
//
// and the ambient values has a value for area.
if (value != null)
{
context.AmbientValues.TryGetValue(key, out providedValue);
}
}
return TemplateBinder.RoutePartsEqual(providedValue, value);
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
throw new NotImplementedException();
}
public virtual VirtualPathData GetVirtualPath(VirtualPathContext context)
{
EnsureOptions(context.Context);
// If we're using Best-Effort link generation then it means that we'll first look for a route where
// the route values are validated (context.IsBound == true). If we can't find a match like that, then
// we'll return the path from the first route to return one.
var useBestEffort = _options.UseBestEffortLinkGeneration;
if (!string.IsNullOrEmpty(context.RouteName))
{
var isValidated = false;
VirtualPathData bestPathData = null;
INamedRouter matchedNamedRoute;
if (_namedRoutes.TryGetValue(context.RouteName, out matchedNamedRoute))
{
bestPathData = matchedNamedRoute.GetVirtualPath(context);
isValidated = context.IsBound;
}
// If we get here and context.IsBound == true, then we know we have a match, we want to keep
// iterating to see if we have multiple matches.
foreach (var unnamedRoute in _unnamedRoutes)
{
// reset because we're sharing the context
context.IsBound = false;
var pathData = unnamedRoute.GetVirtualPath(context);
if (pathData == null)
{
continue;
}
if (bestPathData != null)
{
// There was already a previous route which matched the name.
throw new InvalidOperationException(
Resources.FormatNamedRoutes_AmbiguousRoutesFound(context.RouteName));
}
else if (context.IsBound)
{
// This is the first 'validated' match that we've found.
bestPathData = pathData;
isValidated = true;
}
else
{
Debug.Assert(bestPathData == null);
// This is the first 'unvalidated' match that we've found.
bestPathData = pathData;
isValidated = false;
}
}
if (isValidated || useBestEffort)
{
context.IsBound = isValidated;
if (bestPathData != null)
{
bestPathData = new VirtualPathData(
bestPathData.Router,
NormalizeVirtualPath(bestPathData.VirtualPath),
bestPathData.DataTokens);
}
return bestPathData;
}
else
{
return null;
}
}
else
{
VirtualPathData bestPathData = null;
for (var i = 0; i < Count; i++)
{
var route = this[i];
var pathData = route.GetVirtualPath(context);
if (pathData == null)
{
continue;
}
if (context.IsBound)
{
// This route has validated route values, short circuit.
return new VirtualPathData(
pathData.Router,
NormalizeVirtualPath(pathData.VirtualPath),
pathData.DataTokens);
}
else if (bestPathData == null)
{
// The values aren't validated, but this is the best we've seen so far
bestPathData = pathData;
}
}
if (useBestEffort)
{
return new VirtualPathData(
bestPathData.Router,
NormalizeVirtualPath(bestPathData.VirtualPath),
bestPathData.DataTokens);
}
else
{
return null;
}
}
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
GenerationContext = context;
if (GenerationDelegate == null)
{
context.IsBound = true;
}
else
{
context.IsBound = GenerationDelegate(context);
}
return null;
}
protected abstract VirtualPathData OnVirtualPathGenerated(VirtualPathContext context);
public virtual VirtualPathData GetVirtualPath(VirtualPathContext context)
{
EnsureOptions(context.Context);
// If we're using Best-Effort link generation then it means that we'll first look for a route where
// the route values are validated (context.IsBound == true). If we can't find a match like that, then
// we'll return the path from the first route to return one.
var useBestEffort = _options.UseBestEffortLinkGeneration;
if (!string.IsNullOrEmpty(context.RouteName))
{
var isValidated = false;
VirtualPathData bestPathData = null;
INamedRouter matchedNamedRoute;
if (_namedRoutes.TryGetValue(context.RouteName, out matchedNamedRoute))
{
bestPathData = matchedNamedRoute.GetVirtualPath(context);
isValidated = context.IsBound;
}
// If we get here and context.IsBound == true, then we know we have a match, we want to keep
// iterating to see if we have multiple matches.
foreach (var unnamedRoute in _unnamedRoutes)
{
// reset because we're sharing the context
context.IsBound = false;
var pathData = unnamedRoute.GetVirtualPath(context);
if (pathData == null)
{
continue;
}
if (bestPathData != null)
{
// There was already a previous route which matched the name.
throw new InvalidOperationException(
Resources.FormatNamedRoutes_AmbiguousRoutesFound(context.RouteName));
}
else if (context.IsBound)
{
// This is the first 'validated' match that we've found.
bestPathData = pathData;
isValidated = true;
}
else
{
Debug.Assert(bestPathData == null);
// This is the first 'unvalidated' match that we've found.
bestPathData = pathData;
isValidated = false;
}
}
if (isValidated || useBestEffort)
{
context.IsBound = isValidated;
if (bestPathData != null)
{
bestPathData = new VirtualPathData(
bestPathData.Router,
NormalizeVirtualPath(bestPathData.VirtualPath),
bestPathData.DataTokens);
}
return(bestPathData);
}
else
{
return(null);
}
}
else
{
VirtualPathData bestPathData = null;
for (var i = 0; i < Count; i++)
{
var route = this[i];
var pathData = route.GetVirtualPath(context);
if (pathData == null)
{
continue;
}
if (context.IsBound)
{
// This route has validated route values, short circuit.
return(new VirtualPathData(
pathData.Router,
NormalizeVirtualPath(pathData.VirtualPath),
pathData.DataTokens));
}
else if (bestPathData == null)
{
// The values aren't validated, but this is the best we've seen so far
bestPathData = pathData;
}
}
if (useBestEffort)
{
return(new VirtualPathData(
bestPathData.Router,
NormalizeVirtualPath(bestPathData.VirtualPath),
bestPathData.DataTokens));
}
else
{
return(null);
}
}
}
private VirtualPathContext CreateContext(object values, object ambientValues = null)
{
var context = new VirtualPathContext(
new DefaultHttpContext(),
new RouteValueDictionary(ambientValues),
new RouteValueDictionary(values));
return context;
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
return _defaultHandler.GetVirtualPath(context);
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
// We don't really care what the values look like.
context.IsBound = true;
return null;
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
// We just want to act as a pass-through for link generation
return _next.GetVirtualPath(context);
}