FluentValidation和ActionFilterAttribute-在验证模型之前对其进行更新 [英] FluentValidation and ActionFilterAttribute - update model before it is validated
本文介绍了FluentValidation和ActionFilterAttribute-在验证模型之前对其进行更新的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
在我的WebAPI项目中，我正在使用FluentValidation.我通过添加在全球范围内启用它
FluentValidationModelValidatorProvider.Configure(config);在Startup.cs内部
Inside my WebAPI project I'm using FluentValidation. I'm enabling it globally by adding
FluentValidationModelValidatorProvider.Configure(config); inside Startup.cs
我添加了自定义ActionFolterAttribute，该自定义ActionFolterAttribute可以在方法内部使用模型之前对其进行更改，但是经过测试后，我发现执行顺序不正确.
I've added custom ActionFolterAttribute that is changing model before it is used inside my method, but after testing I can see that I have bad order of execution.
我希望在FluentVatiodation验证我的模型之前对其模型进行更改，但现在要在FluentVatiodation验证我的模型之后对其进行更新.
我需要它能够访问FluentVatiodation验证数据中的一些路由数据
I want my model to be changed before it is validated by FluentVatiodation, but right now it is updated after FluentVatiodation validates my model.
I need this to be able to access some route data inside FluentVatiodation validation data
以下是我的自定义属性:
Below is my custom attribute:
public class UpdateModelAttribute : ActionFilterAttribute
{
public override void OnActionExecuting(HttpActionContext actionContext)
{
if (actionContext.ActionArguments.Any())
{
var args = actionContext.ActionArguments;
var pId = args["productId"] as int?;
var model = args["newAccount"] as TestBindingModel;
if (pId.HasValue && model != null)
{
model.Id = pId.Value;
}
}
base.OnActionExecuting(actionContext);
}
}
我的带有验证器的模型:
My model with validator:
[Validator(typeof(TestBindingModelValidator))]
public class TestBindingModel
{
public int Id { get; set; }
public string Name { get; set; }
}
public class TestBindingModelValidator : AbstractValidator<TestBindingModel>
{
public TestBindingModelValidator()
{
RuleFor(u => u.Id)
.Cascade(CascadeMode.StopOnFirstFailure)
.NotEmpty().WithMessage("Id is required")
.Must(BetweenOneAndTwo).WithMessage("Id is bad");
RuleFor(u => u.Name)
.Cascade(CascadeMode.StopOnFirstFailure)
.NotEmpty().WithMessage("Name is required");
}
private bool BetweenOneAndTwo(TestBindingModel createAccountBindingModel, int id, PropertyValidatorContext context)
{
return id > 1;
}
}
我的方法:
[AllowAnonymous]
[Route("create/{productId:int?}")]
[HttpPost]
[UpdateModelAttribute]
public async Task<IHttpActionResult> CreateAccount(TestBindingModel newAccount, int productId=100)
{
if (!ModelState.IsValid)
{
return BadRequest("Invalid data");
}
Debug.WriteLine("{0} {1}", newAccount.Id, newAccount.Name);
await Task.CompletedTask;
return Ok("Works fine!");
}
我已经通过使用PostMan通过将POST发送到带有数据的URL http://localhost:63564/test/create/20来进行了检查:
I've checked this using PostMan by sending POST to URL http://localhost:63564/test/create/20 with data:
Id:1
Name:Test
内部验证程序ID的值为= 1，但在我的方法主体内部的值为20.
Inside validator Id has value=1, but inside my method body value=20.
我想更改订单并在验证器中保存更新的值.
I'd like to change that order and have that updated value inside my validator.
可以更改吗?
此处讨论了类似的事情:在FluentValidation for WebApi中访问路由数据2 和我根据问题作者的评论建立上述解决方案.
Similar thing was discussed here: Access route data in FluentValidation for WebApi 2 and I based above solution on question author comment.
推荐答案
是的，可以对其进行更改，但是您需要将通用过滤器提供程序替换为强制执行已定义顺序的过滤器提供程序.
Yes it can be changed, however you need to replace the generic filter provider with one that enforces a defined order.
webApiConfiguration.Services.Replace(typeof(System.Web.Http.Filters.IFilterProvider), new OrderedFilterProvider());
您可以按照触发它们的顺序添加过滤器，如下所示:
You can either add the filters in the order you want them fired like this:
webApiConfiguration.Filters.Add(new UpdateModelAttribute());
webApiConfiguration.Filters.Add(new ValidationActionFilter());
或设置由IOrderedFilterAttribute公开的Order属性.如果要通过配置/依赖注入或在编译时未知的其他因素来控制排序，则不妨使用此方法.
Or set the Order property exposed by IOrderedFilterAttribute. You may wish to use this method if you want to control the ordering via config/dependency injection, or some other factor not known at compile time.
OrderedFilterProvider.cs
OrderedFilterProvider.cs
/// <summary>
/// Combines Action Filters from multiple sources
/// </summary>
public class OrderedFilterProvider : IFilterProvider
{
private List<IFilterProvider> _filterProviders;
/// <summary>
/// Constructor using default filter providers
/// </summary>
public OrderedFilterProvider()
{
_filterProviders = new List<IFilterProvider>();
_filterProviders.Add(new ConfigurationFilterProvider());
_filterProviders.Add(new ActionDescriptorFilterProvider());
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="innerProviders">The inner providers.</param>
public OrderedFilterProvider(IEnumerable<IFilterProvider> innerProviders)
{
_filterProviders = innerProviders.ToList();
}
/// <summary>
/// Returns all appropriate Filters for the specified action, sorted by their Order property if they have one
/// </summary>
public IEnumerable<FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor)
{
if (configuration == null) { throw new ArgumentNullException("configuration"); }
if (actionDescriptor == null) { throw new ArgumentNullException("actionDescriptor"); }
List<OrderedFilterInfo> filters = new List<OrderedFilterInfo>();
foreach (IFilterProvider fp in _filterProviders)
{
filters.AddRange(
fp.GetFilters(configuration, actionDescriptor)
.Select(fi => new OrderedFilterInfo(fi.Instance, fi.Scope)));
}
var orderedFilters = filters.OrderBy(i => i).Select(i => i.ConvertToFilterInfo());
return orderedFilters;
}
}
要使用它，您将需要一些支持类.
And to use that, you'll need a few supporting classes.
OrderedFilterInfo.cs
OrderedFilterInfo.cs
/// <summary>
/// Our version of FilterInfo, with the ability to sort by an Order attribute. This cannot simply inherit from
/// FilterInfo in the Web API class because it's sealed :(
/// </summary>
public class OrderedFilterInfo : IComparable
{
public OrderedFilterInfo(IFilter instance, FilterScope scope)
{
if (instance == null) { throw new ArgumentNullException("instance"); }
Instance = instance;
Scope = scope;
}
/// <summary>
/// Filter this instance is about
/// </summary>
public IFilter Instance { get; private set; }
/// <summary>
/// Scope of this filter
/// </summary>
public FilterScope Scope { get; private set; }
/// <summary>
/// Allows controlled ordering of filters
/// </summary>
public int CompareTo(object obj)
{
if (obj is OrderedFilterInfo)
{
var otherfilterInfo = obj as OrderedFilterInfo;
// Global filters should be executed before Controller and Action Filters. We don't strictly have to
// do this, since it's done again in the framework, but it's a little more consistent for testing!
if (this.Scope == FilterScope.Global && otherfilterInfo.Scope != FilterScope.Global)
{
return -10;
}
else if (this.Scope != FilterScope.Global && otherfilterInfo.Scope == FilterScope.Global)
{
return 10;
}
IOrderedFilterAttribute thisAttribute = this.Instance as IOrderedFilterAttribute;
IOrderedFilterAttribute otherAttribute = otherfilterInfo.Instance as IOrderedFilterAttribute;
IFilter thisNonOrderedAttribute = this.Instance as IFilter;
IFilter otherNonOrderedAttribute = otherfilterInfo.Instance as IFilter;
if (thisAttribute != null && otherAttribute != null)
{
int value = thisAttribute.Order.CompareTo(otherAttribute.Order);
if (value == 0)
{
// If they both have the same order, sort by name instead
value = thisAttribute.GetType().FullName.CompareTo(otherAttribute.GetType().FullName);
}
return value;
}
else if (thisNonOrderedAttribute != null && otherAttribute != null)
{
return 1;
}
else if (thisAttribute != null && otherNonOrderedAttribute != null)
{
return -1;
}
{
return thisNonOrderedAttribute.GetType().FullName.CompareTo(otherNonOrderedAttribute.GetType().FullName);
}
}
else
{
throw new ArgumentException("Object is of the wrong type");
}
}
/// <summary>
/// Converts this to a FilterInfo (because FilterInfo is sealed, and we can't extend it. /sigh
/// </summary>
/// <returns></returns>
public FilterInfo ConvertToFilterInfo()
{
return new FilterInfo(Instance, Scope);
}
}
IOrderedFilterAttribute.cs:
IOrderedFilterAttribute.cs:
/// <summary>
/// Allows ordering of filter attributes
/// </summary>
public interface IOrderedFilterAttribute
{
/// <summary>
/// Order of execution for this filter
/// </summary>
int Order { get; set; }
}
BaseActionFilterAttribute.cs
BaseActionFilterAttribute.cs
public abstract class BaseActionFilterAttribute : ActionFilterAttribute, IOrderedFilterAttribute
{
/// <summary>
/// Order of execution for this filter
/// </summary>
public int Order { get; set; }
public BaseActionFilterAttribute()
{
Order = 0;
}
public BaseActionFilterAttribute(int order)
{
Order = order;
}
}
FluentValidationActionFilter.cs
FluentValidationActionFilter.cs
/// <summary>
/// A Filter which can be applied to Web API controllers or actions which runs any FluentValidation Validators
/// registered in the DependencyResolver to be run. It's not currently possible to perform this validation in the
/// standard Web API validation location, since this doesn't provide any way of instantiating Validators on a
/// per-request basis, preventing injection of Unit of Work or DbContexts, for example. ///
/// </summary>
public class FluentValidationActionFilter : BaseActionFilterAttribute
{
private static readonly List<HttpMethod> AllowedHttpMethods = new List<HttpMethod> { HttpMethod.Post, HttpMethod.Put, HttpMethod.Delete };
/// <summary>
/// Constructor
/// </summary>
/// <param name="order">Order to run this filter</param>
public FluentValidationActionFilter(int order = 1)
: base(order)
{ }
/// <summary>
/// Pick out validation errors and turn these into a suitable exception structure
/// </summary>
/// <param name="actionContext">Action Context</param>
public override void OnActionExecuting(HttpActionContext actionContext)
{
ModelStateDictionary modelState = actionContext.ModelState;
// Only perform the FluentValidation if we've not already failed validation earlier on
if (modelState.IsValid && AllowedHttpMethods.Contains(actionContext.Request.Method))
{
IDependencyScope scope = actionContext.Request.GetDependencyScope();
var mvp = scope.GetService(typeof(IFluentValidatorProvider)) as IFluentValidatorProvider;
if (mvp != null)
{
ModelMetadataProvider metadataProvider = actionContext.GetMetadataProvider();
foreach (KeyValuePair<string, object> argument in actionContext.ActionArguments)
{
if (argument.Value != null && !argument.Value.GetType().IsSimpleType())
{
ModelMetadata metadata = metadataProvider.GetMetadataForType(
() => argument.Value,
argument.Value.GetType()
);
var validationContext = new InternalValidationContext
{
MetadataProvider = metadataProvider,
ActionContext = actionContext,
ModelState = actionContext.ModelState,
Visited = new HashSet<object>(),
KeyBuilders = new Stack<IKeyBuilder>(),
RootPrefix = String.Empty,
Provider = mvp,
Scope = scope
};
ValidateNodeAndChildren(metadata, validationContext, null);
}
}
}
}
}
/// <summary>
/// Validates a single node (not including children)
/// </summary>
/// <param name="metadata">Model Metadata</param>
/// <param name="validationContext">Validation Context</param>
/// <param name="container">The container.</param>
/// <returns>True if validation passes successfully</returns>
private static bool ShallowValidate(ModelMetadata metadata, InternalValidationContext validationContext, object container)
{
bool isValid = true;
// Use the DependencyResolver to find any validators appropriate for this type
IEnumerable<IValidator> validators = validationContext.Provider.GetValidators(metadata.ModelType, validationContext.Scope);
foreach (IValidator validator in validators)
{
IValidatorSelector selector = new DefaultValidatorSelector();
var context = new ValidationContext(metadata.Model, new PropertyChain(), selector);
ValidationResult result = validator.Validate(context);
foreach (var error in result.Errors)
{
if (!validationContext.ModelState.ContainsKey(error.PropertyName))
{
validationContext.ModelState.Add(error.PropertyName, new ModelState
{
Value = new ValueProviderResult(error.AttemptedValue, error.AttemptedValue?.ToString(), CultureInfo.CurrentCulture)
});
}
validationContext.ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
isValid = false;
}
}
return isValid;
}
#region Copied from DefaultBodyModelValidator in Web API Source
private bool ValidateElements(IEnumerable model, InternalValidationContext validationContext)
{
bool isValid = true;
Type elementType = GetElementType(model.GetType());
ModelMetadata elementMetadata = validationContext.MetadataProvider.GetMetadataForType(null, elementType);
var elementScope = new ElementScope { Index = 0 };
validationContext.KeyBuilders.Push(elementScope);
foreach (object element in model)
{
elementMetadata.Model = element;
if (!ValidateNodeAndChildren(elementMetadata, validationContext, model))
{
isValid = false;
}
elementScope.Index++;
}
validationContext.KeyBuilders.Pop();
return isValid;
}
private bool ValidateNodeAndChildren(ModelMetadata metadata, InternalValidationContext validationContext, object container)
{
bool isValid = true;
object model = metadata.Model;
// Optimization: we don't need to recursively traverse the graph for null and primitive types
if (model != null && model.GetType().IsSimpleType())
{
return ShallowValidate(metadata, validationContext, container);
}
// Check to avoid infinite recursion. This can happen with cycles in an object graph.
if (validationContext.Visited.Contains(model))
{
return true;
}
validationContext.Visited.Add(model);
// Validate the children first - depth-first traversal
var enumerableModel = model as IEnumerable;
if (enumerableModel == null)
{
isValid = ValidateProperties(metadata, validationContext);
}
else
{
isValid = ValidateElements(enumerableModel, validationContext);
}
if (isValid && metadata.Model != null)
{
// Don't bother to validate this node if children failed.
isValid = ShallowValidate(metadata, validationContext, container);
}
// Pop the object so that it can be validated again in a different path
validationContext.Visited.Remove(model);
return isValid;
}
private bool ValidateProperties(ModelMetadata metadata, InternalValidationContext validationContext)
{
bool isValid = true;
var propertyScope = new PropertyScope();
validationContext.KeyBuilders.Push(propertyScope);
foreach (ModelMetadata childMetadata in validationContext.MetadataProvider.GetMetadataForProperties(
metadata.Model, GetRealModelType(metadata)))
{
propertyScope.PropertyName = childMetadata.PropertyName;
if (!ValidateNodeAndChildren(childMetadata, validationContext, metadata.Model))
{
isValid = false;
}
}
validationContext.KeyBuilders.Pop();
return isValid;
}
#endregion Copied from DefaultBodyModelValidator in Web API Source
#region Inaccessible Helper Methods from the Web API source needed by the other code here
private interface IKeyBuilder
{
string AppendTo(string prefix);
}
private static string CreateIndexModelName(string parentName, int index) => CreateIndexModelName(parentName, index.ToString(CultureInfo.InvariantCulture));
private static string CreateIndexModelName(string parentName, string index) => (parentName.Length == 0) ? $"[{index}]" : $"{parentName}[{index}]";
private static string CreatePropertyModelName(string prefix, string propertyName)
{
if (String.IsNullOrEmpty(prefix))
{
return propertyName ?? String.Empty;
}
else if (String.IsNullOrEmpty(propertyName))
{
return prefix ?? String.Empty;
}
else
{
return prefix + "." + propertyName;
}
}
private static Type GetElementType(Type type)
{
Contract.Assert(typeof(IEnumerable).IsAssignableFrom(type));
if (type.IsArray)
{
return type.GetElementType();
}
foreach (Type implementedInterface in type.GetInterfaces())
{
if (implementedInterface.IsGenericType && implementedInterface.GetGenericTypeDefinition() == typeof(IEnumerable<>))
{
return implementedInterface.GetGenericArguments()[0];
}
}
return typeof(object);
}
private Type GetRealModelType(ModelMetadata metadata)
{
Type realModelType = metadata.ModelType;
// Don't call GetType() if the model is Nullable<T>, because it will
// turn Nullable<T> into T for non-null values
if (metadata.Model != null && !metadata.ModelType.IsNullableValueType())
{
realModelType = metadata.Model.GetType();
}
return realModelType;
}
private class ElementScope : IKeyBuilder
{
public int Index { get; set; }
public string AppendTo(string prefix) => CreateIndexModelName(prefix, Index);
}
private class PropertyScope : IKeyBuilder
{
public string PropertyName { get; set; }
public string AppendTo(string prefix) => CreatePropertyModelName(prefix, PropertyName);
}
#endregion Inaccessible Helper Methods from the Web API source needed by the other code here
private class InternalValidationContext
{
public HttpActionContext ActionContext { get; set; }
public Stack<IKeyBuilder> KeyBuilders { get; set; }
public ModelMetadataProvider MetadataProvider { get; set; }
public ModelStateDictionary ModelState { get; set; }
public IFluentValidatorProvider Provider { get; set; }
public string RootPrefix { get; set; }
public IDependencyScope Scope { get; set; }
public HashSet<object> Visited { get; set; }
}
}
ValidationActionFilter.cs-实际上返回错误模型:
ValidationActionFilter.cs - this actually returns an error model:
public class ValidationActionFilter : BaseActionFilterAttribute
{
// This must run AFTER the FluentValidation filter, which runs as 0
public ValidationActionFilter() : base(1000) { }
public override void OnActionExecuting(HttpActionContext actionContext)
{
var modelState = actionContext.ModelState;
if (modelState.IsValid) return;
var errors = new ErrorModel();
foreach (KeyValuePair<string, ModelState> item in actionContext.ModelState)
{
errors.ModelErrors.AddRange(item.Value.Errors.Select(e => new ModelPropertyError
{
PropertyName = item.Key,
ErrorMessage = e.ErrorMessage
}));
}
actionContext.Response = actionContext.Request.CreateResponse(HttpStatusCode.BadRequest, errors);
}
}
IFluentValidatorProvider.cs
IFluentValidatorProvider.cs
/// <summary>
/// Provides FluentValidation validators for a type
/// </summary>
public interface IFluentValidatorProvider
{
/// <summary>
/// Provides any FluentValidation Validators appropriate for validating the specified type. These will have
/// been created within the specified Dependency Scope
/// </summary>
/// <param name="type">Model type to find validators for</param>
/// <param name="scope">Scope to create validators from</param>
/// <returns></returns>
IEnumerable<IValidator> GetValidators(Type type, IDependencyScope scope);
}
这篇关于FluentValidation和ActionFilterAttribute-在验证模型之前对其进行更新的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
