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));
}
}
public override VirtualPathData GetVirtualPath(VirtualPathContext context)
{
object value;
// Return null if it doesn't match the home route values
foreach (var entry in _tokens)
{
if (String.Equals(entry.Key, "area", StringComparison.OrdinalIgnoreCase))
{
if (!context.AmbientValues.TryGetValue("area", out value) || !String.Equals(value.ToString(), _tokens["area"].ToString(), StringComparison.OrdinalIgnoreCase))
{
return null;
}
}
else
{
if (!context.Values.TryGetValue(entry.Key, out value) || !String.Equals(value.ToString(), entry.Value.ToString(), StringComparison.OrdinalIgnoreCase))
{
return null;
}
}
}
// Remove the values that should not be rendered in the query string
foreach(var key in _tokens.Keys)
{
context.Values.Remove(key);
}
var result = base.GetVirtualPath(context);
return result;
}
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;
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
VirtualPathData result = null;
var values = context.Values;
var controller = Convert.ToString(values["controller"]);
var action = Convert.ToString(values["action"]);
var id = Convert.ToString(values["id"]);
if ("Item".Equals(controller) && "View".Equals(action))
{
return("abcd?id=" + id);
}
// IMPORTANT: Always return null if there is no match.
// This tells .NET routing to check the next route that is registered.
return(result);
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
if (IsValidRequest(context.HttpContext))
{
foreach (var route in _routes)
{
var result = route.GetVirtualPath(context);
if(result != null)
{
return result;
}
}
}
return null;
}
// 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([NotNull] VirtualPathContext context)
{
if (context.ProvidedValues == null)
{
// We need the route's values to be able to double check our work.
return(false);
}
var actions =
GetActions().Where(
action =>
action.RouteConstraints == null ||
action.RouteConstraints.All(constraint => constraint.Accept(context.ProvidedValues)));
return(actions.Any());
}
// We need to recursively walk the decision tree based on the provided route data
// (context.Values + context.AmbientValues) to find all entries that match. This process is
// virtually identical to action selection.
//
// Each entry has a collection of 'required link values' that must be satisfied. These are
// key-value pairs that make up the decision tree.
//
// A 'require link value' is considered satisfied IF:
// 1. The value in context.Values matches the required value OR
// 2. There is no value in context.Values and the value in context.AmbientValues matches OR
// 3. The required value is 'null' and there is no value in context.Values.
//
// Ex:
// entry requires { area = null, controller = Store, action = Buy }
// context.Values = { controller = Store, action = Buy }
// context.AmbientValues = { area = Help, controller = AboutStore, action = HowToBuyThings }
//
// In this case the entry is a match. The 'controller' and 'action' are both supplied by context.Values,
// and the 'area' is satisfied because there's NOT a value in context.Values. It's OK to ignore ambient
// values in link generation.
//
// If another entry existed like { area = Help, controller = Store, action = Buy }, this would also
// match.
//
// The decision tree uses a tree data structure to execute these rules across all candidates at once.
private void Walk(
List <AttributeRouteLinkGenerationEntry> results,
VirtualPathContext context,
DecisionTreeNode <AttributeRouteLinkGenerationEntry> node)
{
// Any entries in node.Matches have had all their required values satisfied, so add them
// to the results.
for (var i = 0; i < node.Matches.Count; i++)
{
results.Add(node.Matches[i]);
}
for (var i = 0; i < node.Criteria.Count; i++)
{
var criterion = node.Criteria[i];
var key = criterion.Key;
object value;
if (context.Values.TryGetValue(key, out value))
{
DecisionTreeNode <AttributeRouteLinkGenerationEntry> branch;
if (criterion.Branches.TryGetValue(value ?? string.Empty, out branch))
{
Walk(results, context, branch);
}
}
else
{
// If a value wasn't explicitly supplied, match BOTH the ambient value and the empty value
// if an ambient value was supplied.
DecisionTreeNode <AttributeRouteLinkGenerationEntry> branch;
if (context.AmbientValues.TryGetValue(key, out value) &&
!criterion.Branches.Comparer.Equals(value, string.Empty))
{
if (criterion.Branches.TryGetValue(value, out branch))
{
Walk(results, context, branch);
}
}
if (criterion.Branches.TryGetValue(string.Empty, out branch))
{
Walk(results, context, branch);
}
}
}
}
// Routes must configured in Configure
public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
{
var trackPackageRouteHandler = new RouteHandler(context =>
{
var routeValues = context.GetRouteData().Values;
return(context.Response.WriteAsync(
$"Hello! Route values: {string.Join(", ", routeValues)}"));
});
var routeBuilder = new RouteBuilder(app, trackPackageRouteHandler);
routeBuilder.MapRoute(
"Track Package Route",
"package/{operation:regex(track|create|detonate)}/{id:int}");
routeBuilder.MapGet("hello/{name}", context =>
{
var name = context.GetRouteValue("name");
// This is the route handler when HTTP GET "hello/<anything>" matches
// To match HTTP GET "hello/<anything>/<anything>,
// use routeBuilder.MapGet("hello/{*name}"
return(context.Response.WriteAsync($"Hi, {name}!"));
});
var routes = routeBuilder.Build();
app.UseRouter(routes);
// Show link generation when no routes match.
app.Run(async(context) =>
{
var dictionary = new RouteValueDictionary
{
{ "operation", "create" },
{ "id", 123 }
};
var vpc = new VirtualPathContext(context, null, dictionary, "Track Package Route");
var path = routes.GetVirtualPath(vpc).VirtualPath;
context.Response.ContentType = "text/html";
await context.Response.WriteAsync("Menu<hr/>");
await context.Response.WriteAsync($"<a href='{path}'>Create Package 123</a><br/>");
});
// End of app.Run
}
private static void URLGenerationTest(IApplicationBuilder app, IRouter routes)
{
app.Run(async context =>
{
var dic = new RouteValueDictionary
{
{ "operation", "create" },
{ "id", 123 }
};
var vpc = new VirtualPathContext(context, null, dic, "Track Package Route");
var path = routes.GetVirtualPath(vpc).VirtualPath;
context.Response.ContentType = "text/html";
await context.Response.WriteAsync("Menu<hr/>");
await context.Response.WriteAsync($"<a href='{path}'>Create Package 123</a><br/>");
});
}
public virtual string GetVirtualPath(VirtualPathContext context)
{
var values = _binder.GetValues(context.AmbientValues, context.Values);
if (values == null)
{
// We're missing one of the required values for this route.
return(null);
}
EnsureLoggers(context.Context);
if (!RouteConstraintMatcher.Match(Constraints,
values.CombinedValues,
context.Context,
this,
RouteDirection.UrlGeneration,
_constraintLogger))
{
return(null);
}
// Validate that the target can accept these values.
var childContext = CreateChildVirtualPathContext(context, values.AcceptedValues);
var path = _target.GetVirtualPath(childContext);
if (path != null)
{
// If the target generates a value then that can short circuit.
context.IsBound = true;
return(path);
}
else if (!childContext.IsBound)
{
// The target has rejected these values.
return(null);
}
path = _binder.BindValues(values.AcceptedValues);
if (path != null)
{
context.IsBound = true;
}
return(path);
}
// Routes must configured in Configure
public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
{
var trackPackageRouteHandler = new RouteHandler(context =>
{
var routeValues = context.GetRouteData().Values;
return context.Response.WriteAsync(
$"Hello! Route values: {string.Join(", ", routeValues)}");
});
var routeBuilder = new RouteBuilder(app, trackPackageRouteHandler);
routeBuilder.MapRoute(
"Track Package Route",
"package/{operation:regex(track|create|detonate)}/{id:int}");
routeBuilder.MapGet("hello/{name}", context =>
{
var name = context.GetRouteValue("name");
// This is the route handler when HTTP GET "hello/<anything>" matches
// To match HTTP GET "hello/<anything>/<anything>,
// use routeBuilder.MapGet("hello/{*name}"
return context.Response.WriteAsync($"Hi, {name}!");
});
var routes = routeBuilder.Build();
app.UseRouter(routes);
// Show link generation when no routes match.
app.Run(async (context) =>
{
var dictionary = new RouteValueDictionary
{
{ "operation", "create" },
{ "id", 123}
};
var vpc = new VirtualPathContext(context, null, dictionary, "Track Package Route");
var path = routes.GetVirtualPath(vpc).VirtualPath;
context.Response.ContentType = "text/html";
await context.Response.WriteAsync("Menu<hr/>");
await context.Response.WriteAsync($"<a href='{path}'>Create Package 123</a><br/>");
});
// End of app.Run
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var controller = string.Empty;
var action = string.Empty;
bool containsRouteData =
context.Values.TryGetValueAsString(ControllerKey, out controller) &&
context.Values.TryGetValueAsString(ActionKey, out action);
return(containsRouteData
? new VirtualPathData(this, $"/{controller}/{action}")
: null);
}
/// <summary>
/// Returns information about the URL that is associated with the route
/// </summary>
/// <param name="context">A context for virtual path generation operations</param>
/// <returns>Information about the route and virtual path</returns>
public override VirtualPathData GetVirtualPath(VirtualPathContext context)
{
//get base virtual path
var data = base.GetVirtualPath(context);
//if (data == null)
// return null;
//if (!DataSettingsManager.DatabaseIsInstalled || !SeoFriendlyUrlsForLanguagesEnabled)
// return data;
////add language code to page URL in case if it's localized URL
//var path = context.HttpContext.Request.Path.Value;
//if (path.IsLocalizedUrl(context.HttpContext.Request.PathBase, false, out Language language))
// data.VirtualPath = $"/{language.UniqueSeoCode}{data.VirtualPath}";
return(data);
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
EnsureOptions(context.HttpContext);
var requestCulture = DetectRequestCulture(context.HttpContext);
var path = _virtualPathResolver.Resolve(context, _defaultRequestCulture, requestCulture);
if (!path.HasValue)
{
// We just want to act as a pass-through for link generation
return _defaultHandler.GetVirtualPath(context);
}
var virtualPathData = new VirtualPathData(_defaultHandler, path);
return NormalizeVirtualPath(virtualPathData);
}
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 VirtualPathData GetVirtualPath(VirtualPathContext context)
{
EnsureOptions(context.HttpContext);
var requestCulture = DetectRequestCulture(context.HttpContext);
var path = _virtualPathResolver.Resolve(context, _defaultRequestCulture, requestCulture);
if (!path.HasValue)
{
// We just want to act as a pass-through for link generation
return(_next.GetVirtualPath(context));
}
var virtualPathData = new VirtualPathData(_next, path);
//context.IsBound = true;
return(NormalizeVirtualPath(virtualPathData));
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var controller = string.Empty;
var action = string.Empty;
bool containsRouteData =
context.Values.TryGetValueAsString(ControllerKey, out controller)
&& context.Values.TryGetValueAsString(ActionKey, out action);
return containsRouteData
? new VirtualPathData(this, $"/{controller}/{action}")
: null;
}
// 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);
}
// 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.Trace);
var defaultHandler = new RouteHandler((c) =>
c.Response.WriteAsync($"Hello world! Route values: " +
$"{string.Join(", ", c.GetRouteData().Values)}")
);
var routeBuilder = new RouteBuilder(app, defaultHandler);
routeBuilder.AddHelloRoute(app);
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 static LinkTransformationBuilder AddRoutePath(this LinkTransformationBuilder builder)
{
return(builder.Add(ctx =>
{
if (string.IsNullOrEmpty(ctx.LinkSpec.RouteName))
{
throw new InvalidOperationException($"Invalid route specified in link specification.");
}
var valuesDictionary = GetValuesDictionary(ctx.LinkSpec.RouteValues);
var virtualPathContext = new VirtualPathContext(ctx.HttpContext, ctx.RouteValues, valuesDictionary, ctx.LinkSpec.RouteName);
var virtualPathData = ctx.Router.GetVirtualPath(virtualPathContext);
if (virtualPathData == null)
{
throw new InvalidOperationException($"Invalid virtualPathData when adding route '{ctx.LinkSpec.RouteName}'. RouteValues: {String.Join(",", valuesDictionary.Select(x => String.Concat(x.Key,"=",x.Value)))}");
}
return virtualPathData.VirtualPath;
}));
}
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));
}
// 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.Trace);
var defaultHandler = new RouteHandler((c) =>
c.Response.WriteAsync($"Hello world! Route values: " +
$"{string.Join(", ", c.GetRouteData().Values)}")
);
var routeBuilder = new RouteBuilder(app, defaultHandler);
routeBuilder.AddHelloRoute(app);
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 (context.Values["area"]?.ToString() == "Orchard.Contents" &&
context.Values["controller"]?.ToString() == "Item" &&
context.Values["action"]?.ToString() == "Display" &&
context.Values["id"] != null)
{
// Matching route value, lookup for the id
int contentItemId = int.Parse(context.Values["id"]?.ToString());
string path;
if (_entries.TryGetPath(contentItemId, out path))
{
return(new VirtualPathData(_target, path));
}
}
return(null);
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
var currentNode = RoutedModules.First;
while ((currentNode != null))
{
var module = currentNode.Value;
var moduleRouter = module.Router;
var virtulPath = moduleRouter.GetVirtualPath(context);
if (virtulPath != null)
{
return(virtulPath);
}
currentNode = currentNode.Next;
}
return(null);
}
public override VirtualPathData GetVirtualPath(VirtualPathContext context)
{
var tokens = GetHomeRouteValues(context.HttpContext);
if (tokens == null || tokens.Count == 0)
{
return(null);
}
// Return null if it doesn't match the home route values
foreach (var entry in tokens)
{
object value;
if (string.Equals(entry.Key, "area", StringComparison.OrdinalIgnoreCase))
{
if (!context.Values.TryGetValue("area", out value) || !String.Equals(value.ToString(), tokens["area"].ToString(), StringComparison.OrdinalIgnoreCase))
{
return(null);
}
}
else
{
if (!context.Values.TryGetValue(entry.Key, out value) || !String.Equals(value.ToString(), entry.Value.ToString(), StringComparison.OrdinalIgnoreCase))
{
return(null);
}
}
}
// Remove the values that should not be rendered in the query string
var clonedContext = new VirtualPathContext(context.HttpContext, context.AmbientValues, new RouteValueDictionary(context.Values), context.RouteName);
foreach (var key in tokens.Keys)
{
clonedContext.Values.Remove(key);
}
var result = base.GetVirtualPath(clonedContext);
return(result);
}
/// <inheritdoc />
/// <remarks>This signature uses types that are AspNetCore-specific.</remarks>
public override VirtualPathData GetVirtualPath(VirtualPathContext context)
{
// Fast path link generation where we recognize an OData route of the form "prefix/{*odataPath}".
// Link generation using HttpRoute.GetVirtualPath can consume up to 30% of processor time
object odataPathValue;
if (context.Values.TryGetValue(ODataRouteConstants.ODataPath, out odataPathValue))
{
string odataPath = odataPathValue as string;
if (odataPath != null)
{
// Try to generate an optimized direct link
// Otherwise, fall back to the base implementation
return(CanGenerateDirectLink
? GenerateLinkDirectly(odataPath)
: base.GetVirtualPath(context));
}
}
return(null);
}
public override VirtualPathData GetVirtualPath(VirtualPathContext context)
{
object value;
var tokens = GetHomeRouteValuesAsync().Result;
if (tokens == null)
{
return(null);
}
// Return null if it doesn't match the home route values
foreach (var entry in tokens)
{
if (String.Equals(entry.Key, "area", StringComparison.OrdinalIgnoreCase))
{
if (!context.AmbientValues.TryGetValue("area", out value) || !String.Equals(value.ToString(), tokens["area"].ToString(), StringComparison.OrdinalIgnoreCase))
{
return(null);
}
}
else
{
if (!context.Values.TryGetValue(entry.Key, out value) || !String.Equals(value.ToString(), entry.Value.ToString(), StringComparison.OrdinalIgnoreCase))
{
return(null);
}
}
}
// Remove the values that should not be rendered in the query string
foreach (var key in tokens.Keys)
{
context.Values.Remove(key);
}
var result = base.GetVirtualPath(context);
return(result);
}
public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
{
var trackPackageRouterHandler = new RouteHandler(context =>
{
var routeValues = context.GetRouteData().Values;
return(context.Response.WriteAsync($"Hello! Route values: { string.Join(",", routeValues)}"));
});
var routeBuilder = new RouteBuilder(app, trackPackageRouterHandler);
routeBuilder.MapRoute(
"Track Package Route",
"package/{operation:regex(^track|create$)}/{id:int}");
routeBuilder.MapRoute("hello/{name}", context =>
{
var name = context.GetRouteValue("name");
return(context.Response.WriteAsync($"Hi, {name}"));
});
var routes = routeBuilder.Build();
app.UseRouter(routes);
app.Run(async(context) =>
{
var dictionary = new RouteValueDictionary
{
{ "operation", "create" },
{ "id", 123 }
};
var vpc = new VirtualPathContext(context, null, dictionary, "Track Package Route");
var path = routes.GetVirtualPath(vpc).VirtualPath;
context.Response.ContentType = "text/html";
await context.Response.WriteAsync("Menu<hr/>");
await context.Response.WriteAsync($"<a href='{path}'>Create Package 123</a><br/>");
});
}
public override VirtualPathData GetVirtualPath(VirtualPathContext context)
{
object value;
var tokens = GetHomeRouteValues(context.HttpContext);
if (tokens == null)
{
return(null);
}
foreach (var entry in tokens)
{
if (String.Equals(entry.Key, "area", StringComparison.OrdinalIgnoreCase))
{
if (!context.AmbientValues.TryGetValue("area", out value) || !String.Equals(value.ToString(), tokens["area"].ToString(), StringComparison.OrdinalIgnoreCase))
{
return(null);
}
}
else
{
if (!context.Values.TryGetValue(entry.Key, out value) || !String.Equals(value.ToString(), entry.Value.ToString(), StringComparison.OrdinalIgnoreCase))
{
return(null);
}
}
}
foreach (var key in tokens.Keys)
{
context.Values.Remove(key);
}
var result = base.GetVirtualPath(context);
return(result);
}
public void GetVirtualPath_Sends_ProvidedValues_ButNotQueryStringValues()
{
// Arrange
VirtualPathContext childContext = null;
var target = new Mock <IRouter>(MockBehavior.Strict);
target
.Setup(r => r.GetVirtualPath(It.IsAny <VirtualPathContext>()))
.Callback <VirtualPathContext>(c => { childContext = c; c.IsBound = true; })
.Returns <string>(null);
var route = CreateRoute(target.Object, "{controller}/{action}");
var context = CreateVirtualPathContext(new { action = "Store", id = 5 }, new { Controller = "Home", action = "Blog" });
var expectedValues = new RouteValueDictionary(new { controller = "Home", action = "Store" });
// Act
var path = route.GetVirtualPath(context);
// Assert
Assert.Equal("Home/Store?id=5", path);
Assert.Equal(expectedValues, childContext.ProvidedValues);
}
public override VirtualPathData GetVirtualPath(VirtualPathContext context)
{
var data = base.GetVirtualPath(context);
if (data == null)
{
return(null);
}
if (!DataAyarlarıYardımcısı.DatabaseYüklendi() || !SeoFriendlyUrlsForLanguagesEnabled)
{
return(data);
}
var path = context.HttpContext.Request.Path.Value;
if (path.IsLocalizedUrl(context.HttpContext.Request.PathBase, false, out Dil language))
{
data.VirtualPath = $"/{language.ÖzelSeoKodu}{data.VirtualPath}";
}
return(data);
}
public override VirtualPathData GetVirtualPath(VirtualPathContext context)
{
//в RouteData должен быть CurrentItem
if (!context.HttpContext.GetRouteData().DataTokens.ContainsKey(RoutingKeys.CurrentItem))
{
return(null);
}
var page = (context.HttpContext.GetRouteData().DataTokens[RoutingKeys.CurrentItem] as IAbstractItem);
if (page == null)
{
return(null);
}
//проверим, что переданный контроллер соответствует типу страницы
var controllerName = ControllerMapper.Map(page);
if (!string.Equals(controllerName, context.Values["controller"]))
{
return(null);
}
context.Values["controller"] = "--replace-with-path--";
context.Values.Remove(RoutingKeys.CurrentItem);
var vp = base.GetVirtualPath(context);
if (vp == null)
{
return(null);
}
vp.VirtualPath = vp.VirtualPath.Replace("--replace-with-path--", page.GetTrail().TrimStart('/'));
return(vp);
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
string contentItemId = context.Values["contentItemId"]?.ToString();
if (string.IsNullOrEmpty(contentItemId))
{
return(null);
}
var displayRouteData = GetContentItemDisplayRoutes(context.HttpContext, contentItemId).Result;
if (string.Equals(context.Values["area"]?.ToString(), displayRouteData?["area"]?.ToString(), StringComparison.OrdinalIgnoreCase) &&
string.Equals(context.Values["controller"]?.ToString(), displayRouteData?["controller"]?.ToString(), StringComparison.OrdinalIgnoreCase) &&
string.Equals(context.Values["action"]?.ToString(), displayRouteData?["action"]?.ToString(), StringComparison.OrdinalIgnoreCase))
{
string path;
if (_entries.TryGetPath(contentItemId, out path))
{
if (context.Values.Count > 4)
{
foreach (var data in context.Values)
{
if (!_keys.Contains(data.Key))
{
path = QueryHelpers.AddQueryString(path, data.Key, data.Value.ToString());
}
}
}
return(new VirtualPathData(_target, path));
}
}
return(null);
}
/// <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);
}
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
return null;
}
private VirtualPathContext CreateContext(object values, object ambientValues = null)
{
var context = new VirtualPathContext(
new DefaultHttpContext(),
new RouteValueDictionary(ambientValues),
new RouteValueDictionary(values));
return context;
}
private VirtualPathContext CreateChildVirtualPathContext(
VirtualPathContext context,
IDictionary<string, object> acceptedValues)
{
// We want to build the set of values that would be provided if this route were to generated
// a link and then immediately match it. This includes all the accepted parameter values, and
// the defaults. Accepted values that would go in the query string aren't included.
var providedValues = new RouteValueDictionary();
foreach (var parameter in _parsedTemplate.Parameters)
{
object value;
if (acceptedValues.TryGetValue(parameter.Name, out value))
{
providedValues.Add(parameter.Name, value);
}
}
foreach (var kvp in _defaults)
{
if (!providedValues.ContainsKey(kvp.Key))
{
providedValues.Add(kvp.Key, kvp.Value);
}
}
return new VirtualPathContext(context.Context, context.AmbientValues, context.Values)
{
ProvidedValues = providedValues,
};
}
public virtual VirtualPathData GetVirtualPath(VirtualPathContext context)
{
var values = _binder.GetValues(context.AmbientValues, context.Values);
if (values == null)
{
// We're missing one of the required values for this route.
return null;
}
EnsureLoggers(context.Context);
if (!RouteConstraintMatcher.Match(Constraints,
values.CombinedValues,
context.Context,
this,
RouteDirection.UrlGeneration,
_constraintLogger))
{
return null;
}
// Validate that the target can accept these values.
var childContext = CreateChildVirtualPathContext(context, values.AcceptedValues);
var pathData = _target.GetVirtualPath(childContext);
if (pathData != null)
{
// If the target generates a value then that can short circuit.
return pathData;
}
// If we can produce a value go ahead and do it, the caller can check context.IsBound
// to see if the values were validated.
// When we still cannot produce a value, this should return null.
var tempPath = _binder.BindValues(values.AcceptedValues);
if (tempPath == null)
{
return null;
}
pathData = new VirtualPathData(this, tempPath);
if (DataTokens != null)
{
foreach (var dataToken in DataTokens)
{
pathData.DataTokens.Add(dataToken.Key, dataToken.Value);
}
}
context.IsBound = childContext.IsBound;
return pathData;
}
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 VirtualPathData GetVirtualPath(VirtualPathContext context)
{
GenerationContext = context;
return null;
}
/// <summary>
/// Generates the virtual path data for the router
/// </summary>
/// <param name="context">Virtual path context</param>
/// <returns>Virtual path data for the router</returns>
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
// We return null here because we're not responsible for generating the url, the route is.
return null;
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
return(_defaultRouter.GetVirtualPath(context));
}
public bool HasValidAction(VirtualPathContext context)
{
return true;
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
return Router.GetVirtualPath(context);
}
public PathString Resolve(VirtualPathContext virtualPathContext, RequestCulture defaultRequestCulture, RequestCulture requestCulture)
{
// Handle when the page is added as a route parameter
object value;
if (virtualPathContext.Values.TryGetValue("page", out value))
{
var page = value as Page;
if (page == null) return null;
object culture;
if (virtualPathContext.Values.TryGetValue("culture", out culture))
{
string cultureValue = culture as string;
if (cultureValue != null)
{
requestCulture = new RequestCulture(cultureValue);
}
}
var trie = _routeResolverTrie.LoadTrieAsync(requestCulture);
trie.Wait();
var node = trie.Result.FirstOrDefault(n => n.Value.PageId == page.Id);
PathString path = new PathString();
if (defaultRequestCulture.Culture.Name != requestCulture.Culture.Name)
{
path = path.Add("/" + requestCulture.Culture.TwoLetterISOLanguageName);
}
return path.Add(node.Key);
}
if (virtualPathContext.Values.TryGetValue("id", out value))
{
var id = value as string;
if (id == null) return null;
object culture;
if (virtualPathContext.Values.TryGetValue("culture", out culture))
{
string cultureValue = culture as string;
if (cultureValue != null)
{
requestCulture = new RequestCulture(cultureValue);
}
}
var trie = _routeResolverTrie.LoadTrieAsync(requestCulture);
trie.Wait();
var node = trie.Result.FirstOrDefault(n => n.Value.PageId == id);
PathString path = new PathString();
if (defaultRequestCulture.Culture.Name != requestCulture.Culture.Name)
{
path = path.Add("/" + requestCulture.Culture.TwoLetterISOLanguageName);
}
return path.Add(node.Key);
}
return null;
}
public VirtualPathData GetVirtualPath(VirtualPathContext context) => _routeCollection.GetVirtualPath(context);
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
//required
public void Configure(IApplicationBuilder app, Microsoft.AspNetCore.Hosting.IHostingEnvironment env)
{
logger.LogInformation(1001, "Logging from Configure!");
//var configureLogger = loggerFactory.CreateLogger("Startup.Configure");
//configureLogger.LogInformation("Logging from Configure");
//is responsible for the actual configuration of the application's HTTP request pipeline and is required by the runtime
//app.Use(async (context, next) =>
//{
// if (context.Request.Path == "/foo")
// await context.Response.WriteAsync($"Welcome to Foo");
// else
// await next();
//});
//app.Use(async (context, next) =>
//{
// if (context.Request.Path == "/bar")
// await context.Response.WriteAsync($"Welcome to Bar");
// else
// await next();
//});
app.Map("/foo", config => config.Use(async(context, next) => await context.Response.WriteAsync("Welcome to /foo")));
app.MapWhen(context =>
context.Request.Method == "POST" &&
context.Request.Path == "/bar",
config => config.Use(async(context, next) => await context.Response.WriteAsync("Welcome to /bar")));
app.Run(async(context) =>
{
//We can group a set of logical operations with the same log information by using scopes, which are
//IDisposable objects that result from calling ILogger.BeginScope<TState> and last until they are disposed of.
using (logger.BeginScope("This is an awesome group"))
{
logger.LogInformation("Log entry 1");
logger.LogWarning("Log entry 2");
logger.LogError("Log entry 3");
}
logger.LogInformation(1002, "Logging from app.Run!");
//var logger = loggerFactory.CreateLogger("Startup.Configure.Run");
//configureLogger.LogInformation("Logging from app.Run!");
//logger.LogInformation("This is awesome");
await context.Response.WriteAsync($"Welcome to the default");
});
app.UseRouter(builder =>
{
//builder.MapRoute(string.Empty, context =>
//{
// return context.Response.WriteAsync($"Welcome to the default route!");
//});
builder.MapGet("foo/{name}/{surname?}", (request, response, routeData) =>
{
return(response.WriteAsync($"Welcome to Foo, {routeData.Values["name"]} {routeData.Values["surename"]}"));
});
builder.MapPost("bar/{number:int}", (request, response, routeData) =>
{
return(response.WriteAsync($"Welcome to Bar, number is {routeData.Values["number"]}"));
});
builder.MapRoute(string.Empty, context =>
{
var routeValues = new RouteValueDictionary
{
{ "number", 456 }
};
var vpc = new VirtualPathContext(context, null, routeValues, "bar/{number:int}");
var route = builder.Routes.Single(x => x.ToString().Equals(vpc.RouteName));
var barUrl = route.GetVirtualPath(vpc).VirtualPath;
return(context.Response.WriteAsync($"URL: {barUrl}"));
});
});
app.UseMiddleware <AwesomeRateLimiterMiddleware>();
app.UseMiddleware <AwesomeGraphQLMiddleware>();
app.UseAuthentication();
app.UseCors("AwesomePolicy");//(config => config.WithOrigins("http://awesome.com"));
app.UseSwagger();
app.UseSwaggerUI(x =>
{
x.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
});
app.UseMvc();
var options = new RewriteOptions().AddRedirectToHttps();
app.UseRewriter(options);
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
return new VirtualPathData(this, "");
}
public VirtualPathData GetVirtualPath(VirtualPathContext context)
{
return(null);
}
/// <summary>
/// Gets the <see cref="VirtualPathData"/> 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 <see cref="VirtualPathData"/>.
/// </param>
/// <param name="values">A dictionary that contains the parameters for a route.</param>
/// <returns>The <see cref="VirtualPathData"/>.</returns>
protected virtual VirtualPathData GetVirtualPathData(string routeName, RouteValueDictionary values)
{
var context = new VirtualPathContext(HttpContext, AmbientValues, values, routeName);
return Router.GetVirtualPath(context);
}
