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)); }