Exemple #1
0
        /// <summary>
        /// Función que carga la relacion ParentCategory desde la base de datos
        /// </summary>
        /// <param name="category">Padre: CategoryEntity</param>
        /// <exception cref="ArgumentNullException">
        /// Si <paramref name="category"/> no es un <c>CategoryEntity</c>.
        /// </exception>
        public void LoadRelationParentCategory(CategoryEntity category, Dictionary <string, IEntity> scope)
        {
            if (category == null)
            {
                throw new ArgumentException("The argument can't be null");
            }
            bool closeConnection = false;

            try
            {
                // Crea una nueva conexión si es necesario
                if (dbConnection == null || dbConnection.State.CompareTo(ConnectionState.Closed) == 0)
                {
                    closeConnection = true;
                    dbConnection    = dataAccess.GetNewConnection();
                    dbConnection.Open();
                }
                // Crea un nuevo command

                string         cmdText    = "SELECT idParentCategory FROM [Category] WHERE idCategory = @idCategory";
                SqlCeCommand   sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction);
                SqlCeParameter parameter  = dataAccess.GetNewDataParameter("@idCategory", DbType.Int32);
                // Establece los valores a los parametros del command

                parameter.Value = category.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);
                    // Carga los objetos relacionados

                    category.ParentCategory = categoryDataAccess.Load(((int)idRelation), true, scope);
                }
            }
            catch (DbException dbException)
            {
                // Relanza una excepcion personalizada
                throw new UtnEmallDataAccessException(dbException.Message, dbException);
            }
            finally
            {
                // Cierra la conexión si fue inicializada
                if (closeConnection)
                {
                    dbConnection.Close();
                }
            }
        }
Exemple #2
0
        /// <summary>
        /// Función para eliminar una lista de entidades relacionadas desde la base de datos
        /// </summary>
        /// <param name="collectionDataAccess">IDataAccess de la relacion</param>
        /// <param name="collection">La colección de entidades a eliminar</param>
        /// <param name="scope">Estructura interna para evitar problemas de referencia circular</param>
        /// <returns>True si la colección no es nula</returns>
        private bool DeleteCategoryCollection(CategoryDataAccess collectionDataAccess, Collection <CategoryEntity> collection, Dictionary <string, IEntity> scope)
        {
            if (collection == null)
            {
                return(false);
            }
            // Establece los objetos de conexión al data access de la relación.
            collectionDataAccess.SetConnectionObjects(dbConnection, dbTransaction);
            // Elimina los objetos relacionados

            for (int i = 0; i < collection.Count; i++)
            {
                collectionDataAccess.Delete(collection[i], scope);
            }
            return(true);
        }
Exemple #3
0
        /// <summary>
        /// Función que carga la relacion Childs desde la base de datos
        /// </summary>
        /// <param name="category">Entidad padre CategoryEntity</param>
        /// <param name="scope">Estructura de datos interna para evitar los problemas de referencia circular</param>
        /// <exception cref="ArgumentNullException">
        /// Si <paramref name="category"/> no es un <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");
            }
            // Crea un objeto data access para los objetos relacionados
            CategoryDataAccess categoryDataAccess = new CategoryDataAccess();

            // Establece los objetos de la conexión al data access de la relacion

            categoryDataAccess.SetConnectionObjects(dbConnection, dbTransaction);
            // Carga los objetos relacionadoss

            category.Childs = categoryDataAccess.LoadByCategoryCollection(category.Id, scope);
        }
