Self hosted FLOSS fitness/workout, nutrition and weight tracker
Simplify the powersync handlers by registering the individual ones
Roland Geiderf1950c534579
diff --git a/settings/main.py b/settings/main.pyindex 32c4892ea..2ce32945e 100644--- a/settings/main.py+++ b/settings/main.py@@ -105,7 +105,7 @@ POWERSYNC_JWKS_PRIVATE_KEY = env.str('POWERSYNC_JWKS_PRIVATE_KEY', '')POWERSYNC_URL_PATH = env.str('POWERSYNC_URL_PATH', 'ps')POWERSYNC_URL = env.str('POWERSYNC_URL', '')if not DEBUG and any(- POWERSYNC_JWKS_PUBLIC_KEY and hashlib.sha256(key.encode()).hexdigest() in _DEFAULT_POWERSYNC_KEY_HASHES+ key and hashlib.sha256(key.encode()).hexdigest() in _DEFAULT_POWERSYNC_KEY_HASHESfor key in (POWERSYNC_JWKS_PUBLIC_KEY, POWERSYNC_JWKS_PRIVATE_KEY)):warnings.warn(diff --git a/wger/core/api/views.py b/wger/core/api/views.pyindex 8c446f123..18aff74e9 100644--- a/wger/core/api/views.py+++ b/wger/core/api/views.py@@ -57,11 +57,13 @@ from rest_framework.permissions import (from rest_framework.response import Response# wger-import wger.gallery.powersync as ps_gallery-import wger.manager.powersync as ps_manager-import wger.measurements.powersync as ps_measurements-import wger.nutrition.powersync as ps_nutrition-import wger.weight.powersync as ps_weight+# The per-app powersync modules are imported for their side effect: each one+# registers its handlers with wger.utils.powersync.REGISTRY at import time.+import wger.gallery.powersync # noqa: F401+import wger.manager.powersync # noqa: F401+import wger.measurements.powersync # noqa: F401+import wger.nutrition.powersync # noqa: F401+import wger.weight.powersync # noqa: F401from wger.core.api import powersyncfrom wger.core.api.serializers import (LanguageCheckSerializer,@@ -83,6 +85,7 @@ from wger.core.models import ()from wger.utils.api_token import create_tokenfrom wger.utils.permissions import WgerPermission+from wger.utils.powersync import REGISTRY as POWERSYNC_REGISTRYfrom wger.version import (MIN_APP_VERSION,MIN_SERVER_VERSION,@@ -492,145 +495,17 @@ def upload_powersync_data(request):logger.info(f'Received PowerSync data for table {table} via {http_verb} for user {user_id}')- # Each handler returns either `None` (operation processed successfully) or- # an error dict which we propagate back to the client. The HTTP status stays- # at 200 even on logical errors since powersync treats non-2xx statuses as- # "retry forever".- result: dict | None = None+ handler = POWERSYNC_REGISTRY.get(table)+ if handler is None:+ logger.warning(f'Received unknown PowerSync table: {table}')+ return JsonResponse({'error': f'Unknown table: {table}'}, status=200)++ # Handlers return either `None` (operation processed successfully) or an+ # error dict which we propagate back to the client. The HTTP status stays+ # at 200 even on logical errors, since powersync treats non-2xx statuses+ # as "retry forever".try:- match table:- # Body weight- case 'weight_weightentry':- if http_verb == 'PUT':- result = ps_weight.handle_create(- payload=payload,- user_id=user_id,- request=request,- )- elif http_verb == 'PATCH':- result = ps_weight.handle_update(- payload=payload,- user_id=user_id,- request=request,- )- elif http_verb == 'DELETE':- result = ps_weight.handle_delete(payload=payload, user_id=user_id)-- # Measurements- case 'measurements_category':- if http_verb == 'PUT':- result = ps_measurements.handle_create_category(- payload=payload, user_id=user_id- )- elif http_verb == 'PATCH':- result = ps_measurements.handle_update_category(- payload=payload, user_id=user_id- )- elif http_verb == 'DELETE':- result = ps_measurements.handle_delete_category(- payload=payload, user_id=user_id- )-- case 'measurements_measurement':- if http_verb == 'PUT':- result = ps_measurements.handle_create_measurement(- payload=payload, user_id=user_id- )- elif http_verb == 'PATCH':- result = ps_measurements.handle_update_measurement(- payload=payload, user_id=user_id- )- elif http_verb == 'DELETE':- result = ps_measurements.handle_delete_measurement(- payload=payload, user_id=user_id- )-- # Routines- case 'manager_workoutlog':- if http_verb == 'PUT':- result = ps_manager.handle_create_log(payload=payload, user_id=user_id)- elif http_verb == 'PATCH':- result = ps_manager.handle_update_log(payload=payload, user_id=user_id)- elif http_verb == 'DELETE':- result = ps_manager.handle_delete_log(payload=payload, user_id=user_id)-- case 'manager_workoutsession':- if http_verb == 'PUT':- result = ps_manager.handle_create_session(payload=payload, user_id=user_id)- elif http_verb == 'PATCH':- result = ps_manager.handle_update_session(payload=payload, user_id=user_id)- elif http_verb == 'DELETE':- result = ps_manager.handle_delete_session(payload=payload, user_id=user_id)-- case 'manager_routine':- # Creation still goes through REST; only edit and delete reach us via PowerSync- if http_verb == 'PATCH':- result = ps_manager.handle_update_routine(payload=payload, user_id=user_id)- elif http_verb == 'DELETE':- result = ps_manager.handle_delete_routine(payload=payload, user_id=user_id)- elif http_verb == 'PUT':- result = {- 'error': 'Method not allowed',- 'details': 'Routine creation must go through the REST API',- }-- # Nutrition- case 'nutrition_nutritionplan':- if http_verb == 'PUT':- result = ps_nutrition.handle_create_plan(payload=payload, user_id=user_id)- elif http_verb == 'PATCH':- result = ps_nutrition.handle_update_plan(payload=payload, user_id=user_id)- elif http_verb == 'DELETE':- result = ps_nutrition.handle_delete_plan(payload=payload, user_id=user_id)-- case 'nutrition_meal':- if http_verb == 'PUT':- result = ps_nutrition.handle_create_meal(payload=payload, user_id=user_id)- elif http_verb == 'PATCH':- result = ps_nutrition.handle_update_meal(payload=payload, user_id=user_id)- elif http_verb == 'DELETE':- result = ps_nutrition.handle_delete_meal(payload=payload, user_id=user_id)-- case 'nutrition_mealitem':- if http_verb == 'PUT':- result = ps_nutrition.handle_create_mealitem(- payload=payload, user_id=user_id- )- elif http_verb == 'PATCH':- result = ps_nutrition.handle_update_mealitem(- payload=payload, user_id=user_id- )- elif http_verb == 'DELETE':- result = ps_nutrition.handle_delete_mealitem(- payload=payload, user_id=user_id- )-- case 'nutrition_logitem':- if http_verb == 'PUT':- result = ps_nutrition.handle_create_log(payload=payload, user_id=user_id)- elif http_verb == 'PATCH':- result = ps_nutrition.handle_update_log(payload=payload, user_id=user_id)- elif http_verb == 'DELETE':- result = ps_nutrition.handle_delete_log(payload=payload, user_id=user_id)-- # Gallery- case 'gallery_image':- # Creation (and edits that swap the file) still go through REST,- # because PowerSync can't carry the binary upload. Only metadata- # edits and deletes reach us via PowerSync.- if http_verb == 'PATCH':- result = ps_gallery.handle_update_image(payload=payload, user_id=user_id)- elif http_verb == 'DELETE':- result = ps_gallery.handle_delete_image(payload=payload, user_id=user_id)- elif http_verb == 'PUT':- result = {- 'error': 'Method not allowed',- 'details': 'Gallery image creation must go through the REST API',- }-- case _:- logger.warning(f'Received unknown PowerSync table: {table}')- return JsonResponse({'error': f'Unknown table: {table}'}, status=200)+ result = handler.dispatch(http_verb, payload=payload, user_id=user_id)except Exception as e:logger.exception(f'Error processing PowerSync data for table {table}')return JsonResponse({'error': str(e)}, status=200)diff --git a/wger/core/tests/powersync_base_test.py b/wger/core/tests/powersync_base_test.pyindex 205b9b7ef..8ed02d60f 100644--- a/wger/core/tests/powersync_base_test.py+++ b/wger/core/tests/powersync_base_test.py@@ -95,6 +95,15 @@ class PowerSyncCreateTestCase:)return self.resource.objects.get(pk=new_pks.pop())+ def _client_supplied_id_field(self, obj):+ """+ Return the value of the field that the client-supplied ``id`` should+ round-trip into. Defaults to ``pk`` (correct for UUID-PK models like+ Category). Models with an integer PK and a separate UUID column+ (WeightEntry) override this to return ``obj.uuid``.+ """+ return obj.pk+def test_create_anonymous_forbidden(self):if self.resource is None or self.create_payload is None:return@@ -132,7 +141,7 @@ class PowerSyncCreateTestCase:new_obj = self._diff_new_object(pks_before)self.assertEqual(- str(new_obj.pk),+ str(self._client_supplied_id_field(new_obj)),str(self.create_payload['id']),'Server replaced the client-supplied id with a fresh one',)diff --git a/wger/gallery/powersync.py b/wger/gallery/powersync.pyindex df9bcfa70..ab047714a 100644--- a/wger/gallery/powersync.py+++ b/wger/gallery/powersync.py@@ -13,67 +13,32 @@# You should have received a copy of the GNU Affero General Public License# along with Workout Manager. If not, see <http://www.gnu.org/licenses/>.-# Standard Library-import logging-from typing import Any-# wgerfrom wger.gallery.api.serializers import ImageSerializerfrom wger.gallery.models import Image+from wger.utils.powersync import (+ PowerSyncHandler,+ register_handler,+)-logger = logging.getLogger(__name__)---def handle_update_image(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PATCH event for a gallery image.-- Creation still goes through REST (the file upload itself can't be carried- by the PowerSync push pipeline), so there is no `handle_create_image`. Edits- that swap the image file likewise go through REST, only metadata-only edits- (date, description) reach this handler.+@register_handler+class ImageHandler(PowerSyncHandler):+ """+ Creation (and edits that swap the file itself) goes through REST because+ the binary upload can't be carried by the PowerSync push pipeline; only+ metadata-only PATCH and DELETE arrive here. The ``image`` field is dropped+ from the payload because it would otherwise overwrite the ImageField with+ a relative path string.++ The model's ``post_delete`` signal removes the underlying file from+ storage in the same transaction as the row delete."""- logger.debug(f'Received PowerSync payload for gallery image update: {payload}')- try:- entry = Image.objects.get(pk=payload['id'], user_id=user_id)- except Image.DoesNotExist:- logger.warning(- f'Gallery image with id {payload["id"]} and user {user_id} not found for update.'- )- return {- 'error': 'Not found',- 'details': f'Gallery image with id {payload["id"]} not found',- }-- # Drop the binary `image` field — the file is owned by Django and only- # changes via REST. PowerSync only carries the relative path, which would- # break the ImageField on a partial update.- payload.pop('image', None)-- serializer = ImageSerializer(entry, data=payload, partial=True)- if serializer.is_valid():- serializer.save()- logger.info(f'Updated gallery image {entry.pk} for user {user_id}')- return None- logger.warning(f'PowerSync gallery image update validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}--def handle_delete_image(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync DELETE event for a gallery image.+ model = Image+ serializer_class = ImageSerializer+ supports_create = False- The model's `post_delete` signal also removes the underlying file from- storage in the same transaction.- """- logger.debug(f'Received PowerSync payload for gallery image delete: {payload}')- try:- entry = Image.objects.get(pk=payload['id'], user_id=user_id)- except Image.DoesNotExist:- logger.warning(f'Gallery image with id {payload["id"]} not found for delete.')- return {- 'error': 'Not found',- 'details': f'Gallery image with id {payload["id"]} not found',- }- entry.delete()- logger.info(f'Deleted gallery image {payload["id"]} for user {user_id}')- return None+ def preprocess_payload(self, payload):+ payload.pop('image', None)+ return payloaddiff --git a/wger/manager/powersync.py b/wger/manager/powersync.pyindex eb06a3507..b72c9c52d 100644--- a/wger/manager/powersync.py+++ b/wger/manager/powersync.py@@ -13,10 +13,6 @@# You should have received a copy of the GNU Affero General Public License# along with Workout Manager. If not, see <http://www.gnu.org/licenses/>.-# Standard Library-import logging-from typing import Any-# wgerfrom wger.manager.api.serializers import (RoutineSerializer,@@ -33,173 +29,40 @@ from wger.manager.models import (WorkoutLog,WorkoutSession,)-from wger.utils.viewsets import check_fk_ownership---logger = logging.getLogger(__name__)---def handle_update_log(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a push event from PowerSync"""- logger.debug(f'Received PowerSync payload for update: {payload}')- try:- entry = WorkoutLog.objects.get(pk=payload['id'], user_id=user_id)- except WorkoutLog.DoesNotExist:- logger.warning(- f'WorkoutLog with UUID {payload["id"]} and user {user_id} not found for update.'- )- return {'error': 'Not found', 'details': f'WorkoutLog with UUID {payload["id"]} not found'}-- if not check_fk_ownership(payload, WorkoutLogViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'WorkoutLog references an object you do not own'}-- serializer = WorkoutLogSerializer(- entry, data=payload, partial=True, context={'user_id': user_id}- )- if serializer.is_valid():- serializer.save()- logger.info(f'Updated WorkoutLog {entry.pk} for user {user_id}')- return None- logger.warning(f'PowerSync update validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_create_log(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a create event from PowerSync"""- logger.debug(f'Received PowerSync payload for create: {payload}')-- if not check_fk_ownership(payload, WorkoutLogViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'WorkoutLog references an object you do not own'}-- serializer = WorkoutLogSerializer(data=payload, context={'user_id': user_id})- if serializer.is_valid():- serializer.save(user_id=user_id)- return None- logger.warning(f'PowerSync create validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_delete_log(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a delete event from PowerSync"""- logger.debug(f'Received PowerSync payload for delete: {payload}')- try:- entry = WorkoutLog.objects.get(pk=payload['id'], user_id=user_id)- except WorkoutLog.DoesNotExist:- logger.warning(f'WorkoutLog with UUID {payload["id"]} not found for delete.')- return {'error': 'Not found', 'details': f'WorkoutLog with UUID {payload["id"]} not found'}- entry.delete()- return None---def handle_update_session(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a push event from PowerSync"""- logger.debug(f'Received PowerSync payload for update: {payload}')- try:- entry = WorkoutSession.objects.get(pk=payload['id'], user_id=user_id)- except WorkoutSession.DoesNotExist:- logger.warning(- f'WorkoutSession with UUID {payload["id"]} and user {user_id} not found for update.'- )- return {- 'error': 'Not found',- 'details': f'WorkoutSession with UUID {payload["id"]} not found',- }-- if not check_fk_ownership(payload, WorkoutSessionViewSet.get_owner_objects(), user_id):- return {- 'error': 'Forbidden',- 'details': 'WorkoutSession references an object you do not own',- }-- serializer = WorkoutSessionSerializer(entry, data=payload, partial=True)- if serializer.is_valid():- serializer.save()- logger.info(f'Updated WorkoutSession {entry.pk} for user {user_id}')- return None- logger.warning(f'PowerSync update validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_create_session(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a create event from PowerSync"""- logger.debug(f'Received PowerSync payload for create: {payload}')+from wger.utils.powersync import (+ PowerSyncHandler,+ register_handler,+)- if not check_fk_ownership(payload, WorkoutSessionViewSet.get_owner_objects(), user_id):- return {- 'error': 'Forbidden',- 'details': 'WorkoutSession references an object you do not own',- }- serializer = WorkoutSessionSerializer(data=payload)- if serializer.is_valid():- serializer.save(user_id=user_id)- return None- logger.warning(f'PowerSync create validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}+@register_handler+class WorkoutLogHandler(PowerSyncHandler):+ """+ Logs reference both a ``Routine`` and a ``WorkoutSession``; the serializer+ consults ``user_id`` from the context when pinning a log to a session.+ """+ model = WorkoutLog+ serializer_class = WorkoutLogSerializer+ viewset_class = WorkoutLogViewSet+ pass_user_id_in_context = True-def handle_delete_session(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a delete event from PowerSync"""- logger.debug(f'Received PowerSync payload for delete: {payload}')- try:- entry = WorkoutSession.objects.get(pk=payload['id'], user_id=user_id)- except WorkoutSession.DoesNotExist:- logger.warning(f'WorkoutSession with UUID {payload["id"]} not found for delete.')- return {- 'error': 'Not found',- 'details': f'WorkoutSession with UUID {payload["id"]} not found',- }- entry.delete()- return None+@register_handler+class WorkoutSessionHandler(PowerSyncHandler):+ model = WorkoutSession+ serializer_class = WorkoutSessionSerializer+ viewset_class = WorkoutSessionViewSet-def handle_update_routine(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PATCH event for a routine.- Creation still goes through REST (the backend assigns the integer PK and- `created` timestamp), so there is no `handle_create_routine` here — only- edit and delete are part of the PowerSync upload pipeline.+@register_handler+class RoutineHandler(PowerSyncHandler):"""- logger.debug(f'Received PowerSync payload for routine update: {payload}')- try:- entry = Routine.objects.get(pk=payload['id'], user_id=user_id)- except Routine.DoesNotExist:- logger.warning(- f'Routine with id {payload["id"]} and user {user_id} not found for update.'- )- return {- 'error': 'Not found',- 'details': f'Routine with id {payload["id"]} not found',- }-- if not check_fk_ownership(payload, RoutineViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'Routine references an object you do not own'}-- serializer = RoutineSerializer(entry, data=payload, partial=True)- if serializer.is_valid():- serializer.save()- logger.info(f'Updated Routine {entry.pk} for user {user_id}')- return None- logger.warning(f'PowerSync routine update validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_delete_routine(payload: dict[str, Any], user_id: int) -> dict | None:+ Creation goes through REST so the backend can assign the integer PK and+ ``created`` timestamp; only PATCH/DELETE arrive via PowerSync."""- Handle a PowerSync DELETE event for a routine.- Django's FK CASCADE removes all dependent days, slots, set configs,- sessions and logs in the same transaction.- """- logger.debug(f'Received PowerSync payload for routine delete: {payload}')- try:- entry = Routine.objects.get(pk=payload['id'], user_id=user_id)- except Routine.DoesNotExist:- logger.warning(f'Routine with id {payload["id"]} not found for delete.')- return {- 'error': 'Not found',- 'details': f'Routine with id {payload["id"]} not found',- }- entry.delete()- logger.info(f'Deleted Routine {payload["id"]} for user {user_id}')- return None+ model = Routine+ serializer_class = RoutineSerializer+ viewset_class = RoutineViewSet+ supports_create = Falsediff --git a/wger/manager/tests/test_log_session_api.py b/wger/manager/tests/test_log_session_api.pyindex d6e6bcd7d..546ca3a2e 100644--- a/wger/manager/tests/test_log_session_api.py+++ b/wger/manager/tests/test_log_session_api.py@@ -23,15 +23,12 @@ from rest_framework import status# wgerfrom wger.core.tests.base_testcase import WgerTestCase+from wger.core.tests.powersync_base_test import PowerSyncBaseTestCase+from wger.manager.api.serializers import WorkoutLogSerializerfrom wger.manager.models import (WorkoutLog,WorkoutSession,)-from wger.manager.powersync import (- handle_create_log,- handle_update_log,-)-OWN_SESSION = 'bbbbbbbb-bbbb-bbbb-bbbb-000000000001'@@ -65,7 +62,6 @@ class WorkoutLogSessionPinningRESTTestCase(WgerTestCase):super().setUp()self.user_login('admin')-def test_create_log_with_explicit_own_session(self):"""POST with an own session UUID pins the log to that session."""@@ -108,9 +104,7 @@ class WorkoutLogSessionPinningRESTTestCase(WgerTestCase):"""POST without a session falls back to the legacy auto-create."""new_date = datetime.date(2030, 6, 15)- before = WorkoutSession.objects.filter(- user_id=1, routine_id=1, date=new_date- ).count()+ before = WorkoutSession.objects.filter(user_id=1, routine_id=1, date=new_date).count()self.assertEqual(before, 0)response = self.client.post(@@ -157,14 +151,20 @@ class WorkoutLogSessionPinningRESTTestCase(WgerTestCase):self.assertEqual(str(log.session_id), OWN_SESSION_OTHER_DATE)-class WorkoutLogSessionPinningPowerSyncTestCase(WgerTestCase):+class WorkoutLogSessionPinningPowerSyncTestCase(PowerSyncBaseTestCase):"""- Same scenarios, but exercising the PowerSync upload handlers directly.+ Same scenarios as the REST suite, but pushed through the PowerSync upload+ endpoint. Logs in this fixture are owned by ``admin`` (user 1)."""+ table = 'manager_workoutlog'+ user_access = 'admin'+def test_create_log_with_explicit_own_session(self):before = WorkoutLog.objects.filter(session_id=OWN_SESSION_OTHER_DATE).count()- result = handle_create_log(+ self.authenticate()+ response = self.push(+ 'PUT',{'exercise': 1,'routine': 1,@@ -173,15 +173,17 @@ class WorkoutLogSessionPinningPowerSyncTestCase(WgerTestCase):'weight': 30,'repetitions': 8,},- user_id=1,)- self.assertIsNone(result)+ self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)+ self.assertEqual(response.json(), {'status': 'ok!'})after = WorkoutLog.objects.filter(session_id=OWN_SESSION_OTHER_DATE).count()self.assertEqual(after, before + 1)def test_create_log_with_foreign_session_returns_forbidden(self):before = WorkoutLog.objects.count()- result = handle_create_log(+ self.authenticate()+ response = self.push(+ 'PUT',{'exercise': 1,'routine': 1,@@ -190,29 +192,25 @@ class WorkoutLogSessionPinningPowerSyncTestCase(WgerTestCase):'weight': 30,'repetitions': 8,},- user_id=1,)- self.assertIsNotNone(result)- self.assertEqual(result.get('error'), 'Forbidden')+ self.assertEqual(response.status_code, status.HTTP_200_OK)+ self.assertEqual(response.json().get('error'), 'Forbidden')self.assertEqual(WorkoutLog.objects.count(), before)def test_update_log_with_foreign_session_returns_forbidden(self):- result = handle_update_log(- {'id': OWN_LOG, 'session': FOREIGN_SESSION},- user_id=1,- )- self.assertIsNotNone(result)- self.assertEqual(result.get('error'), 'Forbidden')+ self.authenticate()+ response = self.push('PATCH', {'id': OWN_LOG, 'session': FOREIGN_SESSION})+ self.assertEqual(response.status_code, status.HTTP_200_OK)+ self.assertEqual(response.json().get('error'), 'Forbidden')log = WorkoutLog.objects.get(pk=OWN_LOG)self.assertEqual(str(log.session_id), OWN_SESSION)def test_update_log_pins_own_session(self):- result = handle_update_log(- {'id': OWN_LOG, 'session': OWN_SESSION_OTHER_DATE},- user_id=1,- )- self.assertIsNone(result)+ self.authenticate()+ response = self.push('PATCH', {'id': OWN_LOG, 'session': OWN_SESSION_OTHER_DATE})+ self.assertEqual(response.status_code, status.HTTP_200_OK, response.content)+ self.assertEqual(response.json(), {'status': 'ok!'})log = WorkoutLog.objects.get(pk=OWN_LOG)self.assertEqual(str(log.session_id), OWN_SESSION_OTHER_DATE)@@ -226,8 +224,6 @@ class WorkoutLogSerializerSessionFilterTestCase(WgerTestCase):"""def test_serializer_rejects_foreign_session_via_user_id_context(self):- from wger.manager.api.serializers import WorkoutLogSerializer-serializer = WorkoutLogSerializer(data={'exercise': 1,@@ -243,8 +239,6 @@ class WorkoutLogSerializerSessionFilterTestCase(WgerTestCase):self.assertIn('session', serializer.errors)def test_serializer_accepts_own_session_via_user_id_context(self):- from wger.manager.api.serializers import WorkoutLogSerializer-serializer = WorkoutLogSerializer(data={'exercise': 1,@@ -265,8 +259,6 @@ class WorkoutLogSerializerSessionFilterTestCase(WgerTestCase):able to resolve any session UUID — the queryset is empty bydefault, so the call falls through to a validation error."""- from wger.manager.api.serializers import WorkoutLogSerializer-serializer = WorkoutLogSerializer(data={'exercise': 1,diff --git a/wger/measurements/powersync.py b/wger/measurements/powersync.pyindex 83a611047..f2f11a05e 100644--- a/wger/measurements/powersync.py+++ b/wger/measurements/powersync.py@@ -13,10 +13,6 @@# You should have received a copy of the GNU Affero General Public License# along with Workout Manager. If not, see <http://www.gnu.org/licenses/>.-# Standard Library-import logging-from typing import Any-# wgerfrom wger.measurements.api.serializers import (CategorySerializer,@@ -27,116 +23,30 @@ from wger.measurements.models import (Category,Measurement,)-from wger.utils.viewsets import check_fk_ownership---logger = logging.getLogger(__name__)---#-# Categories-#---def handle_create_category(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PUT event for a measurement category."""- logger.debug(f'Received PowerSync payload for category create: {payload}')- serializer = CategorySerializer(data=payload)- if serializer.is_valid():- serializer.save(user_id=user_id)- logger.info(f'Created Category {payload["id"]} for user {user_id}')- return None- logger.warning(f'PowerSync category create validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_update_category(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PATCH event for a measurement category."""- logger.debug(f'Received PowerSync payload for category update: {payload}')- try:- entry = Category.objects.get(pk=payload['id'], user_id=user_id)- except Category.DoesNotExist:- logger.warning(f'Category {payload["id"]} for user {user_id} not found for update.')- return {'error': 'Not found', 'details': f'Category {payload["id"]} not found'}-- serializer = CategorySerializer(entry, data=payload, partial=True)- if serializer.is_valid():- serializer.save()- logger.info(f'Updated Category {entry.pk} for user {user_id}')- return None- logger.warning(f'PowerSync category update validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_delete_category(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync DELETE event for a measurement category.-- Django's FK CASCADE removes any dependent measurements in the same- transaction.- """- logger.debug(f'Received PowerSync payload for category delete: {payload}')- try:- entry = Category.objects.get(pk=payload['id'], user_id=user_id)- except Category.DoesNotExist:- logger.warning(f'Category {payload["id"]} not found for delete.')- return {'error': 'Not found', 'details': f'Category {payload["id"]} not found'}- entry.delete()- logger.info(f'Deleted Category {payload["id"]} for user {user_id}')- return None---#-# Measurements-#---def handle_create_measurement(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PUT event for a measurement."""- logger.debug(f'Received PowerSync payload for measurement create: {payload}')-- if not check_fk_ownership(payload, MeasurementViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'Measurement references a category you do not own'}+from wger.utils.powersync import (+ PowerSyncHandler,+ register_handler,+)- serializer = MeasurementSerializer(data=payload)- if serializer.is_valid():- serializer.save()- logger.info(f'Created Measurement {payload["id"]} for user {user_id}')- return None- logger.warning(f'PowerSync measurement create validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}+@register_handler+class CategoryHandler(PowerSyncHandler):+ """Measurement categories — directly owned by ``user`` so no FK ownership check is needed."""-def handle_update_measurement(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PATCH event for a measurement."""- logger.debug(f'Received PowerSync payload for measurement update: {payload}')- try:- entry = Measurement.objects.get(pk=payload['id'], category__user_id=user_id)- except Measurement.DoesNotExist:- logger.warning(- f'Measurement {payload["id"]} for user {user_id} not found for update.'- )- return {'error': 'Not found', 'details': f'Measurement {payload["id"]} not found'}+ model = Category+ serializer_class = CategorySerializer- if not check_fk_ownership(payload, MeasurementViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'Measurement references a category you do not own'}- serializer = MeasurementSerializer(entry, data=payload, partial=True)- if serializer.is_valid():- serializer.save()- logger.info(f'Updated Measurement {entry.pk} for user {user_id}')- return None- logger.warning(f'PowerSync measurement update validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}+@register_handler+class MeasurementHandler(PowerSyncHandler):+ """Measurements live under a ``Category``; ownership rides on that FK."""+ model = Measurement+ serializer_class = MeasurementSerializer+ viewset_class = MeasurementViewSet+ user_filter = 'category__user_id'-def handle_delete_measurement(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync DELETE event for a measurement."""- logger.debug(f'Received PowerSync payload for measurement delete: {payload}')- try:- entry = Measurement.objects.get(pk=payload['id'], category__user_id=user_id)- except Measurement.DoesNotExist:- logger.warning(f'Measurement {payload["id"]} not found for delete.')- return {'error': 'Not found', 'details': f'Measurement {payload["id"]} not found'}- entry.delete()- logger.info(f'Deleted Measurement {payload["id"]} for user {user_id}')- return None+ def create_save_kwargs(self, payload, user_id):+ # Ownership is enforced through the category FK, not via a direct+ # user_id on the Measurement row.+ return {}diff --git a/wger/nutrition/powersync.py b/wger/nutrition/powersync.pyindex daf5d0b50..8e0385776 100644--- a/wger/nutrition/powersync.py+++ b/wger/nutrition/powersync.py@@ -13,10 +13,6 @@# You should have received a copy of the GNU Affero General Public License# along with Workout Manager. If not, see <http://www.gnu.org/licenses/>.-# Standard Library-import logging-from typing import Any-# wgerfrom wger.nutrition.api.serializers import (LogItemSerializer,@@ -36,242 +32,55 @@ from wger.nutrition.models import (MealItem,NutritionPlan,)-from wger.utils.viewsets import check_fk_ownership---logger = logging.getLogger(__name__)---#-# Nutritional plans-#---def handle_create_plan(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PUT event for a nutritional plan."""- logger.debug(f'Received PowerSync payload for nutritional plan create: {payload}')- serializer = NutritionPlanSerializer(data=payload)- if serializer.is_valid():- serializer.save(user_id=user_id)- logger.info(f'Created NutritionPlan {payload["id"]} for user {user_id}')- return None- logger.warning(f'PowerSync nutritional plan create validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_update_plan(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PATCH event for a nutritional plan."""- logger.debug(f'Received PowerSync payload for nutritional plan update: {payload}')- try:- entry = NutritionPlan.objects.get(pk=payload['id'], user_id=user_id)- except NutritionPlan.DoesNotExist:- logger.warning(- f'NutritionPlan {payload["id"]} for user {user_id} not found for update.'- )- return {- 'error': 'Not found',- 'details': f'NutritionPlan {payload["id"]} not found',- }-- if not check_fk_ownership(payload, NutritionPlanViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'NutritionPlan references an object you do not own'}+from wger.utils.powersync import (+ PowerSyncHandler,+ register_handler,+)- serializer = NutritionPlanSerializer(entry, data=payload, partial=True)- if serializer.is_valid():- serializer.save()- logger.info(f'Updated NutritionPlan {entry.pk} for user {user_id}')- return None- logger.warning(f'PowerSync nutritional plan update validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}+@register_handler+class NutritionPlanHandler(PowerSyncHandler):+ model = NutritionPlan+ serializer_class = NutritionPlanSerializer+ viewset_class = NutritionPlanViewSet-def handle_delete_plan(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync DELETE event for a nutritional plan.- Django's FK CASCADE removes all dependent meals, meal items and diary- log entries in the same transaction.+@register_handler+class MealHandler(PowerSyncHandler):"""- logger.debug(f'Received PowerSync payload for nutritional plan delete: {payload}')- try:- entry = NutritionPlan.objects.get(pk=payload['id'], user_id=user_id)- except NutritionPlan.DoesNotExist:- logger.warning(f'NutritionPlan {payload["id"]} not found for delete.')- return {- 'error': 'Not found',- 'details': f'NutritionPlan {payload["id"]} not found',- }- entry.delete()- logger.info(f'Deleted NutritionPlan {payload["id"]} for user {user_id}')- return None---#-# Meals-#---def handle_create_meal(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PUT event for a meal.-- The `order` field is set to whatever the client computed (or 1 by default,- matching the existing REST `perform_create`).+ Meals live under a plan; ownership is enforced via the ``plan`` FK, not a+ direct user_id on the row. ``order`` defaults to 1, matching the existing+ REST ``perform_create``."""- logger.debug(f'Received PowerSync payload for meal create: {payload}')-- if not check_fk_ownership(payload, MealViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'Meal references an object you do not own'}-- serializer = MealSerializer(data=payload)- if serializer.is_valid():- serializer.save(order=payload.get('order', 1))- logger.info(f'Created Meal {payload["id"]} for user {user_id}')- return None- logger.warning(f'PowerSync meal create validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_update_meal(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PATCH event for a meal."""- logger.debug(f'Received PowerSync payload for meal update: {payload}')- try:- entry = Meal.objects.get(pk=payload['id'], plan__user_id=user_id)- except Meal.DoesNotExist:- logger.warning(f'Meal {payload["id"]} for user {user_id} not found for update.')- return {'error': 'Not found', 'details': f'Meal {payload["id"]} not found'}-- if not check_fk_ownership(payload, MealViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'Meal references an object you do not own'}-- serializer = MealSerializer(entry, data=payload, partial=True)- if serializer.is_valid():- serializer.save()- logger.info(f'Updated Meal {entry.pk} for user {user_id}')- return None- logger.warning(f'PowerSync meal update validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_delete_meal(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync DELETE event for a meal.-- Django's FK CASCADE removes all dependent meal items in the same transaction.- """- logger.debug(f'Received PowerSync payload for meal delete: {payload}')- try:- entry = Meal.objects.get(pk=payload['id'], plan__user_id=user_id)- except Meal.DoesNotExist:- logger.warning(f'Meal {payload["id"]} not found for delete.')- return {'error': 'Not found', 'details': f'Meal {payload["id"]} not found'}- entry.delete()- logger.info(f'Deleted Meal {payload["id"]} for user {user_id}')- return None---#-# Meal items-#---def handle_create_mealitem(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PUT event for a meal item."""- logger.debug(f'Received PowerSync payload for meal item create: {payload}')-- if not check_fk_ownership(payload, MealItemViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'MealItem references an object you do not own'}-- serializer = MealItemSerializer(data=payload)- if serializer.is_valid():- serializer.save(order=payload.get('order', 1))- logger.info(f'Created MealItem {payload["id"]} for user {user_id}')- return None- logger.warning(f'PowerSync meal item create validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_update_mealitem(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PATCH event for a meal item."""- logger.debug(f'Received PowerSync payload for meal item update: {payload}')- try:- entry = MealItem.objects.get(pk=payload['id'], meal__plan__user_id=user_id)- except MealItem.DoesNotExist:- logger.warning(f'MealItem {payload["id"]} for user {user_id} not found for update.')- return {'error': 'Not found', 'details': f'MealItem {payload["id"]} not found'}-- if not check_fk_ownership(payload, MealItemViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'MealItem references an object you do not own'}-- serializer = MealItemSerializer(entry, data=payload, partial=True)- if serializer.is_valid():- serializer.save()- logger.info(f'Updated MealItem {entry.pk} for user {user_id}')- return None- logger.warning(f'PowerSync meal item update validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_delete_mealitem(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync DELETE event for a meal item."""- logger.debug(f'Received PowerSync payload for meal item delete: {payload}')- try:- entry = MealItem.objects.get(pk=payload['id'], meal__plan__user_id=user_id)- except MealItem.DoesNotExist:- logger.warning(f'MealItem {payload["id"]} not found for delete.')- return {'error': 'Not found', 'details': f'MealItem {payload["id"]} not found'}- entry.delete()- logger.info(f'Deleted MealItem {payload["id"]} for user {user_id}')- return None---#-# Log items (nutrition diary)-#--def handle_create_log(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PUT event for a diary log entry."""- logger.debug(f'Received PowerSync payload for log create: {payload}')+ model = Meal+ serializer_class = MealSerializer+ viewset_class = MealViewSet+ user_filter = 'plan__user_id'- if not check_fk_ownership(payload, LogItemViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'LogItem references an object you do not own'}+ def create_save_kwargs(self, payload, user_id):+ return {'order': payload.get('order', 1)}- serializer = LogItemSerializer(data=payload)- if serializer.is_valid():- serializer.save()- logger.info(f'Created LogItem {payload["id"]} for user {user_id}')- return None- logger.warning(f'PowerSync log create validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}+@register_handler+class MealItemHandler(PowerSyncHandler):+ model = MealItem+ serializer_class = MealItemSerializer+ viewset_class = MealItemViewSet+ user_filter = 'meal__plan__user_id'-def handle_update_log(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync PATCH event for a diary log entry."""- logger.debug(f'Received PowerSync payload for log update: {payload}')- try:- entry = LogItem.objects.get(pk=payload['id'], plan__user_id=user_id)- except LogItem.DoesNotExist:- logger.warning(f'LogItem {payload["id"]} for user {user_id} not found for update.')- return {'error': 'Not found', 'details': f'LogItem {payload["id"]} not found'}+ def create_save_kwargs(self, payload, user_id):+ return {'order': payload.get('order', 1)}- if not check_fk_ownership(payload, LogItemViewSet.get_owner_objects(), user_id):- return {'error': 'Forbidden', 'details': 'LogItem references an object you do not own'}- serializer = LogItemSerializer(entry, data=payload, partial=True)- if serializer.is_valid():- serializer.save()- logger.info(f'Updated LogItem {entry.pk} for user {user_id}')- return None- logger.warning(f'PowerSync log update validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}+@register_handler+class LogItemHandler(PowerSyncHandler):+ """Diary log entries — owned via the plan FK chain."""+ model = LogItem+ serializer_class = LogItemSerializer+ viewset_class = LogItemViewSet+ user_filter = 'plan__user_id'-def handle_delete_log(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a PowerSync DELETE event for a diary log entry."""- logger.debug(f'Received PowerSync payload for log delete: {payload}')- try:- entry = LogItem.objects.get(pk=payload['id'], plan__user_id=user_id)- except LogItem.DoesNotExist:- logger.warning(f'LogItem {payload["id"]} not found for delete.')- return {'error': 'Not found', 'details': f'LogItem {payload["id"]} not found'}- entry.delete()- logger.info(f'Deleted LogItem {payload["id"]} for user {user_id}')- return None+ def create_save_kwargs(self, payload, user_id):+ return {}diff --git a/wger/utils/powersync.py b/wger/utils/powersync.pynew file mode 100644index 000000000..94146523c--- /dev/null+++ b/wger/utils/powersync.py@@ -0,0 +1,240 @@+# 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+# along with Workout Manager. If not, see <http://www.gnu.org/licenses/>.++"""+Shared infrastructure for the PowerSync push handlers.++Each app declares one ``PowerSyncHandler`` subclass per synchronised table+and registers it via ``@register_handler``. The dispatcher in+``wger.core.api.views.upload_powersync_data`` looks up the handler by table+name and calls ``dispatch(http_verb, ...)``.+"""++# Standard Library+import logging+from typing import Any++# Django+from django.db.models import Model++# Third Party+from rest_framework.serializers import Serializer++# wger+from wger.utils.viewsets import check_fk_ownership+++logger = logging.getLogger(__name__)+++REGISTRY: dict[str, 'PowerSyncHandler'] = {}+++class PowerSyncHandler:+ """+ Base class for PowerSync upload handlers.++ Subclasses set declarative attributes describing the table, model,+ serializer and ownership rules. The most common variations+ (``lookup_field``, ``user_filter``, FK-ownership viewset, serializer+ context, save kwargs, payload preprocessing) are all expressible via+ attributes or single-method overrides.+ """++ # Django model and DRF serializer for the table.+ model: type[Model] = None+ serializer_class: type[Serializer] = None++ # PowerSync table name. Populated by ``register_handler`` from+ # ``model._meta.db_table`` — the same value PowerSync sees in Postgres.+ table: str = ''++ # Set to a ViewSet class to enable check_fk_ownership against+ # ``ViewSetClass.get_owner_objects()``. Leave as None if the model has+ # no FKs that need ownership-validation (e.g. WeightEntry, Category).+ viewset_class = None++ # Lookup config for update/delete:+ # Model.objects.get(<lookup_field>=payload['id'], <user_filter>=user_id)+ # ``lookup_field`` is 'pk' (most models) or 'uuid' (WeightEntry).+ # ``user_filter`` is 'user_id' for direct ownership or a chained lookup+ # like 'plan__user_id' / 'meal__plan__user_id' / 'category__user_id'.+ lookup_field: str = 'pk'+ user_filter: str = 'user_id'++ # Set to False for tables where creation must go through REST (Routine,+ # Image). The dispatcher then returns "Method not allowed" instead of+ # running the create handler.+ supports_create: bool = True++ # If True, the handler passes ``user_id`` into the serializer context so+ # that owner-scoped fields (e.g. WorkoutLogSerializer.session) can filter+ # their queryset.+ pass_user_id_in_context: bool = False++ @property+ def label(self) -> str:+ """Human-readable model name used in log lines and error details."""+ return self.model.__name__++ #+ # Hooks+ #++ def preprocess_payload(self, payload: dict[str, Any]) -> dict[str, Any]:+ """+ Last-chance mutation of the payload before validation. Default is a+ no-op; gallery uses this to drop the binary ``image`` field that only+ REST is allowed to write.+ """+ return payload++ def create_save_kwargs(self, payload: dict[str, Any], user_id: int) -> dict[str, Any]:+ """+ kwargs forwarded to ``serializer.save()`` on create. Default forces the+ owning user. Override for client-supplied UUID PKs (WeightEntry),+ ordering (Meal/MealItem) or models that don't take ``user_id`` because+ ownership rides on a FK chain (LogItem, MealItem).+ """+ return {'user_id': user_id}++ #+ # Public CRUD entry points+ #++ def handle_create(self, payload: dict[str, Any], user_id: int) -> dict | None:+ if not self.supports_create:+ return {+ 'error': 'Method not allowed',+ 'details': f'{self.label} creation must go through the REST API',+ }++ logger.debug(f'Received PowerSync payload for {self.label} create: {payload}')+ payload = self.preprocess_payload(payload)++ fk_err = self._check_fk(payload, user_id)+ if fk_err is not None:+ return fk_err++ serializer = self.serializer_class(+ data=payload,+ context=self._serializer_context(user_id),+ )+ if serializer.is_valid():+ serializer.save(**self.create_save_kwargs(payload, user_id))+ logger.debug(f'Created {self.label} {payload.get("id")} for user {user_id}')+ return None+ return self._validation_failed(serializer.errors)++ def handle_update(self, payload: dict[str, Any], user_id: int) -> dict | None:+ logger.debug(f'Received PowerSync payload for {self.label} update: {payload}')+ payload = self.preprocess_payload(payload)++ entry = self._get_or_none(payload, user_id)+ if entry is None:+ return self._not_found(payload['id'])++ fk_err = self._check_fk(payload, user_id)+ if fk_err is not None:+ return fk_err++ serializer = self.serializer_class(+ entry,+ data=payload,+ partial=True,+ context=self._serializer_context(user_id),+ )+ if serializer.is_valid():+ serializer.save()+ logger.debug(f'Updated {self.label} {entry.pk} for user {user_id}')+ return None+ return self._validation_failed(serializer.errors)++ def handle_delete(self, payload: dict[str, Any], user_id: int) -> dict | None:+ logger.debug(f'Received PowerSync payload for {self.label} delete: {payload}')+ entry = self._get_or_none(payload, user_id)+ if entry is None:+ return self._not_found(payload['id'])+ entry.delete()+ logger.debug(f'Deleted {self.label} {payload["id"]} for user {user_id}')+ return None++ def dispatch(+ self,+ http_verb: str,+ payload: dict[str, Any],+ user_id: int,+ ) -> dict | None:+ """Route an HTTP verb to the matching CRUD handler."""+ if http_verb == 'PUT':+ return self.handle_create(payload, user_id)+ if http_verb == 'PATCH':+ return self.handle_update(payload, user_id)+ if http_verb == 'DELETE':+ return self.handle_delete(payload, user_id)+ return {'error': 'Method not allowed', 'details': f'Unsupported HTTP verb: {http_verb}'}++ #+ # Internals+ #++ def _serializer_context(self, user_id: int) -> dict[str, Any]:+ if self.pass_user_id_in_context:+ return {'user_id': user_id}+ return {}++ def _check_fk(self, payload: dict[str, Any], user_id: int) -> dict | None:+ if self.viewset_class is None:+ return None+ if check_fk_ownership(payload, self.viewset_class.get_owner_objects(), user_id):+ return None+ return {+ 'error': 'Forbidden',+ 'details': f'{self.label} references an object you do not own',+ }++ def _get_or_none(self, payload: dict[str, Any], user_id: int):+ ident = payload['id']+ try:+ return self.model.objects.get(**{self.lookup_field: ident, self.user_filter: user_id})+ except self.model.DoesNotExist:+ return None++ def _not_found(self, ident) -> dict:+ msg = f'{self.label} with id {ident} not found'+ logger.warning(msg)+ return {'error': 'Not found', 'details': msg}++ def _validation_failed(self, errors) -> dict:+ logger.warning(f'PowerSync {self.label} validation failed: {errors}')+ return {'error': 'Validation failed', 'details': errors}+++def register_handler(cls: type[PowerSyncHandler]) -> type[PowerSyncHandler]:+ """+ Class decorator: instantiate ``cls`` and add the singleton to ``REGISTRY``+ keyed by the model's DB table name (which is what the PowerSync sync rules+ expose).+ """+ if cls.model is None:+ raise ValueError(f'{cls.__name__} must set `model`')+ cls.table = cls.model._meta.db_table+ if cls.table in REGISTRY:+ raise ValueError(+ f'PowerSync handler for table "{cls.table}" is already registered '+ f'(by {type(REGISTRY[cls.table]).__name__})'+ )+ REGISTRY[cls.table] = cls()+ return clsdiff --git a/wger/weight/powersync.py b/wger/weight/powersync.pyindex 13dfd4dad..5a19831c5 100644--- a/wger/weight/powersync.py+++ b/wger/weight/powersync.py@@ -14,69 +14,28 @@# along with Workout Manager. If not, see <http://www.gnu.org/licenses/>.# Standard Library-import loggingfrom typing import Any-# Django-from django.http import HttpRequest-# wger+from wger.utils.powersync import (+ PowerSyncHandler,+ register_handler,+)from wger.weight.api.serializers import WeightEntrySerializerfrom wger.weight.models import WeightEntry-logger = logging.getLogger(__name__)---def handle_update(payload: dict[str, Any], user_id: int, request: HttpRequest) -> dict | None:- """Handle a push event from PowerSync"""- logger.debug(f'Received PowerSync payload for update: {payload}')- try:- entry = WeightEntry.objects.get(uuid=payload['id'], user_id=user_id)- except WeightEntry.DoesNotExist:- logger.warning(- f'WeightEntry with UUID {payload["id"]} and user {user_id} not found for update.'- )- return {- 'error': 'Not found',- 'details': f'WeightEntry with UUID {payload["id"]} not found',- }-- serializer = WeightEntrySerializer(- entry,- data=payload,- partial=True,- context={'request': request},- )- if serializer.is_valid():- serializer.save()- logger.info(f'Updated WeightEntry {entry.pk} (uuid={entry.uuid}) for user {user_id}')- return None- logger.warning(f'PowerSync update validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}---def handle_create(payload: dict[str, Any], user_id: int, request: HttpRequest) -> dict | None:- """Handle a create event from PowerSync"""- logger.debug(f'Received PowerSync payload for create: {payload}')- serializer = WeightEntrySerializer(data=payload, context={'request': request})- if serializer.is_valid():- serializer.save(user_id=user_id, uuid=payload['id'])- return None- logger.warning(f'PowerSync create validation failed: {serializer.errors}')- return {'error': 'Validation failed', 'details': serializer.errors}+@register_handler+class WeightEntryHandler(PowerSyncHandler):+ """+ Body weight uses a client-supplied UUID as the synchronised primary key,+ so the handler must round-trip the payload's ``id`` into the ``uuid``+ column on create.+ """+ model = WeightEntry+ serializer_class = WeightEntrySerializer+ lookup_field = 'uuid'-def handle_delete(payload: dict[str, Any], user_id: int) -> dict | None:- """Handle a delete event from PowerSync"""- logger.debug(f'Received PowerSync payload for delete: {payload}')- try:- entry = WeightEntry.objects.get(uuid=payload['id'], user_id=user_id)- except WeightEntry.DoesNotExist:- logger.warning(f'WeightEntry with UUID {payload["id"]} not found for delete.')- return {- 'error': 'Not found',- 'details': f'WeightEntry with UUID {payload["id"]} not found',- }- entry.delete()- return None+ def create_save_kwargs(self, payload: dict[str, Any], user_id: int) -> dict[str, Any]:+ return {'user_id': user_id, 'uuid': payload['id']}diff --git a/wger/weight/tests/test_powersync.py b/wger/weight/tests/test_powersync.pyindex 7335834b9..8634af4d8 100644--- a/wger/weight/tests/test_powersync.py+++ b/wger/weight/tests/test_powersync.py@@ -44,3 +44,8 @@ class WeightEntryPowerSyncTestCase(powersync_base_test.PowerSyncResourceTestCasedef _get_entry_for_update(self):# WeightEntry's PowerSync handler looks up by uuid, not pkreturn WeightEntry.objects.get(uuid=self.update_payload['id'])++ def _client_supplied_id_field(self, obj):+ # WeightEntry has an integer PK plus a separate uuid column; the+ # client-supplied id round-trips into uuid, not pk.+ return obj.uuid