removed static files from repo

.env.example

@@ -11,10 +11,5 @@ 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

.gitignore

@@ -173,5 +173,5 @@ cython_debug/
 # PyPI configuration file
 .pypirc
 
-# django
+# Django
 static

.idea/misc.xml

@@ -5,5 +5,5 @@
     <option name="enabledOnSave" value="true" />
     <option name="sdkName" value="Python 3.13 (api)" />
   </component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 virtualenv at ~/Projects/MovieNight/movie-night-api/.venv" project-jdk-type="Python SDK" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 (api)" 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 virtualenv at ~/Projects/MovieNight/movie-night-api/.venv" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="Python 3.13 (api)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
   <component name="PyDocumentationSettings">

Dockerfile

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

docker-compose.yml

@@ -5,18 +5,15 @@ services:
     environment:
       POSTGRES_DB: ${DATABASE_NAME}
       POSTGRES_USER: ${DATABASE_USERNAME}
-      PGUSER: ${DATABASE_USERNAME}
       POSTGRES_PASSWORD: ${DATABASE_PASSWORD}
     env_file:
       - .env
     ports:
       - "5432:5432"
-    user: postgres
     volumes:
       - movienight_data:/var/lib/postgresql/data
-      - ./init-scripts:/docker-entrypoint-initdb.d
     healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U $DATABASE_USERNAME"]
+      test: ["CMD-SHELL", "pg_isready", "-d", "$DATABASE_NAME"]
       interval: 30s
       timeout: 60s
       retries: 5
@@ -43,7 +40,6 @@ services:
       DATABASE_PASSWORD: ${DATABASE_PASSWORD}
       DATABASE_HOST: ${DATABASE_HOST}
       DATABASE_PORT: ${DATABASE_PORT}
-      OMDB_API_KEY: ${OMDB_API_KEY}
     env_file:
       - .env
     volumes:

init-scripts/01-create-db.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-set -e
-
-# Create a postgres database for the user set in the .env file.
-# Everything works fine without this, but this prevents a FATAL
-# error from spamming the logs
-psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" <<-EOSQL
-    CREATE DATABASE "$POSTGRES_USER";
-    GRANT ALL PRIVILEGES ON DATABASE "$POSTGRES_USER" TO "$POSTGRES_USER";
-EOSQL

movie_db/admin.py

@@ -1,3 +0,0 @@
-from django.contrib import admin
-
-# Register your models here.

movie_db/apps.py

@@ -1,6 +0,0 @@
-from django.apps import AppConfig
-
-
-class MoviedbConfig(AppConfig):
-    default_auto_field = 'django.db.models.BigAutoField'
-    name = 'movie_db'

movie_db/db_providers/omdb.py

@@ -1,38 +0,0 @@
-import os
-
-from django.conf import settings
-
-from movie_db.movie_db import MovieDB
-import requests
-
-from movie_db.serializers import MovieSerializer, MovieResultSerializer
-
-
-class OMDb(MovieDB):
-    def __init__(self):
-        self.api_key = settings.OMDB_API_KEY
-        self.base_url = "https://www.omdbapi.com/?apikey=" + self.api_key
-        super().__init__()
-
-    def search(self, query, options=None):
-        if options["type"] == "imdb_id":
-            return self.search_by_imdb_id(query)
-        elif options["type"] == "title":
-            return self.search_by_title(query)
-        else:
-            return self.search_by_term(query)
-
-    def search_by_title(self, title):
-        response = requests.get(self.base_url + "&t=" + title).json()
-        return MovieSerializer(response).data
-
-    def search_by_imdb_id(self, imdb_id):
-        response = requests.get(self.base_url + "&i=" + imdb_id).json()
-        return MovieSerializer(response).data
-
-    def search_by_term(self, term):
-        response = requests.get(self.base_url + "&s=" + term).json()
-        try:
-            return MovieResultSerializer(response["Search"], many=True).data
-        except KeyError:
-            return {"error": response}

movie_db/models.py

@@ -1,3 +0,0 @@
-from django.db import models
-
-# Create your models here.

movie_db/movie_db.py

@@ -1,8 +0,0 @@
-from abc import ABC
-
-class MovieDB(ABC):
-    def __init__(self):
-        pass
-
-    def search(self, query, options=None):
-        pass

movie_db/serializers.py

