vas_task_service.py 8.2 KB

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