def populate_database(self):
record = Menu.query.first()
if not record:
new_record = Menu(name="Pasta")
new_record2 = Menu(name="Burger")
new_record3 = Menu(name="Salad")
new_record4 = Menu(name="Risotto")
new_record5 = Menu(name="Cookie")
db.session.add(new_record)
db.session.add(new_record2)
db.session.add(new_record3)
db.session.add(new_record4)
db.session.add(new_record5)
db.session.commit()
def createMenu(self, id = 1):
with self.app.app_context():
menu = Menu.query.get(id)
if not menu:
menu = Menu(category=MenuType.BREAKFAST)
menu.save()
return menu.id
def post(self):
"""Create a new menu item"""
args = self.parser.parse_args()
name = args.get("name", "")
description = args.get("description", "")
price = args.get("price", "")
if empty(name) or empty(description) or empty(price):
return {
"message":
"You have to specify all"
" details of an item"
" such as name, price, description"
}, 403
if not valid_name(name):
return {"message": "Please specify a valid name for item"}, 403
if not valid_price(price):
return {
"message": "Please specify a valid price"
" for the item"
}, 403
if not valid_description(description):
return {
"message": "Please specify a valid description "
"for the item"
}
menu_item = Menu(name, description, price)
saved = menu_item.save()
if saved:
return {
"message": "The menu item was successfully saved",
"data": menu_item.json1
}, 201
return {"message": "There was problem saving the item. Try again"}, 403
def post(self):
'''
添加菜单
'''
args = parse_base.parse_args()
pid = args.get('pid')
name = args.get('name')
url = args.get('url')
icon = args.get('icon')
sort = args.get('sort')
_data = Menu.query.filter_by(name = name,is_del = '0').first()
if _data:
abort(RET.Forbidden,msg='菜单已存在')
model_data = Menu()
model_data.pid = pid
model_data.name = name
model_data.url = url
model_data.icon = icon
model_data.sort = sort
model_data.last_editor = g.admin.username
if model_data.add():
data = {
'status':RET.Created,
'msg':'添加成功',
'data':model_data
}
return marshal(data,sing_fields)
abort(RET.BadRequest,msg='添加失败，请重试')
def setUp(self):
db.create_all()
db.session.add(
Place(name='Testname',
address="123 Test st.",
city="Englewood",
state="Florida",
zip_="34224",
website="http://fake.com",
phone="123-456-7899",
owner="Jeff Reiher",
yrs_open=1))
db.session.add(
Menu(name="burger",
course="dinner",
description="test description",
price="$1.00",
place_id=1))
db.session.add(
User(username="******",
email="*****@*****.**",
password="******",
avatar="picofjeff.jpg"))
db.session.commit()
def create(auth_name, path, level):
if Menu.query.filter(or_(Menu.auth_name == auth_name)).first():
return ValidationErrorResult(message='Menu已存在')
menu = Menu(level=level, auth_name=auth_name, path=path)
db.session.add(menu)
db.session.flush()
return jsonify(schemas.menu_schema.dump(menu)), 201
def menu_manipulation():
auth_header = request.headers.get('Authorization')
if auth_header:
access_token = auth_header.split(" ")[1]
if access_token:
user_id = User.decode_token(access_token)
if isinstance(user_id, int):
current_user = User.query.filter_by(id=user_id).first()
if current_user.caterer:
menu = Menu.query.order_by('menu.date').all()[-1]
if not menu:
abort(404)
if request.method == "DELETE":
menu.delete()
return {
"message":
"Todays menu has been deleted".format(menu.id)
}, 200
elif request.method == 'PUT':
menu_meals = request.data.get('meal_list', '')
date = request.data.get('date', '')
menu.delete()
if date == '':
date = datetime.datetime.now()
if menu_meals:
meals = [Meal.get(id=id) for id in menu_meals]
menu = Menu(date=date)
menu.add_meal_to_menu(meals)
return {
'message':
'The menu has successfully been updated',
'menu': menu_meals
}, 200
return {'message': 'Please add meals to menu'}, 202
menu.save()
else:
response = {
'message':
'You are not authorized to perform these functions'
}
return make_response(jsonify(response)), 401
else:
# user is not legit, so the payload is an error message
message = user_id
response = {'message': message}
return make_response(jsonify(response)), 401
else:
response = {'message': 'Please input access token'}
return make_response(jsonify(response)), 401
else:
return {'message': 'Please input access token'}
def post_new_menu(date_int):
category = request.json['category']
description = request.json['description']
cycle = request.json['cycle']
new_menu = Menu(date_int, category, description, cycle)
db.session.add(new_menu)
db.session.commit()
menu_id = new_menu.menuid
return str(menu_id)
def test_menu_item(self):
test_name = "test"
test_item = Menu(name=test_name)
db.session.add(test_item)
db.session.commit()
response = self.app.get('/menu', follow_redirects=True)
self.assertEqual(response.status_code, 200)
#self.assertEqual(response.mimetype, 'application/json')
body = response.data
self.assertTrue('menu' in body)
def post(self):
menu = request.get_json()
m = Menu(meal_id=menu.get('meal_id'), meal_name=menu.get('meal_name'), price=menu.get('price'),
category=menu.get('category'))
menus.append(m)
result = jsonify({"message": "meal added to menu"})
result.status_code = 201
return result
def menu():
auth_header = request.headers.get('Authorization')
if auth_header:
access_token = auth_header.split(" ")[1]
if access_token:
user_id = User.decode_token(access_token)
if isinstance(user_id, int):
current_user = User.query.filter_by(id=user_id).first()
if request.method == "POST":
if current_user.caterer:
menu_meals = request.data.get('meal_list', '')
date = request.data.get('date', '')
if date == '':
date = datetime.datetime.now()
if menu_meals:
meals = [Meal.get(id=id) for id in menu_meals]
menu = Menu(date=date)
menu.add_meal_to_menu(meals)
return {
'message': 'Todays menu has been updated'
}, 201
return {'message': 'Please add meals to menu'}, 202
else:
response = {
'message':
'You are unauthorized to access this'
}
return make_response(jsonify(response)), 401
else: # GET
menu = Menu.query.order_by('menu.date').all()[-1]
menu_meals = [item.make_dict() for item in menu.meals]
return {
'message': 'Here is the menu for today',
'menu': menu_meals
}, 200
else:
# user is not legit, so the payload is an error message
message = user_id
response = {'message': message}
return make_response(jsonify(response)), 401
else:
response = {'message': 'Please input access token'}
return make_response(jsonify(response)), 401
else:
return {'message': 'Please input access token'}
def test_list_menus_range_ok_response(
self, mock_menu_controller_pagination_meta,
mock_meal_item_repo_get,
mock_menu_repo_get_range_paginated_options,
mock_meal_periods_has_value, mock_auth_get_location):
'''Test list_menus_range OK response.
'''
# Arrange
with self.app.app_context():
mock_auth_get_location.return_value = 1
mock_meal_periods_has_value.return_value = True
mock_menu = Menu(date=datetime.now(),
meal_period='',
location_id=1,
main_meal_id=1,
allowed_side=1,
allowed_protein=1,
side_items='1,2',
protein_items='1,2',
vendor_engagement_id=1,
created_at=datetime.now(),
updated_at=datetime.now())
mock_meal_item = MealItem(id=1,
meal_type=1,
name='',
image='',
location_id=1,
created_at=datetime.now(),
updated_at=datetime.now())
mock_menu_repo_get_range_paginated_options.return_value.items = [
mock_menu,
]
mock_meal_item_repo_get.return_value = mock_meal_item
mock_period_start_date = '2019-01-01'
mock_period_end_date = '2019-02-28'
mock_menu_controller_pagination_meta.return_value = {
'total_rows': 1,
'total_pages': 1,
'current_page': 1,
'next_page': False,
'prev_page': False
}
menu_controller = MenuController(self.request_context)
# Act
result = menu_controller.list_menus_range('lunch',
mock_period_start_date,
mock_period_end_date)
# Assert
assert result.status_code == 200
assert result.get_json()['msg'] == 'OK'
def new_menu_item(place_id):
if request.method == "POST":
new_menu = Menu(name=request.form["name"],
course=request.form["course"],
description=request.form["description"],
price=request.form["price"],
place_id=place_id,
user_id=current_user.id)
db.session.add(new_menu)
db.session.commit()
flash("Just add a new menu item", "success")
return redirect(url_for("home.show_menu", place_id=place_id))
return render_template("new_menu.html", place_id=place_id)
def test_delete_menu_already_deleted(self, mock_menu_repo_get):
'''Test response on delete_menu when menu is already
deleted.
'''
# Arrange
with self.app.app_context():
mock_menu_repo_get.return_value = Menu(is_deleted=True)
menu_controller = MenuController(self.request_context)
# Act
result = menu_controller.delete_menu(1)
# Assert
assert result.status_code == 400
assert result.get_json()['msg'] == 'Menu has already been deleted'
def save_menu(form):
session = ORM.db()
try:
menu = Menu(game_id=form.id.data,
item=form.name.data,
url=form.url.data,
createdAt=dt())
session.add(menu)
except Exception as e:
session.rollback()
else:
session.commit()
finally:
session.close()
return
def post(self):
try:
form = request.get_json(force=True)
# print(form)
name = form.get('name')
if name is None:
ret = {'message': 'Menu name is required'}
return Response(json.dumps(ret),
status=400,
mimetype='application/json')
used = form.get('used')
if used is None:
used = 0
try:
used = int(used)
except Exception as e:
print(e)
ret = {'message': ('Used must be 0 or 1,' ' 1 means in use')}
return Response(json.dumps(ret),
status=400,
mimetype='application/json')
if used != 0 and used != 1:
ret = {'message': ('Used must be 0 or 1,' ' 1 means in use')}
return Response(json.dumps(ret),
status=400,
mimetype='application/json')
menu = Menu()
menu.name = name
menu.used = used
menu.restId = 1
menu.delete = False
db.session.add(menu)
db.session.commit()
ret = {'message': 'Add a new menu successfully', 'id': menu.id}
return Response(json.dumps(ret),
status=200,
mimetype='application/json')
except Exception as e:
print(e)
ret = {'message': 'Internal Server Error'}
return Response(json.dumps(ret),
status=500,
mimetype='application/json')
def createMenuItem(self, id=1):
with self.app.app_context():
menu_item = MenuItem.query.get(id)
if not menu_item:
menu = Menu.query.get(1)
if not menu:
menu = Menu(category=MenuType.BREAKFAST)
menu.save()
meal_name = 'ugali'
meal = Meal.query.filter_by(name=meal_name).first()
if not meal:
meal = Meal(name=meal_name, img_path='#', cost=200)
meal.save()
menu_item = MenuItem(menu_id=menu.id, meal_id=meal.id)
menu_item.save()
return menu_item.id
def test_delete_menu_successful(self, mock_menu_repo_get,
mock_meal_repo_update):
'''Test delete_menu success.
'''
with self.app.app_context():
mock_menu_repo_get.return_value = Menu(is_deleted=False)
mock_meal_repo_update.return_value = Mock()
menu_controller = MenuController(self.request_context)
# Act
result = menu_controller.delete_menu(1)
# Assert
assert result.status_code == 200
assert result.get_json()['msg'] == 'Menu deleted'
assert result.get_json()['payload']['status'] == 'success'
def put(self, menu_id):
"""Update a menu item"""
menu = Menu.find_by_id(meal_id=menu_id)
if menu is None:
return {
"message":
"The menu item with an id number %s doesn't"
" exist" % menu_id
}, 404
args = self.parser.parse_args()
name = args.get("name", "")
description = args.get("description", "")
price = args.get("price", "")
if empty(name) or empty(description) or empty(price):
return {
"message":
"You have to specify all"
" details of an item"
" such as name, price, description"
}, 403
if not valid_name(name):
return {"message": "Please specify a valid name for item"}, 403
if not valid_price(price):
return {
"message": "Please specify a valid price"
" for the item"
}, 403
if not valid_description(description):
return {
"message": "Please specify a valid description "
"for the item"
}
menu_item = Menu(name, description, 200)
menu_item.id = menu.id
updated = menu_item.update()
if updated:
return {
"message": "The menu item was successfully updated",
"menu_item": menu_item.json
}, 200
else:
return {
"message":
"There was a problem updating the menu item"
" maybe you provided a name already taken by"
" another menu item"
}, 400
def admin_menu():
form = MenuForm()
menuItems = Menu.query.all()
if request.method=='POST':
file = form.m_img.data
filename = file.filename
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
menu = Menu(
m_title = form.m_title.data,
m_price = form.m_price.data,
m_content = form.m_content.data,
m_img = filename
)
db.session.add(menu)
db.session.commit()
return redirect(url_for('admin_menu'))
return loginCheck(render_template('admin/menu.html',form = form,menuItems=menuItems))
def test_user_can_access_menu(self):
"""Test user can access the menu (GET request)."""
date = datetime.utcnow().date()
menu = Menu(date=date)
meal = Meal(name='Beef', description='Saucy beef', price=10)
meal.save()
menu.add_meal_to_menu(meal)
menu.save()
result = self.login_user()
self.assertEqual(200, result.status_code)
access_token = json.loads(result.data.decode())['access_token']
res = self.client().get('api/v1/menu/',
headers=dict(Authorization="Bearer " +
access_token))
self.assertEqual(res.status_code, 200)
self.assertEqual('Here is the menu for today',
json.loads(res.data.decode('utf-8'))['message'])
def test_list_menus_valid_meal_period_date(self,
mock_menu_repo_get_meal_items,
mock_meal_repo_get,
mock_menu_repo_get_unpaginated,
mock_auth_get_location,
mock_meal_periods_has_value):
'''Test list_menus response when the meal period or date is valid.
'''
# Arrange
with self.app.app_context():
mock_menu = Menu(date=datetime.now(),
meal_period='',
location_id=1,
main_meal_id=1,
allowed_side=1,
allowed_protein=1,
side_items='',
protein_items='',
vendor_engagement_id=1,
created_at=datetime.now(),
updated_at=datetime.now())
mock_meal_item = MealItem(id=1,
meal_type=1,
name='',
image='',
location_id=1,
created_at=datetime.now(),
updated_at=datetime.now())
mock_meal_periods_has_value.return_value = True
mock_auth_get_location.return_value = 1
mock_menu_repo_get_unpaginated.return_value = [
mock_menu,
]
mock_meal_repo_get.return_value = mock_meal_item
mock_menu_repo_get_meal_items.return_value = []
menu_controller = MenuController(self.request_context)
# Act
result = menu_controller.list_menus('lunch', '2019-02-01')
# Assert
assert result.status_code == 200
assert result.get_json()['msg'] == 'OK'
def addmenu():
nam = []
form = MenuForm()
meal = Meal.query.all()
for m in meal:
nam.append(m.name)
print(m.name)
if request.method == 'POST':
req = request.form
mname = req['meal_name']
type = req['meal_type']
week = req['weekday']
menu = Menu(meal_name=mname,
description=form.description.data,
type=type,
week_day=week)
db.session.add(menu)
db.session.commit()
return redirect(url_for('result'))
return render_template('addMenu.html', form=form, nam=nam)
def post(current_user, self, meal_id):
if not current_user.type_admin:
response = jsonify(
{"message": "Not authorized to perform this function!"})
response.status_code = 401
return response
meal = Meal.query.filter_by(id=meal_id).first()
if not meal:
response = jsonify({"message": "Meal not available"})
response.status_code = 404
return response
menus = Menu(meal.m_name, meal.category, meal.price)
menus.save()
response = jsonify({"message": "Meal added to menu"})
response.status_code = 200
return response
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('name', required = True,
help = 'This can not be blank')
parser.add_argument('description', type = str,
default = "")
data = parser.parse_args()
new_menu = Menu(
name = data['name'],
description = data['description']
)
try:
new_menu.add_menu_to_db()
return {
'message': 'Menu {} created successfully'.format(data['name'])
}, 201
except:
return {
'message': 'Something went wrong.'
}, 500
def test_update_menu_ok_response(self, mock_meal_item_repo_get,
mock_menu_repo_update, mock_menu_repo_get,
mock_menu_controller_request_params):
'''Test update_menu when the response is OK.
'''
# Arrange
with self.app.app_context():
mock_menu_controller_request_params.return_value = ('2019-01-01',
'lunch', 1, 1,
1, '1,1',
'1,2', 1)
mock_menu = Menu(date=datetime.now(),
meal_period='',
location_id=1,
main_meal_id=1,
allowed_side=1,
allowed_protein=1,
side_items='1,2',
protein_items='1,2',
vendor_engagement_id=1,
created_at=datetime.now(),
updated_at=datetime.now())
mock_meal_item = MealItem(id=1,
meal_type=1,
name='',
image='',
location_id=1,
created_at=datetime.now(),
updated_at=datetime.now())
mock_menu_repo_get.return_value = mock_menu
mock_menu_repo_update.return_value = mock_menu
mock_meal_item_repo_get.return_value = mock_meal_item
mock_menu_id = 1
menu_controller = MenuController(self.request_context)
# Act
result = menu_controller.update_menu(mock_menu_id)
# Assert
assert result.status_code == 200
assert result.get_json()['msg'] == 'OK'
def menu_add():
"""添加菜单
@@@
#### args
| args | nullable | type | remark |
|--------|--------|--------|--------|
| menu_name | False | String | 菜单昵称 |
| menu_path | True | String | 菜单路径 |
| menu_icon | True | String | 菜单图标类 |
| parent_id | True | Int | 所属菜单 |
#### return
- ##### json
> {"msg": "success", "code": 200}
@@@
"""
menu_name = request.form.get("menu_name")
menu_path = request.form.get("menu_path") if request.form.get(
"menu_path") else None
menu_icon = request.form.get("menu_icon") if request.form.get(
"menu_icon") else "icon"
parent_id = request.form.get("parent_id") if request.form.get(
"parent_id") else 0
if menu_name is None:
return jsonify({"status": 201, "msg": "菜单昵称不能为空"})
elif Menu.query.filter_by(menu_name=menu_name).first() is not None:
return jsonify({"status": 202, "msg": "菜单项已存在"})
else:
res = Menu(menu_name=menu_name,
menu_path=menu_path,
menu_icon=menu_icon,
parent_id=parent_id)
db.session.add(res)
db.session.commit()
return jsonify({
"username": res.menu_name,
"status": 200,
"msg": "添加成功"
})
def menu_create(icon, url, name, identifier, is_hide, is_hide_children, important, parent_id):
try:
new_menu = Menu()
new_menu.icon = icon
new_menu.url = url
new_menu.name = name
new_menu.identifier = identifier
if is_hide == 1:
new_menu.is_hide = True
elif is_hide == 2:
new_menu.is_hide = False
else:
raise Exception('is_hide_children information is incorrect, 1 is True, 2 is False')
if is_hide_children == 1:
new_menu.is_hide_children = True
elif is_hide_children == 2:
new_menu.is_hide_children = False
else:
raise Exception('is_hide_children information is incorrect, 1 is True, 2 is False')
new_menu.important = important
if parent_id:
parent_menu = db.session.query(Menu).filter_by(id=parent_id).first()
if parent_menu:
new_menu.parent_id = parent_id
else:
new_menu.parent_id = 0
else:
new_menu.parent_id = 0
db.session.add(new_menu)
db.session.flush()
db.session.commit()
return new_menu.id
except Exception as e:
# print(e)
raise Exception('Database operation exception')
def test_update_menu_when_menu_is_deleted(
self, mock_menu_repo_get, mock_menu_controller_request_params):
'''Test update_menu when the menu is deleted.
'''
# Arrange
with self.app.app_context():
mock_deleted_menu = Menu(is_deleted=True)
mock_menu_repo_get.return_value = mock_deleted_menu
mock_menu_controller_request_params.return_value = (None, None,
None, None,
None, None,
None, None)
mock_menu_id = 1
menu_controller = MenuController(mock_menu_id)
# Act
result = menu_controller.update_menu(mock_menu_id)
# Assert
assert result.status_code == 400
assert result.get_json()['msg'] == 'This menu is ' \
'already deleted'
def menu_create(options=None):
new_menu = Menu()
new_menu.icon = options['icon']
new_menu.url = options['url']
new_menu.name = options['name']
new_menu.identifier = options['identifier']
if options['is_hide'] == 1:
new_menu.is_hide = True
elif options['is_hide'] == 2:
new_menu.is_hide = False
else:
print('is_hide')
return False
if options['is_hide_children'] == 1:
new_menu.is_hide_children = True
elif options['is_hide_children'] == 2:
new_menu.is_hide_children = False
else:
print('is_hide_children')
return False
# new_menu.is_hide = False
# new_menu.is_hide_children = False
new_menu.important = options['important']
if options['parent_id']:
parent_menu = db.session.query(Menu).filter_by(id=options['parent_id']).first()
if parent_menu:
new_menu.parent_id = options['parent_id']
else:
new_menu.parent_id = 0
else:
new_menu.parent_id = 0
try:
db.session.add(new_menu)
db.session.commit()
except Exception, e:
return False
