示例#1
0
def create_recipe(request):
    args = {'form': CreationFormRecipe}
    args.update(csrf(request))

    if request.method == 'POST':
        form = CreationFormRecipe(request.POST, request.FILES)
        print(request.FILES)

        if form.is_valid():
            data = form.data

            new_recipe = Recipe(
                recipe_name=data['recipe_name'],
                recipe_description=data['recipe_description'],
                recipe_ingredients=data['recipe_ingredients'],
                recipe_steps=data['recipe_steps'],
                recipe_photo=request.FILES['recipe_photo'],
                recipe_type_of_meal=data['recipe_type_of_meal'],
                recipe_author=User.objects.get(user_nickname='Антон'))
            new_recipe.save()

            return redirect('/recipe/')
    else:
        form = CreationFormRecipe()

    return render(request, 'recipes/create_recipe.html', args)
示例#2
0
    def create(self, validated_data):
        """
        Create a recipe instance.
        """
        username = validated_data['user']
        try:
            user = User.objects.get(username=username)
        except User.DoesNotExist:
            raise NotFound(detail='User not found.')

        name = validated_data['name']
        try:
            obj = Recipe.objects.get(user=user)
            raise ValidationError('recipe already exists for this user.')
        except Recipe.DoesNotExist:
            recipe = Recipe(name=name, user=user)
            recipe.save()

        steps = validated_data['steps']
        if steps:
            for step in steps:
                obj = Step(name=step, recipe=recipe)
                obj.save()

        ingredients = validated_data['ingredients']
        if ingredients:
            for ingredient in ingredients:
                obj = Ingredient(name=ingredient, recipe=recipe)
                obj.save()

        return recipe
示例#3
0
def test_partial_update(factory: APIRequestFactory, recipe: Recipe) -> None:
    """
    Test API client can update one or more recipe's fields
    """

    # Test data
    data = {"title": "Sausages With Potato Salad & Caramelised Onion"}

    # build url
    url = reverse("recipe-detail", args=(recipe.pk, ))

    # Create request object
    request = factory.patch(url, data, format="json")

    # Make request to api view
    view = RecipeViewSet.as_view(actions={"patch": "partial_update"})
    response = view(request, pk=recipe.pk)

    old_title = recipe.title
    recipe.refresh_from_db()  # Pull latest update from database after update

    # Test if request was successful
    assert response.status_code == 200

    # Test updated field are returned
    assert response.data == data

    # Test recipe title was updated
    assert old_title != recipe.title
示例#4
0
def recipeAdd(request):
	if request.method != 'POST':
		return sendError('No post request')

	if request.POST['name'] is None:
		return sendError('Name not defined')

	recipeIngredients = request.POST.getlist('ingredients', None)

	ingredientSet = checkIngredient(recipeIngredients)

	if ingredientSet is False:
		return sendError('Ingredients error')

	newRecipe = Recipe(name=request.POST['name'],
					   description=request.POST.get('description', None),
					   preparationTime=request.POST.get('preparationTime', None),
					   backingTime=request.POST.get('backingTime', None),
					   howmanypeoples=request.POST.get('howmanypeoples', None))

	newRecipe.save()

	for ingredient in ingredientSet:
		Recipe_Ingredient.objects.create(ingredient=ingredient,
										 recipe=newRecipe,
										 quantity=1)

	return sendResponse(json.dumps({'status': 'success', 'id': newRecipe.id}))
示例#5
0
 def get(self, request, *args, **kwargs):
     for i in range(2, 120):
         try:
             url_list = 'https://eda.ru/recepty?page=' + str(i)
             resp = requests.get(url_list)
             soup = BeautifulSoup(resp.text)
             items = soup.findAll('h3', {'class': 'item-title'})
             urls = [
                 'https://eda.ru/' + [child
                                      for child in item.children][1]['href']
                 for item in items
             ]
             for url in urls:
                 resp = requests.get(url)
                 soup = BeautifulSoup(resp.text)
                 title = soup.find('h1', {
                     'class': 'recipe__name'
                 }).text.strip()
                 steps = [[child for child in step.children][-1]
                          for step in soup.findAll(
                              'span', {'class': 'instruction__description'})
                          ]
                 recipe = Recipe(name=title)
                 recipe.save()
                 for step in steps:
                     Instruction(step=step, recipe=recipe).save()
         except Exception as e:
             pass
     return HttpResponse('ok')
