visitor_visitor_shop.py

Go to the documentation of this file.

 
 
from abc import ABC, abstractmethod
from typing import TypeAlias
 
Visitor_Village : TypeAlias = "Visitor_Village"
 
from .visitor_ordervisitor import OrderVisitor
from .visitor_class import Visitor
 
 
 
 
def are_list_contents_the_same(left: list, right: list):
    matched = False
    if len(left) == len(right):
        matched = True
        for left_item in left:
            if left_item not in right:
                matched = False
                break
    return matched
 
 
 
 
class Visitor_Shop(ABC):
 
    
 
    
    @property
    def Name(self) -> str:
        return self._shopName
 
    
    @Name.setter
    def Name(self, name : str) -> None:
        self._shopName = name
 
    
    @property
    def Address(self) -> str:
        return self._shopAddress
 
    
    @Address.setter
    def Address(self, address : str) -> None:
        self._shopAddress = address
 
    
    @property
    def Village(self)  -> Visitor_Village:
        return self._village
 
    
    @Village.setter
    def Village(self, v : Visitor_Village) -> None:
        self._village = v
 
    
    @property
    def IngredientsForItems(self) -> dict[str, list[str]]:
        return self._ingredientsForItems
 
    
    @IngredientsForItems.setter
    def IngredientsForItems(self, ingredients : dict[str, list[str]]) -> None:
        self._ingredientsForItems = ingredients
 
    
    @property
    def Inventory(self) -> dict[str, int]:
        return self._inventory
    
 
 
    
    def __init__(self) -> None:
        self._shopName = ""
        self._shopAddress = ""
        self._village = None # type: Visitor_Village
        self._ingredientsForItems = {} # type: dict[str, list[str]]
        self._inventory = {} # type: dict[str, int]
 
    
 
    #-------------------------------------------------------------------
 
    
    def DoesShopSellItem(self, item : str) -> bool:
        return item in self._ingredientsForItems
 
    
    def IsItemInStock(self, item : str) -> bool:
        return item in self.Inventory and self.Inventory[item] > 0
 
 
    
    def AddItemToInventory(self, item : str) -> None:
        if not item in self.Inventory:
            self.Inventory[item] = 1
        else:
            self.Inventory[item] += 1
 
 
    
    def StringizeList(self, items : list[str]) -> str:
        return ", ".join(items)
 
 
    
    def PlaceOrder(self, items : list[str]) -> bool:
        orderPlaced = False
        outOfStockItems = []  # type: list[str]
        itemsInThisShop = []  # type: list[str]
 
        for item in items:
            if self.DoesShopSellItem(item):
                if not self.IsItemInStock(item):
                    outOfStockItems.append(item)
                itemsInThisShop.append(item)
 
        if itemsInThisShop:
            print("  {0}: Received an order for {1}.".format(
                    self.NameName, self.StringizeList(itemsInThisShop)))
            orderPlaced = True
 
        if outOfStockItems:
            for itemToOrder in outOfStockItems:
                if self._ingredientsForItems[itemToOrder]:
                    print("  {0}:   {1} out of stock, ordering ingredients to make more...".format(
                            self.NameName, itemToOrder))
                    visitor = OrderVisitor(self._ingredientsForItems[itemToOrder])
                    self._village.Accept(visitor)
                    if are_list_contents_the_same(visitor.ItemsReceived, self._ingredientsForItems[itemToOrder]):
                        # verify the ingredients received matches the ingredients
                        # needed. Only then add 1 to the inventory.
                        self.AddItemToInventory(itemToOrder)
                else:
                    # The ordered item has no ingredients so the
                    # ordered item will be magically added to inventory
                    print("  {0}:   {1} out of stock, making...".format(
                            self.NameName, itemToOrder))
                    self.AddItemToInventory(itemToOrder)
        return orderPlaced
 
 
    
    def PickupOrder(self, items : list[str], itemsToBePickedUp : list[str]) -> None:
        for item in items:
            # If this shop sells the item and the item is in stock then
            if self.DoesShopSellItem(item):
                if self.IsItemInStock(item):
                    itemsToBePickedUp.append(item)
                else:
                    print("  Error!  {0}: Item {1} is not in the inventory when it should be.".format(
                            self.NameName, item))
 
        if itemsToBePickedUp:
            itemsReceivedFromThisShop = []
            # Reduce inventory for the ordered items
            for itemToBePickedUp in itemsToBePickedUp:
                if self.DoesShopSellItem(itemToBePickedUp):
                     self.Inventory[itemToBePickedUp] -= 1
                     itemsReceivedFromThisShop.append(itemToBePickedUp)
            output = self.StringizeList(itemsReceivedFromThisShop)
            print("  {0}: Order picked up for {1}.".format(self.NameName, output))
 
 
    
    @abstractmethod
    def Accept(self, visitor : Visitor) -> None:
        pass