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)