コード例 #1
0
        /// <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();
                }
            }
        }
コード例 #2
0
        /// <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);
        }
コード例 #3
0
        /// <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);
        }
コード例 #4
0
        /// <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);
                    }
                }
            }
        }