SOLID là gì? Ví dụ dễ hiểu về nguyên lý SOLID cho người mới

class OrderManagement:
    def take_order(self, order):
        # Logic để xử lý đơn hàng
        print("Order taken.")

    def calculate_bill(self, order):
        # Logic để tính toán hóa đơn
        total = sum(item['price'] * item['quantity'] for item in order)
        print(f"Bill calculated: ${total}")
        return total

    def generate_invoice(self, order, total):
        # Logic để tạo file PDF hóa đơn
        print("Invoice generated in PDF format.")

# Sử dụng lớp OrderManagement
order = [
    {"name": "Item 1", "price": 10, "quantity": 2},
    {"name": "Item 2", "price": 20, "quantity": 1}
]

order_management = OrderManagement()
order_management.take_order(order)
total = order_management.calculate_bill(order)
order_management.generate_invoice(order, total)

class OrderProcessor:
    def take_order(self, order):
        # Logic để xử lý đơn hàng
        print("Order taken.")

class BillingCalculator:
    def calculate_bill(self, order):
        # Logic để tính toán hóa đơn
        total = sum(item['price'] * item['quantity'] for item in order)
        print(f"Bill calculated: ${total}")
        return total

class InvoiceGenerator:
    def generate_invoice(self, order, total):
        # Logic để tạo file PDF hóa đơn
        print("Invoice generated in PDF format.")

# Sử dụng các lớp đã tách riêng
order = [
    {"name": "Item 1", "price": 10, "quantity": 2},
    {"name": "Item 2", "price": 20, "quantity": 1}
]

order_processor = OrderProcessor()
billing_calculator = BillingCalculator()
invoice_generator = InvoiceGenerator()

order_processor.take_order(order)
total = billing_calculator.calculate_bill(order)
invoice_generator.generate_invoice(order, total)

class Order:
    def __init__(self, amount):
        self.amount = amount

    def process_payment(self, payment_method):
        if payment_method == "credit_card":
            self.pay_by_credit_card()
        elif payment_method == "paypal":
            self.pay_by_paypal()

    def pay_by_credit_card(self):
        print(f"Processing credit card payment of ${self.amount}")

    def pay_by_paypal(self):
        print(f"Processing PayPal payment of ${self.amount}")

# Sử dụng hệ thống thanh toán
order = Order(100)
order.process_payment("credit_card")
order.process_payment("paypal")

from abc import ABC, abstractmethod

class PaymentProcessor(ABC):
    @abstractmethod
    def process_payment(self, amount):
        pass

class CreditCardPayment(PaymentProcessor):
    def process_payment(self, amount):
        print(f"Processing credit card payment of ${amount}")

class PayPalPayment(PaymentProcessor):
    def process_payment(self, amount):
        print(f"Processing PayPal payment of ${amount}")

class EWalletPayment(PaymentProcessor):
    def process_payment(self, amount):
        print(f"Processing eWallet payment of ${amount}")

class Order:
    def __init__(self, amount):
        self.amount = amount

    def process_payment(self, payment_processor: PaymentProcessor):
        payment_processor.process_payment(self.amount)

# Sử dụng hệ thống thanh toán với khả năng mở rộng
order = Order(100)
order.process_payment(CreditCardPayment())
order.process_payment(PayPalPayment())

# Thêm phương thức thanh toán mới mà không thay đổi mã cũ
order.process_payment(EWalletPayment())

class Order:
    def process_payment(self, payment_method):
        # Xử lý thanh toán mặc định
        print(f"Processing payment using {payment_method}")

class OnlineOrder(Order):
    def process_payment(self, payment_method):
        # Xử lý thanh toán trực tuyến
        if payment_method == "credit_card":
            print("Processing online payment with credit card")
        else:
            raise NotImplementedError("Only credit card payments are supported online")

class InStoreOrder(Order):
    def process_payment(self, payment_method):
        # Xử lý thanh toán tại cửa hàng
        if payment_method in ["cash", "credit_card"]:
            print(f"Processing in-store payment with {payment_method}")
        else:
            raise NotImplementedError("Only cash or credit card payments are supported in-store")

# Sử dụng các đối tượng
def handle_order(order: Order, payment_method):
    order.process_payment(payment_method)

online_order = OnlineOrder()
in_store_order = InStoreOrder()

handle_order(online_order, "credit_card")  # Hoạt động bình thường
handle_order(in_store_order, "cash")       # Hoạt động bình thường
handle_order(in_store_order, "paypal")     # Sẽ lỗi vì không hỗ trợ PayPal

from abc import ABC, abstractmethod

# Lớp cơ sở trừu tượng cho phương thức thanh toán
class PaymentProcessor(ABC):
    @abstractmethod
    def process_payment(self, amount):
        pass

