/// <summary>
/// This method loads a 'FieldSetFieldView' object
/// from the dataRow passed in.
/// </summary>
/// <param name='dataRow'>The 'DataRow' to load from.</param>
/// <returns>A 'FieldSetFieldView' DataObject.</returns>
public static FieldSetFieldView Load(DataRow dataRow)
{
// Initial Value
FieldSetFieldView fieldSetFieldView = new FieldSetFieldView();
// Create field Integers
int databaseIdfield = 0;
int dataTypefield = 1;
int decimalPlacesfield = 2;
int defaultValuefield = 3;
int enumDataTypeNamefield = 4;
int fieldIdfield = 5;
int fieldNamefield = 6;
int fieldOrdinalfield = 7;
int fieldSetFieldIdfield = 8;
int fieldSetIdfield = 9;
int fieldSetNamefield = 10;
int fieldSizefield = 11;
int isEnumerationfield = 12;
int isNullablefield = 13;
int orderByDescendingfield = 14;
int parameterModefield = 15;
int primaryKeyfield = 16;
int projectIdfield = 17;
int requiredfield = 18;
int scopefield = 19;
int tableIdfield = 20;
try
{
// Load Each field
fieldSetFieldView.DatabaseId = DataHelper.ParseInteger(dataRow.ItemArray[databaseIdfield], 0);
fieldSetFieldView.DataType = (DataTypeEnum)DataHelper.ParseInteger(dataRow.ItemArray[dataTypefield], 0);
fieldSetFieldView.DecimalPlaces = DataHelper.ParseInteger(dataRow.ItemArray[decimalPlacesfield], 0);
fieldSetFieldView.DefaultValue = DataHelper.ParseString(dataRow.ItemArray[defaultValuefield]);
fieldSetFieldView.EnumDataTypeName = DataHelper.ParseString(dataRow.ItemArray[enumDataTypeNamefield]);
fieldSetFieldView.FieldId = DataHelper.ParseInteger(dataRow.ItemArray[fieldIdfield], 0);
fieldSetFieldView.FieldName = DataHelper.ParseString(dataRow.ItemArray[fieldNamefield]);
fieldSetFieldView.FieldOrdinal = DataHelper.ParseInteger(dataRow.ItemArray[fieldOrdinalfield], 0);
fieldSetFieldView.FieldSetFieldId = DataHelper.ParseInteger(dataRow.ItemArray[fieldSetFieldIdfield], 0);
fieldSetFieldView.FieldSetId = DataHelper.ParseInteger(dataRow.ItemArray[fieldSetIdfield], 0);
fieldSetFieldView.FieldSetName = DataHelper.ParseString(dataRow.ItemArray[fieldSetNamefield]);
fieldSetFieldView.FieldSize = DataHelper.ParseInteger(dataRow.ItemArray[fieldSizefield], 0);
fieldSetFieldView.IsEnumeration = DataHelper.ParseBoolean(dataRow.ItemArray[isEnumerationfield], false);
fieldSetFieldView.IsNullable = DataHelper.ParseInteger(dataRow.ItemArray[isNullablefield], 0);
fieldSetFieldView.OrderByDescending = DataHelper.ParseBoolean(dataRow.ItemArray[orderByDescendingfield], false);
fieldSetFieldView.ParameterMode = DataHelper.ParseBoolean(dataRow.ItemArray[parameterModefield], false);
fieldSetFieldView.PrimaryKey = DataHelper.ParseBoolean(dataRow.ItemArray[primaryKeyfield], false);
fieldSetFieldView.ProjectId = DataHelper.ParseInteger(dataRow.ItemArray[projectIdfield], 0);
fieldSetFieldView.Required = DataHelper.ParseBoolean(dataRow.ItemArray[requiredfield], false);
fieldSetFieldView.Scope = (ScopeEnum)DataHelper.ParseInteger(dataRow.ItemArray[scopefield], 0);
fieldSetFieldView.TableId = DataHelper.ParseInteger(dataRow.ItemArray[tableIdfield], 0);
}
catch
{
}
// return value
return(fieldSetFieldView);
}
// <Summary>
// This method is used to export a FieldSetField object to xml.
// </Summary>
public string ExportFieldSetField(FieldSetFieldView fieldSetField, int indent = 0)
{
// initial value
string fieldSetFieldXml = "";
// locals
string indentString = TextHelper.Indent(indent);
string indentString2 = TextHelper.Indent(indent + 2);
// If the fieldSetField object exists
if (NullHelper.Exists(fieldSetField))
{
// Create a StringBuilder
StringBuilder sb = new StringBuilder();
// Append the indentString
sb.Append(indentString);
// Write the open fieldSetField node
sb.Append("<FieldSetField>" + Environment.NewLine);
// Write out each property
// Write out the value for Descending
sb.Append(indentString2);
sb.Append("<Descending>" + fieldSetField.OrderByDescending + "</Descending>" + Environment.NewLine);
// Write out the value for FieldId
sb.Append(indentString2);
sb.Append("<FieldId>" + fieldSetField.FieldId + "</FieldId>" + Environment.NewLine);
// Write out the value for FieldOrdinal
sb.Append(indentString2);
sb.Append("<FieldOrdinal>" + fieldSetField.FieldOrdinal + "</FieldOrdinal>" + Environment.NewLine);
// Write out the value for FieldSetId
sb.Append(indentString2);
sb.Append("<FieldSetId>" + fieldSetField.FieldSetId + "</FieldSetId>" + Environment.NewLine);
// Append the indentString
sb.Append(indentString);
// Write out the close fieldSetField node
sb.Append("</FieldSetField>" + Environment.NewLine);
// set the return value
fieldSetFieldXml = sb.ToString();
}
// return value
return(fieldSetFieldXml);
}
/// <summary>
/// This method fetches all 'FieldSetFieldView' objects.
/// </summary>
/// <param name='List<PolymorphicObject>'>The 'FieldSetFieldView' to delete.
/// <returns>A PolymorphicObject object with all 'FieldSetFieldViews' objects.
internal PolymorphicObject FetchAll(List <PolymorphicObject> parameters, DataConnector dataConnector)
{
// Initial Value
PolymorphicObject returnObject = new PolymorphicObject();
// locals
List <FieldSetFieldView> fieldSetFieldViewListCollection = null;
// Create FetchAll StoredProcedure
FetchAllFieldSetFieldViewsStoredProcedure fetchAllProc = null;
// If the data connection is connected
if ((dataConnector != null) && (dataConnector.Connected == true))
{
// Get FieldSetFieldViewParameter
// Declare Parameter
FieldSetFieldView paramFieldSetFieldView = null;
// verify the first parameters is a(n) 'FieldSetFieldView'.
if (parameters[0].ObjectValue as FieldSetFieldView != null)
{
// Get FieldSetFieldViewParameter
paramFieldSetFieldView = (FieldSetFieldView)parameters[0].ObjectValue;
}
// Now create FetchAllFieldSetFieldViewsProc from FieldSetFieldViewWriter
fetchAllProc = FieldSetFieldViewWriter.CreateFetchAllFieldSetFieldViewsStoredProcedure(paramFieldSetFieldView);
}
// Verify fetchAllProc exists
if (fetchAllProc != null)
{
// Execute FetchAll Stored Procedure
fieldSetFieldViewListCollection = this.DataManager.FieldSetFieldViewManager.FetchAllFieldSetFieldViews(fetchAllProc, dataConnector);
// if dataObjectCollection exists
if (fieldSetFieldViewListCollection != null)
{
// set returnObject.ObjectValue
returnObject.ObjectValue = fieldSetFieldViewListCollection;
}
}
else
{
// Raise Error Data Connection Not Available
throw new Exception("The database connection is not available.");
}
// return value
return(returnObject);
}
/// <summary>
/// This method creates the parameter for a 'FieldSetFieldView' data operation.
/// </summary>
/// <param name='fieldsetfieldview'>The 'FieldSetFieldView' to use as the first
/// parameter (parameters[0]).</param>
/// <returns>A List<PolymorphicObject> collection.</returns>
private List <PolymorphicObject> CreateFieldSetFieldViewParameter(FieldSetFieldView fieldSetFieldView)
{
// Initial Value
List <PolymorphicObject> parameters = new List <PolymorphicObject>();
// Create PolymorphicObject to hold the parameter
PolymorphicObject parameter = new PolymorphicObject();
// Set parameter.ObjectValue
parameter.ObjectValue = fieldSetFieldView;
// Add userParameter to parameters
parameters.Add(parameter);
// return value
return(parameters);
}
/// <summary>
/// This method returns the Field Set Field View
/// </summary>
public static FieldSetField ConvertFieldSetFieldView(FieldSetFieldView fieldSetFieldView)
{
// initial value
FieldSetField field = null;
// If the fieldSetFieldView object exists
if (NullHelper.Exists(fieldSetFieldView))
{
// Create a new instance of a 'FieldSetField' object.
field = new FieldSetField();
// set each property
field.FieldId = fieldSetFieldView.FieldId;
field.FieldOrdinal = fieldSetFieldView.FieldOrdinal;
field.FieldSetId = fieldSetFieldView.FieldSetId;
field.OrderByDescending = fieldSetFieldView.OrderByDescending;
}
// return value
return(field);
}
/// <summary>
/// This method converts a DataField to a DTNField.
/// </summary>
public static DTNField ConvertDataField(FieldSetFieldView 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);
// set the properties
field.DecimalPlaces = sourceField.DecimalPlaces;
field.DefaultValue = sourceField.DefaultValue;
field.EnumDataTypeName = sourceField.EnumDataTypeName;
field.FieldName = sourceField.FieldName;
field.FieldOrdinal = sourceField.FieldOrdinal;
field.FieldSize = sourceField.FieldSize;
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 the FieldId
field.UpdateIdentity(sourceField.FieldId);
}
// return value
return(field);
}
/// <summary>
/// This method fetches a collection of 'FieldSetFieldView' objects.
/// This method used the DataBridgeManager to execute the fetch all using the
/// procedure 'FieldSetFieldView_FetchAll'.</summary>
/// <param name='tempFieldSetFieldView'>A temporary FieldSetFieldView for passing values.</param>
/// <returns>A collection of 'FieldSetFieldView' objects.</returns>
public List <FieldSetFieldView> FetchAll(FieldSetFieldView tempFieldSetFieldView)
{
// Initial value
List <FieldSetFieldView> fieldSetFieldViewList = 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.FieldSetFieldViewMethods.FetchAll;
// Create parameters for this method
List <PolymorphicObject> parameters = CreateFieldSetFieldViewParameter(tempFieldSetFieldView);
// Perform DataOperation
PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, fetchAllMethod, parameters);
// If return object exists
if ((returnObject != null) && (returnObject.ObjectValue as List <FieldSetFieldView> != null))
{
// Create Collection From ReturnObject.ObjectValue
fieldSetFieldViewList = (List <FieldSetFieldView>)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(fieldSetFieldViewList);
}
/// <summary>
/// This method loads a collection of 'FieldSetFieldView' objects.
/// from the dataTable.Rows object passed in.
/// </summary>
/// <param name='dataTable'>The 'DataTable.Rows' to load from.</param>
/// <returns>A FieldSetFieldView Collection.</returns>
public static List <FieldSetFieldView> LoadCollection(DataTable dataTable)
{
// Initial Value
List <FieldSetFieldView> fieldSetFieldViews = new List <FieldSetFieldView>();
try
{
// Load Each row In DataTable
foreach (DataRow row in dataTable.Rows)
{
// Create 'FieldSetFieldView' from rows
FieldSetFieldView fieldSetFieldView = Load(row);
// Add this object to collection
fieldSetFieldViews.Add(fieldSetFieldView);
}
}
catch
{
}
// return value
return(fieldSetFieldViews);
}
/// <summary>
/// This method creates an instance of a
/// 'FetchAllFieldSetFieldViewsStoredProcedure' object and
/// creates the sql parameter[] array needed
/// to execute the procedure 'FieldSetFieldView_FetchAll'.
/// </summary>
/// <returns>An instance of a(n) 'FetchAllFieldSetFieldViewsStoredProcedure' object.</returns>
public static new FetchAllFieldSetFieldViewsStoredProcedure CreateFetchAllFieldSetFieldViewsStoredProcedure(FieldSetFieldView fieldSetFieldView)
{
// Initial value
FetchAllFieldSetFieldViewsStoredProcedure fetchAllFieldSetFieldViewsStoredProcedure = new FetchAllFieldSetFieldViewsStoredProcedure();
// if the fieldSetFieldView object exists
if (fieldSetFieldView != null)
{
// if LoadByFieldSetId is true
if (fieldSetFieldView.LoadByFieldSetId)
{
// Change the procedure name
fetchAllFieldSetFieldViewsStoredProcedure.ProcedureName = "FieldSetFieldView_FetchAllByFieldSetId";
// Create the @FieldSetId parameter
fetchAllFieldSetFieldViewsStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@FieldSetId", fieldSetFieldView.FieldSetId);
}
}
// return value
return(fetchAllFieldSetFieldViewsStoredProcedure);
}
/// <summary>
/// This method creates an instance of a
/// 'FetchAllFieldSetFieldViewsStoredProcedure' object and
/// creates the sql parameter[] array needed
/// to execute the procedure 'FieldSetFieldView_FetchAll'.
/// </summary>
/// <returns>An instance of a(n) 'FetchAllFieldSetFieldViewsStoredProcedure' object.</returns>
public static FetchAllFieldSetFieldViewsStoredProcedure CreateFetchAllFieldSetFieldViewsStoredProcedure(FieldSetFieldView fieldSetFieldView)
{
// Initial value
FetchAllFieldSetFieldViewsStoredProcedure fetchAllFieldSetFieldViewsStoredProcedure = new FetchAllFieldSetFieldViewsStoredProcedure();
// return value
return(fetchAllFieldSetFieldViewsStoredProcedure);
}
