def post(self, request, place_id, format=None):
"""
Creates a Review
"""
try:
place = Place.objects.get(id=place_id)
except ObjectDoesNotExist:
raise NotFound(detail="Place not found")
data = JSONParser().parse(request)
if 'user_id' not in data:
raise ParseError(detail="Missing user_id", code=400)
try:
user = User.objects.get(id=data['user_id'])
except ObjectDoesNotExist:
raise NotFound(detail="User not found")
if 'text' not in data:
raise ParseError(detail="Missing text", code=400)
data["place"] = place.id
data["user"] = user.id
serializer = ReviewSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_validate_beyond_five_rating(self):
self.data['rating'] = 6
serializer = ReviewSerializer(data=self.data)
self.assertIsInstance(serializer, serializers.ModelSerializer)
self.assertFalse(serializer.is_valid())
self.assertEqual(len(serializer.errors.get('rating')), 1)
def test_validate_invalid_ip_address(self):
self.data['ip_address'] = '127,0,0,1'
serializer = ReviewSerializer(data=self.data)
self.assertIsInstance(serializer, serializers.ModelSerializer)
self.assertFalse(serializer.is_valid())
self.assertEqual(len(serializer.errors.get('ip_address')), 1)
def test_to_internal_value_adds_ip_and_reviewer(
self, mock_req):
user = factories.UserFactory(username='******')
mock_req.META = {
'HTTP_X_FORWARDED_FOR': '192.0.0.1',
'REMOTE_ADDR': '142.0.0.1'
}
mock_req.user = user
mock_req.versionong_scheme.get_versioned_viewname.return_value = ''
s = ReviewSerializer(context={'request': mock_req}, partial=True)
data = {
"rating": 5,
"title": "test title",
"summary": "test summary",
}
expected_ret = {
"rating": 5,
"title": "test title",
"summary": "test summary",
"ip_address": "192.0.0.1",
"reviewer": user.reviewer
}
ret = s.to_internal_value(data)
self.assertEqual(ret, expected_ret)
def test_validate_long_summary(self):
self.data['summary'] = ''.join(['a' for i in range(10001)])
serializer = ReviewSerializer(data=self.data)
self.assertIsInstance(serializer, serializers.ModelSerializer)
self.assertFalse(serializer.is_valid())
self.assertEqual(len(serializer.errors.get('summary')), 1)
def test__get_request_user_no_reviewer(self, mock_req):
user = factories.UserFactory(username='******', reviewer=None)
mock_req.user = user
s = ReviewSerializer(context={'request': mock_req})
with self.assertRaises(ValidationError):
s._get_request_user()
def post(self, request):
data = json.loads(request.body)
serializer = ReviewSerializer(data=data)
if not serializer.is_valid():
return JsonResponse({'errors': serializer.errors},
status=status_codes.HTTP_400_BAD_REQUEST)
clean_data = serializer.validated_data
business = User.objects.filter(
username=clean_data['business_username'],
is_business=True).first()
if not business:
return JsonResponse({'errors': 'Business ID Provided is invalid'},
status=status_codes.HTTP_403_FORBIDDEN)
user = User.objects.get(id=request.user.id)
if not user:
return JsonResponse(
{'error': 'user not found'},
status=status_codes.HTTP_500_INTERNAL_SERVER_ERROR)
model = BusinessReviews(
user_id=request.user.id,
user_name=user.name,
business_username=clean_data['business_username'],
review_text=clean_data['review_text'],
stars=clean_data['stars'])
model.save()
return JsonResponse({'data': model.to_dict()},
status=status_codes.HTTP_200_OK)
def post(self, request, *args, **kwargs):
data = request.data
data['ip_address'] = request.META.get('REMOTE_ADDR')
serializer = ReviewSerializer(data=data)
if serializer.is_valid():
serializer.save(user=request.user)
return Response(serializer.data, status.HTTP_201_CREATED)
return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
def test_validate_long_title(self):
self.data[
'title'] = 'This is a very very very very very very very very very long title'
serializer = ReviewSerializer(data=self.data)
self.assertIsInstance(serializer, serializers.ModelSerializer)
self.assertFalse(serializer.is_valid())
self.assertEqual(len(serializer.errors.get('title')), 1)
def post(self, request, pk):
request.data['movie_id']=pk
serializer = ReviewSerializer(data=request.data)
if serializer.is_valid():
# serializer.movie_id = pk
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def test__get_ip_address_from_request_no_match(self, mock_req):
mock_req.META = {
'HTTP_X_FORWARDED_FOR': '',
'REMOTE_ADDR': ''
}
s = ReviewSerializer(context={'request': mock_req})
expected_ret = ''
ret = s._get_ip_address_from_request()
self.assertEqual(ret, expected_ret)
def test__get_request_user_known_user(self, mock_req):
user = factories.UserFactory(username='******')
reviewer = user.reviewer
mock_req.user = user
s = ReviewSerializer(context={'request': mock_req})
expected_ret = reviewer
ret = s._get_request_user()
self.assertEqual(ret, expected_ret)
def create(self, request):
serializer = ReviewSerializer(data=request.data)
if serializer.is_valid():
serializer.save(card_id=request.data['card'])
card = Card.objects.get(pk=request.data['card'])
card.review(request.data['answer_quality'])
card.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test__get_ip_address_from_request_client_forward(self, mock_req):
mock_req.META = {
'HTTP_X_FORWARDED_FOR': '192.0.0.1',
'REMOTE_ADDR': '142.0.0.1'
}
s = ReviewSerializer(context={'request': mock_req})
expected_ret = '192.0.0.1'
ret = s._get_ip_address_from_request()
self.assertEqual(ret, expected_ret)
def post(self, request):
request.data["reviewer"] = request.user.id
ip = get_client_ip(request)[0]
request.data["ip"] = self.convert_ip(ip)
serializer = ReviewSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({'error': serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def critical(self, request):
critical_reviews = get_users_critical_reviews(request.user)
page = self.paginate_queryset(critical_reviews)
if page is not None:
serializer = ReviewSerializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = ReviewSerializer(critical_reviews, many=True)
return Response(serializer.data)
def put(self, request, review_id):
review = self.get_object(review_id)
request.data["reviewer"] = request.user.id
ip = get_client_ip(request)[0]
request.data["ip"] = self.convert_ip(ip)
serializer = ReviewSerializer(instance=review, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response({'error': serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def test__get_request_user_anon_user(self, mock_req):
# set the property, then reset when done
user = factories.UserFactory(username='******', reviewer=None)
type(user).is_anonymous = mock.PropertyMock(return_value=True)
mock_req.user = user
s = ReviewSerializer(context={'request': mock_req})
with self.assertRaises(ValidationError):
s._get_request_user()
type(user).is_anonymous = mock.PropertyMock(return_value=False)
def get(self, request, **kwargs):
if kwargs.get('review_id') is None:
review_queryset = Review.objects.all()
review_queryset_serializer = ReviewSerializer(review_queryset,
many=True)
return Response(review_queryset_serializer.data,
status=status.HTTP_200_OK)
else:
review_id = kwargs.get('review_id')
review_serializer = ReviewSerializer(
Review.objects.get(review_id=review_id))
return Response(review_serializer.data, status=status.HTTP_200_OK)
def createReview(request, pk):
if request.user.is_anonymous == False:
serializer = ReviewSerializer(data=request.data)
if serializer.is_valid():
product = Product.objects.get(id=pk)
serializer.save(user=request.user, product=product)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors,
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
return Response(status=status.HTTP_401_UNAUTHORIZED)
def test_deserialize_data(self):
serializer = ReviewSerializer(data=self.data)
self.assertIsInstance(serializer, serializers.ModelSerializer)
self.assertTrue(serializer.is_valid())
validated_data = serializer.validated_data
self.assertEqual(validated_data.get('title'), 'My review')
self.assertEqual(validated_data.get('summary'),
'This is my first review.')
self.assertEqual(validated_data.get('rating'), 1)
self.assertEqual(validated_data.get('ip_address'), '127.0.0.1')
self.assertEqual(validated_data.get('company'), 'Some Company')
self.assertEqual(validated_data.get('reviewer'), 'Some Reviewer')
def get(self, request):
if request.user.is_staff == 1:
reviews = Review.objects.all()
serializer = ReviewSerializer(reviews, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
return Response({'details': 'permission denied'},
status=status.HTTP_403_FORBIDDEN)
def get(self, request):
if request.user.is_superuser:
reviews = Review.objects.all()
else:
reviews = Review.objects.filter(reviewer=request.user)
serializer = ReviewSerializer(reviews, many=True)
return Response(serializer.data)
def book_detail(request, book_id):
try:
book = Book.objects.get(id=book_id)
except Book.DoesNotExist as e:
return Response({'error': str(e)})
if request.method == 'GET':
serializer = BookSerializer(book)
return Response(serializer.data)
elif request.method == 'POST':
serializer = ReviewSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({'error': serializer.errors},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
elif request.method == 'PUT':
serializer = BookSerializer(instance=book, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response({'error': serializer.errors})
elif request.method == 'DELETE':
book.delete()
return Response({'deleted': True})
def get_user_reviews(request):
if request.method == 'GET':
if request.user.is_anonymous:
return Response(status=status.HTTP_401_UNAUTHORIZED)
else:
reviews = Review.objects.for_user(request.user)
serializer = ReviewSerializer(reviews, many=True)
return Response(serializer.data)
def get(self, request, **kwargs):
user_id = request.GET.get('user_id', '00000000000')
review_queryset = Review.objects.filter(
user_id=user_id).order_by('date')
review_queryset_serializer = ReviewSerializer(review_queryset,
many=True)
return Response(review_queryset_serializer.data,
status=status.HTTP_200_OK)
def get(self, request):
try:
reviews = Review.objects.all()
serializer = ReviewSerializer(reviews, many=True)
return Response(serializer.data, status=status.HTTP_200_OK)
except:
return Response({"error": "Error getting reviews"},
status=status.HTTP_404_NOT_FOUND)
def get_reviews(request, pk):
try:
product = Product.objects.get(id=pk)
reviews = product.reviews.all()
serializer = ReviewSerializer(reviews, many=True)
return Response(serializer.data)
except Product.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
def get(self, request, review_id, format=None):
""" Retrieves a specific Review """
try:
review = Review.objects.get(id=review_id)
except ObjectDoesNotExist:
raise NotFound(detail="Review not found")
return Response(ReviewSerializer(review).data)
def update(self, request, pk):
review = Review.objects.for_user(self.request.user).get(id=pk)
review.text = request.data['text']
review.save()
serializer = ReviewSerializer(review)
logger.debug(f'Review {serializer.instance} was updated')
logger.info(f'Review {serializer.instance} was updated')
return Response(serializer.data)