@@ -1,24 +0,0 @@
-from rest_framework import serializers
-
-
-class MovieSerializer(serializers.Serializer):
-    actors = serializers.CharField(source="Actors")
-    director = serializers.CharField(source="Director")
-    genre = serializers.CharField(source="Genre")
-    imdb_id = serializers.CharField(source="imdbID")
-    critic_scores = serializers.CharField(source="Ratings")
-    mpaa_rating = serializers.CharField(source="Rated")
-    media_type = serializers.CharField(source="Type")
-    plot = serializers.CharField(source="Plot")
-    poster = serializers.CharField(source="Poster")
-    runtime = serializers.CharField(source="Runtime")
-    title = serializers.CharField(source="Title")
-    year = serializers.CharField(source="Year")
-
-
-class MovieResultSerializer(serializers.Serializer):
-    title = serializers.CharField(source="Title")
-    year = serializers.CharField(source="Year")
-    imdb_id = serializers.CharField(source="imdbID")
-    media_type = serializers.CharField(source="Type")
-    poster = serializers.CharField(source="Poster")

movie_db/tests.py

@@ -1,3 +0,0 @@
-from django.test import TestCase
-
-# Create your tests here.

movie_db/views.py

@@ -1,25 +0,0 @@
-from django.http import JsonResponse
-from movie_db.db_providers.omdb import OMDb
-
-
-def omdb_search(request):
-    query = request.GET.get("q")
-    if not query:
-        return JsonResponse({"Error": "Missing query"}, status=400)
-
-    search_type = request.GET.get("type")
-    omdb = OMDb()
-
-    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

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

movie_manager/migrations/0001_initial.py

@@ -1,4 +1,4 @@
-# Generated by Django 5.1.4 on 2025-04-21 00:50
+# Generated by Django 5.1.4 on 2025-03-31 04:04
 
 import django.db.models.deletion
 from django.conf import settings
@@ -20,22 +20,18 @@ class Migration(migrations.Migration):
                 ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                 ('title', models.CharField(max_length=100)),
                 ('imdb_id', models.CharField(max_length=100)),
-                ('year', models.IntegerField(blank=True, null=True)),
-                ('director', models.CharField(blank=True, max_length=500, null=True)),
-                ('actors', models.TextField(blank=True, null=True)),
-                ('plot', models.TextField(blank=True, null=True)),
-                ('genre', models.CharField(blank=True, max_length=100, null=True)),
-                ('mpaa_rating', models.CharField(blank=True, max_length=20, null=True)),
-                ('critic_scores', models.TextField(blank=True, null=True)),
-                ('poster', models.TextField(blank=True, null=True)),
+                ('year', models.IntegerField()),
+                ('critic_score', models.CharField(max_length=500)),
+                ('genre', models.CharField(max_length=100)),
+                ('director', models.CharField(max_length=500)),
+                ('actors', models.CharField(max_length=500)),
+                ('plot', models.CharField(max_length=500)),
+                ('poster', models.CharField(max_length=500)),
+                ('last_watched', models.DateTimeField()),
                 ('created_at', models.DateTimeField(auto_now_add=True)),
                 ('updated_at', models.DateTimeField(auto_now=True)),
                 ('deleted_at', models.DateTimeField(blank=True, null=True)),
-                ('added_by', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, to=settings.AUTH_USER_MODEL)),
             ],
-            options={
-                'ordering': ['title'],
-            },
         ),
         migrations.CreateModel(
             name='MovieList',
@@ -46,40 +42,7 @@ class Migration(migrations.Migration):
                 ('created_at', models.DateTimeField(auto_now_add=True)),
                 ('updated_at', models.DateTimeField(auto_now=True)),
                 ('deleted_at', models.DateTimeField(blank=True, null=True)),
-                ('movies', models.ManyToManyField(to='movie_manager.movie')),
                 ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
             ],
-            options={
-                'ordering': ['name'],
-            },
-        ),
-        migrations.CreateModel(
-            name='Schedule',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('name', models.CharField(max_length=100)),
-                ('public', models.BooleanField(default=False)),
-                ('slug', models.SlugField(default='', max_length=100)),
-                ('created_at', models.DateTimeField(auto_now_add=True)),
-                ('updated_at', models.DateTimeField(auto_now=True)),
-                ('deleted_at', models.DateTimeField(blank=True, null=True)),
-                ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
-            ],
-        ),
-        migrations.CreateModel(
-            name='Showing',
-            fields=[
-                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('public', models.BooleanField(default=False)),
-                ('showtime', models.DateTimeField()),
-                ('created_at', models.DateTimeField(auto_now_add=True)),
-                ('updated_at', models.DateTimeField(auto_now=True)),
-                ('deleted_at', models.DateTimeField(blank=True, null=True)),
-                ('movie', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='movie_manager.movie')),
-                ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
-            ],
-            options={
-                'ordering': ['showtime'],
-            },
         ),
     ]

