TD-34: Endpoint for getting all players and tests

api/api.yml

@@ -70,23 +70,20 @@ components:
       required:
         - username
     #############################################
-    #  GetAllPlayersConfigurationData                                   #
+    #  PlayerFilter                             #
     #############################################
-    GetAllPlayersConfigurationData:
+    PlayerFilter:
       description: Configuration data for query for the getting all players endpoint
       type: object
       properties:
         page:
           type: integer
-          default: 0
           description: "Page number (zero-based index)."
         pageSize:
           type: integer
-          default: 10
           description: "Number of players per page."
         sortBy:
           type: string
-          default: "username"
           description: "Field to sort by (default is username)."
         order:
           type: string
@@ -95,6 +92,10 @@ components:
         username:
           type: string
           description: "Filter players by username (case-insensitive, partial match)."
+      required:
+        - page
+        - pageSize
+        - order
   responses:
     201PlayerCreated:
       description: "201 - Player Created"
@@ -188,15 +189,15 @@ paths:
   /admin/players:
     get:
       operationId: "GetAllPlayers"
+      tags:
+        - admin
       summary: "Retrieve a paginated list of players"
       description: "Returns a paginated list of players, optionally filtered by username."
       requestBody:
         content:
           application/json:
             schema:
-              $ref: "#/components/schemas/GetAllPlayersConfigurationData"
+              $ref: "#/components/schemas/PlayerFilter"
-      tags:
-        - admin
       responses:
         200:
           description: "A List of all Player"

src/main/java/de/towerdefence/server/admin/AdminApiController.java

@@ -5,9 +5,10 @@ import de.towerdefence.server.auth.UserSession;
 import de.towerdefence.server.oas.AdminApi;
 import de.towerdefence.server.oas.models.AdminAuthInfo;
 import de.towerdefence.server.oas.models.AdministratablePlayer;
-import de.towerdefence.server.oas.models.GetAllPlayersConfigurationData;
+import de.towerdefence.server.oas.models.PlayerFilter;
 import de.towerdefence.server.player.Player;
 import de.towerdefence.server.player.PlayerRepository;
