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