/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { return new EnumConversionRule(EnumType) { IgnoreCase = IgnoreCase }; }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { return new LengthStringRule(Minimum, Maximum) { TrimWhiteSpace = TrimWhiteSpace }; }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { return new RegexRule(validationExpression) { RegexOptions = RegexOptions }; }
/// <remarks> /// null is an invalid value for both <paramref name="rule"/> and <paramref name="errorMessage"/>. /// Due to performance concerns <see cref="ArgumentNullException"/> will no be thrown. /// So just don't pass in null or an empty string. /// </remarks> /// <param name="rule">The <see cref="Rule"/> that this <see cref="ValidationError"/> has been generated from.</param> /// <param name="errorMessage">The error message.</param> /// <param name="attemptedValue">The invalid member's value</param> /// <param name="infoDescriptor">The <see cref="InfoDescriptor"/> that this <see cref="ValidationError"/> has been generated from.</param> public ValidationError(Rule rule, string errorMessage, object attemptedValue, InfoDescriptor infoDescriptor) { //Dont guard these. the performance hit is not worth the minor help it gives developers. Rule = rule; ErrorMessage = errorMessage; AttemptedValue = attemptedValue; InfoDescriptor = infoDescriptor; }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { return new RangeRule<long>(Minimum, Maximum) { EqualsMaximumIsValid = EqualsMaximumIsValid, EqualsMinimumIsValid = EqualsMinimumIsValid }; }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { var equalityComparer = (IEqualityComparer) TypeExtensions.GetStaticProperty(EqualityComparerTypeName, EqualityComparerPropertyName); return new EnumerableDuplicateRule() { Comparer = equalityComparer }; }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { var equalityComparer = (IEqualityComparer)TypeExtensions.GetStaticProperty(EqualityComparerTypeName, EqualityComparerPropertyName); return new LengthCollectionRule(Minimum, Maximum) { ExcludeDuplicatesFromCount = ExcludeDuplicatesFromCount, Comparer = equalityComparer }; }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { var minimumDateTime = DateTimeConverter.Parse(Minimum); var maximumDateTime = DateTimeConverter.Parse(Maximum); return new RangeRule<DateTime>(minimumDateTime, maximumDateTime) { EqualsMaximumIsValid = EqualsMaximumIsValid, EqualsMinimumIsValid = EqualsMinimumIsValid }; }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { if (initialValue == null) { return RequiredObjectRuleCreator.ReadConfig(ErrorMessage, UseErrorMessageProvider, null, infoDescriptor.RuntimeType); } else { return RequiredObjectRuleCreator.ReadConfig(ErrorMessage, UseErrorMessageProvider, XmlReader.Create(new StringReader(initialValue)), infoDescriptor.RuntimeType); } }
/// <inheritdoc /> public override bool Validate(object targetMemberValue, object context, InfoDescriptor infoDescriptor) { if (targetMemberValue != null) { var valueAsString = (string) targetMemberValue; if (TrimWhiteSpace) { valueAsString = valueAsString.Trim(); } return LengthValidationHelper.IsLengthValid(valueAsString.Length, Minimum, Maximum); } return true; }
/// <inheritdoc /> public override bool Validate(object targetMemberValue, object context, InfoDescriptor infoDescriptor) { bool isValid; if (targetMemberValue == null) { return true; } else { return TypeExtensions.IsEnumDefined(EnumType, infoDescriptor.RuntimeType, targetMemberValue, IgnoreCase); } }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { if (initialValue.HasValue) { return new RequiredRule<long> { InitialValue = initialValue.Value }; } else { return new RequiredRule<long>(); } }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { var initialValueDateTime = DateTimeConverter.ParseNullable(InitialValue); if (initialValueDateTime.HasValue) { return new RequiredRule<DateTime> { InitialValue = initialValueDateTime.Value }; } else { return new RequiredRule<DateTime>(); } }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { var initialValueDecimal = (decimal?) initialValue; if (initialValue.HasValue) { return new RequiredRule<decimal> { InitialValue = initialValueDecimal.Value }; } else { return new RequiredRule<decimal>(); } }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { var instance = new ValidatableRule(); if (UseMemberErrorMessages) { if (ErrorMessage == null) { instance.UseMemberErrorMessages = true; } else { throw new InvalidOperationException("Cannot use 'useMemberErrorMessages'"); } } return instance; }
/// <inheritdoc /> public override ValidationError BaseValidate(object targetObjectValue, object targetMemberValue, object context, InfoDescriptor infoDescriptor) { if (targetMemberValue != null) { var validatable = targetMemberValue as IValidatable; bool isValid; string errorMessages = null; if (validatable == null) { var validationErrors = PropertyValidationManager.ValidateAll(targetMemberValue, RuleSet, context); isValid = validationErrors.Count == 0; if (!isValid) { errorMessages = ResultFormatter.GetConcatenatedErrorMessages(validationErrors); } } else { isValid = validatable.IsValid; var messages = validatable.ErrorMessages; if (!isValid) { errorMessages = ResultFormatter.GetConcatenatedErrorMessages(messages); } } if (!isValid) { if (UseErrorMessageProvider) { var errorMessage = ConfigurationService.ErrorMessageProvider.RetrieveErrorMessage(this, targetObjectValue, targetMemberValue, context); return new ValidationError(this, errorMessage, infoDescriptor, targetMemberValue); } else if (UseMemberErrorMessages) { return new ValidationError(this, errorMessages, infoDescriptor, targetMemberValue); } else { return CreateValidationError(targetObjectValue, targetMemberValue, context, infoDescriptor); } } } return null; }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { Guard.ArgumentNotNull(infoDescriptor, "infoDescriptor"); if (InitialValueAsString == null) { if (InitialValueAsLong == null) { return RequiredEnumRuleCreator.ReadConfig(ErrorMessage, UseErrorMessageProvider, infoDescriptor.RuntimeType); } else { return RequiredEnumRuleCreator.ReadConfig(InitialValueAsLong.Value, ErrorMessage, UseErrorMessageProvider, infoDescriptor.RuntimeType); } } else { return RequiredEnumRuleCreator.ReadConfig(InitialValueAsString, ErrorMessage, UseErrorMessageProvider, infoDescriptor.RuntimeType); } }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { if (InitialValue == null) { return new RequiredStringRule { TrimWhiteSpace = TrimWhiteSpace }; } else { return new RequiredStringRule { InitialValue = InitialValue, TrimWhiteSpace = TrimWhiteSpace, IgnoreCase = IgnoreCase }; } }
/// <inheritdoc /> public override bool Validate(object targetMemberValue, object context, InfoDescriptor infoDescriptor) { if (targetMemberValue == null) { return true; } else { var s = (string) targetMemberValue; if (s.Length == 0) { return true; } else { var m = Regex.Match(s, ValidationExpression, RegexOptions); return (m.Success && (m.Index == 0) && (m.Length == s.Length)); } } }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { Guid? initialValueGuid; if (string.IsNullOrEmpty(InitialValue)) { initialValueGuid = null; } else { initialValueGuid = new Guid(InitialValue); } if (initialValueGuid.HasValue) { return new RequiredRule<Guid> { InitialValue = initialValueGuid.Value }; } else { return new RequiredRule<Guid>(); } }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { var numberFormatInfo = (NumberFormatInfo) TypeExtensions.GetStaticProperty(NumberFormatInfoTypeName, NumberFormatInfoPropertyName); //TODO: populate other properties return new NumberConversionRule(TypeCode) { NumberFormatInfo = numberFormatInfo }; }
/// <inheritdoc /> public override bool Validate(object targetMemberValue, object context, InfoDescriptor infoDescriptor) { if (targetMemberValue != null) { int count; if (ExcludeDuplicatesFromCount) { count = GetCountExcludeDuplicates(targetMemberValue); } else { count = GetCount(targetMemberValue); } return LengthValidationHelper.IsLengthValid(count, Minimum, Maximum); } return true; }
/// <inheritdoc /> internal override void CheckType(InfoDescriptor infoDescriptor) { //var targetMemberRuntimeTypeHandle = infoDescriptor.RuntimeType; //var typeToCheck = Type.GetTypeFromHandle(targetMemberRuntimeTypeHandle); var typeToCheck = infoDescriptor.RuntimeType; var isGenericICollection = genericCollectionType.IsAssignableFrom(typeToCheck, true); var isICollection = collectionType.IsAssignableFrom(typeToCheck, true); if (!isICollection && !isGenericICollection) { throw new ArgumentException("Property must be a ICollection<T> or ICollection to be used for the LengthCollectionRule."); } }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { return new CustomRule(ValidationType, ValidationMethod, RuleInterpretation); }
private static void AddRuleToInfoDescriptor(IList<RuleData> list, InfoDescriptor infoDescriptor) { for (var ruleDateIndex = 0; ruleDateIndex < list.Count; ruleDateIndex++) { var ruleData = list[ruleDateIndex]; var runtimeType = infoDescriptor.RuntimeType; var rule = GetRule(ruleData, runtimeType); infoDescriptor.Rules.Add(rule); } }
/// <inheritdoc/> public sealed override bool Validate(object targetObjectValue, object targetMemberValue, object context, InfoDescriptor infoDescriptor) { return Validate(targetMemberValue, context, infoDescriptor); }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { return new CompareRule<long>(ValueToCompare, Operator); }
/// <summary> /// Validate the member this <see cref="Rule"/> is applied to. /// </summary> /// <returns><see langword="true"/> if the member is valid; otherwise <see langword="false"/>.</returns> /// <param name="targetMemberValue">The value of the member to validate.</param> /// <param name="context">An <see cref="object"/> that contains data for the <see cref="Rule"/> to validate. The default is null.</param> /// <param name="infoDescriptor">The <see cref="InfoDescriptor"/> for the member being validated.</param> public abstract bool Validate(object targetMemberValue, object context, InfoDescriptor infoDescriptor);
/// <inheritdoc /> public override bool Validate(object targetMemberValue, object context, InfoDescriptor infoDescriptor) { if (targetMemberValue == null) { return true; } else { var memberValueAsString = (string) targetMemberValue; if (RemoveWhiteSpace) { var stringBuilder = new StringBuilder(memberValueAsString.Length); foreach (var c in memberValueAsString) { if (!char.IsWhiteSpace(c)) { stringBuilder.Append(c); } } memberValueAsString = stringBuilder.ToString(); } if (memberValueAsString.Length == 0) { return true; } else { return GetIsValid(memberValueAsString); } } }
/// <inheritdoc/> public override Rule CreateInstance(InfoDescriptor infoDescriptor) { return new ComparePropertyRule(PropertyToCompare, Operator); }