def post(self, request, format=None):
serializer = RecipeSerializer(data=request.data,
context={'request': request})
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 add(request):
data = JSONParser().parse(request)
serializer = RecipeSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors)
def put(self, request, user_id, format=None):
recipe = self.get_object(user_id)
serializer = RecipeSerializer(recipe, 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_filter_recipes_by_ingredients(self):
"""Returning recipes with specific ingredients"""
recipe_one = sample_recipe(user=self.user,
title='Thai Vegetable Curry')
recipe_two = sample_recipe(user=self.user, title='Aubergine Tahini')
ingredient_one = sample_ingredient(user=self.user, name='Curry')
ingredient_two = sample_ingredient(user=self.user, name='Tahini')
recipe_one.ingredients.add(ingredient_one)
recipe_two.ingredients.add(ingredient_two)
recipe_three = sample_recipe(user=self.user, title='Fish and Chips')
res = self.client.get(
RECIPES_URL,
{'ingredients': f'{ingredient_one.id},{ingredient_two.id}'})
serializer_one = RecipeSerializer(recipe_one)
serializer_two = RecipeSerializer(recipe_two)
serializer_three = RecipeSerializer(recipe_three)
self.assertIn(serializer_one.data, res.data)
self.assertIn(serializer_two.data, res.data)
self.assertNotIn(serializer_three.data, res.data)
def post(self, request):
# TODO: Restrict a doctor to specify the `is_accepted` field.
try:
if request.data['doctor'] != str(request.user.id):
return Response(
{
"doctor":
["Only the creator of the recipe can be the doctor."]
},
status=status.HTTP_400_BAD_REQUEST,
)
except KeyError:
return Response(
{"doctor": ["This field is required."]},
status=status.HTTP_400_BAD_REQUEST,
)
serializer = RecipeSerializer(data=request.data)
if not serializer.is_valid():
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST,
)
serializer.save()
return Response(
serializer.data,
status=status.HTTP_201_CREATED,
)
def patch(self, request, pk):
# TODO: Restrict a doctor to modify the `is_accepted` field.
"""
This method works only for doctors.
A doctor can modify fields and assign
a patient to the recipe to be accepted/declined.
"""
recipe = self.get_object(pk)
if recipe.doctor != request.user:
return Response(status=status.HTTP_404_NOT_FOUND, )
if recipe.is_accepted is not None:
return Response(
{
"is_accepted":
["Can't modify the accepted/declined recipe."]
},
status=status.HTTP_400_BAD_REQUEST,
)
serializer = RecipeSerializer(recipe, data=request.data)
if not serializer.is_valid():
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST,
)
serializer.save()
return Response(serializer.data)
def put(self, request, pk, format=None):
recipe = Recipe.objects.get(pk=pk)
serializer = RecipeSerializer(recipe, data=request.data, partial=True)
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 put(self, request, pk, format=None):
recipe = Recipe.objects.get(pk=pk)
serializer = RecipeSerializer(recipe, data=request.data, partial=True)
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 post(self, request):
data = JSONParser().parse(request)
serializer = RecipeSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data,
status=status.HTTP_201_CREATED)
return JSONResponse(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def test_serializer_create(self):
recipe_data, expected_recipe = get_recipe_data_flat('frozen_pizza')
serializer = RecipeSerializer(data=recipe_data)
self.assertTrue(serializer.is_valid())
recipe = serializer.save()
ingredient_amounts = get_ingredient_amounts(recipe)
self.compare_object_values(recipe, expected_recipe)
for i, ingredient in enumerate(recipe_data['ingredients']):
self.compare_object_values(ingredient_amounts[i], ingredient)
def test_serializer_update_recipe(self):
recipe_data, _ = get_recipe_data_flat('lekker')
recipe_data['instructions'] = "Stir well for 20 minutes"
recipe, _ = Recipe.recipes.get(pk=self.lekker.pk)
serializer = RecipeSerializer(recipe, data=recipe_data)
self.assertTrue(serializer.is_valid())
recipe = serializer.save()
self.compare_object_values(recipe,
get_recipe_no_ingredients(recipe_data))
def test_data_serializer(self):
recipe_data, expected_recipe = get_recipe_data_flat('frozen_pizza')
serializer = RecipeSerializer(data=recipe_data)
self.assertTrue(serializer.is_valid())
serializer_recipe = get_recipe_no_ingredients(serializer.data)
self.compare_values(serializer_recipe, expected_recipe)
for i, ingredient in enumerate(recipe_data['ingredients']):
self.compare_values(serializer.validated_data['ingredients'][i],
ingredient)
def patch(self, request, pk):
try:
data = Recipe.objects.get(pk=pk)
except Recipe.DoesNotExist:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
parsed_data = JSONParser().parse(request)
serializer = RecipeSerializer(data, data=parsed_data, partial=True)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data)
return JSONResponse(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def test_serializer_update_recipe_ingredients(self):
recipe_data, expected_recipe = get_recipe_data_flat('lekker')
recipe_data['ingredients'][1]['ingredient']['name'] = "onion"
recipe_data['ingredients'][1]['ingredient']['plural'] = "onions"
recipe, _ = Recipe.recipes.get(pk=self.lekker.pk)
serializer = RecipeSerializer(recipe, data=recipe_data)
self.assertTrue(serializer.is_valid())
recipe = serializer.save()
ingredient_amounts = get_ingredient_amounts(recipe)
self.compare_object_values(recipe, expected_recipe)
for i, ingredient in enumerate(recipe_data['ingredients']):
self.compare_object_values(ingredient_amounts[i], ingredient)
def recipe_detail(request, pk, format=None): # pylint: disable=redefined-builtin,invalid-name,unused-argument
"""
Retrieve, update or delete a recipe.
"""
try:
recipe, ingredient_amounts = Recipe.recipes.get(pk=pk)
except Recipe.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
serializer = RecipeSerializer(
dict(recipe=recipe, ingredients=ingredient_amounts))
return Response(serializer.data)
if request.method == 'PUT':
serializer = RecipeSerializer(recipe, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(RecipeSerializer(serializer.validated_data).data,
status=status.HTTP_204_NO_CONTENT)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
if request.method == 'DELETE':
recipe.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
return None
def create(self, request, *args, **kwargs):
data = request.data
author = request.user.pk
recipe_serializer = RecipeSerializer(data={
'author': author,
**request.data
})
if recipe_serializer.is_valid():
recipe_serializer.save()
return Response(recipe_serializer.data)
else:
return Response(recipe_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
class BookmarkSerializer(serializers.ModelSerializer):
# 2018.11.16
# Remove 'user' field from the Bookmark API response.
# user = UserSerializer(read_only=True)
recipe = RecipeSerializer(read_only=True)
class Meta:
model = Bookmark
fields = (
'id',
'recipe',
'collection',
'created_date',
)
def validate_collection(self, collection):
user = self.context['request'].user
if not user.collection_set.filter(id=collection.pk):
raise CustomAPIException(
status_code=status.HTTP_403_FORBIDDEN,
detail='collection does not belong to request user',
collection_pk=collection.pk)
return collection
def get(self, request, pk):
try:
data = Recipe.objects.get(pk=pk)
except Recipe.DoesNotExist:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
serializer = RecipeSerializer(data)
return JSONResponse(serializer.data)
def test_filter_recipes_by_tags(self):
"""Test retrieving filtered list of recipes by tag"""
recipe1 = sample_recipe(user=self.user, title='Pastel de papas')
recipe2 = sample_recipe(user=self.user, title='Spaghetti bolognese')
recipe3 = sample_recipe(user=self.user, title='Ensalada sin carne')
tag1 = sample_tag(user=self.user, name='tasty')
tag2 = sample_tag(user=self.user, name='amazing')
recipe1.tags.add(tag1)
recipe2.tags.add(tag2)
res = self.client.get(RECIPES_URL, {'tags': f'{tag1.id},{tag2.id}'})
serializer1 = RecipeSerializer(recipe1)
serializer2 = RecipeSerializer(recipe2)
serializer3 = RecipeSerializer(recipe3)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
def recipe(request, pk):
try:
recipe = Recipe.objects.get(id=pk)
serializer = RecipeSerializer(recipe)
return Response(serializer.data)
except Recipe.DoesNotExist:
return Response(status=404)
def to_representation(self, instance):
ret = super().to_representation(instance)
# bookmarked_recipe_list = []
# for i in ret['bookmarked_recipe']:
# # nested 구조로 serializer가 데이터를 받지 않아서 아래 주석처리
# # object = Recipe.objects.get(pk=i['recipe'])
# object = Recipe.objects.get(pk=i)
# bookmarked_recipe_list.append(object)
# 위 4줄 -> 1줄 축약
bookmarked_recipe_list = Recipe.objects.filter(
pk__in=ret['bookmarked_recipe'])
# 방법 1) informal way
# serializer = RecipeSerializer(bookmarked_recipe_list, many=True)
# serializer._context = self.context
# 아래코드로는 AttributeError: can't set attribute 발생
# _context, context 차이?
# serializer.context = self.context
# 방법 2) formal way
# context = self.context
# serializer = RecipeSerializer(bookmarked_recipe_list, many=True, context=context)
# 변경 3)
# iOS 요청으로 일단 auth_user_like_state, auth_user_bookmark_state를
# null로 표시되도록 임시 변경
serializer = RecipeSerializer(bookmarked_recipe_list, many=True)
del ret['bookmarked_recipe']
ret['bookmarked_recipe'] = serializer.data
return ret
def test_recipe_serialization__no_desired_yield(self):
"""
Verify that MultipliedRecipe without a multiplier passed in is the same as a standard serialized Recipe
"""
multiplied_data = MultipliedRecipeSerializer(self.recipe).data
recipe_data = RecipeSerializer(self.recipe).data
self.assertCountEqual(multiplied_data, recipe_data)
def recipe_list_ethnicity(request):
# GET all recipes by ethnicity
recipes = Recipe.objects.filter(published=True)
if request.method == 'GET':
recipes_serializer = RecipeSerializer(recipes, many=True)
return JsonResponse(recipes_serializer.data, safe=False)
class DrinkSerializer(serializers.ModelSerializer):
recipes = RecipeSerializer(many=True, read_only=True)
class Meta:
model = Drink
fields = ('id', 'name', 'volume', 'recipes')
def test_get_valid_single_recipe(self):
response = client.get(
reverse('recipes:recipe', kwargs={'pk': self.recipe.id}))
recipe = Recipe.objects.get(pk=self.recipe.id)
serializer = RecipeSerializer(recipe, many=False)
self.assertEqual(response.data, serializer.data)
def get(self, request, pk):
recipe = self.get_object(pk)
if recipe.doctor != request.user and recipe.patient != request.user:
raise Http404
serializer = RecipeSerializer(recipe)
return Response(serializer.data)
def test_filter_recipes_by_tags(self):
recipe1 = sample_recipe(user=self.user, title="Thai vegetable curry")
recipe2 = sample_recipe(user=self.user, title="Aubergine with tahini")
tag1 = sample_tag(user=self.user, name="Vegan")
tag2 = sample_tag(user=self.user, name="Vegetarian")
recipe1.tags.add(tag1)
recipe2.tags.add(tag2)
recipe3 = sample_recipe(user=self.user, title="Fish and chips")
res = self.client.get(RECIPE_URL, {"tags": f"{tag1.id},{tag2.id}"})
serializer1 = RecipeSerializer(recipe1)
serializer2 = RecipeSerializer(recipe2)
serializer3 = RecipeSerializer(recipe3)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
class UserSerializer(serializers.ModelSerializer):
meals = MealSerializer(many=True)
recipes = RecipeSerializer(many=True)
class Meta:
model = User
fields = ('id', 'username', 'first_name', 'last_name', 'meals',
'recipes')
def recipe_detail(request, pk):
# find recipe by pk (id)
try:
recipe = Recipe.objects.get(pk=pk)
except Recipe.DoesNotExist:
return JsonResponse({'message': 'The recipe does not exist'},
status=status.HTTP_404_NOT_FOUND)
# GET / PUT / DELETE recipe
if request.method == 'GET':
recipe_serializer = RecipeSerializer(recipe)
return JsonResponse(recipe_serializer.data)
elif request.method == 'PUT':
recipe_data = JSONParser().parse(request)
recipe_serializer = RecipeSerializer(recipe, data=recipe_data)
if recipe_serializer.is_valid():
recipe_serializer.save()
return JsonResponse(recipe_serializer.data)
return JsonResponse(recipe_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
recipe.delete()
return JsonResponse({'message': 'recipe was deleted successfully!'},
status=status.HTTP_204_NO_CONTENT)
def test_filter_recipes_by_ingredients(self):
recipe1 = sample_recipe(user=self.user, title="Posh beans on toast")
recipe2 = sample_recipe(user=self.user, title="Chicken cacciatore")
ingredient1 = sample_ingredient(user=self.user, name="Feta cheese")
ingredient2 = sample_ingredient(user=self.user, name="Chicken")
recipe1.ingredients.add(ingredient1)
recipe2.ingredients.add(ingredient2)
recipe3 = sample_recipe(user=self.user, title="Steak and mushrooms")
res = self.client.get(
RECIPE_URL, {"ingredients": f"{ingredient1.id},{ingredient2.id}"})
serializer1 = RecipeSerializer(recipe1)
serializer2 = RecipeSerializer(recipe2)
serializer3 = RecipeSerializer(recipe3)
self.assertIn(serializer1.data, res.data)
self.assertIn(serializer2.data, res.data)
self.assertNotIn(serializer3.data, res.data)
def test_read_recipe(self):
recipe = Recipe.objects.create(name='Bread',
description='Put it in the oven')
Ingredient.objects.create(recipe=recipe, name='dough')
recipe = Recipe.objects.get(pk=1)
serializer = RecipeSerializer(recipe)
response = self.client.get('/api/v1/recipes/1/') # urlresolver
self.assertEqual(response.data, serializer.data)
def post(self, request, format=None):
serializer = RecipeSerializer(data=request.data, context={'request': request})
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)