class CreditCardPayment(PaymentProcessor):
    def process_payment(self, amount):
        print(f"Processing credit card payment of ${amount}")

class CashPayment(PaymentProcessor):
    def process_payment(self, amount):
        print(f"Processing cash payment of ${amount}")

# Lớp Order với các phương thức thanh toán được truyền vào
class Order(ABC):
    def __init__(self, amount, payment_processor: PaymentProcessor):
        self.amount = amount
        self.payment_processor = payment_processor

    def process_order(self):
        self.payment_processor.process_payment(self.amount)

class OnlineOrder(Order):
    pass

class InStoreOrder(Order):
    pass

# Sử dụng các đối tượng
def handle_order(order: Order):
    order.process_order()

online_order = OnlineOrder(100, CreditCardPayment())
in_store_order = InStoreOrder(50, CashPayment())

handle_order(online_order)  # Xử lý thanh toán trực tuyến
handle_order(in_store_order) # Xử lý thanh toán tại cửa hàng

class OrderOperations:
    def place_order(self):
        raise NotImplementedError
    
    def cancel_order(self):
        raise NotImplementedError
    
    def track_order(self):
        raise NotImplementedError
    
    def refund_order(self):
        raise NotImplementedError

class InStoreOrder(OrderOperations):
    def place_order(self):
        print("Placing in-store order")
    
    def cancel_order(self):
        print("Cancelling in-store order")
    
    def track_order(self):
        pass  # Không thực sự cần thiết nhưng vẫn phải triển khai
    
    def refund_order(self):
        pass  # Không thực sự cần thiết nhưng vẫn phải triển khai

class OnlineOrder(OrderOperations):
    def place_order(self):
        print("Placing online order")
    
    def cancel_order(self):
        print("Cancelling online order")
    
    def track_order(self):
        print("Tracking online order")
    
    def refund_order(self):
        print("Refunding online order")

# Sử dụng các lớp
in_store_order = InStoreOrder()
in_store_order.place_order()
in_store_order.track_order()  # Gọi phương thức nhưng không có gì xảy ra

online_order = OnlineOrder()
online_order.place_order()
online_order.track_order()  # Thực hiện đúng chức năng

from abc import ABC, abstractmethod

class Placeable(ABC):
    @abstractmethod
    def place_order(self):
        pass

class Cancelable(ABC):
    @abstractmethod
    def cancel_order(self):
        pass

class Trackable(ABC):
    @abstractmethod
    def track_order(self):
        pass

class Refundable(ABC):
    @abstractmethod
    def refund_order(self):
        pass

class InStoreOrder(Placeable, Cancelable):
    def place_order(self):
        print("Placing in-store order")
    
    def cancel_order(self):
        print("Cancelling in-store order")

class OnlineOrder(Placeable, Cancelable, Trackable, Refundable):
    def place_order(self):
        print("Placing online order")
    
    def cancel_order(self):
        print("Cancelling online order")
    
    def track_order(self):
        print("Tracking online order")
    
    def refund_order(self):
        print("Refunding online order")

# Sử dụng các lớp
in_store_order = InStoreOrder()
in_store_order.place_order()

online_order = OnlineOrder()
online_order.place_order()
online_order.track_order()  # Thực hiện đúng theo nhu cầu

class EmailNotifier:
    def send_email(self, message):
        print(f"Sending email: {message}")

class OrderProcessor:
    def __init__(self, order_id):
        self.order_id = order_id
        self.notifier = EmailNotifier()  # Phụ thuộc trực tiếp vào EmailNotifier

    def process_order(self):
        print(f"Processing order {self.order_id}")
        self.notifier.send_email(f"Order {self.order_id} has been processed")

# Sử dụng hệ thống
order_processor = OrderProcessor(123)
order_processor.process_order()

from abc import ABC, abstractmethod

class Notifier(ABC):
    @abstractmethod
    def notify(self, message):
        pass

class EmailNotifier(Notifier):
    def notify(self, message):
        print(f"Sending email: {message}")

class SMSNotifier(Notifier):
    def notify(self, message):
        print(f"Sending SMS: {message}")

class OrderProcessor:
    def __init__(self, order_id, notifier: Notifier):
        self.order_id = order_id
        self.notifier = notifier  # Phụ thuộc vào abstraction Notifier

    def process_order(self):
        print(f"Processing order {self.order_id}")
        self.notifier.notify(f"Order {self.order_id} has been processed")

email_notifier = EmailNotifier()
sms_notifier = SMSNotifier()

order_processor_email = OrderProcessor(123, email_notifier)
order_processor_email.process_order()

order_processor_sms = OrderProcessor(456, sms_notifier)
order_processor_sms.process_order()