Merge pull request 'reorganize-viewsets' (#12) from reorganize-viewsets into main

Reviewed-on: #12

.env.example

@@ -11,5 +11,10 @@ DATABASE_HOST=movienight-db
 DATABASE_NAME=movienight
 DATABASE_USERNAME=admin
 DATABASE_PASSWORD=super_secret_password
+
+# Django key generator: https://djecrety.ir/
 SECRET_KEY=your_django_secret_key
 DJANGO_SECRET_KEY=your_django_secret_key
+
+# You can get a free key here: https://www.omdbapi.com/apikey.aspx
+OMDB_API_KEY=your_omdb_api_key

.idea/dictionaries/project.xml

@@ -0,0 +1,8 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="project">
+    <words>
+      <w>mpaa</w>
+      <w>viewset</w>
+    </words>
+  </dictionary>
+</component>

.idea/misc.xml

@@ -3,7 +3,9 @@
   <component name="Black">
     <option name="enabledOnReformat" value="true" />
     <option name="enabledOnSave" value="true" />
-    <option name="sdkName" value="Python 3.13 (api)" />
+    <option name="executionMode" value="BINARY" />
+    <option name="pathToExecutable" value="$USER_HOME$/.local/bin/black" />
+    <option name="sdkName" value="Python 3.13 virtualenv at ~/Projects/MovieNight/movie-night-api/.venv" />
   </component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 (api)" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 virtualenv at ~/Projects/MovieNight/movie-night-api/.venv" project-jdk-type="Python SDK" />
 </project>

.idea/movie-night-py.iml

@@ -17,7 +17,7 @@
       <excludeFolder url="file://$MODULE_DIR$/.venv" />
       <excludeFolder url="file://$MODULE_DIR$/.venv1" />
     </content>
-    <orderEntry type="jdk" jdkName="Python 3.13 (api)" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="Python 3.13 virtualenv at ~/Projects/MovieNight/movie-night-api/.venv" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
   <component name="PyDocumentationSettings">

Dockerfile

@@ -35,4 +35,4 @@ USER web
 
 EXPOSE 8000
 
-CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "3", "movienight.wsgi:application"]
+CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

movie_db/db_providers/omdb.py

@@ -1,5 +1,7 @@
 import os
 
+from django.conf import settings
+
 from movie_db.movie_db import MovieDB
 import requests
 
@@ -8,8 +10,7 @@ from movie_db.serializers import MovieSerializer, MovieResultSerializer
 
 class OMDb(MovieDB):
     def __init__(self):
-        api_key = os.getenv("OMDB_API_KEY")
+        self.api_key = settings.OMDB_API_KEY
-        self.api_key = f"{api_key}"
         self.base_url = "https://www.omdbapi.com/?apikey=" + self.api_key
         super().__init__()
 

movie_db/views.py

@@ -9,4 +9,17 @@ def omdb_search(request):
 
     search_type = request.GET.get("type")
     omdb = OMDb()
-    return JsonResponse(omdb.search(query, {"type": search_type}), safe=False)
+
+    results = omdb.search(query, {"type": search_type})
+    if "error" in results:
+        return parse_error(results)
+
+    return JsonResponse(results, safe=False)
+
+
+def parse_error(results):
+    error_json = results["error"]
+    if "Error" in error_json and error_json["Error"] == "Movie not found!":
+        return JsonResponse({}, status=404)
+    else:
+        return JsonResponse("Error while searching for movie.", status=500)

movie_manager/admin.py

@@ -6,19 +6,19 @@ from movie_manager.models import Movie, MovieList, Schedule, Showing
 # Register your models here.
 @admin.register(Movie)
 class MovieAdmin(admin.ModelAdmin):
-    pass
+    list_display = ["title", "imdb_id", "added_by"]
 
 
 @admin.register(MovieList)
 class MovieListAdmin(admin.ModelAdmin):
-    pass
+    list_display = ["name", "owner"]
 
 
 @admin.register(Schedule)
 class ScheduleAdmin(admin.ModelAdmin):
