Handle(TRequest request, System.Threading.CancellationToken cancellationToken, MediatR.RequestHandlerDelegate <TResponse> next) { if (Validators.Any()) { var context = new FluentValidation.ValidationContext <TRequest>(request); var validationResults = await System.Threading.Tasks.Task.WhenAll (Validators.Select(v => v.ValidateAsync(context, cancellationToken))); var failures = validationResults .SelectMany(current => current.Errors) .Where(current => current != null) .ToList() ; if (failures.Count != 0) { throw new FluentValidation.ValidationException(errors: failures); } } return(await next()); }
protected override bool PreValidate(FluentValidation.ValidationContext <StudentTransportation> context, FluentValidation.Results.ValidationResult result) { if (context.InstanceToValidate == null) { result.Errors.Add(new ValidationFailure("", "Please ensure a model was supplied.")); return(false); } var instance = context.InstanceToValidate; var failures = new List <ValidationFailure>(); // ----------------------- // Validate unified keys // ----------------------- // Recursively invoke the child collection item validators if (failures.Any()) { foreach (var failure in failures) { result.Errors.Add(failure); } return(false); } return(true); }
public IEnumerable <ModelValidationResult> Validate(ModelValidationContext mvContext) { var selector = _customizations.ToValidatorSelector(); var interceptor = _customizations.GetInterceptor() ?? _validator as IValidatorInterceptor; var context = new FluentValidation.ValidationContext(mvContext.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)mvContext.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)mvContext.ActionContext, context, result) ?? result; } return(result.Errors.Select(x => new ModelValidationResult(x.PropertyName, x.ErrorMessage))); }
public IEnumerable <ModelValidationResult> Validate(ModelValidationContext mvContext) { // Skip validation if model is null or the model has been marked for skipping. if (mvContext.Model == null || ShouldSkip(mvContext)) { return(Enumerable.Empty <ModelValidationResult>()); } var factory = mvContext.ActionContext.HttpContext.RequestServices.GetService(typeof(IValidatorFactory)) as IValidatorFactory; if (factory != null) { var validator = factory.GetValidator(mvContext.ModelMetadata.ModelType); if (validator != null) { var customizations = GetCustomizations(mvContext.ActionContext, mvContext.Model); if (customizations.Skip) { return(Enumerable.Empty <ModelValidationResult>()); } if (mvContext.Container != null) { var containerCustomizations = GetCustomizations(mvContext.ActionContext, mvContext.Container); if (containerCustomizations.Skip) { return(Enumerable.Empty <ModelValidationResult>()); } } var selector = customizations.ToValidatorSelector(); var interceptor = customizations.GetInterceptor() ?? (validator as IValidatorInterceptor); var context = new FluentValidation.ValidationContext(mvContext.Model, new FluentValidation.Internal.PropertyChain(), selector); context.RootContextData["InvokedByMvc"] = true; 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)mvContext.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)mvContext.ActionContext, context, result) ?? result; } return(result.Errors.Select(x => new ModelValidationResult(x.PropertyName, x.ErrorMessage))); } } return(Enumerable.Empty <ModelValidationResult>()); }
public static bool CheckCourse(IRepository repository, FluentValidation.ValidationContext <ManagementDto> validationContext, ValidationResult validationResult) { var course = repository.GetLastByFilter <Course>(x => x.Id == validationContext.InstanceToValidate.ClassId); if (course == null) { validationResult.Errors.Add(new ValidationFailure("ClassId", "The Course with this id was not found!")); return(false); } return(true); }
public static bool CheckQuestion(IRepository repository, FluentValidation.ValidationContext <AnswerDto> validationContext, ValidationResult validationResult) { var course = repository.GetLastByFilter <Question>(x => x.Id == validationContext.InstanceToValidate.QuestionId); if (course == null) { validationResult.Errors.Add(new ValidationFailure("QuestionId", "The Question with this id was not found!")); return(false); } return(true); }
public override IEnumerable <ModelValidationResult> Validate(ModelMetadata metadata, object container) { if (metadata.Model != null) { var customizations = Customizations ?? new CustomizeValidatorAttribute(); if (customizations.Skip) { return(Enumerable.Empty <ModelValidationResult>()); } var selector = customizations.ToValidatorSelector(); var interceptor = customizations.GetInterceptor() ?? (_validator as IValidatorInterceptor); var context = new FluentValidation.ValidationContext(metadata.Model, new FluentValidation.Internal.PropertyChain(), selector); context.RootContextData["InvokedByWebApi"] = true; 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(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(ActionContext, context, result) ?? result; } if (!result.IsValid) { return(ConvertValidationResultToModelValidationResults(result)); } } return(Enumerable.Empty <ModelValidationResult>()); }
public ValidationResult AfterMvcValidation(ControllerContext controllerContext, ValidationContext validationContext, ValidationResult result) { return(new ValidationResult()); //empty errors }
public ValidationContext BeforeMvcValidation(ControllerContext controllerContext, ValidationContext validationContext) { return(validationContext); }
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 MemberNameValidatorSelector(properties)); return(newContext); }
public ValidationContext BeforeMvcValidation(HttpActionContext cc, ValidationContext context) { return(null); }
public ValidationContext BeforeMvcValidation(HttpActionContext cc, ValidationContext context) { var newContext = context.Clone(selector: new FluentValidation.Internal.MemberNameValidatorSelector(properties)); return(newContext); }
public override bool ShouldValidateAsync(FluentValidation.ValidationContext context) { return(context.IsAsync()); }
public void Validate(ActionContext actionContext, ValidationStateDictionary validationState, string prefix, object model) { if (actionContext == null) { throw new ArgumentNullException(nameof(actionContext)); } var validatorFactory = (IValidatorFactory)actionContext.HttpContext.RequestServices.GetService(typeof(IValidatorFactory)); IValidator validator = null; var metadata = model == null ? null : _modelMetadataProvider.GetMetadataForType(model.GetType()); var prependPrefix = true; if (model != null) { validator = validatorFactory.GetValidator(metadata.ModelType); if (validator == null && metadata.IsCollectionType) { validator = BuildCollectionValidator(prefix, metadata, validatorFactory); prependPrefix = false; } } if (validator == null) { // Use default impl if FV doesn't have a validator for the type. RunDefaultValidation(actionContext, _validatorProvider, validationState, prefix, model, metadata, ImplicitlyValidateChildProperties, validatorFactory, new CustomizeValidatorAttribute()); return; } 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 + "."; } var keysProcessed = new HashSet <string>(); //First pass: Clear out any model errors for these properties generated by MVC. foreach (var modelError in result.Errors) { var 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) && !keysProcessed.Contains(key)) { actionContext.ModelState[key].Errors.Clear(); } keysProcessed.Add(key); actionContext.ModelState.AddModelError(key, modelError.ErrorMessage); } // Now allow the default MVC validation to run. if (RunDefaultMvcValidation) { RunDefaultValidation(actionContext, _validatorProvider, validationState, prefix, model, metadata, ImplicitlyValidateChildProperties, validatorFactory, customizations); } HandleIValidatableObject(actionContext, prefix, model, prependPrefix); }
public ValidationResult AfterMvcValidation(HttpActionContext cc, ValidationContext context, ValidationResult result) { return(new ValidationResult()); }