/// <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;
}
