private void ConfigurePoidGenerator(
IModelInspector modelInspector, System.Type type,
IClassAttributesMapper classCustomizer)
{
classCustomizer.Id(id =>
id.Generator(Generators.GuidComb));
}
protected void BeforeMapManyToOne(IModelInspector modelInspector, PropertyPath member, IManyToOneMapper propertyCustomizer)
{
propertyCustomizer.Column(this.GetNormalizedDbName(String.Concat(member.LocalMember.GetPropertyOrFieldType().Name, "ID")));
propertyCustomizer.Cascade(Cascade.Detach);
propertyCustomizer.Lazy(LazyRelation.NoProxy);
propertyCustomizer.Fetch(FetchKind.Select);
}
/// <summary>
/// Maps a many to one relationship
/// </summary>
/// <param name="modelInspector">The model inspector</param>
/// <param name="property">The property to map</param>
/// <param name="mapper">The property mapper</param>
private void MapManyToOne(IModelInspector modelInspector, PropertyPath property, IManyToOneMapper mapper)
{
Type targetEntityType = property.LocalMember.GetPropertyOrFieldType();
Type sourceEntityType = property.GetContainerEntity(modelInspector);
MemberInfo member = property.PreviousPath != null ? property.PreviousPath.LocalMember : property.LocalMember;
var targetEntityIDProperty = modelInspector.GetIdentifierMember(targetEntityType);
var foreignKeyProperty = property.LocalMember;
string columnName = null;
string foreignKeyName = null;
var one = modelInspector.IsOneToOne(property.LocalMember);
if (MatchOneToOneComponent(property, modelInspector))
{
columnName = namingEngine.ToComponentForeignKeyColumnName(foreignKeyProperty, member, targetEntityIDProperty);
foreignKeyName = namingEngine.ToForeignKeyName(sourceEntityType, targetEntityType, member, targetEntityIDProperty);
}
else
{
columnName = namingEngine.ToForeignKeyColumnName(property.LocalMember, targetEntityIDProperty);
foreignKeyName = namingEngine.ToForeignKeyName(sourceEntityType, targetEntityType, foreignKeyProperty, targetEntityIDProperty);
}
mapper.Column(columnName);
mapper.ForeignKey(foreignKeyName);
}
private void OnBeforeMapProperty(IModelInspector modelinspector, PropertyPath member, IPropertyMapper propertycustomizer)
{
if (member.LocalMember.Name == "Name")
{
propertycustomizer.Unique(true);
}
}
private void OnBeforeMapProperty(IModelInspector modelinspector, PropertyPath member, IPropertyMapper propertycustomizer)
{
if(member.LocalMember.Name == "Name")
{
propertycustomizer.Unique(true);
}
}
void ApplySubClassConvention(IModelInspector mi, Type type, IUnionSubclassAttributesMapper map)
{
var tableAttribute = GetAttribute <TableNameAttribute>(type);
if (tableAttribute != null)
{
map.Table(tableAttribute.TableName);
if (!String.IsNullOrEmpty(tableAttribute.Schema))
{
map.Schema(tableAttribute.Schema);
}
return;
}
//if the type is nested use the name of the parent
if (type.DeclaringType != null)
{
if (typeof(IContainSagaData).IsAssignableFrom(type))
{
map.Table(type.DeclaringType.Name);
}
else
{
map.Table(type.DeclaringType.Name + "_" + type.Name);
}
}
}
protected virtual void OnBeforeMappingCollectionConvention(IModelInspector modelinspector, PropertyPath member, ICollectionPropertiesMapper collectionPropertiesCustomizer)
{
if (modelinspector.IsManyToMany(member.LocalMember))
{
collectionPropertiesCustomizer.Table(member.ManyToManyIntermediateTableName("To"));
}
if (modelinspector.IsSet(member.LocalMember))
{
// If otherside has many-to-one, make it inverse, if not specify foreign key on Key element
MemberInfo oneToManyProperty = member.OneToManyOtherSideProperty();
IEnumerable <MemberInfo> candidatesManyToOne =
MembersProvider
.GetRootEntityMembers(oneToManyProperty.DeclaringType)
.Where(modelinspector.IsManyToOne);
if (candidatesManyToOne.Any(mi => mi.MemberType() == member.LocalMember.DeclaringType))
{
collectionPropertiesCustomizer.Inverse(true);
}
else
{
Contract.Assert(oneToManyProperty.DeclaringType != null, "otherSideProperty.DeclaringType != null");
collectionPropertiesCustomizer.Key(k => k.ForeignKey(string.Format("FK_{0}_{1}", oneToManyProperty.DeclaringType.Name, oneToManyProperty.Name)));
}
}
collectionPropertiesCustomizer.Key(k => k.Column(GetKeyColumnName(modelinspector, member)));
}
/// <summary>
/// Returns the name of the table column for an entity's property.
/// </summary>
/// <param name="inspector">The model inspector.</param>
/// <param name="member">The entity property.</param>
/// <param name="declaringType"> </param>
/// <returns>The name of the table column.</returns>
public string Column(IModelInspector inspector, PropertyPath member, Type declaringType = null)
{
Requires.That(member, "member").IsNotNull();
Requires.That(member.LocalMember, "member.LocalMember").IsNotNull();
var localName = member.LocalMember.Name.Underscore();
if (declaringType != null)
{
return(KeyColumnFormat.Formatted(declaringType.Name.Underscore(), localName));
}
var type = member.LocalMember.GetPropertyOrFieldType();
if (inspector.IsEntity(type)) // is a foreign key
{
var id = inspector.FindPersistentId(type);
if (id != null)
{
return(KeyColumnFormat.Formatted(localName, Column(inspector, id)));
}
}
return(localName);
}
protected virtual void MemberReadOnlyAccessor(IModelInspector modelInspector, PropertyPath member, IAccessorPropertyMapper propertyCustomizer)
{
if (MatchReadOnlyProperty(member.LocalMember))
{
propertyCustomizer.Access(Accessor.ReadOnly);
}
}
protected virtual string GetColumnName(IModelInspector modelInspector, PropertyPath member)
{
string defaultColumnName = member.ToColumnName();
string columnPrefix = null;
string columnName = null;
Type currentType = member.LocalMember.ReflectedType;
bool walkToParent = modelInspector.IsTablePerClassHierarchy(currentType);
while (currentType != null && currentType != typeof(object))
{
ModelMetaData modelMetaData;
if (ModelMetaDatasByType.TryGetValue(currentType, out modelMetaData))
{
columnPrefix = modelMetaData.ColumnPrefix;
modelMetaData.ColumnNames.TryGetValue(defaultColumnName, out columnName);
break;
}
currentType = walkToParent ? currentType.BaseType : null;
}
string result = string.Concat(columnPrefix, columnName ?? GetIdentifier(defaultColumnName));
return(result);
}
public static void DefaultPropertyMapper(IModelInspector modelInspector, PropertyPath path, IPropertyMapper mapper)
{
if (path.LocalMember.GetPropertyOrFieldType() == typeof(bool))
{
mapper.Column(path.ToColumnName() + "Flag");
}
}
private static void ReferenceConvention(IModelInspector modelInspector,
PropertyPath propertyPath,
IManyToOneMapper manyToOneMapper)
{
manyToOneMapper.Column(cm => cm.Name(string.Concat(propertyPath.LocalMember.Name,
ConventionNames.PrimaryKeyPostfix)));
}
public static void MapStringLengthFromAttribute(IModelInspector modelinspector, PropertyPath member, IPropertyMapper propertycustomizer)
{
var propertyInfo = member.LocalMember as PropertyInfo;
if (propertyInfo == null || propertyInfo.PropertyType != typeof(string))
{
return;
}
var attributes = propertyInfo.GetCustomAttributes(true);
var attribute = attributes.FirstOrDefault(x => x.GetType().Name.IndexOf("Length") > -1);
if (attribute == null)
{
return;
}
int value = 0;
var possiblePropertyNames = new[] { "MaximumLength", "Length", "Max", "MaxLength" };
foreach (var name in possiblePropertyNames)
{
var attributeProperty = attribute.GetType().GetProperty(name);
if (attributeProperty != null)
{
value = (int)attributeProperty.GetValue(attribute, null);
break;
}
}
if (value == 0)
{
throw new InvalidOperationException(
string.Format("could not get the length of property {0}", propertyInfo.Name));
}
propertycustomizer.Length(value);
}
protected override void OnBeforeMapClass(IModelInspector modelInspector, Type type, IClassAttributesMapper classCustomizer)
{
classCustomizer.DynamicInsert(DynamicInsert);
classCustomizer.DynamicUpdate(DynamicUpdate);
classCustomizer.Table(GetTableName(modelInspector, type));
classCustomizer.Id(
m =>
{
m.Column(GetKeyColumnName(modelInspector, type, false));
m.Generator(Generators.HighLow);
});
if (modelInspector.IsTablePerClassHierarchy(type))
{
classCustomizer.Discriminator(m => m.Column(GetDiscriminatorColumnName(modelInspector, type)));
classCustomizer.DiscriminatorValue(GetDiscriminatorValue(modelInspector, type));
}
MemberInfo[] versionProperties = VersionProperties(modelInspector, type).ToArray();
if (versionProperties.Length == 1)
{
classCustomizer.Version(versionProperties[0], m => m.Column(GetVersionColumnName(modelInspector, type)));
}
}
private void ConfigureListCascading(
IModelInspector modelInspector, PropertyPath member,
IListPropertiesMapper propertyCustomizer)
{
propertyCustomizer.Cascade(Cascade.All |
Cascade.DeleteOrphans);
}
private void BeforeMappingCollectionConvention(IModelInspector inspector, PropertyPath member, ICollectionPropertiesMapper customizer)
{
if (inspector.IsManyToMany(member.LocalMember))
customizer.Table(member.ManyToManyIntermediateTableName());
customizer.Key(k => k.Column(DetermineKeyColumnName(inspector, member)));
}
private void OnBeforeMapProperty(IModelInspector mi, PropertyPath member, IPropertyMapper map)
{
var type = member.LocalMember.GetPropertyOrFieldType();
if (type == typeof(string))
{
if (member.LocalMember.Name == "FileName")
{
map.Length(255);
}
else
{
map.Type <DefaultStringType>();
map.Length(50);
}
}
else if (type == typeof(byte[]))
{
map.Length(Int32.MaxValue / 2);
map.Column(x => x.SqlType("varbinary(max)"));
}
if (member.LocalMember.Name == "DateCreated")
{
map.Update(false);
}
}
public static void ManyToManyConvention(IModelInspector modelInspector, PropertyPath member, IManyToManyMapper map)
{
map.ForeignKey(
string.Format("fk_{0}_{1}",
member.LocalMember.Name,
member.GetContainerEntity(modelInspector).Name));
}
protected virtual IEnumerable <MemberInfo> VersionProperties(IModelInspector modelInspector, Type type)
{
if (type == null)
{
yield break;
}
Type currentType = type;
while (currentType != null && currentType != typeof(object))
{
PropertyInfo[] properties = currentType.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
foreach (PropertyInfo property in properties.Where(modelInspector.IsVersion))
{
yield return(property);
}
currentType = currentType.BaseType;
}
IEnumerable <PropertyInfo> versionProperties =
type
.GetInterfaces()
.SelectMany(@interface => @interface.GetProperties().Where(modelInspector.IsVersion));
foreach (PropertyInfo property in versionProperties)
{
yield return(property);
}
}
/// <summary>
/// Sets table name and table's schema following the rule that the table name is the same as the type name.
/// </summary>
/// <remarks>
/// Exceptions to the rule:
/// - "ClientScope" class has to be mapped to the "ClientScopes" table.
/// </remarks>
private void BeforeMapConfigurationStoreClass(IModelInspector modelInspector, Type type, IClassAttributesMapper classCustomizer)
{
TableDefinition tableDef = null;
if (type == typeof(ClientScope))
{
tableDef = GetTableDefinition(nameof(_options.ClientScopes), _options);
}
else
{
tableDef = GetTableDefinition(type.Name, _options);
}
if (tableDef != null)
{
classCustomizer.MapToTable(tableDef, _options);
}
// Common mapping rule for IDs
classCustomizer.Id(map =>
{
map.Column("Id");
map.Generator(Generators.Native);
});
}
protected virtual void MemberNoSetterToField(IModelInspector modelInspector, PropertyPath member, IAccessorPropertyMapper propertyCustomizer)
{
if (MatchNoSetterProperty(member.LocalMember))
{
propertyCustomizer.Access(Accessor.NoSetter);
}
}
protected virtual void MemberReadOnlyAccessor(IModelInspector modelInspector, PropertyPath member, IAccessorPropertyMapper propertyCustomizer)
{
if (MatchReadOnlyProperty(member.LocalMember))
{
propertyCustomizer.Access(Accessor.ReadOnly);
}
}
void ApplyPropertyConvention(IModelInspector mi, PropertyPath type, IPropertyMapper map)
{
if (type.PreviousPath != null)
{
if (mi.IsComponent(((PropertyInfo)type.PreviousPath.LocalMember).PropertyType))
{
map.Column(type.PreviousPath.LocalMember.Name + type.LocalMember.Name);
}
}
if (type.LocalMember.GetCustomAttributes(typeof(UniqueAttribute), false).Any())
{
map.Unique(true);
}
var propertyInfo = type.LocalMember as PropertyInfo;
if (propertyInfo != null)
{
if (propertyInfo.PropertyType == typeof(byte[]))
{
map.Length(Int32.MaxValue);
}
return;
}
var fieldInfo = type.LocalMember as FieldInfo;
if (fieldInfo != null && fieldInfo.FieldType == typeof(byte[]))
{
map.Length(Int32.MaxValue);
}
}
private void ConfigureDiscriminatorColumn(IModelInspector modelInspector, Type type, IClassAttributesMapper classCustomizer)
{
if (modelInspector.IsTablePerClassHierarchy(type))
{
classCustomizer.Discriminator(x => x.Column(type.Name + "Type"));
}
}
private static void PropertyConvension(IModelInspector modelInspector,
PropertyPath propertyPath,
IPropertyMapper propertyMapper)
{
if (modelInspector.IsSet(propertyPath.LocalMember))
{
propertyMapper.Access(Accessor.Field);
}
var type = propertyPath.LocalMember.GetPropertyOrFieldType();
if (!type.IsNullable())
{
propertyMapper.NotNullable(true);
}
var propertyName = propertyPath.LocalMember.Name;
if (modelInspector.IsComponent(propertyPath.LocalMember.ReflectedType))
{
var entityName = propertyPath.LocalMember.ReflectedType.Name;
propertyMapper.Column(IdentityBuilder.BuildColumnName(entityName,
propertyName));
}
else
{
propertyMapper.Column(IdentityBuilder.BuildColumnName(propertyName));
}
}
/// <summary>
/// Sets the following conventions:
/// 1) Foreign key fields are named as the property name suffixed by the value of _foreignKeyColumnSuffix.
/// 2) Many to Many link tables are named as the object type names sorted alphabetically with the _manyToManyLinkTableInsert inserted inbetween them.
/// </summary>
private void BeforeMappingCollectionConvention(
IModelInspector inspector,
PropertyPath member,
ICollectionPropertiesMapper customizer)
{
string tableName;
if (inspector.IsManyToMany(member.LocalMember))
{
tableName = this.GetManyToManyLinkTableName(member);
customizer.Table(tableName);
}
else
{
tableName = member.GetCollectionElementType().Name;
}
string columnName = this.GetKeyColumnName(inspector, member);
string foreignKeyName = $"{this._foreignKeyNamePrefix}{tableName}_{columnName}";
customizer.Key(
k =>
{
k.Column(columnName);
k.ForeignKey(foreignKeyName);
});
}
private void OnBeforeMapSet(IModelInspector mi, PropertyPath member, ISetPropertiesMapper map)
{
map.Cascade(Cascade.All | Cascade.DeleteOrphans);
map.BatchSize(50);
map.Lazy(CollectionLazy.Lazy);
map.Inverse(true);
}
/// <summary>
/// Sets the mapper to use:
/// 1) a native generator for int primary keys
/// 2) a Generators.GuidComb generator for Guid primary keys
/// 3) a string length of 128 for string primary keys
/// </summary>
private void OnMapperOnBeforeMapClass(IModelInspector inspector, Type type, IClassAttributesMapper customizer)
{
foreach (var p in type.GetProperties())
{
if (inspector.IsPersistentId(p))
{
var idType = p.PropertyType;
if (idType == typeof(int))
{
customizer.Id(x => x.Generator(Generators.Native));
}
else if (idType == typeof(string))
{
var customAttributes = p.GetCustomAttributes(false);
StringLengthAttribute stringlengthAttribute =
(StringLengthAttribute)
customAttributes.FirstOrDefault(x => x.GetType() == typeof(StringLengthAttribute));
int length = this.DefaltStringIdLength;
if (stringlengthAttribute != null && stringlengthAttribute.MaximumLength > 0)
{
length = stringlengthAttribute.MaximumLength;
}
customizer.Id(x => x.Length(length));
}
else if (idType == typeof(Guid))
{
customizer.Id(x => { x.Generator(Generators.GuidComb); });
}
}
}
}
public static void ManyToManyConvention(IModelInspector modelInspector, PropertyPath member, IManyToManyMapper map)
{
map.ForeignKey(
string.Format("fk_{0}_{1}",
member.LocalMember.Name,
member.GetContainerEntity(modelInspector).Name));
}
public static void RefTextNamingConvention(IModelInspector modelInspector, PropertyPath member, IPropertyMapper map)
{
var property = member.LocalMember as PropertyInfo;
if (property.Name == "RefText")
{
var props = member.GetContainerEntity(modelInspector).GetProperties();
var refTextProp = props.Where(p => Attribute.IsDefined(p, typeof(RefTextAttribute), true));
if (refTextProp.Count() == 1)
{
map.Formula(refTextProp.First().Name);
}
else
{
string s = "";
var signatures = props.Where(
p => Attribute.IsDefined(p, typeof(DomainSignatureAttribute), true) && p.PropertyType == typeof(String));
foreach (var prop in signatures)
{
s += prop.Name + "+'-'+";
}
//if (s == "") throw new NetArchException("Must define RefText, or DomainSignature on string props for a DomainObject class:" + member.GetContainerEntity(modelInspector).Name);
if (s == "")
{
map.Formula("'not defined'");
}
else
{
map.Formula(s.Remove(s.Length - 5));
}
}
}
}
public static void MapMapKeyManyToMany(IModelInspector modelInspector, PropertyPath member, IMapKeyManyToManyMapper map)
{
var property = member.LocalMember as PropertyInfo;
var keytypename = property.PropertyType.DetermineDictionaryKeyType().Name;
map.Column(keytypename + "Id");
}
public static void ComponentNamingConvention(IModelInspector modelInspector, PropertyPath member, IPropertyMapper map)
{
//var property = member.LocalMember as PropertyInfo;
//if (modelInspector.IsComponent(property.DeclaringType))
//{
// map.Column(member.PreviousPath.LocalMember.Name + "_" + member.LocalMember.Name);
//}
}
private static string DetermineKeyColumnName(IModelInspector inspector, PropertyPath member)
{
var otherSideProperty = member.OneToManyOtherSideProperty();
if (inspector.IsOneToMany(member.LocalMember) && otherSideProperty != null)
return otherSideProperty.Name + ForeignKeyColumnPostfix;
return member.Owner().Name + ForeignKeyColumnPostfix;
}
private static void BeforeBag(IModelInspector modelinspector, PropertyPath member,
IBagPropertiesMapper propertycustomizer)
{
propertycustomizer.Key(x => x.Column(member.GetContainerEntity(modelinspector).Name + "Id"));
propertycustomizer.Cascade(Cascade.All);
propertycustomizer.Inverse(false);
propertycustomizer.Lazy(CollectionLazy.NoLazy);
}
private void OnBeforeMapClass(IModelInspector mi, Type type, IClassAttributesMapper map)
{
if (mi.IsRootEntity(type))
{
this.MapTable(type, map);
this.MapIdentifier(type, map);
}
}
public static void MapStringAsVarchar(IModelInspector modelInspector, PropertyPath member, IPropertyMapper propertyCustomizer)
{
var propertyInfo = member.LocalMember as PropertyInfo;
if (propertyInfo != null && propertyInfo.PropertyType == typeof(string))
{
propertyCustomizer.Type(NHibernateUtil.AnsiString);
}
}
protected void BeforeMapManyToMany(IModelInspector modelInspector, PropertyPath member, IManyToManyMapper collectionRelationManyToManyCustomizer)
{
collectionRelationManyToManyCustomizer.Lazy(LazyRelation.Proxy);
Type destinationType = member.LocalMember.GetPropertyOrFieldType().GetGenericArguments()[0];
collectionRelationManyToManyCustomizer.Column(this.GetNormalizedDbName(String.Concat(destinationType.Name, "ID")));
collectionRelationManyToManyCustomizer.Class(destinationType);
}
public static System.Type GetContainerEntity(this PropertyPath propertyPath, IModelInspector domainInspector)
{
PropertyPath analizing = propertyPath;
while (analizing.PreviousPath != null && !domainInspector.IsEntity(analizing.LocalMember.ReflectedType))
{
analizing = analizing.PreviousPath;
}
return analizing.LocalMember.ReflectedType;
}
/// <summary>
/// Returns the name of the foreign key in a relationship.
/// </summary>
/// <param name="inspector">The model inspector.</param>
/// <param name="member">The entity property.</param>
/// <returns>The name of the foreign key.</returns>
public string ForeignKey(IModelInspector inspector, PropertyPath member, Type declaringType = null, Type idDeclaringType = null)
{
Requires.That(member, "member").IsNotNull();
Requires.That(member.LocalMember, "member.LocalMember").IsNotNull();
return ForeignKeyNameFormat.Formatted(Table(inspector, idDeclaringType ?? member.LocalMember.GetPropertyOrFieldType()),
Table(inspector, declaringType ?? member.LocalMember.DeclaringType),
Column(inspector, member, idDeclaringType));
}
public static void ReferenceConvention(IModelInspector modelInspector, PropertyPath member, IManyToOneMapper map)
{
map.Column(k => k.Name(member.LocalMember.GetPropertyOrFieldType().Name + "Id"));
map.ForeignKey(
string.Format("fk_{0}_{1}",
member.LocalMember.Name,
member.GetContainerEntity(modelInspector).Name));
map.Cascade(Cascade.All | Cascade.DeleteOrphans);
}
/// <summary>
/// Applies the <see cref="DateTimeOffsetSplitType"/> Composite user type to all <see cref="DateTimeOffset"/> fields in the mapping.
/// </summary>
/// <remarks>
/// Allows the use of <see cref="DateTimeOffset"/> type with databases that do not natively support it.
/// User: mapper.BeforeMapProperty += ModelMapperHelper.ApplyDateTimeOffsetSplitTypeToDateTimeOffset
/// </remarks>
public static void ApplyDateTimeOffsetSplitTypeToDateTimeOffset(IModelInspector inspector, PropertyPath property, IPropertyMapper mapper)
{
Type propertyType = property.LocalMember.GetPropertyOrFieldType();
if (propertyType == typeof(DateTimeOffset) || propertyType == typeof(DateTimeOffset?))
{
mapper.Type(typeof(DateTimeOffsetSplitType), null);
string columName = property.ToColumnName();
mapper.Columns(n => n.Name(columName + "DateTime"), n => n.Name(columName + "Offset"));
}
}
private ConventionModelMapper(string tablePrefix, IModelInspector modelInspector, ICustomizersHolder customizerHolder)
: base(modelInspector, modelInspector as IModelExplicitDeclarationsHolder, customizerHolder, new DefaultCandidatePersistentMembersProvider())
{
Conventions = new MappingConventions
{
TablePrefix = tablePrefix
};
CustomizersHolder = customizerHolder;
AppendDefaultEvents();
}
private void DicriminatorColumnNamedClass(IModelInspector modelInspector, Type type, IClassAttributesMapper classCustomizer)
{
if(DiscriminatorIsNotRequired(type)) return;
classCustomizer.Discriminator(
dm =>
{
dm.Column("Class");
dm.NotNullable(true);
});
}
private void IdBagTableName(IModelInspector modelInspector, PropertyPath member, IIdBagPropertiesMapper propertyCustomizer)
{
if (member.LocalMember.IsComponentCollection(Mapper.ModelInspector))
{
propertyCustomizer.Table(member.GetRootMember().DeclaringType.Name + member.ToColumnName());
}
else
{
propertyCustomizer.Table(BidirectionAssociation.AnalizeManyToMany(member.LocalMember).ManyToManyTablename);
}
}
public static void OneToManyConvention(IModelInspector modelInspector, PropertyPath member, IBagPropertiesMapper map)
{
var inv = member.LocalMember.GetInverseProperty();
if (inv == null)
{
map.Key(x => x.Column(member.GetContainerEntity(modelInspector).Name + "Id"));
map.Cascade(Cascade.All | Cascade.DeleteOrphans);
map.BatchSize(20);
map.Inverse(true);
}
}
private void NameKeyColumn(IModelInspector modelinspector, PropertyPath member, IBagPropertiesMapper propertycustomizer)
{
var association = BidirectionAssociation.AnalyzeManyToOne(member);
var columnName = association.IsBidirectional
? association.ColumnNameOnCollectionSide
: member.GetRootMember().ReflectedType.Name + "Id";
propertycustomizer.Key(keyMapper => keyMapper.Column(columnName));
propertycustomizer.Inverse(association.IsBidirectional);
}
private static void MapEnumAsString(IModelInspector modelInspector, PropertyPath member, IPropertyMapper propertyCustomizer)
{
var propertyType = member.LocalMember.GetPropertyOrFieldType();
if (propertyType.IsEnumOrNullableEnum() == false) return;
var enumType = propertyType.IsEnum ? propertyType : propertyType.GetGenericArguments().Single();
var type = typeof(EnumStringType<>).MakeGenericType(enumType);
propertyCustomizer.Type(type, null);
}
protected virtual void ComponentParentNoSetterToField(IModelInspector modelInspector, PropertyPath member, IComponentAttributesMapper componentMapper)
{
System.Type componentType = member.LocalMember.GetPropertyOrFieldType();
IEnumerable<MemberInfo> persistentProperties =
MembersProvider.GetComponentMembers(componentType).Where(p => ModelInspector.IsPersistentProperty(p));
MemberInfo parentReferenceProperty = GetComponentParentReferenceProperty(persistentProperties, member.LocalMember.ReflectedType);
if (parentReferenceProperty != null && MatchNoSetterProperty(parentReferenceProperty))
{
componentMapper.Parent(parentReferenceProperty, cp => cp.Access(Accessor.NoSetter));
}
}
protected virtual new void BeforeMapSet(IModelInspector modelInspector, PropertyPath member, ISetPropertiesMapper propertyCustomizer)
{
if (modelInspector.IsManyToMany(member.LocalMember) == true)
{
propertyCustomizer.Key(x => x.Column(member.LocalMember.DeclaringType.Name + "_Id"));
Type sourceType = member.LocalMember.DeclaringType;
Type destinationType = member.LocalMember.GetPropertyOrFieldType().GetGenericArguments().First();
String [] names = new Type[] { sourceType, destinationType }.Select(x => x.Name).OrderBy(x => x).ToArray();
//set inverse on the relation of the alphabetically first entity name
propertyCustomizer.Inverse(sourceType.Name == names.First());
//set mapping table name from the entity names in alphabetical order
propertyCustomizer.Table(String.Join("_", names));
}
}
private void IdBagHiloGenerator(IModelInspector modelInspector, PropertyPath member, IIdBagPropertiesMapper propertyCustomizer)
{
var hiloRowName = member.LocalMember.IsComponentCollection(Mapper.ModelInspector)
? member.GetRootMember().DeclaringType.Name + member.ToColumnName()
: BidirectionAssociation.AnalizeManyToMany(member.LocalMember).ManyToManyTablename;
propertyCustomizer.Id(idMap =>
{
idMap.Generator(new EntityHighLowGeneratorDef(hiloRowName));
idMap.Column("Id");
idMap.Type((IIdentifierType)NHibernateUtil.Int64);
});
Mapper.AddHiLoScript(EntityHighLowGenerator.GetInsertFor(hiloRowName));
}
/// <summary>
/// Returns the name of the table column for an entity's property.
/// </summary>
/// <param name="inspector">The model inspector.</param>
/// <param name="member">The entity property.</param>
/// <param name="declaringType"> </param>
/// <returns>The name of the table column.</returns>
public string Column(IModelInspector inspector, PropertyPath member, Type declaringType = null)
{
Requires.That(member, "member").IsNotNull();
Requires.That(member.LocalMember, "member.LocalMember").IsNotNull();
var localName = member.LocalMember.Name.Underscore();
if (declaringType != null)
{
return KeyColumnFormat.Formatted(declaringType.Name.Underscore(), localName);
}
var type = member.LocalMember.GetPropertyOrFieldType();
if (inspector.IsEntity(type)) // is a foreign key
{
var id = inspector.FindPersistentId(type);
if (id != null) return KeyColumnFormat.Formatted(localName, Column(inspector, id));
}
return localName;
}
/// <summary>
/// Indicates if a given property matches a one to one component relationship
/// </summary>
/// <param name="property">The property</param>
/// <param name="modelInspector">An instance of the current model inspector</param>
/// <returns>True if the property matches a one to one component relationship, false if not</returns>
private bool MatchOneToOneComponent(PropertyPath property, IModelInspector modelInspector)
{
bool result = false;
if (modelInspector.IsComponent(property.LocalMember.DeclaringType))
{
result = (property.PreviousPath != null) && !property.PreviousPath.LocalMember.GetPropertyOrFieldType().IsGenericCollection();
}
return result;
}
/// <summary>
/// Maps an union subclass inheritance hierarchy
/// </summary>
/// <param name="modelInspector">The model inspector</param>
/// <param name="type">The entity type</param>
/// <param name="mapper">The union subclass mapper</param>
private void MapUnionSubclass(IModelInspector modelInspector, Type type, IUnionSubclassAttributesMapper mapper)
{
Type entityType = type.UnderlyingSystemType;
string schemaName = namingEngine.ToSchemaName(entityType);
string tableName = namingEngine.ToTableName(entityType);
// Mapping
mapper.Schema(schemaName);
mapper.Table(tableName);
}
/// <summary>
/// Maps a property according the naming conventions configuration
/// </summary>
/// <param name="modelInspector">The model inspector</param>
/// <param name="property">The property</param>
/// <param name="mapper">The property mapper</param>
private void MapProperty(IModelInspector modelInspector, PropertyPath property, IPropertyMapper mapper)
{
if (MatchOneToOneComponent(property, modelInspector))
{
mapper.Column(this.namingEngine.ToComponentColumnName(property.LocalMember, property.PreviousPath.LocalMember));
}
else
{
mapper.Column(this.namingEngine.ToColumnName(property.LocalMember));
}
}
/// <summary>
/// Maps a map relationship
/// </summary>
/// <param name="modelInspector">The model inspector</param>
/// <param name="member">The member to map</param>
/// <param name="collectionRelationElementCustomizer">The property mapper </param>
private void MapMapKey(IModelInspector modelInspector, PropertyPath member, IMapKeyMapper mapper)
{
string columName = namingEngine.ToElementKeyColumnName(member.LocalMember);
mapper.Column(columName);
}
/// <summary>
/// Maps a many to one relationship
/// </summary>
/// <param name="modelInspector">The model inspector</param>
/// <param name="property">The property to map</param>
/// <param name="mapper">The property mapper</param>
private void MapManyToOne(IModelInspector modelInspector, PropertyPath property, IManyToOneMapper mapper)
{
Type targetEntityType = property.LocalMember.GetPropertyOrFieldType();
Type sourceEntityType = property.GetContainerEntity(modelInspector);
MemberInfo member = property.PreviousPath != null ? property.PreviousPath.LocalMember : property.LocalMember;
var targetEntityIDProperty = modelInspector.GetIdentifierMember(targetEntityType);
var foreignKeyProperty = property.LocalMember;
string columnName = null;
string foreignKeyName = null;
if (MatchOneToOneComponent(property, modelInspector))
{
columnName = namingEngine.ToComponentForeignKeyColumnName(foreignKeyProperty, member, targetEntityIDProperty);
foreignKeyName = namingEngine.ToForeignKeyName(sourceEntityType, targetEntityType, member, targetEntityIDProperty);
}
else
{
columnName = namingEngine.ToForeignKeyColumnName(property.LocalMember, targetEntityIDProperty);
foreignKeyName = namingEngine.ToForeignKeyName(sourceEntityType, targetEntityType, foreignKeyProperty, targetEntityIDProperty);
}
mapper.Column(columnName);
mapper.ForeignKey(foreignKeyName);
}
/// <summary>
/// Maps a many to many relationship
/// </summary>
/// <param name="modelInspector">The model inspector</param>
/// <param name="property">The property to map</param>
/// <param name="mapper">The property mapper</param>
private void MapManyToMany(IModelInspector modelInspector, PropertyPath property, IManyToManyMapper mapper)
{
Type sourceType = property.LocalMember.DeclaringType;
Type targetType = property.LocalMember.GetPropertyOrFieldType().DetermineCollectionElementType();
var primaryKeyProperty = modelInspector.GetIdentifierMember(targetType);
var foreignKeyProperty = property.LocalMember;
string foreignKeyColumnName = namingEngine.ToManyToManyForeignKeyColumnName(targetType, primaryKeyProperty);
string foreignKeyName = namingEngine.ToManyToManyForeignKeyName(sourceType, targetType, targetType, primaryKeyProperty);
mapper.Column(foreignKeyColumnName);
mapper.ForeignKey(foreignKeyName);
}
/// <summary>
/// Maps a joined subclass inheritance hierarchy
/// </summary>
/// <param name="modelInspector">The model inspector</param>
/// <param name="type">The entity type</param>
/// <param name="mapper">The joined subclass mapper</param>
private void MapJoinedSubclass(IModelInspector modelInspector, Type type, IJoinedSubclassAttributesMapper mapper)
{
Type entityType = type.UnderlyingSystemType;
Type baseType = type.GetBaseTypes().FirstOrDefault(t => IsEntity(t));
string schemaName = namingEngine.ToSchemaName(entityType);
string tableName = namingEngine.ToTableName(entityType);
var idProperty = modelInspector.GetIdentifierMember(entityType);
string foreignKeyColumnName = namingEngine.ToForeignKeyColumnName(baseType, idProperty);
string foreignKeyName = namingEngine.ToForeignKeyName(entityType, baseType, entityType, idProperty);
// Mapping
mapper.Schema(schemaName);
mapper.Table(tableName);
mapper.Key(k =>
{
k.Column(foreignKeyColumnName);
k.ForeignKey(foreignKeyName);
});
}
/// <summary>
/// Maps a collection of components or entities
/// </summary>
/// <param name="modelInspector">The model inspector</param>
/// <param name="property">The property to map</param>
/// <param name="mapper">The collections mapper</param>
private void MapCollection(IModelInspector modelInspector, PropertyPath property, ICollectionPropertiesMapper mapper)
{
Type sourceType = property.GetContainerEntity(modelInspector);
Type targetType = property.LocalMember.GetPropertyOrFieldType().DetermineCollectionElementType();
var primaryKeyProperty = modelInspector.GetIdentifierMember(sourceType);
var foreignKeyProperty = property.LocalMember;
string foreignKeyColumnName = null;
string foreignKeyName = null;
string tableName = null;
string schemaName = null;
if (modelInspector.IsEntity(targetType))
{
// Entity Relationship Mapping
if (modelInspector.IsManyToMany(property.LocalMember))
{
// Many to many
foreignKeyColumnName = namingEngine.ToManyToManyForeignKeyColumnName(sourceType, primaryKeyProperty);
foreignKeyName = namingEngine.ToManyToManyForeignKeyName(sourceType, targetType, sourceType, primaryKeyProperty);
tableName = namingEngine.ToManyToManyTableName(sourceType, targetType);
schemaName = namingEngine.ToSchemaName(sourceType, targetType);
}
else
{
// One to Many
foreignKeyColumnName = namingEngine.ToForeignKeyColumnName(sourceType, primaryKeyProperty);
foreignKeyName = namingEngine.ToForeignKeyName(targetType, sourceType, sourceType, primaryKeyProperty);
}
}
else if (IsElement(targetType))
{
// Element mapping
foreignKeyColumnName = namingEngine.ToForeignKeyColumnName(sourceType, primaryKeyProperty);
foreignKeyName = namingEngine.ToComponentForeignKeyName(targetType, sourceType, foreignKeyProperty, primaryKeyProperty);
tableName = namingEngine.ToElementTableName(sourceType, targetType, property.LocalMember);
schemaName = namingEngine.ToSchemaName(sourceType, targetType);
}
else
{
// Component Relationship Mapping
foreignKeyColumnName = namingEngine.ToForeignKeyColumnName(sourceType, primaryKeyProperty);
foreignKeyName = namingEngine.ToComponentForeignKeyName(targetType, sourceType, foreignKeyProperty, primaryKeyProperty);
tableName = namingEngine.ToComponentTableName(sourceType, targetType, property.LocalMember);
schemaName = namingEngine.ToSchemaName(sourceType, targetType);
}
// Mapping
mapper.Schema(schemaName);
mapper.Table(tableName);
mapper.Key(k =>
{
k.Column(foreignKeyColumnName);
k.ForeignKey(foreignKeyName);
});
}
/// <summary>
/// Maps a property according the naming conventions configuration
/// </summary>
/// <param name="modelInspector">The model inspector</param>
/// <param name="property">The class type</param>
/// <param name="mapper">The class mapper</param>
private void MapClass(IModelInspector modelInspector, Type classType, IClassAttributesMapper mapper)
{
Type entityType = classType.UnderlyingSystemType;
string schemaName = namingEngine.ToSchemaName(entityType) ?? mapper.GetSchema();
string tableName = namingEngine.ToTableName(entityType);
var idProperty = modelInspector.GetIdentifierMember(entityType);
var versionProperty = modelInspector.GetVersionMember(entityType);
string primaryKeyColumnName = namingEngine.ToPrimaryKeyColumnName(entityType, idProperty);
// Mapping
mapper.Schema(schemaName);
mapper.Table(tableName);
mapper.Id(id => id.Column(primaryKeyColumnName));
// Version mapping
if (versionProperty != null)
{
string versionColumnName = namingEngine.ToColumnName(versionProperty);
mapper.Version(versionProperty, m => m.Column(versionColumnName));
}
}
