mirror of
https://github.com/pacnpal/thrillwiki_django_no_react.git
synced 2025-12-20 13:31:08 -05:00
c26414ff74
- Implemented extensive test cases for the Parks API, covering endpoints for listing, retrieving, creating, updating, and deleting parks. - Added tests for filtering, searching, and ordering parks in the API. - Created tests for error handling in the API, including malformed JSON and unsupported methods. - Developed model tests for Park, ParkArea, Company, and ParkReview models, ensuring validation and constraints are enforced. - Introduced utility mixins for API and model testing to streamline assertions and enhance test readability. - Included integration tests to validate complete workflows involving park creation, retrieval, updating, and deletion.
257 lines
10 KiB
Python
257 lines
10 KiB
Python
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 import Company
|
|
from media.models import Photo
|
|
from core.history import TrackedModel
|
|
|
|
if TYPE_CHECKING:
|
|
from 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
|
|
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 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)
|
|
|
|
# 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']},
|
|
)
|
|
photos = GenericRelation(Photo, related_query_name="park")
|
|
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)
|
|
|
|
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 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)
|
|
|
|
# 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 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',
|
|
}
|
|
return status_colors.get(self.status, 'bg-gray-100 text-gray-500')
|
|
|
|
@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[Tuple[float, float]]:
|
|
"""Returns coordinates as a tuple (latitude, longitude)"""
|
|
if hasattr(self, 'location') and self.location:
|
|
return self.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 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")
|