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