def build_menu():
menu = Menu()
menu.add_product(Product(1, 'Hamburger', 5.99))
menu.add_product(Product(2, 'Cheeseburger', 6.99))
menu.add_product(Product(4, 'Fries', 1.99))
menu.add_product(Product(3, 'Double Cheeseburger', 7.99))
return menu
def main():
all_links = []
queries = ['under armour white shirt',
'nike white shirt',
'adidas white shirt',
'calvin klein white shirt',
'levis white shirt',
'armani white shirt',
'tommy hilfiger white shirt']
for query in queries:
url = create_search_url(query)
links = scrape_search(url)
all_links += links
print(len(all_links))
products = []
for link in all_links:
print(link)
try:
products.append(Product(BASE + link).to_list())
except Exception:
p = Product(BASE + link, title=' ', color='White', price=np.random.uniform(10, 27), features=[' '],
hierarchy=[' '], brand=' ',
composition=[' '], img=' ', scrape=False).to_list()
products.append(p)
print(len(products))
with open('all_prods', 'w', newline='') as f:
wr = csv.writer(f, quoting=csv.QUOTE_ALL)
for prod in products:
wr.writerow(prod)
def __init__(self, qrcodescanner, display):
threading.Thread.__init__(self)
self.cart = []
self.qrcodescanner = qrcodescanner
self.display = display
self.allProducts = [
Product("milch", "Milch", 1.49),
Product("butter", "Butter", 0.89),
Product("apfel", "Apfel", 0.79),
Product("schokolade", "Schokolade", 1.29)
]
self.buttonQuit = Button(37, self.quit)
self.buttonOne = Button(15, self.numberOne)
self.buttonTwo = Button(13, self.numberTwo)
self.buttonThree = Button(11, self.numberThree)
self.buttonFour = Button(35, self.numberFour)
self.buttonFive = Button(33, self.numberFive)
self.buttonSix = Button(31, self.numberSix)
self.buttonSeven = Button(18, self.numberSeven)
self.buttonEight = Button(16, self.numberEight)
self.buttonNine = Button(12, self.numberNine)
self.buttonZero = Button(7, self.numberZero)
self.buttonAccept = Button(29, self.accept)
self.current_amount = ""
self.isRunning = True
def get_variants_as_products(product_id=None,
fieldset=[],
product_get_params={},
variant_get_params={}):
product_set = []
logger.info(
f'Downloading product{"s" if product_id is None else f" {product_id}"}'
)
products = get_product(product_id, **product_get_params)
for pd in products:
prod_id = pd['id']
if 'type' in pd and pd['type'] == 'variable':
logger.info(f"Downloading variants of product '{prod_id}'")
variants = get_product_variants(prod_id, **variant_get_params)
for pvd in variants:
product = Product()
product.fields = fieldset
for field in product.fields:
if not isinstance(field, VariantAttributeField):
if field.is_variant_field():
field.value_from_dict(pvd)
else:
field.value_from_dict(pd)
else:
field.value_from_dict(pvd, pd)
product_set.append(product)
else:
product = Product()
product.fields = fieldset
for field in product.fields:
field.value_from_dict(pd)
product_set.append(product)
return product_set
def playstationProducts(self,
url='https://www.nuuvem.com/lp/pt/playstation/'):
self.driver.get(url)
self.driver.implicitly_wait(3)
produtos = []
virtualCards = self.driver.find_elements_by_class_name('game-pass')
for virtualCard in virtualCards:
name = virtualCard.find_element_by_class_name(
'card-name').text + " Playstation"
price = virtualCard.find_element_by_class_name('price-gg').text
produto = Product(name=name, price=price,
typeProduct='Gift Card').getProduct()
produtos.append(produto)
pass
playstationPlus = self.driver.find_elements_by_class_name('psnplus')
for psnPlus in playstationPlus:
name = "Playstation Plus " + \
psnPlus.find_element_by_class_name('meses').text
price = psnPlus.find_element_by_class_name('buy-area').text.split(
'\n')[0]
produto = Product(name=name, price=price,
typeProduct='Gift Card').getProduct()
produtos.append(produto)
pass
return produtos
def test_cart():
c = Cart()
p = Product("widget", 123)
c.add_product(p, 100)
item2 = Product("gadget", 45)
c.add_product(item2, 1)
assert c.get_total() == 12345 # 100x123=12300 + 1x45=45
assert len(c.line_items) == 2
assert c.line_items[0].get_extended_price() == 12300
assert c.line_items[1].get_extended_price() == 45
content = str(c)
assert content.find("widget") != -1
assert content.find("gadget") != -1
assert content.find("123") != -1
assert content.find("12300") != -1
assert content.find("1") != -1
assert content.find("45") != -1
assert content.find("total") != -1
assert content.find("12345") != -1
display_cart(c)
c.remove(2)
c.update_quantity(1, 200) # line number and quantity
content = str(c)
assert content.find("24600") != -1 # 123x200=24600
display_cart(c)
def main():
print("### Testing Products ###")
p1 = Product("1238223", "Sword", 1899.99, 10)
print("Id: {}".format(p1.id))
print("Name: {}".format(p1.name))
print("Price: {}".format(p1.price))
print("Quantity: {}".format(p1.quantity))
p1.display()
print()
p2 = Product("838ab883", "Shield", 989.75, 6)
print("Id: {}".format(p2.id))
print("Name: {}".format(p2.name))
print("Price: {}".format(p2.price))
print("Quantity: {}".format(p2.quantity))
p2.display()
print("\n### Testing Orders ###")
# Now test Orders
order1 = Order()
order1.id = "1138"
order1.add_product(p1)
order1.add_product(p2)
order1.display_receipt()
print("\n### Testing Customers ###")
# Now test customers
c = Customer()
c.id = "aa32"
c.name = "Gandalf"
c.add_order(order1)
c.display_summary()
print()
c.display_receipts()
# Add another product and order and display again
p3 = Product("2387127", "The Ring", 1000000, 1)
p4 = Product("1828191", "Wizard Staff", 199.99, 3)
order2 = Order()
order2.id = "1277182"
order2.add_product(p3)
order2.add_product(p4)
c.add_order(order2)
print()
c.display_summary()
print()
c.display_receipts()
def createAllProducts():
global Products
Products.append(Product(1, "Computador Dell", 4200.00))
Products.append(Product(2, "Placa de Video RTX2080Ti", 7800.00))
Products.append(Product(3, "Mouse Logitech", 110.00))
Products.append(Product(4, "Teclado Razer", 800.00))
res = {'status': 'ok'}
return jsonify(res)
def test_adding_products_to_catalogue(self):
self.test_catalogue = Catalogue(self.test_products)
self.test_catalogue.add_products([
Product('Additional Product 1', 1.00),
Product('Additional Product 2', 1.00)
])
self.assertEqual(len(self.test_catalogue.products),
len(self.test_products) + 2)
def test_add_list(self):
test_list_server = ListServer()
p1 = Product('abc44', 222.3)
p2 = Product('ab33', 17.23)
test_list_server.catalog.append(p1)
test_list_server.catalog.append(p2)
self.assertEqual(test_list_server.catalog[0], p1)
self.assertEqual(test_list_server.catalog[1], p2)
def test_get_entries(self):
test_list_server = ListServer()
p1 = Product('abc44', 222.3)
p2 = Product('ab33', 17.23)
test_list_server.catalog.append(p1)
test_list_server.catalog.append(p2)
entries = test_list_server.get_entries(3)
self.assertEqual(Counter([p1]), Counter(entries))
def test_undo(self):
self.repository.add(Product("1", "Paine", "1"))
self.repository.add(Product("2", "Paine2", "23"))
self.repository.add(Product("21", "Paine3", "232"))
self.repository.delete("1")
self.assertEquals(len(self.repository.get_all()), 1)
self.repository.undo()
self.assertEquals(len(self.repository.get_all()), 3)
class Execution:
item1 = Product(1, "Milk", 30)
item2 = Product(2, "Bread", 40)
item3 = Product(3, "Butter", 50)
item4 = Product(4, "Egg", 50)
def show_menu(self):
print(self.item1.p_id, self.item1.name, self.item1.price)
print(self.item2.p_id, self.item2.name, self.item2.price)
print(self.item3.p_id, self.item3.name, self.item3.price)
print(self.item4.p_id, self.item4.name, self.item4.price)
list1 = []
def cart(self):
p_id = int(input("enter id"))
if p_id == 1:
self.list1.append(self.item1.name)
self.list1.append(self.item1.price)
print(self.item1.name, self.item1.price)
if p_id == 2:
self.list1.append(self.item2.name)
self.list1.append(self.item2.price)
print(self.item2.name, self.item2.price)
if p_id == 3:
self.list1.append(self.item3.name)
self.list1.append(self.item3.price)
print(self.item3.name, self.item3.price)
if p_id == 4:
self.list1.append(self.item4.name)
self.list1.append(self.item4.price)
print(self.item4.name, self.item4.price)
choice = input("do u want to buy more items")
if choice == 'y':
self.cart()
elif choice == 'n':
pass
def show_cart(self):
print(self.list1)
price = self.list1[1:len(self.list1):2]
self.total_price = sum(price)
print("total amount is", self.total_price)
def billing(self):
print("billed amount", self.total_price)
paid_amount = int(input("enter amount u want to pay"))
if paid_amount == self.total_price:
print("THANKS FOR SHOPPING WITH US")
elif paid_amount < self.total_price:
due_amount = self.total_price - paid_amount
print("YOUR PENDING AMOUNT IS:", due_amount)
self.total_price = due_amount
#print("total amount to be paid is:",self.total_price)
self.billing()
elif paid_amount > self.total_price:
refund_amount = paid_amount - self.total_price
print("AMOUNT REFUNDABLE IS:", refund_amount)
def best_price(self):
if self.valid_inputs():
product_a = Product("Product A", int(self.quantity_a.text),
float(self.price_a.text))
product_b = Product("Product B", int(self.quantity_b.text),
float(self.price_b.text))
compare = Compare([product_a, product_b])
best_product = compare.best()
self.highlight_best_product(best_product)
def test_client_list_server(self):
list_server = ListServer()
p1 = Product('abc44', 222.3)
p2 = Product('ab33', 17.23)
p3 = Product('abc33', 444.4)
list_server.add(p1)
list_server.add(p2)
list_server.add(p3)
test_client = Client(list_server)
self.assertEqual(17.23, test_client.get_total_price(2))
def test_add_two_products(self):
cart = ShoppingCart()
product1 = Product('shoes', 'S', 'blue')
product2 = Product('tshirt', 'M', 'black')
cart.add_product(product1)
cart.add_product(product2)
expected_cart_value = {'SHOES-S-BLUE':{'quantity': 1}, 'TSHIRT-M-BLACK':{'quantity':1}}
self.assertDictEqual(expected_cart_value, cart.products)
def test_client_map_server(self):
map_server = MapServer()
p1 = Product('abc44', 222.3)
p2 = Product('ab33', 17.23)
p3 = Product('abc33', 444.4)
map_server.add(p1)
map_server.add(p2)
map_server.add(p3)
test_client = Client(map_server)
self.assertEqual(666.7, test_client.get_total_price(3))
def setUpClass(cls):
cls.nick = Customer("Nick", "Chemsak", "111 Street Rd", "suite 3",
"Nashville", "TN", "37075", "123-123-0987",
"*****@*****.**")
cls.order = Order("Nick", "Basketball", True, 1)
cls.product = Product("Basketball", 5.00, 1)
cls.zelda = Product('Legend of Zelda', 49.99, 100)
cls.payment_option = PaymentOption("Nick", "Chemsak",
"1234567891234567", "2017-05-05",
"123", "VISA")
cls.order2 = Order("Nick", "", True, 1)
def get_product(ctx: dict) -> Product:
idx = int(ctx["parameters"]["current-index"])
products = ctx["parameters"]["products"]
if idx < len(products):
prd_dict = products[idx]
return Product(prd_dict["article-number"], prd_dict["name"],
prd_dict["price"], prd_dict["image"], prd_dict["url"])
else:
return Product(-1, "", "", "", "")
def construct_product_items(productItemsArrayList):
productItemsArrayList.append(Product(501, "Chocolate", 4, 1))
productItemsArrayList.append(Product(502, "PopCorn", 1, 3))
productItemsArrayList.append(Product(503, "Green Beans", 2, 2))
productItemsArrayList.append(Product(504, "FaceWash", 1, 5))
productItemsArrayList.append(Product(505, "Bread", 2, 4))
productItemsArrayList.append(Product(506, "Soup, 2 Cans", 2, 6))
productItemsArrayList.append(Product(508, "Grapes", 1, 3))
productItemsArrayList.append(Product(507, "Body Wash", 3, 7))
productItemsArrayList.append(Product(509, "Advil", 1, 8))
productItemsArrayList.append(Product(510, "Milk", 2, 2))
def test_product(app):
app.implicitly_wait(5)
app.get("http://localhost/litecart/en/")
item = app.find_element_by_xpath('//li[contains(@class,"product")]')
title = item.find_element_by_xpath(".//div[@class='name']").text
try:
regular_price = item.find_element_by_css_selector('.price').text
product = Product(title=title, regular_price=regular_price)
color_regular = app.find_element_by_css_selector(
'.price').value_of_css_property("color")[5:-4].split(",")
assert check_grey_color(color_regular)
sale = False
except:
regular_price = item.find_element_by_css_selector(
'.regular-price').text
deal_price = item.find_element_by_css_selector('.campaign-price').text
product = Product(title=title,
regular_price=regular_price,
deal_price=deal_price)
color_regular = item.find_element_by_css_selector(
'.regular-price').value_of_css_property("color")[5:-4].split(",")
color_deal = item.find_element_by_css_selector(
'.campaign-price').value_of_css_property("color")[5:-4].split(",")
assert check_red_color(color_deal)
assert check_grey_color(color_regular)
assert item.find_element_by_css_selector(
'.regular-price').value_of_css_property(
"font-size") < item.find_element_by_css_selector(
'.campaign-price').value_of_css_property("font-size")
assert (item.find_element_by_css_selector(
'.regular-price').value_of_css_property("text-decoration")
).split()[0] == 'line-through'
sale = True
item.click()
assert product.title == app.find_element_by_xpath(
'//h1[@class="title"]').text
if sale:
regular_price_on_page = app.find_element_by_css_selector(
'.regular-price')
assert product.regular_price == regular_price_on_page.text
deal_price_on_page = app.find_element_by_css_selector(
'.campaign-price')
assert product.deal_price == deal_price_on_page.text
assert regular_price_on_page.value_of_css_property(
"font-size") < deal_price_on_page.value_of_css_property(
"font-size")
assert (regular_price_on_page.value_of_css_property("text-decoration")
).split()[0] == 'line-through'
else:
assert product.regular_price == app.find_element_by_xpath(
'//span[@itemprop="price"]').text
def product_search(q):
# get matches
productsFound = Product().product_search(graph_db, q + ".*")
# create array
products = Product().product_results_as_list(productsFound)
# set response type
response.content_type = 'application/json'
# return as json
return dumps(products)
def xboxProducts(self, url='https://www.nuuvem.com/lp/pt/xbox/'):
self.driver.get(url)
self.driver.implicitly_wait(3)
produtos = []
giftsCard = self.driver.find_element_by_id('giftcard')
giftsCards = giftsCard.find_elements_by_class_name('greencard')
for card in giftsCards:
name = 'Cartão Presente XBOX'
price = card.find_element_by_class_name(
'card-buy-area').text.split('\n')[0]
produto = Product(name=name, price=price,
typeProduct='Gift Card').getProduct()
produtos.append(produto)
pass
gamePass = self.driver.find_element_by_id('gamepass')
gamePasses = gamePass.find_elements_by_class_name('game-pass')
for gamePass in gamePasses:
name = "XBOX GAME PASS" + \
gamePass.find_element_by_class_name('card-name').text
price = gamePass.find_element_by_class_name(
'card-buy-area').text.split('\n')[0]
produto = Product(name=name, price=price,
typeProduct='Gift Card').getProduct()
produtos.append(produto)
pass
liveGold = self.driver.find_element_by_id('livegold')
plansLiveGold = liveGold.find_elements_by_class_name('greencard')
for gold in plansLiveGold:
name = gold.find_element_by_tag_name('div').text
price = gold.find_element_by_class_name(
'card-buy-area').text.split('\n')[0]
produto = Product(name=name, price=price,
typeProduct='Gift Card').getProduct()
produtos.append(produto)
pass
return produtos
def setUp(self):
catalog = Catalog()
catalog.addShippingRule("U50", 50, 4.95)
catalog.addShippingRule("U90", 90, 2.95)
catalog.addShippingRule("U90", 90, 0)
catalog.addOffer(BOGO50Offer("BOGO50", "R01"))
catalog.addProduct(Product("R01", "Red Widget", 32.95))
catalog.addProduct(Product("G01", "Green Widget", 24.95))
catalog.addProduct(Product("B01", "Blue Widget", 7.95))
self.basket = Basket(catalog)
def get_available_products():
milk = Product("Milk", "2 Liters", 2, 123)
bread = Product("Bread", "1 loaf", 8, 456)
apple = Product("Apple", "1", 7, 654)
suger = Product("Suger", "1 Kg", 12, 236)
tomatoes = Product("Tomatoes", "0.5Kg", 6, 987)
available_products.append(milk)
available_products.append(bread)
available_products.append(apple)
available_products.append(suger)
available_products.append(tomatoes)
return available_products
def consumption():
products = Product().get_products(graph_db, 0)
next = True
nextPageUrl = "/consumption/10"
productTrail = Product().get_product_trail(
graph_db, request.cookies[graphstoryUserAuthKey])
return template('public/templates/graphs/consumption/index.html',
layout=applayout,
products=products,
productTrail=productTrail,
next=next,
nextPageUrl=nextPageUrl,
title="Consumption")
def index():
# was tag supplied, then get product matches based on specific tag
if request.query.get('tag'):
usersWithMatchingTags = Product(
).get_products_has_specific_tag_and_user_uses_specific_tag(
graph_db, request.query.get('tag'))
# otherwise return all product matches as long as at least one tag matches against the users
else:
usersWithMatchingTags = Product(
).get_products_has_a_tag_and_user_uses_a_matching_tag(graph_db)
return template('public/templates/graphs/consumption/console.html',
layout=applayout,
usersWithMatchingTags=usersWithMatchingTags,
title="Consumption Console")
def __init__(self, path):
self.path = path
input_data = self._get_input(path)
self.deadline = input_data["deadline"]
self.rows = input_data["rows"]
self.columns = input_data["columns"]
self.num_products = input_data["num_products"]
self.num_drones = input_data["num_drones"]
self.num_orders = input_data["num_orders"]
self.num_warehouses = input_data["num_warehouses"]
self.max_load = input_data["max_load"]
self.products = [
Product(weight) for weight in input_data["product_weights"]
]
self.warehouses = [
Warehouse(wh["row"], wh["column"], wh["stock"])
for wh in input_data["warehouses"]
]
self.drones = [
Drone(i, self.warehouses, input_data["max_load"])
for i in range(input_data["num_drones"])
]
self.orders = [
Order(i, order["row"], order["column"], order["product_ids"])
for i, order in enumerate(input_data["orders"])
]
def productify(self, prods):
parsingList = self.getCellList()
for cell in parsingList:
product = Product(cell, 'acc')
prods.append(product)
def product_id_not_cached(id, image):
product = Product(id, image)
if product.image_status(image):
product.inset_object_in_cache()
return
