class TestProduct(unittest.TestCase): def setUp(self): self.manufacturer_1 = Manufacturer( "Cadbury's", "PO Box 12, Bournville, Birmingham B30 2LU", True) self.product1 = Product("Dairy Milk", "bar of milk chocolate", 5, 0.2, 1, "chocolate bars", self.manufacturer_1) def test_product_has_name(self): self.assertEqual("Dairy Milk", self.product1.name) def test_product_has_description(self): self.assertEqual("bar of milk chocolate", self.product1.description) def test_product_has_stock_quantity(self): self.assertEqual(5, self.product1.stock_quantity) def test_product_has_buying_cost(self): self.assertEqual(0.2, self.product1.buying_cost) def test_product_has_selling_price(self): self.assertEqual(1, self.product1.selling_price) def test_product_has_category(self): self.assertEqual("chocolate bars", self.product1.category) def test_product_has_manufacturer(self): self.assertEqual(self.manufacturer_1, self.product1.manufacturer) def test_can_calculate_profit(self): self.assertEqual(0.8, self.product1.calculate_profit(self.product1)) def test_can_calculate_markup(self): self.assertEqual(400, self.product1.calculate_markup(self.product1))
def create_fixtures(self): self.user_email = self.user_email_template.format(random_string(8)) self.user = User(self.user_email, 'test_user') self.db.session.add(self.user) self.group_name = self.group_template.format(random_string(8)) self.group = ProductGroup(type='test', name=self.group_name, capacity_max=10) self.product1 = Product(name=self.product1_name, parent=self.group, capacity_max=3) self.tier1_1 = PriceTier(name=self.tier1_1_name, parent=self.product1) self.price1_1 = Price(price_tier=self.tier1_1, currency='GBP', price_int=10) self.db.session.add(self.tier1_1) self.tier1_2 = PriceTier(name=self.tier1_2_name, parent=self.product1) self.price1_2 = Price(price_tier=self.tier1_2, currency='GBP', price_int=20) self.db.session.add(self.tier1_2) self.product2 = Product(name=self.product2_name, parent=self.group) self.tier3 = PriceTier(name=self.tier3_name, parent=self.product2) self.price3 = Price(price_tier=self.tier3, currency='GBP', price_int=30) self.db.session.add(self.tier3) self.db.session.commit()
def job_package(): # Log.info("请异步发送") need_do = '' orders = Order.get_working_orders() for order in orders: product = Product.lookup(order['p_id']) exchange = Exchange.get_exchange(order['e_id']) packages = Package.getPackageByName(order['package_id']) for package in packages: need_do = need_do+json.dumps({'port':product['port'],'bandwidth':order['bandwidth'],\ 'status':order['status'],'port_name':product['port'], 'ipAddress':exchange['ipAddress'], \ 'package_id':package['package_name']}) # Order.finish_order(order['_id']) need_back = '' orders = Order.get_back_orders() for order in orders: custom_time = order['custom_time'] product = Product.lookup(order['p_id']) exchange = Exchange.look(order['e_id']) packages = Package.getPackageByName(order['package_id']) for package in packages: need_back = need_back+json.dumps({'port':product['port'],'ex_bandwidth':order['bandwidth'],\ 'status':order['status'],'port_name':product['port'], 'ipAddress':exchange['ipAddress'], \ 'package_id':package['package_name']}) # Order.back_order(order['_id']) print 'set_package_job end at ', datetime.datetime.now()
def post(self): product = Product() product.from_json(request.json) product_repository.add_product(product, current_user.id) inventory = Inventory() inventory.product_id = product.id inventory_repository.add_inventory(inventory)
def get_product(): if 'view' in request.args: user_data = session.get('user_data', None) logged_in = session.get('logged_in', False) id=request.args['view'] product = Product.get_product(connection,id) if logged_in: user = json.loads(user_data) user_id = user['id'] quantity_recommendations = 6 with_rated = False print("User id para recomendaciones", user_id) candidate_generation = user_candidate_generation(user_id, "id", "id_product") total_sources = get_total_sources(candidate_generation, user_id, with_rated=with_rated, verbosity=0) recp = total_sources[0:quantity_recommendations] # Aquí se enviará la lista de productos de recomendaciones personalizadas. res = grs(user_id) if res: recg = res else: recg = Product.select_best_sellers(connection, 6) return render_template("module_home/product.html", logged_in =logged_in, user=json.loads(user_data) if user_data else None, product = product, recp=recp, recg=recg, similar=Product.select_similar_products(connection,product.id_product,product.id_category,3)) else: return render_template("module_home/product.html", logged_in =logged_in, product = product, similar=Product.select_similar_products(connection,product.id_product,product.id_category,3))
def select_category(self): """ Method used when cb_category is activated This method retrieves the product depending of the source selected by the user. Load the product's name in cb_producty Combobox """ if self.ui.cb_category.count() > 0: category = self.ui.cb_category.currentText() if self.ui.cb_source.currentText() == "API": self.products = Prod.select_from_api(self.message, self.sql, category) else: self.products = Prod.select_from_db(self.sql, self.message, category) if len(self.products) == 0: self.products = Prod.select_from_api( self.message, self.sql, category) if len(self.products) > 0: self.ui.cb_substitute.clear() widgets.empty_table_column(self.ui.tab_product, 1) widgets.empty_table_column(self.ui.tab_substitute, 1) products_name = [ str(product) for product in self.products[:CST.NB_OF_PRODUCT_TO_SHOW] ] widgets.add_list_items_to_combobox( self.ui.cb_product, products_name, ) Message.select(self.message, "product")
def save_product(self, product): link = product.find("a", {"class": "product"}).get("href") image = product.find("img").get("src") try: site_product_id = link.split("?productId=xlsImpprod")[1] except IndexError: site_product_id = link.split("productId=")[1] brand = product.find("h4", {"class": "prod-title"}).text.strip() item_name = product.find("p", {"class": "prod-desc"}).text.strip() item_name = item_name.replace("Online Only ", "") try: price = product.find("span", {"class": "regPrice"}) except AttributeError: price = product.find("span", {"class": "pro-new-price"}) if price is not None: price = WebFunctions.only_digits(price.text) product = Product(site_name="ulta", link=link, image=image, site_product_id=site_product_id, brand=brand, item_name=item_name, price=price) product.add_product(self.database)
def addProductType(): # form : product_id, bar_code form = request.form.to_dict() print('form', form) # 上传图片 file = request.files['file'] if file is not None: # 储存图片获取数据 data = Img.save_one(file, form) print('upload data', data) if data['src'] is not None and base_url not in data['src']: data['src'] = base_url + '/' + data['src'] form['cover'] = data['src'] if data is not None: r = Res.success(data) else: r = Res.fail({}, msg='图片已存在') print('新图片', form) product = Product.add(form) if type(product) is str: r = Res.fail(msg=product) else: all = Product.all() print('all', all) r = Res.success(all) return make_response(jsonify(r))
def deleteProductFromList(self, list_id, pid): if list_id ==None or pid ==None: return False Product.deleteProduct(pid) ListOfProducts.deleteProduct(pid) return True
def test_bakery(self): vs = Product("Vegemite Scroll", "VS5", {3: 6.99, 5: 8.99}) mb = Product("Blueberry Muffin", "MB11", {2: 9.95, 5: 16.95, 8: 24.95}) cf = Product("Croissant", "CF", {3: 5.95, 5: 9.95, 9: 16.99}) bakery = Bakery([vs, mb, cf]) # test get product by code test_code = "VS5" self.assertEqual(bakery.get_product("VS5").code, test_code) self.assertRaises(KeyError, bakery.get_product, "not_exist_code") # init order for test order = Order({"VS5": "10", "WRONG_CODE": 14, "CF": 13}) # input format test bakery.process_order(order) self.assertTrue(order.get_product("WRONG_CODE")["total_price"] is None) # test single product order order = Order({"VS5": 10}) bakery.process_order(order) self.assertEqual(order.get_product("VS5")["packs"], {5: 2}) # test combined products order order = Order({"VS5": 10, "MB11": 14, "CF": 13}) bakery.process_order(order) self.assertEqual(order.get_product("VS5")["packs"], {5: 2}) self.assertEqual(order.get_product("VS5")["remainder"], 0) self.assertEqual(order.get_product("MB11")["packs"], {8: 1, 2: 3}) self.assertEqual(order.get_product("MB11")["remainder"], 0) self.assertEqual(order.get_product("CF")["remainder"], 0) self.assertEqual(order.get_product("CF")["packs"], {5: 2, 3: 1})
def add_product_to_db(product: dict) -> None: """Takes a dictionary and inserts the product into the db. If a product with duplicate name is found, existing data will be updated if the 'date_updated' is higher than the existing record. Parameters ---------- product : dict Row of Product data Returns ------- None """ try: Product.insert( product_name=product["product_name"], product_price=product["product_price"], product_quantity=product["product_quantity"], date_updated=product["date_updated"], ).execute() except IntegrityError: result = Product.get(product_name=product["product_name"]) if product["date_updated"] >= result.date_updated: result.product_quantity = product["product_quantity"] result.product_price = product["product_price"] result.date_updated = product["date_updated"] result.save()
def on_ticket_clicked(self, button): from reportlab.platypus import Table from reportlab.platypus import SimpleDocTemplate from reportlab.lib.pagesizes import A4 from reportlab.lib import colors script = [] table_header = [["ID", "NOMBRE", "TIPO", "STOCK", "PRECIO", "DESCRIPCION"]] table = Table(table_header) table.setStyle([('INNERGRID', (0,0),(-1,-1), 0.25, colors.black), ('BOX', (0,0), (-1,-1), 0.25, colors.black)]) script.append(table) product = Product(self.search_entry.get_text()) # New costumer object with the user id on search_entry product_list = product.get_products() # Gets the database data if product_list == []: #self.validation_label.set_markup("<span color='red'>No existe ese usuario</span>") '''''' else: table = Table(product_list) table.setStyle([('BOX', (0,0),(-1,-1), 0.25, colors.black), ('INNERGRID', (0, 0), (-1, -1), 0.25, colors.black)]) script.append(table) #creacion del archivo pdf doc = SimpleDocTemplate("productos.pdf", pagesize=A4, showBoundary=1) doc.build(script)
def edit2(id): cat = Category() pro = Product() a = cat.getCategories() b = pro.getProductById(id) print(b) return render_template('product/edit2.html', arr=a, u=b)
def create_database() -> None: """Create the database """ try: Product.create_table(safe=True) except InternalError as err: print(str(err))
class TestProduct(unittest.TestCase): def setUp(self): self.product = Product("Castlemania", "Thee Oh Sees", "Castleface Records", "LP", "Psychedelic", 25, 9.50, 15.99) def test_product_has_title(self): self.assertEqual("Castlemania", self.product.title) def test_product_has_artist(self): self.assertEqual("Thee Oh Sees", self.product.artist) def test_product_has_record_label(self): self.assertEqual("Castleface Records", self.product.record_label) def test_product_has_format(self): self.assertEqual("LP", self.product.format) def test_product_has_genre(self): self.assertEqual("Psychedelic", self.product.genre) def test_product_has_quantity(self): self.assertEqual(25, self.product.quantity) def test_product_has_buy_cost(self): self.assertEqual(9.50, self.product.buy_cost) def test_product_has_sell_price(self): self.assertEqual(15.99, self.product.sell_price) def test_calculate_margin(self): self.assertEqual(6.49, self.product.calculate_margin()) def test_calculate_total_margin(self): self.assertEqual(162.25, self.product.calculate_total_margin())
def generate_report(): try: product = Product() myresult = product.get_inf_report() wb = Workbook() headers = [ "ProductID", "DepartmentID", "Category", "IDSKU", "ProductName", "Quantity", "UnitPrice", "UnitPriceUSD", "UnitPriceEuro", "Ranking", "ProductDesc", "UnitsInStock", "UnitsInOrder" ] sheet1 = wb.add_sheet("Report") for i in range(len(headers)): sheet1.write(0, i, headers[i]) counter = 0 for x in myresult: counter += 1 for i in range(len(headers)): sheet1.write(counter, i, x[i]) now = datetime.now() datetime_now = now.strftime("%d%m%Y_%H%M%S") wb.save("report_" + str(datetime_now) + ".xls") print(get_time_now() + " Report generated successfully!") logging.info(get_time_now() + " Report generated successfully!") except BaseException as e: print(get_time_now() + " Problem with generate_report function." + str(e)) logging.error(get_time_now() + " Problem with generate_report function." + str(e))
def job_package(): # Log.info("请异步发送") need_do = '' orders = Order.get_working_orders() for order in orders: product = Product.lookup(order['p_id']) exchange = Exchange.get_exchange(order['e_id']) packages = Package.getPackageByName(order['package_id']) for package in packages: need_do = need_do+json.dumps({'port':product['port'],'bandwidth':order['bandwidth'],\ 'status':order['status'],'port_name':product['port'], 'ipAddress':exchange['ipAddress'], \ 'package_id':package['package_name']}) # Order.finish_order(order['_id']) need_back='' orders = Order.get_back_orders() for order in orders: custom_time = order['custom_time'] product = Product.lookup(order['p_id']) exchange = Exchange.look(order['e_id']) packages = Package.getPackageByName(order['package_id']) for package in packages: need_back = need_back+json.dumps({'port':product['port'],'ex_bandwidth':order['bandwidth'],\ 'status':order['status'],'port_name':product['port'], 'ipAddress':exchange['ipAddress'], \ 'package_id':package['package_name']}) # Order.back_order(order['_id']) print 'set_package_job end at ',datetime.datetime.now()
def post(self): product_data = ProductSchema().load(request.json) quantity = product_data.pop("quantity", None) shop_id = product_data.pop("shop_id", None) product = Product(**product_data) try: product.save() except: return {"message": ERROR_INSERTING_PRODUCT}, 500 inventory_data = { "product_id": product.id, "quantity": quantity, "shop_id": shop_id } inventory = Inventory(**inventory_data) try: inventory.save() except: return {"message": ERROR_INSERTING_INVENTORY}, 500 return {"id": str(product.id)}, 201
def search_results(): if 'q' in request.args: prods = Product.query(connection,request.args['q'],6) user_data = session.get('user_data', None) logged_in = session.get('logged_in', False) if logged_in: user = json.loads(user_data) user_id = user['id'] quantity_recommendations = 6 with_rated = False print("User id para recomendaciones", user_id) candidate_generation = user_candidate_generation(user_id, "id", "id_product") total_sources = get_total_sources(candidate_generation, user_id, with_rated=with_rated, verbosity=0) recp = total_sources[0:quantity_recommendations] # Aquí se enviará la lista de productos de recomendaciones personalizadas. res = grs(user_id) if res: recg = res else: recg = Product.select_best_sellers(connection, 6) return render_template("module_home/search.html", logged_in=logged_in, prods= prods, user=json.loads(user_data) if user_data else None, recp=recp, recg=recg ) else: return render_template("module_home/search.html", logged_in=logged_in, prods= prods, )
def step_impl(context): for row in context.table: try: Product.get(Product.name == row['name']) except Product.DoesNotExist: Product.create(name=row['name'], price=row['price'], category_id=row['category_id'])
def index(): cat = Category() brd = Brand() arr = Product() a = arr.getProducts() b = brd.getBrands() c = cat.getCategories() return render_template('home/index.html', arr=a, brr=b, crr=c)
def _create_cart(self): iphone_silver = Product('Iphone Silver', 'Silver', 999) iphone_black = Product('Iphone Black', 'Black', 899) cart = Cart(self._create_user()) cart.add(iphone_silver, 2) cart.add(iphone_black, 1) return cart
def setup(self): self.product_1 = Product( 'Omnitronic BD-1350 Turntable', 'Belt drive DJ turntable with adjustable speed control', '50', '80', '150') self.product_2 = Product('Pioneer DDJ-400', 'DJ Controller with FULL Rekordbox Software', '40', '150', '200')
def step_1(context): for row in context.table: try: Product.get(Product.name == row['name']) except Product.DoesNotExist: Product.create(name=row['name'], price=row['price'], description=row['description'])
def mutate(root, info, company_id, product_data): company = CompanyModel.find_by_id(company_id) if not company: raise Exception("Company doesn't exist!") product = ProductModel(**product_data, company=company_id) product.save() return NewProduct(product=product)
def brand(id): cat = Category() brand = Brand() pro = Product() a = pro.getProductsByBrand(id) b = brand.getBrands() c = cat.getCategories() d = brand.getBrandById(id) return render_template('home/brand.html', arr=a, crr=c, brr=b, title=d[1])
def test_add(self): product = Product() product.title = "title" product.descr = "desc" product.type = ProductType.MATERIAL product.updated_at = product.inserted_at = util.utcnow() self.db.add(product) self.db.commit() self.assertTrue(True)
def detail(id): cat = Category() brand = Brand() pro = Product() a = pro.getProductById(id) b = brand.getBrands() c = cat.getCategories() d = pro.getProductsRelation(id) return render_template('home/detail.html', u=a, crr=c, brr=b, arr=d)
def mutate(self, info, code, name, color, price, quantity): product = ProductModel(code=code, name=name, color=color, price=price, quantity=quantity) product.save() return CreateProduct(product=product)
def search(search): session['search'] = search all_product_type = Product.objects(product_type=search) if len(all_product_type) > 0: return render_template('search/search.html', all_product=all_product_type) else: all_product_place = Product.objects(place=search) return render_template('search/search.html', all_product=all_product_place)
def _get_product(category, json_product): '''Gets a cleaned product from a product in json format.''' product = { 'product_id': None, 'name': None, 'category_id': category.category_id, 'description': '', 'nutri_score': None, 'stores': '', 'url': None } product = Product(product) if 'product_name_fr' in json_product: if json_product['product_name_fr'] != '': product.name = json_product['product_name_fr'] elif 'product_name' in json_product: if json_product['product_name'] != '': product.name = json_product['product_name'] if 'generic_name_fr' in json_product: product.description = json_product['generic_name_fr'] elif 'generic_name' in json_product: product.description = json_product['generic_name'] if 'nutrition_grade_fr' in json_product: if json_product['nutrition_grade_fr'] in 'abcdeABCDE': product.nutri_score = json_product['nutrition_grade_fr'] if 'stores' in json_product: product.stores = json_product['stores'] if 'url' in json_product: url = json_product['url'].lower() if 'https://' in url and '.openfoodfacts.org/' in url: product.url = json_product['url'] if not (product.name and product.nutri_score and product.url): product = None return product
def set_bandwidth_job(): from models.order import Order from models.product import Product from models.exchange import Exchange from client.rpc_client import TelnetRpcClient from tornado.options import options import json from util import encrypt_util Log.info(" [x] Requesting") Log.info('set_bandwidth_job start at ', datetime.datetime.now()) need_do = '' Log.info("请异步发送") orders = Order.get_working_orders() for order in orders: product = Product.lookup(order['p_id']) exchange = Exchange.lookup(product['e_id']) need_do = need_do+json.dumps({'switch_name':exchange['ename'],"vlan":product['vlan'], \ "port_name":product['port'], "host":exchange['ipAddress'], \ "bandwidth":order['bandwidth']}) Order.finish_order(order['_id']) need_back='' orders = Order.get_back_orders() for order in orders: product = Product.lookup(order['p_id']) exchange = Exchange.lookup(product['e_id']) need_back = need_back+json.dumps({'switch_name':exchange['ename'],"vlan":product['vlan'], \ "port_name":product['port'], "host":exchange['ipAddress'], \ "bandwidth":order['bandwidth']}) Order.back_order(order['_id']) orders = {} flag = False if(need_do!=''): orders['need_do']=need_do flag = True if(need_back!=''): orders['need_back']=need_back flag = True if(flag!=True): rpc = TelnetRpcClient(options.service_ip) encoded = encrypt_util.encode(str(orders)) response = rpc.call("rpc_queue",encoded) Log.info('set_bandwidth_job end at ', datetime.datetime.now()) Log.info(response) # rpc = TelnetRpcClient('192.168.0.2') # orders = Order.get_working_orders() # for order in orders: # product = Product.lookup(order['p_id']) # exchange = Exchange.lookup(product['e_id']) # response = rpc.call(json.dumps({'switch_name':'TelnetManage3560', "vlan":product['vlan'], # "port_name":product['port'], "host":exchange['ipAddress'], "bandwidth":product['ctype']*order['percent']/100})) print 'set_bandwidth_job end at ', datetime.datetime.now()
def seller_tool_product_edit(seller,code): T = {"sellername":seller} ret = seller_tool_check_login(seller, T) if ret is not True: return ret if request.method == 'GET': seller_tool_check_new_order(T) key_name = "%s-%s" % (seller, code) product = Product.get_by_key_name("%s-%s" % (seller, code)) stock = ProductStock.get_by_key_name("%s-%s" % (seller, code)) T["product_title"] = product.title T["product_code"] = product.code T["product_price"] = product.price T["product_desc"] = product.desc T["product_stock"] = stock.quantity T["breadcrumbs"] = [{"url":url_for("seller_tool_index",seller=seller), "title":u"ツールトップ"}, {"url":url_for("seller_tool_products",seller=seller), "title":u"商品一覧"}, {"title":u"商品情報編集: %s" % product.code}] return render_template('seller_tool_product_edit.html', T=T) else: try: logging.error(seller) logging.error(code) product = Product.get_by_key_name("%s-%s" % (seller, code)) stock = ProductStock.get_by_key_name("%s-%s" % (seller, code)) product.title = request.form['product_title'] product.desc = request.form['product_desc'] product.price = float(request.form['product_price']) product.put() stock.quantity = int(request.form['product_stock']) stock.put() flash(u'保存しました', category='success') return redirect(url_for('seller_tool_products', seller=seller)) except: logging.error(sys.exc_info()) flash(u'失敗しました', category='warning') return render_template('seller_tool_product_edit.html', T=T)
def seller_index(seller): T = {'sellername':seller} helpers.template.get_user(T=T, path=request.path) products = [] pp = Product.all().fetch(limit=10) host = "http://localhost:5000/" for p in pp: product = {} product['seller'] = p.seller product['code'] = p.code product['title'] = p.title product['desc'] = p.desc product['price'] = u"%d 円" % p.price if p.image1: path = get_image_path(p.seller, p.code, 1, '120', '120', p.image1) product['imgurl'] = '%s%s' % (host, path) else: product['imgurl'] = 'http://placehold.it/120x120' products.append(product) T["products"] = products return render_template('seller_index.html', T=T)
def seller_product(seller, code): T = {"sellername":seller, "code":code} ret = seller_tool_check_login(seller, T) s = Seller.get_by_key_name('%s' % seller) if not 2: abort(404) p = Product.get_by_key_name('%s-%s' % (seller,code)) if not p: abort(404) T['seller'] = s T['product'] = p host = "http://localhost:5000/" if p.image1: T['imageurl1'] = "%s%s" % (host, get_image_path(seller,code,1,300,300,p.image1)) else: T['imageurl1'] = 'http://placehold.it/300x300' if p.image2: T['imageurl2'] = "%s%s" % (host, get_image_path(seller,code,2,120,120,p.image2)) if p.image3: T['imageurl3'] = "%s%s" % (host, get_image_path(seller,code,3,120,120,p.image3)) T['cart_url'] = url_for('cart_add', seller=seller, code=p.code) return render_template('seller_product.html', T=T)
def get(self): template_values = {} p_id = self.get_argument('p_id', '') product = Product.lookup(p_id) template_values['p_id'] = product['_id'] template_values['oname'] = product['oname'] template_values['cname'] = product['cname'] template_values['next'] = self.get_argument('next', '/') self.render_template('/site/bandwidth.html', **template_values)
def rebuilt_category_product(): Category_Product.objects().delete() categories = Category.objects() for category in categories: product_of_categorys = Product.objects(category=category.id) bulk = [] for product_of_category in product_of_categorys: bulk.append(Category_Product(product=product_of_category.id, category=category.id)) if len(bulk) > 0: Category_Product.objects.insert(bulk) children = Category.objects(ancestors__contains=category.id) for child in children: product_of_childs = Product.objects(category=child.id) bulk = [] for product_of_child in product_of_childs: bulk.append(Category_Product(product=product_of_child.id, category=category.id)) if len(bulk) > 0: Category_Product.objects.insert(bulk)
def seller_tool_product_new(seller): T = {"sellername":seller} ret = seller_tool_check_login(seller, T) if ret is not True: return ret if request.method == 'GET': seller_tool_check_new_order(T) T["breadcrumbs"] = [{"url":url_for("seller_tool_index",seller=seller), "title":u"ツールトップ"}, {"url":url_for("seller_tool_products",seller=seller), "title":u"商品一覧"}, {"title":u"新規商品情報追加"}] return render_template('seller_tool_product_new.html', T=T) else: try: new_product = Product( key_name = "%s-%s" % (seller, request.form['product_code']), seller = seller, code = request.form['product_code'], title = request.form['product_title'], price = float(request.form['product_price']), desc = request.form['product_desc'], ) new_product.put() new_product_stock = ProductStock( key_name = "%s-%s" % (seller, request.form['product_code']), seller = seller, code = request.form['product_code'], quantity = int(request.form['product_stock']), ) new_product_stock.put() flash(u'保存しました', category='success') return redirect(url_for('seller_tool_products', seller=seller)) except: logging.error(sys.exc_info()) flash(u'失敗しました', category='warning') return render_template('seller_tool_product_new.html', T=T)
def get(self, id): path = os.path.join(os.path.dirname(__file__), '../views/products/edit.html') template_values = { 'name': self.__class__.__name__, 'product': Product.get_by_id(int(id)) } self.response.out.write(template.render(path, template_values))
def get(self): path = os.path.join(os.path.dirname(__file__), '../views/products/index.html') template_values = { 'name': self.__class__.__name__, 'products': Product.all(), } self.response.out.write(template.render(path, template_values))
def test_capacity_propagation(db, parent_group, user): product1 = Product(name='product', parent=parent_group, capacity_max=3) tier1_1 = PriceTier(name='tier1', parent=product1) Price(price_tier=tier1_1, currency='GBP', price_int=10) db.session.add(tier1_1) tier1_2 = PriceTier(name='tier2', parent=product1) Price(price_tier=tier1_2, currency='GBP', price_int=20) db.session.add(tier1_2) product2 = Product(name='product2', parent=parent_group) tier3 = PriceTier(name='tier3', parent=product2) Price(price_tier=tier3, currency='GBP', price_int=30) db.session.commit() # Check all our items have the correct initial capacity assert parent_group.get_total_remaining_capacity() == 10 assert product1.get_total_remaining_capacity() == 3 assert tier1_1.get_total_remaining_capacity() == 3 assert tier1_2.get_total_remaining_capacity() == 3 assert product2.get_total_remaining_capacity() == 10 assert tier3.get_total_remaining_capacity() == 10 # Issue three instances to exhaust product1 create_purchases(tier1_1, 3, user) db.session.commit() # Now we shouldn't be able to issue any more tickets from this product with pytest.raises(CapacityException): create_purchases(tier1_1, 1, user) with pytest.raises(CapacityException): create_purchases(tier1_2, 1, user) db.session.commit() # All the capacity went from product1 assert tier1_1.get_total_remaining_capacity() == 0 assert tier1_2.get_total_remaining_capacity() == 0 assert product1.get_total_remaining_capacity() == 0 # produtill has capacity but is limited by the parent assert parent_group.get_total_remaining_capacity() == 7 assert product2.get_total_remaining_capacity() == 7 assert tier3.get_total_remaining_capacity() == 7 price1 = Price(price_tier=tier1_1, currency='GBP', price_int=5) price2 = Price(price_tier=tier1_2, currency='GBP', price_int=500) db.session.add(price1) db.session.add(price2) db.session.commit() assert price1 == product1.get_cheapest_price('GBP')
def get(self): user = self.get_username() products = Product.getProduct(user) #page info page = self.get_argument('page', 1) page = page if page >= 1 else 1 #get the document count param count = self.get_argument('count', 5) count = count if count >= 1 else 5 paginator = Paginator(products, page, count, len(products)) template_values = {} template_values['paginator'] = paginator self.render_template('/site/product.html', **template_values)
def seller_tool_products(seller): T = {"sellername":seller} ret = seller_tool_check_login(seller, T) if ret is not True: return ret seller_tool_check_new_order(T) products = [] pp = Product.gql('where seller=:seller', seller=seller).fetch(limit=10) for p in pp: product = {} product['seller'] = p.seller product['code'] = p.code product['title'] = p.title product['desc'] = p.desc host = "http://localhost:5000/" if p.image1: path = get_image_path(p.seller, p.code, 1, '120', '120', p.image1) product['imgurl'] = '%s%s' % (host, path) else: product['imgurl'] = 'http://placehold.it/120x120' products.append(product) T["products"] = products T["breadcrumbs"] = [{"url":url_for("seller_tool_index",seller=seller), "title":u"ツールトップ"}, {"title":u"商品一覧"}] return render_template('seller_tool_products.html', T=T)
def create_product_groups(): top_level_groups = [ # name, capacity, expires ('admissions', None, 2500), ('parking', None, None), ('campervan', None, None), ('merchandise', None, None), ] for name, expires, capacity in top_level_groups: if ProductGroup.get_by_name(name): continue pg = ProductGroup(name=name, type=name, capacity_max=capacity, expires=expires) db.session.add(pg) db.session.flush() allocations = [ # name, capacity ('vendors', 100), ('sponsors', 200), ('speakers', 100), ('general', 1800), ] admissions = ProductGroup.get_by_name('admissions') for name, capacity in allocations: if ProductGroup.get_by_name(name): continue ProductGroup(name=name, capacity_max=capacity, parent=admissions) view = ProductView.get_by_name('main') if not view: view = ProductView(name='main', type='tickets') db.session.add(view) db.session.flush() general = ProductGroup.get_by_name('general') products = [ # name, display name, transferable, badge, capacity, description, (std cap, gbp eur), (early cap, gbp, eur), (late cap, gbp, eur) ('full', 'Full Camp Ticket', True, True, None, 'Full ticket', ((1500, 115, 135), (250, 105, 125), (None, 125, 145)) ), ('full-s', 'Full Camp Ticket (Supporter)', True, True, None, 'Support this non-profit event by paying a bit more. All money will go towards making EMF more awesome.', ((None, 150, 180),) ), ('full-sg', 'Full Camp Ticket (Gold Supporter)', True, True, None, 'Support this non-profit event by paying a bit more. All money will go towards making EMF more awesome.', ((None, 200, 240),) ), ('u18', 'Under-18', True, False, 150, 'For visitors born after August 30th, 2000. All under-18s must be accompanied by an adult.', ((None, 55, 63),) ), ('u12', 'Under-12', True, False, 50, 'For children born after August 30th, 2006. All children must be accompanied by an adult.', ((None, 0, 0),) ), ] order = 0 for name, display_name, has_xfer, has_badge, capacity, description, prices in products: if Product.get_by_name('general', name): continue product = Product(name=name, display_name=display_name, capacity_max=capacity, description=description, parent=general, attributes={'is_transferable': has_xfer, 'has_badge': has_badge}) for index, (price_cap, gbp, eur) in enumerate(prices): if len(prices) == 1 or index == 0: tier_name = name + '-std' active = True elif index == 1: tier_name = name + '-early-bird' active = False elif index == 2: tier_name = name + '-late' active = False if PriceTier.get_by_name('general', 'name', tier_name): continue pt = PriceTier(name=tier_name, capacity_max=price_cap, personal_limit=10, parent=product, active=active) Price(currency='GBP', price_int=gbp * 100, price_tier=pt) Price(currency='EUR', price_int=eur * 100, price_tier=pt) ProductViewProduct(view, product, order) order += 1 db.session.flush() misc = [ # name, display_name, cap, personal_limit, gbp, eur, description ('parking', 'Parking Ticket', 1700, 4, 15, 21, "We're trying to keep cars to a minimum. Please take public transport or car-share if you can."), ('campervan', 'Caravan/\u200cCampervan Ticket', 60, 2, 30, 42, "If you bring a caravan, you won't need a separate parking ticket for the towing car."), ] for name, display_name, cap, personal_limit, gbp, eur, description in misc: if Product.get_by_name(name, name): continue group = ProductGroup.get_by_name(name) product = Product(name=name, display_name=display_name, description=description, parent=group) pt = PriceTier(name=name, personal_limit=personal_limit, parent=product) db.session.add(pt) db.session.add(Price(currency='GBP', price_int=gbp * 100, price_tier=pt)) db.session.add(Price(currency='EUR', price_int=eur * 100, price_tier=pt)) ProductViewProduct(view, product, order) order += 1 db.session.commit()
def seller_tool_product_image(seller,code): T = {"sellername":seller} ret = seller_tool_check_login(seller, T) if ret is not True: return ret if request.method == "GET": seller_tool_check_new_order(T) T["breadcrumbs"] = [{"url":url_for("seller_tool_index",seller=seller), "title":u"ツールトップ"}, {"title":u"商品一覧", "url":url_for("seller_tool_products",seller=seller)}, {"title":u"商品画像編集"}] key_name = "%s-%s" % (seller, code) product = Product.get_by_key_name("%s-%s" % (seller, code)) T["product_title"] = product.title for x in range(1,4): logging.error(product.__dict__["_image%d" % x]) if 0 < product.__dict__["_image%d" % x]: path = get_image_path(seller, code, x, '300', '300', product.__dict__["_image%d" % x]) host = "http://localhost:5000/" T["product_image%d" % x] = '%s%s' % (host, path) T["upload_url"] = blobstore.create_upload_url(request.base_url) return render_template('seller_tool_product_image.html', T=T) else: try: logging.error(request) imgnum = request.values['product_image_num'] filename = 'product_image%s' % imgnum headers = request.files[filename].headers['Content-Type'] msgtype, params = cgi.parse_header(headers) blob_key = blobstore.BlobKey(params['blob-key']) blob = blobstore.BlobInfo.get(blob_key) logging.error(blob.size) if 524288 < blob.size: raise Exception('size error') logging.error(blob.content_type) if blob.content_type == 'image/jpeg': imgtype = 'jpeg' imgtypenum = 1 elif blob.content_type == 'image/png': imgtype = 'png' imgtypenum = 2 elif blob.content_type == 'image/gif': imgtype = 'gif' imgtypenum = 3 else: raise Exception('invalid image type: %s' % blob.content_type) blob_reader = blobstore.BlobReader(blob_key, buffer_size=524288) imgbody = blob_reader.read() # thumbsize imgsizes = '60x60,120x120,300x300' # API POST url = 'http://localhost:8000/upload/product' query = 'group=%s&name=%s&type=%s&resizes=%s&num=%s' % (seller, code, imgtype, imgsizes, imgnum) req = urllib2.Request('%s?%s' % (url,query), data=imgbody, headers={'Content-type':'image/%s' % imgtype}) req.get_method= lambda: 'PUT' ret = urllib2.urlopen(req) ret.read(1024) product = Product.get_by_key_name("%s-%s" % (seller, code)) product.__dict__["_image%s" % imgnum] = imgtypenum product.put() # cleanup blob.delete() except: logging.error(sys.exc_info()) flash(u'失敗しました', category='warning') return redirect(request.base_url)
def main(): from models.product import Product from models.order import Order from models.package import Package # from views.paginator import Paginator from models.exchange import Exchange # # from datetime import datetime # start = datetime(2010, 4, 1) # end = datetime(2015, 5, 1) # for exchange in Exchange.get_status_exchanges(1): need_do = [] orders = Order.get_working_orders(1, exchange["_id"]) for order in orders: print order["custom_time"] product = Product.lookup(order["p_id"]) exchange = Exchange.get_exchange(order["e_id"]) package = Package.lookup(order["package_id"]) # need_do = need_do + json.dumps({'switch_name':exchange['ename'],'port':product['port'], 'bandwidth':order['bandwidth'], \ # 'port_name':product['port'], 'ipAddress':exchange['ipAddress'],'o_id':order['_id'] }) need_do.append( json.dumps( { "switch_name": exchange["ename"], "port": product["port"], "port_name": product["port"], "host": exchange["ipAddress"], "bandwidth": order["bandwidth"], } ) ) if len(need_do) > 0: cmd = json.dumps({"switch_name": exchange["ename"], "host": exchange["ipAddress"], "orders": need_do}) # print cmd print len(cmd) print cmd print "-----------" keys = json.loads(cmd) print keys["host"] print keys["orders"] ################################################## # if read(key_file): # keys = json.loads(encrypt_util.decode(body)) if 1 == 1: keys = json.loads(cmd) host = keys["host"] username, password = json.loads(read(key_file))[host] # here is the switch address values = keys["orders"] switch_name = keys["switch_name"] ################################################################### # switch_name = keys['switch_name'] # port_name = keys['port_name'] # bandwidth = keys['bandwidth'] # vlan = keys['vlan'] response = do_command(switch_name, host, username, password, values)
def detail(product_slug): product_id = product_slug.split(':')[0] product = Product.objects(id=str(product_id)).first() return render('sites/product/detail.html', product=product)
def test_delete_exist_product_should_be_done(self): product = ProductFactory.create() resp = self.post('/admin/product/' + str(product.id) + '/delete',{}) expect(len(Product.objects(id=product.id))).to_equal(0)
# -*- coding: utf-8 -*-
from models.order import Order from models.product import Product from models.exchange import Exchange from client.rpc_client import TelnetRpcClient import json,datetime from util import encrypt_util rpc = TelnetRpcClient(options.service_ip) need_do = '' orders = Order.get_working_orders() for order in orders: product = Product.lookup(order['p_id']) exchange = Exchange.lookup(product['e_id']) need_do = need_do+json.dumps({'switch_name':exchange['ename'],"vlan":product['port'], \ "port_name":product['port'], "host":exchange['ipAddress'], \ "bandwidth":order['bandwidth'],"flag":1}) Order.finish_order(order['_id']) need_back='' orders = Order.get_back_orders() for order in orders: product = Product.lookup(order['p_id']) exchange = Exchange.lookup(product['e_id']) need_back = need_back+json.dumps({'switch_name':exchange['ename'],"vlan":product['port'], \ "port_name":product['port'], "host":exchange['ipAddress'], \ "bandwidth":order['bandwidth'],"flag":0}) Order.back_order(order['_id'])
def products(self): if self.products_data: return self.products_data else: return Product.objects(id__in=self.data.keys())