/// <summary> /// Configures the DAL. /// </summary> internal DalConfigurator ConfigureInMemory(out ISession session) { if (isConfigured) { throw new ConfigurationException(); } this.ConfigurationSetup = config => { // this NHibernate tool takes a configuration (with mapping info in) // and exports a database schema from it new SchemaExport(config) .Create(false, true); Configuration = config; }; this.MySQLiteConfiguration = SQLiteConfiguration .Standard .InMemory(); this.BuildSessionFactory(); session = DalConfigurator.SessionFactory.OpenSession(); this.executeScript = true; new SchemaExport(Configuration) .Execute(true, true, false, session.Connection, null); return(this); }
/// <summary> /// Initializes a new instance of the <see cref="BaseContext" /> class. /// </summary> /// <param name="config"> /// The config. /// </param> protected BaseContext(IPersistenceConfigurer config) { Configuration = Fluently.Configure().Database(config).Mappings(SetupConventions) .Mappings(ConfigureMappings).BuildConfiguration(); SetConfig(); }
public Database( IPersistenceConfigurer persistenceConfigurer, Assembly classMapAssembly, Action <Configuration> configAction = null, bool resetSchema = false) { if (configAction == null) { configAction = configuration => { } } ; _sessionFactory = Fluently.Configure() .Database(() => persistenceConfigurer) .Mappings(m => m.FluentMappings.AddFromAssembly(classMapAssembly)) .ExposeConfiguration(config => { if (resetSchema) { new SchemaExport(config).Create(false, true); } configAction(config); }) .BuildSessionFactory(); }
protected Database(IPersistenceConfigurer pcfg, IDomainDefinition mappings) { var clsmaps = new DomainType[]{DomainType.Class,DomainType.ClassWithoutBaseClass}; var cfg = Fluently.Configure() .Database(pcfg) .Mappings(m => { var am1 = AutoMap.Assembly(mappings.DomainAssembly) .Where(t => clsmaps.Contains(mappings.GetDomainType(t))) .Setup(c => { c.IsComponentType = t => typeof(MyText).IsAssignableFrom(t) || mappings.GetDomainType(t) == DomainType.Component; c.IsConcreteBaseType = t => IsConcreteBaseType(t) || mappings.GetDomainType(t) == DomainType.ClassWithoutBaseClass; c.GetComponentColumnPrefix = pi => { return pi.Name; }; }); foreach (var mod in mappings.RegisteredModules) mod.Map(mappings, am1); am1.GetType().GetMethod("UseOverridesFromAssemblyOf").MakeGenericMethod(mappings.GetType()).Invoke(am1, null); am1.Alterations(a => { a.GetType().GetMethod("AddFromAssemblyOf").MakeGenericMethod(mappings.GetType()).Invoke(a, null); }); m.AutoMappings.Add(am1); if (mappings.WriteHbmFilesToPath != null) { foreach (var v in m.AutoMappings) { v.BuildMappings(); v.WriteMappingsTo(mappings.WriteHbmFilesToPath); } } }).ExposeConfiguration(c => { foreach (var mod in mappings.RegisteredModules) mod.Configure(c); }).BuildConfiguration(); SessionFactory = cfg.BuildSessionFactory(); CreateDB = () => { LocalSession = LocalSession??SessionFactory.OpenSession(); new SchemaExport(cfg).Execute(false, true, false, LocalSession.Connection, null); }; UpdateDB = () => { new SchemaUpdate(cfg).Execute(false, true); }; DropDB = () => { new SchemaExport(cfg).Drop(true, true); }; }
public static ISessionFactory criarSession() { if (session != null) { return(session); } IPersistenceConfigurer configDB = MsSqlConfiguration.MsSql2012.ConnectionString(connectionString); //var configMap = Fluently.Configure().Database(configDB) // .ExposeConfiguration(cfg => new SchemaExport(cfg).Create(true, true)) // .Mappings(c => c.FluentMappings // .AddFromAssemblyOf<Mapping.UserMap>() // .AddFromAssemblyOf<Mapping.EnterpriseMap>() // .AddFromAssemblyOf<Mapping.RelationshipMap>()); //session = configMap.BuildSessionFactory(); var configMap = Fluently.Configure().Database(configDB) .Mappings(c => c.FluentMappings .AddFromAssemblyOf <Mapping.UserMap>() .AddFromAssemblyOf <Mapping.EnterpriseMap>() .AddFromAssemblyOf <Mapping.RelationshipMap>()); session = configMap.BuildSessionFactory(); return(session); }
public SessionFactoryBuilder(IDatabaseMappingScheme<MappingConfiguration> mappingScheme, IPersistenceConfigurer persistenceConfigurer, IInterceptor interceptor = null) { _mappingScheme = mappingScheme; _persistenceConfigurer = persistenceConfigurer; _interceptor = interceptor; }
public static Configuration Init( ISessionStorage storage, string[] mappingAssemblies, AutoPersistenceModel autoPersistenceModel, string cfgFile, IDictionary <string, string> cfgProperties, string validatorCfgFile, IPersistenceConfigurer persistenceConfigurer) { InitStorage(storage); try { return(AddConfiguration( DefaultFactoryKey, mappingAssemblies, autoPersistenceModel, cfgFile, cfgProperties, validatorCfgFile, persistenceConfigurer)); } catch { // If this NHibernate config throws an exception, null the Storage reference so // the config can be corrected without having to restart the web application. Storage = null; throw; } }
private static ISessionFactory CreateSessionFactory <T>() where T : ICurrentSessionContext { try { IPersistenceConfigurer persistenceConfigurer = null; string cnx = System.Configuration.ConfigurationManager.ConnectionStrings["cnxSebraeAcademico"].ConnectionString; persistenceConfigurer = MsSqlConfiguration .MsSql2008 .IsolationLevel(System.Data.IsolationLevel.ReadCommitted) //.UseOuterJoin() #if DEBUG .ShowSql() .UseOuterJoin() .FormatSql() #endif .ConnectionString(cnx); //.AdoNetBatchSize(30); FluentConfiguration nhbConfig = Fluently.Configure() .CurrentSessionContext <T>()//.CurrentSessionContext("web") //("ManagedWebSessionContext") .Database(persistenceConfigurer) .Cache(it => it.Not.UseSecondLevelCache()) .Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.Load("Sebrae.Academico.BM"))); _sessionFactory = nhbConfig.BuildSessionFactory(); } catch (FluentConfigurationException ex) { throw ex; } return(_sessionFactory); }
private static void InitMssql() { log4net.Config.XmlConfigurator.Configure(); Console.WriteLine("initializing mssql..."); IPersistenceConfigurer dbCfg = MsSqlConfiguration.MsSql2008 //.ShowSql() .FormatSql() .ConnectionString(c => c.Is(ConfigurationManager.ConnectionStrings["Mssql"].ConnectionString)); var nhCfg = Fluently.Configure() .Database(dbCfg) .Mappings(m => m.AutoMappings .Add( AutoMap.Assembly(typeof(RootFactory).Assembly) .Conventions.Add <CascadeAll>() .Conventions.Add(FluentNHibernate.Conventions.Helpers.DefaultLazy.Never()) // eager loading ).ExportTo("..\\..\\nhmaps")) // to see what is actually going on .ExposeConfiguration(delegate(Configuration cfg) { // preapre schema var schema = new SchemaExport(cfg); schema.Drop(false, true); schema.Create(false, true); }); _sessionFactory = nhCfg.BuildSessionFactory(); }
public NHibernateStorage WithDatabaseConfiguration(IPersistenceConfigurer persistenceConfigurer) { Requires.NotNull(persistenceConfigurer, "persistenceConfigurer"); PersistenceConfigurer = persistenceConfigurer; return(this); }
public Configuration BuildConfiguration(IPersistenceConfigurer persistenceConfigurer) { return Fluently.Configure() .Database(persistenceConfigurer) .Mappings(ConfigureMappings) .BuildConfiguration(); }
private static ISessionFactory CreateSessionFactory(Assembly contextAssembly, IPersistenceConfigurer dbPersister, AutoPersistenceModel autoPersistanceModel = null) { // Create config var factoryConfig = Fluently.Configure(); factoryConfig.Database(dbPersister); return CreateSessionFactory(contextAssembly, factoryConfig, autoPersistanceModel); }
public IPersistenceConfigurer Get() { if (_provider == Database.SqlServer) { _database = MsSqlConfiguration.MsSql2012.ConnectionString(builder => builder.Is(_connex)) .AdoNetBatchSize(10) .UseOuterJoin() .ShowSql() .QuerySubstitutions("true 1, false 0, yes 'Y', no 'N'"); } else if (_provider == Database.MySql) { _database = MySQLConfiguration.Standard.ConnectionString(builder => builder.Is(_connex)) .AdoNetBatchSize(10) .UseOuterJoin() .ShowSql() .QuerySubstitutions("true 1, false 0, yes 'Y', no 'N'"); } else if (_provider == Database.Sqlite) { _database = SQLiteConfiguration.Standard .AdoNetBatchSize(10) .UseOuterJoin() .QuerySubstitutions("true 1, false 0, yes 'Y', no 'N'") .ConnectionString(_connex); } return(_database); }
public static ISessionFactory GetSessionFactory(NhDataContext context, IPersistenceConfigurer dbPersister, AutoPersistenceModel autoPersistanceModel = null) { var contextType = context.GetType(); var contextAssembly = Assembly.GetAssembly(contextType); return _factories.GetOrAdd(contextType, CreateSessionFactory(contextAssembly, dbPersister, autoPersistanceModel)); }
/// <summary> /// Metodo responsavel por executar o mapeamento das classes com o banco de dados /// </summary> /// <param name="databaseConfigurer"></param> /// <param name="validatorEngine"></param> /// <returns></returns> private static ISessionFactory ConfigureNHibernate(IPersistenceConfigurer databaseConfigurer, out ValidatorEngine validatorEngine) { ValidatorEngine ve = null; ISessionFactory factory = Fluently.Configure() .Database(databaseConfigurer) .Mappings(m => m.FluentMappings.AddFromAssemblyOf<UsuarioMap>() .Conventions.Add(typeof(CascadeAll)) ) .Cache(x => x.UseQueryCache() .UseSecondLevelCache() .ProviderClass<SysCacheProvider>() ) .ExposeConfiguration(c => { ve = ConfigureValidator(c); c.SetProperty("adonet.batch_size", "5"); c.SetProperty("generate_statistics", "false"); //c.SetProperty("cache.use_second_level_cache", "true"); }) .BuildConfiguration().BuildSessionFactory(); validatorEngine = ve; return factory; }
public static Configuration GetConfig(IPersistenceConfigurer db) { var cfg = new ORMConfiguration(); return(Fluently.Configure() .Database(db) .Mappings(m => m.AutoMappings .Add(AutoMap.AssemblyOf <ORMConfiguration> (cfg) .Conventions.Add <ReferenceConventions> () .Conventions.Add <EnumTypeConvention> () .Conventions.Add <IPAddressConvention> () .Conventions.Add <VectorConvention> () .Conventions.Add <CascadeConvention> () .Conventions.Add <RequiredConvention> () .IncludeBase <BaseItem> () .IncludeBase <FloorItem> () .IncludeBase <WallItem> () .IncludeBase <CatalogPageLayout> () .IncludeBase <NavigatorCategory> () .UseOverridesFromAssemblyOf <ORMConfiguration>() )) .ExposeConfiguration(BuildSchema) .BuildConfiguration()); }
/// <summary>Creates a database configuration.</summary> private Configuration CreateDatabaseConfiguration(IPersistenceConfigurer persistenceConfigurer) { return(Fluently .Configure() .Database(persistenceConfigurer) .Cache(ConfigureCache) .Mappings(m => m.AutoMappings.Add( AutoMap .AssemblyOf <Muwesome.DomainModel.Identifiable>(new DatabaseMappingConfiguration()) .Conventions.Setup(ConfigureConventions) .UseOverridesFromAssembly(Assembly.GetExecutingAssembly()))) .ExposeConfiguration(c => c.SetProperty("generate_statistics", "true")) .BuildConfiguration()); void ConfigureCache(CacheSettingsBuilder cacheBuilder) => cacheBuilder.ProviderClass <HashtableCacheProvider>().UseQueryCache().UseSecondLevelCache(); void ConfigureConventions(IConventionFinder conventions) { conventions.Add(ForeignKey.EndsWith("Id")); conventions.Add(new NotNullConvention()); conventions.Add(new NotLazyLoadConvention()); conventions.Add(new CacheConfigurationConvention()); } }
internal ConfigurationInfo(IPersistenceConfigurer configurer, FluentNHibernatePersistenceBuilderOptions options, ProviderTypeEnum providerType) { PersistenceConfigurer = configurer; ProviderType = providerType; Options = options; }
//#endif #endregion /// <summary> /// Initializes a new instance of the <see cref="SessionManager"/> class. /// </summary> private SessionManager() { IPersistenceConfigurer persistenceConfigurer = null; string cnx = System.Configuration.ConfigurationManager.ConnectionStrings["cnxSebraeAcademico"].ConnectionString; persistenceConfigurer = MsSqlConfiguration .MsSql2008 .IsolationLevel(System.Data.IsolationLevel.ReadCommitted) //.UseOuterJoin() #if DEBUG .ShowSql() .UseOuterJoin() .FormatSql() #endif .ConnectionString(cnx); //.AdoNetBatchSize(30); FluentConfiguration nhbConfig = Fluently.Configure() .Database(persistenceConfigurer) .Cache(it => it.Not.UseSecondLevelCache()) .Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.Load("Sebrae.Academico.BM"))); _sessionFactory = nhbConfig.BuildSessionFactory(); }
public static ISessionFactory CriaSessionFactory() { //Casa //IPersistenceConfigurer configDB = PostgreSQLConfiguration.PostgreSQL82.ConnectionString("Server=localhost;Port=5432;Database=money_sic;User Id=postgres;Password=123456;"); //Trabalho //IPersistenceConfigurer configDB = PostgreSQLConfiguration.PostgreSQL82.ConnectionString("Server=localhost;Port=5432;Database=money_sic;User Id=login_money;Password=123456;"); IPersistenceConfigurer configDB = MsSqlConfiguration.MsSql2012.ConnectionString("Server=(local);Database=Ccg2009;User Id=userImportacao;Password=35456575; "); var configMap = Fluently.Configure().Database(configDB) //Mappings(c => c.FluentMappings.AddFromAssemblyOf<Mapping.PessoaFisicaMapping>()); .Mappings(x => { x.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()); }) //.Mappings(m => m.FluentMappings.Add<CarrinhoMapping>()) //.Mappings(_ => _.FluentMappings.AddFromAssemblyOf<Carrinho>()) //ExposeConfiguration( y => new SchemaExport(y).Create(true, false)); .ExposeConfiguration(y => new SchemaUpdate(y).Execute(true, true)) .BuildConfiguration() .BuildSessionFactory(); factory = configMap; return(factory); }
public static void Instance(IPersistenceConfigurer configurer, params Assembly[] assemblies) { if (sessionFactory != null) { return; } Configuration config = new Configuration(); config.SetNamingStrategy(DefaultNamingStrategy.Instance); config = Fluently.Configure(config) .Database(configurer) .Mappings(m => { foreach (var assembly in assemblies) { m.FluentMappings.AddFromAssembly(assembly); } }) .CurrentSessionContext <WebSessionContext>() .ExposeConfiguration(cfg => new SchemaUpdate(cfg).Execute((sql) => { ILogger logger = new Tiantianquan.Common.Logging.Log4Net.Log4NetLoggerFactory("log4net.config").Create("NhSessionFactory"); logger.Info(sql); }, true)) .BuildConfiguration(); sessionFactory = config.BuildSessionFactory(); }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ public static void InitOnce() { if (SessionFactory != null) { throw new Exception("Factory has already been initialized."); } string root = Directory.GetCurrentDirectory(); string path = Path.GetFullPath(root + "/../../../../Data/" + DbFile); Console.WriteLine("Database File: " + path); IPersistenceConfigurer conn = SQLiteConfiguration .Standard .ConnectionString("Data Source=" + path + ";Version=3"); SessionFactory = Fluently.Configure() .Database(conn) .Mappings(m => m .FluentMappings .AddFromAssemblyOf <ArtifactMap>() .Conventions .Add( PrimaryKey.Name.Is(x => "Id"), ForeignKey.EndsWith("Id") ) ) .ExposeConfiguration(c => { Config = c; }) .BuildSessionFactory(); }
private static void InitializeSessionFactory(IPersistenceConfigurer connection) { //IPersistenceConfigurer SQLitePersistenceConfigurer = SQLiteConfiguration.Standard.UsingFile("Testproject.db"); //IPersistenceConfigurer MsSql2008PersistenceConfigurer = MsSqlConfiguration.MsSql2008.ConnectionString(@"Server=(local);initial catalog=TestDB;user=sa;password=sa2008;").ShowSql(); //IPersistenceConfigurer connection = MsSqlConfiguration.MsSql2012.ConnectionString(@"Data Source=(LocalDB)\v11.0;AttachDbFilename=C:\Users\Bram.vandenBossche\Documents\HibernateTest.mdf;Integrated Security=True;Connect Timeout=30").ShowSql(); /*_sessionFactory = Fluently.Configure() * .Database(connection) * .Mappings(m => * m.FluentMappings * .AddFromAssemblyOf<T>()) * .ExposeConfiguration(cfg => new SchemaExport(cfg) * .Create(true, true)) * .BuildSessionFactory();*/ _sessionFactory = Fluently.Configure() .Database(connection) .Mappings(m => m.FluentMappings.AddFromAssemblyOf <T>()) .ExposeConfiguration(cfg => new SchemaUpdate(cfg).Execute(true, true)) .BuildSessionFactory(); /* * _sessionFactory = Fluently.Configure() * .Database(connection) * .Mappings(m => * m.AutoMappings.Add( * AutoMap.AssemblyOf<Userview>())) * .BuildSessionFactory();*/ }
public ISessionFactory build_session_factory(IPersistenceConfigurer db_configuration, Assembly assembly, string top_namespace, Action <Configuration> additional_function) { Log.bound_to(this).log_a_debug_event_containing("Building Session Factory"); var config = Fluently.Configure() .Database(db_configuration) .Mappings(m => { m.FluentMappings.Add(assembly.GetType(top_namespace + ".orm.VersionMapping", true, true)) .Add(assembly.GetType(top_namespace + ".orm.ScriptsRunMapping", true, true)) .Add(assembly.GetType(top_namespace + ".orm.ScriptsRunErrorMapping", true, true)); //.Conventions.AddAssembly(assembly); //m.HbmMappings.AddFromAssembly(assembly); }) .ExposeConfiguration(cfg => { // FIXME: Quick workaround for MySQL's defect with reserved words auto-quoting http://216.121.112.228/browse/NH-1906 //TODO:please verify fixed Diyan cfg.Properties["hbm2ddl.keywords"] = "none"; cfg.SetListener(ListenerType.PreInsert, new AuditEventListener()); cfg.SetListener(ListenerType.PreUpdate, new AuditEventListener()); cfg.SetProperty("command_timeout", TimeSpan.FromMinutes(5).TotalSeconds.ToString(CultureInfo.InvariantCulture)); }) .ExposeConfiguration(additional_function); return(config.BuildSessionFactory()); }
private static NHibernate.Cfg.Configuration Bootstrap(IPersistenceConfigurer persistenceConfigurer, IEnumerable <Assembly> mappingAssemblies) { var nhibernateConfiguration = Fluently.Configure() .Database(persistenceConfigurer) .Mappings(m => { foreach (var assembly in mappingAssemblies) { m.FluentMappings.AddFromAssembly(assembly); } m.FluentMappings.Conventions.Add(AutoImport.Never()); }) .ExposeConfiguration(c => { c.SetProperty(NHibernate.Cfg.Environment.BatchSize, "20"); c.SetProperty(NHibernate.Cfg.Environment.PrepareSql, "false"); c.SetProperty(NHibernate.Cfg.Environment.Hbm2ddlKeyWords, "none"); #if DEBUG c.SetProperty(NHibernate.Cfg.Environment.GenerateStatistics, "true"); #endif c.SetProperty(NHibernate.Cfg.Environment.ConnectionDriver, typeof(StackExchange.Profiling.NHibernate.Drivers.MiniProfilerSql2008ClientDriver).AssemblyQualifiedName); }) .BuildConfiguration(); return(nhibernateConfiguration); }
public static void ConfigureDataAccess(IPersistenceConfigurer databaseConfigurer, InstanceScope sessionScope, out NHibernate.Cfg.Configuration cfg) { NHibernate.Cfg.Configuration configuration = null; ObjectFactory.Initialize(i => ConfigureDataAccess(i, databaseConfigurer, sessionScope, out configuration)); ObjectFactory.AssertConfigurationIsValid(); cfg = configuration; }
public Configuration BuildConfiguration(IPersistenceConfigurer persistenceConfigurer) { return(Fluently.Configure() .Database(persistenceConfigurer) .Mappings(ConfigureMappings) .BuildConfiguration()); }
public void OnlyOnce() { _configurer = new SqLitePersistenceConfigurerFactory() .GetPersistenceConfigurer(); factory = new SessionFactoryBuilder(_configurer) .Build(); }
// This method gets called by the runtime. Use this method to add services to the container. public void ConfigureServices(IServiceCollection services) { services.AddControllersWithViews(); services.AddRazorPages().AddRazorRuntimeCompilation(); IPersistenceConfigurer dbConfig = MySQLConfiguration.Standard.ConnectionString("Server=localhost;Port=3306;Database=desafiopv;Uid=sances;Pwd=laranjauva;"); var _sessionFactory = Fluently.Configure() .Database(dbConfig) .Mappings(m => m.FluentMappings.AddFromAssembly(GetType().Assembly)) .ExposeConfiguration(cfg => new SchemaUpdate(cfg).Execute(false, true)) .BuildSessionFactory(); //Creates database structure services.AddScoped(factory => { return(_sessionFactory.OpenSession()); }); // services.AddScoped(factory => //{ // return ConnectionNH.StartSession(); //}); }
public static SessionFactoryInfo GetFromAssemblyOf <T>(IPersistenceConfigurer configurer, FluentNHibernatePersistenceBuilderOptions options = null) { return(GetFromAssemblies(new List <Assembly> { typeof(T).Assembly }, configurer, options)); }
private static NHibernateOrg.ISessionFactory CreateSessionFactoryFor( IEnumerable <string> mappingAssemblies, AutoPersistenceModel autoPersistenceModel, Configuration cfg, IPersistenceConfigurer persistenceConfigurer) { var fluentConfiguration = Fluently.Configure(cfg); if (persistenceConfigurer != null) { fluentConfiguration.Database(persistenceConfigurer); } fluentConfiguration.Mappings( m => { foreach (var mappingAssembly in mappingAssemblies) { var assembly = Assembly.LoadFrom(MakeLoadReadyAssemblyName(mappingAssembly)); m.HbmMappings.AddFromAssembly(assembly); m.FluentMappings.AddFromAssembly(assembly).Conventions.AddAssembly(assembly); } if (autoPersistenceModel != null) { m.AutoMappings.Add(autoPersistenceModel); } }); fluentConfiguration.ExposeConfiguration(c => ConfigureValidator(c)); return(fluentConfiguration.BuildSessionFactory()); }
private ISessionFactory CreateSessionFactory() { FluentConfiguration fluentConfiguration = Fluently.Configure(); IPersistenceConfigurer sqlConfiguration = CreateSqlConfiguration(); if (sqlConfiguration != null) { fluentConfiguration = fluentConfiguration.Database(sqlConfiguration); } mappingResolver.AddAvailableMappings(fluentConfiguration); var eventListenerHelper = new EventListenerHelper(securityService); var saveOrUpdateEventListener = new SaveOrUpdateEventListener(eventListenerHelper); var deleteEventListener = new DeleteEventListener(eventListenerHelper); fluentConfiguration = fluentConfiguration .Mappings(m => m.FluentMappings .Conventions.Add(ForeignKey.EndsWith("Id")) .Conventions.Add <EnumConvention>()) .ExposeConfiguration(c => c.SetProperty("show_sql", "false")) .ExposeConfiguration(c => c.SetListener(ListenerType.Delete, deleteEventListener)) .ExposeConfiguration(c => c.SetListener(ListenerType.SaveUpdate, saveOrUpdateEventListener)) .ExposeConfiguration(c => c.SetListener(ListenerType.Save, saveOrUpdateEventListener)) .ExposeConfiguration(c => c.SetListener(ListenerType.Update, saveOrUpdateEventListener)); return(fluentConfiguration .BuildConfiguration() .BuildSessionFactory()); }
public static DerivedInfo GetDerivedConnectionInfo(IPersistenceConfigurer configurer) { var toPropertiesMethodName = nameof(Tmp.ToProperties); var genericBaseType = configurer.GetType().GetBaseTypes().FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(PersistenceConfiguration <,>)); if (genericBaseType != null) { var genericType = typeof(PersistenceConfiguration <,>).MakeGenericType(genericBaseType.GetGenericArguments()); var methodInfo = genericType.GetMethod(toPropertiesMethodName); if (methodInfo != null && methodInfo.GetParameters().Length == 0) { var result = new DerivedInfo(); var connectionString = methodInfo.Invoke(configurer, null) as IDictionary <string, string>; if (connectionString != null) { result.ConnectionString = connectionString[Tmp.ConnectionStringKey]; if (connectionString.ContainsKey(Tmp.DefaultSchemaKey)) { result.DefaultSchema = connectionString[Tmp.DefaultSchemaKey]; } } return(result); } } return(null); }
private static ISessionFactory CreateSessionFactoryFor( string[] mappingAssemblies, AutoPersistenceModel autoPersistenceModel, Configuration cfg, IPersistenceConfigurer persistenceConfigurer) { FluentConfiguration fluentConfiguration = Fluently.Configure(cfg); if (persistenceConfigurer != null) { fluentConfiguration.Database(persistenceConfigurer); } fluentConfiguration.Mappings(m => { foreach (var mappingAssembly in mappingAssemblies) { var assembly = Assembly.LoadFrom(MakeLoadReadyAssemblyName(mappingAssembly)); m.HbmMappings.AddFromAssembly(assembly); m.FluentMappings.AddFromAssembly(assembly) .ConventionDiscovery.AddAssembly(assembly); } if (autoPersistenceModel != null) { m.AutoMappings.Add(autoPersistenceModel); } }); return(fluentConfiguration.BuildSessionFactory()); }
public static ISessionFactory CreateSessionFactory(IPersistenceConfigurer persistenceConfigurer = null, NHibernateConfigurationConfigurationOptions configurationOptions = NHibernateConfigurationConfigurationOptions.UpdateDB) { return(Fluently.Configure() .Database(persistenceConfigurer) .Mappings(m => m.FluentMappings.AddFromAssemblyOf <VisitMap>()) //.Mappings(m => m.FluentMappings.AddFromAssemblyOf<WayMap>()) //.Mappings(m => m.FluentMappings.AddFromAssemblyOf<PeriodMap>()) .ExposeConfiguration(cfg => { Config = cfg; switch (configurationOptions) { case NHibernateConfigurationConfigurationOptions.RecreateDB: var export = new SchemaExport(cfg); export.Drop(false, true); export.Create(false, true); break; case NHibernateConfigurationConfigurationOptions.UpdateDB: new SchemaUpdate(cfg).Execute(false, true); break; case NHibernateConfigurationConfigurationOptions.None: break; default: throw new ArgumentOutOfRangeException(nameof(configurationOptions), configurationOptions, "unexpected"); } }) .BuildSessionFactory()); }
protected virtual void Session_Start(Object sender, EventArgs e) { IPersistenceConfigurer config = PostgreSQLConfiguration.PostgreSQL82.ConnectionString("Server=" + ConfigurationManager.AppSettings["PostgreSQL"] + ";Port=5432;Database=rising_sun_web;User Id=postgres;Password=password;SSL=true;"); ISessionFactory factory = Fluently.Configure() .Database(config) .Mappings(m => m.FluentMappings.AddFromAssemblyOf <WebUser>()) .BuildSessionFactory(); this.Session["User?Session"] = factory.OpenSession(); config = PostgreSQLConfiguration.PostgreSQL82.ConnectionString("Server=" + ConfigurationManager.AppSettings["PostgreSQL"] + ";Port=5432;Database=rising_sun;User Id=postgres;Password=password;SSL=true;"); factory = Fluently.Configure() .Database(config) .Mappings(m => m.FluentMappings.AddFromAssemblyOf <PersistentScan>()) .Mappings(m => m.FluentMappings.AddFromAssemblyOf <PersistentNessusScan>()) .Mappings(m => m.FluentMappings.AddFromAssemblyOf <PersistentOpenVASScan>()) .Mappings(m => m.FluentMappings.AddFromAssemblyOf <PersistentNexposeScan>()) .Mappings(m => m.FluentMappings.AddFromAssemblyOf <PersistentMetasploitScan>()) .BuildSessionFactory(); this.Session["Service?Session"] = factory.OpenSession(); }
/// <summary> /// Metodo responsavel por executar o mapeamento das classes com o banco de dados /// </summary> /// <param name="databaseConfigurer"></param> /// <param name="validatorEngine"></param> /// <returns></returns> private static ISessionFactory ConfigureNHibernate(IPersistenceConfigurer databaseConfigurer, out ValidatorEngine validatorEngine) { ValidatorEngine ve = null; ISessionFactory factory = Fluently.Configure() .Database(databaseConfigurer) .Mappings(m => m.FluentMappings.AddFromAssemblyOf <FornecedorMap>() .Conventions.Add(typeof(CascadeAll)) ) .Cache(x => x.UseQueryCache() .UseSecondLevelCache() .ProviderClass <SysCacheProvider>() ) .ExposeConfiguration(c => { ve = ConfigureValidator(c); c.SetProperty("adonet.batch_size", "5"); c.SetProperty("generate_statistics", "false"); //c.SetProperty("cache.use_second_level_cache", "true"); }) .BuildConfiguration().BuildSessionFactory(); validatorEngine = ve; return(factory); }
public ISessionFactory build_session_factory(IPersistenceConfigurer db_configuration, Assembly assembly, string top_namespace, Action<Configuration> additional_function) { Log.bound_to(this).log_a_debug_event_containing("Building Session Factory"); var config = Fluently.Configure() .Database(db_configuration) .Mappings(m => { m.FluentMappings.Add(assembly.GetType(top_namespace + ".orm.VersionMapping", true, true)) .Add(assembly.GetType(top_namespace + ".orm.ScriptsRunMapping", true, true)) .Add(assembly.GetType(top_namespace + ".orm.ScriptsRunErrorMapping", true, true)); //.Conventions.AddAssembly(assembly); //m.HbmMappings.AddFromAssembly(assembly); }) .ExposeConfiguration(cfg => { // FIXME: Quick workaround for MySQL's defect with reserved words auto-quoting http://216.121.112.228/browse/NH-1906 //TODO:please verify fixed Diyan cfg.Properties["hbm2ddl.keywords"] = "none"; cfg.SetListener(ListenerType.PreInsert, new AuditEventListener()); cfg.SetListener(ListenerType.PreUpdate, new AuditEventListener()); }) .ExposeConfiguration(additional_function); return config.BuildSessionFactory(); }
private ISessionFactory BuildISessionFactory(IPersistenceConfigurer msSqlConfiguration) { return(Fluently.Configure() .Database(msSqlConfiguration) .Mappings(m => m.AutoMappings.Add(AutomappingConventions)) .BuildSessionFactory()); }
public static void Init(IPersistenceConfigurer databaseConfig, Action<Configuration> schemaConfiguration) { SessionFactory = Fluently.Configure() .Database( databaseConfig) .Mappings(m => m.FluentMappings.AddFromAssemblyOf<NHibernateConfiguration>()) .ExposeConfiguration(schemaConfiguration) .BuildSessionFactory(); }
private static FluentConfiguration GenerateFluentConfiguration(IPersistenceConfigurer dbConfiguration) { //return Fluently.Configure() // .Database(dbConfiguration) // .Mappings(m => m.FluentMappings.AddFromAssemblyOf<Item>()); return Fluently.Configure() .Database(dbConfiguration) .Mappings(m => m.HbmMappings.AddFromAssemblyOf<ContentItem>()); }
public static ISessionFactory Construct(IPersistenceConfigurer persistanceConfigurer) { return Fluently.Configure() .Database(persistanceConfigurer) .Mappings(x => x.FluentMappings.Add<AgentBucket.Map>()) .Mappings(x => x.FluentMappings.Add<GroupStatusBucket.Map>()) .Mappings(x => x.FluentMappings.Add<UserStatusBucket.Map>()) .BuildSessionFactory(); }
/// <summary> /// Creates a new session factory /// </summary> /// <param name="persistenceConfigurer">Method of connection (includes connection string)</param> /// <returns>New session factory</returns> public ISessionFactory CreateSessionFactory(IPersistenceConfigurer persistenceConfigurer) { // NOTE JetDriver fails to load copy .dll to console or main app output dir var config = new StoreConfiguration(); return Fluently.Configure() .Database(persistenceConfigurer) .Mappings(m => m.AutoMappings.Add(AutoMap.AssemblyOf<Employee>(config))) .BuildSessionFactory(); }
/// <summary> /// Creates a session factory using the configurer and the action /// </summary> /// <param name="configurer">Configuration for persistence to use</param> /// <param name="buildSchema">Optional schema generation</param> /// <returns></returns> public static ISessionFactory CreateSessionFactory(IPersistenceConfigurer configurer, Action<Configuration> buildSchema) { return Fluently .Configure() .ExposeConfiguration(buildSchema) .ExposeConfiguration(AddProxyConfiguration) .Database(configurer) .Mappings(m => m.AutoMappings.Add(AutoMap.AssemblyOf<Movie>())) .BuildSessionFactory(); }
protected DataProvider(IPersistenceConfigurer dbType) { var cfg = Fluently.Configure(); cfg.Database(dbType); cfg.Mappings(m => m.FluentMappings.AddFromAssemblyOf<DataModel>()); cfg.ExposeConfiguration(c => { c.Properties.Add("hbm2ddl.keywords", "none"); //fix for mysql Configuration = c; }); SessionFactory = cfg.BuildSessionFactory(); }
public ISessionFactory Construct(IPersistenceConfigurer persistanceConfigurer) { return _configuration ?? (_configuration = Fluently.Configure() .Database(persistanceConfigurer) .Mappings(m => m.FluentMappings.Add<ACDAgentDatum.Map>()) .Mappings(m => m.FluentMappings.Add<ACDAgentSplitDatum.Map>()) .Mappings(m => m.FluentMappings.Add<ACDSplitDatum.Map>()) .Mappings(m => m.FluentMappings.Add<CallSplit.Map>()) .Mappings(m => m.FluentMappings.Add<Device.Map>()) .Mappings(m => m.FluentMappings.Add<DeviceAgent.Map>()) .BuildSessionFactory()); }
public XangoConfiguration(Assembly domainAssembly, bool isWeb, IPersistenceConfigurer database, Assembly validationAssembly, Assembly overrideMapAssembly) { DomainAssembly = domainAssembly; IsWeb = isWeb; Database = database; ValidationAssembly = validationAssembly; OverrideMapAssembly = overrideMapAssembly; }
public static Configuration GetConfiguration(IPersistenceConfigurer persistentConf) { return Fluently.Configure() .Database(persistentConf) .Mappings(m => { //foreach (Tuple<MappingClassAttribute, Type> T in AttributeExtender.GetMarkedTypeInTheAssembly<MappingClassAttribute>()) m.FluentMappings.Add(T.Item2); AttributeExtender.GetMarkedTypeInTheAssembly<MappingClassAttribute>().Apply( t=> m.FluentMappings.Add(t.Item2)); m.FluentMappings.Conventions.Add(new BufferConvention()); }).BuildConfiguration(); }
private static ISessionFactory ConfigureNHibernate(IPersistenceConfigurer databaseConfigurer, NHibernate.Cfg.Configuration cfg) { var factory = Fluently.Configure(cfg) .Database(databaseConfigurer) .Mappings(m => m.FluentMappings.AddFromAssemblyOf<MovieSessionMap>()) .ExposeConfiguration(c => { c.SetProperty("adonet.batch_size", "5"); c.SetProperty("generate_statistics", "true"); }) .BuildSessionFactory(); return factory; }
public static NHibernate.Cfg.Configuration CreateFluentConfiguration(IPersistenceConfigurer persistenceConfigurer, IEnumerable<Assembly> mappingAssemblies) { return Fluently.Configure() .Database(persistenceConfigurer) .Mappings(m => { foreach (var assembly in mappingAssemblies) { m.FluentMappings.AddFromAssembly(assembly); //m.HbmMappings.AddFromAssembly(assembly); } }) .ExposeConfiguration(c => { c.SetProperty(NHibernate.Cfg.Environment.BatchSize, "20"); c.SetProperty(NHibernate.Cfg.Environment.GenerateStatistics, "true"); }) .BuildConfiguration(); }
private ISessionFactory GetSessionFactory(IPersistenceConfigurer dbconf) { var map = AutoMap .AssemblyOf<Meeting>() .Where(e => e.Namespace.EndsWith("Entities")) .Conventions.AddFromAssemblyOf<Meeting>() .UseOverridesFromAssemblyOf<Meeting>(); var factory = Fluently.Configure() .Database(dbconf) .Mappings(m => m.AutoMappings.Add(map)) .ExposeConfiguration(c => Configuration = c) .BuildSessionFactory(); return factory; }
public static Configuration GetDatabaseConfiguration(IPersistenceConfigurer databaseDriver, bool buildDatabase) { var fluentConfiguration = Fluently.Configure() .Database(databaseDriver) .Mappings(m => m.AutoMappings.Add( AutoMap.AssemblyOf<Player>(new DefaultMappingConfiguration()) .Conventions.AddFromAssemblyOf<IdGenerationConvention>() .UseOverridesFromAssemblyOf<OverMappingOverride>())); if (buildDatabase) { fluentConfiguration.ExposeConfiguration(BuildDatabase); } return fluentConfiguration.BuildConfiguration(); }
public Fluently ConfigureDatabase(IPersistenceConfigurer cfg) { lock (syncRoot) { currentFluentConfig.Database(cfg); // if (this.createDatabase) { currentFluentConfig.ExposeConfiguration(c => { new SchemaExport(c).Execute(false, true, false); }); } // currentNHConfig = currentFluentConfig.BuildConfiguration(); } return new Fluently(currentFluentConfig, currentNHConfig, this.createDatabase); }
public DataSessionProvider(DataManagerTechnology technology, string connectionInfo) { if (technology == DataManagerTechnology.SQLite) { persistanceConfigurer = SQLiteConfiguration.Standard.ConnectionString(connectionInfo); } else if (technology == DataManagerTechnology.MySql) { persistanceConfigurer = MySQLConfiguration.Standard.ConnectionString(connectionInfo); } else if (technology == DataManagerTechnology.MSSQL2008) { persistanceConfigurer = MsSqlConfiguration.MsSql2008.ConnectionString(connectionInfo); } else if (technology == DataManagerTechnology.MSSQL7) { persistanceConfigurer = MsSqlConfiguration.MsSql2008.ConnectionString(connectionInfo); } }
public Configuration CreateCoreDatabaseConfiguration( IPersistenceConfigurer databaseDriver, Action<Configuration> databaseBuilder = null) { var fluentConfiguration = Fluently.Configure() .Database(databaseDriver) .Mappings(m => m.AutoMappings.Add( AutoMap.AssemblyOf<Player>(new DefaultMappingConfiguration()) .Conventions.AddFromAssemblyOf<IdGenerationConvention>() .UseOverridesFromAssemblyOf<OverMappingOverride>())); if (databaseBuilder != null) { fluentConfiguration.ExposeConfiguration(databaseBuilder); } return fluentConfiguration.BuildConfiguration(); }
public static void ConfigureDataAccess(IInitializationExpression i, IPersistenceConfigurer databaseConfigurer, InstanceScope sessionScope, out NHibernate.Cfg.Configuration cfg) { cfg = new NHibernate.Cfg.Configuration(); i.ForRequestedType<ISessionFactory>() .CacheBy(InstanceScope.Singleton) .TheDefault.IsThis(ConfigureNHibernate(databaseConfigurer, cfg)); i.ForRequestedType<ISession>() .CacheBy(sessionScope) .TheDefault.Is.ConstructedBy(() => ObjectFactory.GetInstance<ISessionFactory> ().OpenSession()); //More StructureMap configuration goes here: //i.ForRequestedType<ISomeModelRepository>() // .CacheBy(InstanceScope.PerRequest) // .TheDefaultIsConcreteType<SomeModelRepository>(); }
private static void ConfigureDataAccess(ConfigurationExpression i, IPersistenceConfigurer databaseConfigurer) { ValidatorEngine validatorEngine; //Configura o IoC para session factory do nhibernate ser singleton por toda a aplicação i.For<ISessionFactory>() .Singleton() .Use(ConfigureNHibernate(databaseConfigurer, out validatorEngine)); //Configura o IoC para criar uma nova sessão a cada requisição i.For<ISession>() .LifecycleIs(Lifecycles.GetLifecycle(InstanceScope.PerRequest)) .Use(() => ObjectFactory.GetInstance<ISessionFactory> ().OpenSession()); //Configura o validador de entidades do nhibernate i.For<ValidatorEngine>() .Singleton() .Use(validatorEngine); }
public Database( IPersistenceConfigurer persistenceConfigurer, Assembly classMapAssembly, Action<Configuration> configAction = null, bool resetSchema = false) { if (configAction==null) configAction = configuration => { }; _sessionFactory = Fluently.Configure() .Database(() => persistenceConfigurer) .Mappings(m => m.FluentMappings.AddFromAssembly(classMapAssembly)) .ExposeConfiguration(config => { if (resetSchema) new SchemaExport(config).Create(false, true); configAction(config); }) .BuildSessionFactory(); }
public ISessionFactory build_session_factory(IPersistenceConfigurer db_configuration, Assembly assembly, string top_namespace, Action<Configuration> additional_function) { Log.bound_to(this).log_a_debug_event_containing("Building Session Factory"); var config = Fluently.Configure() .Database(db_configuration) .Mappings(m => { m.FluentMappings.Add(assembly.GetType(top_namespace + ".orm.VersionMapping", true, true)) .Add(assembly.GetType(top_namespace + ".orm.ScriptsRunMapping", true, true)) .Add(assembly.GetType(top_namespace + ".orm.ScriptsRunErrorMapping", true, true)); //.Conventions.AddAssembly(assembly); //m.HbmMappings.AddFromAssembly(assembly); }) .ExposeConfiguration(cfg => { if (is_merged) { const string proxy_factory = "proxyfactory.factory_class"; string proxy_factory_merged_name = proxy_factory_name + ", " + ApplicationParameters.get_merged_assembly_name(); if (cfg.Properties.ContainsKey(proxy_factory)) { cfg.Properties[proxy_factory] = proxy_factory_merged_name; } else { cfg.Properties.Add(proxy_factory, proxy_factory_merged_name); } } // FIXME: Quick workaround for MySQL's defect with reserved words auto-quoting http://216.121.112.228/browse/NH-1906 cfg.Properties["hbm2ddl.keywords"] = "none"; cfg.SetListener(ListenerType.PreInsert, new AuditEventListener()); cfg.SetListener(ListenerType.PreUpdate, new AuditEventListener()); }) .ExposeConfiguration(additional_function); return config.BuildSessionFactory(); }
public NHibernateSQLiteDatastoreModule(IPersistenceConfigurer persConf, Action<FluentConfiguration> configAction,params Assembly[] mappingAssemblies) { _persConf = persConf; _mappingAssemblies = mappingAssemblies; _configAction = configAction; }