order.py 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141
  1. from typing import List
  2. from fastapi import APIRouter, Query, Depends
  3. from sqlalchemy.ext.asyncio import AsyncSession
  4. from app.utils.validation_utils import validate_user_inputs
  5. from app.core.redis import get_redis_client
  6. from app.core.database import get_db
  7. from app.core.auth import get_current_user
  8. from redis.asyncio import Redis
  9. from app.utils.response import success
  10. from app.models.user import VasUser
  11. from app.schemas.common import ApiResponse, PageResponse
  12. from app.schemas.order import VasOrderAdjustPrice, VasOrderCreate, VasOrderOut, VasOrderPatchUserInputs
  13. from app.schemas.order_event import VasOrderEventCreate, VasOrderEventOut
  14. from app.services.order_event_service import OrderEventService
  15. from app.services.order_service import OrderService
  16. from app.services.product_service import ProductService
  17. from app.services.schema_service import SchemaService
  18. public_router = APIRouter()
  19. protected_router = APIRouter()
  20. admin_required_router = APIRouter()
  21. @protected_router.post("/vas/order/create", summary="创建订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
  22. async def vas_order_create(
  23. payload: VasOrderCreate,
  24. current_user: VasUser = Depends(get_current_user),
  25. db: AsyncSession = Depends(get_db),
  26. redis_client: Redis = Depends(get_redis_client)
  27. ):
  28. product = await ProductService.get(db, payload.product_id)
  29. # ① 获取产品绑定的 schema
  30. schema = await SchemaService.get(db, product.schema_id)
  31. # ② 校验 user_inputs
  32. validate_user_inputs(
  33. schema_json=schema.schema_json,
  34. user_inputs=payload.user_inputs,
  35. )
  36. created_order = await OrderService.create(db, payload, product, current_user, redis_client)
  37. return success(data=created_order)
  38. @admin_required_router.post("/vas/order/create_by_admin", summary="管理员创建订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
  39. async def vas_order_create_by_admin(
  40. payload: VasOrderCreate,
  41. current_user: VasUser = Depends(get_current_user),
  42. db: AsyncSession = Depends(get_db)
  43. ):
  44. product = await ProductService.get(db, payload.product_id)
  45. # ① 获取产品绑定的 schema
  46. schema = await SchemaService.get(db, product.schema_id)
  47. # ② 校验 user_inputs
  48. validate_user_inputs(
  49. schema_json=schema.schema_json,
  50. user_inputs=payload.user_inputs,
  51. )
  52. created_order = await OrderService.create_by_admin(db, payload, product, current_user)
  53. return success(data=created_order)
  54. @admin_required_router.post("/vas/order/adjust-price", summary="管理员调整订单价格", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
  55. async def vas_order_adjust_price(
  56. order_id: str,
  57. payload: VasOrderAdjustPrice,
  58. db: AsyncSession = Depends(get_db),
  59. current_user: VasUser = Depends(get_current_user)
  60. ):
  61. order = await OrderService.adjust_order_price(db, order_id, payload)
  62. return success(data=order)
  63. @admin_required_router.get("/vas/order/detail", summary="查询订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
  64. async def vas_order_create(
  65. order_id: str,
  66. db: AsyncSession = Depends(get_db),
  67. ):
  68. order = await OrderService.get(db, order_id)
  69. return success(data=order)
  70. @admin_required_router.post("/vas/order/patch_user_inputs", summary="更新订单的用户信息", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
  71. async def vas_order_patch_user_inputs(
  72. order_id: str,
  73. payload: VasOrderPatchUserInputs,
  74. db: AsyncSession = Depends(get_db),
  75. ):
  76. order = await OrderService.patch_user_inputs(db, order_id, payload)
  77. return success(data=order)
  78. @protected_router.get("/vas/order/list_by_user", summary="查看所有订单", tags=["textskin"], response_model=ApiResponse[PageResponse[VasOrderOut]])
  79. async def vas_order_list_by_user(
  80. page: int = Query(0, description="第几页"),
  81. size: int = Query(10, description="分页大小"),
  82. keyword: str = Query("", description="查询条件"),
  83. current_user: VasUser = Depends(get_current_user),
  84. db: AsyncSession = Depends(get_db)
  85. ):
  86. orders = await OrderService.list_by_user(db, current_user.id, page, size, keyword)
  87. return success(data=orders)
  88. @protected_router.get("/vas/order/list_all", summary="查看所有订单", tags=["textskin"], response_model=ApiResponse[PageResponse[VasOrderOut]])
  89. async def vas_order_list_all(
  90. page: int = Query(0, description="第几页"),
  91. size: int = Query(10, description="分页大小"),
  92. keyword: str = Query("", description="查询条件"),
  93. db: AsyncSession = Depends(get_db)
  94. ):
  95. orders = await OrderService.list_all(db, page, size, keyword)
  96. return success(data=orders)
  97. @admin_required_router.post("/vas/order/cancel", summary="取消订单", tags=["textskin"], response_model=ApiResponse[VasOrderOut])
  98. async def vas_order_cancel(
  99. order_id: str,
  100. current_user: VasUser = Depends(get_current_user),
  101. db: AsyncSession = Depends(get_db),
  102. redis_client: Redis = Depends(get_redis_client)
  103. ):
  104. cancelled_order = await OrderService.cancel(db, order_id)
  105. return success(data=cancelled_order)
  106. @admin_required_router.post("/vas/order-event/create", summary="创建订单事件", tags=["textskin"], response_model=ApiResponse[VasOrderEventOut])
  107. async def vas_order_event_create(
  108. event_data: VasOrderEventCreate,
  109. db: AsyncSession = Depends(get_db)
  110. ):
  111. obj = await OrderEventService.create(db, event_data)
  112. return success(data=obj)
  113. @protected_router.get("/vas/order-event/list", summary="获取订单的所有事件", tags=["textskin"], response_model=ApiResponse[List[VasOrderEventOut]])
  114. async def vas_list_order_events_by_order(
  115. order_id: str,
  116. db: AsyncSession = Depends(get_db)
  117. ):
  118. events = await OrderEventService.get_by_order_id(db, order_id)
  119. return success(data=events)