Thiết Kế API & Database: Từ Code Chạy Được Đến Hệ Thống Mở Rộng

from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel
from typing import Optional

app = FastAPI()

class User(BaseModel):
    name: str
    email: str
    age: Optional[int] = None

class UserUpdate(BaseModel):
    name: Optional[str] = None
    email: Optional[str] = None
    age: Optional[int] = None

# READ - Lấy một user
@app.get("/users/{user_id}")
def get_user(user_id: int):
    user = db.get_user(user_id)
    if not user:
        raise HTTPException(
            status_code=404,
            detail=f"User {user_id} not found"
        )
    return user

# CREATE - Tạo user mới
@app.post("/users", status_code=status.HTTP_201_CREATED)
def create_user(user: User):
    # Kiểm tra email đã tồn tại chưa
    if db.email_exists(user.email):
        raise HTTPException(
            status_code=400,
            detail="Email already registered"
        )

    user_id = db.create_user(user)
    return {
        "id": user_id,
        "name": user.name,
        "email": user.email,
        "message": "User created successfully"
    }

# UPDATE - Cập nhật một phần
@app.patch("/users/{user_id}")
def update_user(user_id: int, user: UserUpdate):
    if not db.user_exists(user_id):
        raise HTTPException(status_code=404, detail="User not found")

    # Chỉ cập nhật các trường được cung cấp
    db.update_user(user_id, user.dict(exclude_unset=True))
    return {"message": "User updated successfully"}

# DELETE - Xóa user
@app.delete("/users/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
def delete_user(user_id: int):
    if not db.user_exists(user_id):
        raise HTTPException(status_code=404, detail="User not found")

    db.delete_user(user_id)
    # 204 responses không có body

@app.post("/checkout")
def checkout(order: Order):
    try:
        # Kiểm tra tồn kho
        if not inventory.check_stock(order.items):
            raise HTTPException(
                status_code=409,  # Conflict
                detail="Some items are out of stock"
            )

        # Xử lý thanh toán
        payment = payment_service.charge(order.total)
        if payment.status == "failed":
            raise HTTPException(
                status_code=402,  # Payment Required
                detail="Payment failed"
            )

        # Tạo order
        order_id = db.create_order(order)
        return {"order_id": order_id, "status": "confirmed"}

    except PaymentServiceTimeout:
        raise HTTPException(
            status_code=504,  # Gateway Timeout
            detail="Payment service timeout. Please try again."
        )
    except Exception as e:
        # Log lỗi để debug
        logger.error(f"Checkout failed: {e}")
        raise HTTPException(
            status_code=500,
            detail="Internal server error"
        )

from fastapi import Depends, HTTPException
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import jwt

security = HTTPBearer()

def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
    try:
        # Giải mã JWT (không cần tra cứu database!)
        payload = jwt.decode(
            credentials.credentials,
            SECRET_KEY,
            algorithms=["HS256"]
        )
        return payload["user_id"]
    except jwt.ExpiredSignatureError:
        raise HTTPException(status_code=401, detail="Token expired")
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="Invalid token")

@app.get("/profile")
def get_profile(user_id: int = Depends(verify_token)):
    # user_id được lấy từ token, không cần session
    return db.get_user(user_id)

from sqlalchemy import create_engine
from pymongo import MongoClient

# PostgreSQL cho core business
pg_db = create_engine("postgresql://localhost/ecommerce")

# MongoDB cho events/logs
mongo_client = MongoClient("mongodb://localhost:27017")
mongo_db = mongo_client["analytics"]

@app.post("/checkout")
def checkout(order: Order):

    # PostgreSQL: Transaction quan trọng
    with pg_db.begin() as conn:

        # Tạo order (cần ACID)
        result = conn.execute("""
            INSERT INTO orders (user_id, total, status)
            VALUES (:user_id, :total, 'confirmed')
            RETURNING id
        """, {"user_id": order.user_id, "total": order.total})

        order_id = result.fetchone()[0]

    # MongoDB: Ghi log sự kiện (nhanh, không quan trọng)
    mongo_db.events.insert_one({
        "event_type": "checkout",
        "user_id": order.user_id,
        "order_id": order_id,
        "timestamp": datetime.now(),
        "metadata": {
            "items_count": len(order.items),
            "device": request.headers.get("User-Agent")
        }
    })

    return {"order_id": order_id}

@app.get("/users")
def get_users():
    users = db.query("SELECT * FROM users")
    return users

from fastapi import Query

