/// <summary> /// This method returns the Database By Name /// </summary> public static DTNDatabase FindDatabaseByName(string name, List <DTNDatabase> projectDatabases) { // initial value DTNDatabase database = null; // If the projectDatabases collection exists and has one or more items if (ListHelper.HasOneOrMoreItems(projectDatabases)) { // Iterate the collection of Database objects foreach (DTNDatabase tempDatabase in projectDatabases) { // if this is the name being sought if (TextHelper.IsEqual(tempDatabase.DatabaseName, name)) { // set the return value database = tempDatabase; // break out of the loop break; } } } // return value return(database); }
/// <summary> /// This method saves the Project Databases. /// </summary> public bool SaveProjectDatabases(Gateway gateway) { // initial value bool databasesSaved = false; bool tempSaved = false; // if the SelectedProject has Databases if ((this.SelectedProject.HasDatabases) && (this.selectedProject.Databases.Count > 0)) { // default to true until a failure happens databasesSaved = true; // iterate the Databases foreach (DTNDatabase database in this.SelectedProject.Databases) { // clone the object so it can be saved by reference DTNDatabase tempDatabase = database.Clone(); // save the DTNDatabase tempSaved = gateway.SaveDTNDatabase(ref tempDatabase); // if the value for tempSaved is false if (!tempSaved) { // set to false databasesSaved = false; } } } // return value return(databasesSaved); }
/// <summary> /// This method finds a 'DTNDatabase' object. /// This method uses the 'DTNDatabase_Find' procedure. /// </summary> /// <returns>A 'DTNDatabase' object.</returns> /// </summary> public DTNDatabase FindDTNDatabase(FindDTNDatabaseStoredProcedure findDTNDatabaseProc, DataConnector databaseConnector) { // Initial Value DTNDatabase dTNDatabase = null; // Verify database connection is connected if ((databaseConnector != null) && (databaseConnector.Connected)) { // First Get Dataset DataSet dTNDatabaseDataSet = this.DataHelper.LoadDataSet(findDTNDatabaseProc, databaseConnector); // Verify DataSet Exists if (dTNDatabaseDataSet != null) { // Get DataTable From DataSet DataRow row = this.DataHelper.ReturnFirstRow(dTNDatabaseDataSet); // if row exists if (row != null) { // Load DTNDatabase dTNDatabase = DTNDatabaseReader.Load(row); } } } // return value return(dTNDatabase); }
/// <summary> /// Saves a 'DTNDatabase' object into the database. /// This method calls the 'Insert' or 'Update' method. /// </summary> /// <param name='dTNDatabase'>The 'DTNDatabase' object to save.</param> /// <returns>True if successful or false if not.</returns> public bool Save(ref DTNDatabase dTNDatabase) { // Initial value bool saved = false; // If the dTNDatabase exists. if (dTNDatabase != null) { // Is this a new DTNDatabase if (dTNDatabase.IsNew) { // Insert new DTNDatabase int newIdentity = this.Insert(dTNDatabase); // if insert was successful if (newIdentity > 0) { // Update Identity dTNDatabase.UpdateIdentity(newIdentity); // Set return value saved = true; } } else { // Update DTNDatabase saved = this.Update(dTNDatabase); } } // return value return(saved); }
/// <summary> /// This method deletes a 'DTNDatabase' object. /// </summary> /// <param name='List<PolymorphicObject>'>The 'DTNDatabase' to delete. /// <returns>A PolymorphicObject object with a Boolean value. internal PolymorphicObject DeleteDTNDatabase(List <PolymorphicObject> parameters, DataConnector dataConnector) { // Initial Value PolymorphicObject returnObject = new PolymorphicObject(); // If the data connection is connected if ((dataConnector != null) && (dataConnector.Connected == true)) { // Create Delete StoredProcedure DeleteDTNDatabaseStoredProcedure deleteDTNDatabaseProc = null; // verify the first parameters is a(n) 'DTNDatabase'. if (parameters[0].ObjectValue as DTNDatabase != null) { // Create DTNDatabase DTNDatabase dTNDatabase = (DTNDatabase)parameters[0].ObjectValue; // verify dTNDatabase exists if (dTNDatabase != null) { // Now create deleteDTNDatabaseProc from DTNDatabaseWriter // The DataWriter converts the 'DTNDatabase' // to the SqlParameter[] array needed to delete a 'DTNDatabase'. deleteDTNDatabaseProc = DTNDatabaseWriter.CreateDeleteDTNDatabaseStoredProcedure(dTNDatabase); } } // Verify deleteDTNDatabaseProc exists if (deleteDTNDatabaseProc != null) { // Execute Delete Stored Procedure bool deleted = this.DataManager.DTNDatabaseManager.DeleteDTNDatabase(deleteDTNDatabaseProc, dataConnector); // Create returnObject.Boolean returnObject.Boolean = new NullableBoolean(); // If delete was successful if (deleted) { // Set returnObject.Boolean.Value to true returnObject.Boolean.Value = NullableBooleanEnum.True; } else { // Set returnObject.Boolean.Value to false returnObject.Boolean.Value = NullableBooleanEnum.False; } } } else { // Raise Error Data Connection Not Available throw new Exception("The database connection is not available."); } // return value return(returnObject); }
/// <summary> /// This method finds a 'DTNDatabase' object. /// </summary> /// <param name='List<PolymorphicObject>'>The 'DTNDatabase' to delete. /// <returns>A PolymorphicObject object with a Boolean value. internal PolymorphicObject FindDTNDatabase(List <PolymorphicObject> parameters, DataConnector dataConnector) { // Initial Value PolymorphicObject returnObject = new PolymorphicObject(); // locals DTNDatabase dTNDatabase = null; // If the data connection is connected if ((dataConnector != null) && (dataConnector.Connected == true)) { // Create Find StoredProcedure FindDTNDatabaseStoredProcedure findDTNDatabaseProc = null; // verify the first parameters is a 'DTNDatabase'. if (parameters[0].ObjectValue as DTNDatabase != null) { // Get DTNDatabaseParameter DTNDatabase paramDTNDatabase = (DTNDatabase)parameters[0].ObjectValue; // verify paramDTNDatabase exists if (paramDTNDatabase != null) { // Now create findDTNDatabaseProc from DTNDatabaseWriter // The DataWriter converts the 'DTNDatabase' // to the SqlParameter[] array needed to find a 'DTNDatabase'. findDTNDatabaseProc = DTNDatabaseWriter.CreateFindDTNDatabaseStoredProcedure(paramDTNDatabase); } // Verify findDTNDatabaseProc exists if (findDTNDatabaseProc != null) { // Execute Find Stored Procedure dTNDatabase = this.DataManager.DTNDatabaseManager.FindDTNDatabase(findDTNDatabaseProc, dataConnector); // if dataObject exists if (dTNDatabase != null) { // set returnObject.ObjectValue returnObject.ObjectValue = dTNDatabase; } } } else { // Raise Error Data Connection Not Available throw new Exception("The database connection is not available."); } } // return value return(returnObject); }
/// <summary> /// This method fetches all 'DTNDatabase' objects. /// </summary> /// <param name='List<PolymorphicObject>'>The 'DTNDatabase' to delete. /// <returns>A PolymorphicObject object with all 'DTNDatabases' objects. internal PolymorphicObject FetchAll(List <PolymorphicObject> parameters, DataConnector dataConnector) { // Initial Value PolymorphicObject returnObject = new PolymorphicObject(); // locals List <DTNDatabase> dTNDatabaseListCollection = null; // Create FetchAll StoredProcedure FetchAllDTNDatabasesStoredProcedure fetchAllProc = null; // If the data connection is connected if ((dataConnector != null) && (dataConnector.Connected == true)) { // Get DTNDatabaseParameter // Declare Parameter DTNDatabase paramDTNDatabase = null; // verify the first parameters is a(n) 'DTNDatabase'. if (parameters[0].ObjectValue as DTNDatabase != null) { // Get DTNDatabaseParameter paramDTNDatabase = (DTNDatabase)parameters[0].ObjectValue; } // Now create FetchAllDTNDatabasesProc from DTNDatabaseWriter fetchAllProc = DTNDatabaseWriter.CreateFetchAllDTNDatabasesStoredProcedure(paramDTNDatabase); } // Verify fetchAllProc exists if (fetchAllProc != null) { // Execute FetchAll Stored Procedure dTNDatabaseListCollection = this.DataManager.DTNDatabaseManager.FetchAllDTNDatabases(fetchAllProc, dataConnector); // if dataObjectCollection exists if (dTNDatabaseListCollection != null) { // set returnObject.ObjectValue returnObject.ObjectValue = dTNDatabaseListCollection; } } else { // Raise Error Data Connection Not Available throw new Exception("The database connection is not available."); } // return value return(returnObject); }
/// <summary> /// Deletes a 'DTNDatabase' from the database /// This method calls the DataBridgeManager to execute the delete using the /// procedure 'DTNDatabase_Delete'. /// </summary> /// <param name='dtndatabase'>The 'DTNDatabase' to delete.</param> /// <returns>True if the delete is successful or false if not.</returns> public bool Delete(DTNDatabase tempDTNDatabase) { // locals bool deleted = false; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "DeleteDTNDatabase"; string objectName = "ApplicationLogicComponent.Controllers"; try { // verify tempdTNDatabase exists before attemptintg to delete if (tempDTNDatabase != null) { // Create Delegate For DataOperation ApplicationController.DataOperationMethod deleteDTNDatabaseMethod = this.AppController.DataBridge.DataOperations.DTNDatabaseMethods.DeleteDTNDatabase; // Create parameters for this method List <PolymorphicObject> parameters = CreateDTNDatabaseParameter(tempDTNDatabase); // Perform DataOperation PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, deleteDTNDatabaseMethod, parameters); // If return object exists if (returnObject != null) { // Test For True if (returnObject.Boolean.Value == NullableBooleanEnum.True) { // Set Deleted To True deleted = true; } } } } catch (Exception error) { // If ErrorProcessor exists if (this.ErrorProcessor != null) { // Log the current error this.ErrorProcessor.LogError(methodName, objectName, error); } } // return value return(deleted); }
/// <summary> /// This method creates the parameter for a 'DTNDatabase' data operation. /// </summary> /// <param name='dtndatabase'>The 'DTNDatabase' to use as the first /// parameter (parameters[0]).</param> /// <returns>A List<PolymorphicObject> collection.</returns> private List <PolymorphicObject> CreateDTNDatabaseParameter(DTNDatabase dTNDatabase) { // Initial Value List <PolymorphicObject> parameters = new List <PolymorphicObject>(); // Create PolymorphicObject to hold the parameter PolymorphicObject parameter = new PolymorphicObject(); // Set parameter.ObjectValue parameter.ObjectValue = dTNDatabase; // Add userParameter to parameters parameters.Add(parameter); // return value return(parameters); }
/// <summary> /// This method creates the sql Parameter[] array /// that holds the primary key value. /// </summary> /// <param name='dTNDatabase'>The 'DTNDatabase' to get the primary key of.</param> /// <returns>A SqlParameter[] array which contains the primary key value. /// to delete.</returns> internal static SqlParameter[] CreatePrimaryKeyParameter(DTNDatabase dTNDatabase) { // Initial Value SqlParameter[] parameters = new SqlParameter[1]; // verify user exists if (dTNDatabase != null) { // Create PrimaryKey Parameter SqlParameter @DatabaseId = new SqlParameter("@DatabaseId", dTNDatabase.DatabaseId); // Set parameters[0] to @DatabaseId parameters[0] = @DatabaseId; } // return value return(parameters); }
/// <summary> /// This method returns the Database Id By Name /// </summary> public static int FindDatabaseIdByName(string name, List <DTNDatabase> projectDatabases) { // initial value int databaseId = 0; // attempt to find the database by name DTNDatabase database = FindDatabaseByName(name, projectDatabases); // If the database object exists if (NullHelper.Exists(database)) { // set the return value databaseId = database.DatabaseId; } // return value return(databaseId); }
/// <summary> /// Finds a 'DTNDatabase' object by the primary key. /// This method used the DataBridgeManager to execute the 'Find' using the /// procedure 'DTNDatabase_Find'</param> /// </summary> /// <param name='tempDTNDatabase'>A temporary DTNDatabase for passing values.</param> /// <returns>A 'DTNDatabase' object if found else a null 'DTNDatabase'.</returns> public DTNDatabase Find(DTNDatabase tempDTNDatabase) { // Initial values DTNDatabase dTNDatabase = null; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "Find"; string objectName = "ApplicationLogicComponent.Controllers"; try { // If object exists if (tempDTNDatabase != null) { // Create DataOperation ApplicationController.DataOperationMethod findMethod = this.AppController.DataBridge.DataOperations.DTNDatabaseMethods.FindDTNDatabase; // Create parameters for this method List <PolymorphicObject> parameters = CreateDTNDatabaseParameter(tempDTNDatabase); // Perform DataOperation PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, findMethod, parameters); // If return object exists if ((returnObject != null) && (returnObject.ObjectValue as DTNDatabase != null)) { // Get ReturnObject dTNDatabase = (DTNDatabase)returnObject.ObjectValue; } } } catch (Exception error) { // If ErrorProcessor exists if (this.ErrorProcessor != null) { // Log the current error this.ErrorProcessor.LogError(methodName, objectName, error); } } // return value return(dTNDatabase); }
/// <summary> /// Insert a 'DTNDatabase' object into the database. /// This method uses the DataBridgeManager to execute the 'Insert' using the /// procedure 'DTNDatabase_Insert'.</param> /// </summary> /// <param name='dTNDatabase'>The 'DTNDatabase' object to insert.</param> /// <returns>The id (int) of the new 'DTNDatabase' object that was inserted.</returns> public int Insert(DTNDatabase dTNDatabase) { // Initial values int newIdentity = -1; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "Insert"; string objectName = "ApplicationLogicComponent.Controllers"; try { // If DTNDatabaseexists if (dTNDatabase != null) { ApplicationController.DataOperationMethod insertMethod = this.AppController.DataBridge.DataOperations.DTNDatabaseMethods.InsertDTNDatabase; // Create parameters for this method List <PolymorphicObject> parameters = CreateDTNDatabaseParameter(dTNDatabase); // Perform DataOperation PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, insertMethod, parameters); // If return object exists if (returnObject != null) { // Set return value newIdentity = returnObject.IntegerValue; } } } catch (Exception error) { // If ErrorProcessor exists if (this.ErrorProcessor != null) { // Log the current error this.ErrorProcessor.LogError(methodName, objectName, error); } } // return value return(newIdentity); }
/// <summary> /// This method Updates a 'DTNDatabase' object in the database. /// This method used the DataBridgeManager to execute the 'Update' using the /// procedure 'DTNDatabase_Update'.</param> /// </summary> /// <param name='dTNDatabase'>The 'DTNDatabase' object to update.</param> /// <returns>True if successful else false if not.</returns> public bool Update(DTNDatabase dTNDatabase) { // Initial value bool saved = false; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "Update"; string objectName = "ApplicationLogicComponent.Controllers"; try { if (dTNDatabase != null) { // Create Delegate ApplicationController.DataOperationMethod updateMethod = this.AppController.DataBridge.DataOperations.DTNDatabaseMethods.UpdateDTNDatabase; // Create parameters for this method List <PolymorphicObject> parameters = CreateDTNDatabaseParameter(dTNDatabase); // Perform DataOperation PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, updateMethod, parameters); // If return object exists if ((returnObject != null) && (returnObject.Boolean != null) && (returnObject.Boolean.Value == NullableBooleanEnum.True)) { // Set saved to true saved = true; } } } catch (Exception error) { // If ErrorProcessor exists if (this.ErrorProcessor != null) { // Log the current error this.ErrorProcessor.LogError(methodName, objectName, error); } } // return value return(saved); }
/// <summary> /// This method loads a 'DTNDatabase' object /// from the dataRow passed in. /// </summary> /// <param name='dataRow'>The 'DataRow' to load from.</param> /// <returns>A 'DTNDatabase' DataObject.</returns> public static DTNDatabase Load(DataRow dataRow) { // Initial Value DTNDatabase dTNDatabase = new DTNDatabase(); // Create field Integers int authenticationTypefield = 0; int connectionStringfield = 1; int databaseIdfield = 2; int databaseNamefield = 3; int databaseTypefield = 4; int dBPasswordfield = 5; int excludefield = 6; int pathfield = 7; int projectIdfield = 8; int serializablefield = 9; int serverNamefield = 10; int userIdfield = 11; try { // Load Each field dTNDatabase.AuthenticationType = DataHelper.ParseInteger(dataRow.ItemArray[authenticationTypefield], 0); dTNDatabase.ConnectionString = DataHelper.ParseString(dataRow.ItemArray[connectionStringfield]); dTNDatabase.UpdateIdentity(DataHelper.ParseInteger(dataRow.ItemArray[databaseIdfield], 0)); dTNDatabase.DatabaseName = DataHelper.ParseString(dataRow.ItemArray[databaseNamefield]); dTNDatabase.DatabaseType = DataHelper.ParseInteger(dataRow.ItemArray[databaseTypefield], 0); dTNDatabase.DBPassword = DataHelper.ParseString(dataRow.ItemArray[dBPasswordfield]); dTNDatabase.Exclude = DataHelper.ParseInteger(dataRow.ItemArray[excludefield], 0); dTNDatabase.Path = DataHelper.ParseString(dataRow.ItemArray[pathfield]); dTNDatabase.ProjectId = DataHelper.ParseInteger(dataRow.ItemArray[projectIdfield], 0); dTNDatabase.Serializable = DataHelper.ParseBoolean(dataRow.ItemArray[serializablefield], false); dTNDatabase.ServerName = DataHelper.ParseString(dataRow.ItemArray[serverNamefield]); dTNDatabase.UserId = DataHelper.ParseString(dataRow.ItemArray[userIdfield]); } catch { } // return value return(dTNDatabase); }
/// <summary> /// This method adds a new database to the selected project. /// </summary> private void EditDatabase(DTNDatabase database) { // If the selected project exists if (this.SelectedProject != null) { // Create instance of Database SelectorForm DatabaseSelectorForm databaseForm = new DatabaseSelectorForm(); // Set selected project databaseForm.DatabaseSelectorControl.Setup(this.SelectedProject, database); // Show Dialog databaseForm.ShowDialog(); // if the user did not cancel if (!databaseForm.DatabaseSelectorControl.UserCancelled) { // if the selected project exists and the SelectedDatabase exists on the databaseForm if ((this.HasSelectedProject) && (databaseForm.DatabaseSelectorControl.SelectedDatabase != null)) { // Get the index of this database int index = this.SelectedProject.GetDatabaseIndex(databaseForm.DatabaseSelectorControl.SelectedDatabase.DatabaseId); // if the index was found if (index >= 0) { // remove this database this.SelectedProject.Databases.RemoveAt(index); } // Add the selected database this.SelectedProject.Databases.Add(databaseForm.DatabaseSelectorControl.SelectedDatabase); // Display Database this.DisplaySelectedProject(); } } } }
/// <summary> /// This method prepares this control to be launched. /// </summary> /// <param name="selectedProjectArg"></param> internal void Setup(Project selectedProjectArg, DTNDatabase databaseArg) { // set selected project this.SelectedProject = selectedProjectArg; // set SelectedDatabase this.SelectedDatabase = databaseArg; // If this is not a new database (this is an edit) if (!this.SelectedDatabase.IsNew) { // if the form exists if (this.HasParentDatabaseSelectorForm) { // Change the text this.ParentDatabaseSelectorForm.Text = "Edit Database"; } // Display the selected database this.DisplaySelectedDatabase(); } }
/// <summary> /// This method loads a collection of 'DTNDatabase' objects. /// from the dataTable.Rows object passed in. /// </summary> /// <param name='dataTable'>The 'DataTable.Rows' to load from.</param> /// <returns>A DTNDatabase Collection.</returns> public static List <DTNDatabase> LoadCollection(DataTable dataTable) { // Initial Value List <DTNDatabase> dTNDatabases = new List <DTNDatabase>(); try { // Load Each row In DataTable foreach (DataRow row in dataTable.Rows) { // Create 'DTNDatabase' from rows DTNDatabase dTNDatabase = Load(row); // Add this object to collection dTNDatabases.Add(dTNDatabase); } } catch { } // return value return(dTNDatabases); }
/// <summary> /// This method converts a Data Table to a DTNTable for storing some of the scheme info in SQL. /// </summary> public static DTNTable ConvertDataTable(DataTable sourceTable, Project project, DTNDatabase dtnDatabase) { // initial value DTNTable table = null; // if the sourceTable exists and there are one or more Databases for this project if ((NullHelper.Exists(sourceTable, project, dtnDatabase)) && (project.HasDatabases) && (ListHelper.HasOneOrMoreItems(project.Databases))) { // Create a new instance of a 'DTNTable' object. table = new DTNTable(); // Set any properties to store table.ClassFileName = sourceTable.ClassFileName; table.ClassName = sourceTable.ClassName; table.Exclude = sourceTable.Exclude; table.CreateBindingCallback = sourceTable.CreateBindingCallback; // Only 1 Database is officially supported now table.DatabaseId = project.Databases[0].DatabaseId; // Convert the Fields table.Fields = ConvertDataFields(sourceTable.Fields, table.DatabaseId, project.ProjectId, sourceTable.TableId); table.IsView = sourceTable.IsView; table.ProjectId = project.ProjectId; table.Serializable = sourceTable.Serializable; table.TableName = sourceTable.Name; // Update 3.26.2019: The TableId does not actually exist on the DataTable. // This will only be set when a project is reopened so that duplicate tables // are not attempted to be inserted. table.UpdateIdentity(sourceTable.TableId); } // return value return(table); }
/// <summary> /// This method creates an instance of a /// 'FetchAllDTNDatabasesUsersStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'DTNDatabase_FetchAll'. /// </summary> /// <returns>An instance of a(n) 'FetchAllDTNDatabasesStoredProcedure' object.</returns> public new static FetchAllDTNDatabasesStoredProcedure CreateFetchAllDTNDatabasesStoredProcedure(DTNDatabase database) { // Initial value FetchAllDTNDatabasesStoredProcedure fetchAllDTNDatabasesStoredProcedure = new FetchAllDTNDatabasesStoredProcedure(); // verify the database exists if ((database != null) && (database.ProjectId > 0)) { // set the procedure name fetchAllDTNDatabasesStoredProcedure.ProcedureName = "DTNDatabase_FetchAllForProject"; // create the parameters fetchAllDTNDatabasesStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@ProjectId", database.ProjectId); } // return value return(fetchAllDTNDatabasesStoredProcedure); }
/// <summary> /// This method creates an instance of a /// 'FindDTNDatabaseStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'DTNDatabase_Find'. /// </summary> /// <param name="dTNDatabase">The 'DTNDatabase' to use to /// get the primary key parameter.</param> /// <returns>An instance of an FetchUserStoredProcedure</returns> public static FindDTNDatabaseStoredProcedure CreateFindDTNDatabaseStoredProcedure(DTNDatabase dTNDatabase) { // Initial Value FindDTNDatabaseStoredProcedure findDTNDatabaseStoredProcedure = null; // verify dTNDatabase exists if (dTNDatabase != null) { // Instanciate findDTNDatabaseStoredProcedure findDTNDatabaseStoredProcedure = new FindDTNDatabaseStoredProcedure(); // Now create parameters for this procedure findDTNDatabaseStoredProcedure.Parameters = CreatePrimaryKeyParameter(dTNDatabase); } // return value return(findDTNDatabaseStoredProcedure); }
/// <summary> /// This method creates an instance of an /// 'DeleteDTNDatabase'StoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'DTNDatabase_Delete'. /// </summary> /// <param name="dTNDatabase">The 'DTNDatabase' to Delete.</param> /// <returns>An instance of a 'DeleteDTNDatabaseStoredProcedure' object.</returns> public static DeleteDTNDatabaseStoredProcedure CreateDeleteDTNDatabaseStoredProcedure(DTNDatabase dTNDatabase) { // Initial Value DeleteDTNDatabaseStoredProcedure deleteDTNDatabaseStoredProcedure = new DeleteDTNDatabaseStoredProcedure(); // Now Create Parameters For The DeleteProc deleteDTNDatabaseStoredProcedure.Parameters = CreatePrimaryKeyParameter(dTNDatabase); // return value return(deleteDTNDatabaseStoredProcedure); }
/// <summary> /// This method creates an instance of a /// 'FetchAllDTNDatabasesStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'DTNDatabase_FetchAll'. /// </summary> /// <returns>An instance of a(n) 'FetchAllDTNDatabasesStoredProcedure' object.</returns> public static FetchAllDTNDatabasesStoredProcedure CreateFetchAllDTNDatabasesStoredProcedure(DTNDatabase dTNDatabase) { // Initial value FetchAllDTNDatabasesStoredProcedure fetchAllDTNDatabasesStoredProcedure = new FetchAllDTNDatabasesStoredProcedure(); // return value return(fetchAllDTNDatabasesStoredProcedure); }
/// <summary> /// Converts a ObjectLibrary.Database /// SQLServer database to a DataJuggler.Net Database /// and reads the schema. /// </summary> /// <param name="databases"></param> /// <returns></returns> private Database ConvertSQLDatabase(DTNDatabase db, List <Enumeration> enumerations) { // Create sqlConnector SQLDatabaseConnector sqlConnector = new SQLDatabaseConnector(); // if the tables are not loaded for the db if ((NullHelper.Exists(db)) && (!ListHelper.HasOneOrMoreItems(db.Tables))) { // Create a new instance of a 'Gateway' object. Gateway gateway = new Gateway(); // load the tables db.Tables = gateway.LoadDTNTablesByProjectId(this.CurrentProject.ProjectId); } // if the DataManager does not exist if (NullHelper.IsNull(DataManager)) { if (NullHelper.Exists(CurrentProject)) { // Don't know why this is still here, VB.Net was abandoned in 2006 or 2007 DataManager = new DataManager(CurrentProject.ProjectFolder, currentProject.ProjectName, DataManager.ClassOutputLanguage.CSharp); } else { // exit return(null); } } // Create Database DataJuggler.Net.Database database = new Database(this.DataManager); // Set Database Properties database.ClassFileName = this.DataManager.ClassFileName; database.ClassName = db.DatabaseName + ".cs"; database.ConnectionString = db.ConnectionString; database.Name = db.DatabaseName; database.ParentDataManager = this.DataManager; database.Password = db.DBPassword; database.Serializable = true; database.StoredProcedures = new List <StoredProcedure>(); // set connection string sqlConnector.DatabaseConnection.ConnectionString = database.ConnectionString; // open database sqlConnector.DatabaseConnection.Open(); // read database schema database = sqlConnector.LoadDatabaseSchema(database); // close this database sqlConnector.DatabaseConnection.Close(); // if there are one or more tables if (ListHelper.HasOneOrMoreItems(database.Tables)) { // iterate the collection of tables foreach (DataTable table in database.Tables) { // if a DotNet5 project and EnableBlazorFeatures is true and BindingCallBack option is set to CreateBinding if ((currentProject.TargetFramework != TargetFrameworkEnum.NetFramework) && (currentProject.EnableBlazorFeatures) && (currentProject.BindingCallbackOption == BindingCallbackOptionEnum.Create_Binding)) { // Create the BindingCall back needs to be set to true to code generate the Callback. table.CreateBindingCallback = true; } // if there are one or more fields if (ListHelper.HasOneOrMoreItems(table.Fields, enumerations)) { // iterate the fields foreach (DataField field in table.Fields) { // now iterate te enumerations foreach (Enumeration enumeration in enumerations) { // if this field is designated as an enumeration if (TextHelper.IsEqual(field.FieldName, enumeration.FieldName)) { // set to true field.IsEnumeration = true; // Set this as enumeration field.DataType = DataManager.DataTypeEnum.Enumeration; // Set the EnumerationName field.EnumDataTypeName = enumeration.EnumerationName; } } } } } } // return value return(database); }
/// <summary> /// This method creates an instance of an /// 'UpdateDTNDatabaseStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'DTNDatabase_Update'. /// </summary> /// <param name="dTNDatabase"The 'DTNDatabase' object to update</param> /// <returns>An instance of a 'UpdateDTNDatabaseStoredProcedure</returns> public static UpdateDTNDatabaseStoredProcedure CreateUpdateDTNDatabaseStoredProcedure(DTNDatabase dTNDatabase) { // Initial Value UpdateDTNDatabaseStoredProcedure updateDTNDatabaseStoredProcedure = null; // verify dTNDatabase exists if (dTNDatabase != null) { // Instanciate updateDTNDatabaseStoredProcedure updateDTNDatabaseStoredProcedure = new UpdateDTNDatabaseStoredProcedure(); // Now create parameters for this procedure updateDTNDatabaseStoredProcedure.Parameters = CreateUpdateParameters(dTNDatabase); } // return value return(updateDTNDatabaseStoredProcedure); }
/// <summary> /// This method creates the sql Parameters[] needed for /// update an existing dTNDatabase. /// </summary> /// <param name="dTNDatabase">The 'DTNDatabase' to update.</param> /// <returns></returns> internal static SqlParameter[] CreateUpdateParameters(DTNDatabase dTNDatabase) { // Initial Values SqlParameter[] parameters = new SqlParameter[12]; SqlParameter param = null; // verify dTNDatabaseexists if (dTNDatabase != null) { // Create parameter for [AuthenticationType] param = new SqlParameter("@AuthenticationType", dTNDatabase.AuthenticationType); // set parameters[0] parameters[0] = param; // Create parameter for [ConnectionString] param = new SqlParameter("@ConnectionString", dTNDatabase.ConnectionString); // set parameters[1] parameters[1] = param; // Create parameter for [DatabaseName] param = new SqlParameter("@DatabaseName", dTNDatabase.DatabaseName); // set parameters[2] parameters[2] = param; // Create parameter for [DatabaseType] param = new SqlParameter("@DatabaseType", dTNDatabase.DatabaseType); // set parameters[3] parameters[3] = param; // Create parameter for [DBPassword] param = new SqlParameter("@DBPassword", dTNDatabase.DBPassword); // set parameters[4] parameters[4] = param; // Create parameter for [Exclude] param = new SqlParameter("@Exclude", dTNDatabase.Exclude); // set parameters[5] parameters[5] = param; // Create parameter for [Path] param = new SqlParameter("@Path", dTNDatabase.Path); // set parameters[6] parameters[6] = param; // Create parameter for [ProjectId] param = new SqlParameter("@ProjectId", dTNDatabase.ProjectId); // set parameters[7] parameters[7] = param; // Create parameter for [Serializable] param = new SqlParameter("@Serializable", dTNDatabase.Serializable); // set parameters[8] parameters[8] = param; // Create parameter for [ServerName] param = new SqlParameter("@ServerName", dTNDatabase.ServerName); // set parameters[9] parameters[9] = param; // Create parameter for [UserId] param = new SqlParameter("@UserId", dTNDatabase.UserId); // set parameters[10] parameters[10] = param; // Create parameter for [DatabaseId] param = new SqlParameter("@DatabaseId", dTNDatabase.DatabaseId); parameters[11] = param; } // return value return(parameters); }
/// <summary> /// This method creates an instance of an /// 'InsertDTNDatabaseStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'DTNDatabase_Insert'. /// </summary> /// <param name="dTNDatabase"The 'DTNDatabase' object to insert</param> /// <returns>An instance of a 'InsertDTNDatabaseStoredProcedure' object.</returns> public static InsertDTNDatabaseStoredProcedure CreateInsertDTNDatabaseStoredProcedure(DTNDatabase dTNDatabase) { // Initial Value InsertDTNDatabaseStoredProcedure insertDTNDatabaseStoredProcedure = null; // verify dTNDatabase exists if (dTNDatabase != null) { // Instanciate insertDTNDatabaseStoredProcedure insertDTNDatabaseStoredProcedure = new InsertDTNDatabaseStoredProcedure(); // Now create parameters for this procedure insertDTNDatabaseStoredProcedure.Parameters = CreateInsertParameters(dTNDatabase); } // return value return(insertDTNDatabaseStoredProcedure); }
/// <summary> /// This method adds all the databases in the current project /// to the DataManager (DM). /// </summary> /// <param name="currentProject"></param> public void AddDatabases(ref Project currentProject) { // Make sure the CurrentProject is set; I think this changed and now the CurrentProject // is created earlier. if ((CurrentProject == null) || (!CurrentProject.Equals(currentProject))) { // this has to be set before the DataManager can be created this.CurrentProject = currentProject; } // locals Database database = null; List <Enumeration> enumerations = null; List <DTNDatabase> databases = null; // If the currentProject object exists if (NullHelper.Exists(currentProject)) { // set the databases databases = currentProject.Databases; // if the current project has enumerations if (ListHelper.HasOneOrMoreItems(currentProject.Enumerations)) { // get a list of enumerations enumerations = new List <Enumeration>(); // if the enumrations exist foreach (Enumeration enumeration in currentProject.Enumerations) { // add thsi enumerations enumerations.Add(enumeration); } } } // if databases exists if ((ListHelper.HasOneOrMoreItems(databases)) && (DataManager != null)) { // loop through each database foreach (DTNDatabase db in databases) { // convert to DataJuggler.Net.Sql database database = ConvertSQLDatabase(db, enumerations); // if the database exists if (database != null) { // If the database has Serializable selected if (db.Serializable) { // Serialize each table foreach (DataTable table in database.Tables) { // Set serializable on the table table.Serializable = true; } } // if there are one or more tables in the current Project if (ListHelper.HasOneOrMoreItems(CurrentProject.Tables)) { // iterate the tables foreach (DTNTable table in CurrentProject.Tables) { // attempt to find this table in this database DataTable dataTable = database.Tables.FirstOrDefault(x => x.Name == table.TableName); // If the dataTable object exists if (NullHelper.Exists(dataTable)) { // Store the tableId in dataTable so a save performs an update and not a duplicate insert dataTable.TableId = table.TableId; // Set the value for Exclude in the dataTable dataTable.Exclude = table.Exclude; dataTable.CreateBindingCallback = table.CreateBindingCallback; // if this table has one or more fields if (ListHelper.HasOneOrMoreItems(table.Fields)) { // iterate the fields foreach (DTNField field in table.Fields) { // We now must find the field in this DataTable DataField dataField = dataTable.Fields.FirstOrDefault(x => x.FieldName == field.FieldName); // If the dataField object exists if (NullHelper.Exists(dataField)) { // Store the FieldId, which is not really mapped, but when the field is converted // back to a DTNField, this FieldId is converted if present. dataField.FieldId = field.FieldId; // set Exclude dataField.Exclude = field.Exclude; } } } } } } // Add this database this.DataManager.Databases.Add(database); } } // now we must recreate the currentProject.Tables to match the database if ((DataManager != null) && (DataManager.Databases != null) && (DataManager.Databases.Count > 0) && (DataManager.Databases[0].Tables.Count > 0)) { // create the currentTables List <DTNTable> currentTables = new List <DTNTable>(); // iterate the databases foreach (Database db in DataManager.Databases) { // attempt to find the database DTNDatabase dtnDatabase = currentProject.Databases.FirstOrDefault(x => x.DatabaseName == db.Name); // If the dtnDatabase object exists if (NullHelper.Exists(dtnDatabase)) { // iterate the tables foreach (DataTable table in db.Tables) { // create the table DTNTable dtnTable = DataConverter.ConvertDataTable(table, currentProject, dtnDatabase); // We must check if we have an existing table already with this name that is excluded DTNTable existingTable = CurrentProject.Tables.FirstOrDefault(x => x.TableName == table.Name); // if the table exists if (NullHelper.Exists(dtnTable)) { // if the existingTable was found if (NullHelper.Exists(existingTable)) { // Update the value for exclude dtnTable.Exclude = existingTable.Exclude; dtnTable.CreateBindingCallback = existingTable.CreateBindingCallback; } // Add this table currentTables.Add(dtnTable); } } } } // Now set the CurrentProject.Tables back currentProject.Tables = currentTables; } } }