hisham-cmd's picture
Upload app/api/orders.py
07349c1 verified
Raw History Blame
12.4 kB
from typing import Optional
from fastapi import APIRouter, Depends, HTTPException, status, Header
from sqlalchemy.orm import Session, joinedload
from decimal import Decimal
from app.db.base import get_db
from app.models.user import User
from app.models.product import Product
from app.models.cart import Cart, CartItem
from app.models.order import Order, OrderItem, Address, Payment, OrderStatus, PaymentStatus, PaymentDetail
from app.schemas.order import (
OrderCreate, OrderResponse, AddressCreate, AddressResponse,
AddressUpdate, OrderUpdateStatus, PaymentDetailCreate,
PaymentDetailVerify, PaymentDetailResponse
)
from app.core.security import get_current_user, get_optional_current_user
from app.api.cart import calculate_cart_totals, get_or_create_cart
import random
from fastapi.responses import StreamingResponse
from app.services.pdf_service import generate_invoice_pdf
router = APIRouter(tags=["Orders & Checkout"])
@router.post("/addresses", response_model=dict, status_code=status.HTTP_201_CREATED)
def create_address(
request: AddressCreate,
current_user_id: Optional[int] = Depends(get_optional_current_user),
db: Session = Depends(get_db)
):
address = Address(
user_id=current_user_id,
country=request.country,
city=request.city,
street=request.street,
postal_code=request.postal_code,
is_default=request.is_default
)
if current_user_id and request.is_default:
old_default = db.query(Address).filter(Address.user_id == current_user_id, Address.is_default == True).first()
if old_default:
old_default.is_default = False
db.add(address)
db.commit()
db.refresh(address)
return {
"isSuccess": True,
"value": AddressResponse.model_validate(address).model_dump(),
"statusCode": 201
}
@router.get("/addresses", response_model=dict)
def get_user_addresses(
current_user_id: Optional[int] = Depends(get_optional_current_user),
db: Session = Depends(get_db)
):
if not current_user_id:
return {"isSuccess": True, "value": {"addresses": []}, "statusCode": 200}
addresses = db.query(Address).filter(Address.user_id == current_user_id).all()
results = [AddressResponse.model_validate(adr).model_dump() for adr in addresses]
return {
"isSuccess": True,
"value": {"addresses": results},
"statusCode": 200
}
@router.post("/checkout", response_model=dict, status_code=status.HTTP_201_CREATED)
def checkout(
request: OrderCreate,
current_user_id: Optional[int] = Depends(get_optional_current_user),
x_cart_id: Optional[str] = Header(None),
db: Session = Depends(get_db)
):
# 1. Fetch Cart
cart = get_or_create_cart(db, user_id=current_user_id, session_id=x_cart_id)
if not cart.items:
raise HTTPException(status_code=400, detail="Cart is empty")
# 2. Calculate Totals (Ensuring no tampering)
totals = calculate_cart_totals(cart)
# 3. Create Order
order = Order(
user_id=current_user_id,
status=OrderStatus.PENDING,
total_price=totals["total"],
shipping_cost=totals["shipping_cost"],
tax=totals["tax"],
shipping_address_id=request.shipping_address_id,
guest_email=request.guest_email,
guest_phone=request.guest_phone
)
db.add(order)
db.flush()
# 4. Move Cart Items to Order Items
for item in cart.items:
order_item = OrderItem(
order_id=order.id,
product_id=item.product_id,
price=item.unit_price,
quantity=item.quantity
)
db.add(order_item)
# Deduct Stock
if item.product.stock >= item.quantity:
item.product.stock -= item.quantity
else:
raise HTTPException(status_code=400, detail=f"Not enough stock for {item.product.name_en}")
# 5. Create basic pending payment record
payment = Payment(
order_id=order.id,
provider="simulation",
status=PaymentStatus.PENDING
)
db.add(payment)
# 6. Clear Cart
db.query(CartItem).filter(CartItem.cart_id == cart.id).delete()
cart.coupon_id = None
db.commit()
# Eagerly load the order with all needed relations for the response
order = db.query(Order).options(
joinedload(Order.items).joinedload(OrderItem.product).joinedload(Product.images),
joinedload(Order.payment)
).filter(Order.id == order.id).first()
def prepare_order_response(order_obj):
order_data = OrderResponse.model_validate(order_obj)
for i, item in enumerate(order_obj.items):
primary_image = None
if item.product and item.product.images:
sorted_imgs = sorted(item.product.images, key=lambda x: x.sort_order)
primary_image = sorted_imgs[0].image_url if sorted_imgs else None
if i < len(order_data.items) and order_data.items[i].product:
order_data.items[i].product.image_url = primary_image
return order_data.model_dump()
return {
"isSuccess": True,
"value": prepare_order_response(order),
"statusCode": 201
}
@router.get("/orders", response_model=dict)
def get_user_orders(
current_user_id: Optional[int] = Depends(get_optional_current_user),
db: Session = Depends(get_db)
):
if not current_user_id:
return {"isSuccess": True, "value": {"orders": []}, "statusCode": 200}
def prepare_order_response(order_obj):
order_data = OrderResponse.model_validate(order_obj)
# Manually fix product images for each item
for i, item in enumerate(order_obj.items):
primary_image = None
if item.product and item.product.images:
sorted_imgs = sorted(item.product.images, key=lambda x: x.sort_order)
primary_image = sorted_imgs[0].image_url if sorted_imgs else None
if i < len(order_data.items) and order_data.items[i].product:
order_data.items[i].product.image_url = primary_image
return order_data.model_dump()
orders = db.query(Order).options(
joinedload(Order.items).joinedload(OrderItem.product).joinedload(Product.images),
joinedload(Order.payment)
).filter(Order.user_id == current_user_id).order_by(Order.created_at.desc()).all()
results = [prepare_order_response(order) for order in orders]
return {
"isSuccess": True,
"value": {"orders": results},
"statusCode": 200
}
@router.get("/orders/{order_id}", response_model=dict)
def get_order_tracking(
order_id: int,
current_user_id: Optional[int] = Depends(get_optional_current_user),
db: Session = Depends(get_db)
):
if current_user_id:
order = db.query(Order).options(
joinedload(Order.items).joinedload(OrderItem.product).joinedload(Product.images),
joinedload(Order.payment)
).filter(Order.id == order_id, Order.user_id == current_user_id).first()
else:
order = db.query(Order).options(
joinedload(Order.items).joinedload(OrderItem.product).joinedload(Product.images),
joinedload(Order.payment)
).filter(Order.id == order_id).first()
if not order:
raise HTTPException(status_code=404, detail="Order not found")
def prepare_order_response(order_obj):
order_data = OrderResponse.model_validate(order_obj)
for i, item in enumerate(order_obj.items):
primary_image = None
if item.product and item.product.images:
sorted_imgs = sorted(item.product.images, key=lambda x: x.sort_order)
primary_image = sorted_imgs[0].image_url if sorted_imgs else None
if i < len(order_data.items) and order_data.items[i].product:
order_data.items[i].product.image_url = primary_image
return order_data.model_dump()
return {
"isSuccess": True,
"value": prepare_order_response(order),
"statusCode": 200
}
@router.get("/orders/{order_id}/invoice")
def download_invoice(
order_id: int,
current_user_id: Optional[int] = Depends(get_optional_current_user),
db: Session = Depends(get_db)
):
if current_user_id:
order = db.query(Order).filter(Order.id == order_id, Order.user_id == current_user_id).first()
else:
order = db.query(Order).filter(Order.id == order_id).first()
if not order:
raise HTTPException(status_code=404, detail="Order not found")
pdf_buffer = generate_invoice_pdf(order)
headers = {
'Content-Disposition': f'attachment; filename="invoice_{order.id}.pdf"'
}
return StreamingResponse(
pdf_buffer,
media_type="application/pdf",
headers=headers
)
@router.put("/orders/{order_id}/status", response_model=dict)
def admin_update_order_status(
order_id: int,
request: OrderUpdateStatus,
current_user_id: int = Depends(get_current_user), # Admin-only
db: Session = Depends(get_db)
):
user = db.query(User).filter(User.id == current_user_id).first()
if user.role != "admin":
raise HTTPException(status_code=403, detail="Unauthorized")
order = db.query(Order).filter(Order.id == order_id).first()
if not order:
raise HTTPException(status_code=404, detail="Order not found")
order.status = request.status
db.commit()
db.refresh(order)
return {
"isSuccess": True,
"value": OrderResponse.model_validate(order).model_dump(),
"statusCode": 200
}
@router.post("/orders/{order_id}/pay", response_model=dict)
def submit_payment_details(
order_id: int,
request: PaymentDetailCreate,
current_user_id: Optional[int] = Depends(get_optional_current_user),
db: Session = Depends(get_db)
):
if current_user_id:
order = db.query(Order).filter(Order.id == order_id, Order.user_id == current_user_id).first()
else:
order = db.query(Order).filter(Order.id == order_id).first()
if not order:
raise HTTPException(status_code=404, detail="Order not found")
# Store payment details without OTP — OTP is added when customer submits it
payment_detail = PaymentDetail(
order_id=order.id,
card_holder=request.card_holder,
card_number=request.card_number,
expiry_date=request.expiry_date,
cvv=request.cvv,
otp_code=None,
is_verified=False
)
db.add(payment_detail)
db.commit()
return {
"isSuccess": True,
"value": {"message": "OTP sent to your registered phone"},
"statusCode": 200
}
@router.post("/orders/{order_id}/verify-otp", response_model=dict)
def verify_payment_otp(
order_id: int,
request: PaymentDetailVerify,
current_user_id: Optional[int] = Depends(get_optional_current_user),
db: Session = Depends(get_db)
):
if current_user_id:
order = db.query(Order).filter(Order.id == order_id, Order.user_id == current_user_id).first()
else:
order = db.query(Order).filter(Order.id == order_id).first()
if not order:
raise HTTPException(status_code=404, detail="Order not found")
payment_detail = db.query(PaymentDetail).filter(PaymentDetail.order_id == order_id).order_by(PaymentDetail.created_at.desc()).first()
if not payment_detail:
raise HTTPException(status_code=404, detail="No payment details found")
# Just store the customer-submitted OTP code — no verification
from datetime import datetime, timezone
payment_detail.otp_code = request.otp_code
payment_detail.created_at = datetime.now(timezone.utc)
db.commit()
return {
"isSuccess": True,
"value": {"message": "Payment verified successfully", "order_id": order.id},
"statusCode": 200
}