/// <summary> /// Function to Load the relation Source from database. /// </summary> /// <param name="connectionWidget">ConnectionWidgetEntity parent</param> /// <exception cref="ArgumentNullException"> /// if <paramref name="connectionWidget"/> is not a <c>ConnectionWidgetEntity</c>. /// </exception> public void LoadRelationSource(ConnectionWidgetEntity connectionWidget, Dictionary <string, IEntity> scope) { if (connectionWidget == 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 idSource FROM [ConnectionWidget] WHERE idConnectionWidget = @idConnectionWidget"; IDbCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); IDbDataParameter parameter = dataAccess.GetNewDataParameter("@idConnectionWidget", DbType.Int32); // Set command parameters values parameter.Value = connectionWidget.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 ConnectionPointDataAccess connectionPointDataAccess = new ConnectionPointDataAccess(); connectionPointDataAccess.SetConnectionObjects(dbConnection, dbTransaction); // Load related object connectionWidget.Source = connectionPointDataAccess.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(ConnectionWidgetEntity connectionWidget, IDbCommand sqlCommand) { IDbDataParameter parameter; parameter = dataAccess.GetNewDataParameter("@idTarget", DbType.Int32); parameter.Value = connectionWidget.IdTarget; sqlCommand.Parameters.Add(parameter); parameter = dataAccess.GetNewDataParameter("@idSource", DbType.Int32); parameter.Value = connectionWidget.IdSource; sqlCommand.Parameters.Add(parameter); parameter = dataAccess.GetNewDataParameter("@idCustomerServiceData", DbType.Int32); parameter.Value = connectionWidget.IdCustomerServiceData; sqlCommand.Parameters.Add(parameter); }
public static string Relation(ConnectionWidgetEntity connection) { // Reemplaza elementos de plantillas string tpl = RelationTemplate; // Fuente if (connection.Source.ParentComponent.ComponentType == (int)ComponentType.DataSource) { tpl = tpl.Replace("%SOURCE%", Utilities.GetValidIdentifier(connection.Source.ParentComponent.InputDataContext.Name, true)); } else if (connection.Source.ParentComponent.ComponentType == (int)ComponentType.FormMenuItem) { tpl = tpl.Replace("%SOURCE%", GetNameForComponent(connection.Source.ParentComponent.ParentComponent, true)); } else { tpl = tpl.Replace("%SOURCE%", GetNameForComponent(connection.Source.ParentComponent, true)); } // Opción if (connection.Source.ParentComponent.ComponentType == (int)ComponentType.FormMenuItem) { tpl = tpl.Replace("%OPTION%", "Option = \"" + Utilities.GetValidIdentifier(connection.Source.ParentComponent.Text, true) + "\";"); } else { tpl = tpl.Replace("%OPTION%", ""); } // Destino if (connection.Target.ParentComponent.ComponentType == (int)ComponentType.DataSource) { tpl = tpl.Replace("%TARGET%", Utilities.GetValidIdentifier(connection.Target.ParentComponent.OutputDataContext.Name, true)); } else { tpl = tpl.Replace("%TARGET%", GetNameForComponent(connection.Target.ParentComponent, true)); } return(tpl); }
/// <summary> /// Busca el componente origen /// </summary> /// <param name="connectableComponents"></param> /// <param name="connectionWidgetEntity"></param> /// <param name="serviceDocumentWpf"></param> /// <returns></returns> private static Component SearchForSourceComponent(Dictionary <Component, ComponentEntity> connectableComponents, ConnectionWidgetEntity connectionWidgetEntity, ServiceDocumentWpf serviceDocumentWpf) { bool found = false; ComponentEntity relatedEntity; Component relatedSourceWpf = null; // Busca el indice del origen for (int i = 0; !found; i++) { // Verifica que la entidad tiene el id correcto if ((connectableComponents.TryGetValue(serviceDocumentWpf.Components[i], out relatedEntity)) && (relatedEntity.Id == connectionWidgetEntity.Source.IdParentComponent)) { relatedSourceWpf = serviceDocumentWpf.Components[i]; found = true; } // Si un MenuForm fue encontrado, Se itera en sus items. else if (serviceDocumentWpf.Components[i] is MenuFormWpf) { foreach (FormMenuItem menuItem in (serviceDocumentWpf.Components[i] as MenuFormWpf).MenuItems) { if ((connectableComponents.TryGetValue(menuItem, out relatedEntity)) && (relatedEntity.Id == connectionWidgetEntity.Source.IdParentComponent)) { relatedSourceWpf = serviceDocumentWpf.Components[i]; found = true; } } } } return(relatedSourceWpf); }
private static Component SearchForTargetComponent(Dictionary <Component, ComponentEntity> connectableComponents, ConnectionWidgetEntity connectionWidgetEntity, ServiceDocumentWpf serviceDocumentWpf) { bool found = false; ComponentEntity relatedEntity; Component relatedTargetWpf = null; for (int i = 0; !found; i++) { if ((connectableComponents.TryGetValue(serviceDocumentWpf.Components[i], out relatedEntity)) && (relatedEntity.Id == connectionWidgetEntity.Target.IdParentComponent)) { relatedTargetWpf = serviceDocumentWpf.Components[i]; found = true; } // Si un MenuForm fue encontrado, Se itera en sus items. else if (serviceDocumentWpf.Components[i] is MenuFormWpf) { foreach (FormMenuItem menuItem in (serviceDocumentWpf.Components[i] as MenuFormWpf).MenuItems) { // Si uno de los items del menu ocurre debe estar conectado if ((connectableComponents.TryGetValue(menuItem, out relatedEntity)) && (relatedEntity.Id == connectionWidgetEntity.Target.IdParentComponent)) { relatedTargetWpf = serviceDocumentWpf.Components[i]; found = true; } } } } return(relatedTargetWpf); }
public static ConnectionWpf ConvertEntityToConnection(Dictionary <Component, ComponentEntity> connectableComponents, ConnectionWidgetEntity connectionWidgetEntity, ServiceDocumentWpf serviceDocumentWpf) { Component relatedSourceWpf = null; Component relatedTargetWpf = null; ConnectionPointWpf source = null; ConnectionPointWpf target = null; // Busca por el componente origen relatedSourceWpf = SearchForSourceComponent(connectableComponents, connectionWidgetEntity, serviceDocumentWpf); // Busca el componente destino relatedTargetWpf = SearchForTargetComponent(connectableComponents, connectionWidgetEntity, serviceDocumentWpf); DataSourceWpf dataSourceWpf = relatedSourceWpf as DataSourceWpf; ListFormWpf listFormWpf = relatedSourceWpf as ListFormWpf; MenuFormWpf menuFormWpf = relatedSourceWpf as MenuFormWpf; EnterSingleDataFormWpf enterSingleDataFormWpf = relatedSourceWpf as EnterSingleDataFormWpf; ShowDataFormWpf showDataFormWpf = relatedSourceWpf as ShowDataFormWpf; // Si el Source es de entrada //obtengo y guardo el connectionpoint del widget correspondiente if (connectionWidgetEntity.Source.ConnectionType == (int)ConnectionPointType.Input) { if (dataSourceWpf != null) { source = dataSourceWpf.InputConnectionPoint as ConnectionPointWpf; } if (listFormWpf != null) { source = listFormWpf.InputConnectionPoint as ConnectionPointWpf; } if (menuFormWpf != null) { source = menuFormWpf.InputConnectionPoint as ConnectionPointWpf; } if (enterSingleDataFormWpf != null) { source = enterSingleDataFormWpf.InputConnectionPoint as ConnectionPointWpf; } if (showDataFormWpf != null) { source = showDataFormWpf.InputConnectionPoint as ConnectionPointWpf; } } // El Source es de Output obtengo y guardo el Widget correpondiente else { if (dataSourceWpf != null) { source = dataSourceWpf.OutputConnectionPoint as ConnectionPointWpf; } if (listFormWpf != null) { source = listFormWpf.OutputConnectionPoint as ConnectionPointWpf; } if (menuFormWpf != null) { foreach (FormMenuItemWpf menuItem in menuFormWpf.MenuItems) { if (String.CompareOrdinal(menuItem.Text, connectionWidgetEntity.Source.ParentComponent.Text) == 0) { source = menuItem.OutputConnectionPoint as ConnectionPointWpf; } } } if (enterSingleDataFormWpf != null) { source = enterSingleDataFormWpf.OutputConnectionPoint as ConnectionPointWpf; } if (showDataFormWpf != null) { source = showDataFormWpf.OutputConnectionPoint as ConnectionPointWpf; } } dataSourceWpf = relatedTargetWpf as DataSourceWpf; listFormWpf = relatedTargetWpf as ListFormWpf; menuFormWpf = relatedTargetWpf as MenuFormWpf; enterSingleDataFormWpf = relatedTargetWpf as EnterSingleDataFormWpf; showDataFormWpf = relatedTargetWpf as ShowDataFormWpf; // Si el Target es input if (connectionWidgetEntity.Target.ConnectionType == (int)ConnectionPointType.Input) { if (dataSourceWpf != null) { target = dataSourceWpf.InputConnectionPoint as ConnectionPointWpf; } if (listFormWpf != null) { target = listFormWpf.InputConnectionPoint as ConnectionPointWpf; } if (menuFormWpf != null) { target = menuFormWpf.InputConnectionPoint as ConnectionPointWpf; } if (enterSingleDataFormWpf != null) { target = enterSingleDataFormWpf.InputConnectionPoint as ConnectionPointWpf; } if (showDataFormWpf != null) { target = showDataFormWpf.InputConnectionPoint as ConnectionPointWpf; } } // El Target es de Output obtengo y guardo el Widget correpondiente else { if (dataSourceWpf != null) { target = dataSourceWpf.OutputConnectionPoint as ConnectionPointWpf; } if (listFormWpf != null) { target = listFormWpf.OutputConnectionPoint as ConnectionPointWpf; } if (menuFormWpf != null) { target = menuFormWpf.OutputConnectionPoint as ConnectionPointWpf; } if (enterSingleDataFormWpf != null) { target = enterSingleDataFormWpf.OutputConnectionPoint as ConnectionPointWpf; } if (showDataFormWpf != null) { target = showDataFormWpf.OutputConnectionPoint as ConnectionPointWpf; } } ConnectionWpf connectionWpf = new ConnectionWpf(source, target); return(connectionWpf); }
/// <summary> /// Function to load a ConnectionWidgetEntity 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 ConnectionWidgetEntity Load(int id, bool loadRelation, Dictionary <string, IEntity> scope) { // Build a key for internal scope object string scopeKey = id.ToString(NumberFormatInfo.InvariantInfo) + "ConnectionWidget"; if (scope != null) { // If scope contains the object it was already loaded, // return it to avoid circular references if (scope.ContainsKey(scopeKey)) { return((ConnectionWidgetEntity)scope[scopeKey]); } } else { // If there isn't a current scope create one scope = new Dictionary <string, IEntity>(); } ConnectionWidgetEntity connectionWidget = 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)) { connectionWidget = inMemoryEntities[id]; // Add current object to current load scope scope.Add(scopeKey, connectionWidget); } 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 idConnectionWidget, idTarget, idSource, idCustomerServiceData, timestamp FROM [ConnectionWidget] WHERE idConnectionWidget = @idConnectionWidget"; // Create the command IDbCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); // Create the Id parameter for the query IDbDataParameter parameter = dataAccess.GetNewDataParameter("@idConnectionWidget", DbType.Int32); parameter.Value = id; sqlCommand.Parameters.Add(parameter); // Use a DataReader to get data from db IDataReader reader = sqlCommand.ExecuteReader(); connectionWidget = new ConnectionWidgetEntity(); if (reader.Read()) { // Load fields of entity connectionWidget.Id = reader.GetInt32(0); connectionWidget.IdTarget = reader.GetInt32(1); connectionWidget.IdSource = reader.GetInt32(2); connectionWidget.IdCustomerServiceData = reader.GetInt32(3); // Add current object to the scope scope.Add(scopeKey, connectionWidget); // Add current object to cache of loaded entities inMemoryEntities.Add(connectionWidget.Id, connectionWidget); // Read the timestamp and set new and changed properties connectionWidget.Timestamp = reader.GetDateTime(4); connectionWidget.IsNew = false; connectionWidget.Changed = false; // Close the reader reader.Close(); // Load related objects if required if (loadRelation) { LoadRelationTarget(connectionWidget, scope); LoadRelationSource(connectionWidget, 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(connectionWidget); }
/// <summary> /// Function to Delete a ConnectionWidgetEntity from database. /// </summary> /// <param name="connectionWidget">ConnectionWidgetEntity 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="connectionWidget"/> is not a <c>ConnectionWidgetEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Delete(ConnectionWidgetEntity connectionWidget, Dictionary <string, IEntity> scope) { if (connectionWidget == 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 connectionWidget = this.Load(connectionWidget.Id, true); if (connectionWidget == null) { throw new UtnEmallDataAccessException("Error retrieving data while trying to delete."); } // Create a command for delete string cmdText = "DeleteConnectionWidget"; IDbCommand sqlCommand = dataAccess.GetNewCommand(cmdText, dbConnection, dbTransaction); sqlCommand.CommandType = CommandType.StoredProcedure; // Add values to parameters IDbDataParameter parameterID = dataAccess.GetNewDataParameter("@idConnectionWidget", DbType.Int32); parameterID.Value = connectionWidget.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(connectionWidget.Id); // Remove entity from current internal scope if (scope != null) { string scopeKey = connectionWidget.Id.ToString(NumberFormatInfo.InvariantInfo) + "ConnectionWidget"; 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 ConnectionWidgetEntity from database. /// </summary> /// <param name="connectionWidget">ConnectionWidgetEntity to delete</param> /// <exception cref="ArgumentNullException"> /// If <paramref name="connectionWidget"/> is not a <c>ConnectionWidgetEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Delete(ConnectionWidgetEntity connectionWidget) { Delete(connectionWidget, null); }
/// <summary> /// Function to Save a ConnectionWidgetEntity in the database. /// </summary> /// <param name="connectionWidget">ConnectionWidgetEntity 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="connectionWidget"/> is not a <c>ConnectionWidgetEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Save(ConnectionWidgetEntity connectionWidget, Dictionary <string, IEntity> scope) { if (connectionWidget == null) { throw new ArgumentException("The argument can't be null"); } // Create a unique key to identify the object in the internal scope string scopeKey = connectionWidget.Id.ToString(NumberFormatInfo.InvariantInfo) + "ConnectionWidget"; 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 (connectionWidget.IsNew || !DataAccessConnection.ExistsEntity(connectionWidget.Id, "ConnectionWidget", "idConnectionWidget", dbConnection, dbTransaction)) { commandName = "SaveConnectionWidget"; } else { isUpdate = true; commandName = "UpdateConnectionWidget"; } // 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("@idConnectionWidget", DbType.Int32); parameter.Value = connectionWidget.Id; sqlCommand.Parameters.Add(parameter); } FillSaveParameters(connectionWidget, sqlCommand); // Execute the command if (isUpdate) { sqlCommand.ExecuteNonQuery(); } else { IDbDataParameter parameterIdOutput = dataAccess.GetNewDataParameter("@idConnectionWidget", DbType.Int32); parameterIdOutput.Direction = ParameterDirection.ReturnValue; sqlCommand.Parameters.Add(parameterIdOutput); sqlCommand.ExecuteNonQuery(); connectionWidget.Id = Convert.ToInt32(parameterIdOutput.Value, NumberFormatInfo.InvariantInfo); } scopeKey = connectionWidget.Id.ToString(NumberFormatInfo.InvariantInfo) + "ConnectionWidget"; // Add entity to current internal scope scope.Add(scopeKey, connectionWidget); // 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 connectionWidget.IsNew = false; connectionWidget.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 ConnectionWidgetEntity in the database. /// </summary> /// <param name="connectionWidget">ConnectionWidgetEntity to save</param> /// <exception cref="ArgumentNullException"> /// if <paramref name="connectionWidget"/> is not a <c>ConnectionWidgetEntity</c>. /// </exception> /// <exception cref="UtnEmallDataAccessException"> /// If an DbException occurs in the try block while accessing the database. /// </exception> public void Save(ConnectionWidgetEntity connectionWidget) { Save(connectionWidget, null); }