def update(self, request, pk=None):
movie = get_object_or_404(Movie, id=pk)
self.check_object_permissions(request, movie)
serializer = MovieSerializer(movie, data=request.data, partial=True)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(data=serializer.data)
def put(self, request, movie_id, format=None):
movie = self.get_object(movie_id)
serializer = MovieSerializer(movie, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_invalid_movie_serializer():
invalid_serializer_data = {'title': 'No man land', 'year': '1916'}
serializer = MovieSerializer(data=invalid_serializer_data)
assert not serializer.is_valid()
assert serializer.validated_data == {}
assert serializer.data == invalid_serializer_data
assert 'genre' not in serializer.data
def test_invalid_movie_serializer():
invalid_serializer_data = {"title": "Raising Arizona", "genre": "comedy"}
serializer = MovieSerializer(data=invalid_serializer_data)
assert not serializer.is_valid()
assert serializer.validated_data == {}
assert serializer.data == invalid_serializer_data
assert serializer.errors == {"year": ["This field is required."]}
def test_valid_movie_serializer():
valid_serializer_data = {"title": "yyy", "genre": "comedy", "year": "2019"}
serializer = MovieSerializer(data=valid_serializer_data)
assert serializer.is_valid()
assert serializer.validated_data == valid_serializer_data
assert serializer.data == valid_serializer_data
assert serializer.errors == {}
def test_invalid_movie_serializer():
invalid_serializer_data = {'title': 'Raising Arizona', 'genre': 'Comedy'}
serializer = MovieSerializer(data=invalid_serializer_data)
assert not serializer.is_valid()
assert serializer.validated_data == {}
assert serializer.data == invalid_serializer_data
assert serializer.errors == {'year': ['This field is required.']}
def put(self, request, pk1, pk2):
movie = self.get_movie(request, pk1, pk2)
try:
request.data.pop('genre')
except:
pass
serializer = MovieSerializer(instance=movie, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
def test_valid_movie_serializer():
valid_serializer_data = {
'title': 'Avatar',
'genre': 'action',
'year': "2009"
}
serializer = MovieSerializer(data=valid_serializer_data)
assert serializer.is_valid()
assert serializer.validated_data == valid_serializer_data
assert serializer.data == valid_serializer_data
assert serializer.errors == {}
def test_valid_movie_serializer():
valid_serializer_data = {
"title": "Raising Arizona",
"genre": "comedy",
"year": "1987",
}
serializer = MovieSerializer(data=valid_serializer_data)
assert serializer.is_valid()
assert serializer.validated_data == valid_serializer_data
assert serializer.data == valid_serializer_data
assert serializer.errors == {}
def test_valid_movie_serializer():
valid_serializer_data = {
"title": "High Fidelity",
"genre": "comedy",
"year": "1999",
}
serializer = MovieSerializer(data=valid_serializer_data)
assert serializer.is_valid()
assert serializer.validated_data == valid_serializer_data
assert serializer.data == valid_serializer_data
assert serializer.errors == {}
def test_valid_movie_serializer():
valid_serializer_data = {
'title': 'Raising Arizona',
'genre': 'Comedy',
'year': '1987'
}
serializer = MovieSerializer(data=valid_serializer_data)
assert serializer.is_valid()
assert serializer.validated_data == valid_serializer_data
assert serializer.data == valid_serializer_data
assert serializer.errors == {}
def create(self, request):
serializer = MovieSerializer(data=request.data, partial=True)
if not serializer.is_valid():
return Response(serializer.errors, status=400)
movie = serializer.save()
if not movie.image:
image = Image.objects.create(data=DEFAULT_MOVIE_IMAGE,
kind=MOVIE_IMAGE[0])
movie.image = image
movie.save()
return Response(serializer.data)
def movie_list(request):
if request.method == 'GET':
movies = Movie.objects.all()
movies_serializer = MovieSerializer(movies, many=True)
return Response(movies_serializer.data)
elif request.method == 'POST':
movie_serializer = MovieSerializer(data=request.data)
if movie_serializer.is_valid():
movie_serializer.save()
return Response(movie_serializer.data,
status=status.HTTP_201_CREATED)
return Response(movie_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, auth, format=None, *args, **kwargs):
serializer = MovieSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response({
'data': serializer.data,
'success': True
},
status=status.HTTP_201_CREATED)
return Response({
'error': serializer.errors,
'success': False
},
status=status.HTTP_400_BAD_REQUEST)
def movie_list(request, format=None):
"""
List all movies, or create a new movie.
"""
if request.method == 'GET':
movies = DoubanMovie.objects.all()
serializer = MovieSerializer(movies, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = MovieSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def movie_list(request):
"""
List all code snippets, or create a new snippet.
"""
if request.method == 'GET':
snippets = MovieModel.objects.all()
serializer = MovieSerializer(snippets, many=True)
return JsonResponse(serializer.data, safe=False)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = MovieSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def movie_detail(request, pk):
try:
movie = Movie.objects.get(pk=pk)
except Movie.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
movie_serializer = MovieSerializer(movie)
return Response(movie_serializer.data)
elif request.method == 'PUT':
movie_serializer = MovieSerializer(movie, data=request.data)
if movie_serializer.is_valid():
movie_serializer.save()
return Response(movie_serializer.data)
return Response(movie_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
movie.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def movie_detail(request, pk, format=None):
"""
Retrieve, update or delete a movie.
"""
try:
movie = DoubanMovie.objects.get(pk=pk)
except DoubanMovie.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = MovieSerializer(movie)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = MovieSerializer(movie, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
movie.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
def put(self, request, auth, format=None, *args, **kwargs):
id = request.data.get('movie_id', None)
movie = self.get_object(id)
serializer = MovieSerializer(movie, data=request.data)
if movie:
role_exists = Movie.objects.filter(
role__permission__slug="update_movie",
role__user_role__id=auth['user_id'],
id=id,
is_active=True).distinct('id')
if auth['is_admin'] or role_exists.exists():
if serializer.is_valid():
# try:
serializer.save()
# except Exception as e:
# Response({'error':e.message, 'success':False}, status=status.HTTP_400_BAD_REQUEST)
return Response({
'data': serializer.data,
'success': True
},
status=status.HTTP_200_OK)
return Response(
{
'error': {
'unauthorized': ["UNAUTHORIZED USER"]
},
'success': False
},
status=status.HTTP_400_BAD_REQUEST)
return Response({
'error': {
'movie': ["NOT PRESENT"]
},
'success': False
},
status=status.HTTP_400_BAD_REQUEST)
def movie(request):
"""
/movies
POST /movies
@param `title` required validated
fetch details from omdbapi.com and save to DB
@response (
full movie object,
data fetched from API
)
GET /movies
fetch list of all movies present (be smart) <serializer>(<queryset>, many=True)
"""
if request.method == "POST":
title = request.POST.get("title", "")
#if title is blank space return error
if title == "":
return JsonResponse({"error": "no title"}, status=400)
#get movie
movie = get_movie(title)
#check if already in database
entry = Movie.objects.filter(Title__iexact=movie["Title"])
if entry.exists():
return JsonResponse({"error": "already in database, use GET"}, status=400)
#response could fail
if movie["Response"] == "False": # in what universe would you do this
return JsonResponse({"error": movie["Error"].lower()})
#we only care for movies
if not(movie["Type"] == "movie"):
return JsonResponse({"error": "not a movie"}, status=400)
#copy original movie object (tfw 2018 and still have to use tricks to duplicate variable)
org_movie = dict(movie)
#check if anywhere is N/A and make that field blank
for key in movie.keys():
if movie[key] == "N/A":
movie[key] = ""
#make Ratings proper formatting
# <source>:<value>;<source>:<value>
tmp_r = []
for rating in movie["Ratings"]:
#join values with delimeter :
tmp_r += [":".join(rating.values())]
#join array with delimeter ;
movie["Ratings"] = ";".join(tmp_r)
#make IntegerField friendly
movie["Runtime"] = int(movie["Runtime"].replace(" min", ""))
movie["imdbVotes"] = int(movie["imdbVotes"].replace(",", ""))
#make dates model friendly
movie["Released"] = datetime.strptime(movie["Released"], "%d %b %Y").strftime("%Y-%m-%d")
movie["DVD"] = datetime.strptime(movie["DVD"], "%d %b %Y").strftime("%Y-%m-%d")
serializer = MovieSerializer(data=movie)
if serializer.is_valid():
serializer.save()
resp = {"fetched_api_data": org_movie}
resp.update(serializer.data)
return JsonResponse(resp, status=201, safe=False)
return JsonResponse(serializer.errors, status=400)
if request.method == "GET":
title = request.GET.get("title", "")
year = request.GET.get("year", "")
rated = request.GET.get("rated", "")
runtime = request.GET.get("runtime", "")
runtime_gte = request.GET.get("runtime_gte", "")
#get all movies
allmovies = Movie.objects.all()
#filter if argument exists
if not(title == ""):
allmovies = allmovies.filter(Title__icontains=title)
if not(year == ""):
allmovies = allmovies.filter(Year=year)
if not(rated == ""):
allmovies = allmovies.filter(Rated__icontains=rated)
if not(runtime == ""):
allmovies = allmovies.filter(Runtime=runtime)
if not(runtime_gte == ""):
allmovies = allmovies.filter(Runtime__gte=runtime_gte)
a = MovieSerializer(allmovies, many=True)
return JsonResponse(a.data, safe=False, status=201)
def handle(self, *args, **options):
import os
url = "http://192.168.1.143:8080/static/movies/categories/"
os.chdir('movies/static/movies/categories')
# List all directories in the categories folder
categories = os.listdir('.')
for category in categories:
os.chdir(category)
print(colored("Searching inside {0}", 'blue').format(category))
# Loop through every file in the current directory
for file in os.listdir('.'):
# Loop through the directories of each category pick down its movies
if os.path.isdir(file):
print("Files ", file)
self.stdout.write(
self.style.WARNING(
"Found A directory!!!"
"looking for treasures in '{0}'".format(category +
"/" +
file)))
# This directory hold movies so navigate it looking for movies
# Change directory into it
os.chdir(file)
print("All files inside here are {0}".format(
os.listdir('.')))
# Filter the images i.e thumbnails out and the movies out.
# Create a url for them.
# Something like ['showdown-in-manila-movie-poster.jpg', 'showdown-in-manila-trailer-1_h480p.mov']
# get the thumbnail first
movie_thumbnail = ''
source_url = ''
duration = ''
cat_id = ''
for movie in os.listdir('.'):
if movie.endswith(".jpg") | movie.endswith(
".png") | movie.endswith('.jpeg'):
movie_thumbnail = url + category + '/' + file + '/' + movie
# Encode the url
movie_thumbnail = urllib.parse.quote(
movie_thumbnail, safe=":,/")
print('Thumbnail', movie_thumbnail)
for movie in os.listdir('.'):
if movie.endswith(".jpg") | movie.endswith(
".png") | movie.endswith('.jpeg'):
pass
# Get the movie source. i.e the Movie URL
if movie.lower().endswith(".mov") | movie.lower(
).endswith(".mp4") | movie.lower().endswith(
".wav") | movie.lower().endswith(".mkv"):
source_url = url + category + '/' + file + '/' + movie
source_url = urllib.parse.quote(source_url,
safe=":,/")
print('MOVIE', movie)
# Get movie duration
metadata = subprocess.Popen(
["ffprobe", movie],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
for stream in metadata.stdout.readlines():
stream = stream.decode("utf-8")
if "Duration" in stream:
duration = stream.split(',')[0].split()[1]
print("Thumbnail ", movie_thumbnail)
cat = MoviesCategories.objects.filter(
name=category).first()
cat_id = cat.id
videos = MovieSerializer(
data={
'name': movie[:-4],
'thumbnail': movie_thumbnail,
'source_url': source_url,
'duration': duration[:-3],
'category': cat_id
})
print(
colored("Trying to add '{0}' into {1}",
'magenta').format(
movie[:-4], category))
if videos.is_valid():
try:
videos.save()
print(
colored('Successfully Added {0}',
"green").format(movie))
except Exception as e:
print(colored("Error ", "red"), e)
else:
self.stderr.write(
self.style.ERROR(
"Movie '{0}' not valid: {1}".format(
movie[:-4], videos.errors)))
os.chdir('..')
os.chdir('..')
def post(self, request, format=None):
serializer = MovieSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(request):
serializer = MovieSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
return Response(serializer.errors, status=400)
def post(self, request):
serializer = MovieSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
