/// <summary>
/// This method returns the Field
/// </summary>
public static DTNField FindField(List <DTNField> fields, int fieldId)
{
// initial value
DTNField field = null;
// If the fields collection exists and has one or more items
if ((ListHelper.HasOneOrMoreItems(fields)) && (fieldId > 0))
{
// Iterate the collection of DTNField objects
foreach (DTNField tempField in fields)
{
// if this is the field being sought
if (tempField.FieldId == fieldId)
{
// set the return value
field = tempField;
// break;
break;
}
}
}
// return value
return(field);
}
/// <summary>
/// This method returns the Primary Key for a table.
/// This method is for single field Primary Keys, not
/// Composite primary keys consisting of multiple fields.
/// You can manually add a second jparameter if needed for now.
/// </summary>
public DTNField FindPrimaryKey(DTNTable table)
{
// initial value
DTNField primaryKey = null;
// if the table has fields
if ((NullHelper.Exists(table)) && (table.HasFields))
{
// iterate the fields
foreach (DTNField field in table.Fields)
{
// the field is a PrimaryKey
if (field.PrimaryKey)
{
// set the reeturn value
primaryKey = field;
// no reason to stick around until multiple primary key fields is handled.
break;
}
}
}
// return value
return(primaryKey);
}
/// <summary>
/// This method returns a list of Data Fields
/// </summary>
public static List <DTNField> ConvertDataFields(List <FieldSetFieldView> sourceFields, int databaseId, int projectId, int tableId)
{
// initial value
List <DTNField> fields = null;
// local
DTNField field = null;
// If the sourceFields collection exists and has one or more items
if (ListHelper.HasOneOrMoreItems(sourceFields))
{
// create the return value
fields = new List <DTNField>();
// Iterate the collection of DataField objects
foreach (FieldSetFieldView fieldSetFieldView in sourceFields)
{
// Convert this field
field = ConvertDataField(fieldSetFieldView, databaseId, projectId, tableId);
// Add this field
fields.Add(field);
}
}
// return value
return(fields);
}
/// <summary>
/// This method converts a DTNField to a DataField.
/// </summary>
public static DataField ConvertDataField(DTNField sourceField)
{
// initial value
DataField field = null;
// If the sourceField object exists
if (NullHelper.Exists(sourceField))
{
// Create a new instance of a 'DTNField' object.
field = new DataField();
// Set each property
field.AccessMode = (DataManager.AccessMode)sourceField.AccessMode;
field.Caption = sourceField.Caption;
// Both enums derive from int, so the double cast converts the Enum types
field.DataType = (DataManager.DataTypeEnum)sourceField.DataType;
field.DecimalPlaces = sourceField.DecimalPlaces;
field.DefaultValue = sourceField.DefaultValue;
field.FieldName = sourceField.FieldName;
field.FieldOrdinal = sourceField.FieldOrdinal;
field.Size = sourceField.FieldSize;
field.PrimaryKey = sourceField.PrimaryKey;
field.Required = sourceField.Required;
field.Scope = (DataManager.Scope)sourceField.Scope;
field.Exclude = sourceField.Exclude;
}
// return value
return(field);
}
/// <summary>
/// Saves a 'DTNField' object into the database.
/// This method calls the 'Insert' or 'Update' method.
/// </summary>
/// <param name='dTNField'>The 'DTNField' object to save.</param>
/// <returns>True if successful or false if not.</returns>
public bool Save(ref DTNField dTNField)
{
// Initial value
bool saved = false;
// If the dTNField exists.
if (dTNField != null)
{
// Is this a new DTNField
if (dTNField.IsNew)
{
// Insert new DTNField
int newIdentity = this.Insert(dTNField);
// if insert was successful
if (newIdentity > 0)
{
// Update Identity
dTNField.UpdateIdentity(newIdentity);
// Set return value
saved = true;
}
}
else
{
// Update DTNField
saved = this.Update(dTNField);
}
}
// return value
return(saved);
}
/// <summary>
/// This method finds a 'DTNField' object.
/// This method uses the 'DTNField_Find' procedure.
/// </summary>
/// <returns>A 'DTNField' object.</returns>
/// </summary>
public DTNField FindDTNField(FindDTNFieldStoredProcedure findDTNFieldProc, DataConnector databaseConnector)
{
// Initial Value
DTNField dTNField = null;
// Verify database connection is connected
if ((databaseConnector != null) && (databaseConnector.Connected))
{
// First Get Dataset
DataSet dTNFieldDataSet = this.DataHelper.LoadDataSet(findDTNFieldProc, databaseConnector);
// Verify DataSet Exists
if (dTNFieldDataSet != null)
{
// Get DataTable From DataSet
DataRow row = this.DataHelper.ReturnFirstRow(dTNFieldDataSet);
// if row exists
if (row != null)
{
// Load DTNField
dTNField = DTNFieldReader.Load(row);
}
}
}
// return value
return(dTNField);
}
/// <summary>
/// This method deletes a 'DTNField' object.
/// </summary>
/// <param name='List<PolymorphicObject>'>The 'DTNField' to delete.
/// <returns>A PolymorphicObject object with a Boolean value.
internal PolymorphicObject DeleteDTNField(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
DeleteDTNFieldStoredProcedure deleteDTNFieldProc = null;
// verify the first parameters is a(n) 'DTNField'.
if (parameters[0].ObjectValue as DTNField != null)
{
// Create DTNField
DTNField dTNField = (DTNField)parameters[0].ObjectValue;
// verify dTNField exists
if (dTNField != null)
{
// Now create deleteDTNFieldProc from DTNFieldWriter
// The DataWriter converts the 'DTNField'
// to the SqlParameter[] array needed to delete a 'DTNField'.
deleteDTNFieldProc = DTNFieldWriter.CreateDeleteDTNFieldStoredProcedure(dTNField);
}
}
// Verify deleteDTNFieldProc exists
if (deleteDTNFieldProc != null)
{
// Execute Delete Stored Procedure
bool deleted = this.DataManager.DTNFieldManager.DeleteDTNField(deleteDTNFieldProc, 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 loads a 'DTNField' object
/// from the dataRow passed in.
/// </summary>
/// <param name='dataRow'>The 'DataRow' to load from.</param>
/// <returns>A 'DTNField' DataObject.</returns>
public static DTNField Load(DataRow dataRow)
{
// Initial Value
DTNField dTNField = new DTNField();
// Create field Integers
int accessModefield = 0;
int captionfield = 1;
int databaseIdfield = 2;
int dataTypefield = 3;
int decimalPlacesfield = 4;
int defaultValuefield = 5;
int enumDataTypeNamefield = 6;
int excludefield = 7;
int fieldIdfield = 8;
int fieldNamefield = 9;
int fieldOrdinalfield = 10;
int fieldSizefield = 11;
int isEnumerationfield = 12;
int isNullablefield = 13;
int primaryKeyfield = 14;
int projectIdfield = 15;
int requiredfield = 16;
int scopefield = 17;
int tableIdfield = 18;
try
{
// Load Each field
dTNField.AccessMode = (AccessModeEnum)DataHelper.ParseInteger(dataRow.ItemArray[accessModefield], 0);
dTNField.Caption = DataHelper.ParseString(dataRow.ItemArray[captionfield]);
dTNField.DatabaseId = DataHelper.ParseInteger(dataRow.ItemArray[databaseIdfield], 0);
dTNField.DataType = (DataTypeEnum)DataHelper.ParseInteger(dataRow.ItemArray[dataTypefield], 0);
dTNField.DecimalPlaces = DataHelper.ParseInteger(dataRow.ItemArray[decimalPlacesfield], 0);
dTNField.DefaultValue = DataHelper.ParseString(dataRow.ItemArray[defaultValuefield]);
dTNField.EnumDataTypeName = DataHelper.ParseString(dataRow.ItemArray[enumDataTypeNamefield]);
dTNField.Exclude = DataHelper.ParseBoolean(dataRow.ItemArray[excludefield], false);
dTNField.UpdateIdentity(DataHelper.ParseInteger(dataRow.ItemArray[fieldIdfield], 0));
dTNField.FieldName = DataHelper.ParseString(dataRow.ItemArray[fieldNamefield]);
dTNField.FieldOrdinal = DataHelper.ParseInteger(dataRow.ItemArray[fieldOrdinalfield], 0);
dTNField.FieldSize = DataHelper.ParseInteger(dataRow.ItemArray[fieldSizefield], 0);
dTNField.IsEnumeration = DataHelper.ParseBoolean(dataRow.ItemArray[isEnumerationfield], false);
dTNField.IsNullable = DataHelper.ParseInteger(dataRow.ItemArray[isNullablefield], 0);
dTNField.PrimaryKey = DataHelper.ParseBoolean(dataRow.ItemArray[primaryKeyfield], false);
dTNField.ProjectId = DataHelper.ParseInteger(dataRow.ItemArray[projectIdfield], 0);
dTNField.Required = DataHelper.ParseBoolean(dataRow.ItemArray[requiredfield], false);
dTNField.Scope = (ScopeEnum)DataHelper.ParseInteger(dataRow.ItemArray[scopefield], 0);
dTNField.TableId = DataHelper.ParseInteger(dataRow.ItemArray[tableIdfield], 0);
}
catch
{
}
// return value
return(dTNField);
}
/// <summary>
/// This method finds a 'DTNField' object.
/// </summary>
/// <param name='List<PolymorphicObject>'>The 'DTNField' to delete.
/// <returns>A PolymorphicObject object with a Boolean value.
internal PolymorphicObject FindDTNField(List <PolymorphicObject> parameters, DataConnector dataConnector)
{
// Initial Value
PolymorphicObject returnObject = new PolymorphicObject();
// locals
DTNField dTNField = null;
// If the data connection is connected
if ((dataConnector != null) && (dataConnector.Connected == true))
{
// Create Find StoredProcedure
FindDTNFieldStoredProcedure findDTNFieldProc = null;
// verify the first parameters is a 'DTNField'.
if (parameters[0].ObjectValue as DTNField != null)
{
// Get DTNFieldParameter
DTNField paramDTNField = (DTNField)parameters[0].ObjectValue;
// verify paramDTNField exists
if (paramDTNField != null)
{
// Now create findDTNFieldProc from DTNFieldWriter
// The DataWriter converts the 'DTNField'
// to the SqlParameter[] array needed to find a 'DTNField'.
findDTNFieldProc = DTNFieldWriter.CreateFindDTNFieldStoredProcedure(paramDTNField);
}
// Verify findDTNFieldProc exists
if (findDTNFieldProc != null)
{
// Execute Find Stored Procedure
dTNField = this.DataManager.DTNFieldManager.FindDTNField(findDTNFieldProc, dataConnector);
// if dataObject exists
if (dTNField != null)
{
// set returnObject.ObjectValue
returnObject.ObjectValue = dTNField;
}
}
}
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 'DTNField' objects.
/// </summary>
/// <param name='List<PolymorphicObject>'>The 'DTNField' to delete.
/// <returns>A PolymorphicObject object with all 'DTNFields' objects.
internal PolymorphicObject FetchAll(List <PolymorphicObject> parameters, DataConnector dataConnector)
{
// Initial Value
PolymorphicObject returnObject = new PolymorphicObject();
// locals
List <DTNField> dTNFieldListCollection = null;
// Create FetchAll StoredProcedure
FetchAllDTNFieldsStoredProcedure fetchAllProc = null;
// If the data connection is connected
if ((dataConnector != null) && (dataConnector.Connected == true))
{
// Get DTNFieldParameter
// Declare Parameter
DTNField paramDTNField = null;
// verify the first parameters is a(n) 'DTNField'.
if (parameters[0].ObjectValue as DTNField != null)
{
// Get DTNFieldParameter
paramDTNField = (DTNField)parameters[0].ObjectValue;
}
// Now create FetchAllDTNFieldsProc from DTNFieldWriter
fetchAllProc = DTNFieldWriter.CreateFetchAllDTNFieldsStoredProcedure(paramDTNField);
}
// Verify fetchAllProc exists
if (fetchAllProc != null)
{
// Execute FetchAll Stored Procedure
dTNFieldListCollection = this.DataManager.DTNFieldManager.FetchAllDTNFields(fetchAllProc, dataConnector);
// if dataObjectCollection exists
if (dTNFieldListCollection != null)
{
// set returnObject.ObjectValue
returnObject.ObjectValue = dTNFieldListCollection;
}
}
else
{
// Raise Error Data Connection Not Available
throw new Exception("The database connection is not available.");
}
// return value
return(returnObject);
}
/// <summary>
/// Deletes a 'DTNField' from the database
/// This method calls the DataBridgeManager to execute the delete using the
/// procedure 'DTNField_Delete'.
/// </summary>
/// <param name='dtnfield'>The 'DTNField' to delete.</param>
/// <returns>True if the delete is successful or false if not.</returns>
public bool Delete(DTNField tempDTNField)
{
// locals
bool deleted = false;
// Get information for calling 'DataBridgeManager.PerformDataOperation' method.
string methodName = "DeleteDTNField";
string objectName = "ApplicationLogicComponent.Controllers";
try
{
// verify tempdTNField exists before attemptintg to delete
if (tempDTNField != null)
{
// Create Delegate For DataOperation
ApplicationController.DataOperationMethod deleteDTNFieldMethod = this.AppController.DataBridge.DataOperations.DTNFieldMethods.DeleteDTNField;
// Create parameters for this method
List <PolymorphicObject> parameters = CreateDTNFieldParameter(tempDTNField);
// Perform DataOperation
PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, deleteDTNFieldMethod, 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 'DTNField' data operation.
/// </summary>
/// <param name='dtnfield'>The 'DTNField' to use as the first
/// parameter (parameters[0]).</param>
/// <returns>A List<PolymorphicObject> collection.</returns>
private List <PolymorphicObject> CreateDTNFieldParameter(DTNField dTNField)
{
// Initial Value
List <PolymorphicObject> parameters = new List <PolymorphicObject>();
// Create PolymorphicObject to hold the parameter
PolymorphicObject parameter = new PolymorphicObject();
// Set parameter.ObjectValue
parameter.ObjectValue = dTNField;
// Add userParameter to parameters
parameters.Add(parameter);
// return value
return(parameters);
}
/// <summary>
/// This method creates an instance of a
/// 'FindDTNFieldStoredProcedure' object and
/// creates the sql parameter[] array needed
/// to execute the procedure 'DTNField_Find'.
/// </summary>
/// <param name="dTNField">The 'DTNField' to use to
/// get the primary key parameter.</param>
/// <returns>An instance of an FetchUserStoredProcedure</returns>
public static FindDTNFieldStoredProcedure CreateFindDTNFieldStoredProcedure(DTNField dTNField)
{
// Initial Value
FindDTNFieldStoredProcedure findDTNFieldStoredProcedure = null;
// verify dTNField exists
if (dTNField != null)
{
// Instanciate findDTNFieldStoredProcedure
findDTNFieldStoredProcedure = new FindDTNFieldStoredProcedure();
// Now create parameters for this procedure
findDTNFieldStoredProcedure.Parameters = CreatePrimaryKeyParameter(dTNField);
}
// return value
return(findDTNFieldStoredProcedure);
}
/// <summary>
/// This method creates the sql Parameter[] array
/// that holds the primary key value.
/// </summary>
/// <param name='dTNField'>The 'DTNField' to get the primary key of.</param>
/// <returns>A SqlParameter[] array which contains the primary key value.
/// to delete.</returns>
internal static SqlParameter[] CreatePrimaryKeyParameter(DTNField dTNField)
{
// Initial Value
SqlParameter[] parameters = new SqlParameter[1];
// verify user exists
if (dTNField != null)
{
// Create PrimaryKey Parameter
SqlParameter @FieldId = new SqlParameter("@FieldId", dTNField.FieldId);
// Set parameters[0] to @FieldId
parameters[0] = @FieldId;
}
// return value
return(parameters);
}
/// <summary>
/// Finds a 'DTNField' object by the primary key.
/// This method used the DataBridgeManager to execute the 'Find' using the
/// procedure 'DTNField_Find'</param>
/// </summary>
/// <param name='tempDTNField'>A temporary DTNField for passing values.</param>
/// <returns>A 'DTNField' object if found else a null 'DTNField'.</returns>
public DTNField Find(DTNField tempDTNField)
{
// Initial values
DTNField dTNField = null;
// Get information for calling 'DataBridgeManager.PerformDataOperation' method.
string methodName = "Find";
string objectName = "ApplicationLogicComponent.Controllers";
try
{
// If object exists
if (tempDTNField != null)
{
// Create DataOperation
ApplicationController.DataOperationMethod findMethod = this.AppController.DataBridge.DataOperations.DTNFieldMethods.FindDTNField;
// Create parameters for this method
List <PolymorphicObject> parameters = CreateDTNFieldParameter(tempDTNField);
// Perform DataOperation
PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, findMethod, parameters);
// If return object exists
if ((returnObject != null) && (returnObject.ObjectValue as DTNField != null))
{
// Get ReturnObject
dTNField = (DTNField)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(dTNField);
}
/// <summary>
/// Insert a 'DTNField' object into the database.
/// This method uses the DataBridgeManager to execute the 'Insert' using the
/// procedure 'DTNField_Insert'.</param>
/// </summary>
/// <param name='dTNField'>The 'DTNField' object to insert.</param>
/// <returns>The id (int) of the new 'DTNField' object that was inserted.</returns>
public int Insert(DTNField dTNField)
{
// Initial values
int newIdentity = -1;
// Get information for calling 'DataBridgeManager.PerformDataOperation' method.
string methodName = "Insert";
string objectName = "ApplicationLogicComponent.Controllers";
try
{
// If DTNFieldexists
if (dTNField != null)
{
ApplicationController.DataOperationMethod insertMethod = this.AppController.DataBridge.DataOperations.DTNFieldMethods.InsertDTNField;
// Create parameters for this method
List <PolymorphicObject> parameters = CreateDTNFieldParameter(dTNField);
// 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 'DTNField' object in the database.
/// This method used the DataBridgeManager to execute the 'Update' using the
/// procedure 'DTNField_Update'.</param>
/// </summary>
/// <param name='dTNField'>The 'DTNField' object to update.</param>
/// <returns>True if successful else false if not.</returns>
public bool Update(DTNField dTNField)
{
// Initial value
bool saved = false;
// Get information for calling 'DataBridgeManager.PerformDataOperation' method.
string methodName = "Update";
string objectName = "ApplicationLogicComponent.Controllers";
try
{
if (dTNField != null)
{
// Create Delegate
ApplicationController.DataOperationMethod updateMethod = this.AppController.DataBridge.DataOperations.DTNFieldMethods.UpdateDTNField;
// Create parameters for this method
List <PolymorphicObject> parameters = CreateDTNFieldParameter(dTNField);
// 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 converts a DataField to a DTNField.
/// </summary>
public static DTNField ConvertDataField(DataField sourceField, int databaseId, int projectId, int tableId)
{
// initial value
DTNField field = null;
// If the sourceField object exists
if (NullHelper.Exists(sourceField))
{
// Create a new instance of a 'DTNField' object.
field = new DTNField();
// Set each property
field.AccessMode = (AccessModeEnum)((int)sourceField.AccessMode);
field.Caption = sourceField.Caption;
field.DatabaseId = databaseId;
// Both enums derive from int, so the double cast converts the Enum types
field.DataType = (DataTypeEnum)((int)sourceField.DataType);
field.DecimalPlaces = sourceField.DecimalPlaces;
field.DefaultValue = sourceField.DefaultValue;
field.EnumDataTypeName = sourceField.EnumDataTypeName;
field.Exclude = sourceField.Exclude;
field.FieldName = sourceField.FieldName;
field.FieldOrdinal = sourceField.FieldOrdinal;
field.FieldSize = sourceField.Size;
field.IsEnumeration = sourceField.IsEnumeration;
field.PrimaryKey = sourceField.PrimaryKey;
field.ProjectId = projectId;
field.Required = sourceField.Required;
field.Scope = (ScopeEnum)((int)sourceField.Scope);
field.TableId = tableId;
// Update 3.26.2019: Set the FieldId, so if set an update is performed
// and not a failed duplicate attempt.
field.UpdateIdentity(sourceField.FieldId);
}
// return value
return(field);
}
/// <summary>
/// This method fetches a collection of 'DTNField' objects.
/// This method used the DataBridgeManager to execute the fetch all using the
/// procedure 'DTNField_FetchAll'.</summary>
/// <param name='tempDTNField'>A temporary DTNField for passing values.</param>
/// <returns>A collection of 'DTNField' objects.</returns>
public List <DTNField> FetchAll(DTNField tempDTNField)
{
// Initial value
List <DTNField> dTNFieldList = null;
// Get information for calling 'DataBridgeManager.PerformDataOperation' method.
string methodName = "FetchAll";
string objectName = "ApplicationLogicComponent.Controllers";
try
{
// Create DataOperation Method
ApplicationController.DataOperationMethod fetchAllMethod = this.AppController.DataBridge.DataOperations.DTNFieldMethods.FetchAll;
// Create parameters for this method
List <PolymorphicObject> parameters = CreateDTNFieldParameter(tempDTNField);
// Perform DataOperation
PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, fetchAllMethod, parameters);
// If return object exists
if ((returnObject != null) && (returnObject.ObjectValue as List <DTNField> != null))
{
// Create Collection From ReturnObject.ObjectValue
dTNFieldList = (List <DTNField>)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(dTNFieldList);
}
/// <summary>
/// This method loads a collection of 'DTNField' objects.
/// from the dataTable.Rows object passed in.
/// </summary>
/// <param name='dataTable'>The 'DataTable.Rows' to load from.</param>
/// <returns>A DTNField Collection.</returns>
public static List <DTNField> LoadCollection(DataTable dataTable)
{
// Initial Value
List <DTNField> dTNFields = new List <DTNField>();
try
{
// Load Each row In DataTable
foreach (DataRow row in dataTable.Rows)
{
// Create 'DTNField' from rows
DTNField dTNField = Load(row);
// Add this object to collection
dTNFields.Add(dTNField);
}
}
catch
{
}
// return value
return(dTNFields);
}
/// <summary>
/// This method prepares the NewProcedureEditor control.
/// </summary>
public void Setup(MethodInfo methodInfo, Project openProject, CustomReader customReader = null, DTNField orderByField = null, FieldSet orderByFieldSet = null)
{
// If the NewStoredProcedureEditor object exists
if (NewStoredProcedureEditor != null)
{
// Setup the control
this.NewStoredProcedureEditor.Setup(methodInfo, openProject, customReader, orderByField, orderByFieldSet);
}
}
/// <summary>
/// This method creates an instance of an
/// 'InsertDTNFieldStoredProcedure' object and
/// creates the sql parameter[] array needed
/// to execute the procedure 'DTNField_Insert'.
/// </summary>
/// <param name="dTNField"The 'DTNField' object to insert</param>
/// <returns>An instance of a 'InsertDTNFieldStoredProcedure' object.</returns>
public static InsertDTNFieldStoredProcedure CreateInsertDTNFieldStoredProcedure(DTNField dTNField)
{
// Initial Value
InsertDTNFieldStoredProcedure insertDTNFieldStoredProcedure = null;
// verify dTNField exists
if (dTNField != null)
{
// Instanciate insertDTNFieldStoredProcedure
insertDTNFieldStoredProcedure = new InsertDTNFieldStoredProcedure();
// Now create parameters for this procedure
insertDTNFieldStoredProcedure.Parameters = CreateInsertParameters(dTNField);
}
// return value
return(insertDTNFieldStoredProcedure);
}
/// <summary>
/// This method creates the sql Parameters[] needed for
/// update an existing dTNField.
/// </summary>
/// <param name="dTNField">The 'DTNField' to update.</param>
/// <returns></returns>
internal static SqlParameter[] CreateUpdateParameters(DTNField dTNField)
{
// Initial Values
SqlParameter[] parameters = new SqlParameter[19];
SqlParameter param = null;
// verify dTNFieldexists
if (dTNField != null)
{
// Create parameter for [AccessMode]
param = new SqlParameter("@AccessMode", dTNField.AccessMode);
// set parameters[0]
parameters[0] = param;
// Create parameter for [Caption]
param = new SqlParameter("@Caption", dTNField.Caption);
// set parameters[1]
parameters[1] = param;
// Create parameter for [DatabaseId]
param = new SqlParameter("@DatabaseId", dTNField.DatabaseId);
// set parameters[2]
parameters[2] = param;
// Create parameter for [DataType]
param = new SqlParameter("@DataType", dTNField.DataType);
// set parameters[3]
parameters[3] = param;
// Create parameter for [DecimalPlaces]
param = new SqlParameter("@DecimalPlaces", dTNField.DecimalPlaces);
// set parameters[4]
parameters[4] = param;
// Create parameter for [DefaultValue]
param = new SqlParameter("@DefaultValue", dTNField.DefaultValue);
// set parameters[5]
parameters[5] = param;
// Create parameter for [EnumDataTypeName]
param = new SqlParameter("@EnumDataTypeName", dTNField.EnumDataTypeName);
// set parameters[6]
parameters[6] = param;
// Create parameter for [Exclude]
param = new SqlParameter("@Exclude", dTNField.Exclude);
// set parameters[7]
parameters[7] = param;
// Create parameter for [FieldName]
param = new SqlParameter("@FieldName", dTNField.FieldName);
// set parameters[8]
parameters[8] = param;
// Create parameter for [FieldOrdinal]
param = new SqlParameter("@FieldOrdinal", dTNField.FieldOrdinal);
// set parameters[9]
parameters[9] = param;
// Create parameter for [FieldSize]
param = new SqlParameter("@FieldSize", dTNField.FieldSize);
// set parameters[10]
parameters[10] = param;
// Create parameter for [IsEnumeration]
param = new SqlParameter("@IsEnumeration", dTNField.IsEnumeration);
// set parameters[11]
parameters[11] = param;
// Create parameter for [IsNullable]
param = new SqlParameter("@IsNullable", dTNField.IsNullable);
// set parameters[12]
parameters[12] = param;
// Create parameter for [PrimaryKey]
param = new SqlParameter("@PrimaryKey", dTNField.PrimaryKey);
// set parameters[13]
parameters[13] = param;
// Create parameter for [ProjectId]
param = new SqlParameter("@ProjectId", dTNField.ProjectId);
// set parameters[14]
parameters[14] = param;
// Create parameter for [Required]
param = new SqlParameter("@Required", dTNField.Required);
// set parameters[15]
parameters[15] = param;
// Create parameter for [Scope]
param = new SqlParameter("@Scope", dTNField.Scope);
// set parameters[16]
parameters[16] = param;
// Create parameter for [TableId]
param = new SqlParameter("@TableId", dTNField.TableId);
// set parameters[17]
parameters[17] = param;
// Create parameter for [FieldId]
param = new SqlParameter("@FieldId", dTNField.FieldId);
parameters[18] = param;
}
// return value
return(parameters);
}
// <Summary>
// This method is used to export a DTNField object to xml.
// </Summary>
public string ExportDTNField(DTNField dTNField, int indent = 0)
{
// initial value
string dTNFieldXml = "";
// locals
string indentString = TextHelper.Indent(indent);
string indentString2 = TextHelper.Indent(indent + 2);
// If the dTNField object exists
if (NullHelper.Exists(dTNField))
{
// Create a StringBuilder
StringBuilder sb = new StringBuilder();
// Append the indentString
sb.Append(indentString);
// Write the open dTNField node
sb.Append("<DTNField>" + Environment.NewLine);
// Write out each property
// Write out the value for AccessMode
sb.Append(indentString2);
sb.Append("<AccessMode>" + dTNField.AccessMode + "</AccessMode>" + Environment.NewLine);
// Write out the value for Caption
sb.Append(indentString2);
sb.Append("<Caption>" + dTNField.Caption + "</Caption>" + Environment.NewLine);
// Write out the value for DatabaseId
sb.Append(indentString2);
sb.Append("<DatabaseId>" + dTNField.DatabaseId + "</DatabaseId>" + Environment.NewLine);
// Write out the value for DataType
sb.Append(indentString2);
sb.Append("<DataType>" + dTNField.DataType + "</DataType>" + Environment.NewLine);
// Write out the value for DecimalPlaces
sb.Append(indentString2);
sb.Append("<DecimalPlaces>" + dTNField.DecimalPlaces + "</DecimalPlaces>" + Environment.NewLine);
// Write out the value for DefaultValue
sb.Append(indentString2);
sb.Append("<DefaultValue>" + dTNField.DefaultValue + "</DefaultValue>" + Environment.NewLine);
// Write out the value for DeleteAllForProject
sb.Append(indentString2);
sb.Append("<DeleteAllForProject>" + dTNField.DeleteAllForProject + "</DeleteAllForProject>" + Environment.NewLine);
// Write out the value for Descending
sb.Append(indentString2);
sb.Append("<Descending>" + dTNField.Descending.ToString() + "</Descending>" + Environment.NewLine);
// Write out the value for Exclude
sb.Append(indentString2);
sb.Append("<Exclude>" + dTNField.Exclude + "</Exclude>" + Environment.NewLine);
// Write out the value for FetchAllForFieldSet
sb.Append(indentString2);
sb.Append("<FetchAllForFieldSet>" + dTNField.FetchAllForFieldSet + "</FetchAllForFieldSet>" + Environment.NewLine);
// Write out the value for FetchAllForTable
sb.Append(indentString2);
sb.Append("<FetchAllForTable>" + dTNField.FetchAllForTable + "</FetchAllForTable>" + Environment.NewLine);
// Write out the value for FieldName
sb.Append(indentString2);
sb.Append("<FieldName>" + dTNField.FieldName + "</FieldName>" + Environment.NewLine);
// Write out the value for FieldOrdinal
sb.Append(indentString2);
sb.Append("<FieldOrdinal>" + dTNField.FieldOrdinal + "</FieldOrdinal>" + Environment.NewLine);
// Write out the value for FieldSetId
sb.Append(indentString2);
sb.Append("<FieldSetId>" + dTNField.FieldSetId + "</FieldSetId>" + Environment.NewLine);
// Write out the value for FieldSize
sb.Append(indentString2);
sb.Append("<FieldSize>" + dTNField.FieldSize + "</FieldSize>" + Environment.NewLine);
// Write out the value for IsNullable
sb.Append(indentString2);
sb.Append("<IsNullable>" + dTNField.IsNullable + "</IsNullable>" + Environment.NewLine);
// Write out the value for PrimaryKey
sb.Append(indentString2);
sb.Append("<PrimaryKey>" + dTNField.PrimaryKey + "</PrimaryKey>" + Environment.NewLine);
// Write out the value for ProjectId
sb.Append(indentString2);
sb.Append("<ProjectId>" + dTNField.ProjectId + "</ProjectId>" + Environment.NewLine);
// Write out the value for Required
sb.Append(indentString2);
sb.Append("<Required>" + dTNField.Required + "</Required>" + Environment.NewLine);
// Write out the value for Scope
sb.Append(indentString2);
sb.Append("<Scope>" + dTNField.Scope + "</Scope>" + Environment.NewLine);
// Write out the value for TableId
sb.Append(indentString2);
sb.Append("<TableId>" + dTNField.TableId + "</TableId>" + Environment.NewLine);
// Append the indentString
sb.Append(indentString);
// Write out the close dTNField node
sb.Append("</DTNField>" + Environment.NewLine);
// set the return value
dTNFieldXml = sb.ToString();
}
// return value
return(dTNFieldXml);
}
/// <summary>
/// This method creates an instance of an
/// 'UpdateDTNFieldStoredProcedure' object and
/// creates the sql parameter[] array needed
/// to execute the procedure 'DTNField_Update'.
/// </summary>
/// <param name="dTNField"The 'DTNField' object to update</param>
/// <returns>An instance of a 'UpdateDTNFieldStoredProcedure</returns>
public static UpdateDTNFieldStoredProcedure CreateUpdateDTNFieldStoredProcedure(DTNField dTNField)
{
// Initial Value
UpdateDTNFieldStoredProcedure updateDTNFieldStoredProcedure = null;
// verify dTNField exists
if (dTNField != null)
{
// Instanciate updateDTNFieldStoredProcedure
updateDTNFieldStoredProcedure = new UpdateDTNFieldStoredProcedure();
// Now create parameters for this procedure
updateDTNFieldStoredProcedure.Parameters = CreateUpdateParameters(dTNField);
}
// return value
return(updateDTNFieldStoredProcedure);
}
/// <summary>
/// event is fired when Create Blazor Services Button _ Link Clicked
/// </summary>
private void CreateBlazorServicesButton_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
// locals
int attempts = 0;
string path = "";
string path2 = "";
bool filesCreated = false;
string message = "";
try
{
// if the value for HasServicesFolder is true
if ((HasServicesFolder) && (HasTable))
{
// Setup the Graph
Graph.Maximum = 20;
Graph.Minimum = 0;
Graph.Value = 0;
// Show the graph
Graph.Visible = true;
// Create a Process to launch a command window (hidden) to create the item templates
Process process = new Process();
ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.WindowStyle = ProcessWindowStyle.Hidden;
startInfo.FileName = "cmd.exe";
startInfo.WorkingDirectory = Project.ServicesFolder;
startInfo.Arguments = "/C " + CreateServices;
process.StartInfo = startInfo;
process.Start();
// next I am performing a wait for the files to be here, which on different people's machines
// speeds I am allowing up to 5 seconds. My machine takes about half a second maybe more,
// so 5 should be enough or give up. If it doesn't work for and you haven't upgraded your
// computer in a while, maybe you should buy a new computer.
// If your internet is slow and this takes longer than 5 seconds let me know and I will extend
// the wait.
do
{
// Increment the value for attempt
attempts++;
// Show the graph
Graph.Value = attempts;
// refresh everything
this.Refresh();
// Try every half second
System.Threading.Thread.Sleep(500);
// get the path
path = Path.Combine(Project.ServicesFolder, DataWatcherFileName);
// if the file exists
if (File.Exists(path))
{
// The files were created
filesCreated = true;
// break out of the loop
break;
}
}while (attempts < 20);
// Wait one extra half second after the file is avialable before trying to modify it
System.Threading.Thread.Sleep(500);
// if the files were created
if (filesCreated)
{
// ***************************************
// ************** DataWatcher.cs Class *************
// ***************************************
// Now the file must be read
string fileText = File.ReadAllText(path);
// now create the replaceParameter values
string tableName = table.TableName;
string variableName = CSharpClassWriter.CapitalizeFirstCharEx(table.TableName, true);
string pluralTableName = PluralWordHelper.GetPluralName(table.TableName, false);
string pluralVariableName = PluralWordHelper.GetPluralName(table.TableName, true);
string primaryKeyDataType = "";
string primaryKeyVariableName = "";
string primaryKeyPropertyName = "";
// Update 12.12.2020: The DataService (for Blazor) requires the PrimaryKey
// cataType and field name.
DTNField field = FindPrimaryKey(table);
// if the field was found
if (NullHelper.Exists(field))
{
// get the dataType
primaryKeyDataType = field.DataType.ToString().ToLower();
primaryKeyVariableName = CSharpClassWriter.CapitalizeFirstCharEx(field.FieldName, true);
primaryKeyPropertyName = CSharpClassWriter.CapitalizeFirstCharEx(field.FieldName, false);
// if an autonumber identity field (which most will be)
if (primaryKeyDataType == "autonumber")
{
// switch to int
primaryKeyDataType = "int";
}
}
// string parameterDataType = FindPrimaryKey
// Replace out the fileText replacement parameters
fileText = fileText.Replace("[TableName]", tableName);
fileText = fileText.Replace("[VariableName]", variableName);
fileText = fileText.Replace("[PluralVariableName]", pluralVariableName);
// Delete the current file at path
File.Delete(path);
// rename the file
path = path.Replace("DataWatcher.cs", Table.TableName + "DataWatcher.cs");
// Write out the next text
File.WriteAllText(path, fileText);
// ***************************************
// ************** Service.cs Class *************
// ***************************************
// now change path to the Service class
path2 = Path.Combine(Project.ServicesFolder, ServiceFileName);
// Now the file must be read
fileText = File.ReadAllText(path2);
// Replace out the fileText replacement parameters
fileText = fileText.Replace("[TableName]", tableName);
fileText = fileText.Replace("[VariableName]", variableName);
fileText = fileText.Replace("[PluralVariableName]", pluralVariableName);
fileText = fileText.Replace("[PluralTableName]", pluralTableName);
fileText = fileText.Replace("[ParameterDataType]", primaryKeyDataType);
fileText = fileText.Replace("[PrimaryKey]", primaryKeyVariableName);
fileText = fileText.Replace("[PrimaryKeyPropertyName]", primaryKeyPropertyName);
// Delete the current file at path2
File.Delete(path2);
// rename the file
path2 = path2.Replace("Service.cs", Table.TableName + "Service.cs");
// Write out the next text
File.WriteAllText(path2, fileText);
// Show a message
message = "The following classes were created:" + Environment.NewLine + path + Environment.NewLine + path2;
// Hide the graph
Graph.Visible = false;
// Show the user a message
MessageBoxHelper.ShowMessage(message, "Files Created");
}
else
{
// change the message
message = "Oops, something went wrong. Step through the code in DataTier.Net.Client.Controls.BlazorDataServices.cs, event name CreateBlazorServicesButton_Click.";
// Show the user a message
MessageBoxHelper.ShowMessage(message, "Files Could Not Be Created", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
}
catch (Exception error)
{
// Set the error
DebugHelper.WriteDebugError("CreateBlazorServicesButton_LinkClicked", this.Name, error);
// show the user a message
MessageBoxHelper.ShowMessage("The Blazor Data Services Either Were Not Installed Or You Do Not Have Permission To Create Files In This Directory", "Create Data Services Failed");
}
}
/// <summary>
/// This method creates an instance of a
/// 'FetchAllDTNFieldsStoredProcedure' object and
/// creates the sql parameter[] array needed
/// to execute the procedure 'DTNField_FetchAll'.
/// </summary>
/// <returns>An instance of a(n) 'FetchAllDTNFieldsStoredProcedure' object.</returns>
public static FetchAllDTNFieldsStoredProcedure CreateFetchAllDTNFieldsStoredProcedure(DTNField dTNField)
{
// Initial value
FetchAllDTNFieldsStoredProcedure fetchAllDTNFieldsStoredProcedure = new FetchAllDTNFieldsStoredProcedure();
// return value
return(fetchAllDTNFieldsStoredProcedure);
}
/// <summary>
/// This method creates an instance of an
/// 'DeleteDTNField'StoredProcedure' object and
/// creates the sql parameter[] array needed
/// to execute the procedure 'DTNField_Delete'.
/// </summary>
/// <param name="dTNField">The 'DTNField' to Delete.</param>
/// <returns>An instance of a 'DeleteDTNFieldStoredProcedure' object.</returns>
public static DeleteDTNFieldStoredProcedure CreateDeleteDTNFieldStoredProcedure(DTNField dTNField)
{
// Initial Value
DeleteDTNFieldStoredProcedure deleteDTNFieldStoredProcedure = new DeleteDTNFieldStoredProcedure();
// Now Create Parameters For The DeleteProc
deleteDTNFieldStoredProcedure.Parameters = CreatePrimaryKeyParameter(dTNField);
// return value
return(deleteDTNFieldStoredProcedure);
}
/// <summary>
/// This method creates an instance of a
/// 'FetchAllDTNFieldsStoredProcedure' object and
/// creates the sql parameter[] array needed
/// to execute the procedure 'DTNField_FetchAll'.
/// </summary>
/// <returns>An instance of a(n) 'FetchAllDTNFieldsStoredProcedure' object.</returns>
public static new FetchAllDTNFieldsStoredProcedure CreateFetchAllDTNFieldsStoredProcedure(DTNField field)
{
// Initial value
FetchAllDTNFieldsStoredProcedure fetchAllDTNFieldsStoredProcedure = new FetchAllDTNFieldsStoredProcedure();
// If the dTNField object exists
if (field != null)
{
// if FetchAllForTable is true and the TableId is set
if ((field.FetchAllForTable) && (field.HasTableId))
{
// change the procedure name
fetchAllDTNFieldsStoredProcedure.ProcedureName = "DTNField_FetchAllForTableId";
// create the @TableId parameter
fetchAllDTNFieldsStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@TableId", field.TableId);
}
}
// return value
return(fetchAllDTNFieldsStoredProcedure);
}
/// <summary>
/// This method prepares this control to be shown
/// </summary>
public void Setup(MethodInfo methodInfo, Project openProject, CustomReader customReader = null, DTNField orderByField = null, FieldSet orderByFieldSet = null)
{
// store the args
this.MethodInfo = methodInfo;
this.OpenProject = openProject;
// locals
DataJuggler.Net.DataField parameter = null;
List <DataJuggler.Net.DataField> parameters = null;
ProcedureWriter writer = null;
// If the MethodInfo object exists
if (this.HasMethodInfo)
{
// create a new
MethodsWriter methodsWriter = new MethodsWriter();
// get the StoredXml
StoredXml = methodsWriter.ExportMethodInfo(this.MethodInfo);
// if the OrderByFieldSet object exists
if (NullHelper.Exists(orderByFieldSet))
{
// set the gateway
Gateway gateway = new Gateway();
// load the orderByFields
orderByFieldSet.FieldSetFields = gateway.LoadFieldSetFieldViewsByFieldSetId(orderByFieldSet.FieldSetId);
}
// Set the Name of the Table
this.SelectedTableControl.Text = this.MethodInfo.SelectedTable.TableName;
// set the procedureName
this.ProcedureNameControl.Text = MethodInfo.ProcedureName;
// Check the button for Manual Update (user clicks Copy and goes to their SQL instance and executes).
this.ManualUpdateRadioButton.Checked = true;
// Check the box if UseCustomReader is true
this.CustomWhereCheckBox.Checked = MethodInfo.UseCustomWhere;
// Set the CustomWhereText (if any)
this.WhereTextBox.Text = MethodInfo.WhereText;
// convert the table
DataJuggler.Net.DataTable table = DataConverter.ConvertDataTable(MethodInfo.SelectedTable, this.OpenProject);
// if this is a Single Field Parameter and the Parameter Field exists
if ((MethodInfo.ParameterType == ParameterTypeEnum.Single_Field) && (MethodInfo.HasParameterField))
{
// convert the field from a DTNField to a DataJuggler.Net.DataField
parameter = DataConverter.ConvertDataField(MethodInfo.ParameterField);
// Create a new instance of a 'ProcedureWriter' object (in TextWriter mode).
writer = new ProcedureWriter(true);
// if this is a FindByField method
if (writer.HasTextWriter)
{
// If Delete By is the Method Type
if (MethodInfo.MethodType == MethodTypeEnum.Delete_By)
{
// Write out the Delete Proc
writer.CreateDeleteProc(table, MethodInfo.ProcedureName, parameter);
}
// If Find By is the Method Type
if (MethodInfo.MethodType == MethodTypeEnum.Find_By)
{
// create a find procedure
writer.CreateFindProc(table, false, MethodInfo.ProcedureName, parameter, customReader, orderByField, orderByFieldSet, methodInfo.OrderByDescending, methodInfo.TopRows);
}
// if Load By is the Method Type
else if (MethodInfo.MethodType == MethodTypeEnum.Load_By)
{
// If the orderByField object exists
if (NullHelper.Exists(orderByFieldSet))
{
// if there are not any fields loaded
if (!ListHelper.HasOneOrMoreItems(orderByFieldSet.Fields))
{
// load the Fields
orderByFieldSet.Fields = FieldSetHelper.LoadFieldSetFields(orderByFieldSet.FieldSetId);
}
}
// create a find procedure
writer.CreateFindProc(table, true, MethodInfo.ProcedureName, parameter, customReader, orderByField, orderByFieldSet, methodInfo.OrderByDescending, methodInfo.TopRows);
}
}
}
else if ((MethodInfo.ParameterType == ParameterTypeEnum.Field_Set) && (MethodInfo.HasParameterFieldSet) && (MethodInfo.ParameterFieldSet.HasFields))
{
// convert the DTNFields to DataFields
parameters = DataConverter.ConvertDataFields(MethodInfo.ParameterFieldSet.Fields);
// If the parameters collection exists and has one or more items
if (ListHelper.HasOneOrMoreItems(parameters))
{
// set the FieldSetName so the description writes the method description correctly
parameters[0].FieldSetName = MethodInfo.ParameterFieldSet.Name;
}
// Create a new instance of a 'ProcedureWriter' object (in TextWriter mode).
writer = new ProcedureWriter(true);
// if this is a FindByField method
if (writer.HasTextWriter)
{
// If Delete By is the Method Type
if (MethodInfo.MethodType == MethodTypeEnum.Delete_By)
{
// Write out the Delete Proc
writer.CreateDeleteProc(table, MethodInfo.ProcedureName, parameters);
}
// If Find By is the Method Type
if (MethodInfo.MethodType == MethodTypeEnum.Find_By)
{
// create a find procedure
writer.CreateFindProc(table, false, MethodInfo.ProcedureName, parameters, MethodInfo.CustomReader, orderByField, orderByFieldSet);
}
// if Load By is the Method Type
else if (MethodInfo.MethodType == MethodTypeEnum.Load_By)
{
// create a find procedure
writer.CreateFindProc(table, true, MethodInfo.ProcedureName, parameters, MethodInfo.CustomReader, orderByField, orderByFieldSet);
}
}
}
else if ((MethodInfo.ParameterType == ParameterTypeEnum.No_Parameters))
{
// Create a new instance of a 'ProcedureWriter' object (in TextWriter mode).
writer = new ProcedureWriter(true);
// if this is a FindByField method
if (writer.HasTextWriter)
{
// If Delete By is the Method Type
if (MethodInfo.MethodType == MethodTypeEnum.Delete_By)
{
// Write out the Delete Proc
writer.CreateDeleteProc(table, MethodInfo.ProcedureName, parameters);
}
// If Find By is the Method Type
if (MethodInfo.MethodType == MethodTypeEnum.Find_By)
{
// create a find procedure
writer.CreateFindProc(table, false, MethodInfo.ProcedureName, parameters, MethodInfo.CustomReader, orderByField, orderByFieldSet);
}
// if Load By is the Method Type
else if (MethodInfo.MethodType == MethodTypeEnum.Load_By)
{
// create a find procedure
writer.CreateFindProc(table, true, MethodInfo.ProcedureName, parameters, MethodInfo.CustomReader, orderByField, orderByFieldSet);
}
}
}
// if the writer exists
if (NullHelper.Exists(writer))
{
// get the procedureText
string procedureText = writer.TextWriter.ToString();
// Show the Where Panel if CustomWhere is true
WherePanel.Visible = MethodInfo.UseCustomWhere;
// if CustomWhere
if (MethodInfo.UseCustomWhere)
{
// now the existing where text must be replaced
int whereIndex = procedureText.ToLower().IndexOf("where [");
// if the WhereText does not exist yet
if ((!MethodInfo.HasWhereText) && (whereIndex > 0))
{
// Set the text as it is now
string whereText = procedureText.Substring(whereIndex);
// If the whereText string exists
if (TextHelper.Exists(whereText))
{
// get the textLines
List <TextLine> textLines = WordParser.GetTextLines(whereText);
// If the textLines collection exists and has one or more items
if (ListHelper.HasOneOrMoreItems(textLines))
{
// Create a new instance of a 'StringBuilder' object.
StringBuilder sb = new StringBuilder();
// add each textLine of the Where Clause except the last one
foreach (TextLine textLine in textLines)
{
// if this is the End line
if (!textLine.Text.ToLower().StartsWith("end"))
{
// Add this line
sb.Append(textLine.Text);
}
}
// Get the Where Clause
MethodInfo.WhereText = sb.ToString().Trim();
}
}
}
// Set the WhereText
WhereTextBox.Text = MethodInfo.WhereText;
// if the whereIndex was found
if (whereIndex >= 0)
{
// if the WhereText does not already exist
if (!TextHelper.Exists(MethodInfo.WhereText))
{
// Set the default WhereText
MethodInfo.WhereText = procedureText.Substring(whereIndex);
}
// set the new ProcedureText
procedureText = procedureText.Substring(0, whereIndex) + MethodInfo.WhereText + Environment.NewLine + Environment.NewLine + "END";
}
}
// Remove any double blank lines
procedureText = CodeLineHelper.RemoveDoubleBlankLines(procedureText);
// display the procedure As Is for now.
this.ProcedureTextBox.Text = procedureText;
}
}
}
