private static ModelBindingContext GetBindingContext(Type modelType, Type binderType = null)
{
var metadataProvider = new TestModelMetadataProvider();
metadataProvider.ForType(modelType).BindingDetails(bd => bd.BinderType = binderType);
var operationBindingContext = new OperationBindingContext
{
MetadataProvider = metadataProvider,
HttpContext = new DefaultHttpContext(),
ValidatorProvider = Mock.Of <IModelValidatorProvider>(),
};
var bindingContext = new ModelBindingContext
{
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = "someName",
ValueProvider = Mock.Of <IValueProvider>(),
ModelState = new ModelStateDictionary(),
OperationBindingContext = operationBindingContext,
BinderType = binderType
};
return(bindingContext);
}
private async Task PopulateArgumentAsync(
ActionContext actionContext,
ActionBindingContext bindingContext,
IDictionary <string, object> arguments,
IEnumerable <ModelMetadata> parameterMetadata)
{
var operationBindingContext = new OperationBindingContext
{
ModelBinder = bindingContext.ModelBinder,
ValidatorProvider = bindingContext.ValidatorProvider,
MetadataProvider = _modelMetadataProvider,
HttpContext = actionContext.HttpContext,
ValueProvider = bindingContext.ValueProvider,
};
foreach (var parameter in parameterMetadata)
{
var parameterType = parameter.ModelType;
var modelBindingContext = GetModelBindingContext(parameter, actionContext, operationBindingContext);
if (await bindingContext.ModelBinder.BindModelAsync(modelBindingContext) &&
modelBindingContext.IsModelSet)
{
arguments[parameter.PropertyName] = modelBindingContext.Model;
}
}
}
public async Task <ModelBindingResult?> BindModelAsync(
ParameterDescriptor parameter,
OperationBindingContext operationContext)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (operationContext == null)
{
throw new ArgumentNullException(nameof(operationContext));
}
var metadata = _modelMetadataProvider.GetMetadataForType(parameter.ParameterType);
var modelBindingContext = DefaultModelBindingContext.CreateBindingContext(
operationContext,
metadata,
parameter.BindingInfo,
parameter.Name);
if (parameter.BindingInfo?.BinderModelName != null)
{
// The name was set explicitly, always use that as the prefix.
modelBindingContext.ModelName = parameter.BindingInfo.BinderModelName;
}
else if (modelBindingContext.ValueProvider.ContainsPrefix(parameter.Name))
{
// We have a match for the parameter name, use that as that prefix.
modelBindingContext.ModelName = parameter.Name;
}
else
{
// No match, fallback to empty string as the prefix.
modelBindingContext.ModelName = string.Empty;
}
var binder = _modelBinderFactory.CreateBinder(new ModelBinderFactoryContext()
{
BindingInfo = parameter.BindingInfo,
Metadata = metadata,
CacheToken = parameter,
});
await binder.BindModelAsync(modelBindingContext);
var modelBindingResult = modelBindingContext.Result;
if (modelBindingResult != null && modelBindingResult.Value.IsModelSet)
{
_validator.Validate(
operationContext.ActionContext,
operationContext.ValidatorProvider,
modelBindingContext.ValidationState,
modelBindingResult.Value.Key,
modelBindingResult.Value.Model);
}
return(modelBindingResult);
}
public async Task <ModelBindingResult> BindModelAsync(
[NotNull] ParameterDescriptor parameter,
[NotNull] ModelStateDictionary modelState,
[NotNull] OperationBindingContext operationContext)
{
var metadata = _modelMetadataProvider.GetMetadataForType(parameter.ParameterType);
var modelBindingContext = GetModelBindingContext(
parameter.Name,
metadata,
parameter.BindingInfo,
modelState,
operationContext);
var modelBindingResult = await operationContext.ModelBinder.BindModelAsync(modelBindingContext);
if (modelBindingResult != null && modelBindingResult.IsModelSet)
{
var key = modelBindingResult.Key;
var modelExplorer = new ModelExplorer(
_modelMetadataProvider,
metadata,
modelBindingResult.Model);
var validationContext = new ModelValidationContext(
modelBindingContext.BindingSource,
operationContext.ValidatorProvider,
modelState,
modelExplorer);
_validator.Validate(validationContext, modelBindingResult.ValidationNode);
}
return(modelBindingResult);
}
public async Task <ModelBindingResult> BindModelAsync(
[NotNull] ParameterDescriptor parameter,
[NotNull] ModelStateDictionary modelState,
[NotNull] OperationBindingContext operationContext)
{
var metadata = _modelMetadataProvider.GetMetadataForType(parameter.ParameterType);
var modelBindingContext = ModelBindingContext.CreateBindingContext(
operationContext,
modelState,
metadata,
parameter.BindingInfo,
parameter.Name);
var modelBindingResult = await operationContext.ModelBinder.BindModelAsync(modelBindingContext);
if (modelBindingResult.IsModelSet)
{
_validator.Validate(
operationContext.ValidatorProvider,
modelState,
modelBindingContext.ValidationState,
modelBindingResult.Key,
modelBindingResult.Model);
}
return(modelBindingResult);
}
public async Task <ModelBindingResult> BindModelAsync(
ParameterDescriptor parameter,
OperationBindingContext operationContext)
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (operationContext == null)
{
throw new ArgumentNullException(nameof(operationContext));
}
var metadata = _modelMetadataProvider.GetMetadataForType(parameter.ParameterType);
var modelBindingContext = ModelBindingContext.CreateBindingContext(
operationContext,
metadata,
parameter.BindingInfo,
parameter.Name);
var modelBindingResult = await operationContext.ModelBinder.BindModelAsync(modelBindingContext);
if (modelBindingResult.IsModelSet)
{
_validator.Validate(
operationContext.ActionContext,
operationContext.ValidatorProvider,
modelBindingContext.ValidationState,
modelBindingResult.Key,
modelBindingResult.Model);
}
return(modelBindingResult);
}
private static ModelBindingContext GetBindingContext(
Type modelType,
IInputFormatter inputFormatter = null,
HttpContext httpContext = null,
IModelMetadataProvider metadataProvider = null)
{
if (httpContext == null)
{
httpContext = new DefaultHttpContext();
}
if (metadataProvider == null)
{
metadataProvider = new EmptyModelMetadataProvider();
}
var operationBindingContext = new OperationBindingContext
{
ModelBinder = GetBodyBinder(httpContext, inputFormatter),
MetadataProvider = metadataProvider,
HttpContext = httpContext,
};
var bindingContext = new ModelBindingContext
{
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = "someName",
ValueProvider = Mock.Of <IValueProvider>(),
ModelState = new ModelStateDictionary(),
OperationBindingContext = operationBindingContext,
BindingSource = BindingSource.Body,
};
return(bindingContext);
}
/// <summary>
/// Updates the specified <paramref name="model"/> instance using the specified <paramref name="modelBinder"/>
/// and the specified <paramref name="valueProvider"/> and executes validation using the specified
/// <paramref name="validatorProvider"/>.
/// </summary>
/// <param name="model">The model instance to update and validate.</param>
/// <param name="modelType">The type of model instance to update and validate.</param>
/// <param name="prefix">The prefix to use when looking up values in the <paramref name="valueProvider"/>.
/// </param>
/// <param name="httpContext">The <see cref="HttpContext"/> for the current executing request.</param>
/// <param name="modelState">The <see cref="ModelStateDictionary"/> used for maintaining state and
/// results of model-binding validation.</param>
/// <param name="metadataProvider">The provider used for reading metadata for the model type.</param>
/// <param name="modelBinder">The <see cref="IModelBinder"/> used for binding.</param>
/// <param name="valueProvider">The <see cref="IValueProvider"/> used for looking up values.</param>
/// <param name="objectModelValidator">The <see cref="IObjectModelValidator"/> used for validating the
/// bound values.</param>
/// <param name="validatorProvider">The <see cref="IModelValidatorProvider"/> used for executing validation
/// on the model instance.</param>
/// <param name="predicate">A predicate which can be used to
/// filter properties(for inclusion/exclusion) at runtime.</param>
/// <returns>A <see cref="Task"/> that on completion returns <c>true</c> if the update is successful</returns>
public static async Task <bool> TryUpdateModelAsync(
[NotNull] object model,
[NotNull] Type modelType,
[NotNull] string prefix,
[NotNull] HttpContext httpContext,
[NotNull] ModelStateDictionary modelState,
[NotNull] IModelMetadataProvider metadataProvider,
[NotNull] IModelBinder modelBinder,
[NotNull] IValueProvider valueProvider,
[NotNull] IObjectModelValidator objectModelValidator,
[NotNull] IModelValidatorProvider validatorProvider,
[NotNull] Func <ModelBindingContext, string, bool> predicate)
{
if (!modelType.IsAssignableFrom(model.GetType()))
{
var message = Resources.FormatModelType_WrongType(
model.GetType().FullName,
modelType.FullName);
throw new ArgumentException(message, nameof(modelType));
}
var modelMetadata = metadataProvider.GetMetadataForType(modelType);
// Clear ModelStateDictionary entries for the model so that it will be re-validated.
ClearValidationStateForModel(modelType, modelState, metadataProvider, prefix);
var operationBindingContext = new OperationBindingContext
{
ModelBinder = modelBinder,
ValidatorProvider = validatorProvider,
MetadataProvider = metadataProvider,
HttpContext = httpContext
};
var modelBindingContext = new ModelBindingContext
{
Model = model,
ModelMetadata = modelMetadata,
ModelName = prefix,
ModelState = modelState,
ValueProvider = valueProvider,
FallbackToEmptyPrefix = true,
OperationBindingContext = operationBindingContext,
PropertyFilter = predicate
};
var modelBindingResult = await modelBinder.BindModelAsync(modelBindingContext);
if (modelBindingResult != null)
{
var modelExplorer = new ModelExplorer(metadataProvider, modelMetadata, modelBindingResult.Model);
var modelValidationContext = new ModelValidationContext(modelBindingContext, modelExplorer);
modelValidationContext.RootPrefix = prefix;
objectModelValidator.Validate(modelValidationContext);
return(modelState.IsValid);
}
return(false);
}
/// <inheritdocs />
public async Task <IDictionary <string, object> > BindArgumentsAsync(WidgetContext context, MethodInfo method, IDictionary <string, object> values)
{
var bindingContext = new OperationBindingContext
{
HttpContext = context.ViewContext.HttpContext,
InputFormatters = _options.InputFormatters,
MetadataProvider = _modelMetadataProvider,
ModelBinder = new CompositeModelBinder(_options.ModelBinders),
ValidatorProvider = new CompositeModelValidatorProvider(_options.ModelValidatorProviders),
ValueProvider = await CompositeValueProvider.CreateAsync(_options.ValueProviderFactories, new ValueProviderFactoryContext(context.ViewContext.HttpContext, context.ViewContext.RouteData.Values))
};
var arguments = new Dictionary <string, object>(StringComparer.Ordinal);
var parameters = method.GetParameters();
foreach (var parameter in parameters)
{
if (values.ContainsKey(parameter.Name))
{
arguments.Add(parameter.Name, values[parameter.Name]);
}
else
{
var attribute = parameter.GetCustomAttributes().OfType <IBindingSourceMetadata>().FirstOrDefault();
var bindingInfo = new BindingInfo()
{
BindingSource = attribute?.BindingSource
};
var metadata = _modelMetadataProvider.GetMetadataForType(parameter.ParameterType);
var modelBindingContext = ModelBindingContext.CreateBindingContext(
bindingContext,
context.ModelState,
metadata,
bindingInfo,
parameter.Name);
var result = await bindingContext.ModelBinder.BindModelAsync(modelBindingContext);
if (result.IsModelSet)
{
_objectModelValidator.Validate(bindingContext.ValidatorProvider, context.ModelState, modelBindingContext.ValidationState, result.Key, result.Model);
arguments.Add(parameter.Name, result.Model);
}
else
{
arguments.Add(parameter.Name, Activator.CreateInstance(parameter.ParameterType));
}
}
}
return(arguments);
}
private bool TryValidateModel(
object model,
string prefix,
OperationBindingContext operationContext)
{
var controller = new TestController();
controller.ControllerContext = new ControllerContext(operationContext.ActionContext);
controller.ObjectValidator = ModelBindingTestHelper.GetObjectValidator(operationContext.MetadataProvider);
controller.MetadataProvider = operationContext.MetadataProvider;
controller.ControllerContext.ValidatorProviders = new[] { operationContext.ValidatorProvider }.ToList();
return(controller.TryValidateModel(model, prefix));
}
private async Task PopulateArgumentsAsync(
OperationBindingContext operationContext,
ModelStateDictionary modelState,
IDictionary <string, object> arguments,
IEnumerable <ParameterDescriptor> parameterMetadata)
{
foreach (var parameter in parameterMetadata)
{
var modelBindingResult = await BindModelAsync(parameter, modelState, operationContext);
if (modelBindingResult != null && modelBindingResult.IsModelSet)
{
arguments[parameter.Name] = modelBindingResult.Model;
}
}
}
private Task <bool> TryUpdateModel(
object model,
string prefix,
OperationBindingContext operationContext)
{
return(ModelBindingHelper.TryUpdateModelAsync(
model,
model.GetType(),
prefix,
operationContext.ActionContext,
operationContext.MetadataProvider,
operationContext.ModelBinder,
operationContext.ValueProvider,
operationContext.InputFormatters,
ModelBindingTestHelper.GetObjectValidator(operationContext.MetadataProvider),
operationContext.ValidatorProvider));
}
private static DefaultModelBindingContext GetBindingContext(
Type modelType,
IEnumerable <IInputFormatter> inputFormatters = null,
HttpContext httpContext = null,
IModelMetadataProvider metadataProvider = null)
{
if (httpContext == null)
{
httpContext = new DefaultHttpContext();
}
if (inputFormatters == null)
{
inputFormatters = Enumerable.Empty <IInputFormatter>();
}
if (metadataProvider == null)
{
metadataProvider = new EmptyModelMetadataProvider();
}
var operationBindingContext = new OperationBindingContext
{
ActionContext = new ActionContext()
{
HttpContext = httpContext,
},
InputFormatters = inputFormatters.ToList(),
MetadataProvider = metadataProvider,
};
var bindingContext = new DefaultModelBindingContext
{
FieldName = "someField",
IsTopLevelObject = true,
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = "someName",
ValueProvider = Mock.Of <IValueProvider>(),
ModelState = new ModelStateDictionary(),
OperationBindingContext = operationBindingContext,
BindingSource = BindingSource.Body,
};
return(bindingContext);
}
private static ModelBindingContext GetModelBindingContext(
string parameterName,
ModelMetadata metadata,
BindingInfo bindingInfo,
ModelStateDictionary modelState,
OperationBindingContext operationBindingContext)
{
var modelBindingContext = ModelBindingContext.GetModelBindingContext(
metadata,
bindingInfo,
parameterName);
modelBindingContext.ModelState = modelState;
modelBindingContext.ValueProvider = operationBindingContext.ValueProvider;
modelBindingContext.OperationBindingContext = operationBindingContext;
return(modelBindingContext);
}
private async Task PopulateArgumentsAsync(
OperationBindingContext operationContext,
ModelStateDictionary modelState,
IDictionary <string, object> arguments,
IList <ParameterDescriptor> parameterMetadata)
{
// Perf: Avoid allocations
for (var i = 0; i < parameterMetadata.Count; i++)
{
var parameter = parameterMetadata[i];
var modelBindingResult = await BindModelAsync(parameter, modelState, operationContext);
if (modelBindingResult.IsModelSet)
{
arguments[parameter.Name] = modelBindingResult.Model;
}
}
}
internal static ModelBindingContext GetModelBindingContext(
ModelMetadata modelMetadata,
ActionBindingContext actionBindingContext,
OperationBindingContext operationBindingContext)
{
var modelBindingContext = new ModelBindingContext
{
ModelName = modelMetadata.BinderModelName ?? modelMetadata.PropertyName,
ModelMetadata = modelMetadata,
ModelState = actionBindingContext.ActionContext.ModelState,
// Fallback only if there is no explicit model name set.
FallbackToEmptyPrefix = modelMetadata.BinderModelName == null,
ValueProvider = actionBindingContext.ValueProvider,
OperationBindingContext = operationBindingContext,
};
return(modelBindingContext);
}
/// <summary>
/// Updates the specified <paramref name="model"/> instance using the specified <paramref name="modelBinder"/>
/// and the specified <paramref name="valueProvider"/> and executes validation using the specified
/// <paramref name="validatorProvider"/>.
/// </summary>
/// <typeparam name="TModel">The type of the model object.</typeparam>
/// <param name="model">The model instance to update and validate.</param>
/// <param name="prefix">The prefix to use when looking up values in the <paramref name="valueProvider"/>.
/// </param>
/// <param name="httpContext">The <see cref="HttpContext"/> for the current executing request.</param>
/// <param name="modelState">The <see cref="ModelStateDictionary"/> used for maintaining state and
/// results of model-binding validation.</param>
/// <param name="metadataProvider">The provider used for reading metadata for the model type.</param>
/// <param name="modelBinder">The <see cref="IModelBinder"/> used for binding.</param>
/// <param name="valueProvider">The <see cref="IValueProvider"/> used for looking up values.</param>
/// <param name="validatorProvider">The <see cref="IModelValidatorProvider"/> used for executing validation
/// on the model instance.</param>
/// <param name="predicate">A predicate which can be used to
/// filter properties(for inclusion/exclusion) at runtime.</param>
/// <returns>A <see cref="Task"/> that on completion returns <c>true</c> if the update is successful</returns>
public static async Task <bool> TryUpdateModelAsync <TModel>(
[NotNull] TModel model,
[NotNull] string prefix,
[NotNull] HttpContext httpContext,
[NotNull] ModelStateDictionary modelState,
[NotNull] IModelMetadataProvider metadataProvider,
[NotNull] IModelBinder modelBinder,
[NotNull] IValueProvider valueProvider,
[NotNull] IModelValidatorProvider validatorProvider,
[NotNull] Func <ModelBindingContext, string, bool> predicate)
where TModel : class
{
var modelMetadata = metadataProvider.GetMetadataForType(
modelAccessor: null,
modelType: typeof(TModel));
var operationBindingContext = new OperationBindingContext
{
ModelBinder = modelBinder,
ValidatorProvider = validatorProvider,
MetadataProvider = metadataProvider,
HttpContext = httpContext
};
var modelBindingContext = new ModelBindingContext
{
ModelMetadata = modelMetadata,
ModelName = prefix,
Model = model,
ModelState = modelState,
ValueProvider = valueProvider,
FallbackToEmptyPrefix = true,
OperationBindingContext = operationBindingContext,
PropertyFilter = predicate
};
if (await modelBinder.BindModelAsync(modelBindingContext))
{
return(modelState.IsValid);
}
return(false);
}
private async Task <IDictionary <string, object> > PopulateArgumentsAsync(
OperationBindingContext operationContext,
IList <ParameterDescriptor> parameterMetadata)
{
var arguments = new Dictionary <string, object>(StringComparer.Ordinal);
// Perf: Avoid allocations
for (var i = 0; i < parameterMetadata.Count; i++)
{
var parameter = parameterMetadata[i];
var modelBindingResult = await BindModelAsync(parameter, operationContext);
if (modelBindingResult != null && modelBindingResult.Value.IsModelSet)
{
arguments[parameter.Name] = modelBindingResult.Value.Model;
}
}
return(arguments);
}
private static ModelBindingContext GetBindingContext(Type modelType)
{
var metadataProvider = new DataAnnotationsModelMetadataProvider();
var operationBindingContext = new OperationBindingContext
{
MetadataProvider = metadataProvider,
HttpContext = new DefaultHttpContext(),
ValidatorProvider = Mock.Of <IModelValidatorProvider>(),
};
var bindingContext = new ModelBindingContext
{
ModelMetadata = metadataProvider.GetMetadataForType(null, modelType),
ModelName = "someName",
ValueProvider = Mock.Of <IValueProvider>(),
ModelState = new ModelStateDictionary(),
OperationBindingContext = operationBindingContext,
};
return(bindingContext);
}
private static ModelBindingContext GetBindingContext(Type modelType, IInputFormatter inputFormatter)
{
var metadataProvider = new EmptyModelMetadataProvider();
var operationBindingContext = new OperationBindingContext
{
ModelBinder = GetBodyBinder(inputFormatter, null),
MetadataProvider = metadataProvider,
HttpContext = new DefaultHttpContext(),
};
ModelBindingContext bindingContext = new ModelBindingContext
{
ModelMetadata = metadataProvider.GetMetadataForType(null, modelType),
ModelName = "someName",
ValueProvider = Mock.Of <IValueProvider>(),
ModelState = new ModelStateDictionary(),
OperationBindingContext = operationBindingContext,
};
return(bindingContext);
}
private async Task PopulateArgumentsAsync(
OperationBindingContext operationContext,
ModelStateDictionary modelState,
IDictionary <string, object> arguments,
IEnumerable <ParameterDescriptor> parameterMetadata)
{
modelState.MaxAllowedErrors = _options.MaxModelValidationErrors;
foreach (var parameter in parameterMetadata)
{
var metadata = _modelMetadataProvider.GetMetadataForType(parameter.ParameterType);
var parameterType = parameter.ParameterType;
var modelBindingContext = GetModelBindingContext(
parameter.Name,
metadata,
parameter.BindingInfo,
modelState,
operationContext);
var modelBindingResult = await operationContext.ModelBinder.BindModelAsync(modelBindingContext);
if (modelBindingResult != null && modelBindingResult.IsModelSet)
{
var modelExplorer = new ModelExplorer(
_modelMetadataProvider,
metadata,
modelBindingResult.Model);
arguments[parameter.Name] = modelBindingResult.Model;
var validationContext = new ModelValidationContext(
modelBindingResult.Key,
modelBindingContext.BindingSource,
operationContext.ValidatorProvider,
modelState,
modelExplorer);
_validator.Validate(validationContext);
}
}
}
private static DefaultModelBindingContext GetBindingContext(
Type modelType,
IEnumerable<IInputFormatter> inputFormatters = null,
HttpContext httpContext = null,
IModelMetadataProvider metadataProvider = null)
{
if (httpContext == null)
{
httpContext = new DefaultHttpContext();
}
if (inputFormatters == null)
{
inputFormatters = Enumerable.Empty<IInputFormatter>();
}
if (metadataProvider == null)
{
metadataProvider = new EmptyModelMetadataProvider();
}
var operationBindingContext = new OperationBindingContext
{
ActionContext = new ActionContext()
{
HttpContext = httpContext,
},
InputFormatters = inputFormatters.ToList(),
MetadataProvider = metadataProvider,
};
var bindingContext = new DefaultModelBindingContext
{
FieldName = "someField",
IsTopLevelObject = true,
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = "someName",
ValueProvider = Mock.Of<IValueProvider>(),
ModelState = new ModelStateDictionary(),
OperationBindingContext = operationBindingContext,
BindingSource = BindingSource.Body,
};
return bindingContext;
}
private static ModelBindingContext GetBindingContext(Type modelType, Type binderType = null)
{
var metadataProvider = new TestModelMetadataProvider();
metadataProvider.ForType(modelType).BindingDetails(bd => bd.BinderType = binderType);
var operationBindingContext = new OperationBindingContext
{
ActionContext = new ActionContext()
{
HttpContext = new DefaultHttpContext(),
},
MetadataProvider = metadataProvider,
ValidatorProvider = Mock.Of<IModelValidatorProvider>(),
};
var bindingContext = new ModelBindingContext
{
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = "someName",
ValueProvider = Mock.Of<IValueProvider>(),
ModelState = new ModelStateDictionary(),
OperationBindingContext = operationBindingContext,
BinderType = binderType
};
return bindingContext;
}
