private void EnforceBindRequiredAndValidate(ActionContext actionContext, ModelMetadata metadata, ModelBindingContext modelBindingContext, ModelBindingResult modelBindingResult)
{
if (!modelBindingResult.IsModelSet && metadata.IsBindingRequired)
{
// Enforce BindingBehavior.Required (e.g., [BindRequired])
var modelName = modelBindingContext.FieldName;
var message = metadata.ModelBindingMessageProvider.MissingBindRequiredValueAccessor(modelName);
actionContext.ModelState.TryAddModelError(modelName, message);
}
else if (modelBindingResult.IsModelSet || metadata.IsRequired)
{
// Enforce any other validation rules
var visitor = new ValidationVisitor(
actionContext,
_validatorProvider,
_validatorCache,
_modelMetadataProvider,
modelBindingContext.ValidationState);
visitor.Validate(
metadata,
modelBindingContext.ModelName,
modelBindingResult.Model,
alwaysValidateAtTopLevel: metadata.IsRequired);
}
}
/// <inheritdoc />
public void Validate(
ActionContext actionContext,
IModelValidatorProvider validatorProvider,
ValidationStateDictionary validationState,
string prefix,
object model)
{
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
if (validatorProvider == null)
{
throw new ArgumentNullException(nameof(validatorProvider));
}
var visitor = new ValidationVisitor(
actionContext,
validatorProvider,
_validatorCache,
_modelMetadataProvider,
validationState);
var metadata = model == null ? null : _modelMetadataProvider.GetMetadataForType(model.GetType());
visitor.Validate(metadata, prefix, model);
}
public void Validate(
ActionContext actionContext,
ValidationStateDictionary validationState,
string prefix,
object model)
{
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
var visitor = new ValidationVisitor(
actionContext,
this.validatorProvider,
this.validatorCache,
this.modelMetadataProvider,
validationState);
if (actionContext.HttpContext.RequestServices.GetService(typeof(IModelProvider)) is ModelProvider mp)
{
mp.SetModel(model);
}
var metadata = model == null ? null : this.modelMetadataProvider.GetMetadataForType(model.GetType());
visitor.Validate(metadata, prefix, model);
}
private async Task GetAggregationQueryInfoAsync(IQueryParser parser, string query, bool isValid, int maxNodeDepth, HashSet <string> fields, Dictionary <string, ICollection <string> > operations)
{
IQueryNode queryNode;
var context = new ElasticQueryVisitorContext {
QueryType = QueryType.Aggregation
};
try {
queryNode = await parser.ParseAsync(query, context);
} catch (Exception ex) {
_logger.LogError(ex, "Error parsing query: {Message}", ex.Message);
if (isValid)
{
throw;
}
return;
}
var info = await ValidationVisitor.RunAsync(queryNode, context);
Assert.Equal(QueryType.Aggregation, info.QueryType);
Assert.Equal(isValid, info.IsValid);
Assert.Equal(maxNodeDepth, info.MaxNodeDepth);
Assert.Equal(fields, info.ReferencedFields);
Assert.Equal(operations, info.Operations.ToDictionary(pair => pair.Key, pair => pair.Value));
}
/// <inheritdoc />
public void Validate(
ActionContext actionContext,
IModelValidatorProvider validatorProvider,
ValidationStateDictionary validationState,
string prefix,
object model)
{
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
if (validatorProvider == null)
{
throw new ArgumentNullException(nameof(validatorProvider));
}
var visitor = new ValidationVisitor(
actionContext,
validatorProvider,
_validatorCache,
_modelMetadataProvider,
validationState);
var metadata = model == null ? null : _modelMetadataProvider.GetMetadataForType(model.GetType());
visitor.Validate(metadata, prefix, model);
}
/// <summary>
/// Initialize a new <see cref="StateManager"/>.
/// </summary>
/// <param name="visitor">The visitor.</param>
/// <param name="newModel">The model to validate.</param>
public StateManager(ValidationVisitor visitor, object newModel)
{
_visitor = visitor;
_container = _visitor.Container;
_key = _visitor.Key;
_metadata = _visitor.Metadata;
_model = _visitor.Model;
_strategy = _visitor.Strategy;
}
public void HasValidators()
{
// Validating a byte array of size 30, with the ModelMetadata.HasValidators optimization.
var validationVisitor = new ValidationVisitor(
ActionContext,
CompositeModelValidatorProvider,
ValidatorCache,
ModelMetadataProvider,
new ValidationStateDictionary());
validationVisitor.Validate(ModelMetadata, "key", Model);
}
public void Validate(ActionContext actionContext, ValidationStateDictionary validationState, string prefix, object model)
{
var visitor = new ValidationVisitor(
actionContext,
_validatorProvider,
_validatorCache,
_modelMetadataProvider,
validationState);
var metadata = model == null ? null : _modelMetadataProvider.GetMetadataForType(model.GetType());
visitor.ValidateComplexTypesIfChildValidationFails = ValidateComplexTypesIfChildValidationFails;
visitor.Validate(metadata, prefix, model);
}
public void Visit_TypeWithSomeValidatedProperties()
{
// Validating a typical model with some properties that require validation.
// This executes with the ModelMetadata.HasValidators optimization.
var validationVisitor = new ValidationVisitor(
ActionContext,
CompositeModelValidatorProvider,
ValidatorCache,
ModelMetadataProvider,
new ValidationStateDictionary());
validationVisitor.Validate(ModelMetadata, "key", Model);
}
public void Baseline()
{
// Baseline for validating a byte array of size 30, without the ModelMetadata.HasValidators optimization.
// This is the behavior as of 2.1.
var validationVisitor = new ValidationVisitor(
ActionContext,
CompositeModelValidatorProvider,
ValidatorCache,
BaselineModelMetadataProvider,
new ValidationStateDictionary());
validationVisitor.Validate(BaselineModelMetadata, "key", Model);
}
public PersistenceModel(IConventionFinder conventionFinder)
{
BiDirectionalManyToManyPairer = (c, o, w) => {};
Conventions = conventionFinder;
visitors.Add(new SeparateSubclassVisitor(subclassProviders));
visitors.Add(new ComponentReferenceResolutionVisitor(componentResolvers, componentProviders));
visitors.Add(new RelationshipPairingVisitor(BiDirectionalManyToManyPairer));
visitors.Add(new ManyToManyTableNameVisitor());
visitors.Add(new ConventionVisitor(Conventions));
visitors.Add(new ComponentColumnPrefixVisitor());
visitors.Add(new RelationshipKeyPairingVisitor());
visitors.Add((validationVisitor = new ValidationVisitor()));
}
public override ValidationVisitor GetValidationVisitor(ActionContext actionContext, IModelValidatorProvider validatorProvider, ValidatorCache validatorCache, IModelMetadataProvider metadataProvider, ValidationStateDictionary validationState)
{
var visitor = new ValidationVisitor(
actionContext,
validatorProvider,
validatorCache,
metadataProvider,
validationState)
{
MaxValidationDepth = _mvcOptions.MaxValidationDepth,
ValidateComplexTypesIfChildValidationFails = _mvcOptions.ValidateComplexTypesIfChildValidationFails,
};
return(visitor);
}
private async Task GetQueryInfoAsync(IQueryParser parser)
{
const string query = "stuff hey:now nested:(stuff:33)";
var result = await parser.ParseAsync(query);
var info = await ValidationVisitor.RunAsync(result);
Assert.Equal(QueryType.Query, info.QueryType);
Assert.Equal(2, info.MaxNodeDepth);
Assert.Equal(new HashSet <string> {
"",
"hey",
"nested",
"stuff"
}, info.ReferencedFields);
}
/*
* private IModelValidatorProvider GetModelValidatorProvider(IValidatorFactory validatorFactory, CustomizeValidatorAttribute customizations) {
* var modelValidatorProvider = ImplicitlyValidateChildProperties ? new FluentValidationModelValidatorProvider(validatorFactory, customizations, _validatorProvider) : (IModelValidatorProvider) _validatorProvider;
* return modelValidatorProvider;
* }
*/
protected virtual void RunDefaultValidation(ActionContext actionContext, IModelValidatorProvider validatorProvider, ValidationStateDictionary validationState, string prefix, object model, ModelMetadata metadata, bool implicitlyValidateChildPropertiesUsingFluentValidation, IValidatorFactory factory, CustomizeValidatorAttribute customizations)
{
ValidationVisitor visitor;
// if (ImplicitlyValidateChildProperties) {
// visitor = new CustomValidationVisitor(actionContext, validatorProvider, _validatorCache, _modelMetadataProvider, validationState, factory, customizations);
// }
// else {
visitor = new ValidationVisitor(
actionContext,
validatorProvider,
_validatorCache,
_modelMetadataProvider,
validationState);
// }
visitor.Validate(metadata, prefix, model);
}
public static StateManager Recurse(
ValidationVisitor visitor,
string key,
ModelMetadata metadata,
object model,
IValidationStrategy strategy)
{
var recursifier = new StateManager(visitor, model);
visitor.Container = visitor.Model;
visitor.Key = key;
visitor.Metadata = metadata;
visitor.Model = model;
visitor.Strategy = strategy;
return(recursifier);
}
public override ValidationVisitor GetValidationVisitor(
ActionContext actionContext,
IModelValidatorProvider validatorProvider,
ValidatorCache validatorCache,
IModelMetadataProvider metadataProvider,
ValidationStateDictionary validationState)
{
var visitor = new ValidationVisitor(
actionContext,
validatorProvider,
validatorCache,
metadataProvider,
validationState);
visitor.MaxValidationDepth = _mvcOptions.MaxValidationDepth;
return(visitor);
}
public override ValidationVisitor GetValidationVisitor(
ActionContext actionContext,
IModelValidatorProvider validatorProvider,
ValidatorCache validatorCache,
IModelMetadataProvider metadataProvider,
ValidationStateDictionary validationState)
{
var visitor = new ValidationVisitor(
actionContext,
validatorProvider,
validatorCache,
metadataProvider,
validationState);
visitor.MaxValidationDepth = _mvcOptions.MaxValidationDepth;
visitor.AllowShortCircuitingValidationWhenNoValidatorsArePresent = _mvcOptions.AllowShortCircuitingValidationWhenNoValidatorsArePresent;
return(visitor);
}
public override (bool success, string validationError) Accept(ValidationVisitor visitor)
{
return(visitor.VisitConnectionLine(this));
}
public void Validate(ActionContext actionContext, ValidationStateDictionary validationState, string prefix, object model)
{
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
IValidator validator = null;
var metadata = model == null ? null : _modelMetadataProvider.GetMetadataForType(model.GetType());
bool prependPrefix = true;
if (model != null)
{
if (metadata.IsCollectionType)
{
validator = BuildCollectionValidator(prefix, metadata);
prependPrefix = false;
}
else
{
validator = _validatorFactory.GetValidator(metadata.ModelType);
}
}
if (validator == null)
{
// Use default impl if FV doesn't have a validator for the type.
var visitor = new ValidationVisitor(
actionContext,
_validatorProvider,
_validatorCache,
_modelMetadataProvider,
validationState);
visitor.Validate(metadata, prefix, model);
return;
}
foreach (var value in actionContext.ModelState.Values
.Where(v => v.ValidationState == ModelValidationState.Unvalidated))
{
// Set all unvalidated states to valid. If we end up adding an error below then that properties state
// will become ModelValidationState.Invalid and will set ModelState.IsValid to false
value.ValidationState = ModelValidationState.Valid;
}
var customizations = GetCustomizations(actionContext, model.GetType(), prefix);
var selector = customizations.ToValidatorSelector();
var interceptor = customizations.GetInterceptor() ?? (validator as IValidatorInterceptor);
var context = new FluentValidation.ValidationContext(model, new FluentValidation.Internal.PropertyChain(), selector);
if (interceptor != null)
{
// Allow the user to provide a customized context
// However, if they return null then just use the original context.
context = interceptor.BeforeMvcValidation((ControllerContext)actionContext, context) ?? context;
}
var result = validator.Validate(context);
if (interceptor != null)
{
// allow the user to provice a custom collection of failures, which could be empty.
// However, if they return null then use the original collection of failures.
result = interceptor.AfterMvcValidation((ControllerContext)actionContext, context, result) ?? result;
}
if (!string.IsNullOrEmpty(prefix))
{
prefix = prefix + ".";
}
foreach (var modelError in result.Errors)
{
string key = modelError.PropertyName;
if (prependPrefix)
{
key = prefix + key;
}
else
{
key = key.Replace(ModelKeyPrefix, string.Empty);
}
// See if there's already an item in the ModelState for this key.
if (actionContext.ModelState.ContainsKey(key))
{
actionContext.ModelState[key].Errors.Clear();
}
actionContext.ModelState.AddModelError(key, modelError.ErrorMessage);
}
// Otherwise:
/*
*
*/
}
public abstract (bool success, string validationError) Accept(ValidationVisitor visitor);
public async Task <QueryProcessResult> ValidateAggregationsAsync(IQueryNode query)
{
var info = await ValidationVisitor.RunAsync(query).AnyContext();
return(ApplyAggregationRules(info));
}