/// <summary>
/// Gets the name of the foreign key.
/// </summary>
/// <param name="manyToOneMapping">The many to one mapping.</param>
/// <param name="componentMapping">The component mapping.</param>
/// <param name="entityType">Type of the entity.</param>
/// <returns>A <see cref="System.String"/></returns>
public static string GetForeignKeyName(this ManyToOneMapping manyToOneMapping, IComponentMapping componentMapping, Type entityType)
{
var manyToOnePropertyType = manyToOneMapping.Member.PropertyType;
var propertyTypeName = manyToOnePropertyType.Name;
//if ( typeof( ILookup ).IsAssignableFrom ( manyToOnePropertyType ) )
//{
// propertyTypeName += "Lkp";
//}
var namingStrategy = componentMapping.GetNamingStrategy();
var columnName = namingStrategy.GetColumnName(
componentMapping.Member.DeclaringType,
componentMapping.Member.PropertyType,
componentMapping.Name,
manyToOneMapping.Member.DeclaringType,
manyToOneMapping.Member.PropertyType,
manyToOneMapping.Name,
true);
var referenceName = string.Format("{0}_{1}", entityType.Name, propertyTypeName);
const string ForeignKeyNameSuffix = "_FK";
if (columnName != propertyTypeName.Replace("Lkp", string.Empty))
{
referenceName = string.Format("{0}_{1}_{2}", entityType.Name, propertyTypeName, columnName);
}
var foreignKeyName = string.Format("{0}{1}", referenceName, ForeignKeyNameSuffix);
return(foreignKeyName);
}
ManyToOneMapping IManyToOneMappingProvider.GetManyToOneMapping()
{
var mapping = new ManyToOneMapping(attributes.Clone())
{
ContainingEntityType = entity,
Member = member
};
mapping.Set(x => x.Name, Layer.Defaults, member.Name);
mapping.Set(x => x.Class, Layer.Defaults, new TypeReference(typeof(TOther)));
if (columns.Count == 0 && !mapping.IsSpecified("Formula"))
{
mapping.AddColumn(Layer.Defaults, CreateColumn(member.Name + "_id"));
}
foreach (var column in columns)
{
var columnMapping = CreateColumn(column);
mapping.AddColumn(Layer.UserSupplied, columnMapping);
}
return(mapping);
}
ManyToOneMapping IManyToOneMappingProvider.GetManyToOneMapping()
{
var mapping = new ManyToOneMapping(attributes.CloneInner());
mapping.ContainingEntityType = entity;
mapping.Member = property;
if (!mapping.IsSpecified("Name"))
{
mapping.Name = property.Name;
}
if (!mapping.IsSpecified("Class"))
{
mapping.SetDefaultValue(x => x.Class, new TypeReference(typeof(TOther)));
}
if (columns.Count == 0)
{
mapping.AddDefaultColumn(CreateColumn(property.Name + "_id"));
}
foreach (var column in columns)
{
var columnMapping = CreateColumn(column);
mapping.AddColumn(columnMapping);
}
return(mapping);
}
protected ManyToOneMapping reference_with_column(string column)
{
var reference = new ManyToOneMapping();
reference.AddColumn(Layer.Defaults, new ColumnMapping("propertyColumn"));
return(reference);
}
public override void Visit(ManyToOneMapping manyToOneMapping)
{
var writer = serviceLocator.GetWriter <ManyToOneMapping>();
var manyToOneXml = writer.Write(manyToOneMapping);
document.ImportAndAppendChild(manyToOneXml);
}
/// <summary>
/// Sets the Foreign Key.
/// </summary>
/// <param name="manyToOneMapping">The many to one mapping.</param>
/// <param name="foreignKeyName">Name of the foreign key.</param>
public static void ForeignKey(this ManyToOneMapping manyToOneMapping, string foreignKeyName)
{
if (!manyToOneMapping.IsSpecified("ForeignKey"))
{
manyToOneMapping.ForeignKey = foreignKeyName;
}
}
public static void ForeignKey(this ManyToOneMapping manyToOneMapping, string foreignKeyName)
{
if (!manyToOneMapping.IsSpecified("ForeignKey"))
{
manyToOneMapping.Set <string>(c => c.ForeignKey, 1, foreignKeyName);
}
}
public override void ProcessManyToOne(ManyToOneMapping mapping)
{
var conventions = finder.Find <IReferenceConvention>();
Apply <IManyToOneInspector, IManyToOneInstance>(conventions,
new ManyToOneInstance(mapping));
}
public override void establish_context()
{
manyToOneARankedFirstToHolder = new ManyToOneMapping();
manyToOneARankedFirstToHolder.Set(x => x.Class, Layer.Defaults, new TypeReference(typeof(Holder)));
manyToOneARankedFirstToHolder.Set(x => x.Name, Layer.Defaults, "ARankedFirstProperty");
manyToOneARankedFirstToHolder.ContainingEntityType = typeof(ARankedFirst);
manyToOneARankedFirstToHolder.Member = new PropertyMember(typeof(ARankedFirst).GetProperty("ARankedFirstProperty"));
manyToOneBRankedSecondToHolder = new ManyToOneMapping();
manyToOneBRankedSecondToHolder.Set(x => x.Class, Layer.Defaults, new TypeReference(typeof(Holder)));
manyToOneBRankedSecondToHolder.Set(x => x.Name, Layer.Defaults, "BRankedSecondProperty");
manyToOneBRankedSecondToHolder.ContainingEntityType = typeof(BRankedSecond);
manyToOneBRankedSecondToHolder.Member = new PropertyMember(typeof(BRankedSecond).GetProperty("BRankedSecondProperty"));
var relationship = new OneToManyMapping();
relationship.Set(x => x.Class, Layer.Defaults, new TypeReference(typeof(BRankedSecond)));
relationship.ContainingEntityType = typeof(Holder);
collectionMappingToBRankedSecond = CollectionMapping.Bag();
collectionMappingToBRankedSecond.Set(x => x.ChildType, Layer.Defaults, typeof(BRankedSecond));
collectionMappingToBRankedSecond.Set(x => x.Name, Layer.Defaults, "ColectionOfBRankedSeconds");
collectionMappingToBRankedSecond.Set(x => x.Relationship, Layer.Defaults, relationship);
collectionMappingToBRankedSecond.ContainingEntityType = typeof(Holder);
visitor = new RelationshipPairingVisitor(A.Fake <PairBiDirectionalManyToManySidesDelegate>());
}
public override void Visit(ManyToOneMapping mapping)
{
var writer = serviceLocator.GetWriter<ManyToOneMapping>();
var xml = writer.Write(mapping);
document.ImportAndAppendChild(xml);
}
public void ShouldWriteProxyLazyAttribute()
{
var mapping = new ManyToOneMapping();
mapping.Set(x => x.Lazy, Layer.Defaults, Laziness.Proxy.ToString());
writer.VerifyXml(mapping)
.HasAttribute("lazy", "proxy");
}
public void CanAddReference()
{
var reference = new ManyToOneMapping();
reference.Set(x => x.Name, Layer.Defaults, "parent");
mapping.AddReference(reference);
mapping.References.ShouldContain(reference);
}
public void ShouldWriteColumns()
{
var mapping = new ManyToOneMapping();
mapping.AddColumn(new ColumnMapping());
writer.VerifyXml(mapping)
.Element("column").Exists();
}
public void ShouldWriteProxyLazyAttribute()
{
var mapping = new ManyToOneMapping();
mapping.Lazy = true;
writer.VerifyXml(mapping)
.HasAttribute("lazy", "proxy");
}
protected ManyToOneMapping reference_with_column(string column)
{
var reference = new ManyToOneMapping();
reference.AddDefaultColumn(new ColumnMapping {
Name = "propertyColumn"
});
return(reference);
}
public void CanAddReference()
{
var reference = new ManyToOneMapping {
Name = "parent"
};
_classMapping.AddReference(reference);
_classMapping.References.ShouldContain(reference);
}
public ColumnMapping Apply(ManyToOneMapping manyToOneMap, Lazy <Dictionary <Type, ClassMapping> > lazyTypeMap)
{
var codeListAttr = manyToOneMap.Member.PropertyType.GetCustomAttribute <CodeListConfigurationAttribute>(false);
var length = codeListAttr?.CodeLength ?? 20;
var keyName = GetKeyName(manyToOneMap.Member, manyToOneMap.Class.GetUnderlyingSystemType());
var col = manyToOneMap.Columns.First();
col.Set(o => o.Name, Layer.UserSupplied, keyName);
col.Set(o => o.Length, Layer.UserSupplied, length);
return(col);
}
/// <summary>
/// Sets the Index.
/// </summary>
/// <param name="manyToOneMapping">The many to one mapping.</param>
/// <param name="indexName">Name of the index.</param>
public static void Index(this ManyToOneMapping manyToOneMapping, string indexName)
{
if (manyToOneMapping.Columns.First().IsSpecified("Index"))
{
return;
}
foreach (var column in manyToOneMapping.Columns)
{
column.Index = indexName;
}
}
/// <summary>
/// Sets the Foreign Key.
/// </summary>
/// <param name="manyToOneMapping">The many to one mapping.</param>
/// <param name="foreignKeyName">Name of the foreign key.</param>
public static void ForeignKey(this ManyToOneMapping manyToOneMapping, string foreignKeyName)
{
if (!manyToOneMapping.IsSpecified("ForeignKey"))
{
manyToOneMapping.Set(x => x.ForeignKey, Layer.Defaults, foreignKeyName);
//var columnPart = new ManyToOnePart(column);
//columnPart. (indexName);
// manyToOneMapping.ForeignKey = foreignKeyName;
}
}
public override void ProcessManyToOne(ManyToOneMapping thisSide)
{
if (thisSide.OtherSide == null)
{
return;
}
// other side is always going to be a collection for a many-to-one mapping
var otherSide = (CollectionMapping)thisSide.OtherSide;
otherSide.Key.MakeColumnsEmpty(Layer.Defaults);
thisSide.Columns.Each(x => otherSide.Key.AddColumn(Layer.Defaults, x.Clone()));
}
private ManyToOneMapping CreateMapping(Member property)
{
var mapping = new ManyToOneMapping {
Member = property
};
mapping.SetDefaultValue(x => x.Name, property.Name);
mapping.SetDefaultValue(x => x.Class, new TypeReference(property.PropertyType));
mapping.AddDefaultColumn(new ColumnMapping {
Name = property.Name + "_id"
});
return(mapping);
}
protected virtual ManyToOneBuilder <TOther> References <TOther>(Member property, string columnName)
{
var manyToOneMapping = new ManyToOneMapping();
var part = new ManyToOneBuilder <TOther>(manyToOneMapping, typeof(T), property);
if (columnName != null)
{
part.Column(columnName);
}
mapping.AddReference(manyToOneMapping);
return(part);
}
protected virtual ManyToOneBuilder <TOther> References <TOther>(Member property, string columnName)
{
var manyToOneMapping = new ManyToOneMapping();
var part = new ManyToOneBuilder <TOther>(manyToOneMapping, EntityType, property);
if (columnName != null)
{
part.Column(columnName);
}
references.Add(new PassThroughMappingProvider(manyToOneMapping));
return(part);
}
/// <summary>
/// Sets the column.
/// </summary>
/// <param name="manyToOneMapping">The many to one mapping.</param>
/// <param name="columnName">Name of the column.</param>
public static void Column(this ManyToOneMapping manyToOneMapping, string columnName)
{
if (manyToOneMapping.Columns.UserDefined.Count() > 0)
{
return;
}
var originalColumn = manyToOneMapping.Columns.FirstOrDefault();
var column = originalColumn == null ? new ColumnMapping() : originalColumn.Clone();
column.Name = columnName;
manyToOneMapping.ClearColumns();
manyToOneMapping.AddColumn(column);
}
void SetDefaultAccess(Member member, ManyToOneMapping mapping)
{
var resolvedAccess = MemberAccessResolver.Resolve(member);
if (resolvedAccess != Access.Property && resolvedAccess != Access.Unset)
{
// if it's a property or unset then we'll just let NH deal with it, otherwise
// set the access to be whatever we determined it might be
mapping.Set(x => x.Access, Layer.Defaults, resolvedAccess.ToString());
}
if (member.IsProperty && !member.CanWrite)
{
mapping.Set(x => x.Access, Layer.Defaults, cfg.GetAccessStrategyForReadOnlyProperty(member).ToString());
}
}
private ManyToOneMapping CreateMapping(Member member)
{
var mapping = new ManyToOneMapping {
Member = member
};
mapping.Set(x => x.Name, Layer.Defaults, member.Name);
mapping.Set(x => x.Class, Layer.Defaults, new TypeReference(member.PropertyType));
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, member.Name + "_id");
mapping.AddColumn(Layer.Defaults, columnMapping);
SetDefaultAccess(member, mapping);
return(mapping);
}
public override void ProcessManyToOne(ManyToOneMapping thisSide)
{
if (thisSide.OtherSide == null)
{
return;
}
// other side is always going to be a collection for a many-to-one mapping
var otherSide = (CollectionMapping)thisSide.OtherSide;
if (thisSide.ContainingEntityType == otherSide.ContainingEntityType)
{
// special case for self-referential relationships
otherSide.Key.MakeColumnsEmpty(Layer.Defaults);
thisSide.Columns.Each(x => otherSide.Key.AddColumn(Layer.Defaults, x.Clone()));
}
}
protected virtual NaturalIdPart <T> Reference(Member member, string columnName)
{
var key = new ManyToOneMapping
{
Name = member.Name,
Class = new TypeReference(member.PropertyType),
ContainingEntityType = typeof(T)
};
key.AddColumn(new ColumnMapping {
Name = columnName
});
manyToOnes.Add(key);
return(this);
}
protected virtual NaturalIdPart <T> Reference(Member member, string columnName)
{
var key = new ManyToOneMapping
{
ContainingEntityType = typeof(T)
};
key.Set(x => x.Name, Layer.Defaults, member.Name);
key.Set(x => x.Class, Layer.Defaults, new TypeReference(member.PropertyType));
var columnMapping = new ColumnMapping();
columnMapping.Set(x => x.Name, Layer.Defaults, columnName);
key.AddColumn(Layer.Defaults, columnMapping);
manyToOnes.Add(key);
return(this);
}
/// <summary>
/// Sets the column.
/// </summary>
/// <param name="manyToOneMapping">The many to one mapping.</param>
/// <param name="columnName">Name of the column.</param>
public static void Column(this ManyToOneMapping manyToOneMapping, string columnName)
{
if (manyToOneMapping.Columns.Any())
{
return;
}
var originalColumn = manyToOneMapping.Columns.FirstOrDefault();
var column = originalColumn == null ? new ColumnMapping() : originalColumn.Clone();
var columnPart = new ColumnPart(column);
columnPart.Name(columnName);
manyToOneMapping.MakeColumnsEmpty(Layer.Defaults);
manyToOneMapping.AddColumn(Layer.Defaults, column);
// manyToOneMapping.AddColumn ( column );
}
private ManyToOneMapping CreateMapping(Member member)
{
var mapping = new ManyToOneMapping {
Member = member
};
mapping.SetDefaultValue(x => x.Name, member.Name);
mapping.SetDefaultValue(x => x.Class, new TypeReference(member.PropertyType));
mapping.AddDefaultColumn(new ColumnMapping {
Name = member.Name + "_id"
});
if (member.IsProperty && !member.CanWrite)
{
mapping.Access = cfg.GetAccessStrategyForReadOnlyProperty(member).ToString();
}
return(mapping);
}
public override void ProcessManyToOne(ManyToOneMapping manyToOneMapping)
{
Process(manyToOneMapping, manyToOneMapping.PropertyInfo);
}
public void AddReference(ManyToOneMapping manyToOne)
{
mergedComponent.AddReference(manyToOne);
}
public void AddReference(ManyToOneMapping manyToOne)
{
mappedMembers.AddReference(manyToOne);
}
public object Write(ManyToOneMapping mappingModel)
{
return _manyToOneWriter.Write(mappingModel);
}