pretix-map 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

{pretix_map-0.1.2.dist-info → pretix_map-0.1.4.dist-info}/METADATA

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

@@ -1,8 +1,8 @@
-pretix_map-0.1.2.dist-info/licenses/LICENSE,sha256=RhQ89ePNDClBzEROahhwjDrBSEb5Zpx6XewZfGlY4Ss,569
-pretix_mapplugin/__init__.py,sha256=O1y2i1C4m602NbHgLdHmpflu9TGf21O6bs3ZEn_x0w4,23
+pretix_map-0.1.4.dist-info/licenses/LICENSE,sha256=RhQ89ePNDClBzEROahhwjDrBSEb5Zpx6XewZfGlY4Ss,569
+pretix_mapplugin/__init__.py,sha256=wQL21SKqJmZ-NSboyC8tgIR3EmyN1XDjwrN7CAHZpGQ,23
 pretix_mapplugin/apps.py,sha256=AnThwyRw2AAz5f-kmXZ8hm85OmKnlDkRosVoQOBgPzE,830
 pretix_mapplugin/geocoding.py,sha256=lBmwMvmE_cPyOHxWE8H3Se2P-2Eq0UjDTCv9gUs97Fo,4018
-pretix_mapplugin/models.py,sha256=v0v9K0sb5OQHs5Gc6-jea_aEGECUQp1tZoYMwwb3YIM,994
+pretix_mapplugin/models.py,sha256=klKrgMu1bmiPBwucTdOAZGWtv4WAEKcnoeqPlZgFR1A,2091
 pretix_mapplugin/signals.py,sha256=pSkucUPU6XgR0KLw4bKYEUW2Bqs5vfQXhO5YILQ2wps,3928
 pretix_mapplugin/tasks.py,sha256=F_c36RwyTQzUJ9kBBos_-2zth1UXw_kpcQpUcE90BNM,5428
 pretix_mapplugin/urls.py,sha256=o5407vULF4S-bUihU7AeRxUcMyazg2lPjbvqRflsGxE,838
@@ -14,12 +14,13 @@ 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=y6v7Oug0kw6cLAn0iJgaFGv6NYGP9f9K-zNavlyJq_8,11703
+pretix_mapplugin/management/commands/geocode_existing_orders.py,sha256=zD8OD7c1ZXPCR1KNOc-gWY8ZlIk_IbMKtagFinG6qf0,14099
 pretix_mapplugin/migrations/0001_initial.py,sha256=KAl1Egxptv1bpregGbsh8wUbr4Yh5A_zazVSAQdmoHM,1020
+pretix_mapplugin/migrations/0002_remove_ordergeocodedata_geocoded_timestamp_and_more.py,sha256=dXmZRdqrND0pxiPRuitlDdg-Q2JBqYG-sRPJxr6Urpk,889
 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
-pretix_mapplugin/static/pretix_mapplugin/js/salesmap.js,sha256=zKSWlJp96VCt6PFVuw5xV8jA-yCyWDG1Vj94Vq7hQlA,16941
+pretix_mapplugin/static/pretix_mapplugin/css/salesmap.css,sha256=9t2grYB2nWk90Q8h7XjDrlMw9UvcwYS4lcXM1KFidqI,964
+pretix_mapplugin/static/pretix_mapplugin/js/salesmap.js,sha256=ObXC0E0UOJMIiS5DobuGkTVjNzxDjODs8WgxbKaryWE,18591
 pretix_mapplugin/static/pretix_mapplugin/libs/leaflet-sales-map/MarkerCluster.Default.css,sha256=LWhzWaQGZRsWFrrJxg-6Zn8TT84k0_trtiHBc6qcGpY,1346
 pretix_mapplugin/static/pretix_mapplugin/libs/leaflet-sales-map/MarkerCluster.css,sha256=-bdWuWOXMFkX0v9Cvr3OWClPiYefDQz9GGZP_7xZxdc,886
 pretix_mapplugin/static/pretix_mapplugin/libs/leaflet-sales-map/leaflet-heat.js,sha256=aPb_2lnWKnXsUc1_-aT9-kbtr4CV3c85jH9xC1e5QDI,5168
@@ -38,9 +39,9 @@ pretix_mapplugin/static/pretix_mapplugin/libs/leaflet-sales-map/images/marker-ic
 pretix_mapplugin/static/pretix_mapplugin/libs/leaflet-sales-map/images/marker-icon.png,sha256=V0w6XMqF9BFAhbaEFZbWLwDXyJLHsD8oy_owHesdxDc,1466
 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.1.2.dist-info/METADATA,sha256=Qf2yvDEHWVnIs5rZNPeHDTLDD-LLyWuoUKhVtg5yj9c,9518
