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 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_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);
}
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);
}
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));
}
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 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());
}
public RouteEntry CreateRoute(DirectRouteFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// get the prefix
var routePrefixAttributes = context
.Actions
.First()
.ControllerDescriptor
.GetCustomAttributes <RoutePrefixAttribute>();
string prefix = null;
if (routePrefixAttributes != null && routePrefixAttributes.Any())
{
if (routePrefixAttributes.Count > 1)
{
throw new Exception("Multiple route prefix attributes are not allowed.");
}
prefix = routePrefixAttributes.Single().Prefix;
}
string[] templateSplit = Template.Split('/');
string constraintName = $"v_{MinimumValue}_{MaximumValue}";
List <string> routeSegments = new List <string>
{
"api",
$"v{{{constraintName}:int:min({MinimumValue}):max({MaximumValue})}}",
prefix
};
Constraints = new Dictionary <string, object>
{
{
constraintName,
new CompoundRouteConstraint(new List <IHttpRouteConstraint>
{
new IntRouteConstraint(),
new MinRouteConstraint(MinimumValue),
new MaxRouteConstraint(MaximumValue)
})
}
};
routeSegments.AddRange(templateSplit);
string newTemplate = string.Join("/", routeSegments);
IDirectRouteBuilder builder = context.CreateBuilder(newTemplate);
builder.Name = Name;
builder.Order = Order;
IDictionary <string, object> defaults1 = builder.Defaults;
if (defaults1 == null)
{
builder.Defaults = Defaults;
}
else
{
IDictionary <string, object> defaults2 = Defaults;
if (defaults2 != null)
{
foreach (KeyValuePair <string, object> keyValuePair in defaults2)
{
defaults1[keyValuePair.Key] = keyValuePair.Value;
}
}
}
IDictionary <string, object> constraints1 = builder.Constraints;
if (constraints1 == null)
{
builder.Constraints = Constraints;
}
else
{
IDictionary <string, object> constraints2 = Constraints;
if (constraints2 != null)
{
foreach (KeyValuePair <string, object> keyValuePair in constraints2)
{
constraints1[keyValuePair.Key] = keyValuePair.Value;
}
}
}
IDictionary <string, object> dataTokens1 = builder.DataTokens;
if (dataTokens1 == null)
{
builder.DataTokens = DataTokens;
}
else
{
IDictionary <string, object> dataTokens2 = DataTokens;
if (dataTokens2 != null)
{
foreach (KeyValuePair <string, object> keyValuePair in dataTokens2)
{
dataTokens1[keyValuePair.Key] = keyValuePair.Value;
}
}
}
var result = builder.Build();
return(result);
}
