🍕 Mario's Pizzeria Tutorial¶

"""Pizza entity for Mario's Pizzeria domain"""

from decimal import Decimal
from typing import Optional
from uuid import uuid4

from api.dtos import PizzaDto

from neuroglia.data.abstractions import Entity
from neuroglia.mapping.mapper import map_from, map_to

from .enums import PizzaSize


@map_from(PizzaDto)
@map_to(PizzaDto)
class Pizza(Entity[str]):
    """Pizza entity with pricing and toppings"""

    def __init__(self, name: str, base_price: Decimal, size: PizzaSize, description: Optional[str] = None):
        super().__init__()
        self.id = str(uuid4())
        self.name = name
        self.base_price = base_price
        self.size = size
        self.description = description or ""
        self.toppings: list[str] = []

    @property
    def size_multiplier(self) -> Decimal:
        """Get price multiplier based on pizza size"""
        multipliers = {
            PizzaSize.SMALL: Decimal("1.0"),
            PizzaSize.MEDIUM: Decimal("1.3"),
            PizzaSize.LARGE: Decimal("1.6"),
        }
        return multipliers[self.size]

    @property
    def topping_price(self) -> Decimal:
        """Calculate total price for all toppings"""
        return Decimal(str(len(self.toppings))) * Decimal("2.50")

    @property
    def total_price(self) -> Decimal:
        """Calculate total pizza price including size and toppings"""
        base_with_size = self.base_price * self.size_multiplier
        return base_with_size + self.topping_price

    def add_topping(self, topping: str) -> None:
        """Add a topping to the pizza"""
        if topping not in self.toppings:
            self.toppings.append(topping)

    def remove_topping(self, topping: str) -> None:
        """Remove a topping from the pizza"""
        if topping in self.toppings:
            self.toppings.remove(topping)

"""Order entity for Mario's Pizzeria domain"""

from datetime import datetime, timezone
from decimal import Decimal
from typing import Optional
from uuid import uuid4

from api.dtos import OrderDto

from neuroglia.data.abstractions import Entity
from neuroglia.mapping.mapper import map_from, map_to

from .enums import OrderStatus
from .pizza import Pizza


@map_from(OrderDto)
@map_to(OrderDto)
class Order(Entity[str]):
    """Order entity with pizzas and status management"""

    def __init__(self, customer_id: str, estimated_ready_time: Optional[datetime] = None):
        super().__init__()
        self.id = str(uuid4())
        self.customer_id = customer_id
        self.pizzas: list[Pizza] = []
        self.status = OrderStatus.PENDING
        self.order_time = datetime.now(timezone.utc)
        self.confirmed_time: Optional[datetime] = None
        self.cooking_started_time: Optional[datetime] = None
        self.actual_ready_time: Optional[datetime] = None
        self.estimated_ready_time = estimated_ready_time
        self.notes: Optional[str] = None

    @property
    def total_amount(self) -> Decimal:
        """Calculate total order amount"""
        return sum((pizza.total_price for pizza in self.pizzas), Decimal("0.00"))

    @property
    def pizza_count(self) -> int:
        """Get total number of pizzas in the order"""
        return len(self.pizzas)

    def add_pizza(self, pizza: Pizza) -> None:
        """Add a pizza to the order"""
        if self.status != OrderStatus.PENDING:
            raise ValueError("Cannot modify confirmed orders")
        self.pizzas.append(pizza)

    def confirm_order(self) -> None:
        """Confirm the order and set confirmed time"""
        if self.status != OrderStatus.PENDING:
            raise ValueError("Only pending orders can be confirmed")

        if not self.pizzas:
            raise ValueError("Cannot confirm order without pizzas")

        self.status = OrderStatus.CONFIRMED
        self.confirmed_time = datetime.now(timezone.utc)

    def start_cooking(self) -> None:
        """Start cooking the order"""
        if self.status != OrderStatus.CONFIRMED:
            raise ValueError("Only confirmed orders can start cooking")

        self.status = OrderStatus.COOKING
        self.cooking_started_time = datetime.now(timezone.utc)

    def mark_ready(self) -> None:
        """Mark order as ready for pickup/delivery"""
        if self.status != OrderStatus.COOKING:
            raise ValueError("Only cooking orders can be marked ready")

        self.status = OrderStatus.READY
        self.actual_ready_time = datetime.now(timezone.utc)

class OrderStatus(Enum):
    """Order lifecycle statuses"""

    PENDING = "pending"
    CONFIRMED = "confirmed"
    COOKING = "cooking"
    READY = "ready"

from dataclasses import dataclass
from datetime import datetime
from decimal import Decimal
from neuroglia.data.abstractions import DomainEvent

