fix some bugs in player serializer

sepid-org · May 20, 2024 · 60eca7e · 60eca7e
1 parent a6ceaa8
commit 60eca7e
Show file tree

Hide file tree

Showing 4 changed files with 34 additions and 33 deletions.
diff --git a/apps/fsm/serializers/player_serializer.py b/apps/fsm/serializers/player_serializer.py
@@ -13,10 +13,18 @@ class Meta:
 
 
 class PlayerSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Player
+        fields = '__all__'
+        read_only_fields = ['id']
+
+
+class PlayerStateSerializer(serializers.ModelSerializer):
     current_state = StateSerializer()
     team = TeamSerializer()
 
     class Meta:
         model = Player
-        fields = ['id', 'current_state', 'team']
-        read_only_fields = ['id']
+        fields = ['id', 'team', 'current_state']
+        read_only_fields = ['id', 'current_state', 'team']
diff --git a/apps/fsm/views/edge_view.py b/apps/fsm/views/edge_view.py
@@ -12,7 +12,7 @@
 from apps.fsm.models import Edge, FSM, Team
 from apps.fsm.permissions import IsEdgeModifier
 from apps.fsm.serializers.fsm_serializers import EdgeSerializer, KeySerializer, TeamGetSerializer
-from apps.fsm.serializers.player_serializer import PlayerSerializer
+from apps.fsm.serializers.player_serializer import PlayerStateSerializer
 from apps.fsm.utils import get_a_random_player_from_team, get_player, transit_player_in_fsm, transit_team_in_fsm
 
 logger = logging.getLogger(__name__)
@@ -42,7 +42,7 @@ def get_permissions(self):
             permission_classes = [IsEdgeModifier]
         return [permission() for permission in permission_classes]
 
-    @swagger_auto_schema(responses={200: PlayerSerializer}, tags=['player'])
+    @swagger_auto_schema(responses={200: PlayerStateSerializer}, tags=['player'])
     @transaction.atomic
     @action(detail=True, methods=['post'], serializer_class=KeySerializer)
     def transit_player_on_edge(self, request, pk):
@@ -72,18 +72,17 @@ def transit_player_on_edge(self, request, pk):
             if player.current_state == edge.tail:
                 transit_team_in_fsm(team, fsm, edge.tail, edge.head, edge)
                 player = get_a_random_player_from_team(team, fsm)
-            return Response(PlayerSerializer(context=self.get_serializer_context()).to_representation(player),
-                            status=status.HTTP_200_OK)
+            return Response(PlayerStateSerializer(player).data, status=status.HTTP_200_OK)
 
         elif fsm.fsm_p_type == FSM.FSMPType.Individual:
             if player.current_state == edge.tail:
                 player = transit_player_in_fsm(
                     player, edge.tail, edge.head, edge)
 
