예제 #1
0
        /// <summary>
        /// Validates the current MainModel
        /// </summary>
        /// <param name="model"></param>
        /// <param name="throwException">Determine if it should fire a MVPValidationException on validation error</param>
        /// <returns>True if sucessfully validated</returns>
        protected virtual bool DoValidate(T model, bool throwException)
        {
#if FRAMEWORK_3
            IValidatorRunner runner = new ValidatorRunner(new CachedValidationRegistry());
            if (runner.IsValid(model))
            {
                return(true);
            }

            ErrorSummary errors = runner.GetErrorSummary(model);

            for (int i = 0; i < errors.ErrorsCount; i++)
            {
                ErrorList.Add(new ValidationError(errors.InvalidProperties[i], errors.ErrorMessages[i]));
            }

            if (throwException)
            {
                // TODO: Colocar a string em um resource
                throw new MVPValidationException(
                          string.Format("Validation has failed with {0} errors. See inner exceptions for details.",
                                        errors.ErrorsCount),
                          ErrorList);
            }
#endif
            return(false);
        }
예제 #2
0
 public void Setup()
 {
     validator          = new ValidatorRunner(new CachedValidationRegistry());
     accessor           = new StaticValidatorAccessor();
     accessor.Validator = validator;
     ValidEventListner.ValidatorAccessor = accessor;
 }
예제 #3
0
        /// <summary>
        /// Generates a client-side validation script based on the attributes of the modelToValidate.
        /// </summary>
        /// <param name="modelToValidate">The model to validate.</param>
        /// <param name="formId">The client ID of the form.</param>
        /// <param name="propertyNameToElementId">Delegate that can translate properties of the model to form elements.</param>
        /// <returns></returns>
        public string GenerateClientScript(object modelToValidate, string formId, Func <string, string> propertyNameToElementId)
        {
            // Create a BrowserValidationConfiguration instance to store all validation rules.
            BrowserValidationConfiguration config = this._browserValidatorProvider.CreateConfiguration(null);
            // Create a ValidatorRunner that is needed to obtain the validators for the given modelToValidate.
            var validatorRunner = new ValidatorRunner(this._validatorRegistry);
            // Create a script generator and that is linked to the BrowserValidationConfiguration
            IBrowserValidationGenerator generator =
                _browserValidatorProvider.CreateGenerator(config, InputElementType.Undefined, propertyNameToElementId);

            // Get all validators for the given modelToValidate
            IValidator[] validators =
                _validatorRegistry.GetValidators(validatorRunner, modelToValidate.GetType(), RunWhen.Everytime);
            // Iterate the validators and call ApplyBrowserValidation to generate the validation rules and messages into the BrowserValidationConfiguration.
            foreach (var validator in validators)
            {
                validator.ApplyBrowserValidation(config, InputElementType.Undefined, generator, null, propertyNameToElementId(validator.Property.Name));
            }

            // Generate the validation script block
            var sb = new StringBuilder();

            sb.Append("<script type=\"text/javascript\">" + Environment.NewLine);
            // Call CreateBeforeFormClosed of the BrowserValidationConfiguration. This generates the client script.
            // Note: it's called CreateBeforeFormClosed because originally (in Monorail), it was used to only
            // generate some extra scripts for validation.
            sb.Append(config.CreateBeforeFormClosed(formId));
            sb.Append("</script>" + Environment.NewLine);
            return(sb.ToString());
        }
예제 #4
0
        private static void ValidateContext(WebServerConfiguration context)
        {
            var validator = new ValidatorRunner(true, new CachedValidationRegistry());

            if (!validator.IsValid(context))
            {
                string[] errorList      = validator.GetErrorSummary(context).ErrorMessages;
                var      messageBuilder = new StringBuilder("The CassisniContext contained invalid data. ");
                foreach (string item in errorList)
                {
                    messageBuilder.AppendLine(item);
                }

                throw new ValidationException(messageBuilder.ToString());
            }

            if (context.PortNumber == 0)
            {
                string message =
                    "You must specify a port number. Auto-configured port numbers are not supported untill I figure out how to return the selected port number.";
                throw new NotImplementedException(message);
            }

            if (!File.Exists(Path.Combine(context.WebSiteRootFolder, context.DefaultWebPageFileName)))
            {
                string message = string.Format("Could not find the default page '{0}'",
                                               Path.Combine(context.WebSiteRootFolder, context.DefaultWebPageFileName));
                throw new FileNotFoundException(message);
            }
        }
예제 #5
0
        /// <summary>
        /// Creates the validator runner.
        /// </summary>
        /// <returns></returns>
        protected virtual IValidatorRunner CreateRunner()
        {
            IValidationContributor[] contributors = new IValidationContributor[] { contributor };
            IValidatorRunner         runner       = new ValidatorRunner(contributors, new CachedValidationRegistry());

            return(runner);
        }