-    pass
+    list_display = ["name", "owner"]
 
 
 @admin.register(Showing)
 class ShowingAdmin(admin.ModelAdmin):
-    pass
+    list_display = ["showtime", "movie"]

movie_manager/permissions.py

@@ -0,0 +1,6 @@
+from rest_framework import permissions
+from rest_framework.permissions import SAFE_METHODS
+
+class ReadOnly(permissions.BasePermission):
+    def has_permission(self, request, view):
+        return request.method in SAFE_METHODS

movie_manager/serializers.py

@@ -5,21 +5,55 @@ from movie_manager.models import Movie, MovieList, Schedule, Showing
 
 
 class MovieSerializer(serializers.ModelSerializer):
+    has_been_scheduled = serializers.SerializerMethodField()
+
     class Meta:
         model = Movie
-        fields = "__all__"
+        fields = [
+            "id",
+            "title",
+            "imdb_id",
+            "year",
+            "director",
+            "actors",
+            "plot",
+            "genre",
+            "mpaa_rating",
+            "critic_scores",
+            "poster",
+            "added_by_id",
+            "has_been_scheduled",
+        ]
 
+    def get_has_been_scheduled(self, obj):
+        return Showing.objects.filter(movie_id=obj.id).exists()
 
-class MovieListSerializer(serializers.ModelSerializer):
+class MovieListListSerializer(serializers.ModelSerializer):
     movie_count = serializers.SerializerMethodField()
-    movies = MovieSerializer(read_only=True, many=True)
 
     class Meta:
         model = MovieList
-        fields = ["id", "name", "owner", "public", "movies", "movie_count"]
+        fields = ["id", "name", "owner", "public", "movie_count"]
 
     def get_movie_count(self, obj):
-        return len(obj.movies.all())
+        return obj.movies.count()
+
+
+class MovieListSerializer(serializers.ModelSerializer):
+    movies = MovieSerializer(read_only=True, many=True)
+    serializer_class = MovieSerializer
+    owner = serializers.PrimaryKeyRelatedField(read_only=True)
+
+    def get_queryset(self):
+        return MovieList.objects.prefetch_related(
+            "movies",
+            "movies__showing_set"
+        )
+
+    class Meta:
+        model = MovieList
+        fields = ["id", "name", "owner", "public", "movies"]
+
 
 
 class UserSerializer(serializers.Serializer):

movie_manager/views.py