-pretix_map-0.1.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-pretix_map-0.1.2.dist-info/entry_points.txt,sha256=C3NAjeZHoCekafkLMCJynPcABRTK8AUprtQv7sUNDZs,137
-pretix_map-0.1.2.dist-info/top_level.txt,sha256=CAtEnkgA73zE9Gadm5mjt1SpXHBPOS-QWP0dQVoNToE,17
-pretix_map-0.1.2.dist-info/RECORD,,
+pretix_mapplugin/templates/pretix_mapplugin/map_page.html,sha256=wrUFxvtlmBhgADoRqB7sL3QsGETNC_DgYjWboHvDYFw,4827
+pretix_map-0.1.4.dist-info/METADATA,sha256=BkU4P9Kyz6cXKpmquqrTwkVXTd3ng0ygN_kmbP3YBuU,9518
+pretix_map-0.1.4.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pretix_map-0.1.4.dist-info/entry_points.txt,sha256=C3NAjeZHoCekafkLMCJynPcABRTK8AUprtQv7sUNDZs,137
+pretix_map-0.1.4.dist-info/top_level.txt,sha256=CAtEnkgA73zE9Gadm5mjt1SpXHBPOS-QWP0dQVoNToE,17
+pretix_map-0.1.4.dist-info/RECORD,,

pretix_mapplugin/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.2"
+__version__ = "0.1.4"

pretix_mapplugin/management/commands/geocode_existing_orders.py

@@ -1,6 +1,8 @@
 import logging
+import time  # Import time for sleep
 from django.core.management.base import BaseCommand, CommandError
 from django.core.exceptions import FieldDoesNotExist, ObjectDoesNotExist
+from django.db import transaction
 
 # --- Import Pretix Global Settings accessor ---
 from django_scopes import scope
@@ -8,7 +10,6 @@ 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:
@@ -31,38 +32,40 @@ except ImportError:
 # --- Import necessary Pretix models ---
 from pretix.base.models import Order, Event, Organizer
 
-# --- Import your Geocode model and the task ---
+# --- Import your Geocode model and geocoding functions ---
 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
+# --- Import geocoding functions directly, NOT the task ---
+from pretix_mapplugin.geocoding import (
+    geocode_address,
+    get_formatted_address_from_order,
+    DEFAULT_NOMINATIM_USER_AGENT
+)
 
 logger = logging.getLogger(__name__)
 
 
 class Command(BaseCommand):
-    help = 'Scans paid orders and queues geocoding tasks for those missing geocode data.'
+    help = ('Scans paid orders and geocodes addresses for those missing geocode data directly '
+            'within the command, respecting Nominatim rate limits (approx 1 req/sec). '
+            'This can take a long time for many orders.')
 
     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 without geocoding or saving.',
         )
         parser.add_argument(
-            '--force-recode',
-            action='store_true',
-            help='Queue geocoding even for orders that already have geocode data.',
+            '--force-recode', action='store_true',
+            help='Geocode even for orders that already have geocode data.',
+        )
+        parser.add_argument(
+            '--delay', type=float, default=1.1,
+            help='Delay in seconds between geocoding requests (default: 1.1 to be safe). Set to 0 to disable.'
         )
 
     def handle(self, *args, **options):
@@ -70,6 +73,14 @@ class Command(BaseCommand):
         event_slug = options['event']
         dry_run = options['dry_run']
         force_recode = options['force_recode']
+        delay = options['delay']
+
+        if delay < 1.0 and delay != 0:  # Allow disabling delay with 0
+            self.stdout.write(self.style.WARNING(
+                f"Delay is {delay}s, which is less than 1 second. This may violate Nominatim usage policy."))
+        elif delay == 0:
+            self.stdout.write(
+                self.style.WARNING("Delay is disabled (--delay 0). Ensure you comply with geocoding service terms."))
 
         if event_slug and not organizer_slug:
             raise CommandError("You must specify --organizer when using --event.")
@@ -78,8 +89,6 @@ class Command(BaseCommand):
         user_agent = DEFAULT_NOMINATIM_USER_AGENT
         try:
             gs = SettingsProxy()
-            # Construct the setting key specific to plugins
-            # The format 'plugin:plugin_name:setting_name' is common
             setting_key = 'plugin:pretix_mapplugin: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)
