All database models have create and get functions.

src/gin-cpularp.go

@@ -28,10 +28,13 @@ func main() {
 	app.GET("/get/user/authorized", api.GetIsUserAuthorized)
 	app.GET("/get/group", api.GetDatabaseGroup)
 	app.GET("/get/groups", api.GetDatabaseGroups)
+	app.GET("/get/all/groups", api.GetAllDatabaseGroups)
 	app.GET("/get/function", api.GetDatabaseFunction)
 	app.GET("/get/functions", api.GetDatabaseFunctions)
+	app.GET("/get/all/functions", api.GetAllDatabaseFunctions)
 	app.GET("/get/function-tag", api.GetDatabaseFunctionTag)
 	app.GET("/get/function-tags", api.GetDatabaseFunctionTags)
+	app.GET("/get/all/function-tags", api.GetAllDatabaseFunctionTags)
 	// Delete
 	app.Run(":31337")
 }

src/lib/api/api.go

@@ -267,7 +267,15 @@ func GetDatabaseGroup(context *gin.Context) {
 }
 
 func GetDatabaseGroups(context *gin.Context) {
-	groups := databasecommands.GetDatabaseGroups(GlobalDatabase)
+	groupNames := context.QueryArray("groups")
+	groups := databasecommands.GetDatabaseGroups(GlobalDatabase, groupNames)
+	context.JSON(http.StatusOK, gin.H{
+		"groups": groups,
+	})
+}
+
+func GetAllDatabaseGroups(context *gin.Context) {
+	groups := databasecommands.GetAllDatabaseGroups(GlobalDatabase)
 	context.JSON(http.StatusOK, gin.H{
 		"groups": groups,
 	})
@@ -286,7 +294,15 @@ func GetDatabaseFunction(context *gin.Context) {
 }
 
 func GetDatabaseFunctions(context *gin.Context) {
-	functions := databasecommands.GetDatabaseFunctions(GlobalDatabase)
+	functionNames := context.QueryArray("functions")
+	functions := databasecommands.GetDatabaseFunctions(GlobalDatabase, functionNames)
+	context.JSON(http.StatusOK, gin.H{
+		"functions": functions,
+	})
+}
+
+func GetAllDatabaseFunctions(context *gin.Context) {
+	functions := databasecommands.GetAllDatabaseFunctions(GlobalDatabase)
 	context.JSON(http.StatusOK, gin.H{
 		"functions": functions,
 	})
@@ -305,7 +321,15 @@ func GetDatabaseFunctionTag(context *gin.Context) {
 }
 
 func GetDatabaseFunctionTags(context *gin.Context) {
-	functionTags := databasecommands.GetDatabaseFunctionTags(GlobalDatabase)
+	functionTagNames := context.QueryArray("functiontags")
+	functionTags := databasecommands.GetDatabaseFunctionTags(GlobalDatabase, functionTagNames)
+	context.JSON(http.StatusOK, gin.H{
+		"function_tags": functionTags,
+	})
+}
+
+func GetAllDatabaseFunctionTags(context *gin.Context) {
+	functionTags := databasecommands.GetAllDatabaseFunctionTags(GlobalDatabase)
 	context.JSON(http.StatusOK, gin.H{
 		"function_tags": functionTags,
 	})

src/lib/database/commands/commands.go

@@ -196,14 +196,26 @@ func GetDatabasePerson(db *gorm.DB, inputPerson string) databasemodels.Person {
 	if result.Error != nil {
 		return databasemodels.Person{}
 	}
+	db.Model(&outputPerson).Association("Groups").Find(&outputPerson.Groups)
 	return outputPerson
 }
 
-func GetDatabasePersons(db *gorm.DB) []databasemodels.Person {
+func GetDatabasePersons(db *gorm.DB, inputPersons []string) []databasemodels.Person {
 	var outputPersons []databasemodels.Person
-	db.Find(&outputPersons)
+	for _, inputPerson := range inputPersons {
+		outputPersons = append(outputPersons, GetDatabasePerson(db, inputPerson))
+	}
+	return outputPersons
+}
+
+func GetAllDatabasePersons(db *gorm.DB) []databasemodels.Person {
+	var outputPersons []databasemodels.Person
+	result := db.Find(&outputPersons)
+	if result.Error != nil {
+		log.Println(result.Error)
+	}
 	for index, outputPerson := range outputPersons {
-		db.Model(&outputPerson).Association("Groups").Find(&outputPersons[index].Groups)
+		outputPersons[index] = GetDatabasePerson(db, outputPerson.Name)
 	}
 	return outputPersons
 }
@@ -217,18 +229,24 @@ func GetDatabaseGroup(db *gorm.DB, inputGroup string) databasemodels.Group {
 	return outputGroup
 }
 
-func GetDatabaseGroups(db *gorm.DB) []string {
+func GetDatabaseGroups(db *gorm.DB, inputGroups []string) []databasemodels.Group {
+	var outputGroups []databasemodels.Group
+	for _, inputGroup := range inputGroups {
+		outputGroups = append(outputGroups, GetDatabaseGroup(db, inputGroup))
+	}
+	return outputGroups
+}
+
+func GetAllDatabaseGroups(db *gorm.DB) []databasemodels.Group {
 	var outputGroups []databasemodels.Group
-	var outputGroupsList []string
 	result := db.Find(&outputGroups)
 	if result.Error != nil {
-		return outputGroupsList
+		log.Println(result.Error)
-	} else {
-		for _, group := range outputGroups {
-			outputGroupsList = append(outputGroupsList, group.Name)
 	}
-		return outputGroupsList
+	for index, outputGroup := range outputGroups {
+		outputGroups[index] = GetDatabaseGroup(db, outputGroup.Name)
 	}
+	return outputGroups
 }
 
 func GetDatabaseCharacter(db *gorm.DB, inputCharacter string) databasemodels.Character {
@@ -237,17 +255,29 @@ func GetDatabaseCharacter(db *gorm.DB, inputCharacter string) databasemodels.Cha
 	if result.Error != nil {
 		return databasemodels.Character{}
 	}
+	db.Model(&outputCharacter).Association("Owners").Find(&outputCharacter.Owners)
+	db.Model(&outputCharacter).Association("Roles").Find(&outputCharacter.Roles)
+	db.Model(&outputCharacter).Association("FunctionSets").Find(&outputCharacter.FunctionSets)
+	db.Model(&outputCharacter).Association("Inventory").Find(&outputCharacter.Inventory)
 	return outputCharacter
 }
 
-func GetDatabaseCharacters(db *gorm.DB) []databasemodels.Character {
+func GetDatabaseCharacters(db *gorm.DB, inputCharacters []string) []databasemodels.Character {
 	var outputCharacters []databasemodels.Character
-	db.Find(&outputCharacters)
+	for _, inputCharacter := range inputCharacters {
+		outputCharacters = append(outputCharacters, GetDatabaseCharacter(db, inputCharacter))
+	}
+	return outputCharacters
+}
+
+func GetAllDatabaseCharacters(db *gorm.DB) []databasemodels.Character {
+	var outputCharacters []databasemodels.Character
+	result := db.Find(&outputCharacters)
+	if result.Error != nil {
+		log.Println(result.Error)
+	}
 	for index, outputCharacter := range outputCharacters {
-		db.Model(&outputCharacter).Association("Owners").Find(&outputCharacters[index].Owners)
+		outputCharacters[index] = GetDatabaseCharacter(db, outputCharacter.Name)
-		db.Model(&outputCharacter).Association("Roles").Find(&outputCharacters[index].Roles)
-		db.Model(&outputCharacter).Association("FunctionSets").Find(&outputCharacters[index].FunctionSets)
-		db.Model(&outputCharacter).Association("Inventory").Find(&outputCharacters[index].Inventory)
 	}
 	return outputCharacters
 }
@@ -258,15 +288,28 @@ func GetDatabaseRole(db *gorm.DB, inputRole string) databasemodels.Role {
 	if result.Error != nil {
 		return databasemodels.Role{}
 	}
+	db.Model(&outputRole).Association("Tiers").Find(&outputRole.Tiers)
+	db.Model(&outputRole).Association("Visibility").Find(&outputRole.Visibility)
 	return outputRole
 }
 
 func GetDatabaseRoles(db *gorm.DB) []databasemodels.Role {
 	var outputRoles []databasemodels.Role
 	db.Find(&outputRoles)
+	for _, outputRole := range outputRoles {
+		outputRoles = append(outputRoles, GetDatabaseRole(db, outputRole.Name))
+	}
+	return outputRoles
+}
+
+func GetAllDatabaseRoles(db *gorm.DB) []databasemodels.Role {
+	var outputRoles []databasemodels.Role
+	result := db.Find(&outputRoles)
+	if result.Error != nil {
+		log.Println(result.Error)
+	}
 	for index, outputRole := range outputRoles {
-		db.Model(&outputRole).Association("Tiers").Find(&outputRoles[index].Tiers)
+		outputRoles[index] = GetDatabaseRole(db, outputRole.Name)
-		db.Model(&outputRole).Association("Visibility").Find(&outputRoles[index].Visibility)
 	}
 	return outputRoles
 }
@@ -277,33 +320,88 @@ func GetDatabaseTier(db *gorm.DB, inputTier int) databasemodels.Tier {
 	if result.Error != nil {
 		return databasemodels.Tier{}
 	}
+	db.Model(&outputTier).Association("FunctionSets").Find(&outputTier.FunctionSets)
 	return outputTier
 }
 
-func GetDatabaseTiers(db *gorm.DB) []databasemodels.Tier {
+func GetDatabaseTiers(db *gorm.DB, inputTiers []int) []databasemodels.Tier {
 	var outputTiers []databasemodels.Tier
-	db.Find(&outputTiers)
+	for _, inputTier := range inputTiers {
-	for index, outputTier := range outputTiers {
+		outputTiers = append(outputTiers, GetDatabaseTier(db, inputTier))
-		db.Model(&outputTier).Association("FunctionSets").Find(&outputTiers[index].FunctionSets)
 	}
 	return outputTiers
 }
 
+func GetAllDatabaseTiers(db *gorm.DB) []databasemodels.Tier {
+	var outputTiers []databasemodels.Tier
+	result := db.Find(&outputTiers)
+	if result.Error != nil {
+		log.Println(result.Error)
+	}
+	for index, outputTier := range outputTiers {
+		outputTiers[index] = GetDatabaseTier(db, int(outputTier.ID))
+	}
+	return outputTiers
+}
+
+func GetDatabaseFunctionSet(db *gorm.DB, inputFunctionSet int) databasemodels.FunctionSet {
+	var outputFunctionSet databasemodels.FunctionSet
+	result := db.Model(&databasemodels.FunctionSet{}).Where("id = ?", inputFunctionSet).Take(&outputFunctionSet)
+	if result.Error != nil {
+		return databasemodels.FunctionSet{}
+	}
+	db.Model(&outputFunctionSet).Association("Functions").Find(&outputFunctionSet.Functions)
+	return outputFunctionSet
+}
+
+func GetDatabaseFunctionSets(db *gorm.DB, inputFunctionSets []int) []databasemodels.FunctionSet {
+	var outputFunctionSets []databasemodels.FunctionSet
+	db.Find(&outputFunctionSets)
+	for _, inputFunctionSet := range inputFunctionSets {
+		outputFunctionSets = append(outputFunctionSets, GetDatabaseFunctionSet(db, inputFunctionSet))
+	}
+	return outputFunctionSets
+}
+
+func GetAllDatabaseFunctionSets(db *gorm.DB) []databasemodels.FunctionSet {
+	var outputFunctionSets []databasemodels.FunctionSet
+	result := db.Find(&outputFunctionSets)
+	if result.Error != nil {
+		log.Println(result.Error)
+	}
+	for index, outputFunctionSet := range outputFunctionSets {
+		outputFunctionSets[index] = GetDatabaseFunctionSet(db, int(outputFunctionSet.ID))
+	}
+	return outputFunctionSets
+}
+
 func GetDatabaseFunction(db *gorm.DB, inputFunction string) databasemodels.Function {
 	var outputFunction databasemodels.Function
 	result := db.Model(&databasemodels.Function{}).Where("name = ?", inputFunction).Take(&outputFunction)
 	if result.Error != nil {
 		return databasemodels.Function{}
 	}
+	db.Model(&outputFunction).Association("Tags").Find(&outputFunction.Tags)
+	db.Model(&outputFunction).Association("Requirements").Find(&outputFunction.Requirements)
 	return outputFunction
 }
 
-func GetDatabaseFunctions(db *gorm.DB) []databasemodels.Function {
+func GetDatabaseFunctions(db *gorm.DB, inputFunctions []string) []databasemodels.Function {
 	var outputFunctions []databasemodels.Function
-	db.Find(&outputFunctions)
+	for _, inputFunction := range inputFunctions {
+		outputFunctions = append(outputFunctions, GetDatabaseFunction(db, inputFunction))
+	}
+	return outputFunctions
+}
+
+func GetAllDatabaseFunctions(db *gorm.DB) []databasemodels.Function {
+	var outputFunctions []databasemodels.Function
+	result := db.Find(&outputFunctions)
+	if result.Error != nil {
+		log.Println(result.Error)
+	}
 	for index, outputFunction := range outputFunctions {
-		db.Model(&outputFunction).Association("Tags").Find(&outputFunctions[index].Tags)
+		outputFunctions[index] = GetDatabaseFunction(db, outputFunction.Name)
-		db.Model(&outputFunction).Association("Requirements").Find(&outputFunctions[index].Requirements)
 	}
 	return outputFunctions
 }
@@ -317,18 +415,182 @@ func GetDatabaseFunctionTag(db *gorm.DB, inputFunctionTag string) databasemodels
 	return outputFunctionTag
 }
 
-func GetDatabaseFunctionTags(db *gorm.DB) []string {
+func GetDatabaseFunctionTags(db *gorm.DB, inputFunctionTags []string) []databasemodels.FunctionTag {
+	var outputFunctionTags []databasemodels.FunctionTag
+	for _, inputFunctionTag := range inputFunctionTags {
+		outputFunctionTags = append(outputFunctionTags, GetDatabaseFunctionTag(db, inputFunctionTag))
+	}
+	return outputFunctionTags
+}
+
+func GetAllDatabaseFunctionTags(db *gorm.DB) []databasemodels.FunctionTag {
 	var outputFunctionTags []databasemodels.FunctionTag
-	var outputFunctionTagsList []string
 	result := db.Find(&outputFunctionTags)
 	if result.Error != nil {
-		return outputFunctionTagsList
+		log.Println(result.Error)
-	} else {
-		for _, functionTag := range outputFunctionTags {
-			outputFunctionTagsList = append(outputFunctionTagsList, functionTag.Name)
 	}
-		return outputFunctionTagsList
+	for index, outputFunctionTag := range outputFunctionTags {
+		outputFunctionTags[index] = GetDatabaseFunctionTag(db, outputFunctionTag.Name)
 	}
+	return outputFunctionTags
+}
+
+func GetDatabaseInventorySlot(db *gorm.DB, inputInventorySlot int) databasemodels.InventorySlot {
+	var outputInventorySlot databasemodels.InventorySlot
+	result := db.Model(&databasemodels.InventorySlot{}).Where("id = ?", inputInventorySlot).Take(&outputInventorySlot)
+	if result.Error != nil {
+		return databasemodels.InventorySlot{}
+	}
+	db.Model(&outputInventorySlot).Association("Item").Find(&outputInventorySlot.Item)
+	return outputInventorySlot
+}
+
+func GetDatabaseInventorySlots(db *gorm.DB, inputInventorySlots []int) []databasemodels.InventorySlot {
+	var outputInventorySlots []databasemodels.InventorySlot
+	for _, inputInventorySlot := range inputInventorySlots {
+		outputInventorySlots = append(outputInventorySlots, GetDatabaseInventorySlot(db, inputInventorySlot))
+	}
+	return outputInventorySlots
+}
+
+func GetAllDatabaseInventorySlots(db *gorm.DB) []databasemodels.InventorySlot {
+	var outputInventorySlots []databasemodels.InventorySlot
+	result := db.Find(&outputInventorySlots)
+	if result.Error != nil {
+		log.Println(result.Error)
+	}
+	for index, outputInventorySlot := range outputInventorySlots {
+		outputInventorySlots[index] = GetDatabaseInventorySlot(db, int(outputInventorySlot.ID))
+	}
+	return outputInventorySlots
+}
+
+func GetDatabaseItem(db *gorm.DB, inputItem string) databasemodels.Item {
+	var outputItem databasemodels.Item
+	result := db.Model(&databasemodels.Item{}).Where("name = ?", inputItem).Take(&outputItem)
+	if result.Error != nil {
+		return databasemodels.Item{}
+	}
+	db.Model(&outputItem).Association("Functions").Find(&outputItem.Functions)
+	db.Model(&outputItem).Association("Tags").Find(&outputItem.Tags)
+	db.Model(&outputItem).Association("Customizations").Find(&outputItem.Customizations)
+	db.Model(&outputItem).Association("Visibility").Find(&outputItem.Visibility)
+	return outputItem
+}
+
+func GetDatabaseItems(db *gorm.DB, inputItems []string) []databasemodels.Item {
+	var outputItems []databasemodels.Item
+	for _, inputItem := range inputItems {
+		outputItems = append(outputItems, GetDatabaseItem(db, inputItem))
+	}
+	return outputItems
+}
+
+func GetAllDatabaseItems(db *gorm.DB) []databasemodels.Item {
+	var outputItems []databasemodels.Item
+	result := db.Find(&outputItems)
+	if result.Error != nil {
+		log.Println(result.Error)
+	}
+	for index, outputItem := range outputItems {
+		outputItems[index] = GetDatabaseItem(db, outputItem.Name)
+	}
+	return outputItems
+}
+
+func GetDatabaseItemTag(db *gorm.DB, inputItemTag string) databasemodels.ItemTag {
+	var outputItemTag databasemodels.ItemTag
+	result := db.Model(&databasemodels.ItemTag{}).Where("name = ?", outputItemTag).Take(&outputItemTag)
+	if result.Error != nil {
+		return databasemodels.ItemTag{}
+	}
+	return outputItemTag
+}
+
+func GetDatabaseItemTags(db *gorm.DB, inputItemTags []string) []databasemodels.ItemTag {
+	var outputItemTags []databasemodels.ItemTag
+	for _, inputItemTag := range inputItemTags {
+		outputItemTags = append(outputItemTags, GetDatabaseItemTag(db, inputItemTag))
+	}
+	return outputItemTags
+}
+
+func GetAllDatabaseItemTags(db *gorm.DB) []databasemodels.ItemTag {
+	var outputItemTags []databasemodels.ItemTag
+	result := db.Find(&outputItemTags)
+	if result.Error != nil {
+		log.Println(result.Error)
+	}
+	for index, outputItemTag := range outputItemTags {
+		outputItemTags[index] = GetDatabaseItemTag(db, outputItemTag.Name)
+	}
+	return outputItemTags
+}
+
+func GetDatabaseCustomization(db *gorm.DB, inputCustomization string) databasemodels.Customization {
+	var outputCustomization databasemodels.Customization
+	result := db.Model(&databasemodels.Customization{}).Where("name = ?", inputCustomization).Take(&outputCustomization)
+	if result.Error != nil {
+		return databasemodels.Customization{}
+	}
+	db.Model(&outputCustomization).Association("Functions").Find(&outputCustomization.Functions)
+	db.Model(&outputCustomization).Association("Tags").Find(&outputCustomization.Tags)
+	db.Model(&outputCustomization).Association("Visibility").Find(&outputCustomization.Visibility)
+	return outputCustomization
+}
+
+func GetDatabaseCustomizations(db *gorm.DB, inputCustomizations []string) []databasemodels.Customization {
+	var outputCustomizations []databasemodels.Customization
+	for _, inputCustomization := range inputCustomizations {
+		outputCustomizations = append(outputCustomizations, GetDatabaseCustomization(db, inputCustomization))
+	}
+	return outputCustomizations
+}
+
+func GetAllDatabaseCustomizations(db *gorm.DB) []databasemodels.Customization {
+	var outputCustomizations []databasemodels.Customization
+	result := db.Find(&outputCustomizations)
+	if result.Error != nil {
+		log.Println(result.Error)
+	}
+	for index, outputCustomization := range outputCustomizations {
+		outputCustomizations[index] = GetDatabaseCustomization(db, outputCustomization.Name)
+	}
+	return outputCustomizations
+}
+
+func GetDatabaseSchematic(db *gorm.DB, inputSchematic int) databasemodels.Schematic {
+	var outputSchematic databasemodels.Schematic
+	result := db.Model(&databasemodels.Schematic{}).Where("id = ?", inputSchematic).Take(&outputSchematic)
+	if result.Error != nil {
+		return databasemodels.Schematic{}
+	}
+	db.Model(&outputSchematic).Association("Material").Find(&outputSchematic.Material)
+	db.Model(&outputSchematic).Association("Tools").Find(&outputSchematic.Tools)
+	db.Model(&outputSchematic).Association("Requirements").Find(&outputSchematic.Requirements)
+	db.Model(&outputSchematic).Association("Result").Find(&outputSchematic.Result)
+	db.Model(&outputSchematic).Association("Visibility").Find(&outputSchematic.Visibility)
+	return outputSchematic
+}
+
+func GetDatabaseSchematics(db *gorm.DB, inputSchematics []int) []databasemodels.Schematic {
+	var outputSchematics []databasemodels.Schematic
+	for _, inputSchematic := range inputSchematics {
+		outputSchematics = append(outputSchematics, GetDatabaseSchematic(db, inputSchematic))
+	}
+	return outputSchematics
+}
+
+func GetAllDatabaseSchematics(db *gorm.DB) []databasemodels.Schematic {
+	var outputSchematics []databasemodels.Schematic
+	result := db.Find(&outputSchematics)
+	if result.Error != nil {
+		log.Println(result.Error)
+	}
+	for index, outputSchematic := range outputSchematics {
+		outputSchematics[index] = GetDatabaseSchematic(db, int(outputSchematic.ID))
+	}
+	return outputSchematics
 }
 
 // Update Functions

src/lib/database/models/models.go

@@ -91,7 +91,7 @@ type ItemTag struct {
 
 type Customization struct {
 	gorm.Model
-	Name                string     `json:"name"`
+	Name                string     `gorm:"primaryKey uniqueIndex" json:"name"`
 	Functions           []Function `gorm:"many2many:customization_function_associations" json:"functions"`
 	FlavorText          string     `json:"flavor_text"`
 	RulesDescription    string     `json:"rules_description"`