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;
}