Skip to content

armgit / wger

Public Imported from GitHub
0

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.py
index 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_HASHES
for 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.py
index 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: F401
from wger.core.api import powersync
from wger.core.api.serializers import (
LanguageCheckSerializer,
@@ -83,6 +85,7 @@ from wger.core.models import (
)
from wger.utils.api_token import create_token
from wger.utils.permissions import WgerPermission
+from wger.utils.powersync import REGISTRY as POWERSYNC_REGISTRY
from 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.py
index 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.py
index 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
-
# wger
from wger.gallery.api.serializers import ImageSerializer
from 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 payload
diff --git a/wger/manager/powersync.py b/wger/manager/powersync.py
index 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
-
# wger
from 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 = False
diff --git a/wger/manager/tests/test_log_session_api.py b/wger/manager/tests/test_log_session_api.py
index 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
# wger
from wger.core.tests.base_testcase import WgerTestCase
+from wger.core.tests.powersync_base_test import PowerSyncBaseTestCase
+from wger.manager.api.serializers import WorkoutLogSerializer
from 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 by
default, 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.py
index 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
-
# wger
from 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.py
index 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
-
# wger
from 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.py
new file mode 100644
index 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 cls
diff --git a/wger/weight/powersync.py b/wger/weight/powersync.py
index 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 logging
from typing import Any
-# Django
-from django.http import HttpRequest
-
# wger
+from wger.utils.powersync import (
+ PowerSyncHandler,
+ register_handler,
+)
from wger.weight.api.serializers import WeightEntrySerializer
from 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.py
index 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.PowerSyncResourceTestCase
def _get_entry_for_update(self):
# WeightEntry's PowerSync handler looks up by uuid, not pk
return 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