@@ -90,136 +99,173 @@ class Command(BaseCommand):
                     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
+        total_processed_count = 0  # Orders actually attempted (had address or forced)
+        total_geocoded_success = 0
+        total_geocode_failed = 0  # Geocoder returned None
+        total_skipped_no_address = 0
+        total_skipped_db_error = 0
+        total_checked_count = 0  # All orders matching initial filter
 
-        # --- Iterate through organizers and activate scope ---
+        # --- Iterate through organizers ---
         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
+            # current_organizer_pk = organizer.pk # No longer needed for task
 
             with scope(organizer=organizer):
-                # --- Get orders within scope ---
-                orders_qs = Order.objects.filter(status=Order.STATUS_PAID)
+                # --- Get orders ---
+                orders_qs = Order.objects.filter(status=Order.STATUS_PAID).select_related(
+                    'invoice_address', 'event'
+                )
 
-                # --- Filter by event if specified ---
+                # --- Filter by event ---
                 if event_slug and organizer.slug == organizer_slug:
                     try:
                         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})")
+                        self.stdout.write(f"  Filtering for event: {event.name} ({event_slug})")
                     except Event.DoesNotExist:
-                        self.stderr.write(self.style.WARNING(
-                            f"  Event '{event_slug}' not found for this organizer. Skipping event filter."))
-                        # 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's related_name
-                if not force_recode:
+                        self.stderr.write(
+                            self.style.WARNING(f"  Event '{event_slug}' not found. Skipping event filter."))
+                        if organizer_slug and event_slug: continue
+
+                # --- Determine which orders to process ---
+                relation_name = 'geocode_data'  # Check model
+                orders_to_geocode_list = []
+                current_checked_count = orders_qs.count()  # Count before filtering for geocode status
+                total_checked_count += current_checked_count
+
+                if force_recode:
+                    orders_to_geocode_list = list(orders_qs)
+                    self.stdout.write(self.style.WARNING(
+                        f"  Will process all {len(orders_to_geocode_list)} orders (--force-recode)..."))
+                else:
                     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...")
+                        Order._meta.get_field(relation_name)
+                        existing_pks = set(OrderGeocodeData.objects.filter(
+                            order__in=orders_qs
+                        ).values_list('order_id', flat=True))
+                        orders_to_geocode_list = list(orders_qs.exclude(pk__in=existing_pks))
+                        self.stdout.write(
+                            f"  Found {len(orders_to_geocode_list)} orders missing geocode data (out of {current_checked_count} checked).")
                     except FieldDoesNotExist:
-                        # 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
+                        self.stderr.write(
+                            self.style.ERROR(f"  Relation '{relation_name}' not found. Skipping organizer."))
+                        continue
                     except Exception as e:
-                        # 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 specified)..."))
+                        self.stderr.write(self.style.ERROR(f"  Error checking relation: {e}. Skipping organizer."))
+                        continue
 
-                # --- Process orders for this scope ---
-                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 not orders_to_geocode_list:
+                    self.stdout.write("  No orders require geocoding for this selection.")
+                    continue
 
-                if current_org_orders_count == 0:
-                    self.stdout.write(f"  No orders need geocoding ({all_checked_for_org} checked).")
-                    continue  # Skip to next organizer
+                # --- Process Orders Sequentially ---
+                count_this_org = 0
+                org_geocoded = 0
+                org_failed = 0
+                org_skipped_no_addr = 0
+                org_skipped_db = 0
 
-                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 i, order in enumerate(orders_to_geocode_list):
+                    count_this_org += 1
+                    self.stdout.write(
+                        f"  Processing order {count_this_org}/{len(orders_to_geocode_list)}: {order.code} ...",
+                        ending="")
+
+                    address_str = get_formatted_address_from_order(order)
+                    if not address_str:
+                        self.stdout.write(self.style.WARNING(" No address. Skipping."))
+                        total_skipped_no_address += 1
+                        org_skipped_no_addr += 1
+                        # Save null coords to prevent re-processing if not forcing
+                        if not dry_run and not force_recode:
+                            try:
+                                with transaction.atomic():
+                                    OrderGeocodeData.objects.update_or_create(order=order, defaults={'latitude': None,
+                                                                                                     'longitude': None})
+                            except Exception as db_err:
+                                self.stdout.write(self.style.ERROR(f" FAILED (DB Error saving null: {db_err})"))
+                                logger.exception(
+                                    f"Failed to save null geocode data via command for order {order.code}: {db_err}")
+                                total_skipped_db_error += 1
+                                org_skipped_db += 1
+                        continue  # Move to next order
+
+                    # Only increment this if we actually attempt geocoding
+                    total_processed_count += 1
 
