/// <summary>
/// Validates the specified context.
/// </summary>
/// <param name="context">The context.</param>
/// <returns>IEnumerable{ValidationFailure}.</returns>
public override IEnumerable <ValidationFailure> Validate([NotNull] PropertyValidatorContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// bail out if the property is null
if (context.PropertyValue == null || !(context.PropertyValue is T value))
{
return(Enumerable.Empty <ValidationFailure>());
}
var validator = _validatorFactory.GetValidator(value.GetType());
if (context.ParentContext.IsChildCollectionContext)
{
return(validator.Validate(context.ParentContext.CloneForChildValidator(value)).Errors);
}
var validationContext = new ValidationContext <T>(
value,
PropertyChain.FromExpression(context.Rule.Expression),
context.ParentContext.Selector
);
validationContext.SetServiceProvider(_serviceProvider);
return(validator.Validate(validationContext).Errors);
}
public void CreateTestMasterMapping(TestMasterMapping testMasterMapping)
{
var validator = validatorFactory.GetValidator <TestMasterMapping>();
validator.ValidateAndThrow(testMasterMapping);
testMasterMappingRepositry.Add(testMasterMapping);
}
void ITestMasterService.CreateTestMaster(TestMaster testMaster)
{
var validator = validatorFactory.GetValidator <TestMaster>();
validator.ValidateAndThrow(testMaster);
testMasterRepository.Add(testMaster);
}
public PublisherService(IUnitOfWork unitOfWork, IValidatorFactory validatorFactory, ILogger logger)
{
_unitOfWork = unitOfWork;
_logger = logger;
_createUpdatePublisherValidator = validatorFactory.GetValidator <CreateUpdatePublisherInput>();
_getDeletePublisherValidator = validatorFactory.GetValidator <GetDeletePublisherInput>();
}
public async Task <IOperationResult <Product> > CreateAsync(Product entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
var validator = _validatorFactory.GetValidator <CreateProductValidator>();
var validatorResult = validator.Validate(entity);
if (!validatorResult.Succeeded)
{
return(OperationResult <Product> .Failed(validatorResult.Errors.ToArray()));
}
Product repositoryResult;
var userId = _authenticationService.GetUserId();
try
{
repositoryResult = await _productRepository.CreateAsync(entity, userId);
}
catch (Exception e)
{
_logger.LogError(e, "An error occured");
return(OperationResult <Product> .Failed(new OperationError()
{
Name = "Repository",
Description = e.Message
}));
}
return(OperationResult <Product> .Success(repositoryResult));
}
public CommentService(IUnitOfWork unitOfWork, IValidatorFactory validatorFactory, ILogger logger)
{
_unitOfWork = unitOfWork;
_logger = logger;
_createUpdateCommentValidator = validatorFactory.GetValidator <CreateUpdateCommentInput>();
_getDeleteCommentValidator = validatorFactory.GetValidator <GetDeleteCommentInput>();
_getDeleteGameValidator = validatorFactory.GetValidator <GetDeleteGameInput>();
}
protected virtual IValidator CreateValidator(ModelValidatorProviderContext context)
{
if (IsValidatingProperty(context))
{
return(_ValidatorFactory.GetValidator(context.ModelMetadata.ContainerType));
}
return(_ValidatorFactory.GetValidator(context.ModelMetadata.ModelType));
}
public GameService(IUnitOfWork unitOfWork, IValidatorFactory validatorFactory, ILogger logger)
{
_unitOfWork = unitOfWork;
_logger = logger;
_createUpdateGameValidator = validatorFactory.GetValidator <CreateUpdateGameInput>();
_getDeleteGameValidator = validatorFactory.GetValidator <GetDeleteGameInput>();
_getDeleteGenreValidator = validatorFactory.GetValidator <GetDeleteGenreInput>();
_getDeletePlatformTypeValidator = validatorFactory.GetValidator <GetDeletePlatformTypeInput>();
}
public bool IsValid <T>(T item)
{
var validator = ValidatorFactory.GetValidator(typeof(T));
if (validator != null)
{
return(validator.Validate(item).IsValid);
}
return(true);
}
public TResult Query <TResult>(IQuery <TResult> query)
{
var validator = _factory.GetValidator(query.GetType());
var result = validator?.Validate(query);
if ((result != null) && !result.IsValid)
{
throw new ValidationException(result.Errors);
}
return(_inner.Query(query));
}
private void Validate <TRequest>(TRequest request)
where TRequest : ApiRequest
{
_validators
.GetValidator(request.GetType())
.ThrowIf(request);
}
public ActionResult Creation(UpdateUserViewModel user)
{
var validator = _validatorFactory.GetValidator <UpdateUserViewModel>();
var result = validator.Validate(user);
if (result.IsValid)
{
if (user.UserId != 0)
{
_userService.Update(Mapper.Map <UpdateUserViewModel, UserDto>(user));
}
else
{
_userService.Add(Mapper.Map <UpdateUserViewModel, UserDto>(user));
}
return(RedirectToAction("Index"));
}
else
{
SetErrorsInModelState(result.Errors);
InitializeDictionary(user);
return(View(user));
}
}
public void CreateValidators(ClientValidatorProviderContext context)
{
var modelType = context.ModelMetadata.ContainerType;
if (modelType != null)
{
var validator = _validatorFactory.GetValidator(modelType);
if (validator != null)
{
var descriptor = validator.CreateDescriptor();
var propertyName = context.ModelMetadata.PropertyName;
var validatorsWithRules = from rule in descriptor.GetRulesForMember(propertyName)
let propertyRule = (PropertyRule)rule
let validators = rule.Validators
where validators.Any()
from propertyValidator in validators
let modelValidatorForProperty = GetModelValidator(context, propertyRule, propertyValidator)
where modelValidatorForProperty != null
select modelValidatorForProperty;
foreach (var propVal in validatorsWithRules)
{
context.Results.Add(new ClientValidatorItem {
Validator = propVal,
IsReusable = false
});
}
}
}
}
public ReflectionBasedValidator(IValidatorFactory validatorFactory)
{
if (validatorFactory == null)
{
throw new ArgumentNullException(nameof(validatorFactory));
}
foreach (var property in typeof(T).GetProperties( ))
{
if (!property.CanRead)
{
continue;
}
var validator = validatorFactory.GetValidator(property.PropertyType);
if (validator == null)
{
continue;
}
var rule = new PropertyRule(property,
NonGenericExpression(property).Compile( ),
GenericExpression(property),
() => ValidatorOptions.Global.CascadeMode,
property.PropertyType,
typeof(T));
var adaptorType = typeof(ChildValidatorAdaptor <, >).MakeGenericType(typeof(T), property.PropertyType);
rule.AddValidator((IPropertyValidator)Activator.CreateInstance(adaptorType, validator, validator.GetType( )));
AddRule(rule);
}
}
public sealed override void OnActionExecuting(FilterContext filterContext)
{
IValidatorFactory factory = Container.Resolve <IValidatorFactory>();
foreach (KeyValuePair <Type, object> p in filterContext.ServiceArguments)
{
Type type = p.Key;
if (type.IsClass && !type.FullName.StartsWith("System.") && typeof(List <ServerFile>) != type)
{
IValidator validator = factory.GetValidator(type);
if (validator != null)
{
if (p.Value != null)
{
ValidationResult result = validator.Validate(p.Value);
if (!result.IsValid)
{
ValidationFailure error = result.Errors.First();
filterContext.Result = ValidateModel(error);
}
}
}
}
}
}
IEnumerable <Attribute> ConvertFVMetaDataToAttributes(Type type, string name)
{
var validator = factory.GetValidator(type);
if (validator == null)
{
return(Enumerable.Empty <Attribute>());
}
IEnumerable <IPropertyValidator> validators;
// if (name == null) {
//validators = validator.CreateDescriptor().GetMembersWithValidators().SelectMany(x => x);
// validators = Enumerable.Empty<IPropertyValidator>();
// }
// else {
validators = validator.CreateDescriptor().GetValidatorsForMember(name);
// }
var attributes = validators.OfType <IAttributeMetadataValidator>()
.Select(x => x.ToAttribute())
.Concat(SpecialCaseValidatorConversions(validators));
return(attributes.ToList());
}
public ValidationResult Validate <T>(T item) where T : class
{
var validator = _validatorFactory.GetValidator(item.GetType());
var result = validator.Validate(item);
return(result);
}
public virtual async Task Store <TAggregate>(TAggregate aggregate, Func <StreamState, Task> action = null) where TAggregate : IAggregate
{
var events = aggregate.DequeueUncommittedEvents();
var initialVersion = aggregate.Version - events.Count();
foreach (var @event in events)
{
initialVersion++;
var validator = _validationFactory.GetValidator(@event.GetType());
var result = validator?.Validate(new ValidationContext <IEvent>(@event));
if (result != null && !result.IsValid)
{
continue;
}
await AppendEvent <TAggregate>(aggregate.Id, @event, initialVersion, action);
foreach (var projection in projections.Where(
projection => projection.Handles.Contains(@event.GetType())))
{
projection.Handle(@event);
}
}
snapshots
.FirstOrDefault(snapshot => snapshot.Handles == typeof(TAggregate))?
.Handle(aggregate);
}
protected ValidationResult Validate(IValidatorFactory factory, Type modelType, object model)
{
IValidationContext context = new ValidationContext <object>(model);
var result = factory.GetValidator(modelType)?.Validate(context);
return(result);
}
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate <TResponse> next)
{
var typeName = request.GetType().Name;
_logger.LogInformation("----- Validating command {CommandType}", typeName);
IValidator <TRequest> validator = _validatorFactory.GetValidator <TRequest>();
if (validator != null)
{
var result = validator.Validate(request);
if (!result.IsValid)
{
var failures = result.Errors;
var sb = new StringBuilder();
if (failures.Any())
{
_logger.LogWarning("Validation errors - {CommandType} - Command: {@Command} - Errors: {@ValidationErrors}", typeName, request, failures);
failures.ToList()
.ForEach(x => sb.AppendLine(x.ErrorMessage));
throw new Exception(sb.ToString());
}
}
}
return(await next());
}
public ValidationResult Validate <T>(T entity) where T : class
{
var validator = _validatorFactory.GetValidator(entity.GetType());
var result = validator.Validate(entity);
return(result);
}
/// <inheritdoc />
public void Apply(OpenApiSchema schema, SchemaFilterContext context)
{
if (_validatorFactory == null)
{
_logger.LogWarning(0, "ValidatorFactory is not provided. Please register FluentValidation.");
return;
}
IValidator validator = null;
try
{
validator = _validatorFactory.GetValidator(context.Type);
}
catch (Exception e)
{
_logger.LogWarning(0, e, $"GetValidator for type '{context.Type}' fails.");
}
if (validator == null)
{
return;
}
ApplyRulesToSchema(schema, context, validator);
try
{
AddRulesFromIncludedValidators(schema, context, validator);
}
catch (Exception e)
{
_logger.LogWarning(0, e, $"Applying IncludeRules for type '{context.Type}' fails.");
}
}
public IEnumerable <Post> GetPosts(int limit)
{
var posts = new List <Post>();
var validator = _validatorFactory.GetValidator <Post>();
// Get ids of top stories
var ids = _httpClientWrapper.Get <List <int> >(TopStoriesUri).GetRange(0, limit);
// Load each item
for (int i = 0; i < ids.Count; i++)
{
//TODO: make this async and run in parallel
var item = _httpClientWrapper.Get <HackerNewsItem>($"{ItemBaseUrl}/{ids[i]}.json");
// Map to post - could use Automapper here but it's easier to do it manually here with the index/ranking
var post = new Post()
{
Author = item.By,
Comments = item.Descendants,
Points = item.Score,
Rank = i + 1, //Items are already sorted when we retrieve them
Title = item.Title,
Uri = item.Url
};
// Add only if pass validation
if (validator.Validate(post).IsValid)
{
posts.Add(post);
}
}
return(posts);
}
public virtual void Execute(TCommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var validator = _validatorFactory.GetValidator <TCommand>();
if (validator != null)
{
var result = validator.Validate(command);
if (result == null)
{
throw new ValidationException("Validation failed");
}
if (!result.IsValid)
{
throw new ValidationException(result.Errors);
}
}
RunCommand(command);
}
public async Task ValidateAsync <T>(T model)
{
var validator = _validatorFactory.GetValidator <T>();
await InvokePhases(validator, model, "Phase 1");
await InvokePhases(validator, model, "Phase 2");
}
private static async Task <ValidationResult> InternalValidateAsync(object model)
{
var validator = ValidatorFactory.GetValidator(model.GetType());
if (null == validator)
{
throw new InvalidOperationException("Validator for model " + model.GetType().FullName + " not found!");
}
var result = await validator.ValidateAsync(model);
if (!ValidationCache.TryGetValue(model, out var tmp))
{
ValidationCache.Add(model, result);
}
return(result);
}
private async Task ValidateEntries(CancellationToken cancellationToken = default)
{
if (_validatorFactory == null)
{
return;
}
var addedOrModifiedEntries = ChangeTracker.Entries()
.Where(x => x.State == EntityState.Added || x.State == EntityState.Modified)
.ToList();
foreach (var entry in addedOrModifiedEntries)
{
var validator = _validatorFactory.GetValidator(entry.Metadata.ClrType);
if (validator == null)
{
continue;
}
var validationContext = ValidationContext <object> .CreateWithOptions(entry.Entity, options => options.IncludeRuleSets(RuleSetNames.All));
var validationResult = await validator.ValidateAsync(validationContext, cancellationToken);
if (validationResult.IsValid == false)
{
throw new ValidationException(validationResult.Errors);
}
}
}
private void NullifyInvalidFieldAttributes(IValidatorFactory validatorFactory)
{
var validator = validatorFactory.GetValidator(GetType());
if (validator == null)
{
return;
}
var result = validator.Validate(this);
foreach (var property in GetProperties(this))
{
var attribute = EntityFieldAttribute(property);
if (attribute == null)
{
continue;
}
if (result.Errors.Any(e => e.PropertyName == property.Name))
{
property.SetValue(this, null);
}
}
}
public CorporateRegisterController(INotificationManager notificationManager, IStoreService storeService,
IMemberService memberService, IRoleManagementService roleService, ISecurityService securityService,
IValidatorFactory validatorFactory) : base(securityService)
{
_notificationManager = notificationManager;
_storeService = storeService;
_memberService = memberService;
_roleService = roleService;
_securityService = securityService;
_companyOwnerRegistrationDataValidator = validatorFactory.GetValidator <CompanyOwnerRegistrationData>();
_companyMemberRegistrationDataValidator = validatorFactory.GetValidator <CompanyMemberRegistrationData>();
_companyMemberRegistrationByInviteDataValidator = validatorFactory.GetValidator <CompanyMemberRegistrationByInviteData>();
_inviteValidator = validatorFactory.GetValidator <Invite>();
_inviteDataValidator = validatorFactory.GetValidator <InviteData>();
}
public void Validate(ActionContext actionContext, IModelValidatorProvider validatorProvider,
ValidationStateDictionary validationState, string prefix, object model)
{
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
// would model ever be null ??
if (model == null)
{
return;
}
// get our IValidator
var validator = _validatorFactory.GetValidator(model.GetType());
if (validator == null)
{
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;
}
// validate the model using Fluent Validation rules
var result = validator.Validate(model);
// add all our model errors to the modelstate
if (!string.IsNullOrEmpty(prefix))
{
prefix = prefix + ".";
}
foreach (var modelError in result.Errors)
{
// See if there's already an item in the ModelState for this key.
if (actionContext.ModelState.ContainsKey(modelError.PropertyName))
{
actionContext.ModelState[modelError.PropertyName].Errors.Clear();
}
actionContext.ModelState.AddModelError(prefix + modelError.PropertyName, modelError.ErrorMessage);
}
}
