def _parse_children(parent, parent_obj):
if 'children' not in parent:
return
for ch in parent['children']:
child = MenuItem(name=ch['name'], url=ch['url'], title=ch.get('title', None), parent=parent_obj)
child.save()
_parse_children(ch, child)
def _get_menu():
menu = memcache.get('doubleb_menu')
if not menu:
company = DoublebCompany.get()
menu = get_doubleb_menu(company)['menu']
category = MenuCategory(id=667)
category.category = MenuCategory.get_initial_category().key
category.title = u'Напитки'
categories = [category]
items = []
for index, item_dict in enumerate(menu[u'Напитки']):
item = MenuItem(id=int(item_dict['id']))
item.category = category.key
item.price = item_dict['price'] * 100
item.title = item_dict['title']
item.picture = ''
item.description = ''
item.order = index
item.kal = 0
item.weight = 0
items.append(item)
items, modifiers = _set_modifiers(items)
menu = categories, items, modifiers
memcache.set('doubleb_menu', menu, time=3600)
return menu
def test_patch_permission(self):
new_menu_item = MenuItem(name=self.menu_item.get('name'), category=self.menu_item.get('category'),
ingredients=self.menu_item.get('ingredients'), price=self.menu_item.get('price'))
new_menu_item.insert()
menu_item_id = new_menu_item.id
res = self.client().patch('/menu/{}'.format(menu_item_id, json={"price": 200}))
data = json.loads(res.data)
self.assertEqual(res.status_code, 401)
self.assertEqual(data['success'], False)
def test_get_menu_with_new_value(self):
new_menu_item = MenuItem(name=self.menu_item.get('name'), category=self.menu_item.get('category'),
ingredients=self.menu_item.get('ingredients'), price=self.menu_item.get('price'))
new_menu_item.insert()
res = self.client().get('/menu')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(len(data['menu_items']) >= 0)
def menu_delete(request, key=None):
if not key:
return redirect(menu_list)
if request.POST.get('confirmation') == 'yes':
m = MenuItem.get(key)
if m:
m.delete()
MenuItem.get(key) # for refreshing purposes http://stackoverflow.com/questions/15773892/should-i-expect-stale-results-after-redirect-on-local-environment
if request.POST.get('confirmation'):
return redirect(menu_list)
return render_to_response("confirmation.html", {}, context_instance=RequestContext(request))
def test_patch_menu_item(self):
new_menu_item = MenuItem(name=self.menu_item.get('name'), category=self.menu_item.get('category'),
ingredients=self.menu_item.get('ingredients'), price=self.menu_item.get('price'))
new_menu_item.insert()
menu_item_id = new_menu_item.id
menu_item = MenuItem.query.filter(MenuItem.id == menu_item_id).one_or_none()
self.assertIsNotNone(menu_item)
res = self.client().patch('/menu/{}'.format(menu_item_id), json={"price": 100}, headers=self.chef_header)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def save_menu(request):
name = request.POST.get("name", "")
menu_id = request.POST.get("menu_item", "")
try:
menu = MenuItem.objects.get(pk=menu_id);
menu.name= name
msg = "MenuItem was sucesfully created!!"
except:
menu = MenuItem(name= name);
msg = "MenuItem was sucesfully updated!!"
menu.save();
response_data= {"status": True, "msg": msg}
return HttpResponse(json.dumps(response_data), content_type="application/json")
def new_menu_item(restaurant_id):
if request.method == 'POST':
menu_item_name = request.form['menu_item_name']
menu_item_description = request.form['menu_item_description']
menu_item_price = request.form['menu_item_price']
MenuItem.create(name=menu_item_name,
description=menu_item_description,
price=menu_item_price,
restaurant_id=restaurant_id)
flash('New menu item created')
return redirect(
url_for('single_restaurant', restaurant_id=restaurant_id))
else:
restaurant = Restaurant.get_by_id(restaurant_id)
return render_template('new-menu-item.html', restaurant=restaurant)
def load_item(d): v = load_venue(d["venue"]) try: m = MenuItem.objects.get(locu_id=d["id"]) except MenuItem.DoesNotExist: m = MenuItem(locu_id=d["id"], venue=v, title=d["name"], description=d["description"], section=d["section"], price=d["price"], image_url=None ) m.save() return m
def test_delete_menu_item_bare(self):
new_menu_item = MenuItem(name=self.menu_item.get('name'), category=self.menu_item.get('category'),
ingredients=self.menu_item.get('ingredients'), price=self.menu_item.get('price'))
new_menu_item.insert()
menu_item_id = new_menu_item.id
menu_item = MenuItem.query.filter(MenuItem.id == menu_item_id).one_or_none()
self.assertIsNotNone(menu_item)
menu_item.delete()
menu_item_deleted = MenuItem.query.filter(MenuItem.id == menu_item_id).one_or_none()
self.assertIsNone(menu_item_deleted)
res = self.client().get('/menu')
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
def newMenuItem(restaurant_id):
"""
New menu item page
Input:
restaurant_id - restaurant id for which we want to create new menu item
Output:
Render new menu item creation page or populate entered info into DB and redirect to this restaurant's menu page
"""
if request.method == 'POST':
imgfile = request.files['imgfile']
if imgfile and allowed_file(imgfile.filename):
filename = secure_filename(imgfile.filename)
imgfile.save(os.path.join(UPLOAD_FOLDER, filename))
else:
filename = 'midummy.gif'
newItem = MenuItem(name=request.form['name'],
description=request.form['description'],
price=request.form['price'],
course=request.form['course'],
img=filename,
restaurant_id=restaurant_id,
user_id=login_session['user_id'])
session.add(newItem)
session.commit()
flash("new menu item created!")
return redirect(url_for('showMenu', restaurant_id=restaurant_id))
else:
return render_template('newMenuItem.html', restaurant_id=restaurant_id)
def post(self):
auth_code = self.request.get("auth_code")
if auth_code != PASSCODE and AUTH_ENABLED:
self.response.out.write("AUTH FAILED")
return
rest = Restaurant.create(self.request.get("name"))
return_obj = {"secret_key": rest.secret_key, "restaurant_id": rest.restaurant_id}
menu = Menu.create("menu", rest)
uiProfile = UIProfile.create(menu)
menu_item_1 = MenuItem.create("Starter Item 1", menu, 10.00, "Appy", "This is a sample menu Item")
menu_item_2 = MenuItem.create("Starter Item 2", menu, 11.00, "Drink", "This is a sample menu Item")
self.response.headers["Access-Control-Allow-Origin"] = "*"
self.response.out.write(json.dumps(return_obj))
def DocFromModels(rest_id, menu_id):
# try:
rest = Restaurant.get_by_id(rest_id)
menu = Menu.get_by_id(menu_id)
ui_profile = UIProfile.get_by_menu(menu)
menuitems = MenuItem.get_by_menu(menu)
grab_vars = lambda item: deepcopy(vars(item)["_entity"])
obj = {}
obj["menu_id"] = menu.menu_id
obj["restaurant_id"] = rest.restaurant_id
obj["restaurant_name"] = rest.name
obj["menu_name"] = menu.name
obj["ui_profile"] = grab_vars(ui_profile)
obj["ui_profile"]["menu"] = "null"
obj["menuitems"] = {}
for menuitem in menuitems:
category = menuitem.category
menu_item_dict = grab_vars(menuitem)
menu_item_dict["menu"] = "null"
if obj["menuitems"].has_key(category):
obj["menuitems"][category].append(menu_item_dict)
else:
obj["menuitems"][category] = [menu_item_dict]
return json.dumps(obj)
def new_menu_item(restaurant_id):
try:
restaurant = session.query(Restaurant).filter_by(
id=restaurant_id).one()
except:
return "No such restaurant"
if login_session['user_id'] != restaurant.user_id:
return "<script>function myFunction() {" \
"alert(" \
"'You are not authorized to add menu items " \
"to this restaurant. " \
"Please create your own restaurant in order to add items.');}" \
"</script><body onload='myFunction()''>"
if request.method == 'POST':
new_item = MenuItem(name=request.form['name'],
description=request.form['description'],
price=request.form['price'],
course=request.form['course'],
restaurant_id=restaurant_id,
user_id=restaurant.user_id)
session.add(new_item)
session.commit()
flash('New Menu %s Item Successfully Created' % new_item.name)
return redirect(url_for('show_menu', restaurant_id=restaurant_id))
else:
return render_template('newmenuitem.html', restaurant_id=restaurant_id)
def get(self):
item_id = self.request.get_range('item_id')
item = MenuItem.get_by_id(item_id)
if not item:
self.abort(400)
status = self.STATUS_MAP[item.status]
self.render('/menu/item_info.html', item=item, status=status)
def post_menus(restaurant_id: int):
session = DBSession()
new_item = MenuItem(
name=request.json["name"],
description=request.json["description"],
price=request.json["price"],
course=request.json["course"],
restaurant_id=restaurant_id,
)
session.add(new_item)
session.commit()
return (
jsonify(
{
"name": new_item.name,
"description": new_item.description,
"id": new_item.id,
"price": new_item.price,
"course": new_item.course,
}, ),
201,
{
"Location":
url_for("api.get_menus", restaurant_id=restaurant_id) +
f"/{new_item.id}",
},
)
def newMenuItem(restaurant_id):
"""
Create a menu item with a specific restaurant's id.
:param restaurant_id: Restaurant's id to which new menu item belongs.
:return:
on GET: Render new menu form template.
on POST: Redirect to the menu page if the create request has been succeeded.
"""
restaurant = session.query(Restaurant). \
filter_by(id=restaurant_id).one()
if restaurant.user_id != login_session['user_id']:
flash("You are not authorized to create this menu!")
return redirect(url_for('showMenu', restaurant_id=restaurant_id))
if request.method == 'POST':
menuItem = MenuItem(name=request.form['name'],
description=request.form['description'],
price=request.form['price'],
category=request.form['category'],
restaurant_id=restaurant_id,
user_id=restaurant.user_id)
session.add(menuItem)
session.commit()
flash('New menu %s successfully created!' % menuItem.name)
return redirect(url_for('showMenu', restaurant_id=restaurant_id))
else:
return render_template('newMenu.html', restaurant_id=restaurant_id)
def get_products(self, group_modifier, choice):
products = []
for product in MenuItem.query(MenuItem.status == STATUS_AVAILABLE).fetch():
if group_modifier.key in product.group_modifiers:
products.append(product)
product.has_choice = choice.choice_id not in product.group_choice_restrictions
return products
def menu_edit(request, key=None):
if not key:
return redirect(menu_list)
m = MenuItem.get(key)
if request.method == 'POST':
formset = MenuItemForm(request.POST, instance=m)
if formset.is_valid():
m = formset.save()
MenuItem.get(m.key()) # for refreshing purposes http://stackoverflow.com/questions/15773892/should-i-expect-stale-results-after-redirect-on-local-environment
return redirect(menu_list)
else:
formset = MenuItemForm(instance=m)
return render_to_response("menu_add.html", {
"formset": formset,
"level" : m.level
}, context_instance=RequestContext(request))
def createItem(request, login_session, restaurant):
"""
Takes request and login session objects and
a restaurant object as inputs
Checks for user login
If user is not logged in, respond with an error
Adds a menu item to the database
Returns a redirect to the menu page
"""
# Check if user is authorized.
if (restaurant.user_id == login_session['user_id']
or login_session['user_id'] == 2):
# If so, add the menu item.
newItem = MenuItem(name=request.form['name'],
course=request.form['course'],
price=request.form['price'],
description=request.form['description'],
restaurant=restaurant,
restaurant_id=restaurant.id,
user_id=login_session['user_id'])
db.session.add(newItem)
db.session.commit()
flash('New menu item created!')
# Redirect user to the menu page
return redirect(url_for('showMenuItems', restaurant_id=restaurant.id))
# User is not logged in. Send an error.
else:
response = make_response(json.dumps('Unauthorized access'), 401)
return response
def post_menuitems():
request_data = request.get_json()
name = request_data["name"]
# I won't always be adding a tag to an item
if 'tag' in request_data:
tag = request_data["tag"]
new_menuitem = MenuItem(name=name, tag=tag)
else:
new_menuitem = MenuItem(name=name)
db.session.add(new_menuitem)
db.session.commit()
return "created", 201
def get(self):
dishes = MenuItem.query().fetch()
subscription_menu_items = SubscriptionMenuItem.query().fetch()
subscription_dishes = []
categories = {}
for dish in dishes:
if dish.category and dish.category.get():
categories[dish.category.get().title] = []
else:
categories[u'Без категории'] = []
for dish in dishes:
if dish.category and dish.category.get():
categories[dish.category.get().title].append(dish)
else:
categories[u'Без категории'].append(dish)
for menu_item in subscription_menu_items:
subscription_dishes.append(menu_item.item.get())
self.render('/subscription/subscription_menu_items_list.html',
subscription_dishes=subscription_dishes,
categories=categories)
def ModelsFromDoc(jsonString, rest_id):
try:
obj = json.loads(jsonString)
profile_id = obj["ui_profile"]["profile_id"]
# Create or Update Rest
rest = Restaurant.get_by_id(rest_id)
rest.name = obj["restaurant_name"]
# Create or Update Menu
menu = Menu.get_menus_by_rest_id(rest_id)[0]
menu.name = obj["menu_name"]
menu.resturant = rest
# Create or Update UI Profile
UIProfile.delete_by_menu(menu)
ui_profile = UIProfile.create(menu)
ui_profile.template = obj["ui_profile"]["template"]
ui_profile.color = obj["ui_profile"]["color"]
ui_profile.font = obj["ui_profile"]["font"]
ui_profile.logo_url = obj["ui_profile"]["logo_url"]
# logging.info(str(obj))
# Create or Update menuitems
MenuItem.delete_by_menu(menu)
menu_items_dict = obj["menuitems"]
logging.info(type(menu_items_dict))
for category in menu_items_dict.keys():
category_list = menu_items_dict[category]
for menu_item_dict in category_list:
menuitem = MenuItem.create(
menu_item_dict["name"],
menu,
menu_item_dict["price"],
category,
menu_item_dict["image"],
menu_item_dict["description"],
)
menuitem.put()
ui_profile.put()
menu.put()
rest.put()
return True
except:
return False
def add_menu_item(token):
"""Adds a new menu item to the menu."""
body = request.get_json()
if body is None:
abort(422)
try:
new_name = body.get('name')
new_ingredients = body.get('ingredients')
new_price = body.get('price')
new_category = body.get('category')
new_item = MenuItem(name=new_name, category=new_category, ingredients=new_ingredients, price=new_price)
new_item.insert()
menu_items = MenuItem.query.order_by(MenuItem.id).all()
return jsonify({"success": True,
"menu_items": [menu_item.format() for menu_item in menu_items]
})
except Exception:
abort(422)
def new_menu_item(restaurant_id):
if request.method == 'POST':
new_item = MenuItem(name=request.form['item-name'],description=request.form['description'],price=request.form['price'],restaurant_id=restaurant_id)
session.add(new_item)
session.commit()
flash("New menu item created")
return redirect(url_for('show_menu', restaurant_id=restaurant_id))
else:
return render_template('newmenuitem.html', restaurant_id=restaurant_id)
def add_menu_item():
name = request.json['name']
tag = request.json['tag']
new_menu_item = MenuItem(name, tag)
db.session.add(new_menu_item)
db.session.commit()
return menu_item_schema.jsonify(new_menu_item)
def add_menu_item(session, restaurant, data):
new_item = MenuItem(name=data['name'],
description=data['description'],
price=data['price'],
course=data['course'],
restaurant_id=restaurant.id,
user_id=restaurant.user_id)
session.add(new_item)
session.commit()
return new_item
def get(self):
category_id = self.request.get_range('category_id')
category = MenuCategory.get_by_id(category_id)
if not category:
self.abort(400)
product_id = self.request.get_range('item_id')
product = MenuItem.get_by_id(product_id)
if not product:
self.abort(400)
self.render('/menu/add_item.html', product=product, category=category)
def loaddir(directory, clear=False):
if clear:
MenuItem.objects.all().delete()
Menu.objects.all().delete()
def _parse_children(parent, parent_obj):
if 'children' not in parent:
return
for ch in parent['children']:
child = MenuItem(name=ch['name'], url=ch['url'], title=ch.get('title', None), parent=parent_obj)
child.save()
_parse_children(ch, child)
for menufile in os.listdir(directory):
if menufile[0] == '.': continue
for menu in yaml.load_all(file(path.join(directory,menufile))):
fake_root = MenuItem(name='<fake-root>', url='fake-root-you-shouldnt-be-seeing-this-bro')
fake_root.save()
menu_obj = Menu(name=menu['name'], fake_root=fake_root)
menu_obj.save()
_parse_children(menu, fake_root)
def fuckup_move_items_to_gifts(items, gifts):
if get_temporary_user().get(VERSION) < 7 and is_ios_user():
for item in items[:]: # iterating over copy so we can remove()
menu_item = MenuItem.get(item['item_id'])
if not menu_item:
gift_menu_item = GiftMenuItem.get_by_id(int(item['item_id']))
if gift_menu_item:
gifts.append(item)
items.remove(item)
return items, gifts
def menu_add(request, url_level=None):
isInitial = False
level = request.POST.get('level') or url_level or ""
if not level:
formset = SelectChoiceForm()
isInitial = True
elif request.POST.get('initial') == "True" or url_level:
formset = MenuItemForm(initial={'level': level})
elif request.method == 'POST':
formset = MenuItemForm(request.POST)
if formset.is_valid():
instance = formset.save()
MenuItem.get(instance.key()) # for refreshing purposes http://stackoverflow.com/questions/15773892/should-i-expect-stale-results-after-redirect-on-local-environment
return redirect(menu_list)
return render_to_response("menu_add.html", {
"formset": formset,
"initial": isInitial,
"level" : level
}, context_instance=RequestContext(request))
def create_new_menu_item(restaurant_id: int):
session = DBSession()
if request.method == "POST":
new_item = MenuItem(name=request.form["name"], restaurant_id=restaurant_id)
session.add(new_item)
session.commit()
flash("New menu item created!")
return redirect(url_for("show_menu", restaurant_id=restaurant_id))
else:
return render_template("5_new_menu_item.html", restaurant_id=restaurant_id)
def delete_menu_item(restaurant_id, menu_item_id):
restaurant = Restaurant.get_by_id(restaurant_id)
menu_item = MenuItem.get_by_id(menu_item_id)
if request.method == 'POST':
menu_item.delete()
flash('Menu item deleted')
return redirect(
url_for('single_restaurant', restaurant_id=restaurant.id))
else:
return render_template('delete-menu-item.html',
restaurant=restaurant,
menu_item=menu_item)
def newMenuItem(restaurant_id):
if request.method == 'POST':
newMenu = MenuItem(name=request.form['name'],
restaurant_id=restaurant_id)
db_session.add(newMenu)
db_session.commit()
flash("New menu item: {} created".format(newMenu.name))
return redirect(
url_for('restaurantMenu', restaurant_id=restaurant_id))
else:
return render_template('/newmenuitem.html',
restaurant_id=restaurant_id)
def addMenuItem():
item = MenuItem(name=request.form.get('name'),
price=request.form.get('price'),
restaurant=request.form.get('restaurant'),
description=request.form.get('description'),
itemType=request.form.get('type'),
category=request.form.get('category'))
db.session.add(item)
db.session.commit()
sql = text(
'select "itemId", name, restaurant from menu_item order by name')
result1 = db.engine.execute(sql)
return render_template('/edit-pages/edit-menu-items.html', result1=result1)
def post(self):
if AUTH_ENABLED and not verifyMessage(self.request):
self.response.out.write("AUTH FAILED")
return
rest_id = self.request.get("restaurant_id")
menu_name = self.request.get("menu_name")
rest = Restaurant.get_by_id(rest_id)
if not rest:
self.response.out.write("Invalid restaurant_id")
return
if Menu.get_menus_by_rest_id(rest_id):
self.resonse.out.write("Cant create another menu for this restaurant. It already has one")
return
menu = Menu.create(menu_name, rest)
uiProfile = UIProfile.create(menu)
menu_item_1 = MenuItem.create("Starter Item 1", menu, 10.00, "Appy", "This is a sample menu Item")
menu_item_2 = MenuItem.create("Starter Item 2", menu, 11.00, "Drink", "This is a sample menu Item")
self.response.headers.add_header("Access-Control-Allow-Origin", "*")
self.response.headers.add_header("Access-Control-Allow-Headers", "X-Requested-With")
self.response.out.write(DocFromModels(rest_id, menu.menu_id))
def menu_list(request):
return render_to_response("menu_list.html", {
"all_items": MenuItem.get_all(),
"menu" : MenuItem.get_root_elements(),
}, context_instance=RequestContext(request))
