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); } } } } }