@@ -1,203 +0,0 @@
-import datetime
-import json
-
-from django.http import JsonResponse
-from django.contrib.auth.models import User
-from django.utils.dateparse import parse_datetime
-from rest_framework import permissions, viewsets
-from knox.auth import TokenAuthentication
-from rest_framework.decorators import action, api_view
-from rest_framework.exceptions import NotFound
-from rest_framework.permissions import AllowAny, SAFE_METHODS
-
-from movie_db.db_providers.omdb import OMDb
-from movie_manager.models import Movie, MovieList, Schedule, Showing
-from movie_manager.serializers import (
-    MovieListSerializer,
-    MovieSerializer,
-    ScheduleSerializer,
-    ShowingSerializer,
-)
-
-
-class ReadOnly(permissions.BasePermission):
-    def has_permission(self, request, view):
-        return request.method in SAFE_METHODS
-
-
-# Create your views here.
-class MovieViewset(viewsets.ModelViewSet):
-    queryset = Movie.objects.all().order_by("title")
-    authentication_classes = [TokenAuthentication]
-    permission_classes = [permissions.IsAuthenticated]
-
-    serializer_class = MovieSerializer
-
-    def update(self, request, pk=None, *args, **kwargs):
-        omdb = OMDb()
-        updated_movie = omdb.search(request.data.get("imdb_id"), {"type": "imdb_id"})
-
-        movie = Movie.objects.get(pk=pk)
-
-        movie.title = updated_movie["title"]
-        movie.actors = updated_movie["actors"]
-        movie.year = updated_movie["year"]
-        movie.critic_scores = updated_movie["critic_scores"]
-        movie.mpaa_rating = updated_movie["mpaa_rating"]
-        movie.director = updated_movie["director"]
-        movie.poster = updated_movie["poster"]
-        movie.plot = updated_movie["plot"]
-        movie.genre = updated_movie["genre"]
-
-        movie.save()
-
-        return JsonResponse(MovieSerializer(movie).data)
-
-
-class MovieListViewset(viewsets.ModelViewSet):
-    queryset = MovieList.objects.all().order_by("name")
-    authentication_classes = [TokenAuthentication]
-    permission_classes = [permissions.IsAuthenticated | ReadOnly]
-
-    serializer_class = MovieListSerializer
-
-    def create(self, request, *args, **kwargs):
-        movie_list = MovieList.objects.create(
-            name=request.data.get("name"),
-            owner=request.user,
-        )
-
-        return JsonResponse(MovieListSerializer(movie_list).data)
-
-    def update(self, request, pk=None, *args, **kwargs):
-        movie_list = MovieList.objects.get(pk=pk)
-        movie_list.name = request.data.get("name")
-        movie_list.owner = User.objects.get(pk=request.data.get("owner"))
-
-        if request.data.get("movies"):
-            movie_ids = request.data.get("movies")
-            for movie_id in movie_ids:
-                try:
-                    movie = Movie.objects.get(pk=movie_id)
-                    movie_list.movies.add(movie)
-                except Movie.DoesNotExist:
-                    raise NotFound(f"Movie {movie_id} does not exist")
-
-            removed_movies = Movie.objects.exclude(id__in=movie_ids)
-            for removed_movie in removed_movies:
-                removed_movie.delete()
-
-        movie_list.save()
-
-        return JsonResponse(MovieListSerializer(movie_list).data)
-
-    @action(
-        detail=True, methods=["put", "delete"], url_path="movie/(?P<imdb_id>tt[0-9]+)"
-    )
-    def add_movie(self, request, pk=None, imdb_id=None, *args, **kwargs):
-        if request.method == "DELETE":
-            return self.remove_movie(request, pk, imdb_id)
-
-        movie_list = MovieList.objects.get(pk=pk)
-        try:
-            new_movie = Movie.objects.get(imdb_id=imdb_id)
-        except Movie.DoesNotExist:
-            omdb = OMDb()
-            movie = omdb.search(imdb_id, {"type": "imdb_id"})
-
-            new_movie = Movie.objects.create(
-                title=movie["title"],
-                actors=movie["actors"],
-                year=movie["year"],
-                imdb_id=movie["imdb_id"],
-                poster=movie["poster"],
-                plot=movie["plot"],
-                genre=movie["genre"],
-                critic_scores=movie["critic_scores"],
-                mpaa_rating=movie["mpaa_rating"],
-                director=movie["director"],
-                added_by_id=request.user.id,
-            )
-
-        movie_list.movies.add(new_movie)
-
-        return JsonResponse(MovieListSerializer(movie_list).data)
-
-    def remove_movie(self, request, pk=None, imdb_id=None, *args, **kwargs):
-        movie = Movie.objects.filter(imdb_id=imdb_id).first()
-
-        movie_list = MovieList.objects.get(pk=pk)
-        movie_list.movies.remove(movie)
-
-        return JsonResponse(MovieListSerializer(movie_list).data)
-
-
-class ScheduleViewset(viewsets.ModelViewSet):
-    queryset = Schedule.objects.all().order_by("name")
-    authentication_classes = [TokenAuthentication]
-    permission_classes = [permissions.IsAuthenticated | ReadOnly]
-
-    serializer_class = ScheduleSerializer
-
-    def retrieve(self, request, pk=None, *args, **kwargs):
-        # Get the schedule instance
-        instance = self.get_object()
-        today = datetime.datetime.now()
-
-        upcoming_showings = Showing.objects.filter(
-            showtime__gte=today, schedule=instance
-        )
-
-        # Create a serialized response
-        serializer = self.get_serializer(instance)
-        data = serializer.data
-
-        # Replace all showings with only future showings
-        data["showings"] = ShowingSerializer(upcoming_showings, many=True).data
-
-        if request.GET.get("past_showings") == "true":
-            past_showings = Showing.objects.filter(
-                showtime__lt=today, schedule=instance
-            )
-
-            # Add both to the response
-            data["past_showings"] = [
-                {
-                    "id": showing.id,
-                    "showtime": showing.showtime.isoformat(),
-                    "movie": MovieSerializer(showing.movie).data,
-                }
-                for showing in past_showings
-            ]
-        else:
-            data["past_showings"] = []
-
-        return JsonResponse(data)
-
-
-class ShowingViewset(viewsets.ModelViewSet):
-    queryset = Showing.objects.all().order_by("showtime")
-    authentication_classes = [TokenAuthentication]
-    permission_classes = [permissions.IsAuthenticated | ReadOnly]
-
-    serializer_class = ShowingSerializer
-
-    def create(self, request, *args, **kwargs):
-        movie_id = request.data.get("movie")
-        movie = Movie.objects.get(pk=movie_id)
-
-        schedule_id = request.data.get("schedule")
-        schedule = Schedule.objects.get(pk=schedule_id)
-
-        showtime_str = request.data.get("showtime")
-        showtime = parse_datetime(showtime_str)
-
-        showing = Showing.objects.create(
-            movie=movie,
-            schedule=schedule,
-            showtime=showtime,
-            public=request.data.get("public"),
-            owner=request.user,
-        )
-
-        return JsonResponse(ShowingSerializer(showing).data)

