public void Map(ClassMappingBase classMap, Member property)
{
if (!(classMap is ClassMapping))
{
return;
}
var version = new VersionMapping
{
Name = property.Name,
};
version.SetDefaultValue("Type", GetDefaultType(property));
version.AddDefaultColumn(new ColumnMapping {
Name = property.Name
});
if (IsSqlTimestamp(property))
{
version.Columns.Each(x =>
{
x.SqlType = "timestamp";
x.NotNull = true;
});
version.UnsavedValue = null;
}
((ClassMapping)classMap).Version = version;
}
public void Map(ClassMappingBase classMap, Member member)
{
var manyToOne = CreateMapping(member);
manyToOne.ContainingEntityType = classMap.Type;
classMap.AddReference(manyToOne);
}
public void Map(ClassMappingBase classMap, Member member)
{
if (!(classMap is ClassMapping))
{
return;
}
var version = new VersionMapping
{
ContainingEntityType = classMap.Type,
};
version.Set(x => x.Name, Layer.Defaults, member.Name);
version.Set(x => x.Type, Layer.Defaults, GetDefaultType(member));
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, member.Name);
version.AddColumn(Layer.Defaults, columnMapping);
SetDefaultAccess(member, version);
if (IsSqlTimestamp(member))
{
version.Columns.Each(column =>
{
column.Set(x => x.SqlType, Layer.Defaults, "timestamp");
column.Set(x => x.NotNull, Layer.Defaults, true);
});
version.Set(x => x.UnsavedValue, Layer.Defaults, null);
}
((ClassMapping)classMap).Set(x => x.Version, Layer.Defaults, version);
}
public virtual void MapEverythingInClass(ClassMappingBase mapping, Type entityType, IList <string> mappedProperties)
{
foreach (var property in entityType.GetProperties())
{
TryToMapProperty(mapping, property.ToMember(), mappedProperties);
}
}
public void Map(ClassMappingBase classMap, Member member)
{
if (!(classMap is ClassMapping))
{
return;
}
var idMapping = new IdMapping {
ContainingEntityType = classMap.Type
};
idMapping.AddDefaultColumn(new ColumnMapping()
{
Name = member.Name
});
idMapping.Name = member.Name;
idMapping.Type = new TypeReference(member.PropertyType);
idMapping.Member = member;
idMapping.SetDefaultValue("Generator", GetDefaultGenerator(member));
if (member.IsProperty && !member.CanWrite)
{
idMapping.Access = cfg.GetAccessStrategyForReadOnlyProperty(member).ToString();
}
((ClassMapping)classMap).Id = idMapping;
}
public void Map(ClassMappingBase classMap, Member member)
{
if (!(classMap is ClassMapping))
{
return;
}
var version = new VersionMapping
{
Name = member.Name,
ContainingEntityType = classMap.Type,
};
version.SetDefaultValue("Type", GetDefaultType(member));
version.AddDefaultColumn(new ColumnMapping {
Name = member.Name
});
if (member.IsProperty && !member.CanWrite)
{
version.Access = cfg.GetAccessStrategyForReadOnlyProperty(member).ToString();
}
if (IsSqlTimestamp(member))
{
version.Columns.Each(x =>
{
x.SqlType = "timestamp";
x.NotNull = true;
});
version.UnsavedValue = null;
}
((ClassMapping)classMap).Version = version;
}
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList <Member> mappedMembers)
{
var discriminatorSet = HasDiscriminator(mapping);
var isDiscriminated = cfg.IsDiscriminated(classType) || discriminatorSet;
var mappingTypesWithLogicalParents = GetMappingTypesWithLogicalParents();
foreach (var inheritedClass in mappingTypesWithLogicalParents
.Where(x => x.Value != null && x.Value.Type == classType)
.Select(x => x.Key))
{
var tempMapping = mapping as ClassMapping;
var tempIsNull = tempMapping == null;
if (isDiscriminated && !discriminatorSet && !tempIsNull)
{
var discriminatorColumn = cfg.GetDiscriminatorColumn(classType);
var discriminator = new DiscriminatorMapping
{
ContainingEntityType = classType,
};
discriminator.Set(x => x.Type, Layer.Defaults, new TypeReference(typeof(string)));
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, discriminatorColumn);
discriminator.AddColumn(Layer.Defaults, columnMapping);
tempMapping.Set(x => x.Discriminator, Layer.Defaults, discriminator);
discriminatorSet = true;
}
SubclassMapping subclassMapping;
var tempSubClassMap = mapping as SubclassMapping;
if (!tempIsNull && tempMapping.IsUnionSubclass || tempSubClassMap != null && tempSubClassMap.SubclassType == SubclassType.UnionSubclass)
{
subclassMapping = new SubclassMapping(SubclassType.UnionSubclass);
subclassMapping.Set(x => x.Type, Layer.Defaults, inheritedClass.Type);
}
else if (isDiscriminated || tempSubClassMap != null && tempSubClassMap.SubclassType == SubclassType.Subclass)
{
subclassMapping = new SubclassMapping(SubclassType.Subclass);
subclassMapping.Set(x => x.Type, Layer.Defaults, inheritedClass.Type);
}
else
{
subclassMapping = new SubclassMapping(SubclassType.JoinedSubclass);
subclassMapping.Set(x => x.Type, Layer.Defaults, inheritedClass.Type);
subclassMapping.Set(x => x.Key, Layer.Defaults, new KeyMapping());
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, mapping.Type.Name + "_id");
subclassMapping.Key.AddColumn(Layer.Defaults, columnMapping);
}
// track separate set of properties for each sub-tree within inheritance hierarchy
var subclassMembers = new List <Member>(mappedMembers);
MapSubclass(subclassMembers, subclassMapping, inheritedClass);
mapping.AddSubclass(subclassMapping);
MergeMap(inheritedClass.Type, subclassMapping, subclassMembers);
}
}
public virtual void VisitClassBase(ClassMappingBase classMapping)
{
foreach (var reference in classMapping.References)
{
VisitReference(reference);
}
foreach (var collection in classMapping.Collections)
{
VisitCollection(collection);
}
foreach (var subClass in classMapping.Subclasses)
{
VisitSubclass(subClass);
}
foreach (var component in classMapping.Components)
{
if (component is ReferenceComponentMapping)
{
var refComponent = component as ReferenceComponentMapping;
var propertyName = component.Name;
var tableName = string.Empty;
if (classMapping is ClassMapping)
{
tableName = ((ClassMapping)classMapping).TableName.Replace("`", "");
}
else
{
tableName = classMapping.Type.Name;
}
foreach (var reference in component.References)
{
var fkName = $"FK_{tableName}{propertyName}{reference.Name}To_{reference.Name}";
reference.Set(x => x.ForeignKey, Layer.UserSupplied, fkName);
}
}
VisitComponent(component);
}
foreach (var any in classMapping.Anys)
{
VisitAny(any);
}
foreach (var join in classMapping.Joins)
{
VisitJoin(join);
}
foreach (var one in classMapping.OneToOnes)
{
VisitOneToOne(one);
}
}
static bool HasDiscriminator(ClassMappingBase mapping)
{
if (mapping is ClassMapping && ((ClassMapping)mapping).Discriminator != null)
{
return(true);
}
return(false);
}
private void MapInheritanceTree(Type classType, ClassMappingBase mapping, IList <string> mappedProperties)
{
var discriminatorSet = false;
var isDiscriminated = expressions.IsDiscriminated(classType);
foreach (var inheritedClass in mappingTypes.Where(q =>
q.Type.BaseType == classType &&
!expressions.IsConcreteBaseType(q.Type.BaseType)))
{
if (isDiscriminated && !discriminatorSet && mapping is ClassMapping)
{
var discriminatorColumn = expressions.DiscriminatorColumn(classType);
var discriminator = new DiscriminatorMapping
{
ContainingEntityType = classType,
Type = new TypeReference(typeof(string))
};
discriminator.AddDefaultColumn(new ColumnMapping {
Name = discriminatorColumn
});
((ClassMapping)mapping).Discriminator = discriminator;
discriminatorSet = true;
}
ISubclassMapping subclassMapping;
var subclassStrategy = expressions.SubclassStrategy(classType);
if (subclassStrategy == SubclassStrategy.JoinedSubclass)
{
// TODO: This id name should be removed. Ideally it needs to be set by a
// default and be overridable by a convention (preferably the ForeignKey convention
// that already exists)
var subclass = new JoinedSubclassMapping
{
Type = inheritedClass.Type
};
subclass.Key = new KeyMapping();
subclass.Key.AddDefaultColumn(new ColumnMapping {
Name = mapping.Type.Name + "_id"
});
subclassMapping = subclass;
}
else
{
subclassMapping = new SubclassMapping();
}
MapSubclass(mappedProperties, subclassMapping, inheritedClass);
mapping.AddSubclass(subclassMapping);
MergeMap(inheritedClass.Type, (ClassMappingBase)subclassMapping, mappedProperties);
}
}
public void Map(ClassMappingBase classMap, Member member)
{
// don't map the component here, mark it as a reference which'll
// allow us to integrate with ComponentMap or automap at a later
// stage
var mapping = new ReferenceComponentMapping(ComponentType.Component, member, member.PropertyType, classMap.Type, cfg.GetComponentColumnPrefix(member));
classMap.AddComponent(mapping);
}
protected override void ProcessClassBase(ClassMappingBase classMapping)
{
if (!classMapping.IsNameSpecified)
{
if (classMapping.Type == null)
throw new ConventionException("Cannot apply the naming convention. No type specified.", classMapping);
classMapping.Name = DetermineNameFromType(classMapping.Type);
}
}
private void SetRelationship(Member property, ClassMappingBase classMap, ICollectionMapping mapping)
{
var relationship = new OneToManyMapping
{
Class = new TypeReference(property.PropertyType.GetGenericArguments()[0]),
ContainingEntityType = classMap.Type
};
mapping.SetDefaultValue(x => x.Relationship, relationship);
}
public void Map(ClassMappingBase classMap, Member member)
{
var inverseProperty = GetInverseProperty(member);
var parentSide = cfg.GetParentSideForManyToMany(member.DeclaringType, inverseProperty.DeclaringType);
var mapping = GetCollection(member);
ConfigureModel(member, mapping, classMap, parentSide);
classMap.AddCollection(mapping);
}
public void Map(ClassMappingBase classMap, Member property)
{
var inverseProperty = GetInverseProperty(property);
var parentSide = expressions.GetParentSideForManyToMany(property.DeclaringType, inverseProperty.DeclaringType);
var mapping = GetCollection(property);
ConfigureModel(property, mapping, classMap, parentSide);
classMap.AddCollection(mapping);
}
static void SetRelationship(Member property, ClassMappingBase classMap, CollectionMapping mapping)
{
var relationship = new OneToManyMapping
{
ContainingEntityType = classMap.Type
};
relationship.Set(x => x.Class, Layer.Defaults, new TypeReference(property.PropertyType.GetGenericArguments()[0]));
mapping.Set(x => x.Relationship, Layer.Defaults, relationship);
}
private void ApplyOverrides(Type classType, IList <string> mappedProperties, ClassMappingBase mapping)
{
var autoMapType = typeof(AutoMapping <>).MakeGenericType(classType);
var autoMap = Activator.CreateInstance(autoMapType, mappedProperties);
inlineOverrides
.Where(x => x.CanOverride(classType))
.Each(x => x.Apply(autoMap));
((IAutoClasslike)autoMap).AlterModel(mapping);
}
private void ApplyOverrides(Type classType, IList <Member> mappedMembers, ClassMappingBase mapping)
{
var autoMapType = ReflectionHelper.AutomappingTypeForEntityType(classType);
var autoMap = Activator.CreateInstance(autoMapType, mappedMembers);
inlineOverrides
.Where(x => x.CanOverride(classType))
.Each(x => x.Apply(autoMap));
((IAutoClasslike)autoMap).AlterModel(mapping);
}
public void SetKey(Member property, ClassMappingBase classMap, ICollectionMapping mapping)
{
var columnName = property.DeclaringType.Name + "_id";
var key = new KeyMapping();
key.ContainingEntityType = classMap.Type;
key.AddDefaultColumn(new ColumnMapping {
Name = columnName
});
mapping.SetDefaultValue(x => x.Key, key);
}
private void SetElement(Member property, ClassMappingBase classMap, ICollectionMapping mapping)
{
var element = new ElementMapping
{
ContainingEntityType = classMap.Type,
Type = new TypeReference(property.PropertyType.GetGenericArguments()[0])
};
element.AddDefaultColumn(new ColumnMapping {
Name = cfg.SimpleTypeCollectionValueColumn(property)
});
mapping.SetDefaultValue(x => x.Element, element);
}
public void Map(ClassMappingBase classMap, Member property)
{
var mapping = new ComponentMapping
{
Name = property.Name,
Member = property,
ContainingEntityType = classMap.Type,
Type = property.PropertyType
};
mapper.FlagAsMapped(property.PropertyType);
mapper.MergeMap(property.PropertyType, mapping, new List <string>());
classMap.AddComponent(mapping);
}
private void SetElement(Member property, ClassMappingBase classMap, CollectionMapping mapping)
{
var element = new ElementMapping
{
ContainingEntityType = classMap.Type,
};
element.Set(x => x.Type, Layer.Defaults, new TypeReference(property.PropertyType.GetGenericArguments()[0]));
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, cfg.SimpleTypeCollectionValueColumn(property));
element.AddColumn(Layer.Defaults, columnMapping);
mapping.Set(x => x.Element, Layer.Defaults, element);
}
static void SetKey(Member property, ClassMappingBase classMap, CollectionMapping mapping)
{
var columnName = property.DeclaringType.Name + "_id";
var key = new KeyMapping
{
ContainingEntityType = classMap.Type
};
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, columnName);
key.AddColumn(Layer.Defaults, columnMapping);
mapping.Set(x => x.Key, Layer.Defaults, key);
}
public ClassMappingBase MergeMap(Type classType, ClassMappingBase mapping, IList <Member> mappedMembers)
{
// map class first, then subclasses - this way subclasses can inspect the class model
// to see which properties have already been mapped
ApplyOverrides(classType, mappedMembers, mapping);
ProcessClass(mapping, classType, mappedMembers);
if (mappingTypes != null)
{
MapInheritanceTree(classType, mapping, mappedMembers);
}
return(mapping);
}
public void Map(ClassMappingBase classMap, Member member)
{
if (member.DeclaringType != classMap.Type)
{
return;
}
if (simpleTypeCollectionStepStep.ShouldMap(member))
{
simpleTypeCollectionStepStep.Map(classMap, member);
}
else if (collectionStep.ShouldMap(member))
{
collectionStep.Map(classMap, member);
}
}
private void ConfigureModel(Member property, ICollectionMapping mapping, ClassMappingBase classMap, Type parentSide)
{
// TODO: Make the child type safer
mapping.SetDefaultValue(x => x.Name, property.Name);
mapping.Relationship = CreateManyToMany(property, property.PropertyType.GetGenericArguments()[0], classMap.Type);
mapping.ContainingEntityType = classMap.Type;
mapping.ChildType = property.PropertyType.GetGenericArguments()[0];
mapping.Member = property;
SetKey(property, classMap, mapping);
if (parentSide != property.DeclaringType)
{
mapping.Inverse = true;
}
}
private void ConfigureModel(Member member, CollectionMapping mapping, ClassMappingBase classMap, Type parentSide)
{
// TODO: Make the child type safer
mapping.ContainingEntityType = classMap.Type;
mapping.Set(x => x.Name, Layer.Defaults, member.Name);
mapping.Set(x => x.Relationship, Layer.Defaults, CreateManyToMany(member, member.PropertyType.GetGenericArguments()[0], classMap.Type));
mapping.Set(x => x.ChildType, Layer.Defaults, member.PropertyType.GetGenericArguments()[0]);
mapping.Member = member;
SetDefaultAccess(member, mapping);
SetKey(member, classMap, mapping);
if (parentSide != member.DeclaringType)
{
mapping.Set(x => x.Inverse, Layer.Defaults, true);
}
}
public void Map(ClassMappingBase classMap, Member property)
{
if (property.DeclaringType != classMap.Type)
{
return;
}
var mapping = GetCollectionMapping(property.PropertyType);
mapping.ContainingEntityType = classMap.Type;
mapping.Member = property;
mapping.SetDefaultValue(x => x.Name, property.Name);
SetRelationship(property, classMap, mapping);
SetKey(property, classMap, mapping);
classMap.AddCollection(mapping);
}
private void SetKey(Member property, ClassMappingBase classMap, ICollectionMapping mapping)
{
var columnName = property.DeclaringType.Name + "_Id";
if (classMap is ComponentMapping)
{
columnName = expressions.GetComponentColumnPrefix(((ComponentMapping)classMap).Member) + columnName;
}
var key = new KeyMapping();
key.ContainingEntityType = classMap.Type;
key.AddDefaultColumn(new ColumnMapping {
Name = columnName
});
mapping.SetDefaultValue(x => x.Key, key);
}
public override void MapEverythingInClass(ClassMappingBase mapping, Type entityType, IList <string> mappedProperties)
{
// This will ONLY map private properties. Do not call base.
var rule = localExpressions.FindMappablePrivateProperties;
if (rule == null)
{
throw new InvalidOperationException("The FindMappablePrivateProperties convention must be supplied to use the PrivateAutoMapper. ");
}
foreach (var property in entityType.GetProperties(BindingFlags.Instance | BindingFlags.NonPublic).Select(x => x.ToMember()))
{
if (rule(property))
{
TryToMapProperty(mapping, property, mappedProperties);
}
}
}
protected void TryToMapProperty(ClassMappingBase mapping, Member property, IList <string> mappedProperties)
{
if (!property.HasIndexParameters)
{
foreach (var rule in mappingRules)
{
if (rule.MapsProperty(property))
{
if (mappedProperties.Count(name => name == property.Name) == 0)
{
rule.Map(mapping, property);
mappedProperties.Add(property.Name);
break;
}
}
}
}
}
protected virtual void ProcessClassBase(ClassMappingBase classMapping)
{
}
