Fix client deserialization

api/src/main/java/be/naaturel/boardmateapi/controllers/BrokerController.java

@@ -1,6 +1,7 @@
 package be.naaturel.boardmateapi.controllers;
 
 import be.naaturel.boardmateapi.common.exceptions.ServiceException;
+import be.naaturel.boardmateapi.controllers.dtos.ResponseBody;
 import be.naaturel.boardmateapi.services.MqttService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;

api/src/main/java/be/naaturel/boardmateapi/controllers/GameController.java

@@ -2,10 +2,10 @@ package be.naaturel.boardmateapi.controllers;
 
 import be.naaturel.boardmateapi.common.exceptions.ServiceException;
 import be.naaturel.boardmateapi.common.models.Game;
+import be.naaturel.boardmateapi.controllers.dtos.ResponseBody;
 import be.naaturel.boardmateapi.controllers.dtos.GameDto;
 import be.naaturel.boardmateapi.controllers.mappings.GameMapper;
 import be.naaturel.boardmateapi.services.GameService;
-import jakarta.websocket.server.PathParam;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
@@ -21,17 +21,6 @@ public class GameController {
         this.service = service;
     }
 
-    @GetMapping("/games/")
-    public ResponseEntity<?> retrieveAllGames(){
-        try{
-            return ResponseEntity
-                    .status(HttpStatus.INTERNAL_SERVER_ERROR)
-                    .build();
-        } catch (Exception e){
-            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
-        }
-    }
-
     @GetMapping("/games/{id}")
     public ResponseEntity<ResponseBody<GameDto>> retrieveGames(@PathVariable String id){
         ResponseBody<GameDto> result = ResponseBody.createEmpty();

api/src/main/java/be/naaturel/boardmateapi/controllers/dtos/ResponseBody.java

@@ -1,4 +1,4 @@
-package be.naaturel.boardmateapi.controllers;
+package be.naaturel.boardmateapi.controllers.dtos;
 
 import java.util.Optional;
 

rpi/api-resources/board-mate.yaml

@@ -6,17 +6,7 @@ info:
 servers:
   - url: "https://boardmate_api"
 paths:
-  /games:
+
-    get:
-      summary: "GET games"
-      operationId: "retrieveAllGames"
-      responses:
-        "200":
-          description: "OK"
-          content:
-            '*/*':
-              schema:
-                type: "object"
   /games/{id}:
     get:
       summary: "GET games/{id}"
@@ -33,7 +23,7 @@ paths:
           content:
             '*/*':
               schema:
-                $ref: "#/components/schemas/GameDto"
+                $ref: "#/components/schemas/ResponseBodyGameDto"
   /create:
     post:
       summary: "POST create"
@@ -50,7 +40,7 @@ paths:
           content:
             '*/*':
               schema:
-                type: "string"
+                $ref: "#/components/schemas/ResponseBodyString"
   /moves/add/{gameId}:
     post:
       summary: "POST moves/add/{gameId}"
@@ -73,9 +63,36 @@ paths:
           content:
             '*/*':
               schema:
-                type: "string"
+                $ref: "#/components/schemas/ResponseBodyString"
 components:
   schemas:
+
+    ResponseBodyGameDto:
+      type: "object"
+      properties:
+        data:
+          type: "object"
+          nullable: true
+        message:
+          type: "string"
+          nullable: true
+        success:
+          type: "boolean"
+          nullable: false
+
+    ResponseBodyString:
+      type: "object"
+      properties:
+        data:
+          type: "string"
+          nullable: true
+        message:
+          type: "string"
+          nullable: true
+        success:
+          type: "boolean"
+          nullable: false
+
     GameDto:
       type: "object"
       properties:

rpi/board_mate_client/__init__.py

@@ -32,3 +32,5 @@ from board_mate_client.exceptions import ApiException
 
 # import models into sdk package
 from board_mate_client.models.game_dto import GameDto
+from board_mate_client.models.response_body_game_dto import ResponseBodyGameDto
+from board_mate_client.models.response_body_string import ResponseBodyString

rpi/board_mate_client/api/default_api.py

@@ -17,8 +17,9 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 from typing_extensions import Annotated
 
 from pydantic import StrictStr
-from typing import Any, Dict
 from board_mate_client.models.game_dto import GameDto
+from board_mate_client.models.response_body_game_dto import ResponseBodyGameDto
+from board_mate_client.models.response_body_string import ResponseBodyString
 
 from board_mate_client.api_client import ApiClient, RequestSerialized
 from board_mate_client.api_response import ApiResponse
@@ -55,7 +56,7 @@ class DefaultApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> str:
+    ) -> ResponseBodyString:
         """POST moves/add/{gameId}
 
 
@@ -95,7 +96,7 @@ class DefaultApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': "ResponseBodyString",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -125,7 +126,7 @@ class DefaultApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[str]:
+    ) -> ApiResponse[ResponseBodyString]:
         """POST moves/add/{gameId}
 
 
