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

{pretix_map-0.1.1/pretix_map.egg-info → pretix_map-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pretix-map
-Version: 0.1.1
+Version: 0.1.3
 Summary: An overview map of the catchment area of previous orders. Measured by postcode
 Author-email: MarkenJaden <jjsch1410@gmail.com>
 Maintainer-email: MarkenJaden <jjsch1410@gmail.com>

{pretix_map-0.1.1 → pretix_map-0.1.3/pretix_map.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pretix-map
-Version: 0.1.1
+Version: 0.1.3
 Summary: An overview map of the catchment area of previous orders. Measured by postcode
 Author-email: MarkenJaden <jjsch1410@gmail.com>
 Maintainer-email: MarkenJaden <jjsch1410@gmail.com>

{pretix_map-0.1.1 → pretix_map-0.1.3}/pretix_map.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ pretix_mapplugin/management/__init__.py
 pretix_mapplugin/management/commands/__init__.py
 pretix_mapplugin/management/commands/geocode_existing_orders.py
 pretix_mapplugin/migrations/0001_initial.py
+pretix_mapplugin/migrations/0002_remove_ordergeocodedata_geocoded_timestamp_and_more.py
 pretix_mapplugin/migrations/__init__.py
 pretix_mapplugin/static/pretix_mapplugin/.gitkeep
 pretix_mapplugin/static/pretix_mapplugin/css/salesmap.css

pretix_map-0.1.3/pretix_mapplugin/__init__.py

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

pretix_map-0.1.3/pretix_mapplugin/management/commands/geocode_existing_orders.py

@@ -0,0 +1,271 @@
+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
+
+# 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
+
+
+        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.")
+
+
+        # This will likely cause the command to fail later, but allows it to start
+        class SettingsProxy:
+            def __init__(self): self.settings = {}  # Empty dict to avoid errors later
+
+# --- Import necessary Pretix models ---
+from pretix.base.models import Order, Event, Organizer
+
+# --- Import your Geocode model and geocoding functions ---
+from pretix_mapplugin.models import OrderGeocodeData
+# --- 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 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.',
+        )
+        parser.add_argument(
+            '--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 without geocoding or saving.',
+        )
+        parser.add_argument(
+            '--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):
+        organizer_slug = options['organizer']
+        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.")
+
+        # --- Read User-Agent using Pretix Settings accessor ---
+        user_agent = DEFAULT_NOMINATIM_USER_AGENT
+        try:
+            gs = SettingsProxy()
+            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)
+
+            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:
+            self.stderr.write(self.style.ERROR(f"Failed to read plugin settings: {e}. Using default User-Agent."))
+        # --- End Read User-Agent ---
+
+        # --- Determine which organizers to process ---
+        organizers_to_process = []
+        if organizer_slug:
+            try:
+                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:
+            organizers_to_process = list(Organizer.objects.all())
+            self.stdout.write(f"Processing all {len(organizers_to_process)} organizers...")
+
+        # --- Initialize counters ---
+        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 ---
+        for organizer in organizers_to_process:
+            self.stdout.write(f"\n--- Processing Organizer: {organizer.name} ({organizer.slug}) ---")
+            # current_organizer_pk = organizer.pk # No longer needed for task
+
+            with scope(organizer=organizer):
+                # --- Get orders ---
+                orders_qs = Order.objects.filter(status=Order.STATUS_PAID).select_related(
+                    'invoice_address', 'invoice_address__country', 'event'
+                )
+
+                # --- 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 for event: {event.name} ({event_slug})")
+                    except Event.DoesNotExist:
+                        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)
+                        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:
+                        self.stderr.write(
+                            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
+
+                if not orders_to_geocode_list:
+                    self.stdout.write("  No orders require geocoding for this selection.")
+                    continue
+
+                # --- Process Orders Sequentially ---
+                count_this_org = 0
+                org_geocoded = 0
+                org_failed = 0
+                org_skipped_no_addr = 0
+                org_skipped_db = 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
+
+                    if dry_run:
+                        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:
+                            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:
+                            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 Geocoding Summary:")
+        self.stdout.write(f"  Organizers processed: {len(organizers_to_process)}")
+        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 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"  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_map-0.1.3/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_map-0.1.3/pretix_mapplugin/models.py

@@ -0,0 +1,47 @@
+from django.db import models
+from pretix.base.models import LoggedModel, Order
+
+
+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,
+        related_name='geocode_data',
+        primary_key=True  # Keep this if you want order PK as primary key
+    )
+    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:
+        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):
+        # 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_map-0.1.1 → pretix_map-0.1.3}/pretix_mapplugin/signals.py

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

pretix_map-0.1.3/pretix_mapplugin/static/pretix_mapplugin/css/salesmap.css

@@ -0,0 +1,52 @@
+.plugin-map-content-wrapper {
+    display: flex;
+    flex-direction: column;
+    height: calc(100vh - 200px);
+    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: 100%;
+    width: 100%;
+    display: block;
+    position: relative;
+}
+
+#map-status-overlay {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+}
+
+#map-status-overlay p {
+    padding: 1em;
+    background: #fff;
+    border-radius: 5px;
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
+}
+
+#heatmap-options-panel input[type=range] {
+    width: 100%;
+    display: block;
+}
+
+#map-status-overlay p.text-danger {
+    color: #a94442;
+    background-color: #f2dede;
+    border-color: #ebccd1;
+}