public override bool AppliesTo(RequestBinderContext context)
{
return(!context.RequestContext.Route.HasRequest &&
context.RequestContext.Route.QuerystringParameters.Any() &&
context.RequestContext.RequestMessage.ContentTypeIs(
MimeTypes.ApplicationFormUrlEncoded));
}
GetValues(RequestBinderContext context)
{
var data = await context.RequestContext
.RequestMessage.Content.ReadAsStringAsync();
return(data.ParseQueryString());
}
public async Task <BindResult> Bind(RequestBinderContext context)
{
var data = await _requestMessage.Content.ReadAsStringAsync();
return(_argumentBinder.Bind(data.ParseQueryString(), context.ActionArguments,
_routeDescriptor.Parameters));
}
public Task <BindResult> Bind(RequestBinderContext context)
{
var parameters = _routeDescriptor.Parameters
.Where(x => IncludeParameter(x, _configuration.RequestInfoBindingMode)).ToArray();
return(_argumentBinder.Bind(_requestProperties.GetProperties().ToLookup(),
context.ActionArguments, parameters, MapParameterName).ToTaskResult());
}
public async Task <BindResult> Bind(RequestBinderContext context)
{
var data = await _requestMessage.Content.ReadAsStringAsync();
var values = JsonConvert.DeserializeObject <Dictionary <string, object> >(data).ToLookup();
return(_argumentBinder.Bind(values, context.ActionArguments, _routeDescriptor.Parameters));
}
public Task <BindResult> Bind(RequestBinderContext context)
{
var values = _requestMessage.Headers.ToLookup();
var parameters = _routeDescriptor.Parameters
.Where(x => IncludeParameter(x, _configuration.HeadersBindingMode)).ToArray();
return(_argumentBinder.Bind(values, context.ActionArguments,
parameters, MapParameterName).ToTaskResult());
}
public virtual async Task Bind(RequestBinderContext context)
{
var route = context.RequestContext.Route;
var position = route.RequestParameter.Position;
var reader = _readers.ThatApplyTo(context.RequestContext, _configuration);
if (reader != null)
{
context.ActionArguments[position] = await reader.Read(context);
}
}
public Task <BindResult> Bind(RequestBinderContext context)
{
var values = _urlParameters.SelectMany(x =>
ExpandWildcardParameters(x, _routeDescriptor
.UrlParameters)).ToLookup();
var parameters = _routeDescriptor.UrlParameters
.Concat(_routeDescriptor.Parameters).ToArray();
return(_argumentBinder.Bind(values, context.ActionArguments,
parameters).ToTaskResult());
}
public Task <BindResult> Bind(RequestBinderContext context)
{
GetParameters().ForEach(x =>
{
if (x.GetArgument(context.ActionArguments) == null)
{
x.BindArgument(context.ActionArguments, _container
.GetInstance(x.TypeDescriptor.Type));
}
});
return(BindResult.Success().ToTaskResult());
}
public virtual async Task Bind(RequestBinderContext context)
{
var parameters = await GetValues(context);
foreach (var parameter in GetParameters(context))
{
var values = parameters[parameter.Name].ToArray();
var result = _mappers.Map(values, parameter, context.RequestContext, _configuration);
if (result.Mapped)
{
context.ActionArguments[parameter.Position] = result.Value;
}
}
}
private object EnsureRequestValue(RequestBinderContext context,
ParameterDescriptor requestParameter)
{
var instance = context.ActionArguments.EnsureValue(
requestParameter.Position,
requestParameter.ParameterType.TryCreate);
if (instance == null)
{
throw new RequestTypeCreationException(requestParameter
.ParameterType, _actionDescriptor.Action);
}
return(instance);
}
private void BindMultipartParameters(RequestBinderContext context,
MultipartContent multipartContent)
{
var route = _actionDescriptor.Route;
var parameter = IsEnumerableStream(route.RequestParameter?.ParameterType)
? route.RequestParameter
: route.Parameters.FirstOrDefault(x =>
IsEnumerableStream(x.TypeDescriptor))?.ParameterDescriptor;
if (parameter == null)
{
return;
}
context.ActionArguments[parameter.Position] =
parameter.ParameterType.Type == typeof(IEnumerable <InputStream>)
? (object)multipartContent
: multipartContent.GetStreams();
}
private BindResult BindValues(List <KeyValuePair <string, object> > values,
RequestBinderContext context)
{
if (!values.Any())
{
return(BindResult.Success());
}
var valueLookup = values.ToLookup();
if (_actionDescriptor.Route.Parameters.Any())
{
var result = _argumentBinder.Bind(valueLookup,
context.ActionArguments, _actionDescriptor.Route.Parameters);
if (result.Status == BindingStatus.Failure)
{
return(result);
}
}
if (!_actionDescriptor.Route.HasRequest)
{
return(BindResult.Success());
}
var requestParameter = _actionDescriptor.Route.RequestParameter;
if (IsEnumerableStream(requestParameter.ParameterType))
{
return(BindResult.Success());
}
var instance = EnsureRequestValue(context, requestParameter);
var actionParameters = requestParameter.ParameterType.Properties
.Select(x => new ActionParameter(_actionDescriptor.Action, requestParameter, x));
return(_parameterBinder.Bind(valueLookup, actionParameters,
(p, v) => p.BindProperty(instance, v),
BindResult.Success, BindResult.Failure));
}
private void BindMultipartProperties(ParameterDescriptor requestParameter,
RequestBinderContext context, MultipartContent multipartContent)
{
if (!_actionDescriptor.Route.HasRequest)
{
return;
}
var property = requestParameter?.ParameterType.Properties
.FirstOrDefault(x => IsEnumerableStream(x.PropertyType));
if (property == null)
{
return;
}
var instance = EnsureRequestValue(context, requestParameter);
property.SetValue(instance,
property.PropertyType.Type == typeof(IEnumerable <InputStream>)
? (object)multipartContent
: multipartContent.GetStreams());
}
private async Task <BindResult> Read(HttpContent content,
ParameterDescriptor requestParameter,
RequestBinderContext context)
{
var readContext = content.CreateReaderContext(_actionDescriptor);
var reader = _actionDescriptor.RequestReaders
.ThatApplyToOrDefault(_readers, readContext)
.FirstOrDefault();
if (reader == null)
{
return(BindResult.NoReader());
}
var result = await reader.Read(readContext);
if (result.Status == ReadStatus.Failure)
{
return(BindResult.Failure(result.ErrorMessage));
}
context.ActionArguments[requestParameter.Position] = result.Value;
return(BindResult.Success());
}
public virtual async Task <BindResult> Bind(RequestBinderContext context)
{
var position = _actionDescriptor.Route.RequestParameter.Position;
var headers = _requestMessage.Content?.Headers;
if ((headers?.ContentLength ?? 0) == 0)
{
if (_configuration.CreateEmptyRequestParameterValue)
{
context.ActionArguments[position] = _actionDescriptor
.Route.RequestParameter.ParameterType.TryCreate();
}
return(BindResult.Success());
}
var readContext = _requestMessage.Content
.CreateReaderContext(_actionDescriptor);
var reader = _actionDescriptor.RequestReaders
.ThatApplyToOrDefault(_readers, readContext)
.FirstOrDefault();
if (reader == null)
{
return(BindResult.NoReader());
}
var result = await reader.Read(readContext);
if (result.Status == ReadStatus.Failure)
{
return(BindResult.Failure(result.ErrorMessage));
}
context.ActionArguments[position] = result.Value;
return(BindResult.Success());
}
protected abstract ParameterDescriptor[] GetParameters(RequestBinderContext context);
GetParameters(RequestBinderContext context)
{
return(context.RequestContext.Route.QuerystringParameters);
}
protected abstract Task <ILookup <string, string> > GetValues(RequestBinderContext context);
public bool AppliesTo(RequestBinderContext context)
{
return(GetParameters().Any());
}
public override bool AppliesTo(RequestBinderContext context)
{
return(context.RequestContext.Route.QuerystringParameters.Any());
}
public bool AppliesTo(RequestBinderContext context)
{
return(_requestMessage.HasMimeMultipartContent());
}
public bool AppliesTo(RequestBinderContext context)
{
return(_routeDescriptor.UrlParameters.Any());
}
public bool AppliesTo(RequestBinderContext context)
{
return(_routeDescriptor.Parameters.Any() &&
_configuration.HeadersBindingMode != BindingMode.None);
}
protected override ParameterDescriptor[] GetParameters(RequestBinderContext context)
{
return(context.RequestContext.Route.QuerystringParameters);
}
public Task <BindResult> Bind(RequestBinderContext context)
{
return(_argumentBinder.Bind(_querystringParameters,
context.ActionArguments, _routeDescriptor.Parameters)
.ToTaskResult());
}
public virtual bool AppliesTo(RequestBinderContext context)
{
return(context.RequestContext.Route.HasRequest);
}
GetValues(RequestBinderContext context)
{
return(context.RequestContext.QuerystringParameters.ToTaskResult());
}
public async Task <BindResult> Bind(RequestBinderContext context)
{
var route = _actionDescriptor.Route;
var requestParameter = route.RequestParameter;
var stream = await _requestMessage.Content.ReadAsStreamAsync();
var multipartContent = new MultipartContent(stream,
_requestMessage.Content.Headers, _configuration);
var values = new List <KeyValuePair <string, object> >();
while (true)
{
var content = multipartContent.Peek();
if (content == null)
{
break;
}
if (content.Error)
{
return(new BindResult(BindingStatus.Failure, content.ErrorMessage));
}
if (route.HasRequest)
{
var result = await Read(content, requestParameter, context);
if (result.Status == BindingStatus.Failure)
{
return(result);
}
if (result.Status == BindingStatus.Success)
{
multipartContent.Pop();
continue;
}
}
if (route.HasParameterNamed(content.Name) ||
requestParameter.HasPropertyNamed(content.Name))
{
values.Add(content.Name, await content.ReadAsStringAsync());
multipartContent.Pop();
continue;
}
break;
}
var bindResult = BindValues(values, context);
if (bindResult.Status == BindingStatus.Failure)
{
return(bindResult);
}
BindMultipartParameters(context, multipartContent);
BindMultipartProperties(requestParameter, context, multipartContent);
return(BindResult.Success());
}
public bool AppliesTo(RequestBinderContext context)
{
return(!_routeDescriptor.HasRequest && _routeDescriptor.Parameters.Any() &&
_requestMessage.ContentTypeIs(MimeTypes.ApplicationFormUrlEncoded));
}
