Ks 2023 01 several tokens in session

meinberlin/apps/budgeting/api.py

@@ -106,7 +106,8 @@ def list(self, request, *args, **kwargs):
         # only show during voting phase and when token is entered
         if (
             has_feature_active(self.module, Proposal, "vote")
-            and "voting_token" in request.session
+            and "voting_tokens" in request.session
+            and str(self.module.id) in request.session["voting_tokens"]
         ):
             filters["own_votes"] = {
                 "label": _("Voting"),

meinberlin/apps/budgeting/serializers.py

@@ -85,23 +85,29 @@ def get_session_token_voted(self, proposal):
         been voted with the token in the current session
         """
         if "request" in self.context:
-            if "voting_token" in self.context["request"].session:
-                token = None
-                try:
-                    token = VotingToken.objects.get(
-                        token=self.context["request"].session["voting_token"],
-                        module=self.context["view"].module,
+            if "voting_tokens" in self.context["request"].session:
+                module = self.context["view"].module
+                module_key = str(module.id)
+                if module_key in self.context["request"].session["voting_tokens"]:
+                    token = None
+                    try:
+                        token = VotingToken.objects.get(
+                            token=self.context["request"].session["voting_tokens"][
+                                module_key
+                            ],
+                            module=module,
+                        )
+                    except VotingToken.DoesNotExist:
+                        pass
+
+                    vote = TokenVote.objects.filter(
+                        token=token,
+                        content_type=ContentType.objects.get_for_model(
+                            proposal.__class__
+                        ),
+                        object_pk=proposal.pk,
                     )
-                except VotingToken.DoesNotExist:
-                    pass
-
-                vote = TokenVote.objects.filter(
-                    token=token,
-                    content_type=ContentType.objects.get_for_model(proposal.__class__),
-                    object_pk=proposal.pk,
-                )
-                if vote.exists():
-                    return True
+                    return vote.exists()
 
         return False
 

meinberlin/apps/budgeting/templatetags/react_proposals_vote.py

@@ -25,18 +25,21 @@ def react_proposals_vote(context, module, proposal):
     request = context["request"]
     session_token_voted = False
     token_info = None
-    if "voting_token" in request.session:
-        try:
-            token = VotingToken.objects.get(
-                token=request.session["voting_token"], module=module
-            )
-            serializer = VotingTokenSerializer(token)
-            token_info = serializer.data
-            session_token_voted = TokenVote.objects.filter(
-                token__pk=token.pk, content_type=proposal_ct, object_pk=proposal.pk
-            ).exists()
-        except VotingToken.DoesNotExist:
-            pass
+
+    if "voting_tokens" in request.session:
+        module_key = str(module.id)
+        if module_key in request.session["voting_tokens"]:
+            try:
+                token = VotingToken.objects.get(
+                    token=request.session["voting_tokens"][module_key], module=module
+                )
+                serializer = VotingTokenSerializer(token)
+                token_info = serializer.data
+                session_token_voted = TokenVote.objects.filter(
+                    token__pk=token.pk, content_type=proposal_ct, object_pk=proposal.pk
+                ).exists()
+            except VotingToken.DoesNotExist:
+                pass
 
     attributes = {
         "tokenvote_api_url": tokenvote_api_url,

meinberlin/apps/budgeting/views.py

@@ -69,11 +69,14 @@ def has_valid_token_in_session(self, request):
 
         The token is valid if it is valid for the respective module.
         """
-        if "voting_token" in request.session:
-            token_queryset = VotingToken.objects.filter(
-                token=request.session["voting_token"], module=self.module
-            )
-            return token_queryset.exists()
+        if "voting_tokens" in request.session:
+            module_key = str(self.module.id)
+            if module_key in request.session["voting_tokens"]:
+                token_queryset = VotingToken.objects.filter(
+                    token=request.session["voting_tokens"][module_key],
+                    module=self.module,
+                )
+                return token_queryset.exists()
         return False
 
     def dispatch(self, request, **kwargs):
@@ -96,7 +99,15 @@ def post(self, request, *args, **kwargs):
         self.object_list = self.get_queryset()
         token_form = TokenForm(request.POST, module_id=self.module.id)
         if token_form.is_valid():
-            request.session["voting_token"] = token_form.cleaned_data["token"]
+            if "voting_tokens" in request.session:
+                request.session["voting_tokens"][
+                    str(self.module.id)
+                ] = token_form.cleaned_data["token"]
+                request.session.save()
+            else:
+                request.session["voting_tokens"] = {
+                    str(self.module.id): token_form.cleaned_data["token"]
+                }
             kwargs["valid_token_present"] = True
             self.mode = "list"
         kwargs["token_form"] = token_form

meinberlin/apps/votes/api.py

@@ -1,6 +1,4 @@
 from django.contrib.contenttypes.models import ContentType
-from django.contrib.sessions.models import Session
-from django.core.exceptions import ObjectDoesNotExist
 from django.http import Http404
 from django.shortcuts import get_object_or_404
 from django.utils.translation import gettext_lazy as _
@@ -30,15 +28,18 @@ class VotingTokenInfoMixin:
     def list(self, request, *args, **kwargs):
         response = super().list(request, args, kwargs)
         token_info = None
-        if "voting_token" in request.session:
-            try:
-                token = VotingToken.objects.get(
-                    token=request.session["voting_token"], module=self.module
-                )
-                serializer = VotingTokenSerializer(token)
-                token_info = serializer.data
-            except VotingToken.DoesNotExist:
-                pass
+        if "voting_tokens" in request.session:
+            module_key = str(self.module.id)
+            if module_key in request.session["voting_tokens"]:
+                try:
+                    token = VotingToken.objects.get(
+                        token=request.session["voting_tokens"][module_key],
+                        module=self.module,
+                    )
+                    serializer = VotingTokenSerializer(token)
+                    token_info = serializer.data
+                except VotingToken.DoesNotExist:
+                    pass
 
         response.data["token_info"] = token_info
         return response
@@ -53,16 +54,16 @@ class TokenVoteMixin:
     def dispatch(self, request, *args, **kwargs):
         self.module_pk = kwargs.get("module_pk", "")
         self.content_type_id = kwargs.get("content_type", "")
-        try:
-            session = Session.objects.get(pk=request.session.session_key)
-            self.token = VotingToken.objects.get(
-                token=session.get_decoded()["voting_token"], module=self.module
-            )
-        except ObjectDoesNotExist:
-            pass
-
-        except KeyError:
-            pass
+        if "voting_tokens" in request.session:
+            module_key = str(self.module.id)
+            if module_key in request.session["voting_tokens"]:
+                try:
+                    self.token = VotingToken.objects.get(
+                        token=request.session["voting_tokens"][module_key],
+                        module=self.module,
+                    )
+                except VotingToken.DoesNotExist:
+                    pass
 
         return super().dispatch(request, *args, **kwargs)
 

meinberlin/apps/votes/filters.py

@@ -9,25 +9,23 @@ class OwnVotesFilterBackend(BaseFilterBackend):
 
     def filter_queryset(self, request, queryset, view):
 
-        if 'own_votes' in request.GET:
-            own_votes = request.GET['own_votes']
+        if "own_votes" in request.GET:
+            own_votes = request.GET["own_votes"]
             if own_votes:
-                if 'voting_token' in request.session:
-                    token = None
-                    try:
-                        token = VotingToken.objects.get(
-                            token=request.session['voting_token'],
-                            module=view.module
-                        )
-                    except VotingToken.DoesNotExist:
-                        pass
+                if "voting_tokens" in request.session:
+                    module_key = str(view.module.id)
+                    if module_key in request.session["voting_tokens"]:
+                        token = None
+                        try:
+                            token = VotingToken.objects.get(
+                                token=request.session["voting_tokens"][module_key],
+                                module=view.module,
+                            )
+                        except VotingToken.DoesNotExist:
+                            pass
 
-                    if token:
-                        own_votes = TokenVote.objects.filter(
-                            token=token
-                        )
-                        return queryset.filter(
-                            id__in=own_votes.values("object_pk")
-                        )
+                        if token:
+                            own_votes = TokenVote.objects.filter(token=token)
+                            return queryset.filter(id__in=own_votes.values("object_pk"))
                 return queryset.none()
         return queryset

tests/budgeting/test_proposals_api.py

@@ -16,7 +16,7 @@ def test_proposal_list_mixins(
         phase_factory, proposal_factory, phases.SupportPhase
     )
     token = voting_token_factory(module=module)
-    add_token_to_session(apiclient, token)
+    add_token_to_session(apiclient.session, token)
 
     url = reverse("proposals-list", kwargs={"module_pk": module.pk})
 

tests/budgeting/test_proposals_api_filtering.py

@@ -52,7 +52,7 @@ def test_proposal_list_filter_mixin(
 
     url = reverse("proposals-list", kwargs={"module_pk": module.pk})
     token = voting_token_factory(module=module)
-    add_token_to_session(apiclient, token)
+    add_token_to_session(apiclient.session, token)
 
     response = apiclient.get(url)
 
@@ -323,7 +323,7 @@ def test_proposal_own_vote_filter(
     apiclient, module, proposal_factory, voting_token_factory, token_vote_factory
 ):
     token = voting_token_factory(module=module)
-    add_token_to_session(apiclient, token)
+    add_token_to_session(apiclient.session, token)
     other_token = voting_token_factory(module=module)
 
     proposal_factory(module=module)

tests/budgeting/test_proposals_serializer.py

@@ -25,7 +25,7 @@ def test_proposal_serializer(
 
     url = reverse("proposals-list", kwargs={"module_pk": module.pk})
     token = voting_token_factory(module=module)
-    add_token_to_session(apiclient, token)
+    add_token_to_session(apiclient.session, token)
 
     proposal_rated = proposal_factory(
         module=module, category=category, budget=25, point_label=""

tests/budgeting/test_proposals_templatetags.py

@@ -13,6 +13,7 @@
 from adhocracy4.test.helpers import setup_phase
 from meinberlin.apps.budgeting import phases
 from meinberlin.apps.budgeting.models import Proposal
+from tests.votes.test_token_vote_api import add_token_to_session
 
 
 @pytest.mark.django_db
@@ -79,8 +80,7 @@ def test_react_proposals_vote(
         }
 
     token = voting_token_factory(module=module)
-    request.session["voting_token"] = token.token
-    request.session.save()
+    add_token_to_session(request.session, token)
     token_vote_factory(token=token, content_object=proposal)
 
     with freeze_phase(phase):

tests/budgeting/test_views_integration.py

@@ -75,7 +75,7 @@ def test_list_view_token_form(
 
         response = client.post(url, data)
         assert response.status_code == 200
-        assert "voting_token" in client.session
+        assert "voting_tokens" in client.session
         assert "token_form" in response.context
 
     other_module = module_factory()
@@ -95,7 +95,7 @@ def test_list_view_token_form(
         assert "token" in response.context_data["token_form"].errors
         msg = _("This token is not valid")
         assert msg in response.context_data["token_form"].errors["token"]
-        assert "voting_token" not in client.session
+        assert "voting_tokens" not in client.session
 
 
 @pytest.mark.django_db