Added Exam Preparation/Python OOP Exam - 10 December 2022

Author: MitkoVtori

OOP/C.Exam Preparation/Python OOP Exam - 10 December 2022/Structure and Functionality/project.zip

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+
+
+class Booth(ABC):
+
+    def __init__(self, booth_number: int, capacity: int):
+        self.booth_number = booth_number
+        self.capacity = capacity
+        self.delicacy_orders = [] # objects
+        self.price_for_reservation = 0
+        self.is_reserved = False
+
+    @property
+    def capacity(self):
+        return self.__capacity
+
+    @capacity.setter
+    def capacity(self, value):
+        if value < 0:
+            raise ValueError("Capacity cannot be a negative number!")
+
+        self.__capacity = value
+
+    @abstractmethod
+    def reserve(self, number_of_people: int):
+        pass
+

OOP/C.Exam Preparation/Python OOP Exam - 10 December 2022/Structure and Functionality/project/booths/__init__.py

@@ -0,0 +1,11 @@
+from project.booths.booth import Booth
+
+
+class OpenBooth(Booth):
+    price_per_person = 2.50
+
+    def reserve(self, number_of_people: int):
+        price = OpenBooth.price_per_person * number_of_people
+        self.price_for_reservation = price
+        self.is_reserved = True
+

OOP/C.Exam Preparation/Python OOP Exam - 10 December 2022/Structure and Functionality/project/booths/booth.py

@@ -0,0 +1,11 @@
+from project.booths.booth import Booth
+
+
+class PrivateBooth(Booth):
+    price_per_person = 3.50
+
+    def reserve(self, number_of_people: int):
+        price = PrivateBooth.price_per_person * number_of_people
+        self.price_for_reservation = price
+        self.is_reserved = True
+

OOP/C.Exam Preparation/Python OOP Exam - 10 December 2022/Structure and Functionality/project/booths/open_booth.py

@@ -0,0 +1,82 @@
+from project.delicacies.gingerbread import Gingerbread
+from project.delicacies.stolen import Stolen
+from project.booths.open_booth import OpenBooth
+from project.booths.private_booth import PrivateBooth
+
+
+class ChristmasPastryShopApp:
+
+    def __init__(self):
+        self.booths = [] # objects
+        self.delicacies = [] # objects
+        self.income = 0.0
+
+    def add_delicacy(self, type_delicacy: str, name: str, price: float):
+        if name in [x.name for x in self.delicacies]:
+            raise Exception(f"{name} already exists!")
+
+        if type_delicacy not in ["Gingerbread", "Stolen"]:
+            raise Exception(f"{type_delicacy} is not on our delicacy menu!")
+
+        if type_delicacy == "Gingerbread":
+            delicacy = Gingerbread(name, price)
+        else:
+            delicacy = Stolen(name, price)
+
+        self.delicacies.append(delicacy)
+
+        return f"Added delicacy {name} - {type_delicacy} to the pastry shop."
+
+    def add_booth(self, type_booth: str, booth_number: int, capacity: int):
+        if booth_number in [x.booth_number for x in self.booths]:
+            raise Exception(f"Booth number {booth_number} already exists!")
+
+        if type_booth not in ["Open Booth", "Private Booth"]:
+            raise Exception(f"{type_booth} is not a valid booth!")
+
+        if type_booth == "Open Booth":
+            booth = OpenBooth(booth_number, capacity)
+        else:
+            booth = PrivateBooth(booth_number, capacity)
+
+        self.booths.append(booth)
+
+        return f"Added booth number {booth_number} in the pastry shop."
+
+    def reserve_booth(self, number_of_people: int):
+        booth = [x for x in self.booths if x.capacity >= number_of_people and not x.is_reserved]
+        if not booth:
+            raise Exception(f"No available booth for {number_of_people} people!")
+
+        booth = booth[0]
+        booth.reserve(number_of_people)
+
+        return f"Booth {booth.booth_number} has been reserved for {number_of_people} people."
+
+    def order_delicacy(self, booth_number: int, delicacy_name: str):
+        if booth_number not in [x.booth_number for x in self.booths]:
+            raise Exception(f"Could not find booth {booth_number}!")
+
+        if delicacy_name not in [x.name for x in self.delicacies]:
+            raise Exception(f"No {delicacy_name} in the pastry shop!")
+
+        booth = [x for x in self.booths if x.booth_number == booth_number][0]
+        delicacy = [x for x in self.delicacies if x.name == delicacy_name][0]
+        booth.delicacy_orders.append(delicacy)
+
+        return f"Booth {booth_number} ordered {delicacy_name}."
+
+    def leave_booth(self, booth_number: int):
+        booth = [x for x in self.booths if x.booth_number == booth_number][0]
+        bill = booth.price_for_reservation + sum([x.price for x in booth.delicacy_orders])
+        self.income += bill
+
+        booth.delicacy_orders = []
+        booth.is_reserved = False
+        booth.price_for_reservation = 0
+
+        return f"Booth {booth_number}:\nBill: {bill:.2f}lv."
+
+    def get_income(self):
+        return f"Income: {self.income:.2f}lv."
+

