/// <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);
}
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;
}
}
public void TestFixtureSetUp()
{
configuration = new Configuration();
configuration.SessionFactory()
.Integrate.Using<SQLiteDialect>()
.Connected.Using("Data source=testdb")
.AutoQuoteKeywords()
.LogSqlInConsole()
.EnableLogFormattedSql();
var mapper = new ConventionModelMapper();
mapper.Class<Foo>(cm => { });
mapper.Class<Bar>(cm => { });
CustomizeMapping(mapper);
var mappingDocument = mapper.CompileMappingForAllExplicitlyAddedEntities();
new XmlSerializer(typeof(HbmMapping)).Serialize(Console.Out, mappingDocument);
configuration.AddDeserializedMapping(mappingDocument, "Mappings");
new SchemaExport(configuration).Create(true, true);
sessionFactory = configuration.BuildSessionFactory();
using (var session = sessionFactory.OpenSession())
using (var tx = session.BeginTransaction())
{
var foo = new Foo { Bars = CreateCollection() };
foo.Bars.Add(new Bar { Data = 1 });
foo.Bars.Add(new Bar { Data = 2 });
id = session.Save(foo);
tx.Commit();
}
sessionFactory.Statistics.IsStatisticsEnabled = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="MappingEngine"/> class
/// </summary>
/// <param name="rootConfig">The root configuration</param>
/// <param name="nhConfig">The current NH configuration</param>
/// <param name="modelMapper">The model mapper</param>
public MappingEngine(FirehawkConfig rootConfig, Configuration nhConfig, ConventionModelMapper modelMapper)
{
this.rootConfig = rootConfig;
this.nhConfig = nhConfig;
this.modelMapper = modelMapper;
this.namingEngine = new NamingEngine(rootConfig.NamingConventionsConfig);
}
public ConventionsMapper()
{
this.conventionModelMapper = new ConventionModelMapper();
var baseEntityType = typeof(Entity);
this.conventionModelMapper.IsEntity((t, declared) => baseEntityType.IsAssignableFrom(t) && baseEntityType != t && !t.IsInterface);
this.conventionModelMapper.IsRootEntity((t, declared) => baseEntityType.Equals(t.BaseType));
this.conventionModelMapper.Class<Entity>(map => {
map.Id(x => x.Id, m => m.Generator(Generators.Identity));
map.Id(x => x.Id, m => m.Column("id"));
map.Version(x => x.Version, m => m.Generated(VersionGeneration.Always));
map.Version(x => x.Version, m => m.Column("version"));
});
this.conventionModelMapper.BeforeMapProperty += (insp, prop, map) => map.Column(prop.LocalMember.Name);
this.conventionModelMapper.BeforeMapManyToOne += (insp, prop, map) => map.Column(prop.LocalMember.GetPropertyOrFieldType().Name + "Id");
this.conventionModelMapper.BeforeMapManyToOne += (insp, prop, map) => map.Cascade(Cascade.Persist);
this.conventionModelMapper.BeforeMapBag += (insp, prop, map) => map.Table(prop.GetContainerEntity(insp).Name + prop.GetRootMember().Name);
this.conventionModelMapper.BeforeMapBag += (insp, prop, map) => map.Key(km => km.Column(prop.GetContainerEntity(insp).Name + "Id"));
this.conventionModelMapper.BeforeMapBag += (insp, prop, map) => map.Cascade(Cascade.All);
this.conventionModelMapper.BeforeMapClass += (insp, prop, map) => map.Table(prop.Name);
this.conventionModelMapper.AddMappings(typeof(RestaurantMappings).Assembly.GetTypes());
this.mapping = this.conventionModelMapper.CompileMappingFor(baseEntityType.Assembly.GetExportedTypes().Where(t => t.Namespace != null && t.Namespace.EndsWith("Entities")));
}
public void ProcessMapper(NHibernate.Mapping.ByCode.ConventionModelMapper mapper)
{
foreach (var entity in entities)
{
var properties = entity.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (var property in properties)
{
var propertyTypeToCheck = property.PropertyType;
if (propertyTypeToCheck.DetermineCollectionElementOrDictionaryValueType() != null)
{
continue;
}
if (entities.Contains(propertyTypeToCheck))
{
continue;
}
if (property.CanWrite == false)
{
var method = typeof(ReadOnlyConvention).GetMethod("MapReadOnly", BindingFlags.Public | BindingFlags.Static)
.MakeGenericMethod(new[] { property.DeclaringType, property.PropertyType });
method.Invoke(null, new object[] { mapper, property });
}
}
}
}
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;
}
static void Main(string[] args)
{
SqlServerTypes.Utilities.LoadNativeAssemblies(AppDomain.CurrentDomain.BaseDirectory);
var mapper = new ConventionModelMapper();
mapper.Class<SomeAreaClass>(c =>
{
c.Property(x => x.Area, m =>
{
m.Type<MsSql2008GeographyType>();
m.NotNullable(true);
});
});
var cfg = new Configuration()
.DataBaseIntegration(db =>
{
db.ConnectionString = "YourConnectionString";
db.Dialect<MsSql2012GeographyDialect>();
});
cfg
.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
cfg
.AddAuxiliaryDatabaseObject(new SpatialAuxiliaryDatabaseObject(cfg));
new SchemaExport(cfg).Execute(false, true, false);
}
static void ExplicitMapping(ConventionModelMapper mapper)
{
mapper.Class<Master>(x =>
{
x.Id(y => y.Id, y => y.Generator(Generators.HighLow));
x.Set(y => y.Options, y =>
{
y.Key(z => z.Column("master_id"));
y.Table("master_option");
}, y =>
{
y.ManyToMany(z =>
{
z.Column("option_id");
});
});
});
mapper.Class<Option>(x =>
{
x.Id(y => y.Id, y => y.Generator(Generators.HighLow));
x.Set(y => y.Masters, y =>
{
y.Key(z => z.Column("option_id"));
y.Table("master_option");
y.Inverse(true);
}, y =>
{
y.ManyToMany(z =>
{
z.Column("master_id");
});
});
});
}
public static Configuration Initialize()
{
INHibernateConfigurationCache cache = new NHibernateConfigurationFileCache();
var mappingAssemblies = new[] {
typeof(ActionConfirmation<>).Assembly.GetName().Name
};
var configuration = cache.LoadConfiguration(CONFIG_CACHE_KEY, null, mappingAssemblies);
if (configuration == null) {
configuration = new Configuration();
configuration
.Proxy(p => p.ProxyFactoryFactory<DefaultProxyFactoryFactory>())
.DataBaseIntegration(db => {
db.ConnectionStringName = "DonSharpLiteConnectionString";
db.Dialect<MsSql2008Dialect>();
})
.AddAssembly(typeof(ActionConfirmation<>).Assembly)
.CurrentSessionContext<LazySessionContext>();
var mapper = new ConventionModelMapper();
mapper.WithConventions(configuration);
cache.SaveConfiguration(CONFIG_CACHE_KEY, configuration);
}
return configuration;
}
protected override void CallGenericRelationMethod(NHibernate.Mapping.ByCode.ConventionModelMapper mapper, System.Reflection.PropertyInfo property, System.Reflection.PropertyInfo inverseProperty)
{
var method = typeof(BidirectionalOneToManyConvention).GetMethod("MapOneToMany", BindingFlags.Public | BindingFlags.Static)
.MakeGenericMethod(new[] { property.DeclaringType, inverseProperty.DeclaringType });
method.Invoke(null, new object[] { mapper, property, inverseProperty });
}
public void ProcessMapper(NHibernate.Mapping.ByCode.ConventionModelMapper mapper)
{
mapper.Class <Entity>(map =>
{
map.Version("Version", m => m.Generated(VersionGeneration.Never));
});
}
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);
}
public void ProcessMapper(NHibernate.Mapping.ByCode.ConventionModelMapper mapper)
{
mapper.BeforeMapClass += (modelInspector, type, map) =>
{
PluralizeEntityName(type, map);
PrimaryKeyConvention(type, map);
};
mapper.BeforeMapClass += MakeNotLazy;
mapper.BeforeMapManyToOne += ReferenceConvention;
mapper.BeforeMapBag += OneToManyConvention;
mapper.BeforeMapManyToMany += ManyToManyConvention;
mapper.BeforeMapJoinedSubclass += MapJoinedSubclass;
mapper.BeforeMapAny += MapAny;
mapper.BeforeMapComponent += MapComponent;
mapper.BeforeMapElement += MapElement;
mapper.BeforeMapIdBag += MapIdBag;
mapper.BeforeMapList += MapList;
mapper.BeforeMapMap += MapMap;
mapper.BeforeMapMapKey += MapMapKey;
mapper.BeforeMapMapKeyManyToMany += MapMapKeyManyToMany;
mapper.BeforeMapOneToMany += MapOneToMany;
mapper.BeforeMapOneToOne += MapOneToOne;
mapper.BeforeMapProperty += MapProperty;
mapper.BeforeMapSet += MapSet;
mapper.BeforeMapSubclass += MapSubclass;
mapper.BeforeMapUnionSubclass += MapUnionSubclass;
mapper.BeforeMapProperty += ReadOnlyConvention;
}
/// <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 void CustomizeMapping(ConventionModelMapper mapper)
{
mapper.Class<Foo>(cm => cm.List(x => x.Bars, bpm =>
{
bpm.Cascade(Cascade.All);
bpm.Type<PersistentQueryableListType<Bar>>();
}));
}
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 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");
}
private static void DefineBaseClass(ConventionModelMapper mapper, System.Type[] baseEntityToIgnore)
{
if (baseEntityToIgnore == null) return;
mapper.IsEntity((type, declared) =>
baseEntityToIgnore.Any(x => x.IsAssignableFrom(type)) &&
!baseEntityToIgnore.Any(x => x == type) &&
!type.IsInterface);
mapper.IsRootEntity((type, declared) => baseEntityToIgnore.Any(x => x == type.BaseType));
}
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 WhenReadOnlyPropertyWithSameBackFieldNoMatch()
{
var mapper = new ConventionModelMapper();
var hbmMapping = mapper.CompileMappingFor(new[] { typeof(MyClass) });
var hbmClass = hbmMapping.RootClasses[0];
var hbmProperty = hbmClass.Properties.Single(x => x.Name == "ReadOnlyWithSameBackField");
Assert.That(hbmProperty.Access, Is.Not.StringContaining("field"));
}
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();
}
protected override void CustomizeMapping(ConventionModelMapper mapper)
{
mapper.Class<Foo>(cm => cm.IdBag(x => x.Bars,
bpm =>
{
bpm.Cascade(Cascade.All);
bpm.Type<PersistentQueryableIdBagType<Bar>>();
},
cer => cer.ManyToMany()));
}
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
}
}
}
public static ISessionFactory GetSessionFactory()
{
var config = new Configuration();
config.SessionFactory().Integrate.Using<SQLiteDialect>().Connected.Using("Data source=nhtest.sqlite").AutoQuoteKeywords();
var mapper = new ConventionModelMapper();
Map(mapper);
config.AddDeserializedMapping(mapper.CompileMappingForAllExplicitlyAddedEntities(), "Mappings");
SchemaMetadataUpdater.QuoteTableAndColumns(config);
new SchemaUpdate(config).Execute(false, true);
return config.BuildSessionFactory();
}
/// <summary>
/// Looks through this assembly for any IOverride classes. If found, it creates an instance
/// of each and invokes the Override(mapper) method, accordingly.
/// </summary>
private static void AddConventionOverrides(ConventionModelMapper mapper) {
Type overrideType = typeof(IOverride);
List<Type> types = typeof(IOverride).Assembly.GetTypes()
.Where(t => overrideType.IsAssignableFrom(t) && t != typeof(IOverride))
.ToList();
types.ForEach(t => {
IOverride conventionOverride = Activator.CreateInstance(t) as IOverride;
conventionOverride.Override(mapper);
});
}
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 static IConfigurationProvider CreateConfigurationProvider()
{
var configFilePath = PathHelpers.InCurrentAppDomain(Constants.NHibernateConfigFileName);
var configuration = new Configuration();
configuration.Configure(configFilePath);
var mapper = new ConventionModelMapper();
mapper.WithConventions();
mapper.WithMappings(configuration);
return new ConfigurationProvider(configuration);
}
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 ProcessMapper(NHibernate.Mapping.ByCode.ConventionModelMapper mapper, IEnumerable <Type> entities)
{
mapper.AfterMapClass += EscapeAndMaybePluralizeEntityName;
mapper.AfterMapClass += PrimaryKeyConvention;
mapper.AfterMapManyToOne += ReferenceConvention;
mapper.AfterMapSet += OneToManyConvention;
mapper.AfterMapBag += OneToManyConvention;
mapper.AfterMapList += OneToManyConvention;
mapper.AfterMapManyToMany += ManyToManyConvention;
mapper.AfterMapJoinedSubclass += MapJoinedSubclass;
mapper.AfterMapProperty += ComponentNamingConvention;
mapper.AfterMapProperty += EscapeColumnName;
}
public static ISessionFactory GetSessionFactory()
{
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
var config = new Configuration();
//config.SessionFactory().Integrate.Using<SQLiteDialect>().Connected.Using("Data source=nhtest.sqlite").AutoQuoteKeywords();
config.SessionFactory().Integrate.Using<SQLiteDialect>().Connected.Using(String.Format("Data source={0}", Path.Combine(clientPath, "nhtest.sqlite"))).AutoQuoteKeywords();
var mapper = new ConventionModelMapper();
Map(mapper);
config.AddDeserializedMapping(mapper.CompileMappingForAllExplicitlyAddedEntities(), "Mappings");
SchemaMetadataUpdater.QuoteTableAndColumns(config);
new SchemaUpdate(config).Execute(false, true);
return config.BuildSessionFactory();
}
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");
}
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 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);
}
/// <summary>
/// Looks through this assembly for any IOverride classes. If found, it creates an instance
/// of each and invokes the Override(mapper) method, accordingly.
/// </summary>
private static void AddConventionOverrides(ConventionModelMapper mapper)
{
var overrideType = typeof(IOverride);
var types = typeof(IOverride).Assembly.GetTypes()
.Where(t => overrideType.IsAssignableFrom(t) && t != typeof(IOverride))
.ToList();
types.ForEach(t =>
{
var conventionOverride = Activator.CreateInstance(t) as IOverride;
conventionOverride.Override(mapper);
});
}
public void ProcessMapper(NHibernate.Mapping.ByCode.ConventionModelMapper mapper)
{
var mappedItemsCache = new List <string>();
foreach (var entity in entities)
{
var properties = entity.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (var property in properties)
{
this.ShouldProcess = false;
var propertyTypeToCheck = property.PropertyType;
if (propertyTypeToCheck.DetermineCollectionElementOrDictionaryValueType() != null)
{
propertyTypeToCheck = propertyTypeToCheck.GetGenericArguments()[0];
}
if (this.BaseEntityType != null && !propertyTypeToCheck.IsSubclassOf(this.BaseEntityType))
{
continue;
}
if (!this.entities.Contains(propertyTypeToCheck))
{
continue;
}
var inverseProperty = GetInverseProperty(property);//should return inverse property if conditions are met or return null otherwise
if ((inverseProperty != null && mappedItemsCache.Contains(inverseProperty.PropertyType.FullName + inverseProperty.Name + inverseProperty.DeclaringType.FullName)) || mappedItemsCache.Contains(property.PropertyType.FullName + property.Name + property.DeclaringType.FullName))
{
continue;
}
if (ShouldProcess)
{
CallGenericRelationMethod(mapper, property, inverseProperty);
if (inverseProperty != null)
{
mappedItemsCache.Add(inverseProperty.PropertyType.FullName + inverseProperty.Name + inverseProperty.DeclaringType.FullName);
}
mappedItemsCache.Add(property.PropertyType.FullName + property.Name + property.DeclaringType.FullName);
}
}
}
}
protected abstract void CallGenericRelationMethod(NHibernate.Mapping.ByCode.ConventionModelMapper mapper, PropertyInfo property, PropertyInfo inverseProperty);
public void ProcessMapper(NHibernate.Mapping.ByCode.ConventionModelMapper mapper)
{
mapper.BeforeMapProperty += mapProperty;
}
public void ProcessMapper(NHibernate.Mapping.ByCode.ConventionModelMapper mapper, IEnumerable <Type> entities)
{
mapper.BeforeMapProperty += mapProperty;
}
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");
}