private void ValidateThis(HttpActionContext actionContext, ModelValidationNode parentNode)
{
ModelStateDictionary modelState = actionContext.ModelState;
if (!modelState.IsValidField(ModelStateKey))
{
return; // short-circuit
}
// If 'this' is null and there is no parent, we cannot validate, and
// the DataAnnotationsModelValidator will throw. So we intercept here
// to provide a catch-all value-required validation error
if (parentNode == null && ModelMetadata.Model == null)
{
string trueModelStateKey = ModelBindingHelper.CreatePropertyModelName(ModelStateKey, ModelMetadata.DisplayName);
modelState.AddModelError(trueModelStateKey, SRResources.Validation_ValueNotFound);
return;
}
object container = TryConvertContainerToMetadataType(parentNode);
foreach (ModelValidator validator in ModelMetadata.GetValidators(actionContext.GetValidatorProviders()))
{
foreach (ModelValidationResult validationResult in validator.Validate(container))
{
string trueModelStateKey = ModelBindingHelper.CreatePropertyModelName(ModelStateKey, validationResult.MemberName);
modelState.AddModelError(trueModelStateKey, validationResult.Message);
}
}
}
/// <summary>
/// Determines whether the <paramref name="model"/> is valid and adds any validation errors to the <paramref name="actionContext"/>'s <see cref="ModelStateDictionary"/>
/// </summary>
/// <param name="model">The model to be validated.</param>
/// <param name="type">The <see cref="Type"/> to use for validation.</param>
/// <param name="metadataProvider">The <see cref="ModelMetadataProvider"/> used to provide the model metadata.</param>
/// <param name="actionContext">The <see cref="HttpActionContext"/> within which the model is being validated.</param>
/// <param name="keyPrefix">The <see cref="string"/> to append to the key for any validation errors.</param>
/// <returns><c>true</c>if <paramref name="model"/> is valid, <c>false</c> otherwise.</returns>
public bool Validate(
object model,
Type type,
ModelMetadataProvider metadataProvider,
HttpActionContext actionContext,
string keyPrefix
)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (metadataProvider == null)
{
throw Error.ArgumentNull("metadataProvider");
}
if (actionContext == null)
{
throw Error.ArgumentNull("actionContext");
}
if (model != null && !ShouldValidateType(model.GetType()))
{
return(true);
}
ModelValidatorProvider[] validatorProviders = actionContext
.GetValidatorProviders()
.ToArray();
// Optimization : avoid validating the object graph if there are no validator providers
if (validatorProviders == null || validatorProviders.Length == 0)
{
return(true);
}
ModelMetadata metadata = metadataProvider.GetMetadataForType(() => model, type);
BodyModelValidatorContext validationContext = new BodyModelValidatorContext(
actionContext.ModelState
)
{
MetadataProvider = metadataProvider,
ActionContext = actionContext,
ValidatorCache = actionContext.GetValidatorCache(),
RootPrefix = keyPrefix
};
return(ValidateNodeAndChildren(
metadata,
validationContext,
container: null,
validators: null
));
}
private static IEnumerable <ModelValidator> GetValidators(HttpActionContext actionContext, ModelMetadata metadata, IModelValidatorCache validatorCache)
{
if (validatorCache == null)
{
// slow path: there is no validator cache on the configuration
return(metadata.GetValidators(actionContext.GetValidatorProviders()));
}
else
{
return(validatorCache.GetValidators(metadata));
}
}
// Validates a single node (not including children)
// Returns true if validation passes successfully
private static bool ShallowValidate(ModelMetadata metadata, HttpActionContext actionContext, object container, string key)
{
bool isValid = true;
foreach (ModelValidator validator in metadata.GetValidators(actionContext.GetValidatorProviders()))
{
foreach (ModelValidationResult error in validator.Validate(container))
{
actionContext.ModelState.AddModelError(key, error.Message);
isValid = false;
}
}
return(isValid);
}
/// <summary>
/// Determines whether the <paramref name="model"/> is valid and adds any validation errors to the <paramref name="actionContext"/>'s <see cref="ModelStateDictionary"/>
/// </summary>
/// <param name="model">The model to be validated.</param>
/// <param name="type">The <see cref="Type"/> to use for validation.</param>
/// <param name="metadataProvider">The <see cref="ModelMetadataProvider"/> used to provide the model metadata.</param>
/// <param name="actionContext">The <see cref="HttpActionContext"/> within which the model is being validated.</param>
/// <param name="keyPrefix">The <see cref="string"/> to append to the key for any validation errors.</param>
/// <returns><c>true</c>if <paramref name="model"/> is valid, <c>false</c> otherwise.</returns>
public bool Validate(object model, Type type, ModelMetadataProvider metadataProvider, HttpActionContext actionContext, string keyPrefix)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (metadataProvider == null)
{
throw Error.ArgumentNull("metadataProvider");
}
if (actionContext == null)
{
throw Error.ArgumentNull("actionContext");
}
if (model != null && MediaTypeFormatterCollection.IsTypeExcludedFromValidation(model.GetType()))
{
// no validation for some DOM like types
return(true);
}
ModelValidatorProvider[] validatorProviders = actionContext.GetValidatorProviders().ToArray();
// Optimization : avoid validating the object graph if there are no validator providers
if (validatorProviders == null || validatorProviders.Length == 0)
{
return(true);
}
ModelMetadata metadata = metadataProvider.GetMetadataForType(() => model, type);
ValidationContext validationContext = new ValidationContext()
{
MetadataProvider = metadataProvider,
ActionContext = actionContext,
ValidatorCache = actionContext.GetValidatorCache(),
ModelState = actionContext.ModelState,
Visited = new HashSet <object>(),
KeyBuilders = new Stack <IKeyBuilder>(),
RootPrefix = keyPrefix
};
return(ValidateNodeAndChildren(metadata, validationContext, container: null));
}
/// <summary>
/// Determines whether the <paramref name="model"/> is valid and adds any validation errors to the <paramref name="actionContext"/>'s <see cref="ModelStateDictionary"/>
/// </summary>
/// <param name="model">The model to be validated.</param>
/// <param name="type">The <see cref="Type"/> to use for validation.</param>
/// <param name="metadataProvider">The <see cref="ModelMetadataProvider"/> used to provide the model metadata.</param>
/// <param name="actionContext">The <see cref="HttpActionContext"/> within which the model is being validated.</param>
/// <param name="keyPrefix">The <see cref="string"/> to append to the key for any validation errors.</param>
/// <returns><c>true</c>if <paramref name="model"/> is valid, <c>false</c> otherwise.</returns>
public bool Validate(object model, Type type, ModelMetadataProvider metadataProvider, HttpActionContext actionContext, string keyPrefix)
{
if (type == null)
{
throw new ArgumentException("type");
}
if (metadataProvider == null)
{
throw new ArgumentException("metadataProvider");
}
if (actionContext == null)
{
throw new ArgumentException("actionContext");
}
if (model != null && !ShouldValidateType(model.GetType()))
{
return(true);
}
ModelValidatorProvider[] validatorProviders = actionContext.GetValidatorProviders().ToArray();
// Optimization : avoid validating the object graph if there are no validator providers
if (validatorProviders == null || validatorProviders.Length == 0)
{
return(true);
}
ModelMetadata metadata = metadataProvider.GetMetadataForType(() => model, type);
ValidationContext validationContext = new ValidationContext()
{
MetadataProvider = metadataProvider,
ActionContext = actionContext,
ValidatorCache = getValidatorCache.Invoke(null, new object[] { actionContext }),
ModelState = actionContext.ModelState,
Visited = new HashSet <object>(ReferenceEqualityComparer.Instance),
KeyBuilders = new Stack <IKeyBuilder>(),
RootPrefix = keyPrefix
};
return(ValidateNodeAndChildren(metadata, validationContext, container: null, validators: null));
}
private void ValidateProperties(HttpActionContext actionContext)
{
// Based off CompositeModelValidator.
ModelStateDictionary modelState = actionContext.ModelState;
// DevDiv Bugs #227802 - Caching problem in ModelMetadata requires us to manually regenerate
// the ModelMetadata.
object model = ModelMetadata.Model;
ModelMetadata updatedMetadata = actionContext.GetMetadataProvider().GetMetadataForType(() => model, ModelMetadata.ModelType);
foreach (ModelMetadata propertyMetadata in updatedMetadata.Properties)
{
// Only want to add errors to ModelState if something doesn't already exist for the property node,
// else we could end up with duplicate or irrelevant error messages.
string propertyKeyRoot = ModelBindingHelper.CreatePropertyModelName(ModelStateKey, propertyMetadata.PropertyName);
if (modelState.IsValidField(propertyKeyRoot))
{
foreach (ModelValidator propertyValidator in propertyMetadata.GetValidators(actionContext.GetValidatorProviders()))
{
foreach (ModelValidationResult propertyResult in propertyValidator.Validate(model))
{
string thisErrorKey = ModelBindingHelper.CreatePropertyModelName(propertyKeyRoot, propertyResult.MemberName);
modelState.AddModelError(thisErrorKey, propertyResult.Message);
}
}
}
}
}