-            return Response(PlayerSerializer(context=self.get_serializer_context()).to_representation(player),
+            return Response(PlayerStateSerializer(player).data,
                             status=status.HTTP_200_OK)
 
-    @swagger_auto_schema(responses={200: PlayerSerializer}, tags=['mentor'])
+    @swagger_auto_schema(responses={200: PlayerStateSerializer}, tags=['mentor'])
     @transaction.atomic
     @action(detail=True, methods=['post'], serializer_class=TeamGetSerializer)
     def mentor_move_forward(self, request, pk):
@@ -96,5 +95,4 @@ def mentor_move_forward(self, request, pk):
         transit_team_in_fsm(team, fsm, edge.tail, edge.head, edge)
         player = get_a_random_player_from_team(team, fsm)
 
-        return Response(PlayerSerializer(context=self.get_serializer_context()).to_representation(player),
-                        status=status.HTTP_200_OK)
+        return Response(PlayerStateSerializer(player).data, status=status.HTTP_200_OK)
diff --git a/apps/fsm/views/fsm_view.py b/apps/fsm/views/fsm_view.py
@@ -18,7 +18,7 @@
 from apps.fsm.serializers.fsm_serializers import FSMMinimalSerializer, FSMSerializer, KeySerializer, EdgeSerializer, \
     TeamGetSerializer
 from apps.fsm.serializers.paper_serializers import StateSimpleSerializer, EdgeSimpleSerializer
-from apps.fsm.serializers.player_serializer import PlayerSerializer, PlayerHistorySerializer
+from apps.fsm.serializers.player_serializer import PlayerSerializer, PlayerHistorySerializer, PlayerStateSerializer
 from apps.fsm.serializers.widget_serializers import MockWidgetSerializer
 from apps.fsm.serializers.widget_polymorphic import WidgetPolymorphicSerializer
 from apps.fsm.utils import get_player, get_receipt, get_a_player_from_team, _get_fsm_edges
@@ -58,7 +58,7 @@ def get_serializer_context(self):
     @transaction.atomic
     @action(detail=True, methods=['post'], serializer_class=KeySerializer)
     def enter(self, request, pk=None):
-        key = self.request.data.get('key', None)
+        password = self.request.data.get('password', None)
         fsm = self.get_object()
         user = self.request.user
         receipt = get_receipt(user, fsm)
@@ -81,29 +81,27 @@ def enter(self, request, pk=None):
         # first time entering fsm
         if not player:
             if fsm.lock and len(fsm.lock) > 0:
-                if not key:
+                if not password:
                     raise PermissionDenied(serialize_error('4085'))
-                elif key != fsm.lock:
+                elif password != fsm.lock:
                     raise PermissionDenied(serialize_error('4080'))
             serializer = PlayerSerializer(data={'user': user.id, 'fsm': fsm.id, 'receipt': receipt.id,
                                                 'current_state': fsm.first_state.id, 'last_visit': timezone.now()},
                                           context=self.get_serializer_context())
-            if serializer.is_valid(raise_exception=True):
-                player = serializer.save()
-                serializer = PlayerHistorySerializer(data={'player': player.id, 'state': player.current_state.id,
-                                                           'start_time': player.last_visit},
-                                                     context=self.get_serializer_context())
-                if serializer.is_valid(raise_exception=True):
-                    player_history = serializer.save()
+            serializer.is_valid(raise_exception=True)
+            player = serializer.save()
+            serializer = PlayerHistorySerializer(data={'player': player.id, 'state': player.current_state.id,
+                                                       'start_time': player.last_visit}, context=self.get_serializer_context())
+            serializer.is_valid(raise_exception=True)
+            player_history = serializer.save()
 
         else:
             # if any state has been deleted and player has no current state:
             if player.current_state is None:
                 player.current_state = fsm.first_state
                 player.save()
 
-        return Response(PlayerSerializer(context=self.get_serializer_context()).to_representation(player),
-                        status=status.HTTP_200_OK)
+        return Response(PlayerStateSerializer(player).data, status=status.HTTP_200_OK)
 
     @swagger_auto_schema(responses={200: MockWidgetSerializer}, tags=['player', 'fsm'])
     @transaction.atomic

diff --git a/apps/fsm/views/player_view.py b/apps/fsm/views/player_view.py
@@ -14,14 +14,14 @@
 from apps.fsm.permissions import PlayerViewerPermission
 from apps.fsm.models import FSM
 from apps.fsm.serializers.fsm_serializers import KeySerializer, TeamGetSerializer
-from apps.fsm.serializers.player_serializer import PlayerSerializer
+from apps.fsm.serializers.player_serializer import PlayerStateSerializer
 from apps.fsm.utils import get_a_random_player_from_team, get_player_backward_edge, transit_player_in_fsm, transit_team_in_fsm
 
 
 class PlayerViewSet(viewsets.GenericViewSet, RetrieveModelMixin):
     permission_classes = [IsAuthenticated]
     queryset = Player.objects.all()
-    serializer_class = PlayerSerializer
+    serializer_class = PlayerStateSerializer
     my_tags = ['fsm']
 
     def get_permissions(self):
@@ -40,7 +40,7 @@ def get_serializer_context(self):
     def retrieve(self, request, *args, **kwargs):
         return super(PlayerViewSet, self).retrieve(request, *args, **kwargs)
 
-    @swagger_auto_schema(responses={200: PlayerSerializer}, tags=['player'])
+    @swagger_auto_schema(responses={200: PlayerStateSerializer}, tags=['player'])
     @transaction.atomic
     @action(detail=True, methods=['post'], serializer_class=KeySerializer)
     def go_backward(self, request, pk):
@@ -63,20 +63,18 @@ def go_backward(self, request, pk):
             if player.current_state == edge.head:
                 transit_team_in_fsm(team, fsm, edge.head, edge.tail, edge)
                 player = get_a_random_player_from_team(team, fsm)
-            return Response(PlayerSerializer(context=self.get_serializer_context()).to_representation(player),
-                            status=status.HTTP_200_OK)
+            return Response(PlayerStateSerializer(player).data, status=status.HTTP_200_OK)
 
         elif fsm.fsm_p_type == FSM.FSMPType.Individual:
             if player.current_state == edge.head:
                 player = transit_player_in_fsm(
                     player, edge.head, edge.tail, edge)
-            return Response(PlayerSerializer(context=self.get_serializer_context()).to_representation(player),
-                            status=status.HTTP_200_OK)
+            return Response(PlayerStateSerializer(player).data, status=status.HTTP_200_OK)
 
         else:
             raise InternalServerError('Not implemented Yet😎')
 
-    @swagger_auto_schema(responses={200: PlayerSerializer}, tags=['mentor'])
+    @swagger_auto_schema(responses={200: PlayerStateSerializer}, tags=['mentor'])
     @transaction.atomic
     @action(detail=True, methods=['post'], serializer_class=TeamGetSerializer)
     def mentor_move_backward(self, request, pk):
@@ -92,8 +90,7 @@ def mentor_move_backward(self, request, pk):
         if fsm.fsm_p_type == FSM.FSMPType.Team:
             transit_team_in_fsm(team, fsm, edge.head, edge.tail, edge)
             player = get_a_random_player_from_team(team, fsm)
-            return Response(PlayerSerializer(context=self.get_serializer_context()).to_representation(player),
-                            status=status.HTTP_200_OK)
+            return Response(PlayerStateSerializer(player).data, status=status.HTTP_200_OK)
 
         else:
             raise InternalServerError('Not implemented Yet😎')