/// <summary>
        /// This method creates an instance of a
        /// 'FindFieldSetFieldStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'FieldSetField_Find'.
        /// </summary>
        /// <param name="fieldSetField">The 'FieldSetField' to use to
        /// get the primary key parameter.</param>
        /// <returns>An instance of an FetchUserStoredProcedure</returns>
        public static new FindFieldSetFieldStoredProcedure CreateFindFieldSetFieldStoredProcedure(FieldSetField fieldSetField)
        {
            // Initial Value
            FindFieldSetFieldStoredProcedure findFieldSetFieldStoredProcedure = null;

            // verify fieldSetField exists
            if (fieldSetField != null)
            {
                // Instanciate findFieldSetFieldStoredProcedure
                findFieldSetFieldStoredProcedure = new FindFieldSetFieldStoredProcedure();

                // if fieldSetField.FindByFieldSetId is true
                if (fieldSetField.FindByFieldSetId)
                {
                    // Change the procedure name
                    findFieldSetFieldStoredProcedure.ProcedureName = "FieldSetField_FindByFieldSetId";

                    // Create the @FieldSetId parameter
                    findFieldSetFieldStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@FieldSetId", fieldSetField.FieldSetId);
                }
                else
                {
                    // Now create parameters for this procedure
                    findFieldSetFieldStoredProcedure.Parameters = CreatePrimaryKeyParameter(fieldSetField);
                }
            }

            // return value
            return(findFieldSetFieldStoredProcedure);
        }
Example #2
0
        /// <summary>
        /// This method creates an instance of a
        /// 'FindMethodStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'Method_Find'.
        /// </summary>
        /// <param name="method">The 'Method' to use to
        /// get the primary key parameter.</param>
        /// <returns>An instance of an FetchUserStoredProcedure</returns>
        public static new FindMethodStoredProcedure CreateFindMethodStoredProcedure(Method method)
        {
            // Initial Value
            FindMethodStoredProcedure findMethodStoredProcedure = null;

            // verify method exists
            if (method != null)
            {
                // Instanciate findMethodStoredProcedure
                findMethodStoredProcedure = new FindMethodStoredProcedure();

                // if method.FindByName is true
                if (method.FindByName)
                {
                    // Change the procedure name
                    findMethodStoredProcedure.ProcedureName = "Method_FindByName";

                    // Create the @Name parameter
                    findMethodStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@Name", method.Name);
                }
                else
                {
                    // Now create parameters for this procedure
                    findMethodStoredProcedure.Parameters = CreatePrimaryKeyParameter(method);
                }
            }

            // return value
            return(findMethodStoredProcedure);
        }
        /// <summary>
        /// This method creates an instance of an
        /// 'DeleteDTNTable'StoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'DTNTable_Delete'.
        /// </summary>
        /// <param name="dTNTable">The 'DTNTable' to Delete.</param>
        /// <returns>An instance of a 'DeleteDTNTableStoredProcedure' object.</returns>
        public static new DeleteDTNTableStoredProcedure CreateDeleteDTNTableStoredProcedure(DTNTable table)
        {
            // Initial Value
            DeleteDTNTableStoredProcedure deleteDTNTableStoredProcedure = new DeleteDTNTableStoredProcedure();

            // If the table object exists
            if (table != null)
            {
                // if DeleteAllForProjectId is true and the ProjectId is set
                if ((table.DeleteAllForProjectId) && (table.HasProjectId))
                {
                    // change the procedureName
                    deleteDTNTableStoredProcedure.ProcedureName = "DTNTable_DeleteAllForProject";

                    // Set the @ProjectId parameter
                    deleteDTNTableStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@ProjectId", table.ProjectId);
                }
                else
                {
                    // Now Create Parameters For The DeleteProc
                    deleteDTNTableStoredProcedure.Parameters = CreatePrimaryKeyParameter(table);
                }
            }

            // return value
            return(deleteDTNTableStoredProcedure);
        }
        /// <summary>
        /// This method creates an instance of a
        /// 'FindUIFieldStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'UIField_Find'.
        /// </summary>
        /// <param name="uIField">The 'UIField' to use to
        /// get the primary key parameter.</param>
        /// <returns>An instance of an FetchUserStoredProcedure</returns>
        public static new FindUIFieldStoredProcedure CreateFindUIFieldStoredProcedure(UIField uIField)
        {
            // Initial Value
            FindUIFieldStoredProcedure findUIFieldStoredProcedure = null;

            // verify uIField exists
            if (uIField != null)
            {
                // Instanciate findUIFieldStoredProcedure
                findUIFieldStoredProcedure = new FindUIFieldStoredProcedure();

                // if uIField.FindByUserInterfaceId is true
                if (uIField.FindByUserInterfaceId)
                {
                    // Change the procedure name
                    findUIFieldStoredProcedure.ProcedureName = "UIField_FindByUserInterfaceId";

                    // Create the @UserInterfaceId parameter
                    findUIFieldStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@UserInterfaceId", uIField.UserInterfaceId);
                }
                else
                {
                    // Now create parameters for this procedure
                    findUIFieldStoredProcedure.Parameters = CreatePrimaryKeyParameter(uIField);
                }
            }

            // return value
            return(findUIFieldStoredProcedure);
        }
