public RouteConditionData(OwinEnv env, RouteParameters routeParameters, Route route, object conditionData)
{
OwinEnv = env;
RouteParameters = routeParameters;
Route = route;
ConditionData = conditionData;
}
private Task InfoAppFunc(OwinEnv env)
{
// Don't do this in real code!
return(Task.Factory.StartNew(() => {
// show info page
}));
}
public static void DoesNotRouteTo(OwinEnv owinEnv, AppFunc action, Routes routes)
{
var router = new Router();
router.AddRoutes(routes);
var result = router.Resolve(owinEnv);
Assert.False(result.Success);
}
public static void RoutesTo(OwinEnv owinEnv, AppFunc action, Routes routes)
{
var router = new Router();
router.AddRoutes(routes);
var result = router.Resolve(owinEnv);
Assert.True(result.Success);
Assert.True(action.Equals(result.Route.OwinAction));
}
protected bool RoutesTo(
Route correctEntry,
IEnumerable <Route> otherEntries,
OwinEnv request
)
{
Router router = new Router();
router.AddRoute(correctEntry);
var entry = router.Resolve(request);
return(entry.Route == correctEntry);
}
protected bool DoesNotRouteTo(
Route correctEntry,
OwinEnv request
)
{
Router router = new Router();
router.AddRoute(correctEntry);
var entry = router.Resolve(request);
if (entry == null)
{
return(true);
}
return(entry.Route != correctEntry);
}
private bool CheckConditions(Route route, OwinEnv env, IDictionary <string, RouteValue> parameters)
{
if (route.Conditions == null)
{
return(true);
}
foreach (var condition in route.Conditions)
{
if (!condition.Condition(new RouteConditionData(env, parameters, route, condition.Data)))
{
return(false);
}
}
return(true);
}
public void StoringArbitraryData(OwinEnv owinEnironment)
{
var route = new Route("GET", "/customers/show/{id}", App);
route.Data["CacheOptions"] = new CacheOptions(/* options */);
var router = new Router();
router.AddRoute(route);
var result = router.Resolve(FakeRequest.Get("/customers/show/{id}"));
var cacheOptions = (CacheOptions)route.Data["CacheOptions"];
// Add Caching Options to HTTP-Header
result.Route.OwinAction.Invoke(owinEnironment);
}
/// <summary>
/// Finds a route for the request.
/// </summary>
public ResolveResult Internal_Resolve(OwinEnv env, Func <Route, bool> predicate = null)
{
var path = env ["owin.RequestPath"] as string;
var method = env["owin.RequestMethod"] as string;
var candidates = _routes.GetCandidates(path, method);
var segments = path.Substring(1, path.Length - 1).Split('/');
var routesWithMatchingPath = new List <MatchingRoute>();
foreach (var route in candidates)
{
IDictionary <string, RouteValue> parameters;
if (!PathMatcher.Matches(route, segments, out parameters))
{
continue;
}
routesWithMatchingPath.Add(new MatchingRoute(route, parameters));
}
foreach (var item in routesWithMatchingPath.OrderByDescending(x => x.Route.Priority))
{
if (!CheckConditions(item.Route, env, item.Parameters))
{
continue;
}
if (!CheckParameterConditions(item.Route, item.Parameters))
{
continue;
}
if (predicate != null && !predicate.Invoke(item.Route))
{
continue;
}
return(ResolveResult.RouteFound(item.Route, item.Parameters));
}
return(ResolveResult.NoResult());
}
public void Owin_Environment_is_passed_to_condition_function()
{
var route = new Route("GET", "/test", App);
OwinEnv receivedOwinEnv = null;
route.AddCondition(new RouteCondition(data => {
receivedOwinEnv = data.OwinEnv;
return(true);
}));
var router = new Router();
router.AddRoute(route);
var owinEnv = Utils.BuildGetRequest("/test");
owinEnv["test"] = true;
router.Resolve(owinEnv);
Assert.Equal(true, receivedOwinEnv["test"]);
}
public Task ProcessRequest(OwinEnv env)
{
var router = new Router();
var route = new Route("GET", "/products/{id}-{name}.html", InfoAppFunc);
router.AddRoute(route);
var result = router.Resolve(env);
if (result.Success)
{
var id = result.Parameters["id"];
var name = result.Parameters["name"];
return(result.Route.OwinAction(env)); //Call the AppFunc
}
else
{
// Do something else
throw new Exception();
}
}
private static Task InfoAppFunc(OwinEnv env)
{
return(Task.Factory.StartNew(() => {
// show info page
}));
}
public ResolveResult Resolve(OwinEnv env, Func <Route, bool> predicate)
{
return(Internal_Resolve(env, predicate));
}
public ResolveResult Resolve(OwinEnv env)
{
return(Internal_Resolve(env, null));
}
