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)