예제 #6
0
        static void Main(string[] args)
        {
            var order = new Order
            {
                Product = new Product {
                    Name = "Widget", MinQuantity = 5, MaxQuantity = 100
                },
                Quantity = 50
            };

            var runner = new ValidatorRunner(new CachedValidationRegistry());

            if (runner.IsValid(order))
            {
                Console.WriteLine("The order is valid!");
            }
            else
            {
                ErrorSummary summary = runner.GetErrorSummary(order);
                foreach (var invalidProperty in summary.InvalidProperties)
                {
                    Console.WriteLine("{0} is invalid because:", invalidProperty);
                    foreach (var error in summary.GetErrorsForProperty(invalidProperty))
                    {
                        Console.WriteLine("\t * {0}", error);
                    }
                }
            }

            Console.ReadLine();
        }
		public void Should_Validate_Object_Using_Validators_From_Metadata()
		{
			var runner = new ValidatorRunner(new CachedMetadataValidationRegistry());

			var person = new Person();
			Assert.IsFalse(runner.IsValid(person));

			person = new Person{Name = "stan"};
			Assert.IsTrue(runner.IsValid(person));
		}
예제 #8
0
        /// <errorSummary>
        /// Determines whether the specified instance is valid.
        /// </errorSummary>
        /// <param name="instance">The instance.</param>
        /// <param name="fieldValue">The field value.</param>
        /// <returns>
        ///     <c>true</c> if the specified instance is valid; otherwise, <c>false</c>.
        /// </returns>
        public override bool IsValid(object instance, object fieldValue)
        {
            ValidatorRunner runner = new ValidatorRunner(validationRegistry.BaseRegistry);
            bool            valid  = runner.IsValid(instance);

            if (!valid)
            {
                errorSummary = runner.GetErrorSummary(instance);
            }

            return(valid);
        }
예제 #9
0
        public void Should_Validate_Object_Using_Validators_From_Metadata()
        {
            var runner = new ValidatorRunner(new CachedMetadataValidationRegistry());

            var person = new Person();

            Assert.IsFalse(runner.IsValid(person));

            person = new Person {
                Name = "stan"
            };
            Assert.IsTrue(runner.IsValid(person));
        }
예제 #10
0
        public ErrorSummary Validate()
        {
            ValidatorRunner vr = new ValidatorRunner(true, new CachedValidationRegistry());

            if (!vr.IsValid(this))
            {
                return(vr.GetErrorSummary(this));
            }
            else
            {
                return(null);
            }
        }
        public IEnumerable <ErrorInfo> GetErrors <ENTITY>(ENTITY entity) where ENTITY : DomainEntity
        {
            var result = new List <ErrorInfo>();
            var runner = new ValidatorRunner(registry);

            if (entity != null && !runner.IsValid(entity))
            {
                var errorSummary = runner.GetErrorSummary(entity);
                var errorInfos   = errorSummary.InvalidProperties.SelectMany(
                    prop => errorSummary.GetErrorsForProperty(prop),
                    (prop, err) => new ErrorInfo(prop, err));
                result.AddRange(errorInfos);
            }
            return(result);
        }
        public CrudReport Validate <ENTITY>(ENTITY entity) where ENTITY : DomainEntity
        {
            var crudReport = new CrudReport();
            var runner     = new ValidatorRunner(registry);

            if (runner.IsValid(entity))
            {
                crudReport.Success = true;
            }
            else
            {
                crudReport.AddErrorInfos(GetErrors(entity));
            }
            return(crudReport);
        }
예제 #13
0
        public void ExecutesCustomContributors()
        {
            ValidatorRunner runnerWithContributor = new ValidatorRunner(true, new CachedValidationRegistry(),
                                                                        new IValidationContributor[] { new AlwaysErrorContributor() });

            object target = new object();

            Assert.IsFalse(runnerWithContributor.IsValid(target));
            ErrorSummary errors = runnerWithContributor.GetErrorSummary(target);

            Assert.IsTrue(errors.HasError);
            Assert.AreEqual(1, errors.ErrorsCount);
            string[] errorsForKey = errors.GetErrorsForProperty("someKey");
            Assert.AreEqual(1, errorsForKey.Length);
            Assert.AreEqual("error", errorsForKey[0]);
        }
		public void ValidationOrderTest()
		{
			ValidatorRunner runner = new ValidatorRunner(new CachedValidationRegistry());

			Supplier supplier = new Supplier();
			supplier.Password = "******";

			runner.IsValid(supplier);

			ErrorSummary summary = runner.GetErrorSummary(supplier);
			Assert.IsNotNull(summary);

			Assert.AreEqual("This is a required field", summary.ErrorMessages[0]);
			Assert.AreEqual("Fields do not match", summary.ErrorMessages[1]);
			Assert.AreEqual("This is a required field", summary.ErrorMessages[2]);
		}
        public void ValidationOrderTest()
        {
            ValidatorRunner runner = new ValidatorRunner(new CachedValidationRegistry());

            Supplier supplier = new Supplier();

            supplier.Password = "******";

            runner.IsValid(supplier);

            ErrorSummary summary = runner.GetErrorSummary(supplier);

            Assert.IsNotNull(summary);

            Assert.AreEqual("This is a required field", summary.ErrorMessages[0]);
            Assert.AreEqual("Fields do not match", summary.ErrorMessages[1]);
            Assert.AreEqual("This is a required field", summary.ErrorMessages[2]);
        }
		public void Init()
		{
			runner = new ValidatorRunner(new CachedValidationRegistry());
		}
