diff --git a/src/gin-cpularp.go b/src/gin-cpularp.go index cf2b134..471f562 100755 --- a/src/gin-cpularp.go +++ b/src/gin-cpularp.go @@ -12,25 +12,24 @@ func main() { api.GlobalDatabase = database.InitializeDatabase() api.GlobalConfig.ParseConfig("../config.toml") api.GlobalOAuth = authdiscord.CreateDiscordOAuthConfig(api.GlobalConfig) - app := gin.Default() + router := gin.Default() // Authentication Workflow - app.GET("/auth/callback", api.AuthCallback) - app.GET("/auth/login", api.AuthLoginRedirect) - app.GET("/auth/logout", api.AuthLogoutRedirect) - // Create & Update - app.POST("/post/user/update", api.CreateOrUpdateUser) - app.POST("/post/group", api.CreateGroup) - app.POST("/post/function", api.CreateFunction) - app.POST("/post/function-tag", api.CreateFunctionTag) + router.GET("/auth/callback", api.AuthCallback) + router.GET("/auth/login", api.AuthLoginRedirect) + router.GET("/auth/logout", api.AuthLogoutRedirect) + // Create + router.POST("/user/update", api.CreateOrUpdateUser) + router.POST("/group", api.CreateGroup) + router.POST("/function", api.CreateFunction) + router.POST("/function-tag", api.CreateFunctionTag) + // Update + router.PUT("/function", api.UpdateFunction) // Read - app.GET("/get/user/info", api.GetDiscordUser) - app.GET("/get/user/authorized", api.GetUserLoggedIn) - app.GET("/get/groups", api.GetGroups) - app.GET("/get/all/groups", api.GetAllGroups) - app.GET("/get/functions", api.GetFunctions) - app.GET("/get/all/functions", api.GetAllFunctions) - app.GET("/get/function-tags", api.GetFunctionTags) - app.GET("/get/all/function-tags", api.GetAllFunctionTags) + router.GET("/user/info", api.GetDiscordUser) + router.GET("/user/authorized", api.GetUserLoggedIn) + router.GET("/:object", api.GetObjects) + router.GET("/all/:object", api.GetAllObjects) // Delete - app.Run(":31337") + router.DELETE("/function", api.DeleteFunction) + router.Run(":31337") } diff --git a/src/lib/api/api.go b/src/lib/api/api.go index 75ae50d..a05bb1d 100644 --- a/src/lib/api/api.go +++ b/src/lib/api/api.go @@ -5,12 +5,23 @@ import ( "fmt" "log" "net/http" + "strconv" authdiscord "example.com/auth/discord" configserver "example.com/config/server" + character "example.com/database/character" + customization "example.com/database/customization" function "example.com/database/function" + functionset "example.com/database/functionset" functiontag "example.com/database/functiontag" group "example.com/database/group" + inventoryslot "example.com/database/inventoryslot" + item "example.com/database/item" + itemtag "example.com/database/itemtag" + person "example.com/database/person" + role "example.com/database/role" + schematic "example.com/database/schematic" + tier "example.com/database/tier" user "example.com/database/user" "github.com/gin-gonic/gin" @@ -25,6 +36,19 @@ var GlobalOAuth *oauth2.Config // Private Functions +func objectIDStringsToInts(context *gin.Context, objectIDs []string) *[]int { + var objectIDInts []int + for _, objectID := range objectIDs { + objectIDInt, err := strconv.Atoi(objectID) + if err != nil { + objectIDInts = append(objectIDInts, objectIDInt) + } else { + context.AbortWithStatus(http.StatusBadRequest) + } + } + return &objectIDInts +} + // Authentication Workflow func AuthCallback(context *gin.Context) { @@ -161,6 +185,24 @@ func CreateFunctionTag(context *gin.Context) { // Update Endpoints (put/) +func UpdateFunction(context *gin.Context) { + GetUserLoggedIn(context) + isAuthorized := context.GetBool("is-authorized") + if isAuthorized { + name, nameOk := context.GetQuery("name") + tags := context.QueryArray("tags") + requirements := context.QueryArray("requirements") + if nameOk { + function.Update(GlobalDatabase, name, tags, requirements) + context.Status(http.StatusOK) + } else { + context.AbortWithStatus(http.StatusBadRequest) + } + } else { + context.AbortWithStatus(http.StatusUnauthorized) + } +} + // Read Endpoints (get/) func GetDiscordUser(context *gin.Context) { @@ -216,55 +258,143 @@ func GetUserLoggedIn(context *gin.Context) { context.Set("is-authorized", false) } -func GetGroups(context *gin.Context) { - groupNames, ok := context.GetQueryArray("groups") - if ok { - context.JSON(http.StatusOK, gin.H{ - "groups": group.Get(GlobalDatabase, groupNames), - }) +func GetObjects(context *gin.Context) { + objectIDs, idOk := context.GetQueryArray("id") + if idOk { + switch objectType := context.Param("object"); objectType { + case "persons": + context.JSON(http.StatusOK, gin.H{ + "persons": person.Get(GlobalDatabase, objectIDs), + }) + case "groups": + context.JSON(http.StatusOK, gin.H{ + "groups": group.Get(GlobalDatabase, objectIDs), + }) + case "characters": + context.JSON(http.StatusOK, gin.H{ + "characters": character.Get(GlobalDatabase, objectIDs), + }) + case "roles": + context.JSON(http.StatusOK, gin.H{ + "roles": role.Get(GlobalDatabase, objectIDs), + }) + case "tiers": + objectIDInts := objectIDStringsToInts(context, objectIDs) + context.JSON(http.StatusOK, gin.H{ + "tiers": tier.Get(GlobalDatabase, *objectIDInts), + }) + case "function-sets": + objectIDInts := objectIDStringsToInts(context, objectIDs) + context.JSON(http.StatusOK, gin.H{ + "function_sets": functionset.Get(GlobalDatabase, *objectIDInts), + }) + case "functions": + context.JSON(http.StatusOK, gin.H{ + "functions": function.Get(GlobalDatabase, objectIDs), + }) + case "function-tags": + context.JSON(http.StatusOK, gin.H{ + "function_tags": functiontag.Get(GlobalDatabase, objectIDs), + }) + case "inventory-slot": + objectIDInts := objectIDStringsToInts(context, objectIDs) + context.JSON(http.StatusOK, gin.H{ + "inventory_slot": inventoryslot.Get(GlobalDatabase, *objectIDInts), + }) + case "items": + context.JSON(http.StatusOK, gin.H{ + "items": item.Get(GlobalDatabase, objectIDs), + }) + case "item-tags": + context.JSON(http.StatusOK, gin.H{ + "item_tags": itemtag.Get(GlobalDatabase, objectIDs), + }) + case "customizations": + context.JSON(http.StatusOK, gin.H{ + "customizations": customization.Get(GlobalDatabase, objectIDs), + }) + case "schematics": + objectIDInts := objectIDStringsToInts(context, objectIDs) + context.JSON(http.StatusOK, gin.H{ + "schematics": schematic.Get(GlobalDatabase, *objectIDInts), + }) + } } else { context.Status(http.StatusBadRequest) } } -func GetAllGroups(context *gin.Context) { - context.JSON(http.StatusOK, gin.H{ - "groups": group.GetAll(GlobalDatabase), - }) -} - -func GetFunctions(context *gin.Context) { - functionNames, ok := context.GetQueryArray("functions") - if ok { +func GetAllObjects(context *gin.Context) { + switch objectType := context.Param("object"); objectType { + case "persons": context.JSON(http.StatusOK, gin.H{ - "functions": function.Get(GlobalDatabase, functionNames), + "persons": person.GetAll(GlobalDatabase), }) - } else { - context.Status(http.StatusBadRequest) - } -} - -func GetAllFunctions(context *gin.Context) { - context.JSON(http.StatusOK, gin.H{ - "functions": function.GetAll(GlobalDatabase), - }) -} - -func GetFunctionTags(context *gin.Context) { - functionTagNames, ok := context.GetQueryArray("functiontags") - if ok { + case "groups": context.JSON(http.StatusOK, gin.H{ - "function_tags": functiontag.Get(GlobalDatabase, functionTagNames), + "groups": group.GetAll(GlobalDatabase), + }) + case "characters": + context.JSON(http.StatusOK, gin.H{ + "characters": character.GetAll(GlobalDatabase), + }) + case "roles": + context.JSON(http.StatusOK, gin.H{ + "roles": role.GetAll(GlobalDatabase), + }) + case "tiers": + context.JSON(http.StatusOK, gin.H{ + "tiers": tier.GetAll(GlobalDatabase), + }) + case "function-sets": + context.JSON(http.StatusOK, gin.H{ + "function_sets": functionset.GetAll(GlobalDatabase), + }) + case "functions": + context.JSON(http.StatusOK, gin.H{ + "functions": function.GetAll(GlobalDatabase), + }) + case "function-tags": + context.JSON(http.StatusOK, gin.H{ + "function_tags": functiontag.GetAll(GlobalDatabase), + }) + case "inventory-slot": + context.JSON(http.StatusOK, gin.H{ + "inventory_slot": inventoryslot.GetAll(GlobalDatabase), + }) + case "items": + context.JSON(http.StatusOK, gin.H{ + "items": item.GetAll(GlobalDatabase), + }) + case "item-tags": + context.JSON(http.StatusOK, gin.H{ + "item_tags": itemtag.GetAll(GlobalDatabase), + }) + case "customizations": + context.JSON(http.StatusOK, gin.H{ + "customizations": customization.GetAll(GlobalDatabase), + }) + case "schematics": + context.JSON(http.StatusOK, gin.H{ + "schematics": schematic.GetAll(GlobalDatabase), }) - } else { - context.Status(http.StatusBadRequest) } } -func GetAllFunctionTags(context *gin.Context) { - context.JSON(http.StatusOK, gin.H{ - "function_tags": functiontag.GetAll(GlobalDatabase), - }) -} - // Delete Endpoints (delete/) + +func DeleteFunction(context *gin.Context) { + GetUserLoggedIn(context) + isAuthorized := context.GetBool("is-authorized") + if isAuthorized { + functionNames, ok := context.GetQueryArray("name") + if ok { + function.Delete(GlobalDatabase, functionNames) + context.Status(http.StatusOK) + } else { + context.AbortWithStatus(http.StatusBadRequest) + } + } else { + context.AbortWithStatus(http.StatusUnauthorized) + } +} diff --git a/src/lib/api/go.mod b/src/lib/api/go.mod index 54f6f03..4a5e1f3 100644 --- a/src/lib/api/go.mod +++ b/src/lib/api/go.mod @@ -37,6 +37,16 @@ replace example.com/config/server => ../config/server go 1.24.2 require ( + example.com/database/character v0.0.0 + example.com/database/customization v0.0.0 + example.com/database/functionset v0.0.0 + example.com/database/inventoryslot v0.0.0 + example.com/database/item v0.0.0 + example.com/database/itemtag v0.0.0 + example.com/database/person v0.0.0 + example.com/database/role v0.0.0 + example.com/database/schematic v0.0.0 + example.com/database/tier v0.0.0 example.com/auth/discord v0.0.0 example.com/config/server v0.0.0 example.com/database/function v0.0.0 diff --git a/src/lib/database/character/character.go b/src/lib/database/character/character.go index e40dacf..02d08d0 100644 --- a/src/lib/database/character/character.go +++ b/src/lib/database/character/character.go @@ -20,7 +20,7 @@ type Character struct { Inventory []inventoryslot.InventorySlot `gorm:"many2many:character_inventory_associations" json:"inventory"` } -func CreateDatabaseCharacter(db *gorm.DB, character Character) error { +func (character Character) Create(db *gorm.DB) error { result := db.Create(&character) if result.Error != nil { return result.Error @@ -28,43 +28,90 @@ func CreateDatabaseCharacter(db *gorm.DB, character Character) error { return nil } -func GetDatabaseCharacter(db *gorm.DB, inputCharacter string) Character { - var outputCharacter Character - result := db.Model(&Character{}).Where("name = ?", inputCharacter).Take(&outputCharacter) - if result.Error != nil { - return 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 (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 GetDatabaseCharacters(db *gorm.DB, inputCharacters []string) []Character { - var outputCharacters []Character - for _, inputCharacter := range inputCharacters { - outputCharacters = append(outputCharacters, GetDatabaseCharacter(db, inputCharacter)) - } - return outputCharacters +func (character *Character) Get(db *gorm.DB, inputCharacter string) { + db.Where("name = ?", inputCharacter).Take(&character) + character.getAssociations(db) } -func GetAllDatabaseCharacters(db *gorm.DB) []Character { - var outputCharacters []Character - result := db.Find(&outputCharacters) - if result.Error != nil { - log.Println(result.Error) +func (character Character) Update(db *gorm.DB) error { + var originalCharacter Character + originalCharacter.Get(db, character.Name) + ownersError := db.Model(&originalCharacter).Association("Owners").Replace(&character.Owners) + if ownersError != nil { + return ownersError } - for index, outputCharacter := range outputCharacters { - outputCharacters[index] = GetDatabaseCharacter(db, outputCharacter.Name) + rolesError := db.Model(&originalCharacter).Association("Roles").Replace(&character.Roles) + if rolesError != nil { + return rolesError } - return outputCharacters + functionSetsError := db.Model(&originalCharacter).Association("FunctionSets").Replace(&character.FunctionSets) + if functionSetsError != nil { + return functionSetsError + } + inventoryError := db.Model(&originalCharacter).Association("Inventory").Replace(&character.Inventory) + if inventoryError != nil { + return inventoryError + } + return nil } -func UpdateDatabaseCharacter(db *gorm.DB, character Character) error { - result := db.Save(&character) +func (character Character) Delete(db *gorm.DB) error { + result := db.Delete(&character) if result.Error != nil { return result.Error } return nil } + +func Create(db *gorm.DB, name string, owners []string, roles []string, functionsets []int, inventory []int) error { + return Character{ + Name: name, + Owners: *person.Get(db, owners), + Roles: *role.Get(db, roles), + FunctionSets: *functionset.Get(db, functionsets), + Inventory: *inventoryslot.Get(db, inventory), + }.Create(db) +} + +func Get(db *gorm.DB, inputCharacters []string) *[]Character { + var outputCharacters []Character + for _, inputCharacter := range inputCharacters { + var outputCharacter Character + outputCharacter.Get(db, inputCharacter) + outputCharacters = append(outputCharacters, outputCharacter) + } + return &outputCharacters +} + +func GetAll(db *gorm.DB) *[]Character { + var outputCharacterNames []string + result := db.Model(&Character{}).Select("name").Find(&outputCharacterNames) + if result.Error != nil { + log.Println(result.Error) + } + return Get(db, outputCharacterNames) +} + +func Update(db *gorm.DB, name string, owners []string, roles []string, functionsets []int, inventory []int) error { + return Character{ + Name: name, + Owners: *person.Get(db, owners), + Roles: *role.Get(db, roles), + FunctionSets: *functionset.Get(db, functionsets), + Inventory: *inventoryslot.Get(db, inventory), + }.Update(db) +} + +func Delete(db *gorm.DB, inputCharacters []string) { + characters := Get(db, inputCharacters) + for _, character := range *characters { + character.Delete(db) + } +} diff --git a/src/lib/database/customization/customization.go b/src/lib/database/customization/customization.go index be7a791..09aa740 100644 --- a/src/lib/database/customization/customization.go +++ b/src/lib/database/customization/customization.go @@ -21,7 +21,7 @@ type Customization struct { Visibility []group.Group `gorm:"many2many:customization_visibility_associations" json:"visibility"` // Unique } -func CreateDatabaseCustomization(db *gorm.DB, customization Customization) error { +func (customization Customization) Create(db *gorm.DB) error { result := db.Create(&customization) if result.Error != nil { return result.Error @@ -29,42 +29,93 @@ func CreateDatabaseCustomization(db *gorm.DB, customization Customization) error return nil } -func GetDatabaseCustomization(db *gorm.DB, inputCustomization string) Customization { - var outputCustomization Customization - result := db.Model(&Customization{}).Where("name = ?", inputCustomization).Take(&outputCustomization) - if result.Error != nil { - return 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 (customization *Customization) getAssociations(db *gorm.DB) { + db.Model(&customization).Association("Functions").Find(&customization.Functions) + db.Model(&customization).Association("Tags").Find(&customization.Tags) + db.Model(&customization).Association("Visibility").Find(&customization.Visibility) } -func GetDatabaseCustomizations(db *gorm.DB, inputCustomizations []string) []Customization { - var outputCustomizations []Customization - for _, inputCustomization := range inputCustomizations { - outputCustomizations = append(outputCustomizations, GetDatabaseCustomization(db, inputCustomization)) - } - return outputCustomizations +func (customization *Customization) Get(db *gorm.DB, inputCustomization string) { + db.Where("name = ?", inputCustomization).Take(&customization) + customization.getAssociations(db) } -func GetAllDatabaseCustomizations(db *gorm.DB) []Customization { - var outputCustomizations []Customization - result := db.Find(&outputCustomizations) - if result.Error != nil { - log.Println(result.Error) +func (customization Customization) Update(db *gorm.DB) error { + var originalCustomization Customization + db.Updates(&Customization{ + FlavorText: customization.FlavorText, + RulesDescription: customization.RulesDescription, + PhysrepRequirements: customization.PhysrepRequirements, + }) + functionsError := db.Model(&originalCustomization).Association("Functions").Replace(&customization.Functions) + if functionsError != nil { + return functionsError } - for index, outputCustomization := range outputCustomizations { - outputCustomizations[index] = GetDatabaseCustomization(db, outputCustomization.Name) + tagsError := db.Model(&originalCustomization).Association("Tags").Replace(&customization.Tags) + if tagsError != nil { + return tagsError } - return outputCustomizations + visibilityError := db.Model(&originalCustomization).Association("Visibility").Replace(&customization.Visibility) + if visibilityError != nil { + return visibilityError + } + return nil } -func UpdateDatabaseCustomization(db *gorm.DB, customization Customization) error { - result := db.Save(&customization) +func (customization Customization) Delete(db *gorm.DB) error { + result := db.Delete(&customization) if result.Error != nil { return result.Error } return nil } + +func Create(db *gorm.DB, name string, functions []string, flavorText string, rulesDescription string, physrepRequesrements string, itemTags []string, visibility []string) error { + return Customization{ + Name: name, + Functions: *function.Get(db, functions), + FlavorText: flavorText, + RulesDescription: rulesDescription, + PhysrepRequirements: physrepRequesrements, + Tags: *itemtag.Get(db, itemTags), + Visibility: *group.Get(db, visibility), + }.Create(db) +} + +func Get(db *gorm.DB, inputCustomizations []string) *[]Customization { + var outputCustomizations []Customization + for _, inputCustomization := range inputCustomizations { + var outputCustomization Customization + outputCustomization.Get(db, inputCustomization) + outputCustomizations = append(outputCustomizations, outputCustomization) + } + return &outputCustomizations +} + +func GetAll(db *gorm.DB) *[]Customization { + var outputCustomizationNames []string + result := db.Model(&Customization{}).Select("name").Find(&outputCustomizationNames) + if result.Error != nil { + log.Println(result.Error) + } + return Get(db, outputCustomizationNames) +} + +func Update(db *gorm.DB, name string, functions []string, flavorText string, rulesDescription string, physrepRequesrements string, itemTags []string, visibility []string) error { + return Customization{ + Name: name, + Functions: *function.Get(db, functions), + FlavorText: flavorText, + RulesDescription: rulesDescription, + PhysrepRequirements: physrepRequesrements, + Tags: *itemtag.Get(db, itemTags), + Visibility: *group.Get(db, visibility), + }.Update(db) +} + +func Delete(db *gorm.DB, inputCustomizations []string) { + customizations := Get(db, inputCustomizations) + for _, customization := range *customizations { + customization.Delete(db) + } +} diff --git a/src/lib/database/function/function.go b/src/lib/database/function/function.go index 9604e67..13b7f6b 100644 --- a/src/lib/database/function/function.go +++ b/src/lib/database/function/function.go @@ -34,7 +34,21 @@ func (function *Function) Get(db *gorm.DB, inputFunction string) { } func (function Function) Update(db *gorm.DB) error { - result := db.Save(&function) + var originalFunction Function + originalFunction.Get(db, function.Name) + tagsError := db.Model(&originalFunction).Association("Tags").Replace(&function.Tags) + if tagsError != nil { + return tagsError + } + requirementsError := db.Model(&originalFunction).Association("Requirements").Replace(&function.Requirements) + if requirementsError != nil { + return requirementsError + } + return nil +} + +func (function Function) Delete(db *gorm.DB) error { + result := db.Delete(&function) if result.Error != nil { return result.Error } @@ -69,9 +83,18 @@ func GetAll(db *gorm.DB) *[]Function { } func Update(db *gorm.DB, name string, tags []string, requirements []string) error { + log.Println(*functiontag.Get(db, tags)) + log.Println(*Get(db, requirements)) return Function{ Name: name, Tags: *functiontag.Get(db, tags), Requirements: *Get(db, requirements), }.Update(db) } + +func Delete(db *gorm.DB, inputFunctions []string) { + functions := Get(db, inputFunctions) + for _, function := range *functions { + function.Delete(db) + } +} diff --git a/src/lib/database/functionset/functionset.go b/src/lib/database/functionset/functionset.go index f78fef2..891749b 100644 --- a/src/lib/database/functionset/functionset.go +++ b/src/lib/database/functionset/functionset.go @@ -38,6 +38,14 @@ func (functionSet FunctionSet) Update(db *gorm.DB) error { return nil } +func (functionSet FunctionSet) Delete(db *gorm.DB) error { + result := db.Delete(&functionSet) + if result.Error != nil { + return result.Error + } + return nil +} + func Create(db *gorm.DB, functions []string) error { return FunctionSet{ Functions: *function.Get(db, functions), @@ -70,3 +78,10 @@ func Update(db *gorm.DB, id int, functions []string) error { outputFunctionSet.ID = uint(id) return outputFunctionSet.Update(db) } + +func Delete(db *gorm.DB, inputFunctionSets []int) { + functionSets := Get(db, inputFunctionSets) + for _, functionSet := range *functionSets { + functionSet.Delete(db) + } +} diff --git a/src/lib/database/inventoryslot/inventoryslot.go b/src/lib/database/inventoryslot/inventoryslot.go index 94874fd..00d4e6f 100644 --- a/src/lib/database/inventoryslot/inventoryslot.go +++ b/src/lib/database/inventoryslot/inventoryslot.go @@ -14,7 +14,7 @@ type InventorySlot struct { Quantity int64 `json:"quantity"` // Positive } -func CreateDatabaseInventorySlot(db *gorm.DB, inventorySlot InventorySlot) error { +func (inventorySlot InventorySlot) Create(db *gorm.DB) error { result := db.Create(&inventorySlot) if result.Error != nil { return result.Error @@ -22,40 +22,73 @@ func CreateDatabaseInventorySlot(db *gorm.DB, inventorySlot InventorySlot) error return nil } -func GetDatabaseInventorySlot(db *gorm.DB, inputInventorySlot int) InventorySlot { - var outputInventorySlot InventorySlot - result := db.Model(&InventorySlot{}).Where("id = ?", inputInventorySlot).Take(&outputInventorySlot) - if result.Error != nil { - return InventorySlot{} - } - db.Model(&outputInventorySlot).Association("Item").Find(&outputInventorySlot.Item) - return outputInventorySlot +func (inventorySlot *InventorySlot) getAssociations(db *gorm.DB) { + db.Model(&inventorySlot).Association("Item").Find(&inventorySlot.Item) + } -func GetDatabaseInventorySlots(db *gorm.DB, inputInventorySlots []int) []InventorySlot { - var outputInventorySlots []InventorySlot - for _, inputInventorySlot := range inputInventorySlots { - outputInventorySlots = append(outputInventorySlots, GetDatabaseInventorySlot(db, inputInventorySlot)) - } - return outputInventorySlots +func (inventorySlot *InventorySlot) Get(db *gorm.DB, inputInventorySlot int) { + db.Where("id = ?", inputInventorySlot).Take(&inventorySlot) + inventorySlot.getAssociations(db) } -func GetAllDatabaseInventorySlots(db *gorm.DB) []InventorySlot { - var outputInventorySlots []InventorySlot - result := db.Find(&outputInventorySlots) - if result.Error != nil { - log.Println(result.Error) +func (inventorySlot InventorySlot) Update(db *gorm.DB) error { + var originalIventorySlot InventorySlot + originalIventorySlot.Get(db, int(inventorySlot.ID)) + itemsError := db.Model(&originalIventorySlot).Association("Item").Replace(&inventorySlot.Item) + if itemsError != nil { + return itemsError } - for index, outputInventorySlot := range outputInventorySlots { - outputInventorySlots[index] = GetDatabaseInventorySlot(db, int(outputInventorySlot.ID)) - } - return outputInventorySlots + originalIventorySlot.Quantity = inventorySlot.Quantity + return nil } -func UpdateDatabaseInventorySlot(db *gorm.DB, inventoySlot InventorySlot) error { - result := db.Save(&inventoySlot) +func (inventorySlot InventorySlot) Delete(db *gorm.DB) error { + result := db.Delete(&inventorySlot) if result.Error != nil { return result.Error } return nil } + +func Create(db *gorm.DB, itemName string, quantity int64) error { + return InventorySlot{ + Item: (*item.Get(db, []string{itemName}))[0], + Quantity: quantity, + }.Create(db) +} + +func Get(db *gorm.DB, inputInventorySlots []int) *[]InventorySlot { + var outputInventorySlots []InventorySlot + for _, inputInventorySlot := range inputInventorySlots { + var outputInventorySlot InventorySlot + outputInventorySlot.Get(db, inputInventorySlot) + outputInventorySlots = append(outputInventorySlots, outputInventorySlot) + } + return &outputInventorySlots +} + +func GetAll(db *gorm.DB) *[]InventorySlot { + var outputInventorySlotIDs []int + result := db.Model(&InventorySlot{}).Select("id").Find(&outputInventorySlotIDs) + if result.Error != nil { + log.Println(result.Error) + } + return Get(db, outputInventorySlotIDs) +} + +func Update(db *gorm.DB, itemID int, itemName string, quantity int64) error { + inventorySlot := InventorySlot{ + Item: (*item.Get(db, []string{itemName}))[0], + Quantity: quantity, + } + inventorySlot.ID = uint(itemID) + return inventorySlot.Update(db) +} + +func Delete(db *gorm.DB, inputInventorySlotIDs []int) { + inventorySlots := Get(db, inputInventorySlotIDs) + for _, inventorySlot := range *inventorySlots { + inventorySlot.Delete(db) + } +} diff --git a/src/lib/database/item/item.go b/src/lib/database/item/item.go index 6a4635c..511a46d 100644 --- a/src/lib/database/item/item.go +++ b/src/lib/database/item/item.go @@ -23,7 +23,7 @@ type Item struct { Visibility []group.Group `gorm:"many2many:item_visibility_associations" json:"visibility"` // Unique } -func CreateDatabaseItem(db *gorm.DB, item Item) error { +func (item Item) Create(db *gorm.DB) error { result := db.Create(&item) if result.Error != nil { return result.Error @@ -31,43 +31,96 @@ func CreateDatabaseItem(db *gorm.DB, item Item) error { return nil } -func GetDatabaseItem(db *gorm.DB, inputItem string) Item { - var outputItem Item - result := db.Model(&Item{}).Where("name = ?", inputItem).Take(&outputItem) - if result.Error != nil { - return 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 (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 GetDatabaseItems(db *gorm.DB, inputItems []string) []Item { - var outputItems []Item - for _, inputItem := range inputItems { - outputItems = append(outputItems, GetDatabaseItem(db, inputItem)) - } - return outputItems +func (item Item) Get(db *gorm.DB, inputItem string) { + db.Where("name = ?", inputItem).Take(&item) + item.getAssociations(db) } -func GetAllDatabaseItems(db *gorm.DB) []Item { - var outputItems []Item - result := db.Find(&outputItems) - if result.Error != nil { - log.Println(result.Error) +func (item Item) Update(db *gorm.DB) error { + var originalItem Item + originalItem.Get(db, item.Name) + functionsError := db.Model(&originalItem).Association("Functions").Find(&originalItem.Functions) + if functionsError != nil { + return functionsError } - for index, outputItem := range outputItems { - outputItems[index] = GetDatabaseItem(db, outputItem.Name) + tagsError := db.Model(&originalItem).Association("Tags").Find(&originalItem.Tags) + if tagsError != nil { + return tagsError } - return outputItems + customizationsError := db.Model(&originalItem).Association("Customizations").Find(&originalItem.Customizations) + if customizationsError != nil { + return customizationsError + } + visibilityError := db.Model(&originalItem).Association("Visibility").Find(&originalItem.Visibility) + if visibilityError != nil { + return visibilityError + } + return nil } -func UpdateDatabaseItem(db *gorm.DB, item Item) error { - result := db.Save(&item) +func (item Item) Delete(db *gorm.DB) error { + result := db.Delete(&item) if result.Error != nil { return result.Error } return nil } + +func Create(db *gorm.DB, name string, functions []string, flavorText string, rulesDescription string, physrepRequirements string, tags []string, customizations []string, visibility []string) error { + return Item{ + Name: name, + Functions: *function.Get(db, functions), + FlavorText: flavorText, + RulesDescription: rulesDescription, + PhysrepRequirements: physrepRequirements, + Tags: *itemtag.Get(db, tags), + Customizations: *customization.Get(db, customizations), + Visibility: *group.Get(db, visibility), + }.Create(db) +} + +func Get(db *gorm.DB, inputItems []string) *[]Item { + var outputItems []Item + for _, inputItem := range inputItems { + var outputItem Item + outputItem.Get(db, inputItem) + outputItems = append(outputItems, outputItem) + } + return &outputItems +} + +func GetAll(db *gorm.DB) *[]Item { + var outputItemNames []string + result := db.Model(&Item{}).Select("name").Find(&outputItemNames) + if result.Error != nil { + log.Println(result.Error) + } + return Get(db, outputItemNames) +} + +func Update(db *gorm.DB, name string, functions []string, flavorText string, rulesDescription string, physrepRequirements string, tags []string, customizations []string, visibility []string) error { + return Item{ + Name: name, + Functions: *function.Get(db, functions), + FlavorText: flavorText, + RulesDescription: rulesDescription, + PhysrepRequirements: physrepRequirements, + Tags: *itemtag.Get(db, tags), + Customizations: *customization.Get(db, customizations), + Visibility: *group.Get(db, visibility), + }.Update(db) +} + +func Delete(db *gorm.DB, inputItem []string) { + items := Get(db, inputItem) + for _, item := range *items { + item.Delete(db) + } +} diff --git a/src/lib/database/itemtag/itemtag.go b/src/lib/database/itemtag/itemtag.go index b06dfbb..9cf6d23 100644 --- a/src/lib/database/itemtag/itemtag.go +++ b/src/lib/database/itemtag/itemtag.go @@ -31,6 +31,14 @@ func (itemTag ItemTag) Update(db *gorm.DB) error { return nil } +func (itemTag ItemTag) Delete(db *gorm.DB) 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, @@ -61,3 +69,10 @@ func Update(db *gorm.DB, name string) error { Name: name, }.Update(db) } + +func Delete(db *gorm.DB, inputItemTags []string) { + itemtags := Get(db, inputItemTags) + for _, itemtag := range *itemtags { + itemtag.Delete(db) + } +} diff --git a/src/lib/database/person/person.go b/src/lib/database/person/person.go index 628ab08..ef153a8 100644 --- a/src/lib/database/person/person.go +++ b/src/lib/database/person/person.go @@ -14,7 +14,7 @@ type Person struct { Groups []group.Group `gorm:"many2many:person_group_associations" json:"groups"` // Unique } -func CreateDatabasePerson(db *gorm.DB, person Person) error { +func (person Person) Create(db *gorm.DB) error { result := db.Create(&person) if result.Error != nil { return result.Error @@ -22,40 +22,69 @@ func CreateDatabasePerson(db *gorm.DB, person Person) error { return nil } -func GetDatabasePerson(db *gorm.DB, inputPerson string) Person { - var outputPerson Person - result := db.Model(&Person{}).Where("name = ?", inputPerson).Take(&outputPerson) - if result.Error != nil { - return Person{} - } - db.Model(&outputPerson).Association("Groups").Find(&outputPerson.Groups) - return outputPerson +func (person *Person) getAssociations(db *gorm.DB) { + db.Model(&person).Association("Groups").Find(&person.Groups) } -func GetDatabasePersons(db *gorm.DB, inputPersons []string) []Person { - var outputPersons []Person - for _, inputPerson := range inputPersons { - outputPersons = append(outputPersons, GetDatabasePerson(db, inputPerson)) - } - return outputPersons +func (person *Person) Get(db *gorm.DB, inputPerson string) { + db.Where("name = ?", inputPerson).Take(&person) + person.getAssociations(db) } -func GetAllDatabasePersons(db *gorm.DB) []Person { - var outputPersons []Person - result := db.Find(&outputPersons) - if result.Error != nil { - log.Println(result.Error) +func (person Person) Update(db *gorm.DB) error { + var originalPerson Person + originalPerson.Get(db, person.Name) + groupsError := db.Model(&originalPerson).Association("Groups").Replace(&person.Groups) + if groupsError != nil { + return groupsError } - for index, outputPerson := range outputPersons { - outputPersons[index] = GetDatabasePerson(db, outputPerson.Name) - } - return outputPersons + return nil } -func UpdateDatabasePerson(db *gorm.DB, person Person) error { - result := db.Save(&person) +func (person Person) Delete(db *gorm.DB) error { + result := db.Delete(&person) if result.Error != nil { return result.Error } return nil } + +func Create(db *gorm.DB, name string, groups []string) error { + return Person{ + Name: name, + Groups: *group.Get(db, groups), + }.Create(db) +} + +func Get(db *gorm.DB, inputPersons []string) *[]Person { + var outputPersons []Person + for _, inputPerson := range inputPersons { + var outputPerson Person + outputPerson.Get(db, inputPerson) + outputPersons = append(outputPersons, outputPerson) + } + return &outputPersons +} + +func GetAll(db *gorm.DB) *[]Person { + var outputPersonNames []string + result := db.Model(&Person{}).Select("name").Find(&outputPersonNames) + if result.Error != nil { + log.Println(result.Error) + } + return Get(db, outputPersonNames) +} + +func Update(db *gorm.DB, name string, groups []string) error { + return Person{ + Name: name, + Groups: *group.Get(db, groups), + }.Update(db) +} + +func Delete(db *gorm.DB, inputPersons []string) { + persons := Get(db, inputPersons) + for _, person := range *persons { + person.Delete(db) + } +} diff --git a/src/lib/database/role/role.go b/src/lib/database/role/role.go index 1aa4d19..e39c7c5 100644 --- a/src/lib/database/role/role.go +++ b/src/lib/database/role/role.go @@ -16,7 +16,7 @@ type Role struct { Visibility []group.Group `gorm:"many2many:role_visibility_associations" json:"visibility"` // Unique } -func CreateDatabaseRole(db *gorm.DB, role Role) error { +func (role Role) Create(db *gorm.DB) error { result := db.Create(&role) if result.Error != nil { return result.Error @@ -24,42 +24,71 @@ func CreateDatabaseRole(db *gorm.DB, role Role) error { return nil } -func GetDatabaseRole(db *gorm.DB, inputRole string) Role { - var outputRole Role - result := db.Model(&Role{}).Where("name = ?", inputRole).Take(&outputRole) - if result.Error != nil { - return Role{} - } - db.Model(&outputRole).Association("Tiers").Find(&outputRole.Tiers) - db.Model(&outputRole).Association("Visibility").Find(&outputRole.Visibility) - return outputRole +func (role *Role) getAssociations(db *gorm.DB) { + db.Model(&role).Association("Tiers").Find(&role.Tiers) + db.Model(&role).Association("Visibility").Find(&role.Visibility) + // } -func GetDatabaseRoles(db *gorm.DB) []Role { - var outputRoles []Role - db.Find(&outputRoles) - for _, outputRole := range outputRoles { - outputRoles = append(outputRoles, GetDatabaseRole(db, outputRole.Name)) - } - return outputRoles +func (role *Role) Get(db *gorm.DB, inputRole string) { + db.Where("name = ?", inputRole).Take(&role) + role.getAssociations(db) } -func GetAllDatabaseRoles(db *gorm.DB) []Role { - var outputRoles []Role - result := db.Find(&outputRoles) - if result.Error != nil { - log.Println(result.Error) - } - for index, outputRole := range outputRoles { - outputRoles[index] = GetDatabaseRole(db, outputRole.Name) - } - return outputRoles -} - -func UpdateDatabaseRole(db *gorm.DB, role Role) error { +func (role Role) Update(db *gorm.DB) error { result := db.Save(&role) if result.Error != nil { return result.Error } return nil } + +func (role Role) Delete(db *gorm.DB) error { + result := db.Delete(&role) + if result.Error != nil { + return result.Error + } + return nil +} + +func Create(db *gorm.DB, name string, tiers []int, visibility []string) error { + return Role{ + Name: name, + Tiers: *tier.Get(db, tiers), + Visibility: *group.Get(db, visibility), + }.Create(db) +} + +func Get(db *gorm.DB, inputRoles []string) *[]Role { + var outputRoles []Role + for _, inputRole := range inputRoles { + var outputRole Role + outputRole.Get(db, inputRole) + outputRoles = append(outputRoles, outputRole) + } + return &outputRoles +} + +func GetAll(db *gorm.DB) *[]Role { + var outputRoleNames []string + result := db.Model(&Role{}).Select("name").Find(&outputRoleNames) + if result.Error != nil { + log.Println(result.Error) + } + return Get(db, outputRoleNames) +} + +func Update(db *gorm.DB, name string, tiers []int, visibility []string) error { + return Role{ + Name: name, + Tiers: *tier.Get(db, tiers), + Visibility: *group.Get(db, visibility), + }.Update(db) +} + +func Delete(db *gorm.DB, inputRoles []string) { + roles := Get(db, inputRoles) + for _, role := range *roles { + role.Delete(db) + } +} diff --git a/src/lib/database/schematic/schematic.go b/src/lib/database/schematic/schematic.go index c9d5a62..e7c96f8 100644 --- a/src/lib/database/schematic/schematic.go +++ b/src/lib/database/schematic/schematic.go @@ -20,7 +20,7 @@ type Schematic struct { Visibility []group.Group `gorm:"many2many:schematic_group_associations" json:"visibility"` // Unique } -func CreateDatabaseSchematic(db *gorm.DB, schematic Schematic) error { +func (schematic Schematic) Create(db *gorm.DB) error { result := db.Create(&schematic) if result.Error != nil { return result.Error @@ -28,44 +28,95 @@ func CreateDatabaseSchematic(db *gorm.DB, schematic Schematic) error { return nil } -func GetDatabaseSchematic(db *gorm.DB, inputSchematic int) Schematic { - var outputSchematic Schematic - result := db.Model(&Schematic{}).Where("id = ?", inputSchematic).Take(&outputSchematic) - if result.Error != nil { - return 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 (schematic *Schematic) getAssociations(db *gorm.DB) { + db.Model(&schematic).Association("Material").Find(&schematic.Material) + db.Model(&schematic).Association("Tools").Find(&schematic.Tools) + db.Model(&schematic).Association("Requirements").Find(&schematic.Requirements) + db.Model(&schematic).Association("Result").Find(&schematic.Result) + db.Model(&schematic).Association("Visibility").Find(&schematic.Visibility) } -func GetDatabaseSchematics(db *gorm.DB, inputSchematics []int) []Schematic { - var outputSchematics []Schematic - for _, inputSchematic := range inputSchematics { - outputSchematics = append(outputSchematics, GetDatabaseSchematic(db, inputSchematic)) - } - return outputSchematics +func (schematic *Schematic) Get(db *gorm.DB, inputSchematic int) { + db.Model(&Schematic{}).Where("id = ?", inputSchematic).Take(&schematic) + schematic.getAssociations(db) } -func GetAllDatabaseSchematics(db *gorm.DB) []Schematic { - var outputSchematics []Schematic - result := db.Find(&outputSchematics) - if result.Error != nil { - log.Println(result.Error) +func (schematic Schematic) Update(db *gorm.DB) error { + materialError := db.Model(&schematic).Association("Material").Replace(&schematic.Material) + if materialError != nil { + return materialError } - for index, outputSchematic := range outputSchematics { - outputSchematics[index] = GetDatabaseSchematic(db, int(outputSchematic.ID)) + toolsError := db.Model(&schematic).Association("Tools").Replace(&schematic.Tools) + if toolsError != nil { + return toolsError } - return outputSchematics + requirementsError := db.Model(&schematic).Association("Requirements").Replace(&schematic.Requirements) + if requirementsError != nil { + return requirementsError + } + resultError := db.Model(&schematic).Association("Result").Replace(&schematic.Result) + if resultError != nil { + return resultError + } + visibilityError := db.Model(&schematic).Association("Visibility").Replace(&schematic.Visibility) + if visibilityError != nil { + return visibilityError + } + return nil } -func UpdateDatabaseSchematic(db *gorm.DB, schematic Schematic) error { - result := db.Save(&schematic) +func (schematic Schematic) Delete(db *gorm.DB) error { + result := db.Delete(&schematic) if result.Error != nil { return result.Error } return nil } + +func Create(db *gorm.DB, material []int, tools []int, requirements []string, timeUnits int64, result int, visibility []string) error { + return Schematic{ + Material: *inventoryslot.Get(db, material), + Tools: *inventoryslot.Get(db, tools), + Requirements: *function.Get(db, requirements), + TimeUnits: timeUnits, + Result: (*inventoryslot.Get(db, []int{result}))[0], + Visibility: *group.Get(db, visibility), + }.Create(db) +} + +func Get(db *gorm.DB, inputSchematics []int) *[]Schematic { + var outputSchematics []Schematic + for _, inputSchematic := range inputSchematics { + var outputSchematic Schematic + outputSchematic.Get(db, inputSchematic) + outputSchematics = append(outputSchematics, outputSchematic) + } + return &outputSchematics +} + +func GetAll(db *gorm.DB) *[]Schematic { + var outputSchematics []int + result := db.Model(&Schematic{}).Select("id").Find(&outputSchematics) + if result.Error != nil { + log.Println(result.Error) + } + return Get(db, outputSchematics) +} + +func Update(db *gorm.DB, material []int, tools []int, requirements []string, timeUnits int64, result int, visibility []string) error { + return Schematic{ + Material: *inventoryslot.Get(db, material), + Tools: *inventoryslot.Get(db, tools), + Requirements: *function.Get(db, requirements), + TimeUnits: timeUnits, + Result: (*inventoryslot.Get(db, []int{result}))[0], + Visibility: *group.Get(db, visibility), + }.Update(db) +} + +func Delete(db *gorm.DB, inputSchematics []int) { + schematics := Get(db, inputSchematics) + for _, schematic := range *schematics { + schematic.Delete(db) + } +} diff --git a/src/lib/database/tier/tier.go b/src/lib/database/tier/tier.go index 00296c6..6ce59cd 100644 --- a/src/lib/database/tier/tier.go +++ b/src/lib/database/tier/tier.go @@ -38,6 +38,14 @@ func (tier Tier) Update(db *gorm.DB) error { return nil } +func (tier Tier) Delete(db *gorm.DB) error { + result := db.Delete(&tier) + if result.Error != nil { + return result.Error + } + return nil +} + func Create(db *gorm.DB, functionSets []int) error { return Tier{ FunctionSets: *functionset.Get(db, functionSets), @@ -70,3 +78,10 @@ func Update(db *gorm.DB, id int, functionSets []int) error { outputTier.ID = uint(id) return outputTier.Update(db) } + +func Delete(db *gorm.DB, inputTiers []int) { + tiers := Get(db, inputTiers) + for _, tier := range *tiers { + tier.Delete(db) + } +}