vas_task_service.py 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391
  1. # app/services/vas_task_service.py
  2. from datetime import datetime, date, timedelta
  3. from typing import List, Optional
  4. from sqlalchemy.ext.asyncio import AsyncSession
  5. from sqlalchemy import func, text, select, or_, and_, cast, String
  6. from redis.asyncio import Redis
  7. from app.core.logger import logger
  8. from app.utils.search import apply_keyword_search_stmt
  9. from app.utils.pagination import paginate
  10. from app.core.biz_exception import NotFoundError, BizLogicError
  11. from app.models.vas_task import VasTask
  12. from app.models.order import VasOrder
  13. from app.schemas.vas_task import VasTaskCreate, VasTaskUpdate
  14. from app.services.task_handlers import task_processor
  15. class VasTaskService:
  16. @staticmethod
  17. async def create(db: AsyncSession, data: VasTaskCreate) -> VasTask:
  18. rec = VasTask(
  19. **data.dict(),
  20. status="pending",
  21. created_at=datetime.utcnow(),
  22. )
  23. db.add(rec)
  24. await db.commit()
  25. await db.refresh(rec)
  26. logger.info(f"📋 [VAS_TASK] Created task: id={rec.id} order_id={rec.order_id} routing_key={rec.routing_key}")
  27. return rec
  28. @staticmethod
  29. async def pop_vas_task(db: AsyncSession, routing_key: str, cooldown_seconds: int = 60) -> VasTask:
  30. stmt = (
  31. select(VasTask)
  32. .where(VasTask.routing_key == routing_key)
  33. .where(VasTask.status == 'pending')
  34. .where(
  35. or_(
  36. VasTask.attempt_count == 0,
  37. and_(
  38. VasTask.attempt_count > 0,
  39. VasTask.updated_at < (func.utc_timestamp() - text(f"INTERVAL {cooldown_seconds} SECOND"))
  40. )
  41. )
  42. )
  43. .order_by(VasTask.priority.desc(), VasTask.id.asc())
  44. .limit(1)
  45. .with_for_update(skip_locked=True)
  46. )
  47. result = await db.execute(stmt)
  48. task = result.scalar_one_or_none()
  49. if not task:
  50. raise NotFoundError(message="Task not found")
  51. task.status = 'running'
  52. task.attempt_count += 1
  53. task.updated_at = func.utc_timestamp()
  54. await db.commit()
  55. await db.refresh(task)
  56. logger.info(f"🏃 [VAS_TASK] Task popped: id={task.id} routing_key={routing_key} attempt={task.attempt_count}")
  57. return task
  58. @staticmethod
  59. async def get_task_by_order_id(
  60. db: AsyncSession,
  61. order_id: str,
  62. ) -> List[VasTask]:
  63. stmt = (
  64. select(
  65. VasTask,
  66. VasOrder.product_id.label("order_product_id"),
  67. VasOrder.product_name.label("order_product_name"),
  68. VasOrder.user_name.label("order_user_name"),
  69. VasOrder.status.label("order_status"),
  70. VasOrder.final_amount.label("order_final_amount"),
  71. VasOrder.base_currency.label("order_base_currency"),
  72. VasOrder.created_at.label("order_created_at"),
  73. )
  74. .outerjoin(VasOrder, VasTask.order_id == VasOrder.id)
  75. .where(VasTask.order_id == order_id)
  76. .order_by(VasTask.created_at.asc(), VasTask.id.asc())
  77. )
  78. rows = (await db.execute(stmt)).all()
  79. items = []
  80. for row in rows:
  81. task = row[0]
  82. task.product_id = row[1]
  83. task.product_name = row[2]
  84. task.order_user_name = row[3]
  85. task.order_status = row[4]
  86. task.order_final_amount = row[5]
  87. task.order_base_currency = row[6]
  88. task.order_created_at = row[7]
  89. items.append(task)
  90. return items
  91. @staticmethod
  92. async def list_task(
  93. db: AsyncSession,
  94. status: Optional[str] = None,
  95. routing_key: Optional[str] = None,
  96. script_version: Optional[str] = None,
  97. keyword: Optional[str] = None,
  98. product_id: Optional[int] = None,
  99. sort_by: str = "created_at",
  100. sort_order: str = "desc",
  101. page: int = 1,
  102. size: int = 20,
  103. ):
  104. stmt = (
  105. select(
  106. VasTask,
  107. VasOrder.product_id.label("order_product_id"),
  108. VasOrder.product_name.label("order_product_name"),
  109. VasOrder.user_name.label("order_user_name"),
  110. VasOrder.status.label("order_status"),
  111. VasOrder.final_amount.label("order_final_amount"),
  112. VasOrder.base_currency.label("order_base_currency"),
  113. VasOrder.created_at.label("order_created_at"),
  114. )
  115. .outerjoin(VasOrder, VasTask.order_id == VasOrder.id)
  116. )
  117. count_stmt = select(func.count(VasTask.id)).outerjoin(VasOrder, VasTask.order_id == VasOrder.id)
  118. if status and status != "all":
  119. stmt = stmt.where(VasTask.status == status)
  120. count_stmt = count_stmt.where(VasTask.status == status)
  121. if routing_key and routing_key != "all":
  122. stmt = stmt.where(VasTask.routing_key == routing_key)
  123. count_stmt = count_stmt.where(VasTask.routing_key == routing_key)
  124. if script_version and script_version != "all":
  125. stmt = stmt.where(VasTask.script_version == script_version)
  126. count_stmt = count_stmt.where(VasTask.script_version == script_version)
  127. if product_id:
  128. stmt = stmt.where(VasOrder.product_id == product_id)
  129. count_stmt = count_stmt.where(VasOrder.product_id == product_id)
  130. if keyword and keyword.strip():
  131. kw = f"%{keyword.strip()}%"
  132. filter_cond = or_(
  133. cast(VasTask.id, String).ilike(kw),
  134. VasTask.order_id.ilike(kw),
  135. VasTask.routing_key.ilike(kw),
  136. VasOrder.product_name.ilike(kw),
  137. VasOrder.user_name.ilike(kw),
  138. )
  139. stmt = stmt.where(filter_cond)
  140. count_stmt = count_stmt.where(filter_cond)
  141. total = await db.scalar(count_stmt) or 0
  142. # 排序逻辑优化:
  143. # - created_at: 最新入队/创建时间优先 (默认)
  144. # - priority: 优先级最高优先 (紧急任务靠前,同优先级按最早创建时间先进先出 FIFO)
  145. # - updated_at: 最近活跃/更新时间优先
  146. # - id: 任务序列号排序
  147. # - order_id: 关联订单号聚合排序
  148. is_asc = str(sort_order).lower() == "asc"
  149. if sort_by == "priority":
  150. if is_asc:
  151. stmt = stmt.order_by(VasTask.priority.asc(), VasTask.created_at.asc(), VasTask.id.asc())
  152. else:
  153. stmt = stmt.order_by(VasTask.priority.desc(), VasTask.created_at.asc(), VasTask.id.asc())
  154. elif sort_by == "updated_at":
  155. stmt = stmt.order_by(
  156. VasTask.updated_at.asc() if is_asc else VasTask.updated_at.desc(),
  157. VasTask.id.desc()
  158. )
  159. elif sort_by == "id":
  160. stmt = stmt.order_by(
  161. VasTask.id.asc() if is_asc else VasTask.id.desc()
  162. )
  163. elif sort_by == "order_id":
  164. stmt = stmt.order_by(
  165. VasTask.order_id.asc() if is_asc else VasTask.order_id.desc(),
  166. VasTask.id.asc()
  167. )
  168. else: # 默认 created_at
  169. stmt = stmt.order_by(
  170. VasTask.created_at.asc() if is_asc else VasTask.created_at.desc(),
  171. VasTask.id.desc()
  172. )
  173. if page < 1:
  174. page = 1
  175. if size < 1:
  176. size = 20
  177. stmt = stmt.offset((page - 1) * size).limit(size)
  178. rows = (await db.execute(stmt)).all()
  179. items = []
  180. for row in rows:
  181. task = row[0]
  182. task.product_id = row[1]
  183. task.product_name = row[2]
  184. task.order_user_name = row[3]
  185. task.order_status = row[4]
  186. task.order_final_amount = row[5]
  187. task.order_base_currency = row[6]
  188. task.order_created_at = row[7]
  189. items.append(task)
  190. return {
  191. "items": items,
  192. "total": total,
  193. "page": page,
  194. "size": size,
  195. }
  196. @staticmethod
  197. async def get_expiring_tasks(
  198. db: AsyncSession,
  199. threshold_days: int = 3
  200. ) -> List[dict]:
  201. """
  202. 获取即将过期的任务列表
  203. """
  204. now = datetime.utcnow()
  205. threshold_date = now + timedelta(days=threshold_days)
  206. stmt = select(VasTask).where(
  207. VasTask.status == "grabbed",
  208. VasTask.grabbed_history.isnot(None)
  209. )
  210. result = await db.execute(stmt)
  211. tasks = result.scalars().all()
  212. expiring_tasks = []
  213. for task in tasks:
  214. grabbed_history = task.grabbed_history or {}
  215. slot_date_str = grabbed_history.get("slot_date")
  216. if not slot_date_str:
  217. continue
  218. try:
  219. try:
  220. slot_date = datetime.strptime(slot_date_str, "%Y-%m-%d")
  221. except ValueError:
  222. slot_date = datetime.strptime(slot_date_str, "%d/%m/%Y")
  223. if slot_date <= threshold_date:
  224. days_remaining = (slot_date.date() - now.date()).days
  225. expiring_tasks.append({
  226. "task_id": task.id,
  227. "order_id": task.order_id,
  228. "routing_key": task.routing_key,
  229. "slot_date": slot_date_str,
  230. "slot_time": grabbed_history.get("slot_time"),
  231. "days_remaining": days_remaining,
  232. "days_remaining_display": f"{days_remaining} days" if days_remaining > 0 else "Today/Expired",
  233. "status": task.status
  234. })
  235. except (ValueError, TypeError):
  236. continue
  237. expiring_tasks.sort(key=lambda x: x["days_remaining"])
  238. return expiring_tasks
  239. @staticmethod
  240. async def update(db: AsyncSession, id: int, payload: VasTaskUpdate) -> VasTask:
  241. stmt = select(VasTask).where(VasTask.id == id)
  242. result = await db.execute(stmt)
  243. rec = result.scalar_one_or_none()
  244. if not rec:
  245. raise NotFoundError("Task not exist")
  246. old_status = rec.status
  247. if payload.status is not None:
  248. rec.status = payload.status
  249. if payload.grabbed_history is not None:
  250. rec.grabbed_history = payload.grabbed_history
  251. if payload.meta is not None:
  252. rec.meta = payload.meta
  253. await db.commit()
  254. await db.refresh(rec)
  255. logger.info(f"🔄 [VAS_TASK] Updated task {id}: status {old_status} -> {rec.status}")
  256. return rec
  257. @staticmethod
  258. async def get_task_by_id(
  259. db: AsyncSession,
  260. task_id: int,
  261. ) -> VasTask:
  262. stmt = (
  263. select(
  264. VasTask,
  265. VasOrder.product_id.label("order_product_id"),
  266. VasOrder.product_name.label("order_product_name"),
  267. VasOrder.user_name.label("order_user_name"),
  268. VasOrder.status.label("order_status"),
  269. VasOrder.final_amount.label("order_final_amount"),
  270. VasOrder.base_currency.label("order_base_currency"),
  271. VasOrder.created_at.label("order_created_at"),
  272. )
  273. .outerjoin(VasOrder, VasTask.order_id == VasOrder.id)
  274. .where(VasTask.id == task_id)
  275. )
  276. row = (await db.execute(stmt)).first()
  277. if not row:
  278. raise NotFoundError("Task not exist")
  279. task = row[0]
  280. task.product_id = row[1]
  281. task.product_name = row[2]
  282. task.order_user_name = row[3]
  283. task.order_status = row[4]
  284. task.order_final_amount = row[5]
  285. task.order_base_currency = row[6]
  286. task.order_created_at = row[7]
  287. return task
  288. @staticmethod
  289. async def return_to_queue(db: AsyncSession, id: int) -> VasTask:
  290. stmt = select(VasTask).where(VasTask.id == id)
  291. result = await db.execute(stmt)
  292. rec = result.scalar_one_or_none()
  293. if not rec:
  294. raise NotFoundError("Task not exist")
  295. if rec.status in ["completed", "cancelled"]:
  296. raise BizLogicError(f"Cannot return a {rec.status} task to queue")
  297. if rec.order_id:
  298. order_stmt = select(VasOrder).where(VasOrder.id == rec.order_id)
  299. order_result = await db.execute(order_stmt)
  300. order = order_result.scalar_one_or_none()
  301. if order and order.status in ["closed", "refunded"]:
  302. raise BizLogicError("Cannot return task to queue: associated order is closed")
  303. rec.status = "pending"
  304. await db.commit()
  305. await db.refresh(rec)
  306. logger.info(f"🔁 [VAS_TASK] Returned task {id} to queue (status=pending)")
  307. return rec
  308. @staticmethod
  309. async def pause(db: AsyncSession, id: int) -> VasTask:
  310. stmt = select(VasTask).where(VasTask.id == id)
  311. result = await db.execute(stmt)
  312. rec = result.scalar_one_or_none()
  313. if not rec:
  314. raise NotFoundError("Task not exist")
  315. if rec.status == "pause":
  316. return rec
  317. if rec.status in ["completed", "cancelled"]:
  318. raise BizLogicError(f"Cannot pause a {rec.status} task")
  319. rec.status = "pause"
  320. await db.commit()
  321. await db.refresh(rec)
  322. logger.info(f"⏸️ [VAS_TASK] Paused task {id} (status=pause)")
  323. return rec
  324. @staticmethod
  325. async def manual_confirm(db: AsyncSession, id: int, redis_client: Redis) -> VasTask:
  326. stmt = select(VasTask).where(VasTask.id == id)
  327. result = await db.execute(stmt)
  328. task = result.scalar_one_or_none()
  329. if not task:
  330. raise NotFoundError("Task not exist")
  331. task.status = "completed"
  332. order_stmt = select(VasOrder).where(VasOrder.id == task.order_id)
  333. order_result = await db.execute(order_stmt)
  334. order = order_result.scalar_one_or_none()
  335. if not order:
  336. raise NotFoundError("Order not exist")
  337. order.status = "completed"
  338. await task_processor.execute(task.routing_key, db, redis_client, task, order)
  339. await db.commit()
  340. await db.refresh(task)
  341. logger.info(f"✅ [VAS_TASK] Manually confirmed task {id} and order {order.id} as completed")
  342. return task