movie_manager/migrations/0002_alter_movie_options_alter_movielist_options_and_more.py

@@ -0,0 +1,26 @@
+# Generated by Django 5.1.4 on 2025-04-07 05:02
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('movie_manager', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterModelOptions(
+            name='movie',
+            options={'ordering': ['title']},
+        ),
+        migrations.AlterModelOptions(
+            name='movielist',
+            options={'ordering': ['name']},
+        ),
+        migrations.AddField(
+            model_name='movielist',
+            name='movies',
+            field=models.ManyToManyField(to='movie_manager.movie'),
+        ),
+    ]

movie_manager/migrations/0002_showing_schedule.py

@@ -1,20 +0,0 @@
-# Generated by Django 5.1.4 on 2025-04-21 01:01
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('movie_manager', '0001_initial'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='showing',
-            name='schedule',
-            field=models.ForeignKey(default=1, on_delete=django.db.models.deletion.CASCADE, to='movie_manager.schedule'),
-            preserve_default=False,
-        ),
-    ]

movie_manager/migrations/0003_alter_schedule_options.py

@@ -1,17 +0,0 @@
-# Generated by Django 5.1.4 on 2025-04-21 03:36
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('movie_manager', '0002_showing_schedule'),
-    ]
-
-    operations = [
-        migrations.AlterModelOptions(
-            name='schedule',
-            options={'ordering': ['name']},
-        ),
-    ]

movie_manager/migrations/0003_movie_added_by.py

@@ -0,0 +1,22 @@
+# Generated by Django 5.1.4 on 2025-04-08 00:18
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('movie_manager', '0002_alter_movie_options_alter_movielist_options_and_more'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='movie',
+            name='added_by',
+            field=models.ForeignKey(default=1, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL),
+            preserve_default=False,
+        ),
+    ]

movie_manager/migrations/0004_alter_movie_last_watched_showing_schedule.py

@@ -0,0 +1,50 @@
+# Generated by Django 5.1.4 on 2025-04-08 03:39
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('movie_manager', '0003_movie_added_by'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='movie',
+            name='last_watched',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+        migrations.CreateModel(
+            name='Showing',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('public', models.BooleanField(default=False)),
+                ('showtime', models.DateTimeField()),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('deleted_at', models.DateTimeField(blank=True, null=True)),
+                ('movie', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='movie_manager.movie')),
+                ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'ordering': ['showtime'],
+            },
+        ),
+        migrations.CreateModel(
+            name='Schedule',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=100)),
+                ('public', models.BooleanField(default=False)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('deleted_at', models.DateTimeField(blank=True, null=True)),
+                ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
+                ('showings', models.ManyToManyField(to='movie_manager.showing')),
+            ],
+        ),
+    ]

movie_manager/migrations/0005_showing_slug.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.4 on 2025-04-08 03:45
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('movie_manager', '0004_alter_movie_last_watched_showing_schedule'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='showing',
+            name='slug',
+            field=models.SlugField(default='', max_length=100),
+        ),
+    ]

movie_manager/migrations/0006_remove_showing_slug_schedule_slug.py

@@ -0,0 +1,22 @@
+# Generated by Django 5.1.4 on 2025-04-08 04:03
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('movie_manager', '0005_showing_slug'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='showing',
+            name='slug',
+        ),
+        migrations.AddField(
+            model_name='schedule',
+            name='slug',
+            field=models.SlugField(default='', max_length=100),
+        ),
+    ]

movie_manager/models.py

@@ -1,21 +1,18 @@
 from django.db import models
 from django.contrib.auth.models import User
-from django.db.models import SET_NULL
-import datetime
-
 
 class Movie(models.Model):
     title = models.CharField(max_length=100)
     imdb_id = models.CharField(max_length=100)
-    year = models.IntegerField(null=True, blank=True)
-    director = models.CharField(max_length=500, null=True, blank=True)
-    actors = models.TextField(null=True, blank=True)
-    plot = models.TextField(null=True, blank=True)
-    genre = models.CharField(max_length=100, null=True, blank=True)
-    mpaa_rating = models.CharField(max_length=20, null=True, blank=True)
-    critic_scores = models.TextField(null=True, blank=True)
-    poster = models.TextField(null=True, blank=True)
-    added_by = models.ForeignKey(User, on_delete=SET_NULL, null=True)
+    year = models.IntegerField()
+    critic_score = models.CharField(max_length=500)
+    genre = models.CharField(max_length=100)
+    director = models.CharField(max_length=500)
+    actors = models.CharField(max_length=500)
+    plot = models.CharField(max_length=500)
+    poster = models.CharField(max_length=500)
+    last_watched = models.DateTimeField(null=True, blank=True)
+    added_by = models.ForeignKey(User, on_delete=models.CASCADE)
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
     deleted_at = models.DateTimeField(null=True, blank=True)