示例#6
0
文件: utils.py 项目: Fizz11/scale
def create_recipe(recipe_type=None, data=None, event=None, is_superseded=False, superseded=None):
    """Creates a recipe for unit testing

    :returns: The recipe model
    :rtype: :class:`recipe.models.Recipe`
    """

    if not recipe_type:
        recipe_type = create_recipe_type()
    if not data:
        data = {}
    if not event:
        event = trigger_test_utils.create_trigger_event()
    if is_superseded and not superseded:
        superseded = timezone.now()

    recipe = Recipe()
    recipe.recipe_type = recipe_type
    recipe.recipe_type_rev = RecipeTypeRevision.objects.get_revision(recipe_type.id, recipe_type.revision_num)
    recipe.event = event
    recipe.data = data
    recipe.is_superseded = is_superseded
    recipe.superseded = superseded
    recipe.save()

    return recipe
示例#7
0
def postrecipe(request):
    if request.method == 'POST':
        recipe_name = request.POST['recipe_name']
        recipe_posted_by = request.user.id
        recipe_des = request.POST['recipe_des']
        recipe_preptime = request.POST['recipe_preptime']
        recipe_cooktime = request.POST['recipe_cooktime']
        recipe_des = request.POST['recipe_des']
        recipe_img1 = request.FILES.get('recipe_img1')
        recipe_img2 = request.FILES.get('recipe_img2')
        recipe_img3 = request.FILES.get('recipe_img3')
        recipe_img4 = request.FILES.get('recipe_img4')
        recipe_servings = request.POST['recipe_servings']
        recipe_cat = request.POST['category']

        data = Recipe(recipe_name=recipe_name,
                      recipe_posted_by=User.objects.get(pk=recipe_posted_by),
                      recipe_des=recipe_des,
                      recipe_preptime=recipe_preptime,
                      recipe_cooktime=recipe_cooktime,
                      recipe_img1=recipe_img1,
                      recipe_img2=recipe_img2,
                      recipe_img3=recipe_img3,
                      recipe_img4=recipe_img4,
                      recipe_servings=recipe_servings,
                      recipe_cat=Category.objects.get(pk=recipe_cat))
        data.save()
        return render(request, 'recipe/post.html',
                      {'success': 'Recipe Posted Successfully'})

    else:
        catdata = Category.objects.all()
        return render(request, 'recipe/post.html', {'catdata': catdata})
示例#8
0
def add_recipe(request):
    if request.method == "GET":
        return render(request, "add_recipe.html", context={"form": NewRecipeForm()})
    if request.method == "POST":
        form = NewRecipeForm(request.POST)
        if form.is_valid():
            recipe = Recipe(name=form.cleaned_data['name'], ingredients=form.cleaned_data['ingredients'], method=form.cleaned_data['method'])
            recipe.save()
    return render(request, "add_recipe.html", context={"form": form})
示例#9
0
文件: utils.py 项目: droessne/scale
def create_recipe(recipe_type=None, data=None, event=None, is_superseded=False, superseded=None):
    """Creates a recipe for unit testing

    :returns: The recipe model
    :rtype: :class:`recipe.models.Recipe`
    """

    if not recipe_type:
        recipe_type = create_recipe_type()
    if not data:
        data = {}
    if not event:
        event = trigger_test_utils.create_trigger_event()
    if is_superseded and not superseded:
        superseded = timezone.now()

    recipe = Recipe()
    recipe.recipe_type = recipe_type
    recipe.recipe_type_rev = RecipeTypeRevision.objects.get_revision(recipe_type.id, recipe_type.revision_num)
    recipe.event = event
    recipe.data = data
    recipe.is_superseded = is_superseded
    recipe.superseded = superseded
    recipe.save()

    return recipe
示例#10
0
def create_recipe(recipe_type=None, data=None, event=None):
    '''Creates a job type model for unit testing

    :param recipe_type: The associated recipe type
    :type recipe_type: :class:'recipe.models.RecipeType'
    :param data: The associated data for the recipe
    :type data: dict
    :param event: The associated event
    :type event: :class:'trigger.models.TriggerEvent'
    :returns: The recipe model
    :rtype: :class:`recipe.models.Recipe`
    '''

    if not data:
        data = {}

    if not recipe_type:
        recipe_type = create_recipe_type()

    if not event:
        event = trigger_test_utils.create_trigger_event()

    recipe = Recipe()
    recipe.recipe_type = recipe_type
    recipe.recipe_type_rev = RecipeTypeRevision.objects.get_revision(
        recipe_type.id, recipe_type.revision_num)
    recipe.event = event
    recipe.data = data
    recipe.save()

    return recipe
 def create_recipe(self):
     self.new_recipe = Recipe(name="testrecipe",
                              date_created=datetime.now(),
                              created_by=self.user.id,
                              date_modified=datetime.now())
     db.session.add(self.new_recipe)
     db.session.commit()
