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