protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
ValidationResult validationResult = ValidationResult.Success;
string pw = value.ToString();
bool num = false;
bool letter = false;
foreach (char c in pw)
{
if (Char.IsDigit(c))
{
num = true;
}
else
{
if (Char.IsLetter(c))
{
letter = true;
}
}
}
if (!num || !letter)
{
validationResult = new ValidationResult(ErrorMessageString);
}
return validationResult;
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
ValidationResult validationResult = new ValidationResult("\"" + value.ToString() + "\"" + ErrorMessageString);
try
{
if (value is string)
{
string frequencyString = (string)value;
if (frequencyString.Equals("hourly"))
validationResult = ValidationResult.Success;
if (frequencyString.Equals("daily"))
validationResult = ValidationResult.Success;
if (frequencyString.Equals("weekly"))
validationResult = ValidationResult.Success;
if (frequencyString.Equals("monthly"))
validationResult = ValidationResult.Success;
if (frequencyString.Equals("yearly"))
validationResult = ValidationResult.Success;
}
else
{
validationResult = new ValidationResult("An error occurred while validating the property. OtherProperty is not of type String");
}
}
catch (Exception ex)
{
// Do stuff, i.e. log the exception
// Let it go through the upper levels, something bad happened
throw ex;
}
return validationResult;
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
ValidationResult validationResult = ValidationResult.Success;
try
{
// Using reflection we can get a reference to the other date property, in this example the project start date
var otherPropertyInfo = validationContext.ObjectType.GetProperty(this.otherPropertyName);
// Let's check that otherProperty is of type DateTime as we expect it to be
if (otherPropertyInfo.PropertyType.Equals(new DateTime().GetType()))
{
DateTime toValidate = (DateTime)value;
DateTime referenceProperty = (DateTime)otherPropertyInfo.GetValue(validationContext.ObjectInstance, null);
// if the end date is lower than the start date, than the validationResult will be set to false and return
// a properly formatted error message
if (toValidate.CompareTo(referenceProperty) < 1)
{
//string message = FormatErrorMessage(validationContext.DisplayName);
//validationResult = new ValidationResult(message);
validationResult = new ValidationResult(ErrorMessageString);
}
}
else
{
validationResult = new ValidationResult("An error occurred while validating the property. OtherProperty is not of type DateTime");
}
}
catch (Exception ex)
{
// Do stuff, i.e. log the exception
// Let it go through the upper levels, something bad happened
throw ex;
}
return validationResult;
}
public static void Can_construct_get_and_set_ErrorMessage()
{
var validationResult = new ValidationResult("SomeErrorMessage");
Assert.Equal("SomeErrorMessage", validationResult.ErrorMessage);
validationResult.ErrorMessage = "SomeOtherErrorMessage";
Assert.Equal("SomeOtherErrorMessage", validationResult.ErrorMessage);
}
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
var validationResults = new HashSet<ValidationResult>();
var contest = this.regData.CustomerCards.GetById(this.ContestId);
var contestQuestions = contest.Questions.ToList();
var counter = 0;
foreach (var question in contestQuestions)
{
var answer = this.Questions.FirstOrDefault(x => x.QuestionId == question.Id);
var memberName = string.Format("Questions[{0}].Answer", counter);
if (answer == null)
{
var validationErrorMessage = string.Format("Question with id {0} was not answered.", question.Id);
var validationResult = new ValidationResult(validationErrorMessage, new[] { memberName });
validationResults.Add(validationResult);
}
else if (!string.IsNullOrWhiteSpace(question.RegularExpressionValidation) &&
!Regex.IsMatch(answer.Answer, question.RegularExpressionValidation))
{
var validationErrorMessage = string.Format(
"Question with id {0} is not in the correct format.", question.Id);
var validationResult = new ValidationResult(validationErrorMessage, new[] { memberName });
validationResults.Add(validationResult);
}
counter++;
}
return validationResults;
}
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
var validationResults = new HashSet<ValidationResult>();
var contest = this.data.Contests.GetById(this.ContestId);
var contestQuestions = contest.Questions
.Where(x => !x.IsDeleted)
.ToList();
var counter = 0;
foreach (var question in contestQuestions)
{
var answer = this.Questions.FirstOrDefault(x => x.QuestionId == question.Id);
var memberName = string.Format("Questions[{0}].Answer", counter);
if (answer == null)
{
var validationErrorMessage = string.Format(Resource.Question_not_answered, question.Id);
var validationResult = new ValidationResult(validationErrorMessage, new[] { memberName });
validationResults.Add(validationResult);
}
else if (!string.IsNullOrWhiteSpace(question.RegularExpressionValidation) && !Regex.IsMatch(answer.Answer, question.RegularExpressionValidation))
{
var validationErrorMessage = string.Format(Resource.Question_not_answered_correctly, question.Id);
var validationResult = new ValidationResult(validationErrorMessage, new[] { memberName });
validationResults.Add(validationResult);
}
counter++;
}
return validationResults;
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
ValidationResult validationResult = ValidationResult.Success;
try
{
var otherPropertyInfo = validationContext.ObjectType.GetProperty(this.otherPropertyName);
var sum = (double)value;
var creditId = (int)otherPropertyInfo.GetValue(validationContext.ObjectInstance, null);
using (var scope = CustomDependencyResolver.Resolver.BeginScope())
{
var creditService = scope.GetService(typeof (ICreditService)) as ICreditService;
if (creditService == null)
{
validationResult = new ValidationResult("Cannot resolve ICreditService");
}
else
{
var credit = creditService.Get(creditId);
if (sum < credit.MinSum || sum > credit.MaxSum)
{
var errorMessage = String.Format("Sum should be between {0} and {1}.", credit.MinSum,
credit.MaxSum);
validationResult = new ValidationResult(errorMessage);
}
}
}
}
catch (Exception ex)
{
throw ex;
}
return validationResult;
}
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
var failedValidationResult = new ValidationResult("An error occured!");
var failedResult = new[] { failedValidationResult };
if (!string.IsNullOrEmpty(this.Honeypot))
{
return failedResult;
}
DateTime timestamp;
if (!DateTime.TryParseExact(this.Timestamp, "ffffMMHHyytssmmdd",
null, DateTimeStyles.None, out timestamp))
{
return failedResult;
}
if (DateTime.Now.AddMinutes(-5) > timestamp)
{
return failedResult;
}
return new[] { ValidationResult.Success };
}
// ******************************************************************
/// <summary>
/// Calling with null will remove any existing errors if any.
/// </summary>
/// <param name="propertyName"></param>
/// <param name="validationResults"></param>
public void SetErrorFor <T>(Expression <Func <T> > property, ValidationResult validationResult = null)
{
var asMember = property.Body as MemberExpression;
if (asMember == null)
{
throw new ArgumentException("Unable to find property name.");
}
string propertyName = asMember.Member.Name;
if (validationResult == null || validationResult.ErrorMessage == null)
{
// Remove the existing errors for this property
List <string> fakeListForRemoval;
if (_errors.TryRemove(propertyName, out fakeListForRemoval))
{
OnErrorsChanged(propertyName);
}
}
else
{
// Add or Update
var errorList = new List <string>(1);
errorList.Add(validationResult.ErrorMessage);
_errors[propertyName] = errorList;
OnErrorsChanged(propertyName);
}
}
public void Constructor_String_IEnumerable ()
{
var vr = new ValidationResult ("message", null);
Assert.AreEqual ("message", vr.ErrorMessage, "#A1");
Assert.IsNotNull (vr.MemberNames, "#A2-1");
int count = 0;
foreach (string m in vr.MemberNames)
count++;
Assert.AreEqual (0, count, "#A2-2");
var names = new string[] { "one", "two" };
vr = new ValidationResult ("message", names);
Assert.AreEqual ("message", vr.ErrorMessage, "#A1");
Assert.IsNotNull (vr.MemberNames, "#A2-1");
Assert.AreSame (names, vr.MemberNames, "#A2-2");
count = 0;
foreach (string m in vr.MemberNames)
count++;
Assert.AreEqual (2, count, "#A2-3");
vr = new ValidationResult (null, null);
Assert.AreEqual (null, vr.ErrorMessage, "#A3");
}
private static IEnumerable<ValidationResult> ValidateAttributes(object instance,
ValidationContext validationContext,
string prefix)
{
PropertyDescriptor[] propertyDescriptorCollection =
TypeDescriptor.GetProperties(instance).Cast<PropertyDescriptor>().ToArray();
IEnumerable<ValidationResult> valResults = propertyDescriptorCollection.SelectMany(
prop => prop.Attributes.OfType<ValidationAttribute>(), (prop, attribute) =>
{
validationContext.DisplayName = prop.Name;
ValidationResult validationresult = attribute.GetValidationResult(prop.GetValue(instance),
validationContext);
if (validationresult != null)
{
IEnumerable<string> memberNames = validationresult.MemberNames.Any()
? validationresult.MemberNames.Select(c => prefix + c)
: new[] { prefix + prop.Name };
validationresult = new ValidationResult(validationresult.ErrorMessage, memberNames);
}
return validationresult;
})
.Where(
validationResult =>
validationResult !=
ValidationResult.Success);
return
valResults;
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
ValidationResult validationResult = ValidationResult.Success;
try
{
var otherPropertyInfo = validationContext.ObjectType.GetProperty(this.otherPropertyName);
if (otherPropertyInfo.PropertyType.Equals(new TimeSpan().GetType()))
{
var toValidate = (TimeSpan)value;
var referenceProperty = (TimeSpan)otherPropertyInfo.GetValue(validationContext.ObjectInstance, null);
if (toValidate.CompareTo(referenceProperty) < 1)
{
validationResult = new ValidationResult(ErrorMessageString);
}
}
else
{
validationResult = new ValidationResult("An error occurred while validating the property. OtherProperty is not of type DateTime");
}
}
catch (Exception ex)
{
throw ex;
}
return validationResult;
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
var errorMessage = $"The {validationContext.DisplayName} field is required.";
var validationResult = new ValidationResult(errorMessage, new string[] { validationContext.DisplayName });
if (value == null) return validationResult;
if (value is string && string.IsNullOrWhiteSpace(value.ToString()))
{
return validationResult;
}
var incoming = value.ToString();
decimal val = 0;
if (Decimal.TryParse(incoming, out val) && val == 0)
{
return validationResult;
}
var date = DateTime.MinValue;
if (DateTime.TryParse(incoming, out date) && date == DateTime.MinValue)
{
return validationResult;
}
return ValidationResult.Success;
}
/// <summary>
/// Initializes new instance of the <see cref="ValueComparisonAttribute"/> class.
/// </summary>
/// <param name="otherProperty">The name of the other property.</param>
/// <param name="comparison">The <see cref="ValueComparison"/> to perform between values.</param>
public ValueComparisonAttribute(string propertyName, ValueComparison comparison)
: base(propertyName)
{
this.comparison = comparison;
this.failure = new ValidationResult(String.Empty);
this.success = ValidationResult.Success;
}
public void It_should_succeed()
{
// Act
System.ComponentModel.DataAnnotations.ValidationResult result = _sut.GetValidationResult(TestValues.ValidIban, _validationContext);
// Assert
result.Should().Be(System.ComponentModel.DataAnnotations.ValidationResult.Success);
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (value == null || String.IsNullOrEmpty(value.ToString())) return null;
ValidationResult validationResult = null;
if (!Regex.IsMatch(value.ToString(), Pattern))
validationResult = new ValidationResult(ErrorMessage);
return validationResult;
}
public void WeAreAbleToTransformValidationResultIntoException()
{
var error = new ValidationResult("error is fancy");
var exception = error.ToException();
Assert.IsNotNull(exception);
Assert.AreEqual(error.ErrorMessage, exception.Message);
}
/// <summary>
/// Constructor that creates a copy of an existing ValidationResult.
/// </summary>
/// <param name="validationResult">The validation result.</param>
/// <exception cref="System.ArgumentNullException">The <paramref name="validationResult"/> is null.</exception>
protected ValidationResult(ValidationResult validationResult) {
if (validationResult == null) {
throw new ArgumentNullException("validationResult");
}
this._errorMessage = validationResult._errorMessage;
this._memberNames = validationResult._memberNames;
}
public static bool ValidateProduct(Products product, ValidationContext context, out ValidationResult result) {
result = null;
if (product.ReorderLevel < 0) {
result = new ValidationResult("Reorder level is out of range", new[] { "ReorderLevel" });
return false;
}
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.ComponentModel.DataAnnotations.ValidationResult" /> class by
/// using a <see cref="T:System.ComponentModel.DataAnnotations.ValidationResult" /> object.
/// </summary>
/// <param name="validationResult">The validation result object.</param>
protected ValidationResult( ValidationResult validationResult )
{
if ( validationResult == null )
throw new ArgumentNullException( "validationResult" );
ErrorMessage = validationResult.ErrorMessage;
memberNames = validationResult.memberNames;
}
public static IEnumerable<string> ExpandResults( ValidationResult result )
{
if( result == null )
{
return new List<string>();
}
return ExpandResults( new List<ValidationResult> { result } );
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (value == null)
return null;
ValidationResult r = new ValidationResult("Invalid Postal Code!");
if(!ValidateFunctions.validPostalCode(((String)value).ToUpper()))
return r;
return null;
}
public void AddResult(ValidationResult validationResult)
{
if (validationResult == null)
{
throw new ArgumentNullException("validationResult");
}
m_results.Add(validationResult);
}
public static void MemberNames_can_be_set_through_two_args_constructor()
{
var validationResult = new ValidationResult("SomeErrorMessage", null);
AssertEx.Empty(validationResult.MemberNames);
var memberNames = new List<string>() { "firstMember", "secondMember" };
validationResult = new ValidationResult("SomeErrorMessage", memberNames);
Assert.True(memberNames.SequenceEqual(validationResult.MemberNames));
}
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
var results = new List<ValidationResult>();
if (Price <= 0)
{
var result = new ValidationResult("Price must be higher than zero.", new string[] { "Price" });
results.Add(result);
}
return results;
}
public void It_should_have_error_message_with_displayName()
{
_validationContext.DisplayName = "Property";
// Act
System.ComponentModel.DataAnnotations.ValidationResult result = _sut.GetValidationResult(TestValues.InvalidIban, _validationContext);
// Assert
result.ErrorMessage.Should().Be(string.Format(Resources.IbanAttribute_Invalid, _validationContext.DisplayName));
}
protected override ValidationResult IsValid( object value, ValidationContext validationContext )
{
var result = new ValidationResult (_errorMessage);
decimal price;
if(!decimal.TryParse(value.ToString(), out price) || price <= 0m)
return result;
return ValidationResult.Success;
}
protected override ValidationResult IsValid( object value, ValidationContext validationContext )
{
var result = new ValidationResult (_errorMessage);
int count;
if(!int.TryParse(value.ToString(), out count) || count < 0)
return result;
return ValidationResult.Success;
}
public void IsValid_NotEqualValue_ReturnsValidationResult()
{
AttributesModel model = new AttributesModel { Total = 10 };
ValidationContext context = new ValidationContext(model);
ValidationResult expected = new ValidationResult(attribute.FormatErrorMessage(context.DisplayName));
ValidationResult actual = attribute.GetValidationResult(model.Sum, context);
Assert.Equal(expected.ErrorMessage, actual.ErrorMessage);
}
public ComponentPropertyWrapViewModel(string propertyName, IPropertyValue propertyValue, string type, bool required)
{
mName = propertyName;
mType = (CommonUtils.PropertyType)Enum.Parse(typeof(CommonUtils.PropertyType), type, true);
mRequired = required;
mPropertyValue = propertyValue;
mErrorNumbericalValidationResult = new ValidationResult(string.Format("Field {0} is numerical", mName));
mErrorRequiredValidationResult = new ValidationResult(string.Format("Field {0} is required", mName));
}
/// <summary>
/// Initializes new instance of the <see cref="DateTimeCompareAttribute"/> class.
/// </summary>
/// <param name="otherProperty">The name of the other property.</param>
/// <param name="comparison">The <see cref="ValueComparison"/> to perform between values.</param>
public DateTimeCompareAttribute(string otherProperty, ValueComparison comparison)
: base(otherProperty)
{
if (!Enum.IsDefined(typeof(ValueComparison), comparison))
throw new ArgumentException("Undefined value.", "comparison");
this.comparison = comparison;
this.success = ValidationResult.Success;
this.failure = new ValidationResult(String.Empty);
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
var validationResult = new ValidationResult("Please enter a number with a maximum of 2 decimal places");
if (value != null && value.ToString().IsValidMoneyDecimal())
{
validationResult = ValidationResult.Success;
}
return validationResult;
}
public ComponentTestingPropertyWrapViewModel(ControlSystemComponentTestingProperty componentTestingProperty, ControlSystemComponentTestingPropertyValue propertyValue)
{
mComponentTestingProperty = componentTestingProperty;
mType = (CommonUtils.PropertyType)Enum.Parse(typeof(CommonUtils.PropertyType), componentTestingProperty.Type, true);
var name = componentTestingProperty.Name;
mRequired = componentTestingProperty.Required;
mPropertyValue = propertyValue;
mErrorNumbericalValidationResult = new ValidationResult(string.Format("Field {0} is numerical", name));
mErrorRequiredValidationResult = new ValidationResult(string.Format("Field {0} is required", name));
AcceptCommand = new DelegateCommand<object>(AcceptCommandHandler, CanModifyHandler);
}
private static IEnumerable <ValidationError> GetInnerErrors(DA.ValidationResult validationResult)
{
if (validationResult is CompositeValidationResult)
{
CompositeValidationResult compositeValidationResult = (CompositeValidationResult)validationResult;
return(compositeValidationResult.InnerResults
.Select(x => new ValidationError(x.MemberNames, x.ErrorMessage, GetInnerErrors(x)))
.ToList());
}
else
{
return(null);
}
}
/// <inheritdoc/>
public Task ValidateChangeSetItemAsync(
SubmitContext context,
ChangeSetItem item,
Collection <ChangeSetItemValidationResult> validationResults,
CancellationToken cancellationToken)
{
Ensure.NotNull(validationResults, "validationResults");
DataModificationItem dataModificationItem = item as DataModificationItem;
if (dataModificationItem != null)
{
object entity = dataModificationItem.Entity;
// TODO GitHubIssue#50 : should this PropertyDescriptorCollection be cached?
PropertyDescriptorCollection properties =
new DataAnnotations.AssociatedMetadataTypeTypeDescriptionProvider(entity.GetType())
.GetTypeDescriptor(entity).GetProperties();
DataAnnotations.ValidationContext validationContext = new DataAnnotations.ValidationContext(entity);
foreach (PropertyDescriptor property in properties)
{
validationContext.MemberName = property.Name;
IEnumerable <DataAnnotations.ValidationAttribute> validationAttributes =
property.Attributes.OfType <DataAnnotations.ValidationAttribute>();
foreach (DataAnnotations.ValidationAttribute validationAttribute in validationAttributes)
{
object value = property.GetValue(entity);
DataAnnotations.ValidationResult validationResult =
validationAttribute.GetValidationResult(value, validationContext);
if (validationResult != DataAnnotations.ValidationResult.Success)
{
validationResults.Add(new ChangeSetItemValidationResult()
{
Id = validationAttribute.GetType().FullName,
Message = validationResult.ErrorMessage,
Severity = EventLevel.Error,
Target = entity,
PropertyName = property.Name
});
}
}
}
}
return(Task.WhenAll());
}
public void It_should_set_member_name()
{
// Act
System.ComponentModel.DataAnnotations.ValidationResult result = _sut.GetValidationResult(TestValues.InvalidIban, _validationContext);
// Assert
if (string.IsNullOrEmpty(_validationContext.MemberName))
{
result.MemberNames.Should().BeNullOrEmpty();
}
else
{
result.MemberNames.Should()
.NotBeNull()
.And.BeEquivalentTo(_validationContext.MemberName);
}
}
protected virtual string Validate(object model, string propertyName)
{
string error = string.Empty;
if (string.IsNullOrEmpty(propertyName))
{
return(error);
}
string curPropName = propertyName;
object curmodel = model;
object value = curmodel;
string[] propTree = propertyName.Split('.');
foreach (string prop in propTree)
{
var pi = value.GetType().GetProperty(prop);
if (pi == null)
{
break;
}
curPropName = prop;
curmodel = value;
value = pi.GetValue(value, null);
}
var results = new List <DA.ValidationResult>(1);
var validCtx = new DA.ValidationContext(curmodel, null, null)
{
MemberName = curPropName
};
bool result = DA.Validator.TryValidateProperty(value, validCtx, results);
if (!result)
{
DA.ValidationResult validationResult = results.First();
error = validationResult.ErrorMessage;
}
return(error);
}
protected override System.ComponentModel.DataAnnotations.ValidationResult IsValid(object value, ValidationContext validationContext)
{
_validationResult = null;
_validationResult = base.IsValid(value, validationContext);
var ownerToTest = validationContext.ObjectInstance as Entity <int>;
if (ownerToTest == null)
{
return(_validationResult);
}
var entityType = validationContext.ObjectType;
DbSchemaName = string.IsNullOrEmpty(DbSchemaName) ? entityType.EntityTableName() : DbSchemaName;
DbColumnName = string.IsNullOrEmpty(DbColumnName) ? validationContext.MemberName : DbColumnName;
ValidationMessage = string.IsNullOrEmpty(ValidationMessage)
? string.Format("Property {0} must be unique across all \"{1}\" entities.", validationContext.MemberName, Inflector.Pluralize(entityType.Name))
: ValidationMessage;
var provider = ServiceLocator.Current.GetInstance <IDomainSessionFactoryProvider>();
if (_validationResult == null)
{
int npiCount;
using (var session = provider.SessionFactory.OpenStatelessSession())
{
var query = String.Format("select Count({1}) from [dbo].[{0}] where [{1}]={2} {3}", DbSchemaName, DbColumnName, value, ownerToTest.IsPersisted ? "and Id <> " + ownerToTest.Id : "");
npiCount = session.CreateSQLQuery(query)
.UniqueResult <int>();
}
if (npiCount > 0)
{
_validationResult = new System.ComponentModel.DataAnnotations.ValidationResult(ValidationMessage, new string[] { validationContext.MemberName });
}
}
return(_validationResult);
}
protected virtual void Validate(string propertyName, object value)
{
if (string.IsNullOrEmpty(propertyName))
{
throw new ArgumentNullException("propertyName");
}
string error = string.Empty;
var results = new List <System.ComponentModel.DataAnnotations.ValidationResult>(2);
bool result = Validator.TryValidateProperty(
value,
new ValidationContext(this, null, null)
{
MemberName = propertyName
},
results);
if (!result && (value == null || ((value is int || value is long) && (int)value == 0) || (value is decimal && (decimal)value == 0)))
{
return;
}
if (!result)
{
System.ComponentModel.DataAnnotations.ValidationResult validationResult = results.First();
if (!errorMessages.ContainsKey(propertyName))
{
errorMessages.Add(propertyName, validationResult.ErrorMessage);
}
}
else if (errorMessages.ContainsKey(propertyName))
{
errorMessages.Remove(propertyName);
}
}
protected override DA.ValidationResult IsValid(object value, DA.ValidationContext validationContext)
{
if (value == null)
{
return(DA.ValidationResult.Success);
}
var results = new List <DA.ValidationResult>();
if (value is IEnumerable)
{
// value is an enumerable, so we have to validate each element
// individually.
var enumerable = value as IEnumerable;
int index = 0;
foreach (var val in enumerable)
{
if (val != null)
{
// Validate the list element and wrap any validation info
// inside a composite result
var tmpResults = new List <DA.ValidationResult>();
var tmpContext = new DA.ValidationContext(val);
DA.Validator.TryValidateObject(val, tmpContext, tmpResults, true);
if (tmpResults.Count > 0)
{
var result = new CompositeValidationResult("Failed to validate property.", $"{validationContext.DisplayName}#{index}", tmpResults);
results.Add(result);
}
}
else
{
// Cannot validate a null element in a list
var result = new DA.ValidationResult("Element is null.", new string[] { $"{validationContext.DisplayName}#{index}" });
results.Add(result);
}
index++;
}
}
else
{
// Validate value normally and keep trace of the sub-results
var context = new DA.ValidationContext(value);
DA.Validator.TryValidateObject(value, context, results, true);
}
// Wrap all sub results inside a composite result to be able to gather
// useful information
if (results.Count > 0)
{
return(new CompositeValidationResult($"Failed to validate property.", validationContext.DisplayName, results));
}
else
{
return(DA.ValidationResult.Success);
}
}
protected ValidationResult(ValidationResult validationResult)
{
}
public ValidationException(ValidationResult validationResult, ValidationAttribute validatingAttribute, object value)
: this(validationResult != null ? validationResult.ErrorMessage : null, validatingAttribute, value)
{
this.ValidationResult = validationResult;
}