movie_manager/viewsets/__init__.py

@@ -0,0 +1,11 @@
+from .movie import MovieViewset
+from .movie_list import MovieListViewset
+from .schedule import ScheduleViewset
+from .showing import ShowingViewset
+
+__all__ = [
+    "MovieViewset",
+    "MovieListViewset",
+    "ScheduleViewset",
+    "ShowingViewset",
+]

movie_manager/viewsets/movie.py

@@ -0,0 +1,37 @@
+from django.http import JsonResponse
+from rest_framework import permissions, viewsets
+
+from movie_db.db_providers.omdb import OMDb
+from movie_manager.models import Movie
+
+from knox.auth import TokenAuthentication
+
+from movie_manager.serializers import MovieSerializer
+
+
+class MovieViewset(viewsets.ModelViewSet):
+    queryset = Movie.objects.all().order_by("title")
+    authentication_classes = [TokenAuthentication]
+    permission_classes = [permissions.IsAuthenticated]
+
+    serializer_class = MovieSerializer
+
+    def update(self, request, pk=None, *args, **kwargs):
+        omdb = OMDb()
+        updated_movie = omdb.search(request.data.get("imdb_id"), {"type": "imdb_id"})
+
+        movie = Movie.objects.get(pk=pk)
+
+        movie.title = updated_movie["title"]
+        movie.actors = updated_movie["actors"]
+        movie.year = updated_movie["year"]
+        movie.critic_scores = updated_movie["critic_scores"]
+        movie.mpaa_rating = updated_movie["mpaa_rating"]
+        movie.director = updated_movie["director"]
+        movie.poster = updated_movie["poster"]
+        movie.plot = updated_movie["plot"]
+        movie.genre = updated_movie["genre"]
+
+        movie.save()
+
+        return JsonResponse(MovieSerializer(movie).data)

movie_manager/viewsets/movie_list.py

