pretix-map 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

{pretix_map-0.0.4.dist-info → pretix_map-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pretix-map
-Version: 0.0.4
+Version: 0.0.6
 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.0.4.dist-info → pretix_map-0.0.6.dist-info}/RECORD

@@ -1,10 +1,10 @@
-pretix_map-0.0.4.dist-info/licenses/LICENSE,sha256=RhQ89ePNDClBzEROahhwjDrBSEb5Zpx6XewZfGlY4Ss,569
-pretix_mapplugin/__init__.py,sha256=b8Tfyn46wV92NWm_uziWVxCW3zTxPV8EyFKcI9HhXcA,23
+pretix_map-0.0.6.dist-info/licenses/LICENSE,sha256=RhQ89ePNDClBzEROahhwjDrBSEb5Zpx6XewZfGlY4Ss,569
+pretix_mapplugin/__init__.py,sha256=vnEQ3_faaqtBKoxP4DuJgVUXAxvUIINTpkt3E8qLWks,23
 pretix_mapplugin/apps.py,sha256=AnThwyRw2AAz5f-kmXZ8hm85OmKnlDkRosVoQOBgPzE,830
-pretix_mapplugin/geocoding.py,sha256=pZUF8pJ5mOFoNT1foRNuhCJO1XkJ8040AA9qIjrP8JI,4631
+pretix_mapplugin/geocoding.py,sha256=lBmwMvmE_cPyOHxWE8H3Se2P-2Eq0UjDTCv9gUs97Fo,4018
 pretix_mapplugin/models.py,sha256=v0v9K0sb5OQHs5Gc6-jea_aEGECUQp1tZoYMwwb3YIM,994
-pretix_mapplugin/signals.py,sha256=qUcM50bbHBET75ysI2C0UB7-969LjpLGRLeRLqm4sQo,3036
-pretix_mapplugin/tasks.py,sha256=1y4IExpOWkepDVDaKOw9OgHUgLmPpmO6sN8Z8L-sB90,3590
+pretix_mapplugin/signals.py,sha256=maBMMSq5M7diy_EaNgKr8KRfGFj0U437u-MEl2NVYBw,3661
+pretix_mapplugin/tasks.py,sha256=dxxEe7WGEGqiwLQlmM7btZTNVTKGQq5L6gqM_RdIecY,4558
 pretix_mapplugin/urls.py,sha256=o5407vULF4S-bUihU7AeRxUcMyazg2lPjbvqRflsGxE,838
 pretix_mapplugin/views.py,sha256=7WgmNZeqwmOesT6PrkAIRC8fNfAcWGm-j9-2YqF5egI,7146
 pretix_mapplugin/locale/de/LC_MESSAGES/django.mo,sha256=6VVRAqa0ixL-lDA1QwoVvG0wd5ZBwYjaR4P8T73hxhU,269
@@ -14,8 +14,8 @@ pretix_mapplugin/locale/de_Informal/LC_MESSAGES/django.mo,sha256=6VVRAqa0ixL-lDA
 pretix_mapplugin/locale/de_Informal/LC_MESSAGES/django.po,sha256=tIFKw9KOdGTjGq8bHV6tquRZe_MOn8TT4MJjdTRhId8,323
 pretix_mapplugin/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pretix_mapplugin/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pretix_mapplugin/management/commands/geocode_existing_orders.py,sha256=pvGwC1j6NzSf2Y7r-Lk_-6c7YsgqLr-NCu0HT5VLaeY,8407
-pretix_mapplugin/migrations/0001_initial.py,sha256=K_teTH_wzAf6fBxbjEhZlTbrpuWeu2a4ko73SUyI1OM,1078
+pretix_mapplugin/management/commands/geocode_existing_orders.py,sha256=QZGWXZfk-r3qffS3ernnOEsCK3feurc7hBpvCxhwa4U,9416
+pretix_mapplugin/migrations/0001_initial.py,sha256=KAl1Egxptv1bpregGbsh8wUbr4Yh5A_zazVSAQdmoHM,1020
 pretix_mapplugin/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pretix_mapplugin/static/pretix_mapplugin/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pretix_mapplugin/static/pretix_mapplugin/css/salesmap.css,sha256=z-OXFjpGWOoxv_tlYSDSUlcFLU9p03hhXI-8yxExl3k,598
