public static ModelBindingTestContext GetTestContext( Action <HttpRequest> updateRequest = null, Action <MvcOptions> updateOptions = null, ControllerActionDescriptor actionDescriptor = null) { var httpContext = GetHttpContext(updateRequest, updateOptions); var services = httpContext.RequestServices; var context = new ModelBindingTestContext() { ActionDescriptor = actionDescriptor ?? new ControllerActionDescriptor(), HttpContext = httpContext, MetadataProvider = TestModelMetadataProvider.CreateDefaultProvider(), RouteData = new RouteData(), }; var options = services.GetRequiredService <IOptions <MvcOptions> >(); var valueProviderFactoryContext = new ValueProviderFactoryContext(context); foreach (var factory in options.Value.ValueProviderFactories) { factory.CreateValueProviderAsync(valueProviderFactoryContext).GetAwaiter().GetResult(); } context.ValueProviders = valueProviderFactoryContext.ValueProviders; return(context); }
private async Task InvokeAllActionFiltersAsync() { _cursor.SetStage(FilterStage.ActionFilters); Debug.Assert(_resourceExecutingContext != null); ActionBindingContext = new ActionBindingContext(); ActionBindingContext.InputFormatters = _resourceExecutingContext.InputFormatters; ActionBindingContext.ModelBinder = new CompositeModelBinder(_resourceExecutingContext.ModelBinders); ActionBindingContext.ValidatorProvider = new CompositeModelValidatorProvider( _resourceExecutingContext.ValidatorProviders); var valueProviderFactoryContext = new ValueProviderFactoryContext( ActionContext.HttpContext, ActionContext.RouteData.Values); ActionBindingContext.ValueProvider = CompositeValueProvider.Create( _resourceExecutingContext.ValueProviderFactories, valueProviderFactoryContext); Instance = CreateInstance(); var arguments = await GetActionArgumentsAsync(ActionContext, ActionBindingContext); _actionExecutingContext = new ActionExecutingContext( ActionContext, _filters, arguments, Instance); await InvokeActionFilterAsync(); }
private static async Task AddValueProviderAsync(ValueProviderFactoryContext context, HttpRequest request) { IFormCollection form; try { form = await request.ReadFormAsync(); } catch (InvalidDataException ex) { // ReadFormAsync can throw InvalidDataException if the form content is malformed. // Wrap it in a ValueProviderException that the CompositeValueProvider special cases. throw new ValueProviderException(Resources.FormatFailedToReadRequestForm(ex.Message), ex); } catch (IOException ex) { // ReadFormAsync can throw IOException if the client disconnects. // Wrap it in a ValueProviderException that the CompositeValueProvider special cases. throw new ValueProviderException(Resources.FormatFailedToReadRequestForm(ex.Message), ex); } if (form.Files.Count > 0) { var valueProvider = new FormFileValueProvider(form.Files); context.ValueProviders.Add(valueProvider); } }
private async Task AddValueProviderAsync(ValueProviderFactoryContext context) { var request = context.ActionContext.HttpContext.Request; IFormCollection form; try { request.Body.Position = 0; var body = await request.BodyReader.ReadAsync(); var CiphertextArray = MessagePackSerializer.Deserialize <byte[][]>(body.Buffer, MessagePack.Resolvers.ContractlessStandardResolver.Options); var plainText = new StringBuilder(); for (int i = 0; i < CiphertextArray.Length; i++) { plainText.Append(_certificate.DecryptFromUTF8bytes(CiphertextArray[i])); } var formReader = new FormReader(plainText.ToString()); var formFields = await formReader.ReadFormAsync(); form = new FormCollection(formFields); } catch (Exception) { throw; //throw new ValueProviderException(Resources.FormatFailedToReadRequestForm(ex.Message), ex); } var valueProvider = new FormValueProvider( BindingSource.Form, form, CultureInfo.CurrentCulture); context.ValueProviders.Add(valueProvider); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { context.ValueProviders.Insert(0, new SeparatedQueryStringValueProvider(_key, context.ActionContext.HttpContext.Request.Query, _separator)); return(Task.CompletedTask); }
public Task <ActionBindingContext> GetActionBindingContextAsync(ActionContext actionContext) { if (_bindingContext != null) { if (actionContext == _bindingContext.Item1) { return(Task.FromResult(_bindingContext.Item2)); } } var factoryContext = new ValueProviderFactoryContext( actionContext.HttpContext, actionContext.RouteData.Values); var valueProvider = _compositeValueProviderFactory.GetValueProvider(factoryContext); var context = new ActionBindingContext( actionContext, _modelMetadataProvider, _compositeModelBinder, valueProvider, _inputFormatterSelector, _validatorProvider); _bindingContext = new Tuple <ActionContext, ActionBindingContext>(actionContext, context); return(Task.FromResult(context)); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var headers = context.ActionContext.HttpContext.Request.Headers; if (headers != null && headers.Count > 0) { var valueProvider = new HeaderValueProvider( Header, headers, CultureInfo.InvariantCulture); context.ValueProviders.Add(valueProvider); } #if NET451 return(Task.FromResult(0)); #else return(Task.CompletedTask); #endif }
private static async Task AddValueProviderAsync(ValueProviderFactoryContext context) { var request = context.ActionContext.HttpContext.Request; var body = string.Empty; request.EnableRewind(); using (var reader = new StreamReader(request.Body, Encoding.UTF8, true, 1024, true)) { body = await reader.ReadToEndAsync(); } request.Body.Position = 0; if (string.IsNullOrWhiteSpace(body)) { return; } var jObject = Newtonsoft.Json.Linq.JObject.Parse(body); var valueProvider = new CustomHttpBodyValueProvider( BindingSource.Form, jObject, CultureInfo.CurrentCulture); context.ValueProviders.Add(valueProvider); }
private static async System.Threading.Tasks.Task AddValueProviderAsync(ValueProviderFactoryContext context) { var request = context.ActionContext.HttpContext.Request; string body; request.EnableRewind(); using (var reader = new StreamReader(request.Body, Encoding.UTF8, true, 1024, true)) { body = await reader.ReadToEndAsync(); } request.Body.Position = 0; if (string.IsNullOrWhiteSpace(body)) { return; } var dict = JsonConvert.DeserializeObject <Dictionary <string, object> >(body, SerializationHelper.DefaultSettingsAll); var valueProvider = new FullJsonValueProvider(dict, CultureInfo.CurrentCulture); context.ValueProviders.Add(valueProvider); }
private static async Task AddValueProviderAsync(ValueProviderFactoryContext context, IDictionary <string, string> dicValues) { var request = context.ActionContext.HttpContext.Request; var valueProvider = new DecryptorValueProvier(BindingSource.ModelBinding, dicValues, CultureInfo.CurrentCulture); context.ValueProviders.Add(valueProvider); }
private static async Task AddValueProviderAsync(ValueProviderFactoryContext context) { var request = context.ActionContext.HttpContext.Request; IFormCollection formCollection; try { formCollection = await request.ReadFormAsync(); } catch (InvalidDataException ex) { // ReadFormAsync can throw InvalidDataException if the form content is malformed. // Wrap it in a ValueProviderException that the CompositeValueProvider special cases. throw new ValueProviderException(Resources.FormatFailedToReadRequestForm(ex.Message), ex); } catch (IOException ex) { // ReadFormAsync can throw IOException if the client disconnects. // Wrap it in a ValueProviderException that the CompositeValueProvider special cases. throw new ValueProviderException(Resources.FormatFailedToReadRequestForm(ex.Message), ex); } var valueProvider = new JQueryFormValueProvider( BindingSource.Form, JQueryKeyValuePairNormalizer.GetValues(formCollection, formCollection.Count), CultureInfo.CurrentCulture); context.ValueProviders.Add(valueProvider); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { var authorizationHeader = context.ActionContext.HttpContext.Request.Headers["Authorization"]; var accessToken = authorizationHeader[0].Replace("Bearer ", string.Empty); context.ValueProviders.Add(new BearerTokenValueProvider(BearerTokenBindingSource.Instance, accessToken)); return(Task.CompletedTask); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { var cookies = context.ActionContext.HttpContext.Request.Cookies; context.ValueProviders.Add(new CookieValueProvider(CookieBindingSource.Instance, cookies)); return(Task.CompletedTask); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { if (context.ActionContext.HttpContext.Request.HasFormContentType) { context.ValueProviders.Add(new TrimmedFormValueProvider(context.ActionContext.HttpContext.Request.Form)); } return(Task.CompletedTask); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { context.ValueProviders.Insert(0, new SeparatedRouteValueProvider(_keys, context.ActionContext.HttpContext.GetRouteData().Values, _separator)); return(Task.CompletedTask); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { //var paramsProtector = (CryptoParamsProtector)context.ActionContext.HttpContext // .RequestServices.GetService(typeof(CryptoParamsProtector)); context.ValueProviders.Add(new CryptoValueProvider(context.ActionContext.RouteData.Values["id"]?.ToString())); return(Task.CompletedTask); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { Guard.NotNull(context, nameof(context)); Guard.NotNull(context.ValueProviders, nameof(context.ValueProviders)); context.ValueProviders.Clear(); context.ValueProviders.Add(new RPCParametersValueProvider(context)); return(Task.CompletedTask); }
private Task AddValueProviderAsync(ValueProviderFactoryContext context) { using (StreamReader sr = new StreamReader(context.ActionContext.HttpContext.Request.Body)) { string bodyString = sr.ReadToEnd(); context.ValueProviders.Add(new BlahValueProvider(bodyString)); } return(Task.CompletedTask); }
public IValueProvider GetValueProvider(ValueProviderFactoryContext context) { if (context.HttpContext.Request.Path.Value.Contains("TestValueProvider")) { return(new CustomValueProvider()); } return(null); }
public Task <IValueProvider> GetValueProviderAsync(ValueProviderFactoryContext context) { if (context.HttpContext.Request.Path.Value.Contains("TestValueProvider")) { return(Task.FromResult <IValueProvider>(new CustomValueProvider())); } return(Task.FromResult <IValueProvider>(null)); }
protected override async Task <ModelBindingResult> BindAsync(PageContext pageContext, object value, string name, Type type) { var factories = pageContext.ValueProviderFactories; var valueProviderFactoryContext = new ValueProviderFactoryContext(pageContext); for (var i = 0; i < factories.Count; i++) { var factory = factories[i]; await factory.CreateValueProviderAsync(valueProviderFactoryContext); } var valueProvider = new CompositeValueProvider(valueProviderFactoryContext.ValueProviders); var metadata = _modelMetadataProvider.GetMetadataForType(type); var binder = _modelBinderFactory.CreateBinder(new ModelBinderFactoryContext() { BindingInfo = null, Metadata = metadata, CacheToken = null, }); var modelBindingContext = DefaultModelBindingContext.CreateBindingContext( pageContext, valueProvider, metadata, null, name); modelBindingContext.Model = value; if (modelBindingContext.ValueProvider.ContainsPrefix(name)) { // We have a match for the parameter name, use that as that prefix. modelBindingContext.ModelName = name; } else { // No match, fallback to empty string as the prefix. modelBindingContext.ModelName = string.Empty; } await binder.BindModelAsync(modelBindingContext); var result = modelBindingContext.Result; if (result.IsModelSet) { _validator.Validate( pageContext, modelBindingContext.ValidationState, modelBindingContext.ModelName, result.Model); } return(result); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { var provider = new PathValueProvider( BindingSource.Custom, context.ActionContext.RouteData.Values); context.ValueProviders.Add(provider); return(Task.CompletedTask); }
private static void AddValueProviderAsync(ValueProviderFactoryContext context, string body) { var request = context.ActionContext.HttpContext.Request; var valueProvider = new BodyValueProvider( BindingSource.Body, body, CultureInfo.CurrentCulture); context.ValueProviders.Add(valueProvider); }
/// <inheritdoc /> public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } context.ValueProviders.Add(new ClaimsValueProvider(ClaimsBindingSource.BindingSource, context.ActionContext.HttpContext.User)); return(Task.CompletedTask); }
private static void AddResultsToHttpContext(ValueProviderFactoryContext context, bool isEncryptDatas, bool isDecryptSucceed, Exception decryptException, IDictionary <string, string> dicDecryptDatas) { RequestDataModel reqData = new RequestDataModel(); reqData.IsEncryptDatas = isEncryptDatas; reqData.IsDecryptSucceed = isDecryptSucceed; reqData.DicDecryptDatas = dicDecryptDatas; reqData.DecryptException = decryptException; context.ActionContext.HttpContext.Items.Add(RequestDataModel.RequestDataKey, reqData); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var req = context.ActionContext.HttpContext.Request; return(req.ContentType == "application/json" ? AddValueProviderAsync(context) : Task.CompletedTask); }
private static async Task AddValueProviderAsync(ValueProviderFactoryContext context, IEnumerable <KeyValuePair <string, string> > keyMap) { var request = context.ActionContext.HttpContext.Request; var valueProvider = new MyValueProvider( BindingSource.Form, await request.ReadFormAsync(), keyMap, CultureInfo.CurrentCulture); context.ValueProviders.Add(valueProvider); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.ActionContext.HttpContext.Request.HasFormContentType) { return(AddValueProviderAsync(context, keyMap)); } return(TaskCache.CompletedTask); }
private static ValueProviderFactoryContext CreateThrowingContext(Exception exception) { var context = new Mock <HttpContext>(); context.Setup(c => c.Request.ContentType).Returns("application/x-www-form-urlencoded"); context.Setup(c => c.Request.HasFormContentType).Returns(true); context.Setup(c => c.Request.ReadFormAsync(It.IsAny <CancellationToken>())).ThrowsAsync(exception); var actionContext = new ActionContext(context.Object, new RouteData(), new ActionDescriptor()); var valueProviderContext = new ValueProviderFactoryContext(actionContext); return(valueProviderContext); }
public Task CreateValueProviderAsync(ValueProviderFactoryContext context) { var request = context.ActionContext.HttpContext.Request; var headers = request.Headers; if (headers.Count > 0) { context.ValueProviders.Add(new HeaderValueProvider(headers)); } return(Task.CompletedTask); }
public void GetValueProvider_ReturnsQueryStringValueProviderInstaceWithInvariantCulture() { // Arrange var request = new Mock<HttpRequest>(); request.SetupGet(f => f.Query).Returns(Mock.Of<IReadableStringCollection>()); var context = new Mock<HttpContext>(); context.SetupGet(c => c.Items).Returns(new Dictionary<object, object>()); context.SetupGet(c => c.Request).Returns(request.Object); var factoryContext = new ValueProviderFactoryContext(context.Object, new Dictionary<String, object>(StringComparer.OrdinalIgnoreCase)); // Act var result = _factory.GetValueProvider(factoryContext); // Assert var valueProvider = Assert.IsType<ReadableStringCollectionValueProvider>(result); Assert.Equal(CultureInfo.InvariantCulture, valueProvider.Culture); }
public async Task GetValueProvider_ReturnsQueryStringValueProviderInstanceWithInvariantCulture() { // Arrange var request = new Mock<HttpRequest>(); request.SetupGet(f => f.Query).Returns(Mock.Of<IQueryCollection>()); var context = new Mock<HttpContext>(); context.SetupGet(c => c.Items).Returns(new Dictionary<object, object>()); context.SetupGet(c => c.Request).Returns(request.Object); var actionContext = new ActionContext(context.Object, new RouteData(), new ActionDescriptor()); var factoryContext = new ValueProviderFactoryContext(actionContext); var factory = new QueryStringValueProviderFactory(); // Act await factory.CreateValueProviderAsync(factoryContext); // Assert var valueProvider = Assert.IsType<QueryStringValueProvider>(Assert.Single(factoryContext.ValueProviders)); Assert.Equal(CultureInfo.InvariantCulture, valueProvider.Culture); }