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