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
}