@@ -0,0 +1,120 @@
+from django.http import JsonResponse
+from django.db import models
+from django.contrib.auth.models import User
+from rest_framework import permissions, viewsets
+from rest_framework.decorators import action
+from rest_framework.exceptions import NotFound
+
+from movie_db.db_providers.omdb import OMDb
+from movie_manager.models import MovieList, Movie
+
+from knox.auth import TokenAuthentication
+
+from movie_manager.permissions import ReadOnly
+from movie_manager.serializers import MovieListSerializer, MovieListListSerializer
+
+
+class MovieListViewset(viewsets.ModelViewSet):
+    queryset = MovieList.objects.all()
+    authentication_classes = [TokenAuthentication]
+    permission_classes = [permissions.IsAuthenticated | ReadOnly]
+
+    def get_serializer_class(self):
+        if self.action == "list":
+            return MovieListListSerializer
+        else:
+            return MovieListSerializer
+
+    def get_queryset(self):
+        base_qs = MovieList.objects.all()
+
+        if self.action == "list":
+            if self.request.user.is_authenticated:
+                return base_qs.filter(
+                    models.Q(public=True) | models.Q(owner=self.request.user)
+                ).order_by("name")
+
+            return base_qs.filter(public=True).order_by("name")
+        else:
+            return MovieList.objects.prefetch_related(
+                "movies", "movies__showing_set"
+            ).order_by("name")
+
+    def perform_create(self, serializer):
+        serializer.save(owner=self.request.user)
+
+    def get_permissions(self):
+        if self.action in ["update", "partial_update", "destroy"]:
+            self.permission_classes = [permissions.IsAuthenticated]
+        return super().get_permissions()
+
+    def create(self, request, *args, **kwargs):
+        movie_list = MovieList.objects.create(
+            name=request.data.get("name"),
+            owner=request.user,
+        )
+
+        return JsonResponse(MovieListSerializer(movie_list).data)
+
+    def update(self, request, pk=None, *args, **kwargs):
+        movie_list = MovieList.objects.get(pk=pk)
+        movie_list.name = request.data.get("name")
+        movie_list.owner = User.objects.get(pk=request.data.get("owner"))
+
+        if request.data.get("movies"):
+            movie_ids = request.data.get("movies")
+            for movie_id in movie_ids:
+                try:
+                    movie = Movie.objects.get(pk=movie_id)
+                    movie_list.movies.add(movie)
+                except Movie.DoesNotExist:
+                    raise NotFound(f"Movie {movie_id} does not exist")
+
+            removed_movies = Movie.objects.exclude(id__in=movie_ids)
+            for removed_movie in removed_movies:
+                removed_movie.delete()
+
+        movie_list.save()
+
+        return JsonResponse(MovieListSerializer(movie_list).data)
+
+    @action(
+        detail=True, methods=["put", "delete"], url_path="movie/(?P<imdb_id>tt[0-9]+)"
+    )
+    def add_movie(self, request, pk=None, imdb_id=None, *args, **kwargs):
+        if request.method == "DELETE":
+            return self.remove_movie(request, pk, imdb_id)
+
+        movie_list = MovieList.objects.get(pk=pk)
+        try:
+            new_movie = Movie.objects.get(imdb_id=imdb_id)
+        except Movie.DoesNotExist:
+            omdb = OMDb()
+            movie = omdb.search(imdb_id, {"type": "imdb_id"})
+
+            new_movie = Movie.objects.create(
+                title=movie["title"],
+                actors=movie["actors"],
+                year=movie["year"],
+                imdb_id=movie["imdb_id"],
+                poster=movie["poster"],
+                plot=movie["plot"],
+                genre=movie["genre"],
+                critic_scores=movie["critic_scores"],
+                mpaa_rating=movie["mpaa_rating"],
+                director=movie["director"],
+                added_by_id=request.user.id,
+            )
+
+        movie_list.movies.add(new_movie)
+
+        return JsonResponse(MovieListSerializer(movie_list).data)
+
+    @staticmethod
+    def remove_movie(request, pk=None, imdb_id=None, *args, **kwargs):
+        movie = Movie.objects.filter(imdb_id=imdb_id).first()
+
+        movie_list = MovieList.objects.get(pk=pk)
+        movie_list.movies.remove(movie)
+
+        return JsonResponse(MovieListSerializer(movie_list).data)

movie_manager/viewsets/schedule.py

