task done

cinema/models.py

@@ -1,3 +1,5 @@
+from typing import Callable
+
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.conf import settings
@@ -12,26 +14,26 @@ class CinemaHall(models.Model):
     def capacity(self) -> int:
         return self.rows * self.seats_in_row
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
 
 class Genre(models.Model):
     name = models.CharField(max_length=255, unique=True)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.name
 
 
 class Actor(models.Model):
     first_name = models.CharField(max_length=255)
     last_name = models.CharField(max_length=255)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.first_name + " " + self.last_name
 
     @property
-    def full_name(self):
+    def full_name(self) -> str:
         return f"{self.first_name} {self.last_name}"
 
 
@@ -45,7 +47,7 @@ class Movie(models.Model):
     class Meta:
         ordering = ["title"]
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.title
 
 
@@ -57,7 +59,7 @@ class MovieSession(models.Model):
     class Meta:
         ordering = ["-show_time"]
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.movie.title + " " + str(self.show_time)
 
 
@@ -67,7 +69,7 @@ class Order(models.Model):
         settings.AUTH_USER_MODEL, on_delete=models.CASCADE
     )
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.created_at)
 
     class Meta:
@@ -84,24 +86,41 @@ class Ticket(models.Model):
     row = models.IntegerField()
     seat = models.IntegerField()
 
-    def clean(self):
+    @staticmethod
+    def validate_ticket(
+            row: int,
+            seat: int,
+            cinema_hall: CinemaHall,
+            error: Callable
+    ):
         for ticket_attr_value, ticket_attr_name, cinema_hall_attr_name in [
-            (self.row, "row", "rows"),
-            (self.seat, "seat", "seats_in_row"),
+            (row, "row", "rows"),
+            (seat, "seat", "seats_in_row"),
         ]:
             count_attrs = getattr(
-                self.movie_session.cinema_hall, cinema_hall_attr_name
+                cinema_hall, cinema_hall_attr_name
             )
             if not (1 <= ticket_attr_value <= count_attrs):
-                raise ValidationError(
+                raise error(
                     {
-                        ticket_attr_name: f"{ticket_attr_name} "
-                        f"number must be in available range: "
-                        f"(1, {cinema_hall_attr_name}): "
-                        f"(1, {count_attrs})"
+                        ticket_attr_name: (
+                            f"{ticket_attr_name} "
+                            f"number must be "
+                            f"in available range: "
+                            f"(1, {cinema_hall_attr_name}): "
+                            f"(1, {count_attrs})"
+                        )
                     }
                 )
 
+    def clean(self):
+        Ticket.validate_ticket(
+            self.row,
+            self.seat,
+            self.movie_session.cinema_hall,
+            ValidationError
+        )
+
     def save(
         self,
         force_insert=False,
@@ -114,7 +133,7 @@ def save(
             force_insert, force_update, using, update_fields
         )
 
-    def __str__(self):
+    def __str__(self) -> str:
         return (
             f"{str(self.movie_session)} (row: {self.row}, seat: {self.seat})"
         )

cinema/pagination.py

@@ -0,0 +1,7 @@
+from rest_framework.pagination import PageNumberPagination
+
+
+class OrderSetPagination(PageNumberPagination):
+    page_size = 1
+    page_query_param = "page_size"
+    max_page_size = 20

cinema/serializers.py

@@ -1,6 +1,16 @@
+from django.db import transaction
 from rest_framework import serializers
+from rest_framework.exceptions import ValidationError
 
-from cinema.models import Genre, Actor, CinemaHall, Movie, MovieSession
+from cinema.models import (
+    Genre,
+    Actor,
+    CinemaHall,
+    Movie,
+    MovieSession,
+    Order,
+    Ticket
+)
 
 
 class GenreSerializer(serializers.ModelSerializer):
@@ -59,6 +69,9 @@ class MovieSessionListSerializer(MovieSessionSerializer):
     cinema_hall_capacity = serializers.IntegerField(
         source="cinema_hall.capacity", read_only=True
     )
+    tickets_available = serializers.IntegerField(
+        read_only=True
+    )
 
     class Meta:
         model = MovieSession
@@ -68,13 +81,75 @@ class Meta:
             "movie_title",
             "cinema_hall_name",
             "cinema_hall_capacity",
+            "tickets_available"
         )
 
 
+class TicketRowAndSeatSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Ticket
+        fields = ("row", "seat")
+
+
 class MovieSessionDetailSerializer(MovieSessionSerializer):
     movie = MovieListSerializer(many=False, read_only=True)
     cinema_hall = CinemaHallSerializer(many=False, read_only=True)
+    taken_places = TicketRowAndSeatSerializer(
+        many=True,
+        read_only=True,
+        source="tickets"
+    )
 
     class Meta:
         model = MovieSession
-        fields = ("id", "show_time", "movie", "cinema_hall")
+        fields = ("id", "show_time", "movie", "cinema_hall", "taken_places")
+
+
+class TicketSerializer(serializers.ModelSerializer):
+    movie_session = MovieSessionListSerializer()
+
+    class Meta:
+        model = Ticket
+        fields = ("id", "row", "seat", "movie_session")
+
+    def validate(self, attrs: dict) -> dict:
+        Ticket.validate_ticket(
+            attrs["row"],
+            attrs["seat"],
+            attrs["movie_session"].cinema_hall,
+            ValidationError
+        )
+        return attrs
+
+
+class TicketCreateSerializer(TicketSerializer):
+    movie_session = serializers.PrimaryKeyRelatedField(
+        queryset=MovieSession.objects.all()
+    )
+
+
+class OrderSerializer(serializers.ModelSerializer):
+    tickets = TicketCreateSerializer(
+        many=True,
+        read_only=False,
+        allow_empty=False
+    )
+
+    class Meta:
+        model = Order
+        fields = ("id", "created_at", "tickets")
+
+    def create(self, validated_data: dict):
+        with transaction.atomic():
+            tickets_data = validated_data.pop("tickets")
+            order = Order.objects.create(**validated_data)
+            for ticket_data in tickets_data:
+                Ticket.objects.create(order=order, **ticket_data)
+
+
+class OrderRetrieveSerializer(OrderSerializer):
+    tickets = TicketSerializer(many=True, read_only=True)
+
+    class Meta:
+        model = Order
+        fields = ("id", "created_at", "tickets")

cinema/urls.py

@@ -7,14 +7,20 @@
     CinemaHallViewSet,
     MovieViewSet,
     MovieSessionViewSet,
+    OrderViewSet
 )
 
 router = routers.DefaultRouter()