示例#12
0
文件: utils.py 项目: cshamis/scale
def create_recipe(recipe_type=None, data=None, event=None):
    '''Creates a job type model for unit testing

    :param recipe_type: The associated recipe type
    :type recipe_type: :class:'recipe.models.RecipeType'
    :param data: The associated data for the recipe
    :type data: dict
    :param event: The associated event
    :type event: :class:'trigger.models.TriggerEvent'
    :returns: The recipe model
    :rtype: :class:`recipe.models.Recipe`
    '''

    if not data:
        data = {}

    if not recipe_type:
        recipe_type = create_recipe_type()

    if not event:
        event = trigger_test_utils.create_trigger_event()

    recipe = Recipe()
    recipe.recipe_type = recipe_type
    recipe.recipe_type_rev = RecipeTypeRevision.objects.get_revision(recipe_type.id, recipe_type.revision_num)
    recipe.event = event
    recipe.data = data
    recipe.save()

    return recipe
示例#13
0
def create_rec_obj(r):
    name = r["Recipe Name"]
    img_url = r["Recipe Photo"]
    author = r["Author"] 
    prepare_time = r["Prepare Time"] 
    cook_time = r["Cook Time"] 
    total_time = r["Total Time"] 
    directions = r["Directions"] 
    ingredients_list = r["Ingredients"]
    rec = Recipe(name = name, img_url = img_url, author = author, prepare_time = prepare_time, cook_time = cook_time, total_time = total_time, directions = directions, ingredients_list = ingredients_list)
    return rec
示例#14
0
    def test_create_recipe(self):
        recipe = Recipe()
        recipe.title = 'Recipechik'
        recipe.text = 'Some text'
        recipe.timestamp = timezone.now()

        recipe.save()

        all_recipes = Recipe.objects.all()
        the_recipe = Recipe.objects.get(id=recipe.id)
        self.assertEqual(the_recipe.text, recipe.text)
def recipe():
    ingredient = Ingredient()
    ingredient.name = "test_name_ingredient"
    ingredient.amount = "test_amount_ingredient"
    ingredient.save()

    user = User()
    user.name = 'test_name'
    user.email = "*****@*****.**"
    user.password = "******"
    user.save()

    recipe = Recipe()
    recipe.recipe_name = 'test_recipe'
    recipe.preparation_mode = 'test_preparation_mode'
    recipe.chef = user
    recipe.save()
    recipe.ingredient.add(ingredient)
    return recipe
示例#16
0
def edit_recipe(request, recipe_id):
    if recipe_id is not None:
        recipe = get_object_or_404(Recipe, id=recipe_id)
    else:
        recipe = Recipe(author=request.user)
    editor = RecipeEditor(recipe, request)
    if recipe.author != request.user:
        return HttpResponseForbidden()
    if request.method == 'GET':
        return editor.render_get()
    elif request.method == 'POST':
        form = editor.validate_recipe_with_form()
        if form:
            form.save()
            editor.update_recipe_image()
            editor.create_recipe_tags()
            editor.create_recipe_ingredients()
            return redirect(
                reverse('single_page', kwargs=dict(recipe_id=recipe.id)))
        else:
            return editor.render_get(errors=editor.form_validation_errors)
示例#17
0
 def get(self, request, format=None):
     h = datetime.now().hour
     r = Recommend.get_recommend_by_hour(h)
     recommend = []
     recipe_json = RecipeSerializer(r, many=True).data
     for item in recipe_json:
       item['recommendtype'] = 0
       recommend.append(item)
     for item in RecommendArticle.objects.all():
       article_json = ArticleSerializer(item.article).data
       article_json['recommendtype'] = 1
       recommend.append(article_json)
     for item in RecommendSeries.objects.all():
       series_json = SeriesSerializer(item.series).data
       series_json['recommendtype'] = 2
       recommend.append(series_json)
     result = {
         'recommend': recommend,
         'theme': [ThemeSerializer(t.theme).data for t in RecommendTheme.objects.all()],
         'update': RecipeSerializer(Recipe.get_latest_recipe(), many=True).data,
         }
     return self.success_response(result)
