def index(food):
if food == '':
return '<h1>WELCOME!</h1>'
if request.method == 'GET':
url = f'{base_url}?ingr={food}&app_id={application_ID}&app_key={application_key}'
response = requests.get(url)
data = response.json()['hints']
found_foods = construct_food(data)
search_results = Food.query.filter(Food.name.ilike(f'%{food}%')).all()
return jsonify([*map(food_serializer, search_results)])
elif request.method == 'POST':
if request.is_json:
data = request.get_json()
name = data['name']
new_food = Food(
external_id=f'{name}{uuid.uuid1()}',
name=name,
energy=int(data['energy']),
protein=int(data['protein']),
carbohydrate=int(data['carbohydrate']),
fat=int(data['fat']),
fiber=int(data['fiber']),
image=
'https://cdn.pixabay.com/photo/2018/03/28/20/32/food-3270461_960_720.jpg'
)
db.session.add(new_food)
db.session.commit()
recently_added = Food.query.filter_by(name=new_food.name)
return jsonify([*map(food_serializer, recently_added)])
else:
return {"error": "The request failed."}
def editFood(food_name):
if 'username' not in login_session:
return redirect('/')
if request.method == 'POST':
newFood = Food(request.form, mongo.db)
if food_name == 'createnew' and mongo.db.foods.find_one(
{'$or': [{
'name': newFood.name
}, {
'label': newFood.label
}]}):
flash("A food by that DB name or label already exists.")
return render_template('editfood.html',
food_name=food_name,
food=newFood.json(),
login_session=login_session)
elif not newFood.name or not newFood.label:
flash("Label and DB name can not be empty.")
return render_template('editfood.html',
food_name=food_name,
food=newFood.json(),
login_session=login_session)
newFood.save_to_db(food_name)
return redirect('/foods')
else:
food = mongo.db.foods.find_one({"name": food_name})
return render_template('editfood.html',
food=food,
food_name=food_name,
login_session=login_session)
def test_delete_food(self):
# create a new food to be deleted, then delete
insert_food = Food(
food="Chicken",
protein=5,
carbs=1,
fat=1,
calories=1
)
insert_food.insert()
# record number of foods before delete
number_food = len(Food.query.all())
# delete new food
res = self.client().post(
f'/food/{insert_food.id}/delete',
headers=get_headers(self.admin))
# record number of questions after delete
number_food_new = len(Food.query.all())
self.assertEqual(res.status_code, 200)
self.assertEqual(number_food_new, number_food - 1)
self.assert_template_used('/pages/foods.html')
def setUp(self):
"""Create test client, add clear database tables"""
User.query.delete()
Food.query.delete()
UserFoods.query.delete()
self.client = app.test_client()
# set up a signed in user
tempuser = User.signup(username="******", password="******")
db.session.commit()
self.testuser = db.session.query(User).first()
# set up the Guest user
Guest = User.signup(username="******", password="******")
db.session.commit()
# insert test food item into database
food = Food(data="testfood",
date_string="10-10-10 lunch",
user_id=self.testuser.id)
db.session.add(food)
db.session.commit()
self.food = db.session.query(Food).first()
def addFood():
if 'email' not in session:
flash('Login as Admin to Add Food Item', 'danger')
return redirect('/grill')
owner = User.query.filter_by(email=session['email']).first()
if not owner.admin:
flash("Login as Admin to Add Food Item", 'danger')
return redirect('/grill')
foods = Food.query.all()
if 'name' in request.form:
name = request.form['name']
cook_time = request.form['cook-time']
for food in foods:
if name == food.name:
flash("Duplicate Food Item", 'danger')
return redirect('/grill')
food = Food(name=name, cook_time=cook_time)
db.session.add(food)
db.session.commit()
flash("Food Item was added successfully", 'success')
return redirect('/grill')
return redirect('/grill')
def index():
if request.method == 'POST':
new_data = get_food_data(request.form.get('food_name'))
if request.form.get('write_data'):
if not current_user.is_authenticated:
flash('You need authorization to do it.')
return redirect(url_for('login'))
else:
data = request.form.get('write_data').split('-')
name = data[0]
calories = data[1]
fat = data[2]
new_food_item = Food(
name=name,
calories=calories,
fat=fat,
parent_user_id=current_user.id
)
db.session.add(new_food_item)
db.session.commit()
flash('Successfully added')
return redirect(url_for('index'))
if not new_data:
name = None
parsed_food_data = None
else:
name = new_data['text']
try:
parsed_food_data = new_data['parsed'][0]['food']['nutrients']
except IndexError:
flash('Wrong food name!')
return redirect(url_for('index'))
else:
return render_template('index.html', name=name, food=parsed_food_data, current_user=current_user)
return render_template('index.html', current_user=current_user)
def newFood():
current_user = get_user()
if current_user is None:
# Must be logged in to create a food
return render_template('clientOAuth.html')
if request.method == 'POST':
newFood = Food(name=request.form['name'])
if not newFood.validate_object():
flash("The name field is blank, which is not allowed!")
return render_template('newFood.html')
# Only add a picture if it is valid
prospective_url = bleach.clean(request.form['picture'])
url_resp = Food.verify_valid_pic(prospective_url)
if url_resp is not None:
newFood.picture = url_resp
db.session.add(newFood)
db.session.commit()
new_food = newFood.id
if request.form['redirect_choice'] == 'EditMenu':
return redirect(url_for('foodVarieties', food_id=food.id))
elif request.form['redirect_choice'] == 'ReturnDatabase':
return redirect(url_for('showFoods'))
else:
return render_template('newFood.html')
def mutate_and_get_payload(cls, input, context, info):
food = Food(name=input.get('name'),
description=input.get('description'),
ingrediants=input.get('ingrediants'),
cuisine=input.get('cuisine'),
category=input.get('category'))
food.save()
return NewFood(food=food)
def demo_food():
from models import Food
food = Food.query.filter(Food._name=='Blue - Chicken and Brown Rice Recipe').first()
if food is None:
food = Food('Blue - Chicken and Brown Rice Recipe', 378, 8)
db.session.add(food)
db.session.commit()
return food
def create_food(name, cuisine):
new_food = Food(name=name, cuisine=cuisine)
if new_food:
db.session.add(new_food)
db.session.commit()
return jsonify(new_food.as_dict())
else:
raise Expection('Error in creating new food')
def test_create_food_without_fibre():
# no fibre in constructor
food = Food(id=1,
name="egg",
serving_size="piece",
kcal_per_serving=78,
protein_grams=6.3)
# hence it's set to default 0
assert food.fibre_grams == 0
def test_create_food_casting_no_exception():
# "78" is ok, so is an int for protein's float type
assert Food(
id=1,
name="egg",
serving_size="piece",
kcal_per_serving="78",
protein_grams=6,
fibre_grams=1.2,
)
def food():
food = Food(
id=1,
name="egg",
serving_size="piece",
kcal_per_serving=78,
protein_grams=6.3,
fibre_grams=0,
)
return food
def spawn_food(self, position=0):
if position == 0:
while True:
position = get_random_position(self.screen)
if self.snake:
if not self.snake.collides_with(position):
break
else:
break
self.food.insert(0, Food(position))
def post(self):
the_fav_food = self.request.get('user-fav-food')
#put into database (optional)
food_record = Food(food_name=the_fav_food)
food_record.put()
#pass to the template via a dictionary
variable_dict = {'fav_food_for_view': the_fav_food}
end_template = jinja_current_dir.get_template("templates/results.html")
self.response.write(end_template.render(variable_dict))
def add_menu_item():
date_now = datetime.now()
obj = Food(request.form['title'], date_now)
try:
Food.insert(obj)
except SQLAlchemyError as exc:
error = str(exc.__dict__['orig'])
return jsonify({"error": "Oops! %s" % error})
else:
return jsonify(
{"name": "Menu item successfully added - Reloading"})
def test_create_food_wrong_serving_type():
with pytest.raises(ValidationError):
# note that name=2 is ok with pydantic, it gets casted
Food(
id=1,
name="egg",
serving_size="piece",
kcal_per_serving="2ab",
protein_grams=6.3,
fibre_grams=1.2,
)
def set_food():
if request.data:
new_food_dict = json.loads(request.data)
new_food = Food(name=new_food_dict['name'])
for item in dir(Food):
if item in new_food_dict:
setattr(new_food, item, new_food_dict[item])
new_food.save()
if Food.objects(id=new_food.id).count() > 0:
return "Successfully created item"
return abort(500)
def save(self, data, pk, item):
instance = Food(id=pk,
item=item,
user=data["user"],
date_start=data["date_start"],
date_end=data["date_end"],
status=data["status"],
amount=data["amount"],
measure=data["measure"])
SESSION.add(instance)
SESSION.flush()
def handle_collisions(snake_list, food, speed, snake_length, score):
over = False
head = snake_list[0]
if is_colliding(head, food):
score += 1
speed += 1
snake_list, snake_length = make_new_snake(snake_list, snake_length,
food)
head = snake_list[0]
food = Food(WIDTH, HEIGHT)
if head.boundary_colliding():
game_over(score)
game()
return snake_list, food, speed, snake_length, score
def add_to_db(url, meal, date, location):
r = requests.get(url)
if r.status_code == 200:
html = r.content
meals = parse.parse(html)
meals_db = []
for food in meals:
f = Food(name=food['name'],
link=food['link'],
location=location,
date=date,
time=meal)
meals_db.append(f)
Food.objects.insert(meals_db)
def construct_food(json_data):
for i in range(len(json_data) - 1):
# check for unique external id
external_id = json_data[i]['food']['foodId']
exists = Food.query.filter_by(external_id=external_id).first()
if exists is None:
name = json_data[i]['food']['label']
energy = json_data[i]['food']['nutrients'][
'ENERC_KCAL'] if 'ENERC_KCAL' in json_data[i]['food'][
'nutrients'].keys() else 0
protein = json_data[i]['food']['nutrients'][
'PROCNT'] if 'PROCNT' in json_data[i]['food'][
'nutrients'].keys() else 0
carbohydrate = json_data[i]['food']['nutrients'][
'CHOCDF'] if 'CHOCDF' in json_data[i]['food'][
'nutrients'].keys() else 0
fat = json_data[i]['food']['nutrients'][
'FAT'] if 'FAT' in json_data[i]['food']['nutrients'].keys(
) else 0
fiber = json_data[i]['food']['nutrients'][
'FIBTG'] if 'FIBTG' in json_data[i]['food']['nutrients'].keys(
) else 0
image = json_data[i]['food']['image'] if 'image' in json_data[i][
'food'].keys(
) else 'https://cdn.pixabay.com/photo/2016/12/10/21/26/food-1898194_960_720.jpg'
external_id = json_data[i]['food']['foodId']
food = Food(name=name,
energy=energy,
protein=protein,
carbohydrate=carbohydrate,
fat=fat,
fiber=fiber,
image=image,
external_id=external_id)
db.session.add(food)
db.session.commit()
print(f'{food.name} added to database')
else:
pass
def get_food_from_barcode(barcode):
food = Food.objects(barcode=barcode)
if food:
return food.to_json()
else:
resp = requests.get(f"https://world.openfoodfacts.org/api/v0/product/{barcode}.json")
if resp.status_code == 200:
resp_dict = json.loads(resp.text)
if resp_dict['status'] == 1:
food_data = resp_dict['product']
# Has found a barcode in the openfoodfacts db
food = Food(name=food_data["product_name"], barcode=barcode)
food.save()
return food.to_json()
return "Can't find item for barcode"
def register_food():
food_name = request.form.get('food_name')
food_price = request.form.get('food_price')
currency = request.form.get('currency')
try:
food = Food(food_id=None,
food_name=food_name,
food_price=food_price,
currency=currency)
db.session.add(food)
db.session.commit()
return redirect('/add-food-form')
except Exception as e:
return (str(e))
def newfood(request):
name = request.GET["name"]
try:
Food.objects.get(name__iexact=name)
raise Exception("Already got this food")
except Food.DoesNotExist:
pass
food = Food()
for x in request.GET.keys():
if x in "carb,fiber,protein,fat".split(","):
value = string.atoi(request.GET[x])
else:
value = request.GET[x]
setattr(food, x, value)
food.save()
return redirect('/')
def test_create_food_object():
food = Food(
id=1,
name="egg",
serving_size="piece",
kcal_per_serving=78,
protein_grams=6.3,
fibre_grams=0,
)
assert type(food) == Food
assert food.id == 1
assert food.name == "egg"
assert food.serving_size == "piece"
assert food.kcal_per_serving == 78
assert food.protein_grams == 6.3
assert food.fibre_grams == 0
def generate_food(self, points_worth, steps_worth, all_snakes, all_food, super_food, table_width, table_height, food_size, is_super_food=False):
random_upper_coeficient_x = table_width / food_size
random_upper_coeficient_y = table_height / food_size
while True:
generated_x = random.randint(0, random_upper_coeficient_x) * food_size
generated_y = random.randint(0, random_upper_coeficient_y) * food_size
generated_food = Food(generated_x, generated_y, food_size, food_size, points_worth, steps_worth, is_super_food)
if not self.collision_manager.is_coordinate_colliding(all_snakes,
all_food,
super_food,
table_width,
table_height,
generated_food):
return generated_food
def extract_food_info(entry):
link = BASE_URL + entry['href']
meal_name = entry.contents[0].string
meal_name, gluten_free = truncate_meal_name(meal_name)
# check for vegan and vegetarian foods
vegan, vegetarian = False, False
if entry.font['color'] == VEGE_LEGEND['vegan']:
vegan = True
elif entry.font['color'] == VEGE_LEGEND['vegetarian']:
vegetarian = True
# crawl link (declared above) to check allergens
allergens, ingredients = get_allergens_and_ingredients(link)
return Food(name = meal_name, allergens = allergens, ingredients = ingredients, \
vegan = vegan, vegetarian = vegetarian, gluten_free = gluten_free)
def CreateOrEditFood_view(request, food_id=None):
response_data = {} # словарь для JSON-ответа
if (food_id == None or food_id == '999999'):
_food = Food()
_message = 'Заявка добавлена успешно'
else:
_food = get_object_or_404(Food, id=food_id)
_message = 'Заявка отредактирована успешно'
if request.method == "GET" and request.is_ajax():
# сериализуем только queryset поэтому заворчаиваем объект в [obj,]
data = serializers.serialize(
'json',
[
_food,
],
) #fields=('place_of_residing','quantity_total','quantity_adult',
#'quantity_member', 'date','status','status_comment'))
return _json_response(data)
if request.POST:
print request.POST
formFood = FoodForm(request.POST, instance=_food)
if formFood.is_valid():
res = formFood.save(commit=False)
res.user_id = auth.get_user(
request
).id #передаем ID директора , к которому привязан участник
print res.zavtrak
print res.obed
print res.ugin
res.zavtrak = 1 if ('zavtrak' in request.POST) else 0
res.obed = 1 if ('obed' in request.POST) else 0
res.ugin = 1 if ('ugin' in request.POST) else 0
print res.zavtrak
print res.obed
print res.ugin
# Рассчитываем сумму заявки и сохраняем ;
#res.payment = fee_food
#messages.add_message(request, messages.SUCCESS, _message)
formFood.save()
return HttpResponse('ok')
else:
response_data['errors'] = u'Неправильно заполнена форма.'
response_data['formErrors'] = simplejson.dumps(formFood.errors)
return _json_response(response_data)
return redirect('/')
def post(self):
expiration_string = self.request.get('expirationdate')
expiration_date = datetime.datetime.strptime(expiration_string,
"%Y-%m-%d").date()
# calendar_url = "http://www.google.com/calendar/event?action=TEMPLATE&text=%s&dates=%s/%s"
# calendar_link = calendar_url % ("TestEvent", 7, 12) #calendar_start, calendar_end)
# calendar_html = "<HTML><BODY><A href='%s' target='_blank'>Test Event Link</A></BODY></HTML>"
# self.response.write(calendar_html % calendar_link)
user = users.get_current_user()
food_input = self.request.get('addfooditem')
#put into database (optional)
food_record = Food(food_name=food_input,
user_id=user.user_id(),
expiration_date=expiration_date)
food_record.put()
self.redirect('/input')