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 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 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 __get_products(category, resto_products):
products = []
group_modifiers = {}
single_modifiers = {}
for resto_product in resto_products:
product = MenuItem(id=resto_product['productId'])
product.category = category.key
product.title = resto_product['name']
product.description = resto_product['description']
product.weight = resto_product['weight'] * 1000
product.kal = int(resto_product['energyAmount'] or 0)
product.carbohydrate = float(resto_product['carbohydrateAmount'] or 0)
product.fat = float(resto_product['fatAmount'] or 0)
product.fiber = float(resto_product['fiberAmount'] or 0)
product.picture = resto_product['images'][0] if resto_product[
'images'] else ''
product.price = int(resto_product['price'] * 100)
product.sequence_number = resto_product['order']
products.append(product)
product_group_modifiers = __get_group_modifiers(
resto_product['modifiers'])
product.group_modifiers = product_group_modifiers.keys()
group_modifiers.update(product_group_modifiers)
product_single_modifiers = __get_single_modifiers(
resto_product['single_modifiers'])
product.single_modifiers = product_single_modifiers.keys()
single_modifiers.update(product_single_modifiers)
return products, group_modifiers, single_modifiers
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 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 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 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_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 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 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(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 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 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 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 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 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 new_menu_item():
""" Display page to create new menu item"""
session = connect()
if request.method == 'POST':
newItem = MenuItem(name=request.form['name'],
course=request.form['course'],
description=request.form['description'],
price=request.form['price'])
session.add(newItem)
session.commit()
flash("New menu item '%s' created!" % newItem.name)
return redirect(url_for('show_menu'))
else:
return render_template('newMenuItem.html', title="New Menu Item")
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):
if 'username' not in login_session:
return redirect('/login')
restaurant = Restaurant.query.filter_by(id=restaurant_id).one()
if request.method == 'POST':
newMenu = MenuItem(course=request.form['menuCourse'],
description=request.form['menuDescription'],
name=request.form['menuName'],
price=request.form['menuPrice'],
restaurant_id=restaurant_id)
db.session.add(newMenu)
db.session.commit()
return redirect(url_for('showMenu', restaurant_id=restaurant_id))
elif request.method == 'GET':
return render_template('newRestaurantMenuItem.html',
restaurant_id='restaurant_id',
restaurant=restaurant)
def add_menu_item(loggedInUser):
dataReceived = request.get_json()
validMenuItemCheck = validateMenuItemCreation(dataReceived)
if loggedInUser and loggedInUser.isAdmin:
if validMenuItemCheck['valid']:
restaurant = Restaurant.query.filter_by(
name=dataReceived['restaurantName']).first()
new_menu_item = MenuItem.query.filter_by(
name=dataReceived['name'], restaurantId=restaurant.id).first()
print(new_menu_item)
if not new_menu_item:
item_to_be_added = MenuItem(
name=dataReceived['name'],
restaurantId=restaurant.id,
description=dataReceived['description'],
price=dataReceived['price'],
category=dataReceived['category'],
type=dataReceived['type'])
db.session.add(item_to_be_added)
db.session.commit()
return make_response(
'Menu item created', 200,
{'WWW-Ahtenticate': 'Basic realm="Menu Item created!'})
else:
return make_response(
'Cannot create menu item', 401, {
'WWW-Ahtenticate':
'Basic realm="' + validMenuItemCheck['message'] + '!"'
})
else:
return make_response(
'Cannot create menu item', 401, {
'WWW-Ahtenticate':
'Basic realm="' + validMenuItemCheck['message'] + '!"'
})
else:
return make_response('Cannot create menu item', 401, {
'WWW-Ahtenticate':
'Basic realm="No Permisson to create menu items !"'
})
def post(self):
status_code = 200
parser = reqparse.RequestParser()
parser.add_argument("restaurant_id")
parser.add_argument("name")
parser.add_argument("description")
parser.add_argument("price")
args = parser.parse_args()
try:
item = MenuItem(restaurant_id=args['restaurant_id'], name=args['name'], description=args['description'],
price=args['price'])
db.session.add(item)
db.session.commit()
result = {'Item Name': item.name}
except:
status_code = 404
result = {'message': 'There is some error'}
return result, status_code
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 newItem():
catagory = session.query(Catagory).order_by(Catagory.name)
if 'username' not in login_session:
return redirect('/login')
if request.method == 'POST':
newItem = MenuItem(name=request.form['name'],
description=request.form['description'],
price_retail=request.form['price_retail'],
price_wholesale=request.form['price_wholesale'],
picture=request.form['picture'],
catagory_id=request.form.get("catagory_id", None),
quantity=request.form['quantity'],
user_id=login_session['user_id'])
flash('New item, %s, successfully created' % newItem.name)
session.add(newItem)
session.commit()
return redirect(url_for('showMain'))
else:
return render_template('newItem.html', catagory=catagory)
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 newMenuItem():
if 'email' not in login_session:
return redirect('/login')
if request.method == 'POST':
selected_category = session.query(Category).filter_by(
title=request.form['categoryname']).one()
newMenuItem = MenuItem(title=request.form['title'],
description=request.form['description'],
category_id=selected_category.id,
user_id=login_session['user_id'])
session.add(newMenuItem)
flash('Item %s successfully added' % newMenuItem.title)
session.commit()
return redirect(
url_for('showItems', categoryname=selected_category.title))
else:
categories = session.query(Category).all()
return render_template('newmenuitem.html',
categories=categories,
is_authenticated=is_authenticated)
def add_menu_item(session, name, price, likes, vendor_id):
# Creates a new menu item
# Will add "description" later
try:
menu_item = session.query(MenuItem).filter_by(name=name).filter_by(vendor_id=vendor_id).first()
if menu_item == None:
menu_item = MenuItem(
name=name,
price=price,
likes=likes,
vendor_id=vendor_id
# description = description
)
session.add(menu_item)
output = "New MenuItem"
else:
output = "MenuItem Already Exists"
session.commit()
print output, menu_item
except:
print >> sys.stderr, "Error while adding menu item", name
traceback.print_exc(file=sys.stderr)
print >> sys.stderr, " "
def post(self):
category_id = self.request.get_range('category_id')
category = MenuCategory.get_by_id(category_id)
if not category:
self.abort(400)
item = MenuItem(title=self.request.get('title'))
item.description = self.request.get('description')
if self.request.get('price'):
price = float(self.request.get('price'))
item.price = int(round(price * 100))
item.kal = self.request.get_range('kal')
if self.request.get('volume'):
item.volume = float(self.request.get('volume'))
if self.request.get('weight'):
item.weight = float(self.request.get('weight'))
item.sequence_number = category.generate_sequence_number()
item.put() # it is need to get id in saving image
if self.request.get('image_file') or self.request.get('picture'):
if self.request.get('image_file'):
new_url = get_new_image_url('MenuItem', item.key.id(), image_data=str(self.request.get('image_file')))
if new_url:
item.picture = new_url
elif self.request.get('picture'):
new_url = get_new_image_url('MenuItem', item.key.id(), url=self.request.get('picture'))
if new_url:
item.picture = new_url
if item.picture:
item.icon = get_new_image_url('MenuItemIcon', item.key.id(), url=item.picture, size=ICON_SIZE)
item.category = category.key
if not self.request.get('restriction_on'):
for venue in Venue.query().fetch():
item.restrictions.append(venue.key)
item.put()
self.redirect('/company/menu/item/list?category_id=%s' % category_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':
uploadedFile = request.files['image']
menuItem = MenuItem(name=request.form['name'],
description=request.form['description'],
price=request.form['price'],
category=request.form['category'],
image=uploadedFile.filename,
restaurant_id=restaurant_id,
user_id=restaurant.user_id)
if uploadedFile and allowed_file(uploadedFile.filename):
filename = secure_filename(uploadedFile.filename)
uploadedFile.save(
os.path.join(app.config['UPLOAD_FOLDER'], filename))
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)
