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