update

backend/apps/parks/models/__init__.py

@@ -1,36 +0,0 @@
-"""
-Parks app models with clean import interface.
-
-This module provides a clean import interface for all parks-related models,
-enabling imports like: from parks.models import Park, Operator
-
-The Company model is aliased as Operator to clarify its role as park operators,
-while maintaining backward compatibility through the Company alias.
-"""
-
-from .parks import Park
-from .areas import ParkArea
-from .location import ParkLocation
-from .reviews import ParkReview
-from .companies import Company, CompanyHeadquarters
-from .media import ParkPhoto
-
-# Import choices to trigger registration
-from ..choices import *
-
-# Alias Company as Operator for clarity
-Operator = Company
-
-__all__ = [
-    # Primary models
-    "Park",
-    "ParkArea",
-    "ParkLocation",
-    "ParkReview",
-    "ParkPhoto",
-    # Company models with clear naming
-    "Operator",
-    "CompanyHeadquarters",
-    # Backward compatibility
-    "Company",  # Alias to Operator
-]

backend/apps/parks/models/areas.py

@@ -1,32 +0,0 @@
-from django.db import models
-from django.utils.text import slugify
-import pghistory
-
-from apps.core.history import TrackedModel
-from .parks import Park
-
-
-@pghistory.track()
-class ParkArea(TrackedModel):
-    # Import managers
-    from ..managers import ParkAreaManager
-
-    objects = ParkAreaManager()
-    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)
-
-    def save(self, *args, **kwargs):
-        if not self.slug:
-            self.slug = slugify(self.name)
-        super().save(*args, **kwargs)
-
-    def __str__(self):
-        return self.name
-
-    class Meta:
-        unique_together = ("park", "slug")

backend/apps/parks/models/companies.py

@@ -1,127 +0,0 @@
-from django.contrib.postgres.fields import ArrayField
-from django.db import models
-from django.utils.text import slugify
-from apps.core.models import TrackedModel
-from apps.core.choices.fields import RichChoiceField
-import pghistory
-
-
-@pghistory.track()
-class Company(TrackedModel):
-    # Import managers
-    from ..managers import CompanyManager
-
-    objects = CompanyManager()
-
-    name = models.CharField(max_length=255)
-    slug = models.SlugField(max_length=255, unique=True)
-    roles = ArrayField(
-        RichChoiceField(choice_group="company_roles", domain="parks", max_length=20),
-        default=list,
-        blank=True,
-    )
-    description = models.TextField(blank=True)
-    website = models.URLField(blank=True)
-
-    # Operator-specific fields
-    founded_year = models.PositiveIntegerField(blank=True, null=True)
-    parks_count = models.IntegerField(default=0)
-    rides_count = models.IntegerField(default=0)
-
-    def save(self, *args, **kwargs):
-        if not self.slug:
-            self.slug = slugify(self.name)
-        super().save(*args, **kwargs)
-
-    def __str__(self):
-        return self.name
-
-    class Meta(TrackedModel.Meta):
-        app_label = "parks"
-        ordering = ["name"]
-        verbose_name_plural = "Companies"
-
-
-@pghistory.track()
-class CompanyHeadquarters(models.Model):
-    """
-    Simple address storage for company headquarters without coordinate tracking.
-    Focus on human-readable location information for display purposes.
-    """
-
-    # Relationships
-    company = models.OneToOneField(
-        "Company", on_delete=models.CASCADE, related_name="headquarters"
-    )
-
-    # Address Fields (No coordinates needed)
-    street_address = models.CharField(
-        max_length=255,
-        blank=True,
-        help_text="Mailing address if publicly available",
-    )
-    city = models.CharField(
-        max_length=100, db_index=True, help_text="Headquarters city"
-    )
-    state_province = models.CharField(
-        max_length=100,
-        blank=True,
-        db_index=True,
-        help_text="State/Province/Region",
-    )
-    country = models.CharField(
-        max_length=100,
-        default="USA",
-        db_index=True,
-        help_text="Country where headquarters is located",
-    )
-    postal_code = models.CharField(
-        max_length=20, blank=True, help_text="ZIP or postal code"
-    )
-
-    # Optional mailing address if different or more complete
-    mailing_address = models.TextField(
-        blank=True,
-        help_text="Complete mailing address if different from basic address",
-    )
-
-    # Metadata
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-    @property
-    def formatted_location(self):
-        """Returns a formatted address string for display."""
-        components = []
-        if self.street_address:
-            components.append(self.street_address)
-        if self.city:
-            components.append(self.city)
-        if self.state_province:
-            components.append(self.state_province)
-        if self.postal_code:
-            components.append(self.postal_code)
-        if self.country and self.country != "USA":
-            components.append(self.country)
-        return ", ".join(components) if components else f"{self.city}, {self.country}"
-
-    @property
-    def location_display(self):
-        """Simple city, state/country display for compact views."""
-        parts = [self.city]
-        if self.state_province:
-            parts.append(self.state_province)
-        elif self.country != "USA":
-            parts.append(self.country)
-        return ", ".join(parts) if parts else "Unknown Location"
-
-    def __str__(self):
-        return f"{self.company.name} Headquarters - {self.location_display}"
-
-    class Meta:
-        verbose_name = "Company Headquarters"
-        verbose_name_plural = "Company Headquarters"
-        ordering = ["company__name"]
-        indexes = [
-            models.Index(fields=["city", "country"]),
-        ]