Example #5
0
        /// <summary>
        /// This method creates an instance of a
        /// 'FetchAllMethodsStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'Method_FetchAll'.
        /// </summary>
        /// <returns>An instance of a(n) 'FetchAllMethodsStoredProcedure' object.</returns>
        public static new FetchAllMethodsStoredProcedure CreateFetchAllMethodsStoredProcedure(Method method)
        {
            // Initial value
            FetchAllMethodsStoredProcedure fetchAllMethodsStoredProcedure = new FetchAllMethodsStoredProcedure();

            // If the method object exists
            if (method != null)
            {
                if ((method.FetchAllForTable) && (method.HasTableId))
                {
                    // change the procedureName
                    fetchAllMethodsStoredProcedure.ProcedureName = "Method_FetchAllForTable";

                    // create the @TableId parameter
                    fetchAllMethodsStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@TableId", method.TableId);
                }
                // if method.LoadByProjectId is true
                else if (method.LoadByProjectId)
                {
                    // Change the procedure name
                    fetchAllMethodsStoredProcedure.ProcedureName = "Method_FetchAllByProjectId";

                    // Create the @ProjectId parameter
                    fetchAllMethodsStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@ProjectId", method.ProjectId);
                }
            }

            // return value
            return(fetchAllMethodsStoredProcedure);
        }
        /// <summary>
        /// This method creates an instance of a
        /// 'FindUserInterfaceStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'UserInterface_Find'.
        /// </summary>
        /// <param name="userInterface">The 'UserInterface' to use to
        /// get the primary key parameter.</param>
        /// <returns>An instance of an FetchUserStoredProcedure</returns>
        public static new FindUserInterfaceStoredProcedure CreateFindUserInterfaceStoredProcedure(UserInterface userInterface)
        {
            // Initial Value
            FindUserInterfaceStoredProcedure findUserInterfaceStoredProcedure = null;

            // verify userInterface exists
            if (userInterface != null)
            {
                // Instanciate findUserInterfaceStoredProcedure
                findUserInterfaceStoredProcedure = new FindUserInterfaceStoredProcedure();

                // if userInterface.FindByProjectId is true
                if (userInterface.FindByProjectId)
                {
                    // Change the procedure name
                    findUserInterfaceStoredProcedure.ProcedureName = "UserInterface_FindByProjectId";

                    // Create the @ProjectId parameter
                    findUserInterfaceStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@ProjectId", userInterface.ProjectId);
                }
                else
                {
                    // Now create parameters for this procedure
                    findUserInterfaceStoredProcedure.Parameters = CreatePrimaryKeyParameter(userInterface);
                }
            }

            // return value
            return(findUserInterfaceStoredProcedure);
        }
        /// <summary>
        /// This method creates an instance of a
        /// 'FindArtistStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'Artist_Find'.
        /// </summary>
        /// <param name="artist">The 'Artist' to use to
        /// get the primary key parameter.</param>
        /// <returns>An instance of an FetchUserStoredProcedure</returns>
        public static new FindArtistStoredProcedure CreateFindArtistStoredProcedure(Artist artist)
        {
            // Initial Value
            FindArtistStoredProcedure findArtistStoredProcedure = null;

            // verify artist exists
            if (artist != null)
            {
                // Instanciate findArtistStoredProcedure
                findArtistStoredProcedure = new FindArtistStoredProcedure();

                // if artist.FindByEmailAddress is true
                if (artist.FindByEmailAddress)
                {
                    // Change the procedure name
                    findArtistStoredProcedure.ProcedureName = "Artist_FindByEmailAddress";

                    // Create the @EmailAddress parameter
                    findArtistStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@EmailAddress", artist.EmailAddress);
                }
                else
                {
                    // Now create parameters for this procedure
                    findArtistStoredProcedure.Parameters = CreatePrimaryKeyParameter(artist);
                }
            }

            // return value
            return(findArtistStoredProcedure);
        }
        /// <summary>
        /// This method creates an instance of a
        /// 'FindStateStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'State_Find'.
        /// </summary>
        /// <param name="state">The 'State' to use to
        /// get the primary key parameter.</param>
        /// <returns>An instance of an FetchUserStoredProcedure</returns>
        public static new FindStateStoredProcedure CreateFindStateStoredProcedure(State state)
        {
            // Initial Value
            FindStateStoredProcedure findStateStoredProcedure = null;

            // verify state exists
            if (state != null)
            {
                // Instanciate findStateStoredProcedure
                findStateStoredProcedure = new FindStateStoredProcedure();

                // if state.FindByName is true
                if (state.FindByName)
                {
                    // Change the procedure name
                    findStateStoredProcedure.ProcedureName = "State_FindByName";

                    // Create the @Name parameter
                    findStateStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@Name", state.Name);
                }
                else
                {
                    // Now create parameters for this procedure
                    findStateStoredProcedure.Parameters = CreatePrimaryKeyParameter(state);
                }
            }

            // return value
            return(findStateStoredProcedure);
        }
