Skip to content

armgit / wger

Public Imported from GitHub
0

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.py
index 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_CELE
WGER_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 Authentication
diff --git a/settings/settings_global.py b/settings/settings_global.py
index 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.py
index 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 DjangoValidationError
from 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.py
index 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" session
if 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.py
index c34b84dab..13d4c3c3b 100644
--- a/wger/manager/models/session.py
+++ b/wger/manager/models/session.py
@@ -19,6 +19,7 @@ import datetime
from uuid import uuid4
# Django
+from django.conf import settings
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from 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.py
index 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 datetime
import logging
+# Django
+from django.test import override_settings
+from django.utils import timezone
+
# wger
from wger.core.tests.base_testcase import WgerTestCase
from 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 model
diff --git a/wger/manager/tests/test_workout_session.py b/wger/manager/tests/test_workout_session.py
index 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_settings
from django.urls import reverse
from 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