-                # 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}, Org PK: {current_organizer_pk}) Event: {order.event.slug}")
-                        org_queued += 1
+                        self.stdout.write(self.style.SUCCESS(" [DRY RUN] Would geocode."))
+                        org_geocoded += 1  # Simulate success for dry run count
                     else:
+                        # --- Perform Geocoding Directly ---
+                        coordinates = geocode_address(address_str, nominatim_user_agent=user_agent)
+
+                        # --- Save Result ---
                         try:
-                            # --- Pass user_agent AND organizer_pk to the task ---
-                            geocode_order_task.apply_async(
-                                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
+                            with transaction.atomic():
+                                obj, created = OrderGeocodeData.objects.update_or_create(
+                                    order=order,
+                                    defaults={'latitude': coordinates[0] if coordinates else None,
+                                              'longitude': coordinates[1] if coordinates else None}
+                                )
+                            if coordinates:
+                                self.stdout.write(
+                                    self.style.SUCCESS(f" OK ({coordinates[0]:.4f}, {coordinates[1]:.4f})"))
+                                org_geocoded += 1
+                            else:
+                                self.stdout.write(self.style.WARNING(" FAILED (Geocode returned None)"))
+                                org_failed += 1
                         except Exception as 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
-
-                # 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 'with' block
+                            self.stdout.write(self.style.ERROR(f" FAILED (DB Error: {e})"))
+                            logger.exception(f"Failed to save geocode data via command for order {order.code}: {e}")
+                            org_skipped_db += 1  # Count DB errors separately
+
+                        # --- Apply Delay ---
+                        if delay > 0 and i < len(
+                                orders_to_geocode_list) - 1:  # Don't sleep after the last one or if delay is 0
+                            time.sleep(delay)
+
+                # Add org counts to totals
+                total_geocoded_success += org_geocoded
+                total_geocode_failed += org_failed
+                total_skipped_db_error += org_skipped_db
+
+                self.stdout.write(f"  Finished Organizer: Succeeded: {org_geocoded}, Failed Geocode: {org_failed}, "
+                                  f"Skipped (No Addr): {org_skipped_no_addr}, Skipped (DB Err): {org_skipped_db}.")
+            # End scope
 
         # --- Final Overall Report ---
         self.stdout.write("=" * 40)
-        self.stdout.write("Overall Summary:")
+        self.stdout.write("Overall Geocoding Summary:")
         self.stdout.write(f"  Organizers processed: {len(organizers_to_process)}")
-        self.stdout.write(f"  Total orders checked (paid, matching filters): {total_processed_orders}")
+        self.stdout.write(f"  Total Orders Checked (paid, matching filters): {total_checked_count}")
+        self.stdout.write(f"  Total Orders Attempted (had address or forced): {total_processed_count}")
         if dry_run:
-            self.stdout.write(
-                self.style.SUCCESS(f"[DRY RUN] Complete. Would have queued tasks for {total_queued} order(s)."))
+            self.stdout.write(self.style.SUCCESS(
+                f"[DRY RUN] Complete. Would have attempted geocoding for {total_processed_count} orders "
+                f"(+ {total_skipped_no_address} skipped due to no address)."))
         else:
-            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 (check logs)."))
+            self.stdout.write(self.style.SUCCESS(f"  Successfully Geocoded & Saved: {total_geocoded_success}"))
+            self.stdout.write(self.style.WARNING(f"  Geocoding Failed (None returned): {total_geocode_failed}"))
+            self.stdout.write(f"  Skipped (No Address): {total_skipped_no_address}")
+            if total_skipped_db_error > 0:
+                self.stdout.write(self.style.ERROR(f"  Skipped (DB Save Error): {total_skipped_db_error} (check logs)"))
         self.stdout.write("=" * 40)

pretix_mapplugin/migrations/0002_remove_ordergeocodedata_geocoded_timestamp_and_more.py

@@ -0,0 +1,32 @@
+# Generated by Django 4.2.20 on 2025-04-16 01:22
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('pretix_mapplugin', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='ordergeocodedata',
+            name='geocoded_timestamp',
+        ),
+        migrations.AddField(
+            model_name='ordergeocodedata',
+            name='last_geocoded_at',
+            field=models.DateTimeField(auto_now=True),
+        ),
+        migrations.AlterField(
+            model_name='ordergeocodedata',
+            name='latitude',
+            field=models.FloatField(null=True),
+        ),
+        migrations.AlterField(
+            model_name='ordergeocodedata',
+            name='longitude',
+            field=models.FloatField(null=True),
+        ),
+    ]

