public ExecutionResult Execute(object handler, RequestContext requestContext, HandlerData handlerData)
{
var result = new ExecutionResult();
var httpVerb = requestContext.HttpContext.Request.HttpMethod.ToEnum<HttpVerb>();
var before = getMethod(handler, "Before");
var method = getMethod(handler, httpVerb);
var after = getMethod(handler, "After");
if (method == null)
{
throw new HttpException(HttpStatusCode.NotImplemented.CastInt(), "The request could not be completed because the resource does not support {0}".With(httpVerb.Name()));
}
if (before != null)
{
var beforeArgs = _argumentBuilder.BuildArguments(before.GetParameters(), requestContext, handlerData);
result.BeforeResult = before.Invoke(handler, beforeArgs) as IResult;
}
var methodArgs = _argumentBuilder.BuildArguments(method.GetParameters(), requestContext, handlerData);
result.Result = (IResult) method.Invoke(handler, methodArgs);
if (after != null)
{
var afterArgs = _argumentBuilder.BuildArguments(after.GetParameters(), requestContext, handlerData);
result.AfterResult = after.Invoke(handler, afterArgs) as IResult;
}
return result;
}
public object[] BuildArguments(ParameterInfo[] parameters, RequestContext requestContext, HandlerData handlerData)
{
var argumentDictionary = new Dictionary<string, object>();
foreach (var parameter in parameters)
{
if (argumentDictionary.ContainsKey(parameter.Name))
{
continue;
}
if (parameter.ParameterType.IsValueType || parameter.ParameterType == typeof(String))
{
var value = getValueFromRequest(requestContext, parameter.Name.ToLower(), parameter.ParameterType);
if (value != null)
{
argumentDictionary.Add(parameter.Name, value);
}
}
else if (parameter.ParameterType.IsArray)
{
var value = getArrayValueFromRequest(requestContext, parameter.Name, parameter.ParameterType);
if (value != null)
{
argumentDictionary.Add(parameter.Name, value);
}
}
else if (parameter.ParameterType.IsClass)
{
if (parameter.ParameterType == typeof(RequestContext))
{
argumentDictionary.Add(parameter.Name, requestContext);
}
else if (parameter.ParameterType == typeof(HandlerData))
{
argumentDictionary.Add(parameter.Name, handlerData);
}
else
{
var instance = createAndPopulateInstance(requestContext, parameter.Name, parameter.ParameterType);
argumentDictionary.Add(parameter.Name, instance);
}
}
if (!argumentDictionary.ContainsKey(parameter.Name))
{
throw new Exception(String.Format("No argument was supplied for required parameter {0} ({1})", parameter.Name, parameter.ParameterType));
}
}
return argumentDictionary.Select(p => p.Value).ToArray();
}
private IResult executeFilterMethod(object filter, string filterMethod, RequestContext context, HandlerData handlerData)
{
var method = getMethod(filter, filterMethod);
if (method != null)
{
var args = _argumentBuilder.BuildArguments(method.GetParameters(), context, handlerData);
return method.Invoke(filter, args) as IResult;
}
return null;
}
public IResult Before(RequestContext context, HandlerData data)
{
// Simple validate test but an more controllable example could be
// implemented like so
//
// bool granted = Auth.Test(context, data);
// if (!granted)
// {
// return Auth.OnAccessDenied(context, data);
// }
//
// return Result.None();
return Auth.Validate(context, data);
}
void before_each()
{
// create the fakes
data = new HandlerData() { Type = typeof(FakeHandler) };
rc = A.Fake<RequestContext>();
user = A.Fake<IPrincipal>();
// setup default calls
A.CallTo(() => user.Identity.IsAuthenticated).Returns(false);
A.CallTo(() => user.IsInRole(""))
.WithAnyArguments()
.ReturnsLazily(o => new [] { "Role1", "Role2", "Role3" }.Contains(o.Arguments[0]));
A.CallTo(() => rc.HttpContext.Request.RequestType).Returns("GET");
A.CallTo(() => rc.HttpContext.User).Returns(user);
}
public IResult RunBefore(object filter, RequestContext requestContext, HandlerData handlerData)
{
return executeFilterMethod(filter, "Before", requestContext, handlerData);
}
public object Create(HandlerData handlerData)
{
return ObjectFactory.GetInstance(handlerData.Type);
}
public object Create(HandlerData handlerData)
{
return Activator.CreateInstance(handlerData.Type);
}
private static void addRoute(HandlerData handler)
{
RouteTable.Routes.Add(new SWR.Route(handler.Uri.Trim('/'), new RouteValueDictionary(handler.DefaultRouteValues), new RouteHandler(handler)));
if (AllowFormatExtensions)
{
var route = handler.Uri.Trim('/') + ".{format}";
RouteTable.Routes.Add(new SWR.Route(route, new RouteValueDictionary(handler.DefaultRouteValues), new RouteHandler(handler)));
}
}
public RouteHandler(HandlerData handlerData)
{
this.handlerData = handlerData;
}
private void processAfterFilters(IEnumerable<object> filters, HttpContext context, HandlerData handlerData)
{
filters.ForEach(type =>
{
var result = FilterInvoker.Current.RunAfter(type, _requestContext, handlerData);
if (result != null)
{
result.ProcessResult(new DefaultRequestContext(_requestContext), new DefaultResponseContext(context));
}
});
}
public HttpHandler(RequestContext requestContext, HandlerData handlerData)
{
_requestContext = requestContext;
_handlerData = handlerData;
}
private void processAfterFilters(IEnumerable<FilterInstance> filters, HttpContext context, HandlerData handlerData)
{
filters.Where(filter => filter.AfterFilter).Select(filter => filter.Instance).ForEach(instance =>
{
var result = FilterInvoker.Current.RunAfter(instance, _requestContext, handlerData);
if (result != null)
{
result.ProcessResult(new DefaultRequestContext(_requestContext), new DefaultResponseContext(context));
}
});
}
public IResult Get(RequestContext ctx, HandlerData data)
{
return Result.String("Access Denied");
}