@app.get("/users")
def get_users(
    page: int = Query(1, ge=1),
    limit: int = Query(20, ge=1, le=100)
):
    # Tính offset
    offset = (page - 1) * limit

    # Lấy users đã phân trang
    users = db.query(
        "SELECT * FROM users LIMIT %s OFFSET %s",
        (limit, offset)
    )

    # Lấy tổng số (cho UI)
    total = db.query("SELECT COUNT(*) FROM users")[0]

    return {
        "data": users,
        "pagination": {
            "page": page,
            "limit": limit,
            "total": total,
            "pages": (total + limit - 1) // limit,
            "has_next": page * limit < total,
            "has_prev": page > 1
        }
    }

@app.get("/orders")
def get_orders(
    page: int = Query(1, ge=1),
    limit: int = Query(20, ge=1, le=100),
    status: Optional[str] = None,
    user_id: Optional[int] = None,
    min_total: Optional[float] = None
):
    # Xây dựng query động
    query = "SELECT * FROM orders WHERE 1=1"
    params = []

    if status:
        query += " AND status = %s"
        params.append(status)

    if user_id:
        query += " AND user_id = %s"
        params.append(user_id)

    if min_total:
        query += " AND total >= %s"
        params.append(min_total)

    # Thêm phân trang
    query += " LIMIT %s OFFSET %s"
    params.extend([limit, (page - 1) * limit])

    orders = db.query(query, params)
    total = db.query_count(query.replace("SELECT *", "SELECT COUNT(*)"))

    return {
        "data": orders,
        "pagination": {
            "page": page,
            "limit": limit,
            "total": total
        }
    }

from enum import Enum

class SortField(str, Enum):
    created_at = "created_at"
    total = "total"
    status = "status"

@app.get("/orders")
def get_orders(
    page: int = Query(1, ge=1),
    limit: int = Query(20, ge=1, le=100),
    sort: SortField = SortField.created_at,
    order: str = Query("desc", regex="^(asc|desc)$")
):
    # Xác thực và xây dựng query
    order_clause = "DESC" if order == "desc" else "ASC"

    query = f"""
        SELECT * FROM orders
        ORDER BY {sort.value} {order_clause}
        LIMIT %s OFFSET %s
    """

    orders = db.query(query, (limit, (page - 1) * limit))

    return {"data": orders, "pagination": {...}}

from fastapi import FastAPI, Query, HTTPException
from typing import Optional
from enum import Enum


app = FastAPI()

class OrderStatus(str, Enum):
    pending = "pending"
    completed = "completed"
    cancelled = "cancelled"

class SortField(str, Enum):
    created_at = "created_at"
    total = "total"

@app.get("/orders")
def get_orders(
    # Phân trang
    page: int = Query(1, ge=1, description="Page number"),
    limit: int = Query(20, ge=1, le=100, description="Items per page"),

    # Lọc
    status: Optional[OrderStatus] = None,
    user_id: Optional[int] = None,
    min_total: Optional[float] = None,
    max_total: Optional[float] = None,

    # Sắp xếp
    sort: SortField = SortField.created_at,
    order: str = Query("desc", regex="^(asc|desc)$")
):
    """
    Lấy orders với phân trang, lọc, và sắp xếp.

    Example: GET /orders?status=completed&page=2&limit=20&sort=total&order=desc
    """
    # Xây dựng query
    query = "SELECT * FROM orders WHERE 1=1"
    count_query = "SELECT COUNT(*) FROM orders WHERE 1=1"
    params = []

    # Thêm bộ lọc
    if status:
        query += " AND status = %s"
        count_query += " AND status = %s"
        params.append(status.value)

    if user_id:
        query += " AND user_id = %s"
        count_query += " AND user_id = %s"
        params.append(user_id)

    if min_total:
        query += " AND total >= %s"
        count_query += " AND total >= %s"
        params.append(min_total)

    if max_total:
        query += " AND total <= %s"
        count_query += " AND total <= %s"
        params.append(max_total)

    # Thêm sắp xếp
    query += f" ORDER BY {sort.value} {order.upper()}"

    # Thêm phân trang
    offset = (page - 1) * limit
    query += " LIMIT %s OFFSET %s"
    pagination_params = params + [limit, offset]

    # Thực thi queries
    try:
        orders = db.query(query, pagination_params)
        total = db.query(count_query, params)[0]
    except Exception as e:
        raise HTTPException(status_code=500, detail="Database error")

    return {
        "data": orders,
        "pagination": {
            "page": page,
            "limit": limit,
            "total": total,
            "pages": (total + limit - 1) // limit,
            "has_next": page * limit < total,
            "has_prev": page > 1
        },
        "filters": {
            "status": status,
            "user_id": user_id,
            "min_total": min_total,
            "max_total": max_total
        },
        "sort": {
            "field": sort,
            "order": order
        }
    }