public void VirtualPath_ReturnsEmptyStringIfNull()
{
// Arrange
var router = Mock.Of<IRouter>();
// Act
var pathData = new VirtualPathData(router, virtualPath: null);
// Assert
Assert.Same(router, pathData.Router);
Assert.Empty(pathData.VirtualPath);
Assert.NotNull(pathData.DataTokens);
Assert.Empty(pathData.DataTokens);
}
public void Constructor_CreatesEmptyDataTokensIfNull()
{
// Arrange
var router = Mock.Of<IRouter>();
var path = "/virtual path";
// Act
var pathData = new VirtualPathData(router, path, null);
// Assert
Assert.Same(router, pathData.Router);
Assert.Equal(path, pathData.VirtualPath);
Assert.NotNull(pathData.DataTokens);
Assert.Empty(pathData.DataTokens);
}
/// <summary>
/// Returns information about the URL that is associated with the route.
/// </summary>
/// <param name="requestContext">An object that encapsulates information about the requested route.</param>
/// <param name="values">An object that contains the parameters for a route.</param>
/// <returns>
/// An object that contains information about the URL that is associated with the route.
/// </returns>
public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
{
VirtualPathData data = base.GetVirtualPath(requestContext, values);
if (data != null && DataSettingsHelper.DatabaseIsInstalled() && this.SeoFriendlyUrlsForLanguagesEnabled)
{
string rawUrl = requestContext.HttpContext.Request.RawUrl;
string applicationPath = requestContext.HttpContext.Request.ApplicationPath;
if (rawUrl.IsLocalizedUrl(applicationPath, true))
{
data.VirtualPath = string.Concat(rawUrl.GetLanguageSeoCodeFromUrl(applicationPath, true), "/",
data.VirtualPath);
}
}
return(data);
}
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 void Setup()
{
route = new Mock <RouteBase>();
route
.Setup(r => r.GetVirtualPath(It.IsAny <RequestContext>(), It.IsAny <RouteValueDictionary>()))
.Returns(() => virtualPathData);
virtualPathData = new VirtualPathData(route.Object, "~/VirtualPath");
routes = new RouteCollection();
routes.Add(route.Object);
originalRouteData = new RouteData();
string returnValue = "";
httpContext = new Mock <HttpContextBase>();
httpContext
.Setup(hc => hc.Request.ApplicationPath).Returns("~");
httpContext
.Setup(hc => hc.Response.ApplyAppPathModifier(It.IsAny <string>()))
.Callback <string>(s => returnValue = s)
.Returns(() => returnValue);
httpContext
.Setup(hc => hc.Server.Execute(It.IsAny <IHttpHandler>(), It.IsAny <TextWriter>(), It.IsAny <bool>()));
viewContext = new ViewContext
{
RequestContext = new RequestContext(httpContext.Object, originalRouteData)
};
viewDataContainer = new Mock <IViewDataContainer>();
htmlHelper = new Mock <HtmlHelper>(viewContext, viewDataContainer.Object, routes);
var requestContext = new RequestContext(httpContext.Object, originalRouteData);
ContextService.Get().Push <PageContext>(new PageContext()
{
RequestContext = requestContext
});
pageContext = new Mock <IPageContext>();
pageContext
.Setup(x => x.RequestContext)
.Returns(requestContext);
}
private VirtualPathData ResolveContentActionUrl(RequestContext requestContext, RouteValueDictionary values, ContentItem item)
{
const string controllerPlaceHolder = "---(CTRL)---";
const string areaPlaceHolder = "---(AREA)---";
values[ControllerKey] = controllerPlaceHolder; // pass a placeholder we'll fill with the content path
bool useAreas = innerRoute.DataTokens.ContainsKey("area");
if (useAreas)
{
values[AreaKey] = areaPlaceHolder;
}
if (values.ContainsKey(ContentItemKey))
{
values.Remove(ContentItemKey);
}
VirtualPathData vpd = innerRoute.GetVirtualPath(requestContext, values);
if (vpd == null)
{
return(null);
}
vpd.Route = this;
vpd.DataTokens[PathData.PathKey] = new PathData(item);
string relativeUrl = Url.ToRelative(item.Url);
Url actionUrl = vpd.VirtualPath
.Replace(controllerPlaceHolder, Url.PathPart(relativeUrl).TrimStart('~'));
if (useAreas)
{
actionUrl = actionUrl.SetPath(actionUrl.Path.Replace(areaPlaceHolder + "/", ""));
}
foreach (var kvp in Url.ParseQueryString(Url.QueryPart(relativeUrl)))
{
if ("item".Equals(kvp.Key, StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
actionUrl = actionUrl.AppendQuery(kvp.Key, kvp.Value);
}
vpd.VirtualPath = actionUrl.PathAndQuery.TrimStart('/');
return(vpd);
}
public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary routeValues)
{
NameValueCollection enumerables = new NameValueCollection();
foreach (KeyValuePair <string, object> routeValue in routeValues)
{
IEnumerable <int> values = routeValue.Value as IEnumerable <int>;
// collects all enumerable route values
if (values != null)
{
foreach (int value in values)
{
enumerables.Add(routeValue.Key, value.ToString());
}
}
}
// removes all enumerable route values so they are not processed by the base class
foreach (string key in enumerables.AllKeys)
{
routeValues.Remove(key);
}
// lets the base class generate a URL
VirtualPathData path = base.GetVirtualPath(requestContext, routeValues);
Uri requestUrl = requestContext.HttpContext.Request.Url;
if (enumerables.Count > 0 && requestUrl != null && path != null)
{
string authority = requestUrl.GetLeftPart(UriPartial.Authority);
Uri authorityUri = new Uri(authority);
Uri url = new Uri(authorityUri, path.VirtualPath);
UriBuilder builder = new UriBuilder(url);
NameValueCollection queryString = HttpUtility.ParseQueryString(builder.Query);
// extends the URL's query string with the provided enumerable route values
queryString.Add(enumerables);
builder.Query = queryString.ToString();
path.VirtualPath = builder.Uri.PathAndQuery.TrimStart('/');
}
return(path);
}
internal static VirtualPathData GetVirtualPathForArea(this RouteCollection routes, RequestContext requestContext, string name, RouteValueDictionary values, out bool usingAreas)
{
if (routes == null)
{
throw new ArgumentNullException("routes");
}
if (!String.IsNullOrEmpty(name))
{
// the route name is a stronger qualifier than the area name, so just pipe it through
usingAreas = false;
return(routes.GetVirtualPath(requestContext, name, values));
}
string targetArea = null;
if (values != null)
{
object targetAreaRawValue;
if (values.TryGetValue("area", out targetAreaRawValue))
{
targetArea = targetAreaRawValue as string;
}
else
{
// set target area to current area
if (requestContext != null)
{
targetArea = AreaHelpers.GetAreaName(requestContext.RouteData);
}
}
}
// need to apply a correction to the RVD if areas are in use
RouteValueDictionary correctedValues = values;
RouteCollection filteredRoutes = FilterRouteCollectionByArea(routes, targetArea, out usingAreas);
if (usingAreas)
{
correctedValues = new RouteValueDictionary(values);
correctedValues.Remove("area");
}
VirtualPathData vpd = filteredRoutes.GetVirtualPath(requestContext, correctedValues);
return(vpd);
}
public void GetVirtualPath_WhenAggregationEnabledWithSubfolderInRouteValues_ReturnsSubfolder()
{
//arrange
var httpContext = new Mock <HttpContextBase>();
httpContext.FakeRequest("~/subfolder/default.aspx", "subfolder" /* subfolder */, "~/");
var routeData = new RouteData();
var requestContext = new RequestContext(httpContext.Object, routeData);
var route = new RootRoute(true, new Mock <IServiceLocator>().Object);
var routeValues = new RouteValueDictionary(new { subfolder = "subfolder" });
//act
VirtualPathData virtualPathInfo = route.GetVirtualPath(requestContext, routeValues);
//assert
Assert.AreEqual("subfolder", virtualPathInfo.VirtualPath);
}
public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
{
string relativeUrl;
if (values.ContainsKey("relativeUrl"))
{
relativeUrl = (string)values["relativeUrl"];
}
else
{
relativeUrl = requestContext.HttpContext.Request.Path;
}
relativeUrl = relativeUrl.Split('/').Last().ToLowerInvariant();
if (!_relativeUrlCanonicalUrlDictionary.ContainsKey(relativeUrl))
{
return(null);
}
var canonicalUrl = _relativeUrlCanonicalUrlDictionary[relativeUrl];
var otherParams = new Dictionary <string, object>();
foreach (var param in values)
{
if (param.Key != "relativeUrl" && param.Key != "action" && param.Key != "controller" &&
param.Key != "area")
{
otherParams.Add(param.Key, param.Value);
}
}
StringBuilder otherParamsString = new StringBuilder();
if (otherParams.Any())
{
otherParamsString.Append("?");
}
foreach (var token in otherParams)
{
otherParamsString.Append($"{token.Key}={token.Value}");
if (token.Key != otherParams.Last().Key)
{
otherParamsString.Append("&");
}
}
var result = new VirtualPathData(this, $"{canonicalUrl}{otherParamsString}");
return(result);
}
public void GetVirtualPath_WhenSupplyingRouteValues_ReturnsNull()
{
//arrange
var httpContext = new Mock <HttpContextBase>();
httpContext.FakeRequest("~/subfolder/default.aspx", string.Empty /* subfolder */, "~/");
var routeData = new RouteData();
var requestContext = new RequestContext(httpContext.Object, routeData);
var route = new RootRoute(true, new Mock <IServiceLocator>().Object);
var routeValues = new RouteValueDictionary(new { foo = "bar" });
//act
VirtualPathData virtualPathInfo = route.GetVirtualPath(requestContext, routeValues);
//assert
Assert.IsNull(virtualPathInfo);
}
public ChildActionExtensionsTest()
{
_route = new Mock <RouteBase>();
_route
.Setup(
r =>
r.GetVirtualPath(
It.IsAny <RequestContext>(),
It.IsAny <RouteValueDictionary>()
)
)
.Returns(() => _virtualPathData);
_virtualPathData = new VirtualPathData(_route.Object, "~/VirtualPath");
_routes = new RouteCollection();
_routes.Add(_route.Object);
_originalRouteData = new RouteData();
string returnValue = "";
_httpContext = new Mock <HttpContextBase>();
_httpContext.Setup(hc => hc.Request.ApplicationPath).Returns("~");
_httpContext
.Setup(hc => hc.Response.ApplyAppPathModifier(It.IsAny <string>()))
.Callback <string>(s => returnValue = s)
.Returns(() => returnValue);
_httpContext.Setup(
hc =>
hc.Server.Execute(
It.IsAny <IHttpHandler>(),
It.IsAny <TextWriter>(),
It.IsAny <bool>()
)
);
_viewContext = new ViewContext
{
RequestContext = new RequestContext(_httpContext.Object, _originalRouteData)
};
_viewDataContainer = new Mock <IViewDataContainer>();
_htmlHelper = new Mock <HtmlHelper>(_viewContext, _viewDataContainer.Object, _routes);
}
public void IgnoreRouteInternalNeverMatchesUrlGeneration()
{
// Arrange
RouteCollection routes = new RouteCollection();
routes.IgnoreRoute("SomeUrl");
Route route = routes[0] as Route;
// Act
VirtualPathData vpd = route.GetVirtualPath(
new RequestContext(new Mock <HttpContextBase>().Object, new RouteData()),
null
);
// Assert
Assert.Null(vpd);
}
public static string GetPackageDownloadUrl(ODataPackage package)
{
var routesValues = new RouteValueDictionary {
{ "packageId", package.Id },
{ "version", package.Version }
};
var context = HttpContext.Current;
var route = RouteTable.Routes["DownloadPackage"];
VirtualPathData vpd = route == null ? null : route.GetVirtualPath(context.Request.RequestContext, routesValues);
var applicationPath = Helpers.EnsureTrailingSlash(context.Request.ApplicationPath);
return(applicationPath + (vpd?.VirtualPath ?? ""));
}
/// <inheritdoc/>
public override IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, string name, IDictionary <string, object> values)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
HttpContextBase httpContextBase;
if (!request.Properties.TryGetValue(HttpControllerHandler.HttpContextBaseKey, out httpContextBase))
{
httpContextBase = new HttpRequestMessageContextWrapper(VirtualPathRoot, request);
}
IHttpRouteData routeData = request.GetRouteData();
if (routeData == null)
{
return(null);
}
RequestContext requestContext = new RequestContext(httpContextBase, routeData.ToRouteData());
RouteValueDictionary routeValues = values != null ? new RouteValueDictionary(values) : new RouteValueDictionary();
VirtualPathData virtualPathData = _routeCollection.GetVirtualPath(requestContext, name, routeValues);
if (virtualPathData != null)
{
// If the route is not an HttpWebRoute, try getting a virtual path without the httproute key in the route value dictionary
// This ensures that httproute isn't picked up by non-WebAPI routes that might pollute the virtual path with httproute
if (!(virtualPathData.Route is HttpWebRoute))
{
if (routeValues.Remove(HttpWebRoute.HttpRouteKey))
{
VirtualPathData virtualPathDataWithoutHttpRouteValue = _routeCollection.GetVirtualPath(requestContext, name, routeValues);
if (virtualPathDataWithoutHttpRouteValue != null)
{
virtualPathData = virtualPathDataWithoutHttpRouteValue;
}
}
}
return(new HostedHttpVirtualPathData(virtualPathData, routeData.Route));
}
return(null);
}
public void GetVirtualPath_WhenSupplyingRouteValues_AppendsValuesToQueryString()
{
//arrange
var httpContext = new Mock <HttpContextBase>();
httpContext.FakeRequest("~/subfolder/default.aspx", string.Empty /* subfolder */, "~/");
var routeData = new RouteData();
var requestContext = new RequestContext(httpContext.Object, routeData);
var route = new STRouting.RootRoute(true, new Mock <IDependencyResolver>().Object);
var routeValues = new RouteValueDictionary(new { foo = "bar" });
//act
VirtualPathData virtualPathInfo = route.GetVirtualPath(requestContext, routeValues);
//assert
Assert.AreEqual(virtualPathInfo.VirtualPath, "?foo=bar");
}
public void GetVirtualPath_WhenAggregationEnabledAndNoSubfolderInRouteData_ReturnsRoot()
{
//arrange
var httpContext = new Mock <HttpContextBase>();
httpContext.FakeRequest("~/default.aspx", string.Empty /* subfolder */, "~/");
var routeData = new RouteData();
var requestContext = new RequestContext(httpContext.Object, routeData);
var route = new STRouting.RootRoute(true, new Mock <IDependencyResolver>().Object);
var routeValues = new RouteValueDictionary();
//act
VirtualPathData virtualPathInfo = route.GetVirtualPath(requestContext, routeValues);
//assert
Assert.AreEqual(string.Empty, virtualPathInfo.VirtualPath);
}
public static string GenerateUrl(
string routeName,
string actionName,
string controllerName,
RouteValueDictionary routeValues,
RouteCollection routeCollection,
RequestContext requestContext,
bool includeImplicitMvcValues
)
{
if (routeCollection == null)
{
throw new ArgumentNullException("routeCollection");
}
if (requestContext == null)
{
throw new ArgumentNullException("requestContext");
}
RouteValueDictionary mergedRouteValues = RouteValuesHelpers.MergeRouteValues(
actionName,
controllerName,
requestContext.RouteData.Values,
routeValues,
includeImplicitMvcValues
);
VirtualPathData vpd = routeCollection.GetVirtualPathForArea(
requestContext,
routeName,
mergedRouteValues
);
if (vpd == null)
{
return(null);
}
string modifiedUrl = UrlUtil.GenerateClientUrl(
requestContext.HttpContext,
vpd.VirtualPath
);
return(modifiedUrl);
}
/// <summary>
/// When overridden in a derived class, checks whether the route matches the specified values, and if so, generates a URL and retrieves information about the route.
/// </summary>
/// <param name="requestContext">An object that encapsulates information about the requested route.</param>
/// <param name="values">An object that contains the parameters for a route.</param>
/// <returns>
/// An object that contains the generated URL and information about the route, or null if the route does not match <paramref name="values"/>.
/// </returns>
public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
{
var _patternData = parsedPattern;
FullPathSegment fullPathSegment = _patternData.FullPathSegment;
Regex urlMatch = _patternData.UrlMatch;
var routeValues = new RouteValueDictionary(values);
foreach (var projection in Projections)
{
if (projection.Value == null)
{
continue;
}
projection.Value.Outgoing(projection.Key, routeValues);
}
var valuesMediator = CreateMediator(requestContext, routeValues, RouteDirection.UrlGeneration);
var parametersToCheck = fullPathSegment.RequiredParameters.Select(p => p.Name).Concat(systemRouteValueKeys);
if (!valuesMediator.MatchConstraints(new HashSet <string>(parametersToCheck)))
{
return(null);
}
var url = ConstructUrl(fullPathSegment, valuesMediator);
if (url == null || !urlMatch.IsMatch(url))
{
return(null);
}
url = url.ToLowerInvariant();
var queryString = BuildQueryString(valuesMediator, routeValues);
if (queryString != null)
{
url += "?" + queryString;
}
var data = new VirtualPathData(this, url);
this.DataTokens.CopyTo(data.DataTokens);
return(data);
}
public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
{
VirtualPathData data = base.GetVirtualPath(requestContext, values);
if (data != null)// && string.IsNullOrWhiteSpace(m_Domain) == false)
{
//data.VirtualPath = String.Concat(m_Domain, data.VirtualPath).ToLower();
if (data.VirtualPath != null)
{
//string p = data.VirtualPath.ToLower().Trim().TrimEnd('/', '\\');
string p = data.VirtualPath.Trim().TrimEnd('/', '\\'); // 这里不能直接做ToLower()，因为会导致query string里参数的值也被转小写了，可能导致业务数据错误
if (m_CutOutUrlFirstSection)
{
string firstSection = requestContext.HttpContext.Items["url_first_section"] as string;
if (string.IsNullOrWhiteSpace(firstSection) == false)
{
if (p.Length > 0)
{
p = string.Concat(firstSection.ToLower(), "/", p);
}
else
{
p = firstSection.ToLower();
}
}
}
if (p.Length > 0)
{
int index = p.IndexOf('?');
if (index < 0)
{
data.VirtualPath = (p + "/").ToLower();
}
else if (index > 0)
{
string p1 = p.Substring(0, index);
p1 = p1.TrimEnd('/', '\\') + "/";
string p2 = p.Substring(index);
data.VirtualPath = (p1.ToLower() + p2);
}
}
}
}
return(data);
}
private VirtualPathData GetVirtualPathForArea(RouteCollection routes, RequestContext requestContext, string name, RouteValueDictionary values, out bool usingAreas)
{
// Copied over from https://github.com/aspnet/AspNetWebStack/blob/master/src/System.Web.Mvc/RouteCollectionExtensions.cs#L53
Guard.NotNull(routes, nameof(routes));
if (!String.IsNullOrEmpty(name))
{
// the route name is a stronger qualifier than the area name, so just pipe it through
usingAreas = false;
return(routes.GetVirtualPath(requestContext, name, values));
}
string targetArea = null;
if (values != null)
{
if (values.TryGetValue("area", out var targetAreaRawValue))
{
targetArea = targetAreaRawValue as string;
}
else
{
// set target area to current area
if (requestContext != null)
{
targetArea = requestContext.RouteData.GetAreaName();
}
}
}
// need to apply a correction to the RVD if areas are in use
RouteValueDictionary correctedValues = values;
RouteCollection filteredRoutes = FilterRouteCollectionByArea(routes, targetArea, out usingAreas);
if (usingAreas)
{
correctedValues = new RouteValueDictionary(values);
correctedValues.Remove("area");
}
VirtualPathData vpd = filteredRoutes.GetVirtualPath(requestContext, correctedValues);
return(vpd);
}
/// <summary>
/// Gets the virtual path to the resource after applying substitutions based on route data.
/// </summary>
public string GetSubstitutedVirtualPath(RequestContext requestContext)
{
string substVirtualPath = VirtualPath.Substring(2); //Trim off ~/
if (!VirtualPath.Contains("{"))
{
return(substVirtualPath);
}
Route route = new Route(substVirtualPath, this);
VirtualPathData vpd = route.GetVirtualPath(requestContext, requestContext.RouteData.Values);
if (vpd == null)
{
return(substVirtualPath);
}
return(vpd.VirtualPath);
}
public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
{
VirtualPathData result = null;
var controller = Convert.ToString(values["controller"]);
var action = Convert.ToString(values["action"]);
if (action.Equals("About", StringComparison.OrdinalIgnoreCase))
{
if (controller.Equals("Home", StringComparison.OrdinalIgnoreCase) ||
controller.Equals("Alternate", StringComparison.OrdinalIgnoreCase))
{
return(new VirtualPathData(this, "home/about"));
}
}
// IMPORTANT: Always return null if there is no match.
// This tells .NET routing to check the next route that is registered.
return(result);
}
public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
{
VirtualPathData result = null;
PageInfo page = null;
// Get all of the pages from the cache.
var pages = GetPageList(requestContext.HttpContext);
if (TryFindMatch(pages, values, out page))
{
if (!string.IsNullOrEmpty(page.VirtualPath))
{
result = new VirtualPathData(this, page.VirtualPath);
}
}
// 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)
{
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);
}
/// <summary>
/// Returns information about the URL that is associated with the route.
/// </summary>
/// <param name="requestContext">An object that encapsulates information about the requested route.</param>
/// <param name="values">An object that contains the parameters for a route.</param>
/// <returns>
/// An object that contains information about the URL that is associated with the route.
/// </returns>
public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
{
VirtualPathData data = base.GetVirtualPath(requestContext, values);
if (data != null && DataSettings.DatabaseIsInstalled() && SeoFriendlyUrlsForLanguagesEnabled)
{
var helper = new LocalizedUrlHelper(requestContext.HttpContext.Request, true);
if (helper.IsLocalizedUrl(out string cultureCode))
{
if (!requestContext.RouteData.Values.ContainsKey("StripInvalidSeoCode"))
{
data.VirtualPath = String.Concat(cultureCode, "/", data.VirtualPath).TrimEnd('/');
}
}
}
return(data);
}
private string GeneratePageLink(string linkText, int pageNumber)
{
var pageLinkValueDictionary = new RouteValueDictionary(this.linkWithoutPageValuesDictionary);
pageLinkValueDictionary.Add("page", pageNumber);
VirtualPathData virtualPathData = this.viewContext.RouteData.Route.GetVirtualPath(this.viewContext.RequestContext, pageLinkValueDictionary);
if (virtualPathData != null)
{
string linkFormat = "<a href=\"/{0}\">{1}</a>";
return(string.Format(linkFormat, virtualPathData.VirtualPath, linkText));
}
else
{
return(null);
}
}
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 void UrlHelper_MvcAppGeneratesApiRoute_WithSpecialHttpRouteKey(WhichRoute whichRoute)
{
// Mixed mode app with MVC generating URLs to Web APIs
RouteCollection routes;
RequestContext requestContext;
var url = GetUrlHelperForMixedApp(whichRoute, out routes, out requestContext);
// Note: This is generating a URL the "hard" way because it's simulating what a regular MVC
// app would do when generating a URL. If we went through the Web API functionality it wouldn't
// be testing what would really happen in a mixed app.
VirtualPathData virtualPathData = routes.GetVirtualPath(requestContext, new RouteValueDictionary(new { controller = "something", action = "someotheraction", id = 789, httproute = true }));
Assert.NotNull(virtualPathData);
string generatedUrl = virtualPathData.VirtualPath;
Assert.Equal("$APP$/SOMEAPP/api/something/someotheraction", generatedUrl);
}
/// <summary>
/// Generates the URL using the specified components.
/// </summary>
/// <param name="protocol">The protocol.</param>
/// <param name="host">The host.</param>
/// <param name="pathData">The <see cref="VirtualPathData"/>.</param>
/// <param name="fragment">The URL fragment.</param>
/// <returns>The generated URL.</returns>
protected virtual string GenerateUrl(string protocol, string host, VirtualPathData pathData, string fragment)
{
if (pathData == null)
{
return(null);
}
// VirtualPathData.VirtualPath returns string.Empty instead of null.
Debug.Assert(pathData.VirtualPath != null);
var builder = GetStringBuilder();
try
{
if (string.IsNullOrEmpty(protocol) && string.IsNullOrEmpty(host))
{
AppendPathAndFragment(builder, pathData, fragment);
// We're returning a partial URL (just path + query + fragment), but we still want it to be rooted.
if (builder.Length == 0 || builder[0] != '/')
{
builder.Insert(0, '/');
}
}
else
{
protocol = string.IsNullOrEmpty(protocol) ? "http" : protocol;
builder.Append(protocol);
builder.Append("://");
host = string.IsNullOrEmpty(host) ? HttpContext.Request.Host.Value : host;
builder.Append(host);
AppendPathAndFragment(builder, pathData, fragment);
}
var path = builder.ToString();
return(path);
}
finally
{
// Clear the StringBuilder so that it can reused for the next call.
builder.Clear();
}
}
public void GetVirtualPath_WithoutSubolder_ReturnsUrlWithoutSubfolder()
{
//arrange
var route = new PageRoute("archive/{slug}.aspx", "~/aspx/Dtp.aspx", null,
new Mock <ISubtextPageBuilder>().Object, new Mock <IDependencyResolver>().Object);
var httpContext = new Mock <HttpContextBase>();
httpContext.FakeRequest("~/archive/slug.aspx");
var routeData = new RouteData();
var requestContext = new RequestContext(httpContext.Object, routeData);
//act
VirtualPathData virtualPath = route.GetVirtualPath(requestContext,
new RouteValueDictionary(new { slug = "test-slug" }));
//assert
Assert.IsNotNull(virtualPath);
Assert.AreEqual("archive/test-slug.aspx", virtualPath.VirtualPath);
}
/// <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);
}
}
public void Constructor_CopiesDataTokens()
{
// Arrange
var router = Mock.Of<IRouter>();
var path = "/virtual path";
var dataTokens = new RouteValueDictionary();
dataTokens["TestKey"] = "TestValue";
// Act
var pathData = new VirtualPathData(router, path, dataTokens);
// Assert
Assert.Same(router, pathData.Router);
Assert.Equal(path, pathData.VirtualPath);
Assert.NotNull(pathData.DataTokens);
Assert.Equal("TestValue", pathData.DataTokens["TestKey"]);
Assert.Equal(1, pathData.DataTokens.Count);
Assert.NotSame(dataTokens, pathData.DataTokens);
}
private string GetActionUrl(string actionName)
{
string controllerName = _controllerType.Name;
if (controllerName.EndsWith("Controller", StringComparison.OrdinalIgnoreCase))
{
controllerName = controllerName.Remove(controllerName.Length - 10, 10);
}
RouteValueDictionary values = new RouteValueDictionary();
values = values ?? new RouteValueDictionary();
values.Add("controller", controllerName);
values.Add("action", actionName);
VirtualPathData vpd = RouteTable.Routes.GetVirtualPath(_helper.ViewContext.RequestContext, values);
return((vpd == null) ? null : vpd.VirtualPath);
}
public void AppendPathAndFragment_AppendsFragments(
string appBase,
string virtualPath,
string expected)
{
// Arrage
var fragmentValue = "fragment-value";
expected += $"#{fragmentValue}";
var router = Mock.Of<IRouter>();
var pathData = new VirtualPathData(router, virtualPath)
{
VirtualPath = virtualPath
};
var urlHelper = CreateUrlHelper(appBase, router);
var builder = new StringBuilder();
// Act
urlHelper.AppendPathAndFragment(builder, pathData, fragmentValue);
// Assert
Assert.Equal(expected, builder.ToString());
}
public void AppendPathAndFragment_HandlesLeadingAndTrailingSlashes(
string appBase,
string virtualPath,
string expected)
{
// Arrage
var router = Mock.Of<IRouter>();
var pathData = new VirtualPathData(router, virtualPath)
{
VirtualPath = virtualPath
};
var urlHelper = CreateUrlHelper(appBase, router);
var builder = new StringBuilder();
// Act
urlHelper.AppendPathAndFragment(builder, pathData, string.Empty);
// Assert
Assert.Equal(expected, builder.ToString());
}
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;
}
public void GenerateUrl_FastAndSlowPathsReturnsExpected(
string appBase,
string protocol,
string host,
string virtualPath,
string fragment,
string expected)
{
// Arrage
var router = Mock.Of<IRouter>();
var pathData = new VirtualPathData(router, virtualPath)
{
VirtualPath = virtualPath
};
var urlHelper = CreateUrlHelper(appBase, router);
// Act
var url = urlHelper.GenerateUrl(protocol, host, pathData, fragment);
// Assert
Assert.Equal(expected, url);
}
public new string GenerateUrl(string protocol, string host, VirtualPathData pathData, string fragment)
{
return base.GenerateUrl(
protocol,
host,
pathData,
fragment);
}
private VirtualPathData NormalizeVirtualPath(VirtualPathData pathData)
{
if (pathData == null)
{
return pathData;
}
var url = pathData.VirtualPath;
if (!string.IsNullOrEmpty(url) && (_options.LowercaseUrls || _options.AppendTrailingSlash))
{
var indexOfSeparator = url.IndexOfAny(new char[] { '?', '#' });
var urlWithoutQueryString = url;
var queryString = string.Empty;
if (indexOfSeparator != -1)
{
urlWithoutQueryString = url.Substring(0, indexOfSeparator);
queryString = url.Substring(indexOfSeparator);
}
if (_options.LowercaseUrls)
{
urlWithoutQueryString = urlWithoutQueryString.ToLowerInvariant();
}
if (_options.AppendTrailingSlash && !urlWithoutQueryString.EndsWith("/"))
{
urlWithoutQueryString += "/";
}
// queryString will contain the delimiter ? or # as the first character, so it's safe to append.
url = urlWithoutQueryString + queryString;
return new VirtualPathData(pathData.Router, url, pathData.DataTokens);
}
return pathData;
}
private bool TryFastGenerateUrl(
string protocol,
string host,
VirtualPathData pathData,
string fragment,
out string url)
{
var pathBase = HttpContext.Request.PathBase;
url = null;
if (string.IsNullOrEmpty(protocol)
&& string.IsNullOrEmpty(host)
&& string.IsNullOrEmpty(fragment)
&& !pathBase.HasValue)
{
if (pathData.VirtualPath.Length == 0)
{
url = "/";
return true;
}
else if (pathData.VirtualPath.StartsWith("/", StringComparison.Ordinal))
{
url = pathData.VirtualPath;
return true;
}
}
return false;
}
/// <summary>
/// Generates the URL using the specified components.
/// </summary>
/// <param name="protocol">The protocol.</param>
/// <param name="host">The host.</param>
/// <param name="pathData">The <see cref="VirtualPathData"/>.</param>
/// <param name="fragment">The URL fragment.</param>
/// <returns>The generated URL.</returns>
protected virtual string GenerateUrl(string protocol, string host, VirtualPathData pathData, string fragment)
{
if (pathData == null)
{
return null;
}
// VirtualPathData.VirtualPath returns string.Empty instead of null.
Debug.Assert(pathData.VirtualPath != null);
// Perf: In most of the common cases, GenerateUrl is called with a null protocol, host and fragment.
// In such cases, we might not need to build any URL as the url generated is mostly same as the virtual path available in pathData.
// For such common cases, this FastGenerateUrl method saves a string allocation per GenerateUrl call.
string url;
if (TryFastGenerateUrl(protocol, host, pathData, fragment, out url))
{
return url;
}
var builder = GetStringBuilder();
try
{
if (string.IsNullOrEmpty(protocol) && string.IsNullOrEmpty(host))
{
AppendPathAndFragment(builder, pathData, fragment);
// We're returning a partial URL (just path + query + fragment), but we still want it to be rooted.
if (builder.Length == 0 || builder[0] != '/')
{
builder.Insert(0, '/');
}
}
else
{
protocol = string.IsNullOrEmpty(protocol) ? "http" : protocol;
builder.Append(protocol);
builder.Append("://");
host = string.IsNullOrEmpty(host) ? HttpContext.Request.Host.Value : host;
builder.Append(host);
AppendPathAndFragment(builder, pathData, fragment);
}
var path = builder.ToString();
return path;
}
finally
{
// Clear the StringBuilder so that it can reused for the next call.
builder.Clear();
}
}
// Internal for unit testing.
internal void AppendPathAndFragment(StringBuilder builder, VirtualPathData pathData, string fragment)
{
var pathBase = HttpContext.Request.PathBase;
if (!pathBase.HasValue)
{
if (pathData.VirtualPath.Length == 0)
{
builder.Append("/");
}
else
{
if (!pathData.VirtualPath.StartsWith("/", StringComparison.Ordinal))
{
builder.Append("/");
}
builder.Append(pathData.VirtualPath);
}
}
else
{
if (pathData.VirtualPath.Length == 0)
{
builder.Append(pathBase.Value);
}
else
{
builder.Append(pathBase.Value);
if (pathBase.Value.EndsWith("/", StringComparison.Ordinal))
{
builder.Length--;
}
if (!pathData.VirtualPath.StartsWith("/", StringComparison.Ordinal))
{
builder.Append("/");
}
builder.Append(pathData.VirtualPath);
}
}
if (!string.IsNullOrEmpty(fragment))
{
builder.Append("#").Append(fragment);
}
}
/// <summary>
/// Generates the URL using the specified components.
/// </summary>
/// <param name="protocol">The protocol.</param>
/// <param name="host">The host.</param>
/// <param name="pathData">The <see cref="VirtualPathData"/>.</param>
/// <param name="fragment">The URL fragment.</param>
/// <returns>The generated URL.</returns>
protected virtual string GenerateUrl(string protocol, string host, VirtualPathData pathData, string fragment)
{
if (pathData == null)
{
return null;
}
// VirtualPathData.VirtualPath returns string.Empty instead of null.
Debug.Assert(pathData.VirtualPath != null);
var builder = GetStringBuilder();
try
{
if (string.IsNullOrEmpty(protocol) && string.IsNullOrEmpty(host))
{
AppendPathAndFragment(builder, pathData, fragment);
// We're returning a partial URL (just path + query + fragment), but we still want it to be rooted.
if (builder.Length == 0 || builder[0] != '/')
{
builder.Insert(0, '/');
}
}
else
{
protocol = string.IsNullOrEmpty(protocol) ? "http" : protocol;
builder.Append(protocol);
builder.Append("://");
host = string.IsNullOrEmpty(host) ? HttpContext.Request.Host.Value : host;
builder.Append(host);
AppendPathAndFragment(builder, pathData, fragment);
}
var path = builder.ToString();
return path;
}
finally
{
// Clear the StringBuilder so that it can reused for the next call.
builder.Clear();
}
}
