public virtual void CreateValidators(ModelValidatorProviderContext context)
{
context.Results.Add(new ValidatorItem {
IsReusable = false,
Validator = new FluentValidationModelValidator(_implicitValidationEnabled)
});
}
public void GetValidators(ModelValidatorProviderContext context)
{
if (context.ModelMetadata.ModelType == typeof(MyModel))
{
context.Validators.Add(ServiceProvider.GetService <MyModelValidator>());
}
}
public void CreateValidators(ModelValidatorProviderContext context)
{
for (var i = 0; i < context.Results.Count; i++)
{
var validatorItem = context.Results[i];
if (validatorItem.Validator != null)
{
continue;
}
var attribute = validatorItem.ValidatorMetadata as ValidationAttribute;
if (attribute == null)
{
continue;
}
var validator = new DataAnnotationsModelValidator(
new ValidationAttributeAdapterProvider(),
attribute,
stringLocalizer: null);
validatorItem.Validator = validator;
if (attribute is RequiredAttribute)
{
validatorItem.IsReusable = true;
}
}
}
/// <inheritdoc />
public IEnumerable <ModelClientValidationRule> GetClientValidationRules(
[NotNull] ViewContext viewContext,
ModelExplorer modelExplorer,
string expression)
{
var validatorProvider = _bindingContextAccessor.Value.ValidatorProvider;
modelExplorer = modelExplorer ??
ExpressionMetadataProvider.FromStringExpression(expression, viewContext.ViewData, _metadataProvider);
var validationContext = new ClientModelValidationContext(
modelExplorer.Metadata,
_metadataProvider,
viewContext.HttpContext.RequestServices);
var validatorProviderContext = new ModelValidatorProviderContext(modelExplorer.Metadata);
validatorProvider.GetValidators(validatorProviderContext);
var validators = validatorProviderContext.Validators;
return
(validators
.OfType <IClientModelValidator>()
.SelectMany(v => v.GetClientValidationRules(validationContext)));
}
public void CreateValidators(ModelValidatorProviderContext context)
{
// Perf: Avoid allocations
for (var i = 0; i < ValidatorProviders.Count; i++)
{
ValidatorProviders[i].CreateValidators(context);
}
}
protected virtual IValidator CreateValidator(ModelValidatorProviderContext context)
{
if (IsValidatingProperty(context))
{
return(ValidatorFactory.GetValidator(context.ModelMetadata.ContainerType));
}
return(ValidatorFactory.GetValidator(context.ModelMetadata.ModelType));
}
public void GetValidators(ModelValidatorProviderContext context)
{
IValidator validator = CreateValidator(context);
if (!IsValidatingProperty(context))
{
context.Validators.Add(new FluentValidationModelValidator(validator));
}
}
public void GetValidators(ModelValidatorProviderContext context)
{
var modelType = context.ModelMetadata.ModelType;
if (typeof(EntitySelector).IsAssignableFrom(modelType))
{
context.Validators.Add(Validator);
}
}
protected ModelValidatorProviderContext GetMockedContext()
{
var options = _provider.GetRequiredService <IOptions <MvcOptions> >();
var provider = new DefaultModelMetadataProvider(_compositeMetadataDetailsProvider, options);
var metadata = provider.GetMetadataForType(typeof(ValidatableObject));
var context = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
return(context);
}
/// <summary>
/// Attaches the validator if there is none yet present and the
/// parameter is assignable to an <see cref="IFormFile"/>
/// </summary>
/// <param name="context"></param>
public void CreateValidators(ModelValidatorProviderContext context)
{
if (typeof(IFormFile).IsAssignableFrom(context.ModelMetadata.ModelType))
{
context.Results.Add(new ValidatorItem
{
IsReusable = true,
Validator = new EmptyFormFileValidator()
});
}
}
public void CreateValidators(ModelValidatorProviderContext context)
{
if (context.ModelMetadata.ContainerType == typeof(User))
{
context.Results.Add(new ValidatorItem
{
Validator = new UserModelValidator(),
IsReusable = true
});
}
}
public void CreateValidators(ModelValidatorProviderContext context)
{
// Note that this check does NOT catch complex types that are collection elements (as the ModelMetadataKind will still be 'Type')
if (context.ModelMetadata.MetadataKind == ModelMetadataKind.Type || context.ModelMetadata.MetadataKind == ModelMetadataKind.Parameter || (context.ModelMetadata.MetadataKind == ModelMetadataKind.Property && _implicitValidationEnabled))
{
context.Results.Add(new ValidatorItem {
IsReusable = false,
Validator = new FluentValidationModelValidator()
});
}
}
/// <inheritdoc />
public void GetValidators(ModelValidatorProviderContext context)
{
foreach (var metadata in context.ValidatorMetadata)
{
var validator = metadata as IModelValidator;
if (validator != null)
{
context.Validators.Add(validator);
}
}
}
public void CreateValidators(ModelValidatorProviderContext context)
{
IStringLocalizer stringLocalizer = null;
if (_stringLocalizerFactory != null && _options.Value.DataAnnotationLocalizerProvider != null)
{
stringLocalizer = _options.Value.DataAnnotationLocalizerProvider(
context.ModelMetadata.ContainerType ?? context.ModelMetadata.ModelType,
_stringLocalizerFactory);
}
var results = context.Results;
// Read interface .Count once rather than per iteration
var resultsCount = results.Count;
for (var i = 0; i < resultsCount; i++)
{
var validatorItem = results[i];
if (validatorItem.Validator != null)
{
continue;
}
if (!(validatorItem.ValidatorMetadata is ValidationAttribute attribute))
{
continue;
}
var validator = new DataAnnotationsModelValidator(
_validationAttributeAdapterProvider,
attribute,
stringLocalizer);
validatorItem.Validator = validator;
validatorItem.IsReusable = true;
// Inserts validators based on whether or not they are 'required'. We want to run
// 'required' validators first so that we get the best possible error message.
if (attribute is RequiredAttribute)
{
context.Results.Remove(validatorItem);
context.Results.Insert(0, validatorItem);
}
}
// Produce a validator if the type supports IValidatableObject
if (typeof(IValidatableObject).IsAssignableFrom(context.ModelMetadata.ModelType))
{
context.Results.Add(new ValidatorItem
{
Validator = new ValidatableObjectAdapter(),
IsReusable = true
});
}
}
public void CreateValidators(ModelValidatorProviderContext context)
{
if (context.ModelMetadata.IsEnum || context.ModelMetadata.IsNullableValueType)
{
context.Results.Add(new ValidatorItem
{
Validator = new EnumRangeValidator(),
IsReusable = true
});
}
}
/// <inheritdoc />
public void GetValidators(ModelValidatorProviderContext context)
{
foreach (var metadata in context.ValidatorMetadata)
{
var validator = metadata as IModelValidator;
if (validator != null)
{
context.Validators.Add(validator);
}
}
}
/// <summary>
/// Creates the server validation validators
/// </summary>
/// <param name="context"></param>
public void CreateValidators(ModelValidatorProviderContext context)
{
bool shouldAddRequiredValidator = !(context.Results.Any(x => x.GetType().Equals(typeof(RequiredAttributeAdapter))));
foreach (var validator in GetValidators(context.ModelMetadata, shouldAddRequiredValidator))
{
var validatorItem = new ValidatorItem();
validatorItem.Validator = validator;
validatorItem.IsReusable = false;
context.Results.Add(validatorItem);
}
}
public void CreateValidators(ModelValidatorProviderContext context)
{
var validator = CreateValidator(context);
if (!IsValidatingProperty(context) && validator != null)
{
context.Results.Add(new ValidatorItem {
Validator = new FluentValidationModelValidator(validator),
IsReusable = false
});
}
}
/// <summary>
/// 创建验证器。
/// </summary>
/// <param name="context"></param>
public void CreateValidators(ModelValidatorProviderContext context)
{
context.Results?.ForEach(validatorItem =>
{
if (validatorItem.Validator is null || !(validatorItem.ValidatorMetadata is ValidationAttribute attribute))
{
return;
}
validatorItem.Validator = new DataAnnotationsModelValidator(validatorItem.Validator, attribute);
});
}
public void CreateValidators(ModelValidatorProviderContext context)
{
var validator = GetValidator(context.ModelMetadata.ModelType);
if (validator != null)
{
context.Results.Add(new ValidatorItem()
{
Validator = new ValidationModelValidator(validator)
});
}
}
/// <inheritdoc />
public void GetValidators(ModelValidatorProviderContext context)
{
//Perf: Avoid allocations here
for (var i = 0; i < context.ValidatorMetadata.Count; i++)
{
var validator = context.ValidatorMetadata[i] as IModelValidator;
if (validator != null)
{
context.Validators.Add(validator);
}
}
}
internal static PropertyValidationInfo GetPropertyValidationInfo(ModelBindingContext bindingContext)
{
var validationInfo = new PropertyValidationInfo();
var modelTypeInfo = bindingContext.ModelType.GetTypeInfo();
var typeAttribute = modelTypeInfo.GetCustomAttribute <BindingBehaviorAttribute>();
var properties = bindingContext.ModelType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (var property in properties)
{
var propertyName = property.Name;
var propertyMetadata = bindingContext.ModelMetadata.Properties[propertyName];
if (propertyMetadata == null)
{
// Skip indexer properties and others ModelMetadata ignores.
continue;
}
var validatorProviderContext = new ModelValidatorProviderContext(propertyMetadata);
bindingContext.OperationBindingContext.ValidatorProvider.GetValidators(validatorProviderContext);
var requiredValidator = validatorProviderContext.Validators
.FirstOrDefault(v => v != null && v.IsRequired);
if (requiredValidator != null)
{
validationInfo.RequiredValidators[propertyName] = requiredValidator;
}
var propertyAttribute = property.GetCustomAttribute <BindingBehaviorAttribute>();
var bindingBehaviorAttribute = propertyAttribute ?? typeAttribute;
if (bindingBehaviorAttribute != null)
{
switch (bindingBehaviorAttribute.Behavior)
{
case BindingBehavior.Required:
validationInfo.RequiredProperties.Add(propertyName);
break;
case BindingBehavior.Never:
validationInfo.SkipProperties.Add(propertyName);
break;
}
}
else if (requiredValidator != null)
{
validationInfo.RequiredProperties.Add(propertyName);
}
}
return(validationInfo);
}
public void CreateValidators(ModelValidatorProviderContext context)
{
if (context.ModelMetadata.MetadataKind == ModelMetadataKind.Type)
{
var item = new ValidatorItem
{
Validator = new Valitator(_factory),
IsReusable = true,
};
context.Results.Add(item);
}
var test = context;
//throw new System.NotImplementedException();
}
/// <inheritdoc/>
public void CreateValidators(ModelValidatorProviderContext context)
{
var modelMetadata = context.ModelMetadata;
var modelType = modelMetadata.ModelType;
if (modelType.IsDataSet())
{
if (!context.Results.Any(x => x.Validator.GetType() == typeof(DataSetValidator)))
{
context.Results.Add(new ValidatorItem
{
Validator = new DataSetValidator(),
IsReusable = true
});
}
}
}
public void CreateValidators(ModelValidatorProviderContext context)
{
var stringLocalizerAdapter =
_stringLocalizerFactory != null && _dataAnnotationLocalizerProvider != null && context.ModelMetadata.ModelType.HasInterface(typeof(IValidatableObject)) ?
new StringLocalizerAdapter(_dataAnnotationLocalizerProvider(context.ModelMetadata.ContainerType ?? context.ModelMetadata.ModelType, _stringLocalizerFactory)) :
null;
var validatableObjectAdapterFound = false;
var results = context.Results;
for (int i = 0, n = results.Count; i < n; i++)
{
var result = results[i];
// 1. default messages of built-in validation attributes aren't localized by default (https://github.com/aspnet/Localization/issues/286);
// the least cumbersome solution to this problem is setting the ErrorMessage property, which will ensure that the message will run through the localizer
if (result.ValidatorMetadata is ValidationAttribute validationAttribute)
{
validationAttribute.AdjustToMvcLocalization();
}
// 2. support for ExtendedValidationResult localization in the case of IValidatableObject
if (stringLocalizerAdapter != null)
{
// we need to check type by name because unfortunately ValidatableObjectAdapter is internal
if (result.Validator != null && result.Validator.GetType().FullName == "Microsoft.AspNetCore.Mvc.DataAnnotations.ValidatableObjectAdapter")
{
results[i] = new ValidatorItem(result.ValidatorMetadata)
{
Validator = new CustomValidatableObjectAdapter(_validationAttributeAdapterProvider, stringLocalizerAdapter),
IsReusable = result.IsReusable,
};
validatableObjectAdapterFound = true;
}
}
}
if (stringLocalizerAdapter != null)
{
Debug.Assert(validatableObjectAdapterFound, "Microsoft.AspNetCore.Mvc.DataAnnotations internals have apparently changed.");
}
}
public void CreateValidators(ModelValidatorProviderContext context)
{
//1、只要存在IsReusable为false的那就会每次启动调用所有的IModelValidatorProvider的CreateValidators方法
//2、因为我们初始化rule的时候默认IsReusable的值是false，Validator也是空的，好在这个初始化之后会调用一把我们的CreateValidator方法，
// 所以我们有必要在CreateValidator中将其置为true，并把Validator的值给赋上
//3、如果我们只是添加一个新的可复用的Validator,那由于第一次会将其缓存起来，导致第二次之后都会有两个重复的Validator
//4、具体细节在ValidatorCache类中
foreach (var item in context.Results)
{
if (item.Validator == null)
{
var validateRule = item.ValidatorMetadata as IValidationRule;
if (validateRule != null)
{
item.Validator = new FluentValidationModelValidator(validateRule);
item.IsReusable = true;
}
}
}
//foreach (var rule in context.ValidatorMetadata.OfType<IValidationRule>())
//{
// //if (!hasRequiredAttribute)
// //{
// // foreach (var val in rule.Validators)
// // {
// // hasRequiredAttribute |= (val is NotNullValidator);
// // hasRequiredAttribute |= (val is NotEmptyValidator);
// // }
// //}
// //context.Results.Add(new ValidatorItem(rule)
// //{
// // Validator = new FluentValidationModelValidator(rule),
// // IsReusable = true
// //});
// //移除 Mvc 自动添加的 Required 验证器。
// //if (hasRequiredAttribute && context.ModelMetadata.IsRequired)
// //{
// // RequiredAttributeAdapter adatper = context.Validators.OfType<RequiredAttribute>().FirstOrDefault();
// // if (adatper != null)
// // {
// // context.Validators.Remove(adatper);
// // }
// //}
//}
}
public void IValidatableObjectGetsAValidator()
{
// Arrange
var provider = new DataAnnotationsModelValidatorProvider(
new ValidationAttributeAdapterProvider(),
Options.Create(new MvcDataAnnotationsLocalizationOptions()),
stringLocalizerFactory: null);
var mockValidatable = new Mock <IValidatableObject>();
var metadata = _metadataProvider.GetMetadataForType(mockValidatable.Object.GetType());
var providerContext = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
Assert.Single(providerContext.Results);
}
public void CreateValidators_ReturnsValidatorForDataSetType()
{
// Arrange
var provider = new DataSetValidatorProvider();
var dataSet = DataSet <Person> .Create();
var metadata = _metadataProvider.GetMetadataForType(dataSet.GetType());
var providerContext = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
var validatorItem = Assert.Single(providerContext.Results);
Assert.IsType <DataSetValidator>(validatorItem.Validator);
}
public void UnknownValidationAttributeGetsDefaultAdapter()
{
// Arrange
var provider = new DataAnnotationsModelValidatorProvider(
new ValidationAttributeAdapterProvider(),
Options.Create(new MvcDataAnnotationsLocalizationOptions()),
stringLocalizerFactory: null);
var metadata = _metadataProvider.GetMetadataForType(typeof(DummyClassWithDummyValidationAttribute));
var providerContext = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
var validatorItem = providerContext.Results.Single();
Assert.IsType <DataAnnotationsModelValidator>(validatorItem.Validator);
}
public void CreateValidators_ModelValidatorAttributeOnClass()
{
// Arrange
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var validatorProvider = TestModelValidatorProvider.CreateDefaultProvider();
var metadata = metadataProvider.GetMetadataForType(typeof(ModelValidatorAttributeOnClass));
var context = new ModelValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
var validator = Assert.IsType <CustomModelValidatorAttribute>(Assert.Single(validatorItems).Validator);
Assert.Equal("Class", validator.Tag);
}
