public void ShouldWriteOneToManyForOneToManyMapping()
{
var mapping = new OneToManyMapping();
writer.VerifyXml(mapping)
.RootElement.HasName("one-to-many");
}
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 void Initialize()
{
MockChildMapping = new Mock<IChildMapping<OneToManyItem>>();
MockGridReader = new Mock<IGridReader>();
OneToManyMapping = new OneToManyMapping<ParentItem, OneToManyItem>(child => child.Id, child => child.ParentId, (parent, children) => parent.Children = children.ToList());
}
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 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);
}
/// <summary>
/// Specify the relationship is a one-to-many, this implies the key and value columns of the
/// dictionary will be stored in the child table.
/// </summary>
/// <param name="relationshipConfiguration">Builder for one-to-many</param>
/// <returns>Builder</returns>
public MapBuilder <TKey, TValue> OneToMany(Action <OneToManyBuilder> relationshipConfiguration)
{
mapping.Element = null;
mapping.CompositeElement = null;
mapping.Relationship = oneToMany = oneToMany ?? new OneToManyMapping();
mapping.Relationship.As <OneToManyMapping>(re =>
{
re.Class = new TypeReference(ValueType);
re.ChildType = ValueType;
});
relationshipConfiguration(new OneToManyBuilder(oneToMany));
return(this);
}
protected override ICollectionRelationshipMapping GetRelationship()
{
var mapping = new OneToManyMapping(relationshipAttributes.Clone())
{
ContainingEntityType = entity
};
if (isTernary && valueType != null)
{
mapping.Set(x => x.Class, Layer.Defaults, new TypeReference(valueType));
}
return(mapping);
}
protected OneToManyPart(Type entity, Member member, Type collectionType)
: base(entity, member, collectionType)
{
this.entity = entity;
childType = collectionType;
cascade = new CollectionCascadeExpression <OneToManyPart <TChild> >(this, value => collectionAttributes.Set(x => x.Cascade, value));
notFound = new NotFoundExpression <OneToManyPart <TChild> >(this, value => relationshipMapping.NotFound = value);
collectionAttributes.SetDefault(x => x.Name, member.Name);
relationshipMapping = new OneToManyMapping
{
ContainingEntityType = entity
};
}
public override void ProcessOneToMany(OneToManyMapping oneToManyMapping)
{
ProcessCollectionContents(oneToManyMapping);
}
public void CreateDsl()
{
mapping = new OneToManyMapping();
inspector = new OneToManyInspector(mapping);
}
public virtual void ProcessOneToMany(OneToManyMapping oneToManyMapping)
{
}
public virtual void Visit(OneToManyMapping mapping)
{
}
public OneToManyBuilder(OneToManyMapping mapping)
{
this.mapping = mapping;
}
public override void ProcessOneToMany(OneToManyMapping mapping)
{
var writer = serviceLocator.GetWriter <OneToManyMapping>();
document = writer.Write(mapping);
}
public OneToManyInspector(OneToManyMapping mapping)
{
this.mapping = mapping;
}
public OneToManyInstance(OneToManyMapping mapping)
: base(mapping)
{
this.mapping = mapping;
}
