from fastapi import APIRouter, HTTPException, Depends, Request, UploadFile, File, Form from fastapi.concurrency import run_in_threadpool from pydantic import BaseModel, Field from typing import List, Optional import traceback from utils.auth_helper import requires_permission, assert_actor_match, get_current_actor_required, require_user from utils.turnstile_helper import verify_turnstile from model.order_model import OrderModel from utils.ai_visual_helper import search_image_file router = APIRouter() class CreateOrderItemPayload(BaseModel): skuNumber: str quantity: int = 1 description: Optional[str] = None grossWeight: Optional[str] = None width: Optional[str] = None height: Optional[str] = None length: Optional[str] = None saleUrl: Optional[str] = None class CreateOrderCustomerPayload(BaseModel): name: str phone: Optional[str] = None address1: Optional[str] = None address2: Optional[str] = None city: Optional[str] = None state: Optional[str] = None postalCode: Optional[str] = None country: Optional[str] = None taxNumber: Optional[str] = None class CreateOrderRequest(BaseModel): orderNumber: str channelType: str shippingPartner: Optional[str] = None shipAddress: Optional[str] = None barcode: Optional[str] = None labelUrl: Optional[str] = None sellerAddress: Optional[str] = None customer: CreateOrderCustomerPayload weight: Optional[str] = None length: Optional[str] = None width: Optional[str] = None height: Optional[str] = None chargeableWeight: Optional[str] = None items: List[CreateOrderItemPayload] class AddressPayload(BaseModel): street: Optional[str] = None city: Optional[str] = None state: Optional[str] = None country: Optional[str] = None zipCode: Optional[str] = None class CustomerPayload(BaseModel): name: Optional[str] = None phone: Optional[str] = None email: Optional[str] = None address: Optional[AddressPayload] = None class OrderItemPayload(BaseModel): productId: str productName: Optional[str] = "" style: str quantity: int price: float = 0 size: str design: str shipping: float = 0 tax: float = 0 class UpdateOrderRequest(BaseModel): customer: Optional[CustomerPayload] = None items: Optional[List[OrderItemPayload]] = None class PayOrdersRequest(BaseModel): orderIds: List[str] = Field(default_factory=list) id_khach_hang: str class AdminUpdateOrderStatusRequest(BaseModel): status: str trackingNumber: Optional[str] = None trackingLink: Optional[str] = None actorId: str class AdminBulkUpdateOrderStatusRequest(BaseModel): docIds: List[str] = Field(default_factory=list) status: str trackingNumber: Optional[str] = None trackingLink: Optional[str] = None actorId: str class AdminSyncShippedOrdersRequest(BaseModel): docIds: List[str] = Field(default_factory=list) limit: int = 100 class BulkImportOrdersRequest(BaseModel): orders: List[CreateOrderRequest] class FbaFbtOrderItem(BaseModel): orderNumber: str customer: CreateOrderCustomerPayload items: List[CreateOrderItemPayload] class FbaFbtBulkImportRequest(BaseModel): orders: List[FbaFbtOrderItem] class SetOfferItemPayload(BaseModel): index: int = 0 price: float = 0.0 shipping: float = 0.0 tax: float = 0.0 class SetOfferRequest(BaseModel): items: List[SetOfferItemPayload] actorId: str class RespondOfferRequest(BaseModel): action: str id_khach_hang: Optional[str] = None class AdminMarkDeliveredRequest(BaseModel): orderIds: List[str] = Field(default_factory=list) actorId: str class AdminCancelOrderRequest(BaseModel): cancel_reason: str = "" class UserCancelOrderRequest(BaseModel): cancel_reason: Optional[str] = "" @router.post("/create") async def create_order_ops( body: CreateOrderRequest, actor: dict = Depends(require_user()), ): try: data = body.model_dump() result = await run_in_threadpool(OrderModel.create_order, data, actor) result.pop("_id", None) return {"success": True, "data": result} except ValueError as exc: raise HTTPException(status_code=400, detail=str(exc)) except Exception as exc: raise HTTPException(status_code=500, detail=f"Failed to create order: {exc}") @router.post("/import") async def import_orders_bulk( body: BulkImportOrdersRequest, actor: dict = Depends(require_user()), ): results = [] for order in body.orders: try: data = order.model_dump() result = await run_in_threadpool(OrderModel.create_order, data, actor) result.pop("_id", None) results.append({"success": True, "orderNumber": order.orderNumber}) except Exception as exc: results.append({"success": False, "orderNumber": order.orderNumber, "error": str(exc)}) success_count = sum(1 for r in results if r["success"]) return { "success": True, "total": len(results), "successCount": success_count, "failedCount": len(results) - success_count, "results": results, } @router.get("/") async def get_all_orders( id_khach_hang: str, keyword: Optional[str] = None, status: Optional[str] = "All", dateFrom: Optional[str] = None, dateTo: Optional[str] = None, page: int = 1, pageSize: int = 5, ): try: result = OrderModel.get_all_orders( id_khach_hang=id_khach_hang, keyword=keyword, status=status, dateFrom=dateFrom, dateTo=dateTo, page=page, page_size=pageSize, ) return {"success": True, **result} except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception: raise HTTPException(status_code=500, detail="Failed to fetch orders") @router.get("/admin/search", dependencies=[Depends(requires_permission("order_search"))]) async def admin_get_all_orders( keyword: Optional[str] = None, status: Optional[str] = "All", dateFrom: Optional[str] = None, dateTo: Optional[str] = None, page: int = 1, pageSize: int = 10, ): try: result = OrderModel.admin_get_all_orders( keyword=keyword, status=status, dateFrom=dateFrom, dateTo=dateTo, page=page, page_size=pageSize, ) return {"success": True, **result} except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception: raise HTTPException(status_code=500, detail="Failed to fetch admin orders") @router.post("/admin/search-by-image", dependencies=[Depends(requires_permission("order_search"))]) async def admin_search_orders_by_image( image: Optional[UploadFile] = File(None), keyword: Optional[str] = Form(None), status: Optional[str] = Form("All"), fromDate: Optional[str] = Form(None), toDate: Optional[str] = Form(None), page: int = Form(1), pageSize: int = Form(10), ): try: image_received = False ai_matches = [] if image and image.filename: image_received = True content_type = str(image.content_type or "").lower() if not content_type.startswith("image/"): raise HTTPException(status_code=400, detail="Please upload a valid image file.") image_bytes = await image.read() if len(image_bytes) > 5 * 1024 * 1024: raise HTTPException(status_code=400, detail="Image size must be under 5MB.") ai_response = await run_in_threadpool( search_image_file, image_bytes, image.filename, image.content_type or "image/png", ) ai_matches = ai_response.get("results", []) # Có upload ảnh thì phải tìm order theo ảnh AI match result = OrderModel.admin_get_orders_by_visual_matches( matches=ai_matches, keyword=keyword, status=status, dateFrom=fromDate, dateTo=toDate, page=page, page_size=pageSize, ) else: # Không upload ảnh thì vẫn chỉ lấy Processing / Printing / Shipped result = OrderModel.admin_get_image_search_orders( keyword=keyword, status=status, dateFrom=fromDate, dateTo=toDate, page=page, page_size=pageSize, ) return { "success": True, "imageReceived": image_received, "aiMatches": ai_matches, **result, } except HTTPException: raise except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception: traceback.print_exc() raise HTTPException(status_code=500, detail="Failed to search admin orders by image") @router.get("/admin/dashboard-summary", dependencies=[Depends(requires_permission("view_dashboard"))]) async def admin_get_dashboard_summary( dateFrom: Optional[str] = None, dateTo: Optional[str] = None, salesPage: int = 1, salesPageSize: int = 15, salesSortBy: str = "revenue", salesSortOrder: str = "desc", ): try: data = OrderModel.admin_get_dashboard_summary( dateFrom=dateFrom, dateTo=dateTo, salesPage=salesPage, salesPageSize=salesPageSize, salesSortBy=salesSortBy, salesSortOrder=salesSortOrder, ) return {"success": True, "data": data} except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception: raise HTTPException(status_code=500, detail="Failed to fetch dashboard summary") @router.put("/admin/batch-status", dependencies=[Depends(verify_turnstile)]) async def admin_batch_update_order_status( req: AdminBulkUpdateOrderStatusRequest, current_user=Depends(requires_permission("order_operations")) ): try: actor_id = current_user["id"] actor_name = current_user.get("name", "") assert_actor_match(current_user, req.actorId) data = OrderModel.admin_batch_update_order_status( doc_ids=req.docIds, new_status=req.status, tracking_number=req.trackingNumber, tracking_link=req.trackingLink, ) return { "success": True, "data": data, "message": f"Updated {data['updatedCount']} orders to {req.status}", "actedBy": { "id": actor_id, "name": actor_name, } } except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to update admin batch order status: {str(e)}") @router.post("/admin/sync-delivered", dependencies=[Depends(verify_turnstile)]) async def admin_sync_shipped_orders_to_delivered( req: AdminSyncShippedOrdersRequest, current_user=Depends(requires_permission("order_operations")) ): try: limit = max(int(req.limit or 0), 1) data = await run_in_threadpool( OrderModel.sync_shipped_orders_to_delivered, limit, req.docIds or None, ) return { "success": True, "data": data, "message": f"Checked {data['checked']} shipped orders, updated {data['updated']} delivered orders", "actedBy": { "id": current_user["id"], "name": current_user.get("name", "") } } except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to sync delivered orders: {str(e)}") @router.patch("/admin/mark-delivered", dependencies=[Depends(verify_turnstile)]) async def admin_mark_orders_as_delivered( req: AdminMarkDeliveredRequest, current_user=Depends(requires_permission("order_operations")) ): try: actor_id = current_user["id"] actor_name = current_user.get("name", "") assert_actor_match(current_user, req.actorId) data = OrderModel.admin_mark_orders_as_delivered(req.orderIds) return { "success": True, **data, "actedBy": { "id": actor_id, "name": actor_name, } } except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to mark orders as delivered: {str(e)}") @router.put("/admin/{identifier}/status", dependencies=[Depends(verify_turnstile)]) async def admin_update_order_status( identifier: str, req: AdminUpdateOrderStatusRequest, current_user=Depends(requires_permission("order_operations")) ): try: actor_id = current_user["id"] actor_name = current_user.get("name", "") assert_actor_match(current_user, req.actorId) data = OrderModel.admin_update_order_status( identifier=identifier, new_status=req.status, tracking_number=req.trackingNumber, tracking_link=req.trackingLink, ) return { "success": True, "data": data, "message": f"Order {identifier} updated to {req.status}", "actedBy": { "id": actor_id, "name": actor_name } } except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to update admin order status: {str(e)}") @router.post("/admin/{identifier}/cancel", dependencies=[Depends(verify_turnstile)]) async def admin_cancel_order( identifier: str, request: Request, body: AdminCancelOrderRequest = AdminCancelOrderRequest(), current_user=Depends(requires_permission("order_operations")) ): try: actor_id = current_user["id"] actor_name = current_user.get("name", "") assert_actor_match(current_user, request.headers.get("x-actor-id")) result = OrderModel.admin_cancel_order( identifier=identifier, admin_id=actor_id, admin_name=actor_name, cancel_reason=body.cancel_reason or "", ) return { "success": True, "data": result["order"], "refundAmount": result["refundAmount"], "refundTxId": result["refundTxId"], "message": f"Order {identifier} was cancelled and refunded successfully", "actedBy": { "id": actor_id, "name": actor_name } } except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to cancel admin order: {str(e)}") @router.get("/admin/fba-fbt", dependencies=[Depends(requires_permission("order_search"))]) async def admin_get_fba_fbt_orders( keyword: Optional[str] = None, status: Optional[str] = "All", dateFrom: Optional[str] = None, dateTo: Optional[str] = None, page: int = 1, pageSize: int = 10, ): try: result = OrderModel.admin_get_fba_fbt_orders( keyword=keyword, status=status, dateFrom=dateFrom, dateTo=dateTo, page=page, page_size=pageSize, ) return {"success": True, **result} except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception: raise HTTPException(status_code=500, detail="Failed to fetch FBA&FBT orders") @router.post("/admin/{identifier}/set-offer", dependencies=[Depends(verify_turnstile)]) async def admin_set_offer( identifier: str, body: SetOfferRequest, current_user=Depends(requires_permission("order_operations")), ): try: actor_id = current_user["id"] actor_name = current_user.get("name", "") assert_actor_match(current_user, body.actorId) offer_items = [item.model_dump() for item in body.items] data = await run_in_threadpool( OrderModel.admin_set_offer, identifier, offer_items, actor_id, actor_name ) return {"success": True, "data": data, "message": "Đã gửi giá offer thành công"} except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to set offer: {str(e)}") @router.get("/admin/fba-fbt/{identifier}", dependencies=[Depends(requires_permission("order_search"))]) async def admin_get_fba_fbt_order_detail(identifier: str): try: data = await run_in_threadpool(OrderModel.admin_get_fba_fbt_order_detail, identifier) return {"success": True, "data": data} except ValueError as e: raise HTTPException(status_code=404, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to fetch FBA&FBT order detail: {str(e)}") @router.get("/admin/{identifier}", dependencies=[Depends(requires_permission("order_search"))]) async def admin_get_order_detail(identifier: str): try: data = OrderModel.admin_get_order_detail(identifier) return {"success": True, "data": data} except ValueError as e: raise HTTPException(status_code=404, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to fetch admin order detail: {str(e)}") @router.get("/my/detail/{order_id}") async def get_my_order_detail( order_id: str, actor: dict = Depends(require_user()), ): try: actor_id = str(actor.get("id") or "") data = await run_in_threadpool(OrderModel.get_my_order_detail, order_id, actor_id) return {"success": True, "data": data} except ValueError as e: raise HTTPException(status_code=404, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to fetch order: {str(e)}") @router.get("/my") async def get_my_orders( keyword: Optional[str] = None, status: Optional[str] = None, channel: Optional[str] = None, dateRange: Optional[str] = "7", page: int = 1, pageSize: int = 10, actor: dict = Depends(require_user()), ): try: actor_id = str(actor.get("id") or "") result = await run_in_threadpool( OrderModel.get_my_orders, actor_id=actor_id, keyword=keyword, status=status, channel=channel, date_range=dateRange, page=page, page_size=pageSize, ) return {"success": True, **result} except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to fetch orders: {str(e)}") @router.post("/fba-fbt/import") async def fba_fbt_import_orders( body: FbaFbtBulkImportRequest, actor: dict = Depends(require_user()), ): results = [] for order in body.orders: try: data = order.model_dump() await run_in_threadpool(OrderModel.create_fba_fbt_order, data, actor) results.append({"success": True, "orderNumber": order.orderNumber}) except Exception as exc: results.append({"success": False, "orderNumber": order.orderNumber, "error": str(exc)}) success_count = sum(1 for r in results if r["success"]) return { "success": True, "total": len(results), "successCount": success_count, "failedCount": len(results) - success_count, "results": results, } @router.get("/fba-fbt/my") async def get_my_fba_fbt_orders( keyword: Optional[str] = None, status: Optional[str] = None, page: int = 1, pageSize: int = 10, actor: dict = Depends(require_user()), ): try: actor_id = str(actor.get("id") or "") result = await run_in_threadpool( OrderModel.get_my_fba_fbt_orders, actor_id=actor_id, keyword=keyword, status=status, page=page, page_size=pageSize, ) return {"success": True, **result} except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to fetch FBA&FBT orders: {str(e)}") @router.get("/fba-fbt/my/detail/{order_id}") async def get_my_fba_fbt_order_detail( order_id: str, actor: dict = Depends(require_user()), ): try: actor_id = str(actor.get("id") or "") data = await run_in_threadpool(OrderModel.get_my_fba_fbt_order_detail, order_id, actor_id) return {"success": True, "data": data} except ValueError as e: raise HTTPException(status_code=404, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to fetch order: {str(e)}") @router.post("/fba-fbt/{order_id}/respond-offer") async def fba_fbt_respond_offer( order_id: str, body: RespondOfferRequest, actor: dict = Depends(require_user()), ): try: actor_id = str(actor.get("id") or "") id_khach_hang = body.id_khach_hang or actor_id data = await run_in_threadpool( OrderModel.user_respond_offer, order_id, id_khach_hang, body.action ) return {"success": True, "data": data} except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to respond offer: {str(e)}") @router.post("/fba-fbt/{order_id}/approve-and-pay", dependencies=[Depends(verify_turnstile)]) async def fba_fbt_approve_and_pay( order_id: str, body: RespondOfferRequest, actor: dict = Depends(require_user()), ): try: actor_id = str(actor.get("id") or "") id_khach_hang = body.id_khach_hang or actor_id order = await run_in_threadpool(OrderModel.get_my_fba_fbt_order_detail, order_id, id_khach_hang) if order.get("status") == "Offer": await run_in_threadpool(OrderModel.user_respond_offer, order_id, id_khach_hang, "approve") elif order.get("status") != "Unpaid": raise ValueError(f"Không thể thanh toán đơn có trạng thái '{order.get('status')}'") result = await run_in_threadpool(OrderModel.pay_orders, [order_id], id_khach_hang) return { "success": True, "paidCount": result["paidCount"], "totalAmount": result["totalAmount"], "message": f"Thanh toán thành công ${result['totalAmount']:.2f}", } except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to approve and pay: {str(e)}") @router.get("/{order_id}") async def get_order_detail(order_id: str, id_khach_hang: str): try: data = OrderModel.get_order_detail(order_id, id_khach_hang) return {"success": True, "data": data} except ValueError as e: raise HTTPException(status_code=404, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to fetch order detail: {str(e)}") @router.put("/{order_id}", dependencies=[Depends(verify_turnstile)]) async def update_order(order_id: str, id_khach_hang: str, req: UpdateOrderRequest): try: update_data = req.model_dump(exclude_unset=True, exclude_none=True) data = OrderModel.update_order(order_id, id_khach_hang, update_data) return { "success": True, "data": data, "message": "Order updated successfully", } except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception: raise HTTPException(status_code=500, detail="Failed to update order") @router.post("/{order_id}/cancel", dependencies=[Depends(verify_turnstile)]) async def cancel_order(order_id: str, id_khach_hang: str, body: UserCancelOrderRequest = UserCancelOrderRequest()): try: result = OrderModel.cancel_order(order_id, id_khach_hang, cancel_reason=body.cancel_reason or "") refund_amount = float(result.get("refundAmount", 0) or 0) if refund_amount > 0: message = ( f"Order {order_id} has been cancelled and " f"${refund_amount:.2f} has been refunded to your balance" ) else: message = f"Order {order_id} has been cancelled" return { "success": True, "data": result, "refundAmount": refund_amount, "refundTxId": result.get("refundTxId", ""), "message": message, } except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to cancel order: {str(e)}") @router.post("/quote") async def quote_orders(req: PayOrdersRequest): try: if not req.orderIds: raise ValueError("No orders selected for payment") result = OrderModel.quote_orders(req.orderIds, req.id_khach_hang) return { "success": True, "data": result, } except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to quote orders: {str(e)}") @router.post("/pay", dependencies=[Depends(verify_turnstile)]) async def pay_orders(req: PayOrdersRequest): try: if not req.orderIds: raise ValueError("No orders selected for payment") result = OrderModel.pay_orders(req.orderIds, req.id_khach_hang) response = { "success": True, "paidCount": result["paidCount"], "totalAmount": result["totalAmount"], "message": f"Successfully paid {result['paidCount']} orders totaling ${result['totalAmount']:.2f}", } if "tierCurrent" in result: response["tierCurrent"] = result["tierCurrent"] return response except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: traceback.print_exc() raise HTTPException(status_code=500, detail=f"Failed to pay orders: {str(e)}")