pretix-map 0.1.0__tar.gz → 0.1.2__tar.gz

{pretix_map-0.1.0/pretix_map.egg-info → pretix_map-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pretix-map
-Version: 0.1.0
+Version: 0.1.2
 Summary: An overview map of the catchment area of previous orders. Measured by postcode
 Author-email: MarkenJaden <jjsch1410@gmail.com>
 Maintainer-email: MarkenJaden <jjsch1410@gmail.com>
@@ -140,10 +140,12 @@ This command is essential for processing orders that were placed *before* the ma
 **Example Workflow:**
 
 1.  **Test with Dry Run (All Organizers):**
+
     .. code-block:: bash
 
         python manage.py geocode_existing_orders --dry-run
 2.  **(If satisfied) Run for Real (All Organizers):**
+
     .. code-block:: bash
 
         python manage.py geocode_existing_orders

{pretix_map-0.1.0 → pretix_map-0.1.2}/README.rst

@@ -125,10 +125,12 @@ This command is essential for processing orders that were placed *before* the ma
 **Example Workflow:**
 
 1.  **Test with Dry Run (All Organizers):**
+
     .. code-block:: bash
 
         python manage.py geocode_existing_orders --dry-run
 2.  **(If satisfied) Run for Real (All Organizers):**
+
     .. code-block:: bash
 
         python manage.py geocode_existing_orders

{pretix_map-0.1.0 → pretix_map-0.1.2/pretix_map.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pretix-map
-Version: 0.1.0
+Version: 0.1.2
 Summary: An overview map of the catchment area of previous orders. Measured by postcode
 Author-email: MarkenJaden <jjsch1410@gmail.com>
 Maintainer-email: MarkenJaden <jjsch1410@gmail.com>
@@ -140,10 +140,12 @@ This command is essential for processing orders that were placed *before* the ma
 **Example Workflow:**
 
 1.  **Test with Dry Run (All Organizers):**
+
     .. code-block:: bash
 
         python manage.py geocode_existing_orders --dry-run
 2.  **(If satisfied) Run for Real (All Organizers):**
+
     .. code-block:: bash
 
         python manage.py geocode_existing_orders

pretix_map-0.1.2/pretix_mapplugin/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

{pretix_map-0.1.0 → pretix_map-0.1.2}/pretix_mapplugin/management/commands/geocode_existing_orders.py

@@ -1,6 +1,6 @@
 import logging
 from django.core.management.base import BaseCommand, CommandError
-from django.core.exceptions import FieldDoesNotExist
+from django.core.exceptions import FieldDoesNotExist, ObjectDoesNotExist
 
 # --- Import Pretix Global Settings accessor ---
 from django_scopes import scope
@@ -8,6 +8,7 @@ from django_scopes import scope
 # Check if Pretix version uses AbstractSettingsHolder or GlobalSettingsObject
 # Adjust import based on Pretix version if needed. Assume AbstractSettingsHolder for newer Pretix.
 try:
+    # Newer Pretix often uses this pattern via AbstractSettingsHolder
     from pretix.base.settings import GlobalSettingsObject as SettingsProxy
 except ImportError:
     try:
@@ -21,7 +22,11 @@ except ImportError:
     except ImportError:
         # Fallback or raise error if neither is found
         logger.error("Could not determine Pretix settings accessor for management command.")
-        raise ImportError("Cannot find Pretix settings accessor.")
+
+
+        # This will likely cause the command to fail later, but allows it to start
+        class SettingsProxy:
+            def __init__(self): self.settings = {}  # Empty dict to avoid errors later
 
 # --- Import necessary Pretix models ---
 from pretix.base.models import Order, Event, Organizer
@@ -40,16 +45,23 @@ class Command(BaseCommand):
 
     def add_arguments(self, parser):
         parser.add_argument(
-            '--organizer', type=str, help='Slug of a specific organizer to process orders for.',
+            '--organizer',
+            type=str,
+            help='Slug of a specific organizer to process orders for.',
         )
         parser.add_argument(
-            '--event', type=str, help='Slug of a specific event to process orders for. Requires --organizer.',
+            '--event',
+            type=str,
+            help='Slug of a specific event to process orders for. Requires --organizer.',
         )
         parser.add_argument(
-            '--dry-run', action='store_true', help='Simulate the process without actually queuing tasks.',
+            '--dry-run',
+            action='store_true',
+            help='Simulate the process without actually queuing tasks.',
         )
         parser.add_argument(
-            '--force-recode', action='store_true',
+            '--force-recode',
+            action='store_true',
             help='Queue geocoding even for orders that already have geocode data.',
         )
 
@@ -65,13 +77,12 @@ class Command(BaseCommand):
         # --- Read User-Agent using Pretix Settings accessor ---
         user_agent = DEFAULT_NOMINATIM_USER_AGENT
         try:
-            # Get settings holder instance
             gs = SettingsProxy()
             # Construct the setting key specific to plugins
-            # Format might be 'plugin:plugin_name:setting_name' or just 'plugin_name_setting_name'
-            # Check Pretix docs or experiment if needed. Assuming the former.
+            # The format 'plugin:plugin_name:setting_name' is common
             setting_key = 'plugin:pretix_mapplugin:nominatim_user_agent'
-            user_agent = gs.settings.get(setting_key, DEFAULT_NOMINATIM_USER_AGENT)
+            # Use .get() which is safer for dictionaries possibly returned by load_config
+            user_agent = getattr(gs, 'settings', {}).get(setting_key, DEFAULT_NOMINATIM_USER_AGENT)
 
             if user_agent == DEFAULT_NOMINATIM_USER_AGENT:
                 self.stdout.write(self.style.WARNING(
@@ -88,12 +99,14 @@ class Command(BaseCommand):
         organizers_to_process = []
         if organizer_slug:
             try:
+                # Fetch specific organizer (outside scope)
                 organizer = Organizer.objects.get(slug=organizer_slug)
                 organizers_to_process.append(organizer)
                 self.stdout.write(f"Processing specified organizer: {organizer.name} ({organizer_slug})")
             except Organizer.DoesNotExist:
                 raise CommandError(f"Organizer with slug '{organizer_slug}' not found.")
         else:
+            # Fetch all organizers (outside scope)
             organizers_to_process = list(Organizer.objects.all())
             self.stdout.write(f"Processing all {len(organizers_to_process)} organizers...")
 
@@ -105,9 +118,10 @@ class Command(BaseCommand):
         # --- Iterate through organizers and activate scope ---
         for organizer in organizers_to_process:
             self.stdout.write(f"\n--- Processing Organizer: {organizer.name} ({organizer.slug}) ---")
+            current_organizer_pk = organizer.pk  # Get the PK needed for the task kwarg
 
             with scope(organizer=organizer):
-                # --- Get orders ---
+                # --- Get orders within scope ---
                 orders_qs = Order.objects.filter(status=Order.STATUS_PAID)
 
                 # --- Filter by event if specified ---
@@ -119,74 +133,93 @@ class Command(BaseCommand):
                     except Event.DoesNotExist:
                         self.stderr.write(self.style.WARNING(
                             f"  Event '{event_slug}' not found for this organizer. Skipping event filter."))
-                        if organizer_slug and event_slug: continue
+                        # If filtering by event and it's not found for this org, skip this org entirely
+                        if organizer_slug and event_slug:
+                            self.stdout.write(
+                                f"  Skipping organizer '{organizer.slug}' as specified event was not found.")
+                            continue  # Move to the next organizer
 
                 # --- Filter orders needing geocoding ---
-                relation_name = 'geocode_data'  # Ensure this matches your model
+                relation_name = 'geocode_data'  # Ensure this matches your model's related_name
                 if not force_recode:
                     try:
                         Order._meta.get_field(relation_name)  # Check existence
+                        # Filter orders that don't have the related geocode entry
                         orders_to_process_qs = orders_qs.filter(**{f'{relation_name}__isnull': True})
                         self.stdout.write("  Selecting paid orders missing geocode data...")
                     except FieldDoesNotExist:
-                        self.stderr.write(
-                            self.style.ERROR(f"  Relation '{relation_name}' not found. Skipping organizer."))
-                        continue
+                        # This indicates a code/model setup error, stop for this org
+                        self.stderr.write(self.style.ERROR(
+                            f"  Configuration Error: Reverse relation '{relation_name}' not found on Order model. Check OrderGeocodeData model definition (related_name). Skipping organizer '{organizer.slug}'."))
+                        continue  # Skip this organizer
                     except Exception as e:
-                        self.stderr.write(self.style.ERROR(f"  Error checking relation: {e}. Skipping organizer."))
-                        continue
+                        # Catch other potential errors during query construction
+                        self.stderr.write(self.style.ERROR(
+                            f"  Error checking relation '{relation_name}': {e}. Skipping organizer '{organizer.slug}'."))
+                        continue  # Skip this organizer
                 else:
+                    # If forcing, process all orders that matched the initial filters (paid, event)
                     orders_to_process_qs = orders_qs
-                    self.stdout.write(self.style.WARNING("  Processing ALL selected paid orders (--force-recode)..."))
+                    self.stdout.write(
+                        self.style.WARNING("  Processing ALL selected paid orders (--force-recode specified)..."))
 
                 # --- Process orders for this scope ---
-                current_org_orders_count = orders_to_process_qs.count()
-                all_checked_for_org = orders_qs.count()
-                total_processed_orders += all_checked_for_org
+                current_org_orders_count = orders_to_process_qs.count()  # Count orders to queue
+                all_checked_for_org = orders_qs.count()  # Count all orders checked for this filter set
+                total_processed_orders += all_checked_for_org  # Add to overall total
 
                 if current_org_orders_count == 0:
                     self.stdout.write(f"  No orders need geocoding ({all_checked_for_org} checked).")
-                    continue
+                    continue  # Skip to next organizer
 
                 self.stdout.write(
                     f"  Found {current_org_orders_count} order(s) to potentially geocode ({all_checked_for_org} checked).")
                 org_queued = 0
                 org_skipped = 0
 
-                for order in orders_to_process_qs.iterator():
+                # Iterate and queue tasks
+                for order in orders_to_process_qs.iterator():  # Use iterator for memory efficiency
                     if dry_run:
+                        # Provide slightly more info in dry run
                         self.stdout.write(
-                            f"    [DRY RUN] Would queue Order: {order.code} (PK: {order.pk}) Event: {order.event.slug}")
+                            f"    [DRY RUN] Would queue Order: {order.code} (PK: {order.pk}, Org PK: {current_organizer_pk}) Event: {order.event.slug}")
                         org_queued += 1
                     else:
                         try:
-                            # --- Pass user_agent to task ---
+                            # --- Pass user_agent AND organizer_pk to the task ---
                             geocode_order_task.apply_async(
-                                args=[order.pk],
-                                kwargs={'nominatim_user_agent': user_agent}  # Pass as kwarg
+                                args=[order.pk],  # Positional arg is order_pk
+                                kwargs={
+                                    'nominatim_user_agent': user_agent,
+                                    'organizer_pk': current_organizer_pk  # Pass organizer PK
+                                }
                             )
+                            # Don't log every single queue success unless verbose requested
                             org_queued += 1
                         except Exception as e:
-                            self.stderr.write(self.style.ERROR(f"    ERROR queuing Order {order.code}: {e}"))
+                            # Log error if queueing fails
+                            self.stderr.write(self.style.ERROR(
+                                f"    ERROR queuing task for Order {order.code} (PK: {order.pk}): {e}"))
                             logger.exception(f"Failed to queue geocoding task via command for order {order.code}: {e}")
                             org_skipped += 1
 
-                self.stdout.write(f"  Queued: {org_queued}, Skipped: {org_skipped} for this organizer.")
+                # Report summary for the current organizer
+                self.stdout.write(f"  Finished Organizer: Queued: {org_queued}, Skipped: {org_skipped}.")
                 total_queued += org_queued
                 total_skipped += org_skipped
-            # End scope
+            # End scope 'with' block
 
-        # --- Final Report ---
+        # --- Final Overall Report ---
         self.stdout.write("=" * 40)
         self.stdout.write("Overall Summary:")
         self.stdout.write(f"  Organizers processed: {len(organizers_to_process)}")
-        self.stdout.write(f"  Total orders checked (paid): {total_processed_orders}")
+        self.stdout.write(f"  Total orders checked (paid, matching filters): {total_processed_orders}")
         if dry_run:
             self.stdout.write(
                 self.style.SUCCESS(f"[DRY RUN] Complete. Would have queued tasks for {total_queued} order(s)."))
         else:
-            self.stdout.write(self.style.SUCCESS(f"Complete. Queued tasks for {total_queued} order(s)."))
+            self.stdout.write(self.style.SUCCESS(f"Complete. Successfully queued tasks for {total_queued} order(s)."))
             if total_skipped > 0:
-                self.stdout.write(
-                    self.style.WARNING(f"Skipped {total_skipped} order(s) total due to errors during queueing."))
+                self.stdout.write(self.style.WARNING(
+                    f"Skipped {total_skipped} order(s) total due to errors during queueing (check logs)."))
         self.stdout.write("=" * 40)

{pretix_map-0.1.0 → pretix_map-0.1.2}/pretix_mapplugin/signals.py

@@ -3,7 +3,6 @@ from django.dispatch import receiver
 from django.urls import reverse, NoReverseMatch
 from django.utils.translation import gettext_lazy as _
 from django.http import HttpRequest
-# Import Django settings to read config in web process
 from django.conf import settings
 
 # --- Pretix Signals ---
@@ -13,50 +12,56 @@ from pretix.control.signals import nav_event
 # --- Tasks ---
 from .tasks import geocode_order_task
 # --- Geocoding Default ---
-from .geocoding import DEFAULT_NOMINATIM_USER_AGENT  # Import default
+from .geocoding import DEFAULT_NOMINATIM_USER_AGENT
 
 logger = logging.getLogger(__name__)
 
 # --- Constants ---
 MAP_VIEW_URL_NAME = 'plugins:pretix_mapplugin:event.settings.salesmap.show'
 REQUIRED_MAP_PERMISSION = 'can_view_orders'
-PLUGIN_NAME = 'pretix_mapplugin'  # Define plugin name for settings access
+PLUGIN_NAME = 'pretix_mapplugin'
 
 
-# --- Signal Receiver for Geocoding (Reads setting, passes to task) ---
+# --- Signal Receiver for Geocoding (Passes organizer_pk) ---
 @receiver(order_paid, dispatch_uid="sales_mapper_order_paid_geocode")
 def trigger_geocoding_on_payment(sender, order, **kwargs):
     """
     Listens for the order_paid signal, reads geocoding config,
-    and queues the geocoding task with the config.
+    and queues the geocoding task with order_pk, organizer_pk, and config.
     """
-    user_agent = DEFAULT_NOMINATIM_USER_AGENT  # Start with default
+    user_agent = DEFAULT_NOMINATIM_USER_AGENT
+    organizer_pk = None  # Initialize
     try:
-        # --- Read User-Agent from settings (works in web process) ---
-        # Check structure defensively before accessing
+        # Ensure order has event and organizer before proceeding
+        if not order or not order.event or not order.event.organizer:
+            logger.error(f"Order {order.code} is missing event or organizer information. Cannot queue task.")
+            return
+
+        organizer_pk = order.event.organizer.pk  # Get organizer PK
+
+        # --- Read User-Agent from settings ---
         if hasattr(settings, 'plugins') and hasattr(settings.plugins, PLUGIN_NAME):
             plugin_settings = getattr(settings.plugins, PLUGIN_NAME)
-            user_agent = plugin_settings.get(
-                'nominatim_user_agent',  # Setting name in pretix.cfg
-                DEFAULT_NOMINATIM_USER_AGENT
-            )
+            user_agent = plugin_settings.get('nominatim_user_agent', DEFAULT_NOMINATIM_USER_AGENT)
         else:
-            logger.warning(
-                f"Could not access settings.plugins.{PLUGIN_NAME}, "
-                "using default Nominatim User-Agent for task."
-            )
+            logger.warning(f"Could not access settings.plugins.{PLUGIN_NAME}, using default User-Agent.")
 
-        # --- Queue task with user_agent as keyword argument ---
+        # --- Queue task with user_agent and organizer_pk as keyword arguments ---
         geocode_order_task.apply_async(
-            args=[order.pk],
-            kwargs={'nominatim_user_agent': user_agent}  # Pass as kwarg
+            args=[order.pk],  # Keep order_pk as positional argument
+            kwargs={
+                'nominatim_user_agent': user_agent,
+                'organizer_pk': organizer_pk  # Pass organizer PK
+            }
         )
-        logger.info(f"Geocoding task queued for paid order {order.code} (PK: {order.pk}).")
+        logger.info(f"Geocoding task queued for paid order {order.code} (PK: {order.pk}, Org PK: {organizer_pk}).")
 
-    except ImportError:  # Error finding geocode_order_task itself if tasks.py fails
+    except ImportError:
         logger.exception("Could not import geocode_order_task. Check tasks.py.")
     except Exception as e:
-        logger.exception(f"Failed to queue geocoding task for order {order.code}: {e}")
+        # Log the organizer PK as well if available
+        org_info = f" (Org PK: {organizer_pk})" if organizer_pk else ""
+        logger.exception(f"Failed to queue geocoding task for order {order.code}{org_info}: {e}")
 
 
 # --- Signal Receiver for Adding Navigation Item (No changes needed) ---

pretix_map-0.1.2/pretix_mapplugin/tasks.py

@@ -0,0 +1,113 @@
+import logging
+from django.db import transaction
+from django.core.exceptions import ObjectDoesNotExist
+
+# --- Import django-scopes ---
+from django_scopes import scope
+
+# --- Use Pretix Celery app instance ---
+from pretix.celery_app import app
+# --- Import necessary Pretix models ---
+from pretix.base.models import Order, Organizer  # Import Organizer
+
+# --- Import your Geocode model and geocoding functions ---
+from .models import OrderGeocodeData
+from .geocoding import (
+    get_formatted_address_from_order,
+    geocode_address,
+    DEFAULT_NOMINATIM_USER_AGENT
+)
+
+logger = logging.getLogger(__name__)
+
+
+@app.task(bind=True, max_retries=3, default_retry_delay=60, ignore_result=True)
+# --- Accept organizer_pk as kwarg ---
+def geocode_order_task(self, order_pk: int, organizer_pk: int | None = None, nominatim_user_agent: str | None = None):
+    """
+    Celery task to geocode the address for a given order PK.
+    Accepts organizer_pk and Nominatim User-Agent as arguments.
+    Fetches Organizer first, then activates scope.
+    """
+    organizer = None
+    order = None
+    try:
+        # --- Step 1: Fetch Organizer (unscoped) ---
+        if organizer_pk is None:
+            # This should ideally not happen if called correctly, but handle defensively
+            logger.error(f"organizer_pk not provided for Order PK {order_pk}. Cannot activate scope.")
+            # Depending on policy, you might retry, skip, or raise an error.
+            # Skipping for now.
+            return
+
+        try:
+            organizer = Organizer.objects.get(pk=organizer_pk)
+        except ObjectDoesNotExist:
+            logger.error(f"Organizer with PK {organizer_pk} not found (for Order PK {order_pk}).")
+            # Don't retry if organizer doesn't exist
+            return
+
+        # --- Step 2: Activate Scope ---
+        with scope(organizer=organizer):
+            # --- Step 3: Fetch Order (now within scope) ---
+            try:
+                order = Order.objects.select_related(
+                    'invoice_address'  # Only need this direct relation now
+                ).get(pk=order_pk)
+            except ObjectDoesNotExist:
+                logger.error(f"Order with PK {order_pk} not found within scope of Org {organizer_pk}.")
+                # Don't retry if order doesn't exist in this scope
+                return
+
+            logger.info(
+                f"Starting geocoding task for Order {order.code} (PK: {order_pk}) within scope of Organizer '{organizer.slug}'")
+
+            # --- Rest of the logic runs within scope ---
+            relation_name = 'geocode_data'
+            if OrderGeocodeData.objects.filter(order_id=order_pk).exists():
+                logger.info(f"Geocode data already exists for Order {order.code} (checked within scope). Skipping.")
+                return
+
+            address_str = get_formatted_address_from_order(order)
+            if not address_str:
+                logger.info(f"Order {order.code} has no address suitable for geocoding. Storing null coordinates.")
+                with transaction.atomic():
+                    OrderGeocodeData.objects.update_or_create(
+                        order=order, defaults={'latitude': None, 'longitude': None}
+                    )
+                return
+
+            logger.debug(f"Attempting to geocode address for Order {order.code}: '{address_str}'")
+            coordinates = geocode_address(address_str, nominatim_user_agent=nominatim_user_agent)
+
+            with transaction.atomic():
+                if coordinates:
+                    latitude, longitude = coordinates
+                    obj, created = OrderGeocodeData.objects.update_or_create(
+                        order=order, defaults={'latitude': latitude, 'longitude': longitude}
+                    )
+                    log_level = logging.INFO if created else logging.DEBUG
+                    logger.log(log_level,
+                               f"Saved{' new' if created else ' updated'} geocode data for Order {order.code}: ({latitude}, {longitude})")
+                else:
+                    logger.warning(f"Geocoding failed for Order {order.code}. Storing null coordinates.")
+                    obj, created = OrderGeocodeData.objects.update_or_create(
+                        order=order, defaults={'latitude': None, 'longitude': None}
+                    )
+                    log_level = logging.INFO if created else logging.DEBUG
+                    logger.log(log_level,
+                               f"Saved{' new' if created else ' updated'} null geocode data for Order {order.code} after failed attempt.")
+        # --- Scope deactivated automatically ---
+
+    # --- Outer exception handling ---
+    except ObjectDoesNotExist:
+        # Should be caught earlier now, but keep for safety
+        obj_type = "Organizer" if organizer is None else "Order"
+        obj_pk = organizer_pk if organizer is None else order_pk
+        logger.error(f"{obj_type} with PK {obj_pk} not found.")
+    except Exception as e:
+        org_info = f" (Org PK: {organizer_pk})" if organizer_pk else ""
+        order_info = f" (Order PK: {order_pk})" if order_pk else ""
+        logger.exception(f"Unexpected error in geocode_order_task{org_info}{order_info}: {e}")
+        # Retry on potentially temporary errors
+        raise self.retry(exc=e)

pretix_map-0.1.0/pretix_mapplugin/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"

pretix_map-0.1.0/pretix_mapplugin/tasks.py

@@ -1,90 +0,0 @@
-import logging
-from django.db import transaction
-from django.core.exceptions import ObjectDoesNotExist
-
-# --- Use Pretix Celery app instance ---
-from pretix.celery_app import app
-# --- Import necessary Pretix models ---
-from pretix.base.models import Order
-
-# --- Import your Geocode model and geocoding functions ---
-from .models import OrderGeocodeData
-from .geocoding import (
-    get_formatted_address_from_order,
-    geocode_address,
-    DEFAULT_NOMINATIM_USER_AGENT  # Import default for safety/logging
-)
-
-logger = logging.getLogger(__name__)
-
-
-# Define the Celery task
-# bind=True gives access to self (the task instance) for retrying
-# ignore_result=True as we don't need the return value stored in Celery backend
-@app.task(bind=True, max_retries=3, default_retry_delay=60, ignore_result=True)
-def geocode_order_task(self, order_pk: int,
-                       nominatim_user_agent: str | None = None):  # Added nominatim_user_agent kwarg
-    """
-    Celery task to geocode the address for a given order PK.
-    Accepts the Nominatim User-Agent as an argument.
-    """
-    try:
-        # Fetch order with related address and country data efficiently
-        order = Order.objects.select_related(
-            'invoice_address',
-        ).get(pk=order_pk)
-        logger.info(f"Starting geocoding task for Order {order.code} (PK: {order_pk})")
-
-        # Check if already geocoded to prevent redundant work
-        # Replace 'geocode_data' if your related_name is different
-        relation_name = 'geocode_data'  # Ensure this matches your OrderGeocodeData.order related_name
-        if hasattr(order, relation_name) and getattr(order, relation_name) is not None:
-            logger.info(f"Geocode data already exists for Order {order.code}. Skipping.")
-            return  # Exit successfully
-
-        # 1. Get formatted address string
-        address_str = get_formatted_address_from_order(order)
-        if not address_str:
-            logger.info(f"Order {order.code} has no address suitable for geocoding. Storing null coordinates.")
-            # Store null to prevent reprocessing
-            with transaction.atomic():
-                OrderGeocodeData.objects.update_or_create(
-                    order=order,
-                    defaults={'latitude': None, 'longitude': None}
-                )
-            return  # Exit successfully, nothing to geocode
-
-        # 2. Perform geocoding, passing the user agent received by the task
-        logger.debug(f"Attempting to geocode address for Order {order.code}: '{address_str}'")
-        coordinates = geocode_address(address_str, nominatim_user_agent=nominatim_user_agent)
-
-        # 3. Store result (or null if failed) using atomic transaction
-        with transaction.atomic():
-            if coordinates:
-                latitude, longitude = coordinates
-                obj, created = OrderGeocodeData.objects.update_or_create(
-                    order=order,
-                    defaults={'latitude': latitude, 'longitude': longitude}
-                )
-                log_level = logging.INFO if created else logging.DEBUG  # Be less noisy on updates
-                logger.log(log_level,
-                           f"Saved{' new' if created else ' updated'} geocode data for Order {order.code}: ({latitude}, {longitude})")
-            else:
-                logger.warning(f"Geocoding failed for Order {order.code}. Storing null coordinates.")
-                # Store nulls to indicate an attempt was made and failed
-                obj, created = OrderGeocodeData.objects.update_or_create(
-                    order=order,
-                    defaults={'latitude': None, 'longitude': None}
-                )
-                log_level = logging.INFO if created else logging.DEBUG
-                logger.log(log_level,
-                           f"Saved{' new' if created else ' updated'} null geocode data for Order {order.code} after failed attempt.")
-
-    except ObjectDoesNotExist:  # More specific exception
-        logger.error(f"Order with PK {order_pk} not found in geocode_order_task.")
-        # Don't retry if the order doesn't exist
-    except Exception as e:
-        # Catch any other unexpected errors
-        logger.exception(f"Unexpected error in geocode_order_task for Order PK {order_pk}: {e}")
-        # Retry on potentially temporary errors (database, network issues etc.)
-        raise self.retry(exc=e)  # Let Celery handle retry logic