thrillwiki_django_no_react/parks/models.py

from django.db import models
from django.urls import reverse
from django.utils.text import slugify
from django.contrib.contenttypes.fields import GenericRelation
from django.core.exceptions import ValidationError
from decimal import Decimal, ROUND_DOWN, InvalidOperation
from typing import Tuple, Optional, Any, TYPE_CHECKING
import pghistory

from companies.models import Company
from media.models import Photo
from history_tracking.models import TrackedModel
from location.models import Location

if TYPE_CHECKING:
    from rides.models import Ride

@pghistory.track()
class Park(TrackedModel):
    id: int  # Type hint for Django's automatic id field
    STATUS_CHOICES = [
        ("OPERATING", "Operating"),
        ("CLOSED_TEMP", "Temporarily Closed"),
        ("CLOSED_PERM", "Permanently Closed"),
        ("UNDER_CONSTRUCTION", "Under Construction"),
        ("DEMOLISHED", "Demolished"),
        ("RELOCATED", "Relocated"),
    ]

    name = models.CharField(max_length=255)
    slug = models.SlugField(max_length=255, unique=True)
    description = models.TextField(blank=True)
    status = models.CharField(
        max_length=20, choices=STATUS_CHOICES, default="OPERATING"
    )

    # Location fields using GenericRelation
    location = GenericRelation(Location, related_query_name='park')

    # Details
    opening_date = models.DateField(null=True, blank=True)
    closing_date = models.DateField(null=True, blank=True)
    operating_season = models.CharField(max_length=255, blank=True)
    size_acres = models.DecimalField(
        max_digits=10, decimal_places=2, null=True, blank=True
    )
    website = models.URLField(blank=True)

    # Statistics
    average_rating = models.DecimalField(
        max_digits=3, decimal_places=2, null=True, blank=True
    )
    ride_count = models.IntegerField(null=True, blank=True)
    coaster_count = models.IntegerField(null=True, blank=True)

    # Relationships
    owner = models.ForeignKey(
        Company, on_delete=models.SET_NULL, null=True, blank=True, related_name="parks"
    )
    photos = GenericRelation(Photo, related_query_name="park")
    areas: models.Manager['ParkArea']  # Type hint for reverse relation
    rides: models.Manager['Ride']  # Type hint for reverse relation from rides app

    # Metadata
    created_at = models.DateTimeField(auto_now_add=True, null=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["name"]

    def __str__(self) -> str:
        return self.name

    def save(self, *args: Any, **kwargs: Any) -> None:
        from django.contrib.contenttypes.models import ContentType
        from history_tracking.models import HistoricalSlug
        
        # Get old instance if it exists
        if self.pk:
            try:
                old_instance = type(self).objects.get(pk=self.pk)
                old_name = old_instance.name
                old_slug = old_instance.slug
            except type(self).DoesNotExist:
                old_name = None
                old_slug = None
        else:
            old_name = None
            old_slug = None
        
        # Generate new slug if name has changed or slug is missing
        if not self.slug or (old_name and old_name != self.name):
            self.slug = slugify(self.name)
        
        # Save the model
        super().save(*args, **kwargs)
        
        # If slug has changed, save historical record
        if old_slug and old_slug != self.slug:
            HistoricalSlug.objects.create(
                content_type=ContentType.objects.get_for_model(self),
                object_id=self.pk,
                slug=old_slug
            )

    def get_absolute_url(self) -> str:
        return reverse("parks:park_detail", kwargs={"slug": self.slug})

    def get_status_color(self) -> str:
        """Get Tailwind color classes for park status"""
        status_colors = {
            'OPERATING': 'bg-green-100 text-green-800',
            'CLOSED_TEMP': 'bg-yellow-100 text-yellow-800',
            'CLOSED_PERM': 'bg-red-100 text-red-800',
            'UNDER_CONSTRUCTION': 'bg-blue-100 text-blue-800',
            'DEMOLISHED': 'bg-gray-100 text-gray-800',
            'RELOCATED': 'bg-purple-100 text-purple-800',
        }
        return status_colors.get(self.status, 'bg-gray-100 text-gray-500')

    @property
    def formatted_location(self) -> str:
        if self.location.exists():
            location = self.location.first()
            if location:
                return location.get_formatted_address()
        return ""

    @property
    def coordinates(self) -> Optional[Tuple[float, float]]:
        """Returns coordinates as a tuple (latitude, longitude)"""
        if self.location.exists():
            location = self.location.first()
            if location:
                return location.coordinates
        return None

    @classmethod
    def get_by_slug(cls, slug: str) -> Tuple['Park', bool]:
        """Get park by current or historical slug"""
        from django.contrib.contenttypes.models import ContentType
        from history_tracking.models import HistoricalSlug
        
        print(f"\nLooking up slug: {slug}")
        
        try:
            park = cls.objects.get(slug=slug)
            print(f"Found current park with slug: {slug}")
            return park, False
        except cls.DoesNotExist:
            print(f"No current park found with slug: {slug}")
            
            # Try historical slugs in HistoricalSlug model
            content_type = ContentType.objects.get_for_model(cls)
            print(f"Searching HistoricalSlug with content_type: {content_type}")
            historical = HistoricalSlug.objects.filter(
                content_type=content_type,
                slug=slug
            ).order_by('-created_at').first()
            
            if historical:
                print(f"Found historical slug record for object_id: {historical.object_id}")
                try:
                    park = cls.objects.get(pk=historical.object_id)
                    print(f"Found park from historical slug: {park.name}")
                    return park, True
                except cls.DoesNotExist:
                    print(f"Park not found for historical slug record")
                    pass
            else:
                print("No historical slug record found")
            
            # Try pghistory events
            print(f"Searching pghistory events")
            event_model = getattr(cls, 'event_model', None)
            if event_model:
                historical_event = event_model.objects.filter(
                    slug=slug
                ).order_by('-pgh_created_at').first()
            
            if historical_event:
                print(f"Found pghistory event for pgh_obj_id: {historical_event.pgh_obj_id}")
                try:
                    park = cls.objects.get(pk=historical_event.pgh_obj_id)
                    print(f"Found park from pghistory: {park.name}")
                    return park, True
                except cls.DoesNotExist:
                    print(f"Park not found for pghistory event")
                    pass
            else:
                print("No pghistory event found")
            
            raise cls.DoesNotExist("No park found with this slug")

@pghistory.track()
class ParkArea(TrackedModel):
    id: int  # Type hint for Django's automatic id field
    park = models.ForeignKey(Park, on_delete=models.CASCADE, related_name="areas")
    name = models.CharField(max_length=255)
    slug = models.SlugField(max_length=255)
    description = models.TextField(blank=True)
    opening_date = models.DateField(null=True, blank=True)
    closing_date = models.DateField(null=True, blank=True)

    # Metadata
    created_at = models.DateTimeField(auto_now_add=True, null=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["name"]
        unique_together = ["park", "slug"]

    def __str__(self) -> str:
        return f"{self.name} at {self.park.name}"

    def save(self, *args: Any, **kwargs: Any) -> None:
        if not self.slug:
            self.slug = slugify(self.name)
        super().save(*args, **kwargs)

    def get_absolute_url(self) -> str:
        return reverse(
            "parks:area_detail",
            kwargs={"park_slug": self.park.slug, "area_slug": self.slug},
        )

    @classmethod
    def get_by_slug(cls, slug: str) -> Tuple['ParkArea', bool]:
        """Get area by current or historical slug"""
        try:
            return cls.objects.get(slug=slug), False
        except cls.DoesNotExist:
            # Check historical slugs using pghistory
            history_model = cls.get_history_model()
            history = history_model.objects.filter(
                slug=slug
            ).order_by('-pgh_created_at').first()
            
            if history:
                try:
                    return cls.objects.get(pk=history.pgh_obj_id), True
                except cls.DoesNotExist as e:
                    raise cls.DoesNotExist("No park area found with this slug") from e
            raise cls.DoesNotExist("No park area found with this slug")