Example #9
0
        /// <summary>
        /// This method creates an instance of a
        /// 'FetchAllFieldSetsStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'FieldSet_FetchAll'.
        /// </summary>
        /// <returns>An instance of a(n) 'FetchAllFieldSetsStoredProcedure' object.</returns>
        public static new FetchAllFieldSetsStoredProcedure CreateFetchAllFieldSetsStoredProcedure(FieldSet fieldSet)
        {
            // Initial value
            FetchAllFieldSetsStoredProcedure fetchAllFieldSetsStoredProcedure = new FetchAllFieldSetsStoredProcedure();

            // If the fieldSet object exists
            if (fieldSet != null)
            {
                // if FetchAllForTable is true and the TableId is set
                if ((fieldSet.FetchAllForTable) && (fieldSet.HasTableId))
                {
                    // if ParameterMode is true, only FieldSets set to ParameterMode = true will be shown
                    if (fieldSet.ParameterMode)
                    {
                        // change the ProcedureName
                        fetchAllFieldSetsStoredProcedure.ProcedureName = "FieldSet_FetchAllInParameterModeForTable";
                    }
                    else
                    {
                        // change the ProcedureName
                        fetchAllFieldSetsStoredProcedure.ProcedureName = "FieldSet_FetchAllForTable";
                    }

                    // Create the TableId parameter
                    fetchAllFieldSetsStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@TableId", fieldSet.TableId);
                }
            }

            // return value
            return(fetchAllFieldSetsStoredProcedure);
        }
