/// <inheritdoc />
public void GetValidators(ClientValidatorProviderContext context)
{
foreach (var metadata in context.ValidatorMetadata)
{
var validator = metadata as IClientModelValidator;
if (validator != null)
{
context.Validators.Add(validator);
}
}
}
public void CreateValidators(ClientValidatorProviderContext context)
{
if (context.ModelMetadata.UnderlyingOrModelType == typeof(DateTime))
{
context.Results.Add(new ClientValidatorItem {
Validator = new DateValidator(), IsReusable = true
});
}
else if (DecimalTypes.Contains(context.ModelMetadata.UnderlyingOrModelType))
{
context.Results.Add(new ClientValidatorItem {
Validator = new NumberValidator(), IsReusable = true
});
}
else if (IntegerTypes.Contains(context.ModelMetadata.UnderlyingOrModelType))
{
context.Results.Add(new ClientValidatorItem {
Validator = new IntegerValidator(), IsReusable = true
});
}
}
public void CreateValidators_FromModelMetadataType_MergedValidators()
{
// Arrange
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var validatorProvider = TestClientModelValidatorProvider.CreateDefaultProvider();
var metadata = metadataProvider.GetMetadataForProperty(
typeof(ProductViewModel),
nameof(ProductViewModel.Name));
var context = new ClientValidatorProviderContext(metadata, GetClientValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
Assert.Equal(2, validatorItems.Count);
Assert.Single(validatorItems, v => v.Validator is RegularExpressionAttributeAdapter);
Assert.Single(validatorItems, v => v.Validator is StringLengthAttributeAdapter);
}
public void CreateValidators_ClientValidatorAttribute_SpecificAdapter()
{
// Arrange
var metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
var validatorProvider = TestClientModelValidatorProvider.CreateDefaultProvider();
var metadata = metadataProvider.GetMetadataForProperty(
typeof(RangeAttributeOnProperty),
nameof(RangeAttributeOnProperty.Property));
var context = new ClientValidatorProviderContext(metadata, GetClientValidatorItems(metadata));
// Act
validatorProvider.CreateValidators(context);
// Assert
var validatorItems = context.Results;
Assert.Equal(2, validatorItems.Count);
Assert.Single(validatorItems, v => v.Validator is RangeAttributeAdapter);
Assert.Single(validatorItems, v => v.Validator is RequiredAttributeAdapter);
}
/// <inheritdoc />
public void CreateValidators(ClientValidatorProviderContext context)
{
var hasRequiredAttribute = false;
foreach (var item in context.Results)
{
if (item.Validator == null)
{
var validateRule = item.ValidatorMetadata as IValidationRule;
if (validateRule == null)
{
continue;
}
foreach (var val in validateRule.Validators)
{
if (!hasRequiredAttribute)
{
hasRequiredAttribute |= (val is NotNullValidator);
hasRequiredAttribute |= (val is NotEmptyValidator);
}
FluentValidationClientModelValidationFactory factory;
if (_attributeFactories.TryGetValue(val.GetType(), out factory))
{
item.Validator = factory(val);
item.IsReusable = true;
}
}
}
}
if (hasRequiredAttribute && context.ModelMetadata.IsRequired)
{
var item = context.Results.Where(i => i.Validator is RequiredAttributeAdapter).FirstOrDefault();
//移除 Mvc 自动添加的 Required 验证器。
if (item != null)
{
context.Results.Remove(item);
}
}
}
public void CreateValidators_AddsRequiredAttribute_ForIsRequiredTrue()
{
// Arrange
var provider = new DataAnnotationsClientModelValidatorProvider(
new ValidationAttributeAdapterProvider(),
Options.Create(new MvcDataAnnotationsLocalizationOptions()),
stringLocalizerFactory: null);
var metadata = _metadataProvider.GetMetadataForProperty(
typeof(DummyRequiredAttributeHelperClass),
nameof(DummyRequiredAttributeHelperClass.ValueTypeWithoutAttribute));
var providerContext = new ClientValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
var validatorItem = Assert.Single(providerContext.Results);
Assert.IsType <RequiredAttributeAdapter>(validatorItem.Validator);
}
protected virtual IClientModelValidator GetModelValidator(ClientValidatorProviderContext context, PropertyRule rule, IPropertyValidator propertyValidator)
{
var type = propertyValidator.GetType();
var factory = _validatorFactories
.Where(x => x.Key.IsAssignableFrom(type))
.Select(x => x.Value)
.FirstOrDefault();
if (factory != null)
{
var ruleSetToGenerateClientSideRules = RuleSetForClientSideMessagesAttribute.GetRuleSetsForClientValidation(_httpContextAccessor?.HttpContext);
bool executeDefaultRule = (ruleSetToGenerateClientSideRules.Contains("default", StringComparer.OrdinalIgnoreCase) && (rule.RuleSets.Length == 0 || rule.RuleSets.Contains("default", StringComparer.OrdinalIgnoreCase)));
bool shouldExecute = ruleSetToGenerateClientSideRules.Intersect(rule.RuleSets, StringComparer.OrdinalIgnoreCase).Any() || executeDefaultRule;
if (shouldExecute)
{
return(factory.Invoke(context, rule, propertyValidator));
}
}
return(null);
}
public void CreateValidators_DoesNotAddExtraRequiredAttribute_IfAttributeIsSpecifiedExplicitly()
{
// Arrange
var provider = new DataAnnotationsClientModelValidatorProvider(
new ValidationAttributeAdapterProvider(),
Options.Create(new MvcDataAnnotationsLocalizationOptions()),
stringLocalizerFactory: null);
var metadata = _metadataProvider.GetMetadataForProperty(
typeof(DummyRequiredAttributeHelperClass),
nameof(DummyRequiredAttributeHelperClass.WithAttribute));
var providerContext = new ClientValidatorProviderContext(metadata, GetValidatorItems(metadata));
// Act
provider.CreateValidators(providerContext);
// Assert
var validatorItem = Assert.Single(providerContext.Results);
var adapter = Assert.IsType <RequiredAttributeAdapter>(validatorItem.Validator);
Assert.Equal("Custom Required Message", adapter.Attribute.ErrorMessage);
}
public void CreateValidators_DoesNotAddDuplicateValidators()
{
// Arrange
var provider = new NumericClientModelValidatorProvider();
var metadata = _metadataProvider.GetMetadataForType(typeof(float));
var items = GetValidatorItems(metadata);
var expectedValidatorItem = new ClientValidatorItem
{
Validator = new NumericClientModelValidator(),
IsReusable = true
};
items.Add(expectedValidatorItem);
var providerContext = new ClientValidatorProviderContext(metadata, items);
// Act
provider.CreateValidators(providerContext);
// Assert
var validatorItem = Assert.Single(providerContext.Results);
Assert.Same(expectedValidatorItem.Validator, validatorItem.Validator);
}
/// <inheritdoc />
public void CreateValidators(ClientValidatorProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
IStringLocalizer?stringLocalizer = null;
if (_options.Value.DataAnnotationLocalizerProvider != null && _stringLocalizerFactory != null)
{
// This will pass first non-null type (either containerType or modelType) to delegate.
// Pass the root model type(container type) if it is non null, else pass the model type.
stringLocalizer = _options.Value.DataAnnotationLocalizerProvider(
context.ModelMetadata.ContainerType ?? context.ModelMetadata.ModelType,
_stringLocalizerFactory);
}
var hasRequiredAttribute = false;
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)
{
// Check if a required attribute is already cached.
hasRequiredAttribute |= validatorItem.Validator is RequiredAttributeAdapter;
continue;
}
var attribute = validatorItem.ValidatorMetadata as ValidationAttribute;
if (attribute == null)
{
continue;
}
hasRequiredAttribute |= attribute is RequiredAttribute;
var adapter = _validationAttributeAdapterProvider.GetAttributeAdapter(attribute, stringLocalizer);
if (adapter != null)
{
validatorItem.Validator = adapter;
validatorItem.IsReusable = true;
}
}
if (!hasRequiredAttribute && context.ModelMetadata.IsRequired)
{
// Add a default '[Required]' validator for generating HTML if necessary.
context.Results.Add(new ClientValidatorItem
{
Validator = _validationAttributeAdapterProvider.GetAttributeAdapter(
new RequiredAttribute(),
stringLocalizer),
IsReusable = true
});
}
}
private static void ExecuteProvider(IClientModelValidatorProvider validatorProvider, ModelMetadata metadata, List <ClientValidatorItem> items)
{
var context = new ClientValidatorProviderContext(metadata, items);
validatorProvider.CreateValidators(context);
}
/// <inheritdoc />
public void CreateValidators(ClientValidatorProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
IStringLocalizer stringLocalizer = null;
if (_options.Value.DataAnnotationLocalizerProvider != null && _stringLocalizerFactory != null)
{
// This will pass first non-null type (either containerType or modelType) to delegate.
// Pass the root model type(container type) if it is non null, else pass the model type.
stringLocalizer = _options.Value.DataAnnotationLocalizerProvider(
context.ModelMetadata.ContainerType ?? context.ModelMetadata.ModelType,
_stringLocalizerFactory);
}
var hasRequiredAttribute = false;
var metadata = context.ModelMetadata;
var isPropertyValidation = metadata.ContainerType != null && !String.IsNullOrEmpty(metadata.PropertyName);
var rules = ValidationManager.GetValidationRules(metadata.ContainerType, metadata.PropertyName);
if (rules == null)
{
return;
}
foreach (var rule in rules)
{
var validationAttribute = rule.CreateValidationAttribute();
if (validationAttribute == null)
{
continue;
}
var validatorItem = new ClientValidatorItem(validationAttribute);
if (validatorItem.Validator != null)
{
// Check if a required attribute is already cached.
hasRequiredAttribute |= validatorItem.Validator is RequiredAttributeAdapter;
continue;
}
hasRequiredAttribute |= validationAttribute is RequiredAttribute;
var adapter = _validationAttributeAdapterProvider.GetAttributeAdapter(validationAttribute, stringLocalizer);
if (adapter != null)
{
validatorItem.Validator = adapter;
validatorItem.IsReusable = true;
}
context.Results.Add(validatorItem);
}
if (!hasRequiredAttribute && context.ModelMetadata.IsRequired)
{
// Add a default '[Required]' validator for generating HTML if necessary.
context.Results.Add(new ClientValidatorItem
{
Validator = _validationAttributeAdapterProvider.GetAttributeAdapter(
new RequiredAttribute(),
stringLocalizer),
IsReusable = true
});
}
}
