private static ValidationResult Validate(ValidationContext context) { var properties = context.ObjectType.GetProperties(); if (context.ObjectInstance is IValidatableObject) { IValidatableObject valid = (IValidatableObject)context.ObjectInstance; var validationResults = valid.Validate(context); if (validationResults != null && validationResults.Count() > 0) { return(valid.Validate(context).FirstOrDefault()); } } foreach (var property in properties) { var validationAttributes = property.GetCustomAttributes(false).OfType <ValidationAttribute>(); foreach (var attribute in validationAttributes) { bool isValid = attribute.IsValid(property.GetValue(context.ObjectInstance)); if (!isValid) { return(new ValidationResult(attribute.ErrorMessage, new[] { property.Name })); } } } return(null); }
public override IEnumerable <ModelValidationResult> Validate(object container) { // NOTE: Container is never used here, because IValidatableObject doesn't give you // any way to get access to your container. object model = Metadata.Model; if (model == null) { return(Enumerable.Empty <ModelValidationResult>()); } IValidatableObject validatable = model as IValidatableObject; if (validatable == null) { throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, "The model object inside the metadata claimed to be compatible with {0}, but was actually {1}.", typeof(IValidatableObject).FullName, model.GetType().FullName ) ); } ValidationContext validationContext = new ValidationContext(validatable, null, null) { DisplayName = Metadata.DisplayName, MemberName = Metadata.PropertyName }; return(ConvertResults(validatable.Validate(validationContext))); }
public override IEnumerable <ModelValidationResult> Validate(object container) { // NOTE: Container is never used here, because IValidatableObject doesn't give you // any way to get access to your container. object model = Metadata.Model; if (model == null) { return(Enumerable.Empty <ModelValidationResult>()); } IValidatableObject validatable = model as IValidatableObject; if (validatable == null) { throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, MvcResources.ValidatableObjectAdapter_IncompatibleType, typeof(IValidatableObject).FullName, model.GetType().FullName)); } ValidationContext validationContext = new ValidationContext(validatable, null, null); return(ConvertResults(validatable.Validate(validationContext))); }
public static void ForceValidation(ModelStateDictionary stateDictionary, Object m) { IValidatableObject model = null; if (m is IValidatableObject) { model = m as IValidatableObject; IEnumerable <ValidationResult> errors = model.Validate(new ValidationContext(model, null, null)); List <string> modelStateKeys = stateDictionary.Keys.ToList(); List <ModelState> modelStateValues = stateDictionary.Values.ToList(); foreach (ValidationResult error in errors) { List <string> errorMemberNames = error.MemberNames.ToList(); if (errorMemberNames.Count == 0) { errorMemberNames.Add(String.Empty); } foreach (string memberName in errorMemberNames) { int index = modelStateKeys.IndexOf(memberName); if (index < 0 || !modelStateValues[index].Errors.Any(i => i.ErrorMessage == error.ErrorMessage)) { stateDictionary.AddModelError(memberName, error.ErrorMessage); } } } } }
public override IEnumerable <ModelValidationResult> Validate( ModelMetadata metadata, object container ) { // NOTE: Container is never used here, because IValidatableObject doesn't give you // any way to get access to your container. object model = metadata.Model; if (model == null) { return(Enumerable.Empty <ModelValidationResult>()); } IValidatableObject validatable = model as IValidatableObject; if (validatable == null) { throw Error.InvalidOperation( SRResources.ValidatableObjectAdapter_IncompatibleType, model.GetType() ); } ValidationContext validationContext = new ValidationContext(validatable, null, null); return(ConvertResults(validatable.Validate(validationContext))); }
public ObjectValidationResult ValidateObject(IValidatableObject validatableObject) { if (validatableObject == null) { return(new ObjectValidationResult { Message = "Object can not be null." }); } var validationResults = validatableObject.Validate(new ValidationContext(this)); var enumerable = validationResults as IList <ValidationResult> ?? validationResults.ToList(); if (enumerable.Any()) { return(new ObjectValidationResult { Message = enumerable.First().ErrorMessage }); } return(new ObjectValidationResult { Success = true }); }
/// <summary> /// Validates a column of an IValidatableObject for use with IDataErrorInfo. /// </summary> /// <param name="instance"></param> /// <param name="memberName"></param> /// <returns>Validation error, or empty when valid.</returns> public static string Validate(this IValidatableObject instance, string memberName) { var errors = instance.Validate(null) .Where(vr => vr.MemberNames.Contains(memberName)) .ToList(); return(ValidateInner(errors)); }
public static List <ValidationResult> GetValidationErrors(IValidatableObject obj) { var result = new List <ValidationResult>(); var validationContext = new ValidationContext(obj); Validator.TryValidateObject(obj, validationContext, result); obj.Validate(validationContext); return(result); }
public bool modelStateIsValidAfterReRunValidationOnComplexAttributes( ModelStateDictionary modelState, IValidatableObject model) { modelState.Clear(); var errors = model.Validate(new ValidationContext(model, null, null)); foreach(var error in errors) foreach(var memberName in error.MemberNames) modelState.AddModelError(memberName, error.ErrorMessage); return modelState.IsValid; }
/// <summary> /// Validates this instance, and throws an exception when validation fails. /// </summary> /// <typeparam name="TException">The type of the exception.</typeparam> /// <param name="instance">The instance.</param> public static void Validate <TException>(this IValidatableObject instance) where TException : Exception { var validationErrorMessage = instance.Validate(); if (!string.IsNullOrEmpty(validationErrorMessage)) { throw (Exception)Activator.CreateInstance(typeof(TException), validationErrorMessage); } }
public static string RaiseValidationAndGetResult(this IValidatableObject validatableObject, ValidationContext context) { string result = null; var validationResult = validatableObject.Validate(context); if (validationResult.Any()) { result = string.Join(Environment.NewLine, validationResult.Select(x => x.ErrorMessage)); } return(result); }
public static void RunCustomValidation(this ModelStateDictionary modelState, IValidatableObject viewModel) { var errors = viewModel.Validate(new ValidationContext(viewModel, null, null)); foreach (var error in errors) { foreach (var memberName in error.MemberNames) { modelState.AddModelError(memberName, error.ErrorMessage); } } }
public virtual IReadOnlyList <ValidationResult> Validate(object validatingObject) { var validationErrors = new List <ValidationResult>(); if (validatingObject is IValidatableObject) { IValidatableObject o = validatingObject as IValidatableObject; validationErrors.AddRange(o.Validate(new ValidationContext(o))); } return(validationErrors); }
public static bool IsValidField(this ModelStateDictionary modelSate, string key, IValidatableObject validatableObject) { if (!modelSate.IsValidField(key)) return false; var validationResults = validatableObject.Validate(new ValidationContext(validatableObject, null, null)); foreach (var validationResult in validationResults) if (validationResult.MemberNames.Contains(key)) { modelSate.AddModelError(key, validationResult.ErrorMessage); return false; } return true; }
public static ModelStateDictionary MergeWithValidatableObject(this ModelStateDictionary modelState, IValidatableObject obj) { IEnumerable<ValidationResult> errors = obj.Validate(new ValidationContext(obj, null, null)); foreach (ValidationResult error in errors) foreach (string memberName in error.MemberNames) { if (modelState.ContainsKey(memberName)) modelState.AddModelError(memberName, error.ErrorMessage); else modelState.AddModelError(memberName, error.ErrorMessage); } return modelState; }
public static void IsValid(this IValidatableObject obj) { if (obj == null) { return; } var result = obj.Validate(null); if (result.Any()) { throw new ApplicationException(result.First().ErrorMessage); } }
/// <summary> /// Internal iterator to enumerate all validation errors for the given object instance. /// </summary> /// <param name="instance">Object instance to test.</param> /// <param name="validationContext">Describes the object type.</param> /// <param name="validateAllProperties">if <c>true</c> also validates all properties.</param> /// <param name="breakOnFirstError">Whether to break on the first error or validate everything.</param> /// <returns>A collection of validation errors that result from validating the <paramref name="instance"/> with /// the given <paramref name="validationContext"/>.</returns> /// <exception cref="ArgumentNullException">When <paramref name="instance"/> is null.</exception> /// <exception cref="ArgumentNullException">When <paramref name="validationContext"/> is null.</exception> /// <exception cref="ArgumentException">When <paramref name="instance"/> doesn't match the /// <see cref="ValidationContext.ObjectInstance"/> on <paramref name="validationContext"/>.</exception> private static IEnumerable <ValidationError> GetObjectValidationErrors(object instance, ValidationContext validationContext, bool validateAllProperties, bool breakOnFirstError) { if (instance == null) { throw new ArgumentNullException("instance"); } if (validationContext == null) { throw new ArgumentNullException("validationContext"); } // Step 1: Validate the object properties' validation attributes List <ValidationError> errors = new List <ValidationError>(); errors.AddRange(GetObjectPropertyValidationErrors(instance, validationContext, validateAllProperties, breakOnFirstError)); // We only proceed to Step 2 if there are no errors if (errors.Any()) { return(errors); } // Step 2: Validate the object's validation attributes IEnumerable <ValidationAttribute> attributes = _store.GetTypeValidationAttributes(validationContext); errors.AddRange(GetValidationErrors(instance, validationContext, attributes, breakOnFirstError)); #if !SILVERLIGHT // We only proceed to Step 3 if there are no errors if (errors.Any()) { return(errors); } // Step 3: Test for IValidatableObject implementation IValidatableObject validatable = instance as IValidatableObject; if (validatable != null) { IEnumerable <ValidationResult> results = validatable.Validate(validationContext); foreach (ValidationResult result in results.Where(r => r != ValidationResult.Success)) { errors.Add(new ValidationError(null, instance, result)); } } #endif return(errors); }
public void TestValidate() { //arrange var rule = new IsNotNullOrEmptyRule <string>("Value cannot be null"); _validatableObject.Value = "Hello World"; _validatableObject.AddValidationRule(rule); //act var actual = _validatableObject.Validate(); //assert Assert.AreEqual(true, actual); }
// ******************************************************************* /// <summary> /// This method validates the current object and returns the result /// of any failing validations. /// </summary> /// <returns>A list of failing validations.</returns> /// <exception cref="ArgumentException">This exception is thrown whenever /// the argument is missing, or null.</exception> public static IEnumerable <ValidationResult> Validate( this IValidatableObject validatableObject ) { // Validate the parameters before attempting to use them. Guard.Instance().ThrowIfNull(validatableObject, nameof(validatableObject)); // Validate ourselves. var results = validatableObject.Validate( new ValidationContext(validatableObject) ); // Return the results. return(results); }
public static bool IsValid(this IValidatableObject obj, ValidationContext context = null) { if (obj == null) { return(false); } if (context == null) { context = new ValidationContext(obj); } var result = obj.Validate(context); return(!result.Any()); }
/// <summary> /// Evaluates the condition. /// </summary> /// <returns></returns> protected override bool EvaluateIsValid() { if (_validatorCollection == null) { _validatorCollection = new PageValidatorCollection(Page); } ICollection <ModelPropertyValidator> validators = GetPropertyValidators(); if (validators.Count > 0) { Type modelType = GetModelType(); IValidatableObject model = Activator.CreateInstance(modelType) as IValidatableObject; if (model != null) { // set the model with the form values List <ValidationResult> results = new List <ValidationResult>(); foreach (ModelPropertyValidator propertyValidator in validators) { PropertyInfo property = modelType.GetProperty(propertyValidator.PropertyName); object propertyValue; try { propertyValue = GetModelPropertyValue(property.Name, propertyValidator.ControlToValidate); } catch (ValidationException ex) { results.Add(ex.ValidationResult); continue; } property.SetValue(model, propertyValue, null); } results.AddRange(model.Validate(new ValidationContext(model, null, null))); foreach (ValidationResult result in results) { _validatorCollection.Add(new ValidationError(result.ErrorMessage, ValidationGroup)); } return(!results.Any()); } } return(true); }
private static void ValidValidatableObject(object model, Type modelType, ModelValid modelValid, string modelName) { IValidatableObject validatableObject = model as IValidatableObject; if (validatableObject == null) { return; } ValidationContext validationContext = new ValidationContext(model); foreach (var validResult in validatableObject.Validate(validationContext)) { modelValid.ValidResults.Add(new ValidFailure() { ErrorMessage = validResult.ErrorMessage, MemberNames = validResult.MemberNames, Name = modelName }); } }
private void ValidateBindings(IValidatableObject subject, ValidationContext context) { if (subject is null) { return; } var errors = subject.Validate(context).ToList(); var bindingsOfSameSubject = this.bindings.Where(x => this.GetBindingDataSource(x.DataSource) == subject); foreach (var binding in bindingsOfSameSubject) { var boundProperty = binding.BindingMemberInfo.BindingMember; var errorMessage = errors .FirstOrDefault(x => x.MemberNames.Contains(boundProperty)) ?.ErrorMessage; this.ErrorProvider?.SetError(binding.Control, errorMessage); } }
public static bool IsValid(this IValidatableObject input, out string error) { EnsureArg.IsNotNull(input, nameof(input)); var builder = new StringBuilder(); var validationErrors = input.Validate(new ValidationContext(input)); if (!validationErrors.Any()) { error = null; return(true); } builder.Append("Validation errors: "); foreach (var validationError in validationErrors) { builder.AppendLine($"{validationError.ErrorMessage}"); } error = builder.ToString(); return(false); }
// ******************************************************************* /// <summary> /// This method validates the current object and throws an exception /// with the contents of any failing validations. /// </summary> /// <exception cref="ArgumentException">This exception is thrown whenever /// the argument is missing, or null.</exception> /// <exception cref="ValidationException">This exception is thrown if /// any of the validation checks fail.</exception> public static void ThrowIfInvalid( this IValidatableObject validatableObject ) { // Validate the parameters before attempting to use them. Guard.Instance().ThrowIfNull(validatableObject, nameof(validatableObject)); // Validate ourselves. var results = validatableObject.Validate( new ValidationContext(validatableObject) ); // Did anything fail? if (results.Any()) { // Format the invalid member names. var memberNames = string.Join( ",", results.Select(x => string.Join(",", x.MemberNames)) ); // Format the error message. var errorMessages = string.Join( ",", results.Select(x => x.ErrorMessage) ); // Throw the exception. throw new ValidationException( message: string.Format( Resources.VerifiableObject_Invalid, validatableObject.GetType().Name, errorMessages, memberNames ) ); } }
//public override IEnumerable<ModelValidationResult> Validate(object container) //{ // object model = base.Metadata.Model; // if(model != null) // { // // Ask StructureMap to do setter injection for all properties decorated with SetterProperty attribute. // _container.BuildUp(model); // } // return base.Validate(container); //} public override IEnumerable <ModelValidationResult> Validate(object container) { object model = base.Metadata.Model; if (model != null) { IValidatableObject instance = model as IValidatableObject; if (instance == null) { //the base implementation will throw an exception after //doing the same check - so let's retain that behaviour return(base.Validate(container)); } /* replacement for the core functionality */ ValidationContext validationContext = CreateValidationContext(instance); return(this.ConvertResults(instance.Validate(validationContext))); } else { return(base.Validate(container)); /*base returns an empty set * of values for null. */ } }
public static void EnsureIsValid(this IValidatableObject obj, ValidationContext context = null) { if (obj == null) { return; } if (context == null) { context = new ValidationContext(obj); } var result = obj.Validate(context); var validationResults = result as ValidationResult[] ?? result.ToArray(); if (validationResults.Any()) { var errors = from e in validationResults select new ErrorMessage(e.ErrorMessage, string.Join(",", e.MemberNames)); throw new BusinessException(errors.ToList()); } }
public virtual IEnumerable <DbValidationError> Validate( EntityValidationContext entityValidationContext, InternalMemberEntry property) { if (property != null && property.CurrentValue == null) { return(Enumerable.Empty <DbValidationError>()); } ValidationContext validationContext = entityValidationContext.ExternalValidationContext; validationContext.SetDisplayName(property, this._displayAttribute); IValidatableObject validatableObject = property == null ? (IValidatableObject)entityValidationContext.InternalEntity.Entity : (IValidatableObject)property.CurrentValue; IEnumerable <ValidationResult> validationResults; try { validationResults = validatableObject.Validate(validationContext); } catch (Exception ex) { throw new DbUnexpectedValidationException(Strings.DbUnexpectedValidationException_IValidatableObject((object)validationContext.DisplayName, (object)ObjectContextTypeCache.GetObjectType(validatableObject.GetType())), ex); } return(DbHelpers.SplitValidationResults(validationContext.MemberName, validationResults ?? Enumerable.Empty <ValidationResult>())); }
public GlogErrorsResult(IValidatableObject validatable) { var validationResults = validatable.Validate(new ValidationContext(validatable)); errors = validationResults.Select(vr => vr.ErrorMessage).ToList(); }
public async Task <IActionResult> OnPost() { // Remove all errors from required fields that are not in the Form foreach (var key in ModelState.Keys.Where(k => ModelState[k].Errors.Count > 0 && !this.Request.Form.Keys.Any(ek => ek == k))) { ModelState[key].Errors.Clear(); ModelState[key].ValidationState = ModelValidationState.Valid; } // Test for IValidatableObject implementation IValidatableObject validatable = this.EngineView; var validationContext = new ValidationContext(this.EngineView, this.HttpContext.RequestServices, null); var results = validatable.Validate(validationContext); foreach (ValidationResult result in results.Where(r => r != ValidationResult.Success)) { ModelState.AddModelError("", result.ErrorMessage); } if (!ModelState.IsValid) { return(Page()); } try { YEngine engine; // Merge engine from repository with the one we are editing here if (!this.EngineView.IsNew) { var engineGetAction = await this.enginesController.GetEngineAsync(this.EngineView.Engine.Id).ConfigureAwait(false); if (engineGetAction.HasError) { throw new Exception(engineGetAction.Error?.ToString()); } engine = engineGetAction.Value; engine.EngineName = this.EngineView.EngineName; engine.EngineType = this.EngineView.EngineType; engine.Owners = this.EngineView.Engine.Owners; engine.Members = this.EngineView.Engine.Members; engine.Comments = this.EngineView.Comments; } else { engine = this.EngineView.Engine; } var saveEngineAction = await this.enginesController.SaveEngineAsync(engine.Id, engine); if (saveEngineAction.HasError) { throw new Exception(saveEngineAction.Error?.ToString()); } return(Redirect("/Engines/Index")); } catch (Exception ex) { ModelState.AddModelError("", ex.Message); return(Page()); } }
public ObjectValidationResult ValidateObject(IValidatableObject validatableObject) { if (validatableObject == null) { return new ObjectValidationResult { Message = "Object can not be null." }; } var validationResults = validatableObject.Validate(new ValidationContext(this)); var enumerable = validationResults as IList<ValidationResult> ?? validationResults.ToList(); if (enumerable.Any()) { return new ObjectValidationResult { Message = enumerable.First().ErrorMessage }; } return new ObjectValidationResult { Success = true }; }