@dataclass
class OrderPlacedEvent(DomainEvent):
    """Event raised when a new order is placed"""
    order_id: str
    customer_name: str
    total_amount: Decimal
    estimated_ready_time: datetime

    def __post_init__(self):
        super().__init__(self.order_id)

@dataclass
@map_from(CreateOrderDto)
class PlaceOrderCommand(Command[OperationResult[OrderDto]]):
    """Command to place a new pizza order"""

    customer_name: str
    customer_phone: str
    customer_address: Optional[str] = None
    customer_email: Optional[str] = None
    pizzas: list[CreatePizzaDto] = field(default_factory=list)
    payment_method: str = "cash"
    notes: Optional[str] = None

class PlaceOrderCommandHandler(CommandHandler[PlaceOrderCommand, OperationResult[OrderDto]]):
    """Handler for placing new pizza orders"""

    def __init__(
        self,
        order_repository: IOrderRepository,
        customer_repository: ICustomerRepository,
        mapper: Mapper,
    ):
        self.order_repository = order_repository
        self.customer_repository = customer_repository
        self.mapper = mapper

    async def handle_async(self, request: PlaceOrderCommand) -> OperationResult[OrderDto]:
        try:
            # First create or get customer
            customer = await self._create_or_get_customer(request)

            # Create order with customer_id
            order = Order(customer_id=customer.id)
            if request.notes:
                order.notes = request.notes

            # Add pizzas to order with dynamic pricing
            for pizza_item in request.pizzas:
                size = PizzaSize(pizza_item.size.lower())

                # Dynamic base pricing by pizza type
                base_price = Decimal("12.99")  # Default
                if pizza_item.name.lower() == "margherita":
                    base_price = Decimal("12.99")
                elif pizza_item.name.lower() == "pepperoni":
                    base_price = Decimal("14.99")
                elif pizza_item.name.lower() == "supreme":
                    base_price = Decimal("17.99")

                pizza = Pizza(name=pizza_item.name, base_price=base_price, size=size)

                # Add toppings
                for topping in pizza_item.toppings:
                    pizza.add_topping(topping)

                order.add_pizza(pizza)

            # Validate and confirm order
            if not order.pizzas:
                return self.bad_request("Order must contain at least one pizza")

            order.confirm_order()  # Raises domain event
            await self.order_repository.add_async(order)

            return self.created(self._build_order_dto(order, customer))

@dataclass
class GetOrderByIdQuery(Query[OperationResult[OrderDto]]):
    """Query to get an order by ID"""

    order_id: str

class GetOrderByIdQueryHandler(QueryHandler[GetOrderByIdQuery, OperationResult[OrderDto]]):
    """Handler for getting an order by ID"""

    def __init__(
        self,
        order_repository: IOrderRepository,
        customer_repository: ICustomerRepository,
        mapper: Mapper,
    ):
        self.order_repository = order_repository
        self.customer_repository = customer_repository
        self.mapper = mapper

    async def handle_async(self, request: GetOrderByIdQuery) -> OperationResult[OrderDto]:
        try:
            order = await self.order_repository.get_async(request.order_id)
            if not order:
                return self.not_found("Order", request.order_id)

            # Get customer details
            customer = await self.customer_repository.get_async(order.customer_id)

            # Create OrderDto with customer information
            order_dto = OrderDto(
                id=order.id,
                customer_name=customer.name if customer else "Unknown",
                customer_phone=customer.phone if customer else "Unknown",
                customer_address=customer.address if customer else "Unknown",
                pizzas=[self.mapper.map(pizza, PizzaDto) for pizza in order.pizzas],
                status=order.status.value,
                order_time=order.order_time,
                confirmed_time=order.confirmed_time,
                cooking_started_time=order.cooking_started_time,
                actual_ready_time=order.actual_ready_time,
                estimated_ready_time=order.estimated_ready_time,
                total_amount=order.total_amount,
                notes=order.notes,
            )

            return self.ok(order_dto)
        except Exception as e:
            return self.internal_server_error(f"Failed to get order: {str(e)}")

"""File-based implementation of order repository using generic FileSystemRepository"""

from datetime import datetime

from domain.entities import Order, OrderStatus
from domain.repositories import IOrderRepository

from neuroglia.data.infrastructure.filesystem import FileSystemRepository


