feat: add teamOfficials and gameInfo to endpoint #163

also refactor gameinfo_wrapper.py to raise ValueError

Author: chris0chris

gamedays/api/game_views.py

@@ -23,7 +23,7 @@ def get(self, request: Request, *args, **kwargs):
             try:
                 gamelog = GameService(game_id).get_gamelog()
                 return Response(json.loads(gamelog.as_json(), object_pairs_hook=OrderedDict))
-            except Gameinfo.DoesNotExist:
+            except ValueError:
                 raise NotFound(detail=f'No game found for gameId {game_id}')
         gamelog = Gameinfo.objects.filter(id=game_id).annotate(
             home_id=GameresultHelper.get_gameresult_team_subquery(is_home=True, team_column='id'),
@@ -55,7 +55,7 @@ def post(self, request, *args, **kwargs):
             gamelog = game_service.create_gamelog(data.get('team'), data.get('event'), request.user, data.get('half'))
             game_service.update_score(gamelog)
             return Response(json.loads(gamelog.as_json(), object_pairs_hook=OrderedDict), status=HTTPStatus.CREATED)
-        except Gameinfo.DoesNotExist:
+        except ValueError:
             raise NotFound(detail=f'Could not create team logs ... gameId {request.data.get("gameId")} not found')
         except Team.DoesNotExist:
             raise NotFound(detail=f'Could not create team logs ... team {request.data.get("team")} not found')
@@ -67,7 +67,7 @@ def delete(self, request: Request, *args, **kwargs):
             gamelog = game_service.delete_gamelog(request.data.get('sequence'))
             game_service.update_score(gamelog)
             return Response(json.loads(gamelog.as_json(), object_pairs_hook=OrderedDict), status=HTTPStatus.OK)
-        except Gameinfo.DoesNotExist:
+        except ValueError:
             raise NotFound(detail=f'Could not delete team logs ... gameId {game_id} not found')
 
 

gamedays/service/wrapper/gameinfo_wrapper.py

@@ -1,11 +1,18 @@
 from datetime import datetime
 
-from gamedays.models import Gameinfo
+from django.db.models import Subquery, OuterRef
+
+from gamedays.models import Gameinfo, Gameresult
+from league_manager.utils.view_utils import UserRequestPermission
 
 
 class GameinfoWrapper(object):
-    def __init__(self, game_id):
-        self.gameinfo = Gameinfo.objects.get(id=game_id)
+    def __init__(self, game_id, user_permission: UserRequestPermission = UserRequestPermission()):
+        self.user_permission = user_permission
+        try:
+            self.gameinfo = Gameinfo.objects.get(id=game_id)
+        except Gameinfo.DoesNotExist:
+            raise ValueError(f'No entry found for game_id: {game_id}')
 
     def set_halftime_to_now(self):
         self.gameinfo.status = '2. Halbzeit'
@@ -25,3 +32,18 @@ def set_game_finished_to_now(self):
     def update_team_in_possession(self, team_name):
         self.gameinfo.in_possession = team_name
         self.gameinfo.save()
+
+    def get_game_info_with_home_and_away(self):
+        return Gameinfo.objects.filter(id=self.gameinfo.pk).distinct().annotate(
+            home=self._get_gameresult_team_subquery(is_home=True, team_column='team__description'),
+            away=self._get_gameresult_team_subquery(is_home=False, team_column='team__description'),
+        )
+
+    # noinspection PyMethodMayBeStatic
+    def _get_gameresult_team_subquery(self, is_home: bool, team_column: str):
+        return Subquery(
+            Gameresult.objects.filter(
+                gameinfo=OuterRef('id'),
+                isHome=is_home
+            ).values(team_column)[:1]
+        )

gamedays/tests/service/test_game_service.py

@@ -10,7 +10,7 @@
 
 class TestGameService(TestCase):
     def test_game_not_available(self):
-        with self.assertRaises(Gameinfo.DoesNotExist):
+        with self.assertRaises(ValueError):
             GameService(1)
 
     def test_update_game_by_halftime(self):

officials/api/views.py

@@ -8,6 +8,7 @@
 
 from officials.api.serializers import OfficialTeamListScorecardSerializer
 from officials.models import Official
+from officials.service.official_service import OfficialService
 
 
 class OfficialsTeamListAPIView(APIView):
@@ -16,11 +17,8 @@ class OfficialsTeamListAPIView(APIView):
     # noinspection PyMethodMayBeStatic
     def get(self, request, **kwargs):
         team_id = kwargs.get('pk')
-        officials = Official.objects.filter(team_id=team_id).order_by('first_name', 'last_name').values(
-            *OfficialTeamListScorecardSerializer.ALL_FIELD_VALUES
-        )
-        serializer = OfficialTeamListScorecardSerializer(instance=officials, many=True)
-        return Response(serializer.data, status=HTTPStatus.OK)
+        official_service = OfficialService()
+        return Response(official_service.get_team_officials_by_team_id(team_id), status=HTTPStatus.OK)
 
 
 class OfficialsSearchName(APIView):

officials/service/official_service.py

@@ -1,7 +1,8 @@
 from django.db.models import Sum
 
+from gamedays.models import Gameinfo
 from gamedays.service.team_repository_service import TeamRepositoryService
-from officials.api.serializers import OfficialGameCountSerializer
+from officials.api.serializers import OfficialGameCountSerializer, OfficialTeamListScorecardSerializer
 from officials.models import Official
 from officials.service.game_official_entries import InternalGameOfficialEntry, ExternalGameOfficialEntry
 from officials.service.moodle.moodle_service import MoodleService
@@ -68,3 +69,14 @@ def _aggregate_games(self, external_official_qs):
         all_external_games_count = external_official_qs.aggregate(num_games=Sum('number_games')).get('num_games',
                                                                                                      0) or 0
         return all_external_games_count
+
+    def get_team_officials_by_gameinfo(self, gameinfo_id):
+        gameinfo = Gameinfo.objects.get(pk=gameinfo_id)
+        return self.get_team_officials_by_team_id(gameinfo.officials.pk)
+
+    def get_team_officials_by_team_id(self, team_id):
+        officials = Official.objects.filter(team_id=team_id).order_by('first_name', 'last_name').values(
+            *OfficialTeamListScorecardSerializer.ALL_FIELD_VALUES
+        )
+        return OfficialTeamListScorecardSerializer(instance=officials, many=True).data
+

scorecard2/api/serializers.py

@@ -9,23 +9,39 @@ class ScorecardGameinfoSerializer(Serializer):
     ID_C = 'id'
     FIELD_C = 'field'
     SCHEDULED_C = 'scheduled'
+    STAGE_C = 'stage'
+    STANDING_C = 'standing'
     GAME_FINISHED_C = 'gameFinished'
     OFFICIALS_ID_C = 'officials_id'
     OFFICIALS_DESC_C = 'officials__description'
     HOME_C = 'home'
     AWAY_C = 'away'
 
-    ALL_FIELD_VALUES = [ID_C, FIELD_C, SCHEDULED_C, OFFICIALS_ID_C, OFFICIALS_DESC_C, HOME_C, AWAY_C, GAME_FINISHED_C]
+    ALL_FIELD_VALUES = [ID_C, FIELD_C, SCHEDULED_C, OFFICIALS_ID_C, OFFICIALS_DESC_C, HOME_C, STAGE_C, STANDING_C, AWAY_C, GAME_FINISHED_C]
+    ALL_GAME_OVERVIEW_VALUES = [ID_C, FIELD_C, SCHEDULED_C, OFFICIALS_ID_C, OFFICIALS_DESC_C, HOME_C, AWAY_C, GAME_FINISHED_C]
+    ALL_SETUP_VALUES = [FIELD_C, SCHEDULED_C, HOME_C, STAGE_C, STANDING_C, AWAY_C]
 
     id = IntegerField()
     field = IntegerField()
+    stage = CharField()
+    standing = CharField()
     scheduled = TimeField(format='%H:%M')
     isFinished = SerializerMethodField()
     officialsId = IntegerField(source=OFFICIALS_ID_C)
     officials = CharField(source=OFFICIALS_DESC_C)
     home = CharField()
     away = CharField()
 
+    def __init__(self, *args, **kwargs):
+        fields = kwargs.pop('fields', None)
+        super().__init__(*args, **kwargs)
+
+        if fields:
+            allowed = set(fields)
+            existing = set(self.fields.keys())
+            for field_name in existing - allowed:
+                self.fields.pop(field_name)
+
     def get_isFinished(self, obj: dict) -> bool:
         return obj.get(self.GAME_FINISHED_C) is not None
 
@@ -41,7 +57,7 @@ class ScorecardGamedaySerializer(Serializer):
     id = IntegerField()
     date = DateField(format='%d.%m.%Y')
     name = CharField()
-    games = ScorecardGameinfoSerializer(many=True)
+    games = ScorecardGameinfoSerializer(many=True, fields=ScorecardGameinfoSerializer.ALL_GAME_OVERVIEW_VALUES)
 
 
 class GameOfficialSerializer(ModelSerializer):

scorecard2/api/urls.py

@@ -1,12 +1,12 @@
 from django.urls import path
 
 from scorecard2.api.views import SpecificGamedayAndGamesToOfficiateAPIView, GameOfficialCreateOrUpdateView, \
-    GamedaysAndGamesToOfficiateAPIView, ConfigKickoffGameAPIView
+    GamedaysAndGamesToOfficiateAPIView, GameSetupAPIView
 
 API_SCORECARD_SPECIFIC_GAMEDAY_AND_GAMES_TO_OFFICIATE = 'api-scorecard-specific-gameday-and-games-to-officiate'
 API_SCORECARD_GAMEDAYS_AND_GAMES_TO_OFFICIATE = 'api-scorecard-gamedays-and-games-to-officiate'
 API_SCORECARD_GAME_OFFICIALS = 'api-scorecard-game-officials'
-API_SCORECARD_CONFIG_KICKOFF_GAME = 'api-scorecard-config-kickoff-game'
+API_SCORECARD_GAME_SETUP = 'api-scorecard-game-setup'
 
 urlpatterns = [
     path('gameday/list', GamedaysAndGamesToOfficiateAPIView.as_view(),
@@ -15,5 +15,5 @@
          name=API_SCORECARD_SPECIFIC_GAMEDAY_AND_GAMES_TO_OFFICIATE),
     path('game/<int:pk>/officials', GameOfficialCreateOrUpdateView.as_view(),
          name=API_SCORECARD_GAME_OFFICIALS),
-    path('config/kickoff/game/<int:pk>', ConfigKickoffGameAPIView.as_view(), name=API_SCORECARD_CONFIG_KICKOFF_GAME)
+    path('game/<int:pk>/setup', GameSetupAPIView.as_view(), name=API_SCORECARD_GAME_SETUP)
 ]

scorecard2/api/views.py

@@ -1,14 +1,16 @@
 from http import HTTPStatus
 
+from rest_framework import permissions
 from rest_framework.exceptions import NotFound, PermissionDenied
 from rest_framework.generics import RetrieveUpdateAPIView
 from rest_framework.response import Response
 from rest_framework.views import APIView
 
 from gamedays.models import GameOfficial
 from league_manager.utils.decorators import get_user_request_permission
+from officials.service.official_service import OfficialService
 from scorecard2.api.serializers import GameOfficialSerializer
-from scorecard2.service.scorecard_service import ScorecardGamedayService, ScorecardConfigService
+from scorecard2.service.scorecard_service import ScorecardGamedayService, ScorecardConfigService, ScorecardGameService
 
 
 class SpecificGamedayAndGamesToOfficiateAPIView(APIView):
@@ -58,14 +60,23 @@ def update(self, request, *args, **kwargs):
         return Response(response_data, status=HTTPStatus.OK)
 
 
-class ConfigKickoffGameAPIView(APIView):
+class GameSetupAPIView(APIView):
+    permission_classes = (permissions.IsAuthenticated,)
+
+    @get_user_request_permission
     # noinspection PyMethodMayBeStatic
-    def get(self, **kwargs):
+    def get(self, request, **kwargs):
         gameinfo_id = kwargs.get('pk')
+        user_permission = kwargs.get('user_permission')
         scorecard_config_service = ScorecardConfigService(gameinfo_id)
+        official_service = OfficialService()
+        gameinfo_service = ScorecardGameService(gameinfo_id, user_permission)
         try:
             return Response(
-                scorecard_config_service.get_kickoff_config(),
+                {"scorecard": scorecard_config_service.get_kickoff_config(),
+                 "teamOfficials": official_service.get_team_officials_by_gameinfo(gameinfo_id),
+                 "gameInfo": gameinfo_service.get_game_info(),
+                 },
                 status=HTTPStatus.OK
             )
         except PermissionError as exception:

scorecard2/service/scorecard_service.py

@@ -1,10 +1,12 @@
 import datetime
 
 from django.conf import settings
+from django.db.models import QuerySet
 
 from gamedays.models import Gameday, Team, EmptyTeam, Gameinfo
 from gamedays.service.gameday_service import GamedayService
 from gamedays.service.team_service import TeamService
+from gamedays.service.wrapper.gameinfo_wrapper import GameinfoWrapper
 from league_manager.utils.view_utils import UserRequestPermission
 from scorecard2.api.serializers import ScorecardGameinfoSerializer, ScorecardGamedaySerializer, \
     ScorecardConfigSerializer
@@ -33,7 +35,7 @@ def _merge_gamedays_and_gameinfos(self, gamedays, gameinfo):
         for current_gameday in all_gamdays:
             current_gameday[ScorecardGamedaySerializer.GAMES_C] = list(
                 gameinfo.filter(gameday=current_gameday[ScorecardGamedaySerializer.ID_C]).values(
-                    *ScorecardGameinfoSerializer.ALL_FIELD_VALUES)
+                    *ScorecardGameinfoSerializer.ALL_GAME_OVERVIEW_VALUES)
             )
         return all_gamdays
 
