def post(self, request): data = JSONParser().parse(request) serializer = ReviewSerializer(data=data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return JsonResponse(serializer.errors, status=400)
def test_owner_list(self): url = reverse("reviews:owner-list") response1 = self.client.get(url, HTTP_AUTHORIZATION='Token {}'.format( self.reviewer1.token), content_type='application/json') queryset = Review.objects.filter(reviewer=self.reviewer1.id) review_serializer_1 = ReviewSerializer(queryset, many=True) self.assertEqual(response1.status_code, status.HTTP_200_OK) self.assertEqual(review_serializer_1.data, response1.json()['reviews']) """ Tests user just can see reviews he owns """ response2 = self.client.get(url, HTTP_AUTHORIZATION='Token {}'.format( self.reviewer2.token), content_type='application/json') queryset = Review.objects.filter(reviewer=self.reviewer2.id) review_serializer_2 = ReviewSerializer(queryset, many=True) self.assertEqual(response1.status_code, status.HTTP_200_OK) self.assertNotEqual(response1.json()['reviews'], response2.json()['reviews']) self.assertNotEqual(review_serializer_1.data, review_serializer_2.data)
def create(self, request): if request.user.is_authenticated: serializer = ReviewSerializer(data=request.data, context={'request': request}) 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) else: return Response(status=status.HTTP_401_UNAUTHORIZED)
def test_without_rating(self): """ Test trying to create a review without rating """ del self.data['rating'] with self.assertRaises(ValidationError): serializer = ReviewSerializer(data=self.data) serializer.is_valid(raise_exception=True)
def test_validate_rating(self): """ Test to validate that rating should be in range of 1-5 """ self.data['rating'] = 6 with self.assertRaises(ValidationError): serializer = ReviewSerializer(data=self.data) serializer.is_valid(raise_exception=True)
def create(self, request, *args, **kwargs): data = request.data data['author'] = request.user.id serializer = ReviewSerializer(data=data) if serializer.is_valid(): serializer.save() request.user.profile.set_points('REVIEW') return Response({'message': 'Review criado com sucesso', **(serializer.data)}) else: return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def review_create(request, movie_pk): if request.user.user_rank.filter(id=movie_pk).exists(): content = '리뷰는 하나만 작성가능합니다.' return Response(content, status=status.HTTP_400_BAD_REQUEST) movie = get_object_or_404(Movie, pk=movie_pk) serializer = ReviewSerializer(data=request.data) UserRank.objects.create(user=request.user, movie=movie, rank=request.data['rank']) if serializer.is_valid(raise_exception=True): serializer.save(user=request.user, movie=movie) return Response(serializer.data)
def test_can_read_company_reviews(self): response = self.client.get(reverse('company-reviews', kwargs={"slug": self.test_company.slug}), {"limit": 4}) self.assertEqual(response.status_code, status.HTTP_200_OK) json = response.json() reviews = Review.objects.filter(company=self.test_company) serializer = ReviewSerializer(reviews, many=True) self.assertEqual(json.get('results'), serializer.data)
class HouseSerializer(serializers.ModelSerializer): #host = serializers.PrimaryKeyRelatedField(source='host.username',queryset=get_user_model().objects.all()) host = UserSerializer(read_only=True) reviews = ReviewSerializer(many=True, read_only=True) #house_img = HouseImageSerializer(many=True,read_only=True) reservations = ReservationSerializer(many=True, read_only=True) class Meta: model = House fields = [ 'id', 'title', 'description', 'cost', 'garage', 'wifi', 'aircondition', 'city', 'country', 'image', 'lon', 'lat', 'av_from', 'av_to', 'host', 'reviews', 'reservations', 'heat', 'area', 'beds', 'bedrooms', 'bathrooms', 'transport_desc', 'house_type', 'people_num', 'people_max', 'rules', 'plus_cost' ] def update(self, instance, validated_data): instance.id = validated_data.get('id', instance.id) instance.title = validated_data.get('title', instance.title) instance.description = validated_data.get('description', instance.description) instance.cost = validated_data.get('cost', instance.cost) #instance.rooms = validated_data.get('rooms', instance.rooms) instance.garage = validated_data.get('garage', instance.garage) instance.wifi = validated_data.get('wifi', instance.wifi) instance.aircondition = validated_data.get('aircondition', instance.aircondition) instance.city = validated_data.get('city', instance.city) instance.country = validated_data.get('country', instance.country) instance.image = validated_data.get('image', instance.image) instance.lon = validated_data.get('lon', instance.lon) instance.lat = validated_data.get('lat', instance.lat) #instance.host = validated_data.get('host.username',instance.host) #new fields instance.heat = validated_data.get('heat', instance.heat) instance.area = validated_data.get('area', instance.area) instance.beds = validated_data.get('beds', instance.beds) instance.bedrooms = validated_data.get('bedrooms', instance.bedrooms) instance.bathrooms = validated_data.get('bathrooms', instance.bathrooms) instance.transport_desc = validated_data.get('transport_desc', instance.transport_desc) instance.house_type = validated_data.get('house_type', instance.house_type) instance.people_num = validated_data.get('people_num', instance.people_num) instance.people_max = validated_data.get('people_max', instance.people_max) instance.rules = validated_data.get('rules', instance.rules) instance.plus_cost = validated_data.get('plus_cost', instance.plus_cost) instance.av_from = validated_data.get('av_from', instance.av_from) instance.av_to = validated_data.get('av_to', instance.av_to) instance.save() return instance
class CommentSerializer(serializers.ModelSerializer): author = UserSerializer(read_only=True) review = ReviewSerializer(read_only=True) class Meta: model = Comment fields = '__all__'
def test_admin_list(self): url = reverse("reviews:admin-list") response = self.client.get(url, HTTP_AUTHORIZATION='Token {}'.format( self.reviewer1.token), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) reviewer = Reviewer.objects.get(id=self.reviewer1.id) reviewer.is_staff = True reviewer.save() response = self.client.get(url, HTTP_AUTHORIZATION='Token {}'.format( self.reviewer1.token), content_type='application/json') queryset = Review.objects.all() review_serializer = ReviewSerializer(queryset, many=True) self.assertEqual(review_serializer.data, response.json()['reviews']) self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_retrieve(self): review = Review.objects.create(rating=1, summary="Some summary", title="mock title", reviewer=self.reviewer1, company=self.company1) url = reverse("reviews:retrieve", kwargs={"review_id": review.id}) response = self.client.get(url, HTTP_AUTHORIZATION='Token {}'.format( self.reviewer1.token), content_type='application/json') review = Review.objects.get(id=response.json()['review']['id']) review_serializer = ReviewSerializer(review) reviewer_serializer = ReviewerSerializer(self.reviewer1) self.assertEqual(reviewer_serializer.data, response.json()['review']['reviewer']) self.assertEqual(review_serializer.data, response.json()['review']) self.assertEqual(response.status_code, status.HTTP_200_OK) """ Tests forbidden review if reviewer is not owner """ response = self.client.get(url, HTTP_AUTHORIZATION='Token {}'.format( self.reviewer2.token), content_type='application/json') self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
class UserSerializer(serializers.ModelSerializer): mybook = MyBookSerializer(many=True, read_only=True, required=False, source="mybook_set") review = ReviewSerializer(many=True, read_only=True, required=False, source="review_set") class Meta: model = User fields = ( "id", "username", "nickname", "created_at", "mybook", "review", ) read_only_fields = ( "id", "created_at", "mybook", "review", ) depth = 1
class StoreDetailSerializer(serializers.ModelSerializer): category = CategorySerializer() options = serializers.StringRelatedField(many=True) reviews = ReviewSerializer(many=True, read_only=True) menus = MenuSerializer(many=True, read_only=True) business_hours = BusinessHourSerializer(many=True, read_only=True) class Meta: model = Store fields = ( 'id', 'name', 'category', 'description', 'lon', 'lat', 'thumbnail', 'contact', 'road_addr', 'common_addr', 'addr', 'tags', 'price_avg', 'partner', 'review_cnt', 'view_cnt', 'menus', 'reviews', 'options', 'business_hours', )
def get_reviews(self, obj): show_reviews = self.context.get('show_reviews') request = self.context.get('request') if show_reviews and request: reviews = obj.reviews.filter(author__user=request.user) return ReviewSerializer(reviews, many=True).data return []
def test_validate_calendar_initial_date(self): """ Now() should be grater than calendar.initial_date """ # Set the initial_date 10 days ahead self.order.calendar.initial_date = (now() + timedelta(days=10)).date() self.order.calendar.save() with self.assertRaisesMessage( ValidationError, "{'non_field_errors': ['La orden no cumple con los " "requerimientos para crear un review']}"): serializer = ReviewSerializer(data=self.data) serializer.context = self.context serializer.is_valid(raise_exception=True)
def get(self, request, *args, **kwargs): self.serializer_class = RestaurantSerializer search_string = self.request.query_params.get('search') type_string = self.request.query_params.get('type') if type_string == 'restaurants': response = Restaurant.objects.filter( Q(name__icontains=search_string) | Q(city__icontains=search_string) | Q(category__icontains=search_string)) serializer = RestaurantSerializer(response, many=True) return Response(serializer.data) elif type_string == 'user': self.serializer_class = UserSerializer response = User.objects.filter( Q(username__icontains=search_string) | Q(first_name__icontains=search_string) | Q(last_name__icontains=search_string)) serializer = UserSerializer(response, many=True) return Response(serializer.data) elif type_string == 'review': self.serializer_class = ReviewSerializer response = Review.objects.filter( Q(restaurant__icontains=search_string) | Q(user__icontains=search_string) | Q(content__icontains=search_string)) serializer = ReviewSerializer(response, many=True) return Response(serializer.data) return Response("Search type doesn't exist")
def test_validate_reply(self): """ Test can't change reply """ # Arrangement review = Review.objects.create(rating=5, activity=self.activity, author=self.author, reply='Replied') data = {'reply': 'Replied updated'} with self.assertRaisesMessage( ValidationError, "{'reply': ['No se puede cambiar la respuesta']}"): serializer = ReviewSerializer(review, data=data, partial=True) serializer.is_valid(raise_exception=True)
def reviews(self, request, pk=None): serializer_context = { 'request': request, } queryset = Review.objects.filter(item=pk) serializer = ReviewSerializer(instance=queryset, many=True, context=serializer_context) return Response(serializer.data)
def create(self, request): """ Function: Create a review HTTP Verb: POST Endpoint: /reviews """ review_serializer = ReviewSerializer(data=request.data) if (review_serializer.is_valid()): review_serializer.save() response = Response([review_serializer.data], status=status.HTTP_201_CREATED) else: response = Response(review_serializer.errors, status=status.HTTP_400_BAD_REQUEST) return response
class ProductSerializer(ModelSerializer): properties = PropertySerializer(many=True) attributes = ProductAttributeSerializer(many=True) reviews = ReviewSerializer(read_only=True, many=True) class Meta: model = Product fields = [ 'id', 'slug', 'title', 'brand', 'image', 'description', 'type', 'gender', 'price', 'properties', 'attributes', 'featured', 'active', 'timestamp', 'rating', 'reviews', 'url' ]
class ItemSerializer(serializers.HyperlinkedModelSerializer): reviews = ReviewSerializer(many=True, read_only=True) attachments = AttachmentSerializer(many=True, read_only=True) created_by = serializers.HiddenField( default=serializers.CurrentUserDefault()) id = serializers.IntegerField() # parser_classes = (MultiPartParser, FormParser) class Meta: model = Item #fields = ('url', 'id', 'title', 'description', 'price', 'created_date', 'created_by', 'updated_date', 'reviews', 'attachments') fields = "__all__"
def review_list(self, request): if request.method == 'GET': queryset = Review.objects.all() serializer = ReviewSerializer(queryset, many=True) return JsonResponse(serializer.data, safe=False) elif request.method == 'POST': data = JSONParser().parse(request) serializer = ReviewSerializer(data=data) if serializer.is_valid(): serializer.save() return JsonResponse(serializer.data, status=201) return JsonResponse(serializer.errors, status=400)
def test_company_owner_review_list(self): url = reverse("reviews:create", kwargs={"company_id": self.company1.id}) response = self.client.get(url, HTTP_AUTHORIZATION='Token {}'.format( self.reviewer1.token), content_type='application/json') queryet = Review.objects.filter(reviewer=self.reviewer1, company=self.company1) review_serializer = ReviewSerializer(queryet, many=True) self.assertEqual(review_serializer.data, response.json()['reviews']) self.assertEqual(response.status_code, status.HTTP_200_OK)
def list(self, request): """ Function: List all existing survivors.\n HTTP Verb: GET Endpoint: /reviews Returns: List with all the reviews of the current user """ queryset = Review.objects.filter(reviewer=request.user) serializer = ReviewSerializer(queryset, many=True) response = Response(serializer.data, status=status.HTTP_200_OK) return response
def get(self, request): name = request.GET.get('product') if name: try: product = Product.objects.get(name__icontains=name) except Product.DoesNotExist: return Response({'error': "Produto não cadastrado ou mal formatado"}, status=status.HTTP_404_NOT_FOUND) product_serializer = ProductSerializer(product) reviews = product.reviews.all() reviews_serializer = ReviewSerializer(reviews, many=True) return Response({**product_serializer.data, "reviews": reviews_serializer.data}) else: return Response({'message': 'Keyword "product" não encontrado'}, status=status.HTTP_404_NOT_FOUND)
def reviews(self, request, slug=None): company = self.get_object() reviews = Review.objects.filter( company=company).order_by('-created_date').select_related( 'job', 'company') location = self.request.query_params.get('location', None) title = self.request.query_params.get('title', None) if location: reviews = reviews.filter(job__location=location) if title: reviews = reviews.filter(job__title=title) page = self.paginate_queryset(reviews) review_serializer = ReviewSerializer(page, many=True) return self.get_paginated_response(review_serializer.data)
def test_create(self): """ Test create a review with the serializer """ serializer = ReviewSerializer(data=self.data) serializer.context = self.context serializer.is_valid(raise_exception=True) serializer.save() self.assertTrue(Review.objects.filter(**self.data).exists()) # Check the permissions perms = ('reviews.report_review', 'reviews.reply_review', 'reviews.read_review') self.activity.organizer.user.has_perms(perms)
class MyBookSerializer(serializers.ModelSerializer): book = BookSerializer(read_only=True) isbn = serializers.CharField(max_length=13, write_only=True) owner = serializers.SlugRelatedField( slug_field="nickname", queryset=User.objects.all(), required=False ) review = ReviewSerializer( many=True, read_only=True, required=False, source="book.review_set" ) class Meta: model = MyBook fields = ( "id", "created_at", "owner", "book", "isbn", "review", ) read_only_fields = ("id", "created_at", "owner", "book", "review") depth = 1 ref_name = "shelf_mybook_serializer" def validate_isbn(self, value): request = self.context.get("request", None) owner = request.user if len(value) != 13: raise serializers.ValidationError("ISBN은 13글자 숫자로 이루어진 문자열이어야 합니다.") if MyBook.objects.filter(book__pk=value, owner__username=owner).exists(): raise serializers.ValidationError("책장에 이미 존재하는 책입니다.") if not Book.objects.filter(isbn=value).exists(): raise serializers.ValidationError("잘못된 ISBN입니다.") try: int(value) except ValueError: raise serializers.ValidationError("ISBN은 13글자 숫자로 이루어진 문자열이어야 합니다.") def create(self, validate_data): request = self.context.get("request", None) isbn = self.initial_data["isbn"] book = Book.objects.get(isbn=isbn) mybook = MyBook(book=book, owner=request.user) mybook.save() return mybook
def test_change_replied_at(self): """ Shouldn't be able to change the replied_at date if is set """ replied_at = datetime.datetime(2015, 11, 8, 3, 30, 0, tzinfo=utc) review = ReviewFactory(reply='Replied', replied_at=replied_at) serializer = ReviewSerializer(review, data={'rating': 2}, partial=True) serializer.is_valid(raise_exception=True) serializer.save() review = Review.objects.get(id=review.id) self.assertEqual(review.replied_at, replied_at)