backend/apps/parks/models/location.py

@@ -1,120 +0,0 @@
-from django.contrib.gis.db import models
-from django.contrib.gis.geos import Point
-import pghistory
-
-
-@pghistory.track()
-class ParkLocation(models.Model):
-    """
-    Represents the geographic location and address of a park, with PostGIS support.
-    """
-
-    park = models.OneToOneField(
-        "parks.Park", on_delete=models.CASCADE, related_name="location"
-    )
-
-    # Spatial Data
-    point = models.PointField(
-        srid=4326,
-        null=True,
-        blank=True,
-        help_text="Geographic coordinates (longitude, latitude)",
-    )
-
-    # Address Fields
-    street_address = models.CharField(max_length=255, blank=True)
-    city = models.CharField(max_length=100, db_index=True)
-    state = models.CharField(max_length=100, db_index=True)
-    country = models.CharField(max_length=100, default="USA")
-    continent = models.CharField(
-        max_length=50,
-        blank=True,
-        db_index=True,
-        help_text="Continent where the park is located"
-    )
-    postal_code = models.CharField(max_length=20, blank=True)
-
-    # Road Trip Metadata
-    highway_exit = models.CharField(max_length=100, blank=True)
-    parking_notes = models.TextField(blank=True)
-    best_arrival_time = models.TimeField(null=True, blank=True)
-    seasonal_notes = models.TextField(blank=True)
-
-    # OSM Integration
-    osm_id = models.BigIntegerField(null=True, blank=True)
-    osm_type = models.CharField(
-        max_length=10,
-        blank=True,
-        help_text="Type of OpenStreetMap object (node, way, or relation)",
-    )
-
-    @property
-    def latitude(self):
-        """Return latitude from point field."""
-        if self.point:
-            return self.point.y
-        return None
-
-    @property
-    def longitude(self):
-        """Return longitude from point field."""
-        if self.point:
-            return self.point.x
-        return None
-
-    @property
-    def coordinates(self):
-        """Return (latitude, longitude) tuple."""
-        if self.point:
-            return (self.latitude, self.longitude)
-        return (None, None)
-
-    @property
-    def formatted_address(self):
-        """Return a nicely formatted address string."""
-        address_parts = [
-            self.street_address,
-            self.city,
-            self.state,
-            self.postal_code,
-            self.country,
-        ]
-        return ", ".join(part for part in address_parts if part)
-
-    def set_coordinates(self, latitude, longitude):
-        """
-        Set the location's point from latitude and longitude coordinates.
-        Validates coordinate ranges.
-        """
-        if latitude is None or longitude is None:
-            self.point = None
-            return
-
-        if not -90 <= latitude <= 90:
-            raise ValueError("Latitude must be between -90 and 90.")
-        if not -180 <= longitude <= 180:
-            raise ValueError("Longitude must be between -180 and 180.")
-
-        self.point = Point(longitude, latitude, srid=4326)
-
-    def distance_to(self, other_location):
-        """
-        Calculate the distance to another ParkLocation instance.
-        Returns distance in kilometers.
-        """
-        if not self.point or not other_location.point:
-            return None
-        # Use geodetic distance calculation which returns meters, convert to km
-        distance_m = self.point.distance(other_location.point)
-        return distance_m / 1000.0
-
-    def __str__(self):
-        return f"Location for {self.park.name}"
-
-    class Meta:
-        verbose_name = "Park Location"
-        verbose_name_plural = "Park Locations"
-        ordering = ["park__name"]
-        indexes = [
-            models.Index(fields=["city", "state"]),
-        ]

