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))