pacnpal/thrillwiki_django_no_react
1
1
Fork 0
mirror of https://github.com/pacnpal/thrillwiki_django_no_react.git synced 2025-12-20 05:31:09 -05:00
Code Issues Packages Projects Releases Wiki Activity
Files
0fd6dc2560b8099c6960c05b439ba3b07ca424c0
thrillwiki_django_no_react/backend/apps/api/v1/rides/views.py
pacnpal 0fd6dc2560 feat: Enhance Park Detail Endpoint with Media URL Service Integration 
- Updated ParkDetailOutputSerializer to utilize MediaURLService for generating Cloudflare URLs and friendly URLs for park photos.
- Added support for multiple lookup methods (ID and slug) in the park detail endpoint.
- Improved documentation for the park detail endpoint, including request properties and response structure.
- Created MediaURLService for generating SEO-friendly URLs and handling Cloudflare image URLs.
- Comprehensive updates to frontend documentation to reflect new endpoint capabilities and usage examples.
- Added detailed park detail endpoint documentation, including request and response structures, field descriptions, and usage examples.
2025-08-31 16:45:47 -04:00

1336 lines
57 KiB
Python
Raw Blame History

"""
Full-featured Rides API views for ThrillWiki API v1.
This module implements a "full fat" set of endpoints:
- List / Create: GET /rides/ POST /rides/
- Retrieve / Update / Delete: GET /rides/{pk}/ PATCH/PUT/DELETE
- Filter options: GET /rides/filter-options/
- Company search: GET /rides/search/companies/?q=...
- Ride model search: GET /rides/search-ride-models/?q=...
- Search suggestions: GET /rides/search-suggestions/?q=...
Notes:
- These views try to use real Django models if available. If the domain models/services
are not present, they return a clear 501 response explaining what to wire up.
"""
from typing import Any
from django.db import models
from rest_framework import status, permissions
from rest_framework.views import APIView
from rest_framework.request import Request
from rest_framework.response import Response
from rest_framework.pagination import PageNumberPagination
from rest_framework.exceptions import NotFound
from drf_spectacular.utils import extend_schema, OpenApiParameter
from drf_spectacular.types import OpenApiTypes
# Reuse existing serializers where possible
from apps.api.v1.serializers.rides import (
RideListOutputSerializer,
RideDetailOutputSerializer,
RideCreateInputSerializer,
RideUpdateInputSerializer,
RideImageSettingsInputSerializer,
)
# Attempt to import model-level helpers; fall back gracefully if not present.
try:
from apps.rides.models import Ride, RideModel
from apps.parks.models import Park, Company
MODELS_AVAILABLE = True
except Exception:
Ride = None # type: ignore
RideModel = None # type: ignore
Company = None # type: ignore
Park = None # type: ignore
MODELS_AVAILABLE = False
# Attempt to import ModelChoices to return filter options
try:
from apps.api.v1.serializers.shared import ModelChoices # type: ignore
HAVE_MODELCHOICES = True
except Exception:
ModelChoices = None # type: ignore
HAVE_MODELCHOICES = False
class StandardResultsSetPagination(PageNumberPagination):
page_size = 20
page_size_query_param = "page_size"
max_page_size = 1000
# --- Ride list & create -----------------------------------------------------
class RideListCreateAPIView(APIView):
permission_classes = [permissions.AllowAny]
@extend_schema(
summary="List rides with comprehensive filtering and pagination",
description="List rides with comprehensive filtering options including category, status, manufacturer, designer, ride model, and more.",
parameters=[
OpenApiParameter(
name="page",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Page number for pagination",
),
OpenApiParameter(
name="page_size",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Number of results per page (max 1000)",
),
OpenApiParameter(
name="search",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.STR,
description="Search in ride names and descriptions",
),
OpenApiParameter(
name="park_slug",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.STR,
description="Filter by park slug",
),
OpenApiParameter(
name="park_id",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter by park ID",
),
OpenApiParameter(
name="category",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.STR,
description="Filter by ride category (RC, DR, FR, WR, TR, OT). Multiple values supported: ?category=RC&category=DR",
),
OpenApiParameter(
name="status",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.STR,
description="Filter by ride status. Multiple values supported: ?status=OPERATING&status=CLOSED_TEMP",
),
OpenApiParameter(
name="manufacturer_id",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter by manufacturer company ID",
),
OpenApiParameter(
name="manufacturer_slug",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.STR,
description="Filter by manufacturer company slug",
),
OpenApiParameter(
name="designer_id",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter by designer company ID",
),
OpenApiParameter(
name="designer_slug",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.STR,
description="Filter by designer company slug",
),
OpenApiParameter(
name="ride_model_id",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter by specific ride model ID",
),
OpenApiParameter(
name="ride_model_slug",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.STR,
description="Filter by ride model slug (requires manufacturer_slug)",
),
OpenApiParameter(
name="roller_coaster_type",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.STR,
description="Filter roller coasters by type (SITDOWN, INVERTED, FLYING, etc.)",
),
OpenApiParameter(
name="track_material",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.STR,
description="Filter roller coasters by track material (STEEL, WOOD, HYBRID)",
),
OpenApiParameter(
name="launch_type",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.STR,
description="Filter roller coasters by launch type (CHAIN, LSM, HYDRAULIC, etc.)",
),
OpenApiParameter(
name="min_rating",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.NUMBER,
description="Filter by minimum average rating (1-10)",
),
OpenApiParameter(
name="max_rating",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.NUMBER,
description="Filter by maximum average rating (1-10)",
),
OpenApiParameter(
name="min_height_requirement",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter by minimum height requirement in inches",
),
OpenApiParameter(
name="max_height_requirement",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter by maximum height requirement in inches",
),
OpenApiParameter(
name="min_capacity",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter by minimum hourly capacity",
),
OpenApiParameter(
name="max_capacity",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter by maximum hourly capacity",
),
OpenApiParameter(
name="min_height_ft",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.NUMBER,
description="Filter roller coasters by minimum height in feet",
),
OpenApiParameter(
name="max_height_ft",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.NUMBER,
description="Filter roller coasters by maximum height in feet",
),
OpenApiParameter(
name="min_speed_mph",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.NUMBER,
description="Filter roller coasters by minimum speed in mph",
),
OpenApiParameter(
name="max_speed_mph",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.NUMBER,
description="Filter roller coasters by maximum speed in mph",
),
OpenApiParameter(
name="min_inversions",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter roller coasters by minimum number of inversions",
),
OpenApiParameter(
name="max_inversions",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter roller coasters by maximum number of inversions",
),
OpenApiParameter(
name="has_inversions",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.BOOL,
description="Filter roller coasters that have inversions (true) or don't have inversions (false)",
),
OpenApiParameter(
name="opening_year",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter by opening year",
),
OpenApiParameter(
name="min_opening_year",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter by minimum opening year",
),
OpenApiParameter(
name="max_opening_year",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.INT,
description="Filter by maximum opening year",
),
OpenApiParameter(
name="ordering",
location=OpenApiParameter.QUERY,
type=OpenApiTypes.STR,
description="Order results by field. Options: name, -name, opening_date, -opening_date, average_rating, -average_rating, capacity_per_hour, -capacity_per_hour, created_at, -created_at, height_ft, -height_ft, speed_mph, -speed_mph",
),
],
responses={200: RideListOutputSerializer(many=True)},
tags=["Rides"],
)
def get(self, request: Request) -> Response:
"""List rides with comprehensive filtering and pagination."""
if not MODELS_AVAILABLE:
return Response(
{
"detail": "Ride listing is not available because domain models are not imported. "
"Implement apps.rides.models.Ride (and related managers) to enable listing."
},
status=status.HTTP_501_NOT_IMPLEMENTED,
)
# Start with base queryset with optimized joins
qs = (
Ride.objects.all()
.select_related(
"park",
"manufacturer",
"designer",
"ride_model",
"ride_model__manufacturer",
)
.prefetch_related("coaster_stats")
) # type: ignore
# Text search
search = request.query_params.get("search")
if search:
qs = qs.filter(
models.Q(name__icontains=search)
| models.Q(description__icontains=search)
| models.Q(park__name__icontains=search)
)
# Park filters
park_slug = request.query_params.get("park_slug")
if park_slug:
qs = qs.filter(park__slug=park_slug)
park_id = request.query_params.get("park_id")
if park_id:
try:
qs = qs.filter(park_id=int(park_id))
except (ValueError, TypeError):
pass
# Category filters (multiple values supported)
categories = request.query_params.getlist("category")
if categories:
qs = qs.filter(category__in=categories)
# Status filters (multiple values supported)
statuses = request.query_params.getlist("status")
if statuses:
qs = qs.filter(status__in=statuses)
# Manufacturer filters
manufacturer_id = request.query_params.get("manufacturer_id")
if manufacturer_id:
try:
qs = qs.filter(manufacturer_id=int(manufacturer_id))
except (ValueError, TypeError):
pass
manufacturer_slug = request.query_params.get("manufacturer_slug")
if manufacturer_slug:
qs = qs.filter(manufacturer__slug=manufacturer_slug)
# Designer filters
designer_id = request.query_params.get("designer_id")
if designer_id:
try:
qs = qs.filter(designer_id=int(designer_id))
except (ValueError, TypeError):
pass
designer_slug = request.query_params.get("designer_slug")
if designer_slug:
qs = qs.filter(designer__slug=designer_slug)
# Ride model filters
ride_model_id = request.query_params.get("ride_model_id")
if ride_model_id:
try:
qs = qs.filter(ride_model_id=int(ride_model_id))
except (ValueError, TypeError):
pass
ride_model_slug = request.query_params.get("ride_model_slug")
manufacturer_slug_for_model = request.query_params.get("manufacturer_slug")
if ride_model_slug and manufacturer_slug_for_model:
qs = qs.filter(
ride_model__slug=ride_model_slug,
ride_model__manufacturer__slug=manufacturer_slug_for_model,
)
# Rating filters
min_rating = request.query_params.get("min_rating")
if min_rating:
try:
qs = qs.filter(average_rating__gte=float(min_rating))
except (ValueError, TypeError):
pass
max_rating = request.query_params.get("max_rating")
if max_rating:
try:
qs = qs.filter(average_rating__lte=float(max_rating))
except (ValueError, TypeError):
pass
# Height requirement filters
min_height_req = request.query_params.get("min_height_requirement")
if min_height_req:
try:
qs = qs.filter(min_height_in__gte=int(min_height_req))
except (ValueError, TypeError):
pass
max_height_req = request.query_params.get("max_height_requirement")
if max_height_req:
try:
qs = qs.filter(max_height_in__lte=int(max_height_req))
except (ValueError, TypeError):
pass
# Capacity filters
min_capacity = request.query_params.get("min_capacity")
if min_capacity:
try:
qs = qs.filter(capacity_per_hour__gte=int(min_capacity))
except (ValueError, TypeError):
pass
max_capacity = request.query_params.get("max_capacity")
if max_capacity:
try:
qs = qs.filter(capacity_per_hour__lte=int(max_capacity))
except (ValueError, TypeError):
pass
# Opening year filters
opening_year = request.query_params.get("opening_year")
if opening_year:
try:
qs = qs.filter(opening_date__year=int(opening_year))
except (ValueError, TypeError):
pass
min_opening_year = request.query_params.get("min_opening_year")
if min_opening_year:
try:
qs = qs.filter(opening_date__year__gte=int(min_opening_year))
except (ValueError, TypeError):
pass
max_opening_year = request.query_params.get("max_opening_year")
if max_opening_year:
try:
qs = qs.filter(opening_date__year__lte=int(max_opening_year))
except (ValueError, TypeError):
pass
# Roller coaster specific filters
roller_coaster_type = request.query_params.get("roller_coaster_type")
if roller_coaster_type:
qs = qs.filter(coaster_stats__roller_coaster_type=roller_coaster_type)
track_material = request.query_params.get("track_material")
if track_material:
qs = qs.filter(coaster_stats__track_material=track_material)
launch_type = request.query_params.get("launch_type")
if launch_type:
qs = qs.filter(coaster_stats__launch_type=launch_type)
# Roller coaster height filters
min_height_ft = request.query_params.get("min_height_ft")
if min_height_ft:
try:
qs = qs.filter(coaster_stats__height_ft__gte=float(min_height_ft))
except (ValueError, TypeError):
pass
max_height_ft = request.query_params.get("max_height_ft")
if max_height_ft:
try:
qs = qs.filter(coaster_stats__height_ft__lte=float(max_height_ft))
except (ValueError, TypeError):
pass
# Roller coaster speed filters
min_speed_mph = request.query_params.get("min_speed_mph")
if min_speed_mph:
try:
qs = qs.filter(coaster_stats__speed_mph__gte=float(min_speed_mph))
except (ValueError, TypeError):
pass
max_speed_mph = request.query_params.get("max_speed_mph")
if max_speed_mph:
try:
qs = qs.filter(coaster_stats__speed_mph__lte=float(max_speed_mph))
except (ValueError, TypeError):
pass
# Inversion filters
min_inversions = request.query_params.get("min_inversions")
if min_inversions:
try:
qs = qs.filter(coaster_stats__inversions__gte=int(min_inversions))
except (ValueError, TypeError):
pass
max_inversions = request.query_params.get("max_inversions")
if max_inversions:
try:
qs = qs.filter(coaster_stats__inversions__lte=int(max_inversions))
except (ValueError, TypeError):
pass
has_inversions = request.query_params.get("has_inversions")
if has_inversions is not None:
if has_inversions.lower() in ["true", "1", "yes"]:
qs = qs.filter(coaster_stats__inversions__gt=0)
elif has_inversions.lower() in ["false", "0", "no"]:
qs = qs.filter(coaster_stats__inversions=0)
# Ordering
ordering = request.query_params.get("ordering", "name")
valid_orderings = [
"name",
"-name",
"opening_date",
"-opening_date",
"average_rating",
"-average_rating",
"capacity_per_hour",
"-capacity_per_hour",
"created_at",
"-created_at",
"height_ft",
"-height_ft",
"speed_mph",
"-speed_mph",
]
if ordering in valid_orderings:
if ordering in ["height_ft", "-height_ft", "speed_mph", "-speed_mph"]:
# For coaster stats ordering, we need to join and order by the stats
ordering_field = ordering.replace(
"height_ft", "coaster_stats__height_ft"
).replace("speed_mph", "coaster_stats__speed_mph")
qs = qs.order_by(ordering_field)
else:
qs = qs.order_by(ordering)
paginator = StandardResultsSetPagination()
page = paginator.paginate_queryset(qs, request)
serializer = RideListOutputSerializer(
page, many=True, context={"request": request}
)
return paginator.get_paginated_response(serializer.data)
@extend_schema(
summary="Create a new ride",
description="Create a new ride.",
responses={201: RideDetailOutputSerializer()},
tags=["Rides"],
)
def post(self, request: Request) -> Response:
"""Create a new ride."""
serializer_in = RideCreateInputSerializer(data=request.data)
serializer_in.is_valid(raise_exception=True)
if not MODELS_AVAILABLE:
return Response(
{
"detail": "Ride creation is not available because domain models are not imported. "
"Implement apps.rides.models.Ride and necessary create logic."
},
status=status.HTTP_501_NOT_IMPLEMENTED,
)
validated = serializer_in.validated_data
# Minimal create logic using model fields if available.
try:
park = Park.objects.get(id=validated["park_id"]) # type: ignore
except Park.DoesNotExist: # type: ignore
raise NotFound("Park not found")
ride = Ride.objects.create( # type: ignore
name=validated["name"],
description=validated.get("description", ""),
category=validated.get("category"),
status=validated.get("status"),
park=park,
park_area_id=validated.get("park_area_id"),
opening_date=validated.get("opening_date"),
closing_date=validated.get("closing_date"),
status_since=validated.get("status_since"),
min_height_in=validated.get("min_height_in"),
max_height_in=validated.get("max_height_in"),
capacity_per_hour=validated.get("capacity_per_hour"),
ride_duration_seconds=validated.get("ride_duration_seconds"),
)
# Optional foreign keys
if validated.get("manufacturer_id"):
try:
ride.manufacturer_id = validated["manufacturer_id"]
ride.save()
except Exception:
# ignore if foreign key constraints or models not present
pass
out_serializer = RideDetailOutputSerializer(ride, context={"request": request})
return Response(out_serializer.data, status=status.HTTP_201_CREATED)
# --- Ride retrieve / update / delete ---------------------------------------
@extend_schema(
summary="Retrieve, update or delete a ride",
responses={200: RideDetailOutputSerializer()},
tags=["Rides"],
)
class RideDetailAPIView(APIView):
permission_classes = [permissions.AllowAny]
def _get_ride_or_404(self, pk: int) -> Any:
if not MODELS_AVAILABLE:
raise NotFound(
"Ride detail is not available because domain models are not imported. "
"Implement apps.rides.models.Ride to enable detail endpoints."
)
try:
return Ride.objects.select_related("park").get(pk=pk) # type: ignore
except Ride.DoesNotExist: # type: ignore
raise NotFound("Ride not found")
def get(self, request: Request, pk: int) -> Response:
ride = self._get_ride_or_404(pk)
serializer = RideDetailOutputSerializer(ride, context={"request": request})
return Response(serializer.data)
def patch(self, request: Request, pk: int) -> Response:
ride = self._get_ride_or_404(pk)
serializer_in = RideUpdateInputSerializer(data=request.data, partial=True)
serializer_in.is_valid(raise_exception=True)
if not MODELS_AVAILABLE:
return Response(
{
"detail": "Ride update is not available because domain models are not imported."
},
status=status.HTTP_501_NOT_IMPLEMENTED,
)
validated_data = serializer_in.validated_data
park_change_info = None
# Handle park change specially if park_id is being updated
if 'park_id' in validated_data:
new_park_id = validated_data.pop('park_id')
try:
new_park = Park.objects.get(id=new_park_id) # type: ignore
if new_park.id != ride.park_id:
# Use the move_to_park method for proper handling
park_change_info = ride.move_to_park(new_park)
except Park.DoesNotExist: # type: ignore
raise NotFound("Target park not found")
# Apply other field updates
for key, value in validated_data.items():
setattr(ride, key, value)
ride.save()
# Prepare response data
serializer = RideDetailOutputSerializer(ride, context={"request": request})
response_data = serializer.data
# Add park change information to response if applicable
if park_change_info:
response_data['park_change_info'] = park_change_info
return Response(response_data)
def put(self, request: Request, pk: int) -> Response:
# Full replace - reuse patch behavior for simplicity
return self.patch(request, pk)
def delete(self, request: Request, pk: int) -> Response:
if not MODELS_AVAILABLE:
return Response(
{
"detail": "Ride delete is not available because domain models are not imported."
},
status=status.HTTP_501_NOT_IMPLEMENTED,
)
ride = self._get_ride_or_404(pk)
ride.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
# --- Filter options ---------------------------------------------------------
@extend_schema(
summary="Get comprehensive filter options for rides",
description="Returns all available filter options for rides with complete read-only access to all possible ride model fields and attributes, including dynamic data from database.",
responses={200: OpenApiTypes.OBJECT},
tags=["Rides"],
)
class FilterOptionsAPIView(APIView):
permission_classes = [permissions.AllowAny]
def get(self, request: Request) -> Response:
"""Return comprehensive filter options with all possible ride model fields and attributes."""
if not MODELS_AVAILABLE:
# Comprehensive fallback options with all possible fields
return Response({
"categories": [
{"value": "RC", "label": "Roller Coaster"},
{"value": "DR", "label": "Dark Ride"},
{"value": "FR", "label": "Flat Ride"},
{"value": "WR", "label": "Water Ride"},
{"value": "TR", "label": "Transport"},
{"value": "OT", "label": "Other"},
],
"statuses": [
{"value": "OPERATING", "label": "Operating"},
{"value": "CLOSED_TEMP", "label": "Temporarily Closed"},
{"value": "SBNO", "label": "Standing But Not Operating"},
{"value": "CLOSING", "label": "Closing"},
{"value": "CLOSED_PERM", "label": "Permanently Closed"},
{"value": "UNDER_CONSTRUCTION", "label": "Under Construction"},
{"value": "DEMOLISHED", "label": "Demolished"},
{"value": "RELOCATED", "label": "Relocated"},
],
"post_closing_statuses": [
{"value": "SBNO", "label": "Standing But Not Operating"},
{"value": "CLOSED_PERM", "label": "Permanently Closed"},
],
"roller_coaster_types": [
{"value": "SITDOWN", "label": "Sit Down"},
{"value": "INVERTED", "label": "Inverted"},
{"value": "FLYING", "label": "Flying"},
{"value": "STANDUP", "label": "Stand Up"},
{"value": "WING", "label": "Wing"},
{"value": "DIVE", "label": "Dive"},
{"value": "FAMILY", "label": "Family"},
{"value": "WILD_MOUSE", "label": "Wild Mouse"},
{"value": "SPINNING", "label": "Spinning"},
{"value": "FOURTH_DIMENSION", "label": "4th Dimension"},
{"value": "OTHER", "label": "Other"},
],
"track_materials": [
{"value": "STEEL", "label": "Steel"},
{"value": "WOOD", "label": "Wood"},
{"value": "HYBRID", "label": "Hybrid"},
],
"launch_types": [
{"value": "CHAIN", "label": "Chain Lift"},
{"value": "LSM", "label": "LSM Launch"},
{"value": "HYDRAULIC", "label": "Hydraulic Launch"},
{"value": "GRAVITY", "label": "Gravity"},
{"value": "OTHER", "label": "Other"},
],
"ride_model_target_markets": [
{"value": "FAMILY", "label": "Family"},
{"value": "THRILL", "label": "Thrill"},
{"value": "EXTREME", "label": "Extreme"},
{"value": "KIDDIE", "label": "Kiddie"},
{"value": "ALL_AGES", "label": "All Ages"},
],
"parks": [],
"park_areas": [],
"manufacturers": [],
"designers": [],
"ride_models": [],
"ranges": {
"rating": {"min": 1, "max": 10, "step": 0.1, "unit": "stars"},
"height_requirement": {"min": 30, "max": 90, "step": 1, "unit": "inches"},
"capacity": {"min": 0, "max": 5000, "step": 50, "unit": "riders/hour"},
"ride_duration": {"min": 0, "max": 600, "step": 10, "unit": "seconds"},
"height_ft": {"min": 0, "max": 500, "step": 5, "unit": "feet"},
"length_ft": {"min": 0, "max": 10000, "step": 100, "unit": "feet"},
"speed_mph": {"min": 0, "max": 150, "step": 5, "unit": "mph"},
"inversions": {"min": 0, "max": 20, "step": 1, "unit": "inversions"},
"ride_time": {"min": 0, "max": 600, "step": 10, "unit": "seconds"},
"max_drop_height_ft": {"min": 0, "max": 500, "step": 10, "unit": "feet"},
"trains_count": {"min": 1, "max": 10, "step": 1, "unit": "trains"},
"cars_per_train": {"min": 1, "max": 20, "step": 1, "unit": "cars"},
"seats_per_car": {"min": 1, "max": 8, "step": 1, "unit": "seats"},
"opening_year": {"min": 1800, "max": 2030, "step": 1, "unit": "year"},
},
"boolean_filters": [
{"key": "has_inversions", "label": "Has Inversions",
"description": "Filter roller coasters with or without inversions"},
{"key": "has_coordinates", "label": "Has Location Coordinates",
"description": "Filter rides with GPS coordinates"},
{"key": "has_ride_model", "label": "Has Ride Model",
"description": "Filter rides with specified ride model"},
{"key": "has_manufacturer", "label": "Has Manufacturer",
"description": "Filter rides with specified manufacturer"},
{"key": "has_designer", "label": "Has Designer",
"description": "Filter rides with specified designer"},
],
"ordering_options": [
{"value": "name", "label": "Name (A-Z)"},
{"value": "-name", "label": "Name (Z-A)"},
{"value": "opening_date", "label": "Opening Date (Oldest First)"},
{"value": "-opening_date", "label": "Opening Date (Newest First)"},
{"value": "average_rating", "label": "Rating (Lowest First)"},
{"value": "-average_rating", "label": "Rating (Highest First)"},
{"value": "capacity_per_hour", "label": "Capacity (Lowest First)"},
{"value": "-capacity_per_hour",
"label": "Capacity (Highest First)"},
{"value": "ride_duration_seconds",
"label": "Duration (Shortest First)"},
{"value": "-ride_duration_seconds",
"label": "Duration (Longest First)"},
{"value": "height_ft", "label": "Height (Shortest First)"},
{"value": "-height_ft", "label": "Height (Tallest First)"},
{"value": "length_ft", "label": "Length (Shortest First)"},
{"value": "-length_ft", "label": "Length (Longest First)"},
{"value": "speed_mph", "label": "Speed (Slowest First)"},
{"value": "-speed_mph", "label": "Speed (Fastest First)"},
{"value": "inversions", "label": "Inversions (Fewest First)"},
{"value": "-inversions", "label": "Inversions (Most First)"},
{"value": "created_at", "label": "Date Added (Oldest First)"},
{"value": "-created_at", "label": "Date Added (Newest First)"},
{"value": "updated_at", "label": "Last Updated (Oldest First)"},
{"value": "-updated_at", "label": "Last Updated (Newest First)"},
],
})
# Try to get dynamic options from database
try:
# Get all ride categories from model choices
categories = [
{"value": choice[0], "label": choice[1]}
for choice in Ride.CATEGORY_CHOICES if choice[0] # Skip empty choice
]
# Get all ride statuses from model choices
statuses = [
{"value": choice[0], "label": choice[1]}
for choice in Ride.STATUS_CHOICES if choice[0] # Skip empty choice
]
# Get post-closing statuses from model choices
post_closing_statuses = [
{"value": choice[0], "label": choice[1]}
for choice in Ride.POST_CLOSING_STATUS_CHOICES
]
# Get roller coaster types from model choices
from apps.rides.models.rides import RollerCoasterStats
roller_coaster_types = [
{"value": choice[0], "label": choice[1]}
for choice in RollerCoasterStats.COASTER_TYPE_CHOICES
]
# Get track materials from model choices
track_materials = [
{"value": choice[0], "label": choice[1]}
for choice in RollerCoasterStats.TRACK_MATERIAL_CHOICES
]
# Get launch types from model choices
launch_types = [
{"value": choice[0], "label": choice[1]}
for choice in RollerCoasterStats.LAUNCH_CHOICES
]
# Get ride model target markets from model choices
ride_model_target_markets = [
{"value": choice[0], "label": choice[1]}
for choice in RideModel._meta.get_field('target_market').choices
]
# Get parks data from database
parks = list(Ride.objects.exclude(
park__isnull=True
).select_related('park').values(
'park__id', 'park__name', 'park__slug'
).distinct().order_by('park__name'))
# Get park areas data from database
park_areas = list(Ride.objects.exclude(
park_area__isnull=True
).select_related('park_area').values(
'park_area__id', 'park_area__name', 'park_area__slug'
).distinct().order_by('park_area__name'))
# Get manufacturers (companies with MANUFACTURER role)
manufacturers = list(Company.objects.filter(
roles__contains=['MANUFACTURER']
).values('id', 'name', 'slug').order_by('name'))
# Get designers (companies with DESIGNER role)
designers = list(Company.objects.filter(
roles__contains=['DESIGNER']
).values('id', 'name', 'slug').order_by('name'))
# Get ride models data from database
ride_models = list(RideModel.objects.select_related(
'manufacturer'
).values(
'id', 'name', 'slug', 'manufacturer__name', 'manufacturer__slug', 'category'
).order_by('manufacturer__name', 'name'))
# Calculate ranges from actual data
ride_stats = Ride.objects.aggregate(
min_rating=models.Min('average_rating'),
max_rating=models.Max('average_rating'),
min_height_req=models.Min('min_height_in'),
max_height_req=models.Max('max_height_in'),
min_capacity=models.Min('capacity_per_hour'),
max_capacity=models.Max('capacity_per_hour'),
min_duration=models.Min('ride_duration_seconds'),
max_duration=models.Max('ride_duration_seconds'),
min_year=models.Min('opening_date__year'),
max_year=models.Max('opening_date__year'),
)
# Calculate roller coaster specific ranges
coaster_stats = RollerCoasterStats.objects.aggregate(
min_height_ft=models.Min('height_ft'),
max_height_ft=models.Max('height_ft'),
min_length_ft=models.Min('length_ft'),
max_length_ft=models.Max('length_ft'),
min_speed_mph=models.Min('speed_mph'),
max_speed_mph=models.Max('speed_mph'),
min_inversions=models.Min('inversions'),
max_inversions=models.Max('inversions'),
min_ride_time=models.Min('ride_time_seconds'),
max_ride_time=models.Max('ride_time_seconds'),
min_drop_height=models.Min('max_drop_height_ft'),
max_drop_height=models.Max('max_drop_height_ft'),
min_trains=models.Min('trains_count'),
max_trains=models.Max('trains_count'),
min_cars=models.Min('cars_per_train'),
max_cars=models.Max('cars_per_train'),
min_seats=models.Min('seats_per_car'),
max_seats=models.Max('seats_per_car'),
)
ranges = {
"rating": {
"min": float(ride_stats['min_rating'] or 1),
"max": float(ride_stats['max_rating'] or 10),
"step": 0.1,
"unit": "stars"
},
"height_requirement": {
"min": ride_stats['min_height_req'] or 30,
"max": ride_stats['max_height_req'] or 90,
"step": 1,
"unit": "inches"
},
"capacity": {
"min": ride_stats['min_capacity'] or 0,
"max": ride_stats['max_capacity'] or 5000,
"step": 50,
"unit": "riders/hour"
},
"ride_duration": {
"min": ride_stats['min_duration'] or 0,
"max": ride_stats['max_duration'] or 600,
"step": 10,
"unit": "seconds"
},
"height_ft": {
"min": float(coaster_stats['min_height_ft'] or 0),
"max": float(coaster_stats['max_height_ft'] or 500),
"step": 5,
"unit": "feet"
},
"length_ft": {
"min": float(coaster_stats['min_length_ft'] or 0),
"max": float(coaster_stats['max_length_ft'] or 10000),
"step": 100,
"unit": "feet"
},
"speed_mph": {
"min": float(coaster_stats['min_speed_mph'] or 0),
"max": float(coaster_stats['max_speed_mph'] or 150),
"step": 5,
"unit": "mph"
},
"inversions": {
"min": coaster_stats['min_inversions'] or 0,
"max": coaster_stats['max_inversions'] or 20,
"step": 1,
"unit": "inversions"
},
"ride_time": {
"min": coaster_stats['min_ride_time'] or 0,
"max": coaster_stats['max_ride_time'] or 600,
"step": 10,
"unit": "seconds"
},
"max_drop_height_ft": {
"min": float(coaster_stats['min_drop_height'] or 0),
"max": float(coaster_stats['max_drop_height'] or 500),
"step": 10,
"unit": "feet"
},
"trains_count": {
"min": coaster_stats['min_trains'] or 1,
"max": coaster_stats['max_trains'] or 10,
"step": 1,
"unit": "trains"
},
"cars_per_train": {
"min": coaster_stats['min_cars'] or 1,
"max": coaster_stats['max_cars'] or 20,
"step": 1,
"unit": "cars"
},
"seats_per_car": {
"min": coaster_stats['min_seats'] or 1,
"max": coaster_stats['max_seats'] or 8,
"step": 1,
"unit": "seats"
},
"opening_year": {
"min": ride_stats['min_year'] or 1800,
"max": ride_stats['max_year'] or 2030,
"step": 1,
"unit": "year"
},
}
return Response({
"categories": categories,
"statuses": statuses,
"post_closing_statuses": post_closing_statuses,
"roller_coaster_types": roller_coaster_types,
"track_materials": track_materials,
"launch_types": launch_types,
"ride_model_target_markets": ride_model_target_markets,
"parks": parks,
"park_areas": park_areas,
"manufacturers": manufacturers,
"designers": designers,
"ride_models": ride_models,
"ranges": ranges,
"boolean_filters": [
{"key": "has_inversions", "label": "Has Inversions",
"description": "Filter roller coasters with or without inversions"},
{"key": "has_coordinates", "label": "Has Location Coordinates",
"description": "Filter rides with GPS coordinates"},
{"key": "has_ride_model", "label": "Has Ride Model",
"description": "Filter rides with specified ride model"},
{"key": "has_manufacturer", "label": "Has Manufacturer",
"description": "Filter rides with specified manufacturer"},
{"key": "has_designer", "label": "Has Designer",
"description": "Filter rides with specified designer"},
],
"ordering_options": [
{"value": "name", "label": "Name (A-Z)"},
{"value": "-name", "label": "Name (Z-A)"},
{"value": "opening_date", "label": "Opening Date (Oldest First)"},
{"value": "-opening_date", "label": "Opening Date (Newest First)"},
{"value": "average_rating", "label": "Rating (Lowest First)"},
{"value": "-average_rating", "label": "Rating (Highest First)"},
{"value": "capacity_per_hour", "label": "Capacity (Lowest First)"},
{"value": "-capacity_per_hour",
"label": "Capacity (Highest First)"},
{"value": "ride_duration_seconds",
"label": "Duration (Shortest First)"},
{"value": "-ride_duration_seconds",
"label": "Duration (Longest First)"},
{"value": "height_ft", "label": "Height (Shortest First)"},
{"value": "-height_ft", "label": "Height (Tallest First)"},
{"value": "length_ft", "label": "Length (Shortest First)"},
{"value": "-length_ft", "label": "Length (Longest First)"},
{"value": "speed_mph", "label": "Speed (Slowest First)"},
{"value": "-speed_mph", "label": "Speed (Fastest First)"},
{"value": "inversions", "label": "Inversions (Fewest First)"},
{"value": "-inversions", "label": "Inversions (Most First)"},
{"value": "created_at", "label": "Date Added (Oldest First)"},
{"value": "-created_at", "label": "Date Added (Newest First)"},
{"value": "updated_at", "label": "Last Updated (Oldest First)"},
{"value": "-updated_at", "label": "Last Updated (Newest First)"},
],
})
except Exception:
# Fallback to static options if database query fails
return Response({
"categories": [
{"value": "RC", "label": "Roller Coaster"},
{"value": "DR", "label": "Dark Ride"},
{"value": "FR", "label": "Flat Ride"},
{"value": "WR", "label": "Water Ride"},
{"value": "TR", "label": "Transport"},
{"value": "OT", "label": "Other"},
],
"statuses": [
{"value": "OPERATING", "label": "Operating"},
{"value": "CLOSED_TEMP", "label": "Temporarily Closed"},
{"value": "SBNO", "label": "Standing But Not Operating"},
{"value": "CLOSING", "label": "Closing"},
{"value": "CLOSED_PERM", "label": "Permanently Closed"},
{"value": "UNDER_CONSTRUCTION", "label": "Under Construction"},
{"value": "DEMOLISHED", "label": "Demolished"},
{"value": "RELOCATED", "label": "Relocated"},
],
"post_closing_statuses": [
{"value": "SBNO", "label": "Standing But Not Operating"},
{"value": "CLOSED_PERM", "label": "Permanently Closed"},
],
"roller_coaster_types": [
{"value": "SITDOWN", "label": "Sit Down"},
{"value": "INVERTED", "label": "Inverted"},
{"value": "FLYING", "label": "Flying"},
{"value": "STANDUP", "label": "Stand Up"},
{"value": "WING", "label": "Wing"},
{"value": "DIVE", "label": "Dive"},
{"value": "FAMILY", "label": "Family"},
{"value": "WILD_MOUSE", "label": "Wild Mouse"},
{"value": "SPINNING", "label": "Spinning"},
{"value": "FOURTH_DIMENSION", "label": "4th Dimension"},
{"value": "OTHER", "label": "Other"},
],
"track_materials": [
{"value": "STEEL", "label": "Steel"},
{"value": "WOOD", "label": "Wood"},
{"value": "HYBRID", "label": "Hybrid"},
],
"launch_types": [
{"value": "CHAIN", "label": "Chain Lift"},
{"value": "LSM", "label": "LSM Launch"},
{"value": "HYDRAULIC", "label": "Hydraulic Launch"},
{"value": "GRAVITY", "label": "Gravity"},
{"value": "OTHER", "label": "Other"},
],
"ride_model_target_markets": [
{"value": "FAMILY", "label": "Family"},
{"value": "THRILL", "label": "Thrill"},
{"value": "EXTREME", "label": "Extreme"},
{"value": "KIDDIE", "label": "Kiddie"},
{"value": "ALL_AGES", "label": "All Ages"},
],
"parks": [],
"park_areas": [],
"manufacturers": [],
"designers": [],
"ride_models": [],
"ranges": {
"rating": {"min": 1, "max": 10, "step": 0.1, "unit": "stars"},
"height_requirement": {"min": 30, "max": 90, "step": 1, "unit": "inches"},
"capacity": {"min": 0, "max": 5000, "step": 50, "unit": "riders/hour"},
"ride_duration": {"min": 0, "max": 600, "step": 10, "unit": "seconds"},
"height_ft": {"min": 0, "max": 500, "step": 5, "unit": "feet"},
"length_ft": {"min": 0, "max": 10000, "step": 100, "unit": "feet"},
"speed_mph": {"min": 0, "max": 150, "step": 5, "unit": "mph"},
"inversions": {"min": 0, "max": 20, "step": 1, "unit": "inversions"},
"ride_time": {"min": 0, "max": 600, "step": 10, "unit": "seconds"},
"max_drop_height_ft": {"min": 0, "max": 500, "step": 10, "unit": "feet"},
"trains_count": {"min": 1, "max": 10, "step": 1, "unit": "trains"},
"cars_per_train": {"min": 1, "max": 20, "step": 1, "unit": "cars"},
"seats_per_car": {"min": 1, "max": 8, "step": 1, "unit": "seats"},
"opening_year": {"min": 1800, "max": 2030, "step": 1, "unit": "year"},
},
"boolean_filters": [
{"key": "has_inversions", "label": "Has Inversions",
"description": "Filter roller coasters with or without inversions"},
{"key": "has_coordinates", "label": "Has Location Coordinates",
"description": "Filter rides with GPS coordinates"},
{"key": "has_ride_model", "label": "Has Ride Model",
"description": "Filter rides with specified ride model"},
{"key": "has_manufacturer", "label": "Has Manufacturer",
"description": "Filter rides with specified manufacturer"},
{"key": "has_designer", "label": "Has Designer",
"description": "Filter rides with specified designer"},
],
"ordering_options": [
{"value": "name", "label": "Name (A-Z)"},
{"value": "-name", "label": "Name (Z-A)"},
{"value": "opening_date", "label": "Opening Date (Oldest First)"},
{"value": "-opening_date", "label": "Opening Date (Newest First)"},
{"value": "average_rating", "label": "Rating (Lowest First)"},
{"value": "-average_rating", "label": "Rating (Highest First)"},
{"value": "capacity_per_hour", "label": "Capacity (Lowest First)"},
{"value": "-capacity_per_hour",
"label": "Capacity (Highest First)"},
{"value": "ride_duration_seconds",
"label": "Duration (Shortest First)"},
{"value": "-ride_duration_seconds",
"label": "Duration (Longest First)"},
{"value": "height_ft", "label": "Height (Shortest First)"},
{"value": "-height_ft", "label": "Height (Tallest First)"},
{"value": "length_ft", "label": "Length (Shortest First)"},
{"value": "-length_ft", "label": "Length (Longest First)"},
{"value": "speed_mph", "label": "Speed (Slowest First)"},
{"value": "-speed_mph", "label": "Speed (Fastest First)"},
{"value": "inversions", "label": "Inversions (Fewest First)"},
{"value": "-inversions", "label": "Inversions (Most First)"},
{"value": "created_at", "label": "Date Added (Oldest First)"},
{"value": "-created_at", "label": "Date Added (Newest First)"},
{"value": "updated_at", "label": "Last Updated (Oldest First)"},
{"value": "-updated_at", "label": "Last Updated (Newest First)"},
],
})
# --- Company search (autocomplete) -----------------------------------------
@extend_schema(
summary="Search companies (manufacturers/designers) for autocomplete",
parameters=[
OpenApiParameter(
name="q", location=OpenApiParameter.QUERY, type=OpenApiTypes.STR
)
],
responses={200: OpenApiTypes.OBJECT},
tags=["Rides"],
)
class CompanySearchAPIView(APIView):
permission_classes = [permissions.AllowAny]
def get(self, request: Request) -> Response:
q = request.query_params.get("q", "")
if not q:
return Response([], status=status.HTTP_200_OK)
if Company is None:
# Provide helpful placeholder structure
return Response(
[
{"id": 1, "name": "Rocky Mountain Construction", "slug": "rmc"},
{"id": 2, "name": "Bolliger & Mabillard", "slug": "b&m"},
]
)
qs = Company.objects.filter(name__icontains=q)[:20] # type: ignore
results = [
{"id": c.id, "name": c.name, "slug": getattr(c, "slug", "")} for c in qs
]
return Response(results)
# --- Ride model search (autocomplete) --------------------------------------
@extend_schema(
summary="Search ride models for autocomplete",
parameters=[
OpenApiParameter(
name="q", location=OpenApiParameter.QUERY, type=OpenApiTypes.STR
)
],
tags=["Rides"],
)
class RideModelSearchAPIView(APIView):
permission_classes = [permissions.AllowAny]
def get(self, request: Request) -> Response:
q = request.query_params.get("q", "")
if not q:
return Response([], status=status.HTTP_200_OK)
if RideModel is None:
return Response(
[
{"id": 1, "name": "I-Box (RMC)", "category": "ROLLER_COASTER"},
{
"id": 2,
"name": "Hyper Coaster Model X",
"category": "ROLLER_COASTER",
},
]
)
qs = RideModel.objects.filter(name__icontains=q)[:20] # type: ignore
results = [
{"id": m.id, "name": m.name, "category": getattr(m, "category", "")}
for m in qs
]
return Response(results)
# --- Search suggestions -----------------------------------------------------
@extend_schema(
summary="Search suggestions for ride search box",
parameters=[
OpenApiParameter(
name="q", location=OpenApiParameter.QUERY, type=OpenApiTypes.STR
)
],
tags=["Rides"],
)
class RideSearchSuggestionsAPIView(APIView):
permission_classes = [permissions.AllowAny]
def get(self, request: Request) -> Response:
q = request.query_params.get("q", "")
if not q:
return Response([], status=status.HTTP_200_OK)
# Very small suggestion implementation: look in ride names if available
if MODELS_AVAILABLE and Ride is not None:
qs = Ride.objects.filter(name__icontains=q).values_list("name", flat=True)[
:10
] # type: ignore
return Response([{"suggestion": name} for name in qs])
# Fallback suggestions
fallback = [
{"suggestion": f"{q} coaster"},
{"suggestion": f"{q} ride"},
{"suggestion": f"{q} park"},
]
return Response(fallback)
# --- Ride image settings ---------------------------------------------------
@extend_schema(
summary="Set ride banner and card images",
description="Set banner_image and card_image for a ride from existing ride photos",
request=RideImageSettingsInputSerializer,
responses={
200: RideDetailOutputSerializer,
400: OpenApiTypes.OBJECT,
404: OpenApiTypes.OBJECT,
},
tags=["Rides"],
)
class RideImageSettingsAPIView(APIView):
permission_classes = [permissions.AllowAny]
def _get_ride_or_404(self, pk: int) -> Any:
if not MODELS_AVAILABLE:
raise NotFound("Ride models not available")
try:
return Ride.objects.get(pk=pk) # type: ignore
except Ride.DoesNotExist: # type: ignore
raise NotFound("Ride not found")
def patch(self, request: Request, pk: int) -> Response:
"""Set banner and card images for the ride."""
ride = self._get_ride_or_404(pk)
serializer = RideImageSettingsInputSerializer(data=request.data, partial=True)
serializer.is_valid(raise_exception=True)
# Update the ride with the validated data
for field, value in serializer.validated_data.items():
setattr(ride, field, value)
ride.save()
# Return updated ride data
output_serializer = RideDetailOutputSerializer(
ride, context={"request": request}
)
return Response(output_serializer.data)
# --- Ride duplicate action --------------------------------------------------
Reference in New Issue View Git Blame Copy Permalink