pretix_mapplugin/models.py

@@ -2,26 +2,46 @@ from django.db import models
 from pretix.base.models import LoggedModel, Order
 
 
-class OrderGeocodeData(LoggedModel):
+class OrderGeocodeData(LoggedModel):  # Keep LoggedModel if you want audit logs
     """
     Stores the geocoded coordinates for a Pretix Order's invoice address.
+    Allows null coordinates for failed geocoding attempts.
     """
     order = models.OneToOneField(
         Order,
-        on_delete=models.CASCADE, # Delete geocode data if order is deleted
-        related_name='geocode_data', # Allows accessing this from order: order.geocode_data
-        primary_key=True # Use the order's PK as this model's PK for efficiency
+        on_delete=models.CASCADE,
+        related_name='geocode_data',
+        primary_key=True  # Keep this if you want order PK as primary key
     )
-    latitude = models.FloatField()
-    longitude = models.FloatField()
-    geocoded_timestamp = models.DateTimeField(
-        auto_now_add=True # Automatically set when this record is created
+    latitude = models.FloatField(
+        null=True,  # Allow NULL in the database if geocoding fails
+        blank=True  # Allow blank in forms/admin (good practice with null=True)
+    )
+    longitude = models.FloatField(
+        null=True,  # Allow NULL in the database if geocoding fails
+        blank=True  # Allow blank in forms/admin
+    )
+
+    # Change to auto_now to update timestamp on every save (successful or null)
+    last_geocoded_at = models.DateTimeField(
+        auto_now=True,  # Set/Update timestamp every time the record is saved
+        help_text="Timestamp when geocoding was last attempted/updated."
     )
 
     class Meta:
-        # Optional: Define how instances are named in logs/admin
         verbose_name = "Order Geocode Data"
         verbose_name_plural = "Order Geocode Data"
+        # Optional: Indexing coordinates can speed up map data queries if you have many entries
+        # indexes = [
+        #     models.Index(fields=['latitude', 'longitude']),
+        # ]
 
     def __str__(self):
-        return f"Geocode data for Order {self.order.code}"
+        # Provide more informative string representation
+        if self.latitude is not None and self.longitude is not None:
+            return f"Geocode for Order {self.order.code}: ({self.latitude:.4f}, {self.longitude:.4f})"
+        else:
+            # Indicate if it's pending (never attempted) or failed (null coords stored)
+            # This requires knowing if the record exists but has nulls vs doesn't exist yet
+            # The current __str__ assumes the record exists if called.
+            return f"Geocode data for Order {self.order.code} (Coordinates: None)"

pretix_mapplugin/static/pretix_mapplugin/css/salesmap.css

@@ -1,8 +1,36 @@
+.plugin-map-content-wrapper {
+    display: flex;
+    flex-direction: column;
+    height: calc(100vh - 100px);
+    min-height: 450px;
+}
+
+.plugin-map-content-wrapper h1,
+.plugin-map-content-wrapper .form-group {
+    flex-shrink: 0;
+    margin-bottom: 1em;
+}
+
+.map-wrapper {
+    flex-grow: 1;
+    position: relative;
+    min-height: 0;
+    border: 1px solid #ccc;
+}
+
 #sales-map-container {
-    height: 500px;
+    height: 100%;
     width: 100%;
-    position: relative; /* Needed for Leaflet internal positioning */
-    background: #eee; /* Optional: Light background while tiles load */
+    display: block;
+    position: relative;
+}
+
+#map-status-overlay {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
 }
 
 #map-status-overlay p {
@@ -12,8 +40,13 @@
     box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
 }
 
-#map-status-overlay p.text-danger { /* Style for error messages */
-    color: #a94442; /* Bootstrap danger color */
-    background-color: #f2dede; /* Bootstrap danger background */
-    border-color: #ebccd1; /* Bootstrap danger border */
+#heatmap-options-panel input[type=range] {
+    width: 100%;
+    display: block;
+}
+
+#map-status-overlay p.text-danger {
+    color: #a94442;
+    background-color: #f2dede;
+    border-color: #ebccd1;
 }