class FileOrderRepository(FileSystemRepository[Order, str], IOrderRepository):
    """File-based implementation of order repository using generic FileSystemRepository"""

    def __init__(self, data_directory: str = "data"):
        super().__init__(data_directory=data_directory, entity_type=Order, key_type=str)

    async def get_by_customer_phone_async(self, phone: str) -> list[Order]:
        """Get all orders for a customer by phone number"""
        # Note: This would require a relationship lookup in a real implementation
        # For now, we'll return empty list as Order entity doesn't directly store phone
        return []

    async def get_orders_by_status_async(self, status: OrderStatus) -> list[Order]:
        """Get all orders with a specific status"""
        all_orders = await self.get_all_async()
        return [order for order in all_orders if order.status == status]

    async def get_orders_by_date_range_async(self, start_date: datetime, end_date: datetime) -> list[Order]:
        """Get orders within a date range"""
        all_orders = await self.get_all_async()
        return [order for order in all_orders if start_date <= order.created_at <= end_date]

    async def get_active_orders_async(self) -> list[Order]:
        """Get all active orders (not delivered or cancelled)"""
        all_orders = await self.get_all_async()
        active_statuses = {OrderStatus.CONFIRMED, OrderStatus.COOKING}
        return [order for order in all_orders if order.status in active_statuses]

from typing import List, Optional
from fastapi import HTTPException

from neuroglia.mvc import ControllerBase
from neuroglia.dependency_injection import ServiceProviderBase
from neuroglia.mapping import Mapper
from neuroglia.mediation import Mediator
from classy_fastapi import get, post, put

from api.dtos import (
    OrderDto,
    CreateOrderDto,
    UpdateOrderStatusDto,
)
from application.commands import PlaceOrderCommand, StartCookingCommand, CompleteOrderCommand
from application.queries import (
    GetOrderByIdQuery,
    GetOrdersByStatusQuery,
    GetActiveOrdersQuery,
)


class OrdersController(ControllerBase):
    """Mario's pizza order management endpoints"""

    def __init__(self, service_provider: ServiceProviderBase, mapper: Mapper, mediator: Mediator):
        super().__init__(service_provider, mapper, mediator)

    @get("/{order_id}", response_model=OrderDto, responses=ControllerBase.error_responses)
    async def get_order(self, order_id: str):
        """Get order details by ID"""
        query = GetOrderByIdQuery(order_id=order_id)
        result = await self.mediator.execute_async(query)
        return self.process(result)

    @get("/", response_model=List[OrderDto], responses=ControllerBase.error_responses)
    async def get_orders(self, status: Optional[str] = None):
        """Get orders, optionally filtered by status"""
        if status:
            query = GetOrdersByStatusQuery(status=status)
        else:
            query = GetActiveOrdersQuery()

        result = await self.mediator.execute_async(query)
        return self.process(result)

    @post("/", response_model=OrderDto, status_code=201, responses=ControllerBase.error_responses)
    async def place_order(self, request: CreateOrderDto):
        """Place a new pizza order"""
        command = self.mapper.map(request, PlaceOrderCommand)
        result = await self.mediator.execute_async(command)
        return self.process(result)

    @put("/{order_id}/cook", response_model=OrderDto, responses=ControllerBase.error_responses)
    async def start_cooking(self, order_id: str):
        """Start cooking an order"""
        command = StartCookingCommand(order_id=order_id)
        result = await self.mediator.execute_async(command)
        return self.process(result)

    @put("/{order_id}/ready", response_model=OrderDto, responses=ControllerBase.error_responses)
    async def complete_order(self, order_id: str):
        """Mark order as ready for pickup/delivery"""
        command = CompleteOrderCommand(order_id=order_id)
        result = await self.mediator.execute_async(command)
        return self.process(result)

    @put("/{order_id}/status", response_model=OrderDto, responses=ControllerBase.error_responses)
    async def update_order_status(self, order_id: str, request: UpdateOrderStatusDto):
        """Update order status (general endpoint)"""
        # Route to appropriate command based on status
        if request.status.lower() == "cooking":
            command = StartCookingCommand(order_id=order_id)
        elif request.status.lower() == "ready":
            command = CompleteOrderCommand(order_id=order_id)
        else:
            raise HTTPException(
                status_code=400, detail=f"Unsupported status transition: {request.status}"
            )

        result = await self.mediator.execute_async(command)
        return self.process(result)

#!/usr/bin/env python3
"""
Mario's Pizzeria - Main Application Entry Point

This is the complete sample application demonstrating all major Neuroglia framework features.
"""

import logging
import sys
from pathlib import Path
from typing import Optional

# Set up debug logging early
logging.basicConfig(level=logging.DEBUG)

# Add the project root to Python path so we can import neuroglia
project_root = Path(__file__).parent.parent.parent.parent
sys.path.insert(0, str(project_root / "src"))

# Domain repository interfaces
from domain.repositories import (
    ICustomerRepository,
    IKitchenRepository,
    IOrderRepository,
    IPizzaRepository,
)
from integration.repositories import (
    FileCustomerRepository,
    FileKitchenRepository,
    FileOrderRepository,
    FilePizzaRepository,
)

