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