/// <summary> /// Método invocado cuando se hace click en el botón Aceptar. /// </summary> /// <param name="sender"> /// El objeto que genera el evento. /// </param> /// <param name="e"> /// Un objeto que contiene información acerca del evento. /// </param> private void OnOkClicked(object sender, RoutedEventArgs e) { System.Collections.Generic.List <ServiceCampaignEntity> toRemove = new List <ServiceCampaignEntity>(); // Agrega los servicios quitadas a la lista. foreach (ServiceCampaignEntity serviceCampaign in campaign.ServiceCampaign) { bool exists = false; foreach (ServiceEntity service in Selected) { if (serviceCampaign.Service.Name == service.Name) { exists = true; break; } } if (!exists) { toRemove.Add(serviceCampaign); } } // Quitarlas. foreach (ServiceCampaignEntity serviceCampaign in toRemove) { campaign.ServiceCampaign.Remove(serviceCampaign); } // Agregar los nuevos servicios. foreach (ServiceEntity service in Selected) { bool exists = false; foreach (ServiceCampaignEntity serviceCampaign in campaign.ServiceCampaign) { if (serviceCampaign.Service.Name == service.Name) { exists = true; break; } } if (!exists) { ServiceCampaignEntity serviceCampaign = new ServiceCampaignEntity(); serviceCampaign.Campaign = campaign; campaign.ServiceCampaign.Add(serviceCampaign); } } if (OkSelected != null) { OkSelected(sender, e); } }
/// <summary> /// Function to Load the relation Campaign from database. /// </summary> /// <param name="serviceCampaign">ServiceCampaignEntity parent</param> /// <exception cref="ArgumentNullException"> /// if <paramref name="serviceCampaign"/> is not a <c>ServiceCampaignEntity</c>. /// </exception> public void LoadRelationCampaign(ServiceCampaignEntity serviceCampaign, Dictionary <string, IEntity> scope) { if (serviceCampaign == 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 idCampaign FROM [ServiceCampaign] WHERE idServiceCampaign = @idServiceCampaign"; IDbCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); IDbDataParameter parameter = dataAccess.GetNewDataParameter("@idServiceCampaign", DbType.Int32); // Set command parameters values parameter.Value = serviceCampaign.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 CampaignDataAccess campaignDataAccess = new CampaignDataAccess(); campaignDataAccess.SetConnectionObjects(dbConnection, dbTransaction); // Load related object serviceCampaign.Campaign = campaignDataAccess.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(); } } }
private void FillSaveParameters(ServiceCampaignEntity serviceCampaign, IDbCommand sqlCommand) { IDbDataParameter parameter; parameter = dataAccess.GetNewDataParameter("@idService", DbType.Int32); parameter.Value = serviceCampaign.IdService; sqlCommand.Parameters.Add(parameter); parameter = dataAccess.GetNewDataParameter("@idCampaign", DbType.Int32); parameter.Value = serviceCampaign.IdCampaign; sqlCommand.Parameters.Add(parameter); }
/// <summary> /// Function to load a ServiceCampaignEntity 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 ServiceCampaignEntity Load(int id, bool loadRelation, Dictionary <string, IEntity> scope) { // Build a key for internal scope object string scopeKey = id.ToString(NumberFormatInfo.InvariantInfo) + "ServiceCampaign"; if (scope != null) { // If scope contains the object it was already loaded, // return it to avoid circular references if (scope.ContainsKey(scopeKey)) { return((ServiceCampaignEntity)scope[scopeKey]); } } else { // If there isn't a current scope create one scope = new Dictionary <string, IEntity>(); } ServiceCampaignEntity serviceCampaign = 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)) { serviceCampaign = inMemoryEntities[id]; // Add current object to current load scope scope.Add(scopeKey, serviceCampaign); } 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 idServiceCampaign, idService, idCampaign, timestamp FROM [ServiceCampaign] WHERE idServiceCampaign = @idServiceCampaign"; // Create the command IDbCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); // Create the Id parameter for the query IDbDataParameter parameter = dataAccess.GetNewDataParameter("@idServiceCampaign", DbType.Int32); parameter.Value = id; sqlCommand.Parameters.Add(parameter); // Use a DataReader to get data from db IDataReader reader = sqlCommand.ExecuteReader(); serviceCampaign = new ServiceCampaignEntity(); if (reader.Read()) { // Load fields of entity serviceCampaign.Id = reader.GetInt32(0); serviceCampaign.IdService = reader.GetInt32(1); serviceCampaign.IdCampaign = reader.GetInt32(2); // Add current object to the scope scope.Add(scopeKey, serviceCampaign); // Add current object to cache of loaded entities inMemoryEntities.Add(serviceCampaign.Id, serviceCampaign); // Read the timestamp and set new and changed properties serviceCampaign.Timestamp = reader.GetDateTime(3); serviceCampaign.IsNew = false; serviceCampaign.Changed = false; // Close the reader reader.Close(); // Load related objects if required if (loadRelation) { LoadRelationCampaign(serviceCampaign, scope); } } 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(serviceCampaign); }
/// <summary> /// Function to Delete a ServiceCampaignEntity from database. /// </summary> /// <param name="serviceCampaign">ServiceCampaignEntity 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="serviceCampaign"/> is not a <c>ServiceCampaignEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Delete(ServiceCampaignEntity serviceCampaign, Dictionary <string, IEntity> scope) { if (serviceCampaign == 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 serviceCampaign = this.Load(serviceCampaign.Id, true); if (serviceCampaign == null) { throw new UtnEmallDataAccessException("Error retrieving data while trying to delete."); } // Create a command for delete string cmdText = "DeleteServiceCampaign"; IDbCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); sqlCommand.CommandType = CommandType.StoredProcedure; // Add values to parameters IDbDataParameter parameterID = dataAccess.GetNewDataParameter("@idServiceCampaign", DbType.Int32); parameterID.Value = serviceCampaign.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(serviceCampaign.Id); // Remove entity from current internal scope if (scope != null) { string scopeKey = serviceCampaign.Id.ToString(NumberFormatInfo.InvariantInfo) + "ServiceCampaign"; 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 ServiceCampaignEntity from database. /// </summary> /// <param name="serviceCampaign">ServiceCampaignEntity to delete</param> /// <exception cref="ArgumentNullException"> /// If <paramref name="serviceCampaign"/> is not a <c>ServiceCampaignEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Delete(ServiceCampaignEntity serviceCampaign) { Delete(serviceCampaign, null); }
/// <summary> /// Function to Save a ServiceCampaignEntity in the database. /// </summary> /// <param name="serviceCampaign">ServiceCampaignEntity 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="serviceCampaign"/> is not a <c>ServiceCampaignEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Save(ServiceCampaignEntity serviceCampaign, Dictionary <string, IEntity> scope) { if (serviceCampaign == null) { throw new ArgumentException("The argument can't be null"); } // Create a unique key to identify the object in the internal scope string scopeKey = serviceCampaign.Id.ToString(NumberFormatInfo.InvariantInfo) + "ServiceCampaign"; 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 (serviceCampaign.IsNew || !DataAccessConnection.ExistsEntity(serviceCampaign.Id, "ServiceCampaign", "idServiceCampaign", dbConnection, dbTransaction)) { commandName = "SaveServiceCampaign"; } else { isUpdate = true; commandName = "UpdateServiceCampaign"; } // 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("@idServiceCampaign", DbType.Int32); parameter.Value = serviceCampaign.Id; sqlCommand.Parameters.Add(parameter); } FillSaveParameters(serviceCampaign, sqlCommand); // Execute the command if (isUpdate) { sqlCommand.ExecuteNonQuery(); } else { IDbDataParameter parameterIdOutput = dataAccess.GetNewDataParameter("@idServiceCampaign", DbType.Int32); parameterIdOutput.Direction = ParameterDirection.ReturnValue; sqlCommand.Parameters.Add(parameterIdOutput); sqlCommand.ExecuteNonQuery(); serviceCampaign.Id = Convert.ToInt32(parameterIdOutput.Value, NumberFormatInfo.InvariantInfo); } scopeKey = serviceCampaign.Id.ToString(NumberFormatInfo.InvariantInfo) + "ServiceCampaign"; // Add entity to current internal scope scope.Add(scopeKey, serviceCampaign); // 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 serviceCampaign.IsNew = false; serviceCampaign.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 ServiceCampaignEntity in the database. /// </summary> /// <param name="serviceCampaign">ServiceCampaignEntity to save</param> /// <exception cref="ArgumentNullException"> /// if <paramref name="serviceCampaign"/> is not a <c>ServiceCampaignEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Save(ServiceCampaignEntity serviceCampaign) { Save(serviceCampaign, null); }