progress

src/lib/api/api.go

@@ -297,7 +297,7 @@ func UpdateObject(context *gin.Context) {
 			case "function":
 				result = function.Update(GlobalDatabase, context)
 			case "function-tag":
-				// result = functiontag.Create(GlobalDatabase, objectID)
+				result = functiontag.Update(GlobalDatabase, context)
 			case "inventory-slot":
 				//
 			case "item":
@@ -395,8 +395,9 @@ func GetObjects(context *gin.Context) {
 				"functions": function.Get(GlobalDatabase, uintObjectIDs),
 			})
 		case "function-tags":
+			objectIDInts := objectIDStringsToInts(context, objectIDs)
 			context.JSON(http.StatusOK, gin.H{
-				"function_tags": functiontag.Get(GlobalDatabase, objectIDs),
+				"function_tags": functiontag.Get(GlobalDatabase, *objectIDInts),
 			})
 		case "inventory-slot":
 			objectIDInts := objectIDStringsToInts(context, objectIDs)
@@ -492,35 +493,35 @@ func DeleteObject(context *gin.Context) {
 			uintObjectIDs := objectIDStringsToInts(context, objectIDs)
 			var result error
 			switch objectType := context.Param("object"); objectType {
-			case "user":
+			case "users":
 				//
-			case "person":
+			case "persons":
 				//
 			case "groups":
 				log.Println(*uintObjectIDs, objectIDs)
 				result = group.Delete(GlobalDatabase, *uintObjectIDs)
-			case "character":
+			case "characters":
 				//
-			case "role":
+			case "roles":
 				//
-			case "tier":
+			case "tiers":
 				//
-			case "function-set":
+			case "function-sets":
 				//
-			case "function":
+			case "functions":
 				log.Println(uintObjectIDs)
 				result = function.Delete(GlobalDatabase, *uintObjectIDs)
-			case "function-tag":
-				// result = functiontag.Create(GlobalDatabase, objectID)
-			case "inventory-slot":
+			case "function-tags":
+				result = functiontag.Delete(GlobalDatabase, *uintObjectIDs)
+			case "inventory-slots":
 				//
-			case "item":
+			case "items":
 				//
-			case "item-tag":
+			case "item-tags":
 				//
-			case "customization":
+			case "customizations":
 				//
-			case "schematic":
+			case "schematics":
 				//
 			}
 			if result != nil {

src/lib/database/function/function.go

@@ -22,7 +22,7 @@ type Function struct {
 type functionParams struct {
 	Id           string `json:"id"`
 	Name         string `json:"name"`
-	Tags         []string `json:"tags"`
+	Tags         []uint `json:"tags"`
 	Requirements []uint `json:"requirements"`
 }
 

src/lib/database/functiontag/functiontag.go

@@ -1,7 +1,11 @@
 package functiontag
 
 import (
+	"encoding/json"
+	"errors"
+	"io"
 	"log"
+	"strconv"
 
 	"github.com/gin-gonic/gin"
 	"gorm.io/gorm"
@@ -9,18 +13,45 @@ import (
 
 type FunctionTag struct {
 	gorm.Model
-	Name string `gorm:"primaryKey uniqueIndex" json:"name"`
+	Name string `gorm:"uniqueIndex" json:"name"`
 }
 
-func (functionTag *FunctionTag) get(db *gorm.DB, inputFunctionTag string) {
-	db.Where("name = ?", inputFunctionTag).Take(&functionTag)
+type functionTagParams struct {
+	// ID of the object being modified
+	ID string
+	// New fields
+	Name string
+}
+
+func (params *functionTagParams) validate(context *gin.Context) error {
+	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
+	}
+	var name functionTagParams
+	_ = json.Unmarshal(body, &name)
+	params.ID = ID
+	params.Name = name.Name
+	return nil
+}
+
+func (functionTag *FunctionTag) get(db *gorm.DB, inputFunctionTag uint) {
+	db.Model(&FunctionTag{}).Where("ID = ?", inputFunctionTag).Take(&functionTag)
 }
 
 func (functionTag FunctionTag) update(db *gorm.DB) error {
-	result := db.Save(&functionTag)
+	var originalFunctionTag FunctionTag
+	result := db.Model(&FunctionTag{}).Where("id = ?", functionTag.ID).Take(&originalFunctionTag)
 	if result.Error != nil {
 		return result.Error
 	}
+	originalFunctionTag.Name = functionTag.Name
+	db.Save(&originalFunctionTag)
 	return nil
 }
 
@@ -41,12 +72,21 @@ func (functionTag FunctionTag) delete(db *gorm.DB) error {
 }
 
 func Create(db *gorm.DB, context *gin.Context) 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: context.Query("id"),
+		Name: newFunctionTag.Name,
 	}.create(db)
 }
 
-func Get(db *gorm.DB, inputFunctionTags []string) *[]FunctionTag {
+func Get(db *gorm.DB, inputFunctionTags []uint) *[]FunctionTag {
 	var outputFunctionTags []FunctionTag
 	for _, inputFunctionTag := range inputFunctionTags {
 		var outputFunctionTag FunctionTag
@@ -58,22 +98,32 @@ func Get(db *gorm.DB, inputFunctionTags []string) *[]FunctionTag {
 
 func GetAll(db *gorm.DB) *[]FunctionTag {
 	var outputFunctionTags []FunctionTag
-	var outputFunctionTagNames []string
-	result := db.Model(&FunctionTag{}).Select("name").Find(&outputFunctionTagNames)
+	var outputFunctionTagIDs []uint
+	result := db.Model(&FunctionTag{}).Select("id").Find(&outputFunctionTagIDs)
 	if result.Error != nil {
 		log.Println(result.Error)
 	}
-	outputFunctionTags = *Get(db, outputFunctionTagNames)
+	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{
-		Name: context.Query("id"),
+		Model: gorm.Model{ID: uint(uintID)},
+		Name:  params.Name,
 	}.update(db)
 }
 
-func Delete(db *gorm.DB, inputFunctions []string) error {
+func Delete(db *gorm.DB, inputFunctions []uint) error {
 	functions := Get(db, inputFunctions)
 	for _, function := range *functions {
 		err := function.delete(db)

src/lib/database/group/group.go

@@ -78,7 +78,6 @@ func Create(db *gorm.DB, context *gin.Context) error {
 	}
 	var newGroup Group
 	err = json.Unmarshal(body, &newGroup)
-	log.Println(newGroup)
 	if err != nil {
 		return err
 	}