def post(self,request,pk, sec):
if sec == 'con':
n = Notes.objects.filter(Q(reciever=request.user.id) & Q(connection=pk) & Q(read=True))[:2]
f = food.objects.filter(Q(connection=pk) & Q(direction=True)).last()
m = movies.objects.filter(Q(connection=pk) & Q(direction=True)).last()
a = activities.objects.filter(Q(connection=pk) & Q(direction=True)).last()
e = Events.objects.filter(Q(connection=pk) & Q(request=False)& Q(date__gte=datetime.today())).order_by('date')[:5]
r = Events.objects.filter(Q(connection=pk) & Q(request=True) & Q(date__gte=datetime.today())).exclude(creator=request.user.id).order_by('date')[:5]
return Response({
'events': PopulatedEventsSerializer(e, many=True).data,
'req': PopulatedEventsSerializer(r, many=True).data,
'note': PopulatedNotesSerializer(n, many=True).data,
'food':FoodSerializer(f).data ,
'movie': MovieSerializer(m).data,
'activity': ActivitiesSerializer(a).data})
else :
prefetch= Prefetch('connection', queryset=Connections.objects.filter(participants__id=pk))
e = Events.objects.filter(Q(connection__participants__id=pk) & Q(request=False) & Q(date__gte=datetime.today())).prefetch_related(prefetch).order_by('date')[:5]
r = Events.objects.filter(Q(connection__participants__id=pk)& Q(request=True) & Q(date__gte=datetime.today())).exclude(creator=pk).prefetch_related(prefetch).order_by('date')[:5]
m = movies.objects.filter(Q(user=pk) & Q(direction=True)).order_by('-created_at')[:2]
a = activities.objects.filter(Q(user=pk) & Q(direction=True)).order_by('-created_at')[:2]
f= food.objects.filter(Q(user=pk) & Q(direction=True)).order_by('-created_at')[:2]
n = Notes.objects.filter(Q(reciever=pk) & Q(read=True)).order_by('-created_at')[:2]
return Response({
'events': PopulatedEventsSerializer(e, many=True).data,
'req': PopulatedEventsSerializer(r, many=True).data,
'note': PopulatedNotesSerializer(n,many=True).data,
'food':FoodSerializer(f, many=True).data ,
'movie': MovieSerializer(m, many=True).data,
'activity': ActivitiesSerializer(a, many=True).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": "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_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 userdetail(request):
user = request.user
rated_movies = Rating.objects.filter(user_id=user).exclude(
star=-1).values('movie_id')
liked_movies = Rating.objects.filter(user_id=user,
star=-1).values('movie_id')
rated_movie_list = Movie.objects.filter(movie_id__in=rated_movies)
liked_movie_list = Movie.objects.filter(movie_id__in=liked_movies)
rated_movie_data = MovieSerializer(rated_movie_list, many=True)
liked_movie_data = MovieSerializer(liked_movie_list, many=True)
user_data = get_object_or_404(User, email=user)
user_serializer = UserSerializer(user_data)
rcnt = Rating.objects.filter(user=user).exclude(star=-1).count()
lcnt = Rating.objects.filter(user=user, star=-1).count()
return Response({
'rated_movie_data': rated_movie_data.data,
'liked_movie_data': liked_movie_data.data,
'user_data': user_serializer.data,
'rated_movie_cnt': rcnt,
'liked_movie_cnt': lcnt,
})
return Response()
def get(self, request, auth, format=None, *args, **kwargs):
id = request.query_params.get('movie_id', None)
role_exists = Movie.objects.filter(role__permission__slug="read_movie",
role__user_role__id=auth['user_id'],
is_active=True)
if id:
role_exists = role_exists.filter(id=id)
if auth['is_admin'] or role_exists.exists():
movie = self.get_object(id)
serializer = MovieSerializer(movie)
else:
return Response({
'data': [],
'success': True
},
status=status.HTTP_200_OK)
else:
if auth['is_admin']:
movie = Movie.objects.filter(is_active=True)
else:
movie = role_exists.distinct('id')
serializer = MovieSerializer(movie, many=True)
return Response({
'data': serializer.data,
'success': True
},
status=status.HTTP_200_OK)
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_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 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)
class UserSerializer(serializers.ModelSerializer):
like_user = MovieSerializer(many=True, read_only=True)
rate_user = MovieSerializer(many=True, read_only=True)
rated_user = UserRateMovieSerializer(many=True, read_only=True)
like_articles = ArticleSerializer(many=True, read_only=True)
dislike_articles = ArticleSerializer(many=True, read_only=True)
comments = CommentSerializer(many=True, read_only=True)
class Meta:
model = User
fields = '__all__'
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 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 userMovie(request):
review_user = get_user_model().objects.values('id').filter(
username=request.user)
movies = Movie.objects.filter(user_id=review_user[0]['id'])
serializer = MovieSerializer(movies, many=True)
print(serializer.data)
return Response(serializer.data)
def UserListAgeView(request, age):
# ages=[0,1,2,3,4,5,6]
result=[]
data={}
if request.method == 'GET':
profile=Profile.objects.filter(age__gt=age-1).filter(age__lt=age+10)
# print(profile)
# serializer=ProfileSerializer(profile, many=True)
# print(serializer.data)
for user in profile :
if user.user_visited.all() :
# print(user.user_visited.all())
for p in user.user_visited.all() :
if p.id in data :
data[p.id] += 1
else :
data[p.id] = 1
print(data)
# sorted(data,reverse=True)
answer = (sorted(data, key=lambda k : data[k], reverse=True))
print(answer)
for i in answer: #answer = [(id, views), ... ]
movie = Movie.objects.get(pk=i)
serializer = MovieSerializer(movie)
# print(serializer.data)
result.append(serializer.data)
print(result)
return Response(data=result, status=status.HTTP_200_OK)
def test_undo_hate_movie_not_owner(self):
"""
Ensure that not owner of a movie can undo the hate of a movie.
"""
users = get_sample_users()
movies = get_sample_movies(users)
movie = movies[0]
not_owner = users[-1]
set_sample_opinion(not_owner, movie, OPINION_HATE)
self.assertEqual(movie.hates.count(), 1)
self.assertEqual(movie.hates_counter, 1)
url = reverse('movie-opinion', kwargs={'pk': movies[0].pk})
data = {'opinion': None}
self.client.force_authenticate(user=not_owner)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
movie.refresh_from_db()
request = get_sample_request(not_owner)
expected_response = MovieSerializer(instance=movie,
context={
'request': request
}).data
self.assertEqual(response.data, expected_response)
self.assertEqual(movie.hates_counter, 0)
self.assertEqual(movie.hates.count(), 0)
def test_list_movies_by_undefined_user(self):
"""
Ensure that anonymous user can get no movies filtered by user submitted
them for an username that does not exist.
"""
users = get_sample_users()
movies = get_sample_movies(users)
search_username = users[0].username + 'undefined'
url = '{}?search={}'.format(reverse('movie-list'), search_username)
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
qs = get_paginated_queryset(
Movie.objects.filter(user__username=search_username))
self.assertEqual(qs.count(), 0)
request = get_sample_request()
expected_response = MovieSerializer(qs,
many=True,
context={
'request': request
}).data
self.assertEqual(response.data['results'], expected_response)
def test_ordering_asceding_likes(self):
"""
Ensure that anonymous user can order movies by asceding likes.
"""
url = '{}?ordering={}'.format(reverse('movie-list'), 'likes_counter')
# setup sample data
users = get_sample_users()
movies = get_sample_movies(users)
set_sample_opinions(users, movies, OPINION_LIKE)
# apply request
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
# create expected response data
qs = get_paginated_queryset(Movie.objects.order_by('likes_counter'))
request = get_sample_request()
expected_response = MovieSerializer(qs,
many=True,
context={
'request': request
}).data
self.assertEqual(response.data['results'], expected_response)
class RatingSerializer(serializers.ModelSerializer):
movie = MovieSerializer()
user = UserSerializer()
class Meta:
model = Rating
fields = ['movie', 'user', 'stars']
def user_recos(request, user_id):
user = get_object_or_404(get_user_model(), id=user_id)
posts = user.posts.all()
if posts:
reco_dict = {}
for post in posts:
user_genre = post.movie.genre
user_score = post.score
if user_genre in reco_dict:
reco_dict[user_genre] += user_score
else:
reco_dict[user_genre] = user_score
reco_genre, user_val = None, 0
for key, val in reco_dict.items():
if user_val < val:
user_val = val
reco_genre = key
reco_movies = Movie.objects.filter(~Q(watched_user__in=[user.id]) & Q(
genre=reco_genre)).order_by('-score')[:12]
serializer = MovieSerializer(reco_movies, many=True)
return JsonResponse(serializer.data, safe=False)
else:
return JsonResponse({})
def test_cannot_like_already_liked_movie(self):
"""
Ensure that user cannot like a movie already liked by him.
"""
users = get_sample_users()
movies = get_sample_movies(users)
movie = movies[0]
not_owner = users[-1]
set_sample_opinion(not_owner, movie, OPINION_LIKE)
self.assertEqual(movie.likes_counter, 1)
self.assertEqual(movie.likes.count(), 1)
url = reverse('movie-opinion', kwargs={'pk': movies[0].pk})
data = {'opinion': OPINION_LIKE}
self.client.force_authenticate(user=not_owner)
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(MovieOpinion.objects.count(), 1)
movie.refresh_from_db()
request = get_sample_request(not_owner)
expected_response = MovieSerializer(instance=movie,
context={
'request': request
}).data
self.assertEqual(response.data, expected_response)
self.assertEqual(movie.likes_counter, 1)
self.assertEqual(movie.likes.count(), 1)
class RoomSerializer(serializers.ModelSerializer):
users = serializers.SerializerMethodField(read_only=True)
movies = MovieSerializer(many=True, read_only=True)
unrated_movies = serializers.SerializerMethodField(read_only=True)
@property
def user(self) -> Optional[User]:
try:
return self.context['request'].user
except KeyError:
return None
def get_users(self, room: Room) -> List[Dict]:
return list(room.users.rated_count(room))
def get_unrated_movies(self, room: Room) -> List[Dict]:
qs = room.movies.unrated(user=self.user)
return MovieSerializer(qs, many=True).data
def update(self, instance, validated_data):
instance.sync_user(self.context['request'].user)
return super().update(instance, validated_data)
def create(self, validated_data):
return self.Meta.model.objects.create_room(
admin=self.context['request'].user, **validated_data)
class Meta:
model = Room
fields = ('slug', 'mood', 'admin', 'users', 'movies', 'unrated_movies')
read_only_fields = ('admin', )
def add_movie_to_list_view(request):
new_movie = Movie(**request.data)
user_list = request.user.list
user_list.add_movie_to_list(new_movie)
add_ratings_to_movie(new_movie)
serializer = MovieSerializer(new_movie)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def test_post_movie_save_from_external(self, mock_get):
data = mock_get.side_effect('title')
response = self.client.post(reverse('movies-list'), data=data)
serializer = MovieSerializer(Movie.objects.get(**data))
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertDictEqual(serializer.data, response.data)
self.assertEqual(Movie.objects.get(**data).title, data.popitem()[1])
def test_post_with_saved_movie(self):
response = self.client.post(reverse('movies-list'),
data={'title': self.movie.title})
serializer = MovieSerializer(instance=self.movie)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertDictEqual(serializer.data, response.data)
self.assertEqual(self.movie.title, response.data['title'])
def co_comment_delete(request, movie_id, comment_id, co_comment_id):
co_comment = get_object_or_404(coComment, pk=co_comment_id)
movie = get_object_or_404(Movie, m_id=movie_id)
if co_comment.user != request.user:
return Response({'error': '권한이 없습니다.'})
co_comment.delete()
serializer = MovieSerializer(movie)
return Response(serializer.data)
def post(self, request, format=None):
pk_list = request.data['ids']
if pk_list:
movies = Movies.objects.filter(pk__in=pk_list)
else:
movies = Movies.objects.all()
serializer = MovieSerializer(movies, many=True)
return Response(serializer.data)
