feat: Add currency system, collection templates, and unified search

- Add country currency fields and ExchangeRate model to worldtravel
- Add CollectionTemplate model for reusable trip templates
- Add template CRUD endpoints and frontend pages
- Add CurrencyDropdown, MoneyInput, and price badge components
- Add unified LocationSearchMap with reverse geocode integration
- Add exchange rates store and money formatting utilities
- Add AvgPriceBadge and PriceTierBadge shared card components
- Default public_profile=True for users

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: wanoo

backend/server/adventures/migrations/0081_collectiontemplate.py

@@ -0,0 +1,30 @@
+# Generated manually for CollectionTemplate model
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+        ('adventures', '0080_default_is_public_true'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='CollectionTemplate',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False, unique=True)),
+                ('name', models.CharField(max_length=255)),
+                ('description', models.TextField(blank=True, null=True)),
+                ('template_data', models.JSONField(default=dict)),
+                ('is_public', models.BooleanField(default=False)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='collection_templates', to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+    ]

backend/server/adventures/views/reverse_geocode_view.py

@@ -3,12 +3,22 @@
 from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
 from worldtravel.models import Region, City, VisitedRegion, VisitedCity
-from adventures.models import Location
+from adventures.models import Location, Lodging, Transportation
 from adventures.serializers import LocationSerializer
 from adventures.geocoding import reverse_geocode
 from django.conf import settings
+from django.db.models import Q
 from adventures.geocoding import search_google, search_osm
 
+SEARCH_MODE_SUFFIXES = {
+    'airport': ' Airport',
+    'train': ' Station',
+    'bus': ' Bus Station',
+    'location': '',
+    'cab': '',
+    'vtc': '',
+}
+
 class ReverseGeocodeViewSet(viewsets.ViewSet):
     permission_classes = [IsAuthenticated]
 
@@ -37,12 +47,186 @@ def search(self, request):
         try:
             if getattr(settings, 'GOOGLE_MAPS_API_KEY', None):
                 results = search_google(query)
+                # Google returned error dict - fallback to OSM
+                if isinstance(results, dict):
+                    results = search_osm(query)
             else:
                 results = search_osm(query)
+            # Final check: if still an error dict, return it as error
+            if isinstance(results, dict):
+                return Response(results, status=500)
             return Response(results)
         except Exception:
             return Response({"error": "An internal error occurred while processing the request"}, status=500)
 
