Self hosted FLOSS fitness/workout, nutrition and weight tracker
Make the maximum session length configurable and enforce it
Roland Geider6fd191e851f8
diff --git a/settings/main.py b/settings/main.pyindex 6a2d34508..85828dd11 100644--- a/settings/main.py+++ b/settings/main.py@@ -192,6 +192,7 @@ WGER_SETTINGS['CACHE_API_EXERCISES_CELERY'] = env.bool('CACHE_API_EXERCISES_CELEWGER_SETTINGS['CACHE_API_EXERCISES_CELERY_FORCE_UPDATE'] = env.bool('CACHE_API_EXERCISES_CELERY_FORCE_UPDATE', False)+WGER_MAX_SESSION_LENGTH_HOURS = env.int('WGER_MAX_SESSION_LENGTH_HOURS', 5)## Auth Proxy Authenticationdiff --git a/settings/settings_global.py b/settings/settings_global.pyindex cd508d969..9daeec1af 100644--- a/settings/settings_global.py+++ b/settings/settings_global.py@@ -594,6 +594,12 @@ WGER_SETTINGS = {'TROPHIES_INACTIVE_USER_DAYS': 30, # Days of inactivity before skipping trophy evaluation}+#+# How long a workout session may last. Doubles as the window in which a log+# without a session is attached to an open one instead of starting a new one.+WGER_MAX_SESSION_LENGTH_HOURS = 5++## Social authentication / OAuth# List of allauth provider IDs to load, e.g. ['google', 'github', 'gitlab'].diff --git a/wger/manager/api/serializers.py b/wger/manager/api/serializers.pyindex 41faaa7ee..9edf12a5e 100644--- a/wger/manager/api/serializers.py+++ b/wger/manager/api/serializers.py@@ -17,6 +17,7 @@import datetime# Django+from django.core.exceptions import ValidationError as DjangoValidationErrorfrom django.utils import timezone# Third Party@@ -469,6 +470,31 @@ class WorkoutSessionSerializer(serializers.ModelSerializer):def _local_start(obj: WorkoutSession) -> datetime.datetime | None:return timezone.localtime(obj.datetime_start) if obj.datetime_start else None+ def validate(self, attrs):+ """+ Run the model validation on the interval the request would end up with++ Sessions stored before the limit was introduced, or before it was lowered,+ stay editable as long as the request leaves their times alone.+ """+ start = attrs.get('datetime_start')+ end = attrs.get('datetime_end') if 'datetime_end' in attrs else None+ if self.instance:+ start = start or self.instance.datetime_start+ if 'datetime_end' not in attrs:+ end = self.instance.datetime_end+ if (start, end) == (self.instance.datetime_start, self.instance.datetime_end):+ return attrs+ else:+ start = start or timezone.now()++ try:+ WorkoutSession(datetime_start=start, datetime_end=end).clean()+ except DjangoValidationError as e:+ raise serializers.ValidationError({'datetime_end': e.messages})++ return attrs+def to_internal_value(self, data):return super().to_internal_value(self._translate_legacy_input(data))diff --git a/wger/manager/models/log.py b/wger/manager/models/log.pyindex 3e6306be1..ccfc1e17b 100644--- a/wger/manager/models/log.py+++ b/wger/manager/models/log.py@@ -294,8 +294,7 @@ class WorkoutLog(models.Model):# 2. Check if the log falls within a reasonable window of an "open" sessionif not matching_session:- max_duration = datetime.timedelta(hours=WorkoutSession.MAX_SESSION_LENGTH_HOURS)- time_threshold = log_date - max_duration+ time_threshold = log_date - WorkoutSession.max_duration()matching_session = (WorkoutSession.objects.filter(diff --git a/wger/manager/models/session.py b/wger/manager/models/session.pyindex c34b84dab..13d4c3c3b 100644--- a/wger/manager/models/session.py+++ b/wger/manager/models/session.py@@ -19,6 +19,7 @@ import datetimefrom uuid import uuid4# Django+from django.conf import settingsfrom django.contrib.auth.models import Userfrom django.core.exceptions import ValidationErrorfrom django.db import models@@ -34,8 +35,6 @@ class WorkoutSession(models.Model):Model for a workout session"""- MAX_SESSION_LENGTH_HOURS = 12-IMPRESSION_BAD = '1'IMPRESSION_NEUTRAL = '2'IMPRESSION_GOOD = '3'@@ -133,21 +132,30 @@ class WorkoutSession(models.Model):]indexes = [models.Index(fields=['routine', 'datetime_start'])]+ @classmethod+ def max_duration(cls) -> datetime.timedelta:+ """+ How long a session may last, and how far back a log looks for an open one+ """+ return datetime.timedelta(hours=settings.WGER_MAX_SESSION_LENGTH_HOURS)+def clean(self):"""Perform some additional validations"""# Note: We do NOT force both datetime_start and datetime_end to be present.# A missing datetime_end means the session is currently "open" and ongoing.- if self.datetime_end and self.datetime_start and self.datetime_start > self.datetime_end:+ if not (self.datetime_start and self.datetime_end):+ return++ if self.datetime_start > self.datetime_end:raise ValidationError(_('The start time cannot be after the end time.'))- if self.datetime_end and self.datetime_start:- duration = self.datetime_end - self.datetime_start- if duration > datetime.timedelta(hours=self.MAX_SESSION_LENGTH_HOURS):- raise ValidationError(- _(f'A session cannot be longer than {self.MAX_SESSION_LENGTH_HOURS} hours.')- )+ if self.datetime_end - self.datetime_start > self.max_duration():+ raise ValidationError(+ _('A session cannot be longer than %(hours)s hours.')+ % {'hours': settings.WGER_MAX_SESSION_LENGTH_HOURS}+ )def get_owner_object(self):"""diff --git a/wger/manager/tests/test_log_model.py b/wger/manager/tests/test_log_model.pyindex 648099bc8..bfdf5f57c 100644--- a/wger/manager/tests/test_log_model.py+++ b/wger/manager/tests/test_log_model.py@@ -13,8 +13,13 @@# You should have received a copy of the GNU Affero General Public License# Standard Library+import datetimeimport logging+# Django+from django.test import override_settings+from django.utils import timezone+# wgerfrom wger.core.tests.base_testcase import WgerTestCasefrom wger.manager.models import (@@ -26,6 +31,83 @@ from wger.manager.models import (logger = logging.getLogger(__name__)+class LogSessionMatchingTestCase(WgerTestCase):+ """+ Test which session a log without an explicit one is attached to+ """++ def setUp(self):+ super().setUp()+ WorkoutLog.objects.all().delete()+ WorkoutSession.objects.all().delete()++ @staticmethod+ def make_session(start, end=None):+ return WorkoutSession.objects.create(+ user_id=1,+ routine_id=1,+ datetime_start=timezone.make_aware(datetime.datetime(*start)),+ datetime_end=timezone.make_aware(datetime.datetime(*end)) if end else None,+ )++ @staticmethod+ def make_log(date):+ log = WorkoutLog(+ user_id=1,+ routine_id=1,+ exercise_id=1,+ weight=10,+ repetitions=10,+ date=timezone.make_aware(datetime.datetime(*date)),+ )+ log.save()+ return log++ def test_log_inside_a_session_over_midnight(self):+ """A log after midnight belongs to the session that started the evening before"""++ session = self.make_session((2025, 3, 10, 23, 0), (2025, 3, 11, 1, 0))+ log = self.make_log((2025, 3, 11, 0, 30))++ self.assertEqual(log.session_id, session.pk)+ self.assertEqual(WorkoutSession.objects.count(), 1)++ def test_log_joins_an_open_session(self):+ """A log within the window of a session without an end joins it"""++ session = self.make_session((2025, 3, 10, 23, 0))+ log = self.make_log((2025, 3, 11, 1, 0))++ self.assertEqual(log.session_id, session.pk)++ def test_log_outside_the_window_starts_a_new_session(self):+ """A log too long after an open session gets one of its own"""++ session = self.make_session((2025, 3, 10, 10, 0))+ log = self.make_log((2025, 3, 10, 16, 0))++ self.assertNotEqual(log.session_id, session.pk)+ self.assertEqual(WorkoutSession.objects.count(), 2)++ @override_settings(WGER_MAX_SESSION_LENGTH_HOURS=8)+ def test_the_window_follows_the_setting(self):+ """The same log joins the session once the window is wide enough"""++ session = self.make_session((2025, 3, 10, 10, 0))+ log = self.make_log((2025, 3, 10, 16, 0))++ self.assertEqual(log.session_id, session.pk)++ def test_log_after_a_closed_session_starts_a_new_one(self):+ """A closed session is not extended, even within the window"""++ session = self.make_session((2025, 3, 10, 10, 0), (2025, 3, 10, 11, 0))+ log = self.make_log((2025, 3, 10, 12, 0))++ self.assertNotEqual(log.session_id, session.pk)+ self.assertEqual(WorkoutSession.objects.count(), 2)++class LogModelTestCase(WgerTestCase):"""Test some logic in the workout log modeldiff --git a/wger/manager/tests/test_workout_session.py b/wger/manager/tests/test_workout_session.pyindex 2f9e25e9b..4599e6a51 100644--- a/wger/manager/tests/test_workout_session.py+++ b/wger/manager/tests/test_workout_session.py@@ -16,6 +16,7 @@import datetime# Django+from django.test import override_settingsfrom django.urls import reversefrom django.utils import timezone@@ -45,6 +46,84 @@ class WorkoutSessionApiTestCase(api_base_test.ApiBaseResourceTestCase):}+class WorkoutSessionDurationTestCase(WgerTestCase):+ """+ Test the maximum session length+ """++ SESSION = 'bbbbbbbb-bbbb-bbbb-bbbb-000000000005'+ ROUTINE = 3++ def setUp(self):+ super().setUp()+ self.user_login('test')++ def create_session(self, hours):+ return self.client.post(+ reverse('workoutsession-list'),+ data={+ 'routine': self.ROUTINE,+ 'impression': '2',+ 'datetime_start': '2025-03-12T10:00:00Z',+ 'datetime_end': f'2025-03-12T{10 + hours}:00:00Z',+ },+ )++ def test_session_within_the_limit(self):+ self.assertEqual(self.create_session(4).status_code, status.HTTP_201_CREATED)++ def test_session_over_the_limit_is_rejected(self):+ response = self.create_session(6)+ self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)+ self.assertIn('5 hours', response.json()['datetime_end'][0])++ @override_settings(WGER_MAX_SESSION_LENGTH_HOURS=8)+ def test_the_limit_is_configurable(self):+ self.assertEqual(self.create_session(6).status_code, status.HTTP_201_CREATED)++ def stretch_session(self):+ """Make the fixture session longer than the limit, bypassing the validation"""++ session = WorkoutSession.objects.get(pk=self.SESSION)+ WorkoutSession.objects.filter(pk=self.SESSION).update(+ datetime_end=session.datetime_start + datetime.timedelta(hours=8)+ )++ def test_session_over_the_limit_stays_editable(self):+ """Sessions from before the limit can still be edited as long as it stays untouched"""++ self.stretch_session()+ url = reverse('workoutsession-detail', kwargs={'pk': self.SESSION})+ stored = self.client.get(url).json()++ response = self.client.patch(+ url,+ data={+ 'notes': 'Still editable',+ 'date': stored['date'],+ 'time_start': stored['time_start'],+ 'time_end': stored['time_end'],+ },+ content_type='application/json',+ )++ self.assertEqual(response.status_code, status.HTTP_200_OK)+ self.assertEqual(WorkoutSession.objects.get(pk=self.SESSION).notes, 'Still editable')++ def test_stretching_a_session_further_is_rejected(self):+ """Editing the times of such a session does run into the limit"""++ self.stretch_session()++ response = self.client.patch(+ reverse('workoutsession-detail', kwargs={'pk': self.SESSION}),+ data={'time_end': '23:00'},+ content_type='application/json',+ )++ self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)++class WorkoutSessionLegacyFieldsTestCase(WgerTestCase):"""Test the deprecated date/time_start/time_end fields of the session API