/// <summary> /// This method loads a 'DTNProcedure' object /// from the dataRow passed in. /// </summary> /// <param name='dataRow'>The 'DataRow' to load from.</param> /// <returns>A 'DTNProcedure' DataObject.</returns> public static DTNProcedure Load(DataRow dataRow) { // Initial Value DTNProcedure dTNProcedure = new DTNProcedure(); // Create field Integers int activefield = 0; int namefield = 1; int procedureIdfield = 2; int projectIdfield = 3; int tableIdfield = 4; try { // Load Each field dTNProcedure.Active = DataHelper.ParseBoolean(dataRow.ItemArray[activefield], false); dTNProcedure.Name = DataHelper.ParseString(dataRow.ItemArray[namefield]); dTNProcedure.UpdateIdentity(DataHelper.ParseInteger(dataRow.ItemArray[procedureIdfield], 0)); dTNProcedure.ProjectId = DataHelper.ParseInteger(dataRow.ItemArray[projectIdfield], 0); dTNProcedure.TableId = DataHelper.ParseInteger(dataRow.ItemArray[tableIdfield], 0); } catch { } // return value return(dTNProcedure); }
/// <summary> /// This method finds a 'DTNProcedure' object. /// This method uses the 'DTNProcedure_Find' procedure. /// </summary> /// <returns>A 'DTNProcedure' object.</returns> /// </summary> public DTNProcedure FindDTNProcedure(FindDTNProcedureStoredProcedure findDTNProcedureProc, DataConnector databaseConnector) { // Initial Value DTNProcedure dTNProcedure = null; // Verify database connection is connected if ((databaseConnector != null) && (databaseConnector.Connected)) { // First Get Dataset DataSet dTNProcedureDataSet = this.DataHelper.LoadDataSet(findDTNProcedureProc, databaseConnector); // Verify DataSet Exists if (dTNProcedureDataSet != null) { // Get DataTable From DataSet DataRow row = this.DataHelper.ReturnFirstRow(dTNProcedureDataSet); // if row exists if (row != null) { // Load DTNProcedure dTNProcedure = DTNProcedureReader.Load(row); } } } // return value return(dTNProcedure); }
/// <summary> /// Saves a 'DTNProcedure' object into the database. /// This method calls the 'Insert' or 'Update' method. /// </summary> /// <param name='dTNProcedure'>The 'DTNProcedure' object to save.</param> /// <returns>True if successful or false if not.</returns> public bool Save(ref DTNProcedure dTNProcedure) { // Initial value bool saved = false; // If the dTNProcedure exists. if (dTNProcedure != null) { // Is this a new DTNProcedure if (dTNProcedure.IsNew) { // Insert new DTNProcedure int newIdentity = this.Insert(dTNProcedure); // if insert was successful if (newIdentity > 0) { // Update Identity dTNProcedure.UpdateIdentity(newIdentity); // Set return value saved = true; } } else { // Update DTNProcedure saved = this.Update(dTNProcedure); } } // return value return(saved); }
/// <summary> /// This method deletes a 'DTNProcedure' object. /// </summary> /// <param name='List<PolymorphicObject>'>The 'DTNProcedure' to delete. /// <returns>A PolymorphicObject object with a Boolean value. internal PolymorphicObject DeleteDTNProcedure(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 DeleteDTNProcedureStoredProcedure deleteDTNProcedureProc = null; // verify the first parameters is a(n) 'DTNProcedure'. if (parameters[0].ObjectValue as DTNProcedure != null) { // Create DTNProcedure DTNProcedure dTNProcedure = (DTNProcedure)parameters[0].ObjectValue; // verify dTNProcedure exists if (dTNProcedure != null) { // Now create deleteDTNProcedureProc from DTNProcedureWriter // The DataWriter converts the 'DTNProcedure' // to the SqlParameter[] array needed to delete a 'DTNProcedure'. deleteDTNProcedureProc = DTNProcedureWriter.CreateDeleteDTNProcedureStoredProcedure(dTNProcedure); } } // Verify deleteDTNProcedureProc exists if (deleteDTNProcedureProc != null) { // Execute Delete Stored Procedure bool deleted = this.DataManager.DTNProcedureManager.DeleteDTNProcedure(deleteDTNProcedureProc, 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 'DTNProcedure' object. /// </summary> /// <param name='List<PolymorphicObject>'>The 'DTNProcedure' to delete. /// <returns>A PolymorphicObject object with a Boolean value. internal PolymorphicObject FindDTNProcedure(List <PolymorphicObject> parameters, DataConnector dataConnector) { // Initial Value PolymorphicObject returnObject = new PolymorphicObject(); // locals DTNProcedure dTNProcedure = null; // If the data connection is connected if ((dataConnector != null) && (dataConnector.Connected == true)) { // Create Find StoredProcedure FindDTNProcedureStoredProcedure findDTNProcedureProc = null; // verify the first parameters is a 'DTNProcedure'. if (parameters[0].ObjectValue as DTNProcedure != null) { // Get DTNProcedureParameter DTNProcedure paramDTNProcedure = (DTNProcedure)parameters[0].ObjectValue; // verify paramDTNProcedure exists if (paramDTNProcedure != null) { // Now create findDTNProcedureProc from DTNProcedureWriter // The DataWriter converts the 'DTNProcedure' // to the SqlParameter[] array needed to find a 'DTNProcedure'. findDTNProcedureProc = DTNProcedureWriter.CreateFindDTNProcedureStoredProcedure(paramDTNProcedure); } // Verify findDTNProcedureProc exists if (findDTNProcedureProc != null) { // Execute Find Stored Procedure dTNProcedure = this.DataManager.DTNProcedureManager.FindDTNProcedure(findDTNProcedureProc, dataConnector); // if dataObject exists if (dTNProcedure != null) { // set returnObject.ObjectValue returnObject.ObjectValue = dTNProcedure; } } } 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 'DTNProcedure' objects. /// </summary> /// <param name='List<PolymorphicObject>'>The 'DTNProcedure' to delete. /// <returns>A PolymorphicObject object with all 'DTNProcedures' objects. internal PolymorphicObject FetchAll(List <PolymorphicObject> parameters, DataConnector dataConnector) { // Initial Value PolymorphicObject returnObject = new PolymorphicObject(); // locals List <DTNProcedure> dTNProcedureListCollection = null; // Create FetchAll StoredProcedure FetchAllDTNProceduresStoredProcedure fetchAllProc = null; // If the data connection is connected if ((dataConnector != null) && (dataConnector.Connected == true)) { // Get DTNProcedureParameter // Declare Parameter DTNProcedure paramDTNProcedure = null; // verify the first parameters is a(n) 'DTNProcedure'. if (parameters[0].ObjectValue as DTNProcedure != null) { // Get DTNProcedureParameter paramDTNProcedure = (DTNProcedure)parameters[0].ObjectValue; } // Now create FetchAllDTNProceduresProc from DTNProcedureWriter fetchAllProc = DTNProcedureWriter.CreateFetchAllDTNProceduresStoredProcedure(paramDTNProcedure); } // Verify fetchAllProc exists if (fetchAllProc != null) { // Execute FetchAll Stored Procedure dTNProcedureListCollection = this.DataManager.DTNProcedureManager.FetchAllDTNProcedures(fetchAllProc, dataConnector); // if dataObjectCollection exists if (dTNProcedureListCollection != null) { // set returnObject.ObjectValue returnObject.ObjectValue = dTNProcedureListCollection; } } else { // Raise Error Data Connection Not Available throw new Exception("The database connection is not available."); } // return value return(returnObject); }
/// <summary> /// Deletes a 'DTNProcedure' from the database /// This method calls the DataBridgeManager to execute the delete using the /// procedure 'DTNProcedure_Delete'. /// </summary> /// <param name='dtnprocedure'>The 'DTNProcedure' to delete.</param> /// <returns>True if the delete is successful or false if not.</returns> public bool Delete(DTNProcedure tempDTNProcedure) { // locals bool deleted = false; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "DeleteDTNProcedure"; string objectName = "ApplicationLogicComponent.Controllers"; try { // verify tempdTNProcedure exists before attemptintg to delete if (tempDTNProcedure != null) { // Create Delegate For DataOperation ApplicationController.DataOperationMethod deleteDTNProcedureMethod = this.AppController.DataBridge.DataOperations.DTNProcedureMethods.DeleteDTNProcedure; // Create parameters for this method List <PolymorphicObject> parameters = CreateDTNProcedureParameter(tempDTNProcedure); // Perform DataOperation PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, deleteDTNProcedureMethod, 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 'DTNProcedure' data operation. /// </summary> /// <param name='dtnprocedure'>The 'DTNProcedure' to use as the first /// parameter (parameters[0]).</param> /// <returns>A List<PolymorphicObject> collection.</returns> private List <PolymorphicObject> CreateDTNProcedureParameter(DTNProcedure dTNProcedure) { // Initial Value List <PolymorphicObject> parameters = new List <PolymorphicObject>(); // Create PolymorphicObject to hold the parameter PolymorphicObject parameter = new PolymorphicObject(); // Set parameter.ObjectValue parameter.ObjectValue = dTNProcedure; // 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='dTNProcedure'>The 'DTNProcedure' to get the primary key of.</param> /// <returns>A SqlParameter[] array which contains the primary key value. /// to delete.</returns> internal static SqlParameter[] CreatePrimaryKeyParameter(DTNProcedure dTNProcedure) { // Initial Value SqlParameter[] parameters = new SqlParameter[1]; // verify user exists if (dTNProcedure != null) { // Create PrimaryKey Parameter SqlParameter @ProcedureId = new SqlParameter("@ProcedureId", dTNProcedure.ProcedureId); // Set parameters[0] to @ProcedureId parameters[0] = @ProcedureId; } // return value return(parameters); }
/// <summary> /// Finds a 'DTNProcedure' object by the primary key. /// This method used the DataBridgeManager to execute the 'Find' using the /// procedure 'DTNProcedure_Find'</param> /// </summary> /// <param name='tempDTNProcedure'>A temporary DTNProcedure for passing values.</param> /// <returns>A 'DTNProcedure' object if found else a null 'DTNProcedure'.</returns> public DTNProcedure Find(DTNProcedure tempDTNProcedure) { // Initial values DTNProcedure dTNProcedure = null; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "Find"; string objectName = "ApplicationLogicComponent.Controllers"; try { // If object exists if (tempDTNProcedure != null) { // Create DataOperation ApplicationController.DataOperationMethod findMethod = this.AppController.DataBridge.DataOperations.DTNProcedureMethods.FindDTNProcedure; // Create parameters for this method List <PolymorphicObject> parameters = CreateDTNProcedureParameter(tempDTNProcedure); // Perform DataOperation PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, findMethod, parameters); // If return object exists if ((returnObject != null) && (returnObject.ObjectValue as DTNProcedure != null)) { // Get ReturnObject dTNProcedure = (DTNProcedure)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(dTNProcedure); }
/// <summary> /// Insert a 'DTNProcedure' object into the database. /// This method uses the DataBridgeManager to execute the 'Insert' using the /// procedure 'DTNProcedure_Insert'.</param> /// </summary> /// <param name='dTNProcedure'>The 'DTNProcedure' object to insert.</param> /// <returns>The id (int) of the new 'DTNProcedure' object that was inserted.</returns> public int Insert(DTNProcedure dTNProcedure) { // Initial values int newIdentity = -1; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "Insert"; string objectName = "ApplicationLogicComponent.Controllers"; try { // If DTNProcedureexists if (dTNProcedure != null) { ApplicationController.DataOperationMethod insertMethod = this.AppController.DataBridge.DataOperations.DTNProcedureMethods.InsertDTNProcedure; // Create parameters for this method List <PolymorphicObject> parameters = CreateDTNProcedureParameter(dTNProcedure); // 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 'DTNProcedure' object in the database. /// This method used the DataBridgeManager to execute the 'Update' using the /// procedure 'DTNProcedure_Update'.</param> /// </summary> /// <param name='dTNProcedure'>The 'DTNProcedure' object to update.</param> /// <returns>True if successful else false if not.</returns> public bool Update(DTNProcedure dTNProcedure) { // Initial value bool saved = false; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "Update"; string objectName = "ApplicationLogicComponent.Controllers"; try { if (dTNProcedure != null) { // Create Delegate ApplicationController.DataOperationMethod updateMethod = this.AppController.DataBridge.DataOperations.DTNProcedureMethods.UpdateDTNProcedure; // Create parameters for this method List <PolymorphicObject> parameters = CreateDTNProcedureParameter(dTNProcedure); // 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 creates the sql Parameters[] needed for /// update an existing dTNProcedure. /// </summary> /// <param name="dTNProcedure">The 'DTNProcedure' to update.</param> /// <returns></returns> internal static SqlParameter[] CreateUpdateParameters(DTNProcedure dTNProcedure) { // Initial Values SqlParameter[] parameters = new SqlParameter[5]; SqlParameter param = null; // verify dTNProcedureexists if (dTNProcedure != null) { // Create parameter for [Active] param = new SqlParameter("@Active", dTNProcedure.Active); // set parameters[0] parameters[0] = param; // Create parameter for [Name] param = new SqlParameter("@Name", dTNProcedure.Name); // set parameters[1] parameters[1] = param; // Create parameter for [ProjectId] param = new SqlParameter("@ProjectId", dTNProcedure.ProjectId); // set parameters[2] parameters[2] = param; // Create parameter for [TableId] param = new SqlParameter("@TableId", dTNProcedure.TableId); // set parameters[3] parameters[3] = param; // Create parameter for [ProcedureId] param = new SqlParameter("@ProcedureId", dTNProcedure.ProcedureId); parameters[4] = param; } // return value return(parameters); }
/// <summary> /// This method loads a collection of 'DTNProcedure' objects. /// from the dataTable.Rows object passed in. /// </summary> /// <param name='dataTable'>The 'DataTable.Rows' to load from.</param> /// <returns>A DTNProcedure Collection.</returns> public static List <DTNProcedure> LoadCollection(DataTable dataTable) { // Initial Value List <DTNProcedure> dTNProcedures = new List <DTNProcedure>(); try { // Load Each row In DataTable foreach (DataRow row in dataTable.Rows) { // Create 'DTNProcedure' from rows DTNProcedure dTNProcedure = Load(row); // Add this object to collection dTNProcedures.Add(dTNProcedure); } } catch { } // return value return(dTNProcedures); }
/// <summary> /// This method creates an instance of an /// 'InsertDTNProcedureStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'DTNProcedure_Insert'. /// </summary> /// <param name="dTNProcedure"The 'DTNProcedure' object to insert</param> /// <returns>An instance of a 'InsertDTNProcedureStoredProcedure' object.</returns> public static InsertDTNProcedureStoredProcedure CreateInsertDTNProcedureStoredProcedure(DTNProcedure dTNProcedure) { // Initial Value InsertDTNProcedureStoredProcedure insertDTNProcedureStoredProcedure = null; // verify dTNProcedure exists if (dTNProcedure != null) { // Instanciate insertDTNProcedureStoredProcedure insertDTNProcedureStoredProcedure = new InsertDTNProcedureStoredProcedure(); // Now create parameters for this procedure insertDTNProcedureStoredProcedure.Parameters = CreateInsertParameters(dTNProcedure); } // return value return(insertDTNProcedureStoredProcedure); }
/// <summary> /// This method creates an instance of an /// 'UpdateDTNProcedureStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'DTNProcedure_Update'. /// </summary> /// <param name="dTNProcedure"The 'DTNProcedure' object to update</param> /// <returns>An instance of a 'UpdateDTNProcedureStoredProcedure</returns> public static UpdateDTNProcedureStoredProcedure CreateUpdateDTNProcedureStoredProcedure(DTNProcedure dTNProcedure) { // Initial Value UpdateDTNProcedureStoredProcedure updateDTNProcedureStoredProcedure = null; // verify dTNProcedure exists if (dTNProcedure != null) { // Instanciate updateDTNProcedureStoredProcedure updateDTNProcedureStoredProcedure = new UpdateDTNProcedureStoredProcedure(); // Now create parameters for this procedure updateDTNProcedureStoredProcedure.Parameters = CreateUpdateParameters(dTNProcedure); } // return value return(updateDTNProcedureStoredProcedure); }
/// <summary> /// This method creates an instance of a /// 'FindDTNProcedureStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'DTNProcedure_Find'. /// </summary> /// <param name="dTNProcedure">The 'DTNProcedure' to use to /// get the primary key parameter.</param> /// <returns>An instance of an FetchUserStoredProcedure</returns> public static FindDTNProcedureStoredProcedure CreateFindDTNProcedureStoredProcedure(DTNProcedure dTNProcedure) { // Initial Value FindDTNProcedureStoredProcedure findDTNProcedureStoredProcedure = null; // verify dTNProcedure exists if (dTNProcedure != null) { // Instanciate findDTNProcedureStoredProcedure findDTNProcedureStoredProcedure = new FindDTNProcedureStoredProcedure(); // Now create parameters for this procedure findDTNProcedureStoredProcedure.Parameters = CreatePrimaryKeyParameter(dTNProcedure); } // return value return(findDTNProcedureStoredProcedure); }
/// <summary> /// This method creates an instance of a /// 'FetchAllDTNProceduresStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'DTNProcedure_FetchAll'. /// </summary> /// <returns>An instance of a(n) 'FetchAllDTNProceduresStoredProcedure' object.</returns> public static FetchAllDTNProceduresStoredProcedure CreateFetchAllDTNProceduresStoredProcedure(DTNProcedure dTNProcedure) { // Initial value FetchAllDTNProceduresStoredProcedure fetchAllDTNProceduresStoredProcedure = new FetchAllDTNProceduresStoredProcedure(); // return value return(fetchAllDTNProceduresStoredProcedure); }
/// <summary> /// This method creates an instance of an /// 'DeleteDTNProcedure'StoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'DTNProcedure_Delete'. /// </summary> /// <param name="dTNProcedure">The 'DTNProcedure' to Delete.</param> /// <returns>An instance of a 'DeleteDTNProcedureStoredProcedure' object.</returns> public static DeleteDTNProcedureStoredProcedure CreateDeleteDTNProcedureStoredProcedure(DTNProcedure dTNProcedure) { // Initial Value DeleteDTNProcedureStoredProcedure deleteDTNProcedureStoredProcedure = new DeleteDTNProcedureStoredProcedure(); // Now Create Parameters For The DeleteProc deleteDTNProcedureStoredProcedure.Parameters = CreatePrimaryKeyParameter(dTNProcedure); // return value return(deleteDTNProcedureStoredProcedure); }