示例#18
0
    def test_creating_a_new_recipe(self):
        # Create a new recipe object with its recipe.

        recipe = Recipe()
        recipe.title = "What's up?"
        recipe.description = "This is a goldarn recipe."
        recipe.author = UserFactory.create()
        recipe.created = timezone.now()

        # Check if we can save it to the db
        recipe.save()

        # Now check if we can find it in the db again
        all_recipes_in_db = Recipe.objects.all()
        self.assertEqual(len(all_recipes_in_db), 1)
        only_recipe_in_db = all_recipes_in_db[0]
        self.assertEqual(only_recipe_in_db, recipe)

        # And check that it has saved its two attrbs, question and pub_date
        self.assertEqual(only_recipe_in_db.title, recipe.title)
        self.assertEqual(only_recipe_in_db.description, recipe.description)
    def handle(self, *args, **options):
        with open('fixtures/recipe_fixture.json') as file:
            recipe_fixture = json.load(file)
            directions = defaultdict(list)
            ingredients = defaultdict(list)
            recipes = []
            for key in recipe_fixture.keys():

                recipe = recipe_fixture[key]
                ingredients[recipe['name']] = recipe['ingredients']
                for d in recipe['instructions'].split('.'):
                    directions[recipe['name']].append(d)

                recipes.append(Recipe(
                    name=recipe['name'],
                    servings=recipe['servings'],
                    cook_time=recipe['cook_time'],
                    prep_time=recipe['prep_time'],
                ))

            recipes_created = Recipe.objects.bulk_create(recipes, ignore_conflicts=True)
            recipes_qs = Recipe.objects.filter(name__in=[recipe.name for recipe in recipes_created])

            ingredient_amts_to_create = []

            directions_to_create = []

            for r in recipes_qs:
                r_dirs = directions[r.name]
                for d in r_dirs:
                    directions_to_create.append(Direction(recipe=r, text=d, name=d))

                r_ings = ingredients[r.name]
                for i in r_ings:
                    if i:
                        i_split = i.split(' ')
                        nums = list(filter(lambda x: hasNumbers(x), i_split))
                        amt = Fraction('0/1')
                        if nums:
                            try:
                                amt = reduce(lambda x,y: Fraction(x) + Fraction(y), nums, Fraction('0/1'))
                            except ValueError:
                                pass
                        i_unit = i_split[len(nums)] if amt else None
                        b = int(bool(amt))
                        i_name = ' '.join(i_split[len(nums)+b:])
                        # print(amt, i_unit, i_name)
                        if i_unit:
                            unit, created = Unit.objects.get_or_create(name=i_unit, type=2, system=1)
                        else:
                            unit = None
                        ing, created = Ingredient.objects.get_or_create(name=i_name)
                        ingredient_amts_to_create.append(IngredientAmount(unit=unit, recipe=r, ingredient=ing, amount=Decimal(float(amt))))
            # IngredientAmount.objects.bulk_create(ingredient_amts_to_create, ignore_conflicts=True)

            # for el in ingredient_amts_to_create:
            #     i_a = IngredientAmount.objects.get(recipe=el.recipe,
            #           ingredient=el.ingredient)
            #     i_a.unit = el.unit
            #     i_a.save()

            directions_created = Direction.objects.bulk_create(directions_to_create, ignore_conflicts=True)


            file.close()
示例#20
0
    def post(self, request):
        rec = Recipe()
        rec.name = request.POST['name']
        if request.POST['note']:
            rec.note = request.POST['note']
        rec.description = request.POST['description']
        rec.servings = int(request.POST['servings'])
        prep, prep_min = parseTimes(request.POST['prep'],
                                    request.POST['prepTimeUnit'])
        cook, cook_min = parseTimes(request.POST['cook'],
                                    request.POST['cookTimeUnit'])
        rec.prep = prep
        rec.cook = cook
        rec.total_min = prep_min + cook_min
        image = request.FILES["image-file"]
        fs = FileSystemStorage()
        name = id_generator() + image.name
        filename = fs.save(name, image)
        rec.images = filename
        rec.rate = 0
        rec.user = request.user
        rec.save()

        img = ImageRecipe()
        img.recipe = rec
        img.images = filename
        img.save()

        categorys = request.POST['category']
        categorys = categorys.split(',')
        for i in categorys:
            if i.strip() == '':
                continue
            cate = Category()
            cate.recipe = rec
            cate.name = i.strip()
            cate.save()

        ingredients = request.POST['ingredient']
        ingredients = ingredients.split('\n')
        for i in ingredients:
            if i.strip() == '':
                continue
            ing = Ingredient()
            ing.recipe = rec
            ing.content = i.strip()
            ing.save()

        direction = request.POST['direction']
        direction = direction.split('\n')
        for i in direction:
            if i.strip() == '':
                continue
            dire = Direction()
            dire.recipe = rec
            dire.content = i.strip()
            dire.save()
        return HttpResponseRedirect('/share_recipe')
