/// <summary>
/// Removes a relationship definition from the collection
/// </summary>
/// <param name="relationshipDef">The Relationship definition to remove</param>
protected void Remove(IRelationshipDef relationshipDef)
{
if (Contains(relationshipDef))
{
_relDefs.Remove(relationshipDef.RelationshipName);
}
}
/// <summary>
/// Add an existing relationship to the collection
/// </summary>
/// <param name="relationshipDef">The existing relationship to add</param>
public void Add(IRelationshipDef relationshipDef)
{
if (Contains(relationshipDef))
{
throw new ArgumentException(String.Format(
"A relationship definition with the name '{0}' already " +
"exists.", relationshipDef.RelationshipName));
}
_relDefs.Add(relationshipDef.RelationshipName, relationshipDef);
}
Test_Valid_Relationship_SingleSingleRelationships_CanDetermine_OwningBOHasForeignKey_ReverseDoesNotHave()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"" reverseRelationship=""TestClass"" owningBOHasForeignKey=""true"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""single"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders"" reverseRelationship=""TestRelatedClass"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
IClassDef classDef = classDefList.FindByClassName("TestClass");
IRelationshipDef relationshipDef = classDef.RelationshipDefCol["TestRelatedClass"];
IClassDef reverseClassDef = classDefList.FindByClassName("TestRelatedClass");
IRelationshipDef reverseRelationshipDef = reverseClassDef.RelationshipDefCol["TestClass"];
//--------------------Assert PreConditions---------------
Assert.IsTrue(relationshipDef.OwningBOHasForeignKey);
Assert.IsTrue(reverseRelationshipDef.OwningBOHasForeignKey);
//--------------------Execute Test-------------------------
validator.ValidateClassDefs(classDefList);
//---------------Test Result -----------------------
Assert.IsFalse(relationshipDef.OwningBOHasForeignKey);
Assert.IsTrue(reverseRelationshipDef.OwningBOHasForeignKey);
}
public void Test_Valid_Relationship_SingleSingleRelationships_OnlyOneHasOwningBOHasForeignKey()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"" owningBOHasForeignKey=""true"" reverseRelationship=""TestClass"">
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""single"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders"" reverseRelationship=""TestRelatedClass"" owningBOHasForeignKey=""false"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
//--------------------Assert PreConditions---------------
IClassDef classDef = classDefList.FindByClassName("TestClass");
IRelationshipDef relationshipDef = classDef.RelationshipDefCol["TestRelatedClass"];
Assert.IsTrue(relationshipDef.OwningBOHasForeignKey, "This defaults to true");
IClassDef revesreclassDef = classDefList.FindByClassName("TestClass");
IRelationshipDef reverserelationshipDef = revesreclassDef.RelationshipDefCol["TestRelatedClass"];
Assert.IsTrue(reverserelationshipDef.OwningBOHasForeignKey, "This defaults to true");
//--------------------Execute Test-------------------------
validator.ValidateClassDefs(classDefList);
//---------------Test Result -----------------------
Assert.IsFalse(relationshipDef.OwningBOHasForeignKey, "Should have converted this to false");
Assert.IsFalse(reverserelationshipDef.OwningBOHasForeignKey, "Should have converted this to false");
}
public virtual void Test_WithTypeParameter()
{
//---------------Set up test pack-------------------
XmlClassLoader loader = new XmlClassLoader(new DtdLoader(), GetDefClassFactory());
IClassDef personClassDef =
loader.LoadClass(
@"
<class name=""ContactPersonTestBO"" assembly=""Habanero.Test.BO"" table=""contact_person"" typeParameter=""Human"">
<property name=""ContactPersonID"" type=""Guid"" />
<property name=""Surname"" databaseField=""Surname_field"" compulsory=""true"" />
<property name=""FirstName"" databaseField=""FirstName_field"" />
<property name=""DateOfBirth"" type=""DateTime"" />
<primaryKey>
<prop name=""ContactPersonID"" />
</primaryKey>
</class>
" );
ClassDef.ClassDefs.Add(personClassDef);
const string relXml = @"
<relationship
name=""TestRelationship""
type=""single""
relatedClass=""ContactPersonTestBO""
relatedAssembly=""Habanero.Test.BO""
typeParameter=""Human""
>
<relatedProperty property=""TestProp"" relatedProperty=""TestRelatedProp"" />
</relationship>" ;
//---------------Assert PreConditions---------------
// Assert.IsTrue(ClassDef.ClassDefs.Contains("Habanero.Test.BO", "ContactPersonTestBO_Human"));
//---------------Execute Test ----------------------
IRelationshipDef relDef = _loader.LoadRelationship(relXml, _propDefs);
//---------------Test Result -----------------------
Assert.AreEqual(personClassDef.ClassNameExcludingTypeParameter, relDef.RelatedObjectClassName);
Assert.AreEqual(personClassDef.TypeParameter, relDef.RelatedObjectTypeParameter);
Assert.AreEqual(personClassDef.AssemblyName, relDef.RelatedObjectAssemblyName);
//---------------Tear Down -------------------------
}
public void Test_Valid_Relationship_1_M_Relationships_CanDetermine_OwningBOHasForeignKey_SecondClass_SetAsFalse()
{
//----------------------Test Setup ----------------------
const string classDefsString = @"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""multiple"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
reverseRelationship=""TestClass"" owningBOHasForeignKey=""true"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""single"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
reverseRelationship=""TestRelatedClass"" owningBOHasForeignKey=""false"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
//--------------------Execute Test-------------------------
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
//---------------Test Result -----------------------
Assert.AreEqual(2, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"), "Class 'TestRelatedClass' should have been loaded.");
IClassDef classDef = classDefList.FindByClassName("TestClass");
IRelationshipDef relationshipDef = classDef.RelationshipDefCol["TestRelatedClass"];
IClassDef reverseClassDef = classDefList.FindByClassName("TestRelatedClass");
IRelationshipDef reverseRelationshipDef = reverseClassDef.RelationshipDefCol["TestClass"];
Assert.IsFalse(relationshipDef.OwningBOHasForeignKey);
Assert.IsTrue(reverseRelationshipDef.OwningBOHasForeignKey);
}
/// <summary>
/// Constructor to initialise a new relationship
/// </summary>
/// <param name="owningBo">The business object from where the
/// relationship originates</param>
/// <param name="lRelDef">The relationship definition</param>
/// <param name="lBOPropCol">The set of properties used to
/// initialise the RelKey object</param>
protected Relationship(IBusinessObject owningBo, IRelationshipDef lRelDef, IBOPropCol lBOPropCol)
{
if (owningBo == null)
{
throw new ArgumentNullException("owningBo");
}
if (lRelDef == null)
{
throw new ArgumentNullException("lRelDef");
}
if (lBOPropCol == null)
{
throw new ArgumentNullException("lBOPropCol");
}
_relDef = lRelDef;
_owningBo = owningBo;
_relKey = new Lazy <IRelKey>(() => _relDef.RelKeyDef.CreateRelKey(lBOPropCol));
}
public void Test_GetValidRelationshipValue_ShouldCreateRelatedBO()
{
//---------------Set up test pack-------------------
var boTestFactory = new BOTestFactory(typeof(FakeBO));
var businessObject = (FakeBO)boTestFactory.CreateValidBusinessObject();
var relationship = businessObject.Relationships["NonCompulsoryRelationship"] as ISingleRelationship;
//---------------Assert Precondition----------------
Assert.IsNotNull(relationship);
Assert.IsNull(relationship.GetRelatedObject());
//---------------Execute Test ----------------------
IRelationshipDef relationshipDef = relationship.RelationshipDef;
IBusinessObject validRelationshipValue = boTestFactory.GetValidRelationshipValue(relationshipDef as ISingleValueDef);
//---------------Test Result -----------------------
Assert.IsNotNull(validRelationshipValue);
Assert.IsTrue(validRelationshipValue.Status.IsNew);
}
public void Test_IsOneToOne_WhenNoRevRelTypeLoaded_SetOneToOneSetToFalse_ShouldReturnFalseBug944()
{
//---------------Set up test pack-------------------
var singleRelationshipDef = new FakeSingleRelationshipDef
{
ReverseRelationshipName = GetRandomString()
};
IRelationshipDef relationshipDef = singleRelationshipDef;
//---------------Assert Precondition----------------
Assert.IsInstanceOf(typeof(SingleRelationshipDef), relationshipDef);
Assert.IsNotNullOrEmpty(relationshipDef.ReverseRelationshipName);
//---------------Execute Test ----------------------
bool isOneToOne = relationshipDef.IsOneToOne;
//---------------Test Result -----------------------
Assert.IsFalse(isOneToOne);
}
public void Test_Multiple_InsertAction_Default_ShouldBeInsertRelationship()
{
//---------------Set up test pack-------------------
const string singleRelationshipStringComposition = @"
<relationship
name=""TestRelationship""
type=""multiple""
relatedClass=""Habanero.Test.BO.Loaders.TestRelatedClass""
relatedAssembly=""Habanero.Test.BO""
>
<relatedProperty property=""TestProp"" relatedProperty=""TestRelatedProp"" />
</relationship>" ;
//---------------Execute Test ----------------------
IRelationshipDef relDef = _loader.LoadRelationship(singleRelationshipStringComposition, _propDefs);
//---------------Test Result -----------------------
Assert.AreEqual(RelationshipType.Association, relDef.RelationshipType);
Assert.AreEqual(InsertParentAction.InsertRelationship, relDef.InsertParentAction);
}
private static IRelationshipDef CreateReverseRelDef(IRelationshipDef rel, IClassDef classDef)
{
IRelationshipDef newReverseRelDef;
if (rel.IsManyToOne)
{
newReverseRelDef = new MultipleRelationshipDef(rel.ReverseRelationshipName
, classDef.ClassType, new RelKeyDef(), true, ""
, DeleteParentAction.Prevent);
}
else
{
newReverseRelDef = new SingleRelationshipDef(rel.ReverseRelationshipName
, classDef.ClassType, new RelKeyDef(), true
, DeleteParentAction.DoNothing);
}
newReverseRelDef.ReverseRelationshipName = rel.RelationshipName;
return(newReverseRelDef);
}
private void SetReverseRelationshipName(IRelationshipDef relDef)
{
IEnumerable <AutoMapManyToOneAttribute> attributes = this.PropertyWrapper.GetAttributes <AutoMapManyToOneAttribute>();
AutoMapManyToOneAttribute mToOneAttribute = attributes.FirstOrDefault();
if (mToOneAttribute != null && !string.IsNullOrEmpty(mToOneAttribute.ReverseRelationshipName))
{
relDef.ReverseRelationshipName = mToOneAttribute.ReverseRelationshipName;
return;
}
var reverseRelPropInfo = this.PropertyWrapper.GetMultipleReverseRelPropInfo();
if (reverseRelPropInfo != null)
{
relDef.ReverseRelationshipName = reverseRelPropInfo.Name;
return;
}
relDef.ReverseRelationshipName = StringUtilities.Pluralize(this.PropertyWrapper.DeclaringClassName);
}
public void TestRelationshipType_Multiple_Composition()
{
//---------------Set up test pack-------------------
const string singleRelationshipStringComposition = @"
<relationship
name=""TestRelationship""
type=""multiple""
relationshipType=""Composition""
relatedClass=""Habanero.Test.BO.Loaders.TestRelatedClass""
relatedAssembly=""Habanero.Test.BO""
>
<relatedProperty property=""TestProp"" relatedProperty=""TestRelatedProp"" />
</relationship>" ;
//---------------Execute Test ----------------------
IRelationshipDef relDef = _loader.LoadRelationship(singleRelationshipStringComposition, _propDefs);
//---------------Test Result -----------------------
Assert.AreEqual(RelationshipType.Composition, relDef.RelationshipType);
//---------------Tear Down -------------------------
}
public void Test_ReverseRelationship()
{
//---------------Set up test pack-------------------
const string singleRelationshipStringComposition = @"
<relationship
name=""TestRelationship""
type=""single""
relatedClass=""Habanero.Test.BO.Loaders.TestRelatedClass""
relatedAssembly=""Habanero.Test.BO""
owningBOHasForeignKey=""false""
reverseRelationship=""MyReverseRelationship""
>
<relatedProperty property=""TestProp"" relatedProperty=""TestRelatedProp"" />
</relationship>" ;
//---------------Execute Test ----------------------
IRelationshipDef relDef = _loader.LoadRelationship(singleRelationshipStringComposition, _propDefs);
//---------------Test Result -----------------------
Assert.AreEqual("MyReverseRelationship", relDef.ReverseRelationshipName);
}
private static Result ReverseRelationshipHasSameProps(IRelationshipDef relationshipDef, IRelationshipDef reverseRelationshipDef)
{
if (relationshipDef.RelKeyDef.Count != reverseRelationshipDef.RelKeyDef.Count)
{
return(new Result(false, "relationship KeyCount : " + relationshipDef.RelKeyDef.Count + " reverseRelationshpDef KeyCount : " + reverseRelationshipDef.RelKeyDef.Count));
}
foreach (var relPropDef in relationshipDef.RelKeyDef)
{
var localRelDef = relPropDef;
var foundMatch = reverseRelationshipDef.RelKeyDef.Any(reverseRelPropDef => reverseRelPropDef.DoKeyPropsMatch(localRelDef));
if (!foundMatch)
{
return(new Result(false, "- No matching RelProp found for " + relPropDef.OwnerPropertyName + " -> " + relPropDef.RelatedClassPropName
+ Environment.NewLine + "Relationship " + relationshipDef.RelationshipName + relationshipDef.GetRelPropDefString() +
Environment.NewLine + "ReverseRelationship " + reverseRelationshipDef.RelationshipName + reverseRelationshipDef.GetRelPropDefString()));
}
}
return(new Result(true, ""));
}
private void ValidateRelKeyDef
(IClassDef classDef, ClassDefCol classDefs, IRelationshipDef relationshipDef, IClassDef relatedObjectClassDef,
IDictionary <IClassDef, IPropDefCol> loadedFullPropertyLists)
{
var allPropsForClassDef = GetAllClassDefProps(loadedFullPropertyLists, classDef, classDefs);
var allPropsForRelatedClassDef = GetAllClassDefProps
(loadedFullPropertyLists, relatedObjectClassDef, classDefs);
// Check Relationship Properties
foreach (IRelPropDef relPropDef in relationshipDef.RelKeyDef)
{
string ownerPropertyName = relPropDef.OwnerPropertyName;
if (!allPropsForClassDef.Contains(ownerPropertyName))
{
throw new InvalidXmlDefinitionException
(String.Format
("In a 'relatedProperty' element for the '{0}' relationship of "
+ "the '{1}' class, the property '{2}' given in the "
+ "'property' attribute does not exist for the class or for any of it's superclasses. "
+ "Either add the property definition or check the spelling and "
+
"capitalisation of the specified property. Check in the ClassDefs.xml file or fix in Firestarter",
relationshipDef.RelationshipName, classDef.ClassName, ownerPropertyName));
}
string relatedClassPropName = relPropDef.RelatedClassPropName;
if (!allPropsForRelatedClassDef.Contains(relatedClassPropName))
{
throw new InvalidXmlDefinitionException
(String.Format
("In a 'relatedProperty' element for the '{0}' relationship of "
+ "the '{1}' class, the property '{2}' given in the "
+
"'relatedProperty' attribute does not exist for the Related class '{3}' or for any of it's superclasses. "
+ "Either add the property definition or check the spelling and "
+
"capitalisation of the specified property. Check in the ClassDefs.xml file or fix in Firestarter",
relationshipDef.RelationshipName, classDef.ClassName, relatedClassPropName,
relatedObjectClassDef.ClassNameFull));
}
}
}
public void Test_Multiple_InsertAction_DoNothing()
{
//---------------Set up test pack-------------------
const string singleRelationshipStringAssociation = @"
<relationship
name=""TestRelationship""
type=""multiple""
relatedClass=""Habanero.Test.BO.Loaders.TestRelatedClass""
relatedAssembly=""Habanero.Test.BO""
owningBOHasForeignKey=""false""
insertAction=""DoNothing""
>
<relatedProperty property=""TestProp"" relatedProperty=""TestRelatedProp"" />
</relationship>" ;
//---------------Execute Test ----------------------
IRelationshipDef relDef = _loader.LoadRelationship(singleRelationshipStringAssociation, _propDefs);
//---------------Test Result -----------------------
Assert.AreEqual(RelationshipType.Association, relDef.RelationshipType);
Assert.AreEqual(InsertParentAction.DoNothing, relDef.InsertParentAction);
}
public void Test_Valid_Relationship_1_1_NoReverse_RelatatedProp_IsPartOfCompositePrimaryKey()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey isObjectID=""false"">
<prop name=""TestRelatedClassID""/>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""single"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
owningBOHasForeignKey=""true"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
IClassDef reverseClassDef = classDefList.FindByClassName("TestRelatedClass");
IRelationshipDef relationshipDef = reverseClassDef.RelationshipDefCol["TestClass"];
//---------------Assert PreConditions---------------
Assert.IsTrue(relationshipDef.OwningBOHasForeignKey);
//--------------------Execute Test-------------------------
validator.ValidateClassDefs(classDefList);
//---------------Test Result -----------------------
Assert.IsTrue(relationshipDef.OwningBOHasForeignKey);
}
public void Test_Build_WithRelProp_ShouldCreateRelDefWithOneProp()
{
//---------------Set up test pack-------------------
const string relationshipName = "Drivers";
const string propertyName = "VehicleID";
const string relatedPropName = "CarID";
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var multipleRelationshipDef = new RelationshipsBuilderStub <Car>().WithMultipleRelationship(c => c.Drivers).WithRelProp(propertyName, relatedPropName);
IRelationshipDef relationshipDef = multipleRelationshipDef.Build();
//---------------Test Result -----------------------
Assert.AreEqual(relationshipName, relationshipDef.RelationshipName);
Assert.AreEqual(1, relationshipDef.RelKeyDef.Count);
IRelPropDef relPropDef = relationshipDef.RelKeyDef[propertyName];
Assert.IsNotNull(relPropDef);
Assert.AreEqual(propertyName, relPropDef.OwnerPropertyName);
Assert.AreEqual(relatedPropName, relPropDef.RelatedClassPropName);
}
///<summary>
/// Creates a Reverse Relationship when required.
///</summary>
///<param name="classDefCol"></param>
///<param name="classDef"></param>
///<param name="relationship"></param>
///<returns></returns>
public static IRelationshipDef CreateReverseRelationship(ClassDefCol classDefCol, IClassDef classDef, IRelationshipDef relationship)
{
IRelationshipDef rel = relationship;
if (!ContainsRelatedClass(relationship, classDefCol))
{
return(null);
}
IClassDef relatedClassDef = RelatedObjectClassDef(classDefCol, relationship);
bool foundReverseRelationship = relatedClassDef.RelationshipDefCol.Any(
def => def.RelationshipName == rel.ReverseRelationshipName);
if (foundReverseRelationship)
{
return(null);
}
IRelationshipDef newReverseRelDef = CreateReverseRelDef(rel, classDef);
relatedClassDef.RelationshipDefCol.Add(newReverseRelDef);
IRelPropDef relPropDef = relationship.RelKeyDef.FirstOrDefault();
if (relPropDef != null)
{
var reverseRelPropDef = new RelPropDef(relPropDef.RelatedClassPropName, relPropDef.OwnerPropertyName);
newReverseRelDef.RelKeyDef.Add(reverseRelPropDef);
bool hasPropDef = relatedClassDef.PropDefColIncludingInheritance.Any(
propDef => propDef.PropertyName == reverseRelPropDef.OwnerPropertyName);
if (!hasPropDef)
{
var fkPropDef = new PropDef(reverseRelPropDef.OwnerPropertyName, typeof(Guid), PropReadWriteRule.ReadWrite, null);
relatedClassDef.PropDefcol.Add(fkPropDef);
}
}
return(newReverseRelDef);
}
public void Test_Map_WhenNotHasReverseRelDefined_ShouldCreateRelProp()
{
//---------------Set up test pack-------------------
Type boWithM21 = typeof(FakeManyToOneBoRelNoFK);
Type boWithNoDefinedRel = typeof(FakeBOWithNoRelationship);
FakeTypeSource source = new FakeTypeSource(
new[] { boWithM21, boWithNoDefinedRel });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
IClassDef cDefWithM21 = classDefCol[boWithM21];
cDefWithM21.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef relationshipDef = cDefWithM21.RelationshipDefCol.FirstOrDefault();
Assert.IsNotNull(relationshipDef);
relationshipDef.RelKeyDef.ShouldHaveCount(1);
IRelPropDef relPropDef = relationshipDef.RelKeyDef.FirstOrDefault();
Assert.IsNotNull(relPropDef);
IClassDef cDefNoDefinedRel = classDefCol[boWithNoDefinedRel];
IRelationshipDef reverseRelDef = cDefNoDefinedRel.RelationshipDefCol[relationshipDef.ReverseRelationshipName];
reverseRelDef.RelKeyDef.ShouldHaveCount(1);
IRelPropDef revereRelPropDef = reverseRelDef.RelKeyDef.FirstOrDefault();
Assert.IsNotNull(revereRelPropDef, "ReverseRelationship ShouldHave Been Created");
Assert.AreEqual(relPropDef.OwnerPropertyName, revereRelPropDef.RelatedClassPropName);
Assert.AreEqual(relPropDef.RelatedClassPropName, revereRelPropDef.OwnerPropertyName);
}
public void Test_Map_WhenNotHasReverseRelDefined_ShouldCreateReverseRel()
{
//---------------Set up test pack-------------------
Type boWithM21 = typeof(FakeManyToOneBoRelNoFK);
Type boWithNoDefinedRel = typeof(FakeBOWithNoRelationship);
FakeTypeSource source = new FakeTypeSource(
new[] { boWithM21, boWithNoDefinedRel });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
IClassDef cDefWithM21 = classDefCol[boWithM21];
cDefWithM21.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef relationshipDef = cDefWithM21.RelationshipDefCol.FirstOrDefault();
Assert.IsNotNull(relationshipDef);
Assert.IsNotNullOrEmpty(relationshipDef.ReverseRelationshipName);
IClassDef cDefNoDefinedRel = classDefCol[boWithNoDefinedRel];
cDefNoDefinedRel.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef reverseRelDef = cDefNoDefinedRel.RelationshipDefCol[relationshipDef.ReverseRelationshipName];
Assert.AreEqual(relationshipDef.ReverseRelationshipName, reverseRelDef.RelationshipName);
Assert.AreEqual(relationshipDef.RelationshipName, reverseRelDef.ReverseRelationshipName);
Assert.IsInstanceOf(typeof(MultipleRelationshipDef), reverseRelDef);
Assert.AreEqual(RelationshipType.Association, reverseRelDef.RelationshipType);
Assert.AreEqual(DeleteParentAction.Prevent, reverseRelDef.DeleteParentAction);
Assert.IsFalse(reverseRelDef.OwningBOHasForeignKey);
}
[Test] // Checks that deleting this instance has no effect in the related class
public void Test_SingleRelationshipDeletion_DoNothing_Car()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Driver driver = TestUtilsDriver.CreateSavedDriver();
TestProjectNoDBSpecificProps.BO.Car boForRelationshipCar = TestUtilsCar.CreateSavedCar();
driver.Car = boForRelationshipCar;
driver.Save();
//---------------Assert Preconditions---------------
IRelationshipDef relationshipDef = ClassDef.Get <Driver>().RelationshipDefCol["Car"];
Assert.AreEqual(DeleteParentAction.DoNothing, relationshipDef.DeleteParentAction);
//---------------Execute Test ----------------------
driver.MarkForDelete();
driver.Save();
//---------------Execute Test ----------------------
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
try
{
Broker.GetBusinessObject <Driver>(driver.ID);
Assert.Fail("BO should no longer exist and exception should be thrown");
}
catch (BusObjDeleteConcurrencyControlException ex)
{
StringAssert.Contains("There are no records in the database for the Class: Driver", ex.Message);
}
var relatedBO = Broker.GetBusinessObject <TestProjectNoDBSpecificProps.BO.Car>(boForRelationshipCar.ID);
Assert.AreEqual(relatedBO.ID.ToString(), boForRelationshipCar.ID.ToString());
}
public void Test_IsCompulsory_WhenNotHasCompulsoryFKProps_ShouldReturnFalse()
{
FakeSingleRelationshipDef singleRelationshipDef = new FakeSingleRelationshipDef();
var relKeyDef = new RelKeyDef();
var propDef = new PropDefFake {
Compulsory = false
};
var relPropDef = new RelPropDef(propDef, "SomeThing");
relKeyDef.Add(relPropDef);
singleRelationshipDef.SetRelKeyDef(relKeyDef);
singleRelationshipDef.OwningBOHasForeignKey = true;
IRelationshipDef relationshipDef = singleRelationshipDef;
//---------------Assert Precondition----------------
Assert.IsFalse(propDef.Compulsory);
Assert.IsTrue(singleRelationshipDef.OwningBOHasForeignKey);
//---------------Execute Test ----------------------
bool isCompulsory = relationshipDef.IsCompulsory;
//---------------Test Result -----------------------
Assert.IsFalse(isCompulsory);
}
private void AddChildIfNeeded(string childName, RelationshipCol relationshipCol)
{
IRelationshipDefCol relationshipDefCol = ClassDef.RelationshipDefCol;
if (relationshipDefCol.Contains(childName))
{
IRelationshipDef relationshipDef = relationshipDefCol[childName];
#pragma warning disable 168
IClassDef classDef = relationshipDef.RelatedObjectClassDef;
#pragma warning restore 168
IMultipleRelationship relationship = (IMultipleRelationship)relationshipDef.CreateRelationship(this, this._boPropCol);
//_mock.DynamicMock<IMultipleRelationship>();
//(this, relationshipDef, this._boPropCol);
//BusinessObjectCollection<BusinessObject> businessObjectCollection = new BusinessObjectCollection<BusinessObject>(classDef);
//SetupResult.For(relationship.BusinessObjectCollection)
// .Return(businessObjectCollection);
//SetupResult.For(relationship.RelationshipName)
// .Return(businessObjectCollection);
//SetupResult.For(relationship.GetRelatedBusinessObjectCol<BusinessObject>())
// .Return(businessObjectCollection);
relationshipCol.Add(relationship);
}
}
/// <summary>
/// Constrcutor for <see cref="MultipleRelationshipBase"/>
/// </summary>
/// <param name="owningBo">The <see cref="IBusinessObject"/> that owns this BO.</param>
/// <param name="lRelDef">The <see cref="IRelationshipDef"/> that identifies </param>
/// <param name="lBOPropCol"></param>
protected MultipleRelationshipBase(IBusinessObject owningBo, IRelationshipDef lRelDef, IBOPropCol lBOPropCol)
: base(owningBo, lRelDef, lBOPropCol)
{
}
/// <summary>
/// Indicates whether the collection contains the relationship
/// definition specified
/// </summary>
/// <param name="relationshipDef">The Relationship definition to search for</param>
/// <returns>Returns true if found, false if not</returns>
protected bool Contains(IRelationshipDef relationshipDef)
{
return _relDefs.ContainsKey(relationshipDef.RelationshipName);
}
/// <summary>
/// Constructs the tester with the relationship under test.
/// </summary>
/// <param name="relationshipDef"></param>
public MultipleRelDefTester(IRelationshipDef relationshipDef)
{
if (relationshipDef == null) throw new ArgumentNullException("relationshipDef");
MultipleRelationshipDef = relationshipDef;
}
private bool HasRelDef(string propertyName)
{
IRelationshipDef relationshipDef = GetClassDef().GetRelationship(propertyName);
return(relationshipDef != null);
}
private static bool HasReverseRelationship(IRelationshipDef relationshipDef)
{
return !string.IsNullOrEmpty(relationshipDef.ReverseRelationshipName);
}
private static Result ReverseRelationshipHasSameProps(IRelationshipDef relationshipDef, IRelationshipDef reverseRelationshipDef)
{
if (relationshipDef.RelKeyDef.Count != reverseRelationshipDef.RelKeyDef.Count) return new Result(false, "relationship KeyCount : " + relationshipDef.RelKeyDef.Count + " reverseRelationshpDef KeyCount : " + reverseRelationshipDef.RelKeyDef.Count);
foreach (var relPropDef in relationshipDef.RelKeyDef)
{
var localRelDef = relPropDef;
var foundMatch = reverseRelationshipDef.RelKeyDef.Any(reverseRelPropDef => reverseRelPropDef.DoKeyPropsMatch(localRelDef));
if (!foundMatch) return new Result(false, "- No matching RelProp found for " + relPropDef.OwnerPropertyName + " -> " + relPropDef.RelatedClassPropName
+ Environment.NewLine + "Relationship " + relationshipDef.RelationshipName + relationshipDef.GetRelPropDefString() +
Environment.NewLine + "ReverseRelationship " + reverseRelationshipDef.RelationshipName + reverseRelationshipDef.GetRelPropDefString());
}
return new Result(true, "");
}
private static string GetBaseRelationshipMessage(IRelationshipDef relationshipDef, IClassDef relatedClassDef, string reverseRelationshipName, IClassDef classDef)
{
return string.Format
("The relationship '{0}' could not be loaded because the reverse relationship '{1}' defined for the related class '{2}' and the relationship '{3}' defined for the class '{4}' " ,
relationshipDef.RelationshipName, reverseRelationshipName, relatedClassDef.ClassNameFull,
relationshipDef.RelationshipName, classDef.ClassNameFull);
}
private static bool HasReverseRelationship(IRelationshipDef relationshipDef)
{
return(!string.IsNullOrEmpty(relationshipDef.ReverseRelationshipName));
}
private void SetReverseRelationshipName(IRelationshipDef relDef)
{
IEnumerable<AutoMapManyToOneAttribute> attributes = this.PropertyWrapper.GetAttributes<AutoMapManyToOneAttribute>();
AutoMapManyToOneAttribute mToOneAttribute = attributes.FirstOrDefault();
if (mToOneAttribute != null && !string.IsNullOrEmpty(mToOneAttribute.ReverseRelationshipName))
{
relDef.ReverseRelationshipName = mToOneAttribute.ReverseRelationshipName;
return;
}
var reverseRelPropInfo = this.PropertyWrapper.GetMultipleReverseRelPropInfo();
if (reverseRelPropInfo != null)
{
relDef.ReverseRelationshipName = reverseRelPropInfo.Name;
return;
}
relDef.ReverseRelationshipName = StringUtilities.Pluralize(this.PropertyWrapper.DeclaringClassName);
}
/// <summary>
/// Checks to see if the relationship and reverse relationship are defined for the same relationship.
/// </summary>
/// <param name="relationshipDef"></param>
/// <param name="relatedClassDef"></param>
/// <param name="reverseRelationshipName"></param>
/// <param name="reverseRelationshipDef"></param>
/// <param name="classDef"></param>
private static void CheckReverseRelationshipRelKeyDefProps(IRelationshipDef relationshipDef, IClassDef relatedClassDef, string reverseRelationshipName, IRelationshipDef reverseRelationshipDef, IClassDef classDef)
{
var relationshipHasSameProps = ReverseRelationshipHasSameProps(relationshipDef, reverseRelationshipDef);
if (!relationshipHasSameProps.Valid)
{
var baseMessage = GetBaseRelationshipMessage(relationshipDef, relatedClassDef, reverseRelationshipName,
classDef);
string errorMessage = baseMessage + " do not have the same properties defined as the relationship keys " + relationshipHasSameProps.ErrorMessage;
throw new InvalidXmlDefinitionException(errorMessage);
}
}
private void SetRelationshipType(IRelationshipDef relDef)
{
var att = this.PropertyWrapper.GetAttribute<AutoMapManyToOneAttribute>();
if (att != null) relDef.RelationshipType = att.RelationshipType;
}
private void CreateForeignKeyProp(IRelationshipDef relationshipDef)
{
var relationshipName = relationshipDef.RelationshipName;
var propertyName = PropNamingConvention.GetSingleRelOwningPropName(relationshipName);
var propDef = new PropDef(propertyName, typeof (Guid?), PropReadWriteRule.ReadWrite, null)
{
Compulsory = relationshipDef.IsCompulsory
};
SetDatabaseFieldName(propDef, relationshipName);
this.ClassDef.PropDefcol.Add(propDef);
}
internal static void SetIsOneToOne(this IRelationshipDef singleRelationshipDef)
{
singleRelationshipDef.Stub(def => def.IsOneToOne).Return(true);
}
private void ValidateRelKeyDef
(IClassDef classDef, ClassDefCol classDefs, IRelationshipDef relationshipDef, IClassDef relatedObjectClassDef,
IDictionary<IClassDef, IPropDefCol> loadedFullPropertyLists)
{
var allPropsForClassDef = GetAllClassDefProps(loadedFullPropertyLists, classDef, classDefs);
var allPropsForRelatedClassDef = GetAllClassDefProps
(loadedFullPropertyLists, relatedObjectClassDef, classDefs);
// Check Relationship Properties
foreach (IRelPropDef relPropDef in relationshipDef.RelKeyDef)
{
string ownerPropertyName = relPropDef.OwnerPropertyName;
if (!allPropsForClassDef.Contains(ownerPropertyName))
{
throw new InvalidXmlDefinitionException
(String.Format
("In a 'relatedProperty' element for the '{0}' relationship of "
+ "the '{1}' class, the property '{2}' given in the "
+ "'property' attribute does not exist for the class or for any of it's superclasses. "
+ "Either add the property definition or check the spelling and "
+
"capitalisation of the specified property. Check in the ClassDefs.xml file or fix in Firestarter",
relationshipDef.RelationshipName, classDef.ClassName, ownerPropertyName));
}
string relatedClassPropName = relPropDef.RelatedClassPropName;
if (!allPropsForRelatedClassDef.Contains(relatedClassPropName))
{
throw new InvalidXmlDefinitionException
(String.Format
("In a 'relatedProperty' element for the '{0}' relationship of "
+ "the '{1}' class, the property '{2}' given in the "
+
"'relatedProperty' attribute does not exist for the Related class '{3}' or for any of it's superclasses. "
+ "Either add the property definition or check the spelling and "
+
"capitalisation of the specified property. Check in the ClassDefs.xml file or fix in Firestarter",
relationshipDef.RelationshipName, classDef.ClassName, relatedClassPropName,
relatedObjectClassDef.ClassNameFull));
}
}
}
private static void ValidateReverseRelationship
(IClassDef classDef, IRelationshipDef relationshipDef, IClassDef relatedClassDef)
{
if (!HasReverseRelationship(relationshipDef)) return;
string reverseRelationshipName = relationshipDef.ReverseRelationshipName;
if (!relatedClassDef.RelationshipDefCol.Contains(reverseRelationshipName))
{
throw new InvalidXmlDefinitionException
(string.Format
("The relationship '{0}' could not be loaded for because the reverse relationship '{1}' defined for class '{2}' is not defined as a relationship for class '{2}'. Please check your ClassDefs.xml or fix in Firestarter.",
relationshipDef.RelationshipName, reverseRelationshipName, relatedClassDef.ClassNameFull));
}
var reverseRelationshipDef = relatedClassDef.RelationshipDefCol[reverseRelationshipName];
CheckReverseRelationshipRelKeyDefProps(relationshipDef, relatedClassDef, reverseRelationshipName, reverseRelationshipDef, classDef);
// if (!reverseRelationshipDef.OwningBOHasForeignKey) return;
//
// if (OwningClassHasPrimaryKey(reverseRelationshipDef, relatedClassDef))
// {
// reverseRelationshipDef.OwningBOHasForeignKey = false;
// return;
// }
if (relationshipDef.OwningBOHasForeignKey && reverseRelationshipDef.OwningBOHasForeignKey)
{
var baseMessage = GetBaseRelationshipMessage(relationshipDef, relatedClassDef, reverseRelationshipName, classDef);
string errorMessage = baseMessage + "are both set up as owningBOHasForeignKey = true. Please check your ClassDefs.xml or fix in Firestarter.";
throw new InvalidXmlDefinitionException(errorMessage);
}
}
///<summary>
/// Creates a Reverse Relationship when required.
///</summary>
///<param name="classDefCol"></param>
///<param name="classDef"></param>
///<param name="relationship"></param>
///<returns></returns>
public static IRelationshipDef CreateReverseRelationship(ClassDefCol classDefCol, IClassDef classDef, IRelationshipDef relationship)
{
IRelationshipDef rel = relationship;
if (!ContainsRelatedClass(relationship, classDefCol)) return null;
IClassDef relatedClassDef = RelatedObjectClassDef(classDefCol, relationship);
bool foundReverseRelationship = relatedClassDef.RelationshipDefCol.Any(
def => def.RelationshipName == rel.ReverseRelationshipName);
if (foundReverseRelationship) return null;
IRelationshipDef newReverseRelDef = CreateReverseRelDef(rel, classDef);
relatedClassDef.RelationshipDefCol.Add(newReverseRelDef);
IRelPropDef relPropDef = relationship.RelKeyDef.FirstOrDefault();
if (relPropDef != null)
{
var reverseRelPropDef = new RelPropDef(relPropDef.RelatedClassPropName, relPropDef.OwnerPropertyName);
newReverseRelDef.RelKeyDef.Add(reverseRelPropDef);
bool hasPropDef = relatedClassDef.PropDefColIncludingInheritance.Any(
propDef => propDef.PropertyName == reverseRelPropDef.OwnerPropertyName);
if (!hasPropDef)
{
var fkPropDef = new PropDef(reverseRelPropDef.OwnerPropertyName, typeof (Guid), PropReadWriteRule.ReadWrite, null);
relatedClassDef.PropDefcol.Add(fkPropDef);
}
}
return newReverseRelDef;
}
/// <summary>
/// Checks to see if the relationship and reverse relationship are defined for the same relationship.
/// </summary>
/// <param name="relationshipDef"></param>
/// <param name="relatedClassDef"></param>
/// <param name="reverseRelationshipName"></param>
/// <param name="reverseRelationshipDef"></param>
/// <param name="classDef"></param>
private static void CheckReverseRelationshipRelKeyDefProps(IRelationshipDef relationshipDef, IClassDef relatedClassDef, string reverseRelationshipName, IRelationshipDef reverseRelationshipDef, IClassDef classDef)
{
var relationshipHasSameProps = ReverseRelationshipHasSameProps(relationshipDef, reverseRelationshipDef);
if (!relationshipHasSameProps.Valid)
{
var baseMessage = GetBaseRelationshipMessage(relationshipDef, relatedClassDef, reverseRelationshipName,
classDef);
string errorMessage = baseMessage + " do not have the same properties defined as the relationship keys " + relationshipHasSameProps.ErrorMessage;
throw new InvalidXmlDefinitionException(errorMessage);
}
}
private static IRelationshipDef CreateReverseRelDef(IRelationshipDef rel, IClassDef classDef)
{
IRelationshipDef newReverseRelDef;
if (rel.IsManyToOne)
{
newReverseRelDef = new MultipleRelationshipDef(rel.ReverseRelationshipName
, classDef.ClassType, new RelKeyDef(), true, ""
, DeleteParentAction.Prevent);
}else
{
newReverseRelDef = new SingleRelationshipDef(rel.ReverseRelationshipName
, classDef.ClassType, new RelKeyDef(), true
, DeleteParentAction.DoNothing);
}
newReverseRelDef.ReverseRelationshipName = rel.RelationshipName;
return newReverseRelDef;
}
private static bool OwningClassHasPrimaryKey(IRelationshipDef relationshipDef, IClassDef classDef, ClassDefCol classDefCol)
{
//For each Property in the Relationship Key check if it is defined as the primary key for the
//class if it is then check the other properties else this is not a primaryKey
var primaryKeyDef = ClassDefHelper.GetPrimaryKeyDef(classDef, classDefCol);
foreach (var relPropDef in relationshipDef.RelKeyDef)
{
var isInKeyDef = false;
foreach (IPropDef propDef in primaryKeyDef)
{
if (propDef.PropertyName != relPropDef.OwnerPropertyName)
{
isInKeyDef = false;
break;
}
isInKeyDef = true;
}
if (!isInKeyDef) return false;
}
return true;
}
private static bool ContainsRelatedClass(IRelationshipDef relationship, ClassDefCol classDefCol)
{
return classDefCol.Contains(relationship.RelatedObjectAssemblyName, relationship.RelatedObjectClassName);
}
private bool HasPropInfo(IRelationshipDef relationshipDef)
{
var propName = relationshipDef.RelationshipName;
return(HasPropInfo(propName));
}
/// <summary>
/// The <see cref="ClassDef"/> for the related object.
/// </summary>
private static IClassDef RelatedObjectClassDef(ClassDefCol classDefCol, IRelationshipDef relationshipDef)
{
return classDefCol[relationshipDef.RelatedObjectAssemblyName, relationshipDef.RelatedObjectClassNameWithTypeParameter];
}
private static void createRelationshipXml(XmlElement classDMElement, IRelationshipDef relationshipDef)
{
//IClassDef relatedClassDef = relationshipDef.RelatedObjectClassDef;//.MyRelatedClass.CurrentClass;
//if (relatedClassDef == null) return;
XmlElement relationshipDMElement = XmlUtilities.createXmlElement(classDMElement, "relationship");
XmlUtilities.setXmlAttribute(relationshipDMElement, "name", relationshipDef.RelationshipName);
bool isMultiple = false;
//TODO Mark 28 Sep 2009: Review this and change it to use the IRelationshipDef interface methods or classes
if (relationshipDef.IsManyToOne || relationshipDef.IsOneToOne)
XmlUtilities.setXmlAttribute(relationshipDMElement, "type", "single");
else if (relationshipDef.IsOneToMany)
{
XmlUtilities.setXmlAttribute(relationshipDMElement, "type", "multiple");
isMultiple = true;
}
if (isMultiple)
{
XmlUtilities.setXmlAttribute(relationshipDMElement, "timeout", relationshipDef.TimeOut, 0);
}
XmlUtilities.setXmlAttribute(relationshipDMElement, "relatedClass", relationshipDef.RelatedObjectClassName);
XmlUtilities.setXmlAttribute(relationshipDMElement, "reverseRelationship", relationshipDef.ReverseRelationshipName);
XmlUtilities.setXmlAttribute(relationshipDMElement, "relatedAssembly", relationshipDef.RelatedObjectAssemblyName);
XmlUtilities.setXmlAttribute(relationshipDMElement, "keepReference", relationshipDef.KeepReferenceToRelatedObject, true);
XmlUtilities.setXmlAttribute(relationshipDMElement, "deleteAction", relationshipDef.DeleteParentAction, DeleteParentAction.Prevent);
XmlUtilities.setXmlAttribute(relationshipDMElement, "relationshipType", relationshipDef.RelationshipType, RelationshipType.Association);
// XmlUtilities.setXmlAttribute(relationshipDMElement, "relationshipDescription", relationshipDef.);
if (isMultiple)
{
XmlUtilities.setXmlAttribute(relationshipDMElement, "orderBy", relationshipDef.OrderCriteriaString);
}
else
{
XmlUtilities.setXmlAttribute(relationshipDMElement, "owningBOHasForeignKey", relationshipDef.OwningBOHasForeignKey, true);
}
foreach (IRelPropDef relPropDef in relationshipDef.RelKeyDef)
{
if (relPropDef.OwnerPropertyName != null && relPropDef.RelatedClassPropName != null)
{
XmlElement relPropElement = XmlUtilities.createXmlElement(relationshipDMElement, "relatedProperty");
XmlUtilities.setXmlAttribute(relPropElement, "property", relPropDef.OwnerPropertyName);
XmlUtilities.setXmlAttribute(relPropElement, "relatedProperty", relPropDef.RelatedClassPropName);
}
}
classDMElement.AppendChild(relationshipDMElement);
}
protected static void ValidateRelationshipDef(Type type, IRelationshipDef def, string relationshipName)
{
if (def == null)
{
throw new HabaneroDeveloperException(
string.Format("The relationship '{0}' for the ClassDef for '{1}' is not defined", relationshipName,
type), DEVELOPER_MESSAGE);
}
}
private bool HasPropInfo(IRelationshipDef relationshipDef)
{
var propName = relationshipDef.RelationshipName;
return HasPropInfo(propName);
}
private static IClassDef GetRelatedObjectClassDef(ClassDefCol classDefs, IRelationshipDef relationshipDef)
{
IClassDef relatedObjectClassDef;
try
{
relatedObjectClassDef =
classDefs[relationshipDef.RelatedObjectAssemblyName, relationshipDef.RelatedObjectClassNameWithTypeParameter];
}
catch (HabaneroDeveloperException)
{
try
{
relatedObjectClassDef =
ClassDef.ClassDefs[relationshipDef.RelatedObjectAssemblyName, relationshipDef.RelatedObjectClassNameWithTypeParameter];
}
catch (HabaneroDeveloperException ex)
{
throw new InvalidXmlDefinitionException
(string.Format
("The relationship '{0}' could not be loaded because when trying to retrieve its related class the folllowing error was thrown '{1}'",
relationshipDef.RelationshipName, ex.Message), ex);
}
}
return relatedObjectClassDef;
}
/// <summary>
/// Constructor to initialise a new relationship
/// </summary>
/// <param name="owningBo">The business object from where the
/// relationship originates</param>
/// <param name="lRelDef">The relationship definition</param>
/// <param name="lBOPropCol">The set of properties used to
/// initialise the RelKey object</param>
protected Relationship(IBusinessObject owningBo, IRelationshipDef lRelDef, IBOPropCol lBOPropCol)
{
if (owningBo == null) throw new ArgumentNullException("owningBo");
if (lRelDef == null) throw new ArgumentNullException("lRelDef");
if (lBOPropCol == null) throw new ArgumentNullException("lBOPropCol");
_relDef = lRelDef;
_owningBo = owningBo;
_relKey = new Lazy<IRelKey>(() => _relDef.RelKeyDef.CreateRelKey(lBOPropCol));
}
internal static void SetIsNotManyToOne(this IRelationshipDef singleRelationshipDef)
{
singleRelationshipDef.Stub(def => def.IsManyToOne).Return(false);
}