private void Validate(DataMetaData dataMetaData, AspectContext aspectContext) { var skip = dataMetaData.Attributes.FirstOrDefault(x => x is SkipValidationAttribute); if (skip != null) { dataMetaData.State = DataValidationState.Skipped; return; } if (dataMetaData.Value is IValidatableObject validatableObject) { var validationContext = new ValidationContext(validatableObject, null, null); var results = validatableObject.Validate(validationContext)?.ToList() ?? new List <ValidationResult>(); dataMetaData.State = results.Count == 0 ? DataValidationState.Valid : DataValidationState.Invalid; foreach (var result in results) { foreach (var member in result.MemberNames ?? new List <string>()) { dataMetaData.Errors.Add(new DataValidationError(member, result.ErrorMessage)); } } } foreach (var property in dataMetaData.Type.GetTypeInfo().GetProperties()) { //property.GetIndexParameters().Length > 0 ;Indicates that the attribute is an indexer if (!property.CanRead || property.GetIndexParameters().Length > 0) { continue; } var propertyValidationContext = new PropertyValidationContext(new PropertyMetaData(property, dataMetaData.Value), aspectContext); var results = _propertyValidator.Validate(propertyValidationContext).ToList(); dataMetaData.State = results.Count == 0 && dataMetaData.State != DataValidationState.Invalid ? DataValidationState.Valid : DataValidationState.Invalid; results.ForEach(result => dataMetaData.Errors.Add(result)); } }
internal static Type GetBaseType(IServiceProvider serviceProvider, PropertyValidationContext validationContext) { Type propertyType = null; if (validationContext.Property is PropertyInfo) { return(Helpers.GetBaseType(validationContext.Property as PropertyInfo, validationContext.PropertyOwner, serviceProvider)); } if (validationContext.Property is DependencyProperty) { DependencyProperty property = validationContext.Property as DependencyProperty; if (property == null) { return(propertyType); } if (propertyType == null) { IDynamicPropertyTypeProvider propertyOwner = validationContext.PropertyOwner as IDynamicPropertyTypeProvider; if (propertyOwner != null) { propertyType = propertyOwner.GetPropertyType(serviceProvider, property.Name); } } if (propertyType == null) { propertyType = property.PropertyType; } } return(propertyType); }
public void Ctor_Call_NoException() { Expression <Func <TestDataObject, int> > propertyExpression = x => x.IntValue; var _ = new PropertyValidationContext <TestDataObject, int>(propertyExpression, A.Fake <IValidationContext <TestDataObject> >()); }
public void Validate(IValidationContext <T> validationContext) { if (_checkCondition?.Invoke(validationContext.InstanceForValidation) == false) { return; } var propertyValidationContext = new PropertyValidationContext <T, TProperty>(_propertyExpression, validationContext); // ReSharper disable once LoopCanBePartlyConvertedToQuery foreach (var propertyValidationStep in _validationSteps) { if (!propertyValidationStep.Validate(propertyValidationContext) && validationContext.BreakRuleValidationAfterFirstFailedValidation) { break; } } if (!propertyValidationContext.Faults.Any()) { return; } validationContext.AddFaults(HasFaultMessage ? new[] { new ValidationFault(propertyValidationContext.PropertyName, FaultMessage) } : propertyValidationContext.Faults); }
public void PropertyName_Get_ReturnsPropertyName() { var validationContext = A.Fake <IValidationContext <TestDataObject> >(); var propertyValidationContext = new PropertyValidationContext <TestDataObject, string>(x => x.StrValue, validationContext); Assert.Equal("StrValue", propertyValidationContext.PropertyName); }
public static OptionalMessagePropertyValidationContext <T> NotNull <T>( this PropertyValidationContext <T> context) where T : class { return(context.BeginPredicate( v => v != null, () => $"{context._currentRuleset.PropExpr.GetPropertyName()} must not be null." )); }
public void AddFault_AddNull_ThrowsException() { var validationContext = A.Fake <IValidationContext <TestDataObject> >(); var propertyValidationContext = new PropertyValidationContext <TestDataObject, string>(x => x.StrValue, validationContext); Assert.Throws <ArgumentNullException>(() => propertyValidationContext.AddFault(null)); }
public void AddFault_OneFault_FaultsHasExactOneElement() { var validationContext = A.Fake <IValidationContext <TestDataObject> >(); var propertyValidationContext = new PropertyValidationContext <TestDataObject, string>(x => x.StrValue, validationContext); var fault = A.Fake <IValidationFault>(); propertyValidationContext.AddFault(fault); Assert.Single((IEnumerable)propertyValidationContext.Faults); Assert.Single(propertyValidationContext.Faults, f => f == fault); }
public void AddFault_MultipleFault_FaultsMultipleElements() { var validationContext = A.Fake <IValidationContext <TestDataObject> >(); var propertyValidationContext = new PropertyValidationContext <TestDataObject, string>(x => x.StrValue, validationContext); var fault = A.Fake <IValidationFault>(); var fault1 = A.Fake <IValidationFault>(); var fault2 = A.Fake <IValidationFault>(); propertyValidationContext.AddFault(fault); propertyValidationContext.AddFault(fault1); propertyValidationContext.AddFault(fault2); Assert.Equal(new[] { fault, fault1, fault2 }, propertyValidationContext.Faults); }
public void InstanceForValidation_Get_ReturnCorrectValue() { var testData = new TestDataObject { StrValue = "Test text" }; var validationContext = A.Fake <IValidationContext <TestDataObject> >(); A.CallTo(() => validationContext.InstanceForValidation).Returns(testData); var propertyValidationContext = new PropertyValidationContext <TestDataObject, string>(x => x.StrValue, validationContext); var instanceForValidation = propertyValidationContext.InstanceForValidation; Assert.Equal(testData, instanceForValidation); }
internal static AccessTypes GetAccessType(IServiceProvider serviceProvider, PropertyValidationContext validationContext) { AccessTypes read = AccessTypes.Read; if (validationContext.Property is PropertyInfo) { return(Helpers.GetAccessType(validationContext.Property as PropertyInfo, validationContext.PropertyOwner, serviceProvider)); } if (validationContext.Property is DependencyProperty) { IDynamicPropertyTypeProvider propertyOwner = validationContext.PropertyOwner as IDynamicPropertyTypeProvider; if (propertyOwner != null) { read = propertyOwner.GetAccessType(serviceProvider, ((DependencyProperty)validationContext.Property).Name); } } return(read); }
public void PropertyValue_StrProperty_ReturnsStrValue() { var testData = new TestDataObject { StrValue = "Test text" }; var validationContext = A.Fake <IValidationContext <TestDataObject> >(); A.CallTo(() => validationContext.InstanceForValidation).Returns(testData); var propertyValidationContext = new PropertyValidationContext <TestDataObject, string>(x => x.StrValue, validationContext); var value = propertyValidationContext.PropertyValue; Assert.Equal("Test text", value); }
public IEnumerable <DataValidationError> Validate(PropertyValidationContext propertyValidationContext) { var propertyMetaData = propertyValidationContext.PropertyMetaData; foreach (var attribute in propertyMetaData.Attributes) { if (attribute is ValidationAttribute validation) { var validationContext = new ValidationContext(propertyMetaData.Container ?? propertyMetaData.Value, null, null) { MemberName = propertyMetaData.MemberName, DisplayName = propertyMetaData.DisplayName }; var result = validation.GetValidationResult(propertyMetaData.Value, validationContext); if (result != ValidationResult.Success) { yield return(new DataValidationError(propertyMetaData.MemberName, result.ErrorMessage)); } } } }
public void PropertyValue_GetStrPropertyMultipleTimes_ReturnsAlwaysTheSameResult() { var testData = new TestDataObject { StrValue = "Test text" }; var validationContext = A.Fake <IValidationContext <TestDataObject> >(); A.CallTo(() => validationContext.InstanceForValidation).Returns(testData); var propertyValidationContext = new PropertyValidationContext <TestDataObject, string>(x => x.StrValue, validationContext); var value = propertyValidationContext.PropertyValue; Assert.Equal("Test text", value); var value1 = propertyValidationContext.PropertyValue; Assert.Equal(value, value1); }
internal static ValidationErrorCollection ValidateProperty(ValidationManager manager, Activity activity, object obj, PropertyValidationContext propertyValidationContext, object extendedPropertyContext) { if (manager == null) { throw new ArgumentNullException("manager"); } if (obj == null) { throw new ArgumentNullException("obj"); } if (propertyValidationContext == null) { throw new ArgumentNullException("propertyValidationContext"); } ValidationErrorCollection errors = new ValidationErrorCollection(); manager.Context.Push(activity); manager.Context.Push(propertyValidationContext); if (extendedPropertyContext != null) { manager.Context.Push(extendedPropertyContext); } try { errors.AddRange(ValidationHelpers.ValidateObject(manager, obj)); } finally { manager.Context.Pop(); manager.Context.Pop(); if (extendedPropertyContext != null) { manager.Context.Pop(); } } return(errors); }
public override ValidationErrorCollection Validate(ValidationManager manager, object obj) { ValidationErrorCollection validationErrors = base.Validate(manager, obj); RuleSetReference ruleSetReference = obj as RuleSetReference; if (ruleSetReference == null) { string message = string.Format(CultureInfo.CurrentCulture, Messages.UnexpectedArgumentType, typeof(RuleSetReference).FullName, "obj"); throw new ArgumentException(message, "obj"); } Activity activity = manager.Context[typeof(Activity)] as Activity; if (activity == null) { string message = string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, typeof(Activity).Name); throw new InvalidOperationException(message); } PropertyValidationContext validationContext = manager.Context[typeof(PropertyValidationContext)] as PropertyValidationContext; if (validationContext == null) { string message = string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, typeof(PropertyValidationContext).Name); throw new InvalidOperationException(message); } if (!string.IsNullOrEmpty(ruleSetReference.RuleSetName)) { RuleDefinitions rules = null; RuleSetCollection ruleSetCollection = null; CompositeActivity declaringActivity = Helpers.GetDeclaringActivity(activity); if (declaringActivity == null) { declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity; } if (activity.Site != null) { rules = ConditionHelper.Load_Rules_DT(activity.Site, declaringActivity); } else { rules = ConditionHelper.Load_Rules_RT(declaringActivity); } if (rules != null) { ruleSetCollection = rules.RuleSets; } if (ruleSetCollection == null || !ruleSetCollection.Contains(ruleSetReference.RuleSetName)) { string message = string.Format(CultureInfo.CurrentCulture, Messages.RuleSetNotFound, ruleSetReference.RuleSetName); ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_RuleSetNotFound); validationError.PropertyName = GetFullPropertyName(manager) + "." + "RuleSetName"; validationErrors.Add(validationError); } else { RuleSet actualRuleSet = ruleSetCollection[ruleSetReference.RuleSetName]; ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider)); IDisposable localContextScope = (WorkflowCompilationContext.Current == null ? WorkflowCompilationContext.CreateScope(manager) : null); try { RuleValidation validation = new RuleValidation(activity, typeProvider, WorkflowCompilationContext.Current.CheckTypes); actualRuleSet.Validate(validation); ValidationErrorCollection actualRuleSetErrors = validation.Errors; if (actualRuleSetErrors.Count > 0) { string expressionPropertyName = GetFullPropertyName(manager); string genericErrorMsg = string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetExpression, expressionPropertyName); int errorNumber = ErrorNumbers.Error_InvalidRuleSetExpression; if (activity.Site != null) { foreach (ValidationError actualError in actualRuleSetErrors) { ValidationError validationError = new ValidationError(actualError.ErrorText, errorNumber); validationError.PropertyName = expressionPropertyName + "." + "RuleSet Definition"; validationErrors.Add(validationError); } } else { foreach (ValidationError actualError in actualRuleSetErrors) { ValidationError validationError = new ValidationError(genericErrorMsg + " " + actualError.ErrorText, errorNumber); validationError.PropertyName = expressionPropertyName; validationErrors.Add(validationError); } } } // } finally { if (localContextScope != null) { localContextScope.Dispose(); } } } } else { string message = string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetName, "RuleSetReference"); ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_InvalidRuleSetName); validationError.PropertyName = GetFullPropertyName(manager) + "." + "RuleSetName"; validationErrors.Add(validationError); } return(validationErrors); }
internal static ValidationErrorCollection ValidateProperty(ValidationManager manager, Activity activity, object obj, PropertyValidationContext propertyValidationContext) { return(ValidateProperty(manager, activity, obj, propertyValidationContext, null)); }