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