public Service(IStorage storage, IValidatorFactory validatorFactory) { _storage = storage; _validatorFactory = validatorFactory; _mapper = new MapperConfiguration(cfg => { cfg.AddProfile<AutoMapperProfile>(); }).CreateMapper(); }
public AccountCreator(IAuthorizationService authorizationService, IValidatorFactory validatorFactory, IAccountRepository accountRepository, ICryptographyService cryptographyService, IEmailService emailService, ISettingsProvider settingsProvider) { _authorizationService = authorizationService; _validatorFactory = validatorFactory; _accountRepository = accountRepository; _cryptographyService = cryptographyService; _emailService = emailService; }
public Service(IValidatorFactory validatorFactory) { _assembley = Assembly.Load("ServiceArch.DataProviders"); _validatorFactory = validatorFactory; _mapper = new MapperConfiguration(cfg => { cfg.AddProfile<TransferObjects.AutoMapperProfile>(); }).CreateMapper(); }
public AccountService(IAccountRepository accountRepository, IAuthorizationService authorizationService, ICryptographyService cryptographyService, IEmailService emailService, IValidatorFactory validatorFactory) { _accountRepository = accountRepository; _authorizationService = authorizationService; _cryptographyService = cryptographyService; _emailService = emailService; _validatorFactory = validatorFactory; }
public IModelValidatorFluentBuilder UseFactory(IObjectFactory objectFactory) { if (objectFactory == null) { throw new ArgumentNullException(nameof(objectFactory)); } ValidatorFactory = new ValidatorFactory(objectFactory); return this; }
protected override void Context() { AuthorizationService = MockRepository.GenerateStub<IAuthorizationService>(); ValidatorFactory = MockRepository.GenerateStub<IValidatorFactory>(); AccountRepository = MockRepository.GenerateStub<IAccountRepository>(); CryptographyService = MockRepository.GenerateStub<ICryptographyService>(); EmailService = MockRepository.GenerateStub<IEmailService>(); SettingsProvider = MockRepository.GenerateStub<ISettingsProvider>(); AccountService = new AccountService(AccountRepository, AuthorizationService, CryptographyService, EmailService, ValidatorFactory); }
protected override void Context() { AuthorizationService = MockRepository.GenerateStub<IAuthorizationService>(); CreateCustomerRequestValidator = MockRepository.GenerateStub<CreateCustomerRequestValidator>(); ValidatorFactory = MockRepository.GenerateStub<IValidatorFactory>(); ValidatorFactory.Stub(x => x.GetValidator<CreateCustomerRequest>()) .Return(CreateCustomerRequestValidator); CustomerRepository = MockRepository.GenerateStub<ICustomerRepository>(); CustomerCreator = new CustomerCreator(AuthorizationService, CreateCustomerRequestValidator, CustomerRepository); }
public CustomerController(ILogger logger, IAuthorizationService authorizationService, IValidatorFactory validatorFactory, ICustomerRepository customerRepository, IMappingEngine mappingEngine, ICustomerCreator customerCreator, IAccountRepository accountRepository) { _authorizationService = authorizationService; _validatorFactory = validatorFactory; _customerRepository = customerRepository; _mappingEngine = mappingEngine; _customerCreator = customerCreator; _accountRepository = accountRepository; _logger = logger; }
public ValidationCommandInterceptor() { _validatorFactory = new ValidatorFactory(); }
public LaboModelValidatorProvider(IValidatorFactory validatorFactory = null) { AddImplicitRequiredAttributeForValueTypes = true; ValidatorFactory = validatorFactory ?? new DefaultEntityValidatorFactory(); m_ValidationTransformerManager = ValidatorSettings.ValidationTransformerManager; }
public ConventionalModelMetadataProvider(IValidatorFactory factory) { this.factory = factory; }
public FluentValidationModelValidatorProvider(IValidatorFactory validatorFactory) { AddImplicitRequiredValidator = true; this.validatorFactory = validatorFactory; }
public DataErrorInfoBehavior(IValidatorFactory factory) { this.factory = factory; }
public GenreServiceBuilder WithDefaultFakeValidator() { IValidatorFactory _validatorFactory = A.Fake<IValidatorFactory>(); _validator = _validatorFactory; return this; }
public PhoneCall(Entity entity, ICrmService crm, IValidatorFactory validatorFactory) : base(entity, crm, validatorFactory) { }
public ValidationBehavior(IValidatorFactory validationFactory) { _validationFactory = validationFactory; }
public GenreService(IUnitOfWork unitOfWork, IValidatorFactory validatorFactory, ILogger logger) { _unitOfWork = unitOfWork; _logger = logger; _getDeleteGenreValidator = validatorFactory.GetValidator <GetDeleteGenreInput>(); }
public CellsValueValidator(IValidatorFactory validatorFactory) { this.validatorFactory = validatorFactory; }
public TestMasterService(ITestMasterRepository testMasterRepository, IUnitOfWork unitOfWork, IValidatorFactory validatorFactory) { this.validatorFactory = validatorFactory; this.testMasterRepository = testMasterRepository; this.unitOfWork = unitOfWork; }
public ParseImdbMovieAsyncCommandHandler(IValidatorFactory validatorFactory, FilmCrawlerDatabaseContext dbContext) : base(validatorFactory) { _dbContext = dbContext; }
public static bool TryValidate(this IValidatable validatable, out ValidationResult validationResult, IValidatorFactory validatorFactory = null, IServiceProvider serviceProvider = null) { validationResult = validatable.Validate(validatorFactory, serviceProvider); return(validationResult.IsValid); }
public ValidateCommandInterceptor(IValidatorFactory validatorFactory = null) { _factory = validatorFactory ?? new AttributedValidatorFactory(); }
public EditProjectValidatorFactory(IValidatorFactory fac) : base(fac) { }
public LabelRequiredTagHelper(IHtmlGenerator generator, IValidatorFactory factory) : base(generator) { _factory = factory; }
public RegisterModelBinder(ModelBinderDictionary modelbinders, IValidatorFactory validationFactory) { _modelbinders = modelbinders; _validationFactory = validationFactory; }
public static async Task <ValidationResult> ValidateAsync(this IValidatable validatable, IValidatorFactory validatorFactory = null, IServiceProvider serviceProvider = null, bool throwOnNoValidatorFound = false, bool throwOnValidationError = false) { if (validatable is null) { throw new ArgumentNullException(nameof(validatable)); } var validators = (validatorFactory ?? ValidatorFactory.DefaultFactory).GetValidators(validatable.GetType(), serviceProvider); if (validators.Any()) { var validationTasks = validators .Select(validator => validator.ValidateAsync(validatable)); var validationResults = await Task .WhenAll(validationTasks) .ConfigureAwait(false); var validationResult = validationResults .MergeValidationResults(); if (!validationResult.IsValid && throwOnValidationError) { throw validationResult.ToException(); } return(validationResult); } if (throwOnNoValidatorFound) { throw new NotSupportedException($"Validation of type {validatable.GetType()} is not supported"); } return(new ValidationResult()); }
public PlatformTypeService(IUnitOfWork unitOfWork, IValidatorFactory validatorFactory, ILogger logger) { _unitOfWork = unitOfWork; _logger = logger; _getDeletePlatformTypeValidator = validatorFactory.GetValidator <GetDeletePlatformTypeInput>(); }
public GearboxCommandFunctionality(IUnitOfWork unitOfWork, IMapperFactory mapperFactory, IGenericWriteRepository writeRepository, IValidatorFactory validatorFactory) : base(unitOfWork, mapperFactory, writeRepository, validatorFactory) { }
private IValidator BuildCollectionValidator(string prefix, ModelMetadata collectionMetadata, IValidatorFactory validatorFactory) { var elementValidator = validatorFactory.GetValidator(collectionMetadata.ElementType); if (elementValidator == null) { return(null); } var type = typeof(MvcCollectionValidator <>).MakeGenericType(collectionMetadata.ElementType); var validator = (IValidator)Activator.CreateInstance(type, elementValidator, prefix); return(validator); }
public ValidatorBehavior(IValidatorFactory validatorFactory) { this.validatorFactory = validatorFactory; }
public ValidationMessageMutator(IValidatorFactory validatorFactory) { _validatorFactory = validatorFactory; }
public AuthService(IUnitOfWork unitOfWork, IValidatorFactory validatorFactory) : base(unitOfWork, validatorFactory) { }
public FluentValidationModelValidatorProvider(IValidatorFactory validatorFactory) { ValidatorFactory = validatorFactory; }
public ValidationCommandInterceptor(IValidatorFactory validatorFactory) { _validatorFactory = validatorFactory; }
public CustomModelMetadataProvider(IValidatorFactory factory) { _factory = factory; }
public FluentValidationModelValidatorProvider(IValidatorFactory validatorFactory = null) { ValidatorFactory = validatorFactory ?? new AttributedValidatorFactory(); }
/// <summary> /// Creates a validator for the specified model type. /// </summary> /// <typeparam name="T">The type of the model to validate.</typeparam> /// <param name="factory">The <see cref="IValidatorFactory"/>.</param> /// <returns>A new instance of <see cref="IValidator{T}"/>.</returns> /// <exception cref="ArgumentNullException">Argument <paramref name="factory"/> must not be <c>null</c>.</exception> public static IValidator <T> CreateValidator <T>(this IValidatorFactory factory) { return(new Validator <T>(factory)); }
public ValidationMiddleware(ILogger <Program> logger, IValidatorFactory validatorFactory) { _logger = logger; _validatorFactory = validatorFactory; }
public FluentValidationViewOptionsSetup(IValidatorFactory factory, Action <FluentValidationClientModelValidatorProvider> action) { _factory = factory; _action = action; }
/// <summary> /// Configures the labo model validator provider and adds to the mvc model validator providers. /// </summary> /// <param name="validatorFactory">The validator factory.</param> /// <param name="configurationAction">The configuration action.</param> public static void Configure(IValidatorFactory validatorFactory = null, Action<LaboModelValidatorProvider> configurationAction = null) { configurationAction = configurationAction ?? delegate { }; LaboModelValidatorProvider provider = new LaboModelValidatorProvider(validatorFactory); configurationAction(provider); DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false; ModelValidatorProviders.Providers.Add(provider); }
public ExtendedFluentValidationModelValidatorProvider(IValidatorFactory validatorFactory) { this.validatorFactory = validatorFactory; }
public EditCommentValidatorFactory(IValidatorFactory validatorFactory) : base(validatorFactory) { }
public FluentValidationModelMetadataProvider(IValidatorFactory factory) { this.factory = factory; }
public CommandHandler(IDbContextScopeFactory scopeFactory, IValidatorFactory validatorFactory) { _scopeFactory = scopeFactory; _validatorFactory = validatorFactory; }
public FluentValidationModelBinder(IValidatorFactory validatorFactory) : base(validatorFactory, new IgnoreDataAnnotationsModelBinder()) { }
public ApplicationPersistenceManager(ApplicationDbContext dbContext, IHttpContextAccessor accessor, IValidatorFactory factory, IStringLocalizer <Global> l) : base(dbContext, accessor, factory, l) { }
public FluentValidationModelBinderDecorator(IValidatorFactory validatorFactory, IModelBinder wrappedBinder) { this.validatorFactory = validatorFactory; this.wrappedBinder = wrappedBinder; }
public EventStore(IStore store, IValidatorFactory validationFactory) { _store = store; _validationFactory = validationFactory; }
public DynamicValidationModelBinder(IValidatorFactory validatorFactory) { Argument.ExpectNotNull(() => validatorFactory); _validatorFactory = validatorFactory; }
public ValidationEngine(IPackageBinary packageBinary, IDerivationStrategyFactory derivationStrategyFactory, IMerkleStrategyFactory merkleStrategyFactory, IHashAlgorithmFactory hashAlgorithmFactory, TrustSchemaValidationOptions options, IValidatorFactory validatorFactory) { _packageBinary = packageBinary; _derivationStrategyFactory = derivationStrategyFactory; _merkleStrategyFactory = merkleStrategyFactory; _hashAlgorithmFactory = hashAlgorithmFactory; _options = options; _validatorFactory = validatorFactory; }
public FluentValidationModelBinder(IValidatorFactory validatorFactory) : base(validatorFactory, new DefaultModelBinder()) { }
public PackageSchemaValidator(IDerivationStrategyFactory derivationServiceFactory, IMerkleStrategyFactory merkleStrategyFactory, IHashAlgorithmFactory hashAlgorithmFactory, IPackageBinary packageBinary, IValidatorFactory validatorFactory) { _derivationServiceFactory = derivationServiceFactory; _merkleStrategyFactory = merkleStrategyFactory; _hashAlgorithmFactory = hashAlgorithmFactory; _packageBinary = packageBinary; _validatorFactory = validatorFactory; }
/// <summary>Initializes a new instance of the FluentValidation.Mvc.FluentValidationModelValidatorProvider class.</summary> /// /// <param name="validatorFactory">The validator factory.</param> public FluentValidationModelValidatorProvider(IValidatorFactory validatorFactory = null) { AddImplicitRequiredValidator = true; ValidatorFactory = validatorFactory ?? new AttributedValidatorFactory(); }
public ValidationBusinessRule(IValidatorFactory validatorFactory, IApiResultService apiResultService) { this.validatorFactory = validatorFactory; this.apiResultService = apiResultService; }
public ChoosePasswordViewModel(IValidatorFactory validatorFactory) { this.validatorFactory = validatorFactory; }
/* * private IModelValidatorProvider GetModelValidatorProvider(IValidatorFactory validatorFactory, CustomizeValidatorAttribute customizations) { * var modelValidatorProvider = ImplicitlyValidateChildProperties ? new FluentValidationModelValidatorProvider(validatorFactory, customizations, _validatorProvider) : (IModelValidatorProvider) _validatorProvider; * return modelValidatorProvider; * } */ protected virtual void RunDefaultValidation(ActionContext actionContext, IModelValidatorProvider validatorProvider, ValidationStateDictionary validationState, string prefix, object model, ModelMetadata metadata, bool implicitlyValidateChildPropertiesUsingFluentValidation, IValidatorFactory factory, CustomizeValidatorAttribute customizations) { ValidationVisitor visitor; // if (ImplicitlyValidateChildProperties) { // visitor = new CustomValidationVisitor(actionContext, validatorProvider, _validatorCache, _modelMetadataProvider, validationState, factory, customizations); // } // else { visitor = new ValidationVisitor( actionContext, validatorProvider, _validatorCache, _modelMetadataProvider, validationState); // } visitor.Validate(metadata, prefix, model); }