示例#21
0
文件: utils.py 项目: sau29/scale
def create_recipe(recipe_type=None, input=None, event=None, is_superseded=False, superseded=None,
                  superseded_recipe=None, config=None, batch=None, save=True):
    """Creates a recipe for unit testing

    :returns: The recipe model
    :rtype: :class:`recipe.models.Recipe`
    """

    if not recipe_type:
        recipe_type = create_recipe_type_v6()
    if not input:
        input = {}
    if not event:
        event = trigger_test_utils.create_trigger_event()
    if is_superseded and not superseded:
        superseded = timezone.now()

    recipe = Recipe()
    recipe.recipe_type = recipe_type
    recipe.recipe_type_rev = RecipeTypeRevision.objects.get_revision(recipe_type.name, recipe_type.revision_num)
    recipe.event = event
    recipe.input = input
    recipe.is_superseded = is_superseded
    recipe.superseded = superseded
    recipe.batch = batch
    recipe.configuration = config
    if superseded_recipe:
        root_id = superseded_recipe.root_superseded_recipe_id
        if root_id is None:
            root_id = superseded_recipe.id
        recipe.root_superseded_recipe_id = root_id
        recipe.superseded_recipe = superseded_recipe

    if save:
        recipe.save()

    return recipe
示例#22
0
    def handle(self, *args, **kwargs):
        self.stdout.write("Ouverture du fichier de sauvegarde et restauration \
en cours. Merci de patienter...")
        directory_path = kwargs['path'][0]
        add_media = kwargs['add_media'][0]
        if 'database.json' not in os.listdir(directory_path):
            if 'recipe' not in os.listdir(directory_path):
                cmd1 = f"cd {directory_path}"
                cmd2 = "unzip backup_db.zip"
                os.system(f"{cmd1} && {cmd2}")
                if add_media == 'add-media':
                    os.system(
                        f"mv {directory_path}recipe \"{settings.MEDIA_ROOT}\"")

        jsonfile_path = directory_path + 'database.json'
        with open(jsonfile_path, 'r') as jsonfile:
            data = json.load(jsonfile)

            for mlp in data['meals_per_day']:
                try:
                    MealsPerDay.objects.get(name=mlp)
                except:
                    new_mlp = MealsPerDay(name=mlp)
                    new_mlp.save()
                    if kwargs['verbose']:
                        self.stdout.write(
                            f"{self.style.SUCCESS(new_mlp.name)} \
ajouté à la base de données")

            for food_group in data['food_groups']:
                try:
                    FoodGroup.objects.get(name=food_group)
                except:
                    new_f_g = FoodGroup(name=food_group)
                    new_f_g.save()
                    if kwargs['verbose']:
                        self.stdout.write(
                            f"{self.style.SUCCESS(new_f_g.name)} \
ajouté à la base de données")

            for food in data['foods']:
                try:
                    Food.objects.get(name=food['name'])
                except:
                    new_food = Food()
                    for k, v in food.items():
                        if k == 'group_name':
                            new_food.id_group = FoodGroup.objects.get(name=v)
                        else:
                            setattr(new_food, k, v)
                    new_food.save()
                    if kwargs['verbose']:
                        self.stdout.write(
                            f"{self.style.SUCCESS(new_food.name)} \
ajouté à la base de données")

            for categ in data['recipe_categories']:
                try:
                    CategorieRecipe.objects.get(name=categ['name'])
                except:
                    new_categ = CategorieRecipe()
                    new_categ.name = categ['name']
                    new_categ.image_active = categ['image_active']
                    new_categ.image_not_active = categ['image_not_active']
                    new_categ.save()
                    if kwargs['verbose']:
                        self.stdout.write(
                            f"{self.style.SUCCESS(new_categ.name)} \
ajouté à la base de données")

            for origin in data['origins_recipe']:
                try:
                    OriginRecipe.objects.get(name=origin)
                except:
                    new_origin = OriginRecipe(name=origin)
                    new_origin.save()
                    if kwargs['verbose']:
                        self.stdout.write(
                            f"{self.style.SUCCESS(new_origin.name)} \
ajouté à la base de données")

            for level in data['levels']:
                try:
                    Level.objects.get(name=level)
                except:
                    new_level = Level(name=level)
                    new_level.save()
                    if kwargs['verbose']:
                        self.stdout.write(
                            f"{self.style.SUCCESS(new_level.name)} \
ajouté à la base de données")

            for price_scale in data['price_scales']:
                try:
                    PriceScale.objects.get(name=price_scale)
                except:
                    new_p_s = PriceScale(name=price_scale)
                    new_p_s.save()
                    if kwargs['verbose']:
                        self.stdout.write(
                            f"{self.style.SUCCESS(new_p_s.name)} \
ajouté à la base de données")

            for utensil in data['utensils']:
                try:
                    Utensil.objects.get(name=utensil)
                except:
                    new_u = Utensil(name=utensil)
                    new_u.save()
                    if kwargs['verbose']:
                        self.stdout.write(f"{self.style.SUCCESS(new_u.name)} \
ajouté à la base de données")

            for season in data['seasons']:
                try:
                    Season.objects.get(name=season)
                except:
                    new_s = Season(name=season)
                    new_s.save()
                    if kwargs['verbose']:
                        self.stdout.write(f"{self.style.SUCCESS(new_s.name)} \
ajouté à la base de données")

            for diet in data['diets']:
                try:
                    DietaryPlan.objects.get(name=diet['name'])
                except:
                    new_d = DietaryPlan(name=diet['name'],
                                        description=diet['desc'])
                    new_d.save()
                    if kwargs['verbose']:
                        self.stdout.write(f"{self.style.SUCCESS(new_d.name)} \
ajouté à la base de données")

            for allergie in data['allergies']:
                try:
                    Allergie.objects.get(name=allergie)
                except:
                    new_a = Allergie(name=allergie)
                    new_a.save()
                    if kwargs['verbose']:
                        self.stdout.write(f"{self.style.SUCCESS(new_a.name)} \
ajouté à la base de données")

            for recipe in data['recipes']:
                r_origin = OriginRecipe.objects.get(name=recipe['origin'])
                r_price_scale = PriceScale.objects.get(
                    name=recipe['price_scale'])
                r_level = Level.objects.get(name=recipe['level'])

                categories = set()
                for categ in recipe['categories']:
                    c = CategorieRecipe.objects.get(name=categ)
                    categories.add(c)

                utensils = set()
                for utensil in recipe['utensils']:
                    u = Utensil.objects.get(name=utensil)
                    utensils.add(u)

                seasons = set()
                for season in recipe['season']:
                    s = Season.objects.get(name=season)
                    seasons.add(s)

                diets = set()
                for diet in recipe['dietary_plan']:
                    d = DietaryPlan.objects.get(name=diet)
                    diets.add(d)

                try:
                    new_r = Recipe.objects.get(name=recipe['name'])
                    state = 'modifiée'
                except:
                    new_r = Recipe()
                    state = 'ajoutée'

                new_r.name = recipe['name']
                new_r.preparation_time = recipe['preparation_time']
                new_r.cooking_time = recipe['cooking_time']
                new_r.step = recipe['step']
                new_r.tip = recipe['tip']
                new_r.portion = recipe['portion']
                new_r.point = recipe['point']
                new_r.typical_recipe_city = recipe['typical_recipe_city']
                new_r.source = recipe['source']
                new_r.image = recipe['image']
                new_r.origin = r_origin
                new_r.price_scale = r_price_scale
                new_r.level = r_level
                new_r.save()

                new_r.categories.set(categories)
                new_r.utensils.set(utensils)
                new_r.season.set(seasons)
                new_r.dietary_plan.set(diets)

                for food in recipe['food']:
                    f = Food.objects.get(name=food['name'])
                    fq = FoodAndQuantity()
                    fq.food = f
                    fq.recipe = new_r
                    fq.recipe_quantity = food['recipe_quantity']
                    fq.recipe_unity = food['recipe_unity']
                    fq.food_purchase_quantity = food['purchase_quantity']
                    fq.food_purchase_unity = food['purchase_unity']
                    fq.save()

                if kwargs['verbose']:
                    self.stdout.write(
                        f"{self.style.SUCCESS(new_r.name)} {state} à la base de données"
                    )