@@ -165,7 +166,7 @@ class DefaultApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': "ResponseBodyString",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -235,7 +236,7 @@ class DefaultApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': "ResponseBodyString",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -336,7 +337,7 @@ class DefaultApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> str:
+    ) -> ResponseBodyString:
         """POST create
 
 
@@ -373,7 +374,7 @@ class DefaultApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': "ResponseBodyString",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -402,7 +403,7 @@ class DefaultApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[str]:
+    ) -> ApiResponse[ResponseBodyString]:
         """POST create
 
 
@@ -439,7 +440,7 @@ class DefaultApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': "ResponseBodyString",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -505,7 +506,7 @@ class DefaultApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "str",
+            '200': "ResponseBodyString",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -587,245 +588,6 @@ class DefaultApi:
 
 
 
-    @validate_call
-    def retrieve_all_games(
-        self,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> object:
-        """GET games
-
-
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._retrieve_all_games_serialize(
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "object",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        ).data
-
-
-    @validate_call
-    def retrieve_all_games_with_http_info(
-        self,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[object]:
-        """GET games
-
-
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._retrieve_all_games_serialize(
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "object",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        response_data.read()
-        return self.api_client.response_deserialize(
-            response_data=response_data,
-            response_types_map=_response_types_map,
-        )
-
-
-    @validate_call
-    def retrieve_all_games_without_preload_content(
-        self,
-        _request_timeout: Union[
-            None,
-            Annotated[StrictFloat, Field(gt=0)],
-            Tuple[
-                Annotated[StrictFloat, Field(gt=0)],
-                Annotated[StrictFloat, Field(gt=0)]
-            ]
-        ] = None,
-        _request_auth: Optional[Dict[StrictStr, Any]] = None,
-        _content_type: Optional[StrictStr] = None,
-        _headers: Optional[Dict[StrictStr, Any]] = None,
-        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> RESTResponseType:
-        """GET games
-
-
-        :param _request_timeout: timeout setting for this request. If one
-                                 number provided, it will be total request
-                                 timeout. It can also be a pair (tuple) of
-                                 (connection, read) timeouts.
-        :type _request_timeout: int, tuple(int, int), optional
-        :param _request_auth: set to override the auth_settings for an a single
-                              request; this effectively ignores the
-                              authentication in the spec for a single request.
-        :type _request_auth: dict, optional
-        :param _content_type: force content-type for the request.
-        :type _content_type: str, Optional
-        :param _headers: set to override the headers for a single
-                         request; this effectively ignores the headers
-                         in the spec for a single request.
-        :type _headers: dict, optional
-        :param _host_index: set to override the host_index for a single
-                            request; this effectively ignores the host_index
-                            in the spec for a single request.
-        :type _host_index: int, optional
-        :return: Returns the result object.
-        """ # noqa: E501
-
-        _param = self._retrieve_all_games_serialize(
-            _request_auth=_request_auth,
-            _content_type=_content_type,
-            _headers=_headers,
-            _host_index=_host_index
-        )
-
-        _response_types_map: Dict[str, Optional[str]] = {
-            '200': "object",
-        }
-        response_data = self.api_client.call_api(
-            *_param,
-            _request_timeout=_request_timeout
-        )
-        return response_data.response
-
-
-    def _retrieve_all_games_serialize(
-        self,
-        _request_auth,
-        _content_type,
-        _headers,
-        _host_index,
-    ) -> RequestSerialized:
-
-        _host = None
-
-        _collection_formats: Dict[str, str] = {
-        }
-
-        _path_params: Dict[str, str] = {}
-        _query_params: List[Tuple[str, str]] = []
-        _header_params: Dict[str, Optional[str]] = _headers or {}
-        _form_params: List[Tuple[str, str]] = []
-        _files: Dict[str, Union[str, bytes]] = {}
-        _body_params: Optional[bytes] = None
-
-        # process the path parameters
-        # process the query parameters
-        # process the header parameters
-        # process the form parameters
-        # process the body parameter
-
-
-        # set the HTTP header `Accept`
-        _header_params['Accept'] = self.api_client.select_header_accept(
-            [
-                '*/*'
-            ]
-        )
-
-
-        # authentication setting
-        _auth_settings: List[str] = [
-        ]
-
-        return self.api_client.param_serialize(
-            method='GET',
-            resource_path='/games',
-            path_params=_path_params,
-            query_params=_query_params,
-            header_params=_header_params,
-            body=_body_params,
-            post_params=_form_params,
-            files=_files,
-            auth_settings=_auth_settings,
-            collection_formats=_collection_formats,
-            _host=_host,
-            _request_auth=_request_auth
-        )
-
-
-
-
     @validate_call
     def retrieve_games(
         self,
@@ -842,7 +604,7 @@ class DefaultApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> GameDto:
+    ) -> ResponseBodyGameDto:
         """GET games/{id}
 
 
@@ -879,7 +641,7 @@ class DefaultApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GameDto",
+            '200': "ResponseBodyGameDto",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -908,7 +670,7 @@ class DefaultApi:
         _content_type: Optional[StrictStr] = None,
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
-    ) -> ApiResponse[GameDto]:
+    ) -> ApiResponse[ResponseBodyGameDto]:
         """GET games/{id}
 
 
@@ -945,7 +707,7 @@ class DefaultApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GameDto",
+            '200': "ResponseBodyGameDto",
         }
         response_data = self.api_client.call_api(
             *_param,
@@ -1011,7 +773,7 @@ class DefaultApi:
         )
 
         _response_types_map: Dict[str, Optional[str]] = {
-            '200': "GameDto",
+            '200': "ResponseBodyGameDto",
         }
         response_data = self.api_client.call_api(
             *_param,

rpi/board_mate_client/models/__init__.py

@@ -15,3 +15,5 @@
 
 # import models into model package
 from board_mate_client.models.game_dto import GameDto
+from board_mate_client.models.response_body_game_dto import ResponseBodyGameDto
+from board_mate_client.models.response_body_string import ResponseBodyString

rpi/board_mate_client/models/response_body_game_dto.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    boardmate_api API
+
+    boardmate_api API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ResponseBodyGameDto(BaseModel):
+    """
+    ResponseBodyGameDto
+    """ # noqa: E501
+    data: Optional[Dict[str, Any]] = None
+    message: Optional[StrictStr] = None
+    success: Optional[StrictBool] = None
+    __properties: ClassVar[List[str]] = ["data", "message", "success"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ResponseBodyGameDto from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ResponseBodyGameDto from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "data": obj.get("data"),
+            "message": obj.get("message"),
+            "success": obj.get("success")
+        })
+        return _obj
+
+

rpi/board_mate_client/models/response_body_string.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+"""
+    boardmate_api API
+
+    boardmate_api API
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class ResponseBodyString(BaseModel):
+    """
+    ResponseBodyString
+    """ # noqa: E501
+    data: Optional[StrictStr] = None
+    message: Optional[StrictStr] = None
+    success: Optional[StrictBool] = None
+    __properties: ClassVar[List[str]] = ["data", "message", "success"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ResponseBodyString from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ResponseBodyString from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "data": obj.get("data"),
+            "message": obj.get("message"),
+            "success": obj.get("success")
+        })
+        return _obj
+
+

rpi/controllers/board_mate_controller.py

@@ -0,0 +1,32 @@
+from board_mate_client import ApiClient, DefaultApi, GameDto
+
+
+class ApiController:
+
+    def __init__(self, config) -> None:
+        self.config = config
+
+    def create_party(self, white_name, black_name, time_value, increment) -> str | None:
+        try:
+            with ApiClient(self.config) as client:
+                api = DefaultApi(client)
+
+                game = GameDto(
+                    white_name="Alice",
+                    black_name="Bob",
+                    time_value=300,
+                    increment=10
+                )
+
+                response = api.create_party(game)
+                print("Raw response:", response)
+                return str(response.data)
+        except Exception as e:
+            print("Error during create_party:", e)
+            return None
+
+    def retrieve_game(self, game_id) -> GameDto:
+        with ApiClient(self.config) as client:
+            api = DefaultApi(client)
+            response = api.retrieve_games(game_id)
+            return GameDto.from_dict(response.data)

rpi/main.py

@@ -1,16 +1,16 @@
 #!/usr/bin/env python3
 
 from board_mate_client import ApiClient, Configuration
-from board_mate_client.api.default_api import DefaultApi
+from controllers.board_mate_controller import ApiController
-from board_mate_client.models.game_dto import GameDto
 
 if __name__ == "__main__":
     config = Configuration(
         host="http://192.168.15.120:8000"
     )
 
-    with ApiClient(config) as client:
+    controller = ApiController(config)
-        api = DefaultApi(client)
 
-        response = api.retrieve_games("693eebe727f9ffb33360fa38")
+    game_id = controller.create_party("Aude Vaiselle", "Jean Porte", 30, 0)
-        print(response)
+    print(game_id)
+    data = controller.retrieve_game(game_id)
+    print(data)