Skip to content

armgit / wger

Public Imported from GitHub
0

Self hosted FLOSS fitness/workout, nutrition and weight tracker

Trim unused data from canonical representation

Roland Geider35f6aad3f6cd
diff --git a/wger/core/templates/tags/render_day.html b/wger/core/templates/tags/render_day.html
index f8ee03a30..68583990c 100644
--- a/wger/core/templates/tags/render_day.html
+++ b/wger/core/templates/tags/render_day.html
@@ -107,7 +107,7 @@ $(document).ready(function() {
<p>{{exercise.setting_text}}</p>
{% if editable %}
- {% if not exercise.setting_list %}
+ {% if not exercise.setting_obj_list %}
<p>
{% trans "This exercise has no repetitions." %}<br>
<a href="{% url 'manager:set:edit' set.obj.id %}" class="wger-modal-dialog">
diff --git a/wger/core/tests/test_user_login.py b/wger/core/tests/test_user_login.py
index 1c262dcbb..f0db2db38 100644
--- a/wger/core/tests/test_user_login.py
+++ b/wger/core/tests/test_user_login.py
@@ -1,5 +1,7 @@
+# Standard Library
from unittest import mock
+# wger
from wger.core.tests.base_testcase import WgerTestCase
from wger.core.views.user import trainer_login
diff --git a/wger/core/views/user.py b/wger/core/views/user.py
index a75f5d655..0f0fbadff 100644
--- a/wger/core/views/user.py
+++ b/wger/core/views/user.py
@@ -39,8 +39,8 @@ from django.contrib.auth.views import (
)
from django.http import (
HttpResponseForbidden,
- HttpResponseRedirect,
HttpResponseNotFound,
+ HttpResponseRedirect
)
from django.shortcuts import (
get_object_or_404,
diff --git a/wger/manager/api/serializers.py b/wger/manager/api/serializers.py
index 9939d76e8..fff98956a 100644
--- a/wger/manager/api/serializers.py
+++ b/wger/manager/api/serializers.py
@@ -146,11 +146,10 @@ class WorkoutCanonicalFormExerciseListSerializer(serializers.Serializer):
"""
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()
- setting_text = serializers.ReadOnlyField()
- settings_calculated = serializers.ReadOnlyField()
comment_list = serializers.ReadOnlyField()
image_list = WorkoutCanonicalFormExerciseImagesListSerializer(many=True)
obj = ExerciseSerializer()
@@ -162,8 +161,8 @@ class WorkoutCanonicalFormExerciseSerializer(serializers.Serializer):
"""
obj = SetSerializer()
exercise_list = WorkoutCanonicalFormExerciseListSerializer(many=True)
- has_settings = serializers.BooleanField()
is_superset = serializers.BooleanField()
+ settings_computed = SettingSerializer(many=True)
muscles = MusclesCanonicalFormSerializer()
diff --git a/wger/manager/helpers.py b/wger/manager/helpers.py
index e5445778d..e0a25c5ea 100644
--- a/wger/manager/helpers.py
+++ b/wger/manager/helpers.py
@@ -36,7 +36,6 @@ from reportlab.platypus import (
)
# wger
-from wger.utils.helpers import normalize_decimal
from wger.utils.pdf import (
header_colour,
row_color,
@@ -190,141 +189,6 @@ def render_workout_day(day, nr_of_weeks=7, images=False, comments=False, only_ta
return KeepTogether(t)
-def reps_smart_text(settings, set_obj):
- """
- "Smart" textual representation
-
- This is a human representation of the settings, in a way that humans
- would also write: e.g. "8 8 10 10" but "4 x 10" and not "10 10 10 10".
- This helper also takes care to process, hide or show the different repetition
- and weight units as appropriate, e.g. "8 x 2 Plates", "10, 20, 30, ∞"
-
- :param settings:
- :param set_obj:
- :return setting_text, setting_list:
- """
-
- def get_rir_representation(setting):
- """
- Returns the representation for the RepsInReserve for a setting
- """
-
- if setting.rir:
- rir = f"{setting.rir} RiR"
- else:
- rir = ""
- return rir
-
- def get_reps_reprentation(setting, rep_unit):
- """
- Returns the representation for the repetitions for a setting
-
- This is basically just to allow for a special representation for the
- "Until Failure" unit
- """
- if setting.repetition_unit_id != 2:
- reps = "{0} {1}".format(setting.reps, rep_unit).strip()
- else:
- reps = '∞'
- return reps
-
- def get_weight_unit_reprentation(setting):
- """
- Returns the representation for the weight unit for a setting
-
- This is basically just to allow for a special representation for the
- "Repetition" and "Until Failure" unit
- """
- if setting.repetition_unit.id not in (1, 2):
- rep_unit = _(setting.repetition_unit.name)
- else:
- rep_unit = ''
- return rep_unit
-
- def normalize_weight(setting):
- """
- The weight can be None, or a decimal. In that case, normalize so
- that we don't return e.g. '15.00', but always '15', independently of
- the database used.
- """
- if setting.weight:
- weight = normalize_decimal(setting.weight)
- else:
- weight = setting.weight
- return weight
-
- out = {'text': '',
- 'list': []}
-
- if len(settings) == 0:
- setting_text = ''
- setting_list = []
-
- # Only one setting entry, this is a "compact" representation such as e.g.
- # 4x10 or similar
- elif len(settings) == 1:
- setting = settings[0]
-
- rep_unit = get_weight_unit_reprentation(setting)
- reps = get_reps_reprentation(setting, rep_unit)
- weight_unit = settings[0].weight_unit.name
- weight = normalize_weight(setting)
- rir = get_rir_representation(setting)
-
- setting_text = '{0} × {1}'.format(set_obj.sets, reps).strip()
- setting_list_text = '{0} {1}'.format(reps, rep_unit).strip()
- if weight:
- setting_text += ' ({0} {1}'.format(weight, weight_unit)
- setting_list_text += ' ({0} {1}'.format(weight, weight_unit)
-
- setting_text += ', {0})'.format(rir) if rir else ')'
- setting_list_text += ', {0})'.format(rir) if rir else ')'
-
- else:
- setting_text += ' ({0})'.format(rir) if rir else ''
- setting_list_text += ' ({0})'.format(rir) if rir else ''
-
- setting_list = [setting_list_text] * set_obj.sets
-
- out['text'] = setting_text
- setting = {'reps': setting.reps,
- 'reps_unit': rep_unit,
- 'weight': weight,
- 'weight_unit': setting.weight_unit.name,
- 'rir': setting.rir}
- out['list'] = [setting] * set_obj.sets
-
- # There's more than one setting, each set can have a different combination
- # of repetitions, weight, etc. e.g. 10, 8, 8, 12
- elif len(settings) > 1:
- tmp_reps_text = []
- for setting in settings:
-
- rep_unit = get_weight_unit_reprentation(setting)
- reps = get_reps_reprentation(setting, rep_unit)
- weight = normalize_weight(setting)
- rir = get_rir_representation(setting)
- if weight:
- reps += ' ({0} {1}'.format(weight, setting.weight_unit)
- reps += ', {0})'.format(rir) if rir else ')'
- else:
- reps += ' ({0})'.format(rir) if rir else ''
-
- tmp_reps_text.append(reps)
- setting = {'reps': setting.reps,
- 'reps_unit': setting.repetition_unit.name,
- 'weight': weight,
- 'weight_unit': setting.weight_unit.name,
- 'rir': setting.rir}
- out['list'].append(setting)
-
- setting_text = ' – '.join(tmp_reps_text)
- setting_list = tmp_reps_text
- out['text'] = setting_text
-
- return setting_text, setting_list, out
-
-
class WorkoutCalendar(HTMLCalendar):
"""
A calendar renderer, see this blog entry for details:
diff --git a/wger/manager/models.py b/wger/manager/models.py
index 2c4e0b470..18e7f3508 100644
--- a/wger/manager/models.py
+++ b/wger/manager/models.py
@@ -42,13 +42,13 @@ from wger.core.models import (
WeightUnit
)
from wger.exercises.models import Exercise
-from wger.manager.helpers import reps_smart_text
from wger.utils.cache import (
cache_mapper,
reset_workout_canonical_form,
reset_workout_log
)
from wger.utils.fields import Html5DateField
+from wger.utils.helpers import normalize_decimal
logger = logging.getLogger(__name__)
@@ -459,7 +459,6 @@ class Day(models.Model):
for set_obj in self.set_set.select_related():
exercise_tmp = []
- has_setting_tmp = True
for exercise in set_obj.exercises:
setting_tmp = []
@@ -483,10 +482,7 @@ class Day(models.Model):
setting_tmp.append(setting)
# "Smart" textual representation
- setting_text, setting_list, out = reps_smart_text(setting_tmp, set_obj)
-
- # Flag indicating whether all exercises have settings
- has_setting_tmp = True if len(setting_tmp) > 0 else False
+ setting_text = set_obj.reps_smart_text(exercise)
# Exercise comments
comment_list = []
@@ -509,37 +505,32 @@ class Day(models.Model):
# Put it all together
exercise_tmp.append({'obj': exercise,
'setting_obj_list': setting_tmp,
- 'setting_list': setting_list,
- 'has_weight': has_weight,
-
'setting_text': setting_text,
- 'settings_calculated': out['list'],
+ '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, weight_list,\
- reps_list, repetition_units, weight_units = \
- reps_smart_text(exercise['setting_obj_list'], set_obj)
- exercise['setting_text'] = setting_text
- exercise['repetition_units'] = repetition_units
+
+ # 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,
- 'has_settings': has_setting_tmp,
+ 'settings_computed': set_obj.compute_settings,
'muscles': {
'back': muscles_back,
'front': muscles_front,
@@ -554,8 +545,7 @@ class Day(models.Model):
return {'obj': self,
'days_of_week': {
- 'text': ', '.join([str(_(i.day_of_week))
- for i in tmp_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,
@@ -620,6 +610,141 @@ class Set(models.Model):
"""Returns the exercises for this set"""
return list(dict.fromkeys([s.exercise for s in self.setting_set.all()]))
+ @property
+ def compute_settings(self): # -> typing.List[Setting]:
+ """
+ Compute the synthetic settings for this set.
+
+ If we have super sets the result will be an interleaved list of
+ settings so the result are the exercises that have to be done, in
+ order, e.g.:
+
+ * Exercise 1, 10 reps, 50 kg
+ * Exercise 2, 8 reps, 10 kg
+ * Exercise 1, 10 reps, 50 kg
+ * Exercise 2, 8 reps, 10 kg
+ """
+ setting_lists = []
+ for exercise in self.exercises:
+ setting_lists.append(self.computed_settings_exercise(exercise))
+
+ # Interleave all lists
+ return [val for tup in zip(*setting_lists) for val in tup]
+
+ def computed_settings_exercise(self, exercise: Exercise): # -> typing.List[Setting]
+ """
+ Returns a computed list of settings
+
+ If a set has only one set
+ """
+ settings = self.setting_set.filter(exercise=exercise)
+
+ if settings.count() == 0:
+ return[]
+ elif settings.count() == 1:
+ setting = settings.first()
+ return [setting] * self.sets
+ else:
+ return list(settings.all())
+
+ def reps_smart_text(self, exercise: Exercise):
+ """
+ "Smart" textual representation
+
+ This is a human representation of the settings, in a way that humans
+ would also write: e.g. "8 8 10 10" but "4 x 10" and not "10 10 10 10".
+ This helper also takes care to process, hide or show the different repetition
+ and weight units as appropriate, e.g. "8 x 2 Plates", "10, 20, 30, ∞"
+
+ :param exercise:
+ :return setting_text, setting_list:
+ """
+
+ def get_rir_representation(setting):
+ """
+ Returns the representation for the Reps-In-Reserve for a setting
+ """
+
+ if setting.rir:
+ rir = f"{setting.rir} RiR"
+ else:
+ rir = ""
+ return rir
+
+ def get_reps_reprentation(setting, rep_unit):
+ """
+ Returns the representation for the repetitions for a setting
+
+ This is basically just to allow for a special representation for the
+ "Until Failure" unit
+ """
+ if setting.repetition_unit_id != 2:
+ reps = "{0} {1}".format(setting.reps, rep_unit).strip()
+ else:
+ reps = '∞'
+ return reps
+
+ def get_weight_unit_reprentation(setting):
+ """
+ Returns the representation for the weight unit for a setting
+
+ This is basically just to allow for a special representation for the
+ "Repetition" and "Until Failure" unit
+ """
+ if setting.repetition_unit.id not in (1, 2):
+ rep_unit = _(setting.repetition_unit.name)
+ else:
+ rep_unit = ''
+ return rep_unit
+
+ def normalize_weight(setting):
+ """
+ The weight can be None, or a decimal. In that case, normalize so
+ that we don't return e.g. '15.00', but always '15', independently of
+ the database used.
+ """
+ if setting.weight:
+ weight = normalize_decimal(setting.weight)
+ else:
+ weight = setting.weight
+ return weight
+
+ def get_setting_text(current_setting, multi=False):
+ """Gets the repetition text for a complete setting"""
+ rep_unit = get_weight_unit_reprentation(current_setting)
+ reps = get_reps_reprentation(current_setting, rep_unit)
+ weight_unit = settings[0].weight_unit.name
+ weight = normalize_weight(current_setting)
+ rir = get_rir_representation(current_setting)
+ out = '{0} × {1}'.format(self.sets, reps).strip() if not multi else reps
+ if weight:
+ rir_text = f', {rir}' if rir else ''
+ out += f' ({weight} {weight_unit}{rir_text})'
+ else:
+ out += ' ({0})'.format(rir) if rir else ''
+
+ return out
+
+ settings = self.setting_set.filter(exercise=exercise)
+ setting_text = ''
+
+ # Only one setting entry, this is a "compact" representation such as e.g.
+ # 4x10 or similar
+ if len(settings) == 1:
+ setting = settings[0]
+ setting_text = get_setting_text(setting)
+
+ # There's more than one setting, each set can have a different combination
+ # of repetitions, weight, etc. e.g. 10, 8, 8, 12
+ elif len(settings) > 1:
+ tmp_reps_text = []
+ for setting in settings:
+ tmp_reps_text.append(get_setting_text(setting, multi=True))
+
+ setting_text = ' – '.join(tmp_reps_text)
+
+ return setting_text
+
class Setting(models.Model):
"""
@@ -687,7 +812,7 @@ class Setting(models.Model):
"""
Return a more human-readable representation
"""
- return "settings for exercise {0} in set {1}".format(self.exercise.id, self.set.id)
+ return f"setting {self.id} for exercise {self.exercise_id} in set {self.set_id}"
def save(self, *args, **kwargs):
"""
diff --git a/wger/manager/tests/test_set.py b/wger/manager/tests/test_set.py
index 4aad28e4d..a1e026bdd 100644
--- a/wger/manager/tests/test_set.py
+++ b/wger/manager/tests/test_set.py
@@ -15,6 +15,7 @@
# Standard Library
import logging
from decimal import Decimal
+from typing import List
# Django
from django.core.cache import cache
@@ -31,7 +32,6 @@ from wger.core.tests.base_testcase import (
WgerTestCase
)
from wger.exercises.models import Exercise
-from wger.manager.helpers import reps_smart_text
from wger.manager.models import (
Day,
Set,
@@ -421,7 +421,7 @@ class SettingWorkoutCacheTestCase(WgerTestCase):
self.assertFalse(cache.get(cache_mapper.get_workout_canonical(workout_id)))
-class SetSmartRepr(WgerTestCase):
+class SetSmartReprTestCase(WgerTestCase):
"""Tests the "smart text representation" for sets"""
def test_smart_repr_one_setting(self):
@@ -429,82 +429,96 @@ class SetSmartRepr(WgerTestCase):
Tests the representation with one setting
"""
set_obj = Set.objects.get(pk=1)
- settings = [i for i in set_obj.setting_set.all()]
- setting_text, setting_list, out = reps_smart_text(settings, set_obj)
+ setting_text = set_obj.reps_smart_text(set_obj.exercises[0])
self.assertEqual(setting_text, '2 × 8 (3 RiR)')
- self.assertEqual(len(out['list']), 2)
- self.assertEqual(out['list'][0],
- {'reps': 8,
- 'reps_unit': '',
- 'weight': None,
- 'weight_unit': 'kg',
- 'rir': '3'})
def test_smart_repr_custom_setting(self):
"""
Tests the representation with several settings
"""
set_obj = Set(exerciseday_id=1, order=1, sets=4)
+ set_obj.save()
setting1 = Setting(set=set_obj,
exercise_id=1,
repetition_unit_id=1,
reps=8,
weight=Decimal(90),
weight_unit_id=1,
- rir='3')
+ rir='3',
+ order=1)
+ setting1.save()
setting2 = Setting(set=set_obj,
exercise_id=1,
repetition_unit_id=1,
reps=10,
weight=Decimal(80),
weight_unit_id=1,
- rir='2.5')
+ rir='2.5',
+ order=2)
+ setting2.save()
setting3 = Setting(set=set_obj,
exercise_id=1,
repetition_unit_id=1,
reps=10,
weight=Decimal(80),
weight_unit_id=1,
- rir='2')
+ rir='2',
+ order=3)
+ setting3.save()
setting4 = Setting(set=set_obj,
exercise_id=1,
repetition_unit_id=1,
reps=12,
weight=Decimal(80),
weight_unit_id=1,
- rir='1')
+ rir='1',
+ order=4)
+ setting4.save()
- setting_text, setting_list, out = reps_smart_text([setting1, setting2, setting3, setting4],
- set_obj)
- self.assertEqual(len(out['list']), 4)
+ setting_text = set_obj.reps_smart_text(Exercise.objects.get(pk=1))
self.assertEqual(setting_text,
'8 (90 kg, 3 RiR) – 10 (80 kg, 2.5 RiR) – '
'10 (80 kg, 2 RiR) – 12 (80 kg, 1 RiR)')
- self.assertEqual(out['list'][0],
- {'reps': 8,
- 'reps_unit': 'Repetitions',
- 'weight': Decimal('90'),
- 'weight_unit': 'kg',
- 'rir': '3'})
- self.assertEqual(out['list'][1],
- {'reps': 10,
- 'reps_unit': 'Repetitions',
- 'weight': Decimal('80'),
- 'weight_unit': 'kg',
- 'rir': '2.5'})
- self.assertEqual(out['list'][2],
- {'reps': 10,
- 'reps_unit': 'Repetitions',
- 'weight': Decimal('80'),
- 'weight_unit': 'kg',
- 'rir': '2'})
- self.assertEqual(out['list'][3],
- {'reps': 12,
- 'reps_unit': 'Repetitions',
- 'weight': Decimal('80'),
- 'weight_unit': 'kg',
- 'rir': '1'})
+
+ def test_synthetic_settings(self):
+ set_obj = Set(exerciseday_id=1, order=1, sets=4)
+ set_obj.save()
+ setting1 = Setting(set=set_obj,
+ exercise_id=1,
+ repetition_unit_id=1,
+ reps=8,
+ weight=Decimal(90),
+ weight_unit_id=1,
+ rir='3',
+ order=1)
+ setting1.save()
+ setting2 = Setting(set=set_obj,
+ exercise_id=3,
+ repetition_unit_id=1,
+ reps=10,
+ weight=Decimal(80),
+ weight_unit_id=1,
+ rir='2.5',
+ order=2)
+ setting2.save()
+ settings: List[Setting] = set_obj.compute_settings
+
+ # Check that there are 2 x 4 entries (2 Exercises x 4 Sets)
+ self.assertEqual(len(settings), 8)
+
+ # Check interleaved settings
+ for i in range(0, len(settings)):
+ if (i % 2) == 0:
+ self.assertEqual(settings[i].exercise_id, 1)
+ self.assertEqual(settings[i].reps, 8)
+ self.assertEqual(settings[i].weight, Decimal(90))
+ self.assertEqual(settings[i].rir, '3')
+ else:
+ self.assertEqual(settings[i].exercise_id, 3)
+ self.assertEqual(settings[i].reps, 10)
+ self.assertEqual(settings[i].weight, Decimal(80))
+ self.assertEqual(settings[i].rir, '2.5')
class SetApiTestCase(api_base_test.ApiBaseResourceTestCase):
diff --git a/wger/manager/tests/test_workout_canonical.py b/wger/manager/tests/test_workout_canonical.py
index 0a81f28f5..fe6fb1e50 100644
--- a/wger/manager/tests/test_workout_canonical.py
+++ b/wger/manager/tests/test_workout_canonical.py
@@ -12,9 +12,6 @@
#
# You should have received a copy of the GNU Affero General Public License
-# Standard Library
-from decimal import Decimal
-
# Django
from django.core.cache import cache
@@ -50,6 +47,8 @@ class WorkoutCanonicalFormTestCase(WgerTestCase):
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'],
@@ -74,46 +73,25 @@ class WorkoutCanonicalFormTestCase(WgerTestCase):
'has_weight': False,
'setting_obj_list': [setting_1],
'setting_text': '2 \xd7 8 (3 RiR)',
- 'setting_list': ['8 (3 RiR)',
- '8 (3 RiR)'],
- 'settings_calculated': [
- {
- "reps": 8,
- "reps_unit": "",
- "weight": None,
- "weight_unit": "kg",
- "rir": '3'
- },
- {
- "reps": 8,
- "reps_unit": "",
- "weight": None,
- "weight_unit": "kg",
- "rir": '3'
- }]
}],
'is_superset': False,
- 'has_settings': True,
'muscles': {'back': [muscle2],
'frontsecondary': [],
'backsecondary': [],
'front': [muscle1]},
- 'obj': Set.objects.get(pk=1)}]}
+ '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'])
- self.assertEqual(days_test_data['set_list'][0]['exercise_list'],
- canonical_form['set_list'][0]['exercise_list'])
- self.assertEqual(days_test_data['set_list'][0]['is_superset'],
- canonical_form['set_list'][0]['is_superset'])
- self.assertEqual(days_test_data['set_list'][0]['has_settings'],
- canonical_form['set_list'][0]['has_settings'])
- self.assertEqual(days_test_data['set_list'][0]['muscles'],
- canonical_form['set_list'][0]['muscles'])
- self.assertEqual(days_test_data['set_list'][0]['obj'], canonical_form['set_list'][0]['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'},
@@ -128,64 +106,27 @@ class WorkoutCanonicalFormTestCase(WgerTestCase):
'is_main': False}],
'comment_list': ['Foobar'],
'has_weight': True,
- 'setting_list': ['10 (15 kg)',
- '10 (15 kg)',
- '10 (15 kg)',
- '10 (15 kg)'],
'setting_obj_list': [setting_2],
'setting_text': '4 \xd7 10 (15 kg)',
- 'settings_calculated': [
- {
- "reps": 10,
- "reps_unit": "",
- "weight": Decimal(15),
- "weight_unit": "kg",
- "rir": None
- },
- {
- "reps": 10,
- "reps_unit": "",
- "weight": Decimal(15),
- "weight_unit": "kg",
- "rir": None
- },
- {
- "reps": 10,
- "reps_unit": "",
- "weight": Decimal(15),
- "weight_unit": "kg",
- "rir": None
- },
- {
- "reps": 10,
- "reps_unit": "",
- "weight": Decimal(15),
- "weight_unit": "kg",
- "rir": None
- }],
}],
'is_superset': False,
- 'has_settings': True,
'muscles': {'back': [muscle2],
'frontsecondary': [muscle1],
'backsecondary': [muscle1],
'front': []},
- 'obj': Set.objects.get(pk=2)}]}
+ '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'])
- self.assertEqual(days_test_data['set_list'][0]['exercise_list'],
- canonical_form['set_list'][0]['exercise_list'])
- self.assertEqual(days_test_data['set_list'][0]['is_superset'],
- canonical_form['set_list'][0]['is_superset'])
- self.assertEqual(days_test_data['set_list'][0]['has_settings'],
- canonical_form['set_list'][0]['has_settings'])
- self.assertEqual(days_test_data['set_list'][0]['muscles'],
- canonical_form['set_list'][0]['muscles'])
- self.assertEqual(days_test_data['set_list'][0]['obj'], canonical_form['set_list'][0]['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),
@@ -193,7 +134,8 @@ class WorkoutCanonicalFormTestCase(WgerTestCase):
'front': [],
'frontsecondary': [],
'backsecondary': []},
- 'set_list': []}
+ 'set_list': [],
+ }
self.assertEqual(workout.canonical_representation['day_list'][2], canonical_form)
def test_canonical_form_day(self):
@@ -206,6 +148,7 @@ class WorkoutCanonicalFormTestCase(WgerTestCase):
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'})
@@ -222,46 +165,16 @@ class WorkoutCanonicalFormTestCase(WgerTestCase):
'is_main': False}],
'comment_list': ['Foobar'],
'has_weight': False,
- 'setting_list': ['10', '10', '10', '10'],
'setting_obj_list': [Setting.objects.get(pk=3)],
'setting_text': '4 \xd7 10',
- 'settings_calculated': [
- {
- "reps": 10,
- "reps_unit": "",
- "weight": None,
- "weight_unit": "kg",
- "rir": None
- },
- {
- "reps": 10,
- "reps_unit": "",
- "weight": None,
- "weight_unit": "kg",
- "rir": None
- },
- {
- "reps": 10,
- "reps_unit": "",
- "weight": None,
- "weight_unit": "kg",
- "rir": None
- },
- {
- "reps": 10,
- "reps_unit": "",
- "weight": None,
- "weight_unit": "kg",
- "rir": None
- }],
}],
'is_superset': False,
- 'has_settings': True,
'muscles': {'back': [muscle2],
'frontsecondary': [muscle1],
'backsecondary': [muscle1],
'front': []},
- 'obj': Set.objects.get(pk=3)}]
+ 'obj': Set.objects.get(pk=3),
+ 'settings_computed': [setting] * 4}]
self.assertEqual(day.canonical_representation['set_list'], canonical_form)
diff --git a/wger/manager/views/log.py b/wger/manager/views/log.py
index 1e27a5389..7356fea31 100644
--- a/wger/manager/views/log.py
+++ b/wger/manager/views/log.py
@@ -72,6 +72,7 @@ from wger.weight.helpers import (
process_log_entries
)
+
logger = logging.getLogger(__name__)