mirror of
https://github.com/pacnpal/thrillwiki_django_no_react.git
synced 2025-12-20 08:51:09 -05:00
feat: Add PrimeProgress, PrimeSelect, and PrimeSkeleton components with customizable styles and props
- Implemented PrimeProgress component with support for labels, helper text, and various styles (size, variant, color). - Created PrimeSelect component with dropdown functionality, custom templates, and validation states. - Developed PrimeSkeleton component for loading placeholders with different shapes and animations. - Updated index.ts to export new components for easy import. - Enhanced PrimeVueTest.vue to include tests for new components and their functionalities. - Introduced a custom ThrillWiki theme for PrimeVue with tailored color schemes and component styles. - Added ambient type declarations for various components to improve TypeScript support.
This commit is contained in:
pacnpal
416
backend/apps/api/v1/parks/park_views.py
Normal file
416
backend/apps/api/v1/parks/park_views.py
Normal file
@@ -0,0 +1,416 @@
|
||||
"""
|
||||
Full-featured Parks API views for ThrillWiki API v1.
|
||||
|
||||
This module implements a comprehensive set of endpoints matching the Rides API:
|
||||
- List / Create: GET /parks/ POST /parks/
|
||||
- Retrieve / Update / Delete: GET /parks/{pk}/ PATCH/PUT/DELETE
|
||||
- Filter options: GET /parks/filter-options/
|
||||
- Company search: GET /parks/search/companies/?q=...
|
||||
- Search suggestions: GET /parks/search-suggestions/?q=...
|
||||
"""
|
||||
|
||||
from typing import Any
|
||||
|
||||
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
|
||||
|
||||
# Attempt to import model-level helpers; fall back gracefully if not present.
|
||||
try:
|
||||
from apps.parks.models import Park, Company as ParkCompany # type: ignore
|
||||
from apps.rides.models import Company as RideCompany # type: ignore
|
||||
|
||||
MODELS_AVAILABLE = True
|
||||
except Exception:
|
||||
Park = None # type: ignore
|
||||
ParkCompany = None # type: ignore
|
||||
RideCompany = 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
|
||||
|
||||
# Import serializers - we'll need to create these
|
||||
try:
|
||||
from apps.api.v1.serializers.parks import (
|
||||
ParkListOutputSerializer,
|
||||
ParkDetailOutputSerializer,
|
||||
ParkCreateInputSerializer,
|
||||
ParkUpdateInputSerializer,
|
||||
)
|
||||
|
||||
SERIALIZERS_AVAILABLE = True
|
||||
except Exception:
|
||||
# Fallback serializers will be created
|
||||
SERIALIZERS_AVAILABLE = False
|
||||
|
||||
|
||||
class StandardResultsSetPagination(PageNumberPagination):
|
||||
page_size = 20
|
||||
page_size_query_param = "page_size"
|
||||
max_page_size = 1000
|
||||
|
||||
|
||||
# --- Park list & create -----------------------------------------------------
|
||||
class ParkListCreateAPIView(APIView):
|
||||
permission_classes = [permissions.AllowAny]
|
||||
|
||||
@extend_schema(
|
||||
summary="List parks with filtering and pagination",
|
||||
description="List parks with basic filtering and pagination.",
|
||||
parameters=[
|
||||
OpenApiParameter(
|
||||
name="page", location=OpenApiParameter.QUERY, type=OpenApiTypes.INT
|
||||
),
|
||||
OpenApiParameter(
|
||||
name="page_size", location=OpenApiParameter.QUERY, type=OpenApiTypes.INT
|
||||
),
|
||||
OpenApiParameter(
|
||||
name="search", location=OpenApiParameter.QUERY, type=OpenApiTypes.STR
|
||||
),
|
||||
OpenApiParameter(
|
||||
name="country", location=OpenApiParameter.QUERY, type=OpenApiTypes.STR
|
||||
),
|
||||
OpenApiParameter(
|
||||
name="state", location=OpenApiParameter.QUERY, type=OpenApiTypes.STR
|
||||
),
|
||||
],
|
||||
responses={
|
||||
200: (
|
||||
"ParkListOutputSerializer(many=True)"
|
||||
if SERIALIZERS_AVAILABLE
|
||||
else OpenApiTypes.OBJECT
|
||||
)
|
||||
},
|
||||
tags=["Parks"],
|
||||
)
|
||||
def get(self, request: Request) -> Response:
|
||||
"""List parks with basic filtering and pagination."""
|
||||
if not MODELS_AVAILABLE:
|
||||
return Response(
|
||||
{
|
||||
"detail": (
|
||||
"Park listing is not available because domain models "
|
||||
"are not imported. Implement apps.parks.models.Park "
|
||||
"(and related managers) to enable listing."
|
||||
)
|
||||
},
|
||||
status=status.HTTP_501_NOT_IMPLEMENTED,
|
||||
)
|
||||
|
||||
qs = Park.objects.all().select_related(
|
||||
"operator", "property_owner"
|
||||
) # type: ignore
|
||||
|
||||
# Basic filters
|
||||
q = request.query_params.get("search")
|
||||
if q:
|
||||
qs = qs.filter(name__icontains=q) # simplistic search
|
||||
|
||||
country = request.query_params.get("country")
|
||||
if country:
|
||||
qs = qs.filter(location__country__icontains=country) # type: ignore
|
||||
|
||||
state = request.query_params.get("state")
|
||||
if state:
|
||||
qs = qs.filter(location__state__icontains=state) # type: ignore
|
||||
|
||||
paginator = StandardResultsSetPagination()
|
||||
page = paginator.paginate_queryset(qs, request)
|
||||
|
||||
if SERIALIZERS_AVAILABLE:
|
||||
serializer = ParkListOutputSerializer(
|
||||
page, many=True, context={"request": request}
|
||||
)
|
||||
else:
|
||||
# Fallback serialization
|
||||
serializer_data = [
|
||||
{
|
||||
"id": park.id,
|
||||
"name": park.name,
|
||||
"slug": getattr(park, "slug", ""),
|
||||
"description": getattr(park, "description", ""),
|
||||
"location": str(getattr(park, "location", "")),
|
||||
"operator": (
|
||||
getattr(park.operator, "name", "")
|
||||
if hasattr(park, "operator")
|
||||
else ""
|
||||
),
|
||||
}
|
||||
for park in page
|
||||
]
|
||||
return paginator.get_paginated_response(serializer_data)
|
||||
|
||||
return paginator.get_paginated_response(serializer.data)
|
||||
|
||||
@extend_schema(
|
||||
summary="Create a new park",
|
||||
description="Create a new park.",
|
||||
responses={
|
||||
201: (
|
||||
"ParkDetailOutputSerializer()"
|
||||
if SERIALIZERS_AVAILABLE
|
||||
else OpenApiTypes.OBJECT
|
||||
)
|
||||
},
|
||||
tags=["Parks"],
|
||||
)
|
||||
def post(self, request: Request) -> Response:
|
||||
"""Create a new park."""
|
||||
if not SERIALIZERS_AVAILABLE:
|
||||
return Response(
|
||||
{
|
||||
"detail": "Park creation serializers not available. "
|
||||
"Implement park serializers to enable creation."
|
||||
},
|
||||
status=status.HTTP_501_NOT_IMPLEMENTED,
|
||||
)
|
||||
|
||||
serializer_in = ParkCreateInputSerializer(data=request.data)
|
||||
serializer_in.is_valid(raise_exception=True)
|
||||
|
||||
if not MODELS_AVAILABLE:
|
||||
return Response(
|
||||
{
|
||||
"detail": (
|
||||
"Park creation is not available because domain models "
|
||||
"are not imported. Implement apps.parks.models.Park "
|
||||
"and necessary create logic."
|
||||
)
|
||||
},
|
||||
status=status.HTTP_501_NOT_IMPLEMENTED,
|
||||
)
|
||||
|
||||
validated = serializer_in.validated_data
|
||||
|
||||
# Minimal create logic using model fields if available.
|
||||
park = Park.objects.create( # type: ignore
|
||||
name=validated["name"],
|
||||
description=validated.get("description", ""),
|
||||
# Add other fields as needed based on Park model
|
||||
)
|
||||
|
||||
out_serializer = ParkDetailOutputSerializer(park, context={"request": request})
|
||||
return Response(out_serializer.data, status=status.HTTP_201_CREATED)
|
||||
|
||||
|
||||
# --- Park retrieve / update / delete ---------------------------------------
|
||||
@extend_schema(
|
||||
summary="Retrieve, update or delete a park",
|
||||
responses={
|
||||
200: (
|
||||
"ParkDetailOutputSerializer()"
|
||||
if SERIALIZERS_AVAILABLE
|
||||
else OpenApiTypes.OBJECT
|
||||
)
|
||||
},
|
||||
tags=["Parks"],
|
||||
)
|
||||
class ParkDetailAPIView(APIView):
|
||||
permission_classes = [permissions.AllowAny]
|
||||
|
||||
def _get_park_or_404(self, pk: int) -> Any:
|
||||
if not MODELS_AVAILABLE:
|
||||
raise NotFound(
|
||||
(
|
||||
"Park detail is not available because domain models "
|
||||
"are not imported. Implement apps.parks.models.Park "
|
||||
"to enable detail endpoints."
|
||||
)
|
||||
)
|
||||
try:
|
||||
# type: ignore
|
||||
return Park.objects.select_related("operator", "property_owner").get(pk=pk)
|
||||
except Park.DoesNotExist: # type: ignore
|
||||
raise NotFound("Park not found")
|
||||
|
||||
def get(self, request: Request, pk: int) -> Response:
|
||||
park = self._get_park_or_404(pk)
|
||||
if SERIALIZERS_AVAILABLE:
|
||||
serializer = ParkDetailOutputSerializer(park, context={"request": request})
|
||||
return Response(serializer.data)
|
||||
else:
|
||||
# Fallback serialization
|
||||
return Response(
|
||||
{
|
||||
"id": park.id,
|
||||
"name": park.name,
|
||||
"slug": getattr(park, "slug", ""),
|
||||
"description": getattr(park, "description", ""),
|
||||
"location": str(getattr(park, "location", "")),
|
||||
"operator": (
|
||||
getattr(park.operator, "name", "")
|
||||
if hasattr(park, "operator")
|
||||
else ""
|
||||
),
|
||||
}
|
||||
)
|
||||
|
||||
def patch(self, request: Request, pk: int) -> Response:
|
||||
park = self._get_park_or_404(pk)
|
||||
if not SERIALIZERS_AVAILABLE:
|
||||
return Response(
|
||||
{"detail": "Park update serializers not available."},
|
||||
status=status.HTTP_501_NOT_IMPLEMENTED,
|
||||
)
|
||||
|
||||
serializer_in = ParkUpdateInputSerializer(data=request.data, partial=True)
|
||||
serializer_in.is_valid(raise_exception=True)
|
||||
|
||||
if not MODELS_AVAILABLE:
|
||||
return Response(
|
||||
{
|
||||
"detail": (
|
||||
"Park update is not available because domain models "
|
||||
"are not imported."
|
||||
)
|
||||
},
|
||||
status=status.HTTP_501_NOT_IMPLEMENTED,
|
||||
)
|
||||
for key, value in serializer_in.validated_data.items():
|
||||
setattr(park, key, value)
|
||||
park.save()
|
||||
serializer = ParkDetailOutputSerializer(park, context={"request": request})
|
||||
return Response(serializer.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": (
|
||||
"Park delete is not available because domain models "
|
||||
"are not imported."
|
||||
)
|
||||
},
|
||||
status=status.HTTP_501_NOT_IMPLEMENTED,
|
||||
)
|
||||
park = self._get_park_or_404(pk)
|
||||
park.delete()
|
||||
return Response(status=status.HTTP_204_NO_CONTENT)
|
||||
|
||||
|
||||
# --- Filter options ---------------------------------------------------------
|
||||
@extend_schema(
|
||||
summary="Get filter options for parks",
|
||||
responses={200: OpenApiTypes.OBJECT},
|
||||
tags=["Parks"],
|
||||
)
|
||||
class FilterOptionsAPIView(APIView):
|
||||
permission_classes = [permissions.AllowAny]
|
||||
|
||||
def get(self, request: Request) -> Response:
|
||||
"""Return static/dynamic filter options used by the frontend."""
|
||||
# Try to use ModelChoices if available
|
||||
if HAVE_MODELCHOICES and ModelChoices is not None:
|
||||
try:
|
||||
data = {
|
||||
"park_types": ModelChoices.get_park_type_choices(),
|
||||
"countries": ModelChoices.get_country_choices(),
|
||||
"states": ModelChoices.get_state_choices(),
|
||||
"ordering_options": [
|
||||
"name",
|
||||
"-name",
|
||||
"opening_date",
|
||||
"-opening_date",
|
||||
"ride_count",
|
||||
"-ride_count",
|
||||
],
|
||||
}
|
||||
return Response(data)
|
||||
except Exception:
|
||||
# fallthrough to fallback
|
||||
pass
|
||||
|
||||
# Fallback minimal options
|
||||
return Response(
|
||||
{
|
||||
"park_types": ["THEME_PARK", "AMUSEMENT_PARK", "WATER_PARK"],
|
||||
"countries": ["United States", "Canada", "United Kingdom", "Germany"],
|
||||
"ordering_options": ["name", "-name", "opening_date", "-opening_date"],
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
# --- Company search (autocomplete) -----------------------------------------
|
||||
@extend_schema(
|
||||
summary="Search companies (operators/property owners) for autocomplete",
|
||||
parameters=[
|
||||
OpenApiParameter(
|
||||
name="q", location=OpenApiParameter.QUERY, type=OpenApiTypes.STR
|
||||
)
|
||||
],
|
||||
responses={200: OpenApiTypes.OBJECT},
|
||||
tags=["Parks"],
|
||||
)
|
||||
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 ParkCompany is None:
|
||||
# Provide helpful placeholder structure
|
||||
return Response(
|
||||
[
|
||||
{"id": 1, "name": "Six Flags Entertainment", "slug": "six-flags"},
|
||||
{"id": 2, "name": "Cedar Fair", "slug": "cedar-fair"},
|
||||
{"id": 3, "name": "Disney Parks", "slug": "disney"},
|
||||
]
|
||||
)
|
||||
|
||||
qs = ParkCompany.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)
|
||||
|
||||
|
||||
# --- Search suggestions -----------------------------------------------------
|
||||
@extend_schema(
|
||||
summary="Search suggestions for park search box",
|
||||
parameters=[
|
||||
OpenApiParameter(
|
||||
name="q", location=OpenApiParameter.QUERY, type=OpenApiTypes.STR
|
||||
)
|
||||
],
|
||||
tags=["Parks"],
|
||||
)
|
||||
class ParkSearchSuggestionsAPIView(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 park names if available
|
||||
if MODELS_AVAILABLE and Park is not None:
|
||||
qs = Park.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} Park"},
|
||||
{"suggestion": f"{q} Theme Park"},
|
||||
{"suggestion": f"{q} Amusement Park"},
|
||||
]
|
||||
return Response(fallback)
|
||||
@@ -1,14 +1,148 @@
|
||||
"""
|
||||
Serializers for the parks API.
|
||||
Park media serializers for ThrillWiki API v1.
|
||||
|
||||
This module contains serializers for park-specific media functionality.
|
||||
Enhanced from rogue implementation to maintain full feature parity.
|
||||
"""
|
||||
|
||||
from rest_framework import serializers
|
||||
|
||||
from drf_spectacular.utils import extend_schema_field
|
||||
from apps.parks.models import Park, ParkPhoto
|
||||
|
||||
|
||||
class ParkPhotoOutputSerializer(serializers.ModelSerializer):
|
||||
"""Enhanced output serializer for park photos with rich field structure."""
|
||||
|
||||
uploaded_by_username = serializers.CharField(
|
||||
source="uploaded_by.username", read_only=True
|
||||
)
|
||||
|
||||
file_size = serializers.SerializerMethodField()
|
||||
dimensions = serializers.SerializerMethodField()
|
||||
|
||||
@extend_schema_field(
|
||||
serializers.IntegerField(allow_null=True, help_text="File size in bytes")
|
||||
)
|
||||
def get_file_size(self, obj):
|
||||
"""Get file size in bytes."""
|
||||
return obj.file_size
|
||||
|
||||
@extend_schema_field(
|
||||
serializers.ListField(
|
||||
child=serializers.IntegerField(),
|
||||
min_length=2,
|
||||
max_length=2,
|
||||
allow_null=True,
|
||||
help_text="Image dimensions as [width, height] in pixels",
|
||||
)
|
||||
)
|
||||
def get_dimensions(self, obj):
|
||||
"""Get image dimensions as [width, height]."""
|
||||
return obj.dimensions
|
||||
|
||||
park_slug = serializers.CharField(source="park.slug", read_only=True)
|
||||
park_name = serializers.CharField(source="park.name", read_only=True)
|
||||
|
||||
class Meta:
|
||||
model = ParkPhoto
|
||||
fields = [
|
||||
"id",
|
||||
"image",
|
||||
"caption",
|
||||
"alt_text",
|
||||
"is_primary",
|
||||
"is_approved",
|
||||
"created_at",
|
||||
"updated_at",
|
||||
"date_taken",
|
||||
"uploaded_by_username",
|
||||
"file_size",
|
||||
"dimensions",
|
||||
"park_slug",
|
||||
"park_name",
|
||||
]
|
||||
read_only_fields = [
|
||||
"id",
|
||||
"created_at",
|
||||
"updated_at",
|
||||
"uploaded_by_username",
|
||||
"file_size",
|
||||
"dimensions",
|
||||
"park_slug",
|
||||
"park_name",
|
||||
]
|
||||
|
||||
|
||||
class ParkPhotoCreateInputSerializer(serializers.ModelSerializer):
|
||||
"""Input serializer for creating park photos."""
|
||||
|
||||
class Meta:
|
||||
model = ParkPhoto
|
||||
fields = [
|
||||
"image",
|
||||
"caption",
|
||||
"alt_text",
|
||||
"is_primary",
|
||||
]
|
||||
|
||||
|
||||
class ParkPhotoUpdateInputSerializer(serializers.ModelSerializer):
|
||||
"""Input serializer for updating park photos."""
|
||||
|
||||
class Meta:
|
||||
model = ParkPhoto
|
||||
fields = [
|
||||
"caption",
|
||||
"alt_text",
|
||||
"is_primary",
|
||||
]
|
||||
|
||||
|
||||
class ParkPhotoListOutputSerializer(serializers.ModelSerializer):
|
||||
"""Optimized output serializer for park photo lists."""
|
||||
|
||||
uploaded_by_username = serializers.CharField(
|
||||
source="uploaded_by.username", read_only=True
|
||||
)
|
||||
|
||||
class Meta:
|
||||
model = ParkPhoto
|
||||
fields = [
|
||||
"id",
|
||||
"image",
|
||||
"caption",
|
||||
"is_primary",
|
||||
"is_approved",
|
||||
"created_at",
|
||||
"uploaded_by_username",
|
||||
]
|
||||
read_only_fields = fields
|
||||
|
||||
|
||||
class ParkPhotoApprovalInputSerializer(serializers.Serializer):
|
||||
"""Input serializer for bulk photo approval operations."""
|
||||
|
||||
photo_ids = serializers.ListField(
|
||||
child=serializers.IntegerField(), help_text="List of photo IDs to approve"
|
||||
)
|
||||
approve = serializers.BooleanField(
|
||||
default=True, help_text="Whether to approve (True) or reject (False) the photos"
|
||||
)
|
||||
|
||||
|
||||
class ParkPhotoStatsOutputSerializer(serializers.Serializer):
|
||||
"""Output serializer for park photo statistics."""
|
||||
|
||||
total_photos = serializers.IntegerField()
|
||||
approved_photos = serializers.IntegerField()
|
||||
pending_photos = serializers.IntegerField()
|
||||
has_primary = serializers.BooleanField()
|
||||
recent_uploads = serializers.IntegerField()
|
||||
|
||||
|
||||
# Legacy serializers for backwards compatibility
|
||||
class ParkPhotoSerializer(serializers.ModelSerializer):
|
||||
"""Serializer for the ParkPhoto model."""
|
||||
"""Legacy serializer for the ParkPhoto model - maintained for compatibility."""
|
||||
|
||||
class Meta:
|
||||
model = ParkPhoto
|
||||
|
||||
@@ -1,15 +1,47 @@
|
||||
"""
|
||||
Park API URLs for ThrillWiki API v1.
|
||||
"""Comprehensive URL routes for Parks domain (API v1).
|
||||
|
||||
This file exposes a maximal set of "full-fat" endpoints implemented in
|
||||
`apps.api.v1.parks.park_views` and `apps.api.v1.parks.views`. Endpoints are
|
||||
intentionally expansive to match the rides API functionality and provide
|
||||
complete feature parity for parks management.
|
||||
"""
|
||||
|
||||
from django.urls import path, include
|
||||
from rest_framework.routers import DefaultRouter
|
||||
|
||||
from .park_views import (
|
||||
ParkListCreateAPIView,
|
||||
ParkDetailAPIView,
|
||||
FilterOptionsAPIView,
|
||||
CompanySearchAPIView,
|
||||
ParkSearchSuggestionsAPIView,
|
||||
)
|
||||
from .views import ParkPhotoViewSet
|
||||
|
||||
# Create router for nested photo endpoints
|
||||
router = DefaultRouter()
|
||||
router.register(r"photos", ParkPhotoViewSet, basename="park-photo")
|
||||
|
||||
app_name = "api_v1_parks"
|
||||
|
||||
urlpatterns = [
|
||||
path("", include(router.urls)),
|
||||
# Core list/create endpoints
|
||||
path("", ParkListCreateAPIView.as_view(), name="park-list-create"),
|
||||
# Filter options
|
||||
path("filter-options/", FilterOptionsAPIView.as_view(), name="park-filter-options"),
|
||||
# Autocomplete / suggestion endpoints
|
||||
path(
|
||||
"search/companies/",
|
||||
CompanySearchAPIView.as_view(),
|
||||
name="park-search-companies",
|
||||
),
|
||||
path(
|
||||
"search-suggestions/",
|
||||
ParkSearchSuggestionsAPIView.as_view(),
|
||||
name="park-search-suggestions",
|
||||
),
|
||||
# Detail and action endpoints
|
||||
path("<int:pk>/", ParkDetailAPIView.as_view(), name="park-detail"),
|
||||
# Park photo endpoints - domain-specific photo management
|
||||
path("<int:park_pk>/photos/", include(router.urls)),
|
||||
]
|
||||
|
||||
@@ -1,7 +1,19 @@
|
||||
"""
|
||||
Park API views for ThrillWiki API v1.
|
||||
|
||||
This module contains consolidated park photo viewset for the centralized API structure.
|
||||
Enhanced from rogue implementation to maintain full feature parity.
|
||||
"""
|
||||
|
||||
from .serializers import (
|
||||
ParkPhotoOutputSerializer,
|
||||
ParkPhotoCreateInputSerializer,
|
||||
ParkPhotoUpdateInputSerializer,
|
||||
ParkPhotoListOutputSerializer,
|
||||
ParkPhotoApprovalInputSerializer,
|
||||
ParkPhotoStatsOutputSerializer,
|
||||
)
|
||||
from typing import Any, cast
|
||||
import logging
|
||||
|
||||
from django.core.exceptions import PermissionDenied
|
||||
@@ -9,17 +21,16 @@ from drf_spectacular.utils import extend_schema_view, extend_schema
|
||||
from drf_spectacular.types import OpenApiTypes
|
||||
from rest_framework import status
|
||||
from rest_framework.decorators import action
|
||||
from rest_framework.exceptions import ValidationError
|
||||
from rest_framework.permissions import IsAuthenticated
|
||||
from rest_framework.response import Response
|
||||
from rest_framework.viewsets import ModelViewSet
|
||||
|
||||
from apps.parks.models import ParkPhoto
|
||||
from apps.parks.models import ParkPhoto, Park
|
||||
from apps.parks.services import ParkMediaService
|
||||
from ..media.serializers import (
|
||||
PhotoUpdateInputSerializer,
|
||||
PhotoListOutputSerializer,
|
||||
)
|
||||
from .serializers import ParkPhotoSerializer
|
||||
from django.contrib.auth import get_user_model
|
||||
|
||||
UserModel = get_user_model()
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
@@ -27,79 +38,322 @@ logger = logging.getLogger(__name__)
|
||||
@extend_schema_view(
|
||||
list=extend_schema(
|
||||
summary="List park photos",
|
||||
description="Retrieve a list of photos for a specific park.",
|
||||
responses={200: PhotoListOutputSerializer(many=True)},
|
||||
tags=["Parks"],
|
||||
description="Retrieve a paginated list of park photos with filtering capabilities.",
|
||||
responses={200: ParkPhotoListOutputSerializer(many=True)},
|
||||
tags=["Park Media"],
|
||||
),
|
||||
create=extend_schema(
|
||||
summary="Upload park photo",
|
||||
description="Upload a new photo for a park. Requires authentication.",
|
||||
request=ParkPhotoCreateInputSerializer,
|
||||
responses={
|
||||
201: ParkPhotoOutputSerializer,
|
||||
400: OpenApiTypes.OBJECT,
|
||||
401: OpenApiTypes.OBJECT,
|
||||
},
|
||||
tags=["Park Media"],
|
||||
),
|
||||
retrieve=extend_schema(
|
||||
summary="Get park photo details",
|
||||
description="Retrieve detailed information about a specific park photo.",
|
||||
responses={
|
||||
200: ParkPhotoSerializer,
|
||||
200: ParkPhotoOutputSerializer,
|
||||
404: OpenApiTypes.OBJECT,
|
||||
},
|
||||
tags=["Parks"],
|
||||
tags=["Park Media"],
|
||||
),
|
||||
update=extend_schema(
|
||||
summary="Update park photo",
|
||||
description="Update park photo information (caption, alt text, etc.)",
|
||||
request=PhotoUpdateInputSerializer,
|
||||
description="Update park photo information. Requires authentication and ownership or admin privileges.",
|
||||
request=ParkPhotoUpdateInputSerializer,
|
||||
responses={
|
||||
200: ParkPhotoSerializer,
|
||||
200: ParkPhotoOutputSerializer,
|
||||
400: OpenApiTypes.OBJECT,
|
||||
401: OpenApiTypes.OBJECT,
|
||||
403: OpenApiTypes.OBJECT,
|
||||
404: OpenApiTypes.OBJECT,
|
||||
},
|
||||
tags=["Park Media"],
|
||||
),
|
||||
partial_update=extend_schema(
|
||||
summary="Partially update park photo",
|
||||
description="Partially update park photo information. Requires authentication and ownership or admin privileges.",
|
||||
request=ParkPhotoUpdateInputSerializer,
|
||||
responses={
|
||||
200: ParkPhotoOutputSerializer,
|
||||
400: OpenApiTypes.OBJECT,
|
||||
401: OpenApiTypes.OBJECT,
|
||||
403: OpenApiTypes.OBJECT,
|
||||
404: OpenApiTypes.OBJECT,
|
||||
},
|
||||
tags=["Park Media"],
|
||||
),
|
||||
destroy=extend_schema(
|
||||
summary="Delete park photo",
|
||||
description="Delete a park photo. Requires authentication and ownership or admin privileges.",
|
||||
responses={
|
||||
204: None,
|
||||
401: OpenApiTypes.OBJECT,
|
||||
403: OpenApiTypes.OBJECT,
|
||||
404: OpenApiTypes.OBJECT,
|
||||
},
|
||||
tags=["Park Media"],
|
||||
),
|
||||
)
|
||||
class ParkPhotoViewSet(ModelViewSet):
|
||||
"""
|
||||
Enhanced ViewSet for managing park photos with full feature parity.
|
||||
|
||||
Provides CRUD operations for park photos with proper permission checking.
|
||||
Uses ParkMediaService for business logic operations.
|
||||
Includes advanced features like bulk approval and statistics.
|
||||
"""
|
||||
|
||||
permission_classes = [IsAuthenticated]
|
||||
lookup_field = "id"
|
||||
|
||||
def get_queryset(self): # type: ignore[override]
|
||||
"""Get photos for the current park with optimized queries."""
|
||||
queryset = ParkPhoto.objects.select_related(
|
||||
"park", "park__operator", "uploaded_by"
|
||||
)
|
||||
|
||||
# If park_pk is provided in URL kwargs, filter by park
|
||||
park_pk = self.kwargs.get("park_pk")
|
||||
if park_pk:
|
||||
queryset = queryset.filter(park_id=park_pk)
|
||||
|
||||
return queryset.order_by("-created_at")
|
||||
|
||||
def get_serializer_class(self): # type: ignore[override]
|
||||
"""Return appropriate serializer based on action."""
|
||||
if self.action == "list":
|
||||
return ParkPhotoListOutputSerializer
|
||||
elif self.action == "create":
|
||||
return ParkPhotoCreateInputSerializer
|
||||
elif self.action in ["update", "partial_update"]:
|
||||
return ParkPhotoUpdateInputSerializer
|
||||
else:
|
||||
return ParkPhotoOutputSerializer
|
||||
|
||||
def perform_create(self, serializer):
|
||||
"""Create a new park photo using ParkMediaService."""
|
||||
park_id = self.kwargs.get("park_pk")
|
||||
if not park_id:
|
||||
raise ValidationError("Park ID is required")
|
||||
try:
|
||||
# Use the service to create the photo with proper business logic
|
||||
service = cast(Any, ParkMediaService())
|
||||
photo = service.create_photo(
|
||||
park_id=park_id,
|
||||
uploaded_by=self.request.user,
|
||||
**serializer.validated_data,
|
||||
)
|
||||
|
||||
# Set the instance for the serializer response
|
||||
serializer.instance = photo
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error creating park photo: {e}")
|
||||
raise ValidationError(f"Failed to create photo: {str(e)}")
|
||||
|
||||
def perform_update(self, serializer):
|
||||
"""Update park photo with permission checking."""
|
||||
instance = self.get_object()
|
||||
|
||||
# Check permissions - allow owner or staff
|
||||
if not (
|
||||
self.request.user == instance.uploaded_by
|
||||
or cast(Any, self.request.user).is_staff
|
||||
):
|
||||
raise PermissionDenied("You can only edit your own photos or be an admin.")
|
||||
|
||||
# Handle primary photo logic using service
|
||||
if serializer.validated_data.get("is_primary", False):
|
||||
try:
|
||||
ParkMediaService().set_primary_photo(
|
||||
park_id=instance.park_id, photo_id=instance.id
|
||||
)
|
||||
# Remove is_primary from validated_data since service handles it
|
||||
if "is_primary" in serializer.validated_data:
|
||||
del serializer.validated_data["is_primary"]
|
||||
except Exception as e:
|
||||
logger.error(f"Error setting primary photo: {e}")
|
||||
raise ValidationError(f"Failed to set primary photo: {str(e)}")
|
||||
|
||||
def perform_destroy(self, instance):
|
||||
"""Delete park photo with permission checking."""
|
||||
# Check permissions - allow owner or staff
|
||||
if not (
|
||||
self.request.user == instance.uploaded_by
|
||||
or cast(Any, self.request.user).is_staff
|
||||
):
|
||||
raise PermissionDenied(
|
||||
"You can only delete your own photos or be an admin."
|
||||
)
|
||||
|
||||
try:
|
||||
ParkMediaService().delete_photo(
|
||||
instance.id, deleted_by=cast(UserModel, self.request.user)
|
||||
)
|
||||
except Exception as e:
|
||||
logger.error(f"Error deleting park photo: {e}")
|
||||
raise ValidationError(f"Failed to delete photo: {str(e)}")
|
||||
|
||||
@extend_schema(
|
||||
summary="Set photo as primary",
|
||||
description="Set this photo as the primary photo for the park",
|
||||
responses={
|
||||
200: OpenApiTypes.OBJECT,
|
||||
400: OpenApiTypes.OBJECT,
|
||||
403: OpenApiTypes.OBJECT,
|
||||
404: OpenApiTypes.OBJECT,
|
||||
},
|
||||
tags=["Parks"],
|
||||
),
|
||||
destroy=extend_schema(
|
||||
summary="Delete park photo",
|
||||
description="Delete a park photo (only by owner or admin)",
|
||||
responses={
|
||||
204: None,
|
||||
403: OpenApiTypes.OBJECT,
|
||||
404: OpenApiTypes.OBJECT,
|
||||
},
|
||||
tags=["Parks"],
|
||||
),
|
||||
)
|
||||
class ParkPhotoViewSet(ModelViewSet):
|
||||
"""ViewSet for managing park photos."""
|
||||
|
||||
queryset = ParkPhoto.objects.select_related("park", "uploaded_by").all()
|
||||
permission_classes = [IsAuthenticated]
|
||||
lookup_field = "id"
|
||||
|
||||
def get_serializer_class(self):
|
||||
"""Return appropriate serializer based on action."""
|
||||
if self.action == "list":
|
||||
return PhotoListOutputSerializer
|
||||
elif self.action in ["update", "partial_update"]:
|
||||
return PhotoUpdateInputSerializer
|
||||
return ParkPhotoSerializer
|
||||
|
||||
def perform_update(self, serializer):
|
||||
"""Update photo with permission check."""
|
||||
photo = self.get_object()
|
||||
if not (
|
||||
self.request.user == photo.uploaded_by
|
||||
or self.request.user.has_perm("parks.change_parkphoto")
|
||||
):
|
||||
raise PermissionDenied("You do not have permission to edit this photo.")
|
||||
serializer.save()
|
||||
|
||||
def perform_destroy(self, instance):
|
||||
"""Delete photo with permission check."""
|
||||
if not (
|
||||
self.request.user == instance.uploaded_by
|
||||
or self.request.user.has_perm("parks.delete_parkphoto")
|
||||
):
|
||||
raise PermissionDenied("You do not have permission to delete this photo.")
|
||||
instance.delete()
|
||||
|
||||
tags=["Park Media"],
|
||||
)
|
||||
@action(detail=True, methods=["post"])
|
||||
def set_primary(self, request, id=None):
|
||||
"""Set this photo as the primary photo for its park."""
|
||||
def set_primary(self, request, **kwargs):
|
||||
"""Set this photo as the primary photo for the park."""
|
||||
photo = self.get_object()
|
||||
|
||||
# Check permissions - allow owner or staff
|
||||
if not (request.user == photo.uploaded_by or cast(Any, request.user).is_staff):
|
||||
raise PermissionDenied(
|
||||
"You can only modify your own photos or be an admin."
|
||||
)
|
||||
|
||||
try:
|
||||
ParkMediaService().set_primary_photo(
|
||||
park_id=photo.park_id, photo_id=photo.id
|
||||
)
|
||||
|
||||
# Refresh the photo instance
|
||||
photo.refresh_from_db()
|
||||
serializer = self.get_serializer(photo)
|
||||
|
||||
return Response(
|
||||
{
|
||||
"message": "Photo set as primary successfully",
|
||||
"photo": serializer.data,
|
||||
},
|
||||
status=status.HTTP_200_OK,
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error setting primary photo: {e}")
|
||||
return Response(
|
||||
{"error": f"Failed to set primary photo: {str(e)}"},
|
||||
status=status.HTTP_400_BAD_REQUEST,
|
||||
)
|
||||
|
||||
@extend_schema(
|
||||
summary="Bulk approve/reject photos",
|
||||
description="Bulk approve or reject multiple park photos (admin only)",
|
||||
request=ParkPhotoApprovalInputSerializer,
|
||||
responses={
|
||||
200: OpenApiTypes.OBJECT,
|
||||
400: OpenApiTypes.OBJECT,
|
||||
403: OpenApiTypes.OBJECT,
|
||||
},
|
||||
tags=["Park Media"],
|
||||
)
|
||||
@action(detail=False, methods=["post"], permission_classes=[IsAuthenticated])
|
||||
def bulk_approve(self, request, **kwargs):
|
||||
"""Bulk approve or reject multiple photos (admin only)."""
|
||||
if not cast(Any, request.user).is_staff:
|
||||
raise PermissionDenied("Only administrators can approve photos.")
|
||||
|
||||
serializer = ParkPhotoApprovalInputSerializer(data=request.data)
|
||||
serializer.is_valid(raise_exception=True)
|
||||
|
||||
validated_data = cast(dict, getattr(serializer, "validated_data", {}))
|
||||
photo_ids = validated_data.get("photo_ids")
|
||||
approve = validated_data.get("approve")
|
||||
park_id = self.kwargs.get("park_pk")
|
||||
|
||||
if photo_ids is None or approve is None:
|
||||
return Response(
|
||||
{"error": "Missing required fields: photo_ids and/or approve."},
|
||||
status=status.HTTP_400_BAD_REQUEST,
|
||||
)
|
||||
|
||||
try:
|
||||
# Filter photos to only those belonging to this park (if park_pk provided)
|
||||
photos_queryset = ParkPhoto.objects.filter(id__in=photo_ids)
|
||||
if park_id:
|
||||
photos_queryset = photos_queryset.filter(park_id=park_id)
|
||||
|
||||
updated_count = photos_queryset.update(is_approved=approve)
|
||||
|
||||
return Response(
|
||||
{
|
||||
"message": f"Successfully {'approved' if approve else 'rejected'} {updated_count} photos",
|
||||
"updated_count": updated_count,
|
||||
},
|
||||
status=status.HTTP_200_OK,
|
||||
)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error in bulk photo approval: {e}")
|
||||
return Response(
|
||||
{"error": f"Failed to update photos: {str(e)}"},
|
||||
status=status.HTTP_400_BAD_REQUEST,
|
||||
)
|
||||
|
||||
@extend_schema(
|
||||
summary="Get park photo statistics",
|
||||
description="Get photo statistics for the park",
|
||||
responses={
|
||||
200: ParkPhotoStatsOutputSerializer,
|
||||
404: OpenApiTypes.OBJECT,
|
||||
500: OpenApiTypes.OBJECT,
|
||||
},
|
||||
tags=["Park Media"],
|
||||
)
|
||||
@action(detail=False, methods=["get"])
|
||||
def stats(self, request, **kwargs):
|
||||
"""Get photo statistics for the park."""
|
||||
park_pk = self.kwargs.get("park_pk")
|
||||
park = None
|
||||
if park_pk:
|
||||
try:
|
||||
park = Park.objects.get(pk=park_pk)
|
||||
except Park.DoesNotExist:
|
||||
return Response(
|
||||
{"error": "Park not found."},
|
||||
status=status.HTTP_404_NOT_FOUND,
|
||||
)
|
||||
|
||||
try:
|
||||
if park is not None:
|
||||
stats = ParkMediaService().get_photo_stats(park=park)
|
||||
else:
|
||||
stats = ParkMediaService().get_photo_stats(park=cast(Park, None))
|
||||
serializer = ParkPhotoStatsOutputSerializer(stats)
|
||||
|
||||
return Response(serializer.data, status=status.HTTP_200_OK)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error getting park photo stats: {e}")
|
||||
return Response(
|
||||
{"error": f"Failed to get photo statistics: {str(e)}"},
|
||||
status=status.HTTP_500_INTERNAL_SERVER_ERROR,
|
||||
)
|
||||
|
||||
# Legacy compatibility action using the legacy set_primary logic
|
||||
@extend_schema(
|
||||
summary="Set photo as primary (legacy)",
|
||||
description="Legacy set primary action for backwards compatibility",
|
||||
responses={
|
||||
200: OpenApiTypes.OBJECT,
|
||||
400: OpenApiTypes.OBJECT,
|
||||
403: OpenApiTypes.OBJECT,
|
||||
},
|
||||
tags=["Park Media"],
|
||||
)
|
||||
@action(detail=True, methods=["post"])
|
||||
def set_primary_legacy(self, request, id=None):
|
||||
"""Legacy set primary action for backwards compatibility."""
|
||||
photo = self.get_object()
|
||||
if not (
|
||||
request.user == photo.uploaded_by
|
||||
@@ -110,7 +364,9 @@ class ParkPhotoViewSet(ModelViewSet):
|
||||
status=status.HTTP_403_FORBIDDEN,
|
||||
)
|
||||
try:
|
||||
ParkMediaService.set_primary_photo(photo.park, photo)
|
||||
ParkMediaService().set_primary_photo(
|
||||
park_id=photo.park_id, photo_id=photo.id
|
||||
)
|
||||
return Response({"message": "Photo set as primary successfully."})
|
||||
except Exception as e:
|
||||
logger.error(f"Error in set_primary_photo: {str(e)}", exc_info=True)
|
||||
|
||||
Reference in New Issue
Block a user