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 -*-
# -*- 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())
# -*- coding: utf-8 -*-
