E-commerce Checkout

from hyrex import HyrexRegistry
import stripe
import requests
from decimal import Decimal
import os

hy = HyrexRegistry()

@hy.task
def validate_cart_items(cart_id: str):
    """Validate cart items and calculate totals"""
    cart = get_cart_from_db(cart_id)
    
    total_amount = Decimal('0.00')
    validated_items = []
    
    for item in cart['items']:
        product = get_product_by_id(item['product_id'])
        
        # Check stock availability
        if product['stock_quantity'] < item['quantity']:
            raise Exception(f"Insufficient stock for {product['name']}")
        
        # Validate pricing
        item_total = product['price'] * item['quantity']
        total_amount += item_total
        
        validated_items.append({
            'product_id': item['product_id'],
            'quantity': item['quantity'],
            'unit_price': product['price'],
            'total_price': item_total
        })
    
    return {
        'cart_id': cart_id,
        'items': validated_items,
        'subtotal': total_amount,
        'tax_amount': calculate_tax(total_amount, cart['shipping_address']),
        'shipping_cost': calculate_shipping(cart['shipping_address'])
    }

@hy.task
def process_payment(payment_data: dict):
    """Process payment through Stripe"""
    stripe.api_key = os.environ.get('STRIPE_SECRET_KEY')
    
    try:
        payment_intent = stripe.PaymentIntent.create(
            amount=int(payment_data['amount'] * 100),  # Convert to cents
            currency='usd',
            payment_method=payment_data['payment_method_id'],
            confirm=True,
            return_url=payment_data.get('return_url')
        )
        
        return {
            'payment_intent_id': payment_intent.id,
            'status': payment_intent.status,
            'amount': payment_data['amount']
        }
    except stripe.error.CardError as e:
        raise Exception(f"Payment failed: {e.user_message}")

@hy.task
def reserve_inventory(cart_items: list):
    """Reserve inventory for cart items"""
    reserved_items = []
    
    for item in cart_items:
        success = reserve_product_stock(
            item['product_id'], 
            item['quantity']
        )
        
        if not success:
            # Rollback previous reservations
            for reserved in reserved_items:
                release_product_stock(
                    reserved['product_id'], 
                    reserved['quantity']
                )
            raise Exception(f"Could not reserve stock for product {item['product_id']}")
        
        reserved_items.append(item)
    
    return reserved_items

@hy.task
def create_order(order_data: dict):
    """Create order record in database"""
    order = {
        'customer_id': order_data['customer_id'],
        'items': order_data['items'],
        'subtotal': order_data['subtotal'],
        'tax_amount': order_data['tax_amount'],
        'shipping_cost': order_data['shipping_cost'],
        'total_amount': order_data['total_amount'],
        'shipping_address': order_data['shipping_address'],
        'billing_address': order_data['billing_address'],
        'payment_intent_id': order_data['payment_intent_id'],
        'status': 'confirmed'
    }
    
    order_id = save_order_to_db(order)
    return {'order_id': order_id, 'order': order}

@hy.task
def send_order_confirmation(order_id: str, customer_email: str):
    """Send order confirmation email"""
    order = get_order_by_id(order_id)
    
    email_content = f"""
    Thank you for your order!
    
    Order #: {order_id}
    Total: ${order['total_amount']:.2f}
    
    Items:
    """
    
    for item in order['items']:
        product = get_product_by_id(item['product_id'])
        email_content += f"- {product['name']} x {item['quantity']}: ${item['total_price']:.2f}\\n"
    
    email_content += f"""
    
    Shipping Address:
    {format_address(order['shipping_address'])}
    
    We'll send you a tracking number when your order ships!
    """
    
    send_email(
        to=customer_email,
        subject=f"Order Confirmation #{order_id}",
        body=email_content
    )

@hy.task
def process_checkout(checkout_data: dict):
    """Orchestrate the complete checkout process"""
    try:
        # Step 1: Validate cart and calculate totals
        validation_result = validate_cart_items.send(checkout_data['cart_id']).get()
        
        # Step 2: Reserve inventory
        reserve_inventory.send(validation_result['items']).get()
        
        # Step 3: Process payment
        payment_data = {
            'amount': validation_result['subtotal'] + validation_result['tax_amount'] + validation_result['shipping_cost'],
            'payment_method_id': checkout_data['payment_method_id'],
            'return_url': checkout_data.get('return_url')
        }
        payment_result = process_payment.send(payment_data).get()
        
        # Step 4: Create order
        order_data = {
            **validation_result,
            'customer_id': checkout_data['customer_id'],
            'shipping_address': checkout_data['shipping_address'],
            'billing_address': checkout_data['billing_address'],
            'payment_intent_id': payment_result['payment_intent_id'],
            'total_amount': payment_data['amount']
        }
        order_result = create_order.send(order_data).get()
        
        # Step 5: Send confirmation email
        send_order_confirmation.send(order_result['order_id'], checkout_data['customer_email'])
        
        return {
            'success': True,
            'order_id': order_result['order_id'],
            'payment_status': payment_result['status']
        }
        
    except Exception as e:
        # Handle failures - rollback inventory, refund payment if necessary
        handle_checkout_failure.send(checkout_data, str(e))
        raise e

@hy.task  
def handle_checkout_failure(checkout_data: dict, error_message: str):
    """Handle checkout failures with proper cleanup"""
    # Log the error
    log_checkout_error(checkout_data['cart_id'], error_message)
    
    # Send failure notification to customer
    send_email(
        to=checkout_data['customer_email'],
        subject="Order Processing Issue",
        body=f"We encountered an issue processing your order. Error: {error_message}. Please try again or contact support."
    )

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from .tasks import process_checkout, process_refund

app = FastAPI()

class CheckoutRequest(BaseModel):
    cart_id: str
    customer_id: str
    customer_email: str
    payment_method_id: str
    shipping_address: dict
    billing_address: dict
    return_url: str = None

class RefundRequest(BaseModel):
    order_id: str
    reason: str = None
    amount: float = None  # Partial refund amount

@app.post("/checkout/process")
async def initiate_checkout(request: CheckoutRequest):
    """Start the checkout process"""
    checkout_data = {
        'cart_id': request.cart_id,
        'customer_id': request.customer_id,
        'customer_email': request.customer_email,
        'payment_method_id': request.payment_method_id,
        'shipping_address': request.shipping_address,
        'billing_address': request.billing_address,
        'return_url': request.return_url
    }
    
    task = process_checkout.send(checkout_data)
    
    return {
        "message": "Checkout initiated",
        "task_id": task.task_id,
        "cart_id": request.cart_id
    }

@app.get("/checkout/status/{task_id}")
async def get_checkout_status(task_id: str):
    """Get checkout processing status"""
    task = hy.get_task(task_id)
    
    return {
        "task_id": task_id,
        "status": task.status,
        "result": task.result if task.is_complete else None,
        "error": task.error if task.has_failed else None
    }

@app.post("/orders/refund")
async def process_refund_endpoint(request: RefundRequest):
    """Process order refund"""
    task = process_refund.send(request.order_id, request.amount, request.reason)
    
    return {
        "message": "Refund processing started",
        "task_id": task.task_id,
        "order_id": request.order_id
    }

@app.get("/orders/{order_id}")
async def get_order(order_id: str):
    """Get order details"""
    order = get_order_by_id(order_id)
    if not order:
        raise HTTPException(status_code=404, detail="Order not found")
    
    return order