Self hosted FLOSS fitness/workout, nutrition and weight tracker
Add Personal Record trophy awarded every time a PR is beaten and test cases
Justind3d14f6ab7f7
diff --git a/wger/trophies/checkers/base.py b/wger/trophies/checkers/base.pyindex 613b9850f..d36a6e65e 100644--- a/wger/trophies/checkers/base.py+++ b/wger/trophies/checkers/base.py@@ -124,5 +124,16 @@ class BaseTrophyChecker(ABC):"""return True+ def get_context_data(self) -> Optional[dict]:+ """+ Returns context information about the trophy.++ Override this method in subclasses to return informative context.++ Returns:+ None if no context, dict context information otherwise+ """+ return None+def __repr__(self) -> str:return f'<{self.__class__.__name__}(user={self.user.username}, trophy={self.trophy.name})>'diff --git a/wger/trophies/checkers/personal_record.py b/wger/trophies/checkers/personal_record.pynew file mode 100644index 000000000..caf5f84ac--- /dev/null+++ b/wger/trophies/checkers/personal_record.py@@ -0,0 +1,143 @@+# This file is part of wger Workout Manager <https://github.com/wger-project>.+# Copyright (C) 2013 - 2021 wger Team+#+# 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 Affero General Public License for more details.+#+# You should have received a copy of the GNU Affero General Public License+# along with this program. If not, see <http://www.gnu.org/licenses/>.++from typing import Optional++from wger.trophies.models.trophy import Trophy+from wger.trophies.models.user_trophy import UserTrophy+from .base import BaseTrophyChecker+++class PersonalRecordChecker(BaseTrophyChecker):+ """+ Checker for Personal Record (PR) repeatable trophy.++ Used to detect when PRs are beaten and award trophies accordingly.++ params:+ log (WorkoutLog): workout log used to check if a PR was beaten.++ """++ def _estimate_one_rep_max(self):+ """+ Brzycki's formula: 1RM = weight * (36 / (37 - repetitions))+ """+ log = self.params.get('log', None)++ if not log: raise ValueError("Log should not be None")++ weight = getattr(log, 'weight', None)+ repetitions = getattr(log, 'repetitions', None)++ if weight is None:+ raise ValueError("Weight should not be None")+ if repetitions is None:+ raise ValueError("Repetitions should not be None")++ try:+ reps = int(repetitions)+ except (TypeError, ValueError):+ raise ValueError("Repetitions must be an integer")++ if reps == 37:+ raise ValueError("In Brzycki's formula, repetitions cannot be equal to 37.")++ try:+ w = float(weight)+ except (TypeError, ValueError):+ raise ValueError("Weight must be a number")++ return round(w * (36.0 / float(37 - reps)), 2)+++ def check(self) -> bool:+ """Check if user has beaten Personal Record."""+ log = self.params.get('log', None)++ if not log:+ return False++ exercise = getattr(log, 'exercise', None)++ pr_trophy = Trophy.objects.get(name="Personal Record")+ if not pr_trophy:+ raise Exception("Trophy 'Personal Record' not found.")++ last_pr = UserTrophy.objects.filter(+ user=log.user,+ trophy=pr_trophy,+ context_data__exercise_id=exercise.id,+ ).order_by('-earned_at').first()++ if last_pr and last_pr.context_data:+ prev = last_pr.context_data.get('one_rep_max_estimate')+ try:+ current = self._estimate_one_rep_max()+ except Exception:+ return False++ if prev is not None and prev >= current:+ return False++ return True+++ def get_progress(self) -> float:+ """Get progress as percentage."""+ return 100.0 if self.check() else 0.0++ def get_context_data(self) -> Optional[dict]:+ log = self.params.get('log', None)++ if not log:+ return None++ session = getattr(log, 'session', None)+ exercise = getattr(log, 'exercise', None)+ repetitions_unit = getattr(log, 'repetitions_unit', None)+ weight_unit = getattr(log, 'weight_unit', None)+ repetitions = getattr(log, 'repetitions', None)+ weight = getattr(log, 'weight', None)++ try:+ one_rm_estimate = self._estimate_one_rep_max()+ except Exception as e:+ print(f"PR estimation failed : {e}")+ one_rm_estimate = None++ return {+ 'log_id': getattr(log, 'id', None),+ 'date': getattr(log, 'date', None).isoformat(),+ 'session_id': getattr(session, 'id', None) if session else None,+ 'exercise_id': getattr(exercise, 'id', None) if exercise else None,+ 'repetitions_unit_id': getattr(repetitions_unit, 'id', None) if repetitions_unit else None,+ 'repetitions': float(repetitions) if repetitions else None,+ 'weight_unit_id': getattr(weight_unit, 'id', None) if weight_unit else None,+ 'weight': float(weight) if weight else None,+ 'iteration': getattr(log, 'iteration', None),+ 'one_rep_max_estimate': one_rm_estimate+ }++ def get_target_value(self) -> int:+ return 'N/A'++ def get_current_value(self) -> int:+ return 'N/A'++ def get_progress_display(self) -> str:+ return 'N/A'+diff --git a/wger/trophies/checkers/registry.py b/wger/trophies/checkers/registry.pyindex b7b5dee1c..bc96161bc 100644--- a/wger/trophies/checkers/registry.py+++ b/wger/trophies/checkers/registry.py@@ -24,6 +24,7 @@ from typing import (# Djangofrom django.contrib.auth.models import User+from wger.trophies.models.trophy import Trophy# Localfrom .base import BaseTrophyChecker@@ -34,6 +35,7 @@ from .streak import StreakCheckerfrom .time_based import TimeBasedCheckerfrom .volume import VolumeCheckerfrom .weekend_warrior import WeekendWarriorChecker+from .personal_record import PersonalRecordCheckerlogger = logging.getLogger(__name__)@@ -57,6 +59,7 @@ class CheckerRegistry:'time_based': TimeBasedChecker,'date_based': DateBasedChecker,'inactivity_return': InactivityReturnChecker,+ 'personal_record': PersonalRecordChecker,}@classmethod@@ -109,7 +112,7 @@ class CheckerRegistry:def create_checker(cls,user: User,- trophy: 'Trophy',+ trophy: Trophy,) -> Optional[BaseTrophyChecker]:"""Factory method to create a checker instance for a trophy.diff --git a/wger/trophies/management/commands/load_trophies.py b/wger/trophies/management/commands/load_trophies.pyindex fee11214b..dcbd6a4f1 100644--- a/wger/trophies/management/commands/load_trophies.py+++ b/wger/trophies/management/commands/load_trophies.py@@ -140,6 +140,17 @@ class Command(BaseCommand):'is_progressive': False,'order': 9,},+ {+ 'name': _('Personal Record'),+ 'description': _('Repeatable Personal Record (PR) trophy'),+ 'trophy_type': Trophy.TYPE_OTHER,+ 'checker_class': 'personal_record',+ 'checker_params': {},+ 'is_hidden': True,+ 'is_progressive': False,+ 'is_repeatable': True,+ 'order': 10,+ },]created_count = 0diff --git a/wger/trophies/migrations/0004_trophy_is_repeatable_usertrophy_context_data.py b/wger/trophies/migrations/0004_trophy_is_repeatable_usertrophy_context_data.pyindex 1ab30018a..d1af1e7ab 100644--- a/wger/trophies/migrations/0004_trophy_is_repeatable_usertrophy_context_data.py+++ b/wger/trophies/migrations/0004_trophy_is_repeatable_usertrophy_context_data.py@@ -9,6 +9,29 @@ class Migration(migrations.Migration):('trophies', '0003_load_initial_trophies'),]+ def create_personal_record_trophy(apps, schema_editor):+ Trophy = apps.get_model('trophies', 'Trophy')++ if not Trophy.objects.filter(name='Personal Record').exists():+ Trophy.objects.create(+ name='Personal Record',+ description='Repeatable Personal Record (PR) trophy',+ trophy_type='other',+ checker_class='personal_record',+ checker_params={},+ is_hidden=True,+ is_progressive=False,+ is_repeatable=True,+ order=10,+ )++ print(f'Trophy migration: Created trophy \'Personal Record\'')+++ def remove_personal_record_trophy(apps, schema_editor):+ Trophy = apps.get_model('trophies', 'Trophy')+ Trophy.objects.filter(name='Personal Record').delete()+operations = [migrations.AddField(model_name='trophy',@@ -20,4 +43,5 @@ class Migration(migrations.Migration):name='context_data',field=models.JSONField(blank=True, default=None, help_text='Additional information concerning this trophy', null=True, verbose_name='Context data'),),+ migrations.RunPython(create_personal_record_trophy, remove_personal_record_trophy),]diff --git a/wger/trophies/services/trophy.py b/wger/trophies/services/trophy.pyindex 91242733b..3f52d91a8 100644--- a/wger/trophies/services/trophy.py+++ b/wger/trophies/services/trophy.py@@ -72,14 +72,12 @@ class TrophyService:if cls.should_skip_user(user):return []- # Get all active trophies the user hasn't earned- earned_trophy_ids = UserTrophy.objects.filter(user=user).values_list('trophy_id', flat=True)- unevaluated_trophies = Trophy.objects.filter(is_active=True, is_repeatable=False).exclude(- id__in=earned_trophy_ids- )+ # Evaluate all active trophies. evaluate_trophy() will skip non-repeatable trophies+ # the user already has, while repeatable trophies are always checked.+ trophies = Trophy.objects.filter(is_active=True).order_by('order', 'name')awarded = []- for trophy in unevaluated_trophies:+ for trophy in trophies:user_trophy = cls.evaluate_trophy(user, trophy)if user_trophy:awarded.append(user_trophy)@@ -116,7 +114,8 @@ class TrophyService:try:if checker.check():- return cls.award_trophy(user, trophy, progress=100.0)+ context = checker.get_context_data()+ return cls.award_trophy(user, trophy, progress=100.0, context_data=context)except Exception as e:logger.error(f'Error checking trophy {trophy.name} for user {user.id}: {e}', exc_info=True@@ -125,7 +124,7 @@ class TrophyService:return None@classmethod- def award_trophy(cls, user: User, trophy: Trophy, progress: float = 100.0) -> UserTrophy:+ def award_trophy(cls, user: User, trophy: Trophy, progress: float = 100.0, context_data: Optional[dict]=None) -> UserTrophy:"""Award a trophy to a user.@@ -135,17 +134,24 @@ class TrophyService:user: The user to award the trophy totrophy: The trophy to awardprogress: The progress value (default 100 for earned)+ context_data: Additional information regarding the trophy awardedReturns:The created UserTrophy instance"""if trophy.is_repeatable:- user_trophy, created = UserTrophy.objects.create(user=user, trophy=trophy, progress=progress)+ created = True+ user_trophy = UserTrophy.objects.create(+ user=user,+ trophy=trophy,+ progress=progress,+ context_data=context_data+ )else:user_trophy, created = UserTrophy.objects.get_or_create(user=user,trophy=trophy,- defaults={'progress': progress},+ defaults={'progress': progress, 'context_data': context_data},)if created:diff --git a/wger/trophies/signals.py b/wger/trophies/signals.pyindex 0cf54e134..068d4a510 100644--- a/wger/trophies/signals.py+++ b/wger/trophies/signals.py@@ -36,7 +36,11 @@ from wger.manager.models import (WorkoutLog,WorkoutSession,)+from wger.trophies.checkers.registry import CheckerRegistry+from wger.trophies.models.trophy import Trophy+from wger.trophies.models.user_trophy import UserTrophyfrom wger.trophies.services import UserStatisticsService+from wger.trophies.services.trophy import TrophyServicefrom wger.trophies.tasks import evaluate_user_trophies_task@@ -87,6 +91,16 @@ def workout_log_saved(sender, instance, created, **kwargs):user=instance.user,workout_log=instance,)++ # Personal Record award+ trophy = Trophy.objects.get(name='Personal Record', is_active=True)+ checker = CheckerRegistry.create_checker(instance.user, trophy)+ checker.params = {'log': instance}+ existing = UserTrophy.objects.filter(user=instance.user, trophy=trophy, context_data__log_id=instance.id).exists()+ if not existing and checker and checker.check():+ context = checker.get_context_data()+ TrophyService.award_trophy(instance.user, trophy, progress=100.0, context_data=context)+else:# Edited log - full recalculation for accuracyUserStatisticsService.update_statistics(instance.user)@@ -96,7 +110,6 @@ def workout_log_saved(sender, instance, created, **kwargs):except Exception as e:logger.error(f'Error updating statistics for user {instance.user_id}: {e}', exc_info=True)-@receiver(post_delete, sender=WorkoutLog)def workout_log_deleted(sender, instance, **kwargs):"""diff --git a/wger/trophies/tests/test_checkers.py b/wger/trophies/tests/test_checkers.pyindex d02f3fb0a..81ddbb952 100644--- a/wger/trophies/tests/test_checkers.py+++ b/wger/trophies/tests/test_checkers.py@@ -21,6 +21,9 @@ from django.contrib.auth.models import User# wgerfrom wger.core.tests.base_testcase import WgerTestCase+from wger.exercises.models.base import Exercise+from wger.exercises.models.category import ExerciseCategory+from wger.manager.models.log import WorkoutLogfrom wger.trophies.checkers.count_based import CountBasedCheckerfrom wger.trophies.checkers.date_based import DateBasedCheckerfrom wger.trophies.checkers.inactivity_return import InactivityReturnChecker@@ -485,3 +488,118 @@ class InactivityReturnCheckerTestCase(WgerTestCase):checker = InactivityReturnChecker(self.user, self.trophy, {'inactive_days': 30})self.assertEqual(checker.get_progress(), 100.0)++class PersonalRecordCheckerTestCase(WgerTestCase):+ def setUp(self):+ super().setUp()++ self.user = User.objects.get(username='admin')+ self.exercise = Exercise.objects.create(category=ExerciseCategory.objects.create(name='c3'))++ self.trophy, _ = Trophy.objects.get_or_create(+ name='Personal Record',+ defaults={+ 'trophy_type': Trophy.TYPE_OTHER,+ 'checker_class': 'personal_record',+ 'checker_params': {},+ 'is_active': True,+ 'is_repeatable': True,+ }+ )++ def test_check_returns_false_with_no_logs(self):+ from wger.trophies.checkers.personal_record import PersonalRecordChecker++ checker = PersonalRecordChecker(self.user, self.trophy, {})+ self.assertFalse(checker.check())++ def test_first_log_counts_as_pr(self):+ from wger.trophies.checkers.personal_record import PersonalRecordChecker++ log = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=100)++ checker = PersonalRecordChecker(self.user, self.trophy, {'log': log})++ self.assertTrue(checker.check())+ context = checker.get_context_data()+ self.assertIsNotNone(context)++ def test_improvement_detected_and_context_values(self):+ from wger.trophies.checkers.personal_record import PersonalRecordChecker++ log1 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=100)+ checker1 = PersonalRecordChecker(self.user, self.trophy, {'log': log1})+ self.assertTrue(checker1.check())++ log2 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=110)+ checker2 = PersonalRecordChecker(self.user, self.trophy, {'log': log2})+ self.assertTrue(checker2.check())++ context = checker2.get_context_data()+ self.assertIsNotNone(context)++ def no_award_if_not_an_improvement(self):+ from wger.trophies.checkers.personal_record import PersonalRecordChecker++ log1 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=100)+ checker1 = PersonalRecordChecker(self.user, self.trophy, {'log': log1})+ self.assertTrue(checker1.check())++ # lower weight+ log2 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=90)+ checker2 = PersonalRecordChecker(self.user, self.trophy, {'log': log2})+ self.assertFalse(checker2.check())++ # same weight+ log3 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=100)+ checker3 = PersonalRecordChecker(self.user, self.trophy, {'log': log3})+ self.assertFalse(checker3.check())++ # better weight but lower repetitions+ log4 = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=3, weight=110)+ checker4 = PersonalRecordChecker(self.user, self.trophy, {'log': log4})+ self.assertFalse(checker4.check())++ def test_estimate_1rm(self):+ from wger.trophies.checkers.personal_record import PersonalRecordChecker++ log = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10, weight=100)+ one_rm = round(100 * (36.0 / (37 - 10)), 2)++ checker = PersonalRecordChecker(self.user, self.trophy, {'log': log})+ estimate = checker._estimate_one_rep_max()+ self.assertEquals(estimate, one_rm)+ self.assertEquals(checker.get_context_data().get("one_rep_max_estimate"), one_rm)++ def test_estimate_1rm_raises_on_missing_values(self):+ from wger.trophies.checkers.personal_record import PersonalRecordChecker++ # No log+ checker = PersonalRecordChecker(self.user, self.trophy, {})+ with self.assertRaises(ValueError):+ checker._estimate_one_rep_max()++ # Missing weight+ log = WorkoutLog(user=self.user, exercise=self.exercise, repetitions=10)+ checker = PersonalRecordChecker(self.user, self.trophy, {'log': log})+ with self.assertRaises(ValueError):+ checker._estimate_one_rep_max()++ # Missing repetitions+ log = WorkoutLog(user=self.user, exercise=self.exercise, weight=100)+ checker = PersonalRecordChecker(self.user, self.trophy, {'log': log})+ with self.assertRaises(ValueError):+ checker._estimate_one_rep_max()++ context = checker.get_context_data()+ self.assertIsNone(context.get("one_rep_max_estimate"))++ def test_estimate_1rm_raises_on_repetitions_37(self):+ from wger.trophies.checkers.personal_record import PersonalRecordChecker++ log = WorkoutLog(user=self.user, exercise=self.exercise, weight=100, repetitions=37)+ checker = PersonalRecordChecker(self.user, self.trophy, {'log': log})+ with self.assertRaises(ValueError):+ checker._estimate_one_rep_max()++\ No newline at end of filediff --git a/wger/trophies/tests/test_integration.py b/wger/trophies/tests/test_integration.pyindex 40ba8ebc6..c5a3833c4 100644--- a/wger/trophies/tests/test_integration.py+++ b/wger/trophies/tests/test_integration.py@@ -21,6 +21,8 @@ from django.contrib.auth.models import User# wgerfrom wger.core.tests.base_testcase import WgerTestCase+from wger.exercises.models.base import Exercise+from wger.exercises.models.category import ExerciseCategoryfrom wger.manager.models import (WorkoutLog,WorkoutSession,@@ -84,6 +86,15 @@ class TrophyIntegrationTestCase(WgerTestCase):is_progressive=True,)+ self.personal_record_trophy = Trophy.objects.create(+ name='Personal Record',+ trophy_type=Trophy.TYPE_OTHER,+ checker_class='personal_record',+ checker_params={},+ is_active=True,+ is_repeatable=True,+ )+def test_first_workout_earns_beginner_trophy(self):"""Test that completing first workout earns Beginner trophy"""# Create user statistics@@ -105,6 +116,49 @@ class TrophyIntegrationTestCase(WgerTestCase):self.assertEqual(len(awarded), 1)self.assertEqual(awarded[0].trophy, self.beginner_trophy)+ def test_personal_record_not_awarded_if_no_pr(self):+ """Only awards the Personal Record trophy if the log is a PR"""+ UserTrophy.objects.filter(user=self.user).delete()+ exercise = Exercise.objects.create(category=ExerciseCategory.objects.create(name='pr_cat'))++ # first log = PR+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=10, weight=100)+ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)+ self.assertEqual(pr_trophies.count(), 1)++ # not a PR+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=10, weight=100)+ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)+ self.assertEqual(pr_trophies.count(), 1)++ # not a PR+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=10, weight=90)+ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)+ self.assertEqual(pr_trophies.count(), 1)++ # not a PR+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=5, weight=101)+ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)+ self.assertEqual(pr_trophies.count(), 1)++ # PR+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=11, weight=100)+ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)+ self.assertEqual(pr_trophies.count(), 2)++ def test_personal_record_awarded_on_log_creation(self):+ """Creating a new WorkoutLog which is a PR awards the Personal Record trophy"""+ UserTrophy.objects.filter(user=self.user).delete()++ exercise = Exercise.objects.create(category=ExerciseCategory.objects.create(name='pr_cat'))+ WorkoutLog.objects.create(user=self.user, exercise=exercise, repetitions=10, weight=100)++ pr_trophies = UserTrophy.objects.filter(user=self.user, trophy=self.personal_record_trophy)+ self.assertEqual(pr_trophies.count(), 1)++ context = pr_trophies.first().context_data+ self.assertIsNotNone(context)+def test_lifting_5000kg_earns_lifter_trophy(self):"""Test that lifting 5000kg total earns Lifter trophy"""# Create user statisticsdiff --git a/wger/trophies/tests/test_models.py b/wger/trophies/tests/test_models.pyindex d62a7d69e..5a99aa845 100644--- a/wger/trophies/tests/test_models.py+++ b/wger/trophies/tests/test_models.py@@ -172,6 +172,9 @@ class UserTrophyModelTestCase(WgerTestCase):def setUp(self):super().setUp()self.user = User.objects.get(username='admin')++ UserTrophy.objects.filter(user=self.user).delete()+self.trophy = Trophy.objects.create(name='Test Trophy',trophy_type=Trophy.TYPE_COUNT,@@ -293,11 +296,11 @@ class UserTrophyModelTestCase(WgerTestCase):checker_class='volume',)- user_trophy1 = UserTrophy.objects.create(+ UserTrophy.objects.create(user=self.user,trophy=self.trophy,)- user_trophy2 = UserTrophy.objects.create(+ UserTrophy.objects.create(user=self.user,trophy=trophy2,)diff --git a/wger/trophies/tests/test_services.py b/wger/trophies/tests/test_services.pyindex 5f3e3b2e3..b8b87007d 100644--- a/wger/trophies/tests/test_services.py+++ b/wger/trophies/tests/test_services.py@@ -302,6 +302,19 @@ class TrophyServiceTestCase(WgerTestCase):hidden_in_list = any(p['trophy'].id == hidden_trophy.id for p in progress_list)self.assertTrue(hidden_in_list)+ def test_award_pr_trophy_multiple_times(self):+ """PR trophies can be awarded multiple times via TrophyService"""+ pr_trophy, _ = Trophy.objects.get_or_create(+ name="Personal Record",+ defaults={'is_repeatable': True, 'is_active': True},+ )++ ut1 = TrophyService.award_trophy(self.user, pr_trophy, progress=100.0, context_data={'log_id': 1})+ ut2 = TrophyService.award_trophy(self.user, pr_trophy, progress=100.0, context_data={'log_id': 2})++ self.assertEqual(UserTrophy.objects.filter(user=self.user, trophy=pr_trophy).count(), 2)+ self.assertNotEquals(ut1, ut2)+def test_should_skip_user_inactive(self):"""Test skipping inactive users"""# Set user's last login to over 30 days ago