定时任务订阅模式

This commit is contained in:
吉鑫升 committed 2026-05-13 14:59:27 +08:00
1 parent 839386f0b4
commit aa034f8669
14 files changed
+1143 -98

No files matched your search

@@ -5,17 +5,25 @@ from __future__ import annotations
from datetime import UTC, datetime
from typing import Any
from sqlalchemy import select, update
import uuid
from sqlalchemy import delete, select, update
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
from deerflow.persistence.scheduled_tasks.base import ScheduledTaskStore
from deerflow.persistence.scheduled_tasks.model import ScheduledTaskDeliveryProfileRow, ScheduledTaskRow, ScheduledTaskRunRow, SchedulerThreadRow
from deerflow.persistence.scheduled_tasks.model import (
ScheduledTaskDeliveryProfileRow,
ScheduledTaskRow,
ScheduledTaskRunRow,
ScheduledTaskSubscriptionRow,
SchedulerThreadRow,
)
def _to_dict(row) -> dict[str, Any]:
data = row.to_dict()
for key in ("created_at", "updated_at", "next_run_at", "last_run_at", "scheduled_for", "started_at", "finished_at"):
for key in ("created_at", "updated_at", "next_run_at", "last_run_at", "scheduled_for", "started_at", "finished_at", "published_at"):
value = data.get(key)
if isinstance(value, datetime):
data[key] = value.isoformat()
@@ -194,3 +202,107 @@ class ScheduledTaskRepository(ScheduledTaskStore):
await session.commit()
await session.refresh(row)
return _to_dict(row)
# --- Publish / subscribe ---
async def get_task_any(self, task_id: str) -> dict[str, Any] | None:
async with self._sf() as session:
row = await session.get(ScheduledTaskRow, task_id)
return _to_dict(row) if row is not None else None
async def get_run_any(self, run_id: str) -> dict[str, Any] | None:
async with self._sf() as session:
row = await session.get(ScheduledTaskRunRow, run_id)
return _to_dict(row) if row is not None else None
async def set_task_published(self, task_id: str, owner_user_id: str, *, published: bool) -> dict[str, Any] | None:
async with self._sf() as session:
row = await session.get(ScheduledTaskRow, task_id)
if row is None or row.user_id != owner_user_id:
return None
row.published = bool(published)
row.published_at = datetime.now(UTC) if published else None
row.updated_at = datetime.now(UTC)
await session.commit()
await session.refresh(row)
return _to_dict(row)
async def list_published_tasks(self, *, limit: int = 50, offset: int = 0) -> list[dict[str, Any]]:
async with self._sf() as session:
result = await session.execute(
select(ScheduledTaskRow)
.where(ScheduledTaskRow.published.is_(True))
.order_by(ScheduledTaskRow.published_at.desc().nullslast(), ScheduledTaskRow.created_at.desc())
.offset(max(0, offset))
.limit(max(1, limit))
)
return [_to_dict(row) for row in result.scalars()]
async def list_subscribed_tasks(self, user_id: str) -> list[dict[str, Any]]:
async with self._sf() as session:
result = await session.execute(
select(ScheduledTaskRow, ScheduledTaskSubscriptionRow)
.join(ScheduledTaskSubscriptionRow, ScheduledTaskSubscriptionRow.task_id == ScheduledTaskRow.task_id)
.where(ScheduledTaskSubscriptionRow.user_id == user_id)
.order_by(ScheduledTaskSubscriptionRow.created_at.desc())
)
tasks: list[dict[str, Any]] = []
for task_row, sub_row in result.all():
task = _to_dict(task_row)
task["_subscription"] = _to_dict(sub_row)
tasks.append(task)
return tasks
async def get_subscription(self, task_id: str, user_id: str) -> dict[str, Any] | None:
async with self._sf() as session:
result = await session.execute(
select(ScheduledTaskSubscriptionRow)
.where(ScheduledTaskSubscriptionRow.task_id == task_id, ScheduledTaskSubscriptionRow.user_id == user_id)
.limit(1)
)
row = result.scalar_one_or_none()
return _to_dict(row) if row is not None else None
async def upsert_subscription(self, task_id: str, user_id: str, *, notify_element: bool) -> dict[str, Any]:
async with self._sf() as session:
result = await session.execute(
select(ScheduledTaskSubscriptionRow)
.where(ScheduledTaskSubscriptionRow.task_id == task_id, ScheduledTaskSubscriptionRow.user_id == user_id)
.limit(1)
)
row = result.scalar_one_or_none()
if row is None:
row = ScheduledTaskSubscriptionRow(
id=str(uuid.uuid4()),
task_id=task_id,
user_id=user_id,
notify_element=bool(notify_element),
)
session.add(row)
else:
row.notify_element = bool(notify_element)
row.updated_at = datetime.now(UTC)
await session.commit()
await session.refresh(row)
return _to_dict(row)
async def delete_subscription(self, task_id: str, user_id: str) -> bool:
async with self._sf() as session:
result = await session.execute(
delete(ScheduledTaskSubscriptionRow).where(
ScheduledTaskSubscriptionRow.task_id == task_id,
ScheduledTaskSubscriptionRow.user_id == user_id,
)
)
await session.commit()
return (result.rowcount or 0) > 0
async def list_notify_subscribers(self, task_id: str) -> list[dict[str, Any]]:
async with self._sf() as session:
result = await session.execute(
select(ScheduledTaskSubscriptionRow).where(
ScheduledTaskSubscriptionRow.task_id == task_id,
ScheduledTaskSubscriptionRow.notify_element.is_(True),
)
)
return [_to_dict(row) for row in result.scalars()]