ok

backend/apps/core/management/commands/calculate_new_content.py

@@ -0,0 +1,209 @@
+"""
+Django management command to calculate new content.
+
+This replaces the Celery task for calculating new content.
+Run with: python manage.py calculate_new_content
+"""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Any
+from django.core.management.base import BaseCommand, CommandError
+from django.utils import timezone
+from django.core.cache import cache
+from django.db.models import Q
+
+from apps.parks.models import Park
+from apps.rides.models import Ride
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = 'Calculate new content and cache results'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--content-type',
+            type=str,
+            default='all',
+            choices=['all', 'parks', 'rides'],
+            help='Type of content to calculate (default: all)'
+        )
+        parser.add_argument(
+            '--days-back',
+            type=int,
+            default=30,
+            help='Number of days to look back for new content (default: 30)'
+        )
+        parser.add_argument(
+            '--limit',
+            type=int,
+            default=50,
+            help='Maximum number of results to calculate (default: 50)'
+        )
+        parser.add_argument(
+            '--verbose',
+            action='store_true',
+            help='Enable verbose output'
+        )
+
+    def handle(self, *args, **options):
+        content_type = options['content_type']
+        days_back = options['days_back']
+        limit = options['limit']
+        verbose = options['verbose']
+
+        if verbose:
+            self.stdout.write(f"Starting new content calculation for {content_type}")
+
+        try:
+            cutoff_date = timezone.now() - timedelta(days=days_back)
+            new_items = []
+
+            if content_type in ["all", "parks"]:
+                parks = self._get_new_parks(
+                    cutoff_date, limit if content_type == "parks" else limit * 2)
+                new_items.extend(parks)
+                if verbose:
+                    self.stdout.write(f"Found {len(parks)} new parks")
+
+            if content_type in ["all", "rides"]:
+                rides = self._get_new_rides(
+                    cutoff_date, limit if content_type == "rides" else limit * 2)
+                new_items.extend(rides)
+                if verbose:
+                    self.stdout.write(f"Found {len(rides)} new rides")
+
+            # Sort by date added (most recent first) and apply limit
+            new_items.sort(key=lambda x: x.get("date_added", ""), reverse=True)
+            new_items = new_items[:limit]
+
+            # Format results for API consumption
+            formatted_results = self._format_new_content_results(new_items)
+
+            # Cache results
+            cache_key = f"new_content:calculated:{content_type}:{days_back}:{limit}"
+            cache.set(cache_key, formatted_results, 1800)  # Cache for 30 minutes
+
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"Successfully calculated {len(formatted_results)} new items for {content_type}"
+                )
+            )
+
+            if verbose:
+                for item in formatted_results[:5]:  # Show first 5 items
+                    self.stdout.write(
+                        f"  {item['name']} ({item['park']}) - opened: {item['date_opened']}")
+
+        except Exception as e:
+            logger.error(f"Error calculating new content: {e}", exc_info=True)
+            raise CommandError(f"Failed to calculate new content: {e}")
+
+    def _get_new_parks(self, cutoff_date: datetime, limit: int) -> List[Dict[str, Any]]:
+        """Get recently added parks using real data."""
+        new_parks = (
+            Park.objects.filter(
+                Q(created_at__gte=cutoff_date) | Q(
+                    opening_date__gte=cutoff_date.date()),
+                status="OPERATING",
+            )
+            .select_related("location", "operator")
+            .order_by("-created_at", "-opening_date")[:limit]
+        )
+
+        results = []
+        for park in new_parks:
+            date_added = park.opening_date or park.created_at
+            if date_added:
+                if isinstance(date_added, datetime):
+                    date_added = date_added.date()
+
+            opening_date = getattr(park, "opening_date", None)
+            if opening_date and isinstance(opening_date, datetime):
+                opening_date = opening_date.date()
+
+            results.append({
+                "content_object": park,
+                "content_type": "park",
+                "id": park.pk,
+                "name": park.name,
+                "slug": park.slug,
+                "park": park.name,  # For parks, park field is the park name itself
+                "category": "park",
+                "date_added": date_added.isoformat() if date_added else "",
+                "date_opened": opening_date.isoformat() if opening_date else "",
+                "url": park.url,
+            })
+
+        return results
+
+    def _get_new_rides(self, cutoff_date: datetime, limit: int) -> List[Dict[str, Any]]:
+        """Get recently added rides using real data."""
+        new_rides = (
+            Ride.objects.filter(
+                Q(created_at__gte=cutoff_date) | Q(
+                    opening_date__gte=cutoff_date.date()),
+                status="OPERATING",
+            )
+            .select_related("park", "park__location")
+            .order_by("-created_at", "-opening_date")[:limit]
+        )
+
+        results = []
+        for ride in new_rides:
+            date_added = getattr(ride, "opening_date", None) or getattr(
+                ride, "created_at", None)
+            if date_added:
+                if isinstance(date_added, datetime):
+                    date_added = date_added.date()
+
+            opening_date = getattr(ride, "opening_date", None)
+            if opening_date and isinstance(opening_date, datetime):
+                opening_date = opening_date.date()
+
+            results.append({
+                "content_object": ride,
+                "content_type": "ride",
+                "id": ride.pk,
+                "name": ride.name,
+                "slug": ride.slug,
+                "park": ride.park.name if ride.park else "",
+                "category": "ride",
+                "date_added": date_added.isoformat() if date_added else "",
+                "date_opened": opening_date.isoformat() if opening_date else "",
+                "url": ride.url,
+                "park_url": ride.park.url if ride.park else "",
+            })
+
+        return results
+
+    def _format_new_content_results(self, new_items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Format new content results for frontend consumption."""
+        formatted_results = []
+
+        for item in new_items:
+            try:
+                # Format exactly as frontend expects
+                formatted_item = {
+                    "id": item["id"],
+                    "name": item["name"],
+                    "park": item["park"],
+                    "category": item["category"],
+                    "date_added": item["date_added"],
+                    "date_opened": item["date_opened"],
+                    "slug": item["slug"],
+                    "url": item["url"],
+                }
+
+                # Add park_url for rides
+                if item.get("park_url"):
+                    formatted_item["park_url"] = item["park_url"]
+
+                formatted_results.append(formatted_item)
+
+            except Exception as e:
+                logger.warning(f"Error formatting new content item: {e}")
+
+        return formatted_results

backend/apps/core/management/commands/calculate_trending.py

@@ -0,0 +1,337 @@
+"""
+Django management command to calculate trending content.
+
+This replaces the Celery task for calculating trending content.
+Run with: python manage.py calculate_trending
+"""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Any
+from django.core.management.base import BaseCommand, CommandError
+from django.utils import timezone
+from django.core.cache import cache
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q
+
+from apps.core.analytics import PageView
+from apps.parks.models import Park
+from apps.rides.models import Ride
+
+logger = logging.getLogger(__name__)
+
+
+class Command(BaseCommand):
+    help = 'Calculate trending content and cache results'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--content-type',
+            type=str,
+            default='all',
+            choices=['all', 'parks', 'rides'],
+            help='Type of content to calculate (default: all)'
+        )
+        parser.add_argument(
+            '--limit',
+            type=int,
+            default=50,
+            help='Maximum number of results to calculate (default: 50)'
+        )
+        parser.add_argument(
+            '--verbose',
+            action='store_true',
+            help='Enable verbose output'
+        )
+
+    def handle(self, *args, **options):
+        content_type = options['content_type']
+        limit = options['limit']
+        verbose = options['verbose']
+
+        if verbose:
+            self.stdout.write(f"Starting trending calculation for {content_type}")
+
+        try:
+            # Time windows for calculations
+            current_period_hours = 168  # 7 days
+            # 14 days (for previous 7-day window comparison)
+            previous_period_hours = 336
+
+            trending_items = []
+
+            if content_type in ["all", "parks"]:
+                park_items = self._calculate_trending_parks(
+                    current_period_hours,
+                    previous_period_hours,
+                    limit if content_type == "parks" else limit * 2
+                )
+                trending_items.extend(park_items)
+                if verbose:
+                    self.stdout.write(f"Calculated {len(park_items)} trending parks")
+
+            if content_type in ["all", "rides"]:
+                ride_items = self._calculate_trending_rides(
+                    current_period_hours,
+                    previous_period_hours,
+                    limit if content_type == "rides" else limit * 2
+                )
+                trending_items.extend(ride_items)
+                if verbose:
+                    self.stdout.write(f"Calculated {len(ride_items)} trending rides")
+
+            # Sort by trending score and apply limit
+            trending_items.sort(key=lambda x: x.get("trending_score", 0), reverse=True)
+            trending_items = trending_items[:limit]
+
+            # Format results for API consumption
+            formatted_results = self._format_trending_results(
+                trending_items, current_period_hours, previous_period_hours)
+
+            # Cache results
+            cache_key = f"trending:calculated:{content_type}:{limit}"
+            cache.set(cache_key, formatted_results, 3600)  # Cache for 1 hour
+
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"Successfully calculated {len(formatted_results)} trending items for {content_type}"
+                )
+            )
+
+            if verbose:
+                for item in formatted_results[:5]:  # Show first 5 items
+                    self.stdout.write(
+                        f"  {item['name']} (score: {item.get('views_change', 'N/A')})")
+
+        except Exception as e:
+            logger.error(f"Error calculating trending content: {e}", exc_info=True)
+            raise CommandError(f"Failed to calculate trending content: {e}")
+
+    def _calculate_trending_parks(self, current_period_hours: int, previous_period_hours: int, limit: int) -> List[Dict[str, Any]]:
+        """Calculate trending scores for parks using real data."""
+        parks = Park.objects.filter(
+            status="OPERATING").select_related("location", "operator")
+
+        trending_parks = []
+
+        for park in parks:
+            try:
+                score = self._calculate_content_score(
+                    park, "park", current_period_hours, previous_period_hours)
+                if score > 0:  # Only include items with positive trending scores
+                    trending_parks.append({
+                        "content_object": park,
+                        "content_type": "park",
+                        "trending_score": score,
+                        "id": park.id,
+                        "name": park.name,
+                        "slug": park.slug,
+                        "park": park.name,  # For parks, park field is the park name itself
+                        "category": "park",
+                        "rating": float(park.average_rating) if park.average_rating else 0.0,
+                        "date_opened": park.opening_date.isoformat() if park.opening_date else "",
+                        "url": park.url,
+                    })
+            except Exception as e:
+                logger.warning(f"Error calculating score for park {park.id}: {e}")
+
+        return trending_parks
+
+    def _calculate_trending_rides(self, current_period_hours: int, previous_period_hours: int, limit: int) -> List[Dict[str, Any]]:
+        """Calculate trending scores for rides using real data."""
+        rides = Ride.objects.filter(status="OPERATING").select_related(
+            "park", "park__location")
+
+        trending_rides = []
+
+        for ride in rides:
+            try:
+                score = self._calculate_content_score(
+                    ride, "ride", current_period_hours, previous_period_hours)
+                if score > 0:  # Only include items with positive trending scores
+                    trending_rides.append({
+                        "content_object": ride,
+                        "content_type": "ride",
+                        "trending_score": score,
+                        "id": ride.pk,
+                        "name": ride.name,
+                        "slug": ride.slug,
+                        "park": ride.park.name if ride.park else "",
+                        "category": "ride",
+                        "rating": float(ride.average_rating) if ride.average_rating else 0.0,
+                        "date_opened": ride.opening_date.isoformat() if ride.opening_date else "",
+                        "url": ride.url,
+                        "park_url": ride.park.url if ride.park else "",
+                    })
+            except Exception as e:
+                logger.warning(f"Error calculating score for ride {ride.pk}: {e}")
+
+        return trending_rides
+
+    def _calculate_content_score(self, content_obj: Any, content_type: str, current_period_hours: int, previous_period_hours: int) -> float:
+        """Calculate weighted trending score for content object using real analytics data."""
+        try:
+            # Get content type for PageView queries
+            ct = ContentType.objects.get_for_model(content_obj)
+
+            # 1. View Growth Score (40% weight)
+            view_growth_score = self._calculate_view_growth_score(
+                ct, content_obj.id, current_period_hours, previous_period_hours)
+
+            # 2. Rating Score (30% weight)
+            rating_score = self._calculate_rating_score(content_obj)
+
+            # 3. Recency Score (20% weight)
+            recency_score = self._calculate_recency_score(content_obj)
+
+            # 4. Popularity Score (10% weight)
+            popularity_score = self._calculate_popularity_score(
+                ct, content_obj.id, current_period_hours)
+
+            # Calculate weighted final score
+            final_score = (
+                view_growth_score * 0.4 +
+                rating_score * 0.3 +
+                recency_score * 0.2 +
+                popularity_score * 0.1
+            )
+
+            return final_score
+
+        except Exception as e:
+            logger.error(
+                f"Error calculating score for {content_type} {content_obj.id}: {e}")
+            return 0.0
+
+    def _calculate_view_growth_score(self, content_type: ContentType, object_id: int, current_period_hours: int, previous_period_hours: int) -> float:
+        """Calculate normalized view growth score using real PageView data."""
+        try:
+            current_views, previous_views, growth_percentage = PageView.get_views_growth(
+                content_type,
+                object_id,
+                current_period_hours,
+                previous_period_hours,
+            )
+
+            if previous_views == 0:
+                # New content with views gets boost
+                return min(current_views / 100.0, 1.0) if current_views > 0 else 0.0
+
+            # Normalize growth percentage to 0-1 scale
+            normalized_growth = min(growth_percentage / 500.0,
+                                    1.0) if growth_percentage > 0 else 0.0
+            return max(normalized_growth, 0.0)
+
+        except Exception as e:
+            logger.warning(f"Error calculating view growth: {e}")
+            return 0.0
+
+    def _calculate_rating_score(self, content_obj: Any) -> float:
+        """Calculate normalized rating score."""
+        try:
+            rating = getattr(content_obj, "average_rating", None)
+            if rating is None or rating == 0:
+                return 0.3  # Neutral score for unrated content
+
+            # Normalize rating from 1-10 scale to 0-1 scale
+            return min(max((float(rating) - 1) / 9.0, 0.0), 1.0)
+
+        except Exception as e:
+            logger.warning(f"Error calculating rating score: {e}")
+            return 0.3
+
+    def _calculate_recency_score(self, content_obj: Any) -> float:
+        """Calculate recency score based on when content was added/updated."""
+        try:
+            # Use opening_date for parks/rides, or created_at as fallback
+            date_added = getattr(content_obj, "opening_date", None)
+            if not date_added:
+                date_added = getattr(content_obj, "created_at", None)
+            if not date_added:
+                return 0.5  # Neutral score for unknown dates
+
+            # Handle both date and datetime objects
+            if hasattr(date_added, "date"):
+                date_added = date_added.date()
+
+            # Calculate days since added
+            today = timezone.now().date()
+            days_since_added = (today - date_added).days
+
+            # Recency score: newer content gets higher scores
+            if days_since_added <= 0:
+                return 1.0
+            elif days_since_added <= 30:
+                return 1.0 - (days_since_added / 30.0) * 0.2  # 1.0 to 0.8
+            elif days_since_added <= 365:
+                return 0.8 - ((days_since_added - 30) / (365 - 30)) * 0.7  # 0.8 to 0.1
+            else:
+                return 0.0
+
+        except Exception as e:
+            logger.warning(f"Error calculating recency score: {e}")
+            return 0.5
+
+    def _calculate_popularity_score(self, content_type: ContentType, object_id: int, hours: int) -> float:
+        """Calculate popularity score based on total view count."""
+        try:
+            total_views = PageView.get_total_views_count(
+                content_type, object_id, hours=hours)
+
+            # Normalize views to 0-1 scale
+            if total_views == 0:
+                return 0.0
+            elif total_views <= 100:
+                return total_views / 200.0  # 0.0 to 0.5
+            else:
+                return min(0.5 + (total_views - 100) / 1800.0, 1.0)  # 0.5 to 1.0
+
+        except Exception as e:
+            logger.warning(f"Error calculating popularity score: {e}")
+            return 0.0
+
+    def _format_trending_results(self, trending_items: List[Dict[str, Any]], current_period_hours: int, previous_period_hours: int) -> List[Dict[str, Any]]:
+        """Format trending results for frontend consumption."""
+        formatted_results = []
+
+        for rank, item in enumerate(trending_items, 1):
+            try:
+                # Get view change for display
+                content_obj = item["content_object"]
+                ct = ContentType.objects.get_for_model(content_obj)
+                current_views, previous_views, growth_percentage = PageView.get_views_growth(
+                    ct,
+                    content_obj.id,
+                    current_period_hours,
+                    previous_period_hours,
+                )
+
+                # Format exactly as frontend expects
+                formatted_item = {
+                    "id": item["id"],
+                    "name": item["name"],
+                    "park": item["park"],
+                    "category": item["category"],
+                    "rating": item["rating"],
+                    "rank": rank,
+                    "views": current_views,
+                    "views_change": (
+                        f"+{growth_percentage:.1f}%"
+                        if growth_percentage > 0
+                        else f"{growth_percentage:.1f}%"
+                    ),
+                    "slug": item["slug"],
+                    "date_opened": item["date_opened"],
+                    "url": item["url"],
+                }
+
+                # Add park_url for rides
+                if item.get("park_url"):
+                    formatted_item["park_url"] = item["park_url"]
+
+                formatted_results.append(formatted_item)
+
+            except Exception as e:
+                logger.warning(f"Error formatting trending item: {e}")
+
+        return formatted_results

backend/apps/core/services/trending_service.py

@@ -58,7 +58,7 @@ class TrendingService:
         self, content_type: str = "all", limit: int = 20, force_refresh: bool = False
     ) -> List[Dict[str, Any]]:
         """
-        Get trending content with caching.
+        Get trending content using direct calculation.
 
         Args:
             content_type: 'parks', 'rides', or 'all'
@@ -68,7 +68,7 @@ class TrendingService:
         Returns:
             List of trending content with exact frontend format
         """
-        cache_key = f"{self.CACHE_PREFIX}:trending:{content_type}:{limit}"
+        cache_key = f"trending:calculated:{content_type}:{limit}"
 
         if not force_refresh:
             cached_result = cache.get(cache_key)
@@ -78,41 +78,38 @@ class TrendingService:
                 )
                 return cached_result
 
-        self.logger.info(f"Calculating trending content for {content_type}")
+        self.logger.info(f"Getting trending content for {content_type}")
 
         try:
-            # Calculate trending scores for each content type
+            # Calculate directly without Celery
             trending_items = []
 
             if content_type in ["all", "parks"]:
                 park_items = self._calculate_trending_parks(
-                    limit if content_type == "parks" else limit * 2
-                )
+                    limit * 2 if content_type == "all" else limit)
                 trending_items.extend(park_items)
 
             if content_type in ["all", "rides"]:
                 ride_items = self._calculate_trending_rides(
-                    limit if content_type == "rides" else limit * 2
-                )
+                    limit * 2 if content_type == "all" else limit)
                 trending_items.extend(ride_items)
 
             # Sort by trending score and apply limit
             trending_items.sort(key=lambda x: x.get("trending_score", 0), reverse=True)
             trending_items = trending_items[:limit]
 
-            # Add ranking and format for frontend
+            # Format results for API consumption
             formatted_results = self._format_trending_results(trending_items)
 
             # Cache results
             cache.set(cache_key, formatted_results, self.CACHE_TTL)
 
             self.logger.info(
-                f"Calculated {len(formatted_results)} trending items for {content_type}"
-            )
+                f"Calculated {len(formatted_results)} trending items for {content_type}")
             return formatted_results
 
         except Exception as e:
-            self.logger.error(f"Error calculating trending content: {e}", exc_info=True)
+            self.logger.error(f"Error getting trending content: {e}", exc_info=True)
             return []
 
     def get_new_content(
@@ -123,7 +120,7 @@ class TrendingService:
         force_refresh: bool = False,
     ) -> List[Dict[str, Any]]:
         """
-        Get recently added content.
+        Get recently added content using direct calculation.
 
         Args:
             content_type: 'parks', 'rides', or 'all'
@@ -134,7 +131,7 @@ class TrendingService:
         Returns:
             List of new content with exact frontend format
         """
-        cache_key = f"{self.CACHE_PREFIX}:new:{content_type}:{limit}:{days_back}"
+        cache_key = f"new_content:calculated:{content_type}:{days_back}:{limit}"
 
         if not force_refresh:
             cached_result = cache.get(cache_key)
@@ -144,37 +141,35 @@ class TrendingService:
                 )
                 return cached_result
 
-        self.logger.info(f"Calculating new content for {content_type}")
+        self.logger.info(f"Getting new content for {content_type}")
 
         try:
+            # Calculate directly without Celery
             cutoff_date = timezone.now() - timedelta(days=days_back)
             new_items = []
 
             if content_type in ["all", "parks"]:
                 parks = self._get_new_parks(
-                    cutoff_date, limit if content_type == "parks" else limit * 2
-                )
+                    cutoff_date, limit * 2 if content_type == "all" else limit)
                 new_items.extend(parks)
 
             if content_type in ["all", "rides"]:
                 rides = self._get_new_rides(
-                    cutoff_date, limit if content_type == "rides" else limit * 2
-                )
+                    cutoff_date, limit * 2 if content_type == "all" else limit)
                 new_items.extend(rides)
 
             # Sort by date added (most recent first) and apply limit
             new_items.sort(key=lambda x: x.get("date_added", ""), reverse=True)
             new_items = new_items[:limit]
 
-            # Format for frontend
+            # Format results for API consumption
             formatted_results = self._format_new_content_results(new_items)
 
             # Cache results
-            cache.set(cache_key, formatted_results, self.CACHE_TTL)
+            cache.set(cache_key, formatted_results, 1800)  # Cache for 30 minutes
 
             self.logger.info(
-                f"Found {len(formatted_results)} new items for {content_type}"
-            )
+                f"Calculated {len(formatted_results)} new items for {content_type}")
             return formatted_results
 
         except Exception as e:
@@ -184,7 +179,7 @@ class TrendingService:
     def _calculate_trending_parks(self, limit: int) -> List[Dict[str, Any]]:
         """Calculate trending scores for parks."""
         parks = Park.objects.filter(status="OPERATING").select_related(
-            "location", "operator"
+            "location", "operator", "card_image"
         )
 
         trending_parks = []
@@ -193,6 +188,32 @@ class TrendingService:
             try:
                 score = self._calculate_content_score(park, "park")
                 if score > 0:  # Only include items with positive trending scores
+                    # Get opening date for date_opened field
+                    opening_date = getattr(park, "opening_date", None)
+                    if opening_date and isinstance(opening_date, datetime):
+                        opening_date = opening_date.date()
+
+                    # Get location fields
+                    city = ""
+                    state = ""
+                    country = ""
+                    try:
+                        location = getattr(park, 'location', None)
+                        if location:
+                            city = getattr(location, 'city', '') or ""
+                            state = getattr(location, 'state', '') or ""
+                            country = getattr(location, 'country', '') or ""
+                    except Exception:
+                        pass
+
+                    # Get card image URL
+                    card_image_url = ""
+                    if park.card_image and hasattr(park.card_image, 'image'):
+                        card_image_url = park.card_image.image.url if park.card_image.image else ""
+
+                    # Get primary company (operator)
+                    primary_company = park.operator.name if park.operator else ""
+
                     trending_parks.append(
                         {
                             "content_object": park,
@@ -201,17 +222,20 @@ class TrendingService:
                             "id": park.id,
                             "name": park.name,
                             "slug": park.slug,
-                            "location": (
-                                park.formatted_location
-                                if hasattr(park, "location")
-                                else ""
-                            ),
+                            "park": park.name,  # For parks, park field is the park name itself
                             "category": "park",
                             "rating": (
                                 float(park.average_rating)
                                 if park.average_rating
                                 else 0.0
                             ),
+                            "date_opened": opening_date.isoformat() if opening_date else "",
+                            "url": park.url,
+                            "card_image": card_image_url,
+                            "city": city,
+                            "state": state,
+                            "country": country,
+                            "primary_company": primary_company,
                         }
                     )
             except Exception as e:
@@ -222,7 +246,7 @@ class TrendingService:
     def _calculate_trending_rides(self, limit: int) -> List[Dict[str, Any]]:
         """Calculate trending scores for rides."""
         rides = Ride.objects.filter(status="OPERATING").select_related(
-            "park", "park__location"
+            "park", "park__location", "card_image"
         )
 
         trending_rides = []
@@ -231,14 +255,15 @@ class TrendingService:
             try:
                 score = self._calculate_content_score(ride, "ride")
                 if score > 0:  # Only include items with positive trending scores
-                    # Get location from park (rides don't have direct location field)
-                    location = ""
-                    if (
-                        ride.park
-                        and hasattr(ride.park, "location")
-                        and ride.park.location
-                    ):
-                        location = ride.park.formatted_location
+                    # Get opening date for date_opened field
+                    opening_date = getattr(ride, "opening_date", None)
+                    if opening_date and isinstance(opening_date, datetime):
+                        opening_date = opening_date.date()
+
+                    # Get card image URL
+                    card_image_url = ""
+                    if ride.card_image and hasattr(ride.card_image, 'image'):
+                        card_image_url = ride.card_image.image.url if ride.card_image.image else ""
 
                     trending_rides.append(
                         {
@@ -248,13 +273,17 @@ class TrendingService:
                             "id": ride.pk,  # Use pk instead of id
                             "name": ride.name,
                             "slug": ride.slug,
-                            "location": location,
+                            "park": ride.park.name if ride.park else "",
                             "category": "ride",
                             "rating": (
                                 float(ride.average_rating)
                                 if ride.average_rating
                                 else 0.0
                             ),
+                            "date_opened": opening_date.isoformat() if opening_date else "",
+                            "url": ride.url,
+                            "park_url": ride.park.url if ride.park else "",
+                            "card_image": card_image_url,
                         }
                     )
             except Exception as e:
@@ -421,7 +450,7 @@ class TrendingService:
                 | Q(opening_date__gte=cutoff_date.date()),
                 status="OPERATING",
             )
-            .select_related("location", "operator")
+            .select_related("location", "operator", "card_image")
             .order_by("-created_at", "-opening_date")[:limit]
         )
 
@@ -435,6 +464,32 @@ class TrendingService:
                     date_added = date_added.date()
                 # If it's already a date, keep it as is
 
+            # Get opening date for date_opened field
+            opening_date = getattr(park, "opening_date", None)
+            if opening_date and isinstance(opening_date, datetime):
+                opening_date = opening_date.date()
+
+            # Get location fields
+            city = ""
+            state = ""
+            country = ""
+            try:
+                location = getattr(park, 'location', None)
+                if location:
+                    city = getattr(location, 'city', '') or ""
+                    state = getattr(location, 'state', '') or ""
+                    country = getattr(location, 'country', '') or ""
+            except Exception:
+                pass
+
+            # Get card image URL
+            card_image_url = ""
+            if park.card_image and hasattr(park.card_image, 'image'):
+                card_image_url = park.card_image.image.url if park.card_image.image else ""
+
+            # Get primary company (operator)
+            primary_company = park.operator.name if park.operator else ""
+
             results.append(
                 {
                     "content_object": park,
@@ -442,11 +497,16 @@ class TrendingService:
                     "id": park.pk,  # Use pk instead of id for Django compatibility
                     "name": park.name,
                     "slug": park.slug,
-                    "location": (
-                        park.formatted_location if hasattr(park, "location") else ""
-                    ),
+                    "park": park.name,  # For parks, park field is the park name itself
                     "category": "park",
                     "date_added": date_added.isoformat() if date_added else "",
+                    "date_opened": opening_date.isoformat() if opening_date else "",
+                    "url": park.url,
+                    "card_image": card_image_url,
+                    "city": city,
+                    "state": state,
+                    "country": country,
+                    "primary_company": primary_company,
                 }
             )
 
@@ -460,7 +520,7 @@ class TrendingService:
                 | Q(opening_date__gte=cutoff_date.date()),
                 status="OPERATING",
             )
-            .select_related("park", "park__location")
+            .select_related("park", "park__location", "card_image")
             .order_by("-created_at", "-opening_date")[:limit]
         )
 
@@ -476,10 +536,15 @@ class TrendingService:
                     date_added = date_added.date()
                 # If it's already a date, keep it as is
 
-            # Get location from park (rides don't have direct location field)
-            location = ""
-            if ride.park and hasattr(ride.park, "location") and ride.park.location:
-                location = ride.park.formatted_location
+            # Get opening date for date_opened field
+            opening_date = getattr(ride, "opening_date", None)
+            if opening_date and isinstance(opening_date, datetime):
+                opening_date = opening_date.date()
+
+            # Get card image URL
+            card_image_url = ""
+            if ride.card_image and hasattr(ride.card_image, 'image'):
+                card_image_url = ride.card_image.image.url if ride.card_image.image else ""
 
             results.append(
                 {
@@ -488,9 +553,13 @@ class TrendingService:
                     "id": ride.pk,  # Use pk instead of id for Django compatibility
                     "name": ride.name,
                     "slug": ride.slug,
-                    "location": location,
+                    "park": ride.park.name if ride.park else "",
                     "category": "ride",
                     "date_added": date_added.isoformat() if date_added else "",
+                    "date_opened": opening_date.isoformat() if opening_date else "",
+                    "url": ride.url,
+                    "park_url": ride.park.url if ride.park else "",
+                    "card_image": card_image_url,
                 }
             )
 
@@ -520,7 +589,7 @@ class TrendingService:
                 formatted_item = {
                     "id": item["id"],
                     "name": item["name"],
-                    "location": item["location"],
+                    "park": item["park"],
                     "category": item["category"],
                     "rating": item["rating"],
                     "rank": rank,
@@ -531,8 +600,29 @@ class TrendingService:
                         else f"{growth_percentage:.1f}%"
                     ),
                     "slug": item["slug"],
+                    "date_opened": item["date_opened"],
+                    "url": item["url"],
                 }
 
+                # Add card_image for all items
+                if item.get("card_image"):
+                    formatted_item["card_image"] = item["card_image"]
+
+                # Add park-specific fields
+                if item["content_type"] == "park":
+                    if item.get("city"):
+                        formatted_item["city"] = item["city"]
+                    if item.get("state"):
+                        formatted_item["state"] = item["state"]
+                    if item.get("country"):
+                        formatted_item["country"] = item["country"]
+                    if item.get("primary_company"):
+                        formatted_item["primary_company"] = item["primary_company"]
+
+                # Add park_url for rides
+                if item.get("park_url"):
+                    formatted_item["park_url"] = item["park_url"]
+
                 formatted_results.append(formatted_item)
 
             except Exception as e:
@@ -552,12 +642,33 @@ class TrendingService:
                 formatted_item = {
                     "id": item["id"],
                     "name": item["name"],
-                    "location": item["location"],
+                    "park": item["park"],
                     "category": item["category"],
                     "date_added": item["date_added"],
+                    "date_opened": item["date_opened"],
                     "slug": item["slug"],
+                    "url": item["url"],
                 }
 
+                # Add card_image for all items
+                if item.get("card_image"):
+                    formatted_item["card_image"] = item["card_image"]
+
+                # Add park-specific fields
+                if item["content_type"] == "park":
+                    if item.get("city"):
+                        formatted_item["city"] = item["city"]
+                    if item.get("state"):
+                        formatted_item["state"] = item["state"]
+                    if item.get("country"):
+                        formatted_item["country"] = item["country"]
+                    if item.get("primary_company"):
+                        formatted_item["primary_company"] = item["primary_company"]
+
+                # Add park_url for rides
+                if item.get("park_url"):
+                    formatted_item["park_url"] = item["park_url"]
+
                 formatted_results.append(formatted_item)
 
             except Exception as e:

backend/apps/core/tasks/__init__.py

@@ -0,0 +1,5 @@
+"""
+Core tasks package for ThrillWiki.
+
+This package contains all Celery tasks for the core application.
+"""

backend/apps/core/tasks/trending.py

@@ -0,0 +1,550 @@
+"""
+Trending calculation tasks for ThrillWiki.
+
+This module contains Celery tasks for calculating and caching trending content.
+All tasks run asynchronously to avoid blocking the main application.
+"""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional
+from celery import shared_task
+from django.utils import timezone
+from django.core.cache import cache
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q, Count, Avg, F
+from django.db import transaction
+
+from apps.core.analytics import PageView
+from apps.parks.models import Park
+from apps.rides.models import Ride
+
+logger = logging.getLogger(__name__)
+
+
+@shared_task(bind=True, max_retries=3, default_retry_delay=60)
+def calculate_trending_content(self, content_type: str = "all", limit: int = 50) -> Dict[str, Any]:
+    """
+    Calculate trending content using real analytics data.
+
+    This task runs periodically to update trending calculations based on:
+    - View growth rates
+    - Content ratings
+    - Recency factors
+    - Popularity metrics
+
+    Args:
+        content_type: 'parks', 'rides', or 'all'
+        limit: Maximum number of results to calculate
+
+    Returns:
+        Dict containing trending results and metadata
+    """
+    try:
+        logger.info(f"Starting trending calculation for {content_type}")
+
+        # Time windows for calculations
+        current_period_hours = 168  # 7 days
+        previous_period_hours = 336  # 14 days (for previous 7-day window comparison)
+
+        trending_items = []
+
+        if content_type in ["all", "parks"]:
+            park_items = _calculate_trending_parks(
+                current_period_hours,
+                previous_period_hours,
+                limit if content_type == "parks" else limit * 2
+            )
+            trending_items.extend(park_items)
+
+        if content_type in ["all", "rides"]:
+            ride_items = _calculate_trending_rides(
+                current_period_hours,
+                previous_period_hours,
+                limit if content_type == "rides" else limit * 2
+            )
+            trending_items.extend(ride_items)
+
+        # Sort by trending score and apply limit
+        trending_items.sort(key=lambda x: x.get("trending_score", 0), reverse=True)
+        trending_items = trending_items[:limit]
+
+        # Format results for API consumption
+        formatted_results = _format_trending_results(
+            trending_items, current_period_hours, previous_period_hours)
+
+        # Cache results
+        cache_key = f"trending:calculated:{content_type}:{limit}"
+        cache.set(cache_key, formatted_results, 3600)  # Cache for 1 hour
+
+        logger.info(
+            f"Calculated {len(formatted_results)} trending items for {content_type}")
+
+        return {
+            "success": True,
+            "content_type": content_type,
+            "count": len(formatted_results),
+            "results": formatted_results,
+            "calculated_at": timezone.now().isoformat(),
+        }
+
+    except Exception as e:
+        logger.error(f"Error calculating trending content: {e}", exc_info=True)
+        # Retry the task
+        raise self.retry(exc=e)
+
+
+@shared_task(bind=True, max_retries=3, default_retry_delay=30)
+def calculate_new_content(self, content_type: str = "all", days_back: int = 30, limit: int = 50) -> Dict[str, Any]:
+    """
+    Calculate new content based on opening dates and creation dates.
+
+    Args:
+        content_type: 'parks', 'rides', or 'all'
+        days_back: How many days to look back for new content
+        limit: Maximum number of results
+
+    Returns:
+        Dict containing new content results and metadata
+    """
+    try:
+        logger.info(f"Starting new content calculation for {content_type}")
+
+        cutoff_date = timezone.now() - timedelta(days=days_back)
+        new_items = []
+
+        if content_type in ["all", "parks"]:
+            parks = _get_new_parks(
+                cutoff_date, limit if content_type == "parks" else limit * 2)
+            new_items.extend(parks)
+
+        if content_type in ["all", "rides"]:
+            rides = _get_new_rides(
+                cutoff_date, limit if content_type == "rides" else limit * 2)
+            new_items.extend(rides)
+
+        # Sort by date added (most recent first) and apply limit
+        new_items.sort(key=lambda x: x.get("date_added", ""), reverse=True)
+        new_items = new_items[:limit]
+
+        # Format results for API consumption
+        formatted_results = _format_new_content_results(new_items)
+
+        # Cache results
+        cache_key = f"new_content:calculated:{content_type}:{days_back}:{limit}"
+        cache.set(cache_key, formatted_results, 1800)  # Cache for 30 minutes
+
+        logger.info(f"Calculated {len(formatted_results)} new items for {content_type}")
+
+        return {
+            "success": True,
+            "content_type": content_type,
+            "count": len(formatted_results),
+            "results": formatted_results,
+            "calculated_at": timezone.now().isoformat(),
+        }
+
+    except Exception as e:
+        logger.error(f"Error calculating new content: {e}", exc_info=True)
+        raise self.retry(exc=e)
+
+
+@shared_task(bind=True)
+def warm_trending_cache(self) -> Dict[str, Any]:
+    """
+    Warm the trending cache by pre-calculating common queries.
+
+    This task runs periodically to ensure fast API responses.
+    """
+    try:
+        logger.info("Starting trending cache warming")
+
+        # Common query combinations to pre-calculate
+        queries = [
+            {"content_type": "all", "limit": 20},
+            {"content_type": "parks", "limit": 10},
+            {"content_type": "rides", "limit": 10},
+            {"content_type": "all", "limit": 50},
+        ]
+
+        results = {}
+
+        for query in queries:
+            # Trigger trending calculation
+            calculate_trending_content.delay(**query)
+
+            # Trigger new content calculation
+            calculate_new_content.delay(**query)
+
+            results[f"trending_{query['content_type']}_{query['limit']}"] = "scheduled"
+            results[f"new_content_{query['content_type']}_{query['limit']}"] = "scheduled"
+
+        logger.info("Trending cache warming completed")
+
+        return {
+            "success": True,
+            "queries_scheduled": len(queries) * 2,
+            "results": results,
+            "warmed_at": timezone.now().isoformat(),
+        }
+
+    except Exception as e:
+        logger.error(f"Error warming trending cache: {e}", exc_info=True)
+        return {
+            "success": False,
+            "error": str(e),
+            "warmed_at": timezone.now().isoformat(),
+        }
+
+
+def _calculate_trending_parks(current_period_hours: int, previous_period_hours: int, limit: int) -> List[Dict[str, Any]]:
+    """Calculate trending scores for parks using real data."""
+    parks = Park.objects.filter(
+        status="OPERATING").select_related("location", "operator")
+
+    trending_parks = []
+
+    for park in parks:
+        try:
+            score = _calculate_content_score(
+                park, "park", current_period_hours, previous_period_hours)
+            if score > 0:  # Only include items with positive trending scores
+                trending_parks.append({
+                    "content_object": park,
+                    "content_type": "park",
+                    "trending_score": score,
+                    "id": park.id,
+                    "name": park.name,
+                    "slug": park.slug,
+                    "location": park.formatted_location if hasattr(park, "location") else "",
+                    "category": "park",
+                    "rating": float(park.average_rating) if park.average_rating else 0.0,
+                })
+        except Exception as e:
+            logger.warning(f"Error calculating score for park {park.id}: {e}")
+
+    return trending_parks
+
+
+def _calculate_trending_rides(current_period_hours: int, previous_period_hours: int, limit: int) -> List[Dict[str, Any]]:
+    """Calculate trending scores for rides using real data."""
+    rides = Ride.objects.filter(status="OPERATING").select_related(
+        "park", "park__location")
+
+    trending_rides = []
+
+    for ride in rides:
+        try:
+            score = _calculate_content_score(
+                ride, "ride", current_period_hours, previous_period_hours)
+            if score > 0:  # Only include items with positive trending scores
+                # Get location from park
+                location = ""
+                if ride.park and hasattr(ride.park, "location") and ride.park.location:
+                    location = ride.park.formatted_location
+
+                trending_rides.append({
+                    "content_object": ride,
+                    "content_type": "ride",
+                    "trending_score": score,
+                    "id": ride.pk,
+                    "name": ride.name,
+                    "slug": ride.slug,
+                    "location": location,
+                    "category": "ride",
+                    "rating": float(ride.average_rating) if ride.average_rating else 0.0,
+                })
+        except Exception as e:
+            logger.warning(f"Error calculating score for ride {ride.pk}: {e}")
+
+    return trending_rides
+
+
+def _calculate_content_score(content_obj: Any, content_type: str, current_period_hours: int, previous_period_hours: int) -> float:
+    """
+    Calculate weighted trending score for content object using real analytics data.
+
+    Algorithm Components:
+    - View Growth Rate (40% weight): Recent view increase vs historical
+    - Rating Score (30% weight): Average user rating normalized
+    - Recency Factor (20% weight): How recently content was added/updated
+    - Popularity Boost (10% weight): Total view count normalization
+
+    Returns:
+        Float between 0.0 and 1.0 representing trending strength
+    """
+    try:
+        # Get content type for PageView queries
+        ct = ContentType.objects.get_for_model(content_obj)
+
+        # 1. View Growth Score (40% weight)
+        view_growth_score = _calculate_view_growth_score(
+            ct, content_obj.id, current_period_hours, previous_period_hours)
+
+        # 2. Rating Score (30% weight)
+        rating_score = _calculate_rating_score(content_obj)
+
+        # 3. Recency Score (20% weight)
+        recency_score = _calculate_recency_score(content_obj)
+
+        # 4. Popularity Score (10% weight)
+        popularity_score = _calculate_popularity_score(
+            ct, content_obj.id, current_period_hours)
+
+        # Calculate weighted final score
+        final_score = (
+            view_growth_score * 0.4 +
+            rating_score * 0.3 +
+            recency_score * 0.2 +
+            popularity_score * 0.1
+        )
+
+        logger.debug(
+            f"{content_type} {content_obj.id}: "
+            f"growth={view_growth_score:.3f}, rating={rating_score:.3f}, "
+            f"recency={recency_score:.3f}, popularity={popularity_score:.3f}, "
+            f"final={final_score:.3f}"
+        )
+
+        return final_score
+
+    except Exception as e:
+        logger.error(
+            f"Error calculating score for {content_type} {content_obj.id}: {e}")
+        return 0.0
+
+
+def _calculate_view_growth_score(content_type: ContentType, object_id: int, current_period_hours: int, previous_period_hours: int) -> float:
+    """Calculate normalized view growth score using real PageView data."""
+    try:
+        current_views, previous_views, growth_percentage = PageView.get_views_growth(
+            content_type,
+            object_id,
+            current_period_hours,
+            previous_period_hours,
+        )
+
+        if previous_views == 0:
+            # New content with views gets boost
+            return min(current_views / 100.0, 1.0) if current_views > 0 else 0.0
+
+        # Normalize growth percentage to 0-1 scale
+        # 100% growth = 0.5, 500% growth = 1.0
+        normalized_growth = min(growth_percentage / 500.0,
+                                1.0) if growth_percentage > 0 else 0.0
+        return max(normalized_growth, 0.0)
+
+    except Exception as e:
+        logger.warning(f"Error calculating view growth: {e}")
+        return 0.0
+
+
+def _calculate_rating_score(content_obj: Any) -> float:
+    """Calculate normalized rating score."""
+    try:
+        rating = getattr(content_obj, "average_rating", None)
+        if rating is None or rating == 0:
+            return 0.3  # Neutral score for unrated content
+
+        # Normalize rating from 1-10 scale to 0-1 scale
+        # Rating of 5 = 0.4, Rating of 8 = 0.7, Rating of 10 = 1.0
+        return min(max((float(rating) - 1) / 9.0, 0.0), 1.0)
+
+    except Exception as e:
+        logger.warning(f"Error calculating rating score: {e}")
+        return 0.3
+
+
+def _calculate_recency_score(content_obj: Any) -> float:
+    """Calculate recency score based on when content was added/updated."""
+    try:
+        # Use opening_date for parks/rides, or created_at as fallback
+        date_added = getattr(content_obj, "opening_date", None)
+        if not date_added:
+            date_added = getattr(content_obj, "created_at", None)
+        if not date_added:
+            return 0.5  # Neutral score for unknown dates
+
+        # Handle both date and datetime objects
+        if hasattr(date_added, "date"):
+            date_added = date_added.date()
+
+        # Calculate days since added
+        today = timezone.now().date()
+        days_since_added = (today - date_added).days
+
+        # Recency score: newer content gets higher scores
+        # 0 days = 1.0, 30 days = 0.8, 365 days = 0.1, >365 days = 0.0
+        if days_since_added <= 0:
+            return 1.0
+        elif days_since_added <= 30:
+            return 1.0 - (days_since_added / 30.0) * 0.2  # 1.0 to 0.8
+        elif days_since_added <= 365:
+            return 0.8 - ((days_since_added - 30) / (365 - 30)) * 0.7  # 0.8 to 0.1
+        else:
+            return 0.0
+
+    except Exception as e:
+        logger.warning(f"Error calculating recency score: {e}")
+        return 0.5
+
+
+def _calculate_popularity_score(content_type: ContentType, object_id: int, hours: int) -> float:
+    """Calculate popularity score based on total view count."""
+    try:
+        total_views = PageView.get_total_views_count(
+            content_type, object_id, hours=hours)
+
+        # Normalize views to 0-1 scale
+        # 0 views = 0.0, 100 views = 0.5, 1000+ views = 1.0
+        if total_views == 0:
+            return 0.0
+        elif total_views <= 100:
+            return total_views / 200.0  # 0.0 to 0.5
+        else:
+            return min(0.5 + (total_views - 100) / 1800.0, 1.0)  # 0.5 to 1.0
+
+    except Exception as e:
+        logger.warning(f"Error calculating popularity score: {e}")
+        return 0.0
+
+
+def _get_new_parks(cutoff_date: datetime, limit: int) -> List[Dict[str, Any]]:
+    """Get recently added parks using real data."""
+    new_parks = (
+        Park.objects.filter(
+            Q(created_at__gte=cutoff_date) | Q(opening_date__gte=cutoff_date.date()),
+            status="OPERATING",
+        )
+        .select_related("location", "operator")
+        .order_by("-created_at", "-opening_date")[:limit]
+    )
+
+    results = []
+    for park in new_parks:
+        date_added = park.opening_date or park.created_at
+        if date_added:
+            if isinstance(date_added, datetime):
+                date_added = date_added.date()
+
+        opening_date = getattr(park, "opening_date", None)
+        if opening_date and isinstance(opening_date, datetime):
+            opening_date = opening_date.date()
+
+        results.append({
+            "content_object": park,
+            "content_type": "park",
+            "id": park.pk,
+            "name": park.name,
+            "slug": park.slug,
+            "park": park.name,  # For parks, park field is the park name itself
+            "category": "park",
+            "date_added": date_added.isoformat() if date_added else "",
+            "date_opened": opening_date.isoformat() if opening_date else "",
+        })
+
+    return results
+
+
+def _get_new_rides(cutoff_date: datetime, limit: int) -> List[Dict[str, Any]]:
+    """Get recently added rides using real data."""
+    new_rides = (
+        Ride.objects.filter(
+            Q(created_at__gte=cutoff_date) | Q(opening_date__gte=cutoff_date.date()),
+            status="OPERATING",
+        )
+        .select_related("park", "park__location")
+        .order_by("-created_at", "-opening_date")[:limit]
+    )
+
+    results = []
+    for ride in new_rides:
+        date_added = getattr(ride, "opening_date", None) or getattr(
+            ride, "created_at", None)
+        if date_added:
+            if isinstance(date_added, datetime):
+                date_added = date_added.date()
+
+        opening_date = getattr(ride, "opening_date", None)
+        if opening_date and isinstance(opening_date, datetime):
+            opening_date = opening_date.date()
+
+        results.append({
+            "content_object": ride,
+            "content_type": "ride",
+            "id": ride.pk,
+            "name": ride.name,
+            "slug": ride.slug,
+            "park": ride.park.name if ride.park else "",
+            "category": "ride",
+            "date_added": date_added.isoformat() if date_added else "",
+            "date_opened": opening_date.isoformat() if opening_date else "",
+        })
+
+    return results
+
+
+def _format_trending_results(trending_items: List[Dict[str, Any]], current_period_hours: int, previous_period_hours: int) -> List[Dict[str, Any]]:
+    """Format trending results for frontend consumption."""
+    formatted_results = []
+
+    for rank, item in enumerate(trending_items, 1):
+        try:
+            # Get view change for display
+            content_obj = item["content_object"]
+            ct = ContentType.objects.get_for_model(content_obj)
+            current_views, previous_views, growth_percentage = PageView.get_views_growth(
+                ct,
+                content_obj.id,
+                current_period_hours,
+                previous_period_hours,
+            )
+
+            # Format exactly as frontend expects
+            formatted_item = {
+                "id": item["id"],
+                "name": item["name"],
+                "location": item["location"],
+                "category": item["category"],
+                "rating": item["rating"],
+                "rank": rank,
+                "views": current_views,
+                "views_change": (
+                    f"+{growth_percentage:.1f}%"
+                    if growth_percentage > 0
+                    else f"{growth_percentage:.1f}%"
+                ),
+                "slug": item["slug"],
+            }
+
+            formatted_results.append(formatted_item)
+
+        except Exception as e:
+            logger.warning(f"Error formatting trending item: {e}")
+
+    return formatted_results
+
+
+def _format_new_content_results(new_items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Format new content results for frontend consumption."""
+    formatted_results = []
+
+    for item in new_items:
+        try:
+            # Format exactly as frontend expects
+            formatted_item = {
+                "id": item["id"],
+                "name": item["name"],
+                "park": item["park"],
+                "category": item["category"],
+                "date_added": item["date_added"],
+                "date_opened": item["date_opened"],
+                "slug": item["slug"],
+            }
+
+            formatted_results.append(formatted_item)
+
+        except Exception as e:
+            logger.warning(f"Error formatting new content item: {e}")
+
+    return formatted_results