public IEnumerable <ValidationResult> Validate(FluentValidation.ValidationContext validationContext) { var validator = new SkillDtoValidator(); var result = validator.Validate(this); return(result.Errors.Select(item => new ValidationResult(item.ErrorMessage, new[] { item.PropertyName }))); }
//1. [Required] //2. Other attributes //3. IValidatableObject Implementation public IEnumerable <ValidationResult> Validate(object o) { var attributeValidationContext = new System.ComponentModel.DataAnnotations.ValidationContext(o, _serviceProvider, new Dictionary <object, object>()); var validationResults = new List <ValidationResult>(); var isValid = Validator.TryValidateObject( attributeValidationContext.ObjectInstance, attributeValidationContext, validationResults, validateAllProperties: true); // if true [Required] + Other attributes var attributeValidationResults = validationResults.Where(r => r != ValidationResult.Success); var fluentValidationContext = new FluentValidation.ValidationContext(o); var fluentValidationFailures = _validators .Select(v => v.Validate(fluentValidationContext)) .SelectMany(result => result.Errors) .Where(f => f != null) .ToList(); var fluentValidationResults = fluentValidationFailures.Select(f => new ValidationResult(f.ErrorMessage, new string[] { f.PropertyName })); return(attributeValidationResults.Concat(fluentValidationResults)); }
/// <summary> /// 获取对象的某一项属性错误 /// </summary> /// <param name="obj">待校验的对象</param> /// <param name="propertyName">待校验的属性名</param> /// <param name="validator">FluentValidation验证器</param> /// <returns>错误信息</returns> public static ValidationResult GetPropertyErrorMsg(object obj, string propertyName, IValidator validator = null) { if (string.IsNullOrWhiteSpace(propertyName) || obj == null) { return(new ValidationResult(string.Empty)); } if (validator != null) { var context = new ValidationContext(obj, null, new MemberNameValidatorSelector(new[] { propertyName })); var result = validator.Validate(context); var error = result.Errors.FirstOrDefault(x => x.PropertyName.Equals(propertyName))?.ErrorMessage; if (!string.IsNullOrEmpty(error)) { return(new ValidationResult(error)); } } var vc = new System.ComponentModel.DataAnnotations.ValidationContext(obj, null, null) { MemberName = propertyName }; var res = new List <ValidationResult>(); Validator.TryValidateProperty(obj.GetType().GetProperty(propertyName)?.GetValue(obj, null), vc, res); if (res.Any()) { return(new ValidationResult(string.Join(Environment.NewLine, res.Select(r => r.ErrorMessage).ToArray()))); } return(new ValidationResult(string.Empty)); }
private ValidationResult GetValidationResult(IBaseRequest request) { if (request == null) { return(new ValidationResult(new[] { new ValidationFailure("Request", "Request cannot be null") })); } var context = new ValidationContext(request); return(this.validators .Where(x => x.CanValidateInstancesOfType(request.GetType())) .Select(v => v.Validate(context)) .FirstOrDefault()); }
public Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var context = new ValidationContext(request); var failures = _validators.Select(x => x.Validate(context)) .SelectMany(x => x.Errors) .Where(x => x != null); if (failures.Any()) { throw new ValidationException(failures); } return(next()); }
public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next) { if (_validators.Any()) { var context = new FluentValidation.ValidationContext(request); var validationResults = await Task.WhenAll(_validators.Select(v => v.ValidateAsync(context, cancellationToken))); var failures = validationResults.SelectMany(r => r.Errors).Where(f => f != null).ToList(); if (failures.Count != 0) throw new Exceptions.ValidationException(failures); } return await next(); }
public Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var context = new ValidationContext(request); var failures = _validators .Select(v => v.Validate(context)) .SelectMany(result => result.Errors) .Where(f => f != null) .ToList(); if (failures.Count != 0) { throw new ValidationException(failures); } return(next()); }
public async Task <Unit> Handle(AddCategoryCommand request, CancellationToken cancellationToken) { var context = new FluentValidation.ValidationContext(request); var failures = validators .Select(x => x.Validate(context)) .SelectMany(x => x.Errors) .Where(x => x != null) .ToList(); if (failures.Count > 0) { throw new FluentValidation.ValidationException(failures); } categoryRepository.Add(new Domain.Products.Category(request.Name)); return(await Task.FromResult <Unit>(Unit.Value)); }
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next) { var context = new ValidationContext(request); var errorResponse = new Error.ErrorResponse(); foreach (var validation in _validators) { var validationResponse = await validation.ValidateAsync(context); foreach (var error in validationResponse.Errors) { errorResponse.AddError(error.ErrorMessage); } } errorResponse.ThrowIfErrors(); return(await next()); }
private ICollection <ValidationResult> PerformValidation(ValidationContext validationContext) { // Don't do any processing if there are no FluentValidation validators if (_validators == null || _validators.Length == 0) { return(EmptyValidationResults); } var objectType = validationContext.InstanceToValidate.GetType(); // Run all registered fluent validators that can validate the specified type using the supplied rule set name var fluentValidationResults = GetValidators(objectType) .Select(x => x.Validate(validationContext)); // Combine and adapt the results to DataAnnotation's ValidationResult var validationResults = fluentValidationResults .SelectMany(x => x.Errors.Select(e => new ValidationResult(e.ErrorMessage))); return(validationResults.ToList()); }
/// <summary> /// 获取对象的某一项属性错误 /// </summary> /// <typeparam name="T">对象类型</typeparam> /// <param name="obj">待校验的对象</param> /// <param name="propertyName">待校验的属性名</param> /// <param name="validator">FluentValidation验证器</param> /// <returns></returns> public static ValidationResult GetPropertyErrorMsg <T>(T obj, string propertyName, IValidator <T> validator) { if (validator == null) { throw new ArgumentNullException(nameof(validator)); } if (string.IsNullOrWhiteSpace(propertyName) || obj == null) { return(new ValidationResult(string.Empty)); } var context = new ValidationContext(obj, null, new MemberNameValidatorSelector(new[] { propertyName })); var result = validator.Validate(context); var error = result.Errors.FirstOrDefault(x => x.PropertyName.Equals(propertyName))?.ErrorMessage; if (!string.IsNullOrEmpty(error)) { return(new ValidationResult(error)); } return(new ValidationResult(string.Empty)); }
public ValidationResult AfterMvcValidation(ControllerContext cc, ValidationContext context, ValidationResult result) { return(new ValidationResult()); }
public ValidationContext BeforeMvcValidation(ControllerContext cc, ValidationContext context) { return(null); }
public ValidationContext BeforeMvcValidation(ControllerContext cc, ValidationContext context) { var newContext = context.Clone(selector: new FluentValidation.Internal.MemberNameValidatorSelector(properties)); return(newContext); }
public ValidationContext BeforeMvcValidation(ControllerContext controllerContext, ValidationContext validationContext) { return(validationContext); }
public ValidationResult AfterMvcValidation(ControllerContext controllerContext, ValidationContext validationContext, ValidationResult result) { return(new ValidationResult()); //empty errors }
public void Validate(ActionContext actionContext, ValidationStateDictionary validationState, string prefix, object model) { if (actionContext == null) { throw new ArgumentNullException(nameof(actionContext)); } IValidator validator = null; var metadata = model == null ? null : _modelMetadataProvider.GetMetadataForType(model.GetType()); bool prependPrefix = true; if (model != null) { if (metadata.IsCollectionType) { validator = BuildCollectionValidator(prefix, metadata); prependPrefix = false; } else { validator = _validatorFactory.GetValidator(metadata.ModelType); } } if (validator == null) { // Use default impl if FV doesn't have a validator for the type. var visitor = new ValidationVisitor( actionContext, _validatorProvider, _validatorCache, _modelMetadataProvider, validationState); visitor.Validate(metadata, prefix, model); return; } foreach (var value in actionContext.ModelState.Values .Where(v => v.ValidationState == ModelValidationState.Unvalidated)) { // Set all unvalidated states to valid. If we end up adding an error below then that properties state // will become ModelValidationState.Invalid and will set ModelState.IsValid to false value.ValidationState = ModelValidationState.Valid; } var customizations = GetCustomizations(actionContext, model.GetType(), prefix); var selector = customizations.ToValidatorSelector(); var interceptor = customizations.GetInterceptor() ?? (validator as IValidatorInterceptor); var context = new FluentValidation.ValidationContext(model, new FluentValidation.Internal.PropertyChain(), selector); if (interceptor != null) { // Allow the user to provide a customized context // However, if they return null then just use the original context. context = interceptor.BeforeMvcValidation((ControllerContext)actionContext, context) ?? context; } var result = validator.Validate(context); if (interceptor != null) { // allow the user to provice a custom collection of failures, which could be empty. // However, if they return null then use the original collection of failures. result = interceptor.AfterMvcValidation((ControllerContext)actionContext, context, result) ?? result; } if (!string.IsNullOrEmpty(prefix)) { prefix = prefix + "."; } foreach (var modelError in result.Errors) { string key = modelError.PropertyName; if (prependPrefix) { key = prefix + key; } else { key = key.Replace(ModelKeyPrefix, string.Empty); } // See if there's already an item in the ModelState for this key. if (actionContext.ModelState.ContainsKey(key)) { actionContext.ModelState[key].Errors.Clear(); } actionContext.ModelState.AddModelError(key, modelError.ErrorMessage); } // Otherwise: /* * */ }