/// <summary> /// Saves a 'GitHubFollower' object into the database. /// This method calls the 'Insert' or 'Update' method. /// </summary> /// <param name='gitHubFollower'>The 'GitHubFollower' object to save.</param> /// <returns>True if successful or false if not.</returns> public bool Save(ref GitHubFollower gitHubFollower) { // Initial value bool saved = false; // If the gitHubFollower exists. if (gitHubFollower != null) { // Is this a new GitHubFollower if (gitHubFollower.IsNew) { // Insert new GitHubFollower int newIdentity = this.Insert(gitHubFollower); // if insert was successful if (newIdentity > 0) { // Update Identity gitHubFollower.UpdateIdentity(newIdentity); // Set return value saved = true; } } else { // Update GitHubFollower saved = this.Update(gitHubFollower); } } // return value return(saved); }
/// <summary> /// This method is used to find 'GitHubFollower' objects. /// </summary> /// <param name="id">Find the GitHubFollower with this id</param> /// <param name="tempGitHubFollower">Pass in a tempGitHubFollower to perform a custom find.</param> public GitHubFollower FindGitHubFollower(int id, GitHubFollower tempGitHubFollower = null) { // initial value GitHubFollower gitHubFollower = null; // if the AppController exists if (this.HasAppController) { // if the tempGitHubFollower does not exist if (tempGitHubFollower == null) { // create a temp GitHubFollower tempGitHubFollower = new GitHubFollower(); } // if the id is set if (id > 0) { // set the primary key tempGitHubFollower.UpdateIdentity(id); } // perform the find gitHubFollower = this.AppController.ControllerManager.GitHubFollowerController.Find(tempGitHubFollower); } // return value return(gitHubFollower); }
/// <summary> /// This method is used to delete GitHubFollower objects. /// </summary> /// <param name="id">Delete the GitHubFollower with this id</param> /// <param name="tempGitHubFollower">Pass in a tempGitHubFollower to perform a custom delete.</param> public bool DeleteGitHubFollower(int id, GitHubFollower tempGitHubFollower = null) { // initial value bool deleted = false; // if the AppController exists if (this.HasAppController) { // if the tempGitHubFollower does not exist if (tempGitHubFollower == null) { // create a temp GitHubFollower tempGitHubFollower = new GitHubFollower(); } // if the id is set if (id > 0) { // set the primary key tempGitHubFollower.UpdateIdentity(id); } // perform the delete deleted = this.AppController.ControllerManager.GitHubFollowerController.Delete(tempGitHubFollower); } // return value return(deleted); }
/// <summary> /// This method loads a 'GitHubFollower' object /// from the dataRow passed in. /// </summary> /// <param name='dataRow'>The 'DataRow' to load from.</param> /// <returns>A 'GitHubFollower' DataObject.</returns> public static GitHubFollower Load(DataRow dataRow) { // Initial Value GitHubFollower gitHubFollower = new GitHubFollower(); // Create field Integers int activefield = 0; int emailAddressfield = 1; int followerNamefield = 2; int followerSincefield = 3; int idfield = 4; int notificationIdfield = 5; try { // Load Each field gitHubFollower.Active = DataHelper.ParseBoolean(dataRow.ItemArray[activefield], false); gitHubFollower.EmailAddress = DataHelper.ParseString(dataRow.ItemArray[emailAddressfield]); gitHubFollower.FollowerName = DataHelper.ParseString(dataRow.ItemArray[followerNamefield]); gitHubFollower.FollowerSince = DataHelper.ParseDate(dataRow.ItemArray[followerSincefield]); gitHubFollower.UpdateIdentity(DataHelper.ParseInteger(dataRow.ItemArray[idfield], 0)); gitHubFollower.NotificationId = DataHelper.ParseInteger(dataRow.ItemArray[notificationIdfield], 0); } catch { } // return value return(gitHubFollower); }
/// <summary> /// This method finds a 'GitHubFollower' object. /// This method uses the 'GitHubFollower_Find' procedure. /// </summary> /// <returns>A 'GitHubFollower' object.</returns> /// </summary> public GitHubFollower FindGitHubFollower(FindGitHubFollowerStoredProcedure findGitHubFollowerProc, DataConnector databaseConnector) { // Initial Value GitHubFollower gitHubFollower = null; // Verify database connection is connected if ((databaseConnector != null) && (databaseConnector.Connected)) { // First Get Dataset DataSet gitHubFollowerDataSet = this.DataHelper.LoadDataSet(findGitHubFollowerProc, databaseConnector); // Verify DataSet Exists if (gitHubFollowerDataSet != null) { // Get DataTable From DataSet DataRow row = this.DataHelper.ReturnFirstRow(gitHubFollowerDataSet); // if row exists if (row != null) { // Load GitHubFollower gitHubFollower = GitHubFollowerReader.Load(row); } } } // return value return(gitHubFollower); }
/// <summary> /// This method deletes a 'GitHubFollower' object. /// </summary> /// <param name='List<PolymorphicObject>'>The 'GitHubFollower' to delete. /// <returns>A PolymorphicObject object with a Boolean value. internal PolymorphicObject DeleteGitHubFollower(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 DeleteGitHubFollowerStoredProcedure deleteGitHubFollowerProc = null; // verify the first parameters is a(n) 'GitHubFollower'. if (parameters[0].ObjectValue as GitHubFollower != null) { // Create GitHubFollower GitHubFollower gitHubFollower = (GitHubFollower)parameters[0].ObjectValue; // verify gitHubFollower exists if (gitHubFollower != null) { // Now create deleteGitHubFollowerProc from GitHubFollowerWriter // The DataWriter converts the 'GitHubFollower' // to the SqlParameter[] array needed to delete a 'GitHubFollower'. deleteGitHubFollowerProc = GitHubFollowerWriter.CreateDeleteGitHubFollowerStoredProcedure(gitHubFollower); } } // Verify deleteGitHubFollowerProc exists if (deleteGitHubFollowerProc != null) { // Execute Delete Stored Procedure bool deleted = this.DataManager.GitHubFollowerManager.DeleteGitHubFollower(deleteGitHubFollowerProc, 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 creates the sql Parameters[] needed for /// inserting a new gitHubFollower. /// </summary> /// <param name="gitHubFollower">The 'GitHubFollower' to insert.</param> /// <returns></returns> internal static SqlParameter[] CreateInsertParameters(GitHubFollower gitHubFollower) { // Initial Values SqlParameter[] parameters = new SqlParameter[5]; SqlParameter param = null; // verify gitHubFollowerexists if(gitHubFollower != null) { // Create [Active] parameter param = new SqlParameter("@Active", gitHubFollower.Active); // set parameters[0] parameters[0] = param; // Create [EmailAddress] parameter param = new SqlParameter("@EmailAddress", gitHubFollower.EmailAddress); // set parameters[1] parameters[1] = param; // Create [FollowerName] parameter param = new SqlParameter("@FollowerName", gitHubFollower.FollowerName); // set parameters[2] parameters[2] = param; // Create [FollowerSince] Parameter param = new SqlParameter("@FollowerSince", SqlDbType.DateTime); // If gitHubFollower.FollowerSince does not exist. if ((gitHubFollower.FollowerSince == null) || (gitHubFollower.FollowerSince.Year < 1900)) { // Set the value to 1/1/1900 param.Value = new DateTime(1900, 1, 1); } else { // Set the parameter value param.Value = gitHubFollower.FollowerSince; } // set parameters[3] parameters[3] = param; // Create [NotificationId] parameter param = new SqlParameter("@NotificationId", gitHubFollower.NotificationId); // set parameters[4] parameters[4] = param; } // return value return parameters; }
/// <summary> /// This method finds a 'GitHubFollower' object. /// </summary> /// <param name='List<PolymorphicObject>'>The 'GitHubFollower' to delete. /// <returns>A PolymorphicObject object with a Boolean value. internal PolymorphicObject FindGitHubFollower(List <PolymorphicObject> parameters, DataConnector dataConnector) { // Initial Value PolymorphicObject returnObject = new PolymorphicObject(); // locals GitHubFollower gitHubFollower = null; // If the data connection is connected if ((dataConnector != null) && (dataConnector.Connected == true)) { // Create Find StoredProcedure FindGitHubFollowerStoredProcedure findGitHubFollowerProc = null; // verify the first parameters is a 'GitHubFollower'. if (parameters[0].ObjectValue as GitHubFollower != null) { // Get GitHubFollowerParameter GitHubFollower paramGitHubFollower = (GitHubFollower)parameters[0].ObjectValue; // verify paramGitHubFollower exists if (paramGitHubFollower != null) { // Now create findGitHubFollowerProc from GitHubFollowerWriter // The DataWriter converts the 'GitHubFollower' // to the SqlParameter[] array needed to find a 'GitHubFollower'. findGitHubFollowerProc = GitHubFollowerWriter.CreateFindGitHubFollowerStoredProcedure(paramGitHubFollower); } // Verify findGitHubFollowerProc exists if (findGitHubFollowerProc != null) { // Execute Find Stored Procedure gitHubFollower = this.DataManager.GitHubFollowerManager.FindGitHubFollower(findGitHubFollowerProc, dataConnector); // if dataObject exists if (gitHubFollower != null) { // set returnObject.ObjectValue returnObject.ObjectValue = gitHubFollower; } } } 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 'GitHubFollower' objects. /// </summary> /// <param name='List<PolymorphicObject>'>The 'GitHubFollower' to delete. /// <returns>A PolymorphicObject object with all 'GitHubFollowers' objects. internal PolymorphicObject FetchAll(List <PolymorphicObject> parameters, DataConnector dataConnector) { // Initial Value PolymorphicObject returnObject = new PolymorphicObject(); // locals List <GitHubFollower> gitHubFollowerListCollection = null; // Create FetchAll StoredProcedure FetchAllGitHubFollowersStoredProcedure fetchAllProc = null; // If the data connection is connected if ((dataConnector != null) && (dataConnector.Connected == true)) { // Get GitHubFollowerParameter // Declare Parameter GitHubFollower paramGitHubFollower = null; // verify the first parameters is a(n) 'GitHubFollower'. if (parameters[0].ObjectValue as GitHubFollower != null) { // Get GitHubFollowerParameter paramGitHubFollower = (GitHubFollower)parameters[0].ObjectValue; } // Now create FetchAllGitHubFollowersProc from GitHubFollowerWriter fetchAllProc = GitHubFollowerWriter.CreateFetchAllGitHubFollowersStoredProcedure(paramGitHubFollower); } // Verify fetchAllProc exists if (fetchAllProc != null) { // Execute FetchAll Stored Procedure gitHubFollowerListCollection = this.DataManager.GitHubFollowerManager.FetchAllGitHubFollowers(fetchAllProc, dataConnector); // if dataObjectCollection exists if (gitHubFollowerListCollection != null) { // set returnObject.ObjectValue returnObject.ObjectValue = gitHubFollowerListCollection; } } else { // Raise Error Data Connection Not Available throw new Exception("The database connection is not available."); } // return value return(returnObject); }
/// <summary> /// This method is used to save 'GitHubFollower' objects. /// </summary> /// <param name="gitHubFollower">The GitHubFollower to save.</param> public bool SaveGitHubFollower(ref GitHubFollower gitHubFollower) { // initial value bool saved = false; // if the AppController exists if (this.HasAppController) { // perform the save saved = this.AppController.ControllerManager.GitHubFollowerController.Save(ref gitHubFollower); } // return value return(saved); }
/// <summary> /// This method loads a collection of 'GitHubFollower' objects. /// </summary> public List <GitHubFollower> LoadGitHubFollowers(GitHubFollower tempGitHubFollower = null) { // initial value List <GitHubFollower> gitHubFollowers = null; // if the AppController exists if (this.HasAppController) { // perform the load gitHubFollowers = this.AppController.ControllerManager.GitHubFollowerController.FetchAll(tempGitHubFollower); } // return value return(gitHubFollowers); }
/// <summary> /// Deletes a 'GitHubFollower' from the database /// This method calls the DataBridgeManager to execute the delete using the /// procedure 'GitHubFollower_Delete'. /// </summary> /// <param name='githubfollower'>The 'GitHubFollower' to delete.</param> /// <returns>True if the delete is successful or false if not.</returns> public bool Delete(GitHubFollower tempGitHubFollower) { // locals bool deleted = false; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "DeleteGitHubFollower"; string objectName = "ApplicationLogicComponent.Controllers"; try { // verify tempgitHubFollower exists before attemptintg to delete if (tempGitHubFollower != null) { // Create Delegate For DataOperation ApplicationController.DataOperationMethod deleteGitHubFollowerMethod = this.AppController.DataBridge.DataOperations.GitHubFollowerMethods.DeleteGitHubFollower; // Create parameters for this method List <PolymorphicObject> parameters = CreateGitHubFollowerParameter(tempGitHubFollower); // Perform DataOperation PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, deleteGitHubFollowerMethod, 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 'GitHubFollower' data operation. /// </summary> /// <param name='githubfollower'>The 'GitHubFollower' to use as the first /// parameter (parameters[0]).</param> /// <returns>A List<PolymorphicObject> collection.</returns> private List <PolymorphicObject> CreateGitHubFollowerParameter(GitHubFollower gitHubFollower) { // Initial Value List <PolymorphicObject> parameters = new List <PolymorphicObject>(); // Create PolymorphicObject to hold the parameter PolymorphicObject parameter = new PolymorphicObject(); // Set parameter.ObjectValue parameter.ObjectValue = gitHubFollower; // Add userParameter to parameters parameters.Add(parameter); // return value return(parameters); }
/// <summary> /// This method creates the sql Parameter[] array /// that holds the primary key value. /// </summary> /// <param name='gitHubFollower'>The 'GitHubFollower' to get the primary key of.</param> /// <returns>A SqlParameter[] array which contains the primary key value. /// to delete.</returns> internal static SqlParameter[] CreatePrimaryKeyParameter(GitHubFollower gitHubFollower) { // Initial Value SqlParameter[] parameters = new SqlParameter[1]; // verify user exists if (gitHubFollower != null) { // Create PrimaryKey Parameter SqlParameter @Id = new SqlParameter("@Id", gitHubFollower.Id); // Set parameters[0] to @Id parameters[0] = @Id; } // return value return parameters; }
/// <summary> /// Finds a 'GitHubFollower' object by the primary key. /// This method used the DataBridgeManager to execute the 'Find' using the /// procedure 'GitHubFollower_Find'</param> /// </summary> /// <param name='tempGitHubFollower'>A temporary GitHubFollower for passing values.</param> /// <returns>A 'GitHubFollower' object if found else a null 'GitHubFollower'.</returns> public GitHubFollower Find(GitHubFollower tempGitHubFollower) { // Initial values GitHubFollower gitHubFollower = null; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "Find"; string objectName = "ApplicationLogicComponent.Controllers"; try { // If object exists if (tempGitHubFollower != null) { // Create DataOperation ApplicationController.DataOperationMethod findMethod = this.AppController.DataBridge.DataOperations.GitHubFollowerMethods.FindGitHubFollower; // Create parameters for this method List <PolymorphicObject> parameters = CreateGitHubFollowerParameter(tempGitHubFollower); // Perform DataOperation PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, findMethod, parameters); // If return object exists if ((returnObject != null) && (returnObject.ObjectValue as GitHubFollower != null)) { // Get ReturnObject gitHubFollower = (GitHubFollower)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(gitHubFollower); }
/// <summary> /// Insert a 'GitHubFollower' object into the database. /// This method uses the DataBridgeManager to execute the 'Insert' using the /// procedure 'GitHubFollower_Insert'.</param> /// </summary> /// <param name='gitHubFollower'>The 'GitHubFollower' object to insert.</param> /// <returns>The id (int) of the new 'GitHubFollower' object that was inserted.</returns> public int Insert(GitHubFollower gitHubFollower) { // Initial values int newIdentity = -1; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "Insert"; string objectName = "ApplicationLogicComponent.Controllers"; try { // If GitHubFollowerexists if (gitHubFollower != null) { ApplicationController.DataOperationMethod insertMethod = this.AppController.DataBridge.DataOperations.GitHubFollowerMethods.InsertGitHubFollower; // Create parameters for this method List <PolymorphicObject> parameters = CreateGitHubFollowerParameter(gitHubFollower); // 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 'GitHubFollower' object in the database. /// This method used the DataBridgeManager to execute the 'Update' using the /// procedure 'GitHubFollower_Update'.</param> /// </summary> /// <param name='gitHubFollower'>The 'GitHubFollower' object to update.</param> /// <returns>True if successful else false if not.</returns> public bool Update(GitHubFollower gitHubFollower) { // Initial value bool saved = false; // Get information for calling 'DataBridgeManager.PerformDataOperation' method. string methodName = "Update"; string objectName = "ApplicationLogicComponent.Controllers"; try { if (gitHubFollower != null) { // Create Delegate ApplicationController.DataOperationMethod updateMethod = this.AppController.DataBridge.DataOperations.GitHubFollowerMethods.UpdateGitHubFollower; // Create parameters for this method List <PolymorphicObject> parameters = CreateGitHubFollowerParameter(gitHubFollower); // 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 fetches a collection of 'GitHubFollower' objects. /// This method used the DataBridgeManager to execute the fetch all using the /// procedure 'GitHubFollower_FetchAll'.</summary> /// <param name='tempGitHubFollower'>A temporary GitHubFollower for passing values.</param> /// <returns>A collection of 'GitHubFollower' objects.</returns> public List <GitHubFollower> FetchAll(GitHubFollower tempGitHubFollower) { // Initial value List <GitHubFollower> gitHubFollowerList = 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.GitHubFollowerMethods.FetchAll; // Create parameters for this method List <PolymorphicObject> parameters = CreateGitHubFollowerParameter(tempGitHubFollower); // Perform DataOperation PolymorphicObject returnObject = this.AppController.DataBridge.PerformDataOperation(methodName, objectName, fetchAllMethod, parameters); // If return object exists if ((returnObject != null) && (returnObject.ObjectValue as List <GitHubFollower> != null)) { // Create Collection From ReturnObject.ObjectValue gitHubFollowerList = (List <GitHubFollower>)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(gitHubFollowerList); }
/// <summary> /// This method loads a collection of 'GitHubFollower' objects. /// from the dataTable.Rows object passed in. /// </summary> /// <param name='dataTable'>The 'DataTable.Rows' to load from.</param> /// <returns>A GitHubFollower Collection.</returns> public static List <GitHubFollower> LoadCollection(DataTable dataTable) { // Initial Value List <GitHubFollower> gitHubFollowers = new List <GitHubFollower>(); try { // Load Each row In DataTable foreach (DataRow row in dataTable.Rows) { // Create 'GitHubFollower' from rows GitHubFollower gitHubFollower = Load(row); // Add this object to collection gitHubFollowers.Add(gitHubFollower); } } catch { } // return value return(gitHubFollowers); }
/// <summary> /// This method creates an instance of a /// 'FindGitHubFollowerStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'GitHubFollower_Find'. /// </summary> /// <param name="gitHubFollower">The 'GitHubFollower' to use to /// get the primary key parameter.</param> /// <returns>An instance of an FetchUserStoredProcedure</returns> public static FindGitHubFollowerStoredProcedure CreateFindGitHubFollowerStoredProcedure(GitHubFollower gitHubFollower) { // Initial Value FindGitHubFollowerStoredProcedure findGitHubFollowerStoredProcedure = null; // verify gitHubFollower exists if(gitHubFollower != null) { // Instanciate findGitHubFollowerStoredProcedure findGitHubFollowerStoredProcedure = new FindGitHubFollowerStoredProcedure(); // Now create parameters for this procedure findGitHubFollowerStoredProcedure.Parameters = CreatePrimaryKeyParameter(gitHubFollower); } // return value return findGitHubFollowerStoredProcedure; }
/// <summary> /// This method creates an instance of an /// 'DeleteGitHubFollower'StoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'GitHubFollower_Delete'. /// </summary> /// <param name="gitHubFollower">The 'GitHubFollower' to Delete.</param> /// <returns>An instance of a 'DeleteGitHubFollowerStoredProcedure' object.</returns> public static DeleteGitHubFollowerStoredProcedure CreateDeleteGitHubFollowerStoredProcedure(GitHubFollower gitHubFollower) { // Initial Value DeleteGitHubFollowerStoredProcedure deleteGitHubFollowerStoredProcedure = new DeleteGitHubFollowerStoredProcedure(); // Now Create Parameters For The DeleteProc deleteGitHubFollowerStoredProcedure.Parameters = CreatePrimaryKeyParameter(gitHubFollower); // return value return deleteGitHubFollowerStoredProcedure; }
/// <summary> /// This method creates an instance of a /// 'FetchAllGitHubFollowersStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'GitHubFollower_FetchAll'. /// </summary> /// <returns>An instance of a(n) 'FetchAllGitHubFollowersStoredProcedure' object.</returns> public static FetchAllGitHubFollowersStoredProcedure CreateFetchAllGitHubFollowersStoredProcedure(GitHubFollower gitHubFollower) { // Initial value FetchAllGitHubFollowersStoredProcedure fetchAllGitHubFollowersStoredProcedure = new FetchAllGitHubFollowersStoredProcedure(); // return value return fetchAllGitHubFollowersStoredProcedure; }
/// <summary> /// This method creates an instance of an /// 'UpdateGitHubFollowerStoredProcedure' object and /// creates the sql parameter[] array needed /// to execute the procedure 'GitHubFollower_Update'. /// </summary> /// <param name="gitHubFollower"The 'GitHubFollower' object to update</param> /// <returns>An instance of a 'UpdateGitHubFollowerStoredProcedure</returns> public static UpdateGitHubFollowerStoredProcedure CreateUpdateGitHubFollowerStoredProcedure(GitHubFollower gitHubFollower) { // Initial Value UpdateGitHubFollowerStoredProcedure updateGitHubFollowerStoredProcedure = null; // verify gitHubFollower exists if(gitHubFollower != null) { // Instanciate updateGitHubFollowerStoredProcedure updateGitHubFollowerStoredProcedure = new UpdateGitHubFollowerStoredProcedure(); // Now create parameters for this procedure updateGitHubFollowerStoredProcedure.Parameters = CreateUpdateParameters(gitHubFollower); } // return value return updateGitHubFollowerStoredProcedure; }