backend/apps/parks/models/media.py

@@ -1,120 +0,0 @@
-"""
-Park-specific media models for ThrillWiki.
-
-This module contains media models specific to parks domain.
-"""
-
-from typing import Any, List, Optional, cast
-from django.db import models
-from django.conf import settings
-from apps.core.history import TrackedModel
-from apps.core.services.media_service import MediaService
-import pghistory
-
-
-def park_photo_upload_path(instance: models.Model, filename: str) -> str:
-    """Generate upload path for park photos."""
-    photo = cast("ParkPhoto", instance)
-    park = photo.park
-
-    if park is None:
-        raise ValueError("Park cannot be None")
-
-    return MediaService.generate_upload_path(
-        domain="park", identifier=park.slug, filename=filename
-    )
-
-
-@pghistory.track()
-class ParkPhoto(TrackedModel):
-    """Photo model specific to parks."""
-
-    park = models.ForeignKey(
-        "parks.Park", on_delete=models.CASCADE, related_name="photos"
-    )
-
-    image = models.ForeignKey(
-        'django_cloudflareimages_toolkit.CloudflareImage',
-        on_delete=models.CASCADE,
-        help_text="Park photo stored on Cloudflare Images"
-    )
-
-    caption = models.CharField(max_length=255, blank=True)
-    alt_text = models.CharField(max_length=255, blank=True)
-    is_primary = models.BooleanField(default=False)
-    is_approved = models.BooleanField(default=False)
-
-    # Metadata
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-    date_taken = models.DateTimeField(null=True, blank=True)
-
-    # User who uploaded the photo
-    uploaded_by = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        on_delete=models.SET_NULL,
-        null=True,
-        related_name="uploaded_park_photos",
-    )
-
-    class Meta(TrackedModel.Meta):
-        app_label = "parks"
-        ordering = ["-is_primary", "-created_at"]
-        indexes = [
-            models.Index(fields=["park", "is_primary"]),
-            models.Index(fields=["park", "is_approved"]),
-            models.Index(fields=["created_at"]),
-        ]
-        constraints = [
-            # Only one primary photo per park
-            models.UniqueConstraint(
-                fields=["park"],
-                condition=models.Q(is_primary=True),
-                name="unique_primary_park_photo",
-            )
-        ]
-
-    def __str__(self) -> str:
-        return f"Photo of {self.park.name} - {self.caption or 'No caption'}"
-
-    def save(self, *args: Any, **kwargs: Any) -> None:
-        # Extract EXIF date if this is a new photo
-        if not self.pk and not self.date_taken and self.image:
-            self.date_taken = MediaService.extract_exif_date(self.image)
-
-        # Set default caption if not provided
-        if not self.caption and self.uploaded_by:
-            self.caption = MediaService.generate_default_caption(
-                self.uploaded_by.username
-            )
-
-        # If this is marked as primary, unmark other primary photos for this park
-        if self.is_primary:
-            ParkPhoto.objects.filter(
-                park=self.park,
-                is_primary=True,
-            ).exclude(
-                pk=self.pk
-            ).update(is_primary=False)
-
-        super().save(*args, **kwargs)
-
-    @property
-    def file_size(self) -> Optional[int]:
-        """Get file size in bytes."""
-        try:
-            return self.image.size
-        except (ValueError, OSError):
-            return None
-
-    @property
-    def dimensions(self) -> Optional[List[int]]:
-        """Get image dimensions as [width, height]."""
-        try:
-            return [self.image.width, self.image.height]
-        except (ValueError, OSError):
-            return None
-
-    def get_absolute_url(self) -> str:
-        """Get absolute URL for this photo."""
-        return f"/parks/{self.park.slug}/photos/{self.pk}/"