+    @action(detail=False, methods=['get'])
+    def unified_search(self, request):
+        """
+        Unified search endpoint that combines:
+        1. Geocoding results (addresses from Google Maps/OSM)
+        2. User's own locations
+        3. User's own lodgings
+        4. User's transportation departures and arrivals
+
+        The search_mode parameter controls suffix appended to geocoding queries
+        (e.g., 'airport' appends ' Airport') without affecting internal entity queries.
+
+        Returns grouped results by source type for intelligent autocomplete.
+        """
+        query = request.query_params.get('query', '')
+        search_mode = request.query_params.get('search_mode', 'location')
+        include_geocode = request.query_params.get('include_geocode', 'true').lower() == 'true'
+        include_locations = request.query_params.get('include_locations', 'true').lower() == 'true'
+        include_lodging = request.query_params.get('include_lodging', 'true').lower() == 'true'
+        include_transportation = request.query_params.get('include_transportation', 'true').lower() == 'true'
+
+        if not query or len(query) < 2:
+            return Response({"error": "Query parameter must be at least 2 characters"}, status=400)
+
+        results = {
+            "addresses": [],
+            "locations": [],
+            "lodging": [],
+            "departures": [],
+            "arrivals": []
+        }
+
+        # Search user's locations (raw query, no suffix)
+        if include_locations:
+            locations = Location.objects.filter(
+                Q(user=self.request.user) | Q(is_public=True),
+                Q(name__icontains=query) | Q(location__icontains=query)
+            ).exclude(
+                latitude__isnull=True
+            ).exclude(
+                longitude__isnull=True
+            ).order_by('-updated_at')[:10]
+
+            results["locations"] = [
+                {
+                    "id": str(loc.id),
+                    "name": loc.name,
+                    "display_name": loc.location or loc.name,
+                    "lat": float(loc.latitude),
+                    "lon": float(loc.longitude),
+                    "type": "location",
+                    "category": loc.category.name if loc.category else None,
+                    "source": "location"
+                }
+                for loc in locations
+            ]
+
+        # Search user's lodging (raw query, no suffix)
+        if include_lodging:
+            lodging = Lodging.objects.filter(
+                Q(user=self.request.user) | Q(is_public=True),
+                Q(name__icontains=query) | Q(location__icontains=query)
+            ).exclude(
+                latitude__isnull=True
+            ).exclude(
+                longitude__isnull=True
+            ).order_by('-updated_at')[:10]
+
+            results["lodging"] = [
+                {
+                    "id": str(ldg.id),
+                    "name": ldg.name,
+                    "display_name": ldg.location or ldg.name,
+                    "lat": float(ldg.latitude),
+                    "lon": float(ldg.longitude),
+                    "type": ldg.type,
+                    "category": "lodging",
+                    "source": "lodging"
+                }
+                for ldg in lodging
+            ]
+
+        # Search user's transportation departures and arrivals (raw query, no suffix)
+        if include_transportation:
+            # Search departures (from_location)
+            departures = Transportation.objects.filter(
+                Q(user=self.request.user) | Q(is_public=True),
+                Q(from_location__icontains=query) | Q(name__icontains=query)
+            ).exclude(
+                origin_latitude__isnull=True
+            ).exclude(
+                origin_longitude__isnull=True
+            ).order_by('-updated_at')[:10]
+
+            # Use a set to deduplicate by coordinates
+            seen_departures = set()
+            for t in departures:
+                key = (float(t.origin_latitude), float(t.origin_longitude))
+                if key not in seen_departures:
+                    seen_departures.add(key)
+                    results["departures"].append({
+                        "id": str(t.id),
+                        "name": t.from_location or t.name,
+                        "display_name": t.from_location or t.name,
+                        "lat": float(t.origin_latitude),
+                        "lon": float(t.origin_longitude),
+                        "type": t.type,
+                        "category": "departure",
+                        "source": "departure",
+                        "code": t.start_code or None
+                    })
+
+            # Search arrivals (to_location)
+            arrivals = Transportation.objects.filter(
+                Q(user=self.request.user) | Q(is_public=True),
+                Q(to_location__icontains=query) | Q(name__icontains=query)
+            ).exclude(
+                destination_latitude__isnull=True
+            ).exclude(
+                destination_longitude__isnull=True
+            ).order_by('-updated_at')[:10]
+
+            # Use a set to deduplicate by coordinates
+            seen_arrivals = set()
+            for t in arrivals:
+                key = (float(t.destination_latitude), float(t.destination_longitude))
+                if key not in seen_arrivals:
+                    seen_arrivals.add(key)
+                    results["arrivals"].append({
+                        "id": str(t.id),
+                        "name": t.to_location or t.name,
+                        "display_name": t.to_location or t.name,
+                        "lat": float(t.destination_latitude),
+                        "lon": float(t.destination_longitude),
+                        "type": t.type,
+                        "category": "arrival",
+                        "source": "arrival",
+                        "code": t.end_code or None
+                    })
+
+        # Search addresses via geocoding (suffix applied here only)
+        if include_geocode:
+            try:
+                geocode_query = query + SEARCH_MODE_SUFFIXES.get(search_mode, '')
+                geocode_results = None
+
+                if getattr(settings, 'GOOGLE_MAPS_API_KEY', None):
+                    geocode_results = search_google(geocode_query)
+                    # Google returned error dict - fallback to OSM
+                    if isinstance(geocode_results, dict):
+                        geocode_results = search_osm(geocode_query)
+                else:
+                    geocode_results = search_osm(geocode_query)
+
+                if isinstance(geocode_results, list):
+                    results["addresses"] = [
+                        {
+                            **r,
+                            "source": "address"
+                        }
+                        for r in geocode_results[:10]
+                    ]
+            except Exception:
+                # Geocoding failed, but we can still return internal results
+                pass
+
+        return Response(results)
+
     @action(detail=False, methods=['post'])
     def mark_visited_region(self, request):
         """

backend/server/adventures/views/template_view.py

@@ -0,0 +1,155 @@
+from django.db.models import Q
+from rest_framework import viewsets, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from rest_framework.permissions import IsAuthenticated
+
+from adventures.models import (
+    CollectionTemplate, Collection, Transportation, Note, Checklist,
+    ChecklistItem, Lodging, Location
+)
+from adventures.serializers import CollectionTemplateSerializer, CollectionSerializer
+
+
+class CollectionTemplateViewSet(viewsets.ModelViewSet):
+    """
+    ViewSet for managing collection templates.
+
+    Supports:
+    - List own templates + public templates
+    - Retrieve template details
+    - Delete own templates
+    - Create collection from template
+    """
+    serializer_class = CollectionTemplateSerializer
+    permission_classes = [IsAuthenticated]
+
+    def get_queryset(self):
+        """Return user's own templates plus all public templates"""
+        user = self.request.user
+        return CollectionTemplate.objects.filter(
+            Q(user=user) | Q(is_public=True)
+        ).distinct()
+
+    def perform_create(self, serializer):
+        serializer.save(user=self.request.user)
+
+    def destroy(self, request, *args, **kwargs):
+        """Only allow deletion of own templates"""
+        instance = self.get_object()
+        if instance.user != request.user:
+            return Response(
+                {"error": "You can only delete your own templates"},
+                status=status.HTTP_403_FORBIDDEN
+            )
+        return super().destroy(request, *args, **kwargs)
+
+    def update(self, request, *args, **kwargs):
+        """Only allow update of own templates"""
+        instance = self.get_object()
+        if instance.user != request.user:
+            return Response(
+                {"error": "You can only update your own templates"},
+                status=status.HTTP_403_FORBIDDEN
+            )
+        return super().update(request, *args, **kwargs)
+
+    def partial_update(self, request, *args, **kwargs):
+        """Only allow partial update of own templates"""
+        instance = self.get_object()
+        if instance.user != request.user:
+            return Response(
+                {"error": "You can only update your own templates"},
+                status=status.HTTP_403_FORBIDDEN
+            )
+        return super().partial_update(request, *args, **kwargs)
+
+    @action(detail=True, methods=['post'], url_path='create-collection')
+    def create_collection(self, request, pk=None):
+        """
+        Create a new collection from a template.
+
+        The template_data contains structure for notes, checklists,
+        transportations, and lodgings that will be created in the new collection.
+        """
+        template = self.get_object()
+        user = request.user
+
+        # Get optional name override from request
+        collection_name = request.data.get('name', template.name)
+        collection_description = request.data.get('description', template.description)
+
+        # Create the new collection
+        new_collection = Collection.objects.create(
+            name=collection_name,
+            description=collection_description,
+            is_public=False,  # New collections from templates are always private
+            user=user,
+        )
+
+        template_data = template.template_data or {}
+
+        # Link locations from template (only those the user has access to)
+        location_ids = template_data.get('locations', [])
+        if location_ids:
+            # Get locations that the user owns or are public
+            accessible_locations = Location.objects.filter(
+                Q(id__in=location_ids) & (Q(user=user) | Q(is_public=True))
+            )
+            new_collection.locations.set(accessible_locations)
+
+        # Create notes from template
+        for note_data in template_data.get('notes', []):
+            Note.objects.create(
+                user=user,
+                collection=new_collection,
+                name=note_data.get('name', 'Untitled Note'),
+                content=note_data.get('content', ''),
+                links=note_data.get('links', []),
+                is_public=False,
+            )
+
+        # Create checklists from template
+        for checklist_data in template_data.get('checklists', []):
+            checklist = Checklist.objects.create(
+                user=user,
+                collection=new_collection,
+                name=checklist_data.get('name', 'Untitled Checklist'),
+                is_public=False,
+            )
+            # Create checklist items
+            for item_data in checklist_data.get('items', []):
+                ChecklistItem.objects.create(
+                    user=user,
+                    checklist=checklist,
+                    name=item_data.get('name', ''),
+                    is_checked=False,  # Always start unchecked
+                )
+
+        # Create transportations from template
+        for transport_data in template_data.get('transportations', []):
+            Transportation.objects.create(
+                user=user,
+                collection=new_collection,
+                type=transport_data.get('type', 'other'),
+                name=transport_data.get('name', 'Untitled Transportation'),
+                description=transport_data.get('description', ''),
+                from_location=transport_data.get('from_location', ''),
+                to_location=transport_data.get('to_location', ''),
+                is_public=False,
+            )
+
+        # Create lodgings from template
+        for lodging_data in template_data.get('lodgings', []):
+            Lodging.objects.create(
+                user=user,
+                collection=new_collection,
+                type=lodging_data.get('type', 'other'),
+                name=lodging_data.get('name', 'Untitled Lodging'),
+                description=lodging_data.get('description', ''),
+                location=lodging_data.get('location', ''),
+                is_public=False,
+            )
+
+        serializer = CollectionSerializer(new_collection, context={'request': request})
+        return Response(serializer.data, status=status.HTTP_201_CREATED)