예제 #17
0
 public void SetUp()
 {
     cachedValidationRegistry = new CachedValidationRegistry(new ResourceManager("Castle.Components.Validator.Messages", typeof(CachedValidationRegistry).Assembly));
     runner = new ValidatorRunner(cachedValidationRegistry);
 }
		public void ExecutesCustomContributors()
		{
			ValidatorRunner runnerWithContributor = new ValidatorRunner(true, new CachedValidationRegistry(),
				new IValidationContributor[] {new AlwaysErrorContributor()});

			object target = new object();
			Assert.IsFalse(runnerWithContributor.IsValid(target));
			ErrorSummary errors = runnerWithContributor.GetErrorSummary(target);
			Assert.IsTrue(errors.HasError);
			Assert.AreEqual(1, errors.ErrorsCount);
			string[] errorsForKey = errors.GetErrorsForProperty("someKey");
			Assert.AreEqual(1, errorsForKey.Length);
			Assert.AreEqual("error", errorsForKey[0]);
		}
예제 #19
0
 public IValidator[] GetValidators(ValidatorRunner validatorRunner, Type targetType, PropertyInfo property, RunWhen runWhen)
 {
     throw new NotSupportedException();
 }
예제 #20
0
 public virtual void Init()
 {
     runner = new ValidatorRunner(new CachedValidationRegistry());
 }
예제 #21
0
        /// <summary>
        /// Builds all of the validators for a given method, parameter position, with the defined RunWhen.
        /// </summary>
        /// <param name="method">The method.</param>
        /// <param name="parameterPosition">The parameter position.</param>
        /// <param name="runner">The runner.</param>
        /// <param name="runWhen">The run when.</param>
        /// <param name="parameterInfoMeta">Metadata about the parameters such as whether or not it is params</param>
        /// <returns></returns>
        public IValidator[] GetValidatorsFor(MethodInfo method, int parameterPosition, ValidatorRunner runner, RunWhen runWhen,
                                             out ParameterInfoMeta parameterInfoMeta)
        {
            MethodValidatorMetaInfo meta       = type2MetaInfo[method.DeclaringType];
            List <IValidator>       validators = new List <IValidator>();

            IValidatorBuilder[] builders = meta.GetBuilders(method, parameterPosition, out parameterInfoMeta);

            ParameterInfo[] parameters = method.GetParameters();

            foreach (IValidatorBuilder builder in builders)
            {
                IValidator validator = builder.Build(runner, typeof(MethodInfo));

                if (!IsValidatorOnPhase(validator, runWhen))
                {
                    continue;
                }

                if (string.IsNullOrEmpty(validator.FriendlyName))
                {
                    validator.FriendlyName = parameters[parameterPosition].Name;
                }

                validator.Initialize(registry, null);
                validators.Add(validator);
            }

            return(validators.ToArray());
        }
예제 #22
0
 /// <summary>
 /// Initializes a new instance of the <see cref="AbstractFormRelatedHelper"/> class.
 /// </summary>
 /// <param name="validatorRegistry">The validator registry.</param>
 /// <param name="validatorRunner">The validator runner.</param>
 protected AbstractFormRelatedHelper(IValidatorRegistry validatorRegistry, ValidatorRunner validatorRunner)
 {
     this.validatorRegistry = validatorRegistry;
     this.validatorRunner   = validatorRunner;
 }
 public void SetUp()
 {
     cachedValidationRegistry = new CachedValidationRegistry(new ResourceManager("Castle.Components.Validator.Messages", typeof(CachedValidationRegistry).Assembly));
     runner = new ValidatorRunner(cachedValidationRegistry);
 }
        internal static void AddNestedPropertyValidationErrorMessages(List <string> errorMessages, object instance, ValidatorRunner runner)
        {
            foreach (PropertyInfo propinfo in GetNestedPropertiesToValidate(instance))
            {
                object propval = propinfo.GetValue(instance, null);
                if (propval != null)
                {
                    ErrorSummary summary = runner.GetErrorSummary(propval);

                    if (summary != null)
                    {
                        errorMessages.AddRange(summary.ErrorMessages);
                    }
                }
            }
        }