@@ -39,8 +39,8 @@ pretix_mapplugin/static/pretix_mapplugin/libs/leaflet-sales-map/images/marker-ic
 pretix_mapplugin/static/pretix_mapplugin/libs/leaflet-sales-map/images/marker-shadow.png,sha256=Jk9cZAM58ELdcpBiz8BMF_jqDymIK1OOOEjtjxDttNo,618
 pretix_mapplugin/templates/pretix_mapplugin/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pretix_mapplugin/templates/pretix_mapplugin/map_page.html,sha256=jUfPrCkwcbcTXgZ2d9a5wpUD1U7Y8g5rnB20hklKQ-k,2252
-pretix_map-0.0.4.dist-info/METADATA,sha256=FT3Cd4cQelQYGnjJvs3S7zZyBJWT8TEGZuzebOanU_U,9514
-pretix_map-0.0.4.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-pretix_map-0.0.4.dist-info/entry_points.txt,sha256=C3NAjeZHoCekafkLMCJynPcABRTK8AUprtQv7sUNDZs,137
-pretix_map-0.0.4.dist-info/top_level.txt,sha256=CAtEnkgA73zE9Gadm5mjt1SpXHBPOS-QWP0dQVoNToE,17
-pretix_map-0.0.4.dist-info/RECORD,,
+pretix_map-0.0.6.dist-info/METADATA,sha256=LgMrztKJHpMfIbhAF363Ume1LxzKAXc9qzxLYgdOS0Y,9514
+pretix_map-0.0.6.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pretix_map-0.0.6.dist-info/entry_points.txt,sha256=C3NAjeZHoCekafkLMCJynPcABRTK8AUprtQv7sUNDZs,137
+pretix_map-0.0.6.dist-info/top_level.txt,sha256=CAtEnkgA73zE9Gadm5mjt1SpXHBPOS-QWP0dQVoNToE,17
+pretix_map-0.0.6.dist-info/RECORD,,

pretix_mapplugin/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.4"
+__version__ = "0.0.6"

pretix_mapplugin/geocoding.py

@@ -1,62 +1,54 @@
 import logging
-
-# --- Import Django settings ---
-from django.conf import settings
-from geopy.exc import GeocoderServiceError, GeocoderTimedOut
 from geopy.geocoders import Nominatim
+from geopy.exc import GeocoderTimedOut, GeocoderServiceError
 from time import sleep
 
-# Configure logging for your plugin
+# DO NOT import settings here, as it won't work reliably in Celery
+
 logger = logging.getLogger(__name__)
 
-# --- Configuration Default ---
 # Define a default/fallback User-Agent. Users *should* override this in pretix.cfg.
 DEFAULT_NOMINATIM_USER_AGENT = "pretix-map-plugin/unknown (Please configure nominatim_user_agent in pretix.cfg)"
 
 
-# --- Geocoding Function ---
-
-def geocode_address(address_string: str) -> tuple[float, float] | None:
+# --- Geocoding Function (Accepts user_agent) ---
+def geocode_address(address_string: str, nominatim_user_agent: str | None = None) -> tuple[float, float] | None:
     """
-    Tries to geocode a given address string using Nominatim, reading the
-    User-Agent from Pretix configuration.
+    Tries to geocode a given address string using Nominatim, using the
+    provided User-Agent string.
 
     Args:
         address_string: A single string representing the address.
+        nominatim_user_agent: The User-Agent string to use for Nominatim.
 
     Returns:
         A tuple (latitude, longitude) if successful, otherwise None.
     """
-    # --- Get User-Agent from Pretix Settings ---
-    # Access plugin settings via settings.plugins.<your_plugin_name>
-    # The .get() method allows providing a default value if the setting is missing.
-    user_agent = settings.plugins.pretix_mapplugin.get(
-        'nominatim_user_agent',  # The setting name defined in pretix.cfg
-        DEFAULT_NOMINATIM_USER_AGENT
-    )
-
-    # Log a warning if the default User-Agent is being used, as it's required
-    # by Nominatim policy to be specific and include contact info.
+    # Use the provided User-Agent or the default
+    user_agent = nominatim_user_agent or DEFAULT_NOMINATIM_USER_AGENT
+
     if user_agent == DEFAULT_NOMINATIM_USER_AGENT:
+        # Log warning if default is used - admins should configure this
         logger.warning(
             "Using default Nominatim User-Agent. Please set a specific "
             "'nominatim_user_agent' under [pretix_mapplugin] in your "
             "pretix.cfg according to Nominatim's usage policy."
         )
-    # --- End Settings Retrieval ---
 
-    # Initialize the geolocator with the configured or default user_agent
+    # Initialize the geolocator with the determined user_agent
     geolocator = Nominatim(user_agent=user_agent)
 
     try:
         # Add a 1-second delay to respect Nominatim's usage policy (1 req/sec)
         sleep(1)
 
-        location = geolocator.geocode(address_string, timeout=10)
+        # Perform geocoding
+        location = geolocator.geocode(address_string, timeout=10)  # 10-second timeout
 
         if location:
             logger.debug(
-                f"Geocoded '{address_string}' to ({location.latitude}, {location.longitude}) using User-Agent: {user_agent}")
+                f"Geocoded '{address_string}' to ({location.latitude}, {location.longitude}) using User-Agent: {user_agent}"
+            )
             return (location.latitude, location.longitude)
         else:
             logger.warning(f"Could not geocode address: {address_string} (Address not found by Nominatim)")
@@ -66,48 +58,45 @@ def geocode_address(address_string: str) -> tuple[float, float] | None:
         logger.error(f"Geocoding timed out for address: {address_string}")
         return None
     except GeocoderServiceError as e:
+        # Log specific service errors (e.g., API limits, server issues)
         logger.error(f"Geocoding service error for address '{address_string}': {e}")
         return None
     except Exception as e:
+        # Catch any other unexpected exceptions during geocoding
         logger.exception(f"An unexpected error occurred during geocoding for address '{address_string}': {e}")
         return None
 
 
-# --- Helper to Format Address from Pretix Order (No changes needed here) ---
-
+# --- Helper to Format Address from Pretix Order ---
 def get_formatted_address_from_order(order) -> str | None:
     """
     Creates a formatted address string from a Pretix order's invoice address.
-    """
-    if not order.invoice_address:
-        return None
-    parts = []
-    if order.invoice_address.street: parts.append(order.invoice_address.street)
-    if order.invoice_address.city: parts.append(order.invoice_address.city)
-    if order.invoice_address.zipcode: parts.append(order.invoice_address.zipcode)
-    if order.invoice_address.state: parts.append(order.invoice_address.state)
-    if order.invoice_address.country: parts.append(str(order.invoice_address.country.name))
-    if not parts: return None
-    full_address = ", ".join(filter(None, parts))
-    return full_address
 
+    Args:
+        order: A Pretix `Order` object.
 