@@ -0,0 +1,58 @@
+import datetime
+
+from django.http import JsonResponse
+from knox.auth import TokenAuthentication
+from rest_framework import viewsets, permissions
+
+from movie_manager.models import Schedule, Showing
+from movie_manager.permissions import ReadOnly
+from movie_manager.serializers import (
+    ScheduleSerializer,
+    ShowingSerializer,
+    MovieSerializer,
+)
+
+
+class ScheduleViewset(viewsets.ModelViewSet):
+    queryset = Schedule.objects.all().order_by("name")
+    authentication_classes = [TokenAuthentication]
+    permission_classes = [permissions.IsAuthenticated | ReadOnly]
+
+    serializer_class = ScheduleSerializer
+
+    def retrieve(self, request, pk=None, *args, **kwargs):
+        # Get the schedule instance
+        instance = self.get_object()
+        now = datetime.datetime.now()
+        # get time from start of day
+        today = datetime.datetime(now.year, now.month, now.day)
+
+        upcoming_showings = Showing.objects.filter(
+            showtime__gte=today, schedule=instance
+        )
+
+        # Create a serialized response
+        serializer = self.get_serializer(instance)
+        data = serializer.data
+
+        # Replace all showings with only future showings
+        data["showings"] = ShowingSerializer(upcoming_showings, many=True).data
+
+        if request.GET.get("past_showings") == "true":
+            past_showings = Showing.objects.filter(
+                showtime__lt=today, schedule=instance
+            )
+
+            # Add both to the response
+            data["past_showings"] = [
+                {
+                    "id": showing.id,
+                    "showtime": showing.showtime.isoformat(),
+                    "movie": MovieSerializer(showing.movie).data,
+                }
+                for showing in past_showings
+            ]
+        else:
+            data["past_showings"] = []
+
+        return JsonResponse(data)

movie_manager/viewsets/showing.py

@@ -0,0 +1,36 @@
+from django.http import JsonResponse
+from django.utils.dateparse import parse_datetime
+from knox.auth import TokenAuthentication
+from rest_framework import viewsets, permissions
+
+from movie_manager.models import Showing, Movie, Schedule
+from movie_manager.permissions import ReadOnly
+from movie_manager.serializers import ShowingSerializer
+
+
+class ShowingViewset(viewsets.ModelViewSet):
+    queryset = Showing.objects.all().order_by("showtime")
+    authentication_classes = [TokenAuthentication]
+    permission_classes = [permissions.IsAuthenticated | ReadOnly]
+
+    serializer_class = ShowingSerializer
+
+    def create(self, request, *args, **kwargs):
+        movie_id = request.data.get("movie")
+        movie = Movie.objects.get(pk=movie_id)
+
+        schedule_id = request.data.get("schedule")
+        schedule = Schedule.objects.get(pk=schedule_id)
+
+        showtime_str = request.data.get("showtime")
+        showtime = parse_datetime(showtime_str)
+
+        showing = Showing.objects.create(
+            movie=movie,
+            schedule=schedule,
+            showtime=showtime,
+            public=request.data.get("public"),
+            owner=request.user,
+        )
+
+        return JsonResponse(ShowingSerializer(showing).data)

movienight/settings.py

@@ -126,6 +126,8 @@ USE_I18N = True
 
 USE_TZ = True
 
