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;
}