Example #10
0
        /// <summary>
        /// This method creates an instance of a
        /// 'FetchAllEnumerationsUsersStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'Enumeration_FetchAll'.
        /// </summary>
        /// <returns>An instance of a(n) 'FetchAllEnumerationsStoredProcedure' object.</returns>
        public new static FetchAllEnumerationsStoredProcedure CreateFetchAllEnumerationsStoredProcedure(Enumeration enumeration)
        {
            // Initial value
            FetchAllEnumerationsStoredProcedure fetchAllEnumerationsStoredProcedure = new FetchAllEnumerationsStoredProcedure();

            // if the ProjectId is set
            if ((enumeration != null) && (enumeration.ProjectId > 0))
            {
                // set the procedure name
                fetchAllEnumerationsStoredProcedure.ProcedureName = "Enumeration_FetchAllForProject";

                // Create the parameters
                fetchAllEnumerationsStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@ProjectId", enumeration.ProjectId);
            }

            // return value
            return(fetchAllEnumerationsStoredProcedure);
        }
Example #11
0
        /// <summary>
        /// This method creates an instance of a
        /// 'FetchAllDTNDatabasesUsersStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'DTNDatabase_FetchAll'.
        /// </summary>
        /// <returns>An instance of a(n) 'FetchAllDTNDatabasesStoredProcedure' object.</returns>
        public new static FetchAllDTNDatabasesStoredProcedure CreateFetchAllDTNDatabasesStoredProcedure(DTNDatabase database)
        {
            // Initial value
            FetchAllDTNDatabasesStoredProcedure fetchAllDTNDatabasesStoredProcedure = new FetchAllDTNDatabasesStoredProcedure();

            // verify the database exists
            if ((database != null) && (database.ProjectId > 0))
            {
                // set the procedure name
                fetchAllDTNDatabasesStoredProcedure.ProcedureName = "DTNDatabase_FetchAllForProject";

                // create the parameters
                fetchAllDTNDatabasesStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@ProjectId", database.ProjectId);
            }

            // return value
            return(fetchAllDTNDatabasesStoredProcedure);
        }
Example #12
0
        /// <summary>
        /// This method creates an instance of a
        /// 'FetchAllProjectReferencesUsersStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'ProjectReference_FetchAll'.
        /// </summary>
        /// <returns>An instance of a(n) 'FetchAllProjectReferencesStoredProcedure' object.</returns>
        public static new FetchAllProjectReferencesStoredProcedure CreateFetchAllProjectReferencesStoredProcedure(ProjectReference projectReference)
        {
            // Initial value
            FetchAllProjectReferencesStoredProcedure fetchAllProjectReferencesStoredProcedure = new FetchAllProjectReferencesStoredProcedure();

            // if the projectReference exists
            if ((projectReference != null) && (projectReference.ReferencesSetId > 0))
            {
                // set the procedure name
                fetchAllProjectReferencesStoredProcedure.ProcedureName = "ProjectReference_FetchAllForReferencesSet";

                // create the ReferencesSetID parameter
                fetchAllProjectReferencesStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@ReferencesSetID", projectReference.ReferencesSetId);
            }

            // return value
            return(fetchAllProjectReferencesStoredProcedure);
        }
