protected override HbmMapping GetMappings() { var mapper = new ConventionModelMapper(); // Working Example //mapper.Class<Toy>(rc => rc.Set(x => x.Animals, cmap => { }, rel => rel.ManyToAny<int>(meta => // { // meta.MetaValue(1, typeof (Cat)); // meta.MetaValue(2, typeof (Dog)); // }))); // User needs mapper.Class<Toy>(rc => rc.Set(x => x.Animals, cmap => { cmap.Table("Animals_Toys"); cmap.Key(km => km.Column("Cat_Id")); }, rel => rel.ManyToAny<int>(meta => { meta.MetaValue(1, typeof(Cat)); meta.MetaValue(2, typeof(Dog)); meta.Columns(cid => { cid.Name("Animal_Id"); cid.NotNullable(true); }, ctype => { ctype.Name("Animal_Type"); ctype.NotNullable(true); }); }))); var mappings = mapper.CompileMappingFor(new[] { typeof(Cat), typeof(Dog), typeof(Toy) }); //Console.WriteLine(mappings.AsString()); // <=== uncomment this line to see the XML mapping return mappings; }
/// <summary> /// Gets a mapping that can be used with NHibernate. /// </summary> /// <param name="additionalTypes">Additional Types that are to be added to the mapping, this is useful for adding your ApplicationUser class</param> /// <returns></returns> public static HbmMapping GetIdentityMappings(System.Type[] additionalTypes) { var baseEntityToIgnore = new[] { typeof(NHibernate.AspNet.Identity.DomainModel.EntityWithTypedId<int>), typeof(NHibernate.AspNet.Identity.DomainModel.EntityWithTypedId<string>), }; var allEntities = new List<System.Type> { typeof(ApplicationTenant), typeof(IdentityUser), typeof(IdentityRole), typeof(IdentityUserLogin), typeof(IdentityUserClaim), }; allEntities.AddRange(additionalTypes); var mapper = new ConventionModelMapper(); DefineBaseClass(mapper, baseEntityToIgnore.ToArray()); mapper.IsComponent((type, declared) => typeof(NHibernate.AspNet.Identity.DomainModel.ValueObject).IsAssignableFrom(type)); mapper.AddMapping<IdentityUserMap>(); mapper.AddMapping<IdentityRoleMap>(); mapper.AddMapping<IdentityUserClaimMap>(); mapper.AddMapping<ApplicationTenantMap>(); return mapper.CompileMappingFor(allEntities); }
public static void Configure(ISessionStorage storage) { var baseEntityToIgnore = new[] { typeof(NHibernate.AspNet.Identity.DomainModel.EntityWithTypedId<int>), typeof(NHibernate.AspNet.Identity.DomainModel.EntityWithTypedId<string>), }; var allEntities = new[] { typeof(IdentityUser), typeof(ApplicationUser), typeof(IdentityRole), typeof(IdentityUserLogin), typeof(IdentityUserClaim), }; var mapper = new ConventionModelMapper(); DefineBaseClass(mapper, baseEntityToIgnore); mapper.IsComponent((type, declared) => typeof(NHibernate.AspNet.Identity.DomainModel.ValueObject).IsAssignableFrom(type)); mapper.AddMapping<IdentityUserMap>(); mapper.AddMapping<IdentityRoleMap>(); mapper.AddMapping<IdentityUserClaimMap>(); var mapping = mapper.CompileMappingFor(allEntities); System.Diagnostics.Debug.WriteLine(mapping.AsString()); var configuration = NHibernateSession.Init(storage, mapping); BuildSchema(configuration); }
static NHibernateHelper() { try { cfg = new Configuration(); cfg.Configure("NHibernateQueryModelConfiguration.xml"); var mapper = new ConventionModelMapper(); //mapper.IsEntity((t, declared) => t.Namespace.StartsWith("Sample.QueryModel") || ); mapper.AfterMapClass += (inspector, type, classCustomizer) => { classCustomizer.Lazy(false); //classCustomizer.Id(m => m.Generator(new GuidGeneratorDef())); }; var mapping = mapper.CompileMappingFor( Assembly.Load("Sample.QueryModel").GetExportedTypes() .Union(new Type[] {typeof(Version)})); var allmapping = mapping.AsString(); cfg.AddDeserializedMapping(mapping, "AutoModel"); _sessionFactory = cfg.BuildSessionFactory(); } catch (Exception ex) { throw ex; } }
/// <summary> /// Gets a mapping that can be used with NHibernate. /// </summary> /// <param name="additionalTypes">Additional Types that are to be added to the mapping, this is useful for adding your ApplicationUser class</param> /// <returns></returns> public static HbmMapping GetIdentityMappings(System.Type[] additionalTypes) { var baseEntityToIgnore = new[] { typeof(EntityWithTypedId<int>), typeof(EntityWithTypedId<string>) }; // Modified for NS: PIMS.Infrastructure.NHibernate.NHAspNetIdentity var allEntities = new List<System.Type> { typeof(IdentityUser), typeof(IdentityRole), typeof(IdentityUserLogin), typeof(IdentityUserClaim), }; allEntities.AddRange(additionalTypes); var mapper = new ConventionModelMapper(); DefineBaseClass(mapper, baseEntityToIgnore.ToArray()); mapper.IsComponent((type, declared) => typeof(ValueObject).IsAssignableFrom(type)); // Modified for NS: PIMS.Infrastructure.NHibernate.NHAspNetIdentity mapper.AddMapping<IdentityUserMap>(); mapper.AddMapping<IdentityRoleMap>(); mapper.AddMapping<IdentityUserClaimMap>(); return mapper.CompileMappingFor(allEntities); }
protected override HbmMapping GetMappings() { var mapper = new ConventionModelMapper(); mapper.IsTablePerClass((type, declared) => false); mapper.IsTablePerClassHierarchy((type, declared) => true); var mappings = mapper.CompileMappingFor(new[] {typeof (Animal), typeof (Reptile), typeof (Mammal), typeof (Lizard), typeof (Dog), typeof (Cat)}); return mappings; }
public void WhenAutoPropertyNoAccessor() { var mapper = new ConventionModelMapper(); var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) }); var hbmClass = hbmMapping.RootClasses[0]; var hbmProperty = hbmClass.Properties.Single(x => x.Name == "AProp"); hbmProperty.Access.Should().Be.NullOrEmpty(); }
public void WhenPoidNoSetterThenApplyNosetter() { var mapper = new ConventionModelMapper(); mapper.Class<MyClass>(x => x.Id(mc=> mc.Id)); var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) }); var hbmClass = hbmMapping.RootClasses[0]; hbmClass.Id.access.Should().Be("nosetter.camelcase-underscore"); }
public void WhenPropertyWithSameBackFieldNoMatch() { var mapper = new ConventionModelMapper(); var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) }); var hbmClass = hbmMapping.RootClasses[0]; var hbmProperty = hbmClass.Properties.Single(x => x.Name == "SameTypeOfBackField"); hbmProperty.Access.Should().Be.NullOrEmpty(); }
public void WhenFieldAccessToField() { var mapper = new ConventionModelMapper(); mapper.Class<MyClass>(mc => mc.Property("aField", x => { })); var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) }); var hbmClass = hbmMapping.RootClasses[0]; var hbmProperty = hbmClass.Properties.Single(x => x.Name == "aField"); hbmProperty.Access.Should().Be("field"); }
static void Main(String[] args) { var cfg = new Configuration(); cfg.DataBaseIntegration(x => { x.Dialect<MsSql2008Dialect>(); x.Driver<Sql2008ClientDriver>(); x.ConnectionString = @"Data Source=(local)\SQLEXPRESS; Initial Catalog=NHibernate; Integrated Security=SSPI"; x.SchemaAction = SchemaAutoAction.Update; }) .SetProperty(NHibernate.Cfg.Environment.UseProxyValidator, Boolean.FalseString); var model = new ConventionModelMapper(); model.BeforeMapClass += (a, b, c) => { c.Lazy(false); c.Id(x => x.Generator(Generators.Identity)); }; var mappings = model.CompileMappingFor(new Type[] { typeof(Xpto) }); cfg.AddMapping(mappings); using (var sessionFactory = cfg.BuildSessionFactory()) { var validation = sessionFactory .FluentlyValidate() .Entity<Xpto>(x => x.Name != "aa", "Name is empty"); using (var session = sessionFactory.OpenSession()) using (var tx = session.BeginTransaction()) { var x = new Xpto(); try { session.Save(x); session.Flush(); } catch { //expected } x.Name = "aa"; //disable all validations //sessionFactory.DisableFluentValidation(); //disable validations over the Xpto class //validation.Clear<Xpto>(); //session.Save(new Xpto()); session.Flush(); //should work } } }
static void AddConventionalMapping(Configuration cfg) { var modelMapper = new ConventionModelMapper(); modelMapper.IsEntity((x, y) => x.IsClass == true && x.IsSealed == false && x.Namespace == typeof(Program).Namespace); modelMapper.BeforeMapClass += (x, y, z) => { z.Id(a => a.Generator(Generators.Identity)); z.Lazy(true); }; modelMapper.BeforeMapManyToOne += (x, y, z) => { z.Lazy(LazyRelation.Proxy); z.NotNullable(true); }; var mappings = modelMapper.CompileMappingFor(typeof(Program).Assembly.GetTypes().Where(x => x.IsPublic && x.IsSealed == false)); cfg.AddMapping(mappings); }
public void WhenClassWithoutPoidWithGeneratorThenApplyDefinedGenerator() { var mapper = new ConventionModelMapper(); mapper.Class<MyClassWithoutPoid>(x => x.Id(null, idm=> idm.Generator(Generators.Native))); var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClassWithoutPoid) }); var hbmClass = hbmMapping.RootClasses[0]; var hbmId = hbmClass.Id; hbmId.Should().Not.Be.Null(); hbmId.generator.Should().Not.Be.Null(); [email protected]().Be("native"); hbmId.type1.Should().Be(Generators.Native.DefaultReturnType.GetNhTypeName()); }
public void WhenClassWithoutPoidNorGeeneratorThenApplyGuid() { var mapper = new ConventionModelMapper(); mapper.Class<MyClassWithoutPoid>(x => { }); var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClassWithoutPoid) }); var hbmClass = hbmMapping.RootClasses[0]; var hbmId = hbmClass.Id; hbmId.Should().Not.Be.Null(); hbmId.generator.Should().Not.Be.Null(); [email protected]().Be("guid"); hbmId.type1.Should().Be("Guid"); }
protected override HbmMapping GetMappings() { var mapper = new ConventionModelMapper(); mapper.BeforeMapClass += (inspector, type, map) => map.Id(x => x.Generator(Generators.HighLow)); mapper.BeforeMapClass += (inspector, type, map) => map.Cache(x => x.Usage(CacheUsage.ReadWrite)); mapper.BeforeMapSet += (inspector, property, map) => { map.Cascade(Mapping.ByCode.Cascade.All); map.Cache(x => x.Usage(CacheUsage.ReadWrite)); }; var mapping = mapper.CompileMappingFor(new[] { typeof(Blog), typeof(Post), typeof(Comment) }); return mapping; }
public void CanGenerateMappingDoc() { // Need a separate config so we can get hold of the mapper after using it. // If we use the existing config we get a duplicate mapping exception. var config = NHibernateInitializer.CreateConfiguration(); var mapper = new ConventionModelMapper(); mapper.WithConventions(config); var mapping = mapper.CompileMappingFor(typeof(Entity).Assembly.GetExportedTypes()); var x = mapping.AsString(); File.WriteAllText("../../NHibernateTests/Output.xml", x); }
public void WhenClassWithoutPoidNorGeeneratorThenApplyGuid() { var mapper = new ConventionModelMapper(); mapper.Class<MyClassWithoutPoid>(x => { }); var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClassWithoutPoid) }); var hbmClass = hbmMapping.RootClasses[0]; var hbmId = hbmClass.Id; Assert.That(hbmId, Is.Not.Null); Assert.That(hbmId.generator, Is.Not.Null); Assert.That(hbmId.generator.@class, Is.EqualTo("guid")); Assert.That(hbmId.type1, Is.EqualTo("Guid")); }
private static HbmMapping GetMappings() { var mapper = new ConventionModelMapper(); mapper.BeforeMapClass += (mi, type, map) => { map.Id(g => g.Generator(Generators.Assigned)); }; var entities = Assembly.Load("Vaccine.Core.Domain").GetTypes(); HbmMapping domainMapping = mapper.CompileMappingFor(entities.Where(c=>c.Name.EndsWith("Report"))); return domainMapping; }
protected override HbmMapping GetMappings() { var mapper = new ConventionModelMapper(); System.Type baseEntityType = typeof (DomainObject); mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && !baseEntityType.Equals(t)); mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType)); mapper.Class<DomainObject>(r => { r.Version(x => x.EntityVersion, map => { }); r.Id(x => x.ID, map => map.Generator(Generators.Native)); }); mapper.Class<Class1>(r => { r.IdBag(x => x.Class2List, map => map.Inverse(true), rel => rel.ManyToMany()); }); mapper.Class<Class2>(r => { r.IdBag<Class1>("_class1List", map => { }, rel => rel.ManyToMany()); }); HbmMapping mappings = mapper.CompileMappingFor(new[] {typeof (Class1), typeof (Class2)}); return mappings; }
/// <summary> /// Adds all Hyperion mappings to a NHibernate configuration. /// </summary> /// <param name="nhConf">The NHib configuration instance.</param> /// <returns>Returns the NHib configuration instance with Hyperion mappings.</returns> public static Configuration AddAutoMappings(this Configuration nhConf, IEnumerable<Type> types, Action<ConventionModelMapper> modelMapper = null) { var englishPluralizationService = PluralizationService.CreateService(new CultureInfo("en-US")); var mapper = new ConventionModelMapper(); //var baseEntityType = typeof(IEventHandler); //mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface); //mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType)); mapper.BeforeMapClass += (insp, prop, map) => map.Table(englishPluralizationService.Pluralize(prop.Name)); mapper.BeforeMapClass += (i, t, cm) => cm.Id(map => { map.Column(t.Name + "Id"); if (t.GetProperty("Id").PropertyType == typeof(Int32)) map.Generator(Generators.Identity); else map.Generator(Generators.Assigned); }); mapper.BeforeMapManyToOne += (insp, prop, map) => map.Column(prop.LocalMember.GetPropertyOrFieldType().Name + "Id"); mapper.BeforeMapManyToOne += (insp, prop, map) => map.Cascade(Cascade.None); mapper.BeforeMapBag += (insp, prop, map) => map.Key(km => km.Column(prop.GetContainerEntity(insp).Name + "Id")); mapper.BeforeMapBag += (insp, prop, map) => { map.Cascade(Cascade.All.Include(Cascade.DeleteOrphans)); map.Inverse(true); }; mapper.BeforeMapSet += (insp, prop, map) => map.Key(km => km.Column(prop.GetContainerEntity(insp).Name + "Id")); mapper.BeforeMapSet += (insp, prop, map) => { map.Cascade(Cascade.All.Include(Cascade.DeleteOrphans)); map.Inverse(true); }; if (modelMapper != null) modelMapper(mapper); var mapping = mapper.CompileMappingFor(types); nhConf.AddDeserializedMapping(mapping, "Hyperion"); return nhConf; }
public void WhenPropertyVersionFromBaseEntityThenFindItAsVersion() { var mapper = new ConventionModelMapper(); var baseEntityType = typeof(BaseEntity); mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface); mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType)); mapper.Class<BaseEntity>( map => { map.Id(x => x.Id, idmap => { }); map.Version(x => x.Version, vm => { }); }); var hbmMapping = mapper.CompileMappingFor(new[] { typeof(Person) }); var hbmClass = hbmMapping.RootClasses[0]; var hbmVersion = hbmClass.Version; Assert.That(hbmVersion, Is.Not.Null); Assert.That(hbmVersion.name, Is.EqualTo("Version")); }
public static HbmMapping CreateMappingConfiguration() { var mapper = new ConventionModelMapper(); var baseEntityType = typeof (Entity); mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface); mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType)); mapper.BeforeMapManyToOne += (insp, prop, map) => map.Column(prop.LocalMember.GetPropertyOrFieldType().Name + "Id"); mapper.BeforeMapBag += (insp, prop, map) => map.Key(km => km.Column(prop.GetContainerEntity(insp).Name + "Id")); mapper.BeforeMapBag += (insp, prop, map) => map.Cascade(Cascade.All); mapper.Class<Album>(map => map.Id(x => x.AlbumId, m=> m.Generator(Generators.Identity))); mapper.Class<Artist>(map => map.Id(x => x.ArtistId, m => m.Generator(Generators.Identity))); var mapping = mapper.CompileMappingFor(baseEntityType.Assembly.GetExportedTypes()); return mapping; }
public ISessionFactory Create() { var cfg = new Configuration(); cfg.DataBaseIntegration( db => { db.ConnectionString = "Server=tcp:localhost;Database=DataSample;Trusted_Connection=true;Encrypt=False;"; db.Dialect<MsSql2008Dialect>(); db.BatchSize = 250; db.KeywordsAutoImport = Hbm2DDLKeyWords.AutoQuote; db.SchemaAction = SchemaAutoAction.Update; }).SessionFactory().GenerateStatistics(); var mapper = new ConventionModelMapper(); // filter entities var baseEntityType = typeof(AbstractEntity); mapper.IsEntity( (t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface); mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType)); // override base properties mapper.Class<AbstractEntity>( map => { map.Id(x => x.Id, m => m.Generator(Generators.GuidComb)); }); mapper.BeforeMapProperty += OnBeforeMapProperty; // compile var mapping = mapper.CompileMappingFor( typeof(AbstractEntity).Assembly.GetExportedTypes().Where(type => typeof(AbstractEntity).IsAssignableFrom(type))); // use mappings cfg.AddMapping(mapping); // build return cfg.BuildSessionFactory(); }
public void WhenVersionFromBaseEntityThenShouldntMapVersionAsProperty() { var mapper = new ConventionModelMapper(); var baseEntityType = typeof(BaseEntity); mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface); mapper.IsRootEntity((t, declared) => baseEntityType == t.BaseType); mapper.Class<BaseEntity>( map => { map.Id(x => x.Id, idmap => { }); map.Version(x => x.Version, vm => { }); }); var hbmMapping = mapper.CompileMappingFor(new[] { typeof(Person) }); var hbmClass = hbmMapping.RootClasses[0]; var hbmVersion = hbmClass.Version; Assert.That(hbmVersion, Is.Not.Null); Assert.That(hbmVersion.name, Is.EqualTo("Version")); Assert.That(hbmClass.Properties, Is.Empty, "because one is the POID and the other is the version"); }
public override void ConfigureMapping(NHibernate.Cfg.Configuration configuration) { var mapper = new ConventionModelMapper(); mapper.BeforeMapProperty += (inspector, member, customizer) => { if (member.LocalMember.GetPropertyOrFieldType() == typeof(string)) { customizer.Length(50); } }; mapper.BeforeMapClass += (inspector, type, customizer) => customizer.Id(im => im.Generator(Generators.GuidComb)); // define the mapping shape mapper.Class<Hotel>(ca => ca.List(item => item.Reservations, cm => cm.Key(km => km.Column("HotelId")))); mapper.Class<Room>(ca => ca.List(item => item.Reservations, cm => cm.Key(km => { km.Column("RoomId"); km.OnDelete(OnDeleteAction.NoAction); }))); mapper.Class<Reservation>(ca => { ca.ManyToOne(item => item.Hotel, m => { m.Column("HotelId"); m.Insert(false); m.Update(false); m.Lazy(LazyRelation.Proxy);} ); ca.ManyToOne(item => item.Room, m => { m.Column("RoomId"); m.Insert(false); m.Update(false); m.Lazy(LazyRelation.Proxy); }); }); // list all the entities we want to map. IEnumerable<Type> baseEntities = GetMappingTypes(); // compile the mapping for the specified entities HbmMapping mappingDocument = mapper.CompileMappingFor(baseEntities); // inject the mapping in NHibernate configuration.AddDeserializedMapping(mappingDocument, "Domain"); // fix up the schema SchemaMetadataUpdater.QuoteTableAndColumns(configuration); SessionFactory.SessionFactoryInstance = configuration.BuildSessionFactory(); }
public void Configure(Configuration configuration) { var mapper = new ConventionModelMapper(); var baseEntityType = typeof (Entity); mapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface); mapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType)); mapper.BeforeMapManyToOne += (insp, prop, map) => map.Column(prop.LocalMember.GetPropertyOrFieldType().Name + "Id"); mapper.BeforeMapBag += (insp, prop, map) => map.Key(km => km.Column(prop.GetContainerEntity(insp).Name + "Id")); mapper.BeforeMapBag += (insp, prop, map) => map.Cascade(Cascade.All); mapper.Class<Entity>(map => { map.Id(x => x.Id, m => m.Generator(Generators.GuidComb)); map.Version(x => x.Version, m => m.Generated(VersionGeneration.Never)); }); var mapping = mapper.CompileMappingFor(baseEntityType.Assembly.GetExportedTypes()); configuration.AddDeserializedMapping(mapping, "Cronos"); }
/// <summary> /// Initializes the mappings. /// </summary> /// <param name="config">The configuration.</param> public static void InitMappings(Configuration config) { var mapper = new ConventionModelMapper(); mapper.BeforeMapProperty += (inspector, member, customizer) => { if (member.LocalMember.GetPropertyOrFieldType() == typeof (string) && !member.LocalMember.Name.EndsWith("Text")) { customizer.Length(50); } if (member.LocalMember.GetPropertyOrFieldType() == typeof (string) && member.LocalMember.Name.EndsWith("Text")) { customizer.Type(NHibernateUtil.StringClob); } }; mapper.BeforeMapBag += (inspector, member, customizer) => { customizer.Cascade(Cascade.All | Cascade.DeleteOrphans); }; foreach (var componentDbInit in IoC.ResolveAllInstances<IComponentDbInit>()) { componentDbInit.InitMappings(mapper); } // compile the mapping for the specified entities HbmMapping mappingDocument = mapper.CompileMappingFor(ListOfModelTypes()); // inject the mapping in NHibernate config.AddDeserializedMapping(mappingDocument, "Domain"); // fix up the schema SchemaMetadataUpdater.QuoteTableAndColumns(config); SessionFactory.SessionFactoryInstance = config.BuildSessionFactory(); }
public static HbmMapping Generate() { //Conventions var mapper = new ConventionModelMapper(); var baseEntity = typeof (EntityBase); mapper.BeforeMapProperty += (ispector, member, customizer) => customizer.Length(40); mapper.BeforeMapManyToOne += (insp, prop, map) => map.Column(prop.LocalMember.GetPropertyOrFieldType().Name + "Id"); mapper.BeforeMapManyToOne += (insp, prop, map) => map.Cascade(Cascade.Persist); mapper.BeforeMapBag += (insp, prop, map) => map.Key(km => km.Column(prop.GetContainerEntity(insp).Name + "Id")); mapper.BeforeMapSet += (insp, prop, map) => map.Key(km => km.Column(prop.GetContainerEntity(insp).Name + "Id")); mapper.IsEntity((t, d) => baseEntity.IsAssignableFrom(t) && baseEntity != t); mapper.IsRootEntity((t, d) => t.BaseType == baseEntity); mapper.IsSet(IsSetFieldType); Customize(mapper); HbmMapping mappings = mapper.CompileMappingFor(new[] { typeof (Customization), typeof (Order), typeof (Payment), typeof (OrderItem), typeof (Product) }); return mappings; }
protected override HbmMapping GetMappings() { var mapper = new ConventionModelMapper(); mapper.BeforeMapClass += (mi, t, x) => x.Id(map=> map.Generator(Generators.Guid)); return mapper.CompileMappingFor(new[] { typeof(MyClass) }); }
public void WhenPropertyWithoutFieldNoMatch() { var mapper = new ConventionModelMapper(); mapper.Class<MyClass>(mc => mc.Property(x => x.PropertyWithoutField)); var hbmMapping = mapper.CompileMappingFor(new[] {typeof (MyClass)}); var hbmClass = hbmMapping.RootClasses[0]; var hbmProperty = hbmClass.Properties.Single(x => x.Name == "PropertyWithoutField"); hbmProperty.Access.Should().Not.Contain("field"); }
public static void WithConventions(this ConventionModelMapper mapper, Configuration configuration) { var baseEntityType = typeof(Entity); mapper.IsEntity((type, declared) => IsEntity(type)); mapper.IsComponent((type, b) => IsComponent(type)); mapper.IsRootEntity((type, declared) => baseEntityType.Equals(type.BaseType)); mapper.BeforeMapClass += (modelInspector, type, classCustomizer) => { classCustomizer.Id(c => c.Column("Id")); classCustomizer.Id(c => c.Generator(Generators.HighLow)); classCustomizer.Table(Inflector.Net.Inflector.Pluralize(type.Name.ToString())); }; mapper.IsPersistentProperty((memberinfo, currentlyPersistent) => { return(memberinfo.Name != "Owner"); }); mapper.BeforeMapManyToOne += (modelInspector, propertyPath, map) => { map.Column(propertyPath.LocalMember.GetPropertyOrFieldType().Name + "Id"); map.Cascade(Cascade.Persist); }; mapper.BeforeMapBag += (modelInspector, propertyPath, map) => { map.Key(keyMapper => keyMapper.Column(propertyPath.GetContainerEntity(modelInspector).Name + "Id")); map.Cascade(Cascade.All); }; mapper.BeforeMapProperty += (inspector, member, customizer) => { // This is pure guesswork, but seems to be the only way I can think of to alter // the column naming of a property mapped as part of a component if (typeof(IComponent).IsAssignableFrom(member.LocalMember.DeclaringType)) { if (member.LocalMember.Name == "Value") { customizer.Column(member.PreviousPath.LocalMember.Name); } else if (member.LocalMember.Name != "Owner") { customizer.Column(member.PreviousPath.LocalMember.Name + member.LocalMember.Name); } } }; mapper.Component <RestrictedVisibility <string> >(x => { x.Property(c => c.Value); x.Property(c => c.Visibility); x.Parent(c => c.Owner); }); mapper.Component <RestrictedVisibility <bool> >(x => { x.Property(c => c.Value); x.Property(c => c.Visibility); x.Parent(c => c.Owner); }); // The following probably works, but not if we stop "Owner" from being a persistent property // using mapping.IsPersistentProperty, and if we don't do that we get a Too Many Properties exception. // There's an old thread on nhusers about how there's no documentation in this area... //mapper.BeforeMapComponent += (inspector, member, customizer) => { // if (member.LocalMember.Name == "Owner") { // customizer.Parent(member.LocalMember); // } //}; AddConventionOverrides(mapper); HbmMapping mapping = mapper.CompileMappingFor( typeof(Entity).Assembly.GetExportedTypes().Where(IsEntity)); configuration.AddDeserializedMapping(mapping, "MyStoreMappings"); }