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 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);
}
public static void AutoMapper_BeforeMapManyToOne(IModelInspector modelInspector, PropertyPath member,
IManyToOneMapper propertyCustomizer)
{
var pi = member.LocalMember as PropertyInfo;
if (null != pi)
{
propertyCustomizer.Column(k => k.Name(pi.PropertyType.Name + "Id"));
propertyCustomizer.ForeignKey(GenerateForeignKeyName(pi.PropertyType.Name, pi.DeclaringType.Name,
pi.ReflectedType.Name));
}
}
private void OnBeforeMapManyToOne(IModelInspector mi, PropertyPath member, IManyToOneMapper propertyCustomizer)
{
var pi = member.LocalMember as PropertyInfo;
if (pi != null && mi.IsRootEntity(pi.PropertyType))
{
string name = pi.PropertyType.Name + "ID";
// CreatedBy == MemberID_CreatedBy
if (pi.PropertyType.Name != pi.Name)
{
name += "_" + pi.Name;
}
propertyCustomizer.Column(k => k.Name(name));
}
}
public static void EntityName(this IManyToOneMapper mapper, string entityName)
{
switch (mapper)
{
case KeyManyToOneMapper m:
m.EntityName(entityName);
break;
case ManyToOneMapper m:
m.EntityName(entityName);
break;
default:
throw new ArgumentException(
"Only mappers of type 'KeyManyToOneMapper' and 'ManyToOneMapper' are supported, got " +
mapper.GetType().FullName,
nameof(mapper));
}
}
private void ReferenceConvention(IModelInspector modelInspector, PropertyPath member, IManyToOneMapper map)
{
if (FkColumnNaming != null)
{
foreach (var idProperty in member.LocalMember.GetPropertyOrFieldType().GetProperties().Where(modelInspector.IsPersistentId))
{
map.Column(k => k.Name(FkColumnNaming(member.LocalMember, idProperty)));
}
}
if (FkConstraintNaming != null)
{
map.ForeignKey(
FkConstraintNaming(
member.LocalMember,
member.GetContainerEntity(modelInspector)));
}
}
public static void MapManyToOneWithCascade(IModelInspector modelinspector, PropertyPath member, IManyToOneMapper propertycustomizer)
{
propertycustomizer.Cascade(Cascade.Persist);
}
public static void ReferenceConvention(IModelInspector modelInspector, PropertyPath member, IManyToOneMapper map)
{
map.Column(member.LocalMember.Name + "Id");
}
/// <summary>
/// Maps many formulas.
/// </summary>
/// <param name="mapper">The mapper.</param>
/// <param name="formulas">The formulas to map.</param>
/// <remarks>Replaces any previously mapped column or formula.</remarks>
public static void Formulas(this IManyToOneMapper mapper, params string[] formulas)
{
CallFormulas(mapper, formulas);
}
public void InvokeCustomizers(PropertyPath member, IManyToOneMapper mapper)
{
InvokeCustomizers(manyToOneCustomizers, member, mapper);
}
private void DefaultMapManyToOne(IModelInspector inspector, PropertyPath member, IManyToOneMapper customizer)
{
customizer.Column(member.LocalMember.Name + _foreignKeyColumnPostfix);
}
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);
}
protected override void OnBeforeMapManyToOne(IModelInspector modelInspector, PropertyPath member, IManyToOneMapper propertyCustomizer)
{
string foreignKeyColumnName = GetKeyColumnName(modelInspector, member);
propertyCustomizer.Column(foreignKeyColumnName);
propertyCustomizer.ForeignKey(string.Format("FK_{0}_{1}", member.Owner().Name, foreignKeyColumnName));
bool required =
member.LocalMember
.GetCustomAttributes()
.OfType<RequiredAttribute>()
.Any();
propertyCustomizer.NotNullable(required);
}
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>
/// Maps a mixed list of columns and formulas.
/// </summary>
/// <param name="mapper">The mapper.</param>
/// <param name="columnOrFormulaMapper">The mappers for each column or formula.</param>
/// <remarks>Replaces any previously mapped column or formula.</remarks>
public static void ColumnsAndFormulas(
this IManyToOneMapper mapper,
params Action <IColumnOrFormulaMapper>[] columnOrFormulaMapper)
{
CallColumnsAndFormulas(mapper, columnOrFormulaMapper);
}
private static void ReferenceConvention(IModelInspector modelInspector, PropertyPath propertyPath, IManyToOneMapper manyToOneMapper)
{
manyToOneMapper.Column(cm => cm.Name(IdentityBuilder.BuildPrimaryKey(propertyPath.LocalMember.Name)));
}
/// <summary>
/// Applies any conventions required for many-to-one properties.
/// </summary>
/// <param name="mapper"> The mapper. </param>
/// <param name="property"> The property. </param>
/// <param name="propertyType"> </param>
/// <param name="attributes"> </param>
protected virtual void ApplyManyToOneConventions(IManyToOneMapper mapper, PropertyPath property,
Type propertyType, IEnumerable <Attribute> attributes)
{
mapper.NotNullable(!IsNullable(propertyType, attributes));
}
protected virtual void OnAfterMapManyToOne(IModelInspector modelInspector, PropertyPath member, IManyToOneMapper propertyCustomizer)
{
}
private static void MapperOnBeforeMapManyToOne(IModelInspector insp, PropertyPath prop, IManyToOneMapper map)
{
map.Column(prop.LocalMember.Name + "Id");
}
private static void MapManyToOne(IModelInspector modelinspector, PropertyPath member, IManyToOneMapper manyToOne)
{
var columnName = member.LocalMember.GetPropertyOrFieldType().Name + "Id";
manyToOne.Column(columnName);
string foreignKey = string.Format("FK_{0}__{1}__{2}", member.LocalMember.ReflectedType.Name, member.LocalMember.Name,
columnName);
manyToOne.ForeignKey(foreignKey);
manyToOne.Cascade(Cascade.Persist);
manyToOne.NotNullable(true);
}
private void ApplyManyToOneConvention(IModelInspector mi, PropertyPath type, IManyToOneMapper map)
{
map.Column(type.LocalMember.Name + "_id");
}
protected virtual void OnBeforeMapManyToOne(IModelInspector modelInspector, PropertyPath member, IManyToOneMapper propertyCustomizer)
{
}
protected override void OnBeforeMapManyToOne(IModelInspector modelInspector, PropertyPath member, IManyToOneMapper propertyCustomizer)
{
string foreignKeyColumnName = GetKeyColumnName(modelInspector, member);
propertyCustomizer.Column(foreignKeyColumnName);
propertyCustomizer.ForeignKey(string.Format("FK_{0}_{1}", member.Owner().Name, foreignKeyColumnName));
bool required =
member.LocalMember
.GetCustomAttributes()
.OfType <RequiredAttribute>()
.Any();
propertyCustomizer.NotNullable(required);
}
private void NameForeignKeyColumn(IModelInspector modelinspector, PropertyPath member, IManyToOneMapper propertycustomizer)
{
propertycustomizer.Column(member.ToColumnName() + "Id");
}
/// <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 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);
}