示例#23
0
def scrap_recipe_from_url(url):
	
	#fake test
	#url = 'https://www.marmiton.org/recettes/recette_bruschetta-aux-aubergines_47116.aspx'

	recipe = Recipe()
	recipe.url = url
	recipe.save() #force save to add children

	#get page
	response = requests.get(url)
	soup = BeautifulSoup(response.text, "html.parser")

	#detect the domain and get appropriate tags
	domain_name = url.split('/')[2]

	if (domain_name == 'www.marmiton.org'):
		allItems = soup.findAll("li", {"class": "recipe-preparation__list__item"})
		allIngredientQty = soup.findAll("span", {"class": "recipe-ingredient-qt"})
		allIngredientUnitAndNames = soup.findAll("span", {"class": "ingredient"})
		#allImages = soup.findAll("img", {"id": "recipe-media-viewer-main-picture"})
		imageDiv = soup.find("div", {"class": "recipe-media-viewer-media-container"})
		allImages = imageDiv.findAll("img")
		if (len(allImages) >0):
			img_url = allImages[0]['data-src']
	elif (domain_name == 'www.cuisineaz.com'):
		allItems = soup.findAll("p", {"class": "p10"})
		ingredientSection = soup.find("section", {"class": "large-4 medium-4 small-12 columns recipe_ingredients"})
		allIngredientQty = ingredientSection.findAll("span")
		allIngredientUnitAndNames = 'MANUAL'
		allImages = soup.findAll("img", {"id": "ContentPlaceHolder_recipeImg"})
		if (len(allImages) >0):
			img_url = allImages[0]['data-src']

	#get title
	allTitles = soup.findAll('h1')
	allTitles
	#recipe.name = 'fake name'
	recipe.name = allTitles[0].contents[0].strip()

	#TODO detect url domain, and store list of tags


	#get items list
	#allItems = soup.findAll("li", {"class": "recipe-preparation__list__item"})
	#current_item_tag = allItems[0]
	i=0
	for current_item_tag in allItems:
		currentListContent = ''
		for current_content in current_item_tag.contents:
			currentListContent =  current_content
		if i==0:
			recipe.description = '*' + currentListContent
		else:
			recipe.description = recipe.description + '\n' + currentListContent
		i=i+1

	#INGREDIENTS
	#allIngredientQty = soup.findAll("span", {"class": "recipe-ingredient-qt"})
	#allIngredientUnitAndNames = soup.findAll("span", {"class": "ingredient"})

	#loop on ingredient
	i=0
	for current_ingredient_qty in allIngredientQty:
		
		#print('ouuuuuuu')
		#print(current_ingredient_qty.contents)
		if(len(current_ingredient_qty.contents)<0):
			break
		#if(len(current_ingredient_qty.contents)==1):
			#<span>400g de semoule de blé complète</span>
			#currentQty=1
			#currentUnitAndName = current_ingredient_qty.contents[0]
		else:
			currentQty = current_ingredient_qty.contents[0]
			#currentUnitAndName = allIngredientUnitAndNames[i].contents[0]
			
			#for some sites we need to split 
			if (allIngredientUnitAndNames == 'MANUAL'):
				currentUnitAndName = current_ingredient_qty.contents[0]

				#KO for 60g without space
				number = re.search('^\d+', currentUnitAndName)
				if(number is None):
					#'sel, poivre'
					currentQty = 1
				else:
					currentQty = number.group(0)
					currentUnitAndName = currentUnitAndName[number.end():]



				#currentQty = current_ingredient_qty.contents[0].split(' ')[0]
				#currentUnitAndName = current_ingredient_qty.contents[0].split(' ', 1)[1]
			else:
				currentUnitAndName = allIngredientUnitAndNames[i].contents[0]
			#avoid non integer values in crappy websites

			#check if fraction?
			#if ('/' in currentQty):
			#	myFraction = Fraction(currentQty)
			#	currentQty = float(myFraction)

		#currentQty = math.ceil(float(currentQty))


		#TODO get ingredient by name or create it
		ingredient = Ingredient()
		ingredient.name=currentUnitAndName
		ingredient.save()

		#init ingredient qty object and add it to recipe
		ingredientQty = IngredientQuantity()
		ingredientQty.ingredient = ingredient
		ingredientQty.quantity = currentQty
		ingredientQty.recipe = recipe
		ingredientQty.save()

		i = i+1

	#image
	#allImages = soup.findAll("img", {"id": "recipe-media-viewer-main-picture"})
	if (len(allImages) >0):
		#img_url = allImages[0]['src']
		#recipe.comment = img_url

		# Steam the image from the url
		#request = requests.get(img_url, stream=True)
		
		# Get the filename from the url, used for saving later
		file_name = img_url.split('/')[-1]
		#content = urllib.request.urlretrieve(img_url)
		#recipe.image.save(file_name, File(open(content[0])), save=True)

		

		# save in the ImageField
		result = urllib.request.urlretrieve(img_url) # image_url is a URL to an image
		recipe.image.save(
    		file_name,
    		File(open(result[0], 'rb'))
    	)

		#SECOND ATTEMPT
		#request = requests.get(img_url, stream=True)
		#file = tempfile.NamedTemporaryFile()
		#request.raw.decode_content = True
		#shutil.copyfileobj(request.raw, file)
		#recipe.image = request.raw

	#recipe.name = 'fake name'
	recipe.save()
	return recipe
