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 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)