+OMDB_API_KEY = os.environ.get("OMDB_API_KEY")
+
 # Django Rest Framework
 REST_FRAMEWORK = {
     "DEFAULT_AUTHENTICATION_CLASSES": [

movienight/urls.py

@@ -10,25 +10,33 @@ from django.conf.urls.static import static
 from django.conf import settings
 from rest_framework.routers import DefaultRouter
 
+from movie_manager.viewsets import (
+    MovieViewset,
+    MovieListViewset,
+    ScheduleViewset,
+    ShowingViewset,
+)
 from users import views as user_views
-from movie_manager import views as movie_views
 from movie_db import views as movie_db_views
 from rest_framework.authtoken.views import obtain_auth_token
 
+from users.viewsets.user import register
+from users.viewsets import UserViewSet, GroupViewSet
+
 router = DefaultRouter()
-router.register(r"v1/users", user_views.UserViewSet)
+router.register(r"v1/users", UserViewSet)
-router.register(r"v1/groups", user_views.GroupViewSet)
+router.register(r"v1/groups", GroupViewSet)
-router.register(r"v1/movies", movie_views.MovieViewset)
+router.register(r"v1/movies", MovieViewset)
-router.register(r"v1/lists", movie_views.MovieListViewset)
+router.register(r"v1/lists", MovieListViewset)
-router.register(r"v1/schedules", movie_views.ScheduleViewset)
+router.register(r"v1/schedules", ScheduleViewset)
-router.register(r"v1/showings", movie_views.ShowingViewset)
+router.register(r"v1/showings", ShowingViewset)
 
 urlpatterns = [
     path("", include(router.urls)),
     path("admin/", admin.site.urls),
     path(r"v1/auth/token/", obtain_auth_token),
     path(r"v1/auth/login/", user_views.LoginView.as_view(), name="knox_login"),
-    path(r"v1/auth/register/", user_views.register, name="register"),
+    path(r"v1/auth/register/", register, name="register"),
     path(r"v1/movies/search", movie_db_views.omdb_search, name="omdb_search"),
     path(r"v1/auth/", include("knox.urls")),
 ] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

requirements.txt

@@ -1,4 +1,4 @@
-django==5.1.4
+django==5.2.2
 djangorestframework
 django-rest-knox
 markdown

users/views.py

@@ -1,40 +1,9 @@
 from django.contrib.auth import login
-from django.contrib.auth.models import Group, User, AnonymousUser
+from rest_framework import permissions
-from rest_framework import permissions, viewsets, status
-from knox.auth import TokenAuthentication
 from knox.views import LoginView as KnoxLoginView
 from rest_framework.authtoken.serializers import AuthTokenSerializer
-from rest_framework.response import Response
-from rest_framework.decorators import api_view
 
-from users.serializers import GroupSerializer, UserSerializer
+from users.serializers import UserSerializer
-
-
-class UserViewSet(viewsets.ModelViewSet):
-    authentication_classes = [TokenAuthentication]
-    permission_classes = [permissions.IsAuthenticated]
-
-    queryset = User.objects.all().order_by("-date_joined")
-    serializer_class = UserSerializer
-
-
-class GroupViewSet(viewsets.ModelViewSet):
-    authentication_classes = [TokenAuthentication]
-    permission_classes = [permissions.IsAuthenticated]
-
-    queryset = Group.objects.all().order_by("name")
-    serializer_class = GroupSerializer
-
-
-@api_view(["POST"])
-def register(request):
-    user_data = UserSerializer(data=request.data)
-
-    if user_data.is_valid():
-        User.objects.create_user(**user_data.validated_data)
-        return Response(request.data, status=status.HTTP_201_CREATED)
-    else:
-        return Response([], status=status.HTTP_400_BAD_REQUEST)
 
 
 class LoginView(KnoxLoginView):

users/viewsets/__init__.py

@@ -0,0 +1,4 @@
+from .group import GroupViewSet
+from .user import UserViewSet
+
+__all__ = ["GroupViewSet", "UserViewSet"]

users/viewsets/group.py

@@ -0,0 +1,13 @@
+from knox.auth import TokenAuthentication
+from django.contrib.auth.models import Group
+from rest_framework import viewsets, permissions, status
+
+from users.serializers import GroupSerializer
+
+
+class GroupViewSet(viewsets.ModelViewSet):
+    authentication_classes = [TokenAuthentication]
+    permission_classes = [permissions.IsAuthenticated]
+
+    queryset = Group.objects.all().order_by("name")
+    serializer_class = GroupSerializer

users/viewsets/user.py

@@ -0,0 +1,26 @@
+from django.contrib.auth.models import User, Group
+from knox.auth import TokenAuthentication
+from rest_framework import viewsets, permissions, status
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+
+from users.serializers import UserSerializer, GroupSerializer
+
+
+class UserViewSet(viewsets.ModelViewSet):
+    authentication_classes = [TokenAuthentication]
+    permission_classes = [permissions.IsAuthenticated]
+
+    queryset = User.objects.all().order_by("-date_joined")
+    serializer_class = UserSerializer
+
+
+@api_view(["POST"])
+def register(request):
+    user_data = UserSerializer(data=request.data)
+
+    if user_data.is_valid():
+        User.objects.create_user(**user_data.validated_data)
+        return Response(request.data, status=status.HTTP_201_CREATED)
+    else:
+        return Response([], status=status.HTTP_400_BAD_REQUEST)