-router.register("genres", GenreViewSet)
-router.register("actors", ActorViewSet)
-router.register("cinema_halls", CinemaHallViewSet)
-router.register("movies", MovieViewSet)
-router.register("movie_sessions", MovieSessionViewSet)
+router.register("genres", GenreViewSet, basename="genre")
+router.register("actors", ActorViewSet, basename="actor")
+router.register("cinema_halls", CinemaHallViewSet, basename="cinema_hall")
+router.register("movies", MovieViewSet, basename="movie")
+router.register(
+    "movie_sessions",
+    MovieSessionViewSet,
+    basename="movie_session"
+)
+router.register("orders", OrderViewSet, basename="order")
 
 urlpatterns = [path("", include(router.urls))]
 

cinema/views.py

@@ -1,7 +1,9 @@
+from django.db.models import Count, F, QuerySet
 from rest_framework import viewsets
+from rest_framework.serializers import ModelSerializer
 
-from cinema.models import Genre, Actor, CinemaHall, Movie, MovieSession
-
+from cinema.models import Genre, Actor, CinemaHall, Movie, MovieSession, Order
+from cinema.pagination import OrderSetPagination
 from cinema.serializers import (
     GenreSerializer,
     ActorSerializer,
@@ -12,6 +14,8 @@
     MovieDetailSerializer,
     MovieSessionDetailSerializer,
     MovieListSerializer,
+    OrderSerializer,
+    OrderRetrieveSerializer,
 )
 
 
@@ -34,7 +38,35 @@ class MovieViewSet(viewsets.ModelViewSet):
     queryset = Movie.objects.all()
     serializer_class = MovieSerializer
 
-    def get_serializer_class(self):
+    @staticmethod
+    def _params_to_ints(query_string: str) -> queryset:
+        return [int(str_id) for str_id in query_string.split(",")]
+
+    def get_queryset(self):
+        queryset = self.queryset
+
+        if self.action == "list":
+            actors = self.request.query_params.get("actors")
+            genres = self.request.query_params.get("genres")
+            titles = self.request.query_params.get("title")
+
+            if actors:
+                actors = self._params_to_ints(actors)
+                queryset = queryset.filter(actors__id__in=actors)
+            elif genres:
+                genres = self._params_to_ints(genres)
+                queryset = queryset.filter(genres__id__in=genres)
+            elif titles:
+                queryset = queryset.filter(title__icontains=titles)
+
+        if self.action in ("list", "retrieve"):
+            queryset = queryset.prefetch_related(
+                "genres",
+                "actors"
+            )
+        return queryset.distinct()
+
+    def get_serializer_class(self) -> ModelSerializer:
         if self.action == "list":
             return MovieListSerializer
 
@@ -48,11 +80,62 @@ class MovieSessionViewSet(viewsets.ModelViewSet):
     queryset = MovieSession.objects.all()
     serializer_class = MovieSessionSerializer
 
-    def get_serializer_class(self):
+    def get_queryset(self) -> queryset:
+        queryset = super().get_queryset()
+        if self.action == "list":
+            date = self.request.query_params.get("date")
+            movie = self.request.query_params.get("movie")
+
+            if date:
+                queryset = queryset.filter(show_time__date=date)
+            if movie:
+                queryset = queryset.filter(movie_id=movie)
+
+            queryset = (
+                queryset
+                .select_related("movie", "cinema_hall")
+                .prefetch_related("tickets")
+                .annotate(
+                    capacity=(F("cinema_hall__rows")
+                              * F("cinema_hall__seats_in_row")),
+                    tickets_available=F("capacity") - Count("tickets"))
+            )
+        elif self.action == "retrieve":
+            queryset = (
+                queryset
+                .select_related("movie", "cinema_hall")
+                .prefetch_related("tickets")
+            )
+
+        return queryset
+
+    def get_serializer_class(self) -> ModelSerializer:
         if self.action == "list":
             return MovieSessionListSerializer
 
         if self.action == "retrieve":
             return MovieSessionDetailSerializer
 
         return MovieSessionSerializer
+
+
+class OrderViewSet(viewsets.ModelViewSet):
+    pagination_class = OrderSetPagination
+
+    def get_queryset(self) -> QuerySet:
+        queryset = Order.objects.filter(user=self.request.user)
+
+        if self.action == "list":
+            queryset = queryset.prefetch_related(
+                "tickets__movie_session__movie",
+                "tickets__movie_session__cinema_hall"
+            )
+        return queryset
+
+    def get_serializer_class(self) -> ModelSerializer:
+        if self.action in ("list", "retrieve"):
+            return OrderRetrieveSerializer
+        return OrderSerializer
+
+    def perform_create(self, serializer):
+        serializer.save(user=self.request.user)

cinema_service/settings.py

@@ -124,7 +124,7 @@
 
 USE_I18N = True
 
-USE_TZ = False
+USE_TZ = True
 
 
 # Static files (CSS, JavaScript, Images)