public void Can_add_subclass()
{
var joinedSubclass = new JoinedSubclassMapping();
_classMapping.AddSubclass(joinedSubclass);
_classMapping.Subclasses.ShouldContain(joinedSubclass);
}
public override void ProcessJoinedSubclass(JoinedSubclassMapping subclassMapping)
{
var conventions = finder.Find <IJoinedSubclassConvention>();
Apply <IJoinedSubclassInspector, IJoinedSubclassInstance>(conventions,
new JoinedSubclassInstance(subclassMapping));
}
public void ShouldWriteSetForSetMapping()
{
var mapping = new JoinedSubclassMapping();
writer.VerifyXml(mapping)
.RootElement.HasName("joined-subclass");
}
public void ShouldWriteBag()
{
var mapping = new JoinedSubclassMapping();
mapping.AddCollection(new BagMapping());
writer.VerifyXml(mapping)
.Element("bag").Exists();
}
public void ShouldWriteManyToOnes()
{
var mapping = new JoinedSubclassMapping();
mapping.AddReference(new ManyToOneMapping());
writer.VerifyXml(mapping)
.Element("many-to-one").Exists();
}
public void ShouldWriteDynamicComponents()
{
var mapping = new JoinedSubclassMapping();
mapping.AddComponent(new DynamicComponentMapping());
writer.VerifyXml(mapping)
.Element("dynamic-component").Exists();
}
public void ShouldWriteProperties()
{
var mapping = new JoinedSubclassMapping();
mapping.AddProperty(new PropertyMapping());
writer.VerifyXml(mapping)
.Element("property").Exists();
}
public void ShouldWriteSubclass()
{
var mapping = new JoinedSubclassMapping();
mapping.AddSubclass(new JoinedSubclassMapping());
writer.VerifyXml(mapping)
.Element("joined-subclass").Exists();
}
public void ShouldWriteAny()
{
var mapping = new JoinedSubclassMapping();
mapping.AddAny(new AnyMapping());
writer.VerifyXml(mapping)
.Element("any").Exists();
}
public void ShouldWriteAny()
{
var mapping = new JoinedSubclassMapping();
mapping.AddAny(new AnyMapping());
writer.VerifyXml(mapping)
.Element("any").Exists();
}
public void ShouldWriteBag()
{
var mapping = new JoinedSubclassMapping();
mapping.AddCollection(new BagMapping());
writer.VerifyXml(mapping)
.Element("bag").Exists();
}
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 override void ProcessJoinedSubclass(JoinedSubclassMapping mapping)
{
var subclasses = FindClosestSubclasses(mapping.Type);
foreach (var provider in subclasses)
mapping.AddSubclass(provider.GetSubclassMapping(new JoinedSubclassMapping()));
base.ProcessJoinedSubclass(mapping);
}
public void ShouldWriteOneToOnes()
{
var mapping = new JoinedSubclassMapping();
mapping.AddOneToOne(new OneToOneMapping());
writer.VerifyXml(mapping)
.Element("one-to-one").Exists();
}
public override void ProcessJoinedSubclass(JoinedSubclassMapping mapping)
{
var subclasses = subclassProviders
.Select(x => x.GetSubclassMapping(new JoinedSubclassMapping()))
.Where(x => x.Type.BaseType == mapping.Type);
foreach (var subclass in subclasses)
mapping.AddSubclass(subclass);
base.ProcessJoinedSubclass(mapping);
}
public override void ProcessJoinedSubclass(JoinedSubclassMapping mapping)
{
var subclasses = FindClosestSubclasses(mapping.Type);
foreach (var provider in subclasses)
{
mapping.AddSubclass(provider.GetSubclassMapping(new JoinedSubclassMapping()));
}
base.ProcessJoinedSubclass(mapping);
}
ISubclassMapping ISubclassMappingProvider.GetSubclassMapping()
{
var mapping = new JoinedSubclassMapping(attributes.CloneInner());
mapping.Key = new KeyMapping {
ContainingEntityType = typeof(TSubclass)
};
mapping.Name = typeof(TSubclass).AssemblyQualifiedName;
mapping.Type = typeof(TSubclass);
foreach (var column in columns)
{
mapping.Key.AddColumn(column);
}
foreach (var property in properties)
{
mapping.AddProperty(property.GetPropertyMapping());
}
foreach (var component in components)
{
mapping.AddComponent(component.GetComponentMapping());
}
foreach (var oneToOne in oneToOnes)
{
mapping.AddOneToOne(oneToOne.GetOneToOneMapping());
}
foreach (var collection in collections)
{
mapping.AddCollection(collection.GetCollectionMapping());
}
foreach (var reference in references)
{
mapping.AddReference(reference.GetManyToOneMapping());
}
foreach (var any in anys)
{
mapping.AddAny(any.GetAnyMapping());
}
return(mapping);
}
public virtual void Visit(JoinedSubclassMapping subclassMapping)
{
}
public override void ProcessJoinedSubclass(JoinedSubclassMapping subclassMapping)
{
ProcessClassBase(subclassMapping);
}
public void Should_apply_to_joined_subclass_mapping()
{
var joinedSubclassMapping = new JoinedSubclassMapping();
joinedSubclassMapping.Type = typeof(Album);
_namingConvention.ProcessJoinedSubclass(joinedSubclassMapping);
joinedSubclassMapping.Name.ShouldEqual(joinedSubclassMapping.Type.AssemblyQualifiedName);
}
public override void ProcessJoinedSubclass(JoinedSubclassMapping subclassMapping)
{
var writer = serviceLocator.GetWriter <JoinedSubclassMapping>();
document = writer.Write(subclassMapping);
}
public override void Visit(JoinedSubclassMapping subclassMapping)
{
subclassMapping.AcceptVisitor(this);
}
public void ShouldWriteOneToOnes()
{
var mapping = new JoinedSubclassMapping();
mapping.AddOneToOne(new OneToOneMapping());
writer.VerifyXml(mapping)
.Element("one-to-one").Exists();
}
public virtual void Visit(JoinedSubclassMapping subclassMapping)
{
}
public void CreateDsl()
{
mapping = new JoinedSubclassMapping();
inspector = new JoinedSubclassInspector(mapping);
}
public void ShouldWriteSubclass()
{
var mapping = new JoinedSubclassMapping();
mapping.AddSubclass(new JoinedSubclassMapping());
writer.VerifyXml(mapping)
.Element("joined-subclass").Exists();
}
public override void Visit(JoinedSubclassMapping subclassMapping)
{
subclassMapping.AcceptVisitor(this);
}
public override void ProcessJoinedSubclass(JoinedSubclassMapping subclassMapping)
{
ProcessClassBase(subclassMapping);
}
public void ShouldWriteManyToOnes()
{
var mapping = new JoinedSubclassMapping();
mapping.AddReference(new ManyToOneMapping());
writer.VerifyXml(mapping)
.Element("many-to-one").Exists();
}
public void ShouldWriteDynamicComponents()
{
var mapping = new JoinedSubclassMapping();
mapping.AddComponent(new DynamicComponentMapping());
writer.VerifyXml(mapping)
.Element("dynamic-component").Exists();
}
public JoinedSubclassInspector(JoinedSubclassMapping mapping)
{
this.mapping = mapping;
mappedProperties.Map(x => x.LazyLoad, x => x.Lazy);
}
public virtual void ProcessJoinedSubclass(JoinedSubclassMapping subclassMapping)
{
}
public JoinedSubclassInspector(JoinedSubclassMapping mapping)
{
this.mapping = mapping;
mappedProperties.AutoMap();
mappedProperties.Map(x => x.LazyLoad, x => x.Lazy);
}
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 ShouldWriteProperties()
{
var mapping = new JoinedSubclassMapping();
mapping.AddProperty(new PropertyMapping());
writer.VerifyXml(mapping)
.Element("property").Exists();
}
public virtual void ProcessJoinedSubclass(JoinedSubclassMapping subclassMapping)
{
}
public void Can_add_subclass()
{
var joinedSubclass = new JoinedSubclassMapping();
_classMapping.AddSubclass(joinedSubclass);
_classMapping.Subclasses.ShouldContain(joinedSubclass);
}
public void CreateDsl()
{
mapping = new JoinedSubclassMapping();
inspector = new JoinedSubclassInspector(mapping);
}
public JoinedSubclassInstance(JoinedSubclassMapping mapping)
: base(mapping)
{
this.mapping = mapping;
}