Example #13
0
        /// <summary>
        /// This method creates an instance of a
        /// 'FindUserStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'User_Find'.
        /// </summary>
        /// <param name="user">The 'User' to use to
        /// get the primary key parameter.</param>
        /// <returns>An instance of an FetchUserStoredProcedure</returns>
        public static new FindUserStoredProcedure CreateFindUserStoredProcedure(User user)
        {
            // Initial Value
            FindUserStoredProcedure findUserStoredProcedure = null;

            // verify user exists
            if (user != null)
            {
                // Instanciate findUserStoredProcedure
                findUserStoredProcedure = new FindUserStoredProcedure();

                // if user.FindByEmailAddress is true
                if (user.FindByEmailAddress)
                {
                    // Change the procedure name
                    findUserStoredProcedure.ProcedureName = "User_FindByEmailAddress";

                    // Create the @EmailAddress parameter
                    findUserStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@EmailAddress", user.EmailAddress);
                }
                // if user.FindByUserName is true
                else if (user.FindByUserName)
                {
                    // Change the procedure name
                    findUserStoredProcedure.ProcedureName = "User_FindByUserName";

                    // Create the @UserName parameter
                    findUserStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@UserName", user.UserName);
                }
                else
                {
                    // Now create parameters for this procedure
                    findUserStoredProcedure.Parameters = CreatePrimaryKeyParameter(user);
                }
            }

            // return value
            return(findUserStoredProcedure);
        }
        /// <summary>
        /// This method creates an instance of a
        /// 'FetchAllDTNTablesStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'DTNTable_FetchAll'.
        /// </summary>
        /// <returns>An instance of a(n) 'FetchAllDTNTablesStoredProcedure' object.</returns>
        public static new FetchAllDTNTablesStoredProcedure CreateFetchAllDTNTablesStoredProcedure(DTNTable dTNTable)
        {
            // Initial value
            FetchAllDTNTablesStoredProcedure fetchAllDTNTablesStoredProcedure = new FetchAllDTNTablesStoredProcedure();

            // if the dTNTable object exists
            if (dTNTable != null)
            {
                // if LoadByProjectId is true
                if (dTNTable.LoadByProjectId)
                {
                    // Change the procedure name
                    fetchAllDTNTablesStoredProcedure.ProcedureName = "DTNTable_FetchAllByProjectId";

                    // Create the @ProjectId parameter
                    fetchAllDTNTablesStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@ProjectId", dTNTable.ProjectId);
                }
            }

            // return value
            return(fetchAllDTNTablesStoredProcedure);
        }
        /// <summary>
        /// This method creates an instance of a
        /// 'FetchAllImagesStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'Image_FetchAll'.
        /// </summary>
        /// <returns>An instance of a(n) 'FetchAllImagesStoredProcedure' object.</returns>
        public static new FetchAllImagesStoredProcedure CreateFetchAllImagesStoredProcedure(Image image)
        {
            // Initial value
            FetchAllImagesStoredProcedure fetchAllImagesStoredProcedure = new FetchAllImagesStoredProcedure();

            // if the image object exists
            if (image != null)
            {
                // if LoadByOwnerId is true
                if (image.LoadByOwnerId)
                {
                    // Change the procedure name
                    fetchAllImagesStoredProcedure.ProcedureName = "Image_FetchAllForOwnerId";

                    // Create the @OwnerId parameter
                    fetchAllImagesStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@OwnerId", image.OwnerId);
                }
            }

            // return value
            return(fetchAllImagesStoredProcedure);
        }
        /// <summary>
        /// This method creates an instance of a
        /// 'FetchAllFieldSetFieldsStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'FieldSetField_FetchAll'.
        /// </summary>
        /// <returns>An instance of a(n) 'FetchAllFieldSetFieldsStoredProcedure' object.</returns>
        public static new FetchAllFieldSetFieldsStoredProcedure CreateFetchAllFieldSetFieldsStoredProcedure(FieldSetField fieldSetField)
        {
            // Initial value
            FetchAllFieldSetFieldsStoredProcedure fetchAllFieldSetFieldsStoredProcedure = new FetchAllFieldSetFieldsStoredProcedure();

            // if the fieldSetField object exists
            if (fieldSetField != null)
            {
                // if LoadByFieldSetId is true
                if (fieldSetField.LoadByFieldSetId)
                {
                    // Change the procedure name
                    fetchAllFieldSetFieldsStoredProcedure.ProcedureName = "FieldSetField_FetchAllForFieldSetId";

                    // Create the @FieldSetId parameter
                    fetchAllFieldSetFieldsStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@FieldSetId", fieldSetField.FieldSetId);
                }
            }

            // return value
            return(fetchAllFieldSetFieldsStoredProcedure);
        }
