コード例 #1
0
        public static void ValidateApiModel(object input)
        {
            var provider = new DataAnnotationsModelValidatorProvider();
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperties(input, input.GetType());

            foreach (var modelMetadata in metadata)
            {
                var validators = provider.GetValidators(modelMetadata, new ControllerContext());

                foreach (var validator in validators)
                {
                    var results = validator.Validate(input);
                    foreach (var result in results)
                    {
                        Controller.ModelState.AddModelError(modelMetadata.PropertyName, result.Message);
                    }
                }

                // validation of property value

                var inputType  = input.GetType();
                var properties = new List <PropertyInfo>(inputType.GetProperties());
                foreach (var property in properties)
                {
                    var value = property.GetValue(input, null);
                    if (value != null && value.GetType().Assembly == Controller.GetType().Assembly)
                    {
                        ValidateApiModel(value);
                    }
                }
            }
        }
        public void NonNullableValueTypeDoesntGetImplicitRequiredAttributeWhenFlagIsOff()
        {
            DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;

            try
            {
                // Arrange
                var provider = new DataAnnotationsModelValidatorProvider();
                var context  = new ControllerContext();
                var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(
                    () => null,
                    typeof(DummyRequiredAttributeHelperClass),
                    "WithoutAttribute"
                    );

                // Act
                IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);

                // Assert
                Assert.Empty(validators);
            }
            finally
            {
                DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes =
                    true;
            }
        }
コード例 #3
0
        public override IEnumerable <ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context)
        {
            if (metadata.ModelType == typeof(Content) || metadata.ContainerType == typeof(Content))
            {
                return(Enumerable.Empty <ModelValidator>());
            }

            return(_provider.GetValidators(metadata, context));
        }
コード例 #4
0
        public void RegisterAdapters_RegistersAdapter(String property, Type adapter)
        {
            DataAnnotationsModelValidatorProvider annotations = new DataAnnotationsModelValidatorProvider();
            ModelMetadata metadata = new DataAnnotationsModelMetadataProvider()
                                     .GetMetadataForProperty(null, typeof(AdaptersModel), property);

            application.RegisterAdapters();

            Assert.Single(annotations.GetValidators(metadata, new ControllerContext()), validator => validator.GetType() == adapter);
        }
コード例 #5
0
ファイル: HomeController.cs プロジェクト: baronhq/IISManager
        public ActionResult Index()
        {
            Dictionary <string, ModelValidator[]> modelValidators   = new Dictionary <string, ModelValidator[]>();
            DataAnnotationsModelValidatorProvider validatorProvider = new DataAnnotationsModelValidatorProvider();

            foreach (ModelMetadata metadata in ModelMetadataProviders.Current.GetMetadataForProperties(new DemoModel(), typeof(DemoModel)))
            {
                modelValidators.Add(metadata.PropertyName, validatorProvider.GetValidators(metadata, this.ControllerContext).ToArray());
            }
            return(View(modelValidators));
        }
        public void ReferenceTypesDontGetImplicitRequiredAttribute()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context  = new ControllerContext();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(string));

            // Act
            IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            Assert.Empty(validators);
        }
        public void IValidatableObjectGetsAValidator()
        {
            // Arrange
            var provider        = new DataAnnotationsModelValidatorProvider();
            var mockValidatable = new Mock <IValidatableObject>();
            var context         = new ControllerContext();
            var metadata        = ModelMetadataProviders.Current.GetMetadataForType(() => null, mockValidatable.Object.GetType());

            // Act
            IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            Assert.Single(validators);
        }
コード例 #8
0
        public void RegisterAdapters_RegistersAdapter(String property, Type adapterType)
        {
            DataAnnotationsModelValidatorProvider provider = new DataAnnotationsModelValidatorProvider();
            ModelMetadata metadata = new DataAnnotationsModelMetadataProvider()
                                     .GetMetadataForProperty(null, typeof(AdaptersModel), property);

            application.RegisterAdapters();

            ModelValidator adapter = provider
                                     .GetValidators(metadata, new ControllerContext())
                                     .SingleOrDefault(validator => validator.GetType() == adapterType);

            Assert.NotNull(adapter);
        }
        public void UnknownValidationAttributeGetsDefaultAdapter()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context  = new ControllerContext();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(DummyClassWithDummyValidationAttribute));

            // Act
            IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            var validator = validators.Single();

            Assert.IsType <DataAnnotationsModelValidator>(validator);
        }
