def new_smoothie(): if not request.json or not 'name' in request.json: abort(400) if Smoothie.query.filter_by(name=request.json["name"]).first() is not None: return { "error": "Smoothie {} already present in application".format( request.json["name"]) }, 400 smoothie = Smoothie() smoothie.import_data(request.json) for new_ingredient in request.json["ingredients"]: ingredient = Ingredient() # Check if ingredient is already in the database if Ingredient.query.filter_by(name=new_ingredient).first() is None: ingredient.import_data(new_ingredient) db.session.add(ingredient) else: ingredient = Ingredient.query.filter_by( name=new_ingredient).first() smoothie.recipe.append(ingredient) db.session.add(smoothie) db.session.commit() return {}, 201
def create_ingredients(request): add_ingredient_form = AddIngredientForm(request.POST) if add_ingredient_form.is_valid(): ingredient_name = add_ingredient_form.cleaned_data['name'] add_ingredient_form.fields.pop('name') nutrient = add_ingredient_form.save() ingredient = Ingredient(name=ingredient_name, nutrient=nutrient) try: ingredient.save() edit_icon_html = _get_edit_icon_html() remove_icon_html = _get_remove_icon_html() return JsonResponse( { 'ingredient': ingredient.to_dict(), 'ingredient_actions': edit_icon_html + remove_icon_html }, status=200) except IntegrityError: return JsonResponse( {'errors': { 'name': [u'Ingredient already exists.'] }}, status=400) return JsonResponse({'errors': add_ingredient_form.errors}, status=400)
def test_equality(self): a = Ingredient.from_params('vodka', alcoholic=True, abs=40) b = Ingredient.from_params('vodka1', alcoholic=True, abs=40) c = Ingredient.from_params('vodka2', alcoholic=False) self.assertEqual(a, a) self.assertNotEqual(a,b) self.assertNotEqual(a,c)
def setUp(self): super().setUp() self.ingredient = Ingredient.from_params('water', alcoholic=False) self.ingredient2 = Ingredient.from_params('wine', alcoholic=True, abs=5) self.drink_component = DrinkComponent.from_params(self.ingredient, 200) self.drink_component2 = DrinkComponent.from_params( self.ingredient2, 100)
def test_ingredient_repr(self): u = push_dummy_user() list_ = push_dummy_list(u, 'List') a = Food(list_id=list_.id, name='Food') db.session.add(a) db.session.commit() ing = Ingredient(food_id=a.id, name='Ingredient') db.session.add(ing) db.session.commit() self.assertEqual(ing.__repr__(), '<Ingredient Ingredient of Food Food>')
def index(self): shared_ingredients = Ingredient.load_all_shared(renamed=True) if current_user.is_authenticated: users_ingredients = Ingredient.load_all_by_author(current_user.username) self.ingredients = users_ingredients + shared_ingredients self.diets = current_user.active_diets else: self.ingredients = shared_ingredients self.diets = None return self.template()
def add_recipes(data_format): """ Add a new recipe """ form = AddRecipeFrom(request.form) if request.method == "POST": # if data_format == "json": # user_data = request.json # schema = CreateRecipeSchema() # result = schema.load(user_data) # db.session.add(result) # db.session.commit() # else: recipe = Recipe( name=form.name.data, method=form.method.data, preparation_time=form.preparation_time.data, ) if request.files: image = request.files["picture"] image.save( os.path.join(app.config["IMAGE_UPLOADS"], image.filename)) recipe.picture = image.filename db.session.add(recipe) db.session.commit() ingredients_to_add = get_ingredients(form.ingredients.data) for name in ingredients_to_add: product = db.session.query(Product).filter_by( name=name).first() if not product: product = Product() product.name = name db.session.add(product) db.session.commit() ingredient = Ingredient() ingredient.product_id = product.product_id ingredient.recipe_id = recipe.recipe_id db.session.add(ingredient) db.session.commit() return redirect("/recipes") return render_template("addRecipe.html", form=form, selected_menu="recipes")
def post(self): form = IngredientForm(request.form) if not form.validate_on_submit(): save_form_to_session(request.form) return redirect(url_for("IngredientView:new")) ingredient = Ingredient(author=current_user) form.populate_obj(ingredient) ingredient.save() return redirect( url_for("IngredientView:show", id=ingredient.id, from_new=True))
def new(self): from app.helpers.general import list_without_duplicated active_diets = current_user.active_diets user_ingredients = Ingredient.load_all_by_author(current_user.username) shared_ingredients = Ingredient.load_all_shared(renamed=True) ingredients = user_ingredients + shared_ingredients self.ingredients = list_without_duplicated(ingredients) self.preset_ingredients = request.args.get("preset_ingredient_ids", []) self.diets = active_diets self.is_trialrecipe = False return self.template()
def add_recipe(client, submitted_by_user_id, name='TestRecipe', instructions='Do Stuff', servings=2, follow_redirects=True): onion = Ingredient(name='onion', quantity_type='Cup', calories_per_serving=50) chicken = Ingredient(name='Chicken', quantity_type='Pound', calories_per_serving=75) return client.post( 'recipes', data=dict(submitted_by_user_id=submitted_by_user_id, name=name, instructions=instructions, servings=servings), follow_redirects=follow_redirects )
def addToIngredients(): form = IngredientForm() form['csrf_token'].data = request.cookies['csrf_token'] if form.validate_on_submit(): ingredient = Ingredient( name=form.data['name'], type=form.data['type'], editable=True, ) db.session.add(ingredient) db.session.commit() # print(ingredient) return ingredient.to_dict() return {'errors': validation_errors_to_error_messages(form.errors)}, 401
def post(self): form = IngredientForm(request.form) if not form.validate_on_submit(): save_form_to_session(request.form) return redirect(url_for("IngredientView:new")) ingredient = Ingredient(author=current_user.username) form.populate_obj(ingredient) if ingredient.save(): return redirect(url_for("IngredientView:show", id=ingredient.id)) else: flash("Nepodařilo se vytvořit surovinu", "error") return redirect(url_for("IngredientView:new"))
def admin_add_ingredient(): ingredient = Ingredient(name=request.json['ingredient_name'], ingredient_type=request.json['ingredient_type']) db.session.add(ingredient) db.session.commit() return ingredient_schema.dump(ingredient)
def add_current_user_ingredients(): user = current_user print(request.json) ing = None ingredient_id = request.json.get('id') if ingredient_id != None: ing = Ingredient.query.get_or_404(ingredient_id) ingredient_name = request.json.get('name').lower() if ingredient_name != None: ing = Ingredient.query.filter_by(name=ingredient_name).first() else: print("Ingredient name not found") if ing == None: print("Ingredient not found") ing = Ingredient(name=ingredient_name) db.session.add(ing) if user.is_authenticated: if ing not in user.ingredients: user.ingredients.append(ing) db.session.commit() print("Adding ingredient") return jsonify(user.to_dict()), 201 else: # User is a guest user ingredients = get_guest_ingredients() if ing not in ingredients: ingredients.append(ing) set_guest_ingredients(ingredients) print("Added ingredient to guest") return jsonify(guest_to_dict())
def newIngredients(): """ Add new ingredient """ if request.method == "POST": # store ingredient data from form name = request.form.get('ingredient') product_code = request.form.get('productcode') group = request.form.get('ingredientType') protein = request.form.get('protein') carbs = request.form.get('carbohydrates') sugars = request.form.get('sugars') fat = request.form.get('fats') saturates = request.form.get('saturates') fibre = request.form.get('fibre') salt = request.form.get('salt') sodium = request.form.get('sodium') #enter ingredient into database ingredient = Ingredient(name=name, product_code=product_code, group=group, protein=protein, carbohydrates=carbs, sugars=sugars, fats=fat, saturates=saturates, fibre=fibre, salt=salt, sodium=sodium) db.session.add(ingredient) db.session.commit() flash('Ingredient added') return redirect(url_for('ingredients.showIngredients'))
def upload_json(): """Upload a json file to fill the database""" form = UploadCSV() if form.validate_on_submit(): # Get dictionary out of the file content = form.csv_file.data.stream.read().decode("utf-8") recipe_json = json.loads(content) # Save every entry as recipe for rp_dict in recipe_json['all_recipes']: # Check if Recipe with same name already exists if Recipe.query.filter_by(name=rp_dict['name']).all(): continue else: # Save the Recipe recipe = Recipe(name=rp_dict['name'], desc=rp_dict['desc'], user_id=current_user.id) db.session.add(recipe) db.session.commit() recipe_saved = Recipe.query.filter_by( name=rp_dict['name']).first() for ing in rp_dict['ing'].keys(): new_ing = Ingredient(recipe_key=recipe_saved.key, name=ing, quantity=rp_dict['ing'][ing]) db.session.add(new_ing) db.session.commit() return redirect(url_for('main.index')) return render_template('main/json_upload.html', form=form)
def parse_ingredients(ingredients): return_list = [] ing_list = ingredients.split('\r\n') for ing in ing_list: # check database if this ingredient exists already # use api to get nutritional data ingredient = Ingredient(name=ing, serving_amount=am, serving_unit=unit, calories=calories, carbs=carbs, protein=protein, fat=fat) db.session.add(ingredient) db.session.commit() ingredient_dict = { 'id': Ingredient.query.order_by(Ingredient.id.desc()).first().id, 'amount': am, 'unit': unit } return_list.append(ingredient_dict) return return_list
def ingredients(): form = AddIngredientForm() if form.validate_on_submit(): ingredient = Ingredient( name=form.ingredient_name.data, quantity_type=form.quantity_type.data, calories_per_serving=form.calories_per_serving.data) if Ingredient.query.filter_by(name=ingredient.name).first(): flash('Ingredient already exists.') else: db.session.add(ingredient) db.session.commit() flash('New ingredient added!') page = request.args.get('page', 1, type=int) ingredients = Ingredient.query.paginate( page, current_app.config['POSTS_PER_PAGE'], False) next_url = url_for( 'main.inventory', page=ingredients.next_num) if ingredients.has_next else None prev_url = url_for( 'main.inventory', page=ingredients.prev_num) if ingredients.has_prev else None return render_template('main/ingredients.html', title='Ingredients', form=form, ingredients=ingredients.items, next_url=next_url, prev_url=prev_url)
def addIngredientsToRecipe(ingredientsList, recipeId): for ingredient in ingredientsList: newIngredientEntry = Ingredient(name=ingredient, recipe_id=recipeId) db.session.add(newIngredientEntry) print("Added", '"' + ingredient + '"') print("\n")
def create(): form = CreateForm() if form.validate_on_submit(): name = form.name.data desc = form.desc.data ingredients = form.ingredients.data file = "" if Recipe.query.filter_by(name=name).all(): flash("Recipe already exists") return redirect(url_for('main.create')) try: if form.picture.data is not None: f = form.picture.data filename = secure_filename(f.filename) file = str(datetime.now().timestamp()).replace('.', '') + filename f.save( os.path.join(Config.BASEDIR, 'app', 'static', 'photos', file)) recipe = Recipe(name=name, desc=desc, user_id=current_user.id, picture=file) else: recipe = Recipe(name=name, desc=desc, user_id=current_user.id) db.session.add(recipe) db.session.commit() recipe_saved = Recipe.query.filter_by(name=name).first() for key in ingredients.keys(): numb = "".join(x for x in key if x.isdigit()) name = f"ing_name_{numb}" quant = f"quantity_{numb}" if key == 'csrf_token': pass elif ingredients[key][quant] == '' or ingredients[key][ name] == '': pass else: new_ing = Ingredient(recipe_key=recipe_saved.key, name=ingredients[key][name], quantity=ingredients[key][quant]) db.session.add(new_ing) db.session.commit() flash('Recipe created') except: Recipe.query.filter_by(name=name).delete() if os.path.exists( os.path.join(Config.BASEDIR, 'app', 'static', 'photos', file)): os.remove( os.path.join(Config.BASEDIR, 'app', 'static', 'photos', file)) flash('Recipe was not created') return redirect(url_for('.index')) return render_template('main/create.html', form=form)
def create_dinspiration(): if request.json['title'] is None: return jsonify({'error': 'Title cannot be blank!'}) recipe = Recipe() recipe.title = request.json['title'] if request.json['description'] is not None: recipe.description = request.json['description'] try: db.session.add(recipe) db.session.commit() except exc.SQLAlchemyError: return jsonify({'error': 'Some Error has occurred!!!'}) if request.json['ingredients'] is not None: ingredients = request.json['ingredients'] for ingredient in ingredients: i = Ingredient(quantity=ingredient['quantity'], measurement=ingredient['measurement'], description=ingredient['description'], recipe=recipe) try: db.session.add(i) db.session.commit() except exc.SQLAlchemyError: return jsonify({ 'error': 'Some Error has occurred adding an ingredient!!!' }) new_recipe = serialized_recipe(recipe) return jsonify(new_recipe)
def unused_public_ingredients(self) -> list: from app.models import Ingredient return [ i for i in Ingredient.load_all_public() if i not in self.ingredients ]
def seed_ingredients(): for item in array: ingredient = Ingredient(name=item) db.session.add(ingredient) db.session.commit()
def duplicateAJAX(self): if request.json.get("ingredient_id") is None: abort(500) new_ingredient = Ingredient.load(request.json["ingredient_id"]).duplicate() new_ingredient.save() result = {"ingredient_id": new_ingredient.id} return jsonify(result)
def add_ingredient(): print("PING!") ingredient_name = request.json.get('name').lower() print(ingredient_name) if ingredient_name == None: abort(400) ing = Ingredient.query.filter(Ingredient.name == ingredient_name) if ing.count() == 0: ing = Ingredient(name=ingredient_name) db.session.add(ing) db.session.commit() return jsonify(ing.to_dict(include_recipes=True)), 201 else: response = jsonify(ing[0].to_dict(include_recipes=True)) response.status_code = 409 response.headers['location'] = '/ingredients/{}'.format(ing[0].id) return response
def test_ingredient(set_db): names = {"test", "çéàü", "1234"} for name in names: ingredient = Ingredient(name=name) db.session.add(ingredient) db.session.commit() ingredients = Ingredient.query.all() assert names == set(ingredient.name for ingredient in ingredients)
def new_ingredient(): data = request.get_json() print(data) name = data['name'] image = data['image'] new_ingredient = Ingredient(name=name, image=image) db.session.add(new_ingredient) db.session.commit() return (data)
def test_change_ingredient(self): d = Dispenser.from_params(0, self.ingredient, 1000) i = Ingredient.from_params('juice', alcoholic=False) d.change_ingredient(i, 500) self.assertEqual(d.ingredient, i) self.assertEqual(i.dispenser, d) self.assertEqual(d.volume, 500)
def get_recommendations(): ''' This endpoint takes a list of ingredient ids that represent a user's current search set and return 5 suggestions for an ingredient that is used in a recipe with some of the ingredients within that set. ''' ingredient_ids = request.json.get('ingredients') ingredients = RecipeIngredients.get_recommendations(ingredient_ids) return jsonify(Ingredient.json_dump(ingredients))
def post_shared(self): form = IngredientForm(request.form) if not form.validate_on_submit(): save_form_to_session(request.form) return redirect(url_for("IngredientView:new_shared")) ingredient = Ingredient(is_shared=True, source=current_user.username) form.populate_obj(ingredient) if ingredient.save(): flash( "Děkujeme za vytvoření sdílené suroviny. Až ji zkontrolujeme, bude zobrazena všem uživatelům.", "success", ) return redirect(url_for("IngredientView:index")) else: flash("Nepodařilo se vytvořit surovinu", "error") return redirect(url_for("IngredientView:new_shared"))