backend/apps/parks/models/parks.py

@@ -1,362 +0,0 @@
-from django.db import models
-from django.urls import reverse
-from django.utils.text import slugify
-from django.core.exceptions import ValidationError
-from config.django import base as settings
-from typing import Optional, Any, TYPE_CHECKING, List
-import pghistory
-from apps.core.history import TrackedModel
-from apps.core.choices import RichChoiceField
-
-
-if TYPE_CHECKING:
-    from apps.rides.models import Ride
-    from . import ParkArea
-
-
-@pghistory.track()
-class Park(TrackedModel):
-    # Import managers
-    from ..managers import ParkManager
-
-    objects = ParkManager()
-    id: int  # Type hint for Django's automatic id field
-
-    name = models.CharField(max_length=255)
-    slug = models.SlugField(max_length=255, unique=True)
-    description = models.TextField(blank=True)
-    status = RichChoiceField(
-        choice_group="statuses",
-        domain="parks",
-        max_length=20,
-        default="OPERATING",
-    )
-
-    park_type = RichChoiceField(
-        choice_group="types",
-        domain="parks",
-        max_length=30,
-        default="THEME_PARK",
-        db_index=True,
-        help_text="Type/category of the park"
-    )
-
-    # Location relationship - reverse relation from ParkLocation
-    # location will be available via the 'location' related_name on
-    # ParkLocation
-
-    # 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)
-
-    # Image settings - references to existing photos
-    banner_image = models.ForeignKey(
-        "ParkPhoto",
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        related_name="parks_using_as_banner",
-        help_text="Photo to use as banner image for this park",
-    )
-    card_image = models.ForeignKey(
-        "ParkPhoto",
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        related_name="parks_using_as_card",
-        help_text="Photo to use as card image for this park",
-    )
-
-    # Relationships
-    operator = models.ForeignKey(
-        "Company",
-        on_delete=models.PROTECT,
-        related_name="operated_parks",
-        help_text="Company that operates this park",
-        limit_choices_to={"roles__contains": ["OPERATOR"]},
-    )
-    property_owner = models.ForeignKey(
-        "Company",
-        on_delete=models.PROTECT,
-        related_name="owned_parks",
-        null=True,
-        blank=True,
-        help_text="Company that owns the property (if different from operator)",
-        limit_choices_to={"roles__contains": ["PROPERTY_OWNER"]},
-    )
-    areas: models.Manager["ParkArea"]  # Type hint for reverse relation
-    # Type hint for reverse relation from rides app
-    rides: models.Manager["Ride"]
-
-    # Metadata
-    created_at = models.DateTimeField(auto_now_add=True, null=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-    # Frontend URL
-    url = models.URLField(blank=True, help_text="Frontend URL for this park")
-
-    # Computed fields for hybrid filtering
-    opening_year = models.IntegerField(
-        null=True, 
-        blank=True, 
-        db_index=True,
-        help_text="Year the park opened (computed from opening_date)"
-    )
-    search_text = models.TextField(
-        blank=True, 
-        db_index=True,
-        help_text="Searchable text combining name, description, location, and operator"
-    )
-    
-    # Timezone for park operations
-    timezone = models.CharField(
-        max_length=50,
-        help_text="Timezone identifier for park operations (e.g., 'America/New_York')"
-    )
-
-    class Meta:
-        ordering = ["name"]
-        constraints = [
-            # Business rule: Closing date must be after opening date
-            models.CheckConstraint(
-                name="park_closing_after_opening",
-                check=models.Q(closing_date__isnull=True)
-                | models.Q(opening_date__isnull=True)
-                | models.Q(closing_date__gte=models.F("opening_date")),
-                violation_error_message="Closing date must be after opening date",
-            ),
-            # Business rule: Size must be positive
-            models.CheckConstraint(
-                name="park_size_positive",
-                check=models.Q(size_acres__isnull=True) | models.Q(size_acres__gt=0),
-                violation_error_message="Park size must be positive",
-            ),
-            # Business rule: Rating must be between 1 and 10
-            models.CheckConstraint(
-                name="park_rating_range",
-                check=models.Q(average_rating__isnull=True)
-                | (models.Q(average_rating__gte=1) & models.Q(average_rating__lte=10)),
-                violation_error_message="Average rating must be between 1 and 10",
-            ),
-            # Business rule: Counts must be non-negative
-            models.CheckConstraint(
-                name="park_ride_count_non_negative",
-                check=models.Q(ride_count__isnull=True) | models.Q(ride_count__gte=0),
-                violation_error_message="Ride count must be non-negative",
-            ),
-            models.CheckConstraint(
-                name="park_coaster_count_non_negative",
-                check=models.Q(coaster_count__isnull=True)
-                | models.Q(coaster_count__gte=0),
-                violation_error_message="Coaster count must be non-negative",
-            ),
-            # Business rule: Coaster count cannot exceed ride count
-            models.CheckConstraint(
-                name="park_coaster_count_lte_ride_count",
-                check=models.Q(coaster_count__isnull=True)
-                | models.Q(ride_count__isnull=True)
-                | models.Q(coaster_count__lte=models.F("ride_count")),
-                violation_error_message="Coaster count cannot exceed total ride count",
-            ),
-        ]
-
-    def __str__(self) -> str:
-        return self.name
-
-    def save(self, *args: Any, **kwargs: Any) -> None:
-        from django.contrib.contenttypes.models import ContentType
-        from apps.core.history 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)
-
-        # Generate frontend URL
-        frontend_domain = getattr(settings, "FRONTEND_DOMAIN", "https://thrillwiki.com")
-        self.url = f"{frontend_domain}/parks/{self.slug}/"
-
-        # Populate computed fields for hybrid filtering
-        self._populate_computed_fields()
-
-        # 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 _populate_computed_fields(self) -> None:
-        """Populate computed fields for hybrid filtering"""
-        # Populate opening_year from opening_date
-        if self.opening_date:
-            self.opening_year = self.opening_date.year
-        else:
-            self.opening_year = None
-        
-        # Populate search_text for client-side filtering
-        search_parts = [self.name]
-        
-        if self.description:
-            search_parts.append(self.description)
-        
-        # Add location information if available
-        try:
-            if hasattr(self, 'location') and self.location:
-                if self.location.city:
-                    search_parts.append(self.location.city)
-                if self.location.state:
-                    search_parts.append(self.location.state)
-                if self.location.country:
-                    search_parts.append(self.location.country)
-        except Exception:
-            # Handle case where location relationship doesn't exist yet
-            pass
-        
-        # Add operator information
-        if self.operator:
-            search_parts.append(self.operator.name)
-        
-        # Add property owner information if different
-        if self.property_owner and self.property_owner != self.operator:
-            search_parts.append(self.property_owner.name)
-        
-        # Combine all parts into searchable text
-        self.search_text = ' '.join(filter(None, search_parts)).lower()
-
-    def clean(self):
-        super().clean()
-        if self.operator and "OPERATOR" not in self.operator.roles:
-            raise ValidationError({"operator": "Company must have the OPERATOR role."})
-        if self.property_owner and "PROPERTY_OWNER" not in self.property_owner.roles:
-            raise ValidationError(
-                {"property_owner": "Company must have the PROPERTY_OWNER role."}
-            )
-
-    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",
-        }
-        if self.status in status_colors:
-            return status_colors[self.status]
-        else:
-            raise ValueError(f"Unknown park status: {self.status}")
-
-    @property
-    def formatted_location(self) -> str:
-        """Get formatted address from ParkLocation if it exists"""
-        if hasattr(self, "location") and self.location:
-            return self.location.formatted_address
-        return ""
-
-    @property
-    def coordinates(self) -> Optional[List[float]]:
-        """Returns coordinates as a list [latitude, longitude]"""
-        if hasattr(self, "location") and self.location:
-            coords = self.location.coordinates
-            if coords and isinstance(coords, (tuple, list)):
-                return list(coords)
-        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 apps.core.history 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("Park not found for historical slug record")
-            else:
-                print("No historical slug record found")
-
-            # Try pghistory events
-            print("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("Park not found for pghistory event")
-            else:
-                print("No pghistory event found")
-
-            raise cls.DoesNotExist("No park found with this slug")

backend/apps/parks/models/reviews.py

@@ -1,76 +0,0 @@
-from django.db import models
-from django.db.models import functions
-from django.core.validators import MinValueValidator, MaxValueValidator
-from apps.core.history import TrackedModel
-import pghistory
-
-
-@pghistory.track()
-class ParkReview(TrackedModel):
-    # Import managers
-    from ..managers import ParkReviewManager
-
-    objects = ParkReviewManager()
-    """
-    A review of a park.
-    """
-    park = models.ForeignKey(
-        "parks.Park", on_delete=models.CASCADE, related_name="reviews"
-    )
-    user = models.ForeignKey(
-        "accounts.User", on_delete=models.CASCADE, related_name="park_reviews"
-    )
-    rating = models.PositiveSmallIntegerField(
-        validators=[MinValueValidator(1), MaxValueValidator(10)]
-    )
-    title = models.CharField(max_length=200)
-    content = models.TextField()
-    visit_date = models.DateField()
-
-    # Metadata
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-    # Moderation
-    is_published = models.BooleanField(default=True)
-    moderation_notes = models.TextField(blank=True)
-    moderated_by = models.ForeignKey(
-        "accounts.User",
-        on_delete=models.SET_NULL,
-        null=True,
-        blank=True,
-        related_name="moderated_park_reviews",
-    )
-    moderated_at = models.DateTimeField(null=True, blank=True)
-
-    class Meta:
-        ordering = ["-created_at"]
-        unique_together = ["park", "user"]
-        constraints = [
-            # Business rule: Rating must be between 1 and 10 (database level
-            # enforcement)
-            models.CheckConstraint(
-                name="park_review_rating_range",
-                check=models.Q(rating__gte=1) & models.Q(rating__lte=10),
-                violation_error_message="Rating must be between 1 and 10",
-            ),
-            # Business rule: Visit date cannot be in the future
-            models.CheckConstraint(
-                name="park_review_visit_date_not_future",
-                check=models.Q(visit_date__lte=functions.Now()),
-                violation_error_message="Visit date cannot be in the future",
-            ),
-            # Business rule: If moderated, must have moderator and timestamp
-            models.CheckConstraint(
-                name="park_review_moderation_consistency",
-                check=models.Q(moderated_by__isnull=True, moderated_at__isnull=True)
-                | models.Q(moderated_by__isnull=False, moderated_at__isnull=False),
-                violation_error_message=(
-                    "Moderated reviews must have both moderator and moderation "
-                    "timestamp"
-                ),
-            ),
-        ]
-
-    def __str__(self):
-        return f"Review of {self.park.name} by {self.user.username}"