示例#24
0
def add_recipe():
    with open("recipe_final.json", 'r') as f:
        data = json.load(f)

    user = User.objects.get(id=user_id)
    for idx, dt in enumerate(data):
        path_imgs, _ = get_list_images(os.path.join('images',dt['id']))
        # print(len(path_imgs))
        print(dt['name'])
        rec = Recipe()
        rec.name = dt['name']
        rec.user = user
        rec.servings = int(dt['servings'])
        rec.prep = dt['prep']
        # rec.cook = request.POST['cook']
        rec.total = dt['total']
        rec.total_min = parseTimes(dt['total'])
        rec.note = dt['notes']
        rec.rate = 0
        rec.description = dt['description']
        filename = os.path.join('images', dt['images'].split('%')[-1])
        rec.images = filename
        rec.save()

        for i in path_imgs:
            img = ImageRecipe()
            img.recipe = rec
            img.images = i.replace('images/','')
            img.save()

        categorys = dt['category']
        for i in categorys:
            cate = Category()
            cate.recipe = rec
            cate.name = i
            cate.save()

        ingredients = dt['ingredients']
        for i in ingredients:
            ing = Ingredient()
            ing.recipe = rec
            ing.content = i
            ing.save()

        ing_food = IngredientList(dt['ingredients'])
        for i in ing_food.all:
            math_food = MatchFood()
            math_food.recipe = rec
            math_food.food = Food.objects.get(id=i.matched_food.id)
            math_food.save()

        direction = dt['directions']
        for i in direction:
            dire = Direction()
            dire.recipe = rec
            dire.content = i
            dire.save()
        if idx == 100: break