@@ -42,27 +39,19 @@ class MovieList(models.Model):
     def __str__(self):
         return self.name
 
-
 class Schedule(models.Model):
     name = models.CharField(max_length=100)
     owner = models.ForeignKey(User, on_delete=models.CASCADE)
     public = models.BooleanField(default=False)
+    showings = models.ManyToManyField("Showing")
     slug = models.SlugField(max_length=100, default="")
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
     deleted_at = models.DateTimeField(null=True, blank=True)
 
-    class Meta:
-        ordering = ["name"]
-
-    def __str__(self):
-        return self.name
-
-
 class Showing(models.Model):
     movie = models.ForeignKey(Movie, on_delete=models.CASCADE)
     owner = models.ForeignKey(User, on_delete=models.CASCADE)
-    schedule = models.ForeignKey(Schedule, on_delete=models.CASCADE)
     public = models.BooleanField(default=False)
     showtime = models.DateTimeField()
     created_at = models.DateTimeField(auto_now_add=True)
@@ -71,7 +60,3 @@ class Showing(models.Model):
 
     class Meta:
         ordering = ["showtime"]
-
-    def __str__(self):
-        showtime = self.showtime.strftime("%Y-%m-%d %H:%M")
-        return showtime

movie_manager/serializers.py

@@ -1,60 +1,25 @@
-from django.utils import timezone
 from gunicorn.config import User
 from rest_framework import serializers
 from movie_manager.models import Movie, MovieList, Schedule, Showing
 
 
 class MovieSerializer(serializers.ModelSerializer):
-    has_been_scheduled = serializers.SerializerMethodField()
-
     class Meta:
         model = Movie
-        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 MovieListListSerializer(serializers.ModelSerializer):
-    movie_count = serializers.SerializerMethodField()
-
-    class Meta:
-        model = MovieList
-        fields = ["id", "name", "owner", "public", "movie_count"]
-
-    def get_movie_count(self, obj):
-        return obj.movies.count()
+        fields = '__all__'
 
 
 class MovieListSerializer(serializers.ModelSerializer):
+    movie_count = serializers.SerializerMethodField()
     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"]
+        fields = ["id","name","owner","public", "movies", "movie_count"]
 
 
+    def get_movie_count(self, obj):
+        return len(obj.movies.all())
 
 class UserSerializer(serializers.Serializer):
     class Meta:
@@ -67,23 +32,14 @@ class ShowingSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = Showing
-        fields = ["id", "public", "showtime", "movie", "owner"]
-
-    def to_internal_value(self, data):
-        validated_data = super().to_internal_value(data)
-
-        if "showtime" in validated_data and timezone.is_naive(
-            validated_data["showtime"]
-        ):
-            validated_data["showtime"] = timezone.make_aware(validated_data["showtime"])
-
-        return validated_data
+        fields = ["public", "showtime", "movie", "owner"]
 
 
 class ScheduleSerializer(serializers.ModelSerializer):
     name = serializers.CharField(read_only=True)
-    showings = ShowingSerializer(source="showing_set", read_only=True, many=True)
+    showings = ShowingSerializer(read_only=True, many=True)
 
     class Meta:
         model = Schedule
         fields = ["name", "owner","public","slug", "showings"]
+

movie_manager/views.py

@@ -1,29 +1,14 @@
 import datetime
 
-from django.db.models import QuerySet
 from django.http import JsonResponse
 from django.contrib.auth.models import User
-from django.utils.dateparse import parse_datetime
-from django.db import models
 from rest_framework import permissions, viewsets
 from knox.auth import TokenAuthentication
-from rest_framework.decorators import action, api_view
+from rest_framework.decorators import action
 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, MovieListListSerializer,
-)
-
-
-class ReadOnly(permissions.BasePermission):
-    def has_permission(self, request, view):
-        return request.method in SAFE_METHODS
+from movie_manager.serializers import MovieListSerializer, MovieSerializer, ScheduleSerializer, ShowingSerializer
 
 
 # Create your views here.
@@ -34,78 +19,26 @@ class MovieViewset(viewsets.ModelViewSet):
 
     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()
+    queryset = MovieList.objects.all().order_by("name")
     authentication_classes = [TokenAuthentication]
-    permission_classes = [permissions.IsAuthenticated | ReadOnly]
+    permission_classes = [permissions.IsAuthenticated]
 
