public void Validate_can_validate_all_attributes() { // Arrange var model = new ClassWithMultiValidationAttributes { Company = "My Company Name" }; // Action var metaData = new ModelMetadata(ModelMetadataProviders.Current, null, () => model, typeof(ClassWithMultiValidationAttributes), null); var validator = ModelValidator.GetModelValidator(metaData); var result = validator.Validate(model).ToList(); // Assert Assert.AreEqual(2, result.Count()); Assert.AreEqual("The Name field is required.", result[0].Message); Assert.AreEqual("ClassWithMultiValidationAttributes.Name", result[0].MemberName); Assert.AreEqual("The field Company must be a string with a maximum length of 6.", result[1].Message); Assert.AreEqual("ClassWithMultiValidationAttributes.Company", result[1].MemberName); }
/// <summary> /// Binds the model, and honours any validation attributes set on dyanmically inserted form elements, by using the specified controller context and binding context. /// </summary> /// <param name="controllerContext">The context within which the controller operates. The context information includes the controller, HTTP content, request context, and route data.</param> /// <param name="bindingContext">The context within which the model is bound. The context includes information such as the model object, model name, model type, property filter, and value provider.</param> /// <returns> /// The bound object. /// </returns> /// <exception cref="T:System.ArgumentNullException">The <paramref name="bindingContext "/>parameter is null.</exception> public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { if (bindingContext.Model != null) { return(bindingContext.Model); } var model = base.BindModel(controllerContext, bindingContext); var adminViewModel = model as AdminViewModel; if (adminViewModel == null) { return(model); } var criteriaValue = bindingContext.ValueProvider.GetValue(ValidationPropertyName); adminViewModel.CriteriaModel.Criteria = criteriaValue != null ? criteriaValue.AttemptedValue : string.Empty; ModelMetadata modelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => adminViewModel.CriteriaModel, typeof(ICriteriaModel)); ModelValidator compositeValidator = ModelValidator.GetModelValidator(modelMetadata, controllerContext); foreach (ModelValidationResult result in compositeValidator.Validate(null)) { bindingContext.ModelState.AddModelError(ValidationPropertyName, result.Message); } return(model); }
/// <summary> /// 验证实例 model 数据 /// </summary> /// <typeparam name="T">实例的类型</typeparam> /// <param name="model">实例</param> /// <param name="validationResult">错误信息</param> /// <returns>验证通过 true 不通过 false</returns> public static bool Validate <T>(T model, out List <ModelValidationResult> validationResult) { var modelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, typeof(T)); validationResult = ModelValidator.GetModelValidator(modelMetadata, new ControllerContext()).Validate(null).ToList(); return(validationResult.Count == 0); }
public void GetModelValidatorWithFailedPropertyValidatorsPreventsTypeValidatorFromRunning() { // Arrange ControllerContext context = new ControllerContext(); DataErrorInfo1 model = new DataErrorInfo1 { Error = "Some Type Error" }; model["SomeStringProperty"] = "Some Property Error"; model["SomeOtherStringProperty"] = "Some Other Property Error"; ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType( () => model, model.GetType() ); ModelValidator validator = ModelValidator.GetModelValidator(metadata, context); // Act List <ModelValidationResult> result = validator.Validate(null).ToList(); // Assert Assert.Equal(2, result.Count); Assert.Equal("SomeStringProperty", result[0].MemberName); Assert.Equal("Some Property Error", result[0].Message); Assert.Equal("SomeOtherStringProperty", result[1].MemberName); Assert.Equal("Some Other Property Error", result[1].Message); }
public void Validate_can_validate_nested_item_in_list() { // Arrange var model = new ParentClass { Children = new List <NestedClass> { new NestedClass { Name = "Van Thoai Nguyen" } } }; // Action var metaData = new ModelMetadata(ModelMetadataProviders.Current, null, () => model, typeof(ParentClass), null); var validator = ModelValidator.GetModelValidator(metaData); var result = validator.Validate(model).ToList(); // Assert Assert.AreEqual(1, result.Count()); Assert.AreEqual("The field Name must be a string with a maximum length of 5.", result[0].Message); Assert.AreEqual("ParentClass.Children[0].Name", result[0].MemberName); }
public IEnumerable <ModelValidationResult> ValidateModel(Type modelType, object modelValue, ControllerContext controllerContext) { var modelMetadata = ModelMetadataProvider.GetMetadataForType(() => modelValue, modelType); var validator = ModelValidator.GetModelValidator(modelMetadata, controllerContext); return(validator.Validate(null)); }
public void GetModelValidator_DoesNotReadPropertyValues() { ModelValidatorProvider[] originalProviders = ModelValidatorProviders.Providers.ToArray(); try { // Arrange ModelValidatorProviders.Providers.Clear(); ModelValidatorProviders.Providers.Add(new ObservableModelValidatorProvider()); ObservableModel model = new ObservableModel(); ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(ObservableModel)); ControllerContext controllerContext = new ControllerContext(); // Act ModelValidator validator = ModelValidator.GetModelValidator(metadata, controllerContext); ModelValidationResult[] results = validator.Validate(model).ToArray(); // Assert Assert.False(model.PropertyWasRead()); } finally { ModelValidatorProviders.Providers.Clear(); foreach (ModelValidatorProvider provider in originalProviders) { ModelValidatorProviders.Providers.Add(provider); } } }
private static ModelValidator GetModelValidator(this object model, ControllerBase controller) { return(ModelValidator.GetModelValidator( ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()), controller.ControllerContext )); }
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { object model = bindingContext.ModelMetadata.Model = base.BindModel(controllerContext, bindingContext); ModelMetadata metadata = bindingContext.ModelMetadata; if (metadata.IsComplexType || null == model) { return(model); } //针对简单类型的Model验证 Dictionary <string, bool> dictionary = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase); foreach (ModelValidationResult result in ModelValidator.GetModelValidator(metadata, controllerContext).Validate(null)) { string key = bindingContext.ModelName; if (!dictionary.ContainsKey(key)) { dictionary[key] = bindingContext.ModelState.IsValidField(key); } if (dictionary[key]) { bindingContext.ModelState.AddModelError(key, result.Message); } } return(model); }
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { object model = null; try { var strJson = controllerContext.HttpContext.Request.Params[bindingContext.ModelName]; if (string.IsNullOrEmpty(strJson)) { return(null); } model = JsonConvert.DeserializeObject(strJson, bindingContext.ModelType); var modelMetaData = ModelMetadataProviders.Current .GetMetadataForType(() => model, bindingContext.ModelType); var validator = ModelValidator .GetModelValidator(modelMetaData, controllerContext); var validationResult = validator.Validate(null); foreach (var item in validationResult) { bindingContext.ModelState .AddModelError(item.MemberName, item.Message); } } catch (Exception ex) { bindingContext.ModelState.AddModelError(bindingContext.ModelType.Name, ex.Message); } return(model); }
/// <summary> /// The method is copied from base class (base.OnModelUpdated(controllerContext, bindingContext)) /// and modified. Modified region is commented in the method source code. /// </summary> protected override void OnModelUpdated(ControllerContext controllerContext, ModelBindingContext bindingContext) { var startedValid = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase); foreach (ModelValidationResult validationResult in ModelValidator.GetModelValidator(bindingContext.ModelMetadata, controllerContext).Validate(null)) { // START added code var propertyMetadata = bindingContext.PropertyMetadata[validationResult.MemberName]; var customAttributes = bindingContext.ModelType.GetProperty(propertyMetadata.PropertyName) .GetCustomAttributes(typeof(SkipValidationIfAttribute), true) .Cast <SkipValidationIfAttribute>(); if (customAttributes.Any(a => a.ShouldSkipValidation(controllerContext, bindingContext, propertyMetadata, validationResult))) { continue; } // END added code string subPropertyName = CreateSubPropertyName(bindingContext.ModelName, validationResult.MemberName); if (!startedValid.ContainsKey(subPropertyName)) { startedValid[subPropertyName] = bindingContext.ModelState.IsValidField(subPropertyName); } if (startedValid[subPropertyName]) { bindingContext.ModelState.AddModelError(subPropertyName, validationResult.Message); } } }
private static IEnumerable <ModelValidationResult> GetModelValidationResults <T>(T model) { var modelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, typeof(T)); /* build a stub controller context */ var controllerContext = Fake.ControllerContext.Build(); var validator = ModelValidator.GetModelValidator(modelMetadata, controllerContext); return(validator.Validate(null)); }
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { TEntity entity = base.BindModel(controllerContext, bindingContext) as TEntity; _repositoryFactory = DependencyResolverProxy.Resolver.GetService <IRepositoryFactory>(); foreach (var property in entity.GetEnumerableProperties()) { Type[] collectionTypes = property.PropertyType.GetGenericArguments(); if (collectionTypes.Length > 0) { var providerResult = bindingContext.ValueProvider.GetValue(property.Name); if (providerResult != null) { string[] ids = providerResult.RawValue as string[]; if (ids != null) { var targetType = property.PropertyType.GetGenericArguments()[0]; var repositoryGetMethod = _repositoryFactory.GetType().GetMethod("Get"); var genericGetMethod = repositoryGetMethod.MakeGenericMethod(targetType); var repository = genericGetMethod.Invoke(_repositoryFactory, null); var collection = property.GetValue(entity, null); var find = repository.GetType().GetMethods().Where(m => m.Name.Equals("Find") && m.ReturnType == targetType).Single(); var add = collection.GetType().GetMethod("Add"); foreach (var idString in ids) { int id; if (int.TryParse(idString, out id)) { var collectionInstance = find.Invoke(repository, new object[] { new object[] { id } }); var collectionEntity = add.Invoke(collection, new object[] { collectionInstance }); } } } } } } bindingContext.ModelState.Clear(); var metaData = ModelMetadataProviders.Current.GetMetadataForType(() => entity, typeof(TEntity)); var validator = ModelValidator.GetModelValidator(metaData, controllerContext); validator.Validate(null).ToList().ForEach(result => { bindingContext.ModelState.AddModelError(result.MemberName, result.Message); }); return(entity); }
protected override void OnModelUpdated(ControllerContext controllerContext, ModelBindingContext bindingContext) { foreach (var validationResult in ModelValidator.GetModelValidator(bindingContext.ModelMetadata, controllerContext).Validate(null)) { string subPropertyName = CreateSubPropertyName(bindingContext.ModelName, validationResult.MemberName); if (bindingContext.PropertyFilter(subPropertyName)) { if (bindingContext.ModelState.IsValidField(subPropertyName)) { bindingContext.ModelState.AddModelError(subPropertyName, validationResult.Message); } } } }
public void Validate_on_basic_types() { // Arrange var model = "Thoai"; ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()); var validator = ModelValidator.GetModelValidator(metadata); // Action var result = validator.Validate(model); // Assert Assert.AreEqual(0, result.Count()); }
public static void Revalidate(this Controller controller, object model) { var modelState = controller.ModelState; if (!modelState.IsValid) { modelState.Clear(); ModelMetadata modelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()); ModelValidator compositeValidator = ModelValidator.GetModelValidator(modelMetadata, controller.ControllerContext); foreach (ModelValidationResult result in compositeValidator.Validate(null)) { modelState.AddModelError(result.MemberName, result.Message); } } }
protected bool TryValidateModel(object model, string prefix) { if (model == null) { throw new ArgumentNullException("model"); } ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()); foreach (ModelValidationResult validationResult in ModelValidator.GetModelValidator(metadata, this.ViewContext).Validate(null)) { this.ModelState.AddModelError(CreateSubPropertyName(prefix, validationResult.MemberName), validationResult.Message); } return(this.ModelState.IsValid); }
/// <summary> /// Revalidates the model passed as the first parameter. /// </summary> /// <param name="model">The model instance you wish to validate.</param> /// <returns></returns> protected internal bool TryValidateModel(object model) { if (model == null) { throw new ArgumentNullException("model"); } System.Web.ModelBinding.ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()); var t = new ModelBindingExecutionContext(new HttpContextWrapper(HttpContext.Current), new System.Web.ModelBinding.ModelStateDictionary()); foreach (ModelValidationResult validationResult in ModelValidator.GetModelValidator(metadata, t).Validate(null)) { ModelState.AddModelError(validationResult.MemberName, validationResult.Message); } return ModelState.IsValid; }
public void GetModelValidatorWithPropertyLevelValidator() { // Arrange ControllerContext context = new ControllerContext(); DataErrorInfo1 model = new DataErrorInfo1(); model["SomeStringProperty"] = "Some Property Error"; ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()); ModelValidator validator = ModelValidator.GetModelValidator(metadata, context); // Act ModelValidationResult result = validator.Validate(null).Single(); // Assert Assert.Equal("SomeStringProperty", result.MemberName); Assert.Equal("Some Property Error", result.Message); }
public void Test_complex_validation() { // Arrange var order = new Order { OrderId = 1, FirstOrderDetail = new OrderDetail { OrderId = 1, Price = 100, ProductName = "P123456" }, Details = new List <OrderDetail> { new OrderDetail { OrderId = 1, Price = 100, ProductName = "P123456" }, new OrderDetail { OrderId = 1, Price = 200, ProductName = "P2" } } }; ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => order, order.GetType()); // Action var validator = ModelValidator.GetModelValidator(metadata); var validationResults = validator.Validate(null).ToList(); // Assert Assert.AreEqual(2, validationResults.Count()); Assert.AreEqual("Order.Details[0].ProductName", validationResults[0].MemberName); Assert.AreEqual("The field ProductName must be a string with a maximum length of 5.", validationResults[0].Message); Assert.AreEqual("Order.FirstOrderDetail.ProductName", validationResults[1].MemberName); Assert.AreEqual("The field ProductName must be a string with a maximum length of 5.", validationResults[1].Message); }
protected override void OnModelUpdated(ControllerContext controllerContext, ModelBindingContext bindingContext) { var startedValid = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase); foreach (var validationResult in ModelValidator.GetModelValidator(bindingContext.ModelMetadata, controllerContext).Validate(null)) { var subPropertyName = CreateSubPropertyName(bindingContext.ModelType.Name, validationResult.MemberName); if (!startedValid.ContainsKey(subPropertyName)) { startedValid[subPropertyName] = bindingContext.ModelState.IsValidField(subPropertyName); } if (startedValid[subPropertyName]) { bindingContext.ModelState.AddModelError(subPropertyName, validationResult.Message); } } }
protected internal bool TryValidateModel(object model, string prefix, out string _modelError) { if (model == null) { throw new ArgumentNullException("model"); } ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()); //using System.Web.ModelBinding; var t = new ModelBindingExecutionContext(new HttpContextWrapper(HttpContext.Current), new System.Web.ModelBinding.ModelStateDictionary()); //using System.Web; foreach (ModelValidationResult validationResult in ModelValidator.GetModelValidator(metadata, t).Validate(null)) { ModelState.AddModelError(validationResult.MemberName, validationResult.Message); } _modelError = string.Join(" | ", ModelState.Values .SelectMany(v => v.Errors) .Select(e => e.ErrorMessage)); return(ModelState.IsValid); }
public void Validate_can_validate_on_null_but_required_complex_property() { // Arrange var model = new ParentClassWithARequiredProperty(); // Action var metaData = new ModelMetadata(ModelMetadataProviders.Current, null, () => model, typeof(ParentClassWithARequiredProperty), null); var validator = ModelValidator.GetModelValidator(metaData); var result = validator.Validate(model).ToList(); // Assert Assert.AreEqual(1, result.Count()); Assert.AreEqual("The IamRequired field is required.", result[0].Message); Assert.AreEqual("ParentClassWithARequiredProperty.IamRequired", result[0].MemberName); }
protected override void OnModelUpdated(ControllerContext controllerContext, ModelBindingContext bindingContext) { //base.OnModelUpdated(controllerContext, bindingContext); //start reflected code Dictionary <string, bool> dictionary = new Dictionary <string, bool>((IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase); foreach (ModelValidationResult validationResult in ModelValidator.GetModelValidator(bindingContext.ModelMetadata, controllerContext).Validate((object)null)) { string subPropertyName = DefaultModelBinder.CreateSubPropertyName(bindingContext.ModelName, validationResult.MemberName); if (!dictionary.ContainsKey(subPropertyName)) { dictionary[subPropertyName] = bindingContext.ModelState.IsValidField(subPropertyName); } if (dictionary[subPropertyName]) { bindingContext.ModelState.AddModelError(subPropertyName, validationResult.Message); } } //end reflected code }
public void Validate_does_not_validate_require_rule_by_default() { // Arrange var model = new NestedClass { Name = null }; // Action var metaData = new ModelMetadata(ModelMetadataProviders.Current, null, () => model, typeof(NestedClass), null); var validator = ModelValidator.GetModelValidator(metaData); var result = validator.Validate(model).ToList(); // Assert Assert.AreEqual(0, result.Count()); }
protected ModelStateDictionary ValidateModel(object model) { ControllerContext controllerContext = null; if (HttpContext.Current != null) { var controller = HttpContext.Current.Items["RequestContextController"] as Controller; controllerContext = controller.ControllerContext; } if (controllerContext == null) { controllerContext = new ControllerContext(); } if (model == null) { throw new ArgumentNullException(nameof(model)); } var method_CreateSubPropertyName = typeof(DefaultModelBinder).GetMethod("CreateSubPropertyName", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic); if (method_CreateSubPropertyName == null) { throw new MissingMethodException(nameof(DefaultModelBinder), "CreateSubPropertyName"); } var metadataForType = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()); var modelState = new ModelStateDictionary(); foreach (var current in ModelValidator.GetModelValidator(metadataForType, controllerContext).Validate(null)) { var key = method_CreateSubPropertyName.Invoke(null, new object[] { string.Empty, current.MemberName }) as string; modelState.AddModelError(key, current.Message); } return(modelState); }
public ActionResult Index() { Address address = new Address { Province = "江苏", City = "苏州", District = "工业园区", Street = "星湖街328号" }; Contact contact = new Contact { Name = "张三", PhoneNo = "123456789", EmailAddress = "*****@*****.**", Address = address }; ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => contact, typeof(Contact)); ModelValidator validator = ModelValidator.GetModelValidator(metadata, ControllerContext); return(View(validator.Validate(contact))); }