public override void RegisterArea(AreaRegistrationContext context)
{
RouteMapper.ConfigureArea(context, AreaName);
//context.MapRoute(
// name: $"{AreaName}_index_with_parent",
// url: "Admins/{controller}/{parentId}/{action}",
// defaults: new { action = ActionNames.IndexWithParent },
// namespaces: new[] { $"TenderSearch.Web.Areas.{AreaName}.Controllers" }
//);
//context.MapRoute(
// name: $"{AreaName}_suggestion_with_parent",
// url: "Admins/{controller}/{parentId}/SuggestionsWithParent",
// defaults: new { action = ActionNames.SuggestionsWithParent },
// namespaces: new[] { $"TenderSearch.Web.Areas.{AreaName}.Controllers" }
//);
//context.MapRoute(
// name: $"{AreaName}_create_with_parent",
// url: "Admins/{controller}/{parentId}/CreateWithParent",
// defaults: new { action = ActionNames.CreateWithParent },
// namespaces: new[] { $"TenderSearch.Web.Areas.{AreaName}.Controllers" }
//);
//context.MapRoute(
// name: $"{AreaName}_default",
// url: "Admins/{controller}/{action}/{id}",
// defaults: new { action = ActionNames.Index, id = UrlParameter.Optional },
// namespaces: new[] { $"TenderSearch.Web.Areas.{AreaName}.Controllers" }
//);
}
public void GetAdapterShouldReturnNullForUnknownMethods()
{
var mapper = new RouteMapper(new RouteMetadata[0]);
RouteMethod result = mapper.GetAdapter(ExampleMethodInfo);
Assert.That(result, Is.Null);
}
public void GetAdapterShouldReturnAnAdapterForKnownMethods()
{
var mapper = new RouteMapper(new[] { CreateRoute("GET", "/route") });
RouteMethod result = mapper.GetAdapter(ExampleMethodInfo);
Assert.That(result, Is.Not.Null);
}
//public delegate object RunHandlerDelegate()
public CustomRouting(RequestDelegate next, ContractRouteInitializer routingMapper, HandlerFactory handlerFactory, JsonContractInitializer contractInitializer)
{
_next = next;
this.routingMapper = routingMapper.Mapper;
this.handlerFactory = handlerFactory;
this.contractInitializer = contractInitializer;
}
public void Mapping_Total_Cost_To_Destination_Object()
{
var routeProfile = new RouteMapper();
Mapper.AddProfile(routeProfile);
var dest = Mapper.Map <RouteTotals, Route>(_routeTotals);
Assert.AreEqual(dest.TotalCost, _routeTotals.totalCost);
}
public void MatchShouldSetTheParameters()
{
IReadOnlyDictionary <string, object> parameters = null;
ILookup <string, string> query = Substitute.For <ILookup <string, string> >();
var mapper = new RouteMapper(new[] { CreateRoute("GET", "/route") });
mapper.Match("GET", "/route", query, out parameters);
Assert.That(parameters, Is.Not.Null);
}
public void MatchShouldMatchTheVerb()
{
IReadOnlyDictionary <string, object> parameters = null;
ILookup <string, string> query = Substitute.For <ILookup <string, string> >();
var mapper = new RouteMapper(new[] { CreateRoute("PUT", "/route") });
MethodInfo get = mapper.Match("GET", "/route", query, out parameters);
MethodInfo put = mapper.Match("PUT", "/route", query, out parameters);
Assert.That(get, Is.Null);
Assert.That(put, Is.Not.Null);
}
private RouteMapper FindRoutingTable(String dataSource, String actualTable)
{
foreach (var routeResult in routeResults)
{
RouteMapper result = routeResult.FindTableMapper(dataSource, actualTable);
if (null != result)
{
return(result);
}
}
throw new InvalidOperationException($"Cannot found routing table factor, data source: {dataSource}, actual table: {actualTable}");
}
public IHttpActionResult FindRoutes(string apiKey, string startLocationName, string endLocationName, bool recommended, string goods, double weight)
{
if (!_securityService.IsAuthenticated(apiKey, true))
{
return(Unauthorized());
}
var lowerStart = startLocationName.ToLower();
var lowerEnd = endLocationName.ToLower();
var startLocation = _locationService.FindLocation(lowerStart);
if (startLocation == null)
{
return(NotFound());
}
var endLocation = _locationService.FindLocation(lowerEnd);
if (endLocation == null)
{
return(NotFound());
}
if (weight > 40)
{
return(BadRequest("Weights over 40 kg are not supported"));
}
var canParse = Enum.TryParse <PackageType>(goods, true, out var packageType);
if (!canParse)
{
return(BadRequest("Unknown type of goods"));
}
if (!_allowedPackageTypes.Contains(packageType))
{
return(BadRequest("That type of goods is not allowed"));
}
var cheapestRoute = _routeService.FindCheapest(startLocation, endLocation, true);
var fastestRoute = _routeService.FindFastest(startLocation, endLocation, true);
var viewRoutes = new[]
{
RouteMapper.ViewExternalRouteFromRoute(cheapestRoute, startLocationName, endLocationName, packageType, recommended),
RouteMapper.ViewExternalRouteFromRoute(fastestRoute, startLocationName, endLocationName, packageType, recommended)
};
return(Ok(viewRoutes));
}
public static void AddSkillion(this IServiceCollection services)
{
var assembly = Assembly.GetCallingAssembly();
services.AddControllers().AddNewtonsoftJson();
var config = services.BuildServiceProvider().GetService <IConfiguration>();
var section = config.GetSection("Skillion:Configuration");
services.Configure <SkillionConfiguration>(section);
services.AddScoped <ISkillRequestParser, SkillRequestParser>();
services.AddScoped <SkillionRouteValueTransformer>();
services.AddScoped <ISkillRequestValidator, SkillRequestValidator>();
services.AddSingleton <IRouteDataService>(new RouteDataService(RouteMapper.MapRoutes(GetMethods(assembly))));
}
public void GivenControllerAction_WhenDoesNotHaveAttribute_ReturnEmptyRoutes()
{
const string intentName = "TestIntent";
const string controllerName = "Test";
const string methodName = "TestAction";
var controllerNamespace = $"RouteMapperTests.Controllers.{controllerName}Controller";
var type = new Mock <Type>();
type.Setup(t => t.FullName).Returns(controllerNamespace);
var testMemberInfo = new TestMemberInfo(type.Object, methodName, null);
var routes = RouteMapper.MapRoutes(new List <MemberInfo> {
testMemberInfo
});
Assert.Empty(routes);
}
public void GivenControllerAction_WhenHasAttribute_ReturnRoutes()
{
const string intentName = "TestIntent";
const string controllerName = "Test";
const string methodName = "TestAction";
var controllerNamespace = $"RouteMapperTests.Controllers.{controllerName}Controller";
var type = new Mock <Type>();
type.Setup(t => t.FullName).Returns(controllerNamespace);
var testMemberInfo = new TestMemberInfo(type.Object, methodName, new SkillionRequestAttribute[] { new IntentRequestAttribute(intentName) });
var routes = RouteMapper.MapRoutes(new List <MemberInfo> {
testMemberInfo
});
Assert.True(routes.ContainsKey(intentName));
Assert.Equal(controllerName, routes[intentName].Controller);
}
/// <summary>
/// Create browser driver
/// </summary>
public TestContextFixture()
{
//Create Browser driver.
var driverManager = CraftsmanFactory.CreateDriverManager();
if (this.DriverManager != null)
{
var options = this.DriverManager.Driver.Manage();
options.Cookies.AddCookie(new OpenQA.Selenium.Cookie("wm-ASRep-14-39814", "1"));
options.Cookies.AddCookie(new OpenQA.Selenium.Cookie("wm-ASRep-14-45441", "1"));
options.Window.Maximize();
}
//build router.
var routeMapper = new RouteMapper(driverManager.Driver);
//set data.
this.DriverManager = driverManager;
this.RouteMapper = routeMapper;
}
public RouteResult Route(ShardingRule shardingRule)
{
RouteResult result = new RouteResult();
string dataSourceName = shardingRule.ShardingDataSourceNames.GetRandomDataSourceName();
RouteMapper dataSourceMapper = new RouteMapper(dataSourceName, dataSourceName);
if (shardingRule.IsAllBroadcastTables(logicTables))
{
List <RouteMapper> tableMappers = new List <RouteMapper>(logicTables.Count);
foreach (var logicTable in logicTables)
{
tableMappers.Add(new RouteMapper(logicTable, logicTable));
}
result.GetRouteUnits().Add(new RouteUnit(dataSourceMapper, tableMappers));
}
else if (logicTables.IsEmpty())
{
result.GetRouteUnits().Add(new RouteUnit(dataSourceMapper, new List <RouteMapper>(0)));
}
else if (1 == logicTables.Count)
{
string logicTableName = logicTables.First();
if (shardingRule.FindTableRule(logicTableName) == null)
{
result.GetRouteUnits().Add(new RouteUnit(dataSourceMapper, new List <RouteMapper>(0)));
return(result);
}
DataNode dataNode = shardingRule.GetDataNode(logicTableName);
result.GetRouteUnits().Add(new RouteUnit(dataSourceMapper, new List <RouteMapper>()
{
new RouteMapper(logicTableName, dataNode.GetTableName())
}));
}
else
{
List <RouteMapper> tableMappers = new List <RouteMapper>(logicTables.Count);
ISet <string> availableDatasourceNames = null;
bool first = true;
foreach (var logicTable in logicTables)
{
TableRule tableRule = shardingRule.GetTableRule(logicTable);
DataNode dataNode = tableRule.ActualDataNodes[0];
tableMappers.Add(new RouteMapper(logicTable, dataNode.GetTableName()));
ISet <string> currentDataSourceNames = new HashSet <string>();
foreach (var actualDataNode in tableRule.ActualDataNodes)
{
currentDataSourceNames.Add(actualDataNode.GetDataSourceName());
}
if (first)
{
availableDatasourceNames = currentDataSourceNames;
first = false;
}
else
{
availableDatasourceNames = availableDatasourceNames.Intersect(currentDataSourceNames).ToHashSet();
}
}
if (availableDatasourceNames.IsEmpty())
{
throw new ShardingException($"Cannot find actual dataSource intersection for logic tables: {logicTables}");
}
dataSourceName = shardingRule.ShardingDataSourceNames.GetRandomDataSourceName(availableDatasourceNames);
result.GetRouteUnits().Add(new RouteUnit(new RouteMapper(dataSourceName, dataSourceName), tableMappers));
}
return(result);
}
public override void RegisterArea(AreaRegistrationContext context)
{
RouteMapper.ConfigureArea(context, AreaName);
}
private static void RegisterRoutes(RouteCollection routes)
{
var routeMapper = new RouteMapper(routes);
routeMapper.RegisterRoutes();
}
public RouteCrud()
{
Mapper = new RouteMapper();
Dao = SqlDao.GetInstance();
}
public RouteService(IUnitOfWork unitOfWork)
{
_uof = unitOfWork;
_routeMapper = new RouteMapper();
}
