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]); }