public UserActionClientDataEntity Save(UserActionClientDataEntity userActionClientDataEntity, string session) { try { UserActionClientDataEntity result; // if we are connected if (Connection.IsConnected) { CheckIsSynchronized(); result = Remote.Save(userActionClientDataEntity, session); } else { result = Local.Save(userActionClientDataEntity); } return(result); } catch (UtnEmallDataAccessException dataAccessError) { throw new UtnEmallSmartLayerException(dataAccessError.Message, dataAccessError); } catch (UtnEmallBusinessLogicException businessLogicError) { throw new UtnEmallSmartLayerException(businessLogicError.Message, businessLogicError); } catch (CommunicationException communicationError) { throw new UtnEmallSmartLayerException(communicationError.Message, communicationError); } }
private void FillSaveParameters(UserActionClientDataEntity userActionClientData, IDbCommand sqlCommand) { IDbDataParameter parameter; parameter = dataAccess.GetNewDataParameter("@actionType", DbType.Int32); parameter.Value = userActionClientData.ActionType; sqlCommand.Parameters.Add(parameter); parameter = dataAccess.GetNewDataParameter("@start", DbType.DateTime); parameter.Value = userActionClientData.Start; sqlCommand.Parameters.Add(parameter); parameter = dataAccess.GetNewDataParameter("@stop", DbType.DateTime); parameter.Value = userActionClientData.Stop; sqlCommand.Parameters.Add(parameter); parameter = dataAccess.GetNewDataParameter("@idTable", DbType.Int32); parameter.Value = userActionClientData.IdTable; sqlCommand.Parameters.Add(parameter); parameter = dataAccess.GetNewDataParameter("@idRegister", DbType.Int32); parameter.Value = userActionClientData.IdRegister; sqlCommand.Parameters.Add(parameter); parameter = dataAccess.GetNewDataParameter("@idComponent", DbType.Int32); parameter.Value = userActionClientData.IdComponent; sqlCommand.Parameters.Add(parameter); parameter = dataAccess.GetNewDataParameter("@idService", DbType.Int32); parameter.Value = userActionClientData.IdService; sqlCommand.Parameters.Add(parameter); }
/// <summary> /// Function to delete a UserActionClientDataEntity from database. /// </summary> /// <param name="userActionClientDataEntity">UserActionClientDataEntity to delete</param> /// <param name="session">User's session identifier.</param> /// <returns>null if the UserActionClientDataEntity was deleted successfully, the same UserActionClientDataEntity otherwise</returns> /// <exception cref="ArgumentNullException"> /// if <paramref name="userActionClientDataEntity"/> is null. /// </exception> /// <exception cref="UtnEmallBusinessLogicException"> /// If an UtnEmallDataAccessException occurs in DataModel. /// </exception> public UserActionClientDataEntity Delete(UserActionClientDataEntity userActionClientDataEntity, string session) { bool permited = ValidationService.Instance.ValidatePermission(session, "delete", "UserActionClientData"); if (!permited) { ExceptionDetail detail = new ExceptionDetail(new UtnEmall.Server.BusinessLogic.UtnEmallPermissionException("The user hasn't permissions to delete an entity")); throw new FaultException <ExceptionDetail>(detail); } if (userActionClientDataEntity == null) { throw new ArgumentException("The argument can not be null or be empty"); } try { // Delete userActionClientDataEntity using data access object useractionclientdataDataAccess.Delete(userActionClientDataEntity); return(null); } catch (UtnEmallDataAccessException utnEmallDataAccessException) { throw new UtnEmall.Server.BusinessLogic.UtnEmallBusinessLogicException(utnEmallDataAccessException.Message, utnEmallDataAccessException); } }
private static bool TransformAndSave(UserActionClientDataEntity userActionClientData, string sessionId) { UserAction businessUAClient = new UserAction(); UserActionEntity action = new UserActionEntity(); action.ActionType = userActionClientData.ActionType; action.Customer = SessionManager.Instance.GetCustomerFromSession(sessionId); action.IdComponent = userActionClientData.IdComponent; action.IdRegister = userActionClientData.IdRegister; action.IdService = userActionClientData.IdService; action.IdTable = userActionClientData.IdTable; action.Start = userActionClientData.Start; action.Stop = userActionClientData.Stop; action.Timestamp = userActionClientData.Timestamp; return(businessUAClient.Save(action, sessionId) == null); }
/// <summary> /// Función para eliminar un UserActionClientDataEntity de la base de datos. /// </summary> /// <param name="userActionClientDataEntity">UserActionClientDataEntity a eliminar</param> /// <param name="session">Identificador de sesión.</param> /// <returns>null si el UserActionClientDataEntity fue eliminado con éxito, el mismo UserActionClientDataEntity en otro caso</returns> /// <exception cref="ArgumentNullException"> /// Si <paramref name="userActionClientDataEntity"/> is null. /// </exception> /// <exception cref="UtnEmallBusinessLogicException"> /// Si una excepción UtnEmallDataAccessException ocurre en el data model. /// </exception> public UserActionClientDataEntity Delete(UserActionClientDataEntity userActionClientDataEntity) { if (userActionClientDataEntity == null) { throw new ArgumentException("The argument can't be null", "userActionClientDataEntity"); } try { // Elimina un userActionClientDataEntity usando un objeto data access useractionclientdataDataAccess.Delete(userActionClientDataEntity); return(null); } catch (UtnEmallDataAccessException utnEmallDataAccessException) { throw new UtnEmallBusinessLogicException(utnEmallDataAccessException.Message, utnEmallDataAccessException); } }
/// <summary> /// Función para guardar UserActionClientDataEntity en la base de datos. /// </summary> /// <param name="userActionClientDataEntity">UserActionClientDataEntity a guardar</param> /// <param name="session">Identificador de sesion del usuario.</param> /// <returns>null si el UserActionClientDataEntity se guardo con exito, el mismo UserActionClientDataEntity en otro caso</returns> /// <exception cref="ArgumentNullException"> /// if <paramref name="userActionClientDataEntity"/> is null. /// </exception> /// <exception cref="UtnEmallBusinessLogicException"> /// Si una excepción UtnEmallDataAccessException ocurre en el data model. /// </exception> public UserActionClientDataEntity Save(UserActionClientDataEntity userActionClientDataEntity) { if (userActionClientDataEntity == null) { throw new ArgumentException("The entity can't be null", "userActionClientDataEntity"); } // Valida el UserActionClientDataEntity if (!Validate(userActionClientDataEntity)) { return(userActionClientDataEntity); } try { // Guarda un userActionClientDataEntity usando un objeto de data access useractionclientdataDataAccess.Save(userActionClientDataEntity); return(null); } catch (UtnEmallDataAccessException utnEmallDataAccessException) { // Reenvía como una excepcion personalizada throw new UtnEmallBusinessLogicException(utnEmallDataAccessException.Message, utnEmallDataAccessException); } }
/// <summary> /// Function to load a UserActionClientDataEntity from database. /// </summary> /// <param name="id">The ID of the record to load</param> /// <param name="loadRelation">if is true load the relation</param> /// <param name="scope">Internal structure used to avoid circular reference locks, must be provided if calling from other data access object</param> /// <returns>The entity instance</returns> /// <exception cref="UtnEmallDataAccessException"> /// If a DbException occurs while accessing the database. /// </exception> public UserActionClientDataEntity Load(int id, bool loadRelation, Dictionary <string, IEntity> scope) { // Build a key for internal scope object string scopeKey = id.ToString(NumberFormatInfo.InvariantInfo) + "UserActionClientData"; if (scope != null) { // If scope contains the object it was already loaded, // return it to avoid circular references if (scope.ContainsKey(scopeKey)) { return((UserActionClientDataEntity)scope[scopeKey]); } } else { // If there isn't a current scope create one scope = new Dictionary <string, IEntity>(); } UserActionClientDataEntity userActionClientData = null; // Check if the entity was already loaded by current data access object // and return it if that is the case if (inMemoryEntities.ContainsKey(id)) { userActionClientData = inMemoryEntities[id]; // Add current object to current load scope scope.Add(scopeKey, userActionClientData); } else { bool closeConnection = false; try { // Open a new connection if it isn't on a transaction if (dbConnection == null || dbConnection.State.CompareTo(ConnectionState.Closed) == 0) { closeConnection = true; dbConnection = dataAccess.GetNewConnection(); dbConnection.Open(); } string cmdText = "SELECT idUserActionClientData, actionType, start, stop, idTable, idRegister, idComponent, idService, timestamp FROM [UserActionClientData] WHERE idUserActionClientData = @idUserActionClientData"; // Create the command IDbCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); // Create the Id parameter for the query IDbDataParameter parameter = dataAccess.GetNewDataParameter("@idUserActionClientData", DbType.Int32); parameter.Value = id; sqlCommand.Parameters.Add(parameter); // Use a DataReader to get data from db IDataReader reader = sqlCommand.ExecuteReader(); userActionClientData = new UserActionClientDataEntity(); if (reader.Read()) { // Load fields of entity userActionClientData.Id = reader.GetInt32(0); userActionClientData.ActionType = reader.GetInt32(1); userActionClientData.Start = reader.GetDateTime(2); userActionClientData.Stop = reader.GetDateTime(3); userActionClientData.IdTable = reader.GetInt32(4); userActionClientData.IdRegister = reader.GetInt32(5); userActionClientData.IdComponent = reader.GetInt32(6); userActionClientData.IdService = reader.GetInt32(7); // Add current object to the scope scope.Add(scopeKey, userActionClientData); // Add current object to cache of loaded entities inMemoryEntities.Add(userActionClientData.Id, userActionClientData); // Read the timestamp and set new and changed properties userActionClientData.Timestamp = reader.GetDateTime(8); userActionClientData.IsNew = false; userActionClientData.Changed = false; // Close the reader reader.Close(); // Load related objects if required if (loadRelation) { } } else { reader.Close(); } } catch (DbException dbException) { // Catch DBException and rethrow as custom exception throw new UtnEmallDataAccessException(dbException.Message, dbException); } finally { // Close connection if it was opened by ourself if (closeConnection) { dbConnection.Close(); } } } // Return the loaded entity return(userActionClientData); }
/// <summary> /// Function to Delete a UserActionClientDataEntity from database. /// </summary> /// <param name="userActionClientData">UserActionClientDataEntity to delete</param> /// <param name="scope">Internal structure to avoid circular reference locks. Must provide an instance while calling from other data access object.</param> /// <exception cref="ArgumentNullException"> /// If <paramref name="userActionClientData"/> is not a <c>UserActionClientDataEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Delete(UserActionClientDataEntity userActionClientData, Dictionary <string, IEntity> scope) { if (userActionClientData == null) { throw new ArgumentException("The argument can't be null"); } try { // Open connection and initialize a transaction if needed if (!isGlobalTransaction) { dbConnection = dataAccess.GetNewConnection(); dbConnection.Open(); dbTransaction = dbConnection.BeginTransaction(); } // Reload the entity to ensure deletion of older data userActionClientData = this.Load(userActionClientData.Id, true); if (userActionClientData == null) { throw new UtnEmallDataAccessException("Error retrieving data while trying to delete."); } // Create a command for delete string cmdText = "DeleteUserActionClientData"; IDbCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); sqlCommand.CommandType = CommandType.StoredProcedure; // Add values to parameters IDbDataParameter parameterID = dataAccess.GetNewDataParameter("@idUserActionClientData", DbType.Int32); parameterID.Value = userActionClientData.Id; sqlCommand.Parameters.Add(parameterID); // Execute the command sqlCommand.ExecuteNonQuery(); // Delete related objects // Commit transaction if is mine if (!isGlobalTransaction) { dbTransaction.Commit(); } // Remove entity from loaded objects inMemoryEntities.Remove(userActionClientData.Id); // Remove entity from current internal scope if (scope != null) { string scopeKey = userActionClientData.Id.ToString(NumberFormatInfo.InvariantInfo) + "UserActionClientData"; scope.Remove(scopeKey); } } catch (DbException dbException) { // Rollback transaction if (!isGlobalTransaction) { dbTransaction.Rollback(); } // Rethrow as custom exception throw new UtnEmallDataAccessException(dbException.Message, dbException); } finally { // Close connection if it was initiated by this instance if (!isGlobalTransaction) { dbConnection.Close(); dbConnection = null; dbTransaction = null; } } }
/// <summary> /// Function to Delete a UserActionClientDataEntity from database. /// </summary> /// <param name="userActionClientData">UserActionClientDataEntity to delete</param> /// <exception cref="ArgumentNullException"> /// If <paramref name="userActionClientData"/> is not a <c>UserActionClientDataEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Delete(UserActionClientDataEntity userActionClientData) { Delete(userActionClientData, null); }
/// <summary> /// Function to Save a UserActionClientDataEntity in the database. /// </summary> /// <param name="userActionClientData">UserActionClientDataEntity to save</param> /// <param name="scope">Interna structure to avoid circular reference locks. Provide an instance when calling from other data access object.</param> /// <exception cref="ArgumentNullException"> /// If <paramref name="userActionClientData"/> is not a <c>UserActionClientDataEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Save(UserActionClientDataEntity userActionClientData, Dictionary <string, IEntity> scope) { if (userActionClientData == null) { throw new ArgumentException("The argument can't be null"); } // Create a unique key to identify the object in the internal scope string scopeKey = userActionClientData.Id.ToString(NumberFormatInfo.InvariantInfo) + "UserActionClientData"; if (scope != null) { // If it's on the scope return it, don't save again if (scope.ContainsKey(scopeKey)) { return; } } else { // Create a new scope if it's not provided scope = new Dictionary <string, IEntity>(); } try { // Open a DbConnection and a new transaction if it isn't on a higher level one if (!isGlobalTransaction) { dbConnection = dataAccess.GetNewConnection(); dbConnection.Open(); dbTransaction = dbConnection.BeginTransaction(); } string commandName = ""; bool isUpdate = false; // Check if it is an insert or update command if (userActionClientData.IsNew || !DataAccessConnection.ExistsEntity(userActionClientData.Id, "UserActionClientData", "idUserActionClientData", dbConnection, dbTransaction)) { commandName = "SaveUserActionClientData"; } else { isUpdate = true; commandName = "UpdateUserActionClientData"; } // Create a db command IDbCommand sqlCommand = dataAccess.GetNewCommand(commandName, dbConnection, dbTransaction); sqlCommand.CommandType = CommandType.StoredProcedure; // Add parameters values to current command IDbDataParameter parameter; if (isUpdate) { parameter = dataAccess.GetNewDataParameter("@idUserActionClientData", DbType.Int32); parameter.Value = userActionClientData.Id; sqlCommand.Parameters.Add(parameter); } FillSaveParameters(userActionClientData, sqlCommand); // Execute the command if (isUpdate) { sqlCommand.ExecuteNonQuery(); } else { IDbDataParameter parameterIdOutput = dataAccess.GetNewDataParameter("@idUserActionClientData", DbType.Int32); parameterIdOutput.Direction = ParameterDirection.ReturnValue; sqlCommand.Parameters.Add(parameterIdOutput); sqlCommand.ExecuteNonQuery(); userActionClientData.Id = Convert.ToInt32(parameterIdOutput.Value, NumberFormatInfo.InvariantInfo); } scopeKey = userActionClientData.Id.ToString(NumberFormatInfo.InvariantInfo) + "UserActionClientData"; // Add entity to current internal scope scope.Add(scopeKey, userActionClientData); // Save collections of related objects to current entity // Save objects related to current entity // Update // Close transaction if initiated by me if (!isGlobalTransaction) { dbTransaction.Commit(); } // Update new and changed flags userActionClientData.IsNew = false; userActionClientData.Changed = false; } catch (DbException dbException) { // Rollback transaction if (!isGlobalTransaction) { dbTransaction.Rollback(); } // Rethrow as custom exception throw new UtnEmallDataAccessException(dbException.Message, dbException); } finally { // Close connection if initiated by me if (!isGlobalTransaction) { dbConnection.Close(); dbConnection = null; dbTransaction = null; } } }
/// <summary> /// Function to Save a UserActionClientDataEntity in the database. /// </summary> /// <param name="userActionClientData">UserActionClientDataEntity to save</param> /// <exception cref="ArgumentNullException"> /// if <paramref name="userActionClientData"/> is not a <c>UserActionClientDataEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Save(UserActionClientDataEntity userActionClientData) { Save(userActionClientData, null); }
public bool Validate(UserActionClientDataEntity userActionClientData) { bool result = true; if (userActionClientData == null) { throw new ArgumentException("The argument can't be null"); } // Check entity data if (userActionClientData.ActionType < 0) { userActionClientData.Errors.Add(new Error("ActionType", "ActionType", "El tipo de acción no puede ser negativo")); result = false; } if (userActionClientData.Start > System.DateTime.Now) { userActionClientData.Errors.Add(new Error("Start", "Start", "La fecha de inicio no puede ser mayor a la fecha actual")); result = false; } if (userActionClientData.Start == null) { userActionClientData.Errors.Add(new Error("Start", "Start", "La fecha de inicio no puede ser nula")); result = false; } if (userActionClientData.Stop > System.DateTime.Now) { userActionClientData.Errors.Add(new Error("Stop", "Stop", "La fecha de finalización no puede ser mayor a la fecha actual")); result = false; } if (userActionClientData.Stop < userActionClientData.Start) { userActionClientData.Errors.Add(new Error("Stop", "Stop", "La fecha de finalización no puede ser menor a la fecha de inicio")); result = false; } if (userActionClientData.Stop == null) { userActionClientData.Errors.Add(new Error("Stop", "Stop", "La fecha de finalización no puede ser nula")); result = false; } if (userActionClientData.IdTable < 0) { userActionClientData.Errors.Add(new Error("IdTable", "IdTable", "El id de tabla no puede ser negativo")); result = false; } if (userActionClientData.IdRegister < 0) { userActionClientData.Errors.Add(new Error("IdRegister", "IdRegister", "El id de registro no puede ser negativo")); result = false; } if (userActionClientData.IdComponent < 0) { userActionClientData.Errors.Add(new Error("IdComponent", "IdComponent", "El id de componente no puede ser negativo")); result = false; } if (userActionClientData.IdService < 0) { userActionClientData.Errors.Add(new Error("IdService", "IdService", "El id de servicio no puede ser negativo")); result = false; } return(result); }
/// <summary> /// Función para cargar un UserActionClientDataEntity desde la base de datos. /// </summary> /// <param name="id">El id del registro a cargar</param> /// <param name="loadRelation">Si es true carga las relaciones</param> /// <param name="scope">Estructura interna usada para evitar la referencia circular, debe ser proveida si es llamada desde otro data access</param> /// <returns>La instancia de la entidad</returns> /// <exception cref="UtnEmallDataAccessException"> /// Si una DbException ocurre mientras se accede a la base de datos /// </exception> public UserActionClientDataEntity Load(int id, bool loadRelation, Dictionary <string, IEntity> scope) { // Crea una clave para el objeto de scope interno string scopeKey = id.ToString(NumberFormatInfo.InvariantInfo) + "UserActionClientData"; if (scope != null) { // Si el scope contiene el objeto, este ya fue cargado // retorna el objeto situado en el scope para evitar referencias circulares if (scope.ContainsKey(scopeKey)) { return((UserActionClientDataEntity)scope[scopeKey]); } } else { // Si no existe un scope, crear uno scope = new Dictionary <string, IEntity>(); } UserActionClientDataEntity userActionClientData = null; // Chequear si la entidad fue ya cargada por el data access actual // y retornar si fue ya cargada if (inMemoryEntities.ContainsKey(id)) { userActionClientData = inMemoryEntities[id]; // Agregar el objeto actual al scope scope.Add(scopeKey, userActionClientData); } else { bool closeConnection = false; try { // Abrir una nueva conexión si no es una transaccion if (dbConnection == null || dbConnection.State.CompareTo(ConnectionState.Closed) == 0) { closeConnection = true; dbConnection = dataAccess.GetNewConnection(); dbConnection.Open(); } string cmdText = "SELECT idUserActionClientData, actionType, start, stop, idTable, idRegister, idComponent, idService, timestamp FROM [UserActionClientData] WHERE idUserActionClientData = @idUserActionClientData"; // Crea el command SqlCeCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); // Crear el parametro id para la consulta SqlCeParameter parameter = dataAccess.GetNewDataParameter("@idUserActionClientData", DbType.Int32); parameter.Value = id; sqlCommand.Parameters.Add(parameter); // Usar el datareader para cargar desde la base de datos IDataReader reader = sqlCommand.ExecuteReader(); userActionClientData = new UserActionClientDataEntity(); if (reader.Read()) { // Cargar las filas de la entidad userActionClientData.Id = reader.GetInt32(0); userActionClientData.ActionType = reader.GetInt32(1); userActionClientData.Start = reader.GetDateTime(2); userActionClientData.Stop = reader.GetDateTime(3); userActionClientData.IdTable = reader.GetInt32(4); userActionClientData.IdRegister = reader.GetInt32(5); userActionClientData.IdComponent = reader.GetInt32(6); userActionClientData.IdService = reader.GetInt32(7); // Agregar el objeto actual al scope scope.Add(scopeKey, userActionClientData); // Agregar el objeto a la cahce de entidades cargadas inMemoryEntities.Add(userActionClientData.Id, userActionClientData); // Lee el timestamp y establece las propiedades nuevo y cambiado userActionClientData.Timestamp = reader.GetDateTime(8); userActionClientData.IsNew = false; userActionClientData.Changed = false; // Cerrar el Reader reader.Close(); // Carga los objetos relacionadoss if required if (loadRelation) { } } else { reader.Close(); } } catch (DbException dbException) { // Relanza la excepcion como una excepcion personalizada throw new UtnEmallDataAccessException(dbException.Message, dbException); } finally { // Cierra la conexión si fue creada dentro de la Función if (closeConnection) { dbConnection.Close(); } } } // Retorna la entidad cargada return(userActionClientData); }
/// <summary> /// Función que elimina un UserActionClientDataEntity de la base de datos. /// </summary> /// <param name="userActionClientData">UserActionClientDataEntity a eliminar</param> /// <param name="scope">Estructura interna para evitar problemas de referencia circular.</param> /// <exception cref="ArgumentNullException"> /// Si <paramref name="userActionClientData"/> no es un <c>UserActionClientDataEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// Si una DbException ocurre cuando se accede a la base de datos /// </exception> public void Delete(UserActionClientDataEntity userActionClientData, Dictionary <string, IEntity> scope) { if (userActionClientData == null) { throw new ArgumentException("The argument can't be null"); } try { // Abrir una nueva conexión e inicializar una transacción si es necesario if (!isGlobalTransaction) { dbConnection = dataAccess.GetNewConnection(); dbConnection.Open(); dbTransaction = dbConnection.BeginTransaction(); } // Carga la entidad para garantizar eliminar todos los datos antiguos. userActionClientData = this.Load(userActionClientData.Id, true); if (userActionClientData == null) { throw new UtnEmallDataAccessException("Error al recuperar datos al intentar eliminar."); } // Crea un nuevo command para eliminar string cmdText = "DELETE FROM [UserActionClientData] WHERE idUserActionClientData = @idUserActionClientData"; SqlCeCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); // Agrega los valores de los parametros SqlCeParameter parameterID = dataAccess.GetNewDataParameter("@idUserActionClientData", DbType.Int32); parameterID.Value = userActionClientData.Id; sqlCommand.Parameters.Add(parameterID); // Ejecuta el comando sqlCommand.ExecuteNonQuery(); // Elimina los objetos relacionados // Confirma la transacción si se inicio dentro de la función if (!isGlobalTransaction) { dbTransaction.Commit(); } // Eliminamos la entidad de la lista de entidades cargadas en memoria inMemoryEntities.Remove(userActionClientData.Id); // Eliminamos la entidad del scope if (scope != null) { string scopeKey = userActionClientData.Id.ToString(NumberFormatInfo.InvariantInfo) + "UserActionClientData"; scope.Remove(scopeKey); } } 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 abierta dentro de la Función if (!isGlobalTransaction) { dbConnection.Close(); dbConnection = null; dbTransaction = null; } } }
/// <summary> /// Función que guarda un UserActionClientDataEntity en la base de datos. /// </summary> /// <param name="userActionClientData">UserActionClientDataEntity a guardar</param> /// <param name="scope">Estructura interna para evitar problemas con referencias circulares</param> /// <exception cref="ArgumentNullException"> /// Si <paramref name="userActionClientData"/> no es un <c>UserActionClientDataEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// Si una DbException ocurre cuando se accede a la base de datos /// </exception> public void Save(UserActionClientDataEntity userActionClientData, Dictionary <string, IEntity> scope) { if (userActionClientData == null) { throw new ArgumentException("The argument can't be null"); } // Crear una clave unica para identificar el objeto dentro del scope interno string scopeKey = userActionClientData.Id.ToString(NumberFormatInfo.InvariantInfo) + "UserActionClientData"; 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 (userActionClientData.IsNew || !DataAccessConnection.ExistsEntity(userActionClientData.Id, "UserActionClientData", "idUserActionClientData", dbConnection, dbTransaction)) { commandName = "INSERT INTO [UserActionClientData] (idUserActionClientData, ACTIONTYPE, START, STOP, IDTABLE, IDREGISTER, IDCOMPONENT, IDSERVICE, [TIMESTAMP] ) VALUES( @idUserActionClientData, @actionType,@start,@stop,@idTable,@idRegister,@idComponent,@idService, GETDATE()); "; } else { isUpdate = true; commandName = "UPDATE [UserActionClientData] SET actionType = @actionType, start = @start, stop = @stop, idTable = @idTable, idRegister = @idRegister, idComponent = @idComponent, idService = @idService , timestamp=GETDATE() WHERE idUserActionClientData = @idUserActionClientData"; } // Se crea un command SqlCeCommand sqlCommand = dataAccess.GetNewCommand(commandName, dbConnection, dbTransaction); // Agregar los parametros del command . SqlCeParameter parameter; if (!isUpdate && userActionClientData.Id == 0) { userActionClientData.Id = DataAccessConnection.GetNextId("idUserActionClientData", "UserActionClientData", dbConnection, dbTransaction); } parameter = dataAccess.GetNewDataParameter("@idUserActionClientData", DbType.Int32); parameter.Value = userActionClientData.Id; sqlCommand.Parameters.Add(parameter); FillSaveParameters(userActionClientData, sqlCommand); // Ejecutar el command sqlCommand.ExecuteNonQuery(); scopeKey = userActionClientData.Id.ToString(NumberFormatInfo.InvariantInfo) + "UserActionClientData"; // Agregar la entidad al scope actual scope.Add(scopeKey, userActionClientData); // Guarda las colecciones de objetos relacionados. // Guardar objetos relacionados con la entidad actual // Actualizar // Cierra la conexión si fue abierta en la función if (!isGlobalTransaction) { dbTransaction.Commit(); } // Actualizar los campos new y changed userActionClientData.IsNew = false; userActionClientData.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; } } }