# Framework imports (must be after path manipulation)
from neuroglia.hosting.enhanced_web_application_builder import (
    EnhancedWebApplicationBuilder,
)
from neuroglia.mapping import Mapper
from neuroglia.mediation import Mediator


def create_pizzeria_app(data_dir: Optional[str] = None, port: int = 8000):
    """
    Create Mario's Pizzeria application with multi-app architecture.

    Creates separate apps for:
    - API backend (/api prefix)
    - Future UI frontend (/ prefix)
    """
    # Determine data directory
    data_dir_path = Path(data_dir) if data_dir else Path(__file__).parent / "data"
    data_dir_path.mkdir(exist_ok=True)

    print(f"💾 Data stored in: {data_dir_path}")

    # Create enhanced web application builder
    builder = EnhancedWebApplicationBuilder()

    # Register repositories with file-based implementations
    builder.services.add_singleton(
        IPizzaRepository,
        implementation_factory=lambda _: FilePizzaRepository(str(data_dir_path / "menu")),
    )
    builder.services.add_singleton(
        ICustomerRepository,
        implementation_factory=lambda _: FileCustomerRepository(str(data_dir_path / "customers")),
    )
    builder.services.add_singleton(
        IOrderRepository,
        implementation_factory=lambda _: FileOrderRepository(str(data_dir_path / "orders")),
    )
    builder.services.add_singleton(
        IKitchenRepository,
        implementation_factory=lambda _: FileKitchenRepository(str(data_dir_path / "kitchen")),
    )

    # Configure mediator with auto-discovery from command and query modules
    Mediator.configure(builder, ["application.commands", "application.queries"])

    # Configure auto-mapper with custom profile
    Mapper.configure(builder, ["application.mapping", "api.dtos", "domain.entities"])

    # Configure JSON serialization with type discovery
    from neuroglia.serialization.json import JsonSerializer

    # Configure JsonSerializer with domain modules for enum discovery
    JsonSerializer.configure(
        builder,
        type_modules=[
            "domain.entities.enums",  # Mario Pizzeria enum types
            "domain.entities",  # Also scan entities module for embedded enums
        ],
    )

    # Build the service provider (not the full app yet)
    service_provider = builder.services.build()

    # Create the main FastAPI app directly
    from fastapi import FastAPI

    app = FastAPI(
        title="Mario's Pizzeria",
        description="Complete pizza ordering and management system",
        version="1.0.0",
        debug=True,
    )

    # Make DI services available to the app
    app.state.services = service_provider

    # Create separate API app for backend REST API
    api_app = FastAPI(
        title="Mario's Pizzeria API",
        description="Pizza ordering and management API",
        version="1.0.0",
        docs_url="/docs",
        debug=True,
    )

    # IMPORTANT: Make services available to API app as well
    api_app.state.services = service_provider

    # Register API controllers to the API app
    builder.add_controllers(["api.controllers"], app=api_app)

    # Add exception handling to API app
    builder.add_exception_handling(api_app)

    # Mount the apps
    app.mount("/api", api_app, name="api")
    app.mount("/ui", ui_app, name="ui")

    return app

builder.services.add_singleton(
    IPizzaRepository,
    implementation_factory=lambda _: FilePizzaRepository(str(data_dir_path / "menu")),
)

# Configure mediator with auto-discovery from command and query modules
Mediator.configure(builder, ["application.commands", "application.queries"])

# Configure auto-mapper with custom profile
Mapper.configure(builder, ["application.mapping", "api.dtos", "domain.entities"])

# Configure JsonSerializer with domain modules for enum discovery
JsonSerializer.configure(
    builder,
    type_modules=[
        "domain.entities.enums",  # Mario Pizzeria enum types
        "domain.entities",  # Also scan entities module for embedded enums
    ],
)

def main():
    """Main entry point when running as a script"""
    import uvicorn

    # Parse command line arguments
    port = 8000
    host = "127.0.0.1"
    data_dir = None

    if len(sys.argv) > 1:
        for i, arg in enumerate(sys.argv[1:], 1):
            if arg == "--port" and i + 1 < len(sys.argv):
                port = int(sys.argv[i + 1])
            elif arg == "--host" and i + 1 < len(sys.argv):
                host = sys.argv[i + 1]
            elif arg == "--data-dir" and i + 1 < len(sys.argv):
                data_dir = sys.argv[i + 1]

    # Create the application
    app = create_pizzeria_app(data_dir=data_dir, port=port)

    print(f"🍕 Starting Mario's Pizzeria on http://{host}:{port}")
    print(f"📖 API Documentation available at http://{host}:{port}/api/docs")
    print(f"🌐 UI will be available at http://{host}:{port}/ui (coming soon)")

    # Run the server
    uvicorn.run(app, host=host, port=port)


if __name__ == "__main__":
    main()