/// <summary>
/// Function to Load the relation Category from database.
/// </summary>
/// <param name="storeCategory">StoreCategoryEntity parent</param>
/// <exception cref="ArgumentNullException">
/// if <paramref name="storeCategory"/> is not a <c>StoreCategoryEntity</c>.
/// </exception>
public void LoadRelationCategory(StoreCategoryEntity storeCategory, Dictionary <string, IEntity> scope)
{
if (storeCategory == null)
{
throw new ArgumentException("The argument can't be null");
}
bool closeConnection = false;
try
{
// Create a new connection if needed
if (dbConnection == null || dbConnection.State.CompareTo(ConnectionState.Closed) == 0)
{
closeConnection = true;
dbConnection = dataAccess.GetNewConnection();
dbConnection.Open();
}
// Create a command
string cmdText = "SELECT idCategory FROM [StoreCategory] WHERE idStoreCategory = @idStoreCategory";
IDbCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction);
IDbDataParameter parameter = dataAccess.GetNewDataParameter("@idStoreCategory", DbType.Int32);
// Set command parameters values
parameter.Value = storeCategory.Id;
sqlCommand.Parameters.Add(parameter);
// Execute commands
object idRelation = sqlCommand.ExecuteScalar();
if (idRelation != null && ((int)idRelation) > 0)
{
// Create data access objects and set connection objects
CategoryDataAccess categoryDataAccess = new CategoryDataAccess();
categoryDataAccess.SetConnectionObjects(dbConnection, dbTransaction);
// Load related object
storeCategory.Category = categoryDataAccess.Load(((int)idRelation), true, scope);
}
}
catch (DbException dbException)
{
// Catch and rethrow as custom exception
throw new UtnEmallDataAccessException(dbException.Message, dbException);
}
finally
{
// Close connection if initiated by me
if (closeConnection)
{
dbConnection.Close();
}
}
}
/// <summary>
/// Function to Delete a list of related entities from database.
/// </summary>
/// <param name="collectionDataAccess">IDataAccess of the relation</param>
/// <param name="collection">The collection of entities to delete</param>
/// <param name="scope">Internal structure to keep safe circular referencies</param>
/// <returns>True if collection not null</returns>
private bool DeleteCategoryCollection(CategoryDataAccess collectionDataAccess, Collection <CategoryEntity> collection, Dictionary <string, IEntity> scope)
{
if (collection == null)
{
return(false);
}
// Set connection objects of related data access object
collectionDataAccess.SetConnectionObjects(dbConnection, dbTransaction);
// Delete related objects
for (int i = 0; i < collection.Count; i++)
{
collectionDataAccess.Delete(collection[i], scope);
}
return(true);
}
/// <summary>
/// Function to Load the relation Childs from database.
/// </summary>
/// <param name="category">CategoryEntity parent</param>
/// <param name="scope">Internal structure to avoid problems with circular referencies</param>
/// <exception cref="ArgumentNullException">
/// if <paramref name="category"/> is not a <c>CategoryEntity</c>.
/// </exception>
public void LoadRelationChilds(CategoryEntity category, Dictionary <string, IEntity> scope)
{
if (category == null)
{
throw new ArgumentException("The argument can't be null");
}
// Create data access object for related object
CategoryDataAccess categoryDataAccess = new CategoryDataAccess();
// Set connection objects to the data access
categoryDataAccess.SetConnectionObjects(dbConnection, dbTransaction);
// Load related objects
category.Childs = categoryDataAccess.LoadByCategoryCollection(category.Id, scope);
}
/// <summary>
/// Updates the database to reflect the current state of the list.
/// </summary>
/// <param name="collectionDataAccess">the IDataAccess of the relation</param>
/// <param name="parent">the parent of the object</param>
/// <param name="collection">a collection of items</param>
/// <param name="isNewParent">if the parent is a new object</param>
/// <param name="scope">internal data structure to aviod problems with circular referencies on entities</param>
/// <exception cref="UtnEmallDataAccessException">
/// If an DbException occurs in the try block while accessing the database.
/// </exception>
private void SaveCategoryCollection(CategoryDataAccess collectionDataAccess, CategoryEntity parent, Collection <CategoryEntity> collection, bool isNewParent, Dictionary <string, IEntity> scope)
{
if (collection == null)
{
return;
}
// Set connection objects on collection data access
collectionDataAccess.SetConnectionObjects(dbConnection, dbTransaction);
// Set the child/parent relation
for (int i = 0; i < collection.Count; i++)
{
bool changed = collection[i].Changed;
collection[i].ParentCategory = parent;
collection[i].Changed = changed;
}
// If the parent is new save all childs, else check diferencies with db
if (isNewParent)
{
for (int i = 0; i < collection.Count; i++)
{
collectionDataAccess.Save(collection[i], scope);
}
}
else
{
// Check the childs that are not part of the parent any more
string idList = "0";
if (collection.Count > 0)
{
idList = "" + collection[0].Id;
}
for (int i = 1; i < collection.Count; i++)
{
idList += ", " + collection[i].Id;
}
// Returns the ids that doesn't exists in the current collection
string command = "SELECT idCategory FROM [Category] WHERE idParentCategory = @idParentCategory AND idCategory NOT IN (" + idList + ")";
IDbCommand sqlCommand = dataAccess.GetNewCommand(command, dbConnection, dbTransaction);
IDbDataParameter sqlParameterId = dataAccess.GetNewDataParameter("@idParentCategory", DbType.Int32);
sqlParameterId.Value = parent.Id;
sqlCommand.Parameters.Add(sqlParameterId);
IDataReader reader = sqlCommand.ExecuteReader();
Collection <CategoryEntity> objectsToDelete = new Collection <CategoryEntity>();
// Insert Ids on a list
List <int> listId = new List <int>();
while (reader.Read())
{
listId.Add(reader.GetInt32(0));
}
reader.Close();
// Load items to be removed
foreach (int id in listId)
{
CategoryEntity entityToDelete = collectionDataAccess.Load(id, scope);
objectsToDelete.Add(entityToDelete);
}
// Have to do this because the reader must be closed before
// deletion of entities
for (int i = 0; i < objectsToDelete.Count; i++)
{
collectionDataAccess.Delete(objectsToDelete[i], scope);
}
System.DateTime timestamp;
// Check all the properties of the collection items
// to see if they have changed (timestamp)
for (int i = 0; i < collection.Count; i++)
{
CategoryEntity item = collection[i];
if (!item.Changed && !item.IsNew)
{
// Create the command
string sql = "SELECT timestamp FROM [Category] WHERE idCategory = @idCategory";
IDbCommand sqlCommandTimestamp = dataAccess.GetNewCommand(sql, dbConnection, dbTransaction);
// Set the command's parameters values
IDbDataParameter sqlParameterIdPreference = dataAccess.GetNewDataParameter("@idCategory", DbType.Int32);
sqlParameterIdPreference.Value = item.Id;
sqlCommandTimestamp.Parameters.Add(sqlParameterIdPreference);
timestamp = ((System.DateTime)sqlCommandTimestamp.ExecuteScalar());
if (item.Timestamp != timestamp)
{
item.Changed = true;
}
}
// Save the item if it changed or is new
if (item.Changed || item.IsNew)
{
collectionDataAccess.Save(item);
}
}
}
}