public void Test_CreatePrimaryKey_TwoPropDefs()
{
//---------------Set up test pack-------------------
PropDef propDef1 = new PropDef("prop1", typeof(String), PropReadWriteRule.ReadWrite, null);
PropDef propDef2 = new PropDef("prop2", typeof(String), PropReadWriteRule.ReadWrite, null);
PrimaryKeyDef keyDef = new PrimaryKeyDef {
IsGuidObjectID = false
};
keyDef.Add(propDef2);
keyDef.Add(propDef1);
BOPropCol boPropCol = new BOPropCol();
boPropCol.Add(propDef1.CreateBOProp(false));
boPropCol.Add(propDef2.CreateBOProp(false));
//---------------Assert Precondition----------------
Assert.AreEqual(2, keyDef.Count);
//---------------Execute Test ----------------------
BOPrimaryKey boPrimaryKey = (BOPrimaryKey)keyDef.CreateBOKey(boPropCol);
//---------------Test Result -----------------------
Assert.AreEqual(keyDef.Count, boPrimaryKey.Count);
Assert.IsTrue(boPrimaryKey.IsCompositeKey);
}
/// <summary>
/// Generates a collection of sql statements to delete the business
/// object from the database
/// </summary>
/// <returns>Returns a sql statement collection</returns>
public IEnumerable <ISqlStatement> Generate()
{
var statements = new List <ISqlStatement>();
//AddRelationshipDeleteStatements(statementCollection);
SqlStatement deleteSql = new SqlStatement(_connection);
deleteSql.Statement = new StringBuilder(
@"DELETE FROM " + _connection.SqlFormatter.DelimitTable(StatementGeneratorUtils.GetTableName(_bo)) +
" WHERE " + StatementGeneratorUtils.PersistedDatabaseWhereClause((BOKey)_bo.ID, deleteSql));
statements.Add(deleteSql);
IClassDef currentClassDef = _bo.ClassDef;
while (currentClassDef.IsUsingClassTableInheritance())
{
while (currentClassDef.SuperClassClassDef.SuperClassDef != null &&
currentClassDef.SuperClassClassDef.SuperClassDef.ORMapping == ORMapping.SingleTableInheritance)
{
currentClassDef = currentClassDef.SuperClassClassDef;
}
deleteSql = new SqlStatement(_connection);
deleteSql.Statement.Append(
"DELETE FROM " +
_connection.SqlFormatter.DelimitTable(currentClassDef.SuperClassClassDef.TableName) +
" WHERE " +
StatementGeneratorUtils.PersistedDatabaseWhereClause(BOPrimaryKey.GetSuperClassKey((ClassDef)currentClassDef, _bo), deleteSql));
statements.Add(deleteSql);
currentClassDef = currentClassDef.SuperClassClassDef;
}
return(statements);
}
public void TestSuperClassKey()
{
IBOKey msuperKey = BOPrimaryKey.GetSuperClassKey((ClassDef)Circle.GetClassDef(), objCircle);
Assert.IsTrue(msuperKey.Contains("ShapeID"), "Super class key should contain the ShapeID property");
Assert.AreEqual(1, msuperKey.Count, "Super class key should only have one prop");
Assert.AreEqual(msuperKey["ShapeID"].Value, objCircle.ID["CircleID"].Value,
"ShapeID and CircleID should be the same");
}
public void Test_ObjectID_NotSet()
{
//--------------- Set up test pack ------------------
//--------------- Test Preconditions ----------------
//--------------- Execute Test ----------------------
BOPrimaryKey primaryKey = CreateBOPrimaryKeyString();
//--------------- Test Result -----------------------
Assert.AreEqual(Guid.Empty, primaryKey.ObjectID);
}
/// <summary>
/// Creates a new business object key (BOKey) using this key
/// definition and its property definitions. Creates either a new
/// BOObjectID object (if the primary key is the object's ID)
/// or a BOPrimaryKey object.
/// </summary>
/// <param name="lBOPropCol">The master property collection</param>
/// <returns>Returns a new BOKey object that mirrors this
/// key definition</returns>
public override IBOKey CreateBOKey(IBOPropCol lBOPropCol)
{
BOPrimaryKey lBOKey = _isGuidObjectID ? new BOObjectID(this) : new BOPrimaryKey(this);
foreach (PropDef lPropDef in this)
{
lBOKey.Add(lBOPropCol[lPropDef.PropertyName]);
}
return(lBOKey);
}
public void Test_CreateBOPrimaryKey()
{
//---------------Set up test pack-------------------
PrimaryKeyDef pkDef = new PrimaryKeyDef();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
BOPrimaryKey boPrimaryKey = new BOPrimaryKey(pkDef);
//---------------Test Result -----------------------
Assert.IsNotNull(boPrimaryKey);
}
public void TestSuperClassKey()
{
IBOKey msuperKey = BOPrimaryKey.GetSuperClassKey((ClassDef)FilledCircleInheritsCircleNoPK.GetClassDef(), _filledCircle);
Assert.IsFalse(msuperKey.Contains("CircleID"), "Super class key should not contain the CircleID property");
Assert.IsTrue(msuperKey.Contains("ShapeID"), "Super class key should contain the ShapeID property");
Assert.AreEqual(1, msuperKey.Count, "Super class key should only have one prop");
Assert.AreEqual(_filledCircle.Props["ShapeID"].Value, //msuperKey["ShapeID"].Value,
_filledCircle.ID["FilledCircleID"].Value,
"ShapeID and FilledCircleID should be the same");
}
/// <summary>
/// returns the TransactionLogStub identified by id.
/// </summary>
/// <remarks>
/// If the Contact person is already leaded then an identical copy of it will be returned.
/// </remarks>
/// <param name="id">The object primary Key</param>
/// <returns>The loaded business object</returns>
/// <exception cref="BusObjDeleteConcurrencyControlException">
/// if the object has been deleted already</exception>
public static TransactionLogStub GetTransactionLog(BOPrimaryKey id)
{
//TransactionLogStub myTransactionLogStub = (TransactionLogStub)BOLoader.Instance.GetLoadedBusinessObject(id);
//if (myTransactionLogStub == null)
//{
TransactionLogStub myTransactionLogStub =
BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObject <TransactionLogStub>(id);
// }
return(myTransactionLogStub);
}
public void Test_CreateWithValue_ClassDef_WithSuperClass()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
var value = Guid.NewGuid();
var inheritedClassDef = MyInheritedType.LoadInheritedTypeClassDef();
//---------------Execute Test ----------------------
var key = BOPrimaryKey.CreateWithValue((ClassDef)inheritedClassDef, value);
//---------------Test Result -----------------------
Assert.AreEqual(value.ToString(), key.ToString());
//---------------Tear Down -------------------------
}
public void Test_ObjectID_SetObjectGuidID()
{
//--------------- Set up test pack ------------------
BOPrimaryKey primaryKey = CreateBOPrimaryKeyString();
Guid id = Guid.NewGuid();
//--------------- Test Preconditions ----------------
Assert.AreEqual(Guid.Empty, primaryKey.ObjectID);
//--------------- Execute Test ----------------------
primaryKey.SetObjectGuidID(id);
//--------------- Test Result -----------------------
Assert.AreEqual(id, primaryKey.ObjectID);
}
public void Test_AsString_CurrentValue_TwoPropKey()
{
//--------------- Set up test pack ------------------
BOPrimaryKey primaryKey = CreatePrimaryBOKeyGuidAndString();
Guid guid = Guid.NewGuid();
//--------------- Test Preconditions ----------------
//--------------- Execute Test ----------------------
primaryKey.SetObjectGuidID(guid);
string keyAsString = primaryKey.AsString_CurrentValue();
//--------------- Test Result -----------------------
StringAssert.AreEqualIgnoringCase(guid.ToString(), keyAsString);
}
public void Test_AsString_PreviousValue()
{
//--------------- Set up test pack ------------------
BOPrimaryKey primaryKey = CreateBOObjectID();
Guid originalGuid = Guid.NewGuid();
//--------------- Test Preconditions ----------------
//--------------- Execute Test ----------------------
primaryKey.SetObjectGuidID(originalGuid);
string keyAsString = primaryKey.AsString_PreviousValue();
//--------------- Test Result -----------------------
StringAssert.AreEqualIgnoringCase(originalGuid.ToString(), keyAsString);
}
public void Test_AsString_PreviousValue_SetValue()
{
//--------------- Set up test pack ------------------
BOPrimaryKey primaryKey = CreateBOPrimaryKeyString();
Guid guid = Guid.NewGuid();
string str = TestUtil.GetRandomString();
//--------------- Test Preconditions ----------------
//--------------- Execute Test ----------------------
primaryKey.SetObjectGuidID(guid);
primaryKey[0].Value = str;
string keyAsString = primaryKey.AsString_PreviousValue();
//--------------- Test Result -----------------------
StringAssert.AreEqualIgnoringCase(guid.ToString(), keyAsString);
}
public void Test_AsString_CurrentValue_TwoPropKey_SetTwoProp()
{
//--------------- Set up test pack ------------------
BOPrimaryKey primaryKey = CreatePrimaryBOKeyGuidAndString();
Guid guid = Guid.NewGuid();
primaryKey.SetObjectGuidID(guid);
primaryKey[0].Value = Guid.NewGuid();
primaryKey[1].Value = TestUtil.GetRandomString();
//--------------- Test Preconditions ----------------
//--------------- Execute Test ----------------------
string keyAsString = primaryKey.AsString_CurrentValue();
//--------------- Test Result -----------------------
Assert.AreNotEqual(guid.ToString(), keyAsString);
Assert.AreEqual("ContactPersonTestBO.PropName1=" + primaryKey[0].Value + ";ContactPersonTestBO.PropName2=" + primaryKey[1].Value, keyAsString);
}
public void Test_CreateWithValue_ClassDef()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
int value = TestUtil.GetRandomInt();
IClassDef autoIncClassDef = BOWithIntID.LoadClassDefWithIntID();
BOWithIntID bo = new BOWithIntID {
TestField = "PropValue", IntID = value
};
object expectedID = bo.ID;
//---------------Execute Test ----------------------
BOPrimaryKey key = BOPrimaryKey.CreateWithValue((ClassDef)autoIncClassDef, value);
//---------------Test Result -----------------------
Assert.AreEqual(expectedID.ToString(), key.ToString());
//---------------Tear Down -------------------------
}
public void Test_CreateWithValue_ClassDef_WriteNewProp()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
string value = TestUtil.GetRandomString();
IClassDef classDef = ContactPersonTestBO.LoadClassDefWithSurnameAsPrimaryKey_WriteNew();
ContactPersonTestBO contactPersonTestBO = new ContactPersonTestBO {
Surname = value
};
object expectedID = contactPersonTestBO.ID;
//---------------Execute Test ----------------------
BOPrimaryKey key = BOPrimaryKey.CreateWithValue((ClassDef)classDef, value);
//---------------Test Result -----------------------
Assert.AreEqual(expectedID.ToString(), key.ToString());
//---------------Tear Down -------------------------
}
public void Test_CreateBOPrimaryKey_IsObjectID_False()
{
//---------------Set up test pack-------------------
PrimaryKeyDef pkDef = new PrimaryKeyDef
{
new PropDef("prop2", typeof(Guid), PropReadWriteRule.ReadWrite, null)
};
pkDef.IsGuidObjectID = false;
BOPrimaryKey boPrimaryKey = new BOPrimaryKey(pkDef);
//---------------Assert Precondition----------------
Assert.IsFalse(pkDef.IsGuidObjectID);
//---------------Execute Test ----------------------
bool isObjectID = boPrimaryKey.IsGuidObjectID;
//---------------Test Result -----------------------
Assert.IsFalse(isObjectID);
}
public void Test_AsString_PreviousValue_SetValueTwice()
{
//--------------- Set up test pack ------------------
BOPrimaryKey primaryKey = CreateBOPrimaryKeyString();
Guid guid = Guid.NewGuid();
primaryKey.SetObjectGuidID(guid);
string str1 = TestUtil.GetRandomString();
primaryKey[0].Value = str1;
string str2 = TestUtil.GetRandomString();
//--------------- Test Preconditions ----------------
//--------------- Execute Test ----------------------
primaryKey[0].Value = str2;
string keyAsString = primaryKey.AsString_PreviousValue();
//--------------- Test Result -----------------------
StringAssert.AreEqualIgnoringCase("ContactPersonTestBO.PropName1=" + str1, keyAsString);
}
public void Test_AsString_PreviousValue_TwoPropKey_ResetOneProp()
{
//--------------- Set up test pack ------------------
BOPrimaryKey primaryKey = CreatePrimaryBOKeyGuidAndString();
Guid guid = Guid.NewGuid();
primaryKey.SetObjectGuidID(guid);
primaryKey[0].Value = Guid.NewGuid();
primaryKey[1].Value = TestUtil.GetRandomString();
string origKeyAsString = primaryKey.AsString_CurrentValue();
//--------------- Test Preconditions ----------------
//--------------- Execute Test ----------------------
primaryKey[1].Value = TestUtil.GetRandomString();
string keyAsString = primaryKey.AsString_PreviousValue();
//--------------- Test Result -----------------------
Assert.AreNotEqual(guid.ToString(), keyAsString);
Assert.AreEqual(origKeyAsString, keyAsString);
}
public void Test_ObjectID_SetObjectGuidID_Twice()
{
//--------------- Set up test pack ------------------
BOPrimaryKey primaryKey = CreateBOPrimaryKeyString();
Guid id = Guid.NewGuid();
primaryKey.SetObjectGuidID(id);
//--------------- Test Preconditions ----------------
Assert.AreEqual(id, primaryKey.ObjectID);
//--------------- Execute Test ----------------------
try
{
primaryKey.SetObjectGuidID(Guid.NewGuid());
//--------------- Test Result -----------------------
Assert.Fail("InvalidObjectIdException expected");
}
catch (InvalidObjectIdException ex)
{
Assert.AreEqual("The ObjectGuidID has already been set for this object.", ex.Message);
Assert.AreEqual(id, primaryKey.ObjectID);
}
}
/// <summary>
/// Generates an "update" sql statement for the properties in the
/// business object
/// </summary>
/// <param name="tableName">The table name</param>
/// <param name="propsToInclude">A collection of properties to update,
/// if the previous include-all boolean was not set to true</param>
/// <param name="isSuperClassStatement">Whether a super-class is involved</param>
/// <param name="currentClassDef">The current class definition</param>
private void GenerateSingleUpdateStatement(string tableName, IBOPropCol propsToInclude,
bool isSuperClassStatement, ClassDef currentClassDef)
{
_updateSql = new SqlStatement(_connection);
_updateSql.Statement.Append(
@"UPDATE " + _connection.SqlFormatter.DelimitTable(tableName) + " SET ");
int includedProps = 0;
foreach (BOProp prop in _bo.Props.SortedValues)
{
if (propsToInclude.Contains(prop.PropertyName))
{
PrimaryKeyDef primaryKeyDef = (PrimaryKeyDef)_bo.ClassDef.PrimaryKeyDef ?? (PrimaryKeyDef)_bo.ID.KeyDef;
if (prop.IsDirty &&
((primaryKeyDef.IsGuidObjectID && !primaryKeyDef.Contains(prop.PropertyName)) ||
!primaryKeyDef.IsGuidObjectID))
{
includedProps++;
_updateSql.Statement.Append(_connection.SqlFormatter.DelimitField(prop.DatabaseFieldName));
_updateSql.Statement.Append(" = ");
//prop.PropDef.GetDataMapper().GetDatabaseValue(prop.Value);
_updateSql.AddParameterToStatement(prop.Value);
_updateSql.Statement.Append(", ");
}
}
}
_updateSql.Statement.Remove(_updateSql.Statement.Length - 2, 2); //remove the last ", "
if (isSuperClassStatement)
{
_updateSql.Statement.Append(" WHERE " + StatementGeneratorUtils.PersistedDatabaseWhereClause(BOPrimaryKey.GetSuperClassKey(currentClassDef, _bo), _updateSql));
}
else
{
_updateSql.Statement.Append(" WHERE " + StatementGeneratorUtils.PersistedDatabaseWhereClause((BOKey)_bo.ID, _updateSql));
}
if (includedProps > 0)
{
_statements.Add(_updateSql);
}
}
