private FluentConfiguration buildFluentConfiguration()
{
return(Fluently.Configure()
.Database(_persistenceConfigurer)
.Mappings(_mappingConfig.GetMappings()));
}
public static void PerformDefaultConfiguration()
{
Fluently.Configure()
.WithConnectionFactory(new TempDbConnectionFactory(_db))
.WithEntitiesFrom(typeof(TestQueryExecution).Assembly);
}
static ISessionFactory CreateSessionFactory(
IConfiguration configuration,
IEnumerable <Assembly> assemblies)
{
var database = new Database();
configuration.GetSection("database").Bind(database);
var db = Fluently.Configure();
switch (database.Type)
{
case "MSSQL":
// Notice, version 2012
db = db.Database(MsSqlConfiguration.MsSql2012.ConnectionString(database.Connection));
break;
case "MySQL":
db = db.Database(MySQLConfiguration.Standard.ConnectionString(database.Connection));
break;
case "SQLIte":
db = db.Database(SQLiteConfiguration.Standard.ConnectionString(database.Connection));
break;
// Specific versions of MS SQL
case "MsSql7":
db = db.Database(MsSqlConfiguration.MsSql7.ConnectionString(database.Connection));
break;
case "MsSql2008":
db = db.Database(MsSqlConfiguration.MsSql2008.ConnectionString(database.Connection));
break;
case "MsSql2005":
db = db.Database(MsSqlConfiguration.MsSql2005.ConnectionString(database.Connection));
break;
case "MsSql2000":
db = db.Database(MsSqlConfiguration.MsSql2000.ConnectionString(database.Connection));
break;
default:
throw new ConfigurationErrorsException($"The database type of '{database.Type}' is unsupported.");
}
return(db.Mappings((m) =>
{
foreach (var idxAsm in assemblies)
{
m.FluentMappings.AddFromAssembly(idxAsm);
}
}).ExposeConfiguration(cfg => new SchemaUpdate(cfg).Execute(true, true)).BuildSessionFactory());
// WARNING: The above line of code will automatically generate your database schema. This is probably NOT something you want in a production environment!
/*
* The above "ExposeConfiguration(cfg => new SchemaUpdate(cfg).Execute(true, true))" code will automatically create your database schema.
* In a production environment, you would probably not want your code to automatically do this, since it modifies your database schema,
* and might have dangerous side-effects if not done correctly.
*
* NOTICE!
* If you build the project in "Release" configuration, the database schema will NOT be automatically modified!
*/
}
private static ISessionFactory InitializeSessionFactory(string dbType, string dbVersion, string connString, bool showSql, IList <Type> mappings,
Action <NHibernate.Cfg.Configuration> configuration)
{
var fluentConfiguration = Fluently.Configure();
IPersistenceConfigurer dbConfig = null;
switch (dbType.ToLowerInvariant())
{
case "mssql":
if (showSql)
{
dbConfig = MsSqlConfiguration.MsSql2012.ConnectionString(connString).ShowSql();
}
else
{
dbConfig = MsSqlConfiguration.MsSql2012.ConnectionString(connString);
}
break;
case "oracle10":
if (showSql)
{
dbConfig = OracleDataClientConfiguration.Oracle10.ConnectionString(connString).ShowSql();
}
else
{
dbConfig = OracleDataClientConfiguration.Oracle10.ConnectionString(connString);
}
break;
case "oracle9":
if (showSql)
{
dbConfig = OracleDataClientConfiguration.Oracle9.ConnectionString(connString).ShowSql();
}
else
{
dbConfig = OracleDataClientConfiguration.Oracle9.ConnectionString(connString);
}
break;
}
fluentConfiguration.Mappings(m =>
{
foreach (var sessionOptionsMapping in mappings)
{
m.FluentMappings.Add(sessionOptionsMapping);
}
});
fluentConfiguration.Database(dbConfig);
fluentConfiguration.CurrentSessionContext("web");
if (configuration != null)
{
fluentConfiguration.ExposeConfiguration(configuration);
}
ConfigureAssemblies(ref fluentConfiguration);
return(fluentConfiguration.BuildSessionFactory());
}
protected override global::NHibernate.ISessionFactory InitializeFactory()
{
return(Fluently.Configure().Database(MsSqlConfiguration.MsSql2012
.ConnectionString(p => p.FromConnectionStringWithKey("NorthwindContext")))
.Mappings(p => p.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly())).BuildSessionFactory());
}
private static FluentConfiguration CreateConfiguration()
{
return(Fluently.Configure()
.InitializeFromConfigSqLite("Test.sqlite", true)
.AddMappingsFromAssemblyOf <UserMap>(PrimaryKey.Name.Is(x => "ID"), ForeignKeyConstraintNameConvention.WithConstraintNameConvention()));
}
public static void InitializeStorage()
{
if (!string.IsNullOrEmpty(Preferences.StorageUsername))
{
// if (null != Preferences.StorageUsername && string.Empty != Preferences.StorageUsername) {
Preferences.StorageConnectionString =
//@"Data Source=" +
@"Server=" +
Preferences.StorageServer +
//";Initial Catalog=" +
";Database=" +
Preferences.StorageDatabase +
";Username="******";Password="******";";
}
else
{
Preferences.StorageConnectionString =
//@"Data Source=" +
@"Server=" +
Preferences.StorageServer +
//";Initial Catalog=" +
";Database=" +
Preferences.StorageDatabase +
";Integrated Security=SSPI;";
}
try {
// cmdlet.WriteVerbose("building configuration...");
if (null == Fluently.Configure())
{
Console.WriteLine("Fluently == null");
}
Console.WriteLine("Fluently != null");
Fluently.Configure();
// .Database(MsSqlConfiguration
// .MsSql2008
// //.ConnectionString(Preferences.StorageConnectionString))
// //.ConnectionString(x => x.Is(connString)))
// .ConnectionString(x => x.Is(Preferences.StorageConnectionString)))
// //.Mappings(m => m.FluentMappings.AddFromAssemblyOf<ProductMap>())
// .Mappings(m => m.FluentMappings
// .AddFromAssemblyOf<TestSuiteMap>())
// //.AddFromAssemblyOf<System.Object>())
// .ExposeConfiguration(CreateSchema)
// .BuildConfiguration();
// cmdlet.WriteVerbose("creating session factory...");
SessionFactory = Fluently.Configure()
.Database(MsSqlConfiguration
.MsSql2008
.ConnectionString(Preferences.StorageConnectionString))
.Mappings(m => m.FluentMappings
//.AddFromAssembly(Assembly.GetExecutingAssembly()))
.AddFromAssemblyOf <TestSuiteMap>())
//.AddFromAssemblyOf<System.Object>())
.BuildSessionFactory();
// cmdlet.WriteVerbose("session factory has been created...");
}
catch (Exception eSession) {
// 20140720
// cmdlet.WriteError(
// cmdlet,
// eSession.InnerException.Message,
// "SessionFailed",
// ErrorCategory.InvalidOperation,
// true);
throw new Exception(
eSession.InnerException.Message);
}
}
//var listOfEntityMap = typeof(M).Assembly.GetTypes().Where(t => t.GetInterfaces().Contains(typeof(M))).ToList();
//var sessionFactory = SessionFactoryBuilder.BuildSessionFactory(dbmsTypeAsString, connectionStringName, listOfEntityMap, withLog, create, update);
public static ISessionFactory BuildSessionFactory(string connectionString, bool create = false, bool update = false)
{
return(Fluently.Configure().Database(MsSqlConfiguration.MsSql2012.ConnectionString(connectionString))
//.Mappings(m => entityMappingTypes.ForEach(e => { m.FluentMappings.Add(e); }))
.Mappings(m => m.FluentMappings.AddFromAssemblyOf <NHibernate.Cfg.Mappings>()).CurrentSessionContext("call").ExposeConfiguration(cfg => BuildSchema(cfg, create, update)).BuildSessionFactory());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
// Register the Swagger generator, defining 1 or more Swagger documents
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info
{
Title = "GRID 3.0 API",
Version = "v1",
License = new License
{
Name = "Simpat Tech",
Url = "https://simpat.tech/"
}
});
var security = new Dictionary <string, IEnumerable <string> >
{
{ "Bearer", new string[] { } },
};
c.AddSecurityDefinition("Bearer", new ApiKeyScheme
{
Description = "JWT Authorization header using the Bearer scheme. Example: \"Authorization: Bearer {token}\"",
Name = "Authorization",
In = "header",
Type = "apiKey"
});
c.AddSecurityRequirement(security);
});
services.Configure <JwtSettings>(Configuration.GetSection("JwtSettings"));
services.AddMediatR();
services.AddAutoMapper();
services.AddSingleton(provider =>
{
return(Fluently
.Configure()
.Database(() =>
{
return FluentNHibernate.Cfg.Db.MsSqlConfiguration
.MsSql2012
.ShowSql()
.ConnectionString(ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString);
})
.Mappings(m => m.FluentMappings.AddFromAssemblyOf <PersistentObjectMap>())
.BuildSessionFactory());
});
services.AddScoped(provider =>
provider
.GetService <NHibernate.ISessionFactory>()
.OpenSession()
);
var sharedKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration.GetSection("JwtSettings")["JwtKey"]));
var issuerAudience = Configuration.GetSection("JwtSettings")["Domain"];
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
ValidateIssuer = true,
ValidateAudience = true,
ValidIssuer = issuerAudience,
ValidAudience = issuerAudience,
IssuerSigningKey = sharedKey
};
});
services.AddHttpContextAccessor();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}
protected override ISessionFactory InitializeFactory()
{
return(Fluently.Configure().Database(MsSqlConfiguration.MsSql2012
.ConnectionString(c => c.Username("NorthwindContext")))
.Mappings(t => t.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly())).BuildSessionFactory());
}
public FluentConfiguration GetFluentConfiguration()
{
return(Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2008.ConnectionString(GetConnectionString())));
}
private static FluentConfiguration CreateConfiguration()
{
return(Fluently.Configure()
.Database(SQLiteConfiguration.Standard.ConnectionString(c => c.Is("Data Source=WeatherStation.db")))
.Mappings(x => x.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly())));
}
public static void SetupAutoMapperForEntities(IPersistenceConfigurer database, IDependencyResolver dependencyResolver, params Assembly[] assemblies)
{
var config = Fluently.Configure().Database(database)
.Cache(cache => cache.UseQueryCache().ProviderClass <SysCacheProvider>().QueryCacheFactory <ProjectionEnabledQueryCacheFactory>())
.ProxyFactoryFactory(typeof(DefaultProxyFactoryFactory))
.CurrentSessionContext(CurrentSessionContextClass);
var stringPropertyconvention = ConventionBuilder.Property.When(x => x.Expect(p => p.Property.PropertyType == typeof(string)), a => a.Length(255));
var cacheConvention = ConventionBuilder.Class.Always(c => c.Cache.ReadWrite());
var collectionsConventionMany = ConventionBuilder.HasMany.When(
x => x.Expect(p => !(p.Member is DummyPropertyInfo)),
instance => { instance.Cascade.SaveUpdate(); instance.Cache.ReadWrite(); });
var collectionsConventionManyToMany = ConventionBuilder.HasManyToMany.When(
x => x.Expect(p => !(p.Member is DummyPropertyInfo)),
instance => { instance.Cascade.SaveUpdate(); instance.Cache.ReadWrite(); });
var lazyConvention = ConventionBuilder.Reference.Always(c => c.LazyLoad());
IEnumerable <Assembly> ass;
if (assemblies == null || assemblies.Length == 0)
{
ass = AppDomain.CurrentDomain.GetAssemblies().Where(
a => !a.FullName.StartsWith("System.") &&
!a.FullName.StartsWith("Microsoft.") &&
!a.FullName.Contains("mscorlib") &&
a != typeof(ISession).Assembly &&
a != typeof(AutoMap).Assembly
);
}
else
{
ass = assemblies;
}
var autoPersistenceModel = new AutoPersistenceModel()
.Conventions.Add(cacheConvention, collectionsConventionMany, collectionsConventionManyToMany, stringPropertyconvention, lazyConvention)
.IgnoreBase(typeof(BaseEntity <>))
.IgnoreBase(typeof(IBaseEntity));
foreach (var assembly in ass)
{
try
{
assembly.GetExportedTypes();
}
catch (NotSupportedException)
{
continue;//cannot do dynamic assemblies
}
if (assembly != null)
{
Assembly automapper = assembly;
config.Mappings(m => m.HbmMappings.AddFromAssembly(automapper));
autoPersistenceModel
.AddEntityAssembly(automapper)
.Conventions.AddAssembly(automapper)
.Alterations(alterations => alterations.AddFromAssembly(automapper))
.Alterations(collection => collection.Add(new AutoMappingOverrideAlteration(automapper))) //same as: UseOverridesFromAssemblyOf<Tentity>()
.Where(t => typeof(IBaseEntity).IsAssignableFrom(t));
// MORE Evil hack, since adding to the Alterations does NOT work.
//new AutoMappingOverrideAlteration(automapper).Alter(autoPersistenceModel);
}
}
// Evil hack, since adding to the Alterations does NOT work.
//foreach (var overrideAssembly in ass)
//{
// new AutoMappingOverrideAlteration(overrideAssembly).Alter(autoPersistenceModel);
//}
config.Mappings(m => m.AutoMappings.Add(autoPersistenceModel)
#if DEBUG
.ExportTo(@"C:\temp\")
#endif
);
var nhconfig = config.BuildConfiguration();
var sessionFactory = nhconfig.BuildSessionFactory();
//dependencyResolver.RegisterInstance<Configuration>(nhconfig);
dependencyResolver.RegisterInstance <ISessionFactory>(sessionFactory);
new SchemaUpdate(nhconfig).Execute(true, true);
}
public static global::NHibernate.Cfg.Configuration CreateConfiguration(SupportedNHDrivers nhDriver, string connectionString, Assembly fluentMappingsAssembly, bool showSql, bool enablePostCommitListener, string sessionContext, bool outputNhMappings, bool useNhProfiler, out NhConfigurationCacheKey configurationCacheKey, string connReleaseMode)
{
Mandate.ParameterNotNullOrEmpty(connectionString, "connectionString");
Mandate.ParameterNotNull(fluentMappingsAssembly, "fluentMappingsAssembly");
Mandate.ParameterCondition(nhDriver != SupportedNHDrivers.Unknown, "nhDriver");
configurationCacheKey = new NhConfigurationCacheKey(
nhDriver,
connectionString,
fluentMappingsAssembly,
showSql,
enablePostCommitListener,
sessionContext,
outputNhMappings);
return(ConfigurationCache.GetOrAdd(
configurationCacheKey,
y =>
{
using (new WriteLockDisposable(MappingLocker))
{
if (useNhProfiler)
{
try
{
NHibernateProfiler.Initialize();
}
catch (InvalidOperationException ex)
{
//swallow security exceptions, happens if running in Medium trust
if (!(ex.InnerException is SecurityException))
{
throw ex;
}
}
}
// Check if we already have a serialized Configuration object
// for this assembly version and assembly last-write date
using (new WriteLockDisposable(ConfigCacheLocker))
if (ConfigCacheFileExists(connectionString))
{
var cachedConfig = DeserializeConfig(connectionString);
if (cachedConfig != null)
{
return cachedConfig;
}
}
// We haven't cached config before, or couldn't load it, so dynamically create it
// Figure out the FluentNH persistence configurer based on the desired driver
var persistenceConfigurer = GetPersistenceConfigurer(nhDriver, connectionString);
// Figure out the connection release mode to use, because SqlCe needs "on_close" for perf reasons,
// whereas we should use "auto" for everything else to avoid long-running connections
var trueConnReleaseMode = connReleaseMode; // Could have been set already by a unit test
if (connReleaseMode == NHibernateConfigBuilder.CustomConnReleaseMode) // Only modify if it's a value teling us to modify
{
if (nhDriver == SupportedNHDrivers.MsSqlCe4)
{
trueConnReleaseMode = "on_close";
}
else
{
trueConnReleaseMode = "auto";
}
}
// Configure NH using FluentNH
var fluentConfig = Fluently.Configure().Database(persistenceConfigurer)
//.Cache(x =>
// x.UseMinimalPuts()
// .UseQueryCache()
// .UseSecondLevelCache()
// .ProviderClass(typeof(global::NHibernate.Caches.SysCache2.SysCacheProvider).AssemblyQualifiedName))
// after_transaction does not work for unit tests with Sqlite
.ExposeConfiguration(c => c.SetProperty(Environment.ReleaseConnections, trueConnReleaseMode)
.SetProperty(Environment.CurrentSessionContextClass, sessionContext)
.SetProperty(Environment.GenerateStatistics, useNhProfiler.ToString().ToLower())
.SetProperty(Environment.BatchSize, "20")
.SetProperty(Environment.ProxyFactoryFactoryClass, typeof(ProxyFactoryFactory).AssemblyQualifiedName))
.Mappings(x =>
{
// Add named queries from our embedded mappings file
x.HbmMappings.AddFromAssembly(fluentMappingsAssembly);
// Add class mappings
var container = x.FluentMappings.AddFromAssembly(fluentMappingsAssembly);
AddConventions(nhDriver, container.Conventions);
});
if (showSql)
{
fluentConfig.ExposeConfiguration(c => c.SetProperty(Environment.ShowSql, "true"));
}
try
{
// Generate the NHibernate configuration object from FluentNH
var nhConfig = fluentConfig.BuildConfiguration();
// Add a PostCommitInsert listener which is responsible for passing generated IDs back to the
// mapped entities for entity insert scenarios (since the NH mapped objects aren't passed outside
// of this provider)
if (enablePostCommitListener)
{
var entitySaveEventListener = new NhEventListeners();
nhConfig.SetListener(ListenerType.PostInsert, entitySaveEventListener);
nhConfig.SetListener(ListenerType.PostUpdate, entitySaveEventListener);
nhConfig.SetListener(ListenerType.PostCommitInsert, entitySaveEventListener);
nhConfig.SetListener(ListenerType.PreDelete, entitySaveEventListener);
nhConfig.SetListener(ListenerType.Delete, entitySaveEventListener);
nhConfig.SetListener(ListenerType.Merge, entitySaveEventListener);
nhConfig.SetListener(ListenerType.SaveUpdate, entitySaveEventListener);
nhConfig.SetListener(ListenerType.Flush, entitySaveEventListener);
nhConfig.SetListener(ListenerType.Evict, entitySaveEventListener);
nhConfig.SetListener(ListenerType.PreDelete, entitySaveEventListener);
}
// Add the Aggregate interceptor for running trigger-like actions that NH can't handle
// Disabled, done by event listener instead now: nhConfig.SetInterceptor(new AggregateDataInterceptor());
// Add the FluentNH persistence model and configure NH to use it
var fluentAutoModel = new AutoPersistenceModel();
fluentAutoModel.AddMappingsFromAssembly(fluentMappingsAssembly);
fluentAutoModel.BuildMappings();
fluentAutoModel.Configure(nhConfig);
if (outputNhMappings)
{
var codeBase = Assembly.GetExecutingAssembly().CodeBase;
var uri = new Uri(codeBase);
var path = uri.LocalPath;
var binFolder = new DirectoryInfo(Path.GetDirectoryName(path));
string nhibernateOutputFolder;
if (binFolder.Name == "Debug")
{
nhibernateOutputFolder = Path.Combine(
binFolder.Parent.Parent.FullName, "App_Data", "Logs", "NHibernateConfig");
}
else
{
//its just 'bin'
nhibernateOutputFolder = Path.Combine(
binFolder.Parent.FullName, "App_Data", "Logs", "NHibernateConfig");
}
Directory.CreateDirectory(nhibernateOutputFolder);
fluentAutoModel.WriteMappingsTo(nhibernateOutputFolder);
}
SaveConfigurationToFile(nhConfig, connectionString);
return nhConfig;
}
catch (Exception ex)
{
throw new InvalidOperationException("Cannot build NHibernate configuration", ex);
}
}
}));
}
public void ConfigurationExtensions_InitializeFromConfig_InitializedCorrectly()
{
Fluently.Configure().InitializeFromConfigSqLiteInMemory(true);
Fluently.Configure().InitializeFromConfigSqLiteInMemory(true, c => c.Dialect <SQLiteDialect>());
}
public static ISession GetConnection <T>(string Server, string DataBase, string Usuario, string Password)
{
string _connection_provider = string.Empty;
string _dialect = string.Empty;
string _connection_driver = string.Empty;
string _connection_connection_string = "Server=[SERVER];DataBase=[DATABASE];uid=[USER];pwd=[PASSWORD]";
string _show_sql = "false";
string _showSql = string.Empty;
string _generateStatistics = string.Empty;
NHibernate.Cfg.Configuration nhibernateConfig = new NHibernate.Cfg.Configuration();
_connection_connection_string = _connection_connection_string.Replace("[SERVER]", Server);
_connection_connection_string = _connection_connection_string.Replace("[DATABASE]", DataBase);
_connection_connection_string = _connection_connection_string.Replace("[USER]", Usuario);
_connection_connection_string = _connection_connection_string.Replace("[PASSWORD]", Password);
_dialect = ConfigurationManager.AppSettings["dialect"];
_connection_driver = ConfigurationManager.AppSettings["connectionDriver"];
_showSql = ConfigurationManager.AppSettings["showSql"];
_generateStatistics = ConfigurationManager.AppSettings["generateStatistics"];
if (!string.IsNullOrEmpty(_showSql))
{
_show_sql = _showSql;
}
if (string.IsNullOrEmpty(_generateStatistics))
{
_generateStatistics = "false";
}
if (string.IsNullOrEmpty(_dialect))
{
throw new Exception("The dialect has not been established");
}
nhibernateConfig.Properties[NHibernate.Cfg.Environment.Dialect] = _dialect;
nhibernateConfig.Properties[NHibernate.Cfg.Environment.ConnectionString] = _connection_connection_string;
nhibernateConfig.Properties[NHibernate.Cfg.Environment.GenerateStatistics] = _generateStatistics;
nhibernateConfig.Properties[NHibernate.Cfg.Environment.ShowSql] = _show_sql;
if (iSessionFactory == null)
{
lock (syncRoot)
{
if (iSessionFactory == null)
{
iSessionFactory = Fluently.Configure(nhibernateConfig)
.Cache(c => c.UseQueryCache().ProviderClass <HashtableCacheProvider>())
.Mappings(m => m.FluentMappings.AddFromAssemblyOf <T>())
.BuildConfiguration()
.BuildSessionFactory();
}
}
}
return(iSessionFactory.OpenSession());
}
public InMemoryMappingDatabase()
{
#region Programmatic Configuration assuming .hbm.xml files are embedded resources
//var config = new Configuration()
// .SetProperty(Environment.ReleaseConnections, "on_close")
// .SetProperty(Environment.Dialect, typeof(SQLiteDialect).AssemblyQualifiedName)
// .SetProperty(Environment.ConnectionDriver, typeof(SQLite20Driver).AssemblyQualifiedName)
// .SetProperty(Environment.ConnectionString, "data source=:memory:")
// //.AddFile(@"D:\Dev\AdventuresWithCode\LearnHibernate\LearnHibernate.Persistence\Mappings\Xml\Employee.hbm.xml")
// //.AddFile(@"D:\Dev\AdventuresWithCode\LearnHibernate\LearnHibernate.Persistence\Mappings\Xml\Benefit.hbm.xml")
// //.AddFile(@"D:\Dev\AdventuresWithCode\LearnHibernate\LearnHibernate.Persistence\Mappings\Xml\Address.hbm.xml")
// //.AddFile(@"D:\Dev\AdventuresWithCode\LearnHibernate\LearnHibernate.Persistence\Mappings\Xml\Community.hbm.xml");
// .AddAssembly("LearnHibernate.Persistence");
#endregion
#region Loquacious Configuration
//var config = new Configuration();
//config.DataBaseIntegration(db =>
//{
// db.Dialect<SQLiteDialect>();
// db.Driver<SQLite20Driver>();
// db.ConnectionReleaseMode = ConnectionReleaseMode.OnClose;
// db.ConnectionString = "data source=:memory:";
// db.LogFormattedSql = true;
// db.LogSqlInConsole = true;
//})
//.AddMapping(GetMapping());
#endregion
#region Fluent Configuration
var fnhConfig = Fluently.Configure()
.Database(SQLiteConfiguration.Standard
.DefaultSchema("LearnNH")
.ShowSql()
.FormatSql()
//.AdoNetBatchSize(50)
.InMemory())
//.CurrentSessionContext<AsyncLocalSessionContext>()
//.Cache(cacheBuilder => {
// cacheBuilder.UseQueryCache();
// cacheBuilder.UseSecondLevelCache();
//})
//either of the below is fine. Latter is terse
//.Mappings(mapper => mapper.FluentMappings.AddFromAssembly(typeof(EmployeeFNHMapping).Assembly))
.Mappings(mapper => mapper.FluentMappings.AddFromAssemblyOf <EmployeeFNHMapping>());
var config = fnhConfig.BuildConfiguration();
#endregion
sessionFactory = config.BuildSessionFactory();
Session = sessionFactory.OpenSession();
new SchemaExport(config)
.SetOutputFile(@".\ddl.sql")
//.Create(false, true);
.Execute(true, true, false, Session.Connection, null);
//To increment update database
//new SchemaUpdate(config).Execute(false, true);
//validate that the schema and mappings are in compliance
//this is ideal for an integration test?
//new SchemaValidator(config).Validate();
}
public static void Configuration(IAppBuilder app)
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var connectionString = ConfigurationManager.ConnectionStrings["SMW_Base"];
if (connectionString == null)
{
throw new Exception("Не найдена строка соединения");
}
var builder = new ContainerBuilder();
var modelsAssembly = Assembly.GetAssembly(typeof(User));
foreach (var type in modelsAssembly.GetTypes())
{
var attr = type.GetCustomAttribute <ListenerAttribute>();
if (attr == null)
{
continue;
}
var interfaces = type.GetInterfaces();
var b = builder.RegisterType(type);
foreach (var inter in interfaces)
{
b = b.As(inter);
}
}
builder.Register(x =>
{
var cfg = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012
.ConnectionString(connectionString.ConnectionString)
.Dialect <MsSql2012Dialect>())
.Mappings(m => m.FluentMappings.AddFromAssemblyOf <User>())
.ExposeConfiguration(c => {
SchemaMetadataUpdater.QuoteTableAndColumns(c);
c.EventListeners.PreInsertEventListeners = x.Resolve <IPreInsertEventListener[]>();
c.EventListeners.PreUpdateEventListeners = x.Resolve <IPreUpdateEventListener[]>();
})
.CurrentSessionContext("call");
var conf = cfg.BuildConfiguration();
var schemaExport = new SchemaUpdate(conf);
schemaExport.Execute(true, true);
return(cfg.BuildSessionFactory());
}).As <ISessionFactory>().SingleInstance();
builder.Register(x => x.Resolve <ISessionFactory>().OpenSession())
.As <ISession>()
.InstancePerRequest()
.InstancePerDependency();
foreach (var type in modelsAssembly.GetTypes())
{
var attr = type.GetCustomAttribute <RepositoryAttribute>();
if (attr == null)
{
continue;
}
builder.RegisterType(type);
}
builder.RegisterControllers(Assembly.GetAssembly(typeof(NoteController)));
builder.RegisterModule(new AutofacWebTypesModule());
var container = builder.Build();
Locator.SetImpl(new AutofacLocatorImpl(container));
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
app.UseAutofacMiddleware(container);
app.CreatePerOwinContext(() =>
new UserManager(new IdentityStore(DependencyResolver.Current.GetServices <ISession>().FirstOrDefault())));
app.CreatePerOwinContext <SignInManager>((options, context) =>
new SignInManager(context.GetUserManager <UserManager>(), context.Authentication));
app.UseCookieAuthentication(new CookieAuthenticationOptions
{
AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
LoginPath = new PathString("/Account/Login"),
Provider = new CookieAuthenticationProvider()
});
}
private void InitializeNHibernate()
{
Configuration cfg = Fluently.Configure()
.Database(SQLiteConfiguration.Standard
.ProxyFactoryFactory <ProxyFactoryFactory>()
.CurrentSessionContext <ThreadStaticSessionContext>()
.ShowSql()
.InMemory())
.Mappings(m => m.AutoMappings
.Add(AutoMap.AssemblyOf <Location>()
.Where(t => typeof(IEntity).IsAssignableFrom(t))
.Setup(s =>
{
s.IsComponentType =
type => typeof(ValueObject).IsAssignableFrom(type);
s.GetComponentColumnPrefix =
property => property.PropertyType.Name + "_";
})
.Conventions.AddFromAssemblyOf <IntraAggregateEntityCollectionConvention>()
))
.ExposeConfiguration(x => x.AddAssembly("DDDSample.Domain.Persistence.NHibernate"))
.BuildConfiguration();
//Configuration cfg = new Configuration()
// .AddProperties(new Dictionary<string, string>
// {
// {Environment.ConnectionDriver, typeof (SQLite20Driver).FullName},
// {Environment.Dialect, typeof (SQLiteDialect).FullName},
// {Environment.ConnectionProvider, typeof (DriverConnectionProvider).FullName},
// {Environment.ConnectionString, "Data Source=:memory:;Version=3;New=True;"},
// {
// Environment.ProxyFactoryFactoryClass,
// typeof (ProxyFactoryFactory).AssemblyQualifiedName
// },
// {
// Environment.CurrentSessionContextClass,
// typeof (ThreadStaticSessionContext).AssemblyQualifiedName
// },
// {Environment.ReleaseConnections,"on_close"},
// {Environment.Hbm2ddlAuto, "create"},
// {Environment.ShowSql, true.ToString()}
// });
//cfg.AddAssembly("DDDSample.Domain.Persistence.NHibernate");
_sessionFactory = cfg.BuildSessionFactory();
_ambientContainer.RegisterInstance(_sessionFactory);
ISession session = _sessionFactory.OpenSession();
new SchemaExport(cfg).Execute(false, true, false, session.Connection, Console.Out);
session.Save(new Location(new UnLocode("CNHKG"), "Hongkong"));
session.Save(new Location(new UnLocode("AUMEL"), "Melbourne"));
session.Save(new Location(new UnLocode("SESTO"), "Stockholm"));
session.Save(new Location(new UnLocode("FIHEL"), "Helsinki"));
session.Save(new Location(new UnLocode("USCHI"), "Chicago"));
session.Save(new Location(new UnLocode("JNTKO"), "Tokyo"));
session.Save(new Location(new UnLocode("DEHAM"), "Hamburg"));
session.Save(new Location(new UnLocode("CNSHA"), "Shanghai"));
session.Save(new Location(new UnLocode("NLRTM"), "Rotterdam"));
session.Save(new Location(new UnLocode("SEGOT"), "Göteborg"));
session.Save(new Location(new UnLocode("CNHGH"), "Hangzhou"));
session.Save(new Location(new UnLocode("USNYC"), "New York"));
session.Save(new Location(new UnLocode("USDAL"), "Dallas"));
session.Flush();
_currentSession = session;
CurrentSessionContext.Bind(_currentSession);
}
public static void BuildConfiguration()
{
lock (_nibernateLock)
{
ConfigurationManager.RefreshSection("MonahrqConfigurationSectionGroup");
var database = GetPersistenceConfigurer(_configService.MonahrqSettings.RebuildDatabase);
var moduleAssemblies = GetModuleAssemblies().ToList();
if (Configuration == null)
{
Configuration = Fluently.Configure()
.Database(database)
.Mappings(m => moduleAssemblies.ForEach(mappingAssembly => m.FluentMappings.AddFromAssembly(mappingAssembly)))
.Mappings(m => moduleAssemblies.ForEach(mappingAssembly => m.HbmMappings.AddFromAssembly(mappingAssembly)))
//.Cache(c => c.ProviderClass<SysCacheProvider>().UseSecondLevelCache().UseQueryCache())
.Cache(c => c.ProviderClass <HashtableCacheProvider>().UseSecondLevelCache().UseQueryCache())
.ExposeConfiguration(cfg =>
{
cfg.SetProperty("current_session_context_class", "thread_static")
.SetProperty("use_proxy_validator", "false")
.SetProperty("connection.isolation", "ReadCommitted")
.SetProperty("adonet.batch_size", _configService.MonahrqSettings.BatchSize.ToString(CultureInfo.InvariantCulture))
.SetProperty("command_timeout", "5000");
//cfg.EventListeners.PostDeleteEventListeners = new IPostDeleteEventListener[] { new AuditEventListener() };
//cfg.EventListeners.PostUpdateEventListeners = new IPostUpdateEventListener[] { new AuditEventListener() };
//cfg.EventListeners.PostInsertEventListeners = new IPostInsertEventListener[] { new AuditEventListener() };
cfg.EventListeners.PreDeleteEventListeners = new IPreDeleteEventListener[] { new AuditPreUpdateEventListener() };
cfg.EventListeners.PreUpdateEventListeners = new IPreUpdateEventListener[] { new AuditPreUpdateEventListener() };
cfg.EventListeners.PreInsertEventListeners = new IPreInsertEventListener[] { new AuditPreUpdateEventListener() };
cfg.SetInterceptor(new SqlCaseSensitivityInterceptor());
//cfg.EventListeners.LoadEventListeners = new ILoadEventListener[] { new OrchardLoadEventListener() };
// cfg.SetInterceptor(new DataBindingInterceptor());
if (MonahrqContext.ForceDbUpGrade)
{
return;
}
SchemaMetadataUpdater.QuoteTableAndColumns(cfg);
//if (_configService.MonahrqSettings.RebuildDatabase)
//{
// var schemaExport = new SchemaExport(cfg);
// schemaExport.Drop(false, true);
// schemaExport.Execute(true, false, false);
//}
//else
//{
try
{
var schemaUpdate = new SchemaUpdate(cfg);
schemaUpdate.Execute(false, true);
}
catch (Exception ex)
{
ex.GetType();
}
//}
})
.BuildConfiguration();
}
}
}
/// <summary>
/// Initialize
/// </summary>
/// <param name="database">Database type</param>
/// <param name="connectionString">Connection string</param>
public NHibernateDatabaseContextFactory(string database, string connectionString)
{
// create database configuration
var pathConfig = Application.Ioc.Resolve <LocalPathConfig>();
var fileStorage = Application.Ioc.Resolve <IFileStorage>();
IPersistenceConfigurer db;
if (string.Compare(database, "PostgreSQL", true) == 0)
{
db = BetterPostgreSQLConfiguration.Better.ConnectionString(connectionString);
}
else if (string.Compare(database, "SQLite", true) == 0)
{
db = SQLiteConfiguration.Standard.ConnectionString(
connectionString.Replace("{{App_Data}}", pathConfig.AppDataDirectory));
}
else if (string.Compare(database, "MySQL", true) == 0)
{
db = MySQLConfiguration.Standard.ConnectionString(connectionString);
}
else if (string.Compare(database, "MSSQL", true) == 0)
{
db = MsSqlConfiguration.MsSql2008.ConnectionString(connectionString);
}
else
{
throw new ArgumentException($"unsupported database type {database}");
}
var configuration = Fluently.Configure();
configuration.Database(db);
// register entity mappings
var providers = Application.Ioc.ResolveMany <IEntityMappingProvider>();
var entityTypes = providers.Select(p =>
ReflectionUtils.GetGenericArguments(
p.GetType(), typeof(IEntityMappingProvider <>))[0]).ToList();
configuration.Mappings(m => entityTypes.ForEach(t => m.FluentMappings.Add(
typeof(NHibernateEntityMappingBuilder <>).MakeGenericType(t))));
// call initialize handlers
var handlers = Application.Ioc.ResolveMany <IDatabaseInitializeHandler>();
configuration.Mappings(m => {
m.FluentMappings.Conventions.Add(ConventionBuilder.Class.Always(x => {
var tableName = x.EntityType.Name;
handlers.ForEach(h => h.ConvertTableName(ref tableName));
x.Table(tableName);
}));
m.FluentMappings.Conventions.Add(ConventionBuilder.HasManyToMany.Always(x => {
var tableName = string.Format(
"{0}To{1}", x.EntityType.Name, x.ChildType.Name);
handlers.ForEach(h => h.ConvertTableName(ref tableName));
x.Table(tableName);
}));
});
// initialize database scheme
// flow:
// - generate ddl script
// - compare to App_Data\nh_{hash}.ddl
// - if they are different, upgrade database scheme and write ddl script to file
// it can make the website startup faster
var hash = PasswordUtils.Sha1Sum(
Encoding.UTF8.GetBytes(database + connectionString)).ToHex();
var ddlFileEntry = fileStorage.GetStorageFile($"nh_{hash}.ddl");
Action onBuildFactorySuccess = null;
configuration.ExposeConfiguration(c => {
var scriptBuilder = new StringBuilder();
scriptBuilder.AppendLine("/* this file is for database migration checking, don't execute it */");
new SchemaExport(c).Create(s => scriptBuilder.AppendLine(s), false);
var script = scriptBuilder.ToString();
if (!ddlFileEntry.Exists || script != ddlFileEntry.ReadAllText())
{
var logManager = Application.Ioc.Resolve <LogManager>();
var schemaUpdate = new SchemaUpdate(c);
schemaUpdate.Execute(false, true);
foreach (var ex in schemaUpdate.Exceptions)
{
logManager.LogError($"NHibernate schema update error: ({ex.GetType()}) {ex.Message}");
}
onBuildFactorySuccess = () => ddlFileEntry.WriteAllText(script);
}
});
// create nhibernate session factory and write ddl script to file
Database = database;
SessionFactory = configuration.BuildSessionFactory();
onBuildFactorySuccess?.Invoke();
}
public AbpNHibernateModuleConfiguration()
{
FluentConfiguration = Fluently.Configure();
}
public ISessionFactory CreateSessionFactory()
{
var sDbUser = System.Configuration.ConfigurationManager.AppSettings["dbUser"];
var sDbPassword = System.Configuration.ConfigurationManager.AppSettings["dbPassword"];
var sDbName = System.Configuration.ConfigurationManager.AppSettings["dbName"];
var sDbHost = System.Configuration.ConfigurationManager.AppSettings["dbHost"];
var sDbType = System.Configuration.ConfigurationManager.AppSettings["dbType"];
var sDbPort = System.Configuration.ConfigurationManager.AppSettings["dbPort"];
string sConnectionString;
global::NHibernate.Cfg.Configuration configuration;
switch (sDbType)
{
case "2":
sConnectionString = @"Server=" + sDbHost + ";Initial Catalog=" + sDbName + ";User Id=" + sDbUser + ";Password="******"3":
sConnectionString = @"Server=" + sDbHost + ";Database=" + sDbName + ";User ID=" + sDbUser + ";Password="******";";
configuration = Fluently
.Configure()
.Database(PostgreSQLConfiguration
.Standard
.ConnectionString(sConnectionString)
.ShowSql
)
//.Mappings(m => m.FluentMappings.AddFromAssemblyOf<ACCDataStore.Entity.Mapping.Nationality2012Map>())
.BuildConfiguration();
break;
case "4":
sConnectionString = sDbName;
configuration = Fluently
.Configure()
.Database(JetDriverConfiguration
.Standard
.ConnectionString(c => c.DatabaseFile(sConnectionString))
.ShowSql
)
.Mappings(m => m.FluentMappings.AddFromAssemblyOf <ACCDataStore.Entity.Mapping.MSAccess.DatahubDataObjMap>())
.BuildConfiguration();
break;
default:
sConnectionString = @"Server =" + sDbHost + ";Port=" + sDbPort + ";Database=" + sDbName + ";User ID=" + sDbUser + ";Password="******";";
configuration = Fluently
.Configure()
.Database(MySQLConfiguration
.Standard
.ConnectionString(sConnectionString)
.ShowSql
)
//.Mappings(m => m.FluentMappings.AddFromAssemblyOf<ACCDataStore.Entity.Mapping.MySQL.LA100SchoolsMap>())
.BuildConfiguration();
break;
}
return(configuration.BuildSessionFactory());
}
static void Main(string[] args)
{
WriteLine("Create and configuration database");
ISessionFactory sessionFactory = Fluently
.Configure()
.Database(MsSqlConfiguration.MsSql2012.ConnectionString(
@"Data Source=localhost;Initial Catalog=NHTest; User Id=sa;Password=Hello@123"))
.Mappings(m => m.FluentMappings.AddFromAssemblyOf <Program>())
.ExposeConfiguration(config => new SchemaUpdate(config).Execute(true, true))
.BuildSessionFactory();
WriteLine("Saving Author and Book");
using (ISession session = sessionFactory.OpenSession())
{
var author = new Author
{
Name = "Affonso Solano"
};
WriteLine($"Creating Author:{author}");
session.Save(author);
var book = new Book
{
Name = "O Espadachim de Carvão",
Author = author
};
WriteLine($"Creating Book:{book}");
session.Save(book);
session.Flush();
WriteLine("Saved on database");
WriteLine($"Author: {author} - Book: {book}");
}
using (ISession session = sessionFactory.OpenSession())
{
var author = new Author
{
Name = "Eduardo Spohr"
};
WriteLine($"Creating Author:{author}");
session.Save(author);
var jovemNerd = new Collaborator
{
Name = "Jovem Nerd"
};
WriteLine($"Creating Collaborator:{jovemNerd}");
session.Save(jovemNerd);
var azaghal = new Collaborator
{
Name = "Azaghal"
};
WriteLine($"Creating Collaborator:{azaghal}");
session.Save(azaghal);
var book = new Book
{
Name = "A Batalha do Apocalipse",
Author = author,
};
book.Collaborators.Add(jovemNerd);
book.Collaborators.Add(azaghal);
WriteLine($"Creating Book:{book}");
session.Save(book);
session.Flush();
WriteLine("Saved on database");
WriteLine($"Author: {author} - Book: {book}");
}
using (ISession session = sessionFactory.OpenSession())
{
foreach (Book book in session.Query <Book>().Where(x => x.Collaborators.Any()))
{
WriteLine(book);
}
}
ReadLine();
}
/// <summary>
/// Creates a <see cref="FluentConfiguration"/> instance
/// </summary>
/// <param name="connectionStringName">The name of the connection string</param>
/// <param name="persistenceConfiguration">The persistence configuration type name</param>
/// <param name="dialect">The persistence configuration dialect full type name</param>
/// <returns>An <see cref="FluentConfiguration"/> instance</returns>
private FluentConfiguration FluentlyConfigure(string connectionStringName, string persistenceConfiguration, string dialect = null)
{
if (connectionStringName == null)
{
throw new ArgumentNullException(nameof(connectionStringName));
}
if (persistenceConfiguration == null)
{
throw new ArgumentNullException(nameof(persistenceConfiguration));
}
if (string.IsNullOrWhiteSpace(persistenceConfiguration) || persistenceConfiguration.IndexOf(".", StringComparison.Ordinal) == -1 ||
persistenceConfiguration.IndexOf(".", StringComparison.Ordinal) < 1)
{
throw new FormatException($"Persistence configuration is of invalid format {persistenceConfiguration}");
}
var assembly = Assembly.Load("FluentNHibernate");
if (assembly == null)
{
throw new Exception("Assembly FluentNHibernate not found.");
}
var configurationType =
assembly.GetType(
$"FluentNHibernate.Cfg.Db.{persistenceConfiguration.Substring(0, persistenceConfiguration.IndexOf(".", StringComparison.Ordinal))}");
if (configurationType == null)
{
throw new Exception($"Type {persistenceConfiguration} not found.");
}
var configurationPropertyName =
persistenceConfiguration.Substring(persistenceConfiguration.IndexOf(".", StringComparison.Ordinal) + 1);
var configurationProperty = configurationType.GetProperty(configurationPropertyName);
if (configurationProperty == null)
{
throw new Exception(
$"Property with name {configurationPropertyName} not found on type {configurationType.Name}.");
}
var configurationPropertyValue = configurationProperty.GetValue(configurationType, null);
if (configurationPropertyValue == null)
{
throw new Exception(
$"Property with name {configurationProperty} on type {configurationType} has no value.");
}
Type dialectType = null;
if (!string.IsNullOrWhiteSpace(dialect))
{
dialectType = Type.GetType(dialect);
if (dialectType == null)
{
throw new TypeLoadException($"Cannot load dialect type {dialect}");
}
}
if (dialectType != null)
{
var dialectMethod = configurationPropertyValue.GetType().GetMethod("Dialect", new Type[] { });
if (dialectMethod != null)
{
configurationPropertyValue = dialectMethod.MakeGenericMethod(dialectType).Invoke(configurationPropertyValue, new object[] { });
}
}
if (configurationPropertyValue == null)
{
throw new Exception($"Cannot load dialect {dialect}");
}
var configurationPropertyType = configurationPropertyValue.GetType();
var connectionStringMethod = configurationPropertyType.GetMethod("ConnectionString", new[] { typeof(string) });
if (connectionStringMethod == null)
{
throw new Exception($"ConnectionString method not found on type {configurationPropertyType}.");
}
var connectionString = RyanPenfold.Configuration.ConnectionStrings.Get(connectionStringName);
if (string.IsNullOrEmpty(connectionString))
{
throw new Exception($"Connection string {connectionStringName} not found in the configuration settings");
}
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new Exception($"Connection string {connectionStringName} ");
}
return(Fluently.Configure().Database((IPersistenceConfigurer)connectionStringMethod.Invoke(configurationPropertyValue, new object[] { connectionString })));
}
public static ISessionFactory GetDatabaseSessionFactory(Env? environmentOverride_testOnly = null) {
Configuration c;
var env = environmentOverride_testOnly ?? CurrentEnv ?? Config.GetEnv();
CurrentEnv = env;
if (factories == null)
factories = new Dictionary<Env, ISessionFactory>();
if (!factories.ContainsKey(env)) {
lock (lck) {
ChromeExtensionComms.SendCommand("dbStart");
var config = System.Configuration.ConfigurationManager.AppSettings;
var connectionStrings = System.Configuration.ConfigurationManager.ConnectionStrings;
switch (environmentOverride_testOnly ?? Config.GetEnv()) {
//case Env.local_mysql: {
// var connectionString = connectionStrings["DefaultConnectionMsSql"].ConnectionString;
// var file = connectionString.Split(new String[] { "Data Source=" }, StringSplitOptions.RemoveEmptyEntries)[0].Split(';')[0];
// DbFile = file;
// try {
// c = new Configuration();
// c.SetInterceptor(new NHSQLInterceptor());
// factories[env] = Fluently.Configure(c).Database(MsSqlConfiguration.MsSql2012.ConnectionString(connectionString))
// .Mappings(m => {
// m.FluentMappings.AddFromAssemblyOf<UserModel>();
// })
// .CurrentSessionContext("web")
// .ExposeConfiguration(x => BuildMsSqlSchema(x))
// .BuildSessionFactory();
// } catch (Exception e) {
// throw e;
// }
// break;
// }
//case Env.mssql: {
// try {
// c = new Configuration();
// c.SetInterceptor(new NHSQLInterceptor());
// factories[env] = Fluently.Configure(c).Database(MsSqlConfiguration.MsSql2012.ConnectionString(connectionStrings["DefaultConnectionMsSql"].ConnectionString)/*.ShowSql()*/)
// .Mappings(m => {
// m.FluentMappings.AddFromAssemblyOf<UserModel>();
// })
// .ExposeConfiguration(x => BuildMsSqlSchema(x))
// .BuildSessionFactory();
// } catch (Exception e) {
// var mbox = e.Message;
// if (e.InnerException != null && e.InnerException.Message != null)
// mbox = e.InnerException.Message;
// ChromeExtensionComms.SendCommand("dbError", mbox);
// throw e;
// }
// break;
// }
case Env.test_server: {
try {
c = new Configuration();
c.SetInterceptor(new NHSQLInterceptor());
factories[env] = Fluently.Configure(c).Database(MsSqlConfiguration.MsSql2012.ConnectionString(connectionStrings["Test_Server"].ConnectionString)/*.ShowSql()*/)
.Mappings(m => {
m.FluentMappings.AddFromAssemblyOf<TimeLogs>();
})
.ExposeConfiguration(x => BuildMsSqlSchema(x))
.BuildSessionFactory();
} catch (Exception e) {
var mbox = e.Message;
if (e.InnerException != null && e.InnerException.Message != null)
mbox = e.InnerException.Message;
ChromeExtensionComms.SendCommand("dbError", mbox);
throw e;
}
break;
}
default:
throw new Exception("No database type");
}
Names = new RuntimeNames(c);
ChromeExtensionComms.SendCommand("dbComplete");
}
}
return factories[env];
}
public void InitializeFromConfigOracleClient_SectionNotFound_DatabaseConnectionConfigurationException()
{
// Act
Assert.Throws <DatabaseConnectionConfigurationException>(() => Fluently.Configure().InitializeFromConfigOracleClient("foo"));
}
/// <summary>
/// Initialize<br/>
/// 初始化<br/>
/// </summary>
public NHibernateDatabaseContextFactory(
string database, string connectionString,
IEnumerable <IDatabaseInitializeHandler> handlers,
IEnumerable <IEntityMappingProvider> providers)
{
// create database configuration
var pathConfig = Application.Ioc.Resolve <LocalPathConfig>();
IPersistenceConfigurer db;
if (string.Compare(database, "PostgreSQL", true) == 0)
{
db = BetterPostgreSQLConfiguration.Better.ConnectionString(connectionString);
}
else if (string.Compare(database, "SQLite", true) == 0)
{
db = SQLiteConfiguration.Standard.ConnectionString(
connectionString.Replace("{{App_Data}}", pathConfig.AppDataDirectory));
}
else if (string.Compare(database, "MySQL", true) == 0)
{
db = MySQLConfiguration.Standard.ConnectionString(connectionString);
}
else if (string.Compare(database, "MSSQL", true) == 0)
{
db = MsSqlConfiguration.MsSql2008.ConnectionString(connectionString);
}
else
{
throw new ArgumentException($"unsupported database type {database}");
}
var configuration = Fluently.Configure();
configuration.Database(db);
// register entity mappings
var entityProviders = providers
.GroupBy(p => ReflectionUtils.GetGenericArguments(
p.GetType(), typeof(IEntityMappingProvider <>))[0])
.ToList();
configuration.Mappings(m => {
// FIXME: fluent nhibernate doesn't support passing arguments to builder
// so it still retrieve providers and handers from IoC container
foreach (var group in entityProviders)
{
var builder = typeof(NHibernateEntityMappingBuilder <>).MakeGenericType(group.Key);
m.FluentMappings.Add(builder);
}
});
// set many-to-many table name
configuration.Mappings(m => {
m.FluentMappings.Conventions.Add(ConventionBuilder.HasManyToMany.Always(x => {
var tableName = string.Format("{0}To{1}", x.EntityType.Name, x.ChildType.Name);
foreach (var handler in handlers)
{
handler.ConvertTableName(ref tableName);
}
x.Table(tableName);
}));
});
// check if database auto migration is disabled
var configManager = Application.Ioc.Resolve <WebsiteConfigManager>();
var noAutoMigration = configManager.WebsiteConfig.Extra.GetOrDefault <bool?>(
NHibernateExtraConfigKeys.DisableNHibernateDatabaseAutoMigration) ?? false;
if (!noAutoMigration)
{
MigrateDatabase(database, connectionString, configuration);
}
// create nhibernate session
Database = database;
ConnectionString = connectionString;
SessionFactory = configuration.BuildSessionFactory();
}
private static Configuration CreateConfiguration()
{
FluentConfiguration fluentConfig = Fluently.Configure();
switch (DatabaseType)
{
case SupportedDatabaseType.SQLEXPRESS_2012:
{
// IMPORTANT: The database MUST ALREADY EXIST.
//fluentConfig.Database(
// MsSqlConfiguration.MsSql2012.ConnectionString(x =>
// x.Server(@".\SQLEXPRESS")
// .Database("teltec_backup")
// .TrustedConnection()
// ).UseReflectionOptimizer()
//);
fluentConfig.Database(
MsSqlConfiguration.MsSql2012.ConnectionString(x =>
x.Server(@".\SQLEXPRESS")
.Database("teltec_backup_db")
.Username("teltec_backup_user")
.Password("p@55w0rd")
).UseReflectionOptimizer()
);
break;
}
case SupportedDatabaseType.SQLITE3:
{
string dataDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string dbFilePath = dataDirectory + @"\database.sqlite3";
fluentConfig.Database(SQLiteConfiguration.Standard.UsingFile(dbFilePath));
break;
}
}
//fluentConfig.Diagnostics(diag => diag.Enable().OutputToConsole());
// Add all mappings from this assembly.
fluentConfig.Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()));
Configuration config = fluentConfig.BuildConfiguration();
//config.SetProperty(NHibernate.Cfg.Environment.Hbm2ddlAuto, "true");
if (DatabaseType == SupportedDatabaseType.SQLEXPRESS_2012)
{
config.DataBaseIntegration(db =>
{
db.BatchSize = NHibernateHelper.BatchSize;
db.Dialect <NHibernate.Dialect.MsSql2012Dialect>();
db.Driver <NHibernate.Driver.Sql2008ClientDriver>();
//db.HqlToSqlSubstitutions = "true 1, false 0, yes 'Y', no 'N'";
db.IsolationLevel = System.Data.IsolationLevel.ReadCommitted;
db.KeywordsAutoImport = Hbm2DDLKeyWords.AutoQuote;
#if DEBUG
db.LogFormattedSql = true;
db.LogSqlInConsole = true;
#else
db.LogFormattedSql = false;
db.LogSqlInConsole = false;
#endif
//db.OrderInserts = true;
//db.PrepareCommands = true;
db.SchemaAction = SchemaAutoAction.Update;
});
}
UpdateSchema(config);
ValidateSchema(config);
// Register interceptors.
#if DEBUG
config.SetInterceptor(new NHibernateAuditInterceptor());
#endif
// Register listeners.
config.AppendListeners(ListenerType.Load, new ILoadEventListener[] {
new NHibernateLoadListener(),
});
config.AppendListeners(ListenerType.PostLoad, new IPostLoadEventListener[] {
new NHibernatePersistentEntityListener(),
});
config.AppendListeners(ListenerType.Save, new ISaveOrUpdateEventListener[] {
new NHibernatePersistentEntityListener(),
});
config.AppendListeners(ListenerType.Update, new ISaveOrUpdateEventListener[] {
new NHibernatePersistentEntityListener(),
});
return(config);
}
public FluentConfiguration BuildFluent()
{
return(Fluently.Configure()
.Database(SQLiteConfiguration.Standard.UsingFile("DataStore.db"))
.Mappings(m => m.FluentMappings.AddFromAssemblyOf <NHibInstaller>()));
}
