pretix-map 0.0.5__tar.gz → 0.0.6__tar.gz

{pretix_map-0.0.5/pretix_map.egg-info → pretix_map-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pretix-map
-Version: 0.0.5
+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.5 → pretix_map-0.0.6/pretix_map.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pretix-map
-Version: 0.0.5
+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.6/pretix_mapplugin/__init__.py

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

pretix_map-0.0.6/pretix_mapplugin/geocoding.py

@@ -0,0 +1,102 @@
+import logging
+from geopy.geocoders import Nominatim
+from geopy.exc import GeocoderTimedOut, GeocoderServiceError
+from time import sleep
+
+# DO NOT import settings here, as it won't work reliably in Celery
+
+logger = logging.getLogger(__name__)
+
+# 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 (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, 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.
+    """
+    # 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."
+        )
+
+    # 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)
+
+        # 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}"
+            )
+            return (location.latitude, location.longitude)
+        else:
+            logger.warning(f"Could not geocode address: {address_string} (Address not found by Nominatim)")
+            return None
+
+    except GeocoderTimedOut:
+        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 ---
+def get_formatted_address_from_order(order) -> str | None:
+    """
+    Creates a formatted address string from a Pretix order's invoice address.
+
+    Args:
+        order: A Pretix `Order` object.
+
+    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
+
+    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_map-0.0.5 → pretix_map-0.0.6}/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_map-0.0.6/pretix_mapplugin/signals.py

@@ -0,0 +1,87 @@
+import logging
+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 ---
+from pretix.base.signals import order_paid
+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'
+REQUIRED_MAP_PERMISSION = 'can_view_orders'
+PLUGIN_NAME = 'pretix_mapplugin'  # Define plugin name for settings access
+
+
+# --- 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):
+    """
+    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:
+        # --- 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 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 (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.
+    """
+    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,
+            'event': request.event.slug,
+        })
+    except NoReverseMatch:
+        logger.error(f"Could not reverse URL for map view '{MAP_VIEW_URL_NAME}'. Check urls.py.")
+        return []
+    is_active = False
+    if hasattr(request, 'resolver_match') and request.resolver_match:
+        is_active = request.resolver_match.view_name == MAP_VIEW_URL_NAME
+    return [{
+        'label': _('Sales Map'),
+        'url': map_url,
+        'active': is_active,
+        'icon': 'map-o',
+    }]

pretix_map-0.0.6/pretix_mapplugin/tasks.py

@@ -0,0 +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
+
+# --- 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',
+            '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
+        # 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

pretix_map-0.0.5/pretix_mapplugin/__init__.py

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

pretix_map-0.0.5/pretix_mapplugin/geocoding.py

@@ -1,113 +0,0 @@
-import logging
-
-# --- Import Django settings ---
-from django.conf import settings
-from geopy.exc import GeocoderServiceError, GeocoderTimedOut
-from geopy.geocoders import Nominatim
-from time import sleep
-
-# Configure logging for your plugin
-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:
-    """
-    Tries to geocode a given address string using Nominatim, reading the
-    User-Agent from Pretix configuration.
-
-    Args:
-        address_string: A single string representing the address.
-
-    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.
-    if user_agent == DEFAULT_NOMINATIM_USER_AGENT:
-        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
-    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)
-
-        if location:
-            logger.debug(
-                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)")
-            return None
-
-    except GeocoderTimedOut:
-        logger.error(f"Geocoding timed out for address: {address_string}")
-        return None
-    except GeocoderServiceError as e:
-        logger.error(f"Geocoding service error for address '{address_string}': {e}")
-        return None
-    except Exception as e:
-        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) ---
-
-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
-
-
-# --- 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.")
-        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}")
-        return None

pretix_map-0.0.5/pretix_mapplugin/signals.py

@@ -1,73 +0,0 @@
-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
-
-# --- Pretix Signals ---
-from pretix.base.signals import order_paid
-from pretix.control.signals import nav_event  # Import the navigation signal
-
-# --- Tasks ---
-from .tasks import geocode_order_task
-
-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'
-
-
-# --- Signal Receiver for Geocoding (Keep As Is) ---
-@receiver(order_paid, dispatch_uid="sales_mapper_order_paid_geocode")
-def trigger_geocoding_on_payment(sender, order, **kwargs):
-    # ... (keep your existing geocoding logic) ...
-    try:
-        geocode_order_task.apply_async(args=[order.pk])
-        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 Exception as e:
-        logger.exception(f"Failed to queue geocoding task for order {order.code}: {e}")
-
-
-# --- Signal Receiver for Adding Navigation Item ---
-@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
-    try:
-        map_url = reverse(MAP_VIEW_URL_NAME, kwargs={
-            'organizer': request.organizer.slug,
-            'event': request.event.slug,
-        })
-    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
-    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
-        '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]

pretix_map-0.0.5/pretix_mapplugin/tasks.py

@@ -1,74 +0,0 @@
-import logging
-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,
-    get_formatted_address_from_order,
-)
-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):
-    """
-    Celery task to geocode an order's address and store the result.
-    """
-    try:
-        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 (e.g., if task retries)
-        if OrderGeocodeData.objects.filter(order=order).exists():
-            logger.info(f"Geocode data already exists for Order {order.code}. Skipping.")
-            return # Exit successfully
-
-        # 1. Get formatted address
-        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
-
-        # 2. Perform geocoding (using function from Step 3)
-        logger.debug(f"Attempting to geocode address for Order {order.code}: '{address_str}'")
-        coordinates = geocode_address(address_str) # This handles its own errors/logging
-
-        # 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.
-                obj, created = OrderGeocodeData.objects.update_or_create(
-                    order=order,
-                    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.
-
-    except Order.DoesNotExist:
-        logger.error(f"Order with PK {order_pk} not found for geocoding task.")
-        # Don't retry if the order doesn't exist
-    except Exception as e:
-        # Catch any other unexpected errors in the task
-        logger.exception(f"Unexpected error in geocode_order_task for Order PK {order_pk}: {e}")
-        # Retry on unexpected errors
-        self.retry(exc=e)