-# --- Example Usage (Conceptual - No changes needed here) ---
-# This function itself isn't called directly, the logic is in tasks.py
-def process_order_for_geocoding(order):
-    """Conceptual function showing how to use the geocoding."""
-    address_str = get_formatted_address_from_order(order)
-    if not address_str:
-        logger.info(f"Order {order.code} has no invoice address to geocode.")
+    Returns:
+        A formatted address string suitable for geocoding, or None if no address.
+    """
+    # Ensure order and invoice_address exist
+    if not order or not order.invoice_address:
         return None
 
-    coordinates = geocode_address(address_str)  # This now uses the configured User-Agent
-
-    if coordinates:
-        latitude, longitude = coordinates
-        logger.info(f"Successfully geocoded Order {order.code}: ({latitude}, {longitude})")
-        # Store coordinates...
-        return coordinates
-    else:
-        logger.warning(f"Failed to geocode Order {order.code} with address: {address_str}")
+    parts = []
+    addr = order.invoice_address  # Shortcut
+
+    # Add components in a likely useful order for geocoding
+    if addr.street: parts.append(addr.street)
+    if addr.city: parts.append(addr.city)
+    if addr.zipcode: parts.append(addr.zipcode)
+    if addr.state: parts.append(addr.state)
+    # Use the full country name if possible, geocoders often prefer it
+    if addr.country: parts.append(str(addr.country.name))
+
+    # Only return an address if we have useful parts
+    if not parts:
         return None
+
+    # Join parts with commas. Geocoders are usually good at parsing this.
+    full_address = ", ".join(filter(None, parts))  # filter(None,...) removes empty strings
+    return full_address

pretix_mapplugin/management/commands/geocode_existing_orders.py

@@ -1,16 +1,36 @@
 import logging
-from django.core.exceptions import FieldDoesNotExist
 from django.core.management.base import BaseCommand, CommandError
+from django.core.exceptions import FieldDoesNotExist
 
-# Import scope activation helpers
+# --- Import Pretix Global Settings accessor ---
 from django_scopes import scope
 
-# Import necessary Pretix models
-from pretix.base.models import Event, Order, Organizer
+# Check if Pretix version uses AbstractSettingsHolder or GlobalSettingsObject
+# Adjust import based on Pretix version if needed. Assume AbstractSettingsHolder for newer Pretix.
+try:
+    from pretix.base.settings import GlobalSettingsObject as SettingsProxy
+except ImportError:
+    try:
+        # Older pretix might use this pattern
+        from pretix.base.services.config import load_config
+
 
-# Import your Geocode model and the task
+        class SettingsProxy:
+            def __init__(self):
+                self.settings = load_config()
+    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.")
+
+# --- Import necessary Pretix models ---
+from pretix.base.models import Order, Event, Organizer
+
+# --- Import your Geocode model and the task ---
 from pretix_mapplugin.models import OrderGeocodeData
 from pretix_mapplugin.tasks import geocode_order_task
+# --- Import Default User-Agent ---
+from pretix_mapplugin.geocoding import DEFAULT_NOMINATIM_USER_AGENT
 
 logger = logging.getLogger(__name__)
 
@@ -20,23 +40,16 @@ 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.',
         )
 
@@ -49,86 +62,97 @@ class Command(BaseCommand):
         if event_slug and not organizer_slug:
             raise CommandError("You must specify --organizer when using --event.")
 
+        # --- 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.
+            setting_key = 'plugin:pretix_mapplugin:nominatim_user_agent'
+            user_agent = gs.settings.get(setting_key, DEFAULT_NOMINATIM_USER_AGENT)
+
+            if user_agent == DEFAULT_NOMINATIM_USER_AGENT:
+                self.stdout.write(self.style.WARNING(
+                    "Using default Nominatim User-Agent. Please set a specific "
+                    f"'{setting_key}' in your pretix.cfg."
+                ))
+        except Exception as e:
+            # Catch broad exception during settings access
+            self.stderr.write(self.style.ERROR(f"Failed to read plugin settings: {e}. Using default User-Agent."))
+            # Continue with default user_agent
+        # --- End Read User-Agent ---
+
         # --- Determine which organizers to process ---
         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...")
 
         # --- Initialize counters ---
         total_queued = 0
         total_skipped = 0
-        total_processed_orders = 0  # Track how many orders were checked
+        total_processed_orders = 0
 
         # --- Iterate through organizers and activate scope ---
         for organizer in organizers_to_process:
             self.stdout.write(f"\n--- Processing Organizer: {organizer.name} ({organizer.slug}) ---")
 
-            # --- Activate scope for this organizer ---
             with scope(organizer=organizer):
-                # --- Now perform queries WITHIN the scope ---
-
-                # Start with paid orders FOR THIS ORGANIZER
+                # --- Get orders ---
                 orders_qs = Order.objects.filter(status=Order.STATUS_PAID)
 
-                # Filter by specific Event if requested
-                if event_slug and organizer.slug == organizer_slug:  # Ensure we only filter for the specified org
+                # --- Filter by event if specified ---
+                if event_slug and organizer.slug == organizer_slug:
                     try:
-                        # Event query is now safe within organizer scope
-                        event = Event.objects.get(slug=event_slug)  # No need for organizer filter here
+                        event = Event.objects.get(slug=event_slug)
                         orders_qs = orders_qs.filter(event=event)
                         self.stdout.write(f"  Filtering orders for event: {event.name} ({event_slug})")
                     except Event.DoesNotExist:
-                        # Don't raise CommandError, just report and skip event for this organizer
                         self.stderr.write(self.style.WARNING(
                             f"  Event '{event_slug}' not found for this organizer. Skipping event filter."))
-                        # If only this event was requested for this organizer, skip to next organizer
-                        if organizer_slug and event_slug:
-                            continue
+                        if organizer_slug and event_slug: continue
 
-                # Filter orders needing geocoding (within scope)
+                # --- Filter orders needing geocoding ---
+                relation_name = 'geocode_data'  # Ensure this matches your model
                 if not force_recode:
                     try:
-                        # Check relation name - REPLACE 'geocode_data' if yours is different
-                        relation_name = 'geocode_data'  # Change if necessary
-                        Order._meta.get_field(relation_name)
+                        Order._meta.get_field(relation_name)  # Check existence
                         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"  Could not find reverse relation '{relation_name}' on Order model. Check OrderGeocodeData model. Skipping organizer."))
-                        continue  # Skip this organizer if relation is wrong
-                    except Exception as e:
                         self.stderr.write(
-                            self.style.ERROR(f"  Unexpected error checking relation: {e}. Skipping organizer."))
+                            self.style.ERROR(f"  Relation '{relation_name}' not found. Skipping organizer."))
+                        continue
+                    except Exception as e:
+                        self.stderr.write(self.style.ERROR(f"  Error checking relation: {e}. Skipping organizer."))
                         continue
                 else:
                     orders_to_process_qs = orders_qs
-                    self.stdout.write(self.style.WARNING(
-                        "  Processing ALL selected paid orders for this organizer (--force-recode)..."))
+                    self.stdout.write(self.style.WARNING("  Processing ALL selected paid orders (--force-recode)..."))
 
-                # Get count within scope
+                # --- Process orders for this scope ---
                 current_org_orders_count = orders_to_process_qs.count()
-                total_processed_orders += orders_qs.count()  # Count all checked orders for this org
+                all_checked_for_org = orders_qs.count()
+                total_processed_orders += all_checked_for_org
 
                 if current_org_orders_count == 0:
-                    self.stdout.write("  No orders need geocoding for this organizer/event.")
-                    continue  # Skip to next organizer
+                    self.stdout.write(f"  No orders need geocoding ({all_checked_for_org} checked).")
+                    continue
 
-                self.stdout.write(f"  Found {current_org_orders_count} order(s) to potentially geocode.")
+                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
 
-                # Iterate and queue (within scope)
                 for order in orders_to_process_qs.iterator():
                     if dry_run:
                         self.stdout.write(
@@ -136,9 +160,11 @@ class Command(BaseCommand):
                         org_queued += 1
                     else:
                         try:
-                            geocode_order_task.apply_async(args=[order.pk])
-                            # Be slightly less verbose inside the loop
-                            # self.stdout.write(f"    Queued Order: {order.code} (PK: {order.pk})")
+                            # --- Pass user_agent to task ---
+                            geocode_order_task.apply_async(
+                                args=[order.pk],
+                                kwargs={'nominatim_user_agent': user_agent}  # Pass as kwarg
+                            )
                             org_queued += 1
                         except Exception as e:
                             self.stderr.write(self.style.ERROR(f"    ERROR queuing Order {order.code}: {e}"))
@@ -148,14 +174,13 @@ class Command(BaseCommand):
                 self.stdout.write(f"  Queued: {org_queued}, Skipped: {org_skipped} for this organizer.")
                 total_queued += org_queued
                 total_skipped += org_skipped
-
-            # Scope for 'organizer' is automatically deactivated here by 'with' statement
+            # End scope
 
         # --- Final 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}")  # Report total checked
+        self.stdout.write(f"  Total orders checked (paid): {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)."))

pretix_mapplugin/migrations/0001_initial.py

@@ -1,4 +1,4 @@
-# Generated by Django 4.2.20 on 2025-04-15 22:47
+# Generated by Django 4.2.20 on 2025-04-15 23:21
 
 from django.db import migrations, models
 import django.db.models.deletion
@@ -6,18 +6,14 @@ import pretix.base.models.base
 
 
 class Migration(migrations.Migration):
-
     initial = True
 
-    dependencies = [
-        ('pretixbase', '0280_alter_customer_locale_alter_user_locale'),
-    ]
-
     operations = [
         migrations.CreateModel(
             name='OrderGeocodeData',
             fields=[
-                ('order', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, primary_key=True, related_name='geocode_data', serialize=False, to='pretixbase.order')),
+                ('order', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, primary_key=True,
+                                               related_name='geocode_data', serialize=False, to='pretixbase.order')),
                 ('latitude', models.FloatField()),
                 ('longitude', models.FloatField()),
                 ('geocoded_timestamp', models.DateTimeField(auto_now_add=True)),

pretix_mapplugin/signals.py

@@ -1,51 +1,73 @@
 import logging
 from django.dispatch import receiver
-from django.http import HttpRequest  # For type hinting
-from django.urls import NoReverseMatch, reverse  # Import reverse and NoReverseMatch
-from django.utils.translation import gettext_lazy as _  # For translatable labels
+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 ---
 from pretix.base.signals import order_paid
-from pretix.control.signals import nav_event  # Import the navigation signal
+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
 
 logger = logging.getLogger(__name__)
 
 # --- Constants ---
 MAP_VIEW_URL_NAME = 'plugins:pretix_mapplugin:event.settings.salesmap.show'
-# Define the permission required to see the map link
 REQUIRED_MAP_PERMISSION = 'can_view_orders'
+PLUGIN_NAME = 'pretix_mapplugin'  # Define plugin name for settings access
 
 
-# --- Signal Receiver for Geocoding (Keep As Is) ---
+# --- Signal Receiver for Geocoding (Reads setting, passes to task) ---
 @receiver(order_paid, dispatch_uid="sales_mapper_order_paid_geocode")
 def trigger_geocoding_on_payment(sender, order, **kwargs):
-    # ... (keep your existing geocoding logic) ...
+    """
+    Listens for the order_paid signal, reads geocoding config,
+    and queues the geocoding task with the config.
+    """
+    user_agent = DEFAULT_NOMINATIM_USER_AGENT  # Start with default
     try:
-        geocode_order_task.apply_async(args=[order.pk])
+        # --- Read User-Agent from settings (works in web process) ---
+        # Check structure defensively before accessing
+        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
+            )
+        else:
+            logger.warning(
+                f"Could not access settings.plugins.{PLUGIN_NAME}, "
+                "using default Nominatim User-Agent for task."
+            )
+
+        # --- Queue task with user_agent as keyword argument ---
+        geocode_order_task.apply_async(
+            args=[order.pk],
+            kwargs={'nominatim_user_agent': user_agent}  # Pass as kwarg
+        )
         logger.info(f"Geocoding task queued for paid order {order.code} (PK: {order.pk}).")
-    except NameError:
-        logger.error("geocode_order_task not found. Make sure it's imported correctly.")
+
+    except ImportError:  # Error finding geocode_order_task itself if tasks.py fails
+        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}")
 
 
-# --- Signal Receiver for Adding Navigation Item ---
+# --- Signal Receiver for Adding Navigation Item (No changes needed) ---
 @receiver(nav_event, dispatch_uid="sales_mapper_nav_event_add_map")
 def add_map_nav_item(sender, request: HttpRequest, **kwargs):
     """
     Adds a navigation item for the Sales Map to the event control panel sidebar.
     """
-    # Check if the user has the required permission for the current event
-    has_permission = request.user.has_event_permission(
-        request.organizer, request.event, REQUIRED_MAP_PERMISSION, request=request
-    )
-    if not has_permission:
-        return []  # Return empty list if user lacks permission
-
-    # Try to generate the URL for the map view
+    has_permission = request.user.has_event_permission(request.organizer, request.event, REQUIRED_MAP_PERMISSION,
+                                                       request=request)
+    if not has_permission: return []
     try:
         map_url = reverse(MAP_VIEW_URL_NAME, kwargs={
             'organizer': request.organizer.slug,
@@ -53,21 +75,13 @@ def add_map_nav_item(sender, request: HttpRequest, **kwargs):
         })
     except NoReverseMatch:
         logger.error(f"Could not reverse URL for map view '{MAP_VIEW_URL_NAME}'. Check urls.py.")
-        return []  # Return empty list if URL cannot be generated
-
-    # Check if the current page *is* the map page to set the 'active' state
+        return []
     is_active = False
     if hasattr(request, 'resolver_match') and request.resolver_match:
         is_active = request.resolver_match.view_name == MAP_VIEW_URL_NAME
-
-    # Define the navigation item dictionary
-    nav_item = {
-        'label': _('Sales Map'),  # Translatable label
+    return [{
+        'label': _('Sales Map'),
         'url': map_url,
         'active': is_active,
-        'icon': 'map-o',  # Font Awesome icon name (fa-map-o) - adjust if needed
-        # 'category': _('Orders'), # Optional: Suggests category, placement might vary
-    }
-
-    # Return the item in a list
-    return [nav_item]
+        'icon': 'map-o',
+    }]

pretix_mapplugin/tasks.py

@@ -1,74 +1,91 @@
 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
-from pretix.celery_app import app  # Import the Pretix Celery app instance
 
-from .geocoding import (  # Import from Step 3
-    geocode_address,
+# --- 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
 )
-from .models import OrderGeocodeData
 
 logger = logging.getLogger(__name__)
 
-@app.task(bind=True, max_retries=3, default_retry_delay=60) # Configure retry behavior
-def geocode_order_task(self, order_pk: int):
+
+# 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 an order's address and store the result.
+    Celery task to geocode the address for a given order PK.
+    Accepts the Nominatim User-Agent as an argument.
     """
     try:
