private static RouteData CreateRouteData(RouteBase route, RouteValueDictionary routeValues, RouteValueDictionary dataTokens, ViewContext parentViewContext) { RouteData routeData = new RouteData(); foreach (KeyValuePair <string, object> kvp in routeValues) { routeData.Values.Add(kvp.Key, kvp.Value); } foreach (KeyValuePair <string, object> kvp in dataTokens) { routeData.DataTokens.Add(kvp.Key, kvp.Value); } routeData.Route = route; routeData.DataTokens[ControllerContext.ParentActionViewContextToken] = parentViewContext; // It's possible that the outgoing route is a direct route - in which case it's not possible to reach using // the action name and controller name. We need to check for that case to determine if we need to create a // 'direct route' routedata to reach it. if (route.IsDirectRoute()) { return(RouteCollectionRoute.CreateDirectRouteMatch(route, new List <RouteData>() { routeData })); } else { return(routeData); } }
/// <summary>Calculates a route base for a given origin and destination.</summary> /// <param name="originPoint">The origin point.</param> /// <param name="destinationPoint">The destination point.</param> /// <returns>The route base.</returns> private async Task <RouteBase> CalculateRouteBaseAsync(string originPoint, string destinationPoint) { // Error if origin and destination are the same point PointsValidation.ValidateEqualPointsAsync(originPoint, destinationPoint); // Error if point description does not exist var origin = await PointsValidation.ValidatePointExistsAsync(_pointRepository, originPoint); var destination = await PointsValidation.ValidatePointExistsAsync(_pointRepository, destinationPoint); var routeBase = new RouteBase { Origin = origin, Destination = destination }; // Error if route base with such points does not exist await ValidateRouteBaseExistsAsync(routeBase); // Error if there is not any step to begin the route, or if there is not any step to finish the route await ValidateStepStartExistsAsync(origin); await ValidateStepEndExistsAsync(destination); return(routeBase); }
public void RegisterController_DesignerController_NotRegistersAnyRoutes() { // Arrange var initializer = new DummyControllerContainerInitializer(); Type controller = typeof(DesignerController); using (new ObjectFactoryContainerRegion()) { ObjectFactory.Container.RegisterType <ConfigManager, ConfigManager>(typeof(XmlConfigProvider).Name.ToUpperInvariant(), new InjectionConstructor(typeof(XmlConfigProvider).Name)); ObjectFactory.Container.RegisterType <XmlConfigProvider, DummyConfigProvider>(); // Act initializer.RegisterControllerPublic(controller); } // Assert ControllerInfo registration = ControllerStore.Controllers().SingleOrDefault(c => c.ControllerType == controller); Assert.IsNotNull(registration, "DesignerController was not registered."); RouteBase route = RouteTable.Routes[controller.Name]; Assert.IsNull(route, "Route was registered for the controller."); }
private string GetPath(RouteBase route, string viewName, string[] formats, bool useCache, out string[] strArray) { strArray = null; List <string> pathes = new List <string>(); string virtualPath; foreach (string format in formats) { string path = SiteManager.Current.GetUrlByRoute(route); virtualPath = string.Format(format , viewName , viewName.StartsWith("/") ? string.Empty : path , SiteManager.Current.DistinctName ).Replace("//", "/"); pathes.Add(virtualPath); if (base.VirtualPathProvider.FileExists(virtualPath)) { return(virtualPath); } } strArray = pathes.ToArray(); return(null); }
public async Task Get_PredefinedRouteBase_ReturnsOneRouteBase(string pointOrigin, string pointDestination) { try { var routeBaseFilter = new RouteBase { Origin = new Point { Description = pointOrigin }, Destination = new Point { Description = pointDestination } }; var collectList = await _routeBaseService.GetAsync(routeBaseFilter); var isOne = collectList.Count() == 1; Assert.True(isOne); } catch (AppCustomException) { Assert.True(false); } }
public RedirectRoute(RouteBase sourceRoute, RouteBase targetRoute, bool permanent, Func <RequestContext, RouteValueDictionary> additionalRouteValues) { SourceRoute = sourceRoute; TargetRoute = targetRoute; Permanent = permanent; AdditionalRouteValuesFunc = additionalRouteValues; }
public RedirectRoute(RouteBase sourceRoute, RouteBase targetRoute, bool permanent, RouteValueDictionary additionalRouteValues) { SourceRoute = sourceRoute; TargetRoute = targetRoute; Permanent = permanent; AdditionalRouteValues = additionalRouteValues; }
/// <summary>Validates if the route base already exists.</summary> /// <param name="routeBaseCheck">The route base to check.</param> private async Task ValidateRouteBaseAlreadyExistsAsync(RouteBase routeBaseCheck) { if ((await _routeBaseRepository.GetAsync(routeBaseCheck)).Any()) { throw AppCustomExceptions.RouteBaseAlreadyExists; } }
protected void Page_Load(object sender, EventArgs e) { // Determine current view bool isMobile = WebFormsFriendlyUrlResolver.IsMobileView(new HttpContextWrapper(Context)); CurrentView = isMobile ? "Mobile" : "Desktop"; // Determine alternate view AlternateView = isMobile ? "Desktop" : "Mobile"; // Create switch URL from the route, e.g. ~/__FriendlyUrls_SwitchView/Mobile?ReturnUrl=/Page const string switchViewRouteName = "AspNet.FriendlyUrls.SwitchView"; RouteBase switchViewRoute = RouteTable.Routes[switchViewRouteName]; if (switchViewRoute == null) { // Friendly URLs is not enabled or the name of the switch view route is out of sync Visible = false; return; } string url = GetRouteUrl(switchViewRouteName, new { view = AlternateView, __FriendlyUrls_SwitchViews = true }); url += "?ReturnUrl=" + HttpUtility.UrlEncode(Request.RawUrl); SwitchUrl = url; }
private Type GetControllerTypeWithinNamespaces( RouteBase route, string controllerName, HashSet <string> namespaces ) { // Once the master list of controllers has been created we can quickly index into it ControllerTypeCache.EnsureInitialized(BuildManager); ICollection <Type> matchingTypes = ControllerTypeCache.GetControllerTypes( controllerName, namespaces ); switch (matchingTypes.Count) { case 0: // no matching types return(null); case 1: // single matching type return(matchingTypes.First()); default: // multiple matching types throw CreateAmbiguousControllerException(route, controllerName, matchingTypes); } }
internal static InvalidOperationException CreateAmbiguousControllerException(RouteBase route, string controllerName, ICollection <Type> matchingTypes) { // we need to generate an exception containing all the controller types StringBuilder typeList = new StringBuilder(); foreach (Type matchedType in matchingTypes) { typeList.AppendLine(); typeList.Append(matchedType.FullName); } string errorText; Route castRoute = route as Route; if (castRoute != null) { errorText = String.Format(CultureInfo.CurrentCulture, MvcResources.DefaultControllerFactory_ControllerNameAmbiguous_WithRouteUrl, controllerName, castRoute.Url, typeList, Environment.NewLine); } else { errorText = String.Format(CultureInfo.CurrentCulture, MvcResources.DefaultControllerFactory_ControllerNameAmbiguous_WithoutRouteUrl, controllerName, typeList, Environment.NewLine); } return(new InvalidOperationException(errorText)); }
public async Task UpdateAsync(RouteBase routeBaseUpdate) { // Error if route base does not exist var routeBase = await ValidateRouteBaseExistsAsync(routeBaseUpdate.Id); var routeBaseControl = routeBase; // Error if origin and destination are the same point PointsValidation.ValidateEqualPointsAsync(routeBaseUpdate.Origin?.Description, routeBaseUpdate.Destination?.Description); if (!string.IsNullOrWhiteSpace(routeBaseUpdate.Origin?.Description)) { // Error if point description does not exist var origin = await PointsValidation.ValidatePointExistsAsync(_pointRepository, routeBaseUpdate.Origin.Description); routeBase.Origin = origin; } if (!string.IsNullOrWhiteSpace(routeBaseUpdate.Destination?.Description)) { // Error if point description does not exist var destination = await PointsValidation.ValidatePointExistsAsync(_pointRepository, routeBaseUpdate.Destination.Description); routeBase.Destination = destination; } // Error if route base with such points already exists await ValidateRouteBaseAlreadyExistsAsync(routeBase); await _routeBaseRepository.UpdateAsync(routeBase); RemoveDependentObjectsFromCache(routeBaseControl); }
private static IContentRoute MapCategoryRoute(this RouteCollection routes, string insertAfterRouteName, string name, string url, object defaults, Func<SiteDefinition, ContentReference> contentRootResolver) { var basePathResolver = ServiceLocator.Current.GetInstance<IBasePathResolver>(); var urlSegmentRouter = ServiceLocator.Current.GetInstance<IUrlSegmentRouter>(); var contentLoader = ServiceLocator.Current.GetInstance<IContentLoader>(); urlSegmentRouter.RootResolver = contentRootResolver; Func<RequestContext, RouteValueDictionary, string> resolver = basePathResolver.Resolve; var contentRouteParameters = new MapContentRouteParameters { UrlSegmentRouter = urlSegmentRouter, BasePathResolver = resolver, Direction = SupportedDirection.Both, Constraints = new { node = new ContentTypeConstraint<CategoryData>(contentLoader) } }; RouteBase mediaRoute = RouteTable.Routes[insertAfterRouteName]; int insertIndex = mediaRoute != null ? RouteTable.Routes.IndexOf(mediaRoute) + 1 : RouteTable.Routes.Count; var route = routes.MapContentRoute(name, url, defaults, contentRouteParameters) as DefaultContentRoute; routes.Remove(route); routes.Insert(insertIndex, route); return route; }
/// <summary> /// Check whether the specified route should be exposed in the JavaScript output /// </summary> /// <param name="routeBase">Route to check</param> /// <returns><c>false</c> if the route should definitely be blocked, <c>true</c> if the route should be exposed (or unsure)</returns> public bool AllowRoute(RouteBase routeBase) { var route = routeBase as Route; if (route == null) { return(true); } // WebForms - Not supported if (route.RouteHandler is PageRouteHandler) { return(false); } // Ignore routes if (route.RouteHandler is StopRoutingHandler) { return(false); } // ASP.NET WebAPI (https://github.com/Daniel15/RouteJs/issues/9) // Ugly hack so we don't have to reference the WebAPI assembly for now. if (route.GetType().FullName == "System.Web.Http.WebHost.Routing.HttpWebRoute") { return(false); } return(true); }
RouteModel CreateRouteModelData(String name, RouteBase rr, int index) { RouteModel rm = CreateModel(rr, index); rm.Name = name; return(rm); }
public void ReturnOneMethod(IProxyFactory proxyFactory, ILogger logger) { var alternationImplementation = new RouteBase(proxyFactory, logger); Assert.Equal(2, alternationImplementation.AllMethodsRouteBase.Count()); Assert.Equal(3, alternationImplementation.AllMethodsRoute.Count()); }
public static RouteData CreateDirectRouteMatch(RouteBase route, List <RouteData> matches) { if (matches.Count == 0) { return(null); } else { var routeData = new RouteData(); routeData.Route = route; routeData.RouteHandler = new MvcRouteHandler(); routeData.SetDirectRouteMatches(matches); // At a few points in the code (MvcRouteHandler, MvcHandler) we need to look up the controller // by name. For the purposes of error handling/debugging, it's helpful if we can have a name // in this code to pass through. // // Inside the DefaultControllerFactory we'll double check the route data and throw if we have // multiple controller matches, but for now let's just use the controller of the first match. ControllerDescriptor controllerDescriptor = matches[0].GetTargetControllerDescriptor(); if (controllerDescriptor != null) { routeData.Values[RouteDataTokenKeys.Controller] = controllerDescriptor.ControllerName; } return(routeData); } }
public async Task <RouteBase> CreateAsync(RouteBase routeBase) { // Error if origin and destination are the same point PointsValidation.ValidateEqualPointsAsync(routeBase.Origin?.Description, routeBase.Destination?.Description); // Error if point description does not exist var origin = await PointsValidation.ValidatePointExistsAsync(_pointRepository, routeBase.Origin?.Description); var destination = await PointsValidation.ValidatePointExistsAsync(_pointRepository, routeBase.Destination?.Description); var routeBaseToAdd = new RouteBase { Origin = origin, Destination = destination }; // Error if route base with such points already exists await ValidateRouteBaseAlreadyExistsAsync(routeBaseToAdd); await _routeBaseRepository.AddAsync(routeBaseToAdd); var routeBases = await _routeBaseRepository.GetAsync(); var routeReturn = routeBases.FirstOrDefault(x => (x.Origin?.Description?.Equals(routeBaseToAdd.Origin.Description) == true || x.OriginId == routeBaseToAdd.OriginId) && (x.Destination?.Description?.Equals(routeBaseToAdd.Destination.Description) == true || x.DestinationId == routeBaseToAdd.DestinationId)); return(routeReturn); }
/// <summary> /// Creates the ambiguous controller exception. /// </summary> /// <param name="route">The route.</param> /// <param name="controllerName">Name of the controller.</param> /// <param name="matchingTypes">The matching types.</param> /// <returns></returns> internal static InvalidOperationException CreateAmbiguousControllerException(RouteBase route, string controllerName, ICollection <Type> matchingTypes) { StringBuilder stringBuilder = new StringBuilder(); foreach (Type current in matchingTypes) { stringBuilder.AppendLine(); stringBuilder.Append(current.FullName); } Route route2 = route as Route; string message; if (route2 != null) { message = string.Format(CultureInfo.CurrentUICulture, "The request for '{0}' has found the following matching controllers:{2}\r\n\r\nMultiple types were found that match the controller named '{0}'. This can happen if the route that services this request does not specify namespaces to search for a controller that matches the request. If this is the case, register this route by calling an overload of the 'MapRoute' method that takes a 'namespaces' parameter.", new object[] { controllerName, route2.Url, stringBuilder }); } else { message = string.Format(CultureInfo.CurrentUICulture, "The request for '{0}' has found the following matching controllers:{2}\r\n\r\nMultiple types were found that match the controller named '{0}'.", new object[] { controllerName, stringBuilder }); } return(new InvalidOperationException(message)); }
public LocalResourceUrlManager(DotvvmConfiguration configuration, IResourceHashService hasher) { this.resourceRoute = new DotvvmRoute("dotvvmResource/{hash}/{name:regex(.*)}", null, null, null, configuration); this.hasher = hasher; this.resources = configuration.Resources; this.alternateDirectories = configuration.Debug ? new ConcurrentDictionary <string, string>() : null; this.suppressVersionHash = configuration.Debug; }
public static void MapRoute(string routeName, RouteBase route) { // note_ route name can be null or empty Guard.ArgumentNotNull(route, "route"); // and we add RouteTable.Routes.Add(routeName, route); }
protected override void InsertItem(Int32 index, RouteBase item) { if (EnableRestrictions) { throw new Exception("Unexpected route added".); } base.InsertItem(index, item); }
protected override void SetItem(Int32 index, RouteBase item) { if (EnableRestrictions) { throw new Exception("Unexpected change of RouteCollection item."); } base.SetItem(index, item); }
protected virtual string GetAreaName(RouteBase route) { if (route is Route route2 && route2.DataTokens != null) { return(route2.DataTokens["area"] as string); } return(null); }
internal static Route ShouldBeRoute(this RouteBase subject, Route expected) { subject.Should().NotBeNull().And.BeAssignableTo <Route>(); var route = subject as Route; route.ShouldBeEquivalentTo(expected, o => o.Excluding(r => r.RouteHandler)); return(route); }
protected internal virtual Type GetControllerType(RequestContext requestContext, string controllerName) { if (requestContext == null) { throw new ArgumentNullException("requestContext"); } if (String.IsNullOrEmpty(controllerName) && (requestContext.RouteData == null || !requestContext.RouteData.HasDirectRouteMatch())) { throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName"); } RouteData routeData = requestContext.RouteData; if (routeData != null && routeData.HasDirectRouteMatch()) { return(GetControllerTypeFromDirectRoute(routeData)); } // first search in the current route's namespace collection object routeNamespacesObj; Type match; if (routeData != null && routeData.DataTokens.TryGetValue(RouteDataTokenKeys.Namespaces, out routeNamespacesObj)) { IEnumerable <string> routeNamespaces = routeNamespacesObj as IEnumerable <string>; if (routeNamespaces != null && routeNamespaces.Any()) { HashSet <string> namespaceHash = new HashSet <string>(routeNamespaces, StringComparer.OrdinalIgnoreCase); match = GetControllerTypeWithinNamespaces(routeData.Route, controllerName, namespaceHash); // the UseNamespaceFallback key might not exist, in which case its value is implicitly "true" if (match != null || false.Equals(routeData.DataTokens[RouteDataTokenKeys.UseNamespaceFallback])) { // got a match or the route requested we stop looking return(match); } } } // then search in the application's default namespace collection RouteBase route = routeData == null ? null : routeData.Route; if (ControllerBuilder.DefaultNamespaces.Count > 0) { HashSet <string> namespaceDefaults = new HashSet <string>(ControllerBuilder.DefaultNamespaces, StringComparer.OrdinalIgnoreCase); match = GetControllerTypeWithinNamespaces(route, controllerName, namespaceDefaults); if (match != null) { return(match); } } // if all else fails, search every namespace return(GetControllerTypeWithinNamespaces(route, controllerName, null /* namespaces */)); }
private string GetRouteExistingFiles(RouteBase routeBase) { try { return(routeBase.GetType().InvokeMember("_routeExistingFiles", System.Reflection.BindingFlags.GetField | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance, null, routeBase, null) as string); } catch { } return(String.Empty); }
public virtual RouteBase GetFullPageRoute(RouteBase ampRoute) { if (!RouteMap.TryGetValue(ampRoute, out var fullPageRoute)) { throw new ArgumentException($"Could not find full version of {ampRoute}."); } return(fullPageRoute); }
public void ProcessRequest(HttpContext context) { Logger.Debug("DebugHttpHandler.ProcessRequest"); string format = "<html>\r\n<head>\r\n <title>Route Tester</title>\r\n <style>\r\n body, td, th {{font-family: verdana; font-size: small;}}\r\n .message {{font-size: .9em;}}\r\n caption {{font-weight: bold;}}\r\n tr.header {{background-color: #ffc;}}\r\n label {{font-weight: bold; font-size: 1.1em;}}\r\n .false {{color: #c00;}}\r\n .true {{color: #0c0;}}\r\n </style>\r\n</head>\r\n<body>\r\n<h1>Route Tester</h1>\r\n<div id=\"main\">\r\n <p class=\"message\">\r\n Type in a url in the address bar to see which defined routes match it. \r\n A {{*catchall}} route is added to the list of routes automatically in \r\n case none of your routes match.\r\n </p>\r\n <p><label>Route</label>: {1}</p>\r\n <div style=\"float: left;\">\r\n <table border=\"1\" cellpadding=\"3\" cellspacing=\"0\" width=\"300\">\r\n <caption>Route Data</caption>\r\n <tr class=\"header\"><th>Key</th><th>Value</th></tr>\r\n {0}\r\n </table>\r\n </div>\r\n <div style=\"float: left; margin-left: 10px;\">\r\n <table border=\"1\" cellpadding=\"3\" cellspacing=\"0\" width=\"300\">\r\n <caption>Data Tokens</caption>\r\n <tr class=\"header\"><th>Key</th><th>Value</th></tr>\r\n {4}\r\n </table>\r\n </div>\r\n <hr style=\"clear: both;\" />\r\n <table border=\"1\" cellpadding=\"3\" cellspacing=\"0\">\r\n <caption>All Routes</caption>\r\n <tr class=\"header\">\r\n <th>Matches Current Request</th>\r\n <th>Url</th>\r\n <th>Defaults</th>\r\n <th>Constraints</th>\r\n <th>DataTokens</th>\r\n </tr>\r\n {2}\r\n </table>\r\n <hr />\r\n <strong>AppRelativeCurrentExecutionFilePath</strong>: {3}\r\n</div>\r\n</body>\r\n</html>"; string str2 = string.Empty; RouteData routeData = this.RequestContext.RouteData; RouteValueDictionary values = routeData.Values; RouteBase base2 = routeData.Route; string str3 = string.Empty; using (RouteTable.Routes.GetReadLock()) { foreach (RouteBase base3 in RouteTable.Routes) { bool flag = base3.GetRouteData(this.RequestContext.HttpContext) != null; string str4 = string.Format("<span class=\"{0}\">{0}</span>", flag); string url = "n/a"; string str6 = "n/a"; string str7 = "n/a"; string str8 = "n/a"; Route route = base3 as Route; if (route != null) { url = route.Url; str6 = FormatRouteValueDictionary(route.Defaults); str7 = FormatRouteValueDictionary(route.Constraints); str8 = FormatRouteValueDictionary(route.DataTokens); } str3 = str3 + string.Format("<tr><td>{0}</td><td>{1}</td><td>{2}</td><td>{3}</td><td>{3}</td></tr>", new object[] { str4, url, str6, str7, str8 }); } } string str9 = "n/a"; string str10 = ""; if (base2 is DebugRoute) { str9 = "<strong class=\"false\">NO MATCH!</strong>"; } else { foreach (string str11 in values.Keys) { str2 = str2 + string.Format("\t<tr><td>{0}</td><td>{1} </td></tr>", str11, values[str11]); } foreach (string str11 in routeData.DataTokens.Keys) { str10 = str10 + string.Format("\t<tr><td>{0}</td><td>{1} </td></tr>", str11, routeData.DataTokens[str11]); } Route route2 = base2 as Route; if (route2 != null) { str9 = route2.Url; } } context.Response.Write(string.Format(format, new object[] { str2, str9, str3, context.Request.AppRelativeCurrentExecutionFilePath, str10 })); }
protected virtual string GetAreaName(RouteBase route) { string item; if (!(route is IRouteWithArea routeWithArea)) { if (!(route is Route route1) || route1.DataTokens == null) { item = null; }
private void UpdateRoute(RouteBase.GetRouteData.Message message, ITabSetupContext context) { var model = GetModel(context.GetTabStore()); // string.Empty is a valid routeName if (message.IsMatch && model.MatchedRouteName == null) { // only update the first matched route model.MatchedRouteName = message.RouteName; } }