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;
}
}
}
