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.validators import MinValueValidator, MaxValueValidator
from django.core.exceptions import ValidationError
from decimal import Decimal, ROUND_DOWN, InvalidOperation
from simple_history.models import HistoricalRecords

from companies.models import Company
from media.models import Photo


def normalize_coordinate(value, max_digits, decimal_places):
    """Normalize coordinate to have at most max_digits total digits and decimal_places decimal places"""
    try:
        if value is None:
            return None
            
        # Convert to Decimal for precise handling
        value = Decimal(str(value))
        # Round to specified decimal places
        value = Decimal(value.quantize(Decimal('0.' + '0' * decimal_places), rounding=ROUND_DOWN))
        
        return value
    except (TypeError, ValueError, InvalidOperation):
        return None


def validate_coordinate_digits(value, max_digits, decimal_places):
    """Validate total number of digits in a coordinate value"""
    if value is not None:
        try:
            # Convert to Decimal for precise handling
            value = Decimal(str(value))
            # Round to exactly 6 decimal places
            value = value.quantize(Decimal('0.000001'), rounding=ROUND_DOWN)
            return value
        except (InvalidOperation, TypeError):
            raise ValidationError('Invalid coordinate value.')
    return value


def validate_latitude_digits(value):
    """Validate total number of digits in latitude"""
    return validate_coordinate_digits(value, 9, 6)


def validate_longitude_digits(value):
    """Validate total number of digits in longitude"""
    return validate_coordinate_digits(value, 10, 6)


class Park(models.Model):
    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
    latitude = models.DecimalField(
        max_digits=9,
        decimal_places=6,
        null=True,
        blank=True,
        help_text='Latitude coordinate (-90 to 90)',
        validators=[
            MinValueValidator(Decimal('-90')),
            MaxValueValidator(Decimal('90')),
            validate_latitude_digits,
        ]
    )
    longitude = models.DecimalField(
        max_digits=10,
        decimal_places=6,
        null=True,
        blank=True,
        help_text='Longitude coordinate (-180 to 180)',
        validators=[
            MinValueValidator(Decimal('-180')),
            MaxValueValidator(Decimal('180')),
            validate_longitude_digits,
        ]
    )
    street_address = models.CharField(max_length=255, blank=True)
    city = models.CharField(max_length=255, blank=True)
    state = models.CharField(max_length=255, blank=True)
    country = models.CharField(max_length=255, blank=True)
    postal_code = models.CharField(max_length=20, blank=True)

    # 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
    )
    total_rides = models.IntegerField(null=True, blank=True)
    total_roller_coasters = 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')

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

    class Meta:
        ordering = ['name']

    def __str__(self):
        return self.name

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        
        # Normalize coordinates before saving
        if self.latitude is not None:
            self.latitude = normalize_coordinate(self.latitude, 9, 6)
        if self.longitude is not None:
            self.longitude = normalize_coordinate(self.longitude, 10, 6)
        
        super().save(*args, **kwargs)

    def get_absolute_url(self):
        return reverse('parks:park_detail', kwargs={'slug': self.slug})

    @classmethod
    def get_by_slug(cls, slug):
        """Get park by current or historical slug"""
        try:
            return cls.objects.get(slug=slug), False
        except cls.DoesNotExist:
            # Check historical slugs
            history = cls.history.filter(slug=slug).order_by('-history_date').first()
            if history:
                try:
                    return cls.objects.get(id=history.id), True
                except cls.DoesNotExist:
                    pass
            raise cls.DoesNotExist()


class ParkArea(models.Model):
    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)
    history = HistoricalRecords()

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

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

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

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

    @classmethod
    def get_by_slug(cls, slug):
        """Get area by current or historical slug"""
        try:
            return cls.objects.get(slug=slug), False
        except cls.DoesNotExist:
            # Check historical slugs
            history = cls.history.filter(slug=slug).order_by('-history_date').first()
            if history:
                try:
                    return cls.objects.get(id=history.id), True
                except cls.DoesNotExist:
                    pass
            raise cls.DoesNotExist()