Skip to content

armgit / wger

Public Imported from GitHub
0

Self hosted FLOSS fitness/workout, nutrition and weight tracker

Refactor WorkoutSession to use datetime to support overnight workouts

Appleaaf14fba02ce
diff --git a/wger/gym/helpers.py b/wger/gym/helpers.py
index c263e5a50..90a3b4c11 100644
--- a/wger/gym/helpers.py
+++ b/wger/gym/helpers.py
@@ -37,9 +37,9 @@ def get_user_last_activity(user):
last_activity = last_log.date
# Check workout sessions
- last_session = WorkoutSession.objects.filter(user=user).order_by('date').last()
+ last_session = WorkoutSession.objects.filter(user=user).order_by('datetime_start').last()
if last_session:
- last_session = last_session.date
+ last_session = last_session.datetime_start
# Return the last one
# if last_session:
diff --git a/wger/manager/api/serializers.py b/wger/manager/api/serializers.py
index 5a67e53ac..8dd66a797 100644
--- a/wger/manager/api/serializers.py
+++ b/wger/manager/api/serializers.py
@@ -423,6 +423,8 @@ class WorkoutSessionSerializer(serializers.ModelSerializer):
Workout session serializer
"""
+ date = serializers.SerializerMethodField()
+
class Meta:
model = WorkoutSession
fields = (
@@ -432,10 +434,16 @@ class WorkoutSessionSerializer(serializers.ModelSerializer):
'date',
'notes',
'impression',
- 'time_start',
- 'time_end',
+ 'datetime_start',
+ 'datetime_end',
)
+ def get_date(self, obj):
+ if obj.datetime_start:
+ from django.utils import timezone
+ return timezone.localtime(obj.datetime_start).date()
+ return None
+
class OwnerScopedSessionField(serializers.PrimaryKeyRelatedField):
"""
diff --git a/wger/manager/api/views.py b/wger/manager/api/views.py
index 6513e6fcf..198ea0b12 100644
--- a/wger/manager/api/views.py
+++ b/wger/manager/api/views.py
@@ -249,12 +249,11 @@ class WorkoutSessionViewSet(WgerOwnerObjectModelViewSet):
is_private = True
ordering_fields = '__all__'
filterset_fields = (
- 'date',
'routine',
'notes',
'impression',
- 'time_start',
- 'time_end',
+ 'datetime_start',
+ 'datetime_end',
)
def get_queryset(self):
diff --git a/wger/manager/fixtures/test-workout-session.json b/wger/manager/fixtures/test-workout-session.json
index cc1bca211..0044e3d4c 100644
--- a/wger/manager/fixtures/test-workout-session.json
+++ b/wger/manager/fixtures/test-workout-session.json
@@ -4,11 +4,10 @@
"model": "manager.workoutsession",
"fields": {
"impression": "2",
- "time_start": "17:00:00",
+ "datetime_start": "2025-10-01T17:00:00Z",
"routine": 1,
- "time_end": "18:30:00",
+ "datetime_end": "2025-10-01T18:30:00Z",
"user": 1,
- "date": "2025-10-01",
"notes": "Notes come here"
}
},
@@ -17,11 +16,10 @@
"model": "manager.workoutsession",
"fields": {
"impression": "3",
- "time_start": "17:00:00",
+ "datetime_start": "2025-01-20T17:00:00Z",
"routine": 1,
- "time_end": "18:00:00",
+ "datetime_end": "2025-01-20T18:00:00Z",
"user": 1,
- "date": "2025-01-20",
"notes": "Even more notes and impressions"
}
},
@@ -30,11 +28,10 @@
"model": "manager.workoutsession",
"fields": {
"impression": "3",
- "time_start": "10:00:00",
+ "datetime_start": "2025-01-30T10:00:00Z",
"routine": 2,
- "time_end": "15:00:00",
+ "datetime_end": "2025-01-30T15:00:00Z",
"user": 1,
- "date": "2025-01-30",
"notes": "I spent the whole day in the gym"
}
},
@@ -43,11 +40,10 @@
"model": "manager.workoutsession",
"fields": {
"impression": "3",
- "time_start": "10:00:00",
+ "datetime_start": "2025-11-01T10:00:00Z",
"routine": 3,
- "time_end": "10:15:00",
+ "datetime_end": "2025-11-01T10:15:00Z",
"user": 1,
- "date": "2025-11-01",
"notes": "Something, something else"
}
},
@@ -56,11 +52,10 @@
"model": "manager.workoutsession",
"fields": {
"impression": "3",
- "time_start": "10:00:00",
+ "datetime_start": "2025-11-01T10:00:00Z",
"routine": 3,
- "time_end": "10:15:00",
+ "datetime_end": "2025-11-01T10:15:00Z",
"user": 2,
- "date": "2025-11-01",
"notes": "Something, something else"
}
}
diff --git a/wger/manager/management/commands/dummy-generator-workout-diary.py b/wger/manager/management/commands/dummy-generator-workout-diary.py
index 8be47e26b..cef7d16ac 100644
--- a/wger/manager/management/commands/dummy-generator-workout-diary.py
+++ b/wger/manager/management/commands/dummy-generator-workout-diary.py
@@ -95,33 +95,40 @@ class Command(BaseCommand):
)
hour_start = random.randint(8, 20)
- time_start = datetime.time(
- hour_start,
- random.randint(0, 59),
- random.randint(0, 59),
- )
- time_end = datetime.time(
- hour_start + random.randint(1, 3),
- random.randint(0, 59),
- random.randint(0, 59),
+ datetime_start = make_aware(datetime.datetime.combine(
+ day_data.date,
+ datetime.time(
+ hour_start,
+ random.randint(0, 59),
+ random.randint(0, 59),
+ )
+ ))
+ datetime_end = datetime_start + datetime.timedelta(
+ hours=random.randint(1, 3),
+ minutes=random.randint(0, 59),
+ seconds=random.randint(0, 59),
)
- session = WorkoutSession.objects.get_or_create(
+ session = WorkoutSession.objects.filter(
user=user,
- date=day_data.date,
routine=routine,
- defaults={
- 'impression': random.choice(
+ datetime_start__date=day_data.date,
+ ).first()
+
+ if not session:
+ session = WorkoutSession.objects.create(
+ user=user,
+ routine=routine,
+ datetime_start=datetime_start,
+ datetime_end=datetime_end,
+ impression=random.choice(
[
WorkoutSession.IMPRESSION_GOOD,
WorkoutSession.IMPRESSION_BAD,
WorkoutSession.IMPRESSION_NEUTRAL,
]
),
- 'time_start': time_start,
- 'time_end': time_end,
- },
- )[0]
+ )
logs.append(
WorkoutLog(
diff --git a/wger/manager/migrations/0028_alter_workoutsession_options_and_more.py b/wger/manager/migrations/0028_alter_workoutsession_options_and_more.py
new file mode 100644
index 000000000..a406c43e0
--- /dev/null
+++ b/wger/manager/migrations/0028_alter_workoutsession_options_and_more.py
@@ -0,0 +1,79 @@
+# Generated by Django 6.0.5 on 2026-07-06 12:51
+
+import django.utils.timezone
+from django.conf import settings
+from django.db import migrations, models
+
+
+def forward_func(apps, schema_editor):
+ WorkoutSession = apps.get_model('manager', 'WorkoutSession')
+ import datetime
+ from django.utils.timezone import make_aware
+
+ for session in WorkoutSession.objects.all():
+ start_time = session.time_start if session.time_start else datetime.time(0, 0)
+ # Handle cases where date might be None, though default is today, just in case
+ date = session.date if session.date else datetime.date.today()
+ session.datetime_start = make_aware(datetime.datetime.combine(date, start_time))
+
+ if session.time_end:
+ session.datetime_end = make_aware(datetime.datetime.combine(date, session.time_end))
+ if session.time_end < start_time:
+ session.datetime_end += datetime.timedelta(days=1)
+ session.save()
+
+
+class Migration(migrations.Migration):
+
+ dependencies = [
+ ('manager', '0027_cleanup_fields'),
+ migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+ ]
+
+ operations = [
+ migrations.AlterModelOptions(
+ name='workoutsession',
+ options={'ordering': ['datetime_start']},
+ ),
+ migrations.RemoveIndex(
+ model_name='workoutsession',
+ name='manager_wor_routine_224494_idx',
+ ),
+ migrations.AlterUniqueTogether(
+ name='workoutsession',
+ unique_together=set(),
+ ),
+ migrations.AddField(
+ model_name='workoutsession',
+ name='datetime_end',
+ field=models.DateTimeField(blank=True, null=True, verbose_name='End date and time'),
+ ),
+ migrations.AddField(
+ model_name='workoutsession',
+ name='datetime_start',
+ field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='Start date and time'),
+ ),
+
+ migrations.AlterField(
+ model_name='workoutlog',
+ name='date',
+ field=models.DateTimeField(default=django.utils.timezone.now, verbose_name='Date'),
+ ),
+ migrations.AddIndex(
+ model_name='workoutsession',
+ index=models.Index(fields=['routine', 'datetime_start'], name='manager_wor_routine_46e75a_idx'),
+ ),
+ migrations.RunPython(forward_func),
+ migrations.RemoveField(
+ model_name='workoutsession',
+ name='date',
+ ),
+ migrations.RemoveField(
+ model_name='workoutsession',
+ name='time_end',
+ ),
+ migrations.RemoveField(
+ model_name='workoutsession',
+ name='time_start',
+ ),
+ ]
diff --git a/wger/manager/models/log.py b/wger/manager/models/log.py
index 21b805adf..8f4f11efd 100644
--- a/wger/manager/models/log.py
+++ b/wger/manager/models/log.py
@@ -271,27 +271,44 @@ class WorkoutLog(models.Model):
# Auto-create a session only if the client didn't provide one.
if not self.session_id:
- try:
- self.session = WorkoutSession.objects.get_or_create(
+ import datetime
+ from django.utils import timezone
+
+ # Ensure self.date is a timezone-aware datetime for comparisons
+ log_date = self.date
+ if isinstance(log_date, datetime.date) and not isinstance(log_date, datetime.datetime):
+ log_date = timezone.make_aware(datetime.datetime.combine(log_date, datetime.time()))
+ elif timezone.is_naive(log_date):
+ log_date = timezone.make_aware(log_date)
+
+ # 1. Check if the log falls within an existing closed session's timeframe
+ matching_session = WorkoutSession.objects.filter(
+ user=self.user,
+ routine=self.routine,
+ datetime_start__lte=log_date,
+ datetime_end__gte=log_date,
+ ).first()
+
+ # 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
+
+ matching_session = WorkoutSession.objects.filter(
user=self.user,
- date=self.date,
routine=self.routine,
- )[0]
- except WorkoutSession.MultipleObjectsReturned:
- # TODO: duplicate sessions can exist for the same (user, date, routine)
- # when routine is NULL, as the unique_together does not cover a NULL
- # routine in PostgreSQL.
- # This is a fix till we correctly take care of the problem, we just
- # reuse one session (ids are uuid7, so ordering by id yields the
- # earliest) instead of crashing the log POST with MultipleObjectsReturned.
- self.session = (
- WorkoutSession.objects.filter(
- user=self.user,
- date=self.date,
- routine=self.routine,
- )
- .order_by('id')
- .first()
+ datetime_end__isnull=True,
+ datetime_start__gte=time_threshold,
+ datetime_start__lte=log_date,
+ ).order_by('-datetime_start').first()
+
+ if matching_session:
+ self.session = matching_session
+ else:
+ self.session = WorkoutSession.objects.create(
+ user=self.user,
+ datetime_start=log_date,
+ routine=self.routine,
)
# If the user of next_log is not this user, remove foreign key
diff --git a/wger/manager/models/routine.py b/wger/manager/models/routine.py
index 26fb88cfe..fcc0737b3 100644
--- a/wger/manager/models/routine.py
+++ b/wger/manager/models/routine.py
@@ -235,7 +235,7 @@ class Routine(models.Model):
workout_session_map = defaultdict(set)
for day in days:
for session in day.workoutsession_set.all():
- workout_session_map[day.id].add(session.date)
+ workout_session_map[day.id].add(timezone.localtime(session.datetime_start).date() if session.datetime_start else None)
# Main sequence generation logic
labels = self.label_dict
@@ -449,7 +449,7 @@ class Routine(models.Model):
# Iterate over each workout session associated with the routine
for session in self.sessions.all():
- session_date = session.date
+ session_date = timezone.localtime(session.datetime_start).date()
week_number = session_date.isocalendar().week
# TODO: filter for lb
diff --git a/wger/manager/models/session.py b/wger/manager/models/session.py
index 6d74cd361..4bbca4255 100644
--- a/wger/manager/models/session.py
+++ b/wger/manager/models/session.py
@@ -23,6 +23,7 @@ from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.db import models
from django.utils.translation import gettext_lazy as _
+from django.utils import timezone
# wger
from wger.utils.uuid import uuid7
@@ -33,6 +34,8 @@ class WorkoutSession(models.Model):
Model for a workout session
"""
+ MAX_SESSION_LENGTH_HOURS = 12
+
IMPRESSION_BAD = '1'
IMPRESSION_NEUTRAL = '2'
IMPRESSION_GOOD = '3'
@@ -76,12 +79,21 @@ class WorkoutSession(models.Model):
The day the session belongs to
"""
- date = models.DateField(
- verbose_name='Date',
- default=datetime.date.today,
+ datetime_start = models.DateTimeField(
+ verbose_name='Start date and time',
+ default=timezone.now,
)
"""
- The date the workout session was performed
+ The date and time the workout session started
+ """
+
+ datetime_end = models.DateTimeField(
+ verbose_name='End date and time',
+ blank=True,
+ null=True,
+ )
+ """
+ The date and time the workout session ended
"""
notes = models.TextField(
@@ -105,29 +117,11 @@ class WorkoutSession(models.Model):
The user's general impression of workout
"""
- time_start = models.TimeField(
- verbose_name='Start time',
- blank=True,
- null=True,
- )
- """
- Time the workout session started
- """
-
- time_end = models.TimeField(
- verbose_name='Finish time',
- blank=True,
- null=True,
- )
- """
- Time the workout session ended
- """
-
def __str__(self):
"""
Return a more human-readable representation
"""
- return f'{self.routine} - {self.date}'
+ return f'{self.routine} - {self.datetime_start.date() if self.datetime_start else ""}'
class Meta:
"""
@@ -135,22 +129,24 @@ class WorkoutSession(models.Model):
"""
ordering = [
- 'date',
+ 'datetime_start',
]
- unique_together = ('date', 'user', 'routine')
- indexes = [models.Index(fields=['routine', 'date'])]
+ indexes = [models.Index(fields=['routine', 'datetime_start'])]
def clean(self):
"""
Perform some additional validations
"""
-
- if (not self.time_end and self.time_start) or (self.time_end and not self.time_start):
- raise ValidationError(_('If you enter a time, you must enter both start and end time.'))
-
- if self.time_end and self.time_start and self.time_start > self.time_end:
+ # 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:
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.'))
+
def get_owner_object(self):
"""
Returns the object that has owner information
diff --git a/wger/manager/tests/test_routine.py b/wger/manager/tests/test_routine.py
index b9db0b702..1b1502105 100644
--- a/wger/manager/tests/test_routine.py
+++ b/wger/manager/tests/test_routine.py
@@ -18,6 +18,7 @@ from unittest import mock
# Django
from django.conf import settings
+from django.utils import timezone
from django.urls import reverse
# wger
@@ -301,7 +302,7 @@ class RoutineTestCase(WgerTestCase):
WorkoutSession.objects.create(
day=self.day1,
routine=self.routine,
- date=start + datetime.timedelta(days=2),
+ datetime_start=timezone.make_aware(datetime.datetime.combine(start + datetime.timedelta(days=2), datetime.time())),
user=self.routine.user,
)
diff --git a/wger/manager/tests/test_workout_session.py b/wger/manager/tests/test_workout_session.py
index d1e9b3d93..28cb2dbfd 100644
--- a/wger/manager/tests/test_workout_session.py
+++ b/wger/manager/tests/test_workout_session.py
@@ -15,6 +15,8 @@
# Standard Library
import datetime
+from django.utils import timezone
+
# wger
from wger.core.tests import api_base_test
from wger.manager.models import WorkoutSession
@@ -29,10 +31,9 @@ class WorkoutSessionApiTestCase(api_base_test.ApiBaseResourceTestCase):
resource = WorkoutSession
private_resource = True
data = {
- 'workout': 3,
- 'date': datetime.date(2014, 1, 25),
+ 'routine': 3,
'notes': 'My new insights',
'impression': '3',
- 'time_start': datetime.time(10, 0),
- 'time_end': datetime.time(13, 0),
+ 'datetime_start': timezone.make_aware(datetime.datetime(2014, 1, 25, 10, 0)),
+ 'datetime_end': timezone.make_aware(datetime.datetime(2014, 1, 25, 13, 0)),
}
diff --git a/wger/trophies/services/statistics.py b/wger/trophies/services/statistics.py
index 2128953c7..91f3c7109 100644
--- a/wger/trophies/services/statistics.py
+++ b/wger/trophies/services/statistics.py
@@ -87,11 +87,11 @@ class UserStatisticsService:
stats.total_weight_lifted = total_weight
# Get all workout sessions
- sessions = WorkoutSession.objects.filter(user=user).order_by('date')
+ sessions = WorkoutSession.objects.filter(user=user).order_by('datetime_start')
stats.total_workouts = sessions.count()
# Calculate streaks and other date-based stats
- workout_dates = list(sessions.values_list('date', flat=True).distinct().order_by('date'))
+ workout_dates = list(sessions.values_list('datetime_start__date', flat=True).distinct().order_by('datetime_start__date'))
current_streak, longest_streak = cls._calculate_streaks(workout_dates)
stats.current_streak = current_streak
stats.longest_streak = longest_streak
@@ -154,9 +154,9 @@ class UserStatisticsService:
# Get the session date
session_date = None
if session:
- session_date = session.date
+ session_date = session.datetime_start
elif workout_log and workout_log.session:
- session_date = workout_log.session.date
+ session_date = workout_log.session.datetime_start
if session_date:
# Convert datetime to date if needed for comparison
@@ -198,14 +198,15 @@ class UserStatisticsService:
cls._update_weekend_streak_incremental(stats, session_date)
# Update workout times if session has time info
- if session and session.time_start:
+ if session and session.datetime_start:
+ session_time = session.datetime_start.time()
if (
stats.earliest_workout_time is None
- or session.time_start < stats.earliest_workout_time
+ or session_time < stats.earliest_workout_time
):
- stats.earliest_workout_time = session.time_start
- if stats.latest_workout_time is None or session.time_start > stats.latest_workout_time:
- stats.latest_workout_time = session.time_start
+ stats.earliest_workout_time = session_time
+ if stats.latest_workout_time is None or session_time > stats.latest_workout_time:
+ stats.latest_workout_time = session_time
# Count sessions for total workouts (recalculate to be accurate)
stats.total_workouts = WorkoutSession.objects.filter(user=user).count()
@@ -318,7 +319,7 @@ class UserStatisticsService:
Returns:
Tuple of (earliest_time, latest_time)
"""
- times = [s.time_start for s in sessions if s.time_start is not None]
+ times = [s.datetime_start.time() for s in sessions if s.datetime_start is not None]
if not times:
return None, None
return min(times), max(times)
@@ -415,8 +416,14 @@ class UserStatisticsService:
sunday = saturday + datetime.timedelta(days=1)
# Check if both days have workouts
- has_saturday = WorkoutSession.objects.filter(user=stats.user, date=saturday).exists()
- has_sunday = WorkoutSession.objects.filter(user=stats.user, date=sunday).exists()
+ has_saturday = WorkoutSession.objects.filter(
+ user=stats.user,
+ datetime_start__date=saturday
+ ).exists()
+ has_sunday = WorkoutSession.objects.filter(
+ user=stats.user,
+ datetime_start__date=sunday
+ ).exists()
if has_saturday and has_sunday:
# This weekend is complete
diff --git a/wger/trophies/signals.py b/wger/trophies/signals.py
index 719017e79..997c05e09 100644
--- a/wger/trophies/signals.py
+++ b/wger/trophies/signals.py
@@ -172,7 +172,7 @@ def workout_session_saved(sender, instance: WorkoutSession, created: bool, **kwa
session=instance,
)
else:
- # Session updated (e.g., time_start changed) - update times
+ # Session updated (e.g., datetime_start changed) - update times
UserStatisticsService.increment_workout(
user=instance.user,
session=instance,