Exemple #4
0
        /// <summary>
        /// Actualiza la base de datos para reflejar el estado actual de la lista.
        /// </summary>
        /// <param name="collectionDataAccess">El IDataAccess de la relación</param>
        /// <param name="parent">El objeto padre</param>
        /// <param name="collection">una colección de items</param>
        /// <param name="isNewParent">Si el padre es un objeto nuevo</param>
        /// <param name="scope">Estructura de datos interna para evitar problemas de referencia circular</param>
        /// <exception cref="UtnEmallDataAccessException">
        /// Si una DbException ocurre cuando se accede a la base de datos
        /// </exception>
        private void SaveCategoryCollection(CategoryDataAccess collectionDataAccess, CategoryEntity parent, Collection <CategoryEntity> collection, bool isNewParent, Dictionary <string, IEntity> scope)
        {
            if (collection == null)
            {
                return;
            }
            // Establece los objetos de conexión
            collectionDataAccess.SetConnectionObjects(dbConnection, dbTransaction);
            // Establece la relación padre/hijo

            for (int i = 0; i < collection.Count; i++)
            {
                bool changed = collection[i].Changed;
                collection[i].ParentCategory = parent;
                collection[i].Changed        = changed;
            }
            // Si el padre es nuevo guarda todos los hijos, sino controla las diferencias con la base de datos.

            if (isNewParent)
            {
                for (int i = 0; i < collection.Count; i++)
                {
                    collectionDataAccess.Save(collection[i], scope);
                }
            }
            else
            {
                // Controla los hijos que ya no son parte de la relación
                string idList = "0";
                if (collection.Count > 0)
                {
                    idList = "" + collection[0].Id;
                }

                for (int i = 1; i < collection.Count; i++)
                {
                    idList += ", " + collection[i].Id;
                }
                // Retorna los ids que ya no existe en la colección actual

                string command = "SELECT idCategory FROM [Category] WHERE idParentCategory = @idParentCategory AND idCategory NOT IN (" + idList + ")";

                SqlCeCommand sqlCommand = dataAccess.GetNewCommand(command, dbConnection, dbTransaction);

                SqlCeParameter sqlParameterId = dataAccess.GetNewDataParameter("@idParentCategory", DbType.Int32);
                sqlParameterId.Value = parent.Id;
                sqlCommand.Parameters.Add(sqlParameterId);

                IDataReader reader = sqlCommand.ExecuteReader();
                Collection <CategoryEntity> objectsToDelete = new Collection <CategoryEntity>();
                // Inserta los id en una lista

                List <int> listId = new List <int>();
                while (reader.Read())
                {
                    listId.Add(reader.GetInt32(0));
                }

                reader.Close();
                // Carga los items a ser eliminados

                foreach (int id in listId)
                {
                    CategoryEntity entityToDelete = collectionDataAccess.Load(id, scope);
                    objectsToDelete.Add(entityToDelete);
                }
                // Esto se realiza porque el reader debe ser cerrado despues de eliminar las entidades

                for (int i = 0; i < objectsToDelete.Count; i++)
                {
                    collectionDataAccess.Delete(objectsToDelete[i], scope);
                }

                System.DateTime timestamp;
                // Controla todas las propiedades de los items de la colección
                // para verificar si alguno cambio

                for (int i = 0; i < collection.Count; i++)
                {
                    CategoryEntity item = collection[i];
                    if (!item.Changed && !item.IsNew)
                    {
                        // Crea el command
                        string       sql = "SELECT timestamp FROM [Category] WHERE idCategory = @idCategory";
                        SqlCeCommand sqlCommandTimestamp = dataAccess.GetNewCommand(sql, dbConnection, dbTransaction);
                        // Establece los datos a los parametros del command

                        SqlCeParameter 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;
                        }
                    }
                    // Guarda el item si cambio o es nuevo

                    if (item.Changed || item.IsNew)
                    {
                        collectionDataAccess.Save(item);
                    }
                }
            }
        }