コード例 #10
0
        public void DataAnnotationsModelValidatorProviderAppliesRequiredValidators()
        {
            var controllerContext = new ControllerContext();
            var dataAnnotationsModelValidatorProvider = new DataAnnotationsModelValidatorProvider();

            var expectedValidatorCount = dataAnnotationsModelValidatorProvider
                                         .GetValidators(Expected, controllerContext)
                                         .Count(v => v.IsRequired);

            if (Expected.IsRequired)
            {
                Assert.Equal(1, expectedValidatorCount);
            }
            else
            {
                Assert.InRange(expectedValidatorCount, 0, 1);
            }

            Assert.Equal(
                expectedValidatorCount,
                dataAnnotationsModelValidatorProvider
                .GetValidators(Fluent, controllerContext)
                .Count(v => v.IsRequired));
        }
        public void NonNullableValueTypesGetImplicitRequiredAttribute()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context  = new ControllerContext();
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(DummyRequiredAttributeHelperClass), "WithoutAttribute");

            // Act
            IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            ModelValidator            validator = validators.Single();
            ModelClientValidationRule rule      = validator.GetClientValidationRules().Single();

            Assert.IsType <ModelClientValidationRequiredRule>(rule);
        }
コード例 #12
0
        public void NonNullableValueTypesWithExplicitRequiredAttributeDoesntGetImplictRequiredAttribute()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context  = new ControllerContext();
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(DummyRequiredAttributeHelperClass), "WithAttribute");

            // Act
            IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            ModelValidator            validator = validators.Single();
            ModelClientValidationRule rule      = validator.GetClientValidationRules().Single();

            Assert.AreEqual(typeof(ModelClientValidationRequiredRule), rule.GetType());
            Assert.AreEqual("Custom Required Message", rule.ErrorMessage);
        }
        public void GetValidatorsReturnsClientValidatorForDerivedTypeAppliedAgainstBaseTypeViaFromLambdaExpression()
        { // Dev10 Bug #868619
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context  = new ControllerContext();
            var viewdata = new ViewDataDictionary <DerivedModel>();
            var metadata = ModelMetadata.FromLambdaExpression(m => m.MyProperty, viewdata); // Bug is in FromLambdaExpression

            // Act
            IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            ModelValidator            validator  = validators.Single();
            ModelClientValidationRule clientRule = validator.GetClientValidationRules().Single();

            Assert.IsType <ModelClientValidationStringLengthRule>(clientRule);
            Assert.Equal(10, clientRule.ValidationParameters["max"]);
        }
        public void GetValidatorsReturnsValidationRulesForPropertiesWithMinAndMaxLength()
        { // Dev10 Bug #868619
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context  = new ControllerContext();
            var viewdata = new ViewDataDictionary <DerivedModel>();
            var metadata = ModelMetadata.FromLambdaExpression(m => m.MinMaxProperty, viewdata);

            // Act
            IEnumerable <ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            ModelClientValidationRule[] clientRule = validators.SelectMany(v => v.GetClientValidationRules())
                                                     .OrderBy(t => t.GetType().Name)
                                                     .ToArray();
            Assert.IsType <ModelClientValidationMaxLengthRule>(clientRule[0]);
            Assert.IsType <ModelClientValidationMinLengthRule>(clientRule[1]);
        }
コード例 #15
0
        /// <summary>
        /// If a model derives from <see cref="Models.ActionExecutionModel"/>, augments its validated properties
        /// using its <see cref="Models.ActionExecutionModel.GetParameterSpecifications()"/> method,
        /// otherwise it behaves like a <see cref="DataAnnotationsModelValidatorProvider"/>.
        /// </summary>
        public override IEnumerable <ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context)
        {
            if (metadata == null)
            {
                throw new ArgumentNullException(nameof(metadata));
            }

            if (metadata.Container is Models.ActionExecutionModel actionExecutionModel)
            {
                var actionExecutionModelValidatorProvider = new ActionExecutionModelValidationProvider(actionExecutionModel);

                return(actionExecutionModelValidatorProvider.GetValidators(metadata, context));
            }
            else
            {
                return(dataAnnotationsModelValidatorProvider.GetValidators(metadata, context));
            }
        }
コード例 #16
0
        public static IHttpActionResult CallWithModelValidation <C, R, T>(this C controller,
                                                                          Func <C, R> action, T model)
            where C : ApiController
            where R : IHttpActionResult
            where T : class
        {
            var provider = new DataAnnotationsModelValidatorProvider();
            IEnumerable <ModelMetadata> metadata = ModelMetadataProviders.Current.GetMetadataForProperties(model, typeof(T));

            foreach (ModelMetadata modelMetadata in metadata)
            {
                IEnumerable <ModelValidator> validators = provider
                                                          .GetValidators(modelMetadata, new ControllerContext());
                foreach (ModelValidator validator in validators)
                {
                    IEnumerable <ModelValidationResult> results = validator.Validate(model);
                    foreach (ModelValidationResult result in results)
                    {
                        controller.ModelState.AddModelError(modelMetadata.PropertyName, result.Message);
                    }
                }
            }
            return(action(controller));
        }