def movies(request):
if request.method == 'GET':
movie_list = Movie.objects.order_by('-release_date').all()
serializer = MovieSerializer(movie_list, many=True)
return Response(serializer.data)
# TODO: 관리자 확인
elif request.method == 'POST':
# 영화 정보 생성
genres = Genre.objects.filter(id__in=request.data['genres'])
movie = Movie()
movie.original_title = request.data['original_title']
movie.title = request.data['title']
movie.description = request.data['description']
movie.poster_url = request.data['poster_url']
movie.release_date = request.data['release_date']
movie.trailer_url = request.data['trailer_url']
movie.save()
for genre in genres:
movie.genres.add(genre)
serializer = MovieSerializer(movie, many=False)
return Response(serializer.data)
def post(self, request, *args, **kwargs):
"""
:param request: request the movie details
:return: save the details of a movie in database
"""
try:
# import pdb
# pdb.set_trace()
data = request.data
if 'actor' in data:
actor_list = []
actors = data['actor']
for name in actors:
obj = Actor.objects.get(actor_name=name)
if obj:
actor_list.append(obj.id)
else:
return Response(
SMD_Response(message="Something went wrong when"
"while adding actors"))
data['actor'] = actor_list
if 'producer' in data:
producer_list = []
producers = data['producer']
for name in producers:
obj = Producer.objects.get(producer_name=name)
if obj:
producer_list.append(obj.id)
else:
return Response(
SMD_Response(message="Something went wrong when"
"while adding producers"))
data['producer'] = producer_list
serializer = MovieSerializer(data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
logger.info(
"Successfully Save the movie details in the database")
smd = SMD_Response(
status=True,
message=
"Successfully Save the movie details in the database",
data=[serializer.data])
return Response(smd, status=status.HTTP_201_CREATED)
else:
logger.error("Please Provide Valid Details")
smd = SMD_Response(status=False,
message="Please Provide Valid Details",
data=[serializer.errors])
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.error("Something went wrong-" + str(e))
smd = SMD_Response(message="Something Went Wrong")
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
def list(self, request, *args, **kwargs):
context = {'request': request}
queryset = self.get_queryset().prefetch_related('genre')
queryset = self.filter_queryset(queryset)
page = self.paginate_queryset(queryset)
if page is not None:
serializer = MovieSerializer(page, many=True, context=context)
print(connection.queries)
return self.get_paginated_response(serializer.data)
else:
serializer = MovieSerializer(queryset, many=True, context=context)
data = serializer.data
print(connection.queries)
return Response(data)
def get(self, request, pk, format=None):
user = User.objects.filter(pk=pk).first()
if user:
movies = Movie.objects.filter(view_users__user=user).order_by("-view_users__date")[:8]
serializer = MovieSerializer(movies, many=True)
return Response(serializer.data)
return JsonResponse({})
def movie_delete(request):
movie_name = request.GET.get('movie_name', None)
year = request.GET.get('year', None)
if movie_name and year:
movie_objects = Movie.objects.filter(movie_name=movie_name).filter(
year=year)
elif movie_name and year is None:
movie_objects = Movie.objects.filter(movie_name=movie_name)
elif movie_name is None and year:
movie_objects = Movie.objects.filter(year=year)
else:
return Response("No Movie Data Deleted",
status=status.HTTP_201_CREATED)
if len(movie_objects) == 0:
return Response("No Movie Data Deleted",
status=status.HTTP_201_CREATED)
else:
print(movie_objects)
serializer = MovieSerializer(movie_objects, many=True)
print(serializer)
movie_objects.delete()
return Response("Movies Deleted from database",
status=status.HTTP_201_CREATED)
def get(self, request, id, *args, **kwargs):
"""
:param request: request for get the particular Movie Details
:param id: Here, we pass an ID for update of a specific Movie Object
:return: It will get a requested Movie with ID from the Database
"""
try:
# import pdb
# pdb.set_trace()
movie_data = Movie.objects.filter(id=id)
if movie_data:
serializer = MovieSerializer(movie_data, many=True)
logger.info("Successfully Read Movie Details")
smd = SMD_Response(
status=True,
message="Successfully Get the Requested Movie Details",
data=[serializer.data])
logger.info('Successfully Get Movie Details')
return Response(smd, status=status.HTTP_200_OK)
else:
logger.error("No data available/invalid id")
smd = SMD_Response(status=False,
message="No Content Available",
data=[])
return Response(smd, status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.warning("Something went wrong" + str(e))
smd = SMD_Response(status=False, message="Something Went Wrong")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
def get(self, request, *args, **kwargs):
"""
:param request: Request for getting all the movie details
:return: the details of all producers
"""
try:
all_movie = Movie.objects.all()
if all_movie:
serializer = MovieSerializer(all_movie, many=True)
logger.info(
"Successfully get the movie details from the database")
smd = SMD_Response(
status=True,
message=
"Successfully get the movie details from the database",
data=[serializer.data])
return Response(smd, status=status.HTTP_201_CREATED)
else:
logger.error("No data available to be fetch from DATABASE")
smd = SMD_Response(status=False,
message="No Content Available")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.warning("Something went wrong-" + str(e))
smd = SMD_Response(message="Something went wrong")
return Response(smd, status=status.HTTP_404_NOT_FOUND)
class SessionSerializer(serializers.ModelSerializer):
movie = MovieSerializer(read_only=True)
hall = HallSerializer(read_only=True)
movie_id = serializers.IntegerField(write_only=True)
hall_id = serializers.IntegerField(write_only=True)
class Meta:
model = Session
fields = '__all__'
def create(self, validated_data):
# pop and search movie
movie_id = validated_data.pop('movie_id')
movie = Movie.objects.get(id=movie_id)
# pop and search cinema
hall_id = validated_data.pop('hall_id')
hall = Hall.objects.get(id=hall_id)
if movie and hall:
session = Session.objects.create(movie=movie, hall=hall, **validated_data)
for row in session.hall.rows.all():
for seat in row.seats.all():
reserve = SeatReserve.objects.create(seat=seat, session=session)
reserve.save()
# print('---' + str(reserve) + ' created!')
return session
else:
print('---movie and hall are not found')
class SceneSerializer(serializers.ModelSerializer):
theater = TheaterSerializer()
movie = MovieSerializer()
start = DateSerializerField(read_only=True)
end = DateSerializerField(read_only=True)
class Meta:
model = Scene
fields = ('pk', 'theater', 'movie', 'price', 'effect', 'start', 'end', 'hall', 'seats')
def retrieve(self, request, pk=None, **kwargs):
context = {'request': request}
queryset = self.get_queryset()
movie = get_object_or_404(queryset, pk=pk)
serializer = MovieSerializer(movie, context=context)
return Response(serializer.data)
class ShowSerializer(serializers.ModelSerializer):
movie = MovieSerializer()
theater = TheaterSerializer()
class Meta:
model = Show
fields = '__all__'
def test_filtering_movies_cast(self):
"""Tests for returning movies with specific Casts"""
movie_1 = sample_movie(user=self.user, title='BayWatch')
movie_2 = sample_movie(user=self.user, title='XXX')
cast1 = sample_cast(user=self.user, name='Dwayne Johnson')
cast2 = sample_cast(user=self.user, name='Vin Diesel')
movie_1.cast.add(cast1)
movie_2.cast.add(cast2)
movie_3 = sample_movie(user=self.user, title='Frozen')
res = self.client.get(MOVIE_URL, {'cast': f'{cast1.id},{cast2.id}'})
serializer1 = MovieSerializer(movie_1)
serializer2 = MovieSerializer(movie_2)
serializer3 = MovieSerializer(movie_3)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
def test_filtering_movies_tags(self):
"""Test for returning movies with specific Tags"""
movie_1 = sample_movie(user=self.user, title='MindHunter')
movie_2 = sample_movie(user=self.user, title='Zodiac')
tag1 = sample_tag(user=self.user, name='Thriller')
tag2 = sample_tag(user=self.user, name='Crime')
movie_1.tag.add(tag1)
movie_2.tag.add(tag2)
movie_3 = sample_movie(user=self.user, title='UP')
res = self.client.get(MOVIE_URL, {'tag': f'{tag1.id},{tag2.id}'})
serializer1 = MovieSerializer(movie_1)
serializer2 = MovieSerializer(movie_2)
serializer3 = MovieSerializer(movie_3)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
def get(self, request, format=None):
if request.GET:
q = request.GET.getlist("genre")
movies = Movie.objects.filter(Q(genres__in=q)).distinct()
queryset = self.paginate_queryset(movies, request, view=self)
serializer = MovieSerializer(movies, many=True, context={"request": request})
return self.get_paginated_response(serializer.data)
else:
raise Http404
def test_successful_retrieve(self):
"""Tests for authorized access of page"""
sample_movie(self.user)
sample_movie(self.user)
res = self.client.get(MOVIE_URL)
movies = Movie.objects.all().order_by('-id')
serializer = MovieSerializer(movies, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def get(self, request, format=None):
if request.GET:
q = request.GET.get("q")
movies = Movie.objects.filter(Q(title__icontains=q)).all()
queryset = self.paginate_queryset(movies, request, view=self)
serializer = MovieSerializer(queryset, many=True, context={"request": request})
return self.get_paginated_response(serializer.data)
else:
raise Http404
def test_retrieve_movies(self):
"""Test retrieving list of movies"""
sample_movie(user=self.user)
sample_movie(user=self.user)
res = self.client.get(MOVIES_URL)
movies = Movie.objects.all().order_by('-id')
serializer = MovieSerializer(movies, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(res.data, serializer.data)
def test_movies_limited_to_user(self):
"""Tests for movies access limited to the respective user."""
sample_movie(self.user)
user_1 = get_user_model().objects.create_user('*****@*****.**',
'hellotest123')
sample_movie(user_1)
res = self.client.get(MOVIE_URL)
movies = Movie.objects.filter(user=self.user)
serializer = MovieSerializer(movies, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data, serializer.data)
def movie_recommend(request, user_id):
user = get_object_or_404(User, pk=user_id)
genre_list = user.like_genre.all()
genre_ids = []
for genre in genre_list:
genre_ids.append(genre.id)
movie_list = Movie.objects.filter(genres__id__in=genre_ids).distinct()
serializer = MovieSerializer(movie_list, many=True)
return Response(serializer.data)
def create(self, request, *args, **kwargs):
context = {'request': request}
serializer = MovieSerializer(data=request.data, context=context)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def get_movies(self, request, *args, **kwargs):
movie = Movie(name="a",
director='a',
actors='a',
types='a',
country='a',
language='a',
date='a',
length='a',
rate='a',
watcher='a',
tags='a')
movie_json = MovieSerializer(movie)
return Response(movie_json.data)
def test_movies_limited_to_user(self):
"""Test retrieving movies for user"""
user2 = get_user_model().objects.create_user(
'*****@*****.**',
'pass123'
)
sample_movie(user=user2)
sample_movie(user=self.user)
res = self.client.get(MOVIES_URL)
movies = Movie.objects.filter(user=self.user)
serializer = MovieSerializer(movies, many=True)
self.assertEqual(res.status_code, status.HTTP_200_OK)
self.assertEqual(len(res.data), 1)
self.assertEqual(res.data, serializer.data)
def movie_list(request):
if request.method == 'GET':
movies = Movie.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)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def update(self, request, *args, **kwargs):
context = {'request': request}
instance = self.get_object()
serializer = MovieSerializer(instance,
data=request.data,
partial=False,
context=context)
serializer.is_valid(raise_exception=True)
serializer.save()
return Response(serializer.data)
def movie_detail(request, movie_id):
print('ddddddd')
movie = get_object_or_404(Movie, pk=movie_id)
if request.method == 'GET':
serializer = MovieSerializer(movie)
print(serializer.data)
return Response(serializer.data)
elif request.method == 'PUT':
serializer = MovieSerializer(movie, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response({'message': '수정 완료'})
return Response(serializer.error)
else:
movie.delete()
def get_movies(self, request, *args, **kwargs):
token = request.GET["uid"]
new_movies = []
movies = pick_movies(token)
for movie in movies:
if "summary" in movie:
summary = movie["summary"]
else:
summary = ""
movie = Movie(
id=movie["movie_id"],
name=movie["name"],
directors=",".join(flatten(movie["directors"]))
if movie["directors"] else "",
actors=",".join(flatten(movie["actors"]))
if movie["actors"] else "",
language=",".join(flatten(movie["language"]))
if movie["language"] else "",
types=",".join(flatten(movie["types"]))
if movie["types"] else "",
countries=",".join(flatten(movie["countries"]))
if movie["countries"] else "",
year=movie["year"] if movie["year"] else "",
length=movie["length"] if movie["length"] else "",
rate=movie["rate"],
editors=",".join(flatten(movie["editors"]))
if movie["editors"] else "",
people=movie["people"],
tags=",".join(flatten(movie["tags"])) if movie["tags"] else "",
cover_url="/photos/" + movie["movie_id"],
summary=summary,
)
print movie
new_movies.append(movie)
movie_json = MovieSerializer(new_movies)
return Response(movie_json.data)
def get_movies(request):
page = request.GET.get('page')
limit = request.GET.get('limit')
begin = request.GET.get('begin')
end = request.GET.get('end')
if not begin or not end:
return Response({'success': False, 'message': '...'})
if not page:
page = 1
if not limit:
limit = 5
page = int(page)
limit = int(limit)
start = (page - 1) * limit
movies = Movie.objects.filter(show_time__range=(begin, end)).order_by(
'show_time', 'id')[start:start + limit]
serializer = MovieSerializer(movies, many=True)
return Response({
'success': True,
'message': '成功',
'data': serializer.data
})
def put(self, request, id, *args, **kwargs):
"""
:param request:request for put(update) the Movie Details
:param id:Here, we pass an ID for update of a requested Movie
:return:It will Update a requested Movie Details in Database
"""
try:
# import pdb
# pdb.set_trace()
movie_obj = Movie.objects.get(id=id)
if movie_obj is not None:
data = request.data
if 'actor' in data:
actor_list = []
actors = data['actor']
for name in actors:
obj = Actor.objects.get(actor_name=name)
if obj:
actor_list.append(obj.id)
else:
return Response(
SMD_Response(
message="Something went wrong when"
"while adding actors"))
data['actor'] = actor_list
if 'producer' in data:
producer_list = []
producers = data['producer']
for name in producers:
obj = Producer.objects.get(producer_name=name)
if obj:
producer_list.append(obj.id)
else:
return Response(
SMD_Response(
message="Something went wrong when"
"while adding producers"))
data['producer'] = producer_list
serializer = MovieSerializer(movie_obj, data=data)
if serializer.is_valid():
serializer.save()
logger.info(
"Successfully Updated the Details of the a Movie")
smd = SMD_Response(
status=True,
message="Movie Details Successfully Updated",
data=[serializer.data])
return Response(smd, status=status.HTTP_202_ACCEPTED)
else:
logger.error("Please provide valid details")
smd = SMD_Response(
message="Invalid Request/No such query exist",
data=[serializer.errors])
return Response(smd, status=status.HTTP_400_BAD_REQUEST)
else:
logger.info("No DATA Present")
return Response(SMD_Response(message="No Data Present"),
status=status.HTTP_404_NOT_FOUND)
except Exception as e:
logger.warning("SOMETHING WENT WRONG" + str(e))
return Response(
SMD_Response(message="Please Provide a Valid ID or "
"Something Went Wrong"),
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, pk, format=None):
category = self.get_object(pk)
movies = category.movies.all()
queryset = self.paginate_queryset(movies, request, view=self)
serializer = MovieSerializer(queryset, many=True, context={"request": request})
return self.get_paginated_response(serializer.data)