Solution1

db/models.py

@@ -1,7 +1,8 @@
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.contrib.auth.models import AbstractUser
-from django.conf import settings
+from django.contrib.auth import get_user_model
+
 
 class Genre(models.Model):
  name = models.CharField(max_length=255)
@@ -43,13 +44,18 @@ class MovieSession(models.Model):
  cinema_hall = models.ForeignKey(CinemaHall, on_delete=models.CASCADE)
 
  def __str__(self) -> str:
- return f"{self.movie.title} {str(self.show_time)}"
+ show_time_str = self.show_time.strftime('%Y-%m-%d %H:%M:%S')
+ return f"{self.movie.title} {show_time_str}"
+
+
+class User(AbstractUser):
+ pass
 
 
 class Order(models.Model):
  created_at = models.DateTimeField(auto_now_add=True)
  user = models.ForeignKey(
- settings.AUTH_USER_MODEL,
+ get_user_model(),
  on_delete=models.CASCADE,
  related_name="orders"
  )
@@ -67,14 +73,6 @@ class Ticket(models.Model):
  row = models.IntegerField()
  seat = models.IntegerField()
 
- class Meta:
- constraints = [
- models.UniqueConstraint(
- fields=["row", "seat", "movie_session"],
- name="unique_movie_session"
- )
- ]
-
  def __str__(self) -> str:
  return (
  f"{self.movie_session.movie.title} "
@@ -86,28 +84,30 @@ def clean(self) -> None:
  if not 1 <= self.row <= self.movie_session.cinema_hall.rows:
  raise ValidationError(
  {
- "row": "row number must be in available range: (1, rows): "
- f"(1, {self.movie_session.cinema_hall.rows})"
+ "row": (
+ f"Row number must be in available range: "
+ f"(1, {self.movie_session.cinema_hall.rows})"
+ )
  }
  )
  if not 1 <= self.seat <= self.movie_session.cinema_hall.seats_in_row:
  raise ValidationError(
  {
- "seat": "seat number must be in available range: "
- "(1, seats_in_row): "
- f"(1, {self.movie_session.cinema_hall.seats_in_row})"
+ "seat": (
+ f"Seat number must be in available range: "
+ f"(1, {self.movie_session.cinema_hall.seats_in_row})"
+ )
  }
  )
 
  def save(self, *args, **kwargs) -> None:
  self.full_clean()
  super().save(*args, **kwargs)
 
-
-class User(AbstractUser):
- groups = models.ManyToManyField(
- "auth.Group", related_name="custom_user_set", blank=True
- )
- user_permissions = models.ManyToManyField(
- "auth.Permission", related_name="custom_user_permissions", blank=True
- )
+ class Meta:
+ constraints = [
+ models.UniqueConstraint(
+ fields=["row", "seat", "movie_session"],
+ name="unique_ticket_for_movie_session"
+ )
+ ]

services/movie.py

@@ -1,28 +1,37 @@
 from django.db.models import QuerySet
 from django.db import transaction
 from db.models import Movie
+from typing import List, Optional
 
 def get_movies(
- genres_ids: list[int] = None,
- actors_ids: list[int] = None,
- title: str = None
+ genres_ids: Optional[List[int]] = None,
+ actors_ids: Optional[List[int]] = None,
+ title: Optional[str] = None
 ) -> QuerySet:
  queryset = Movie.objects.all()
 
- if title:
- queryset = queryset.filter(title__icontains=title)
  if genres_ids:
- queryset = queryset.filter(genres__id__in=genres_ids)
+ queryset = queryset.filter(genres__id__in=genres_ids).distinct()
+
  if actors_ids:
- queryset = queryset.filter(actors__id__in=actors_ids)
+ queryset = queryset.filter(actors__id__in=actors_ids).distinct()
+
+ if title:
+ queryset = queryset.filter(title__icontains=title)
 
  return queryset
 
+def get_movie_by_id(movie_id: int) -> Optional[Movie]:
+ try:
+ return Movie.objects.get(id=movie_id)
+ except Movie.DoesNotExist:
+ return None
+
 def create_movie(
  movie_title: str,
  movie_description: str,
- genres_ids: list = None,
- actors_ids: list = None
+ genres_ids: Optional[List[int]] = None,
+ actors_ids: Optional[List[int]] = None
 ) -> Movie:
  with transaction.atomic():
  movie = Movie.objects.create(

services/movie_session.py

@@ -1,32 +1,50 @@
-from django.db import transaction
-from db.models import Ticket, MovieSession, Movie, CinemaHall
-from datetime import datetime
-from django.core.exceptions import ValidationError, ObjectDoesNotExist
+from django.db.models import QuerySet
+from db.models import MovieSession
+from typing import List, Dict
+
+
+def create_movie_session(
+ movie_show_time: str,
+ movie_id: int,
+ cinema_hall_id: int
+) -> MovieSession:
+ return MovieSession.objects.create(
+ show_time=movie_show_time,
+ movie_id=movie_id,
+ cinema_hall_id=cinema_hall_id
+ )
 
-def create_movie_session(movie: Movie, show_time: datetime, cinema_hall: CinemaHall) -> MovieSession:
- movie_session = MovieSession(movie=movie, show_time=show_time, cinema_hall=cinema_hall)
- movie_session.save()
- return movie_session
 
-def update_movie_session(session_id: int, new_movie: Movie = None, new_show_time: datetime = None, new_cinema_hall: CinemaHall = None) -> MovieSession:
- try:
-  movie_session = MovieSession.objects.get(id=session_id)
- except ObjectDoesNotExist:
-  raise ValidationError(f"Movie session with ID {session_id} does not exist.")
+def get_movies_sessions(session_date: str = None) -> QuerySet[MovieSession]:
+ queryset = MovieSession.objects.all()
+ if session_date:
+  queryset = queryset.filter(show_time__date=session_date)
+ return queryset
 
- if new_movie:
- movie_session.movie = new_movie
- if new_show_time:
- movie_session.show_time = new_show_time
- if new_cinema_hall:
- movie_session.cinema_hall = new_cinema_hall
 
+def get_movie_session_by_id(movie_session_id: int) -> MovieSession:
+ return MovieSession.objects.get(id=movie_session_id)
+
+
+def update_movie_session(
+ session_id: int,
+ movie_show_time: str,
+ movie_id: int,
+ cinema_hall_id: int
+) -> MovieSession:
+ movie_session = get_movie_session_by_id(session_id)
+ movie_session.show_time = movie_show_time
+ movie_session.movie_id = movie_id
+ movie_session.cinema_hall_id = cinema_hall_id
  movie_session.save()
  return movie_session
 
+
 def delete_movie_session_by_id(session_id: int) -> None:
- MovieSession.objects.filter(id=session_id).delete()
+ MovieSession.objects.get(id=session_id).delete()
+
 
-def get_taken_seats(movie_session_id: int) -> list[dict]:
- all_taken_tickets = Ticket.objects.filter(movie_session__id=movie_session_id)
- return [{"row": ticket.row, "seat": ticket.seat} for ticket in all_taken_tickets]
+def get_taken_seats(movie_session_id: int) -> List[Dict[str, int]]:
+ movie_session = MovieSession.objects.get(id=movie_session_id)
+ taken_seats = movie_session.ticket_set.values_list("row", "seat")
+ return [{"row": row, "seat": seat} for row, seat in taken_seats]

services/order.py

@@ -1,29 +1,35 @@
 from django.db import transaction
 from django.db.models import QuerySet
 from django.contrib.auth import get_user_model
+
 from db.models import Order, Ticket
 
-def create_order(tickets: list[dict], username: str, date: str = None) -> Order:
- user = get_user_model().objects.get(username=username)
 
+User = get_user_model()
+
+
+def create_order(tickets: list[dict], username: str, date: str = None) -> None:
  with transaction.atomic():
+ user = get_user_model().objects.get(username=username)
+
  order = Order.objects.create(user=user)
 
  if date:
  order.created_at = date
- order.save(update_fields=["created_at"])
+
+ order.save()
 
  for ticket in tickets:
  Ticket.objects.create(
  order=order,
- movie_session_id=ticket["movie_session"],
  row=ticket["row"],
- seat=ticket["seat"]
+ seat=ticket["seat"],
+ movie_session_id=ticket["movie_session"]
  )
 
- return order
 
-def get_orders(username: str = None) -> QuerySet:
+def get_orders(username: str = None) -> QuerySet[Order]:
  if username:
- return Order.objects.filter(user__username=username)
- return Order.objects.all()
+ user = User.objects.get(username=username)
+ return Order.objects.filter(user=user).order_by("id")
+ return Order.objects.all().order_by("-created_at", "id")

services/user.py

@@ -1,36 +1,50 @@
 from django.contrib.auth import get_user_model
-from django.contrib.auth.models import User
+from typing import Optional
 
-def create_user(username: str, password: str, email: str = None, first_name: str = None, last_name: str = None) -> User:
- user = get_user_model().objects.create_user(username=username, password=password)
+User = get_user_model()
 
+
+def create_user(
+ username: str,
+ password: str,
+ email: Optional[str] = None, first_name: Optional[str] = None,
+ last_name: Optional[str] = None
+) -> User:
+ user = User.objects.create_user(
+ username=username,
+ password=password)
  if email:
  user.email = email
  if first_name:
  user.first_name = first_name
  if last_name:
  user.last_name = last_name
-
- user.set_password(password)
  user.save()
-
  return user
 
-def get_user(user_id: int) -> User:
- return get_user_model().objects.get(pk=user_id)
 
-def update_user(user_id: int, username: str = None, password: str = None, email: str = None, first_name: str = None, last_name: str = None) -> None:
- user = get_user(user_id)
+def get_user(user_id: int) -> Optional[User]:
+ return User.objects.get(id=user_id)
+
 
+def update_user(
+ user_id: int,
+ username: Optional[str] = None,
+ password: Optional[str] = None,
+ email: Optional[str] = None,
+ first_name: Optional[str] = None,
+ last_name: Optional[str] = None
+) -> User:
+ user = get_user(user_id)
  if username:
  user.username = username
+ if password:
+ user.set_password(password)
  if email:
  user.email = email
  if first_name:
  user.first_name = first_name
  if last_name:
  user.last_name = last_name
- if password:
- user.set_password(password)
-
  user.save()
+ return user