protected override void ConfigureFluentValidation( FluentValidationMvcConfiguration configuration) { base.ConfigureFluentValidation(configuration); configuration.RegisterValidatorsFromAssembly(Assembly.GetExecutingAssembly()); }
public static void RegisterValidatorsFromAssemblies(this FluentValidationMvcConfiguration builder, Func <Assembly, bool> canScan = null) { if (null == canScan) { canScan = (file) => true; } foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) { try { if (!canScan(assembly)) { continue; } builder.RegisterValidatorsFromAssembly(assembly); } catch (BadImageFormatException) { } catch (FileLoadException) { } catch (Exception) { } } }
public static void Configure(FluentValidationMvcConfiguration config) { ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure; config.RegisterValidatorsFromAssemblies(AutoMapperConfigurator.AutomapperAssemblies); config.RunDefaultMvcValidationAfterFluentValidationExecutes = false; config.ImplicitlyValidateChildProperties = false; }
public void ConfigureServices(IServiceCollection services) { services.AddLogging(builder => builder #if DEBUG .SetMinimumLevel(LogLevel.Trace) #else .SetMinimumLevel(LogLevel.Warning) #endif ); TypeDescriptorProviderGenerator.AddTypeDescriptorProviders(typeof(Schema.Deployment).Namespace, typeof(SchemaExtentions.Deployment).Namespace); services.AddFileReaderService(); services.AddBlazorFileSaver(); services.AddSingleton <IState, State>(); services.AddTransient <IValidatorFactory, ServiceProviderValidatorFactory>(); var config = new FluentValidationMvcConfiguration(); config.RegisterValidatorsFromAssemblyContaining <Startup>(); AssemblyScanner.FindValidatorsInAssemblies(config.AssembliesToRegister).ForEach(pair => { services.Add(ServiceDescriptor.Transient(pair.InterfaceType, pair.ValidatorType)); }); services.AddScoped <IAppInsights, AppInsights>(); }
static void RegisterValidators(FluentValidationMvcConfiguration conf) { Console.WriteLine("Register"); foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies().Where(a => !a.IsDynamic && a.DefinedTypes.Any(t => typeof(IRequestValidator).GetTypeInfo().IsAssignableFrom(t) && !t.IsAbstract))) { conf.RegisterValidatorsFromAssembly(assembly); } }
/// <summary> /// this method dos not modelBuilder method. this is register all dto validator for Fluent Validation Library /// </summary> /// <typeparam name="TInterFace"></typeparam> /// <param name="configuration"></param> /// <param name="assemblies"></param> public static void RegisterAllDtoValidators <TInterFace>(this FluentValidationMvcConfiguration configuration, params Assembly[] assemblies) { IEnumerable <Type> types = assemblies.SelectMany(a => a.GetExportedTypes()) .Where(c => c.IsClass && !c.IsAbstract && c.IsPublic && typeof(TInterFace).IsAssignableFrom(c)); foreach (Type type in types) { configuration.RegisterValidatorsFromAssemblyContaining(type); } }
private static void ConfigureFluentValidationMvc(FluentValidationMvcConfiguration opt, IEnumerable <Assembly> assemblies, ServiceLifetime serviceLifetime = ServiceLifetime.Scoped) { opt.RegisterValidatorsFromAssemblies(assemblies, lifetime: serviceLifetime); opt.RunDefaultMvcValidationAfterFluentValidationExecutes = false; opt.ImplicitlyValidateChildProperties = true; opt.ImplicitlyValidateRootCollectionElements = false; opt.AutomaticValidationEnabled = true; opt.ValidatorOptions.DisplayNameResolver = DisplayNameResolver.Resolve; }
private void ConfigureFluentValidation(FluentValidationMvcConfiguration cfg) { ValidatorOptions.Global.DisplayNameResolver = (type, member, expression) => { if (member == null) { return(null); } var name = member.GetCustomAttribute <DisplayNameAttribute>()?.DisplayName; return(name ?? member.Name); }; cfg.DisableDataAnnotationsValidation = true; }
private static void RegisterValidatorsFromDomain <T>(this FluentValidationMvcConfiguration config, string assemblyNameStartsWith) where T : class { if (config == null) { throw new ArgumentNullException(nameof(config)); } if (string.IsNullOrWhiteSpace(assemblyNameStartsWith)) { throw new ArgumentException("Value cannot be null or whitespace.", nameof(assemblyNameStartsWith)); } var assemblies = GetReferencedAssembliesFromType <T>(assemblyNameStartsWith); config.RegisterValidatorsFromAssemblies(assemblies); }
public void ConfigureServices(IServiceCollection services) { services.AddLogging(builder => builder #if DEBUG .SetMinimumLevel(LogLevel.Information) #else .SetMinimumLevel(LogLevel.Warning) #endif ); services.AddSingleton <IState, State>(); services.AddScoped <IAppInsights, AppInsights>(); services.AddSingleton <Updater>(); var cfg = new FluentValidationMvcConfiguration(); cfg.RegisterValidatorsFromAssemblyContaining <Startup>(); }
public static FluentValidationMvcConfiguration RegisterValidatorsFromDomain(this FluentValidationMvcConfiguration configuration) { configuration.RegisterValidatorsFromAssemblyContaining(typeof(DependencyRegistrationExtensions)); return(configuration); }
/// <summary> /// THe validation settings /// </summary> /// <param name="configuration"></param> public AspNetCoreFluentValidationConvention([CanBeNull] FluentValidationMvcConfiguration?configuration = null) { _configuration = configuration ?? new FluentValidationMvcConfiguration(); }
private static void ConfigurationExpression(FluentValidationMvcConfiguration s) { s.RegisterValidatorsFromAssemblyContaining <Startup> (); s.RunDefaultMvcValidationAfterFluentValidationExecutes = false; }
private void ConfigureValidators(FluentValidationMvcConfiguration cfg) { cfg.RegisterValidatorsFromAssemblyContaining <ApplicationValidator>(); }
public static FluentValidationMvcConfiguration Translate(this FluentValidationMvcConfiguration source) { ValidatorOptions.LanguageManager = new FluenteValidationPortugueseLanguage(); return(source); }
/// <summary> /// THe validation settings /// </summary> /// <param name="validatorConfiguration"></param> /// <param name="validationMvcConfiguration"></param> public AspNetCoreFluentValidationConvention([CanBeNull] ValidatorConfiguration?validatorConfiguration = null, FluentValidationMvcConfiguration?validationMvcConfiguration = null) { _configuration ??= validatorConfiguration ?? new ValidatorConfiguration(); _mvcConfiguration = validationMvcConfiguration ?? new FluentValidationMvcConfiguration(_configuration); }
protected virtual void ConfigureFluentValidation( FluentValidationMvcConfiguration configuration) { }
public static void ConfigureMvcFluentValidation(FluentValidationMvcConfiguration options) { options.RunDefaultMvcValidationAfterFluentValidationExecutes = false; options.AutomaticValidationEnabled = false; }
private static void SetFluentValidationConfiguration(FluentValidationMvcConfiguration options) { options.RegisterValidatorsFromAssembly(Assembly.GetExecutingAssembly()); options.RunDefaultMvcValidationAfterFluentValidationExecutes = false; options.AutomaticValidationEnabled = false; // so we can use our own exception handler }