Skip to content

armgit / wger

Public Imported from GitHub
0

Self hosted FLOSS fitness/workout, nutrition and weight tracker

Finally remove the canonical representation logic for the old workouts

Roland Geiderfec9380fb0e1
diff --git a/wger/core/management/commands/clear-cache.py b/wger/core/management/commands/clear-cache.py
index 07fa5f8f2..99b916144 100644
--- a/wger/core/management/commands/clear-cache.py
+++ b/wger/core/management/commands/clear-cache.py
@@ -25,10 +25,7 @@ from wger.manager.models import (
Workout,
WorkoutLog,
)
-from wger.utils.cache import (
- reset_workout_canonical_form,
- reset_workout_log,
-)
+from wger.utils.cache import reset_workout_log
class Command(BaseCommand):
@@ -50,14 +47,6 @@ class Command(BaseCommand):
help='Clear only template caches',
)
- parser.add_argument(
- '--clear-workout-cache',
- action='store_true',
- dest='clear_workout',
- default=False,
- help='Clear only the workout canonical view',
- )
-
parser.add_argument(
'--clear-all',
action='store_true',
@@ -105,11 +94,6 @@ class Command(BaseCommand):
self.stdout.write(f' Day {day.day}')
reset_workout_log(user.id, entry.year, entry.month, day)
- # Workout canonical form
- if options['clear_workout']:
- for w in Workout.objects.all():
- reset_workout_canonical_form(w.pk)
-
# Nuclear option, clear all
if options['clear_all']:
cache.clear()
diff --git a/wger/exercises/models/comment.py b/wger/exercises/models/comment.py
index 9b62a4bb3..ce22ecf6e 100644
--- a/wger/exercises/models/comment.py
+++ b/wger/exercises/models/comment.py
@@ -25,10 +25,7 @@ from django.utils.translation import gettext_lazy as _
from simple_history.models import HistoricalRecords
# wger
-from wger.utils.cache import (
- reset_exercise_api_cache,
- reset_workout_canonical_form,
-)
+from wger.utils.cache import reset_exercise_api_cache
# Local
from .exercise import Exercise
@@ -72,8 +69,6 @@ class ExerciseComment(models.Model):
"""
Reset cached workouts
"""
- for setting in self.exercise.exercise_base.setting_set.all():
- reset_workout_canonical_form(setting.set.exerciseday.training_id)
# Api cache
reset_exercise_api_cache(self.exercise.exercise_base.uuid)
@@ -84,8 +79,6 @@ class ExerciseComment(models.Model):
"""
Reset cached workouts
"""
- for setting in self.exercise.exercise_base.setting_set.all():
- reset_workout_canonical_form(setting.set.exerciseday.training.pk)
# Api cache
reset_exercise_api_cache(self.exercise.exercise_base.uuid)
diff --git a/wger/exercises/models/exercise.py b/wger/exercises/models/exercise.py
index 52cefcc29..28b547cf9 100644
--- a/wger/exercises/models/exercise.py
+++ b/wger/exercises/models/exercise.py
@@ -32,10 +32,7 @@ from simple_history.models import HistoricalRecords
# wger
from wger.core.models import Language
from wger.exercises.models import ExerciseBase
-from wger.utils.cache import (
- reset_exercise_api_cache,
- reset_workout_canonical_form,
-)
+from wger.utils.cache import reset_exercise_api_cache
from wger.utils.models import (
AbstractHistoryMixin,
AbstractLicenseModel,
@@ -130,17 +127,10 @@ class Exercise(AbstractLicenseModel, AbstractHistoryMixin, models.Model):
# Api cache
reset_exercise_api_cache(self.exercise_base.uuid)
- # Cached workouts
- for setting in self.exercise_base.setting_set.all():
- reset_workout_canonical_form(setting.set.exerciseday.training_id)
-
def delete(self, *args, **kwargs):
"""
Reset all cached infos
"""
- # Cached workouts
- for setting in self.exercise_base.setting_set.all():
- reset_workout_canonical_form(setting.set.exerciseday.training.pk)
# Api cache
reset_exercise_api_cache(self.exercise_base.uuid)
diff --git a/wger/exercises/models/exercise_alias.py b/wger/exercises/models/exercise_alias.py
index ac67d6838..8a3a51ce1 100644
--- a/wger/exercises/models/exercise_alias.py
+++ b/wger/exercises/models/exercise_alias.py
@@ -26,10 +26,7 @@ from django.utils.translation import gettext_lazy as _
from simple_history.models import HistoricalRecords
# wger
-from wger.utils.cache import (
- reset_exercise_api_cache,
- reset_workout_canonical_form,
-)
+from wger.utils.cache import reset_exercise_api_cache
# Local
from .exercise import Exercise
@@ -84,8 +81,6 @@ class Alias(models.Model):
"""
Reset cached workouts
"""
- for setting in self.exercise.exercise_base.setting_set.all():
- reset_workout_canonical_form(setting.set.exerciseday.training.pk)
# Api cache
reset_exercise_api_cache(self.exercise.exercise_base.uuid)
diff --git a/wger/exercises/tests/test_exercise_translation.py b/wger/exercises/tests/test_exercise_translation.py
index 5e6af2287..ace1b10ea 100644
--- a/wger/exercises/tests/test_exercise_translation.py
+++ b/wger/exercises/tests/test_exercise_translation.py
@@ -216,42 +216,6 @@ class MuscleTemplateTagTest(WgerTestCase):
self.assertEqual(rendered_template, '\n\n')
-class WorkoutCacheTestCase(WgerTestCase):
- """
- Workout cache test case
- """
-
- def test_canonical_form_cache_save(self):
- """
- Tests the workout cache when saving
- """
- exercise = Exercise.objects.get(pk=2)
- for setting in exercise.exercise_base.setting_set.all():
- setting.set.exerciseday.training.canonical_representation
- workout_id = setting.set.exerciseday.training_id
- self.assertTrue(cache.get(cache_mapper.get_workout_canonical(workout_id)))
-
- exercise.save()
- self.assertFalse(cache.get(cache_mapper.get_workout_canonical(workout_id)))
-
- def test_canonical_form_cache_delete(self):
- """
- Tests the workout cache when deleting
- """
- exercise = Exercise.objects.get(pk=2)
-
- workout_ids = []
- for setting in exercise.exercise_base.setting_set.all():
- workout_id = setting.set.exerciseday.training_id
- workout_ids.append(workout_id)
- setting.set.exerciseday.training.canonical_representation
- self.assertTrue(cache.get(cache_mapper.get_workout_canonical(workout_id)))
-
- exercise.delete()
- for workout_id in workout_ids:
- self.assertFalse(cache.get(cache_mapper.get_workout_canonical(workout_id)))
-
-
# TODO: fix test, all registered users can upload exercises
class ExerciseApiTestCase(
api_base_test.BaseTestCase, api_base_test.ApiBaseTestCase, api_base_test.ApiGetTestCase
diff --git a/wger/manager/api/serializers.py b/wger/manager/api/serializers.py
index 738ca5aa0..2108e3430 100644
--- a/wger/manager/api/serializers.py
+++ b/wger/manager/api/serializers.py
@@ -336,84 +336,3 @@ class SettingSerializer(serializers.ModelSerializer):
'order',
'comment',
]
-
-
-#
-# Custom helper serializers for the canonical form of a workout
-#
-class MusclesCanonicalFormSerializer(serializers.Serializer):
- """
- Serializer for the muscles in the canonical form of a day/workout
- """
-
- front = serializers.ListField(child=MuscleSerializer())
- back = serializers.ListField(child=MuscleSerializer())
- frontsecondary = serializers.ListField(child=MuscleSerializer())
- backsecondary = serializers.ListField(child=MuscleSerializer())
-
-
-class WorkoutCanonicalFormExerciseImagesListSerializer(serializers.Serializer):
- """
- Serializer for settings in the canonical form of a workout
- """
-
- image = serializers.ReadOnlyField()
- is_main = serializers.ReadOnlyField()
-
-
-class WorkoutCanonicalFormExerciseListSerializer(serializers.Serializer):
- """
- Serializer for settings in the canonical form of a workout
- """
-
- setting_obj_list = SettingSerializer(many=True)
- setting_list = serializers.ReadOnlyField()
- setting_text = serializers.ReadOnlyField()
- reps_list = serializers.ReadOnlyField()
- has_weight = serializers.ReadOnlyField()
- weight_list = serializers.ReadOnlyField()
- comment_list = serializers.ReadOnlyField()
- image_list = WorkoutCanonicalFormExerciseImagesListSerializer(many=True)
- obj = ExerciseBaseInfoSerializer()
-
-
-class WorkoutCanonicalFormExerciseSerializer(serializers.Serializer):
- """
- Serializer for an exercise in the canonical form of a workout
- """
-
- obj = SetSerializer()
- exercise_list = WorkoutCanonicalFormExerciseListSerializer(many=True)
- is_superset = serializers.BooleanField()
- settings_computed = SettingSerializer(many=True)
- muscles = MusclesCanonicalFormSerializer()
-
-
-class DaysOfWeekCanonicalFormSerializer(serializers.Serializer):
- """
- Serializer for a days of week in the canonical form of a workout
- """
-
- text = serializers.ReadOnlyField()
- day_list = serializers.ListField(child=DaysOfWeekSerializer())
-
-
-class DayCanonicalFormSerializer(serializers.Serializer):
- """
- Serializer for a day in the canonical form of a workout
- """
-
- obj = DaySerializer()
- set_list = WorkoutCanonicalFormExerciseSerializer(many=True)
- days_of_week = DaysOfWeekCanonicalFormSerializer()
- muscles = MusclesCanonicalFormSerializer()
-
-
-class WorkoutCanonicalFormSerializer(serializers.Serializer):
- """
- Serializer for the canonical form of a workout
- """
-
- obj = WorkoutSerializer()
- day_list = DayCanonicalFormSerializer(many=True)
- muscles = MusclesCanonicalFormSerializer()
diff --git a/wger/manager/api/views.py b/wger/manager/api/views.py
index eb271557e..d58294149 100644
--- a/wger/manager/api/views.py
+++ b/wger/manager/api/views.py
@@ -36,7 +36,6 @@ from wger.manager.api.serializers import (
ScheduleStepSerializer,
SetSerializer,
SettingSerializer,
- WorkoutCanonicalFormSerializer,
WorkoutDayDataSerializer,
WorkoutLogSerializer,
WorkoutSerializer,
@@ -138,17 +137,6 @@ class WorkoutViewSet(viewsets.ModelViewSet):
"""
serializer.save(user=self.request.user)
- @action(detail=True)
- def canonical_representation(self, request, pk):
- """
- Output the canonical representation of a workout
-
- This is basically the same form as used in the application
- """
-
- out = WorkoutCanonicalFormSerializer(self.get_object().canonical_representation).data
- return Response(out)
-
@action(detail=True)
def log_data(self, request, pk):
"""
diff --git a/wger/manager/models/day.py b/wger/manager/models/day.py
index b74874316..e257283f7 100644
--- a/wger/manager/models/day.py
+++ b/wger/manager/models/day.py
@@ -25,7 +25,6 @@ from django.utils.translation import gettext_lazy as _
# wger
from wger.core.models import DaysOfWeek
from wger.manager.dataclasses import SetData
-from wger.utils.cache import reset_workout_canonical_form
class DayNg(models.Model):
@@ -140,157 +139,3 @@ class Day(models.Model):
to order the days in the template
"""
return self.day.all()[0].pk
-
- def save(self, *args, **kwargs):
- """
- Reset all cached infos
- """
-
- reset_workout_canonical_form(self.training_id)
- super(Day, self).save(*args, **kwargs)
-
- def delete(self, *args, **kwargs):
- """
- Reset all cached infos
- """
-
- reset_workout_canonical_form(self.training_id)
- super(Day, self).delete(*args, **kwargs)
-
- @property
- def canonical_representation(self):
- """
- Return the canonical representation for this day
-
- This is extracted from the workout representation because that one is cached
- and this isn't.
- """
- for i in self.training.canonical_representation['day_list']:
- if int(i['obj'].pk) == int(self.pk):
- return i
-
- def get_canonical_representation(self):
- """
- Creates a canonical representation for this day
- """
- # Local
- from .setting import Setting
-
- canonical_repr = []
- muscles_front = []
- muscles_back = []
- muscles_front_secondary = []
- muscles_back_secondary = []
-
- for set_obj in self.set_set.select_related():
- exercise_tmp = []
-
- for base in set_obj.exercise_bases:
- setting_tmp = []
- exercise_images_tmp = []
-
- # Muscles for this set
- for muscle in base.muscles.all():
- if muscle.is_front and muscle not in muscles_front:
- muscles_front.append(muscle)
- elif not muscle.is_front and muscle not in muscles_back:
- muscles_back.append(muscle)
-
- for muscle in base.muscles_secondary.all():
- if muscle.is_front and muscle not in muscles_front:
- muscles_front_secondary.append(muscle)
- elif not muscle.is_front and muscle.id not in muscles_back:
- muscles_back_secondary.append(muscle)
-
- for setting in Setting.objects.filter(set=set_obj, exercise_base=base).order_by(
- 'order', 'id'
- ):
- setting_tmp.append(setting)
-
- # "Smart" textual representation
- setting_text = set_obj.reps_smart_text(base)
-
- # Exercise comments
- comment_list = []
- # for i in base.exercisecomment_set.all():
- # comment_list.append(i.comment)
-
- # Flag indicating whether any of the settings has saved weight
- has_weight = False
- for i in setting_tmp:
- if i.weight:
- has_weight = True
- break
-
- # Collect exercise images
- for image in base.exerciseimage_set.all():
- exercise_images_tmp.append(
- {
- 'image': image.image.url,
- 'is_main': image.is_main,
- }
- )
-
- # Put it all together
- exercise_tmp.append(
- {
- 'obj': base,
- 'setting_obj_list': setting_tmp,
- 'setting_text': setting_text,
- 'has_weight': has_weight,
- 'comment_list': comment_list,
- 'image_list': exercise_images_tmp,
- }
- )
-
- # If it's a superset, check that all exercises have the same repetitions.
- # If not, just take the smallest number and drop the rest, because otherwise
- # it doesn't make sense
-
- # if len(exercise_tmp) > 1:
- # common_reps = 100
- # for exercise in exercise_tmp:
- # if len(exercise['setting_list']) < common_reps:
- # common_reps = len(exercise['setting_list'])
-
- # for exercise in exercise_tmp:
- # if len(exercise['setting_list']) > common_reps:
- # exercise['setting_list'].pop(-1)
- # exercise['setting_obj_list'].pop(-1)
- # setting_text, setting_list = set_obj.reps_smart_text(exercise)
- # exercise['setting_text'] = setting_text
-
- canonical_repr.append(
- {
- 'obj': set_obj,
- 'exercise_list': exercise_tmp,
- 'is_superset': True if len(exercise_tmp) > 1 else False,
- 'settings_computed': set_obj.compute_settings,
- 'muscles': {
- 'back': muscles_back,
- 'front': muscles_front,
- 'frontsecondary': muscles_front_secondary,
- 'backsecondary': muscles_front_secondary,
- },
- }
- )
-
- # Days of the week
- tmp_days_of_week = []
- for day_of_week in self.day.select_related():
- tmp_days_of_week.append(day_of_week)
-
- return {
- 'obj': self,
- 'days_of_week': {
- 'text': ', '.join([str(_(i.day_of_week)) for i in tmp_days_of_week]),
- 'day_list': tmp_days_of_week,
- },
- 'muscles': {
- 'back': muscles_back,
- 'front': muscles_front,
- 'frontsecondary': muscles_front_secondary,
- 'backsecondary': muscles_front_secondary,
- },
- 'set_list': canonical_repr,
- }
diff --git a/wger/manager/models/set.py b/wger/manager/models/set.py
index 3e8f174a7..99a056b0f 100644
--- a/wger/manager/models/set.py
+++ b/wger/manager/models/set.py
@@ -28,7 +28,6 @@ from django.utils.translation import gettext_lazy as _
# wger
from wger.exercises.models import ExerciseBase
from wger.manager.dataclasses import SetExerciseData
-from wger.utils.cache import reset_workout_canonical_form
from wger.utils.helpers import normalize_decimal
# Local
@@ -139,22 +138,6 @@ class Set(models.Model):
"""
return self.exerciseday.training
- def save(self, *args, **kwargs):
- """
- Reset all cached infos
- """
-
- reset_workout_canonical_form(self.exerciseday.training_id)
- super(Set, self).save(*args, **kwargs)
-
- def delete(self, *args, **kwargs):
- """
- Reset all cached infos
- """
-
- reset_workout_canonical_form(self.exerciseday.training_id)
- super(Set, self).delete(*args, **kwargs)
-
@property
def exercise_bases(self) -> List[ExerciseBase]:
"""Returns the exercises for this set"""
diff --git a/wger/manager/models/setting.py b/wger/manager/models/setting.py
index fc8886402..bbd9a1de9 100644
--- a/wger/manager/models/setting.py
+++ b/wger/manager/models/setting.py
@@ -27,11 +27,7 @@ from wger.core.models import (
RepetitionUnit,
WeightUnit,
)
-from wger.exercises.models import (
- Exercise,
- ExerciseBase,
-)
-from wger.utils.cache import reset_workout_canonical_form
+from wger.exercises.models import ExerciseBase
# Local
from ..consts import RIR_OPTIONS
@@ -124,7 +120,6 @@ class Setting(models.Model):
"""
Reset cache
"""
- reset_workout_canonical_form(self.set.exerciseday.training_id)
# If the user selected "Until Failure", do only 1 "repetition",
# everythin else doesn't make sense.
@@ -132,14 +127,6 @@ class Setting(models.Model):
self.reps = 1
super(Setting, self).save(*args, **kwargs)
- def delete(self, *args, **kwargs):
- """
- Reset cache
- """
-
- reset_workout_canonical_form(self.set.exerciseday.training_id)
- super(Setting, self).delete(*args, **kwargs)
-
def get_owner_object(self):
"""
Returns the object that has owner information
diff --git a/wger/manager/models/workout.py b/wger/manager/models/workout.py
index e981f7923..9e6809924 100644
--- a/wger/manager/models/workout.py
+++ b/wger/manager/models/workout.py
@@ -28,10 +28,6 @@ from wger.manager.managers import (
WorkoutManager,
WorkoutTemplateManager,
)
-from wger.utils.cache import (
- cache_mapper,
- reset_workout_canonical_form,
-)
class Workout(models.Model):
@@ -114,77 +110,8 @@ class Workout(models.Model):
_('You must mark this workout as a template before declaring it public')
)
- def save(self, *args, **kwargs):
- """
- Reset all cached infos
- """
- reset_workout_canonical_form(self.id)
- super(Workout, self).save(*args, **kwargs)
-
- def delete(self, *args, **kwargs):
- """
- Reset all cached infos
- """
- reset_workout_canonical_form(self.id)
- super(Workout, self).delete(*args, **kwargs)
-
def get_owner_object(self):
"""
Returns the object that has owner information
"""
return self
-
- @property
- def canonical_representation(self):
- """
- Returns a canonical representation of the workout
-
- This form makes it easier to cache and use everywhere where all or part
- of a workout structure is needed. As an additional benefit, the template
- caches are not needed anymore.
- """
- workout_canonical_form = cache.get(cache_mapper.get_workout_canonical(self.pk))
- if not workout_canonical_form:
- day_canonical_repr = []
- muscles_front = []
- muscles_back = []
- muscles_front_secondary = []
- muscles_back_secondary = []
-
- # Sort list by weekday
- day_list = [i for i in self.day_set.select_related()]
- day_list.sort(key=lambda day: day.get_first_day_id)
-
- for day in day_list:
- canonical_repr_day = day.get_canonical_representation()
-
- # Collect all muscles
- for i in canonical_repr_day['muscles']['front']:
- if i not in muscles_front:
- muscles_front.append(i)
- for i in canonical_repr_day['muscles']['back']:
- if i not in muscles_back:
- muscles_back.append(i)
- for i in canonical_repr_day['muscles']['frontsecondary']:
- if i not in muscles_front_secondary:
- muscles_front_secondary.append(i)
- for i in canonical_repr_day['muscles']['backsecondary']:
- if i not in muscles_back_secondary:
- muscles_back_secondary.append(i)
-
- day_canonical_repr.append(canonical_repr_day)
-
- workout_canonical_form = {
- 'obj': self,
- 'muscles': {
- 'front': muscles_front,
- 'back': muscles_back,
- 'frontsecondary': muscles_front_secondary,
- 'backsecondary': muscles_back_secondary,
- },
- 'day_list': day_canonical_repr,
- }
- # Save to cache
- cache.set(cache_mapper.get_workout_canonical(self.pk), workout_canonical_form)
-
- return workout_canonical_form
diff --git a/wger/manager/tests/test_day.py b/wger/manager/tests/test_day.py
index 865010aad..3cd0a8ae5 100644
--- a/wger/manager/tests/test_day.py
+++ b/wger/manager/tests/test_day.py
@@ -157,34 +157,6 @@ class RenderWorkoutDayTestCase(WgerTestCase):
self.render_day(fail=True)
-class WorkoutCacheTestCase(WgerTestCase):
- """
- Workout cache test case
- """
-
- def test_canonical_form_cache_save(self):
- """
- Tests the workout cache when saving
- """
- day = Day.objects.get(pk=1)
- day.canonical_representation
- self.assertTrue(cache.get(cache_mapper.get_workout_canonical(day.training_id)))
-
- day.save()
- self.assertFalse(cache.get(cache_mapper.get_workout_canonical(day.training_id)))
-
- def test_canonical_form_cache_delete(self):
- """
- Tests the workout cache when deleting
- """
- day = Day.objects.get(pk=1)
- day.canonical_representation
- self.assertTrue(cache.get(cache_mapper.get_workout_canonical(day.training_id)))
-
- day.delete()
- self.assertFalse(cache.get(cache_mapper.get_workout_canonical(day.training_id)))
-
-
class DayTestCase(WgerTestCase):
"""
Other tests
diff --git a/wger/manager/tests/test_set.py b/wger/manager/tests/test_set.py
index a6acd0681..6ae0bba84 100644
--- a/wger/manager/tests/test_set.py
+++ b/wger/manager/tests/test_set.py
@@ -359,64 +359,6 @@ class SetEditEditTestCase(WgerTestCase):
self.edit_set(fail=False)
-class SetWorkoutCacheTestCase(WgerTestCase):
- """
- Workout cache test case
- """
-
- def test_canonical_form_cache_save(self):
- """
- Tests the workout cache when saving
- """
- set = Set.objects.get(pk=1)
- set.exerciseday.training.canonical_representation
- self.assertTrue(cache.get(cache_mapper.get_workout_canonical(set.exerciseday.training_id)))
-
- set.save()
- self.assertFalse(cache.get(cache_mapper.get_workout_canonical(set.exerciseday.training_id)))
-
- def test_canonical_form_cache_delete(self):
- """
- Tests the workout cache when deleting
- """
- set = Set.objects.get(pk=1)
- set.exerciseday.training.canonical_representation
- self.assertTrue(cache.get(cache_mapper.get_workout_canonical(set.exerciseday.training_id)))
-
- set.delete()
- self.assertFalse(cache.get(cache_mapper.get_workout_canonical(set.exerciseday.training_id)))
-
-
-class SettingWorkoutCacheTestCase(WgerTestCase):
- """
- Workout cache test case
- """
-
- def test_canonical_form_cache_save(self):
- """
- Tests the workout cache when saving
- """
- setting = Setting.objects.get(pk=1)
- workout_id = setting.set.exerciseday.training_id
- setting.set.exerciseday.training.canonical_representation
- self.assertTrue(cache.get(cache_mapper.get_workout_canonical(workout_id)))
-
- setting.save()
- self.assertFalse(cache.get(cache_mapper.get_workout_canonical(workout_id)))
-
- def test_canonical_form_cache_delete(self):
- """
- Tests the workout cache when deleting
- """
- setting = Setting.objects.get(pk=1)
- workout_id = setting.set.exerciseday.training_id
- setting.set.exerciseday.training.canonical_representation
- self.assertTrue(cache.get(cache_mapper.get_workout_canonical(workout_id)))
-
- setting.delete()
- self.assertFalse(cache.get(cache_mapper.get_workout_canonical(workout_id)))
-
-
class SetSmartReprTestCase(WgerTestCase):
"""Tests the "smart text representation" for sets"""
diff --git a/wger/manager/tests/test_workout.py b/wger/manager/tests/test_workout.py
index 21df6b0a4..f71b5b866 100644
--- a/wger/manager/tests/test_workout.py
+++ b/wger/manager/tests/test_workout.py
@@ -133,5 +133,4 @@ class WorkoutApiTestCase(api_base_test.ApiBaseResourceTestCase):
pk = 3
resource = Workout
private_resource = True
- special_endpoints = ('canonical_representation',)
data = {'name': 'A new comment'}
diff --git a/wger/manager/tests/test_workout_canonical.py b/wger/manager/tests/test_workout_canonical.py
deleted file mode 100644
index b958fdbbf..000000000
--- a/wger/manager/tests/test_workout_canonical.py
+++ /dev/null
@@ -1,251 +0,0 @@
-# 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
-
-# Django
-from django.core.cache import cache
-
-# wger
-from wger.core.models import DaysOfWeek
-from wger.core.tests.base_testcase import WgerTestCase
-from wger.exercises.models import (
- ExerciseBase,
- Muscle,
-)
-from wger.manager.models import (
- Day,
- Set,
- Setting,
- Workout,
-)
-from wger.utils.cache import cache_mapper
-
-
-class WorkoutCanonicalFormTestCase(WgerTestCase):
- """
- Tests the canonical form for a workout
- """
-
- maxDiff = None
-
- def test_canonical_form(self):
- """
- Tests the canonical form for a workout
- """
-
- workout = Workout.objects.get(pk=1)
- setting_1 = Setting.objects.get(pk=1)
- setting_2 = Setting.objects.get(pk=2)
- muscle1 = Muscle.objects.get(pk=1)
- muscle2 = Muscle.objects.get(pk=2)
- setting1 = Setting.objects.get(pk=1)
- setting2 = Setting.objects.get(pk=2)
- image1 = '/media/exercise-images/1/protestschwein.jpg'
- image2 = '/media/exercise-images/1/wildschwein.jpg'
- self.assertEqual(
- workout.canonical_representation['muscles'],
- {
- 'back': [muscle2],
- 'frontsecondary': [muscle1],
- 'backsecondary': [muscle1],
- 'front': [muscle1],
- },
- )
- self.assertEqual(workout.canonical_representation['obj'], workout)
-
- canonical_form = {
- 'days_of_week': {'day_list': [DaysOfWeek.objects.get(pk=2)], 'text': 'Tuesday'},
- 'muscles': {
- 'back': [muscle2],
- 'frontsecondary': [],
- 'backsecondary': [],
- 'front': [muscle1],
- },
- 'obj': Day.objects.get(pk=1),
- 'set_list': [
- {
- 'exercise_list': [
- {
- 'obj': ExerciseBase.objects.get(pk=1),
- 'image_list': [
- {'image': image1, 'is_main': True},
- {'image': image2, 'is_main': False},
- ],
- 'comment_list': [],
- 'has_weight': False,
- 'setting_obj_list': [setting_1],
- 'setting_text': '2 \xd7 8 (3 RiR)',
- }
- ],
- 'is_superset': False,
- 'muscles': {
- 'back': [muscle2],
- 'frontsecondary': [],
- 'backsecondary': [],
- 'front': [muscle1],
- },
- 'obj': Set.objects.get(pk=1),
- 'settings_computed': [setting1] * 2,
- }
- ],
- }
-
- days_test_data = workout.canonical_representation['day_list'][0]
- self.assertEqual(days_test_data['days_of_week'], canonical_form['days_of_week'])
- self.assertEqual(days_test_data['muscles'], canonical_form['muscles'])
- self.assertEqual(days_test_data['obj'], canonical_form['obj'])
-
- # Check that the content is the same
- for key in days_test_data['set_list'][0].keys():
- self.assertEqual(days_test_data['set_list'][0][key], canonical_form['set_list'][0][key])
-
- canonical_form = {
- 'days_of_week': {'day_list': [DaysOfWeek.objects.get(pk=4)], 'text': 'Thursday'},
- 'obj': Day.objects.get(pk=2),
- 'muscles': {
- 'back': [muscle2],
- 'frontsecondary': [muscle1],
- 'backsecondary': [muscle1],
- 'front': [],
- },
- 'set_list': [
- {
- 'exercise_list': [
- {
- 'obj': ExerciseBase.objects.get(pk=2),
- 'image_list': [{'image': image2, 'is_main': False}],
- 'comment_list': [],
- 'has_weight': True,
- 'setting_obj_list': [setting_2],
- 'setting_text': '4 \xd7 10 (15 kg)',
- }
- ],
- 'is_superset': False,
- 'muscles': {
- 'back': [muscle2],
- 'frontsecondary': [muscle1],
- 'backsecondary': [muscle1],
- 'front': [],
- },
- 'obj': Set.objects.get(pk=2),
- 'settings_computed': [setting2] * 4,
- }
- ],
- }
- days_test_data = workout.canonical_representation['day_list'][1]
- self.assertEqual(days_test_data['days_of_week'], canonical_form['days_of_week'])
- self.assertEqual(days_test_data['muscles'], canonical_form['muscles'])
- self.assertEqual(days_test_data['obj'], canonical_form['obj'])
-
- for key in days_test_data['set_list'][0].keys():
- self.assertEqual(days_test_data['set_list'][0][key], canonical_form['set_list'][0][key])
-
- # Check that the content is the same
- canonical_form = {
- 'days_of_week': {'day_list': [DaysOfWeek.objects.get(pk=5)], 'text': 'Friday'},
- 'obj': Day.objects.get(pk=4),
- 'muscles': {'back': [], 'front': [], 'frontsecondary': [], 'backsecondary': []},
- 'set_list': [],
- }
- self.assertEqual(workout.canonical_representation['day_list'][2], canonical_form)
-
- def test_canonical_form_day(self):
- """
- Tests the canonical form for a day
- """
-
- day = Day.objects.get(pk=5)
- weekday1 = DaysOfWeek.objects.get(pk=3)
- weekday2 = DaysOfWeek.objects.get(pk=5)
- muscle1 = Muscle.objects.get(pk=1)
- muscle2 = Muscle.objects.get(pk=2)
- setting = Setting.objects.get(pk=3)
- image2 = '/media/exercise-images/1/wildschwein.jpg'
- self.assertEqual(
- day.canonical_representation['days_of_week'],
- {'day_list': [weekday1, weekday2], 'text': 'Wednesday, Friday'},
- )
- self.assertEqual(
- day.canonical_representation['muscles'],
- {
- 'back': [muscle2],
- 'frontsecondary': [muscle1],
- 'backsecondary': [muscle1],
- 'front': [],
- },
- )
- self.assertEqual(day.canonical_representation['obj'], day)
-
- canonical_form = [
- {
- 'exercise_list': [
- {
- 'obj': ExerciseBase.objects.get(pk=2),
- 'image_list': [{'image': image2, 'is_main': False}],
- 'comment_list': [],
- 'has_weight': False,
- 'setting_obj_list': [Setting.objects.get(pk=3)],
- 'setting_text': '4 \xd7 10',
- }
- ],
- 'is_superset': False,
- 'muscles': {
- 'back': [muscle2],
- 'frontsecondary': [muscle1],
- 'backsecondary': [muscle1],
- 'front': [],
- },
- 'obj': Set.objects.get(pk=3),
- 'settings_computed': [setting] * 4,
- }
- ]
-
- self.assertEqual(day.canonical_representation['set_list'], canonical_form)
-
-
-class WorkoutCacheTestCase(WgerTestCase):
- """
- Test case for the workout canonical representation
- """
-
- def test_canonical_form_cache(self):
- """
- Tests that the workout cache of the canonical form is correctly generated
- """
- self.assertFalse(cache.get(cache_mapper.get_workout_canonical(1)))
-
- workout = Workout.objects.get(pk=1)
- workout.canonical_representation
- self.assertTrue(cache.get(cache_mapper.get_workout_canonical(1)))
-
- def test_canonical_form_cache_save(self):
- """
- Tests the workout cache when saving
- """
- workout = Workout.objects.get(pk=1)
- workout.canonical_representation
- self.assertTrue(cache.get(cache_mapper.get_workout_canonical(1)))
-
- workout.save()
- self.assertFalse(cache.get(cache_mapper.get_workout_canonical(1)))
-
- def test_canonical_form_cache_delete(self):
- """
- Tests the workout cache when deleting
- """
- workout = Workout.objects.get(pk=1)
- workout.canonical_representation
- self.assertTrue(cache.get(cache_mapper.get_workout_canonical(1)))
-
- workout.delete()
- self.assertFalse(cache.get(cache_mapper.get_workout_canonical(1)))
diff --git a/wger/utils/cache.py b/wger/utils/cache.py
index a83fabb07..77b2fa60e 100644
--- a/wger/utils/cache.py
+++ b/wger/utils/cache.py
@@ -31,10 +31,6 @@ def delete_template_fragment_cache(fragment_name='', vary_on=None):
cache.delete(make_template_fragment_key(fragment_name, out))
-def reset_workout_canonical_form(workout_id):
- cache.delete(cache_mapper.get_workout_canonical(workout_id))
-
-
def reset_exercise_api_cache(uuid: str):
cache.delete(cache_mapper.get_exercise_api_key(uuid))
@@ -59,7 +55,6 @@ class CacheKeyMapper:
# Keys used by the cache
LANGUAGE_CACHE_KEY = 'language-{0}'
INGREDIENT_CACHE_KEY = 'ingredient-{0}'
- WORKOUT_CANONICAL_REPRESENTATION = 'workout-canonical-representation-{0}'
WORKOUT_LOG_LIST = 'workout-log-hash-{0}'
NUTRITION_CACHE_KEY = 'nutrition-cache-log-{0}'
EXERCISE_API_KEY = 'base-uuid-{0}'
@@ -82,12 +77,6 @@ class CacheKeyMapper:
"""
return self.INGREDIENT_CACHE_KEY.format(self.get_pk(param))
- def get_workout_canonical(self, param):
- """
- Return the workout canonical representation
- """
- return self.WORKOUT_CANONICAL_REPRESENTATION.format(self.get_pk(param))
-
def get_workout_log_list(self, hash_value):
"""
Return the workout canonical representation