/// <summary>
/// Validates a single node (not including children)
/// </summary>
/// <param name="metadata">Model Metadata</param>
/// <param name="validationContext">Validation Context</param>
/// <param name="container">The container.</param>
/// <returns>True if validation passes successfully</returns>
private static bool ShallowValidate(ModelMetadata metadata, InternalValidationContext validationContext, object container)
{
bool isValid = true;
// Use the DependencyResolver to find any validators appropriate for this type
IEnumerable <IValidator> validators = validationContext.Provider.GetValidators(metadata.ModelType, validationContext.Scope);
foreach (IValidator validator in validators)
{
IValidatorSelector selector = new DefaultValidatorSelector();
var context = new ValidationContext(metadata.Model, new PropertyChain(), selector);
ValidationResult result = validator.Validate(context);
foreach (ValidationFailure error in result.Errors)
{
if (!validationContext.ModelState.ContainsKey(error.PropertyName))
{
validationContext.ModelState.Add(error.PropertyName, new ModelState
{
Value = new ValueProviderResult(error.AttemptedValue, error.AttemptedValue.ToString(), CultureInfo.CurrentCulture)
});
}
validationContext.ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
isValid = false;
}
}
return(isValid);
}
public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container) {
if (metadata.Model == null) return Enumerable.Empty<ModelValidationResult>();
var selector = new DefaultValidatorSelector();
var context = new ValidationContext(metadata.Model, new PropertyChain(), selector);
var result = validator.Validate(context);
return !result.IsValid
? ConvertValidationResultToModelValidationResults(result)
: Enumerable.Empty<ModelValidationResult>();
}
public override IEnumerable <ModelValidationResult> Validate(ModelMetadata metadata, object container)
{
if (metadata.Model == null)
{
return(Enumerable.Empty <ModelValidationResult>());
}
var selector = new DefaultValidatorSelector();
var context = new ValidationContext(metadata.Model, new PropertyChain(), selector);
var result = validator.Validate(context);
return(!result.IsValid
? ConvertValidationResultToModelValidationResults(result)
: Enumerable.Empty <ModelValidationResult>());
}
/// <summary>
/// Builds a validator selector from the options specified in the attribute's properties.
/// </summary>
public IValidatorSelector ToValidatorSelector() {
IValidatorSelector selector;
if(! string.IsNullOrEmpty(RuleSet)) {
var rulesets = RuleSet.Split(',', ';');
selector = new RulesetValidatorSelector(rulesets);
}
else if(! string.IsNullOrEmpty(Properties)) {
var properties = Properties.Split(',', ';');
selector = new MemberNameValidatorSelector(properties);
}
else {
selector = new DefaultValidatorSelector();
}
return selector;
}
public static Task <ValidationResult> ValidateAsync(IValidator validator, object instance, string[] ruleSets,
Dictionary <string, object> extraData = null)
{
IValidatorSelector selector = new DefaultValidatorSelector();
if (ruleSets != null)
{
selector = ValidatorOptions.ValidatorSelectors.RulesetValidatorSelectorFactory(ruleSets);
}
var context = new ValidationContext(instance, new PropertyChain(), selector);
if (extraData != null)
{
foreach (var pair in extraData)
{
context.RootContextData[pair.Key] = pair.Value;
}
}
return(validator.ValidateAsync(context));
}
/// <summary>
/// Builds a validator selector from the options specified in the attribute's properties.
/// </summary>
public IValidatorSelector ToValidatorSelector()
{
IValidatorSelector selector;
if (!string.IsNullOrEmpty(RuleSet))
{
var rulesets = RuleSet.Split(',', ';');
selector = new RulesetValidatorSelector(rulesets);
}
else if (!string.IsNullOrEmpty(Properties))
{
var properties = Properties.Split(',', ';');
selector = new MemberNameValidatorSelector(properties);
}
else
{
selector = new DefaultValidatorSelector();
}
return(selector);
}
public static ValidationResult Validate <T>(this IValidator <T> validator, T instance, IValidatorSelector selector = null, string ruleSet = null)
{
if (selector != null && ruleSet != null)
{
throw new InvalidOperationException("Cannot specify both an IValidatorSelector and a RuleSet.");
}
if (selector == null)
{
selector = new DefaultValidatorSelector();
}
if (ruleSet != null)
{
selector = new RulesetValidatorSelector(ruleSet);
}
var context = new ValidationContext <T>(instance, new PropertyChain(), selector);
return(validator.Validate(context));
}
/// <summary>
/// Validates a single node (not including children)
/// </summary>
/// <param name="metadata">Model Metadata</param>
/// <param name="validationContext">Validation Context</param>
/// <param name="container">The container.</param>
/// <returns>True if validation passes successfully</returns>
private static bool ShallowValidate(ModelMetadata metadata, InternalValidationContext validationContext, object container)
{
bool isValid = true;
string key = null;
// Use the DependencyResolver to find any validators appropriate for this type
IEnumerable <IValidator> validators = validationContext.Provider.GetValidators(metadata.ModelType, validationContext.Scope);
foreach (IValidator validator in validators)
{
IValidatorSelector selector = new DefaultValidatorSelector();
ValidationContext context = new ValidationContext(metadata.Model, new PropertyChain(), selector);
ValidationResult result = validator.Validate(context);
foreach (var error in result.Errors)
{
if (key == null)
{
key = validationContext.RootPrefix;
foreach (IKeyBuilder keyBuilder in validationContext.KeyBuilders.Reverse())
{
key = keyBuilder.AppendTo(key);
}
// Avoid adding model errors if the model state already contains model errors for that key
// We can't perform this check earlier because we compute the key string only when we detect an error
if (!validationContext.ModelState.IsValidField(key))
{
return(false);
}
}
validationContext.ModelState.AddModelError(key, JsonConvert.SerializeObject(error));
isValid = false;
}
}
return(isValid);
}
public void DefaultValidatorSelector_always_returns_true()
{
var selector = new DefaultValidatorSelector();
selector.CanExecute<object>(null, null).ShouldBeTrue();
}