示例#25
0
from recipe.models import Recipe
Recipe(name="Chorizo & mozzarella gnocchi bake", ingredients="""    1 tbsp olive oil
    1 onion , finely chopped
    2 garlic cloves , crushed
    120g chorizo , diced
    2 x 400g cans chopped tomatoes
    1 tsp caster sugar
    600g fresh gnocchi
    125g mozzarella ball, cut into chunks
    small bunch of basil , torn
    green salad , to serve""".replace("\n", "").strip(), method="""
    Heat the oil in a medium pan over a medium heat. Fry the onion and garlic for 8-10 mins until soft. Add the chorizo and fry for 5 mins more. Tip in the tomatoes and sugar, and season. Bring to a simmer, then add the gnocchi and cook for 8 mins, stirring often, until soft. Heat the grill to high.
    Stir ¾ of the mozzarella and most of the basil through the gnocchi. Divide the mixture between six ovenproof ramekins, or put in one baking dish. Top with the remaining mozzarella, then grill for 3 mins, or until the cheese is melted and golden. Season, scatter over the remaining basil and serve with green salad.""".strip()).save()

Recipe(name="Easy butter chicken", ingredients="""    500g skinless boneless chicken thighs

For the marinade

    1 lemon, juiced
    2 tsp ground cumin
    2 tsp paprika
    1-2 tsp hot chilli powder
    200g natural yogurt

For the curry

    2 tbsp vegetable oil
    1 large onion, chopped
    3 garlic cloves, crushed
    1 green chilli, deseeded and finely chopped (optional)
    thumb-sized piece ginger, grated