public RouteEntry CreateRoute(DirectRouteFactoryContext context) { if (!context.TargetIsAction) { throw new InvalidOperationException("AutoNamedRouteAttribute should be only used on actions"); } if (!context.Actions.Any()) { throw new InvalidOperationException("Actions should be empty"); } IDirectRouteBuilder builder = context.CreateBuilder(Template); // generate name: // get the first action descriptor from our list because we only need to get its name var actionDescriptor = context.Actions.First(); var controllerDescriptor = actionDescriptor.ControllerDescriptor; var actionName = actionDescriptor.ActionName; var controllerName = controllerDescriptor.ControllerName; // get area also var areaName = getAreaName(controllerDescriptor); // compose a name builder.Name = T4Extensions.ComposeAutoRouteName(areaName, controllerName, actionName); builder.Order = Order; return(builder.Build()); }
public void CreateRoute_UsesOrderPropertyWhenBuilding() { // Arrange int expectedOrder = 123; RouteFactoryAttribute product = CreateProductUnderTest(); product.Order = expectedOrder; int order = 0; IDirectRouteBuilder builder = null; builder = CreateBuilder( () => { order = builder.Order; return(null); } ); DirectRouteFactoryContext context = CreateContext((i) => builder); // Act RouteEntry ignore = product.CreateRoute(context); // Assert Assert.Equal(expectedOrder, order); }
public void CreateRoute_UsesNamePropertyWhenBuilding() { // Arrange string expectedName = "RouteName"; RouteFactoryAttribute product = CreateProductUnderTest(); product.Name = expectedName; string name = null; IDirectRouteBuilder builder = null; builder = CreateBuilder( () => { name = builder.Name; return(null); } ); DirectRouteFactoryContext context = CreateContext((i) => builder); // Act RouteEntry ignore = product.CreateRoute(context); // Assert Assert.Same(expectedName, name); }
private static IHttpRoute BuildWithResolver( string template, IInlineConstraintResolver constraintResolver ) { HttpActionDescriptor[] actions = new HttpActionDescriptor[] { new ReflectedHttpActionDescriptor() }; DirectRouteFactoryContext context = new DirectRouteFactoryContext( null, actions, constraintResolver, targetIsAction: true ); // Act IDirectRouteBuilder builder = context.CreateBuilder(template); IHttpRoute route = builder.Build().Route; // Assertions for default, unspecified behavior: Assert.NotNull(route); Assert.Equal(actions, route.DataTokens["actions"]); return(route); }
private static RouteEntry CreateRouteEntry( string prefix, IDirectRouteFactory factory, IReadOnlyCollection <HttpActionDescriptor> actions, IInlineConstraintResolver constraintResolver, bool targetIsAction ) { Contract.Assert(factory != null); DirectRouteFactoryContext context = new DirectRouteFactoryContext( prefix, actions, constraintResolver, targetIsAction ); RouteEntry entry = factory.CreateRoute(context); if (entry == null) { throw Error.InvalidOperation( SRResources.TypeMethodMustNotReturnNull, typeof(IDirectRouteFactory).Name, "CreateRoute" ); } DirectRouteBuilder.ValidateRouteEntry(entry); return(entry); }
public void CreateRoute_IfBuilderConstraintsIsNull_UsesConstraintsPropertyWhenBuilding() { // Arrange TRouteDictionary expectedConstraints = new TRouteDictionaryConcrete(); Mock <RouteFactoryAttribute> productMock = CreateProductUnderTestMock(); productMock.SetupGet(p => p.Constraints).Returns(expectedConstraints); IDirectRouteFactory product = productMock.Object; RouteEntry expectedEntry = CreateEntry(); TRouteDictionary constraints = null; IDirectRouteBuilder builder = null; builder = CreateBuilder(() => { constraints = builder.Constraints; return(null); }); Assert.Null(builder.Constraints); // Guard DirectRouteFactoryContext context = CreateContext((i) => builder); // Act RouteEntry ignore = product.CreateRoute(context); // Assert Assert.Same(expectedConstraints, constraints); }
public void CreateRoute_IfBuilderDataTokensIsNotNullAndDataTokensPropertyIsNull_UsesBuilderDataTokens() { // Arrange TRouteDictionary existingDataTokens = new TRouteDictionaryConcrete(); Mock <RouteFactoryAttribute> productMock = CreateProductUnderTestMock(); productMock.SetupGet(p => p.DataTokens).Returns((TRouteDictionary)null); IDirectRouteFactory product = productMock.Object; RouteEntry expectedEntry = CreateEntry(); TRouteDictionary dataTokens = null; IDirectRouteBuilder builder = null; builder = CreateBuilder(() => { dataTokens = builder.DataTokens; return(null); }); builder.DataTokens = existingDataTokens; DirectRouteFactoryContext context = CreateContext((i) => builder); // Act RouteEntry ignore = product.CreateRoute(context); // Assert Assert.Same(existingDataTokens, dataTokens); }
public HttpRouteFactory(string prefix = "api") { var constraintResolver = new DefaultInlineConstraintResolver(); List <HttpActionDescriptor> actionDescriptors = new List <HttpActionDescriptor>(); _routeFactoryContext = new DirectRouteFactoryContext(prefix, actionDescriptors, constraintResolver, false); }
public C1PathInfoRouteConstraint(String suffix) { var routeFactory = new DirectRouteFactoryContext(String.Empty, String.Empty, new List <ActionDescriptor>(), new DefaultInlineConstraintResolver(), true); var builder = routeFactory.CreateBuilder(suffix); var route = new Route(builder.Template, builder.Defaults, builder.Constraints, null); _routeInfo = new RouteInfo(route); }
private static IHttpRoute BuildWithoutResolver(string template, IReadOnlyCollection<HttpActionDescriptor> actions) { DirectRouteFactoryContext context = new DirectRouteFactoryContext(null, actions, new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object, targetIsAction: true); IDirectRouteBuilder builder = context.CreateBuilder(template, constraintResolver: null); return builder.Build().Route; }
public RouteEntry CreateRoute(DirectRouteFactoryContext context) { IDirectRouteBuilder builder = context.CreateBuilder(Template); builder.Name = Name; builder.Order = Order; return(builder.Build()); }
private static IHttpRoute BuildWithoutResolver(string template, IReadOnlyCollection <HttpActionDescriptor> actions) { DirectRouteFactoryContext context = new DirectRouteFactoryContext(null, actions, new Mock <IInlineConstraintResolver>(MockBehavior.Strict).Object, targetIsAction: true); IDirectRouteBuilder builder = context.CreateBuilder(template, constraintResolver: null); return(builder.Build().Route); }
public void CreateRoute_IfContextIsNull_Throws() { // Arrange DirectRouteFactoryContext context = null; IDirectRouteFactory product = CreateProductUnderTest(); // Act & Assert Assert.ThrowsArgumentNull(() => product.CreateRoute(context), "context"); }
public void CreateRoute_IfBuilderDataTokensIsNotNull_UpdatesDataTokensFromPropertyWhenBuilding() { // Arrange TRouteDictionary existingDataTokens = new TRouteDictionaryConcrete(); string existingDataTokenKey = "ExistingDataTokenKey"; object existingDataTokenValue = "ExistingDataToken"; existingDataTokens.Add(existingDataTokenKey, existingDataTokenValue); string conflictingDataTokenKey = "ConflictingDataTokenKey"; object oldConflictingDataTokenValue = "OldConflictingDataToken"; existingDataTokens.Add(conflictingDataTokenKey, oldConflictingDataTokenValue); TRouteDictionary additionalDataTokens = new TRouteDictionaryConcrete(); string additionalDataTokenKey = "NewDataTokenKey"; string additionalDataTokenValue = "NewDataToken"; additionalDataTokens.Add(additionalDataTokenKey, additionalDataTokenValue); string newConflictingDataTokenValue = "NewConflictingDataToken"; additionalDataTokens.Add(conflictingDataTokenKey, newConflictingDataTokenValue); Mock <RouteFactoryAttribute> productMock = CreateProductUnderTestMock(); productMock.SetupGet(p => p.DataTokens).Returns(additionalDataTokens); IDirectRouteFactory product = productMock.Object; RouteEntry expectedEntry = CreateEntry(); TRouteDictionary dataTokens = null; IDirectRouteBuilder builder = null; builder = CreateBuilder( () => { dataTokens = builder.DataTokens; return(null); } ); builder.DataTokens = existingDataTokens; DirectRouteFactoryContext context = CreateContext((i) => builder); // Act RouteEntry ignore = product.CreateRoute(context); // Assert Assert.Same(existingDataTokens, dataTokens); Assert.Equal(3, dataTokens.Count); Assert.True(dataTokens.ContainsKey(existingDataTokenKey)); Assert.Same(existingDataTokenValue, dataTokens[existingDataTokenKey]); Assert.True(dataTokens.ContainsKey(conflictingDataTokenKey)); Assert.Same(newConflictingDataTokenValue, dataTokens[conflictingDataTokenKey]); Assert.True(dataTokens.ContainsKey(additionalDataTokenKey)); Assert.Same(additionalDataTokenValue, dataTokens[additionalDataTokenKey]); }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { var result = ((IDirectRouteFactory)InnerAttribute).CreateRoute(context); var writeableResult = new RouteEntry(result.Name, new WriteableRoute(result.Route)); //need to add this here so we can retrieve it later writeableResult.Route.DataTokens.Add("Umb_RouteName", Name); return(writeableResult); }
/// <summary> /// Creates a direct route entry. /// </summary> /// <param name="context">The context to use to create the route.</param> /// <returns> /// The direct route entry. /// </returns> public RouteEntry CreateRoute(DirectRouteFactoryContext context) { // context.Actions will always contain at least one action - and all of the // actions will always belong to the same controller. IDirectRouteBuilder builder = context.CreateBuilder(this.Template); builder.Name = this.Name; builder.Order = this.Order; return(builder.Build()); }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { var builder = context.CreateBuilder(Template); builder.Name = Name; builder.Order = Order; builder.DataTokens = new Dictionary<string, object>(); builder.DataTokens["culture"] = Culture ?? "en-US"; return builder.Build(); }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { var builder = context.CreateBuilder(Template); builder.Name = Name; builder.Order = Order; builder.DataTokens = new Dictionary <string, object>(); builder.DataTokens["culture"] = Culture ?? "en-US"; return(builder.Build()); }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { var result = ((IDirectRouteFactory)InnerAttribute).CreateRoute(context); var writeableResult = new RouteEntry(result.Name, new WriteableRoute(result.Route)); //need to add this here so we can retrieve it later writeableResult.Route.DataTokens.Add("Umb_RouteName", Name); return writeableResult; }
public void BuildRouteTemplate( string areaPrefix, string prefix, string template, string expected ) { var result = DirectRouteFactoryContext.BuildRouteTemplate(areaPrefix, prefix, template); Assert.Equal(expected, result); }
public RouteEntry CreateRoute(DirectRouteFactoryContext context) { var builder = context.CreateBuilder(Template); builder.Name = Name; builder.Order = Order; var result = builder.Build(); return(result); //return new RouteEntry(Template, new HttpRoute(Template)); }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { Contract.Assert(context != null); IDirectRouteBuilder builder = context.CreateBuilder(Template); Contract.Assert(builder != null); builder.Name = Name; builder.Order = Order; return builder.Build(); }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { Contract.Assert(context != null); IDirectRouteBuilder builder = context.CreateBuilder(Template); Contract.Assert(builder != null); builder.Name = Name; builder.Order = Order; return(builder.Build()); }
public new RouteEntry CreateRoute(DirectRouteFactoryContext context) { // context.Actions will always contain at least one action - and all of the // actions will always belong to the same controller. var controllerDescriptor = context.Actions.First().ControllerDescriptor; var template = Template.Replace("{controller}", controllerDescriptor.ControllerName); IDirectRouteBuilder builder = context.CreateBuilder(template); builder.Name = controllerDescriptor.ControllerName+"Api"; builder.Order = Order; return builder.Build(); }
public RouteEntry CreateRoute(DirectRouteFactoryContext context) { var builder = context.CreateBuilder(string.Empty); var action = builder.Actions.First(); var attr = action.GetCustomAttributes<System.Web.Http.RouteAttribute>(true).FirstOrDefault(); if(attr != null) { builder.Template = string.Concat(builder.Template, "/", attr.Template); } var res = context.CreateBuilder(string.Empty).Build(); return res; }
public new RouteEntry CreateRoute(DirectRouteFactoryContext context) { // context.Actions will always contain at least one action - and all of the // actions will always belong to the same controller. var controllerDescriptor = context.Actions.First().ControllerDescriptor; var template = Template.Replace("{controller}", controllerDescriptor.ControllerName); IDirectRouteBuilder builder = context.CreateBuilder(template); builder.Name = Name; builder.Order = Order; return(builder.Build()); }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { var action = context.Actions.FirstOrDefault(); var template = string.Format("{0}/{1}", action.ControllerDescriptor.ControllerName, action.ActionName); if (!string.IsNullOrWhiteSpace(Template)) { template += "/" + Template; } var builder = context.CreateBuilder(template); builder.Name = Name; builder.Order = Order; return builder.Build(); }
/// <summary> /// Creates <see cref="T:System.Web.Http.Routing.RouteEntry" /> instances based on the provided factories and action. The route entries provide direct routing to the provided action. /// </summary> /// <returns>A set of route entries.</returns> /// <param name="actionDescriptor">The action descriptor.</param> /// <param name="factories">The direct route factories.</param> /// <param name="constraintResolver">The constraint resolver.</param> protected override IReadOnlyList <RouteEntry> GetActionDirectRoutes(HttpActionDescriptor actionDescriptor, IReadOnlyList <IDirectRouteFactory> factories, IInlineConstraintResolver constraintResolver) { Contract.Assume(actionDescriptor != null); // let the DefaultDirectRouteProvider create the normal routes based on all factories var routes = new List <RouteEntry>(base.GetActionDirectRoutes(actionDescriptor, factories, constraintResolver)); // check if the current action is part of the default API version and the action is not version neutral var defaultVersion = actionDescriptor.Configuration.GetApiVersioningOptions().DefaultApiVersion; var versionModel = actionDescriptor.ControllerDescriptor.GetApiVersionModel(); var isDefaultVersionRoute = !versionModel.IsApiVersionNeutral && versionModel.DeclaredApiVersions.Any(v => v == defaultVersion); if (isDefaultVersionRoute) { // find all routes for the action that have a version constraint var versionizedRoutes = routes.Where(r => r.Route.Constraints.Any(c => c.Value is ApiVersionRouteConstraint)).ToArray(); foreach (var versionizedRoute in versionizedRoutes) { // separate the URL template into the path segments var chunks = versionizedRoute.Route.RouteTemplate.Split('/'); // build the {version} string based on the route constraint name var versionConstraint = "{" + versionizedRoute.Route.Constraints.Where( c => c.Value is ApiVersionRouteConstraint).Select(c => c.Key).First() + "}"; // join the segments again together but remove the chunks containing the URL constraint var newRouteTemplate = string.Join("/", chunks.Where(c => !c.Contains(versionConstraint))); // build a new route for the new URL template var context = new DirectRouteFactoryContext(string.Empty, new[] { actionDescriptor }, constraintResolver, false); var builder = context.CreateBuilder(newRouteTemplate); if (!string.IsNullOrEmpty(versionizedRoute.Name)) { builder.Name = versionizedRoute.Name + "DefaultVersion"; } builder.DataTokens = new Dictionary <string, object> { { IsDefaultVersionRouteKey, true } }; routes.Add(builder.Build()); } } return(routes); }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { Contract.Assert(context != null); IDirectRouteBuilder builder = context.CreateBuilder(Template); Contract.Assert(builder != null); builder.Name = Name; builder.Order = Order; var entry = builder.Build(); return(new LocalizedRouteEntry(entry.Name, entry.Route, ExplicitCulture, TranslateUrl)); }
public RouteEntry CreateRoute(DirectRouteFactoryContext context) { Contract.Assert(context != null); IDirectRouteBuilder builder = context.CreateBuilder(_infoProvider.Template); Contract.Assert(builder != null); builder.Name = _infoProvider.Name; #if ASPNETWEBAPI builder.Order = _infoProvider.Order; #endif return builder.Build(); }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { Contract.Assert(context != null); if (context.InlineConstraintResolver is RavenInlineConstraintResolver == false) return FakeRouteEntry; IDirectRouteBuilder builder = context.CreateBuilder(Template); Contract.Assert(builder != null); builder.Name = Name; builder.Order = Order; return builder.Build(); }
private static IHttpRoute BuildWithResolver(string template, IInlineConstraintResolver constraintResolver) { HttpActionDescriptor[] actions = new HttpActionDescriptor[] { new ReflectedHttpActionDescriptor() }; DirectRouteFactoryContext context = new DirectRouteFactoryContext(null, actions, constraintResolver, targetIsAction: true); // Act IDirectRouteBuilder builder = context.CreateBuilder(template); IHttpRoute route = builder.Build().Route; // Assertions for default, unspecified behavior: Assert.NotNull(route); Assert.Equal(actions, route.DataTokens["actions"]); return route; }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { var action = context.Actions.FirstOrDefault(); var template = string.Format("{0}/{1}", action.ControllerDescriptor.ControllerName, action.ActionName); if (!string.IsNullOrWhiteSpace(Template)) { template += "/" + Template; } var builder = context.CreateBuilder(template); builder.Name = Name; builder.Order = Order; return(builder.Build()); }
public RouteEntry CreateRoute(DirectRouteFactoryContext context) { Contract.Assert(context != null); IDirectRouteBuilder builder = context.CreateBuilder(_infoProvider.Template); Contract.Assert(builder != null); builder.Name = _infoProvider.Name; #if ASPNETWEBAPI builder.Order = _infoProvider.Order; #endif return(builder.Build()); }
/// <summary> /// Route Factory /// </summary> /// <param name="context">Route Context</param> /// <returns></returns> public RouteEntry CreateRoute(DirectRouteFactoryContext context) { string controllerName = context.Actions.FirstOrDefault().ControllerDescriptor.ControllerName; //Format: {apiVersion}/{controller}/{template} string template = String.Format( "{0}{1}{2}{3}", (String.IsNullOrEmpty(Gale.REST.Config.GaleConfig.apiVersion) ? "" : Gale.REST.Config.GaleConfig.apiVersion + "/"), controllerName, (_template.StartsWith("/") ? "" : "/"), _template ); return((new System.Web.Http.RouteAttribute(template) { } as IDirectRouteFactory).CreateRoute(context)); }
protected RouteEntry createRouteInternal(DirectRouteFactoryContext context) { string actionName = context.Actions.FirstOrDefault().ActionName; string controllerName = context.Actions.FirstOrDefault().ControllerDescriptor.ControllerName; string route = $"{controllerName}/{actionName}"; if (DirectRoutingEnabled && RouteEncryptionService.EncryptionUsed()) { route = RouteEncryptionService.GetEncrypted(route); } IDirectRouteBuilder builder = context.CreateBuilder(route); //builder.Name = this.Name; //builder.Order = this.Order; return(builder.Build()); }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { var tmplt = "api" + "/" + Template; var assembly = context.Actions.FirstOrDefault().ControllerDescriptor.ControllerType.Assembly; var plugin = PluginLoader.Instance[assembly]; if (plugin == null) { throw new Exception("has to have a matching plugin"); } IDirectRouteBuilder builder = context.CreateBuilder("modules/" + plugin.Name + "/" + tmplt); builder.Name = Name; builder.Order = Order; return(builder.Build()); }
public void CreateRoute_DelegatesToContextCreateBuilderBuild() { // Arrange string expectedTemplate = "RouteTemplate"; IDirectRouteFactory product = CreateProductUnderTest(expectedTemplate); RouteEntry expectedEntry = CreateEntry(); IDirectRouteBuilder builder = CreateBuilder(() => expectedEntry); DirectRouteFactoryContext context = CreateContext((template) => template == expectedTemplate ? builder : new DirectRouteBuilder(new TActionDescriptor[0], targetIsAction: true)); // Act RouteEntry entry = product.CreateRoute(context); // Assert Assert.Same(expectedEntry, entry); }
/// <summary> /// Route Factory /// </summary> /// <param name="context">Route Context</param> /// <returns></returns> public RouteEntry CreateRoute(DirectRouteFactoryContext context) { string controllerName = context.Actions.FirstOrDefault().ControllerDescriptor.ControllerName; //Format: {apiVersion}/{controller}/{template} string template = String.Format( "{0}/{1}{2}{3}", Gale.REST.Config.GaleConfig.apiVersion, controllerName, (_template.StartsWith("/") ? "" : "/"), _template ); return (new System.Web.Http.RouteAttribute(template) { } as IDirectRouteFactory).CreateRoute(context); }
RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context) { Contract.Assert(context != null); if (context.InlineConstraintResolver is RavenInlineConstraintResolver == false) { return(FakeRouteEntry); } IDirectRouteBuilder builder = context.CreateBuilder(Template); Contract.Assert(builder != null); builder.Name = Name; builder.Order = Order; return(builder.Build()); }
public RouteEntry CreateRoute(DirectRouteFactoryContext context) { if (context == null) { throw Error.ArgumentNull("context"); } // Current action method var actionDescriptor = context.Actions.First(); var currentVersion = GetVersion(actionDescriptor); IDirectRouteBuilder builder = context.CreateBuilder(Template); builder.Constraints.Add( new KeyValuePair <string, object>("version", new ApiVersionConstraint(currentVersion))); builder.Name = Name; builder.Order = Order; return(builder.Build()); }
/// <inheritdoc /> public RouteEntry CreateRoute(DirectRouteFactoryContext context) { if (context == null) { throw new ArgumentNullException("context"); } IDirectRouteBuilder builder = context.CreateBuilder(Template); Contract.Assert(builder != null); builder.Name = Name; builder.Order = Order; TRouteDictionary builderDefaults = builder.Defaults; if (builderDefaults == null) { builder.Defaults = Defaults; } else { TRouteDictionary defaults = Defaults; if (defaults != null) { foreach (KeyValuePair<string, object> defaultItem in defaults) { builderDefaults[defaultItem.Key] = defaultItem.Value; } } } TRouteDictionary builderConstraints = builder.Constraints; if (builderConstraints == null) { builder.Constraints = Constraints; } else { TRouteDictionary constraints = Constraints; if (constraints != null) { foreach (KeyValuePair<string, object> constraint in constraints) { builderConstraints[constraint.Key] = constraint.Value; } } } TRouteDictionary builderDataTokens = builder.DataTokens; if (builderDataTokens == null) { builder.DataTokens = DataTokens; } else { TRouteDictionary dataTokens = DataTokens; if (dataTokens != null) { foreach (KeyValuePair<string, object> dataToken in dataTokens) { builderDataTokens[dataToken.Key] = dataToken.Value; } } } return builder.Build(); }
internal static RouteEntry CreateRouteEntry( string prefix, IDirectRouteFactory factory, IReadOnlyCollection<HttpActionDescriptor> actions, IInlineConstraintResolver constraintResolver, bool targetIsAction) { Contract.Assert(factory != null); DirectRouteFactoryContext context = new DirectRouteFactoryContext(prefix, actions, constraintResolver, targetIsAction); RouteEntry entry = factory.CreateRoute(context); if (entry == null) { throw Error.InvalidOperation(SRResources.TypeMethodMustNotReturnNull, typeof(IDirectRouteFactory).Name, "CreateRoute"); } IHttpRoute route = entry.Route; Contract.Assert(route != null); HttpActionDescriptor[] targetActions = GetTargetActionDescriptors(route); if (targetActions == null || targetActions.Length == 0) { throw new InvalidOperationException(SRResources.DirectRoute_MissingActionDescriptors); } if (route.Handler != null) { throw new InvalidOperationException(SRResources.DirectRoute_HandlerNotSupported); } return entry; }
private static RouteEntry CreateRouteEntry( string prefix, IDirectRouteFactory factory, IReadOnlyCollection<HttpActionDescriptor> actions, IInlineConstraintResolver constraintResolver, bool targetIsAction) { Contract.Assert(factory != null); DirectRouteFactoryContext context = new DirectRouteFactoryContext(prefix, actions, constraintResolver, targetIsAction); RouteEntry entry = factory.CreateRoute(context); if (entry == null) { throw Error.InvalidOperation(SRResources.TypeMethodMustNotReturnNull, typeof(IDirectRouteFactory).Name, "CreateRoute"); } DirectRouteBuilder.ValidateRouteEntry(entry); return entry; }
public HttpRouteFactory(string prefix = "api") { var constraintResolver = new DefaultInlineConstraintResolver(); List<HttpActionDescriptor> actionDescriptors = new List<HttpActionDescriptor>(); _routeFactoryContext = new DirectRouteFactoryContext(prefix, actionDescriptors, constraintResolver, false); }