From 739a2f74ebab2d37768d811b11e09f09d3f93a72 Mon Sep 17 00:00:00 2001 From: Ada Werefox Date: Sun, 27 Apr 2025 01:22:42 -0700 Subject: [PATCH] All database models have create and get functions. --- src/gin-cpularp.go | 3 + src/lib/api/api.go | 30 ++- src/lib/database/commands/commands.go | 332 +++++++++++++++++++++++--- src/lib/database/models/models.go | 2 +- 4 files changed, 328 insertions(+), 39 deletions(-) diff --git a/src/gin-cpularp.go b/src/gin-cpularp.go index 5322f03..e5bf1c3 100755 --- a/src/gin-cpularp.go +++ b/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") } diff --git a/src/lib/api/api.go b/src/lib/api/api.go index 69f3c6b..80424a9 100644 --- a/src/lib/api/api.go +++ b/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, }) diff --git a/src/lib/database/commands/commands.go b/src/lib/database/commands/commands.go index ae00f10..13962b4 100644 --- a/src/lib/database/commands/commands.go +++ b/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 - } else { - for _, group := range outputGroups { - outputGroupsList = append(outputGroupsList, group.Name) - } - return outputGroupsList + log.Println(result.Error) } + 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) - 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) + outputCharacters[index] = GetDatabaseCharacter(db, outputCharacter.Name) } 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) - db.Model(&outputRole).Association("Visibility").Find(&outputRoles[index].Visibility) + outputRoles[index] = GetDatabaseRole(db, outputRole.Name) } 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 index, outputTier := range outputTiers { - db.Model(&outputTier).Association("FunctionSets").Find(&outputTiers[index].FunctionSets) + for _, inputTier := range inputTiers { + outputTiers = append(outputTiers, GetDatabaseTier(db, inputTier)) } 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) - db.Model(&outputFunction).Association("Requirements").Find(&outputFunctions[index].Requirements) + outputFunctions[index] = GetDatabaseFunction(db, outputFunction.Name) } 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 - } else { - for _, functionTag := range outputFunctionTags { - outputFunctionTagsList = append(outputFunctionTagsList, functionTag.Name) - } - return outputFunctionTagsList + log.Println(result.Error) } + 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 diff --git a/src/lib/database/models/models.go b/src/lib/database/models/models.go index fc1a255..e130f0a 100644 --- a/src/lib/database/models/models.go +++ b/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"`