public void RegisterSpecificDefinitions()
{
var fc = new FluentConfiguration();
fc.Register<AddressValidationDef, Address>().Register<BooValidationDef, Boo>();
var ml = (IMappingLoader) fc;
Assert.That(ml.GetMappings().Count(), Is.EqualTo(2));
}
public void ConfigureCustomResourceManager()
{
var fc = new FluentConfiguration();
fc.SetCustomResourceManager("NHibernate.Validator.Tests.Resource.Messages", Assembly.GetExecutingAssembly());
var cfg = (INHVConfiguration)fc;
Assert.That(cfg.Properties[Environment.CustomResourceManager], Is.EqualTo("NHibernate.Validator.Tests.Resource.Messages, " + Assembly.GetExecutingAssembly().FullName));
}
static void Main(string[] args)
{
#if DEBUG
IConfiguration configuration; // = new JsonConfiguration("test.json");
if (args.Length == 1)
{
configuration = new JsonConfiguration(args[0]);
}
else
{
configuration = new FluentConfiguration(@".\db")
//.AddInput("MongoDb", "logs", "mongodb://*****:*****@"C:\PerfLogs\log-file.txt")
.AddInput("WindowsEventLog", "Application")
//.AddInput("File", "2", @"D:\log-file.txt")
//.AddFilter("RegExTimeStamp", "Type==\"File\" && Id==\"2\"", @"^[\d]{4}-[\d]{2}-[\d]{2} [\d]{2}:[\d]{2}:[\d]{2}", @"Message")
//.AddInput("SqlServer", "ServerName", "DatabaseName", "TableName", "TableId", "CurrentDate", "UserName", "Password")
.AddOutput("Console");
}
#else
IConfiguration configuration = new JsonConfiguration(args[0]);
#endif
using (EventHerder eventHerder = new EventHerder(configuration))
{
Console.WriteLine("Press ENTER to exit...");
Console.ReadLine();
}
}
public void Configure(IWindsorContainer container)
{
var ve = new ValidatorEngine();
container.Register(Component.For<IEntityValidator>()
.ImplementedBy<EntityValidator>());
container.Register(Component.For<ValidatorEngine>()
.Instance(ve)
.LifeStyle.Singleton);
//Register the service for ISharedEngineProvider
container.Register(Component.For<ISharedEngineProvider>()
.ImplementedBy<NHVSharedEngineProvider>());
//Assign the shared engine provider for NHV.
Environment.SharedEngineProvider =
container.Resolve<ISharedEngineProvider>();
//Configure validation framework fluently
var configure = new FluentConfiguration();
configure.Register(typeof (WorkerValidationDefenition).Assembly.ValidationDefinitions())
.SetDefaultValidatorMode(ValidatorMode.OverrideAttributeWithExternal)
.AddEntityTypeInspector<NHVTypeInspector>()
.IntegrateWithNHibernate.ApplyingDDLConstraints().And.RegisteringListeners();
ve.Configure(configure);
}
public void ValidateWithMultipleConditions()
{
var configure = new FluentConfiguration();
var validationDef = new ValidationDef<EntityWithString>();
validationDef.Define(e => e.Name)
.Satisfy(name => name != null && name.StartsWith("ab")).WithMessage("Name should start with 'ab'")
.And
.Satisfy(name => name != null && name.EndsWith("zz")).WithMessage("Name should end with 'zz'");
configure.Register(validationDef).SetDefaultValidatorMode(ValidatorMode.UseExternal);
var ve = new ValidatorEngine();
ve.Configure(configure);
Assert.That(ve.IsValid(new EntityWithString { Name = "abczz" }));
Assert.That(!ve.IsValid(new EntityWithString { Name = "bc" }));
var iv = ve.Validate(new EntityWithString {Name = "abc"});
Assert.That(iv.Length, Is.EqualTo(1));
Assert.That(iv.Select(i => i.Message).First(), Is.EqualTo("Name should end with 'zz'"));
iv = ve.Validate(new EntityWithString { Name = "zz" });
Assert.That(iv.Length, Is.EqualTo(1));
Assert.That(iv.Select(i => i.Message).First(), Is.EqualTo("Name should start with 'ab'"));
iv = ve.Validate(new EntityWithString { Name = "bc" });
Assert.That(iv.Length, Is.EqualTo(2));
var messages = iv.Select(i => i.Message);
Assert.That(messages, Has.Member("Name should start with 'ab'") & Has.Member("Name should end with 'zz'"));
}
public void CreateValidatorEngine()
{
var configure = new FluentConfiguration();
configure.Register(new[] {typeof (UserValidation), typeof (GroupValidation)})
.SetDefaultValidatorMode(ValidatorMode.UseExternal);
validatorEngine = new ValidatorEngine();
validatorEngine.Configure(configure);
}
public void DelegatedValidate_WithoutMessageNotThrow()
{
var configure = new FluentConfiguration();
configure.Register(new[] { typeof(RangeDefWithoutCustomMessage) })
.SetDefaultValidatorMode(ValidatorMode.UseExternal);
var ve = new ValidatorEngine();
ve.Configure(configure);
ActionAssert.NotThrow(()=>ve.IsValid(new Range { Start = 1, End = 4 }));
}
public void RegisterDefinitions()
{
var fc = new FluentConfiguration();
fc.Register(
Assembly.GetExecutingAssembly().ValidationDefinitions()
.Where(x => x.Namespace.Equals("NHibernate.Validator.Tests.Configuration.Loquacious") &&
(x.Name.StartsWith("Address") || x.Name.StartsWith("Boo"))));
var ml = (IMappingLoader)fc;
Assert.That(ml.GetMappings().Count(), Is.EqualTo(2));
}
public TypeMappingConfig(FluentConfiguration fluentConfiguration, Type type)
{
if (fluentConfiguration == null)
throw new ArgumentNullException("fluentConfiguration");
if (type == null)
throw new ArgumentNullException("type");
_configuration = fluentConfiguration;
_type = type;
_mapping = new TypeMappingInfo { Type = type, IdentityField = fluentConfiguration.IdPropertyName };
}
protected ValidatorEngine ConfigureValidator(NHibernate.Cfg.Configuration configuration)
{
var nhvc = new FluentConfiguration();
nhvc.SetDefaultValidatorMode(ValidatorMode.UseExternal).IntegrateWithNHibernate.ApplyingDDLConstraints();
nhvc.Register<PersonValidation, Person>();
nhvc.Register<NameValidation, Name>();
var engine = new ValidatorEngine();
engine.Configure(nhvc);
return engine;
}
protected override void Configure(NHibernate.Cfg.Configuration configuration)
{
base.Configure(configuration);
var nhvc = new FluentConfiguration();
nhvc.SetDefaultValidatorMode(ValidatorMode.UseAttribute).IntegrateWithNHibernate.ApplyingDDLConstraints().And.
RegisteringListeners();
var onlyToUseToInitializeNh_Engine = new ValidatorEngine();
onlyToUseToInitializeNh_Engine.Configure(nhvc);
configuration.Initialize(onlyToUseToInitializeNh_Engine);
}
public void DelegatedValidate_WithoutMessageHasInvalidValue()
{
var configure = new FluentConfiguration();
configure.Register(new[] { typeof(RangeDefWithoutCustomMessage) })
.SetDefaultValidatorMode(ValidatorMode.UseExternal);
var ve = new ValidatorEngine();
ve.Configure(configure);
var iv = ve.Validate(new Range {Start = 5, End = 4});
iv.Should().Not.Be.Empty();
}
public void Engine_Validate()
{
var configure = new FluentConfiguration();
configure.Register(new[] {typeof (RangeDef)}).SetDefaultValidatorMode(ValidatorMode.UseExternal);
var ve = new ValidatorEngine();
ve.Configure(configure);
Assert.That(!ve.IsValid(new Range { Start = 5, End = 4 }));
Assert.That(ve.IsValid(new Range { Start = 1, End = 4 }));
}
public static ValidatorEngine Get_Engine_Configured_for_Fluent()
{
var vtor = new ValidatorEngine();
var configuration = new FluentConfiguration();
configuration
.Register(Assembly.GetExecutingAssembly().GetTypes().Where(t => t.Namespace.Equals("NHibernate.Validator.Demo.Ev.Validators"))
.ValidationDefinitions())
.SetDefaultValidatorMode(ValidatorMode.UseExternal);
vtor.Configure(configuration);
return vtor;
}
public ValidatorFixtureLoquacious()
{
var configure = new FluentConfiguration();
configure.Register(
Assembly.GetExecutingAssembly().GetTypes()
.Where(t => t.Namespace.Equals("NHibernate.Validator.Tests.Base"))
.ValidationDefinitions())
.SetDefaultValidatorMode(ValidatorMode.UseExternal);
ve = new ValidatorEngine();
ve.Configure(configure);
}
public void CanInitialezeValidatorEngine()
{
var fc = new FluentConfiguration();
fc.SetDefaultValidatorMode(ValidatorMode.UseExternal)
.Register<AddressValidationDef, Address>().Register<BooValidationDef, Boo>()
.IntegrateWithNHibernate.AvoidingDDLConstraints().And.AvoidingListenersRegister();
var ve = new ValidatorEngine();
ve.Configure(fc);
Assert.That(ve.GetValidator<Address>(), Is.Not.Null);
Assert.That(ve.GetValidator<Boo>(), Is.Not.Null);
}
public override ValidatorEngine GetValidatorEngine()
{
var ve = new ValidatorEngine();
var configuration = new FluentConfiguration();
configuration
.SetConstraintValidatorFactory<TestConstraintValidatorFactory>()
.SetDefaultValidatorMode(ValidatorMode.UseExternal)
.Register(new [] { typeof(Foo) }) ;
ve.Configure(configuration);
return ve;
}
private static FluentConfiguration GetNhvConfiguration()
{
var nhvConfiguration = new FluentConfiguration();
nhvConfiguration
.SetDefaultValidatorMode(ValidatorMode.UseExternal)
.Register(Assembly.Load("Eg.ClassValidation")
.ValidationDefinitions())
.IntegrateWithNHibernate
.ApplyingDDLConstraints()
.And
.RegisteringListeners();
return nhvConfiguration;
}
public LoquaciousInheritanceFixture()
{
var configure = new FluentConfiguration();
configure.Register(
Assembly.Load("NHibernate.Validator.Tests")
.ValidationDefinitions()
.Where(t => t.Namespace.Equals("NHibernate.Validator.Tests.Inheritance"))
)
.SetDefaultValidatorMode(ValidatorMode.UseExternal);
ve = new ValidatorEngine();
ve.Configure(configure);
}
public void can_validate_legs()
{
var validationDef = new ValidationDef<Cat>();
validationDef.Define(c => c.Legs).GreaterThanOrEqualTo(2);
var vc = new FluentConfiguration();
vc.SetDefaultValidatorMode(ValidatorMode.UseExternal);
vc.Register(validationDef);
var ve = new ValidatorEngine();
ve.Configure(vc);
ve.Validate(new Cat {Legs = 0}).Should().Have.Count.EqualTo(1);
ve.Validate(new Cat {Legs = 3}).Should().Be.Empty();
}
private static void ConfigurarStringConexao <TThisConfiguration, TConnectionString>(
this FluentConfiguration configFluente,
PersistenceConfiguration <TThisConfiguration, TConnectionString> persistenceConfiguration,
bool showSql)
where TThisConfiguration : PersistenceConfiguration <TThisConfiguration, TConnectionString>
where TConnectionString : ConnectionStringBuilder, new()
{
const string connectionStringKey = "ExemploConexao";
if (showSql)
{
persistenceConfiguration.ShowSql();
}
persistenceConfiguration.ConnectionString(c => c.FromConnectionStringWithKey(connectionStringKey));
configFluente.Database(persistenceConfiguration);
}
public static FluentConfiguration CreateSQLServerSchemas(this FluentConfiguration fluentConfiguration)
{
return(fluentConfiguration.ExposeDbCommand((command, cfg) =>
{
var schemas = cfg.ClassMappings.Select(x => x.Table.Schema).Where(x => !string.IsNullOrEmpty(x))
.Distinct()
.Select(x => cfg.NamingStrategy.TableName(x))
.ToList();
foreach (var schema in schemas)
{
command.CommandText = $"IF NOT EXISTS(SELECT * FROM sys.schemas WHERE name = N'{schema}') EXEC('CREATE SCHEMA [{schema}]');";
command.ExecuteNonQuery();
}
}));
}
private static void CreateMappings(FluentConfiguration fmc)
{
(from a in AppDomain.CurrentDomain.GetAssemblies() select a into assemblies select assemblies).ToList().ForEach(a =>
{
if (a.FullName.StartsWith("_DAO"))
{
foreach (var type in a.DefinedTypes)
{
if (type.FullName.StartsWith("_DAO.Maps") && !type.FullName.StartsWith("_DAO.Maps.BaseEntityMap"))
{
fmc.Mappings(m => m.FluentMappings.Add(type));
}
}
}
});
}
private static void InitializeFromConfigMsSql(FluentConfiguration fluentConfiguration,
DbConnectionSettings settings,
Action <MsSqlConfiguration> additionalClientConfiguration = null)
{
var clientConfiguration = MsSqlConfiguration.MsSql2008.ConnectionString(c => c
.Server(settings.ServerName)
.Database(settings.DataBaseName)
.Username(settings.UserName)
.Password(settings.UserPassword));
additionalClientConfiguration?.Invoke(clientConfiguration);
fluentConfiguration.Database(clientConfiguration);
PerformCommonInitialization(fluentConfiguration, settings.ShowSql);
}
private void InitMapping(FluentConfiguration fluentConfiguration)
{
fluentConfiguration.Mappings(
x =>
{
x.AutoMappings.Add(PersistenceModelGenerator.Generate(new string[] { "NHibernateTest.exe" },
new string[] { "NHibernateTest.exe" }));
x.FluentMappings.Add <IsDeletedFilter>();
x.AutoMappings.ExportTo(@"D:\Temp");
});
//fluentConfiguration.Mappings(m => m.FluentMappings.Add<ClassesMap>());
//fluentConfiguration.Mappings(m => m.FluentMappings.Add<StudentMap>());
//fluentConfiguration.Mappings(m => m.FluentMappings.Add<CourseMap>());
}
public static FluentConfiguration RegisterDateTimeGenerators(this FluentConfiguration fluentConfiguration)
{
fluentConfiguration.ExposeConfiguration(config =>
{
config.AddSqlFunction("AddSeconds", new SQLFunctionTemplate(NHibernateUtil.DateTime, "DATEADD(second, ?2, ?1)"));
config.AddSqlFunction("AddMinutes", new SQLFunctionTemplate(NHibernateUtil.DateTime, "DATEADD(minute, ?2, ?1)"));
config.AddSqlFunction("AddHours", new SQLFunctionTemplate(NHibernateUtil.DateTime, "DATEADD(hour, ?2, ?1)"));
config.AddSqlFunction("AddDays", new SQLFunctionTemplate(NHibernateUtil.DateTime, "DATEADD(day, ?2, ?1)"));
config.AddSqlFunction("AddMonths", new SQLFunctionTemplate(NHibernateUtil.DateTime, "DATEADD(month, ?2, ?1)"));
config.AddSqlFunction("AddYears", new SQLFunctionTemplate(NHibernateUtil.DateTime, "DATEADD(year, ?2, ?1)"));
config.LinqToHqlGeneratorsRegistry <CoreSharpLinqToHqlGeneratorsRegistry>();
});
return(fluentConfiguration);
}
public void Workaround()
{
var engine = new ValidatorEngine();
var cfg = new FluentConfiguration();
cfg.Register(new[] {
typeof(SubEntityValidation),
typeof(EntityValidation) // Here is the workaround
});
cfg.SetDefaultValidatorMode(ValidatorMode.OverrideExternalWithAttribute);
engine.Configure(cfg);
InvalidValue[] errors = engine.Validate(_entity);
Assert.That(errors.Length, Is.EqualTo(3));
}
public static void IniciarNHibernate()
{
if (!Directory.Exists("C:\\temp"))
{
Directory.CreateDirectory("C:\\temp");
}
FluentConfiguration dbConfig = Fluently.Configure()
.Database(SQLiteConfiguration.Standard.UsingFile("C:\\temp\\Cadastro.db"));
NHIBERNATE_CONFIGURATION =
dbConfig.Mappings(x => x.FluentMappings.AddFromAssemblyOf <EmpresaMap>())
.Mappings(x => x.FluentMappings.AddFromAssemblyOf <FornecedorMap>())
.Mappings(x => x.FluentMappings.AddFromAssemblyOf <TelefoneMap>())
.BuildConfiguration();
}
private static void ConfigureAssemblies(ref FluentConfiguration configuration)
{
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (var attribute in assembly.GetCustomAttributes(true))
{
if (attribute is HibernatePersistenceAttribute)
{
Assembly bgmAssembly = assembly;
configuration.Mappings(m => m.FluentMappings.AddFromAssembly(bgmAssembly));
}
}
}
//configuration.Mappings(m => m.FluentMappings.AddFromAssemblyOf<Praxio.Tools.Authorization.Infra.Data.NHibernateDataAccess.Repositories.UsersRepository>());
}
public static FluentConfiguration RegisterDateTimeGenerators(this FluentConfiguration fluentConfiguration)
{
fluentConfiguration.ExposeConfiguration(config =>
{
config.AddSqlFunction("AddSeconds", new SQLFunctionTemplate(NHibernateUtil.DateTime, "?1 + (?2 * interval '1 second')"));
config.AddSqlFunction("AddMinutes", new SQLFunctionTemplate(NHibernateUtil.DateTime, "?1 + (?2 * interval '1 minute')"));
config.AddSqlFunction("AddHours", new SQLFunctionTemplate(NHibernateUtil.DateTime, "?1 + (?2 * interval '1 hour')"));
config.AddSqlFunction("AddDays", new SQLFunctionTemplate(NHibernateUtil.DateTime, "?1 + (?2 * interval '1 day')"));
config.AddSqlFunction("AddMonths", new SQLFunctionTemplate(NHibernateUtil.DateTime, "?1 + (?2 * interval '1 month')"));
config.AddSqlFunction("AddYears", new SQLFunctionTemplate(NHibernateUtil.DateTime, "?1 + (?2 * interval '1 year')"));
config.LinqToHqlGeneratorsRegistry <CoreSharpLinqToHqlGeneratorsRegistry>();
});
return(fluentConfiguration);
}
public static void Configurar()
{
string connectionString = "Data Source=SERVIDOR;Initial Catalog=BancoDeDados;User ID=Usuario;Password=Senha";
MsSqlConfiguration configuracao = MsSqlConfiguration.MsSql2012
.ConnectionString(connectionString);
FluentConfiguration fluentConfig = Fluently.Configure()
.Database(configuracao)
.Mappings(mappingConfiguration =>
{
mappingConfiguration.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly());
}).ExposeConfiguration(cfg => new SchemaUpdate(cfg).Execute(true, true));
sessionFactory = fluentConfig.BuildSessionFactory();
}
public static FluentConfiguration AddMySql(this FluentConfiguration fluentConfiguration,
IConfiguration configuration)
{
var dbConfig = configuration.GetSection("DataSources:MySQL");
fluentConfiguration.Database(MySQLConfiguration.Standard.ConnectionString(csBuilder =>
{
csBuilder.Server(dbConfig.GetSection("Host").Value)
.Database(dbConfig.GetSection("DbName").Value)
.Username(dbConfig.GetSection("User").Value)
.Password(dbConfig.GetSection("Password").Value);
})
.ShowSql()
.Dialect <MySQL5Dialect>());
return(fluentConfiguration);
}
public WhenCallingCreateSessionFactory_WithNamedConnection_MultipleTimesForTheSameConnection()
{
var fluentConfiguration = new FluentConfiguration((ISessionFactory s) =>
{
this.sessionFactoryCreatedCount++;
return(s);
});
this.sessionFactory1 = fluentConfiguration
.ForConnection("SqlConnection", new Mock <ISqlDialect>().Object, new Mock <IDbDriver>().Object)
.CreateSessionFactory();
this.sessionFactory2 = fluentConfiguration
.ForConnection("SqlConnection", new Mock <ISqlDialect>().Object, new Mock <IDbDriver>().Object)
.CreateSessionFactory();
}
public void Engine_Validate()
{
var configure = new FluentConfiguration();
configure.Register(new[] { typeof(RangeDef) }).SetDefaultValidatorMode(ValidatorMode.UseExternal);
var ve = new ValidatorEngine();
ve.Configure(configure);
Assert.That(!ve.IsValid(new Range {
Start = 5, End = 4
}));
Assert.That(ve.IsValid(new Range {
Start = 1, End = 4
}));
}
private static ISessionFactory BuildSessionFactory(string connectionString)
{
FluentConfiguration configuration = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012.ConnectionString(connectionString))
.Mappings(m => m.FluentMappings
.AddFromAssembly(Assembly.GetExecutingAssembly())
.Conventions.Add(
ForeignKey.EndsWith("ID"),
ConventionBuilder.Property
.When(criteria => criteria.Expect(x => x.Nullable, Is.Not.Set), x => x.Not.Nullable()))
.Conventions.Add <TableNameConvention>()
.Conventions.Add <HiLoConvention>()
);
return(configuration.BuildSessionFactory());
}
public static FluentConfiguration CreatePostgreSQLSchemas(this FluentConfiguration fluentConfiguration)
{
return(fluentConfiguration.ExposeDbCommand((command, cfg) =>
{
var schemas = cfg.ClassMappings.Select(x => x.Table.Schema).Where(x => !string.IsNullOrEmpty(x))
.Distinct()
.Select(x => cfg.NamingStrategy.TableName(x))
.ToList();
foreach (var schema in schemas)
{
command.CommandText = $"CREATE SCHEMA IF NOT EXISTS {schema};";
command.ExecuteNonQuery();
}
}));
}
/// <summary>
/// Пооверить структуру таблиц.
/// </summary>
/// <returns></returns>
public virtual DbContext ValidateSchema()
{
try
{
FluentConfiguration dbConfig = Configure();
NH.Cfg.Configuration config = dbConfig.BuildConfiguration();
var schema = new SchemaValidator(config);
schema.Validate();
return(new DbContext(this, dbConfig.BuildSessionFactory()));
}
catch (Exception ex)
{
throw new DatabaseException($"Некорректная структура таблиц БД: {this}.", ex);
}
}
protected override void Configure(NHibernate.Cfg.Configuration configuration)
{
var configure = new FluentConfiguration();
configure
.SetDefaultValidatorMode(ValidatorMode.UseExternal)
.IntegrateWithNHibernate
.ApplyingDDLConstraints()
.And
.RegisteringListeners();
var validatorEngine = new ValidatorEngine();
validatorEngine.Configure(configure);
configuration.Initialize(validatorEngine);
}
/// <summary>
/// Create database structure from code
/// </summary>
/// <param name="configuration">The configuration.</param>
public static void ExportSchema(this FluentConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
Configuration config = null;
configuration.ExposeConfiguration(c => config = c);
var factory = configuration.BuildSessionFactory();
var export = new SchemaExport(config);
export.Execute(false, true, false, factory.OpenSession().Connection, null);
}
public void ValidateWithSingleCondition()
{
var configure = new FluentConfiguration();
var validationDef = new ValidationDef<EntityWithString>();
validationDef.Define(e => e.Name).Satisfy(name => name != null && name.StartsWith("ab")).WithMessage(
"Name should start with 'ab'");
configure.Register(validationDef).SetDefaultValidatorMode(ValidatorMode.UseExternal);
var ve = new ValidatorEngine();
ve.Configure(configure);
Assert.That(ve.IsValid(new EntityWithString {Name = "abc"}));
Assert.That(!ve.IsValid(new EntityWithString { Name = "bc" }));
}
public void Validate()
{
var configure = new FluentConfiguration();
var validationDef = new ValidationDef<EntityWithCollection>();
validationDef.Define(e => e.Value).Satisfy(v => v != null && v.Any(e => e == "something")).WithMessage("Should contain 'something'");
configure.Register(validationDef).SetDefaultValidatorMode(ValidatorMode.UseExternal);
var ve = new ValidatorEngine();
ve.Configure(configure);
Assert.That(ve.IsValid(new EntityWithCollection { Value = new[]{"b", "something"} }));
Assert.That(!ve.IsValid(new EntityWithCollection()));
Assert.That(!ve.IsValid(new EntityWithCollection { Value = new[] { "b" } }));
}
private static IDictionary <string, ISessionFactory> LoadAllFactories()
{
var dictionary = new Dictionary <string, ISessionFactory>(2);
// Database 100 (Exact)
FluentConfiguration configuration = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012.ConnectionString(cs => cs.FromConnectionStringWithKey("db2")))
.Mappings(m => m.FluentMappings
.AddFromAssembly(Assembly.Load("DeEekhoorn.Logic"))
.Conventions.Add(
ForeignKey.EndsWith("Id"),
ConventionBuilder.Property
.When(criteria => criteria.Expect(x => x.Nullable, Is.Not.Set), x => x.Not.Nullable()))
)
.ExposeConfiguration(x =>
{
x.EventListeners.PreInsertEventListeners =
new IPreInsertEventListener[] { new EventListener() };
x.EventListeners.PreUpdateEventListeners =
new IPreUpdateEventListener[] { new EventListener() };
});
dictionary.Add("db2", configuration.BuildSessionFactory());
// Database EYEBOARD
configuration = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012.ConnectionString(cs => cs.FromConnectionStringWithKey("db1")))
.Mappings(m => m.FluentMappings
.AddFromAssembly(Assembly.Load("EyeBoard.Logic"))
.Conventions.Add(
ForeignKey.EndsWith("Id"),
ConventionBuilder.Property
.When(criteria => criteria.Expect(x => x.Nullable, Is.Not.Set), x => x.Not.Nullable()))
)
.ExposeConfiguration(x =>
{
x.EventListeners.PreInsertEventListeners =
new IPreInsertEventListener[] { new EventListener() };
x.EventListeners.PreUpdateEventListeners =
new IPreUpdateEventListener[] { new EventListener() };
});
dictionary.Add("db1", configuration.BuildSessionFactory());
return(dictionary);
}
protected virtual void ConfigureMappings(FluentConfiguration fluentConfig)
{
ConfigureFilters();
fluentConfig.Mappings(mappings =>
{
foreach (var assemblyName in options.MappingAssemblies)
{
var assembly = Assembly.Load(assemblyName);
var fluentMappingsContainer = mappings.FluentMappings.AddFromAssembly(assembly);
AddFilters(fluentMappingsContainer);
AddConventions(assembly, fluentMappingsContainer);
}
});
}
public void PropertyShouldHaveOneAuditAttributeWithNoAuditedRelation_using_field()
{
var cfg = new FluentConfiguration();
cfg.Audit <NotAuditedOwnerEntity>()
.ExcludeRelationData("RelationField");
metas = cfg.CreateMetaData(null);
var propInfo = typeof(NotAuditedOwnerEntity).GetField("RelationField");
var entMeta = metas[typeof(NotAuditedOwnerEntity)];
entMeta.MemberMetas[propInfo]
.Should().Have.Count.EqualTo(1);
var auditAttr = (AuditedAttribute)entMeta.MemberMetas[propInfo].First();
auditAttr.TargetAuditMode.Should().Be.EqualTo(RelationTargetAuditMode.NotAudited);
}
private static void InitializeFromConfigPostgreSql(FluentConfiguration fluentConfiguration,
DbConnectionSettings settings,
Action <PostgreSQLConfiguration>?additionalClientConfiguration = null)
{
var clientConfiguration = PostgreSQLConfiguration.PostgreSQL82.ConnectionString(c => c
.Host(settings.ServerName)
.Port(settings.Port ?? 5432)
.Database(settings.DataBaseName)
.Username(settings.UserName)
.Password(settings.UserPassword));
additionalClientConfiguration?.Invoke(clientConfiguration);
fluentConfiguration.Database(clientConfiguration);
PerformCommonInitialization(fluentConfiguration, settings.ShowSql);
}
private static void InitializeFromConfigOracleClient(FluentConfiguration fluentConfiguration,
DbConnectionSettings settings,
Action <OracleDataClientConfiguration>?additionalClientConfiguration = null)
{
var clientConfiguration = OracleDataClientConfiguration.Oracle10.ConnectionString(c =>
c.Server(settings.ServerName)
.Port(settings.Port ?? 1521)
.Instance(settings.DataBaseName)
.Username(settings.UserName)
.Password(settings.UserPassword));
additionalClientConfiguration?.Invoke(clientConfiguration);
fluentConfiguration.Database(clientConfiguration);
PerformCommonInitialization(fluentConfiguration, settings.ShowSql);
}
public static void StartNhibernate(FluentConfiguration instanceBuilderConfiguration, bool reloadDb = true)
{
if (reloadDb)
{
IManagerDataBase managerDataBase = new NhibernateManagerDataBase(instanceBuilderConfiguration);
if (!managerDataBase.IsExist())
{
managerDataBase.Create();
}
managerDataBase.Update();
}
SessionFactory = new NhibernateSessionFactory(instanceBuilderConfiguration);
SpecWithRepository.Repository = BuildNhibernateRepository();
}
public static ISessionFactory BuildSessionFactory(FluentConfiguration config)
{
try
{
return(config.BuildSessionFactory());
}
catch (ArgumentException x)
{
s_log.Fatal(x, "Error while building session factory");
throw;
}
catch (FluentConfigurationException x)
{
s_log.Fatal(x, "Error while building session factory");
throw;
}
}
public static FluentConfiguration ExportMappings(this FluentConfiguration fluentConfiguration, string path, bool export = true)
{
if (!export)
{
return(fluentConfiguration);
}
return(fluentConfiguration.Mappings(m =>
{
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
m.AutoMappings.ExportTo(path);
}));
}
//[Ignore]
public void GerarSchema()
{
FluentConfiguration config = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012
.ConnectionString(c => c.FromAppSetting("connectionString")).ShowSql());
foreach (var assemblyName in AppSettingsHelper.GetValue("mappingAssemblies").Split(','))
{
System.Console.WriteLine("carregando assembly " + assemblyName);
config.Mappings(x => x.FluentMappings.Conventions
.Setup(m => m.Add(AutoImport.Never()))
.AddFromAssembly(Assembly.Load(assemblyName)));
}
config.ExposeConfiguration(BuildSchema);
config.BuildSessionFactory();
}
public DbSessionProvider()
{
FluentConfiguration = Fluently.Configure();
FluentConfiguration
// 配置连接串
.Database(MySQLConfiguration.Standard.ConnectionString(db =>
db.Server("192.168.3.121")
.Database("pay")
.Username("root")
.Password("root")
))
// 配置ORM
.Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()))
.BuildConfiguration();
// 生成session factory
_sessionFactory = FluentConfiguration.BuildSessionFactory();
}
void Initialize(string connectionStringKey)
{
IPersistenceConfigurer persistenceConfigurer = null;
persistenceConfigurer = MsSqlConfiguration.MsSql2008
.UseOuterJoin()
.ConnectionString(connectionStringKey)
.FormatSql()
.ShowSql()
;
_fluentConfiguration = Fluently.Configure()
.Database(persistenceConfigurer)
.ExposeConfiguration(ConfigurePersistence)
.ProxyFactoryFactory(typeof(ProxyFactoryFactory))
.BuildConfiguration()
;
}
public void GetMemberConstraintsLoquacious()
{
var configure = new FluentConfiguration();
configure.Register(
Assembly.GetExecutingAssembly().ValidationDefinitions().Where(x=>x.Equals(typeof(AddressDef))))
.SetDefaultValidatorMode(ValidatorMode.UseExternal);
var ve = new ValidatorEngine();
ve.Configure(configure);
IClassValidator cv = ve.GetValidator<Address>();
IEnumerable<Attribute> ma = cv.GetMemberConstraints("Country");
Assert.That(ma.Count(), Is.EqualTo(2));
Assert.That(ma.Count(x => x.TypeId == (new NotNullAttribute()).TypeId), Is.EqualTo(1));
Assert.That(ma.Count(x => x.TypeId == (new LengthAttribute()).TypeId), Is.EqualTo(1));
}
public CloudflareDbSessionConfiguration()
: base()
{
FluentConfiguration = Fluently.Configure();
// 数据库连接串
//var connString = "data source=|DataDirectory|Cloudflare.db;";
var connString = ConfigurationManager.AppSettings["connStr"];
FluentConfiguration
// 配置连接串
//.Database(SQLiteConfiguration.Standard.ConnectionString(connString))
.Database(MsSqlConfiguration.MsSql2012.ConnectionString(connString))
// 配置ORM
.Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()));
// 生成session factory
SessionFactory = FluentConfiguration.BuildSessionFactory();
}
private static void AppConfigure()
{
#region Configuration Log4Net
// To see the SQLs run the application inside VisualStudio
// watching the Output window
XmlConfigurator.Configure();
//DOMConfigurator.Configure();
#endregion
#region NHibernate configuration
var conf = new Configuration();
conf.Configure();
// Validate the schema: if wrong try to create the new schema
try
{
new SchemaValidator(conf).Validate();
}
catch (HibernateException)
{
var export = new SchemaExport(conf);
export.Drop(false, true);
export.Create(false, true);
}
#endregion
#region NHibernate.Validator configuration
var validatorConf = new FluentConfiguration();
validatorConf.SetDefaultValidatorMode(ValidatorMode.UseExternal).Register(
Assembly.GetExecutingAssembly().GetTypes().Where(t => t.Namespace.Equals("plabel2.Mappings")).
ValidationDefinitions());
var validatorEngine = new ValidatorEngine();
validatorEngine.Configure(validatorConf);
#endregion
ApplicationContext.SessionFactory = conf.BuildSessionFactory();
ApplicationContext.Validator = validatorEngine;
}
public void Validate()
{
var configure = new FluentConfiguration();
var validationDef = new ValidationDef<EntityWithDate>();
validationDef.Define(e => e.Value).Satisfy(v => v.Year == DateTime.Today.Year).WithMessage("In this year");
validationDef.Define(e => e.NullValue).Satisfy(v => v.HasValue).WithMessage("HasValue");
configure.Register(validationDef).SetDefaultValidatorMode(ValidatorMode.UseExternal);
var ve = new ValidatorEngine();
ve.Configure(configure);
Assert.That(ve.IsValid(new EntityWithDate { Value = DateTime.Today, NullValue = DateTime.Today }));
Assert.That(!ve.IsValid(new EntityWithDate()));
Assert.That(!ve.IsValid(new EntityWithDate { Value = DateTime.Today }));
Assert.That(!ve.IsValid(new EntityWithDate { NullValue = DateTime.Today }));
}
public static void Initialize(global::NHibernate.Cfg.Configuration configuration)
{
XangoConfiguration xangoConfig = XangoConfigurationHelper.Get();
Configuration = new FluentConfiguration();
Configuration
.SetDefaultValidatorMode(ValidatorMode.OverrideAttributeWithExternal)
.Register(xangoConfig.ValidationAssembly
.ValidationDefinitions())
.IntegrateWithNHibernate
.ApplyingDDLConstraints()
.And
.RegisteringListeners();
var validatorEngine = new ValidatorEngine();
validatorEngine.Configure(Configuration);
new BasicSharedEngineProvider(validatorEngine,configuration).UseMe();
}
public void ValidateChangedPropertyOfProxy()
{
var validatorConf = new FluentConfiguration();
validatorConf.SetDefaultValidatorMode(ValidatorMode.UseExternal);
var vDefSimple = new ValidationDef<SimpleWithRelation>();
vDefSimple.Define(s => s.Name).MatchWith("OK");
vDefSimple.Define(s => s.Relation).IsValid();
validatorConf.Register(vDefSimple);
var vDefRelation = new ValidationDef<Relation>();
vDefRelation.Define(s => s.Description).MatchWith("OK");
validatorConf.Register(vDefRelation);
var engine = new ValidatorEngine();
engine.Configure(validatorConf);
object savedIdRelation;
// fill DB
using (ISession s = OpenSession())
using (ITransaction tx = s.BeginTransaction())
{
var relation = new Relation { Description = "OK" };
savedIdRelation = s.Save(relation);
tx.Commit();
}
using (ISession s = OpenSession())
{
var proxy = s.Load<Relation>(savedIdRelation);
proxy.Description = "no";
Assert.AreEqual(1, engine.ValidatePropertyValue(proxy, p => p.Description).Length);
Assert.DoesNotThrow(() => engine.ValidatePropertyValue(proxy, p => p.Description));
Assert.AreEqual(1, engine.ValidatePropertyValue(proxy, "Description").Length);
Assert.DoesNotThrow(() => engine.ValidatePropertyValue(proxy, "Description"));
}
CleanDb();
}
public void ValidateHasValidElementsWithProxies()
{
var validatorConf = new FluentConfiguration();
validatorConf.SetDefaultValidatorMode(ValidatorMode.UseExternal);
var vDefSimple = new ValidationDef<SimpleWithCollection>();
vDefSimple.Define(s => s.Relations).HasValidElements();
validatorConf.Register(vDefSimple);
var vDefRelation = new ValidationDef<Relation>();
vDefRelation.Define(s => s.Description).MatchWith("OK");
validatorConf.Register(vDefRelation);
var engine = new ValidatorEngine();
engine.Configure(validatorConf);
object savedIdRelation;
// fill DB
using (ISession s = OpenSession())
using (ITransaction tx = s.BeginTransaction())
{
var relation = new Relation { Description = "OK" };
savedIdRelation = s.Save(relation);
tx.Commit();
}
using (ISession s = OpenSession())
{
var proxy = s.Load<Relation>(savedIdRelation);
var simpleWithCol = new SimpleWithCollection();
simpleWithCol.Relations = new List<Relation> {proxy};
Assert.DoesNotThrow(() => engine.Validate(simpleWithCol));
proxy.Description = "No-o-k";
Assert.IsFalse(engine.IsValid(simpleWithCol));
}
CleanDb();
}
public void Minimal()
{
var fc = new FluentConfiguration();
fc.SetMessageInterpolator<MessageInterpolatorStub>()
.SetDefaultValidatorMode(ValidatorMode.OverrideExternalWithAttribute)
.IntegrateWithNHibernate.ApplyingDDLConstraints().And.RegisteringListeners();
var cfg = (INHVConfiguration) fc;
Assert.That(cfg.Properties["apply_to_ddl"], Is.EqualTo("true"));
Assert.That(cfg.Properties["autoregister_listeners"], Is.EqualTo("true"));
Assert.That(cfg.Properties["message_interpolator_class"], Is.EqualTo(typeof(MessageInterpolatorStub).AssemblyQualifiedName));
Assert.That(cfg.Properties["external_mappings_loader_class"], Is.EqualTo(typeof(FluentMappingLoader).AssemblyQualifiedName));
Assert.That(cfg.Properties["default_validator_mode"], Is.EqualTo("OverrideExternalWithAttribute".ToLowerInvariant()));
fc = new FluentConfiguration();
fc.SetMessageInterpolator<MessageInterpolatorStub>()
.SetDefaultValidatorMode(ValidatorMode.UseExternal)
.IntegrateWithNHibernate.AvoidingDDLConstraints().And.AvoidingListenersRegister();
cfg = fc;
Assert.That(cfg.Properties["apply_to_ddl"], Is.EqualTo("false"));
Assert.That(cfg.Properties["autoregister_listeners"], Is.EqualTo("false"));
Assert.That(cfg.Properties["message_interpolator_class"], Is.EqualTo(typeof(MessageInterpolatorStub).AssemblyQualifiedName));
Assert.That(cfg.Properties["external_mappings_loader_class"], Is.EqualTo(typeof(FluentMappingLoader).AssemblyQualifiedName));
Assert.That(cfg.Properties["default_validator_mode"], Is.EqualTo("UseExternal".ToLowerInvariant()));
}
