Self hosted FLOSS fitness/workout, nutrition and weight tracker
Refactor use gating in WorkoutLogs
Roland Geider3255a684a6ac
diff --git a/wger/manager/api/serializers.py b/wger/manager/api/serializers.pyindex f1d597e50..4134057c1 100644--- a/wger/manager/api/serializers.py+++ b/wger/manager/api/serializers.py@@ -420,12 +420,35 @@ class WorkoutSessionSerializer(serializers.ModelSerializer):)+class OwnerScopedSessionField(serializers.PrimaryKeyRelatedField):+ """+ A writeable session FK that only resolves UUIDs of sessions owned by the+ current user.++ If neither the request or an explicit context is available (e.g. a serializer+ instantiated for read-only display without a user context), the queryset+ becomes empty so that no FK can be set; reads continue to work because+ ``PrimaryKeyRelatedField`` only consults the queryset on write.+ """++ def get_queryset(self):+ user_id = self.context.get('user_id')+ if user_id is None:+ request = self.context.get('request')+ user = getattr(request, 'user', None) if request else None+ if user is not None and user.is_authenticated:+ user_id = user.pk+ if user_id is None:+ return WorkoutSession.objects.none()+ return WorkoutSession.objects.filter(user_id=user_id)++class WorkoutLogSerializer(serializers.ModelSerializer):"""- Workout session serializer+ Workout log serializer"""- session = serializers.PrimaryKeyRelatedField(read_only=True)+ session = OwnerScopedSessionField(required=False, allow_null=True)class Meta:model = WorkoutLogdiff --git a/wger/manager/api/views.py b/wger/manager/api/views.pyindex 17ac077dd..eb4ee04c3 100644--- a/wger/manager/api/views.py+++ b/wger/manager/api/views.py@@ -199,6 +199,10 @@ class RoutineViewSet(viewsets.ModelViewSet):return Response(out)+ @staticmethod+ def get_owner_objects():+ return []+class UserRoutineTemplateViewSet(viewsets.ReadOnlyModelViewSet):"""diff --git a/wger/manager/models/log.py b/wger/manager/models/log.pyindex 2542a164e..64acbc4bc 100644--- a/wger/manager/models/log.py+++ b/wger/manager/models/log.py@@ -264,12 +264,20 @@ class WorkoutLog(models.Model):if self.routine and self.routine.user != self.user:return- # If there is no session for this date and routine, create one- self.session = WorkoutSession.objects.get_or_create(- user=self.user,- date=self.date,- routine=self.routine,- )[0]+ # If a session was explicitly provided but belongs to a different+ # user, drop the reference so we don't accidentally tie this log+ # to someone else's session. The auto-create branch below will+ # then provide the correct one.+ if self.session_id and self.session.user_id != self.user_id:+ self.session = None++ # Auto-create a session only if the client didn't provide one.+ if not self.session_id:+ self.session = WorkoutSession.objects.get_or_create(+ user=self.user,+ date=self.date,+ routine=self.routine,+ )[0]# Reset cachereset_workout_log_cache(diff --git a/wger/manager/powersync.py b/wger/manager/powersync.pyindex 8bda972cf..eb06a3507 100644--- a/wger/manager/powersync.py+++ b/wger/manager/powersync.py@@ -24,6 +24,7 @@ from wger.manager.api.serializers import (WorkoutSessionSerializer,)from wger.manager.api.views import (+ RoutineViewSet,WorkoutLogViewSet,WorkoutSessionViewSet,)@@ -52,7 +53,9 @@ def handle_update_log(payload: dict[str, Any], user_id: int) -> dict | None:if not check_fk_ownership(payload, WorkoutLogViewSet.get_owner_objects(), user_id):return {'error': 'Forbidden', 'details': 'WorkoutLog references an object you do not own'}- serializer = WorkoutLogSerializer(entry, data=payload, partial=True)+ serializer = WorkoutLogSerializer(+ entry, data=payload, partial=True, context={'user_id': user_id}+ )if serializer.is_valid():serializer.save()logger.info(f'Updated WorkoutLog {entry.pk} for user {user_id}')@@ -68,7 +71,7 @@ def handle_create_log(payload: dict[str, Any], user_id: int) -> dict | None:if not check_fk_ownership(payload, WorkoutLogViewSet.get_owner_objects(), user_id):return {'error': 'Forbidden', 'details': 'WorkoutLog references an object you do not own'}- serializer = WorkoutLogSerializer(data=payload)+ serializer = WorkoutLogSerializer(data=payload, context={'user_id': user_id})if serializer.is_valid():serializer.save(user_id=user_id)return None@@ -169,6 +172,9 @@ def handle_update_routine(payload: dict[str, Any], user_id: int) -> dict | None:'details': f'Routine with id {payload["id"]} not found',}+ if not check_fk_ownership(payload, RoutineViewSet.get_owner_objects(), user_id):+ return {'error': 'Forbidden', 'details': 'Routine references an object you do not own'}+serializer = RoutineSerializer(entry, data=payload, partial=True)if serializer.is_valid():serializer.save()diff --git a/wger/manager/tests/test_log_model.py b/wger/manager/tests/test_log_model.pyindex 3c07644f7..fa8f3b328 100644--- a/wger/manager/tests/test_log_model.py+++ b/wger/manager/tests/test_log_model.py@@ -50,33 +50,67 @@ class LogModelTestCase(WgerTestCase):self.assertEqual(WorkoutSession.objects.count(), 1)- def test_dont_create_session(self):+ def test_dont_create_session_when_already_set(self):"""- Test that no session is created if the log already has one+ If the log already has a (valid, own) session, the auto-create magic must+ not run and no extra session must be created."""- self.assertEqual(WorkoutSession.objects.count(), 5)+ initial_count = WorkoutSession.objects.count()+ self.assertEqual(initial_count, 5)log = WorkoutLog.objects.get(pk='aaaaaaaa-aaaa-aaaa-aaaa-000000000001')- log.session_id = 'bbbbbbbb-bbbb-bbbb-bbbb-000000000001'+ target = WorkoutSession.objects.get(pk='bbbbbbbb-bbbb-bbbb-bbbb-000000000002')+ self.assertEqual(log.user_id, target.user_id)+ self.assertNotEqual(log.date.date(), target.date)- self.assertEqual(WorkoutSession.objects.count(), 5)+ log.session = target+ log.save()++ log.refresh_from_db()+ self.assertEqual(str(log.session_id), 'bbbbbbbb-bbbb-bbbb-bbbb-000000000002')+ self.assertEqual(WorkoutSession.objects.count(), initial_count)++ def test_keep_explicit_own_session(self):+ """+ When the client provides an explicit, matching session, save() must not+ replace it with a freshly created one.+ """++ log = WorkoutLog.objects.get(pk='aaaaaaaa-aaaa-aaaa-aaaa-000000000001')+ own_session = WorkoutSession.objects.get(pk='bbbbbbbb-bbbb-bbbb-bbbb-000000000001')++ log.session = own_session+ log.weight = 99 # force a change+ log.save()++ log.refresh_from_db()+ self.assertEqual(str(log.session_id), 'bbbbbbbb-bbbb-bbbb-bbbb-000000000001')def test_session_ownership(self):"""- Test that the session foreign key checks ownership+ A log must never end up attached to another user's session, even if the+ caller tries to set ``log.session`` to a foreign one."""- session1 = WorkoutSession.objects.get(pk='bbbbbbbb-bbbb-bbbb-bbbb-000000000001')- session5 = WorkoutSession.objects.get(pk='bbbbbbbb-bbbb-bbbb-bbbb-000000000005')- self.assertEqual(session1.user_id, 1)- self.assertEqual(session5.user_id, 2)+ own_session = WorkoutSession.objects.get(pk='bbbbbbbb-bbbb-bbbb-bbbb-000000000001')+ foreign_session = WorkoutSession.objects.get(pk='bbbbbbbb-bbbb-bbbb-bbbb-000000000005')++ self.assertEqual(own_session.user_id, 1)+ self.assertEqual(foreign_session.user_id, 2)log = WorkoutLog.objects.get(pk='aaaaaaaa-aaaa-aaaa-aaaa-000000000001')- log.session = session5+ self.assertEqual(log.user_id, 1)++ log.session = foreign_sessionlog.save()- self.assertNotEqual(log.session_id, 4)+ log.refresh_from_db()+ self.assertNotEqual(log.session_id, foreign_session.pk)++ # Whatever session was assigned by the auto-create fallback must belong+ # to the same user as the log.+ self.assertEqual(log.session.user_id, log.user_id)def test_routine_ownership(self):"""diff --git a/wger/manager/tests/test_log_session_api.py b/wger/manager/tests/test_log_session_api.pynew file mode 100644index 000000000..d6e6bcd7d--- /dev/null+++ b/wger/manager/tests/test_log_session_api.py@@ -0,0 +1,281 @@+# This file is part of wger Workout Manager.+#+# wger Workout Manager is free software: you can redistribute it and/or modify+# it under the terms of the GNU Affero General Public License as published by+# the Free Software Foundation, either version 3 of the License, or+# (at your option) any later version.+#+# wger Workout Manager is distributed in the hope that it will be useful,+# but WITHOUT ANY WARRANTY; without even the implied warranty of+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the+# GNU General Public License for more details.+#+# You should have received a copy of the GNU Affero General Public License++# Standard Library+import datetime++# Django+from django.urls import reverse++# Third Party+from rest_framework import status++# wger+from wger.core.tests.base_testcase import WgerTestCase+from wger.manager.models import (+ WorkoutLog,+ WorkoutSession,+)+from wger.manager.powersync import (+ handle_create_log,+ handle_update_log,+)++++OWN_SESSION = 'bbbbbbbb-bbbb-bbbb-bbbb-000000000001'+OWN_SESSION_OTHER_DATE = 'bbbbbbbb-bbbb-bbbb-bbbb-000000000002'+FOREIGN_SESSION = 'bbbbbbbb-bbbb-bbbb-bbbb-000000000005'+OWN_LOG = 'aaaaaaaa-aaaa-aaaa-aaaa-000000000001'+++class WorkoutLogSessionPinningRESTTestCase(WgerTestCase):+ """+ REST-API tests around pinning a log to an explicit session.++ The serializer must accept a writeable ``session`` field so that+ PowerSync (and any other client that owns the session UUID locally)+ can keep its log attached to the session it created. Foreign+ sessions must always be rejected at the viewset layer with a 403.++ Fixture references+ Users:+ 1 = admin (own logs, own sessions, owns routine 1)+ 2 = test (foreign logs/sessions, owns routines 2/3)+ Sessions:+ bbbb…001 -> user=1, routine=1, date=2025-10-01+ bbbb…002 -> user=1, routine=1, date=2025-01-20+ bbbb…005 -> user=2, routine=3, date=2025-11-01+ Logs:+ aaaa…001 -> user=1, routine=1, session=bbbb…001+ """++ def setUp(self):+ super().setUp()+ self.user_login('admin')+++ def test_create_log_with_explicit_own_session(self):+ """POST with an own session UUID pins the log to that session."""++ response = self.client.post(+ reverse('workoutlog-list'),+ data={+ 'exercise': 1,+ 'routine': 1,+ 'session': OWN_SESSION_OTHER_DATE,+ 'date': datetime.date(2025, 10, 1).isoformat(),+ 'weight': 30,+ 'repetitions': 8,+ },+ )+ self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.content)++ log = WorkoutLog.objects.get(pk=response.json()['id'])+ # The explicit session must have been kept+ self.assertEqual(str(log.session_id), OWN_SESSION_OTHER_DATE)++ def test_create_log_with_foreign_session_rejected(self):+ """POST with a foreign session id must return 403 PermissionDenied."""++ before = WorkoutLog.objects.count()+ response = self.client.post(+ reverse('workoutlog-list'),+ data={+ 'exercise': 1,+ 'routine': 1,+ 'session': FOREIGN_SESSION,+ 'date': datetime.date(2025, 10, 1).isoformat(),+ 'weight': 30,+ 'repetitions': 8,+ },+ )+ self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)+ self.assertEqual(WorkoutLog.objects.count(), before)++ def test_create_log_without_session_auto_creates(self):+ """POST without a session falls back to the legacy auto-create."""++ new_date = datetime.date(2030, 6, 15)+ before = WorkoutSession.objects.filter(+ user_id=1, routine_id=1, date=new_date+ ).count()+ self.assertEqual(before, 0)++ response = self.client.post(+ reverse('workoutlog-list'),+ data={+ 'exercise': 1,+ 'routine': 1,+ 'date': new_date.isoformat(),+ 'weight': 30,+ 'repetitions': 8,+ },+ )+ self.assertEqual(response.status_code, status.HTTP_201_CREATED, response.content)++ log = WorkoutLog.objects.get(pk=response.json()['id'])+ self.assertIsNotNone(log.session_id)+ self.assertEqual(log.session.user_id, 1)+ self.assertEqual(log.session.date, new_date)++ def test_patch_log_with_foreign_session_rejected(self):+ """PATCH that tries to move a log onto a foreign session returns 403."""++ response = self.client.patch(+ reverse('workoutlog-detail', kwargs={'pk': OWN_LOG}),+ data={'session': FOREIGN_SESSION},+ content_type='application/json',+ )+ self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)++ log = WorkoutLog.objects.get(pk=OWN_LOG)+ # The original session must still be in place.+ self.assertEqual(str(log.session_id), OWN_SESSION)++ def test_patch_log_with_own_session_pins(self):+ """PATCH with an own session id repoints the log."""+ response = self.client.patch(+ reverse('workoutlog-detail', kwargs={'pk': OWN_LOG}),+ data={'session': OWN_SESSION_OTHER_DATE},+ content_type='application/json',+ )+ self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)++ log = WorkoutLog.objects.get(pk=OWN_LOG)+ self.assertEqual(str(log.session_id), OWN_SESSION_OTHER_DATE)+++class WorkoutLogSessionPinningPowerSyncTestCase(WgerTestCase):+ """+ Same scenarios, but exercising the PowerSync upload handlers directly.+ """++ def test_create_log_with_explicit_own_session(self):+ before = WorkoutLog.objects.filter(session_id=OWN_SESSION_OTHER_DATE).count()+ result = handle_create_log(+ {+ 'exercise': 1,+ 'routine': 1,+ 'session': OWN_SESSION_OTHER_DATE,+ 'date': datetime.date(2025, 10, 1).isoformat(),+ 'weight': 30,+ 'repetitions': 8,+ },+ user_id=1,+ )+ self.assertIsNone(result)+ after = WorkoutLog.objects.filter(session_id=OWN_SESSION_OTHER_DATE).count()+ self.assertEqual(after, before + 1)++ def test_create_log_with_foreign_session_returns_forbidden(self):+ before = WorkoutLog.objects.count()+ result = handle_create_log(+ {+ 'exercise': 1,+ 'routine': 1,+ 'session': FOREIGN_SESSION,+ 'date': datetime.date(2025, 10, 1).isoformat(),+ 'weight': 30,+ 'repetitions': 8,+ },+ user_id=1,+ )+ self.assertIsNotNone(result)+ self.assertEqual(result.get('error'), 'Forbidden')+ self.assertEqual(WorkoutLog.objects.count(), before)++ def test_update_log_with_foreign_session_returns_forbidden(self):+ result = handle_update_log(+ {'id': OWN_LOG, 'session': FOREIGN_SESSION},+ user_id=1,+ )+ self.assertIsNotNone(result)+ self.assertEqual(result.get('error'), 'Forbidden')++ log = WorkoutLog.objects.get(pk=OWN_LOG)+ self.assertEqual(str(log.session_id), OWN_SESSION)++ def test_update_log_pins_own_session(self):+ result = handle_update_log(+ {'id': OWN_LOG, 'session': OWN_SESSION_OTHER_DATE},+ user_id=1,+ )+ self.assertIsNone(result)++ log = WorkoutLog.objects.get(pk=OWN_LOG)+ self.assertEqual(str(log.session_id), OWN_SESSION_OTHER_DATE)+++class WorkoutLogSerializerSessionFilterTestCase(WgerTestCase):+ """+ Unit tests for ``OwnerScopedSessionField`` — the dynamic queryset on+ ``WorkoutLogSerializer.session`` must reject foreign sessions even+ when the upstream ``check_fk_ownership`` layer is not used.+ """++ def test_serializer_rejects_foreign_session_via_user_id_context(self):+ from wger.manager.api.serializers import WorkoutLogSerializer++ serializer = WorkoutLogSerializer(+ data={+ 'exercise': 1,+ 'routine': 1,+ 'session': FOREIGN_SESSION,+ 'date': datetime.date(2025, 10, 1).isoformat(),+ 'weight': 30,+ 'repetitions': 8,+ },+ context={'user_id': 1},+ )+ self.assertFalse(serializer.is_valid())+ self.assertIn('session', serializer.errors)++ def test_serializer_accepts_own_session_via_user_id_context(self):+ from wger.manager.api.serializers import WorkoutLogSerializer++ serializer = WorkoutLogSerializer(+ data={+ 'exercise': 1,+ 'routine': 1,+ 'session': OWN_SESSION,+ 'date': datetime.date(2025, 10, 1).isoformat(),+ 'weight': 30,+ 'repetitions': 8,+ },+ context={'user_id': 1},+ )+ self.assertTrue(serializer.is_valid(), serializer.errors)+ self.assertEqual(str(serializer.validated_data['session'].pk), OWN_SESSION)++ def test_serializer_without_context_has_empty_session_queryset(self):+ """+ A serializer instantiated without any user context must not be+ able to resolve any session UUID — the queryset is empty by+ default, so the call falls through to a validation error.+ """+ from wger.manager.api.serializers import WorkoutLogSerializer++ serializer = WorkoutLogSerializer(+ data={+ 'exercise': 1,+ 'routine': 1,+ 'session': OWN_SESSION,+ 'date': datetime.date(2025, 10, 1).isoformat(),+ 'weight': 30,+ 'repetitions': 8,+ },+ )+ self.assertFalse(serializer.is_valid())+ self.assertIn('session', serializer.errors)diff --git a/wger/nutrition/api/views.py b/wger/nutrition/api/views.pyindex b61d44624..d06282eb1 100644--- a/wger/nutrition/api/views.py+++ b/wger/nutrition/api/views.py@@ -229,6 +229,10 @@ class NutritionPlanViewSet(viewsets.ModelViewSet):)return Response(serializer.data)+ @staticmethod+ def get_owner_objects():+ return []+class NutritionPlanInfoViewSet(NutritionPlanViewSet):"""diff --git a/wger/nutrition/powersync.py b/wger/nutrition/powersync.pyindex c694c55c8..159ba78f0 100644--- a/wger/nutrition/powersync.py+++ b/wger/nutrition/powersync.py@@ -19,7 +19,9 @@ from typing import Any# wgerfrom wger.nutrition.api.serializers import NutritionPlanSerializer+from wger.nutrition.api.views import NutritionPlanViewSetfrom wger.nutrition.models import NutritionPlan+from wger.utils.viewsets import check_fk_ownershiplogger = logging.getLogger(__name__)@@ -44,6 +46,9 @@ def handle_update_plan(payload: dict[str, Any], user_id: int) -> dict | None:'details': f'NutritionPlan with id {payload["id"]} not found',}+ if not check_fk_ownership(payload, NutritionPlanViewSet.get_owner_objects(), user_id):+ return {'error': 'Forbidden', 'details': 'NutritionPlan references an object you do not own'}+serializer = NutritionPlanSerializer(entry, data=payload, partial=True)if serializer.is_valid():serializer.save()@@ -54,7 +59,8 @@ def handle_update_plan(payload: dict[str, Any], user_id: int) -> dict | None:def handle_delete_plan(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync DELETE event for a nutritional plan.+ """+ Handle a PowerSync DELETE event for a nutritional plan.Django's FK CASCADE removes all dependent meals, meal items and diarylog entries in the same transaction.