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 add_post():
food_id = request.form.get('food-id')
food = request.form.get('food-name')
proteins = request.form.get('protein')
carbs = request.form.get('carbohydrates')
fats = request.form.get('fat')
if food_id:
result = Food.update(name=food,
protein=proteins,
carbs=carbs,
fats=fats).where(Food.id == food_id).execute()
if result == 1:
flash("Food item is updated", "succes")
elif result > 1:
flash("Something strange happend, multiple items where updated",
"warning")
elif result < 1:
flash("No item found", "error")
else:
test, isCreated = Food.get_or_create(name=food,
defaults={
'protein': proteins,
'carbs': carbs,
'fats': fats
})
print(test)
if isCreated:
flash("Food is created", "succes")
else:
flash("Food already exists", "error")
return redirect(url_for("main.add"))
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 post(self):
food_name = self.request.get('food_name')
food = Food(parent=food_key(food_name),
food.price = self.request.get('price'),
food.picture = )
food.put()
self.redirect('/?' + urllib.urlencode({'food_name': food_name}))
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 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 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 delete_menu_item():
record_id = request.form['itemid']
try:
obj = Food.query.filter(Food.id == record_id)
for item in obj:
Food.delete(item)
except SQLAlchemyError as exc:
error = str(exc.__dict__['orig'])
return jsonify({"error": "Oops! %s" % error})
else:
return jsonify({"name": "Successfully deleted record"})
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 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 do_save():
"""User/Guest page, if user is not signed in they can save data to the guest account"""
food_data = request.get_json("data")
if g.user:
Food.add_food(g.user.id, food_data["food"], food_data["menuName"])
return "true"
else:
guest = User.query.filter_by(username="******").first()
Food.add_food(guest.id, food_data["food"], food_data["menuName"])
return "true"
def delete_all_menu_items():
try:
obj = Food.query.all()
for item in obj:
Food.delete(item)
except SQLAlchemyError as exc:
error = str(exc.__dict__['orig'])
return jsonify({"error": "Oops! %s" % error})
else:
return jsonify({
"name":
"All items successfully deleted - Reloading in 5 seconds"
})
def sort():
vegetables = Food.query(Food.type=="vegetable").fetch(1000)
vegetables.sort(key=lambda x:x.get_point())
vegetables.reverse()
meats = Food.query(Food.type=="meat").fetch(1000)
meats.sort(key=lambda x:x.get_point())
meats.reverse()
fishs = Food.query(Food.type=="fish").fetch(1000)
fishs.sort(key=lambda x:x.get_point())
fishs.reverse()
c = 0
for vegetable in vegetables:
print 'vegetable', c, vegetable.name
vegetable.rank = c
print vegetable.point
if c:
vegetable.prev = vegetables[c-1].name
if c < len(vegetables) - 1:
vegetable.next_one = vegetables[c+1].name
c += 1
c=0
for meat in meats:
print 'meat', c, meat.name
print meat.point
meat.rank = c
if c:
meat.prev = meats[c-1].name
if c < len(meats) - 1:
meat.next_one = meats[c+1].name
c += 1
c=0
for fish in fishs:
print 'fish', c, fish.name
print fish.point
fish.rank = c
if c:
fish.prev = fishs[c-1].name
if c < len(fishs) - 1:
fish.next_one = fishs[c+1].name
c += 1
result = []
result.extend(vegetables)
result.extend(fishs)
result.extend(meats)
ndb.put_multi(result)
def tot_cost(user):
sum1 = 0
#print(user)
try:
s1 = Food.get(Food.owner_id == user).cost
if s1 is not None:
sum1 = s1 + sum1
print("the total cost of food is")
print(s1)
except:
pass
try:
s2 = Activity.get(Activity.owner_id == user).cost
if s2 is not None:
sum1 = s2 + sum1
print("Cost of your activity is")
print(s2)
except:
pass
try:
s3 = Room.get(Room.owner_id == user).cost
if s3 is not None:
sum1 = s3 + sum1
print("Cost of your Room is")
print(s3)
except:
pass
print(sum1)
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 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 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 add_food_to_log(log_id):
food_id = int(request.form.get('food-select'))
print(food_id, type(food_id))
food_select = Food.select().where(Food.id == food_id).get()
food_select.logs.add(Log.select().where(Log.id == log_id))
return redirect(url_for("main.view", log_id=log_id))
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 search_food():
q = request.args.get("search_food")
f, recipes = None, None
if q:
f = Food.objects(name__icontains=q).first()
f.save()
return render_template("ideal.html", foods=[f,])
def get(self):
print(os.environ.get("FOOD_API_KEY"))
start_template = jinja_current_dir.get_template(
"templates/Recipes.html")
user_foods = Food.query().order(Food.expiration_date).fetch()
user_food_names = ",".join([food.food_name for food in user_foods])
query_params = {
'ingredients': user_food_names,
'apiKey': os.environ.get("FOOD_API_KEY"),
}
#not totally sure
# recipe = Recipe.query().fetch()
# self.response.write(start_template.render(recipe))
url = 'https://api.spoonacular.com/recipes/findByIngredients?%s' % (
urllib.urlencode(query_params))
# self.response.write(url)
try:
result = urlfetch.fetch(url)
if result.status_code == 200:
result_data = json.loads(result.content)
else:
result_data = []
self.response.status_int = result.status_code
except urlfetch.Error:
logging.exception('Caught exception fetching url')
self.response.write(start_template.render({"recipes": result_data}))
def editFood(food_id):
food = db.session.query(Food).filter_by(id=food_id).one()
current_user = get_user()
if food.protected:
# Cannot edit a food that is protected
return render_template('unauthorizedFood.html', food=food)
if current_user is None:
return render_template('clientOAuth.html')
if request.method == 'POST':
food.name = request.form['name']
if not food.validate_object():
flash("The name field is blank, which is not allowed!")
return render_template('editFood.html')
prospective_url = bleach.clean(request.form['picture'])
url_resp = Food.verify_valid_pic(prospective_url)
food.picture = url_resp
db.session.add(food)
db.session.commit()
if request.form['redirect_choice'] == 'Varieties':
return redirect(url_for('foodVarieties', food_id=food.id))
elif request.form['redirect_choice'] == 'ReturnDatabase':
return redirect(url_for('showFoods'))
else:
return render_template('editFood.html', food=food)
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 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 get(self, _type):
size = int(self.request.get('size', 6))
page = int(self.request.get('page', 1))
foods = Food.query(Food.type==_type).fetch(1000)
foods = sorted(foods, key= lambda x:x.rank)[size*page - size : size*page]
result = [{"name":v.name, "price": v.price, "wholesale_price": v.wholesale_price, "image":v.image, "order": v.rank} for v in foods]
self.output(result)
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')
def remove_food_from_db():
delete_food_dict = json.loads(request.data)
food = Food.objects.get_or_404(_id=delete_food_dict["id"])
food.delete()
if Food.objects(_id=delete_food_dict["id"]).count() == 0:
return jsonify({'result': 1})
else:
return abort(500)
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 update_food_menu():
if 'userid' not in session:
return redirect('/login')
adminStatus = Admin.query.get(session['userid'])
if adminStatus:
# ADD
if request.form['update_type'] == 'new':
is_valid = Food.validate_food_item(request.form)
if is_valid:
Food.add_food_item(request.form)
# MAKE ACTIVE/INACTIVE
elif request.form['update_type'] == 'status':
Food.update_food_status(request.form.getlist('food_id_cb'))
# DELETE
elif request.form['update_type'] == 'delete':
Food.delete_food_item(request.form['food_id'])
# UPDATE
# elif
return render_template('partials/admin_food.html',
all_food=Food.query.order_by(
Food.category, Food.name).all())
return redirect('/')
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 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 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 sort():
vegetables = Food.query(Food.type=="vegetable").order(Food.point).fetch(1000)
meats = Food.query(Food.type=="meat").order(Food.point).fetch(1000)
fishs = Food.query(Food.type=="fish").order(Food.point).fetch(1000)
c = 0
for vegetable in vegetables:
print 'vegetable', c, vegetable.name
vegetable.rank = c
if c:
vegetable.prev = vegetables[c-1].name
if c < len(vegetables) - 1:
vegetable.next_one = vegetables[c+1].name
c += 1
c=0
for meat in meats:
print 'meat', c, meat.name
meat.rank = c
if c:
meat.prev = meats[c-1].name
if c < len(meats) - 1:
meat.next_one = meats[c+1].name
c += 1
c=0
for fish in fishs:
print 'fish', c, fish.name
fish.rank = c
if c:
fish.prev = fishs[c-1].name
if c < len(fishs) - 1:
fish.next_one = fishs[c+1].name
c += 1
result = []
result.extend(vegetables)
result.extend(fishs)
result.extend(meats)
ndb.put_multi(result)
def post(self):
items = self.request.POST.items()
food_pool = []
for item in items:
key, url = item[1].encode('utf-8').split('@', 1)
print key
food = Food.get_by_id(key)
if food.image == url:
continue
else:
food.image = url
food.put()
def get(self):
foods = Food.query().fetch(1000)
template = u"<label><img src='{1}'>{2}<input name='data' value='{0}@{1}'></label>"
foods_template = "<br/>".join([template.format(food.name, food.image, food.type) for food in foods])
html = u'''
<form method='post'>
{}
<input type='submit'>
</form>
'''.format(foods_template)
self.response.write(html)
def get(self, _id):
food = Food.get_by_id(_id)
result = {
"name": food.name,
"price": food.price,
"wholesale_price": food.wholesale_price,
"order": food.rank,
"next": food.next_one,
"prev": food.prev,
"description": food.get_recommand(),
"image": food.image
}
self.output(result)
def set_image():
import google_search_image
foods = Food.query().fetch(1000)
import pdb;pdb.set_trace()
for food in foods:
try:
print food.name, food.image
assert not food.image, 'had image'
key = u'{}'.format(food.name)
print key
img = google_search_image.search(key.encode('utf-8')).next()
food.image = img.get('url')
print food.name, food.image
food.put()
except Exception as e:
print e
def process_item(item):
# print item
food = Food.get_or_insert(item['name'])
for key, value in item.items():
try:
if key != 'date':
setattr(food, key, value)
print key, value
except Exception as e:
print e
food.push_info(item['date'])
food.aggregate()
food.get_point()
food.get_recommand()
return food
def get(self):
stall_name=self.request.get('stall_name')
food_query = Food.all().ancestor(
stall_key(stall_name)).order('-name')
food = food_query.run()
if users.get_current_user():
url = users.create_logout_url(self.request.uri)
url_linktext = 'Logout'
else:
url = users.create_login_url(self.request.uri)
url_linktext = 'Login'
self.render_template('index.html',{
'food': food,
'url': url,
'url_linktext': url_linktext,
})
def get(self, _id):
food = Food.get_by_id(_id)
composition = [{"name": "維生素B群 & C 菸鹼素", "amount": 5.2000, 'unit': "mg"}, {"name":"維生素E α-生育醇", "amount": 1.2400, "unit": "mg"}, {"name":"維生素E 維生素E總量", "amount": 3.0200, "unit": "mg"}, {"name":"礦物質 鈣", "amount": 33.0000, "unit": "mg"}]
result = {
"name": food.name,
"price": food.price,
"wholesale_price": food.wholesale_price,
"order": food.rank,
"next": food.next_one,
"prev": food.prev,
"description": food.get_recommand(),
"image": food.image,
"composition": composition,
"type": "豬肉",
}
self.output(result)
def get(self, _id):
result = Food.get_by_id(_id).infos
result = [r.to_dict() for r in result]
days = [r['date'] for r in result]
day = datetime.datetime(2014,6,1)
today = datetime.datetime.today() - datetime.timedelta(1)
while day < today:
day = day + datetime.timedelta(1)
if day.date() in days:
continue
data = {}
data['amount'] = 0
data['date'] = day.date()
data['wholesale_price'] = 0
data['price'] = 0
result.append(data)
result.sort(key=lambda x:x['date'])
self.output(result)
def get(self, _id):
food = Food.get_by_id(_id)
datas = open('20_r').readlines()
composition = []
pattern = re.sub("\(.*\)", "", _id)
pattern = re.sub("-.*", "", pattern)
for d in datas:
if pattern in d:
try:
t1, t2, name, unit, value = d.split(' ')
composition.append({"name": name, "amount":float(value.strip()), "unit":unit})
except Exception as e:
print e
composition = composition or [{"name": "碳水化合物", "unit": "mg", "amount": 1}]
mapping = {"fish": '魚', 'meat': '肉', 'vegetable': '菜'}
_type = mapping[food.type]
result = {
"name": food.name,
"price": food.price,
"wholesale_price": food.wholesale_price,
"order": food.rank,
"next": food.next_one,
"prev": food.prev,
"description": food.get_recommand(),
"image": food.image,
"composition": composition,
"type": _type,
}
self.output(result)
def get(self):
food_list_template = jinja_current_dir.get_template("templates/foodlist.html")
fav_foods = Food.query().order(-Food.food_name).fetch(3)
dict_for_template = {'top_fav_foods': fav_foods}
self.response.write(food_list_template.render(dict_for_template))
def get(self, _id):
result = Food.get_by_id(_id).infos
result = [r.to_dict() for r in result]
self.output(result)
