from dataclasses import dataclass
from typing import List
# In the Customer Management bounded context
@dataclass
class Customer:
    id: str
    name: str
    email: str
class CustomerRepository:
    def __init__(self):
        self.customers = []
    def find_by_id(self, id):
        # Find the customer by id
        for customer in self.customers:
            if customer.id == id:
                return customer
        return None
# In the Order Management bounded context
@dataclass
class OrderItem:
    product_name: str
    quantity: int
@dataclass
class Order:
    customer_id: str
    items: List[OrderItem]
class OrderService:
    def __init__(self, customer_service):
        self.customer_service = customer_service
    def create_order(self, customer_id, items):
        # Use the customer service to get the customer information
        customer = self.customer_service.get_customer(customer_id)
        # Create the order
        order = Order(customer.id, items)
        # Save the order
        # to do
        return order
# The Open Host Service
class CustomerService:
    def __init__(self, customer_repository):
        self.customer_repository = customer_repository
    def get_customer(self, customer_id):
        # Find the customer by id
        customer = self.customer_repository.find_by_id(customer_id)
        if customer is None:
            raise ValueError("Client non trouvé")
        return customer
if __name__ == '__main__':
    # create some customers
    customer1 = Customer(1, 'Léa Lee', 'lea.lee@invivoo.com')
    customer2 = Customer(2, 'Léo Hu', 'leo.hu@invivoo.com')
    # add customers to the customer repository
    customer_repository = CustomerRepository()
    customer_repository.customers = [customer1, customer2]
    # create a customer service using the customer repository
    customer_service = CustomerService(customer_repository)
    # create an order service using the customer service
    order_service = OrderService(customer_service)
    # create an order for customer 1
    items = [OrderItem('jeans', 2), OrderItem('baskets', 5)]

 shared_kernel.py
from dataclasses import dataclass
from typing import List, Optional
@dataclass
class Product:
    id: int
    name: str
    description: str
    price: float
class OrderItem:
    def __init__

 order_management.py
# In the Order Management context
from shared_kernel import Product
@dataclass
class Order:
    customer_id: int
    items: List[OrderItem]
    total_price: Optional[float] = None
    def __post_init__(self):
        self.total_price = sum([item.product.price * item.quantity for item in self.items])
    def add_item(self, product: Product, quantity: int):
        # Add a new item to the order
        item = OrderItem(product, quantity)
        self.items.append(item)
        # Recalculate the total price of the order
        self.total_price = sum([item.product.price * item.quantity for item in self.items])
# inventory_management.py
# In the Inventory Management context 
from shared_kernel import Product
class Inventory:
    def __init__(self):
        self.inventory: List[Product] = []
    def add_product(self, product: Product):
        # Add the product to the inventory
        self.inventory.append(product)
    def remove_product(self, product_name: str):
        # Check if the product is in the inventory
        for product in self.inventory:
            if product.name == product_name:
                # Remove the product from the inventory
                self.inventory.remove(product)
                return True
        return False