-        order = Order.objects.select_related('invoice_address').get(pk=order_pk)
+        # Fetch order with related address and country data efficiently
+        order = Order.objects.select_related(
+            'invoice_address',
+            'invoice_address__country'
+        ).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 (e.g., if task retries)
-        if OrderGeocodeData.objects.filter(order=order).exists():
+        # 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
+            return  # Exit successfully
 
-        # 1. Get formatted address
+        # 1. Get formatted address string
         address_str = get_formatted_address_from_order(order)
         if not address_str:
-            logger.warning(f"Order {order.code} has no invoice address to geocode.")
-            return # Exit successfully, nothing to do
+            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 (using function from Step 3)
+        # 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) # This handles its own errors/logging
+        coordinates = geocode_address(address_str, nominatim_user_agent=nominatim_user_agent)
 
-        # 3. Store result if successful
-        if coordinates:
-            latitude, longitude = coordinates
-            try:
-                # Use update_or_create to handle potential race conditions gracefully,
-                # although the initial check makes it less likely.
+        # 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
-                    }
+                    defaults={'latitude': latitude, 'longitude': longitude}
                 )
-                if created:
-                    logger.info(f"Successfully geocoded and stored coordinates for Order {order.code}: ({latitude}, {longitude})")
-                else:
-                     logger.info(f"Successfully geocoded and updated coordinates for Order {order.code}: ({latitude}, {longitude})")
-
-            except Exception as e:
-                logger.exception(f"Failed to save geocode data for Order {order.code} to database: {e}")
-                # Optionally retry the task if saving failed
-                self.retry(exc=e)
-        else:
-            # Geocoding function failed (already logged within geocode_address)
-            logger.warning(f"Geocoding failed for Order {order.code}. No coordinates stored.")
-            # Decide if you want to retry here based on the type of geocoding failure
-            # For example, don't retry if address was not found, but maybe retry on timeout.
-            # The geocode_address function would need to return more info for that.
-            # For now, we just log and don't store anything.
+                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 Order.DoesNotExist:
-        logger.error(f"Order with PK {order_pk} not found for geocoding task.")
+    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 in the task
+        # Catch any other unexpected errors
         logger.exception(f"Unexpected error in geocode_order_task for Order PK {order_pk}: {e}")
-        # Retry on unexpected errors
-        self.retry(exc=e)
+        # Retry on potentially temporary errors (database, network issues etc.)
+        raise self.retry(exc=e)  # Let Celery handle retry logic