OOP/C.Exam Preparation/Python OOP Exam - 10 December 2022/Structure and Functionality/project/booths/private_booth.py

@@ -0,0 +1,35 @@
+from abc import ABC, abstractmethod
+
+
+class Delicacy(ABC):
+
+    def __init__(self, name: str, portion: int, price: float):
+        self.name = name
+        self.portion = portion
+        self.price = price
+
+    @property
+    def name(self):
+        return self.__name
+
+    @name.setter
+    def name(self, value):
+        if value.rstrip() == "":
+            raise ValueError("Name cannot be null or whitespace!")
+
+        self.__name = value
+
+    @property
+    def price(self):
+        return self.__price
+
+    @price.setter
+    def price(self, value):
+        if value <= 0:
+            raise ValueError("Price cannot be less or equal to zero!")
+
+        self.__price = value
+
+    @abstractmethod
+    def details(self):
+        pass

OOP/C.Exam Preparation/Python OOP Exam - 10 December 2022/Structure and Functionality/project/christmas_pastry_shop_app.py

@@ -0,0 +1,12 @@
+from project.delicacies.delicacy import Delicacy
+
+
+class Gingerbread(Delicacy):
+    portion = 200
+
+    def __init__(self, name: str, price: float):
+        super().__init__(name, Gingerbread.portion, price)
+
+    def details(self):
+        return f"Gingerbread {self.name}: 200g - {self.price:.2f}lv."
+

OOP/C.Exam Preparation/Python OOP Exam - 10 December 2022/Structure and Functionality/project/delicacies/__init__.py

@@ -0,0 +1,12 @@
+from project.delicacies.delicacy import Delicacy
+
+
+class Stolen(Delicacy):
+    portion = 250
+
+    def __init__(self, name: str, price: float):
+        super().__init__(name, Stolen.portion, price)
+
+    def details(self):
+        return f"Stolen {self.name}: 250g - {self.price:.2f}lv."
+

OOP/C.Exam Preparation/Python OOP Exam - 10 December 2022/Structure and Functionality/project/delicacies/__pycache__/__init__.cpython-39.pyc

@@ -0,0 +1,86 @@
+from unittest import TestCase, main
+from project.toy_store import ToyStore
+
+
+class TestToyStore(TestCase):
+
+    def setUp(self) -> None:
+        self.toy_store = ToyStore()
+
+    def test_successful_initialization(self):
+        shelf = {
+            "A": None,
+            "B": None,
+            "C": None,
+            "D": None,
+            "E": None,
+            "F": None,
+            "G": None,
+        }
+        self.assertEqual(shelf, self.toy_store.toy_shelf)
+
+    def test_add_toy_invalid_shelf(self):
+        with self.assertRaises(Exception) as ex:
+            self.toy_store.add_toy("7", "Mark")
+
+        self.assertEqual("Shelf doesn't exist!", str(ex.exception))
+
+    def test_add_toy_already_in_shelf(self):
+        self.toy_store.toy_shelf = {"A": "Mark"}
+
+        with self.assertRaises(Exception) as ex:
+            self.toy_store.add_toy("A", "Mark")
+
+        self.assertEqual("Toy is already in shelf!", str(ex.exception))
+
+    def test_add_toy_shelf_already_taken(self):
+        self.toy_store.toy_shelf["A"] = "Mark"
+
+        with self.assertRaises(Exception) as ex:
+            self.toy_store.add_toy("A", "John")
+
+        self.assertEqual("Shelf is already taken!", str(ex.exception))
+
+    def test_successful_add_toy(self):
+        result = self.toy_store.add_toy("A", "Mark")
+        shelf = {
+            "A": "Mark",
+            "B": None,
+            "C": None,
+            "D": None,
+            "E": None,
+            "F": None,
+            "G": None,
+        }
+        self.assertEqual(shelf, self.toy_store.toy_shelf)
+        self.assertEqual(f"Toy:Mark placed successfully!", result)
+
+    def test_remove_toy_shelf_not_in_shelf_keys(self):
+        with self.assertRaises(Exception) as ex:
+            self.toy_store.remove_toy("7", "Mark")
+
+        self.assertEqual("Shelf doesn't exist!", str(ex.exception))
+
+    def test_remove_toy_name_not_in_shelf(self):
+        with self.assertRaises(Exception) as ex:
+            self.toy_store.remove_toy("A", "Mark")
+
+        self.assertEqual("Toy in that shelf doesn't exists!", str(ex.exception))
+
+    def test_successful_remove_toy(self):
+        self.toy_store.toy_shelf = {
+            "A": "Mark",
+            "B": None,
+            "C": None,
+            "D": None,
+            "E": None,
+            "F": None,
+            "G": None,
+        }
+        result = self.toy_store.remove_toy("A", "Mark")
+        self.assertEqual(None, self.toy_store.toy_shelf["A"])
+        self.assertEqual(f"Remove toy:Mark successfully!", result)
+
+
+if __name__ == '__main__':
+    main()