vas_task_service.py 8.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257
  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_
  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 = select(VasTask).where(
  64. VasTask.order_id == order_id
  65. )
  66. result = await db.execute(stmt)
  67. return result.scalars().all()
  68. @staticmethod
  69. async def list_task(
  70. db: AsyncSession,
  71. status: Optional[str] = None,
  72. routing_key: Optional[str] = None,
  73. script_version: Optional[str] = None,
  74. keyword: Optional[str] = None,
  75. page: int = 0,
  76. size: int = 10,
  77. ):
  78. stmt = select(VasTask)
  79. if status:
  80. stmt = stmt.where(VasTask.status == status)
  81. if routing_key:
  82. stmt = stmt.where(VasTask.routing_key == routing_key)
  83. if script_version:
  84. stmt = stmt.where(VasTask.script_version == script_version)
  85. stmt = apply_keyword_search_stmt(
  86. stmt=stmt,
  87. model=VasTask,
  88. keyword=keyword,
  89. fields=["id", "order_id", "routing_key", "user_inputs", "config", "meta", "grabbed_history"],
  90. ).order_by(VasTask.created_at.desc())
  91. return await paginate(db, stmt, page, size)
  92. @staticmethod
  93. async def get_expiring_tasks(
  94. db: AsyncSession,
  95. threshold_days: int = 3
  96. ) -> List[dict]:
  97. """
  98. 获取即将过期的任务列表
  99. """
  100. now = datetime.utcnow()
  101. threshold_date = now + timedelta(days=threshold_days)
  102. stmt = select(VasTask).where(
  103. VasTask.status == "grabbed",
  104. VasTask.grabbed_history.isnot(None)
  105. )
  106. result = await db.execute(stmt)
  107. tasks = result.scalars().all()
  108. expiring_tasks = []
  109. for task in tasks:
  110. grabbed_history = task.grabbed_history or {}
  111. slot_date_str = grabbed_history.get("slot_date")
  112. if not slot_date_str:
  113. continue
  114. try:
  115. try:
  116. slot_date = datetime.strptime(slot_date_str, "%Y-%m-%d")
  117. except ValueError:
  118. slot_date = datetime.strptime(slot_date_str, "%d/%m/%Y")
  119. if slot_date <= threshold_date:
  120. days_remaining = (slot_date.date() - now.date()).days
  121. expiring_tasks.append({
  122. "task_id": task.id,
  123. "order_id": task.order_id,
  124. "routing_key": task.routing_key,
  125. "slot_date": slot_date_str,
  126. "slot_time": grabbed_history.get("slot_time"),
  127. "days_remaining": days_remaining,
  128. "days_remaining_display": f"{days_remaining} days" if days_remaining > 0 else "Today/Expired",
  129. "status": task.status
  130. })
  131. except (ValueError, TypeError):
  132. continue
  133. expiring_tasks.sort(key=lambda x: x["days_remaining"])
  134. return expiring_tasks
  135. @staticmethod
  136. async def update(db: AsyncSession, id: int, payload: VasTaskUpdate) -> VasTask:
  137. stmt = select(VasTask).where(VasTask.id == id)
  138. result = await db.execute(stmt)
  139. rec = result.scalar_one_or_none()
  140. if not rec:
  141. raise NotFoundError("Task not exist")
  142. old_status = rec.status
  143. if payload.status is not None:
  144. rec.status = payload.status
  145. if payload.grabbed_history is not None:
  146. rec.grabbed_history = payload.grabbed_history
  147. if payload.meta is not None:
  148. rec.meta = payload.meta
  149. await db.commit()
  150. await db.refresh(rec)
  151. logger.info(f"🔄 [VAS_TASK] Updated task {id}: status {old_status} -> {rec.status}")
  152. return rec
  153. @staticmethod
  154. async def get_task_by_id(
  155. db: AsyncSession,
  156. task_id: int,
  157. ) -> VasTask:
  158. stmt = select(VasTask).where(
  159. VasTask.id == task_id,
  160. )
  161. result = await db.execute(stmt)
  162. rec = result.scalar_one_or_none()
  163. if not rec:
  164. raise NotFoundError("Task not exist")
  165. return rec
  166. @staticmethod
  167. async def return_to_queue(db: AsyncSession, id: int) -> VasTask:
  168. stmt = select(VasTask).where(VasTask.id == id)
  169. result = await db.execute(stmt)
  170. rec = result.scalar_one_or_none()
  171. if not rec:
  172. raise NotFoundError("Task not exist")
  173. if rec.status in ["completed", "cancelled"]:
  174. raise BizLogicError(f"Cannot return a {rec.status} task to queue")
  175. if rec.order_id:
  176. order_stmt = select(VasOrder).where(VasOrder.id == rec.order_id)
  177. order_result = await db.execute(order_stmt)
  178. order = order_result.scalar_one_or_none()
  179. if order and order.status in ["closed", "refunded"]:
  180. raise BizLogicError("Cannot return task to queue: associated order is closed")
  181. rec.status = "pending"
  182. await db.commit()
  183. await db.refresh(rec)
  184. logger.info(f"🔁 [VAS_TASK] Returned task {id} to queue (status=pending)")
  185. return rec
  186. @staticmethod
  187. async def pause(db: AsyncSession, id: int) -> VasTask:
  188. stmt = select(VasTask).where(VasTask.id == id)
  189. result = await db.execute(stmt)
  190. rec = result.scalar_one_or_none()
  191. if not rec:
  192. raise NotFoundError("Task not exist")
  193. if rec.status == "pause":
  194. return rec
  195. if rec.status in ["completed", "cancelled"]:
  196. raise BizLogicError(f"Cannot pause a {rec.status} task")
  197. rec.status = "pause"
  198. await db.commit()
  199. await db.refresh(rec)
  200. logger.info(f"⏸️ [VAS_TASK] Paused task {id} (status=pause)")
  201. return rec
  202. @staticmethod
  203. async def manual_confirm(db: AsyncSession, id: int, redis_client: Redis) -> VasTask:
  204. stmt = select(VasTask).where(VasTask.id == id)
  205. result = await db.execute(stmt)
  206. task = result.scalar_one_or_none()
  207. if not task:
  208. raise NotFoundError("Task not exist")
  209. task.status = "completed"
  210. order_stmt = select(VasOrder).where(VasOrder.id == task.order_id)
  211. order_result = await db.execute(order_stmt)
  212. order = order_result.scalar_one_or_none()
  213. if not order:
  214. raise NotFoundError("Order not exist")
  215. order.status = "completed"
  216. await task_processor.execute(task.routing_key, db, redis_client, task, order)
  217. await db.commit()
  218. await db.refresh(task)
  219. logger.info(f"✅ [VAS_TASK] Manually confirmed task {id} and order {order.id} as completed")
  220. return task