Example #17
0
        /// <summary>
        /// This method creates an instance of a
        /// 'FindNotificationStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'Notification_Find'.
        /// </summary>
        /// <param name="notification">The 'Notification' to use to
        /// get the primary key parameter.</param>
        /// <returns>An instance of an FetchUserStoredProcedure</returns>
        public static new FindNotificationStoredProcedure CreateFindNotificationStoredProcedure(Notification notification)
        {
            // Initial Value
            FindNotificationStoredProcedure findNotificationStoredProcedure = null;

            // verify notification exists
            if (notification != null)
            {
                // Instanciate findNotificationStoredProcedure
                findNotificationStoredProcedure = new FindNotificationStoredProcedure();

                // if notification.FindBy is true
                if (notification.FindBy)
                {
                    // Change the procedure name
                    findNotificationStoredProcedure.ProcedureName = "Notification_FindBy";

                    // Create the @EmailAddress parameter
                    findNotificationStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@EmailAddress", notification.EmailAddress);
                }
                // if notification.FindByEmailAddress is true
                else if (notification.FindByEmailAddress)
                {
                    // Change the procedure name
                    findNotificationStoredProcedure.ProcedureName = "Notification_FindByEmailAddress";

                    // Create the @EmailAddress parameter
                    findNotificationStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@EmailAddress", notification.EmailAddress);
                }
                else
                {
                    // Now create parameters for this procedure
                    findNotificationStoredProcedure.Parameters = CreatePrimaryKeyParameter(notification);
                }
            }

            // return value
            return(findNotificationStoredProcedure);
        }
        /// <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 creates an instance of a
        /// 'FetchAllCustomReadersStoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'CustomReader_FetchAll'.
        /// </summary>
        /// <returns>An instance of a(n) 'FetchAllCustomReadersStoredProcedure' object.</returns>
        public static new FetchAllCustomReadersStoredProcedure CreateFetchAllCustomReadersStoredProcedure(CustomReader customReader)
        {
            // Initial value
            FetchAllCustomReadersStoredProcedure fetchAllCustomReadersStoredProcedure = new FetchAllCustomReadersStoredProcedure();

            // If the customReader object exists
            if (customReader != null)
            {
                // if the TableId is set and FetchAllFortable is true
                if ((customReader.HasTableId) && (customReader.FetchAllForTable))
                {
                    // change the procedure name
                    fetchAllCustomReadersStoredProcedure.ProcedureName = "CustomReader_FetchAllForTable";

                    // create the @TableId parameter
                    fetchAllCustomReadersStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@TableId", customReader.TableId);
                }
            }

            // return value
            return(fetchAllCustomReadersStoredProcedure);
        }
        /// <summary>
        /// This method creates an instance of an
        /// 'DeleteFieldSetField'StoredProcedure' object and
        /// creates the sql parameter[] array needed
        /// to execute the procedure 'FieldSetField_Delete'.
        /// </summary>
        /// <param name="fieldSetField">The 'FieldSetField' to Delete.</param>
        /// <returns>An instance of a 'DeleteFieldSetFieldStoredProcedure' object.</returns>
        public static new DeleteFieldSetFieldStoredProcedure CreateDeleteFieldSetFieldStoredProcedure(FieldSetField fieldSetField)
        {
            // Initial Value
            DeleteFieldSetFieldStoredProcedure deleteFieldSetFieldStoredProcedure = new DeleteFieldSetFieldStoredProcedure();

            // If the fieldSetField object exists
            if ((fieldSetField != null) && (fieldSetField.DeleteAllForFieldSet) && (fieldSetField.HasFieldSetId))
            {
                // Set the ProcedureName
                deleteFieldSetFieldStoredProcedure.ProcedureName = "FieldSetField_DeleteAllForFieldSetId";

                // Create the @FieldSetId parameter
                deleteFieldSetFieldStoredProcedure.Parameters = SqlParameterHelper.CreateSqlParameters("@FieldSetId", fieldSetField.FieldSetId);
            }
            else
            {
                // Now Create Parameters For The DeleteProc
                deleteFieldSetFieldStoredProcedure.Parameters = CreatePrimaryKeyParameter(fieldSetField);
            }

            // return value
            return(deleteFieldSetFieldStoredProcedure);
        }