+import de.towerdefence.server.utils.OrderToDirectionMapperService;
 import de.towerdefence.server.utils.PlayerMapperService;
 import jakarta.servlet.http.HttpServletRequest;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -35,6 +36,9 @@ public class AdminApiController implements AdminApi {
     @Autowired
     PlayerMapperService playerMapperService;
 
+    @Autowired
+    OrderToDirectionMapperService orderToDirectionMapperService;
+
 
     @Override
     public Optional<ObjectMapper> getObjectMapper() {
@@ -54,30 +58,21 @@ public class AdminApiController implements AdminApi {
     }
 
     @Override
-    public ResponseEntity<List<AdministratablePlayer>> getAllPlayers(GetAllPlayersConfigurationData body) {
+    public ResponseEntity<List<AdministratablePlayer>> getAllPlayers(PlayerFilter body) {
 
-        var order = body.getOrder();
+        PlayerFilter.OrderEnum order = body.getOrder();
-        var page = body.getPage();
+        Integer page = body.getPage();
-        var pageSize = body.getPageSize();
+        Integer pageSize = body.getPageSize();
-        var sortBy = body.getSortBy();
+        String sortBy = body.getSortBy();
-        var username = body.getUsername();
+        String username = body.getUsername();
 
-        if (order == null) {
+        Sort.Direction direction = orderToDirectionMapperService.OrderToDirection(order);
-            order = GetAllPlayersConfigurationData.OrderEnum.DESCENDING;
-        }
-        Sort.Direction direction;
-
-        if (order == GetAllPlayersConfigurationData.OrderEnum.ASCENDING) {
-            direction = Sort.Direction.ASC;
-        } else {
-            direction = Sort.Direction.DESC;
-        }
 
         Pageable pageable = PageRequest.of(page, pageSize, Sort.by(direction, sortBy));
 
         Page<Player> playerPage;
 
-        if (username != null && !username.trim().isEmpty()) {
+        if (username != null && !username.isEmpty()) {
             playerPage = playerRepository.findByUsernameContainingIgnoreCase(username, pageable);
         } else {
             playerPage = playerRepository.findAll(pageable);
@@ -86,10 +81,6 @@ public class AdminApiController implements AdminApi {
         List<AdministratablePlayer> playersMapped =
                 playerMapperService.mapPlayersToAdministratablePlayers(playerPage.getContent());
 
-        if (playersMapped.isEmpty()) {
-            return ResponseEntity.noContent().build();
-        } else {
         return ResponseEntity.ok(playersMapped);
     }
 }
-}

src/main/java/de/towerdefence/server/utils/OrderToDirectionMapperService.java

@@ -0,0 +1,18 @@
+package de.towerdefence.server.utils;
+
+import de.towerdefence.server.oas.models.PlayerFilter;
+import org.springframework.data.domain.Sort;
+import org.springframework.stereotype.Component;
+
+@Component
+public class OrderToDirectionMapperService {
+
+    public Sort.Direction OrderToDirection(PlayerFilter.OrderEnum order) {
+
+        if (order == PlayerFilter.OrderEnum.ASCENDING) {
+            return Sort.Direction.ASC;
+        } else {
+            return Sort.Direction.DESC;
+        }
+    }
+}

src/main/java/de/towerdefence/server/utils/PlayerMapperService.java

@@ -11,18 +11,18 @@ import java.util.List;
 public class PlayerMapperService {
 
     public List<AdministratablePlayer> mapPlayersToAdministratablePlayers(List<Player> players) {
-        List<AdministratablePlayer> apiPlayers = new ArrayList<>();
+        List<AdministratablePlayer> administratablePlayers = new ArrayList<>();
         for (Player player : players) {
             AdministratablePlayer apiPlayer = new AdministratablePlayer();
             apiPlayer.setUsername(player.getUsername());
-            apiPlayers.add(apiPlayer);
+            administratablePlayers.add(apiPlayer);
         }
-        return apiPlayers;
+        return administratablePlayers;
     }
 
     public AdministratablePlayer mapPlayerToAdministratablePlayer(Player player) {
-        AdministratablePlayer apiPlayer = new AdministratablePlayer();
+        AdministratablePlayer administratablePlayer = new AdministratablePlayer();
-        apiPlayer.setUsername(player.getUsername());
+        administratablePlayer.setUsername(player.getUsername());
-        return apiPlayer;
+        return administratablePlayer;
     }
 }

src/test/java/de/towerdefence/server/IntegrationTest.java

@@ -45,7 +45,7 @@ public abstract class IntegrationTest {
             player.setUsername(username);
             try {
                 playerService.setPassword(player, password);
-                playerRepository.save(player);
+                playerRepository.saveAndFlush(player);
             } catch (NoSuchAlgorithmException e) {
                 System.err.println("Error setting password for player: " + username);
             }

src/test/java/de/towerdefence/server/server/GetAllPlayersTest.java

@@ -1,6 +1,7 @@
 package de.towerdefence.server.server;
 
 import de.towerdefence.server.IntegrationTest;
+import de.towerdefence.server.oas.models.PlayerFilter;
 import org.junit.jupiter.api.Test;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
@@ -19,13 +20,13 @@ class GetAllPlayersTest extends IntegrationTest {
 
     @Test
     void playersExist() throws Exception {
-        String requestBody = "{" +
+        PlayerFilter playerFilter = new PlayerFilter();
-                "\"page\": 0," +
+        playerFilter.setPage(0);
-                "\"pageSize\": 10," +
+        playerFilter.setPageSize(10);
-                "\"sortBy\": \"username\"," +
+        playerFilter.setOrder(PlayerFilter.OrderEnum.DESCENDING);
-                "\"order\": \"descending\"," +
+        playerFilter.setUsername("");
-                "\"username\": \"\"" +
+        playerFilter.setSortBy("username");
-                "}";
+        String requestBody = this.objectMapper.writeValueAsString(playerFilter);
 
         this.mvc.perform(createGetAllPlayersRequest(requestBody))
                 .andExpect(status().isOk())
@@ -35,29 +36,14 @@ class GetAllPlayersTest extends IntegrationTest {
 
     @Test
     void playersSortedByAsc() throws Exception {
-        String requestBody = "{" +
-                "\"page\": 0," +
-                "\"pageSize\": 10," +
-                "\"sortBy\": \"username\"," +
-                "\"order\": \"ascending\"," +
-                "\"username\": \"\"" +
-                "}";
 
-        this.mvc.perform(createGetAllPlayersRequest(requestBody))
+        PlayerFilter playerFilter = new PlayerFilter();
-                .andExpect(status().isOk())
+        playerFilter.setPage(0);
-                .andExpect(jsonPath("$[0].username").value("Alex"))
+        playerFilter.setPageSize(10);
-                .andExpect(jsonPath("$[1].username").value("Zorro"));
+        playerFilter.setOrder(PlayerFilter.OrderEnum.ASCENDING);
-    }
+        playerFilter.setUsername("");
-
+        playerFilter.setSortBy("username");
-    @Test
+        String requestBody = this.objectMapper.writeValueAsString(playerFilter);
-    void playersSortedByDesc() throws Exception {
-        String requestBody = "{" +
-                "\"page\": 0," +
-                "\"pageSize\": 10," +
-                "\"sortBy\": \"username\"," +
-                "\"order\": \"descending\"," +
-                "\"username\": \"\"" +
-                "}";
 
         this.mvc.perform(createGetAllPlayersRequest(requestBody))
                 .andExpect(status().isOk())
@@ -66,17 +52,33 @@ class GetAllPlayersTest extends IntegrationTest {
     }
 
     @Test
-    void playersFiltered() throws Exception {
+    void playersSortedByDesc() throws Exception {
-        String requestBody = "{" +
+        PlayerFilter playerFilter = new PlayerFilter();
-                "\"page\": 0," +
+        playerFilter.setPage(0);
-                "\"pageSize\": 10," +
+        playerFilter.setPageSize(10);
-                "\"username\": \"Alex\","+
+        playerFilter.setOrder(PlayerFilter.OrderEnum.DESCENDING);
-                "\"order\": \"ascending\""+
+        playerFilter.setUsername("");
-                "}";
+        playerFilter.setSortBy("username");
+        String requestBody = this.objectMapper.writeValueAsString(playerFilter);
+
+        this.mvc.perform(createGetAllPlayersRequest(requestBody))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].username").value("Alex"))
+                .andExpect(jsonPath("$[1].username").value("Zorro"));
+    }
+
+    @Test
+    void playersFiltered() throws Exception {
+        PlayerFilter playerFilter = new PlayerFilter();
+        playerFilter.setPage(0);
+        playerFilter.setPageSize(10);
+        playerFilter.setOrder(PlayerFilter.OrderEnum.ASCENDING);
+        playerFilter.setUsername("Alex");
+        playerFilter.setSortBy("username");
+        String requestBody = this.objectMapper.writeValueAsString(playerFilter);
 
         this.mvc.perform(createGetAllPlayersRequest(requestBody))
                 .andExpect(status().isOk())
-                .andExpect(jsonPath("$").isArray())
                 .andExpect(jsonPath("$[0].username").value("Alex"))
                 .andExpect(jsonPath("$").isNotEmpty());
     }