selektion von Chars nach UserID

backend/api/api_test.go

@@ -102,7 +102,7 @@ func TestListCharacters(t *testing.T) {
 	assert.Equal(t, 1, int(listOfCharacter[0].ID)) // Check the simulated ID
 	assert.Equal(t, "Krieger", listOfCharacter[0].Typ)
 	assert.Equal(t, 3, listOfCharacter[0].Grad)
-	assert.Equal(t, "test", listOfCharacter[0].Owner)
+	assert.Equal(t, "bebe", listOfCharacter[0].Owner)
 	assert.Equal(t, false, listOfCharacter[0].Public)
 
 }

backend/character/handlers.go

@@ -32,30 +32,35 @@ func respondWithError(c *gin.Context, status int, message string) {
 func ListCharacters(c *gin.Context) {
 	logger.Debug("ListCharacters aufgerufen")
 
-	var characters []models.Char
-	var listOfChars []models.CharList
+	//var characters []models.Char
+	//var listOfChars []models.CharList
 
 	logger.Debug("Lade Charaktere aus der Datenbank...")
-	if err := database.DB.Find(&characters).Error; err != nil {
+	//if err := database.DB.Find(&characters).Error; err != nil {
+	listOfChars, err := models.FindCharListByUserID(c.GetUint("userID"))
+	if err != nil {
+
 		logger.Error("Fehler beim Laden der Charaktere: %s", err.Error())
 		respondWithError(c, http.StatusInternalServerError, "Failed to retrieve characters")
 		return
 	}
 
-	logger.Debug("Gefundene Charaktere: %d", len(characters))
+	logger.Debug("Gefundene Charaktere: %d", len(listOfChars))
 
-	for i := range characters {
-		listOfChars = append(listOfChars, models.CharList{
-			BamortBase: models.BamortBase{
-				ID:   characters[i].ID,
-				Name: characters[i].Name,
-			},
-			Rasse: characters[i].Rasse,
-			Typ:   characters[i].Typ,
-			Grad:  characters[i].Grad,
-			Owner: "test",
-		})
-	}
+	/*
+		for i := range characters {
+			listOfChars = append(listOfChars, models.CharList{
+				BamortBase: models.BamortBase{
+					ID:   characters[i].ID,
+					Name: characters[i].Name,
+				},
+				Rasse: characters[i].Rasse,
+				Typ:   characters[i].Typ,
+				Grad:  characters[i].Grad,
+				Owner: characters[i].User.Username,
+			})
+		}
+	*/
 
 	logger.Info("Charakterliste erfolgreich geladen: %d Charaktere", len(listOfChars))
 	c.JSON(http.StatusOK, listOfChars)

backend/character/handlers_test.go

@@ -948,3 +948,103 @@ func TestFinalizeCharacterCreation(t *testing.T) {
 		assert.Equal(t, "Unauthorized", response["error"])
 	})
 }
+
+func TestListCharacters(t *testing.T) {
+	// Setup test environment
+	original := os.Getenv("ENVIRONMENT")
+	os.Setenv("ENVIRONMENT", "test")
+	t.Cleanup(func() {
+		if original != "" {
+			os.Setenv("ENVIRONMENT", original)
+		} else {
+			os.Unsetenv("ENVIRONMENT")
+		}
+	})
+
+	// Setup test database
+	database.SetupTestDB(true, true)
+	defer database.ResetTestDB()
+
+	err := models.MigrateStructure()
+	assert.NoError(t, err)
+
+	t.Run("ListCharacters Success", func(t *testing.T) {
+		// Create a test user
+		u := user.User{}
+		u.FirstId(1)
+		token := user.GenerateToken(&u)
+
+		// Create a test HTTP request
+		req, _ := http.NewRequest("GET", "/api/characters", nil)
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Bearer "+token)
+
+		w := httptest.NewRecorder()
+		c, _ := gin.CreateTestContext(w)
+		c.Request = req
+		c.Set("userID", uint(1)) // Set valid userID
+
+		// Call the handler
+		ListCharacters(c)
+
+		// Assert response
+		assert.Equal(t, http.StatusOK, w.Code)
+
+		var response []models.CharList
+		err = json.Unmarshal(w.Body.Bytes(), &response)
+		assert.NoError(t, err)
+
+		// Response should be an array (could be empty if no characters exist)
+		assert.IsType(t, []models.CharList{}, response)
+	})
+
+	t.Run("ListCharacters with Invalid User", func(t *testing.T) {
+		// Create a test user with invalid ID
+		u := user.User{}
+		u.FirstId(999) // Non-existent user ID
+		token := user.GenerateToken(&u)
+
+		// Create a test HTTP request
+		req, _ := http.NewRequest("GET", "/api/characters", nil)
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Bearer "+token)
+
+		w := httptest.NewRecorder()
+		c, _ := gin.CreateTestContext(w)
+		c.Request = req
+		c.Set("userID", uint(999)) // Set invalid userID
+
+		// Call the handler
+		ListCharacters(c)
+
+		// Should still return OK with empty list if user has no characters
+		assert.Equal(t, http.StatusOK, w.Code)
+
+		var response []models.CharList
+		err = json.Unmarshal(w.Body.Bytes(), &response)
+		assert.NoError(t, err)
+		assert.Equal(t, 0, len(response), "Should return empty list for user with no characters")
+	})
+
+	t.Run("ListCharacters without UserID", func(t *testing.T) {
+		// Create a test HTTP request without setting userID in context
+		req, _ := http.NewRequest("GET", "/api/characters", nil)
+		req.Header.Set("Content-Type", "application/json")
+
+		w := httptest.NewRecorder()
+		c, _ := gin.CreateTestContext(w)
+		c.Request = req
+		// Don't set userID in context - this should trigger an error
+
+		// Call the handler
+		ListCharacters(c)
+
+		// Should still return OK with empty list since GetUint("userID") returns 0 for missing userID
+		assert.Equal(t, http.StatusOK, w.Code)
+
+		var response []models.CharList
+		err = json.Unmarshal(w.Body.Bytes(), &response)
+		assert.NoError(t, err)
+		assert.Equal(t, 0, len(response), "Should return empty list for userID 0")
+	})
+}

backend/models/model_character.go

@@ -214,8 +214,9 @@ func (object *Char) FindByUserID(userID uint) ([]Char, error) {
 func FindCharListByUserID(userID uint) ([]CharList, error) {
 	var chars []CharList
 	err := database.DB.Table("char_chars").
-		Select("id, name, user_id, rasse, typ, grad, owner, public").
-		Where("user_id = ?", userID).
+		Select("char_chars.id, char_chars.name, char_chars.user_id, char_chars.rasse, char_chars.typ, char_chars.grad, char_chars.public, users.username as owner").
+		Joins("LEFT JOIN users ON char_chars.user_id = users.user_id").
+		Where("char_chars.user_id = ?", userID).
 		Find(&chars).Error
 	if err != nil {
 		return nil, err