@@ -58,6 +60,18 @@ def _get_gamedays_for_team(self, officiating_team: Team):
         return gamedays
 
 
+class ScorecardGameService:
+    def __init__(self, gameinfo_id: int, user_permission: UserRequestPermission):
+        self.user_permission = user_permission
+        self.gameinfo_wrapper = GameinfoWrapper(gameinfo_id, user_permission)
+
+    def get_game_info(self):
+        gameinfo: QuerySet[Gameinfo] = self.gameinfo_wrapper.get_game_info_with_home_and_away()
+        return ScorecardGameinfoSerializer(
+            instance=gameinfo.values(*ScorecardGameinfoSerializer.ALL_SETUP_VALUES).first(),
+            fields=ScorecardGameinfoSerializer.ALL_SETUP_VALUES).data
+
+
 class ScorecardConfigService:
     def __init__(self, gameinfo_id):
         self.gameinfo_id = gameinfo_id

scorecard2/tests/service/test_scorecard_service.py

@@ -4,7 +4,7 @@
 from gamedays.tests.setup_factories.db_setup import DBSetup
 from league_manager.utils.view_utils import UserRequestPermission
 from scorecard2.api.serializers import ScorecardConfigSerializer
-from scorecard2.service.scorecard_service import ScorecardGamedayService, ScorecardConfigService
+from scorecard2.service.scorecard_service import ScorecardGamedayService, ScorecardConfigService, ScorecardGameService
 from scorecard2.tests.setup_factories.db_setup import DbSetupScorecard
 
 
@@ -84,3 +84,19 @@ def test_get_kickoff_config_success(self):
 
         expected_data = ScorecardConfigSerializer(instance=scorecard_config).data
         self.assertEqual(result, expected_data)
+
+
+class ScorecardGameServiceTest(TestCase):
+    def test_game_info_correct_retrieved(self):
+        DBSetup().g62_status_empty()
+        gameinfo = Gameinfo.objects.first()
+        scorecard_game_service = ScorecardGameService(gameinfo_id=gameinfo.pk,
+                                                      user_permission=UserRequestPermission(is_staff=True))
+        result = scorecard_game_service.get_game_info()
+        assert result == {'field': 1, 'stage': 'Vorrunde', 'standing': 'Gruppe 1', 'scheduled': '10:00',
+                          'home': 'AAAAAAA1', 'away': 'AAAAAAA2'}
+
+    def test_raises_value_error_if_gameinfo_id_not_found(self):
+        with self.assertRaises(ValueError) as error:
+            ScorecardGameService(gameinfo_id=-1, user_permission=UserRequestPermission(is_staff=True))
+        assert str(error.exception) == 'No entry found for game_id: -1'