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

{pretix_map-0.1.1/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.1
+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>

{pretix_map-0.1.1 → 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.1
+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>

pretix_map-0.1.2/pretix_mapplugin/__init__.py

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

{pretix_map-0.1.1 → 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.1 → 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.1 → pretix_map-0.1.2}/pretix_mapplugin/tasks.py

@@ -22,26 +22,48 @@ logger = logging.getLogger(__name__)
 
 
 @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):
+# --- 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 the Nominatim User-Agent as an argument.
-    Activates django-scopes organizer scope before querying scoped models.
+    Accepts organizer_pk and Nominatim User-Agent as arguments.
+    Fetches Organizer first, then activates scope.
     """
-    order = None  # Initialize order to None
+    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:
-            order = Order.objects.select_related('event__organizer', 'invoice_address').get(pk=order_pk)
-            organizer = order.event.organizer  # Get organizer from the fetched order
+            organizer = Organizer.objects.get(pk=organizer_pk)
         except ObjectDoesNotExist:
-            logger.error(f"Order with PK {order_pk} not found in geocode_order_task.")
+            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}'")
 
-            relation_name = 'geocode_data'  # Ensure this matches your model
-            # Check existence within scope (safer)
+            # --- 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
@@ -49,7 +71,6 @@ def geocode_order_task(self, order_pk: int, nominatim_user_agent: str | None = N
             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 within scope
                 with transaction.atomic():
                     OrderGeocodeData.objects.update_or_create(
                         order=order, defaults={'latitude': None, 'longitude': None}
@@ -59,7 +80,6 @@ def geocode_order_task(self, order_pk: int, nominatim_user_agent: str | None = N
             logger.debug(f"Attempting to geocode address for Order {order.code}: '{address_str}'")
             coordinates = geocode_address(address_str, nominatim_user_agent=nominatim_user_agent)
 
-            # Store result within scope
             with transaction.atomic():
                 if coordinates:
                     latitude, longitude = coordinates
@@ -77,14 +97,17 @@ def geocode_order_task(self, order_pk: int, nominatim_user_agent: str | None = N
                     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 here ---
+        # --- Scope deactivated automatically ---
 
-    # Keep outer exception handling
+    # --- Outer exception handling ---
     except ObjectDoesNotExist:
-        # This case is now handled earlier, but keep for safety
-        logger.error(f"Order with PK {order_pk} not found outside scope handling.")
+        # 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:
-        logger.exception(
-            f"Unexpected error in geocode_order_task for Order PK {order_pk} (potentially outside scope): {e}")
-        # Retry on unexpected errors before scope activation
+        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.1/pretix_mapplugin/__init__.py

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