public void InvalidNames() { { Assert.Throws <ArgumentNullException>(() => new RouteConfiguration().DeclareRoute(new SubRouteConfiguration(null, x => true))); Assert.Throws <ArgumentNullException>(() => new RouteConfiguration().AddAction(new TestActionConfiguration(null))); } RouteConfiguration c; { c = new RouteConfiguration() .DeclareRoute(new SubRouteConfiguration("", x => true) .DeclareRoute(new SubRouteConfiguration("", x => true))); Assert.That(c.Resolve(TestHelper.ConsoleMonitor), Is.Null, "A route name can be empty but not 2 can be empty at the same time. The name of the root RouteConfiguration is always the empty string."); } { c = new RouteConfiguration() .AddAction(new TestActionConfiguration("")); Assert.That(c.Resolve(TestHelper.ConsoleMonitor), Is.Null); } { c = new RouteConfiguration() .AddAction(new TestActionConfiguration("/")); Assert.That(c.Resolve(TestHelper.ConsoleMonitor), Is.Null); } { c = new RouteConfiguration() .AddAction(new TestActionConfiguration("A/B")); Assert.That(c.Resolve(TestHelper.ConsoleMonitor), Is.Null); } }
protected void Application_Start(object sender, EventArgs e) { RouteConfiguration.AddRoutes(RouteTable.Routes); Database.SetInitializer(new DropCreateDatabaseIfModelChanges <Context>()); //Debug.WriteLine("Application_Start"); }
public RouteResolver(IActivityMonitor monitor, RouteConfiguration c) { try { using (monitor.OpenGroup(LogLevel.Info, c.Name.Length > 0 ? string.Format("Resolving root configuration (name is '{0}').", c.Name) : "Resolving root configuration.", null)) { ProtoResolver protoResolver = new ProtoResolver(monitor, c); NamedSubRoutes = new Dictionary <string, SubRouteConfigurationResolved>(); using (monitor.OpenGroup(LogLevel.Info, "Building final routes.", null)) { var preRoot = new PreRoute(monitor, protoResolver.Root); Root = new RouteConfigurationResolved(protoResolver.Root.FullName, c.ConfigData, preRoot.FinalizeActions()); foreach (IProtoSubRoute sub in protoResolver.NamedSubRoutes.Values) { var preRoute = new PreRoute(monitor, sub); NamedSubRoutes.Add(sub.FullName, new SubRouteConfigurationResolved(sub, preRoute.FinalizeActions())); } Root.SubRoutes = protoResolver.Root.SubRoutes.Select(p => NamedSubRoutes[p.FullName]).ToArray(); foreach (IProtoSubRoute sub in protoResolver.NamedSubRoutes.Values) { NamedSubRoutes[sub.FullName].SubRoutes = sub.SubRoutes.Select(p => NamedSubRoutes[p.FullName]).ToArray(); } } } } catch (Exception ex) { monitor.SendLine(LogLevel.Fatal, null, ex); } }
public SendSmsHandler(IMessageBuilder messageBuilder, IMessageHttpService messageHttpService, RouteConfiguration routeConfiguration) { _messageBuilder = messageBuilder; _messageHttpService = messageHttpService; _routeConfiguration = routeConfiguration; }
/// <summary> /// /// </summary> /// <param name="services"></param> public void ConfigureServices(IServiceCollection services) { DbContextConfiguration.AddService(services, Configuration); CorsConfiguration.AddService(services); RouteConfiguration.AddService(services); RouteAnalyzerExtension.AddService(services); services.AddMemoryCache(); services.AddHttpContextAccessor(); services.AddSingleton <IActionContextAccessor, ActionContextAccessor>(); try { // TODO: when use code gen, a exception will occurred. #pragma warning disable 618 AuthenticationConfiguration.AddService(services, Configuration); services.AddAutoMapper(); #pragma warning disable 618 } catch { } WebEncoderConfiguration.AddService(services); ValidateConfiguration.AddService(services); JsonExtension.AddService(services); SetCompatibilityVersionExtension.AddService(services); }
protected void Application_Start(object sender, EventArgs e) { Debug.WriteLine("Application_Start"); RouteConfiguration.AddRoutes(RouteTable.Routes); Database.SetInitializer(new InvoiceInitializer()); }
private IActionResult Get(object id) { ApiConfiguration apiConfiguration = RouteData.DataTokens["apiConfiguration"] as ApiConfiguration; RouteConfiguration route = RouteData.DataTokens["routeConfiguration"] as RouteConfiguration; ActionConfiguration action = RouteData.DataTokens["actionConfiguration"] as ActionConfiguration; if (route.Enabled && action.Enabled) { string sqlQuery = ControllerService.GetStringReplacedQuery(Request, route, action, id); SqlServerService sqlServerService = new SqlServerService(apiConfiguration.ConnectionString, route); DataTable resultSetDataTable = sqlServerService.ExecuteResultQuery(sqlQuery); if (resultSetDataTable.Rows.Count > 0) { return(new OkObjectResult(resultSetDataTable.Rows[0])); } else { return(new NotFoundObjectResult(null)); } } else { Response.StatusCode = 501; return(new ObjectResult(null)); } }
public static RouteConfiguration CreateRoute(string routeName, string clusterName) { var virtualHost = new VirtualHost { Name = "all", }; virtualHost.Domains.Add("*"); virtualHost.Routes.Add(new Route { Match = new RouteMatch { Prefix = "/" }, Route_ = new RouteAction { Cluster = clusterName }, }); var routeConfiguration = new RouteConfiguration { Name = routeName }; routeConfiguration.VirtualHosts.Add(virtualHost); return(routeConfiguration); }
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IApplicationLifetime lifetime) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); app.UseDatabaseErrorPage(); } else { ExceptionHandlerConfig.Config(app); } app.UseStatusCodePagesWithReExecute("/Home/Error/{0}"); app.UseCors(builder => builder.AllowAnyHeader().AllowAnyMethod().AllowAnyOrigin().AllowCredentials() .SetPreflightMaxAge(TimeSpan.FromSeconds(86400))); LocalizationConfiguration.Config(app); app.UseStaticFiles(); app.UseSession(); app.UseForwardedHeaders(new ForwardedHeadersOptions { ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto }); app.UseAuthentication(); RouteConfiguration.Config(app); DbConfiguration.MigrateDb(app); }
public static string GetStringReplacedQuery(HttpRequest request, RouteConfiguration route, ActionConfiguration action, object id, string json = null) { string sqlQuery = GetStringReplacedQuery(request, route, action, json); sqlQuery = sqlQuery.Replace(ID_SYMBOL, id.ToString()); return(sqlQuery); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); GlobalConfiguration.Configure(WebAPIConfiguration.Register); FilterConfiguration.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfiguration.RegisterRoutes(RouteTable.Routes); BundleConfiguration.RegisterBundles(BundleTable.Bundles); }
public ProtoResolver(IActivityMonitor monitor, RouteConfiguration root) { _monitor = monitor; NamedSubRoutes = new Dictionary <string, IProtoSubRoute>(); Route r = new Route(this, root); r.ExecuteMetaConfigurations(); Root = r; }
public static string GetName(this Controller controller) { if (controller == null) { throw new ArgumentNullException(nameof(controller)); } return(RouteConfiguration.GetControllerName(controller.GetType())); }
public void SimpleLogConfigAndDump() { var c = new RouteConfiguration() .AddAction(new ActionSequenceConfiguration("Sequence") .AddAction(new WriteActionConfiguration("n°1") { FileName = @"File n°1" }) .AddAction(new WriteActionConfiguration("n°2") { FileName = @"File n°2" })); Assert.That(_host.ObtainRoute(""), Is.SameAs(FinalRoute.Empty)); Assert.That(_host.ConfigurationAttemptCount, Is.EqualTo(0)); Assert.That(_host.SetConfiguration(TestHelper.ConsoleMonitor, c)); Assert.That(_host.SuccessfulConfigurationCount, Is.EqualTo(1)); _defaultRoute = _host.ObtainRoute(null); Assert.That(_defaultRoute.Actions.Length, Is.EqualTo(1)); Assert.That(_defaultRoute.Actions[0], Is.InstanceOf <TestSequence>()); var f1 = File.AllFiles["File n°1"]; var f2 = File.AllFiles["File n°2"]; Assert.That(f1.IsOpened && f2.IsOpened); _defaultRoute.Run(0); CheckContent(f1, "0"); CheckContent(f2, "0"); _defaultRoute.Run(1); _defaultRoute.Run(2); CheckContent(f1, "0", "1", "2"); CheckContent(f2, "0", "1", "2"); var c2 = new RouteConfiguration() .AddAction(new WriteActionConfiguration("n°1") { FileName = @"File n°1" }); Assert.That(_host.SetConfiguration(TestHelper.ConsoleMonitor, c2)); Assert.That(_host.ConfigurationAttemptCount, Is.EqualTo(2)); Assert.That(_host.SuccessfulConfigurationCount, Is.EqualTo(2)); var r2 = _host.ObtainRoute(null); Assert.That(r2, Is.Not.SameAs(_defaultRoute)); _defaultRoute = r2; _defaultRoute.Run(3); _defaultRoute.Run(4); CheckContent(f1, "0", "1", "2", "3", "4"); CheckContent(f2, "0", "1", "2"); Assert.That(ActivityMonitor.CriticalErrorCollector.ToArray().Length, Is.EqualTo(0)); }
public void RoutesAndActions() { RouteConfiguration c = new RouteConfiguration() .AddAction( new ActionSequenceConfiguration("FirstGroup") .AddAction(new TestActionConfiguration("Sink1")) .AddAction(new TestActionConfiguration("Sink2")) .AddAction(new ActionParallelConfiguration("Parallel n°1") .AddAction(new TestActionConfiguration("Sink3")) .AddAction(new TestActionConfiguration("Sink4"))) .AddAction(new ActionParallelConfiguration("Parallel n°2") .AddAction(new TestActionConfiguration("Sink3")) .AddAction(new TestActionConfiguration("Sink4")))) .AddAction(new TestActionConfiguration("SecondGlobal")) .DeclareRoute( new SubRouteConfiguration("CKTask", name => name.StartsWith("CKTask:")) .AddAction(new TestActionConfiguration("TaskSink")) .RemoveAction("SecondGlobal")) .AddAction(new TestActionConfiguration("ForAllExceptCKTask")) .DeclareRoute( new SubRouteConfiguration("Request", name => name.Contains("/request/")) .RemoveAction("FirstGroup") .AddAction(new TestActionConfiguration("RequestSink")) .AddAction(new TestActionConfiguration("AnotherRequestSink")) .DeclareRoute( new SubRouteConfiguration("NoBugInRequest", name => name.Contains("/BugFree/")) { ImportParentActions = false })); var resolved = c.Resolve(TestHelper.ConsoleMonitor); Assert.That(resolved, Is.Not.Null); Assert.That(resolved.AllSubRoutes.Count, Is.EqualTo(3)); var root = resolved.Root; Assert.That(root, Is.Not.Null); Assert.That(root.ActionsResolved, Is.Not.Null.And.Count.EqualTo(3)); var ckTask = resolved.FindSubRouteByName("CKTask"); Assert.That(ckTask, Is.Not.Null); Assert.That(ckTask.ActionsResolved, Is.Not.Null.And.Count.EqualTo(2)); var request = resolved.FindSubRouteByName("Request"); Assert.That(request, Is.Not.Null); Assert.That(request.ActionsResolved, Is.Not.Null.And.Count.EqualTo(4)); var noBug = resolved.FindSubRouteByName("NoBugInRequest"); Assert.That(noBug, Is.Not.Null); Assert.That(noBug.ActionsResolved, Is.Not.Null.And.Count.EqualTo(0)); }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); FilterConfiguration.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfiguration.RegisterRoutes(RouteTable.Routes); var container = MvcApplication.CreateContainer(); DependencyResolver.SetResolver(new AutofacDependencyResolver(container)); }
/// <summary> /// Initializes a new instance of the <see cref="ControllerLessHttpHandler"/> class. /// </summary> /// <param name="requestContext">The requestContext to be used in this instance.</param> public ControllerLessHttpHandler(RequestContext requestContext) { _requestContext = requestContext; _configuration = RouteConfiguration.GetConfigurationSettings(); var target = typeof(ControllerLessHttpHandler).Namespace; if (!ControllerBuilder.Current.DefaultNamespaces.Contains(target)) { ControllerBuilder.Current.DefaultNamespaces.Add(target); } }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); FiltersConfiguration.RegisterGlobalFilters(GlobalFilters.Filters); RouteTable.Routes.RegisterRobotsTxt(); RouteConfiguration.RegisterRoutes(RouteTable.Routes); BundleConfiguration.RegisterBundles(BundleTable.Bundles); }
public void Given_Path_Mismatch_Request_Router_Finds_NoConfiguredRoute() { // Arrange Request request = new Request("/api/testing/router/targets/1", HttpRequestMethod.GET); // Act RouteConfiguration routeConfiguration = GuardianRouter.GetConfiguredRoute(request); // Assert routeConfiguration.Should().BeNull(); }
public IRouteTableConfigurator AddRoute(string name, string template, params RouteConfigurationParameter[] defaultParameters) { var routeConfiguration = new RouteConfiguration { Name = name, Template = template, DefaultParameters = defaultParameters }; return AddRoute(routeConfiguration); }
Route( RouteConfiguration c, Route parent, ProtoResolver r ) { _resolver = r; _parent = parent; _configuration = c; _routeDepth = 0; _namespace = c.Namespace; _fullName = c.Namespace + c.Name; _declaredActions = new Dictionary<string, ProtoDeclaredAction>(); _metaConfigurations = new List<MetaConfiguration>(); _subRoutes = new List<Route>(); }
Route(RouteConfiguration c, Route parent, ProtoResolver r) { _resolver = r; _parent = parent; _configuration = c; _routeDepth = 0; _namespace = c.Namespace; _fullName = c.Namespace + c.Name; _declaredActions = new Dictionary <string, ProtoDeclaredAction>(); _metaConfigurations = new List <MetaConfiguration>(); _subRoutes = new List <Route>(); }
/// <summary> /// Initializes a new instance of the <see cref="ControllerLessHttpHandler"/> class. /// </summary> /// <param name="requestContext">The requestContext to be used in this instance.</param> public ControllerLessHttpHandler(RequestContext requestContext) { _requestContext = requestContext; _configuration = RouteConfiguration.GetConfigurationSettings(); var target = typeof(ControllerLessHttpHandler).Namespace; if (!ControllerBuilder.Current.DefaultNamespaces.Contains(target)) { ControllerBuilder.Current.DefaultNamespaces.Add(target); } }
private static IHandlerBuilder?GetContent(RouteConfiguration config) { if (config.Destination != null) { return(Proxy.Create() .Upstream(config.Destination) .ConnectTimeout(TimeSpan.FromMinutes(3)) .ReadTimeout(TimeSpan.FromMinutes(3))); } return(null); }
private string BuildPropertyString(RouteConfiguration route) { string result = string.Empty; if (route != null && route.Parameter != null && route.Parameter.Parameters != null && route.Parameter.Parameters.Count > 0) { StringBuilder sb = new StringBuilder(500); string propertyString = null; ParameterConfiguraiton parameter = null; for (int i = 0; i < route.Parameter.Parameters.Count; i++) { parameter = route.Parameter.Parameters[i]; if (parameter == null || string.IsNullOrWhiteSpace(parameter.Name)) { continue; } if (parameter.Optional) { propertyString = string.Format("{0} = {1}", parameter.Name, "System.Web.Mvc.UrlParameter.Optional"); } else { if (typeof(string) == Type.GetType(parameter.Type)) { propertyString = string.Format("{0} = \"{1}\"", parameter.Name, parameter.Value); } else if (typeof(char) == Type.GetType(parameter.Type)) { propertyString = string.Format("{0} = '{1}'", parameter.Name, parameter.Value); } else { if (string.IsNullOrWhiteSpace(parameter.Value)) { continue; } propertyString = string.Format("{0} = {1}", parameter.Name, parameter.Value); } } sb.Append(propertyString); sb.Append(","); } result = PropertyStringFormat.Replace("#name#", route.Name).Replace("#content#", sb.ToString().Remove(sb.Length - 1, 1)); } return(result); }
private void LoadSteps(RouteConfiguration config) { RouteStationConfiguration stationConfig = m_station.GetConfigurationFor(config); if (stationConfig == null) { stationConfig = m_station.AddConfiguration(config); } m_activeConfig = stationConfig; stepsGrid.Enabled = true; stepsGrid.DataSource = stationConfig.Steps; }
public void Given_Request_Router_Finds_ConfiguredRoute() { // Arrange Request request = new Request("/api/testing/router/target/1", HttpRequestMethod.GET); // Act RouteConfiguration routeConfiguration = GuardianRouter.GetConfiguredRoute(request); // Assert routeConfiguration.Should().NotBeNull(); routeConfiguration.Path.Should().Be(@"^/api/testing/router/target/"); routeConfiguration.RequestMethod.Should().Be(HttpRequestMethod.GET); }
void routeConfigLookUp_EditValueChanged(object sender, EventArgs e) { RouteConfiguration config = routeConfigLookUp.EditValue as RouteConfiguration; if (config != null) { LoadSteps(config); return; } m_activeConfig = null; stepsGrid.Enabled = false; }
/// <summary> /// Configure a route in the stub. /// </summary> /// <param name="verb">The HTTP verb of the route you wish to configure.</param> /// <param name="route">The HTTP route that you wish to configure.</param> /// <param name="configuration">A route configuration object.</param> /// <returns></returns> /// <exception cref="HttpRequestException"></exception> public async Task ConfigureRouteAsync(HttpMethod verb, string route, RouteConfiguration configuration) { route = route.TrimStart('/'); var requestUri = $"{stubBaseUrl}/Stub/{verb}/api/{route}"; var jsonConfiguration = JsonConvert.SerializeObject(configuration); var response = await httpClient.PostAsync(requestUri, new StringContent(jsonConfiguration)); if (!response.IsSuccessStatusCode) { throw new HttpRequestException($"Response from: {requestUri}. Response status code does not indicate success {(int)response.StatusCode}:{response.StatusCode}"); } }
/// <summary> /// Loads this configuration from a <see cref="XElement"/>. /// </summary> /// <param name="e">The xml element: its name must be GrandOutputConfiguration.</param> /// <param name="monitor">Monitor that will be used.</param> /// <returns>True on success, false if the configuration can not be read.</returns> public bool Load(XElement e, IActivityMonitor monitor) { if (e == null) { throw new ArgumentNullException("e"); } if (monitor == null) { throw new ArgumentNullException("monitor"); } try { if (e.Name != "GrandOutputConfiguration") { throw new XmlException("Element name must be <GrandOutputConfiguration>." + e.GetLineColumnString()); } // AppDomainDefaultFilter was the name before. LogFilter?globalDefaultFilter = e.GetAttributeLogFilter("GlobalDefaultFilter", false) ?? e.GetAttributeLogFilter("AppDomainDefaultFilter", false); SourceFilterApplyMode applyMode; Dictionary <string, LogFilter> sourceFilter = ReadSourceOverrideFilter(e, out applyMode, monitor); if (sourceFilter == null) { return(false); } RouteConfiguration routeConfig; using (monitor.OpenGroup(LogLevel.Trace, "Reading root Channel.", null)) { XElement channelElement = e.Element("Channel"); if (channelElement == null) { monitor.SendLine(LogLevel.Error, "Missing <Channel /> element." + e.GetLineColumnString(), null); return(false); } routeConfig = FillRoute(monitor, channelElement, new RouteConfiguration()); } // No error: set the new values. _routeConfig = routeConfig; _sourceFilter = sourceFilter; _sourceFilterApplyMode = applyMode; _globalDefaultFilter = globalDefaultFilter; return(true); } catch (Exception ex) { monitor.SendLine(LogLevel.Error, null, ex); } return(false); }
public void ActionNamesConflict() { RouteConfiguration c; { c = new RouteConfiguration() .AddAction(new TestActionConfiguration("Name")) .AddAction(new TestActionConfiguration("Name")); Assert.That(c.Resolve(TestHelper.ConsoleMonitor), Is.Null); } { c = new RouteConfiguration() .AddAction(new ActionParallelConfiguration("Parallel") .AddAction(new TestActionConfiguration("Name")) .AddAction(new TestActionConfiguration("Name"))); Assert.That(c.Resolve(TestHelper.ConsoleMonitor), Is.Null); } { c = new RouteConfiguration() .AddAction(new ActionSequenceConfiguration("Sequence") .AddAction(new TestActionConfiguration("Name")) .AddAction(new TestActionConfiguration("Name"))); Assert.That(c.Resolve(TestHelper.ConsoleMonitor), Is.Null); } { c = new RouteConfiguration() .AddAction(new TestActionConfiguration("Name")) .AddAction(new ActionSequenceConfiguration("FirstGroup") .AddAction(new TestActionConfiguration("Name"))); Assert.That(c.Resolve(TestHelper.ConsoleMonitor), Is.Not.Null, "Sequence acts as a namespace."); } { c = new RouteConfiguration() .AddAction(new ActionSequenceConfiguration("G1") .AddAction(new TestActionConfiguration("Name"))) .AddAction(new ActionSequenceConfiguration("G2") .AddAction(new TestActionConfiguration("Name"))); Assert.That(c.Resolve(TestHelper.ConsoleMonitor), Is.Not.Null, "Sequence hide names below them."); } { c = new RouteConfiguration() .AddAction(new ActionSequenceConfiguration("G1") .AddAction(new TestActionConfiguration("Name"))) .AddAction(new ActionParallelConfiguration("P1") .AddAction(new TestActionConfiguration("Name"))) .AddAction(new ActionParallelConfiguration("P2") .AddAction(new TestActionConfiguration("Name"))) .AddAction(new ActionSequenceConfiguration("G2") .AddAction(new TestActionConfiguration("Name"))); Assert.That(c.Resolve(TestHelper.ConsoleMonitor), Is.Not.Null, "Parallels also hide names below them."); } }
public void Configuration(IAppBuilder app) { HttpConfiguration config = new HttpConfiguration(); OAuthServerConfigurations.Register(app); RouteConfiguration.Register(config); JSONMediaTypeConfiguration.Register(config); CORSConfiguration.Register(app); app.UseWebApi(config); }
public ConfigurationModel() { PublicationRouteConfiguration = new RouteConfiguration<IPublishInfo>(); PublicationRouteConfiguration.AddStrategy<MappingRouteInfoLookupStrategy<IPublishInfo>>(); PublicationRouteConfiguration.AddStrategy<DefaultPublicationRouteInfoLookupStrategy>(); ConsumeRouteConfiguration = new RouteConfiguration<IConsumeInfo>(); ConsumeRouteConfiguration.AddStrategy<MappingRouteInfoLookupStrategy<IConsumeInfo>>(); ConsumeRouteConfiguration.AddStrategy<DefaultSubscriptionRouteInfoLookupStrategy>(); DefaultSerializationStrategy = new BinarySerializationStrategy(); DefaultDeadLetterStrategy = new NullDeadLetterStrategy(); AutoSubscriptions = new List<AutoSubscription>(); ConnectionDownQueueStrategy = new ThrowingQueueStrategy<ConnectionUnavailableException>(); ReconnectionInterval = TimeSpan.FromSeconds(10); }
private void Delete(object id) { ApiConfiguration apiConfiguration = RouteData.DataTokens["apiConfiguration"] as ApiConfiguration; RouteConfiguration route = RouteData.DataTokens["routeConfiguration"] as RouteConfiguration; ActionConfiguration action = RouteData.DataTokens["actionConfiguration"] as ActionConfiguration; if (route.Enabled && action.Enabled) { string sqlQuery = ControllerService.GetStringReplacedQuery(Request, route, action, id); SqlServerService sqlServerService = new SqlServerService(apiConfiguration.ConnectionString, route); sqlServerService.ExecuteNonQuery(sqlQuery); } }
public void RegisterRoutes(RouteCollection routes) { routes.MapRoute( "Default", "", new { controller = "Root", action = "Index" }, new { httpMethod = new HttpMethodConstraint("GET") } ); // need to use namespaces when using controllers with the same name var configuration = new RouteConfiguration {Namespaces = new[] {typeof (BlogsController).Namespace}}; var map = new RestfulRouteMapper(RouteTable.Routes, configuration); map.Resources<BlogsController>(m => m.Resources<PostsController>()); map.Namespace("admin", typeof(Controllers.Admin.BlogsController).Namespace, m => { m.Resources<Controllers.Admin.BlogsController>(); m.Resources<Controllers.Admin.PostsController>(); }); // shallow //map.Resources<BlogsController>(config => config.Shallow = true, m => m.Resources<PostsController>()); }
public RouteResolver( IActivityMonitor monitor, RouteConfiguration c ) { try { using( monitor.OpenGroup( LogLevel.Info, c.Name.Length > 0 ? string.Format( "Resolving root configuration (name is '{0}').", c.Name ) : "Resolving root configuration.", null ) ) { ProtoResolver protoResolver = new ProtoResolver( monitor, c ); NamedSubRoutes = new Dictionary<string, SubRouteConfigurationResolved>(); using( monitor.OpenGroup( LogLevel.Info, "Building final routes.", null ) ) { var preRoot = new PreRoute( monitor, protoResolver.Root ); Root = new RouteConfigurationResolved( protoResolver.Root.FullName, c.ConfigData, preRoot.FinalizeActions() ); foreach( IProtoSubRoute sub in protoResolver.NamedSubRoutes.Values ) { var preRoute = new PreRoute( monitor, sub ); NamedSubRoutes.Add( sub.FullName, new SubRouteConfigurationResolved( sub, preRoute.FinalizeActions() ) ); } Root.SubRoutes = protoResolver.Root.SubRoutes.Select( p => NamedSubRoutes[p.FullName] ).ToArray(); foreach( IProtoSubRoute sub in protoResolver.NamedSubRoutes.Values ) { NamedSubRoutes[sub.FullName].SubRoutes = sub.SubRoutes.Select( p => NamedSubRoutes[p.FullName] ).ToArray(); } } } } catch( Exception ex ) { monitor.SendLine( LogLevel.Fatal, null, ex ); } }
internal Route( ProtoResolver r, RouteConfiguration c ) : this( c, null, r ) { CheckValidity(); }
protected override void given() { _configuration = new RouteConfiguration(); }
public IRouteTableConfigurator AddRoute(RouteConfiguration routeConfiguration) { _routes.Add(routeConfiguration); return this; }
public ProtoResolver( IActivityMonitor monitor, RouteConfiguration root ) { _monitor = monitor; NamedSubRoutes = new Dictionary<string, IProtoSubRoute>(); Route r = new Route( this, root ); r.ExecuteMetaConfigurations(); Root = r; }