private static IEnumerable <IConvention> GetConventions()
{
yield return(Table.Is(x => x.EntityType.Name));
// TODO: TBD: does not seem to be taking? having to specify Id column?
yield return(Id.Always(x => x.Column("Id")));
yield return(HasMany.Always(x => x.Cascade.AllDeleteOrphan()));
yield return(HasMany.Always(x => x.LazyLoad()));
yield return(HasMany.Always(x => x.Inverse()));
yield return(HasMany.Always(x => x.AsBag()));
yield return(Reference.Always(x => x.LazyLoad()));
yield return(Reference.Always(x => x.Cascade.All()));
//// TODO: TBD: not strong enough:
//yield return ForeignKey.EndsWith("Id");
// TODO: TBD: does not seem to be taking? having to specify each reference column name?
yield return(ForeignKey.Format((p, t) => (p == null ? t.Name : p.Name) + "Id"));
// TODO: ditto Id Alwyas Id?
yield return(PrimaryKey.Name.Is(x => "Id"));
yield return(DefaultCascade.All());
yield return(DefaultLazy.Always());
}
public Action <MappingConfiguration> MappingConfiguration()
{
return(m => m.FluentMappings.AddFromAssemblyOf <Entity>()
.Conventions.Add(ForeignKey.EndsWith("Id"))
.Conventions.Add(DefaultLazy.Always())
.Conventions.Add(DefaultCascade.SaveUpdate()));
}
// Returns our mappings
private static AutoPersistenceModel CreateMappings()
{
return(AutoMap
.Assembly(System.Reflection.Assembly.GetCallingAssembly())
.Where(t => t.Namespace != null && t.Namespace.EndsWith("Models"))
.Conventions.Setup(c => c.Add(DefaultCascade.SaveUpdate())));
}
// Returns our mappings
private static AutoPersistenceModel CreateMappings()
{
return(AutoMap
.Assembly(System.Reflection.Assembly.GetCallingAssembly())
.Where(t => t.Namespace == "FluentNHibernateConsole.Entities")
.Conventions.Setup(c => c.Add(DefaultCascade.SaveUpdate())));
}
/// <summary>
/// Map the convention.
/// </summary>
/// <param name="finder">Convention finder.</param>
public virtual void Build(IConventionFinder finder)
{
finder.Add <PrimaryKeyConvention>();
finder.Add <PrimaryKeyGuidConvention>();
finder.Add(DefaultCascade.None());
finder.Add(ForeignKey.EndsWith("Id"));
}
public MyAutoPersistenceModel()
{
this.AutoPersistenceModel = AutoMap.AssemblyOf <Entity>(new CustomAutomappingConfiguration())
.IgnoreBase <Entity>()
.Override <User>(map => map.IgnoreProperty(x => x.DisplayedName))
.Override <Appointment>(map => map.IgnoreProperty(x => x.DateRange))
.Override <IllnessPeriod>(map => map.IgnoreProperty(p => p.Duration))
.Override <Role>(map => map.HasManyToMany(x => x.Tasks).Cascade.All())
.Override <DbSetting>(map => map.Map(p => p.Key).Unique())
.Override <Patient>(map =>
{
map.DynamicUpdate();
map.IgnoreProperty(x => x.Age);
map.Map(x => x.IsDeactivated).Default("0").Not.Nullable();
map.HasMany <Bmi>(x => x.BmiHistory).KeyColumn("Patient_Id");
map.HasMany <MedicalRecord>(x => x.MedicalRecords).KeyColumn("Patient_Id");
map.HasMany <IllnessPeriod>(x => x.IllnessHistory).KeyColumn("Patient_Id");
map.HasMany <Appointment>(x => x.Appointments).KeyColumn("Patient_Id");
})
.Override <Person>(map =>
{
map.Map(p => p.FirstName).Index("idx_person_FirstName");
map.Map(p => p.LastName).Index("idx_person_LastName");
})
.Override <ApplicationStatistics>(map =>
{
map.Map(e => e.IsExported).Default("0").Not.Nullable();
map.Map(e => e.Version).Default("\"3.0.3\"").Not.Nullable();
})
.Conventions.Add(DefaultCascade.SaveUpdate()
, DynamicUpdate.AlwaysTrue()
, DynamicInsert.AlwaysTrue()
, LazyLoad.Always());
}
private static void ConfigureConventions(IConventionFinder conventions)
{
conventions.Add(DefaultCascade.All());
conventions.Add(DefaultLazy.Always());
conventions.Add(ConventionBuilder.Id.Always(convention => convention.GeneratedBy.GuidComb()));
conventions.Add(ConventionBuilder.HasMany.Always(convention => convention.Inverse()));
conventions.Add(ConventionBuilder.HasMany.Always(convention => convention.Cascade.AllDeleteOrphan()));
}
public void ShouldSetDefaultAccessToValue()
{
model.Add(new ClassMap <Target>());
model.Conventions.Add(DefaultCascade.All());
model.BuildMappings()
.First()
.DefaultCascade.ShouldEqual("all");
}
static AutoPersistenceModel CreateAutomappings()
{
return(AutoMap.AssemblyOf <T>()
.Where(type => type.Namespace == "Domaine")
.Conventions.Add(
DefaultCascade.All(),
DefaultLazy.Always()
));
}
static void SetupTestMappings(FluentConfiguration config)
{
config.Mappings(map =>
map.AutoMappings.Add(AutoMap.AssemblyOf <BaseTest>()
.Where(typ => typ.Namespace.EndsWith("TestEntities"))
.Conventions.Add(DefaultCascade.All())
.SupportNullablePrimaryKeysNativeGenerated()
.UseOverridesFromAssemblyOf <NullablePrimaryKeyConvention>()));
}
public void AlwaysShouldSetDefaultLazyToTrue()
{
model.Add(new ClassMap <Target>());
model.Conventions.Add(DefaultLazy.Always());
model.Conventions.Add(DefaultCascade.All());
var mapping = model.BuildMappings().First();
mapping.DefaultLazy.ShouldBeTrue();
mapping.DefaultCascade.ShouldEqual("all");
}
public static AutoPersistenceModel GetNhibernateServicesMappings(bool registerOperationalServices, bool registerConfigurationServices)
{
var config = new AutomappingConfiguration(registerOperationalServices, registerConfigurationServices);
var map = AutoMap.AssemblyOf <IBaseEntity>(config)
.Conventions.Add(DefaultCascade.All())
.UseOverridesFromAssemblyOf <IBaseEntity>()
.IgnoreBase(typeof(BaseEntity <>));
return(map);
}
public override FluentConfiguration CreateConfiguration()
{
FluentConfiguration.InitializeFromConfigMsSql(Configuration, ConfigSectionName);
FluentConfiguration.AddMappingsFromAssemblyOf <ExampleSessionFactoryBuilder>(
PrimaryKey.Name.Is(x => "ID"),
Table.Is(x => x.EntityType.Name + "s"),
ForeignKey.EndsWith("ID"),
ForeignKeyConstraintNameConvention.WithConstraintNameConvention(),
DefaultCascade.None());
return(FluentConfiguration);
}
private static FluentConfiguration FluentConfig()
{
var settings = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("settings.json")
.AddEnvironmentVariables().Build();
var settingsToUse = settings["DatabaseToUse"];
var context = settings["SessionContext"];
var connectionStringFormatter = "ConnectionStrings:{0}:ConnectionString";
var providerFormatter = "ConnectionStrings:{0}:Provider";
var driverFormatter = "ConnectionStrings:{0}:Driver";
var connectionString = settings[string.Format(connectionStringFormatter, settingsToUse)];
var providerString = settings[string.Format(providerFormatter, settingsToUse)];
var driverString = settings[string.Format(driverFormatter, settingsToUse)];
var storeConfig = new StoreConfiguration();
//var hbmExport = @"C:\Users\jody_unterschutz\source\repos\TeamApp\TeamApp.Test.Database\HBM Files\"; use this if we want to export hbm xml files
//we need to remap all of the classes explicitly.
//https://github.com/FluentNHibernate/fluent-nhibernate/wiki
return(Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012
.ConnectionString(connectionString)
.Provider(providerString)
.Driver(driverString)
//.ShowSql()
)
.CurrentSessionContext("thread_static")
.Mappings(m =>
{
m.FluentMappings.AddFromNamespaceOf <LeagueMap>().Conventions.Add(DefaultCascade.All());
/*
* m.AutoMappings.Add(
* AutoMap.AssemblyOf<Team>(storeConfig)
* .IgnoreBase<BaseDataObject>()
* .IncludeBase<CompetitionConfig>()
* .IncludeBase<PlayoffSeries>()
* .IncludeBase<Competition>()
* .IncludeBase<CompetitionConfigFinalRankingRule>()
* .Conventions.Add(DefaultCascade.All())
* );
*/
})
.ExposeConfiguration(c => c.EventListeners.PreUpdateEventListeners
= new IPreUpdateEventListener[] { new AuditEventListener() })
.ExposeConfiguration(c => c.EventListeners.PreInsertEventListeners
= new IPreInsertEventListener[] { new AuditEventListener() }));
}
public static void ConfigureMappings(MappingConfiguration mappingConfiguration, params IMappingConfigurationContributor[] configurationContributors)
{
mappingConfiguration.FluentMappings
.Conventions.Add(
ForeignKey.EndsWith("Id"),
PrimaryKey.Name.Is(x => x.EntityType.Name + "Id"),
DefaultCascade.None());
foreach (var configurationContributor in configurationContributors)
{
configurationContributor.ConfigureMappings(mappingConfiguration);
}
}
private void ConfigureMappings(MappingConfiguration config)
{
Database.Configuration.Mappings.ForEach(map => config.FluentMappings.AddFromAssembly(map));
config.FluentMappings.Conventions.Add <EnumConvention>();
config.FluentMappings.Conventions.Add <MonthConvention>();
config.FluentMappings.Conventions.Add(
DefaultLazy.Always(),
DefaultCascade.None(),
DynamicInsert.AlwaysTrue(),
DynamicUpdate.AlwaysTrue());
}
public ISessionFactory CreateFactory(string connectionString)
{
var nhibcfg = new NHibernate.Cfg.Configuration();
var cfg = Fluently.Configure(nhibcfg)
.Database(
PostgreSQLConfiguration
.Standard
.ConnectionString(connectionString)
)
.Mappings(m =>
{
m.AutoMappings.Add(AutoMap.AssemblyOf <Banan>(new AutomappingConfiguration())
.Conventions.Setup
(
con =>
{
con.Add <CommonConventions>();
con.Add(DefaultLazy.Never());
con.Add(DefaultCascade.SaveUpdate());
con.Add(DynamicInsert.AlwaysTrue());
con.Add(DynamicUpdate.AlwaysTrue());
}).UseOverridesFromAssemblyOf <OvverideMappingsFatherBanan>());
m.FluentMappings.Conventions.Add <CommonConventions>();
m.FluentMappings.Conventions.Add(DefaultLazy.Never(), DefaultCascade.SaveUpdate(), DynamicInsert.AlwaysTrue(), DynamicUpdate.AlwaysTrue());
m.MergeMappings();
});
if (true)
{
var directory = $"BananFatherDatabase.HBM";
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
cfg.Mappings(m => m.AutoMappings.ExportTo(directory));
}
cfg.ExposeConfiguration(c => SchemaMetadataUpdater.QuoteTableAndColumns(c, new PostgreSQLDialect()));
cfg.ExposeConfiguration(c => c.SetProperty("command_timeout", "30"));
cfg.ExposeConfiguration(x =>
{
x.SetInterceptor(new SqlStatementInterceptor());
});
UpdateSchema(cfg.BuildConfiguration());
return(cfg.BuildSessionFactory());
}
private static Action <FluentNHibernate.Conventions.IConventionFinder> GetConventions()
{
return(mappings =>
{
mappings.Add <PrimaryKeyConvention>();
mappings.Add <TableNameConvention>();
mappings.Add <EnumConvention>();
mappings.Add(ForeignKey.EndsWith("Id"));
mappings.Add(DefaultCascade.None());
mappings.Add(DefaultAccess.Property());
mappings.Add(DefaultLazy.Always());
mappings.Add(LazyLoad.Always());
});
}
public StockNhContextModelUpdate(string connectionString)
{
SessionFactory = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2012
.ConnectionString(connectionString).ShowSql())
.Mappings(m =>
m.FluentMappings
.Add <CompanyNhibernateMap>().Conventions.Add(DefaultCascade.All())
.Add <StockQuoteNhibernateMap>().Conventions.Add(DefaultCascade.All())
)
.ExposeConfiguration(cfg => SchemaMetadataUpdater.QuoteTableAndColumns(cfg, new MsSql2012Dialect()))
.ExposeConfiguration(cfg => new SchemaExport(cfg).Execute(true, true, false))
.BuildSessionFactory();
}
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());
}
private static AutoPersistenceModel CreateAutomappings()
{
// This is the actual automapping - use AutoMap to start automapping,
// then pick one of the static methods to specify what to map (in this case
// all the classes in the assembly that contains Employee), and then either
// use the Setup and Where methods to restrict that behaviour, or (preferably)
// supply a configuration instance of your definition to control the automapper.
return(AutoMap.AssemblyOf <User>()
.Where(o => o.Namespace != null && o.Namespace.EndsWith("DemoProject.Domain.Model"))
.Conventions.Add <CustomClassNameConvention>()
.Conventions.Add <CustomPropertyConvention>()
.Conventions.Add <CustomPrimaryKeyConvention>()
.Conventions.Add <CustomCollectionConvention>()
.Conventions.Add <CustomReferenceConvention>()
.Conventions.Add <CustomManyToManyConvention>()
.Conventions.Add(DefaultCascade.SaveUpdate()));
}
private static Action <MappingConfiguration> MappingConfig()
{
var domainAssembly = Assembly.GetAssembly(typeof(Person));
return(m => m
.AutoMappings
.Add(AutoMap
.Assembly(domainAssembly, new DomainMappingConfiguration())
.UseOverridesFromAssembly(domainAssembly)
.Conventions.Setup(c =>
{
c.Add(DefaultCascade.All());
c.Add <CustomForeignKeyConvention>();
c.Add <DefaultStringLengthConvention>();
c.Add <EnumConvention>();
c.Add <DateTimeConvention>();
}))
.ExportTo(HostingEnvironment.MapPath("~/App_Data/Mappings/")));
}
private AutoPersistenceModel CreateMappings()
{
var mappingSetup = AutoMap
.AssemblyOf <TEntity>()
.Where(x =>
!typeof(IAutoMapperSettings).IsAssignableFrom(x) && //ignore all classes that implement auto mapper settings.
!x.IsSubclassOf(typeof(BaseRepo)) && //ignore all classes that inherit from nhibernate base repo class
!x.IsSubclassOf(typeof(RepoSplit <TEntity, TOverride>)) && //ignore all classes that inherit from nhibernate repo class
!x.IsSubclassOf(typeof(RepoCombined <TEntity>)) && //ignore all classes that inherit from nhibernate repo class
!typeof(IClassConvention).IsAssignableFrom(x) && //ignore all NHibernate convention classes
!x.IsSubclassOf(typeof(AbstractBaseMigration)) && //ignore all migration files.
!x.IsSubclassOf(typeof(RepoMigrationConfigurationBaseNoneGeneric)) //ignore all migration configuration files.
)
.Conventions.AddFromAssemblyOf <TOverride>()
.UseOverridesFromAssemblyOf <TOverride>()
.Conventions.Add(DefaultLazy.Never())
.Conventions.Add(DefaultCascade.SaveUpdate());
return(mappingSetup);
}
public ISessionFactory CreateSessionFactory()
{
return(Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2008
.ConnectionString(_configurationService.ConnectionString)
.AdoNetBatchSize(20)
.ShowSql())
.Mappings(m => m.
AutoMappings.Add(
AutoMap.AssemblyOf <PersistentObject>()
.Where(type => type.IsSubclassOf(typeof(PersistentObject)))
.Conventions.Add(
Table.Is(x => Inflector.Net.Inflector.Pluralize(x.EntityType.Name)),
PrimaryKey.Name.Is(x => "ID"),
ForeignKey.EndsWith("ID"),
ConventionBuilder.Class.Always(x => x.
Schema(x.EntityType.Namespace == null || x.EntityType.Namespace.EndsWith("Domain")
? "dbo" : x.EntityType.Namespace.Substring(x.EntityType.Namespace.LastIndexOf(".")))),
DefaultCascade.All()
)))
.ExposeConfiguration(x => DbConfiguration = x)
.BuildSessionFactory());
}
public ISessionFactory CreateSessionFactory()
{
return(Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2008
.ConnectionString(_configurationService.ConnectionString)
.AdoNetBatchSize(20)
.ShowSql())
.Mappings(m =>
m.AutoMappings.Add(
AutoMap.AssemblyOf <NHibernateRepository>(new MyAutoConfig())
.UseOverridesFromAssemblyOf <NHibernateRepository>()
.Conventions.Add(
Table.Is(x => Inflector.Net.Inflector.Pluralize(x.EntityType.Name)),
PrimaryKey.Name.Is(x => "ID"),
ForeignKey.EndsWith("ID"),
ConventionBuilder.HasManyToMany.Always(x => x.AsList()),
DefaultCascade.All(),
ConventionBuilder.Class.Always(x =>
x.Schema(
x.EntityType.Namespace == null || x.EntityType.Namespace.EndsWith("Domain") ?
"dbo" : x.EntityType.Namespace.Substring(x.EntityType.Namespace.LastIndexOf(".")))))))
.ExposeConfiguration(cfg => Configuration = cfg)
.BuildSessionFactory());
}
public void Accept(IAcceptanceCriteria <IManyToManyCollectionInspector> criteria)
{
DefaultCascade.All();
}
public void Apply(IManyToOneInstance instance)
{
DefaultCascade.All();
}
public void Apply(IOneToManyCollectionInstance instance)
{
DefaultCascade.All();
}
private static ISessionFactory CreateSessionFactory()
{
_sessionFactory = Fluently.Configure()
.Database(FluentNHibernate.Cfg.Db.MsSqlCeConfiguration.Standard.ShowSql()
.ConnectionString(c => c.FromConnectionStringWithKey("DbConnectionString")))
.Mappings(m => m.FluentMappings.AddFromAssemblyOf <Task.TaskMap>().Conventions.Add(DefaultCascade.SaveUpdate()))
.Mappings(m => m.FluentMappings.AddFromAssemblyOf <User.UserMap>().Conventions.Add(DefaultCascade.SaveUpdate()))
.Mappings(m => m.FluentMappings.AddFromAssemblyOf <TaskCategory.TaskCategoryMap>().Conventions.Add(DefaultCascade.None()))
.BuildSessionFactory();
return(_sessionFactory);
}
public static ISessionFactory GetFactory(Type classMapping, string dbKey, string connectionString)
{
if (!factories.ContainsKey(dbKey))
{
lock (syncObject)
{
try
{
// incluido o exemplo com SQL server e MYsql
if (!factories.ContainsKey(dbKey))
{
ISessionFactory factory;
switch (dbKey)
{
case DatabaseKeys.MYSQL:
factory = Fluently.Configure()
.Database(MySQLConfiguration.Standard.ConnectionString(connectionString))
.Mappings(x => x.FluentMappings.AddFromAssembly(classMapping.Assembly).Conventions.Add(DefaultCascade.None()))
.BuildSessionFactory();
factories.Add(dbKey, factory);
break;
case DatabaseKeys.SQLSERVER:
factory = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2008.FormatSql().ShowSql().AdoNetBatchSize(50).ConnectionString(connectionString))
.Mappings(x => x.FluentMappings.AddFromAssembly(classMapping.Assembly).Conventions.Add(DefaultCascade.None()))
.BuildSessionFactory();
factories.Add(dbKey, factory);
break;
case DatabaseKeys.ORACLE:
throw new NotImplementedException();
default:
break;
}
}
}
catch (System.Exception)
{
throw;
}
}
}
return(factories[dbKey]);
}
