def run_homework():
# first_order = generate_order()
# print(first_order)
# print(f"Liczba pozycji w zamówieniu: {len(first_order)}")
# second_order = generate_order()
# print(second_order)
# print(f"Liczba pozycji w zamówieniu: {len(second_order)}")
# gala = Apple(species_name="Gala", size="S", price=3.2)
# gloster = Apple(species_name="Gloster", size="M", price=4)
# bryza = Potato(species_name="Bryza", size="L", price=2.3)
# etiuda = Potato(species_name="Etiuda", size="M", price=2.9)
# print(gala)
# print(gloster)
# print(bryza)
# print(etiuda)
cookie = Product(name="Ciastko", category_name="Jedzenie", unit_price=4)
juice = Product("Sok", "Napoje", 6)
first_order_elements = [
OrderElement(product=cookie, quantity=3),
OrderElement(product=juice, quantity=4)
]
second_order_elements = [
OrderElement(product=juice, quantity=4),
OrderElement(product=cookie, quantity=3)
]
first_order_eq = Order("Mariusz", "Baran", first_order_elements)
second_order_eq = Order("Mariusz", "Baran", second_order_elements)
if first_order_eq == second_order_eq:
print("Zamówienia są takie same")
else:
print("Zamówienia są różne")
def run_homework():
product_one = Product(name="Cookies", category_name="Food", unit_price=3.5)
product_two = Product(name="Cheese", category_name="Food", unit_price=3.5)
product_three = Product(name="Cookies",
category_name="Food",
unit_price=3.5)
print(f"Products 1 and 2 are equal? {product_one == product_two}")
print(f"Products 1 and 3 are equal? {product_one == product_three}")
print(f"Products 2 and 3 are equal? {product_two == product_three}")
order_element_1 = OrderElement(product_one, 3)
order_element_2 = OrderElement(product_one, 3)
order_element_3 = OrderElement(product_two, 4)
print(
f"Order elements 1 and 2 are equal? {order_element_1 == order_element_2}"
)
print(
f"Order elements 1 and 3 are equal? {order_element_1 == order_element_3}"
)
print(
f"Order elements 2 and 3 are equal? {order_element_2 == order_element_3}"
)
order_1 = Order(client_first_name="Maciej",
client_last_name="Sobieszuk",
order_elements=[order_element_1, order_element_2])
order_2 = Order(client_first_name="Maciej",
client_last_name="Sobieszuk",
order_elements=[order_element_2, order_element_1])
order_3 = Order(client_first_name="Maciej",
client_last_name="Xyz",
order_elements=[order_element_1, order_element_2])
print(f"Orders 1 and 2 are equal? {order_1 == order_2}")
print(f"Orders 1 and 3 are equal? {order_1 == order_3}")
print(f"Orders 2 and 3 are equal? {order_2 == order_3}")
def run_homework():
cookie = Product(name="Ciastko", category_name="Jedzenie", unit_price=4)
# other_cookie = Product(name="Inne ciastko", category_name="Jedzenie", unit_price=4)
juice = Product(name="Sok", category_name="Napoje", unit_price=3)
first_order_elements = [
OrderElement(product=cookie, quantity=3),
# OrderElement(product=other_cookie, quantity=3),
OrderElement(product=juice, quantity=4),
]
# first_order_elements.append(OrderElement(product=juice, quantity=4))
# first_order_elements[0].quantity = 10
second_order_elements = [
OrderElement(product=juice, quantity=4),
OrderElement(product=cookie, quantity=3),
]
first_order = Order(client_first_name="Kuba",
client_last_name="Kowalski",
order_elements=first_order_elements)
second_order = Order(client_first_name="Kuba",
client_last_name="Kowalski",
order_elements=second_order_elements)
# second_order.client_last_name = "Lewandowski"
if first_order == second_order:
print("Te zamówienia są takie same!")
else:
print("Te zamówienia są różne!")
def add_product_to_order(self, product, quantity):
if len(self._order_elements) == Order.MAX_ORDER_ELEMENTS:
print(f"MAX_ORDER_ELEMENTS reached! It is equal to {Order.MAX_ORDER_ELEMENTS}.")
else:
new_element = OrderElement(product, quantity)
self._order_elements.append(new_element)
def load_orders(client_first_name, client_last_name, file_name="orders.json"):
try:
with open(file_name, "r") as orders_file:
orders_by_clients_data = json.load(orders_file).get("orders", {})
except FileNotFoundError:
orders_by_clients_data = {}
client_id = f"{client_first_name}-{client_last_name}"
if client_id not in orders_by_clients_data:
return []
orders = orders_by_clients_data[client_id]
return [
Order(
client_first_name=order["client_first_name"],
client_last_name=order["client_last_name"],
order_elements=[
OrderElement(
quantity=order_element["quantity"],
product=Product(
name=order_element["product"]["name"],
category=ProductCategory[order_element["product"]
["category"]],
unit_price=order_element["product"]["unit_price"],
identifier=order_element["product"]["identifier"],
)) for order_element in order["order_elements"]
],
) for order in orders
]
def add_product_to_order(self, product, quantity):
if len(self._order_elements) >= Order.MAX_ELEMENTS:
raise ElementsInOrderLimitError(allowed_limit=Order.MAX_ELEMENTS)
Store.reserve_product(product, quantity)
new_element = OrderElement(product, quantity)
self._order_elements.append(new_element)
def add_product_to_order(self, product, quantity):
if len(self._order_elements) < Order.MAX_ELEMENTS:
new_element = OrderElement(product, quantity)
self._order_elements.append(new_element)
self.total_price = self._calculate_total_price()
else:
print("Osiągnięto limit pozycji w zamówieniu")
def generate_order(products_number):
order_elements = []
for product_number in range(products_number):
product_name = f"Produkt-{product_number}"
category_name = "Inne"
unit_price = random.randint(1, 30)
product = Product(product_name, category_name, unit_price)
quantity = random.randint(1, 10)
order_elements.append(OrderElement(product, quantity))
return order_elements
def add_product_to_order(self, product, quantity):
if len(self._order_elements) >= Order.MAX_ORDER_ELEMENTS:
raise OrderElementsLimitError(
places_limit=Order.MAX_ORDER_ELEMENTS,
message=
f"MAX_ORDER_ELEMENTS reached! It is equal to {Order.MAX_ORDER_ELEMENTS}.",
)
else:
new_element = OrderElement(product, quantity)
self._order_elements.append(new_element)
def generate_order_elements(products_to_generate=None):
if products_to_generate is None:
products_to_generate = random.randint(1, Order.MAX_ELEMENTS)
order_elements = []
for products_number in range(products_to_generate):
product_name = f"Produkt - {products_number}"
product = generate_product(product_name)
quantity = generate_quantity()
order_elements.append(OrderElement(product, quantity))
return order_elements
def generate_order(number_of_products=None):
order_elements = []
if number_of_products is None:
number_of_products = Order.MAX_ORDER_ELEMENTS
for product_number in range(number_of_products):
product_name = f"Produkt-{product_number}"
category_name = "Inne"
unit_price = random.randint(MIN_UNIT_PRICE, MAX_UNIT_PRICE)
product = Product(product_name, category_name, unit_price)
quantity = random.randint(MIN_PRODUCT_QUANTITY, MAX_PRODUCT_QUANTITY)
order_elements.append(OrderElement(product, quantity))
return order_elements
def generate_order_elements(number_of_products=None):
if number_of_products is None:
number_of_products = random.randint(1, Order.MAX_ELEMENTS)
order_elements = []
for product_number in range(number_of_products):
name = f"Produkt {product_number}"
category_name = "Inne"
unit_price = random.randint(MIN_UNIT_PRICE, MAX_UNIT_PRICE)
produkt = Product(name, category_name, unit_price)
quantity = random.randint(MIN_QUANTITY, MAX_QUANTITY)
order_elements.append(OrderElement(produkt, quantity))
return order_elements
def generate_order(cls, number_of_products):
order_elements = []
for product_number in range(number_of_products):
product_name = f"Produkt-{product_number}"
category_name = "Inne"
unit_price = random.randint(1, 30)
product = Product(product_name, category_name, unit_price)
quantity = random.randint(1, 10)
order_elements.append(OrderElement(product, quantity))
order = Order(client_first_name="Mikołaj", client_last_name="Lewandowski", order_elements=order_elements)
return order
def run_homework():
cookie = Product(name="Ciastko", category_name="Jedzenie", unit_price=4)
tomato = Product(name="Pomidor",
category_name="Owoce i warzywa",
unit_price=3)
something = Product(name="Coś",
category_name="Nieznana kategoria",
unit_price=50)
ten_cookies = OrderElement(cookie, quantity=10)
five_tomatoes = OrderElement(tomato, quantity=5)
single_something = OrderElement(something, quantity=1)
cookies_tax = TaxCalculator.tax_for_order_element(ten_cookies)
tomatoes_tax = TaxCalculator.tax_for_order_element(five_tomatoes)
something_tax = TaxCalculator.tax_for_order_element(single_something)
print(f"Cena ciastek: {ten_cookies.calculate_price()} + {cookies_tax:.2f}")
print(
f"Cena pomidorów: {five_tomatoes.calculate_price()} + {tomatoes_tax:.2f}"
)
print(
f"Cena czegoś: {single_something.calculate_price()} + {something_tax:.2f}"
)
def generate_order_elements(products_to_generate=None):
if products_to_generate is None:
products_to_generate = random.randint(1, Order.MAX_ELEMENTS)
order_elements = []
for product_number in range(products_to_generate):
product_name = f"Produkt-{product_number}"
category = ProductCategory.FOOD
unit_price = random.randint(MIN_UNIT_PRICE, MAX_UNIT_PRICE)
identifier = random.randint(MIN_IDENTIFIER, MAX_IDENTIFIER)
product = Product(product_name, category, unit_price, identifier)
quantity = random.randint(MIN_QUANTITY, MAX_QUANTITY)
order_elements.append(OrderElement(product, quantity))
return order_elements
def generate_order_elements(number_of_products=None):
order_elements = []
if number_of_products is None:
number_of_products = random.randint(1, Order.MAX_ORDER_ELEMENTS)
elif number_of_products > Order.MAX_ORDER_ELEMENTS:
number_of_products = Order.MAX_ORDER_ELEMENTS
for product_number in range(number_of_products):
product_name = f"Produkt-{product_number}"
category = ProductCategory.OTHER
unit_price = random.randint(MIN_UNIT_PRICE, MAX_UNIT_PRICE)
identifier = random.randint(MIN_IDENTIFIER, MAX_IDENTIFIER)
product = Product(product_name, category, unit_price, identifier)
quantity = random.randint(MIN_PRODUCT_QUANTITY, MAX_PRODUCT_QUANTITY)
order_elements.append(OrderElement(product, quantity))
return order_elements
def add_product_to_order(self, product, quantity):
if len(self._order_elements) >= Order.MAX_ELEMENTS:
raise Exception("Osiągnięto limit pozycji w zamówieniu")
new_element = OrderElement(product, quantity)
self._order_elements.append(new_element)
def add_product_to_order(self, product, quantity):
new_element = OrderElement(product, quantity)
self._order_elements.append(new_element)
self.total_price = self._calculate_total_price()
def add_product_to_order(self, product, quantity):
if len(self._order_elements) < self.MAX_ELEMENTS:
new_element = OrderElement(product, quantity)
self._order_elements.append(new_element)
else:
print("Osiągnięto limit produktów")