Every database model has been updated to handle requests in the new format.

src/gin-cpularp.go

@@ -13,6 +13,7 @@ func main() {
 	api.GlobalDatabase = database.InitializeDatabase()
 	api.GlobalConfig.ParseConfig("../config.toml")
 	api.GlobalOAuth = authdiscord.CreateDiscordOAuthConfig(api.GlobalConfig)
+	api.SetFilteredModels()
 	router := gin.Default()
 	router.Use(cors.New(cors.Config{
 		AllowOrigins:     []string{api.GlobalConfig.GetFrontendRootDomain()},

src/lib/api/api.go

@@ -4,9 +4,12 @@ import (
 	"crypto/x509"
 	"encoding/json"
 	"encoding/pem"
+	"errors"
+	"io"
 	"log"
 	"net/http"
 	"slices"
+	"strconv"
 	"strings"
 
 	authdiscord "example.com/auth/discord"
@@ -36,6 +39,7 @@ import (
 var GlobalDatabase *gorm.DB
 var GlobalConfig configserver.AppConfig
 var GlobalOAuth *oauth2.Config
+var filteredModelNames []string
 
 // Private Functions
 
@@ -122,6 +126,86 @@ func checkAuthentication(context *gin.Context) *oauth2.Token {
 	return nil
 }
 
+func validateBasicParams(context *gin.Context) (*[]uint, *[]byte) {
+	IDArray, IDOk := context.GetQueryArray("id")
+	body := []byte{}
+	var err error
+	if slices.Contains([]string{"POST", "PUT"}, context.Request.Method) {
+		if context.Request.Method == "PUT" && IDOk && len(IDArray) != 1 {
+			err = errors.New("invalid number of IDs were included")
+			log.Println(err)
+			context.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+				"error": err.Error(),
+			})
+			return nil, nil
+		}
+		body, err = io.ReadAll(context.Request.Body)
+		if err != nil {
+			log.Println(err)
+			context.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+				"error": err.Error(),
+			})
+			return nil, nil
+		}
+		if !json.Valid(body) {
+			err := errors.New("invalid JSON Body")
+			log.Println(err)
+			context.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+				"error": err.Error(),
+			})
+			return nil, nil
+		}
+	}
+	var IDUintArray []uint
+	for _, ID := range IDArray {
+		IDUint, err := strconv.Atoi(ID)
+		if err != nil {
+			log.Println(err)
+			context.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+				"error": err.Error(),
+			})
+			return nil, nil
+		}
+		IDUintArray = append(IDUintArray, uint(IDUint))
+	}
+	return &IDUintArray, &body
+}
+
+func validateRequest(context *gin.Context) (string, *[]uint, *[]byte) {
+	// Check that the method is valid
+	if !slices.Contains([]string{"GET", "POST", "PUT", "DELETE"}, context.Request.Method) {
+		err := errors.New("request must be GET, POST, PUT, or DELETE")
+		log.Println(err)
+		context.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+			"error": err.Error(),
+		})
+		return "", nil, nil
+	}
+	// Check authentication if not a GET request
+	if (context.Request.Method != "GET") && (checkAuthentication(context) == nil) {
+		err := errors.New("must be authenticated to make this kind of request")
+		log.Println(err)
+		context.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
+			"error": err.Error(),
+		})
+		return "", nil, nil
+	}
+	// Get the object type from the request parameters
+	objectType := context.Param("object")
+	// Check that the object type is valid
+	if !slices.Contains(filteredModelNames, objectType) {
+		err := errors.New("requested object type does not exist")
+		log.Println(err)
+		context.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+			"error": err.Error(),
+		})
+		return "", nil, nil
+	}
+	// Validate and parse out required parameters from request
+	IDUintArray, body := validateBasicParams(context)
+	return objectType, IDUintArray, body
+}
+
 // Authentication Workflow
 
 func AuthCallback(context *gin.Context) {
@@ -178,22 +262,13 @@ func AuthLogoutRedirect(context *gin.Context) {
 
 // Public Functions
 
-func ObjectRequest(context *gin.Context) {
+func SetFilteredModels() {
-	if !slices.Contains([]string{"GET", "POST", "PUT", "DELETE"}, context.Request.Method) {
-		context.AbortWithStatus(http.StatusBadRequest)
-		return
-	}
-	if (context.Request.Method != "GET") && (checkAuthentication(context) == nil) {
-		context.AbortWithStatus(http.StatusUnauthorized)
-		return
-	}
 	var modelNames []string
+	filteredModelNames = []string{}
 	result := GlobalDatabase.Table("sqlite_master").Where("type = ?", "table").Pluck("name", &modelNames)
 	if result.Error != nil {
-		context.AbortWithStatus(http.StatusInternalServerError)
+		log.Fatal(errors.New("unable to access model names"))
-		return
 	}
-	var filteredModelNames []string
 	for _, model := range modelNames {
 		if slices.Contains([]string{"api_keys", "sqlite_sequence"}, model) || slices.Contains(strings.Split(model, "_"), "associations") {
 			continue
@@ -202,52 +277,115 @@ func ObjectRequest(context *gin.Context) {
 		model = strings.Replace(model, "_", "-", -1)
 		filteredModelNames = append(filteredModelNames, model[:len(model)-1])
 	}
-	objectType := context.Param("object")
+}
-	if !slices.Contains(filteredModelNames, objectType) {
+
-		context.AbortWithStatus(http.StatusBadRequest)
+func ObjectRequest(context *gin.Context) {
+	// Make sure request has valid parameters
+	objectType, IDUintArray, body := validateRequest(context)
+	// This shouldn't happen, but just in case...
+	if objectType == "" {
 		return
 	}
+	// Determine how to handle the request
 	var err error
+	method := context.Request.Method
+	resultJSON := gin.H{}
 	switch objectType {
 	case "user":
 		user.GetAll(GlobalDatabase)
 	case "person":
-		person.GetAll(GlobalDatabase)
+		result, resultError := person.HandleRequest(method, GlobalDatabase, IDUintArray, body)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "group":
-		err = group.HandleRequest(GlobalDatabase, context)
+		result, resultError := group.HandleRequest(method, GlobalDatabase, IDUintArray, body)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "character":
-		character.GetAll(GlobalDatabase)
+		result, resultError := character.HandleRequest(method, GlobalDatabase, IDUintArray, body)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "role":
-		role.GetAll(GlobalDatabase)
+		result, resultError := role.HandleRequest(method, GlobalDatabase, IDUintArray, body)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "tier":
-		tier.GetAll(GlobalDatabase)
+		result, resultError := tier.HandleRequest(method, GlobalDatabase, IDUintArray, body)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "function-set":
-		functionset.GetAll(GlobalDatabase)
+		result, resultError := functionset.HandleRequest(method, GlobalDatabase, IDUintArray, body)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "function":
-		// result = function.Create(GlobalDatabase, context)
+		result, resultError := function.HandleRequest(method, GlobalDatabase, IDUintArray, body)
-		function.GetAll(GlobalDatabase)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "function-tag":
-		// result = functiontag.Create(GlobalDatabase, context)
+		result, resultError := functiontag.HandleRequest(method, GlobalDatabase, IDUintArray, body)
-		functiontag.GetAll(GlobalDatabase)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "inventory-slot":
-		inventoryslot.GetAll(GlobalDatabase)
+		result, resultError := inventoryslot.HandleRequest(method, GlobalDatabase, IDUintArray, body)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "item":
-		item.GetAll(GlobalDatabase)
+		result, resultError := item.HandleRequest(method, GlobalDatabase, IDUintArray, body)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "item-tag":
-		itemtag.GetAll(GlobalDatabase)
+		result, resultError := itemtag.HandleRequest(method, GlobalDatabase, IDUintArray, body)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "customization":
-		customization.GetAll(GlobalDatabase)
+		result, resultError := customization.HandleRequest(method, GlobalDatabase, IDUintArray, body)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	case "schematic":
-		schematic.GetAll(GlobalDatabase)
+		result, resultError := schematic.HandleRequest(method, GlobalDatabase, IDUintArray, body)
+		err = resultError
+		resultJSON = gin.H{
+			"result": result,
+		}
 	default:
-		context.AbortWithStatus(http.StatusBadRequest)
+		err = errors.New("request made for object that exists, but is not implemented")
+		context.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{
+			"error": err.Error(),
+		})
 		return
 	}
 	if err != nil {
-		context.Status(http.StatusInternalServerError)
+		log.Println(err)
+		context.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+			"error": err.Error(),
+		})
 		return
 	}
-	context.Status(http.StatusOK)
+	context.JSON(http.StatusOK, resultJSON)
 }
 
 func CreateAPIToken(context *gin.Context) {

src/lib/database/character/character.go

@@ -1,7 +1,8 @@
 package character
 
 import (
-	"log"
+	"encoding/json"
+	"errors"
 
 	functionset "example.com/database/functionset"
 	inventoryslot "example.com/database/inventoryslot"
@@ -13,14 +14,46 @@ import (
 
 type Character struct {
 	gorm.Model
-	Name         string                        `gorm:"primaryKey; uniqueIndex" json:"name"`
+	Name         string                        `gorm:"uniqueIndex" json:"name"`
 	Owners       []person.Person               `gorm:"many2many:character_owner_associations" json:"owners"` // Unique
 	Roles        []role.Role                   `gorm:"many2many:character_role_associations" json:"roles"`   // Unique
 	FunctionSets []functionset.FunctionSet     `gorm:"many2many:character_functionset_associations" json:"function_sets"`
 	Inventory    []inventoryslot.InventorySlot `gorm:"many2many:character_inventory_associations" json:"inventory"`
 }
 
-func (character Character) Create(db *gorm.DB) error {
+type CharacterParams struct {
+	// ID(s) of the object being modified
+	IDArray []uint `json:"id"`
+	// New fields
+	Name         string `json:"name"`
+	Owners       []uint `json:"owners"`
+	Roles        []uint `json:"roles"`
+	FunctionSets []uint `json:"function_sets"`
+	Inventory    []uint `json:"inventory_slot"`
+}
+
+func (params *CharacterParams) parse(IDUintArray *[]uint, body *[]byte) error {
+	var inputParams CharacterParams
+	params.IDArray = *IDUintArray
+	if len(*body) == 0 {
+		return nil
+	}
+	err := json.Unmarshal(*body, &inputParams)
+	if err != nil {
+		return err
+	}
+	if inputParams.Name == "" {
+		return errors.New("input name cannot be empty")
+	}
+	params.Name = inputParams.Name
+	params.Owners = inputParams.Owners
+	params.Roles = inputParams.Roles
+	params.FunctionSets = inputParams.FunctionSets
+	params.Inventory = inputParams.Inventory
+	return nil
+}
+
+func (character Character) create(db *gorm.DB) error {
 	result := db.Create(&character)
 	if result.Error != nil {
 		return result.Error
@@ -28,21 +61,28 @@ func (character Character) Create(db *gorm.DB) error {
 	return nil
 }
 
-func (character Character) getAssociations(db *gorm.DB) {
+func (character *Character) getAssociations(db *gorm.DB) {
 	db.Model(&character).Association("Owners").Find(&character.Owners)
 	db.Model(&character).Association("Roles").Find(&character.Roles)
 	db.Model(&character).Association("FunctionSets").Find(&character.FunctionSets)
 	db.Model(&character).Association("Inventory").Find(&character.Inventory)
 }
 
-func (character *Character) Get(db *gorm.DB, inputCharacter string) {
+func (character *Character) get(db *gorm.DB, inputCharacter uint) {
-	db.Where("name = ?", inputCharacter).Take(&character)
+	db.Where("id = ?", inputCharacter).Take(&character)
 	character.getAssociations(db)
 }
 
-func (character Character) Update(db *gorm.DB) error {
+func (character Character) update(db *gorm.DB) error {
+	// Get the original Character object
 	var originalCharacter Character
-	originalCharacter.Get(db, character.Name)
+	result := db.Model(&Character{}).Where("id = ?", character.Model.ID).Take(&originalCharacter)
+	if result.Error != nil {
+		return result.Error
+	}
+	// Set the static values
+	originalCharacter.Name = character.Name
+	// Set the associated values by grabbing them from the database
 	ownersError := db.Model(&originalCharacter).Association("Owners").Replace(&character.Owners)
 	if ownersError != nil {
 		return ownersError
@@ -59,59 +99,127 @@ func (character Character) Update(db *gorm.DB) error {
 	if inventoryError != nil {
 		return inventoryError
 	}
+	result = db.Model(&originalCharacter).Update("name", originalCharacter.Name)
+	if result.Error != nil {
+		err := errors.New("new name already exists")
+		return err
+	}
+	db.Save(&originalCharacter)
 	return nil
 }
 
-func (character Character) Delete(db *gorm.DB) error {
+func (character Character) delete(db *gorm.DB) error {
-	result := db.Delete(&character)
+	result := db.Unscoped().Delete(&character)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func Create(db *gorm.DB, name string, owners []uint, roles []string, functionsets []uint, inventory []uint) error {
+func Create(db *gorm.DB, params CharacterParams) error {
+	var newOwners []person.Person
+	if len(params.Owners) > 0 {
+		newOwners = *person.Get(db, params.Owners)
+	}
+	var newRoles []role.Role
+	if len(params.Roles) > 0 {
+		newOwners = *person.Get(db, params.Roles)
+	}
+	var newFunctionSets []functionset.FunctionSet
+	if len(params.FunctionSets) > 0 {
+		newOwners = *person.Get(db, params.FunctionSets)
+	}
+	var newInventory []inventoryslot.InventorySlot
+	if len(params.Inventory) > 0 {
+		newOwners = *person.Get(db, params.Inventory)
+	}
 	return Character{
-		Name:         name,
+		Name:         params.Name,
-		Owners:       *person.Get(db, owners),
+		Owners:       newOwners,
-		Roles:        *role.Get(db, roles),
+		Roles:        newRoles,
-		FunctionSets: *functionset.Get(db, functionsets),
+		FunctionSets: newFunctionSets,
-		Inventory:    *inventoryslot.Get(db, inventory),
+		Inventory:    newInventory,
-	}.Create(db)
+	}.create(db)
 }
 
-func Get(db *gorm.DB, inputCharacters []string) *[]Character {
+func Get(db *gorm.DB, inputCharacters []uint) *[]Character {
 	var outputCharacters []Character
+	if len(inputCharacters) < 1 {
+		db.Model(&Character{}).Select("id").Find(&inputCharacters)
+	}
 	for _, inputCharacter := range inputCharacters {
 		var outputCharacter Character
-		outputCharacter.Get(db, inputCharacter)
+		outputCharacter.get(db, inputCharacter)
 		outputCharacters = append(outputCharacters, outputCharacter)
 	}
 	return &outputCharacters
 }
 
-func GetAll(db *gorm.DB) *[]Character {
+func Update(db *gorm.DB, params CharacterParams) error {
-	var outputCharacterNames []string
+	var newOwners []person.Person
-	result := db.Model(&Character{}).Select("name").Find(&outputCharacterNames)
+	if len(params.Owners) > 0 {
-	if result.Error != nil {
+		newOwners = *person.Get(db, params.Owners)
-		log.Println(result.Error)
+	}
+	var newRoles []role.Role
+	if len(params.Roles) > 0 {
+		newOwners = *person.Get(db, params.Roles)
+	}
+	var newFunctionSets []functionset.FunctionSet
+	if len(params.FunctionSets) > 0 {
+		newOwners = *person.Get(db, params.FunctionSets)
+	}
+	var newInventory []inventoryslot.InventorySlot
+	if len(params.Inventory) > 0 {
+		newOwners = *person.Get(db, params.Inventory)
 	}
-	return Get(db, outputCharacterNames)
-}
-
-func Update(db *gorm.DB, name string, owners []uint, roles []string, functionsets []uint, inventory []uint) error {
 	return Character{
-		Name:         name,
+		Name:         params.Name,
-		Owners:       *person.Get(db, owners),
+		Owners:       newOwners,
-		Roles:        *role.Get(db, roles),
+		Roles:        newRoles,
-		FunctionSets: *functionset.Get(db, functionsets),
+		FunctionSets: newFunctionSets,
-		Inventory:    *inventoryslot.Get(db, inventory),
+		Inventory:    newInventory,
-	}.Update(db)
+	}.update(db)
 }
 
-func Delete(db *gorm.DB, inputCharacters []string) {
+func Delete(db *gorm.DB, inputCharacters []uint) error {
-	characters := Get(db, inputCharacters)
+	var characters []Character
-	for _, character := range *characters {
+	// if len(inputCharacters) < 1 {
-		character.Delete(db)
+	// 	result := db.Model(&Character{}).Select("id").Find(&inputCharacters)
+	// 	if result.Error != nil {
+	// 		return result.Error
+	// 	}
+	// }
+	for _, inputCharacter := range inputCharacters {
+		var character Character
+		character.get(db, inputCharacter)
+		characters = append(characters, character)
 	}
+	for _, character := range characters {
+		err := character.delete(db)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]Character, error) {
+	var err error
+	var params CharacterParams
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
+	}
+	var result *[]Character
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
 }

src/lib/database/customization/customization.go

@@ -1,7 +1,8 @@
 package customization
 
 import (
-	"log"
+	"encoding/json"
+	"errors"
 
 	function "example.com/database/function"
 	group "example.com/database/group"
@@ -12,7 +13,7 @@ import (
 
 type Customization struct {
 	gorm.Model
-	Name                string              `gorm:"primaryKey uniqueIndex" json:"name"`
+	Name                string              `gorm:"uniqueIndex" json:"name"`
 	Functions           []function.Function `gorm:"many2many:customization_function_associations" json:"functions"`
 	FlavorText          string              `json:"flavor_text"`
 	RulesDescription    string              `json:"rules_description"`
@@ -21,7 +22,43 @@ type Customization struct {
 	Visibility          []group.Group       `gorm:"many2many:customization_visibility_associations" json:"visibility"` // Unique
 }
 
-func (customization Customization) Create(db *gorm.DB) error {
+type CustomizationParams struct {
+	// ID(s) of the object being modified
+	IDArray []uint `json:"id"`
+	// New fields
+	Name                string `json:"name"`
+	Functions           []uint `json:"functions"`
+	FlavorText          string `json:"flavor_text"`
+	RulesDescription    string `json:"rules_description"`
+	PhysrepRequirements string `json:"physrep_requirements"`
+	Tags                []uint `json:"tags"`
+	Visibility          []uint `json:"visibility"`
+}
+
+func (params *CustomizationParams) parse(IDUintArray *[]uint, body *[]byte) error {
+	var inputParams CustomizationParams
+	params.IDArray = *IDUintArray
+	if len(*body) == 0 {
+		return nil
+	}
+	err := json.Unmarshal(*body, &inputParams)
+	if err != nil {
+		return err
+	}
+	if inputParams.Name == "" {
+		return errors.New("input name cannot be empty")
+	}
+	params.Name = inputParams.Name
+	params.Functions = inputParams.Functions
+	params.FlavorText = inputParams.FlavorText
+	params.RulesDescription = inputParams.RulesDescription
+	params.PhysrepRequirements = inputParams.PhysrepRequirements
+	params.Tags = inputParams.Tags
+	params.Visibility = inputParams.Visibility
+	return nil
+}
+
+func (customization Customization) create(db *gorm.DB) error {
 	result := db.Create(&customization)
 	if result.Error != nil {
 		return result.Error
@@ -35,18 +72,21 @@ func (customization *Customization) getAssociations(db *gorm.DB) {
 	db.Model(&customization).Association("Visibility").Find(&customization.Visibility)
 }
 
-func (customization *Customization) Get(db *gorm.DB, inputCustomization string) {
+func (customization *Customization) get(db *gorm.DB, inputCustomization uint) {
-	db.Where("name = ?", inputCustomization).Take(&customization)
+	db.Where("id = ?", inputCustomization).Take(&customization)
 	customization.getAssociations(db)
 }
 
-func (customization Customization) Update(db *gorm.DB) error {
+func (customization Customization) update(db *gorm.DB) error {
+	// Get the original Function object
 	var originalCustomization Customization
-	db.Updates(&Customization{
+	result := db.Model(&Customization{}).Where("id = ?", customization.Model.ID).Take(&originalCustomization)
-		FlavorText:          customization.FlavorText,
+	if result.Error != nil {
-		RulesDescription:    customization.RulesDescription,
+		return result.Error
-		PhysrepRequirements: customization.PhysrepRequirements,
+	}
-	})
+	// Set the static values
+	originalCustomization.Name = customization.Name
+	// Set the associated values by grabbing them from the database
 	functionsError := db.Model(&originalCustomization).Association("Functions").Replace(&customization.Functions)
 	if functionsError != nil {
 		return functionsError
@@ -59,63 +99,123 @@ func (customization Customization) Update(db *gorm.DB) error {
 	if visibilityError != nil {
 		return visibilityError
 	}
+	result = db.Model(&originalCustomization).Update("name", originalCustomization.Name)
+	if result.Error != nil {
+		err := errors.New("new name already exists")
+		return err
+	}
+	db.Save(&originalCustomization)
 	return nil
 }
 
-func (customization Customization) Delete(db *gorm.DB) error {
+func (customization Customization) delete(db *gorm.DB) error {
-	result := db.Delete(&customization)
+	result := db.Unscoped().Delete(&customization)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func Create(db *gorm.DB, name string, functions []uint, flavorText string, rulesDescription string, physrepRequesrements string, itemTags []string, visibility []uint) error {
+func Create(db *gorm.DB, params CustomizationParams) error {
+	var newFunctions []function.Function
+	if len(params.Functions) > 0 {
+		newFunctions = *function.Get(db, params.Functions)
+	}
+	var newTags []itemtag.ItemTag
+	if len(params.Tags) > 0 {
+		newTags = *itemtag.Get(db, params.Tags)
+	}
+	var newVisibility []group.Group
+	if len(params.Visibility) > 0 {
+		newVisibility = *group.Get(db, params.Visibility)
+	}
 	return Customization{
-		Name:                name,
+		Name:                params.Name,
-		Functions:           *function.Get(db, functions),
+		Functions:           newFunctions,
-		FlavorText:          flavorText,
+		FlavorText:          params.FlavorText,
-		RulesDescription:    rulesDescription,
+		RulesDescription:    params.RulesDescription,
-		PhysrepRequirements: physrepRequesrements,
+		PhysrepRequirements: params.PhysrepRequirements,
-		Tags:                *itemtag.Get(db, itemTags),
+		Tags:                newTags,
-		Visibility:          *group.Get(db, visibility),
+		Visibility:          newVisibility,
-	}.Create(db)
+	}.create(db)
 }
 
-func Get(db *gorm.DB, inputCustomizations []string) *[]Customization {
+func Get(db *gorm.DB, inputCustomizations []uint) *[]Customization {
 	var outputCustomizations []Customization
+	if len(inputCustomizations) < 1 {
+		db.Model(&Customization{}).Select("id").Find(&inputCustomizations)
+	}
 	for _, inputCustomization := range inputCustomizations {
 		var outputCustomization Customization
-		outputCustomization.Get(db, inputCustomization)
+		outputCustomization.get(db, inputCustomization)
 		outputCustomizations = append(outputCustomizations, outputCustomization)
 	}
 	return &outputCustomizations
 }
 
-func GetAll(db *gorm.DB) *[]Customization {
+func Update(db *gorm.DB, params CustomizationParams) error {
-	var outputCustomizationNames []string
+	var newFunctions []function.Function
-	result := db.Model(&Customization{}).Select("name").Find(&outputCustomizationNames)
+	if len(params.Functions) > 0 {
-	if result.Error != nil {
+		newFunctions = *function.Get(db, params.Functions)
-		log.Println(result.Error)
+	}
+	var newTags []itemtag.ItemTag
+	if len(params.Tags) > 0 {
+		newTags = *itemtag.Get(db, params.Tags)
+	}
+	var newVisibility []group.Group
+	if len(params.Visibility) > 0 {
+		newVisibility = *group.Get(db, params.Visibility)
 	}
-	return Get(db, outputCustomizationNames)
-}
-
-func Update(db *gorm.DB, name string, functions []uint, flavorText string, rulesDescription string, physrepRequesrements string, itemTags []string, visibility []uint) error {
 	return Customization{
-		Name:                name,
+		Name:                params.Name,
-		Functions:           *function.Get(db, functions),
+		Functions:           newFunctions,
-		FlavorText:          flavorText,
+		FlavorText:          params.FlavorText,
-		RulesDescription:    rulesDescription,
+		RulesDescription:    params.RulesDescription,
-		PhysrepRequirements: physrepRequesrements,
+		PhysrepRequirements: params.PhysrepRequirements,
-		Tags:                *itemtag.Get(db, itemTags),
+		Tags:                newTags,
-		Visibility:          *group.Get(db, visibility),
+		Visibility:          newVisibility,
-	}.Update(db)
+	}.update(db)
 }
 
-func Delete(db *gorm.DB, inputCustomizations []string) {
+func Delete(db *gorm.DB, inputCustomizations []uint) error {
-	customizations := Get(db, inputCustomizations)
+	var customizations []Customization
-	for _, customization := range *customizations {
+	// if len(inputCustomizations) < 1 {
-		customization.Delete(db)
+	// 	result := db.Model(&Customization{}).Select("id").Find(&inputCustomizations)
+	// 	if result.Error != nil {
+	// 		return result.Error
+	// 	}
+	// }
+	for _, inputCustomization := range inputCustomizations {
+		var customization Customization
+		customization.get(db, inputCustomization)
+		customizations = append(customizations, customization)
 	}
+	for _, customization := range customizations {
+		err := customization.delete(db)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]Customization, error) {
+	var err error
+	var params CustomizationParams
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
+	}
+	var result *[]Customization
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
 }

src/lib/database/function/function.go

@@ -3,12 +3,8 @@ package function
 import (
 	"encoding/json"
 	"errors"
-	"io"
-	"log"
-	"strconv"
 
 	functiontag "example.com/database/functiontag"
-	"github.com/gin-gonic/gin"
 
 	"gorm.io/gorm"
 )
@@ -20,14 +16,35 @@ type Function struct {
 	Requirements []Function                `gorm:"many2many:function_requirement_associations" json:"requirements"`
 }
 
-type functionParams struct {
+type FunctionParams struct {
-	Id           string `json:"id"`
+	// ID(s) of the object being modified
+	IDArray []uint `json:"id"`
+	// New fields
 	Name         string `json:"name"`
 	Tags         []uint `json:"tags"`
 	Requirements []uint `json:"requirements"`
 }
 
-func (function Function) Create(db *gorm.DB) error {
+func (params *FunctionParams) parse(IDUintArray *[]uint, body *[]byte) error {
+	var inputParams FunctionParams
+	params.IDArray = *IDUintArray
+	if len(*body) == 0 {
+		return nil
+	}
+	err := json.Unmarshal(*body, &inputParams)
+	if err != nil {
+		return err
+	}
+	if inputParams.Name == "" {
+		return errors.New("input name cannot be empty")
+	}
+	params.Name = inputParams.Name
+	params.Tags = inputParams.Tags
+	params.Requirements = inputParams.Requirements
+	return nil
+}
+
+func (function Function) create(db *gorm.DB) error {
 	result := db.Create(&function)
 	if result.Error != nil {
 		return result.Error
@@ -40,39 +57,21 @@ func (function *Function) getAssociations(db *gorm.DB) {
 	db.Model(&function).Association("Requirements").Find(&function.Requirements)
 }
 
-func (params *functionParams) validate(context *gin.Context) error {
+func (function *Function) get(db *gorm.DB, inputFunction uint) {
-	ID, IDOk := context.GetQuery("id")
-	if !IDOk {
-		return errors.New("ID was not included in the request")
-	}
-	body, err := io.ReadAll(context.Request.Body)
-	if err != nil {
-		log.Println(err)
-		return err
-	}
-	log.Println(string(body))
-	var newParams functionParams
-	err = json.Unmarshal(body, &newParams)
-	log.Println(err, newParams)
-	params.Id = ID
-	params.Name = newParams.Name
-	params.Tags = newParams.Tags
-	params.Requirements = newParams.Requirements
-	return nil
-}
-
-func (function *Function) Get(db *gorm.DB, inputFunction uint) {
 	db.Where("id = ?", inputFunction).Take(&function)
 	function.getAssociations(db)
 }
 
 func (function Function) update(db *gorm.DB) error {
+	// Get the original Function object
 	var originalFunction Function
 	result := db.Model(&Function{}).Where("id = ?", function.Model.ID).Take(&originalFunction)
 	if result.Error != nil {
 		return result.Error
 	}
+	// Set the static values
 	originalFunction.Name = function.Name
+	// Set the associated values by grabbing them from the database
 	tagsError := db.Model(&originalFunction).Association("Tags").Replace(&function.Tags)
 	if tagsError != nil {
 		return tagsError
@@ -81,76 +80,108 @@ func (function Function) update(db *gorm.DB) error {
 	if requirementsError != nil {
 		return requirementsError
 	}
+	result = db.Model(&originalFunction).Update("name", originalFunction.Name)
+	if result.Error != nil {
+		err := errors.New("new name already exists")
+		return err
+	}
 	db.Save(&originalFunction)
 	return nil
 }
 
-func (function Function) Delete(db *gorm.DB) error {
+func (function Function) delete(db *gorm.DB) error {
-	result := db.Delete(&function)
+	result := db.Unscoped().Delete(&function)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func Create(db *gorm.DB, context *gin.Context) error {
+func Create(db *gorm.DB, params FunctionParams) error {
-	var params functionParams
+	var newTags []functiontag.FunctionTag
-	err := params.validate(context)
+	if len(params.Tags) > 0 {
-	if err != nil {
+		newTags = *functiontag.Get(db, params.Tags)
-		return err
+	}
+	var newRequirements []Function
+	if len(params.Requirements) > 0 {
+		newRequirements = *Get(db, params.Requirements)
 	}
 	return Function{
 		Name:         params.Name,
-		Tags:         *functiontag.Get(db, params.Tags),
+		Tags:         newTags,
-		Requirements: *Get(db, params.Requirements),
+		Requirements: newRequirements,
-	}.Create(db)
+	}.create(db)
 }
 
 func Get(db *gorm.DB, inputFunctions []uint) *[]Function {
 	var outputFunctions []Function
+	if len(inputFunctions) < 1 {
+		db.Model(&Function{}).Select("id").Find(&inputFunctions)
+	}
 	for _, inputFunction := range inputFunctions {
 		var outputFunction Function
-		outputFunction.Get(db, inputFunction)
+		outputFunction.get(db, inputFunction)
 		outputFunctions = append(outputFunctions, outputFunction)
 	}
-	log.Println(outputFunctions)
 	return &outputFunctions
 }
 
-func GetAll(db *gorm.DB) *[]Function {
+func Update(db *gorm.DB, params FunctionParams) error {
-	var outputFunctionNames []uint
+	var newTags []functiontag.FunctionTag
-	result := db.Model(&Function{}).Select("id").Find(&outputFunctionNames)
+	if len(params.Tags) > 0 {
-	if result.Error != nil {
+		newTags = *functiontag.Get(db, params.Tags)
-		log.Println(result.Error)
 	}
-	return Get(db, outputFunctionNames)
+	var newRequirements []Function
-}
+	if len(params.Requirements) > 0 {
-
+		newRequirements = *Get(db, params.Requirements)
-func Update(db *gorm.DB, context *gin.Context) error {
-	var params functionParams
-	err := params.validate(context)
-	if err != nil {
-		return err
-	}
-	uintID, err := strconv.Atoi(params.Id)
-	if err != nil {
-		return err
 	}
 	return Function{
-		Model:        gorm.Model{ID: uint(uintID)},
+		Model:        gorm.Model{ID: params.IDArray[0]},
 		Name:         params.Name,
-		Tags:         *functiontag.Get(db, params.Tags),
+		Tags:         newTags,
-		Requirements: *Get(db, params.Requirements),
+		Requirements: newRequirements,
 	}.update(db)
 }
 
 func Delete(db *gorm.DB, inputFunctions []uint) error {
-	functions := Get(db, inputFunctions)
+	var functions []Function
-	for _, function := range *functions {
+	// if len(inputFunctions) < 1 {
-		err := function.Delete(db)
+	// 	result := db.Model(&Function{}).Select("id").Find(&inputFunctions)
+	// 	if result.Error != nil {
+	// 		return result.Error
+	// 	}
+	// }
+	for _, inputFunction := range inputFunctions {
+		var function Function
+		function.get(db, inputFunction)
+		functions = append(functions, function)
+	}
+	for _, function := range functions {
+		err := function.delete(db)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
+
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]Function, error) {
+	var err error
+	var params FunctionParams
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
+	}
+	var result *[]Function
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
+}

src/lib/database/functionset/functionset.go

@@ -1,7 +1,7 @@
 package functionset
 
 import (
-	"log"
+	"encoding/json"
 
 	function "example.com/database/function"
 
@@ -13,7 +13,28 @@ type FunctionSet struct {
 	Functions []function.Function `gorm:"many2many:functionset_function_associations" json:"functions"`
 }
 
-func (functionSet FunctionSet) Create(db *gorm.DB) error {
+type FunctionSetParams struct {
+	// ID(s) of the object being modified
+	IDArray []uint `json:"id"`
+	// New fields
+	Functions []uint `json:"functions"`
+}
+
+func (params *FunctionSetParams) parse(IDUintArray *[]uint, body *[]byte) error {
+	var inputParams FunctionSetParams
+	params.IDArray = *IDUintArray
+	if len(*body) == 0 {
+		return nil
+	}
+	err := json.Unmarshal(*body, &inputParams)
+	if err != nil {
+		return err
+	}
+	params.Functions = inputParams.Functions
+	return nil
+}
+
+func (functionSet FunctionSet) create(db *gorm.DB) error {
 	result := db.Create(&functionSet)
 	if result.Error != nil {
 		return result.Error
@@ -25,63 +46,107 @@ func (functionSet *FunctionSet) getAssociations(db *gorm.DB) {
 	db.Model(&functionSet).Association("Functions").Find(&functionSet.Functions)
 }
 
-func (functionSet *FunctionSet) Get(db *gorm.DB, inputFunctionSet uint) {
+func (functionSet *FunctionSet) get(db *gorm.DB, inputFunctionSet uint) {
 	db.Where("id = ?", inputFunctionSet).Take(&functionSet)
 	functionSet.getAssociations(db)
 }
 
-func (functionSet FunctionSet) Update(db *gorm.DB) error {
+func (functionSet FunctionSet) update(db *gorm.DB) error {
-	result := db.Save(&functionSet)
+	// Get the original FunctionSet object
+	var originalFunctionSet FunctionSet
+	result := db.Model(&FunctionSet{}).Where("id = ?", functionSet.Model.ID).Take(&originalFunctionSet)
+	if result.Error != nil {
+		return result.Error
+	}
+	// Set the associated values by grabbing them from the database
+	tagsError := db.Model(&originalFunctionSet).Association("Functions").Replace(&functionSet.Functions)
+	if tagsError != nil {
+		return tagsError
+	}
+	db.Save(&originalFunctionSet)
+	return nil
+}
+
+func (functionSet FunctionSet) delete(db *gorm.DB) error {
+	result := db.Unscoped().Delete(&functionSet)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func (functionSet FunctionSet) Delete(db *gorm.DB) error {
+func Create(db *gorm.DB, params FunctionSetParams) error {
-	result := db.Delete(&functionSet)
+	var newFunctions []function.Function
-	if result.Error != nil {
+	if len(params.Functions) > 0 {
-		return result.Error
+		newFunctions = *function.Get(db, params.Functions)
 	}
-	return nil
-}
-
-func Create(db *gorm.DB, functions []uint) error {
 	return FunctionSet{
-		Functions: *function.Get(db, functions),
+		Functions: newFunctions,
-	}.Create(db)
+	}.create(db)
 }
 
 func Get(db *gorm.DB, inputFunctionSets []uint) *[]FunctionSet {
 	var outputFunctionSets []FunctionSet
+	if len(inputFunctionSets) < 1 {
+		db.Model(&FunctionSet{}).Select("id").Find(&inputFunctionSets)
+	}
 	for _, inputFunctionSet := range inputFunctionSets {
 		var outputFunctionSet FunctionSet
-		outputFunctionSet.Get(db, inputFunctionSet)
+		outputFunctionSet.get(db, inputFunctionSet)
 		outputFunctionSets = append(outputFunctionSets, outputFunctionSet)
 	}
 	return &outputFunctionSets
 }
 
-func GetAll(db *gorm.DB) *[]FunctionSet {
+func Update(db *gorm.DB, params FunctionSetParams) error {
-	var outputFunctionSetIDs []uint
+	var newFunctions []function.Function
-	result := db.Model(&FunctionSet{}).Select("id").Find(&outputFunctionSetIDs)
+	if len(params.Functions) > 0 {
-	if result.Error != nil {
+		newFunctions = *function.Get(db, params.Functions)
-		log.Println(result.Error)
 	}
-	return Get(db, outputFunctionSetIDs)
+	return FunctionSet{
+		Functions: newFunctions,
+	}.update(db)
 }
 
-func Update(db *gorm.DB, id int, functions []uint) error {
+func Delete(db *gorm.DB, inputFunctionSets []uint) error {
-	outputFunctionSet := FunctionSet{
+	var functionSets []FunctionSet
-		Functions: *function.Get(db, functions),
+	// if len(inputFunctionSets) < 1 {
+	// 	result := db.Model(&FunctionSet{}).Select("id").Find(&inputFunctionSets)
+	// 	if result.Error != nil {
+	// 		return result.Error
+	// 	}
+	// }
+	for _, inputFunctionSet := range inputFunctionSets {
+		var functionSet FunctionSet
+		functionSet.get(db, inputFunctionSet)
+		functionSets = append(functionSets, functionSet)
 	}
-	outputFunctionSet.ID = uint(id)
+	for _, function := range functionSets {
-	return outputFunctionSet.Update(db)
+		err := function.delete(db)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
-func Delete(db *gorm.DB, inputFunctionSets []uint) {
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]FunctionSet, error) {
-	functionSets := Get(db, inputFunctionSets)
+	var err error
-	for _, functionSet := range *functionSets {
+	var params FunctionSetParams
-		functionSet.Delete(db)
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
 	}
+	var result *[]FunctionSet
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
 }

src/lib/database/functiontag/functiontag.go

@@ -3,11 +3,7 @@ package functiontag
 import (
 	"encoding/json"
 	"errors"
-	"io"
-	"log"
-	"strconv"
 
-	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 )
 
@@ -16,27 +12,35 @@ type FunctionTag struct {
 	Name string `gorm:"uniqueIndex" json:"name"`
 }
 
-type functionTagParams struct {
+type FunctionTagParams struct {
 	// ID of the object being modified
-	ID string
+	IDArray []uint `json:"id"`
 	// New fields
-	Name string
+	Name string `json:"name"`
 }
 
-func (params *functionTagParams) validate(context *gin.Context) error {
+func (params *FunctionTagParams) parse(IDUintArray *[]uint, body *[]byte) error {
-	ID, IDOk := context.GetQuery("id")
+	var inputParams FunctionTagParams
-	if !IDOk {
+	params.IDArray = *IDUintArray
-		return errors.New("ID was not included in the request")
+	if len(*body) == 0 {
+		return nil
 	}
-	body, err := io.ReadAll(context.Request.Body)
+	err := json.Unmarshal(*body, &inputParams)
 	if err != nil {
-		log.Println(err)
 		return err
 	}
-	var name functionTagParams
+	if inputParams.Name == "" {
-	_ = json.Unmarshal(body, &name)
+		return errors.New("input name cannot be empty")
-	params.ID = ID
+	}
-	params.Name = name.Name
+	params.Name = inputParams.Name
+	return nil
+}
+
+func (functionTag FunctionTag) create(db *gorm.DB) error {
+	result := db.Create(&functionTag)
+	if result.Error != nil {
+		return result.Error
+	}
 	return nil
 }
 
@@ -51,43 +55,34 @@ func (functionTag FunctionTag) update(db *gorm.DB) error {
 		return result.Error
 	}
 	originalFunctionTag.Name = functionTag.Name
+	result = db.Model(&originalFunctionTag).Update("name", originalFunctionTag.Name)
+	if result.Error != nil {
+		err := errors.New("new name already exists")
+		return err
+	}
 	db.Save(&originalFunctionTag)
 	return nil
 }
 
-func (functionTag FunctionTag) create(db *gorm.DB) error {
-	result := db.Create(&functionTag)
-	if result.Error != nil {
-		return result.Error
-	}
-	return nil
-}
-
 func (functionTag FunctionTag) delete(db *gorm.DB) error {
-	result := db.Delete(&functionTag)
+	result := db.Unscoped().Delete(&functionTag)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func Create(db *gorm.DB, context *gin.Context) error {
+func Create(db *gorm.DB, params FunctionTagParams) error {
-	body, err := io.ReadAll(context.Request.Body)
-	if err != nil {
-		return err
-	}
-	var newFunctionTag FunctionTag
-	err = json.Unmarshal(body, &newFunctionTag)
-	if err != nil {
-		return err
-	}
 	return FunctionTag{
-		Name: newFunctionTag.Name,
+		Name: params.Name,
 	}.create(db)
 }
 
 func Get(db *gorm.DB, inputFunctionTags []uint) *[]FunctionTag {
 	var outputFunctionTags []FunctionTag
+	if len(inputFunctionTags) < 1 {
+		db.Model(&FunctionTag{}).Select("id").Find(&inputFunctionTags)
+	}
 	for _, inputFunctionTag := range inputFunctionTags {
 		var outputFunctionTag FunctionTag
 		outputFunctionTag.get(db, inputFunctionTag)
@@ -96,40 +91,52 @@ func Get(db *gorm.DB, inputFunctionTags []uint) *[]FunctionTag {
 	return &outputFunctionTags
 }
 
-func GetAll(db *gorm.DB) *[]FunctionTag {
+func Update(db *gorm.DB, params FunctionTagParams) error {
-	var outputFunctionTags []FunctionTag
-	var outputFunctionTagIDs []uint
-	result := db.Model(&FunctionTag{}).Select("id").Find(&outputFunctionTagIDs)
-	if result.Error != nil {
-		log.Println(result.Error)
-	}
-	outputFunctionTags = *Get(db, outputFunctionTagIDs)
-	return &outputFunctionTags
-}
-
-func Update(db *gorm.DB, context *gin.Context) error {
-	var params functionTagParams
-	err := params.validate(context)
-	if err != nil {
-		return err
-	}
-	uintID, err := strconv.Atoi(params.ID)
-	if err != nil {
-		return err
-	}
 	return FunctionTag{
-		Model: gorm.Model{ID: uint(uintID)},
+		Model: gorm.Model{ID: params.IDArray[0]},
 		Name:  params.Name,
 	}.update(db)
 }
 
 func Delete(db *gorm.DB, inputFunctionTags []uint) error {
-	functionTags := Get(db, inputFunctionTags)
+	var functionTags []FunctionTag
-	for _, functiontag := range *functionTags {
+	// if len(inputFunctionTags) < 1 {
-		err := functiontag.delete(db)
+	// 	result := db.Model(&FunctionTag{}).Select("id").Find(&inputFunctionTags)
+	// 	if result.Error != nil {
+	// 		return result.Error
+	// 	}
+	// }
+	for _, inputFunctionTag := range inputFunctionTags {
+		var functionTag FunctionTag
+		functionTag.get(db, inputFunctionTag)
+		functionTags = append(functionTags, functionTag)
+	}
+	for _, functionTag := range functionTags {
+		err := functionTag.delete(db)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
+
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]FunctionTag, error) {
+	var err error
+	var params FunctionTagParams
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
+	}
+	var result *[]FunctionTag
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
+}

src/lib/database/group/group.go

@@ -3,12 +3,7 @@ package group
 import (
 	"encoding/json"
 	"errors"
-	"io"
-	"net/http"
-	"slices"
-	"strconv"
 
-	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
 )
 
@@ -17,26 +12,35 @@ type Group struct {
 	Name string `gorm:"uniqueIndex" json:"name"`
 }
 
-type groupParams struct {
+type GroupParams struct {
-	// ID of the object being modified
+	// ID(s) of the object being modified
-	ID string
+	IDArray []uint
 	// New fields
 	Name string
 }
 
-func (params *groupParams) validate(context *gin.Context) error {
+func (params *GroupParams) parse(IDUintArray *[]uint, body *[]byte) error {
-	ID, IDOk := context.GetQuery("id")
+	var inputParams GroupParams
-	if !IDOk && slices.Contains([]string{"PUT"}, context.Request.Method) {
+	params.IDArray = *IDUintArray
-		return errors.New("ID was not included in the request")
+	if len(*body) == 0 {
+		return nil
 	}
-	body, err := io.ReadAll(context.Request.Body)
+	err := json.Unmarshal(*body, &inputParams)
 	if err != nil {
 		return err
 	}
-	var name groupParams
+	if inputParams.Name == "" {
-	_ = json.Unmarshal(body, &name)
+		return errors.New("input name cannot be empty")
-	params.ID = ID
+	}
-	params.Name = name.Name
+	params.Name = inputParams.Name
+	return nil
+}
+
+func (group Group) create(db *gorm.DB) error {
+	result := db.Create(&group)
+	if result.Error != nil {
+		return result.Error
+	}
 	return nil
 }
 
@@ -51,6 +55,11 @@ func (group Group) update(db *gorm.DB) error {
 		return result.Error
 	}
 	originalGroup.Name = group.Name
+	result = db.Model(&originalGroup).Update("name", originalGroup.Name)
+	if result.Error != nil {
+		err := errors.New("new name already exists")
+		return err
+	}
 	db.Save(&originalGroup)
 	return nil
 }
@@ -63,15 +72,7 @@ func (group Group) delete(db *gorm.DB) error {
 	return nil
 }
 
-func (group Group) create(db *gorm.DB) error {
+func Create(db *gorm.DB, params GroupParams) error {
-	result := db.Create(&group)
-	if result.Error != nil {
-		return result.Error
-	}
-	return nil
-}
-
-func Create(db *gorm.DB, params groupParams) error {
 	return Group{
 		Name: params.Name,
 	}.create(db)
@@ -90,13 +91,9 @@ func Get(db *gorm.DB, inputGroups []uint) *[]Group {
 	return &outputGroups
 }
 
-func Update(db *gorm.DB, params groupParams) error {
+func Update(db *gorm.DB, params GroupParams) error {
-	uintID, err := strconv.Atoi(params.ID)
-	if err != nil {
-		return err
-	}
 	return Group{
-		Model: gorm.Model{ID: uint(uintID)},
+		Model: gorm.Model{ID: params.IDArray[0]},
 		Name:  params.Name,
 	}.update(db)
 }
@@ -123,33 +120,23 @@ func Delete(db *gorm.DB, inputGroups []uint) error {
 	return nil
 }
 
-func HandleRequest(db *gorm.DB, context *gin.Context) error {
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]Group, error) {
-	var params groupParams
-	if err := params.validate(context); err != nil {
-		return err
-	}
-	idArray, _ := context.GetQueryArray("id")
-	var idUintArray []uint
-	for _, id := range idArray {
-		idUint, err := strconv.Atoi(id)
-		if err != nil {
-			return err
-		}
-		idUintArray = append(idUintArray, uint(idUint))
-	}
 	var err error
-	switch context.Request.Method {
+	var params GroupParams
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
+	}
+	var result *[]Group
+	switch method {
 	case "GET":
-		result := Get(db, idUintArray)
+		result = Get(db, params.IDArray)
-		context.JSON(http.StatusOK, gin.H{
-			"result": result,
-		})
 	case "POST":
 		err = Create(db, params)
 	case "PUT":
 		err = Update(db, params)
 	case "DELETE":
-		err = Delete(db, idUintArray)
+		err = Delete(db, params.IDArray)
 	}
-	return err
+	return result, err
 }

src/lib/database/inventoryslot/inventoryslot.go

@@ -1,7 +1,8 @@
 package inventoryslot
 
 import (
-	"log"
+	"encoding/json"
+	"errors"
 
 	item "example.com/database/item"
 
@@ -10,11 +11,34 @@ import (
 
 type InventorySlot struct {
 	gorm.Model
-	Item     item.Item `gorm:"foreignKey:Name" json:"item"`
+	Item     item.Item `gorm:"uniqueIndex foreignKey:Name" json:"item"`
 	Quantity int64     `json:"quantity"` // Positive
 }
 
-func (inventorySlot InventorySlot) Create(db *gorm.DB) error {
+type InventorySlotParams struct {
+	// ID(s) of the object being modified
+	IDArray []uint `json:"id"`
+	// New fields
+	Item     uint  `json:"item"`
+	Quantity int64 `json:"quantity"`
+}
+
+func (params *InventorySlotParams) parse(IDUintArray *[]uint, body *[]byte) error {
+	var inputParams InventorySlotParams
+	params.IDArray = *IDUintArray
+	if len(*body) == 0 {
+		return nil
+	}
+	err := json.Unmarshal(*body, &inputParams)
+	if err != nil {
+		return err
+	}
+	params.Item = inputParams.Item
+	params.Quantity = inputParams.Quantity
+	return nil
+}
+
+func (inventorySlot InventorySlot) create(db *gorm.DB) error {
 	result := db.Create(&inventorySlot)
 	if result.Error != nil {
 		return result.Error
@@ -27,68 +51,112 @@ func (inventorySlot *InventorySlot) getAssociations(db *gorm.DB) {
 
 }
 
-func (inventorySlot *InventorySlot) Get(db *gorm.DB, inputInventorySlot uint) {
+func (inventorySlot *InventorySlot) get(db *gorm.DB, inputInventorySlot uint) {
 	db.Where("id = ?", inputInventorySlot).Take(&inventorySlot)
 	inventorySlot.getAssociations(db)
 }
 
-func (inventorySlot InventorySlot) Update(db *gorm.DB) error {
+func (inventorySlot InventorySlot) update(db *gorm.DB) error {
-	var originalIventorySlot InventorySlot
+	// Get the original InventorySlot object
-	originalIventorySlot.Get(db, inventorySlot.ID)
+	var originalInventorySlot InventorySlot
-	itemsError := db.Model(&originalIventorySlot).Association("Item").Replace(&inventorySlot.Item)
+	result := db.Model(&InventorySlot{}).Where("id = ?", inventorySlot.Model.ID).Take(&originalInventorySlot)
+	if result.Error != nil {
+		return result.Error
+	}
+	// Set the static values
+	originalInventorySlot.Quantity = inventorySlot.Quantity
+	// Set the associated values by grabbing them from the database
+	itemsError := db.Model(&originalInventorySlot).Association("Item").Replace(&inventorySlot.Item)
 	if itemsError != nil {
 		return itemsError
 	}
-	originalIventorySlot.Quantity = inventorySlot.Quantity
+	result = db.Model(&originalInventorySlot).Update("item", originalInventorySlot.Item)
+	if result.Error != nil {
+		err := errors.New("new item already exists")
+		return err
+	}
+	db.Save(&originalInventorySlot)
 	return nil
 }
 
-func (inventorySlot InventorySlot) Delete(db *gorm.DB) error {
+func (inventorySlot InventorySlot) delete(db *gorm.DB) error {
-	result := db.Delete(&inventorySlot)
+	result := db.Unscoped().Delete(&inventorySlot)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func Create(db *gorm.DB, itemName string, quantity int64) error {
+func Create(db *gorm.DB, params InventorySlotParams) error {
+	var newItem item.Item
+	newItem = (*item.Get(db, []uint{params.Item}))[0]
 	return InventorySlot{
-		Item:     (*item.Get(db, []string{itemName}))[0],
+		Item:     newItem,
-		Quantity: quantity,
+		Quantity: params.Quantity,
-	}.Create(db)
+	}.create(db)
 }
 
 func Get(db *gorm.DB, inputInventorySlots []uint) *[]InventorySlot {
 	var outputInventorySlots []InventorySlot
+	if len(inputInventorySlots) < 1 {
+		db.Model(&InventorySlot{}).Select("id").Find(&inputInventorySlots)
+	}
 	for _, inputInventorySlot := range inputInventorySlots {
 		var outputInventorySlot InventorySlot
-		outputInventorySlot.Get(db, inputInventorySlot)
+		outputInventorySlot.get(db, inputInventorySlot)
 		outputInventorySlots = append(outputInventorySlots, outputInventorySlot)
 	}
 	return &outputInventorySlots
 }
 
-func GetAll(db *gorm.DB) *[]InventorySlot {
+func Update(db *gorm.DB, params InventorySlotParams) error {
-	var outputInventorySlotIDs []uint
+	var newItem item.Item
-	result := db.Model(&InventorySlot{}).Select("id").Find(&outputInventorySlotIDs)
+	newItem = (*item.Get(db, []uint{params.Item}))[0]
-	if result.Error != nil {
+	return InventorySlot{
-		log.Println(result.Error)
+		Item:     newItem,
-	}
+		Quantity: params.Quantity,
-	return Get(db, outputInventorySlotIDs)
+	}.update(db)
 }
 
-func Update(db *gorm.DB, itemID int, itemName string, quantity int64) error {
+func Delete(db *gorm.DB, inputInventorySlots []uint) error {
-	inventorySlot := InventorySlot{
+	var inventorySlots []InventorySlot
-		Item:     (*item.Get(db, []string{itemName}))[0],
+	// if len(inputInventorySlots) < 1 {
-		Quantity: quantity,
+	// 	result := db.Model(&InventorySlot{}).Select("id").Find(&inputInventorySlots)
+	// 	if result.Error != nil {
+	// 		return result.Error
+	// 	}
+	// }
+	for _, inputInventorySlot := range inputInventorySlots {
+		var inventorySlot InventorySlot
+		inventorySlot.get(db, inputInventorySlot)
+		inventorySlots = append(inventorySlots, inventorySlot)
 	}
-	inventorySlot.ID = uint(itemID)
+	for _, inventorySlot := range inventorySlots {
-	return inventorySlot.Update(db)
+		err := inventorySlot.delete(db)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
-func Delete(db *gorm.DB, inputInventorySlotIDs []uint) {
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]InventorySlot, error) {
-	inventorySlots := Get(db, inputInventorySlotIDs)
+	var err error
-	for _, inventorySlot := range *inventorySlots {
+	var params InventorySlotParams
-		inventorySlot.Delete(db)
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
 	}
+	var result *[]InventorySlot
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
 }

src/lib/database/item/item.go

@@ -1,7 +1,8 @@
 package item
 
 import (
-	"log"
+	"encoding/json"
+	"errors"
 
 	customization "example.com/database/customization"
 	function "example.com/database/function"
@@ -23,7 +24,45 @@ type Item struct {
 	Visibility          []group.Group                 `gorm:"many2many:item_visibility_associations" json:"visibility"` // Unique
 }
 
-func (item Item) Create(db *gorm.DB) error {
+type ItemParams struct {
+	// ID(s) of the object being modified
+	IDArray []uint `json:"id"`
+	// New fields
+	Name                string `json:"name"`
+	Functions           []uint `json:"functions"`
+	FlavorText          string `json:"flavor_text"`
+	RulesDescription    string `json:"rules_description"`
+	PhysrepRequirements string `json:"phyrep_requirements"`
+	Tags                []uint `json:"tags"`
+	Customizations      []uint `json:"customizations"`
+	Visibility          []uint `json:"visibility"`
+}
+
+func (params *ItemParams) parse(IDUintArray *[]uint, body *[]byte) error {
+	var inputParams ItemParams
+	params.IDArray = *IDUintArray
+	if len(*body) == 0 {
+		return nil
+	}
+	err := json.Unmarshal(*body, &inputParams)
+	if err != nil {
+		return err
+	}
+	if inputParams.Name == "" {
+		return errors.New("input name cannot be empty")
+	}
+	params.Name = inputParams.Name
+	params.Functions = inputParams.Functions
+	params.FlavorText = inputParams.FlavorText
+	params.RulesDescription = inputParams.RulesDescription
+	params.PhysrepRequirements = inputParams.PhysrepRequirements
+	params.Tags = inputParams.Tags
+	params.Customizations = inputParams.Customizations
+	params.Visibility = inputParams.Visibility
+	return nil
+}
+
+func (item Item) create(db *gorm.DB) error {
 	result := db.Create(&item)
 	if result.Error != nil {
 		return result.Error
@@ -31,21 +70,31 @@ func (item Item) Create(db *gorm.DB) error {
 	return nil
 }
 
-func (item Item) getAssociations(db *gorm.DB) {
+func (item *Item) getAssociations(db *gorm.DB) {
 	db.Model(&item).Association("Functions").Find(&item.Functions)
 	db.Model(&item).Association("Tags").Find(&item.Tags)
 	db.Model(&item).Association("Customizations").Find(&item.Customizations)
 	db.Model(&item).Association("Visibility").Find(&item.Visibility)
 }
 
-func (item Item) Get(db *gorm.DB, inputItem string) {
+func (item *Item) get(db *gorm.DB, inputItem uint) {
-	db.Where("name = ?", inputItem).Take(&item)
+	db.Where("id = ?", inputItem).Take(&item)
 	item.getAssociations(db)
 }
 
-func (item Item) Update(db *gorm.DB) error {
+func (item Item) update(db *gorm.DB) error {
+	// Get the original Item object
 	var originalItem Item
-	originalItem.Get(db, item.Name)
+	result := db.Model(&Item{}).Where("id = ?", item.Model.ID).Take(&originalItem)
+	if result.Error != nil {
+		return result.Error
+	}
+	// Set the static values
+	originalItem.Name = item.Name
+	originalItem.FlavorText = item.FlavorText
+	originalItem.RulesDescription = item.RulesDescription
+	originalItem.PhysrepRequirements = item.PhysrepRequirements
+	// Set the associated values by grabbing them from the database
 	functionsError := db.Model(&originalItem).Association("Functions").Find(&originalItem.Functions)
 	if functionsError != nil {
 		return functionsError
@@ -62,65 +111,133 @@ func (item Item) Update(db *gorm.DB) error {
 	if visibilityError != nil {
 		return visibilityError
 	}
+	result = db.Model(&originalItem).Update("name", originalItem.Name)
+	if result.Error != nil {
+		err := errors.New("new name already exists")
+		return err
+	}
+	db.Save(&originalItem)
 	return nil
 }
 
-func (item Item) Delete(db *gorm.DB) error {
+func (item Item) delete(db *gorm.DB) error {
-	result := db.Delete(&item)
+	result := db.Unscoped().Delete(&item)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func Create(db *gorm.DB, name string, functions []uint, flavorText string, rulesDescription string, physrepRequirements string, tags []string, customizations []string, visibility []uint) error {
+func Create(db *gorm.DB, params ItemParams) error {
+	var newFunctions []function.Function
+	if len(params.Functions) > 0 {
+		newFunctions = *function.Get(db, params.Functions)
+	}
+	var newTags []itemtag.ItemTag
+	if len(params.Tags) > 0 {
+		newTags = *itemtag.Get(db, params.Tags)
+	}
+	var newCustomizations []customization.Customization
+	if len(params.Customizations) > 0 {
+		newCustomizations = *customization.Get(db, params.Customizations)
+	}
+	var newVisibility []group.Group
+	if len(params.Visibility) > 0 {
+		newVisibility = *group.Get(db, params.Visibility)
+	}
 	return Item{
-		Name:                name,
+		Name:                params.Name,
-		Functions:           *function.Get(db, functions),
+		Functions:           newFunctions,
-		FlavorText:          flavorText,
+		FlavorText:          params.FlavorText,
-		RulesDescription:    rulesDescription,
+		RulesDescription:    params.RulesDescription,
-		PhysrepRequirements: physrepRequirements,
+		PhysrepRequirements: params.PhysrepRequirements,
-		Tags:                *itemtag.Get(db, tags),
+		Tags:                newTags,
-		Customizations:      *customization.Get(db, customizations),
+		Customizations:      newCustomizations,
-		Visibility:          *group.Get(db, visibility),
+		Visibility:          newVisibility,
-	}.Create(db)
+	}.create(db)
 }
 
-func Get(db *gorm.DB, inputItems []string) *[]Item {
+func Get(db *gorm.DB, inputItems []uint) *[]Item {
 	var outputItems []Item
+	if len(inputItems) < 1 {
+		db.Model(&Item{}).Select("id").Find(&inputItems)
+	}
 	for _, inputItem := range inputItems {
 		var outputItem Item
-		outputItem.Get(db, inputItem)
+		outputItem.get(db, inputItem)
 		outputItems = append(outputItems, outputItem)
 	}
 	return &outputItems
 }
 
-func GetAll(db *gorm.DB) *[]Item {
+func Update(db *gorm.DB, params ItemParams) error {
-	var outputItemNames []string
+	var newFunctions []function.Function
-	result := db.Model(&Item{}).Select("name").Find(&outputItemNames)
+	if len(params.Functions) > 0 {
-	if result.Error != nil {
+		newFunctions = *function.Get(db, params.Functions)
-		log.Println(result.Error)
+	}
+	var newTags []itemtag.ItemTag
+	if len(params.Tags) > 0 {
+		newTags = *itemtag.Get(db, params.Tags)
+	}
+	var newCustomizations []customization.Customization
+	if len(params.Customizations) > 0 {
+		newCustomizations = *customization.Get(db, params.Customizations)
+	}
+	var newVisibility []group.Group
+	if len(params.Visibility) > 0 {
+		newVisibility = *group.Get(db, params.Visibility)
 	}
-	return Get(db, outputItemNames)
-}
-
-func Update(db *gorm.DB, name string, functions []uint, flavorText string, rulesDescription string, physrepRequirements string, tags []string, customizations []string, visibility []uint) error {
 	return Item{
-		Name:                name,
+		Name:                params.Name,
-		Functions:           *function.Get(db, functions),
+		Functions:           newFunctions,
-		FlavorText:          flavorText,
+		FlavorText:          params.FlavorText,
-		RulesDescription:    rulesDescription,
+		RulesDescription:    params.RulesDescription,
-		PhysrepRequirements: physrepRequirements,
+		PhysrepRequirements: params.PhysrepRequirements,
-		Tags:                *itemtag.Get(db, tags),
+		Tags:                newTags,
-		Customizations:      *customization.Get(db, customizations),
+		Customizations:      newCustomizations,
-		Visibility:          *group.Get(db, visibility),
+		Visibility:          newVisibility,
-	}.Update(db)
+	}.update(db)
 }
 
-func Delete(db *gorm.DB, inputItem []string) {
+func Delete(db *gorm.DB, inputItems []uint) error {
-	items := Get(db, inputItem)
+	var items []Item
-	for _, item := range *items {
+	// if len(inputItem) < 1 {
-		item.Delete(db)
+	// 	result := db.Model(&Item{}).Select("id").Find(&inputItem)
+	// 	if result.Error != nil {
+	// 		return result.Error
+	// 	}
+	// }
+	for _, inputItem := range inputItems {
+		var item Item
+		item.get(db, inputItem)
+		items = append(items, item)
 	}
+	for _, item := range items {
+		err := item.delete(db)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]Item, error) {
+	var err error
+	var params ItemParams
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
+	}
+	var result *[]Item
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
 }

src/lib/database/itemtag/itemtag.go

@@ -1,17 +1,42 @@
 package itemtag
 
 import (
-	"log"
+	"encoding/json"
+	"errors"
 
 	"gorm.io/gorm"
 )
 
 type ItemTag struct {
 	gorm.Model
-	Name string `gorm:"primaryKey uniqueIndex" json:"name"`
+	Name string `gorm:"uniqueIndex" json:"name"`
 }
 
-func (itemTag ItemTag) Create(db *gorm.DB) error {
+type ItemTagParams struct {
+	// ID(s) of the object being modified
+	IDArray []uint `json:"id"`
+	// New fields
+	Name string `json:"name"`
+}
+
+func (params *ItemTagParams) parse(IDUintArray *[]uint, body *[]byte) error {
+	var inputParams ItemTagParams
+	params.IDArray = *IDUintArray
+	if len(*body) == 0 {
+		return nil
+	}
+	err := json.Unmarshal(*body, &inputParams)
+	if err != nil {
+		return err
+	}
+	if inputParams.Name == "" {
+		return errors.New("input name cannot be empty")
+	}
+	params.Name = inputParams.Name
+	return nil
+}
+
+func (itemTag ItemTag) create(db *gorm.DB) error {
 	result := db.Create(&itemTag)
 	if result.Error != nil {
 		return result.Error
@@ -19,60 +44,100 @@ func (itemTag ItemTag) Create(db *gorm.DB) error {
 	return nil
 }
 
-func (itemTag *ItemTag) Get(db *gorm.DB, inputItemTag string) {
+func (itemTag *ItemTag) get(db *gorm.DB, inputItemTag uint) {
-	db.Where("name = ?", inputItemTag).Take(&itemTag)
+	db.Where("id = ?", inputItemTag).Take(&itemTag)
 }
 
-func (itemTag ItemTag) Update(db *gorm.DB) error {
+func (itemTag ItemTag) update(db *gorm.DB) error {
-	result := db.Save(&itemTag)
+	// Get the original Function object
+	var originalItemTag ItemTag
+	result := db.Model(&ItemTag{}).Where("id = ?", itemTag.Model.ID).Take(&originalItemTag)
+	if result.Error != nil {
+		return result.Error
+	}
+	// Set the static values
+	originalItemTag.Name = itemTag.Name
+	result = db.Model(&originalItemTag).Update("name", originalItemTag.Name)
+	if result.Error != nil {
+		err := errors.New("new name already exists")
+		return err
+	}
+	db.Save(&originalItemTag)
+	return nil
+}
+
+func (itemTag ItemTag) delete(db *gorm.DB) error {
+	result := db.Unscoped().Delete(&itemTag)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func (itemTag ItemTag) Delete(db *gorm.DB) error {
+func Create(db *gorm.DB, params ItemTagParams) error {
-	result := db.Delete(&itemTag)
-	if result.Error != nil {
-		return result.Error
-	}
-	return nil
-}
-
-func Create(db *gorm.DB, name string) error {
 	return ItemTag{
-		Name: name,
+		Name: params.Name,
-	}.Create(db)
+	}.create(db)
 }
 
-func Get(db *gorm.DB, inputItemTags []string) *[]ItemTag {
+func Get(db *gorm.DB, inputItemTags []uint) *[]ItemTag {
 	var outputItemTags []ItemTag
+	if len(inputItemTags) < 1 {
+		db.Model(&ItemTag{}).Select("id").Find(&inputItemTags)
+	}
 	for _, inputItemTag := range inputItemTags {
 		var outputItemTag ItemTag
-		outputItemTag.Get(db, inputItemTag)
+		outputItemTag.get(db, inputItemTag)
 		outputItemTags = append(outputItemTags, outputItemTag)
 	}
 	return &outputItemTags
 }
 
-func GetAll(db *gorm.DB) *[]ItemTag {
+func Update(db *gorm.DB, params ItemTagParams) error {
-	var outputItemTagNames []string
-	result := db.Model(&ItemTag{}).Select("name").Find(&outputItemTagNames)
-	if result.Error != nil {
-		log.Println(result.Error)
-	}
-	return Get(db, outputItemTagNames)
-}
-
-func Update(db *gorm.DB, name string) error {
 	return ItemTag{
-		Name: name,
+		Name: params.Name,
-	}.Update(db)
+	}.update(db)
 }
 
-func Delete(db *gorm.DB, inputItemTags []string) {
+func Delete(db *gorm.DB, inputItemTags []uint) error {
-	itemtags := Get(db, inputItemTags)
+	var itemTags []ItemTag
-	for _, itemtag := range *itemtags {
+	// if len(inputItemTags) < 1 {
-		itemtag.Delete(db)
+	// 	result := db.Model(&ItemTag{}).Select("id").Find(&inputItemTags)
+	// 	if result.Error != nil {
+	// 		return result.Error
+	// 	}
+	// }
+	for _, inputItemTag := range inputItemTags {
+		var itemTag ItemTag
+		itemTag.get(db, inputItemTag)
+		itemTags = append(itemTags, itemTag)
 	}
+	for _, itemTag := range itemTags {
+		err := itemTag.delete(db)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]ItemTag, error) {
+	var err error
+	var params ItemTagParams
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
+	}
+	var result *[]ItemTag
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
 }

src/lib/database/person/person.go

@@ -1,6 +1,8 @@
 package person
 
 import (
+	"encoding/json"
+	"errors"
 	"log"
 
 	group "example.com/database/group"
@@ -14,7 +16,33 @@ type Person struct {
 	Groups []group.Group `gorm:"many2many:person_group_associations" json:"groups"` // Unique
 }
 
-func (person Person) Create(db *gorm.DB) error {
+type PersonParams struct {
+	// ID(s) of the object being modified
+	IDArray []uint `json:"id"`
+	// New fields
+	Name   string `json:"name"`
+	Groups []uint `json:"groups"`
+}
+
+func (params *PersonParams) parse(IDUintArray *[]uint, body *[]byte) error {
+	var inputParams PersonParams
+	params.IDArray = *IDUintArray
+	if len(*body) == 0 {
+		return nil
+	}
+	err := json.Unmarshal(*body, &inputParams)
+	if err != nil {
+		return err
+	}
+	if inputParams.Name == "" {
+		return errors.New("input name cannot be empty")
+	}
+	params.Name = inputParams.Name
+	params.Groups = inputParams.Groups
+	return nil
+}
+
+func (person Person) create(db *gorm.DB) error {
 	result := db.Create(&person)
 	if result.Error != nil {
 		return result.Error
@@ -26,34 +54,52 @@ func (person *Person) getAssociations(db *gorm.DB) {
 	db.Model(&person).Association("Groups").Find(&person.Groups)
 }
 
-func (person *Person) Get(db *gorm.DB, inputPerson uint) {
+func (person *Person) get(db *gorm.DB, inputPerson uint) {
 	db.Where("id = ?", inputPerson).Take(&person)
 	person.getAssociations(db)
 }
 
-func (person Person) Update(db *gorm.DB) error {
+func (person Person) update(db *gorm.DB) error {
+	// Get the original Person object
 	var originalPerson Person
-	originalPerson.Get(db, person.ID)
+	result := db.Model(&Person{}).Where("id = ?", person.Model.ID).Take(&originalPerson)
+	if result.Error != nil {
+		return result.Error
+	}
+	// Set the static values
+	originalPerson.Name = person.Name
+	// Set the associated values by grabbing them from the database
 	groupsError := db.Model(&originalPerson).Association("Groups").Replace(&person.Groups)
 	if groupsError != nil {
 		return groupsError
 	}
+	result = db.Model(&originalPerson).Update("name", originalPerson.Name)
+	if result.Error != nil {
+		err := errors.New("new name already exists")
+		return err
+	}
+	db.Save(&originalPerson)
 	return nil
 }
 
-func (person Person) Delete(db *gorm.DB) error {
+func (person Person) delete(db *gorm.DB) error {
-	result := db.Delete(&person)
+	result := db.Unscoped().Delete(&person)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func Create(db *gorm.DB, name string, groups []uint) error {
+func Create(db *gorm.DB, params PersonParams) error {
+	var newGroups []group.Group
+	log.Println(params)
+	if len(params.Groups) > 0 {
+		newGroups = *group.Get(db, params.Groups)
+	}
 	return Person{
-		Name:   name,
+		Name:   params.Name,
-		Groups: *group.Get(db, groups),
+		Groups: newGroups,
-	}.Create(db)
+	}.create(db)
 }
 
 func GetByName(db *gorm.DB, name string) *Person {
@@ -65,37 +111,68 @@ func GetByName(db *gorm.DB, name string) *Person {
 
 func Get(db *gorm.DB, inputPersons []uint) *[]Person {
 	var outputPersons []Person
+	if len(inputPersons) < 1 {
+		db.Model(&Person{}).Select("id").Find(&inputPersons)
+	}
 	for _, inputPerson := range inputPersons {
 		var outputPerson Person
-		outputPerson.Get(db, inputPerson)
+		outputPerson.get(db, inputPerson)
 		outputPersons = append(outputPersons, outputPerson)
 	}
 	return &outputPersons
 }
 
-func GetAll(db *gorm.DB) *[]Person {
+func Update(db *gorm.DB, params PersonParams) error {
-	var outputPersonNames []uint
+	var newGroups []group.Group
-	result := db.Model(&Person{}).Select("id").Find(&outputPersonNames)
+	if len(params.Groups) > 0 {
-	if result.Error != nil {
+		newGroups = *group.Get(db, params.Groups)
-		log.Println(result.Error)
 	}
-	return Get(db, outputPersonNames)
-}
-
-func Update(db *gorm.DB, name string, groups []uint) error {
 	return Person{
-		Name:   name,
+		Model:  gorm.Model{ID: params.IDArray[0]},
-		Groups: *group.Get(db, groups),
+		Name:   params.Name,
-	}.Update(db)
+		Groups: newGroups,
+	}.update(db)
 }
 
 func Delete(db *gorm.DB, inputPersons []uint) error {
-	persons := Get(db, inputPersons)
+	var persons []Person
-	for _, person := range *persons {
+	if len(inputPersons) < 1 {
-		err := person.Delete(db)
+		result := db.Model(&Person{}).Select("id").Find(&inputPersons)
+		if result.Error != nil {
+			return result.Error
+		}
+	}
+	for _, inputPerson := range inputPersons {
+		var person Person
+		person.get(db, inputPerson)
+		persons = append(persons, person)
+	}
+	for _, person := range persons {
+		err := person.delete(db)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
+
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]Person, error) {
+	var err error
+	var params PersonParams
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
+	}
+	var result *[]Person
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
+}

src/lib/database/role/role.go

@@ -1,7 +1,8 @@
 package role
 
 import (
-	"log"
+	"encoding/json"
+	"errors"
 
 	group "example.com/database/group"
 	tier "example.com/database/tier"
@@ -11,12 +12,40 @@ import (
 
 type Role struct {
 	gorm.Model
-	Name       string        `gorm:"primaryKey" json:"name"`
+	Name       string        `gorm:"uniqueIndex" json:"name"`
 	Tiers      []tier.Tier   `gorm:"many2many:role_tier_associations" json:"tiers"`
 	Visibility []group.Group `gorm:"many2many:role_visibility_associations" json:"visibility"` // Unique
 }
 
-func (role Role) Create(db *gorm.DB) error {
+type RoleParams struct {
+	// ID(s) of the object being modified
+	IDArray []uint `json:"id"`
+	// New fields
+	Name       string `json:"name"`
+	Tiers      []uint `json:"tiers"`
+	Visibility []uint `json:"visibility"`
+}
+
+func (params *RoleParams) parse(IDUintArray *[]uint, body *[]byte) error {
+	var inputParams RoleParams
+	params.IDArray = *IDUintArray
+	if len(*body) == 0 {
+		return nil
+	}
+	err := json.Unmarshal(*body, &inputParams)
+	if err != nil {
+		return err
+	}
+	if inputParams.Name == "" {
+		return errors.New("input name cannot be empty")
+	}
+	params.Name = inputParams.Name
+	params.Tiers = inputParams.Tiers
+	params.Visibility = inputParams.Visibility
+	return nil
+}
+
+func (role Role) create(db *gorm.DB) error {
 	result := db.Create(&role)
 	if result.Error != nil {
 		return result.Error
@@ -27,68 +56,132 @@ func (role Role) Create(db *gorm.DB) error {
 func (role *Role) getAssociations(db *gorm.DB) {
 	db.Model(&role).Association("Tiers").Find(&role.Tiers)
 	db.Model(&role).Association("Visibility").Find(&role.Visibility)
-	//
 }
 
-func (role *Role) Get(db *gorm.DB, inputRole string) {
+func (role *Role) get(db *gorm.DB, inputRole uint) {
-	db.Where("name = ?", inputRole).Take(&role)
+	db.Where("id = ?", inputRole).Take(&role)
 	role.getAssociations(db)
 }
 
-func (role Role) Update(db *gorm.DB) error {
+func (role Role) update(db *gorm.DB) error {
-	result := db.Save(&role)
+	// Get the original Role object
+	var originalRole Role
+	result := db.Model(&Role{}).Where("id = ?", role.Model.ID).Take(&originalRole)
+	if result.Error != nil {
+		return result.Error
+	}
+	// Set the static values
+	originalRole.Name = role.Name
+	// Set the associated values by grabbing them from the database
+	tiersError := db.Model(&originalRole).Association("Tiers").Replace(&role.Tiers)
+	if tiersError != nil {
+		return tiersError
+	}
+	visibilityError := db.Model(&originalRole).Association("Visibility").Replace(&role.Visibility)
+	if visibilityError != nil {
+		return visibilityError
+	}
+	result = db.Model(&originalRole).Update("name", originalRole.Name)
+	if result.Error != nil {
+		err := errors.New("new name already exists")
+		return err
+	}
+	db.Save(&originalRole)
+	return nil
+}
+
+func (role Role) delete(db *gorm.DB) error {
+	result := db.Unscoped().Delete(&role)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func (role Role) Delete(db *gorm.DB) error {
+func Create(db *gorm.DB, params RoleParams) error {
-	result := db.Delete(&role)
+	var newTiers []tier.Tier
-	if result.Error != nil {
+	if len(params.Tiers) > 0 {
-		return result.Error
+		newTiers = *tier.Get(db, params.Tiers)
+	}
+	var newVisibility []group.Group
+	if len(params.Visibility) > 0 {
+		newVisibility = *group.Get(db, params.Visibility)
 	}
-	return nil
-}
-
-func Create(db *gorm.DB, name string, tiers []uint, visibility []uint) error {
 	return Role{
-		Name:       name,
+		Name:       params.Name,
-		Tiers:      *tier.Get(db, tiers),
+		Tiers:      newTiers,
-		Visibility: *group.Get(db, visibility),
+		Visibility: newVisibility,
-	}.Create(db)
+	}.create(db)
 }
 
-func Get(db *gorm.DB, inputRoles []string) *[]Role {
+func Get(db *gorm.DB, inputRoles []uint) *[]Role {
 	var outputRoles []Role
+	if len(inputRoles) < 1 {
+		db.Model(&Role{}).Select("id").Find(&inputRoles)
+	}
 	for _, inputRole := range inputRoles {
 		var outputRole Role
-		outputRole.Get(db, inputRole)
+		outputRole.get(db, inputRole)
 		outputRoles = append(outputRoles, outputRole)
 	}
 	return &outputRoles
 }
 
-func GetAll(db *gorm.DB) *[]Role {
+func Update(db *gorm.DB, params RoleParams) error {
-	var outputRoleNames []string
+	var newTiers []tier.Tier
-	result := db.Model(&Role{}).Select("name").Find(&outputRoleNames)
+	if len(params.Tiers) > 0 {
-	if result.Error != nil {
+		newTiers = *tier.Get(db, params.Tiers)
-		log.Println(result.Error)
+	}
+	var newVisibility []group.Group
+	if len(params.Visibility) > 0 {
+		newVisibility = *group.Get(db, params.Visibility)
 	}
-	return Get(db, outputRoleNames)
-}
-
-func Update(db *gorm.DB, name string, tiers []uint, visibility []uint) error {
 	return Role{
-		Name:       name,
+		Name:       params.Name,
-		Tiers:      *tier.Get(db, tiers),
+		Tiers:      newTiers,
-		Visibility: *group.Get(db, visibility),
+		Visibility: newVisibility,
-	}.Update(db)
+	}.update(db)
 }
 
-func Delete(db *gorm.DB, inputRoles []string) {
+func Delete(db *gorm.DB, inputRoles []uint) error {
-	roles := Get(db, inputRoles)
+	var roles []Role
-	for _, role := range *roles {
+	if len(inputRoles) < 1 {
-		role.Delete(db)
+		result := db.Model(&Role{}).Select("id").Find(&inputRoles)
+		if result.Error != nil {
+			return result.Error
+		}
 	}
+	for _, inputRole := range inputRoles {
+		var function Role
+		function.get(db, inputRole)
+		roles = append(roles, function)
+	}
+	for _, role := range roles {
+		err := role.delete(db)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]Role, error) {
+	var err error
+	var params RoleParams
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
+	}
+	var result *[]Role
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
 }

src/lib/database/schematic/schematic.go

@@ -1,7 +1,7 @@
 package schematic
 
 import (
-	"log"
+	"encoding/json"
 
 	function "example.com/database/function"
 	group "example.com/database/group"
@@ -20,7 +20,38 @@ type Schematic struct {
 	Visibility   []group.Group                 `gorm:"many2many:schematic_group_associations" json:"visibility"` // Unique
 }
 
-func (schematic Schematic) Create(db *gorm.DB) error {
+type SchematicParams struct {
+	// ID(s) of the object being modified
+	IDArray []uint `json:"id"`
+	// New fields
+	Material     []uint `json:"material"`
+	Tools        []uint `json:"tools"`
+	Requirements []uint `json:"requirements"`
+	TimeUnits    int64  `json:"time_units"`
+	Result       uint   `json:"result"`
+	Visibility   []uint `json:"visibility"`
+}
+
+func (params *SchematicParams) parse(IDUintArray *[]uint, body *[]byte) error {
+	var inputParams SchematicParams
+	params.IDArray = *IDUintArray
+	if len(*body) == 0 {
+		return nil
+	}
+	err := json.Unmarshal(*body, &inputParams)
+	if err != nil {
+		return err
+	}
+	params.Material = inputParams.Material
+	params.Tools = inputParams.Tools
+	params.Requirements = inputParams.Requirements
+	params.TimeUnits = inputParams.TimeUnits
+	params.Result = inputParams.Result
+	params.Visibility = inputParams.Visibility
+	return nil
+}
+
+func (schematic Schematic) create(db *gorm.DB) error {
 	result := db.Create(&schematic)
 	if result.Error != nil {
 		return result.Error
@@ -36,12 +67,21 @@ func (schematic *Schematic) getAssociations(db *gorm.DB) {
 	db.Model(&schematic).Association("Visibility").Find(&schematic.Visibility)
 }
 
-func (schematic *Schematic) Get(db *gorm.DB, inputSchematic uint) {
+func (schematic *Schematic) get(db *gorm.DB, inputSchematic uint) {
 	db.Model(&Schematic{}).Where("id = ?", inputSchematic).Take(&schematic)
 	schematic.getAssociations(db)
 }
 
-func (schematic Schematic) Update(db *gorm.DB) error {
+func (schematic Schematic) update(db *gorm.DB) error {
+	// Get the original Schematic object
+	var originalSchematic Schematic
+	result := db.Model(&Schematic{}).Where("id = ?", schematic.Model.ID).Take(&originalSchematic)
+	if result.Error != nil {
+		return result.Error
+	}
+	// Set the static values
+	originalSchematic.TimeUnits = schematic.TimeUnits
+	// Set the associated values by grabbing them from the database
 	materialError := db.Model(&schematic).Association("Material").Replace(&schematic.Material)
 	if materialError != nil {
 		return materialError
@@ -62,61 +102,128 @@ func (schematic Schematic) Update(db *gorm.DB) error {
 	if visibilityError != nil {
 		return visibilityError
 	}
+	db.Save(&originalSchematic)
 	return nil
 }
 
-func (schematic Schematic) Delete(db *gorm.DB) error {
+func (schematic Schematic) delete(db *gorm.DB) error {
-	result := db.Delete(&schematic)
+	result := db.Unscoped().Delete(&schematic)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func Create(db *gorm.DB, material []uint, tools []uint, requirements []uint, timeUnits int64, result uint, visibility []uint) error {
+func Create(db *gorm.DB, params SchematicParams) error {
+	var newMaterial []inventoryslot.InventorySlot
+	if len(params.Material) > 0 {
+		newMaterial = *inventoryslot.Get(db, params.Material)
+	}
+	var newTools []inventoryslot.InventorySlot
+	if len(params.Tools) > 0 {
+		newTools = *inventoryslot.Get(db, params.Tools)
+	}
+	var newRequirements []function.Function
+	if len(params.Requirements) > 0 {
+		newRequirements = *function.Get(db, params.Requirements)
+	}
+	resultArray := *inventoryslot.Get(db, []uint{params.Result})
+	newResult := resultArray[0]
+	var newVisibility []group.Group
+	if len(params.Visibility) > 0 {
+		newVisibility = *group.Get(db, params.Visibility)
+	}
 	return Schematic{
-		Material:     *inventoryslot.Get(db, material),
+		Material:     newMaterial,
-		Tools:        *inventoryslot.Get(db, tools),
+		Tools:        newTools,
-		Requirements: *function.Get(db, requirements),
+		Requirements: newRequirements,
-		TimeUnits:    timeUnits,
+		TimeUnits:    params.TimeUnits,
-		Result:       (*inventoryslot.Get(db, []uint{result}))[0],
+		Result:       newResult,
-		Visibility:   *group.Get(db, visibility),
+		Visibility:   newVisibility,
-	}.Create(db)
+	}.create(db)
 }
 
 func Get(db *gorm.DB, inputSchematics []uint) *[]Schematic {
 	var outputSchematics []Schematic
+	if len(inputSchematics) < 1 {
+		db.Model(&Schematic{}).Select("id").Find(&inputSchematics)
+	}
 	for _, inputSchematic := range inputSchematics {
 		var outputSchematic Schematic
-		outputSchematic.Get(db, inputSchematic)
+		outputSchematic.get(db, inputSchematic)
 		outputSchematics = append(outputSchematics, outputSchematic)
 	}
 	return &outputSchematics
 }
 
-func GetAll(db *gorm.DB) *[]Schematic {
+func Update(db *gorm.DB, params SchematicParams) error {
-	var outputSchematics []uint
+	var newMaterial []inventoryslot.InventorySlot
-	result := db.Model(&Schematic{}).Select("id").Find(&outputSchematics)
+	if len(params.Material) > 0 {
-	if result.Error != nil {
+		newMaterial = *inventoryslot.Get(db, params.Material)
-		log.Println(result.Error)
+	}
+	var newTools []inventoryslot.InventorySlot
+	if len(params.Tools) > 0 {
+		newTools = *inventoryslot.Get(db, params.Tools)
+	}
+	var newRequirements []function.Function
+	if len(params.Requirements) > 0 {
+		newRequirements = *function.Get(db, params.Requirements)
+	}
+	resultArray := *inventoryslot.Get(db, []uint{params.Result})
+	newResult := resultArray[0]
+	var newVisibility []group.Group
+	if len(params.Visibility) > 0 {
+		newVisibility = *group.Get(db, params.Visibility)
 	}
-	return Get(db, outputSchematics)
-}
-
-func Update(db *gorm.DB, material []uint, tools []uint, requirements []uint, timeUnits int64, result uint, visibility []uint) error {
 	return Schematic{
-		Material:     *inventoryslot.Get(db, material),
+		Material:     newMaterial,
-		Tools:        *inventoryslot.Get(db, tools),
+		Tools:        newTools,
-		Requirements: *function.Get(db, requirements),
+		Requirements: newRequirements,
-		TimeUnits:    timeUnits,
+		TimeUnits:    params.TimeUnits,
-		Result:       (*inventoryslot.Get(db, []uint{result}))[0],
+		Result:       newResult,
-		Visibility:   *group.Get(db, visibility),
+		Visibility:   newVisibility,
-	}.Update(db)
+	}.update(db)
 }
 
-func Delete(db *gorm.DB, inputSchematics []uint) {
+func Delete(db *gorm.DB, inputSchematics []uint) error {
-	schematics := Get(db, inputSchematics)
+	var schematics []Schematic
-	for _, schematic := range *schematics {
+	// if len(inputSchematics) < 1 {
-		schematic.Delete(db)
+	// 	result := db.Model(&Schematic{}).Select("id").Find(&inputSchematics)
+	// 	if result.Error != nil {
+	// 		return result.Error
+	// 	}
+	// }
+	for _, inputSchematic := range inputSchematics {
+		var schematic Schematic
+		schematic.get(db, inputSchematic)
+		schematics = append(schematics, schematic)
 	}
+	for _, schematic := range schematics {
+		err := schematic.delete(db)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]Schematic, error) {
+	var err error
+	var params SchematicParams
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
+	}
+	var result *[]Schematic
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
 }

src/lib/database/tier/tier.go

@@ -1,7 +1,7 @@
 package tier
 
 import (
-	"log"
+	"encoding/json"
 
 	functionset "example.com/database/functionset"
 
@@ -13,7 +13,28 @@ type Tier struct {
 	FunctionSets []functionset.FunctionSet `gorm:"many2many:tier_functionset_associations" json:"function_sets"`
 }
 
-func (tier Tier) Create(db *gorm.DB) error {
+type TierParams struct {
+	// ID(s) of the object being modified
+	IDArray []uint `json:"id"`
+	// New fields
+	FunctionSets []uint `json:"function_sets"`
+}
+
+func (params *TierParams) parse(IDUintArray *[]uint, body *[]byte) error {
+	var inputParams TierParams
+	params.IDArray = *IDUintArray
+	if len(*body) == 0 {
+		return nil
+	}
+	err := json.Unmarshal(*body, &inputParams)
+	if err != nil {
+		return err
+	}
+	params.FunctionSets = inputParams.FunctionSets
+	return nil
+}
+
+func (tier Tier) create(db *gorm.DB) error {
 	result := db.Create(&tier)
 	if result.Error != nil {
 		return result.Error
@@ -25,63 +46,108 @@ func (tier *Tier) getAssociations(db *gorm.DB) {
 	db.Model(&tier).Association("FunctionSets").Find(&tier.FunctionSets)
 }
 
-func (tier *Tier) Get(db *gorm.DB, inputTier uint) {
+func (tier *Tier) get(db *gorm.DB, inputTier uint) {
 	db.Where("id = ?", inputTier).Take(&tier)
 	tier.getAssociations(db)
 }
 
-func (tier Tier) Update(db *gorm.DB) error {
+func (tier Tier) update(db *gorm.DB) error {
-	result := db.Save(&tier)
+	// Get the original Tier object
+	var originalTier Tier
+	result := db.Model(&Tier{}).Where("id = ?", tier.Model.ID).Take(&originalTier)
+	if result.Error != nil {
+		return result.Error
+	}
+	// Set the associated values by grabbing them from the database
+	tagsError := db.Model(&originalTier).Association("FunctionSets").Replace(&tier.FunctionSets)
+	if tagsError != nil {
+		return tagsError
+	}
+	db.Save(&originalTier)
+	return nil
+}
+
+func (tier Tier) delete(db *gorm.DB) error {
+	result := db.Unscoped().Delete(&tier)
 	if result.Error != nil {
 		return result.Error
 	}
 	return nil
 }
 
-func (tier Tier) Delete(db *gorm.DB) error {
+func Create(db *gorm.DB, params TierParams) error {
-	result := db.Delete(&tier)
+	var newFunctionSets []functionset.FunctionSet
-	if result.Error != nil {
+	if len(params.FunctionSets) > 0 {
-		return result.Error
+		newFunctionSets = *functionset.Get(db, params.FunctionSets)
 	}
-	return nil
-}
-
-func Create(db *gorm.DB, functionSets []uint) error {
 	return Tier{
-		FunctionSets: *functionset.Get(db, functionSets),
+		FunctionSets: newFunctionSets,
-	}.Create(db)
+	}.create(db)
 }
 
 func Get(db *gorm.DB, inputTiers []uint) *[]Tier {
 	var outputTiers []Tier
+	if len(inputTiers) < 1 {
+		db.Model(&Tier{}).Select("id").Find(&inputTiers)
+	}
 	for _, inputTier := range inputTiers {
 		var outputTier Tier
-		outputTier.Get(db, inputTier)
+		outputTier.get(db, inputTier)
 		outputTiers = append(outputTiers, outputTier)
 	}
 	return &outputTiers
 }
 
-func GetAll(db *gorm.DB) *[]Tier {
+func Update(db *gorm.DB, params TierParams) error {
-	var outputTierIDs []uint
+	var newFunctionSets []functionset.FunctionSet
-	result := db.Find(&outputTierIDs)
+	if len(params.FunctionSets) > 0 {
-	if result.Error != nil {
+		newFunctionSets = *functionset.Get(db, params.FunctionSets)
-		log.Println(result.Error)
 	}
-	return Get(db, outputTierIDs)
+	return Tier{
+		Model:        gorm.Model{ID: params.IDArray[0]},
+		FunctionSets: newFunctionSets,
+	}.update(db)
 }
 
-func Update(db *gorm.DB, id int, functionSets []uint) error {
+func Delete(db *gorm.DB, inputTiers []uint) error {
-	outputTier := Tier{
+	var tiers []Tier
-		FunctionSets: *functionset.Get(db, functionSets),
+	// if len(inputTiers) < 1 {
+	// 	result := db.Model(&Tier{}).Select("id").Find(&inputTiers)
+	// 	if result.Error != nil {
+	// 		return result.Error
+	// 	}
+	// }
+	for _, inputTier := range inputTiers {
+		var tier Tier
+		tier.get(db, inputTier)
+		tiers = append(tiers, tier)
 	}
-	outputTier.ID = uint(id)
+	for _, tier := range tiers {
-	return outputTier.Update(db)
+		err := tier.delete(db)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
 }
 
-func Delete(db *gorm.DB, inputTiers []uint) {
+func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]Tier, error) {
-	tiers := Get(db, inputTiers)
+	var err error
-	for _, tier := range *tiers {
+	var params TierParams
-		tier.Delete(db)
+	err = params.parse(IDUintArray, body)
+	if err != nil {
+		return nil, err
 	}
+	var result *[]Tier
+	switch method {
+	case "GET":
+		result = Get(db, params.IDArray)
+	case "POST":
+		err = Create(db, params)
+	case "PUT":
+		err = Update(db, params)
+	case "DELETE":
+		err = Delete(db, params.IDArray)
+	}
+	return result, err
 }

src/lib/database/user/user.go

@@ -103,7 +103,7 @@ func (user User) Update(db *gorm.DB) error {
 }
 
 func (user User) Delete(db *gorm.DB) error {
-	result := db.Delete(&user)
+	result := db.Unscoped().Delete(&user)
 	if result.Error != nil {
 		return result.Error
 	}
@@ -146,7 +146,7 @@ func Exists(db *gorm.DB, id string) bool {
 }
 
 func Create(db *gorm.DB, discordId string, displayName string, username string, avatar string, avatarDecoration string, loginToken string, loggedIn bool) error {
-	person.Create(db, displayName, []uint{})
+	person.Create(db, person.PersonParams{Name: displayName, Groups: []uint{}})
 	newPerson := person.GetByName(db, username)
 	newUser := User{
 		Id:               discordId,