protected override VerifyResult VerifyOneImpl(VerifiableMemberContext context) { if (context is null) { return(_options.ReturnNullReferenceOrSuccess()); } // 如果 Value 为 String,对其进行验证 if (context.Value is string str) { var attr = context.GetAttributes <LengthShould16Attribute>().FirstOrDefault(); if (attr is null) { return(VerifyResult.NullReferenceWith("There's no LengthShould16Attribute on this Member.")); } if (str.Length == 16) { return(VerifyResult.Success); } return(new VerifyResult(new VerifyFailure(context.MemberName, "Length should 16.", str))); } // 否则,如果 Value 不是基础类型(即 Value 为引用类型、结构等),对其进一步解析并验证 if (!context.BasicTypeState()) { return(VerifyImpl(context.ConvertToObjectContext())); } // 否则,认为其类型不是所期待的 return(VerifyResult.UnexpectedTypeWith(context.MemberName)); }
public static bool Verify(VerifiableMemberContext context, IEnumerable <IFlagAnnotation> annotations, out VerifyFailure failure) { if (context is null) { throw new ArgumentNullException(nameof(context)); } var errors = new List <VerifyError>(); foreach (var annotation in annotations) { VerifyAnnotation(context, annotation, errors); } if (errors.Any()) { failure = new VerifyFailure(context.MemberName, $"There are multiple errors in this Member '{context.MemberName}'.", context.Value); failure.Details.AddRange(errors); } else { failure = null; } return(failure is null); }
private static void VerifyAnnotation(VerifiableMemberContext context, IFlagAnnotation annotation, List <VerifyError> errors) { switch (annotation) { #region General Annotations case VerifiableParamsAttribute attr: attr.IsValid(context) .IfFalseThenInvoke(() => CreateAndUpdateErrors(attr.ErrorMessage, attr.Name, errors)); break; #endregion #region Custom Annotations // 对自定义(或第三方)验证注解的检查 case CustomAnnotationAttribute attr: var valid = attr.IsValidInternal(context); if (!valid) { CreateAndUpdateErrors(attr.ErrorMessage, attr.Name, errors, ValidatorType.Custom); } break; #endregion } }
/// <summary> /// Verification for VerifiableMemberContext /// </summary> /// <param name="context"></param> /// <returns></returns> internal override CorrectVerifyVal Valid(VerifiableMemberContext context) { var value = GetValueFrom(context); if (!IsActivate(context, value)) { return(CorrectVerifyVal.Ignore); } var verifyVal = CreateVerifyVal(); if (context is null) { UpdateVal(verifyVal, value); } else { var regex = _regexFunc(context.GetParentInstance <T>()); if (regex is null || value is null || !regex.IsMatch((string)value)) { UpdateVal(verifyVal, value, regex?.ToString()); } } return(verifyVal); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="context"></param> /// <returns></returns> /// <exception cref="ArgumentNullException"></exception> public virtual VerifyResult VerifyOneViaContext(VerifiableMemberContext context) { if (context is null) { throw new ArgumentNullException(nameof(context)); } return(VerifyOneImpl(context)); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="declaringType"></param> /// <param name="memberValue"></param> /// <param name="memberName"></param> /// <returns></returns> public virtual VerifyResult VerifyOne(Type declaringType, object memberValue, string memberName) { var memberContract = VerifiableObjectContractManager.Resolve(declaringType)?.GetMemberContract(memberName); if (memberContract is null) { return(VerifyResult.MemberIsNotExists(memberName)); } var memberContext = VerifiableMemberContext.Create(memberValue, memberContract); return(VerifyOneImpl(memberContext)); }
/// <summary> /// Is activate, This method is only applicable to 'Verify'. /// </summary> /// <param name="context"></param> /// <param name="value"></param> /// <returns></returns> protected bool IsActivate(VerifiableMemberContext context, object value) { if (WithActivationConditions && ActivationConditions3 is not null && context.HasParentContext()) { return(ActivationConditions3.Invoke(context.GetParentInstance(), value)); } if (WithActivationConditions && ActivationConditions2 is not null) { return(ActivationConditions2.Invoke(value)); } return(true); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="declaringType"></param> /// <param name="memberValue"></param> /// <param name="memberName"></param> /// <param name="keyValueCollection"></param> /// <returns></returns> public virtual VerifyResult VerifyOneWithDictionary(Type declaringType, object memberValue, string memberName, IDictionary <string, object> keyValueCollection) { var parentContract = VerifiableObjectContractManager.Resolve(declaringType); var memberContract = parentContract?.GetMemberContract(memberName); if (memberContract is null) { return(VerifyResult.MemberIsNotExists(memberName)); } var memberContext = VerifiableMemberContext.Create(memberValue, memberContract, parentContract.WithDictionary(keyValueCollection)); return(VerifyOneImpl(memberContext)); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="declaringType"></param> /// <param name="memberValue"></param> /// <param name="memberName"></param> /// <param name="instance"></param> /// <returns></returns> VerifyResult IValidator.VerifyOneWithInstance(Type declaringType, object memberValue, string memberName, object instance) { var parentContract = VerifiableObjectContractManager.Resolve(declaringType); var memberContract = parentContract?.GetMemberContract(memberName); if (memberContract is null) { return(VerifyResult.MemberIsNotExists(memberName)); } var memberContext = VerifiableMemberContext.Create(memberValue, memberContract, parentContract.WithInstance(instance)); return(VerifyOneImpl(memberContext)); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="memberValue"></param> /// <param name="memberName"></param> /// <param name="instance"></param> /// <returns></returns> public virtual VerifyResult VerifyOneWithInstance(object memberValue, string memberName, T instance) { var parentContract = VerifiableObjectContractManager.Resolve <T>(); var memberContract = parentContract?.GetMemberContract(memberName); if (memberContract is null) { return(VerifyResult.MemberIsNotExists(memberName)); } var memberContext = VerifiableMemberContext.Create(memberValue, memberContract, parentContract.WithInstance(instance)); return(VerifyOneImpl(memberContext)); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="expression"></param> /// <param name="memberValue"></param> /// <typeparam name="TVal"></typeparam> /// <returns></returns> public virtual VerifyResult VerifyOne <TVal>(Expression <Func <T, TVal> > expression, TVal memberValue) { var memberName = PropertySelector.GetPropertyName(expression); var memberContract = VerifiableObjectContractManager.Resolve <T>()?.GetMemberContract(memberName); if (memberContract is null) { return(VerifyResult.MemberIsNotExists(memberName)); } var memberContext = VerifiableMemberContext.Create(memberValue, memberContract); return(VerifyOneImpl(memberContext)); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="declaringType"></param> /// <param name="memberValue"></param> /// <param name="memberName"></param> /// <returns></returns> VerifyResult IValidator.VerifyOne(Type declaringType, object memberValue, string memberName) { if (memberValue is null) { return(_options.ReturnNullReferenceOrSuccess()); } var memberContract = VerifiableObjectContractManager.Resolve(declaringType)?.GetMemberContract(memberName); if (memberContract is null) { return(VerifyResult.MemberIsNotExists(memberName)); } return(VerifyOneInternal(VerifiableMemberContext.Create(memberValue, memberContract))); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="expression"></param> /// <param name="memberValue"></param> /// <param name="keyValueCollection"></param> /// <typeparam name="TVal"></typeparam> /// <returns></returns> public virtual VerifyResult VerifyOneWithDictionary <TVal>(Expression <Func <T, TVal> > expression, TVal memberValue, IDictionary <string, object> keyValueCollection) { var parentContract = VerifiableObjectContractManager.Resolve <T>(); var memberName = PropertySelector.GetPropertyName(expression); var memberContract = parentContract?.GetMemberContract(memberName); if (memberContract is null) { return(VerifyResult.MemberIsNotExists(memberName)); } var memberContext = VerifiableMemberContext.Create(memberValue, memberContract, parentContract.WithDictionary(keyValueCollection)); return(VerifyOneImpl(memberContext)); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="expression"></param> /// <param name="memberValue"></param> /// <typeparam name="TVal"></typeparam> /// <returns></returns> public VerifyResult VerifyOne <TVal>(Expression <Func <T, TVal> > expression, TVal memberValue) { if (expression is null) { return(_options.ReturnNullReferenceOrSuccess()); } var memberName = PropertySelector.GetPropertyName(expression); var memberContract = VerifiableObjectContractManager.Resolve <T>()?.GetMemberContract(memberName); if (memberContract is null) { return(VerifyResult.MemberIsNotExists(memberName)); } return(VerifyOneInternal(VerifiableMemberContext.Create(memberValue, memberContract))); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="declaringType"></param> /// <param name="memberValue"></param> /// <param name="memberName"></param> /// <param name="keyValueCollection"></param> /// <returns></returns> VerifyResult IValidator.VerifyOneWithDictionary(Type declaringType, object memberValue, string memberName, IDictionary <string, object> keyValueCollection) { if (memberValue is null) { return(_options.ReturnNullReferenceOrSuccess()); } var parentContract = VerifiableObjectContractManager.Resolve(declaringType); var memberContract = parentContract?.GetMemberContract(memberName); if (memberContract is null) { return(VerifyResult.MemberIsNotExists(memberName)); } return(VerifyOneInternal(VerifiableMemberContext.Create(memberValue, memberContract, parentContract.WithDictionary(keyValueCollection)))); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="memberValue"></param> /// <param name="memberName"></param> /// <param name="instance"></param> /// <returns></returns> public VerifyResult VerifyOneWithInstance(object memberValue, string memberName, T instance) { if (memberValue is null) { return(_options.ReturnNullReferenceOrSuccess()); } var parentContract = VerifiableObjectContractManager.Resolve <T>(); var memberContract = parentContract?.GetMemberContract(memberName); if (memberContract is null) { return(VerifyResult.MemberIsNotExists(memberName)); } return(VerifyOneInternal(VerifiableMemberContext.Create(memberValue, memberContract, parentContract.WithInstance(instance)))); }
/// <summary> /// Verify a member of the entity. <br /> /// 成员验证入口 /// </summary> /// <param name="expression"></param> /// <param name="memberValue"></param> /// <param name="keyValueCollection"></param> /// <typeparam name="TVal"></typeparam> /// <returns></returns> public VerifyResult VerifyOneWithDictionary <TVal>(Expression <Func <T, TVal> > expression, TVal memberValue, IDictionary <string, object> keyValueCollection) { if (expression is null) { return(_options.ReturnNullReferenceOrSuccess()); } var parentContract = VerifiableObjectContractManager.Resolve <T>(); var memberName = PropertySelector.GetPropertyName(expression); var memberContract = parentContract?.GetMemberContract(memberName); if (memberContract is null) { return(VerifyResult.MemberIsNotExists(memberName)); } return(VerifyOneInternal(VerifiableMemberContext.Create(memberValue, memberContract, parentContract.WithDictionary(keyValueCollection)))); }
/// <summary> /// Verification for VerifiableMemberContext /// </summary> /// <param name="context"></param> /// <returns></returns> internal override CorrectVerifyVal Valid(VerifiableMemberContext context) { var value = GetValueFrom(context); if (!IsActivate(context, value)) { return(CorrectVerifyVal.Ignore); } var verifyVal = CreateVerifyVal(); if (!IsValidImpl(value)) { UpdateVal(verifyVal, value); } return(verifyVal); }
/// <summary> /// Verification for VerifiableMemberContext /// </summary> /// <param name="context"></param> /// <returns></returns> internal override CorrectVerifyVal Valid(VerifiableMemberContext context) { var value = GetValueFrom(context); if (!IsActivate(context, value)) { return(CorrectVerifyVal.Ignore); } var verifyVal = CreateVerifyVal(); if (context is not null && Types.IsCollectionType(VerifiableMember.MemberType) && value is ICollection collection) { if (!IsValidImpl(collection, _func)) { UpdateVal(verifyVal, value); } }
public static VerifyResult VerifyOne(VerifiableMemberContext context) { if (context is null) { throw new ArgumentNullException(nameof(context)); } var annotations = context.Attributes .Where(a => a.GetType().IsDerivedFrom <ValidationAttribute>()) .Select(a => a as ValidationAttribute); var errors = new List <VerifyError>(); foreach (var annotation in annotations) { if (annotation is null) { continue; } if (annotation.IsValid(context.Value)) { continue; } var error = new VerifyError { ErrorMessage = annotation.ErrorMessage, ViaValidatorType = ValidatorType.Custom, ValidatorName = $"DataAnnotation {annotation.GetType().GetFriendlyName()} Validator" }; errors.Add(error); } if (!errors.Any()) { return(VerifyResult.Success); } var failure = new VerifyFailure(context.MemberName, $"There are multiple errors in this Member '{context.MemberName}'.", context.Value); return(new VerifyResult(failure)); }
/// <summary> /// Verification for VerifiableMemberContext /// </summary> /// <param name="context"></param> /// <returns></returns> internal override CorrectVerifyVal Valid(VerifiableMemberContext context) { var value = GetValueFrom(context); if (!IsActivate(context, value)) { return(CorrectVerifyVal.Ignore); } var verifyVal = CreateVerifyVal(); if (!IsValidImpl(value, out var result)) { verifyVal.NameOfExecutedRule = result?.OperationName ?? Name; UpdateVal(verifyVal, value, result?.ErrorMessage); } return(verifyVal); }
/// <summary> /// Verification for VerifiableMemberContext /// </summary> /// <param name="context"></param> /// <returns></returns> internal override CorrectVerifyVal Valid(VerifiableMemberContext context) { var value = GetValueFrom(context); if (!IsActivate(context, value)) { return(CorrectVerifyVal.Ignore); } var verifyVal = CreateVerifyVal(); var valueToCompare = _valueToCompareFunc is null ? _valueToCompare : _valueToCompareFunc.Invoke(); if (!IsValidImpl(value, valueToCompare, _typeOfValueToCompare, out var message)) { UpdateVal(verifyVal, value, message); } return(verifyVal); }
public static bool BasicTypeState(this VerifiableMemberContext context) { if (context is null) { return(false); } switch (context.MemberKind) { case VerifiableMemberKind.CustomContract: return(context.ExposeInternalImpl().IsBasicType); case VerifiableMemberKind.Unknown: case VerifiableMemberKind.Field: case VerifiableMemberKind.Property: return(context.IsBasicType); default: return(false); } }
public static VerifyResult VerifyOne(IValidator validator, VerifiableMemberContext context, Type typeOfValidator) { var propertyValidators = validator.CreateDescriptor().GetValidatorsForMember(context.MemberName); var parentContext = FluentValidationContextFactory.Resolve(context.DeclaringType, default); var originalFailures = new List <ValidationFailure>(); var nameOfExecutedRules = new List <string>(); foreach (var propertyValidator in propertyValidators) { foreach (var rule in (IEnumerable <IValidationRule>)validator) { if (rule is PropertyRule propertyRule) { var propertyValidatorContext = new PropertyValidatorContext((ValidationContext)parentContext, propertyRule, context.MemberName, context.Value); var localFailures = propertyValidator.Validate(propertyValidatorContext); originalFailures.AddRange(localFailures); nameOfExecutedRules.AddRange(propertyRule.RuleSets); } } } if (!originalFailures.Any()) { return(VerifyResult.Success); } var failures = originalFailures.ConvertToVerifyFailures(typeOfValidator); return(new VerifyResult(failures) { NameOfExecutedRules = nameOfExecutedRules.Distinct().ToArray() }); }
private VerifyResult VerifyOneInternal(VerifiableMemberContext memberContext) { VerifyResult result1 = null, result2 = null, result3 = null; if (_projectManager.TryResolve(_type, _name, out var project)) { result1 = project.VerifyOne(memberContext); } if (_options.CustomValidatorEnabled) { result2 = CorrectEngine.ValidViaCustomValidators(memberContext, _customValidatorManager.ResolveAll()); } if (_options.AnnotationEnabled) { result3 = _annotationValidator.VerifyOne(memberContext); } if (result1 is null && result2 is null && result3 is null) { return(_options.ReturnUnregisterProjectForSuchTypeOrSuccess()); } return(result1 is null ? VerifyResult.MakeTogether(result2, result3) : VerifyResult.Merge(result1, result2, result3)); }
public static VerifyResult ValidViaCustomValidators(VerifiableMemberContext context, IEnumerable <CustomValidator> validators) { return(VerifyResult.MakeTogether(validators.Select(validator => validator.VerifyOneViaContext(context)).ToList())); }
protected override VerifyResult VerifyOneImpl(VerifiableMemberContext context) { return(FluentValidationCore.VerifyOne(_validatorImpl, context, typeof(TValidator))); }
protected abstract VerifyResult VerifyOneImpl(VerifiableMemberContext context);
/// <summary> /// Verification for VerifiableMemberContext /// </summary> /// <param name="context"></param> /// <returns></returns> internal abstract CorrectVerifyVal Valid(VerifiableMemberContext context);
public VerifyResult VerifyOne(VerifiableMemberContext context) { return(VerifyResult.Success); }