Skip to content

armgit / wger

Public Imported from GitHub
0

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.py
index 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 = WorkoutLog
diff --git a/wger/manager/api/views.py b/wger/manager/api/views.py
index 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.py
index 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 cache
reset_workout_log_cache(
diff --git a/wger/manager/powersync.py b/wger/manager/powersync.py
index 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.py
index 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_session
log.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.py
new file mode 100644
index 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.py
index 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.py
index c694c55c8..159ba78f0 100644
--- a/wger/nutrition/powersync.py
+++ b/wger/nutrition/powersync.py
@@ -19,7 +19,9 @@ from typing import Any
# wger
from wger.nutrition.api.serializers import NutritionPlanSerializer
+from wger.nutrition.api.views import NutritionPlanViewSet
from wger.nutrition.models import NutritionPlan
+from wger.utils.viewsets import check_fk_ownership
logger = 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 diary
log entries in the same transaction.