-    def get_serializer_class(self):
-        if self.action == "list":
-            return MovieListListSerializer
-        else:
-            return MovieListSerializer
+    serializer_class = 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,
-        )
 
+    def retrieve(self, request, pk=None, *args, **kwargs):
+        movie_list = MovieList.objects.get(pk=pk)
         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.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")
+        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)
@@ -121,88 +54,57 @@ class MovieListViewset(viewsets.ModelViewSet):
 
         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)
+    @action(detail=True, methods=['put', 'delete'], url_path='movie/(?P<movie_id>[0-9]+)')
+    def add_movie(self, request, pk=None, movie_id=None, *args, **kwargs):
+        if request.method == 'DELETE':
+            return self.remove_movie(request, pk, movie_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)
+        movie = Movie.objects.get(pk=movie_id)
+        movie_list.movies.add(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()
+    def remove_movie(self, request, pk=None, movie_id=None, *args, **kwargs):
+        movie = Movie.objects.get(pk=movie_id)
 
         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]
+    permission_classes = [permissions.IsAuthenticated]
 
     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)
+        today = datetime.datetime.now()
 
-        upcoming_showings = Showing.objects.filter(
-            showtime__gte=today, schedule=instance
-        )
+        upcoming_showings = instance.showings.filter(showtime__gte=today)
 
         # 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
+        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
-            )
+
+        if request.GET.get('past_showings') == 'true':
+            past_showings = instance.showings.filter(showtime__lt=today)
 
             # Add both to the response
-            data["past_showings"] = [
-                {
-                    "id": showing.id,
-                    "showtime": showing.showtime.isoformat(),
-                    "movie": MovieSerializer(showing.movie).data,
-                }
+            data['past_showings'] = [
+                {'id': showing.id, 'showtime': showing.showtime.isoformat(), "movie": MovieSerializer(showing.movie).data}
                 for showing in past_showings
             ]
         else:
-            data["past_showings"] = []
+            data['past_showings'] = []
 
         return JsonResponse(data)
 
@@ -210,26 +112,27 @@ class ScheduleViewset(viewsets.ModelViewSet):
 class ShowingViewset(viewsets.ModelViewSet):
     queryset = Showing.objects.all().order_by("showtime")
     authentication_classes = [TokenAuthentication]
-    permission_classes = [permissions.IsAuthenticated | ReadOnly]
+    permission_classes = [permissions.IsAuthenticated]
 
     serializer_class = ShowingSerializer
 
     def create(self, request, *args, **kwargs):
-        movie_id = request.data.get("movie")
+        movie_id = request.data.get('movie')
         movie = Movie.objects.get(pk=movie_id)
 
-        schedule_id = request.data.get("schedule")
+        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,
+            showtime=request.data.get("showtime"),
             public=request.data.get("public"),
-            owner=request.user,
+            owner=User.objects.get(pk=request.data.get("owner"))
         )
 
+        schedule.showings.add(showing)
+
         return JsonResponse(ShowingSerializer(showing).data)
+
+

movienight/settings.py

@@ -126,8 +126,6 @@ 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

@@ -12,23 +12,21 @@ from rest_framework.routers import DefaultRouter
 
 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
 
 router = DefaultRouter()
-router.register(r"v1/users", user_views.UserViewSet)
-router.register(r"v1/groups", user_views.GroupViewSet)
-router.register(r"v1/movies", movie_views.MovieViewset)
-router.register(r"v1/lists", movie_views.MovieListViewset)
-router.register(r"v1/schedules", movie_views.ScheduleViewset)
-router.register(r"v1/showings", movie_views.ShowingViewset)
+router.register(r"api/users", user_views.UserViewSet)
+router.register(r"api/groups", user_views.GroupViewSet)
+router.register(r"api/movies", movie_views.MovieViewset)
+router.register(r"api/lists", movie_views.MovieListViewset)
+router.register(r"api/schedules", movie_views.ScheduleViewset)
+router.register(r"api/showings", movie_views.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/movies/search", movie_db_views.omdb_search, name="omdb_search"),
-    path(r"v1/auth/", include("knox.urls")),
+    path(r"api/auth/token/", obtain_auth_token),
+    path(r"api/auth/login/", user_views.LoginView.as_view(), name="knox_login"),
+    path(r"api/auth/register/", user_views.register, name="register"),
+    path(r"api/auth/", include("knox.urls")),
 ] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

requirements.txt

@@ -6,4 +6,3 @@ django-filter
 gunicorn==23.0.0
 psycopg2-binary==2.9.10
 django-cors-headers==4.7.0
-requests==2.32.3