Exemple #5
0
        /// <summary>
        /// Función que guarda un PreferenceEntity en la base de datos.
        /// </summary>
        /// <param name="preference">PreferenceEntity a guardar</param>
        /// <param name="scope">Estructura interna para evitar problemas con referencias circulares</param>
        /// <exception cref="ArgumentNullException">
        /// Si <paramref name="preference"/> no es un <c>PreferenceEntity</c>.
        /// </exception>
        /// <exception cref="UtnEmallDataAccessException">
        /// Si una DbException ocurre cuando se accede a la base de datos
        /// </exception>
        public void Save(PreferenceEntity preference, Dictionary <string, IEntity> scope)
        {
            if (preference == null)
            {
                throw new ArgumentException("The argument can't be null");
            }
            // Crear una clave unica para identificar el objeto dentro del scope interno
            string scopeKey = preference.Id.ToString(NumberFormatInfo.InvariantInfo) + "Preference";

            if (scope != null)
            {
                // Si se encuentra dentro del scope lo retornamos
                if (scope.ContainsKey(scopeKey))
                {
                    return;
                }
            }
            else
            {
                // Crea un nuevo scope si este no fue enviado
                scope = new Dictionary <string, IEntity>();
            }

            try
            {
                // Crea una nueva conexion y una nueva transaccion si no hay una a nivel superior
                if (!isGlobalTransaction)
                {
                    dbConnection = dataAccess.GetNewConnection();
                    dbConnection.Open();
                    dbTransaction = dbConnection.BeginTransaction();
                }

                string commandName = "";
                bool   isUpdate    = false;
                // Verifica si se debe hacer una actualización o una inserción

                if (preference.IsNew || !DataAccessConnection.ExistsEntity(preference.Id, "Preference", "idPreference", dbConnection, dbTransaction))
                {
                    commandName = "INSERT INTO [Preference] (idPreference, ACTIVE, LEVEL, IDCUSTOMER, IDCATEGORY, [TIMESTAMP] ) VALUES( @idPreference,  @active,@level,@idCustomer,@idCategory, GETDATE()); ";
                }
                else
                {
                    isUpdate    = true;
                    commandName = "UPDATE [Preference] SET active = @active, level = @level, idCustomer = @idCustomer, idCategory = @idCategory , timestamp=GETDATE() WHERE idPreference = @idPreference";
                }
                // Se crea un command
                SqlCeCommand sqlCommand = dataAccess.GetNewCommand(commandName, dbConnection, dbTransaction);
                // Agregar los parametros del command .
                SqlCeParameter parameter;
                if (!isUpdate && preference.Id == 0)
                {
                    preference.Id = DataAccessConnection.GetNextId("idPreference", "Preference", dbConnection, dbTransaction);
                }

                parameter       = dataAccess.GetNewDataParameter("@idPreference", DbType.Int32);
                parameter.Value = preference.Id;
                sqlCommand.Parameters.Add(parameter);

                FillSaveParameters(preference, sqlCommand);
                // Ejecutar el command
                sqlCommand.ExecuteNonQuery();

                scopeKey = preference.Id.ToString(NumberFormatInfo.InvariantInfo) + "Preference";
                // Agregar la entidad al scope actual

                scope.Add(scopeKey, preference);
                // Guarda las colecciones de objetos relacionados.
                // Guardar objetos relacionados con la entidad actual
                if (preference.Category != null)
                {
                    CategoryDataAccess categoryDataAccess = new CategoryDataAccess();
                    categoryDataAccess.SetConnectionObjects(dbConnection, dbTransaction);
                    categoryDataAccess.Save(preference.Category, scope);
                }
                // Actualizar
                Update(preference);
                // Cierra la conexión si fue abierta en la función

                if (!isGlobalTransaction)
                {
                    dbTransaction.Commit();
                }
                // Actualizar los campos new y changed

                preference.IsNew   = false;
                preference.Changed = false;
            }
            catch (DbException dbException)
            {
                // Anula la transaccion
                if (!isGlobalTransaction)
                {
                    dbTransaction.Rollback();
                }
                // Relanza una excepcion personalizada
                throw new UtnEmallDataAccessException(dbException.Message, dbException);
            }
            finally
            {
                // Cierra la conexión si fue inicializada
                if (!isGlobalTransaction)
                {
                    dbConnection.Close();
                    dbConnection  = null;
                    dbTransaction = null;
                }
            }
        }