/// <summary>
/// The build factory.
/// </summary>
/// <returns>
/// The <see cref="ISessionFactory"/>.
/// </returns>
private ISessionFactory BuildFactory()
{
ISessionFactory buildSessionFactory = Fluently.Configure().Database(
MsSqlConfiguration.MsSql2008.ConnectionString(
@"Data Source=TOMEK;Initial Catalog=BlogSamples;Integrated Security=True").ShowSql())
.Mappings(val => val.AutoMappings.Add(AutoMap.AssemblyOf <Project>(new DefaultAutomappingConfiguration()).Conventions.Setup(con =>
{
con.Add(AutoImport.Never());
con.Add <DefaultTableNameConvention>();
con.Add <DefaultPrimaryKeyConvention>();
con.Add <DefaultStringLengthConvention>();
con.Add <DefaultReferenceConvention>();
con.Add <DefaultHasManyConvention>();
})))
.ExposeConfiguration(val =>
{
val.Properties["format_sql"] = "true";
//uncomment if you want to create database schema based on mappings
// new SchemaExport(val).Execute(true, true, false);
})
.BuildSessionFactory();
return
(buildSessionFactory);
}
public virtual void SetUpNHibernate(bool rebulidSchema, params Type[] mapperTypes)
{
//ISessionFactory sessionFactory = NbSessionFactoryProvider.CurrentNbSessionFactory("app").SessionFactory();
ISessionFactory sessionFactory = NHibernateHelper.SessionFactory();
if (sessionFactory == null)
{
string connStr = GetConnStr();
var dbCfg = GetConfigurer(connStr);
NHibernateHelper.InitSessionFactory(dbCfg,
m =>
{
var conventions = FluentNhibernateConvertions.Conventions;
if (conventions != null && conventions.Count > 0)
{
foreach (var hibernateMappingConvention in conventions)
{
var convention = hibernateMappingConvention;
m.FluentMappings.Conventions.Setup(x => x.Add(convention));
}
}
//解决同类名映射问题
m.FluentMappings.Conventions.Setup(x => x.Add(AutoImport.Never()));
foreach (var mapperType in mapperTypes)
{
m.FluentMappings.AddFromAssembly(mapperType.Assembly);
}
},
rebulidSchema, "", true, true, false);
}
}
/// <summary>
///
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public Configuration BuildConfiguration(SessionFactoryParameters parameters)
{
try
{
var database = GetPersistenceConfigurer(parameters.CreateDatabase);
var assemblies = parameters.RecordDescriptors.Select(x => x.Type.Assembly).Distinct();
return(Fluently.Configure()
.Database(database)
.Mappings(m =>
{
foreach (var assembly in assemblies)
{
m.FluentMappings.AddFromAssembly(assembly);
}
m.FluentMappings
.Conventions.AddSource(new TypeSource(parameters.RecordDescriptors))
.Conventions.Setup(x => x.Add(AutoImport.Never()))
.Conventions.Add(new RecordTableNameConvention(parameters))
.Conventions.Add(new CacheConvention(parameters.RecordDescriptors))
.Conventions.AddFromAssemblyOf <DataModule>();
})
.ExposeConfiguration(ExposeConfig)
.BuildConfiguration());
}
catch (Exception e)
{
Logger.Error(e, "AbstractDataServicesProvider.BuildConfiguration");
}
return(null);
}
public static void Initialise(string connectionString)
{
if (_sessionFactory != null)
{
throw new NotImplementedException("Session Factory already initialised");
}
NHibernate.Cfg.Configuration configuration = null;
var fluentConfig = Fluently.Configure()
.Database(
MsSqlConfiguration
.MsSql2008
.ConnectionString(connectionString)
.AdoNetBatchSize(100))
//.Cache(cache => cache.ProviderClass<NHibernate.Caches.SysCache.SysCacheProvider>().UseQueryCache().UseSecondLevelCache().UseMinimalPuts())
.ExposeConfiguration(cfg => configuration = cfg);
var mappings = GetMappingConfigurations();
fluentConfig.Mappings(m => m.FluentMappings.Conventions.Setup(x => x.Add(AutoImport.Never())));
foreach (Action <MappingConfiguration> mapping in mappings)
{
fluentConfig.Mappings(mapping);
}
_sessionFactory = fluentConfig.BuildSessionFactory();
_nHibernateConfiguration = configuration;
}
public static SessionFactoryAndConfiguration Configure(DbOption option)
{
Configuration cfg = null;
// Configurando o NHibernate usando o Fluent NHibernate.
FluentConfiguration config = Fluently.Configure()
.Database(
MsSqlConfiguration.MsSql2008
.ConnectionString(c => c.FromAppSetting("connectionString"))
.ShowSql())
.Cache(c => c.UseQueryCache().ProviderClass <HashtableCacheProvider>());
foreach (var assemblyName in AppSettingsHelper.GetValue("mappingAssemblies").Split(','))
{
System.Console.WriteLine("carregando assembly " + assemblyName);
config.Mappings(x => x.FluentMappings.Conventions
.Setup(m => m.Add(AutoImport.Never()))
.AddFromAssembly(Assembly.Load(assemblyName)));
}
config.ExposeConfiguration(cfg1 => DbCreateOrUpdate(option, cfg = cfg1));
var sessionFactory = config.BuildSessionFactory();
//cfg.SetListener(ListenerType.Delete, new DeleteListener());
return(new SessionFactoryAndConfiguration(sessionFactory, cfg));
}
private void InitialiseSessionFactory()
{
// We only want one copy of this
if (_sessionFactory == null)
{
var firstConfig =
Fluently.Configure()
.Database
(
MsSqlConfiguration.MsSql2008
.UseOuterJoin()
.ShowSql()
.FormatSql()
.ConnectionString(c => c.Is(_settingsService.GetStringValue("Database:ConnectionString"))))
.Mappings(m =>
{
m.FluentMappings
.Conventions
.Setup(x =>
{
x.Add(AutoImport.Never());
})
.AddFromAssemblyOf <FilmMap>();
}
);
_sessionFactory =
firstConfig
.ExposeConfiguration(
c => c.SetProperty(
"current_session_context_class",
_settingsService.GetStringValue("Database:SessionContext")))
.BuildSessionFactory();
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var allAssemblies = AppDomain.CurrentDomain.GetAssemblies();
var myAssembly = allAssemblies
.Where(a => a.GetName().Name.Contains("SimpleWebApi")).FirstOrDefault();
var cfg = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012.ConnectionString(Configuration.GetConnectionString("myConnectionString")))
.ExposeConfiguration(c =>
{
c.SetProperty(Environment.Isolation, "ReadUncommitted");
c.SetProperty(Environment.GenerateStatistics, "true");
c.SetProperty(Environment.ShowSql, "true");
c.SetProperty(Environment.UseSecondLevelCache, "false");
c.SetProperty(Environment.UseQueryCache, "false");
c.SetProperty(Environment.CommandTimeout,
TimeSpan.FromSeconds(30).TotalSeconds.ToString(CultureInfo.InvariantCulture));
})
.Mappings(_ =>
{
_.FluentMappings
.Conventions.Setup(x => x.Add(AutoImport.Never()))
.AddFromAssembly(myAssembly);
});
SessionFactory = cfg.BuildConfiguration().BuildSessionFactory();
services.AddSingleton(SessionFactory);
services.AddScoped(factory => SessionFactory.OpenSession());
services.AddControllers();
}
protected virtual void MapeiaTiposDeAssembly(FluentConfiguration configuration)
{
//Autoimport set to false because there are 2 mappings
configuration.Mappings(m => m.FluentMappings
.Conventions.Setup(x => x.Add(AutoImport.Never()))
.AddFromAssemblyOf <Funcionario>());
}
/// <summary>
/// 配置Nh
/// </summary>
/// <param name="connName"></param>
/// <param name="rebulidSchema"></param>
/// <param name="mapperAssemblies">要从中查找的FluentNH的类映射的程序集</param>
/// <param name="sessionFactoryKey">SessionFactory名，标识不同的SessionFactory, 默认名为Empty</param>
/// <param name="conventions"></param>
public static void InitSessionFactory(string connName, bool rebulidSchema, IList <Assembly> mapperAssemblies, string sessionFactoryKey = "", params IHibernateMappingConvention[] conventions)
{
if (string.IsNullOrWhiteSpace(connName))
{
throw new ArgumentException("必须指定connName");
}
string connStr = ConfigurationManager.ConnectionStrings[connName].ConnectionString;
var dbConfig = MsSqlConfiguration.MsSql2005.ConnectionString(connStr);
Action <MappingConfiguration> mappings = m =>
{
if (conventions != null && conventions.Length > 0)
{
foreach (var hibernateMappingConvention in conventions)
{
var convention = hibernateMappingConvention;
m.FluentMappings.Conventions.Setup(x => x.Add(convention));
}
}
//解决同类名映射问题
m.FluentMappings.Conventions.Setup(x => x.Add(AutoImport.Never()));
if (mapperAssemblies != null && mapperAssemblies.Count > 0)
{
//需要在站架子统一注册的mapper
foreach (var mapperAssembly in mapperAssemblies)
{
m.FluentMappings.AddFromAssembly(mapperAssembly);
}
}
};
InitSessionFactory(dbConfig, mappings, rebulidSchema, sessionFactoryKey);
}
public static AutoPersistenceModel CreatePersistenceModel(ICollection <RecordBlueprint> recordDescriptors)
{
if (recordDescriptors == null)
{
throw new ArgumentNullException("recordDescriptors");
}
return(AutoMap.Source(new TypeSource(recordDescriptors))
// Ensure that namespaces of types are never auto-imported, so that
// identical type names from different namespaces can be mapped without ambiguity
.Conventions.Setup(x => x.Add(AutoImport.Never()))
//此处覆写Table("name"); 本来为统一处理表名（如增加前缀等），现由各个模块自己配置表名
//.Conventions.Add(new RecordTableNameConvention(recordDescriptors))
.Conventions.Add(new CacheConventions(recordDescriptors))
.Alterations(alt =>
{
foreach (var recordAssembly in recordDescriptors.Select(x => x.Type.Assembly).Distinct())
{
alt.Add(new AutoMappingOverrideAlteration(recordAssembly));
}
alt.AddFromAssemblyOf <DataModule>();
//alt.Add(new ContentItemAlteration(recordDescriptors));
})
.Conventions.AddFromAssemblyOf <DataModule>());
}
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);
}
private void InitSessionFactory()
{
string databaseType = AppSettingsHelper.GetValue("databaseType");
if (string.IsNullOrEmpty(databaseType))
{
databaseType = "MsSql2008";
}
FluentConfiguration config = Fluently.Configure();
switch (databaseType)
{
case "MySql":
config.Database(MySQLConfiguration.Standard.ConnectionString(c => c.FromAppSetting("connectionString")).ShowSql());
break;
case "MsSql2008":
config.Database(MsSqlConfiguration.MsSql2008.ConnectionString(c => c.FromAppSetting("connectionString")).ShowSql());
break;
case "MsSql2012":
config.Database(MsSqlConfiguration.MsSql2012.ConnectionString(c => c.FromAppSetting("connectionString")).ShowSql());
break;
}
foreach (var assemblyName in AppSettingsHelper.GetValue("mappingAssemblies").Split(','))
{
config.Mappings(x => x.FluentMappings.Conventions.Setup(m => m.Add(AutoImport.Never())).AddFromAssembly(Assembly.Load(assemblyName)));
}
sessionFactory = config.BuildSessionFactory();
}
public void ShouldSetDefaultAccessToValue()
{
model.Add(new ClassMap <Target>());
model.Conventions.Add(AutoImport.Never());
model.BuildMappings()
.First()
.AutoImport.ShouldEqual(false);
}
public static ISessionFactory BuildSessionFactory(string connectionStringName, bool create = false, bool update = false)
{
return(Fluently.Configure().Database(MsSqlConfiguration.MsSql2012.ConnectionString(connectionStringName))
.Mappings(m =>
{
m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly());
m.FluentMappings.Conventions.Add(AutoImport.Never());
}
).CurrentSessionContext("call").ExposeConfiguration(cfg => BuildSchema(cfg, create, update)).BuildSessionFactory());
}
private static void AddMappings(MappingConfiguration mappings)
{
mappings.FluentMappings.Conventions.Add <IHibernateMappingConvention>(AutoImport.Never());
foreach (System.Reflection.Assembly current in NHibernateManager.FluentAssemblies.Distinct <System.Reflection.Assembly>().ToList <System.Reflection.Assembly>())
{
mappings.FluentMappings.AddFromAssembly(current);
}
foreach (System.Reflection.Assembly current in NHibernateManager.HbmAssemblies.Distinct <System.Reflection.Assembly>().ToList <System.Reflection.Assembly>())
{
mappings.HbmMappings.AddFromAssembly(current);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
string _db_filename = @"c:\tempsq\web-builder.sq3";
services.AddSingleton <FluentConfiguration>((provider) => {
var cfg2 = Fluently.Configure();
cfg2.Database(SQLiteConfiguration.Standard.UsingFile(_db_filename));
cfg2.Mappings(m =>
{
m.FluentMappings.Conventions.Setup(c => c.Add(AutoImport.Never()));
m.FluentMappings.Conventions.AddAssembly(Assembly.GetExecutingAssembly());
m.HbmMappings.AddFromAssembly(Assembly.GetExecutingAssembly());
var assembly = Assembly.Load("web");
m.FluentMappings.Conventions.AddAssembly(assembly);
m.FluentMappings.AddFromAssembly(assembly);
m.HbmMappings.AddFromAssembly(assembly);
});
cfg2.ExposeConfiguration(cfg =>
{
cfg.SetProperty("current_session_context_class", "thread_static");
_cfg = cfg;
});
return(cfg2);
});
services.AddSingleton <NHibernate.ISessionFactory>((provider) => {
var cfg = provider.GetService <FluentConfiguration>();
var fact = cfg.BuildSessionFactory();
return(fact);
});
services.AddScoped <NHibernate.ISession>((provider) =>
{
var cfg = provider.GetService <FluentConfiguration>();
NHibernate.ISessionFactory factory = provider.GetService <NHibernate.ISessionFactory>();
return(factory.OpenSession());
});
services.AddScoped <NHibernate.Cfg.Configuration>((provider) =>
{
return(_cfg);
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}
private void HandleMappings(MappingConfiguration cfg)
{
cfg.HbmMappings.AddFromAssemblyOf <SessionManager <T> >();
cfg.FluentMappings
.AddFromAssembly(GetType().Assembly)
.Conventions.AddAssembly(GetType().Assembly)
.Conventions.Add(
AutoImport.Always(),
ForeignKey.EndsWith("ID"),
LazyLoad.Always(),
DefaultCascade.None(),
DynamicInsert.AlwaysTrue(),
DynamicUpdate.AlwaysTrue());
}
public void InitialiseNHibernate(params Assembly[] assemblies)
{
SessionFactory = Fluently.Configure().Database((SQLiteConfiguration.Standard.InMemory().FormatSql().ShowSql)).Mappings(delegate(MappingConfiguration m)
{
m.FluentMappings.Conventions.Add(AutoImport.Never());
foreach (Assembly assembly in HbmAssemblies)
{
m.HbmMappings.AddFromAssembly(assembly);
}
Assembly[] assemblies2 = assemblies;
foreach (Assembly assembly in assemblies2)
{
m.FluentMappings.AddFromAssembly(assembly);
}
}).ExposeConfiguration((BuildSchema)).BuildSessionFactory();
}
public static void CriarTabela(string nomeDaConexao)
{
FluentConfiguration configuracao = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012
.ConnectionString(x => x.FromConnectionStringWithKey(nomeDaConexao)))
.ExposeConfiguration(cfg => new SchemaExport(cfg).Create(true, true))
.Mappings(x => {
x.FluentMappings.Conventions.Setup(y => {
y.AddFromAssemblyOf <ColumnConvention>();
y.Add(AutoImport.Never());
});
x.FluentMappings.AddFromAssemblyOf <CursoMap>();
});
configuracao.BuildSessionFactory();
}
public static AutoPersistenceModel CreatePersistenceModel(IEnumerable <RecordBlueprint> recordDescriptors)
{
return(AutoMap.Source(new TypeSource(recordDescriptors))
// Ensure that namespaces of types are never auto-imported, so that
// identical type names from different namespaces can be mapped without ambiguity
.Conventions.Setup(x => x.Add(AutoImport.Never()))
.Conventions.Add(new RecordTableNameConvention(recordDescriptors))
.Alterations(alt => {
foreach (var recordAssembly in recordDescriptors.Select(x => x.Type.Assembly).Distinct())
{
alt.Add(new AutoMappingOverrideAlteration(recordAssembly));
}
alt.AddFromAssemblyOf <DataModule>();
alt.Add(new ContentItemAlteration(recordDescriptors));
})
.Conventions.AddFromAssemblyOf <DataModule>());
}
//[Ignore]
public void GerarSchema()
{
FluentConfiguration config = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012
.ConnectionString(c => c.FromAppSetting("connectionString")).ShowSql());
foreach (var assemblyName in AppSettingsHelper.GetValue("mappingAssemblies").Split(','))
{
System.Console.WriteLine("carregando assembly " + assemblyName);
config.Mappings(x => x.FluentMappings.Conventions
.Setup(m => m.Add(AutoImport.Never()))
.AddFromAssembly(Assembly.Load(assemblyName)));
}
config.ExposeConfiguration(BuildSchema);
config.BuildSessionFactory();
}
public static ISessionFactory OneISessionFactory()
{
if (_oneISessionFactory == null)
{
var configurer = PostgreSQLConfiguration.PostgreSQL82.ConnectionString(ConnectionString);
var configMap = Fluently.Configure()
.Database(configurer)
.ExposeConfiguration(c => c.SetProperty(global::NHibernate.Cfg.Environment.ReleaseConnections, "on_close"))
// Remova esse comentário se quizer mostrar os Sqls no output.
//.ExposeConfiguration(c => c.SetInterceptor(new SqlStatementInterceptor()))
.Mappings(m =>
{
m.FluentMappings.Conventions.Setup(s => s.Add(AutoImport.Never()));
m.FluentMappings.AddFromAssembly(System.Reflection.Assembly.GetExecutingAssembly());
m.FluentMappings.Conventions.Add(ConventionBuilder.Class.Always(x => x.Not.LazyLoad()));
m.FluentMappings.Conventions.Add(ConventionBuilder.Reference.Always(x => x.Cascade.None()));
m.FluentMappings.Conventions.Add(ConventionBuilder.Reference.Always(x => x.LazyLoad()));
m.FluentMappings.Conventions.Add(ConventionBuilder.HasMany.Always(x => x.LazyLoad()));
m.FluentMappings.Conventions.Add(ConventionBuilder.HasManyToMany.Always(x => x.LazyLoad()));
m.FluentMappings.Conventions.Add(ConventionBuilder.HasMany.Always(x => x.Cascade.None()));
m.FluentMappings.Conventions.Add(
ConventionBuilder.Property.When(
c => c.Expect(p => p.Property.PropertyType == typeof(string)),
i => i.CustomType("AnsiString")
)
);
});
if (false)
{
configMap.ExposeConfiguration(cfg => new SchemaExport(cfg).Execute(true, true, false));
}
if (false)
{
configMap.ExposeConfiguration(cfg => new SchemaUpdate(cfg).Execute(false, true));
}
_oneISessionFactory = configMap.BuildSessionFactory();
}
return(_oneISessionFactory);
}
private ISessionFactory CreateSessionFactory()
{
return(Fluently.Configure()
.Database(SQLiteConfiguration.Standard.InMemory().ShowSql())
.Mappings(m =>
{
m.FluentMappings.Conventions.Setup(c => c.Add(AutoImport.Never()));
m.FluentMappings.Conventions.AddAssembly(Assembly.GetExecutingAssembly());
m.HbmMappings.AddFromAssembly(Assembly.GetExecutingAssembly());
var assembly = Assembly.Load("foo");
m.FluentMappings.Conventions.AddAssembly(assembly);
m.FluentMappings.AddFromAssembly(assembly);
m.HbmMappings.AddFromAssembly(assembly);
})
.ExposeConfiguration(cfg => _configuration = cfg)
.BuildSessionFactory());
}
public virtual ISessionFactory CriarSessionFactory(ServidorDePublicacao servidorDePublicacao, bool exibirSql = false, bool criarBd = false)
{
var nomeStringDeConexao = "SqlServer" + (servidorDePublicacao == ServidorDePublicacao.Producao ? string.Empty : "-" + servidorDePublicacao);
return(Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2008.ConnectionString(c => c.FromConnectionStringWithKey(nomeStringDeConexao)))
.CurrentSessionContext <TSessionContext>()
.Mappings(x => x.FluentMappings.AddFromAssembly(CurrentAssembly)
.Conventions.Add(AutoImport.Never())
.Conventions.Add <PrimaryKeyConvention>()
.Conventions.Add <ConvencaoEnum>()
.Conventions.Add <CustomForeignKeyConvention>())
.ExposeConfiguration(config =>
{
config.SetProperty("command_timeout", "45");
new SchemaExport(config).Drop(exibirSql, criarBd);
new SchemaExport(config).Create(exibirSql, criarBd);
})
.BuildSessionFactory());
}
public AutoPersistenceModel CreateModel()
{
var conventions = Conventions.ToArray <IConvention>();
var theTypes = TypeSource.GetTypes();
return(AutoMap.Source(TypeSource)
// Ensure that namespaces of types are never auto-imported, so that
// identical type names from different namespaces can be mapped without ambiguity
.Conventions.Setup(x => x.Add(AutoImport.Never()))
.Conventions.Add(conventions)
.Alterations(alt =>
{
foreach (var recordAssembly in theTypes.Select(x => x.Assembly).Union(new[] { typeof(IExtensiblePersistenceModelFactory).Assembly }).Distinct())
{
alt.Add(new AutoMappingOverrideAlteration(recordAssembly));
}
foreach (var custAlt in Alterations)
{
alt.Add(custAlt);
}
}));
}
public static void GerarHBM(string nomeDaConexao)
{
string dir = AppInfo.Local(@"~\NHibernate\TvWeb.Portal");
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
FluentConfiguration configuracao = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012
.Dialect <CustomSqlDialectMsSql2012>()
.ConnectionString(x => x.FromConnectionStringWithKey(nomeDaConexao)))
.Mappings(x => {
x.FluentMappings.Conventions.Setup(y => {
y.AddFromAssemblyOf <ColumnConvention>();
y.Add(AutoImport.Never());
});
x.FluentMappings.AddFromAssemblyOf <CursoMap>().ExportTo(dir);
});
configuracao.BuildSessionFactory();
}
private static ISessionFactory CreateSessionFactory(string jobname)
{
string db_fileName = RegistryHelper.CheckDBFile();
return(Fluently.Configure()
.Database(SQLiteConfiguration.Standard.UsingFile(db_fileName))
.Mappings(m =>
{
m.FluentMappings.Conventions.Setup(c => c.Add(AutoImport.Never()));
m.FluentMappings.Conventions.AddAssembly(Assembly.GetExecutingAssembly());
m.HbmMappings.AddFromAssembly(Assembly.GetExecutingAssembly());
var assembly = Assembly.Load("ComediaCore");
m.FluentMappings.Conventions.AddAssembly(assembly);
m.FluentMappings.AddFromAssembly(assembly);
m.HbmMappings.AddFromAssembly(assembly);
})
.ExposeConfiguration(cfg =>
{
cfg.SetProperty("current_session_context_class", "thread_static");
_configuration = cfg;
})
.BuildSessionFactory());
}
public static ISessionFactory Create(DbConfigurations dbConfigurations)
{
NHibernateLogger.SetLoggersFactory(new SerilogLoggerFactory());
if (dbConfigurations.UseNodaTime)
{
NpgsqlConnection.GlobalTypeMapper.UseNodaTime();
}
var dbConfigurations1 = dbConfigurations;
var persistenceCfg = PostgreSQLConfiguration.Standard
.Provider <global::NHibernate.Connection.DriverConnectionProvider>()
.Dialect <PostgreSQL83Dialect>()
.Driver <NpgsqlDriverExtended>()
.ConnectionString(dbConfigurations1.ConnectionString);
if (dbConfigurations.UseNetTopologySuite)
{
NpgsqlConnection.GlobalTypeMapper.UseRawPostgis();
persistenceCfg.Dialect <global::NHibernate.Spatial.Dialect.PostGis20Dialect>();
}
var cfg = Fluently.Configure()
.Database(persistenceCfg)
.Mappings(x =>
{
dbConfigurations1.EntityTypeAssemblies.ForEach(y => x.FluentMappings.AddFromAssembly(y));
x.FluentMappings.Conventions.Setup(y => y.Add(AutoImport.Never()));
if (dbConfigurations.UseNodaTime)
{
x.FluentMappings.Conventions.Add <NodaTimeConventions>();
}
if (dbConfigurations.UseNetTopologySuite)
{
x.FluentMappings.Conventions.Add <PostGisConventions>();
}
x.FluentMappings.Conventions.Add <GeneralConventions>();
x.FluentMappings.Conventions.Add <ListConventions>();
x.FluentMappings.Conventions.Add <RangeConventions>();
x.FluentMappings.Conventions.Add <JsonConventions>();
})
.ExposeConfiguration(x =>
{
if (!string.IsNullOrWhiteSpace(dbConfigurations.SchemaExportFilename))
{
new SchemaExport(x).Execute(script =>
File.AppendAllText(dbConfigurations.SchemaExportFilename, script),
false, false);
}
})
.BuildConfiguration();
if (dbConfigurations.UseNetTopologySuite)
{
cfg.AddAuxiliaryDatabaseObject(new SpatialAuxiliaryDatabaseObject(cfg));
Metadata.AddMapping(cfg, MetadataClass.GeometryColumn);
Metadata.AddMapping(cfg, MetadataClass.SpatialReferenceSystem);
}
return(cfg.BuildSessionFactory());
}
public bool LoadYaml()
{
NMList = null;
Stop();
Added = null;
TimeStampLen = 15;
RequiredLen = 20;
Autoimport = AutoImport.None;
var yfile = Path.Combine(YamlFolder, YamlFile);
Imports = new List <Regex>();
if (System.IO.File.Exists(yfile))
{
using (var file = new StreamReader(yfile, Encoding.UTF8))
{
var deserializer = new DeserializerBuilder()
.WithNamingConvention(new CamelCaseNamingConvention())
.Build();
var nmlist = deserializer.Deserialize <YamlNMList>(file);
if (nmlist.List == null)
{
throw new FormatException("need list");
}
if (nmlist.Added == "")
{
throw new FormatException("need added Regex");
}
if (nmlist.Importnm == null)
{
throw new FormatException("need importnm");
}
if (nmlist.Weather == null)
{
throw new FormatException("need weather");
}
if (nmlist.Import == "")
{
throw new FormatException("need import");
}
Added = new Regex(nmlist.Added, RegexOptions.Compiled);
TimeStampLen = nmlist.Timestamplen;
RequiredLen = nmlist.Requiredlen;
switch (nmlist.Autoimport.ToLower())
{
case "none":
Autoimport = AutoImport.None;
break;
case "once":
Autoimport = AutoImport.Once;
break;
case "always":
Autoimport = AutoImport.Always;
break;
}
nmlist.MakeDict();
foreach (var nm in nmlist.List)
{
nm.PopTime = DateTime.MinValue;
}
Import = new Regex(nmlist.Import, RegexOptions.Compiled);
foreach (var regexp in nmlist.Importnm)
{
var r = new Regex(regexp, RegexOptions.Compiled);
Imports.Add(r);
}
NMList = nmlist;
}
}
Start();
return(true);
}
/// <inheritdoc />
public void Save(string path)
{
Logger.Info(GlobalStrings.Profile_SavingProfile, path);
XmlWriterSettings writeSettings = new XmlWriterSettings
{
CloseOutput = true,
Indent = true
};
try
{
Utility.BackupFile(path, Settings.Instance.ConfigBackupCount);
}
catch (Exception e)
{
Logger.Error(GlobalStrings.Log_Profile_ConfigBackupFailed, e.Message);
}
XmlWriter writer;
try
{
writer = XmlWriter.Create(path, writeSettings);
}
catch (Exception e)
{
Logger.Warn(GlobalStrings.Profile_FailedToOpenProfileFile, e.Message);
throw new ApplicationException(GlobalStrings.Profile_ErrorSavingProfileFile + e.Message, e);
}
writer.WriteStartElement(XmlNameProfile);
writer.WriteElementString(XmlNameSteamId, SteamID64.ToString(CultureInfo.InvariantCulture));
writer.WriteElementString(XmlNameAutoUpdate, AutoUpdate.ToString().ToLowerInvariant());
writer.WriteElementString(XmlNameAutoImport, AutoImport.ToString().ToLowerInvariant());
writer.WriteElementString(XmlNameAutoExport, AutoExport.ToString().ToLowerInvariant());
writer.WriteElementString(XmlNameLocalUpdate, LocalUpdate.ToString().ToLowerInvariant());
writer.WriteElementString(XmlNameWebUpdate, WebUpdate.ToString().ToLowerInvariant());
writer.WriteElementString(XmlNameExportDiscard, ExportDiscard.ToString().ToLowerInvariant());
writer.WriteElementString(XmlNameAutoIgnore, AutoIgnore.ToString().ToLowerInvariant());
writer.WriteElementString(XmlNameIncludeUnknown, IncludeUnknown.ToString().ToLowerInvariant());
writer.WriteElementString(XmlNameBypassIgnoreOnImport, BypassIgnoreOnImport.ToString().ToLowerInvariant());
writer.WriteElementString(XmlNameOverwriteNames, OverwriteOnDownload.ToString().ToLowerInvariant());
writer.WriteElementString(XmlNameIncludeShortcuts, IncludeShortcuts.ToString().ToLowerInvariant());
writer.WriteStartElement(XmlNameGameList);
foreach (GameInfo gameInfo in GameData.Games.Values)
{
if (!IncludeShortcuts && gameInfo.Id <= 0)
{
continue;
}
// Don't save shortcuts if we aren't including them
writer.WriteStartElement(XmlNameGame);
writer.WriteElementString(XmlNameGameId, gameInfo.Id.ToString(CultureInfo.InvariantCulture));
writer.WriteElementString(XmlNameGameSource, gameInfo.Source.ToString());
if (gameInfo.Name != null)
{
writer.WriteElementString(XmlNameGameName, gameInfo.Name);
}
writer.WriteElementString(XmlNameGameHidden, gameInfo.IsHidden.ToString().ToLowerInvariant());
if (gameInfo.LastPlayed != 0)
{
writer.WriteElementString(XmlNameGameLastPlayed, gameInfo.LastPlayed.ToString(CultureInfo.InvariantCulture));
}
if (gameInfo.HoursPlayed > 0)
{
writer.WriteElementString(XmlNameGameHoursPlayed, gameInfo.HoursPlayed.ToString(CultureInfo.InvariantCulture));
}
if (!gameInfo.Executable.Contains("steam://"))
{
writer.WriteElementString(XmlNameGameExecutable, gameInfo.Executable);
}
writer.WriteStartElement(XmlNameGameCategoryList);
foreach (Category category in gameInfo.Categories)
{
string categoryName = category.Name;
if (category.Name == GameList.FavoriteNewConfigValue)
{
categoryName = GameList.FavoriteConfigValue;
}
writer.WriteElementString(XmlNameGameCategory, categoryName);
}
writer.WriteEndElement(); // categories
writer.WriteEndElement(); // game
}
writer.WriteEndElement(); // games
writer.WriteStartElement(XmlNameFilterList);
foreach (Filter filter in GameData.Filters)
{
WriteFilterToXml(writer, filter);
}
writer.WriteEndElement(); //game filters
writer.WriteStartElement(XmlNameAutoCatList);
foreach (AutoCat autoCat in AutoCats)
{
autoCat.WriteToXml(writer);
}
writer.WriteEndElement(); //autocats
writer.WriteStartElement(XmlNameExclusionList);
foreach (int i in IgnoreList)
{
writer.WriteElementString(XmlNameExclusion, i.ToString(CultureInfo.InvariantCulture));
}
writer.WriteEndElement(); // exclusions
writer.WriteEndElement(); // profile
writer.Close();
FilePath = path;
Logger.Info(GlobalStrings.Profile_ProfileSaveComplete);
}
