public void Validate(ValidationAttribute attribute, object value, ValidationContext validationContext, bool isValid) { if (isValid) { attribute.Validate(value, validationContext); Assert.Equal(ValidationResult.Success, attribute.GetValidationResult(value, validationContext)); // Run the validation twice, in case attributes cache anything attribute.Validate(value, validationContext); Assert.Equal(ValidationResult.Success, attribute.GetValidationResult(value, validationContext)); } else { Assert.Throws <ValidationException>(() => attribute.Validate(value, validationContext)); Assert.NotNull(attribute.GetValidationResult(value, validationContext)); // Run the validation twice, in case attributes cache anything Assert.Throws <ValidationException>(() => attribute.Validate(value, validationContext)); Assert.NotNull(attribute.GetValidationResult(value, validationContext)); } if (!attribute.RequiresValidationContext) { Assert.Equal(isValid, attribute.IsValid(value)); // Run the validation twice, in case attributes cache anything Assert.Equal(isValid, attribute.IsValid(value)); } }
public void Validate(ValidationAttribute attribute, object value, ValidationContext validationContext, bool isValid) { if (isValid) { attribute.Validate(value, validationContext); Assert.Equal(ValidationResult.Success, attribute.GetValidationResult(value, validationContext)); // Run the validation twice, in case attributes cache anything attribute.Validate(value, validationContext); Assert.Equal(ValidationResult.Success, attribute.GetValidationResult(value, validationContext)); } else { Assert.Throws<ValidationException>(() => attribute.Validate(value, validationContext)); Assert.NotNull(attribute.GetValidationResult(value, validationContext)); // Run the validation twice, in case attributes cache anything Assert.Throws<ValidationException>(() => attribute.Validate(value, validationContext)); Assert.NotNull(attribute.GetValidationResult(value, validationContext)); } if (!attribute.RequiresValidationContext) { Assert.Equal(isValid, attribute.IsValid(value)); // Run the validation twice, in case attributes cache anything Assert.Equal(isValid, attribute.IsValid(value)); } }
public void Validate(MemberInfo memberInfo, object value) { ValidationResult result = _validationAttribute.GetValidationResult(value, new ValidationContext(value, null, null)); if (result == ValidationResult.Success) { return; } else { throw new ValidationException(result.ErrorMessage); } }
protected void HookupValidationAttributes() { PropertyInfo[] propertyInfos = GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (PropertyInfo propertyInfo in propertyInfos) { Attribute[] custom = Attribute.GetCustomAttributes(propertyInfo, typeof(ValidationAttribute), true); foreach (Attribute attribute in custom) { PropertyInfo property = propertyInfo; ValidationAttribute validationAttribute = attribute as ValidationAttribute; if (validationAttribute == null) { throw new NotSupportedException("validationAttribute variable should be inherited from ValidationAttribute type"); } string name = property.Name; DisplayAttribute displayAttribute = Attribute.GetCustomAttributes(propertyInfo, typeof(DisplayAttribute)).FirstOrDefault() as DisplayAttribute; if (displayAttribute != null) { name = displayAttribute.GetName(); } string message = validationAttribute.FormatErrorMessage(name); AddValidationFor(propertyInfo.Name).When(x => { object value = property.GetGetMethod().Invoke(this, new object[] {}); ValidationResult result = validationAttribute.GetValidationResult(value, new ValidationContext(this, null, null) { MemberName = property.Name }); return(result != ValidationResult.Success); }).Show(message); } } }
public IEnumerable <ValidationError> Validate(object instance, ValidationAttribute attribute, PropertyDescriptor descriptor) { const string placeHolder = "*DISPLAYNAME_PLACEHOLDER*"; var validationContext = new ValidationContext(instance, null, null) { MemberName = descriptor == null ? null : descriptor.Name, DisplayName = placeHolder }; if (descriptor != null) { // Display(Name) will auto populate the context, while DisplayName() needs to be manually set if (validationContext.MemberName == validationContext.DisplayName && !string.IsNullOrEmpty(descriptor.DisplayName)) { validationContext.DisplayName = descriptor.DisplayName; } instance = descriptor.GetValue(instance); } var result = attribute.GetValidationResult(instance, validationContext); if (result != null && result != System.ComponentModel.DataAnnotations.ValidationResult.Success) { yield return(new ValidationError(validationContext.MemberName, instance, result.ErrorMessage.UnformatWith(placeHolder))); } }
public override IEnumerable <ModelValidationResult> Validate(object container) { var context = new ValidationContext(container, null, null); var result = _attribute.GetValidationResult(Metadata.Model, context); if (result == null) { yield break; } //if (_attribute.IsValid(Metadata.Model)) // yield break; string errorMsg; lock (_attribute) { _attribute.ErrorMessage = _errorMsg; errorMsg = _attribute.FormatErrorMessage(Metadata.GetDisplayName()); _attribute.ErrorMessage = WorkaroundMarker; } yield return(new ModelValidationResult { Message = errorMsg }); }
private static ValidationResult GetLocalizedValidationResult(ValidationAttribute attribute, object value, LocalizedValidationContext validationContext) { lock (attribute) { var displayName = validationContext.Context.DisplayName; var errorMessage = attribute.ErrorMessage; try { var localizer = validationContext.Localizer; if (!string.IsNullOrEmpty(displayName)) { validationContext.Context.DisplayName = localizer[displayName].Value; } if (!string.IsNullOrEmpty(errorMessage)) { attribute.ErrorMessage = localizer[errorMessage].Value; } return(attribute.GetValidationResult(value, validationContext.Context)); } finally { attribute.ErrorMessage = errorMessage; if (!string.IsNullOrEmpty(displayName)) { validationContext.Context.DisplayName = displayName; } } } }
private static bool TryValidate(object value, ValidationContext validationContext, ValidationAttribute attribute, out ValidationError validationError) { if (validationContext == null) { throw new ArgumentNullException("validationContext"); } var disable = (IDisableValidation)validationContext.GetService(typeof(IDisableValidation)); if (disable != null && disable.IsDisabled(value, validationContext, attribute)) { validationError = null; return(true); } ValidationResult validationResult = attribute.GetValidationResult(value, validationContext); if (validationResult != ValidationResult.Success) { validationError = new ValidationError(attribute, value, validationResult); return(false); } validationError = null; return(true); }
public override IEnumerable <ModelValidationError> Validate(object instance, ValidationAttribute attribute, PropertyDescriptor descriptor, NancyContext context) { var validationContext = new ValidationContext(instance, null, null) { MemberName = descriptor == null ? null : descriptor.Name }; if (descriptor != null) { // DisplayName() will auto populate the context, while Display(Name) needs to be manually set if (validationContext.MemberName == validationContext.DisplayName && !string.IsNullOrEmpty(descriptor.DisplayName)) { validationContext.DisplayName = descriptor.DisplayName; } instance = descriptor.GetValue(instance); } var result = attribute.GetValidationResult(instance, validationContext); if (result != null) { yield return(GetValidationError(result, validationContext, attribute)); } }
public void Validate(MemberInfo memberInfo, object value, ChoValidationResults validationResults) { try { ValidationResult result = _validationAttribute.GetValidationResult(value, null); if (result != ValidationResult.Success) { if (validationResults != null) { validationResults.AddResult(result); } } } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { if (validationResults != null) { validationResults.AddResult(new ChoValidationResult(ex.Message)); } } }
// <summary> // Validates a property or an entity. // </summary> // <param name="entityValidationContext"> Validation context. Never null. </param> // <param name="property"> Property to validate. Null for entity validation. Not null for property validation. </param> // <returns> // Validation errors as <see cref="IEnumerable{DbValidationError}" /> . Empty if no errors, never null. // </returns> public virtual IEnumerable <DbValidationError> Validate( EntityValidationContext entityValidationContext, InternalMemberEntry property) { DebugCheck.NotNull(entityValidationContext); var validationContext = entityValidationContext.ExternalValidationContext; validationContext.SetDisplayName(property, _displayAttribute); var objectToValidate = property == null ? entityValidationContext.InternalEntity.Entity : property.CurrentValue; ValidationResult validationResult = null; try { validationResult = _validationAttribute.GetValidationResult(objectToValidate, validationContext); } catch (Exception ex) { throw new DbUnexpectedValidationException( Strings.DbUnexpectedValidationException_ValidationAttribute( validationContext.DisplayName, _validationAttribute.GetType()), ex); } return(validationResult != ValidationResult.Success ? DbHelpers.SplitValidationResults(validationContext.MemberName, new[] { validationResult }) : Enumerable.Empty <DbValidationError>()); }
private static bool TryGetError(object value, ValidationContext context, ValidationAttribute attribute, [NotNullWhen(true)] out ValidationResult?result) { var error = attribute.GetValidationResult(value, context); result = error == ValidationResult.Success ? null : error; return(!(result is null)); }
public override WinValidationResult Validate(object value, CultureInfo cultureInfo) { var result = ValidationAttribute.GetValidationResult(value, ValidationContext); return(result == DaValidationResult.Success ? WinValidationResult.ValidResult : new WinValidationResult(false, result.ErrorMessage)); }
internal ValidationResult GetValidationResult(ValidationAttribute attr, object propertyValue) { var result = attr.GetValidationResult(propertyValue, new ValidationContext(this)); return(result); }
private static string GetFinalMemberName(ValidationAttribute attrib, object contextModel, object mamberValue, string givenMemberName, string givenDisplayName) { return(attrib.GetValidationResult(mamberValue, new ValidationContext(contextModel) { MemberName = givenMemberName, DisplayName = givenDisplayName })?.MemberNames.Single()); }
public static string CheckValidationAttribute(this ValidationAttribute attribute, string displayName, object value) { var validationContext = new ValidationContext(ValidationObject) { MemberName = displayName }; return(attribute.GetValidationResult(value, validationContext)?.ErrorMessage); }
public ValidationResult GetValidationResult(object value, ValidationContext validationContext) { if (attribute.ErrorMessageResourceType == null && attribute.ErrorMessage == null) { attribute.ErrorMessageResourceType = _parent.ErrorMessageResourceType; Console.WriteLine("setting resourcetype from parent"); } return(attribute.GetValidationResult(value, validationContext)); }
/// <summary> /// 検証結果を追加する /// </summary> /// <param name="errors">エラー結果のリスト</param> /// <param name="context">検証コンテキスト</param> /// <param name="va">検証属性</param> /// <param name="value">検査対象の値</param> public static void AddErrors(this IList <ValidationResult> errors, ValidationContext context, ValidationAttribute va, object value) { va.SetupErrorMessageResource(); var result = va.GetValidationResult(value, context); if (result != ValidationResult.Success) { errors.Add(result); } }
public Func <object, ValidationResult> GetValidator(string propertyName, object model) { var validationContext = new ValidationContext(model) { DisplayName = propertyName, MemberName = propertyName }; return(input => _validationAttribute.GetValidationResult(input, validationContext)); }
protected override ValidationResult IsValid(object value, ValidationContext validationContext) { var valid = _properties.All(p => Validator.TryValidateProperty(p.Value(validationContext.ObjectInstance), new ValidationContext(validationContext.ObjectInstance, validationContext.ServiceContainer, validationContext.Items) { MemberName = p.Key }, null)); return(valid ? _validation.GetValidationResult(value, validationContext) : ValidationResult.Success); }
private bool Validate(ValidationAttribute validationAttribute, string propertyName) { var propertyValue = this.propertyGetters[propertyName](this); if (IsConditionalValidationAttribute(validationAttribute)) { return(validationAttribute.GetValidationResult(propertyValue, new ValidationContext(this)) == ValidationResult.Success); } return(validationAttribute.IsValid(propertyValue)); }
private bool TryValidate(object value, ValidationContext validationContext, ValidationAttribute attribute, out ValidationResult result) { result = attribute.GetValidationResult(value, validationContext); if (result == ValidationResult.Success) { result = null; return(true); } return(false); }
/// <summary> /// Tests whether a value is valid against a single <see cref="ValidationAttribute" /> using the <see cref="ValidationContext" />. /// </summary> /// <param name="value">The value to be tested for validity.</param> /// <param name="validationContext">Describes the property member to validate.</param> /// <param name="attribute">The validation attribute to test.</param> /// <param name="validationError"> /// The validation error that occurs during validation. Will be <c>null</c> when the return value is <c>true</c>. /// </param> /// <returns><c>true</c> if the value is valid.</returns> private static bool TryValidate(object value, ValidationContext validationContext, ValidationAttribute attribute, out ExecutionError validationError) { var validationResult = attribute.GetValidationResult(value, validationContext); if (validationResult != ValidationResult.Success) { validationError = CreateExecutionError(attribute, validationResult); return(false); } validationError = null; return(true); }
private static ValidateHandler CreateValidateHandler(ValidationAttribute attribute, ValidationContext context) { return(new ValidateHandler(actionContext => { object value; actionContext.ActionArguments.TryGetValue(context.MemberName, out value); var validationResult = attribute.GetValidationResult(value, context); if (validationResult != null) { actionContext.ModelState.AddModelError(context.MemberName, validationResult.ErrorMessage); } })); }
public IEnumerable <CoconaParameterValidationResult> Validate(CoconaParameterValidationContext ctx) { var validationCtx = new ValidationContext(ctx.Value); validationCtx.DisplayName = ctx.Parameter.Name; var result = _attribute.GetValidationResult(ctx.Value, validationCtx); if (result != ValidationResult.Success) { return(new[] { new CoconaParameterValidationResult(ctx.Parameter.Name, result.ErrorMessage) }); } return(Array.Empty <CoconaParameterValidationResult>()); }
private ValidationResult GetValidationResult(List <string> values, ValidationContext context) { if (values == null) { throw new ArgumentNullException(nameof(values)); } if (_attribute is RequiredAttribute && values.Count == 0) { return(_attribute.GetValidationResult(null, context)); } foreach (var value in values) { var result = _attribute.GetValidationResult(value, context); if (result != ValidationResult.Success) { return(result); } } return(ValidationResult.Success); }
private static bool TryValidate(object value, ValidationContext validationContext, ValidationAttribute attribute, out Validator.ValidationError validationError) { if (validationContext != null) { ValidationResult validationResult = attribute.GetValidationResult(value, validationContext); if (validationResult == ValidationResult.Success) { validationError = null; return(true); } validationError = new Validator.ValidationError(attribute, value, validationResult); return(false); } throw new ArgumentNullException("validationContext"); }
private void ValidateProperty( string objectPath, object instance, object value, string memberName, ValidationAttribute validator) { var validationContext = new ValidationContext(instance) { MemberName = memberName }; ValidationResult result = validator.GetValidationResult(value, validationContext); if (result != ValidationResult.Success) { _hasError = true; _onError.Invoke(new ObjectValidationError(objectPath, validator, result, value)); } }
public IEnumerable <ModelValidationError> Validate(object instance, ValidationAttribute attribute, PropertyDescriptor descriptor, NancyContext context) { var validationContext = new ValidationContext(instance, null, null) { MemberName = ((MatchAttribute)attribute).SourceProperty }; var result = attribute.GetValidationResult(instance, validationContext); if (result != null) { yield return(new ModelValidationError(result.MemberNames, attribute.ErrorMessage)); } yield break; }
private void AddAttributeValidator(PropertyInfo propertyInfo, ValidationAttribute validationAttribute) { string name = propertyInfo.Name; DisplayAttribute displayAttribute = propertyInfo.GetCustomAttributes <DisplayAttribute>().FirstOrDefault(); if (displayAttribute != null) { name = displayAttribute.GetName(); } // Note: See localization guidelines to properly localize the message ValidationResult validationResult = null; AddValidationFor <TBindingModel>(propertyInfo.Name, validationAttribute) .When( x => { object value = propertyInfo.GetMethod.Invoke(this, new object[] { }); ValidationContext validationContext = new ValidationContext(this) { MemberName = propertyInfo.Name }; validationResult = validationAttribute.GetValidationResult(value, validationContext); return(validationResult != ValidationResult.Success); }) .ShowMessage( (validatingModel) => { string result; if (validationResult != null && !String.IsNullOrEmpty(validationResult.ErrorMessage)) { result = validationResult.ErrorMessage; } else { result = validationAttribute.FormatErrorMessage(name); } return(result); }); }
public IEnumerable <ModelValidationError> Validate(object instance) { var context = new ValidationContext(instance, null, null) { MemberName = ((MatchAttribute)attribute).SourceProperty }; var result = attribute.GetValidationResult(instance, context); if (result != null) { yield return(new ModelValidationError(result.MemberNames, attribute.FormatErrorMessage)); } yield break; }