if __name__ == "__main__":
    # Create some example products
    product1 = Product(1, "CD Céline Dion", "Titanic", 30.0)
    product2 = Product(2, "Ticket Astérix ", "Astérix Attraction", 20.0)
    product3 = Product(3, "Guide Paris", "Guide Voyage", 10.0)
    # Create an example order
    order = Order(1, [OrderItem(product1, 2), OrderItem(product2, 1)]

from dataclasses import dataclass
from typing import List
@dataclass
class Product:
    id: int
    name: str
    description: str
    price: float
# Inventory Management Bounded Context
@dataclass
class Inventory:
    products: List[Product]
    def add_product(self, product: Product):
        self.products.append(product)
    def remove_product(self, product: Product):
        self.products.remove(product)
# Order Management Bounded Context
@dataclass
class Order:
    id: int
    customer_id: int
    items: List[Product]
@dataclass
class OrderService:
    inventory: Inventory
    def place_order(self, order: Order):
        for item in order.items:
            if item not in self.inventory.products:
                raise ValueError(f"Product {item.name} is not in inventory.")
        # Place the order...
if __name__ == '__main__':
    # Create some sample data
    product1 = Product(1, "CD Céline Dion", "Titanic", 30.0)
    product2 = Product(2, "Ticket Astérix ", "Astérix Attraction", 20.0)
    product3 = Product(3, "Guide Paris", "Guide Voyage", 10.0)
    inventory = Inventory([product1, product2, product3])
    order = Order(1, 1, [product1, product1, product3]

from dataclasses import dataclass
from typing import List
@dataclass
class Product:
    id: int
    name: str
    description: str
    price: float
# Rating Management bounded context
@dataclass
class Rating:
    customer_id: int
    product_id: int
    rating: int
    review: str
class RatingConformist:
    def __init__(self, ratings: List[Rating]):
        self.ratings = ratings
    def get_ratings_by_product(self, product_id: int) -> List[int]:
        return [rating.rating for rating in self.ratings if rating.product_id == product_id]
# In the Product Recommendations bounded context
class ProductRecommendations:
    def __init__(self, ratings_conformist: RatingConformist):
        self.ratings_conformist = ratings_conformist
    def get_recommendations(self, product_id: int) -> List[Product]:
    # Get the ratings for the product using the RatingConformist
      product_ratings = self.ratings_conformist.get_ratings_by_product(product_id)
      # Get a list of all products that have been rated, except for the current product
      rated_products = set(r.product_id for r in self.ratings_conformist.ratings if r.product_id != product_id)
      # Calculate the average rating for each rated product and store the results in a list of tuples
      avg_ratings = [(product_id, sum(self.ratings_conformist.get_ratings_by_product(product_id)) / len(self.ratings_conformist.get_ratings_by_product(product_id)))
                     for product_id in rated_products]
      # Sort the list of tuples by average rating and get the best products
      top_products = sorted(avg_ratings, key=lambda x: x[1], reverse=True)[:1]
      # Get the recommended products based on the top product IDs
      recommended_products = [p for p in self.ratings_conformist.ratings if p.product_id in [tp[0] for tp in top_products]]
      # Return the recommended products
      return recommended_products
if __name__ == "__main__":
    # In the Rating Management bounded context
    ratings = [
        Rating(customer_id=1, product_id=1, rating=4, review="Good product"),
        Rating(customer_id=2, product_id=1, rating=5, review="Great product"),
        Rating(customer_id=3, product_id=1, rating=3, review="Okay product"),
        Rating(customer_id=1, product_id=2, rating=5, review="Awesome product"),
        Rating(customer_id=2, product_id=2, rating=4, review="Very good product"),
        Rating(customer_id=3, product_id=2, rating=4, review="Great product"),
        Rating(customer_id=1, product_id=3, rating=2, review="Not so good product"),
        Rating(customer_id=2, product_id=3, rating=3, review="Average product"),
        Rating(customer_id=3, product_id=3, rating=2, review="Disappointing product")
    ]

from dataclasses import dataclass
# In the Sales context
@dataclass
class SalesCustomer:
    name: str
    billing_address: Address
@dataclass
class Address:
    street: str
    city: str
    country: str
    zip_code: str
# In the Shipping context
@dataclass
class ShippingCustomer:
    name: str
    shipping_address: Address
# In the Anti-corruption Layer
class SalesToShippingTranslator:
    def translate_customer(self, customer):
        shipping_address = Address(
            street=customer.billing_address.street,
            city=customer.billing_address.city,
            country=customer.billing_address.country,
            zip_code=customer.billing_address.zip_code
        )
        translated_customer = ShippingCustomer(
            name=customer.name,
            shipping_address=shipping_address
        )
        return translated_customer
class ShippingService:
    def create_shipping_order(self, customer):
        print(f"Creating shipping order for customer {customer.name} with address {customer.shipping_address.street}, {customer.shipping_address.city}, {customer.shipping_address.country}, {customer.shipping_address.zip_code}")
if __name__ == "__main__

from dataclasses import dataclass
@dataclass
class Address:
    street: str
    city: str
    zipcode: str
    country: str
@dataclass
class Customer:
    name: str
    email: str
    shipping_address: Address
@dataclass
class Product:
    name: str
    price: float
    sku: str
    def process_order(self, customer):
        if isinstance(self, PhysicalProduct):
            shipping_address = customer.shipping_address
            print(f"Creating shipping order for product {self.name} to customer {customer.name} with shipping address {shipping_address}")
            print(f"Processing payment for customer {customer.name} for amount {self.price}")
        elif isinstance(self, DigitalProduct):
            print(f"Sending download link for product {self.name} to customer {customer.name} at email address {customer.email}")
            print(f"Processing payment for customer {customer.name} for amount {self.price}")
@dataclass
class PhysicalProduct(Product):
    weight: float
@dataclass
class DigitalProduct(Product):
    download_url: str
if __name__ == "__main__