1156 lines
43 KiB
Python
1156 lines
43 KiB
Python
"""AI Steward 上下文缓存服务（Redis）与失效钩子。"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import os
|
||
import re
|
||
from datetime import datetime, timezone
|
||
from pathlib import Path
|
||
from typing import Any, Optional
|
||
|
||
from sqlalchemy import and_, case, event, func, inspect, or_, select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
from sqlalchemy.orm import Session
|
||
|
||
from ..models import Project, ProjectSignalLink, Signal, Task, User, UserProject, UserWorkload
|
||
|
||
try:
|
||
import redis.asyncio as redis_async
|
||
from redis import Redis as RedisSync
|
||
|
||
REDIS_AVAILABLE = True
|
||
except Exception: # pragma: no cover
|
||
REDIS_AVAILABLE = False
|
||
redis_async = None
|
||
RedisSync = None
|
||
|
||
|
||
SYSTEM_TTL_SECONDS = 30 * 60
|
||
USER_TTL_SECONDS = 5 * 60
|
||
SESSION_TTL_SECONDS = 60 * 60
|
||
PROJECT_LIST_TTL_SECONDS = 10 * 60
|
||
SIGNAL_PENDING_TTL_SECONDS = 5 * 60
|
||
SESSION_MAX_MESSAGES = 20
|
||
DONE_TASK_STATUSES = {"done", "completed", "closed", "resolved", "archived"}
|
||
PENDING_SIGNAL_STATUSES = {"pending", "todo", "open", "待处理"}
|
||
|
||
|
||
def _safe_int(value: Any, fallback: int = 0) -> int:
|
||
try:
|
||
return int(value)
|
||
except Exception:
|
||
return fallback
|
||
|
||
|
||
def _json_loads(raw: Optional[str], default: Any) -> Any:
|
||
if not raw:
|
||
return default
|
||
try:
|
||
return json.loads(raw)
|
||
except Exception:
|
||
return default
|
||
|
||
|
||
class ContextCacheService:
|
||
def __init__(self, redis_url: Optional[str] = None) -> None:
|
||
self.redis_url = redis_url or os.getenv("REDIS_URL")
|
||
self._redis: Optional[Any] = None
|
||
|
||
@staticmethod
|
||
def _system_key(tenant_id: int) -> str:
|
||
return f"pmflow:context:system:{tenant_id}"
|
||
|
||
@staticmethod
|
||
def _user_key(tenant_id: int, user_id: int) -> str:
|
||
return f"pmflow:context:user:{tenant_id}:{user_id}"
|
||
|
||
@staticmethod
|
||
def _session_key(tenant_id: int, session_id: int) -> str:
|
||
return f"pmflow:qa:session:{tenant_id}:{session_id}"
|
||
|
||
@staticmethod
|
||
def _project_list_key(tenant_id: int) -> str:
|
||
return f"pmflow:project:list:{tenant_id}"
|
||
|
||
@staticmethod
|
||
def _signal_pending_key(tenant_id: int) -> str:
|
||
return f"pmflow:signal:pending_count:{tenant_id}"
|
||
|
||
async def _get_redis(self):
|
||
if not REDIS_AVAILABLE or not self.redis_url:
|
||
return None
|
||
if self._redis is None:
|
||
self._redis = redis_async.from_url(self.redis_url, decode_responses=True)
|
||
return self._redis
|
||
|
||
async def _get_json(self, key: str) -> Optional[dict[str, Any]]:
|
||
redis = await self._get_redis()
|
||
if redis is None:
|
||
return None
|
||
try:
|
||
raw = await redis.get(key)
|
||
except Exception:
|
||
return None
|
||
if not raw:
|
||
return None
|
||
payload = _json_loads(raw, None)
|
||
return payload if isinstance(payload, dict) else None
|
||
|
||
async def _set_json(self, key: str, value: dict[str, Any], ttl: int) -> None:
|
||
redis = await self._get_redis()
|
||
if redis is None:
|
||
return
|
||
try:
|
||
await redis.setex(key, ttl, json.dumps(value, ensure_ascii=False))
|
||
except Exception:
|
||
pass
|
||
|
||
@staticmethod
|
||
def _is_system_snapshot_complete(payload: Optional[dict[str, Any]]) -> bool:
|
||
if not isinstance(payload, dict):
|
||
return False
|
||
return isinstance(payload.get("assistant_profile"), dict) and isinstance(payload.get("platform_profile"), dict)
|
||
|
||
async def get_system_snapshot(self, *, db: AsyncSession, tenant_id: int) -> dict[str, Any]:
|
||
tid = _safe_int(tenant_id, 1)
|
||
key = self._system_key(tid)
|
||
cached = await self._get_json(key)
|
||
if self._is_system_snapshot_complete(cached):
|
||
return cached
|
||
|
||
payload = await self._build_system_snapshot(db=db, tenant_id=tid)
|
||
await self._set_json(key, payload, SYSTEM_TTL_SECONDS)
|
||
return payload
|
||
|
||
async def get_user_snapshot(
|
||
self,
|
||
*,
|
||
db: AsyncSession,
|
||
tenant_id: int,
|
||
user_id: Optional[int],
|
||
) -> dict[str, Any]:
|
||
if user_id is None:
|
||
return {}
|
||
|
||
tid = _safe_int(tenant_id, 1)
|
||
uid = _safe_int(user_id, 0)
|
||
if uid <= 0:
|
||
return {}
|
||
|
||
key = self._user_key(tid, uid)
|
||
cached = await self._get_json(key)
|
||
if cached is not None:
|
||
return cached
|
||
|
||
payload = await self._build_user_snapshot(db=db, tenant_id=tid, user_id=uid)
|
||
await self._set_json(key, payload, USER_TTL_SECONDS)
|
||
return payload
|
||
|
||
async def _build_system_snapshot(self, *, db: AsyncSession, tenant_id: int) -> dict[str, Any]:
|
||
projects = await self._get_project_list_cached(db=db, tenant_id=tenant_id)
|
||
team = await self._build_team_members_snapshot(db=db, tenant_id=tenant_id)
|
||
pending = await self._get_pending_signal_cached(db=db, tenant_id=tenant_id)
|
||
assistant_profile = self._build_assistant_profile()
|
||
platform_profile = self._build_platform_profile()
|
||
return {
|
||
"tenant_id": tenant_id,
|
||
"assistant_profile": assistant_profile,
|
||
"platform_profile": platform_profile,
|
||
"projects": projects.get("items", []),
|
||
"team_members": team,
|
||
"pending_signals": pending,
|
||
"snapshot_at": datetime.now(timezone.utc).isoformat(),
|
||
}
|
||
|
||
@staticmethod
|
||
def _build_assistant_profile() -> dict[str, Any]:
|
||
return {
|
||
"name": "PMFlow AI 管家",
|
||
"identity": "PMFlow 内置的项目管理与技术协同助手",
|
||
"responsibilities": [
|
||
"识别需求并路由到项目/信号",
|
||
"结合结构化数据与知识库回答问题",
|
||
"辅助任务拆解、分配与优先级判断",
|
||
"输出基于证据的系统状态与风险提示",
|
||
],
|
||
"principles": [
|
||
"只基于可验证上下文回答",
|
||
"证据不足时明确说明不足字段",
|
||
"优先使用系统快照中的实时结构化数据",
|
||
],
|
||
}
|
||
|
||
@staticmethod
|
||
def _count_python_files(target: Path) -> int:
|
||
if not target.exists() or not target.is_dir():
|
||
return 0
|
||
return sum(1 for p in target.rglob("*.py") if p.is_file())
|
||
|
||
@staticmethod
|
||
def _estimate_api_routes(api_dir: Path) -> int:
|
||
if not api_dir.exists() or not api_dir.is_dir():
|
||
return 0
|
||
markers = (
|
||
"@router.get(",
|
||
"@router.post(",
|
||
"@router.put(",
|
||
"@router.patch(",
|
||
"@router.delete(",
|
||
"@router.websocket(",
|
||
)
|
||
route_count = 0
|
||
for py_file in api_dir.rglob("*.py"):
|
||
if not py_file.is_file() or py_file.name.startswith("__"):
|
||
continue
|
||
try:
|
||
text = py_file.read_text(encoding="utf-8", errors="ignore")
|
||
except Exception:
|
||
continue
|
||
for marker in markers:
|
||
route_count += text.count(marker)
|
||
return route_count
|
||
|
||
@staticmethod
|
||
def _detect_database_stack() -> str:
|
||
url = str(os.getenv("DATABASE_URL") or "").lower()
|
||
if "postgresql" in url:
|
||
return "PostgreSQL (pgvector-ready)"
|
||
if "mysql" in url:
|
||
return "MySQL"
|
||
if "sqlite" in url:
|
||
return "SQLite"
|
||
return "Unknown"
|
||
|
||
@staticmethod
|
||
def _default_feature_catalog_items() -> list[dict[str, Any]]:
|
||
return [
|
||
{
|
||
"route": "/workloads",
|
||
"name": "团队负载",
|
||
"summary": "查看团队成员负载、瓶颈与调配建议。",
|
||
"page_component": "WorkloadsPage",
|
||
"page_file": "frontend/src/pages/WorkloadsPage.tsx",
|
||
"apis": ["/workloads/", "/workloads/ai-optimize", "/workloads/ai-optimize/apply"],
|
||
"aliases": ["workloads", "负载", "工作量", "capacity", "团队负载"],
|
||
},
|
||
{
|
||
"route": "/projects",
|
||
"name": "项目列表",
|
||
"summary": "管理项目清单、状态、入口跳转与总览信息。",
|
||
"page_component": "ProjectsPage",
|
||
"page_file": "frontend/src/pages/ProjectsPage.tsx",
|
||
"apis": ["/projects/", "/projects/?summary=1"],
|
||
"aliases": ["projects", "项目", "项目列表", "project list"],
|
||
},
|
||
{
|
||
"route": "/ai-steward",
|
||
"name": "AI 管家",
|
||
"summary": "AI 任务协同与治理中心，包含简报、冲突检测、问答历史。",
|
||
"page_component": "AIStewardPage",
|
||
"page_file": "frontend/src/pages/AIStewardPage.tsx",
|
||
"apis": ["/ai-steward/", "/ai-steward/rag/ask", "/rag/qa-sessions", "/rag/qa-records"],
|
||
"aliases": ["ai steward", "ai管家", "问答", "rag", "智能问答"],
|
||
},
|
||
{
|
||
"route": "/ai-config",
|
||
"name": "智能配置",
|
||
"summary": "配置飞书/企微/GitHub/知识库与模型参数，决定 AI 数据源与行为。",
|
||
"page_component": "AIConfigPage",
|
||
"page_file": "frontend/src/pages/AIConfigPage.tsx",
|
||
"apis": [
|
||
"/ai-steward/config/suggest",
|
||
"/feishu/config",
|
||
"/wecom/config",
|
||
"/rag/knowledge-base/docs",
|
||
"/rag/knowledge-base/upload",
|
||
"/rag/knowledge-base/urls",
|
||
],
|
||
"aliases": [
|
||
"智能配置",
|
||
"ai配置",
|
||
"配置中心",
|
||
"integration",
|
||
"集成配置",
|
||
"knowledge base",
|
||
],
|
||
},
|
||
{
|
||
"route": "/skills",
|
||
"name": "能力管理",
|
||
"summary": "管理能力标签、人员能力画像、任务匹配与推荐。",
|
||
"page_component": "SkillsPage",
|
||
"page_file": "frontend/src/pages/SkillsPage.tsx",
|
||
"apis": ["/skills/tags", "/skills/recommend", "/skills/users/{id}/bindings"],
|
||
"aliases": ["skills", "能力", "技能", "ability", "能力管理"],
|
||
},
|
||
{
|
||
"route": "/users",
|
||
"name": "用户管理",
|
||
"summary": "管理用户档案、角色、状态与权限入口。",
|
||
"page_component": "UsersPage",
|
||
"page_file": "frontend/src/pages/UsersPage.tsx",
|
||
"apis": ["/users/", "/users/{id}", "/users/bulk-delete", "/users/bulk-assign"],
|
||
"aliases": ["users", "成员管理", "用户", "人员管理"],
|
||
},
|
||
]
|
||
|
||
@staticmethod
|
||
def _extract_router_import_map(router_text: str) -> dict[str, str]:
|
||
mapping: dict[str, str] = {}
|
||
for component, page_rel in re.findall(
|
||
r'import\s+([A-Za-z_][A-Za-z0-9_]*)\s+from\s+"@/pages/([^"]+)";',
|
||
str(router_text or ""),
|
||
):
|
||
rel = str(page_rel).strip()
|
||
if not rel:
|
||
continue
|
||
if not rel.endswith(".tsx") and not rel.endswith(".ts"):
|
||
rel = f"{rel}.tsx"
|
||
mapping[str(component).strip()] = f"frontend/src/pages/{rel}"
|
||
return mapping
|
||
|
||
@staticmethod
|
||
def _extract_router_entries(router_text: str) -> list[tuple[str, str]]:
|
||
entries: list[tuple[str, str]] = []
|
||
for route, component in re.findall(
|
||
r'\{\s*path:\s*"([^"]+)"\s*,\s*element:\s*<([A-Za-z_][A-Za-z0-9_]*)\s*/?>\s*\}',
|
||
str(router_text or ""),
|
||
):
|
||
clean_route = str(route or "").strip()
|
||
if not clean_route:
|
||
continue
|
||
if not clean_route.startswith("/"):
|
||
clean_route = f"/{clean_route}"
|
||
entries.append((clean_route, str(component).strip()))
|
||
return entries
|
||
|
||
@staticmethod
|
||
def _extract_sidebar_labels(sidebar_text: str) -> dict[str, str]:
|
||
labels: dict[str, str] = {}
|
||
for route, label in re.findall(
|
||
r'\{\s*to:\s*"([^"]+)"\s*,\s*label:\s*"([^"]+)"',
|
||
str(sidebar_text or ""),
|
||
):
|
||
clean_route = str(route or "").strip()
|
||
if clean_route and not clean_route.startswith("/"):
|
||
clean_route = f"/{clean_route}"
|
||
if clean_route:
|
||
labels[clean_route] = str(label or "").strip()
|
||
return labels
|
||
|
||
@staticmethod
|
||
def _route_feature_summary(route: str) -> tuple[str, list[str], list[str]]:
|
||
route_map: dict[str, tuple[str, list[str], list[str]]] = {
|
||
"/workloads": (
|
||
"查看团队成员负载、瓶颈与调配建议。",
|
||
["/workloads/", "/workloads/ai-optimize", "/workloads/ai-optimize/apply"],
|
||
["workloads", "负载", "工作量", "capacity"],
|
||
),
|
||
"/projects": (
|
||
"管理项目清单、状态、入口跳转与总览信息。",
|
||
["/projects/", "/projects/?summary=1"],
|
||
["projects", "项目", "项目列表", "project list"],
|
||
),
|
||
"/ai-steward": (
|
||
"AI 任务协同与治理中心，包含简报、冲突检测、问答历史。",
|
||
["/ai-steward/", "/ai-steward/rag/ask", "/rag/qa-sessions", "/rag/qa-records"],
|
||
["ai steward", "ai管家", "问答", "rag", "智能问答"],
|
||
),
|
||
"/ai-config": (
|
||
"配置飞书/企微/GitHub/知识库与模型参数，决定 AI 数据源与行为。",
|
||
[
|
||
"/ai-steward/config/suggest",
|
||
"/feishu/config",
|
||
"/wecom/config",
|
||
"/rag/knowledge-base/docs",
|
||
"/rag/knowledge-base/upload",
|
||
"/rag/knowledge-base/urls",
|
||
],
|
||
["智能配置", "ai配置", "配置中心", "integration", "集成配置", "knowledge base"],
|
||
),
|
||
"/skills": (
|
||
"管理能力标签、人员能力画像、任务匹配与推荐。",
|
||
["/skills/tags", "/skills/recommend", "/skills/users/{id}/bindings"],
|
||
["skills", "能力", "技能", "ability", "能力管理"],
|
||
),
|
||
"/users": (
|
||
"管理用户档案、角色、状态与权限入口。",
|
||
["/users/", "/users/{id}", "/users/bulk-delete", "/users/bulk-assign"],
|
||
["users", "成员管理", "用户", "人员管理"],
|
||
),
|
||
}
|
||
if route in route_map:
|
||
return route_map[route]
|
||
return (
|
||
"系统功能页面入口。",
|
||
[],
|
||
[route.strip("/"), route.replace("/", "_").strip("_")],
|
||
)
|
||
|
||
@staticmethod
|
||
def _normalize_aliases(*groups: list[str]) -> list[str]:
|
||
merged: list[str] = []
|
||
for group in groups:
|
||
for item in group:
|
||
alias = str(item or "").strip().lower()
|
||
if not alias:
|
||
continue
|
||
if alias not in merged:
|
||
merged.append(alias)
|
||
return merged
|
||
|
||
def _build_feature_catalog(
|
||
self,
|
||
*,
|
||
backend_root: Path,
|
||
) -> dict[str, Any]:
|
||
workspace_root = backend_root.parent
|
||
frontend_src = workspace_root / "frontend" / "src"
|
||
router_file = frontend_src / "router" / "index.tsx"
|
||
sidebar_file = frontend_src / "components" / "layout" / "Sidebar.tsx"
|
||
|
||
if not frontend_src.exists():
|
||
fallback_items = self._default_feature_catalog_items()
|
||
return {
|
||
"items": fallback_items,
|
||
"count": len(fallback_items),
|
||
"source": "fallback",
|
||
}
|
||
|
||
router_text = ""
|
||
sidebar_text = ""
|
||
try:
|
||
router_text = router_file.read_text(encoding="utf-8", errors="ignore")
|
||
except Exception:
|
||
router_text = ""
|
||
try:
|
||
sidebar_text = sidebar_file.read_text(encoding="utf-8", errors="ignore")
|
||
except Exception:
|
||
sidebar_text = ""
|
||
|
||
import_map = self._extract_router_import_map(router_text)
|
||
router_entries = self._extract_router_entries(router_text)
|
||
sidebar_labels = self._extract_sidebar_labels(sidebar_text)
|
||
|
||
merged: dict[str, dict[str, Any]] = {}
|
||
for route, component in router_entries:
|
||
page_file = import_map.get(component) or ""
|
||
default_name = component.replace("Page", "")
|
||
name = sidebar_labels.get(route) or default_name
|
||
summary, apis, aliases = self._route_feature_summary(route)
|
||
route_aliases = [route.strip("/"), route.replace("/", "_").strip("_"), component]
|
||
merged[route] = {
|
||
"route": route,
|
||
"name": name,
|
||
"summary": summary,
|
||
"page_component": component,
|
||
"page_file": page_file,
|
||
"apis": apis,
|
||
"aliases": self._normalize_aliases(aliases, route_aliases, [name]),
|
||
}
|
||
|
||
for route, label in sidebar_labels.items():
|
||
if route not in merged:
|
||
summary, apis, aliases = self._route_feature_summary(route)
|
||
merged[route] = {
|
||
"route": route,
|
||
"name": label,
|
||
"summary": summary,
|
||
"page_component": "",
|
||
"page_file": "",
|
||
"apis": apis,
|
||
"aliases": self._normalize_aliases(aliases, [route.strip("/"), label]),
|
||
}
|
||
else:
|
||
merged[route]["name"] = label
|
||
merged[route]["aliases"] = self._normalize_aliases(
|
||
list(merged[route].get("aliases") or []),
|
||
[label],
|
||
)
|
||
|
||
items = sorted(merged.values(), key=lambda x: str(x.get("route") or ""))
|
||
if not items:
|
||
items = self._default_feature_catalog_items()
|
||
source = "fallback"
|
||
else:
|
||
source = "frontend_scan"
|
||
return {
|
||
"items": items,
|
||
"count": len(items),
|
||
"source": source,
|
||
}
|
||
|
||
def _build_platform_profile(self) -> dict[str, Any]:
|
||
backend_root = Path(__file__).resolve().parents[2]
|
||
workspace_root = backend_root.parent
|
||
app_root = backend_root / "app"
|
||
api_dir = app_root / "api"
|
||
services_dir = app_root / "services"
|
||
models_dir = app_root / "models"
|
||
schemas_dir = app_root / "schemas"
|
||
dependencies_dir = app_root / "dependencies"
|
||
core_dir = app_root / "core"
|
||
config_dir = app_root / "config"
|
||
|
||
module_counts = {
|
||
"api": self._count_python_files(api_dir),
|
||
"services": self._count_python_files(services_dir),
|
||
"models": self._count_python_files(models_dir),
|
||
"schemas": self._count_python_files(schemas_dir),
|
||
"dependencies": self._count_python_files(dependencies_dir),
|
||
"core": self._count_python_files(core_dir),
|
||
"config": self._count_python_files(config_dir),
|
||
}
|
||
app_python_files = self._count_python_files(app_root)
|
||
route_count = self._estimate_api_routes(api_dir)
|
||
running_in_docker = Path("/.dockerenv").exists()
|
||
redis_enabled = bool(str(os.getenv("REDIS_URL") or "").strip())
|
||
feature_catalog = self._build_feature_catalog(backend_root=backend_root)
|
||
frontend_src = workspace_root / "frontend" / "src"
|
||
frontend_ts_files = 0
|
||
if frontend_src.exists():
|
||
frontend_ts_files = sum(
|
||
1
|
||
for p in frontend_src.rglob("*")
|
||
if p.is_file() and p.suffix.lower() in {".ts", ".tsx", ".js", ".jsx"}
|
||
)
|
||
|
||
return {
|
||
"runtime": "docker" if running_in_docker else "local",
|
||
"backend": {
|
||
"framework": "FastAPI",
|
||
"orm": "SQLAlchemy 2.0",
|
||
"python": "3.11+",
|
||
"module_counts": module_counts,
|
||
"api_route_count_estimate": route_count,
|
||
},
|
||
"infrastructure": {
|
||
"database": self._detect_database_stack(),
|
||
"cache": "Redis" if redis_enabled else "Disabled/Unknown",
|
||
},
|
||
"frontend": {
|
||
"framework": "React 18 + TypeScript + Vite",
|
||
"source_root": str(frontend_src),
|
||
"route_count": int(feature_catalog.get("count") or 0),
|
||
"source_file_count": int(frontend_ts_files),
|
||
},
|
||
"feature_catalog": feature_catalog.get("items") if isinstance(feature_catalog.get("items"), list) else [],
|
||
"source_scan": {
|
||
"backend_root": str(backend_root),
|
||
"app_python_files": app_python_files,
|
||
"feature_catalog_source": str(feature_catalog.get("source") or "unknown"),
|
||
"scanned_at": datetime.now(timezone.utc).isoformat(),
|
||
},
|
||
}
|
||
|
||
async def _get_project_list_cached(self, *, db: AsyncSession, tenant_id: int) -> dict[str, Any]:
|
||
key = self._project_list_key(tenant_id)
|
||
cached = await self._get_json(key)
|
||
if cached is not None:
|
||
return cached
|
||
|
||
project_rows = (
|
||
await db.execute(
|
||
select(
|
||
Project.id,
|
||
Project.name,
|
||
Project.title,
|
||
Project.status,
|
||
Project.owner_id,
|
||
User.name.label("owner_name"),
|
||
)
|
||
.outerjoin(
|
||
User,
|
||
and_(
|
||
User.tenant_id == tenant_id,
|
||
User.id == Project.owner_id,
|
||
),
|
||
)
|
||
.where(Project.tenant_id == tenant_id)
|
||
.order_by(Project.updated_at.desc(), Project.id.desc())
|
||
)
|
||
).all()
|
||
|
||
project_ids = [int(row.id) for row in project_rows]
|
||
signal_count_map: dict[int, int] = {}
|
||
if project_ids:
|
||
signal_rows = (
|
||
await db.execute(
|
||
select(ProjectSignalLink.project_id, func.count(ProjectSignalLink.id))
|
||
.where(
|
||
and_(
|
||
ProjectSignalLink.tenant_id == tenant_id,
|
||
ProjectSignalLink.project_id.in_(project_ids),
|
||
)
|
||
)
|
||
.group_by(ProjectSignalLink.project_id)
|
||
)
|
||
).all()
|
||
signal_count_map = {int(pid): int(cnt or 0) for pid, cnt in signal_rows}
|
||
|
||
task_count_map: dict[int, int] = {}
|
||
task_done_map: dict[int, int] = {}
|
||
if project_ids:
|
||
done_case = case((func.lower(Task.status).in_(DONE_TASK_STATUSES), 1), else_=0)
|
||
task_rows = (
|
||
await db.execute(
|
||
select(
|
||
Task.project_id,
|
||
func.count(Task.id).label("task_total"),
|
||
func.sum(done_case).label("done_count"),
|
||
)
|
||
.where(
|
||
and_(
|
||
Task.tenant_id == tenant_id,
|
||
Task.project_id.in_(project_ids),
|
||
)
|
||
)
|
||
.group_by(Task.project_id)
|
||
)
|
||
).all()
|
||
task_count_map = {int(pid): int(total or 0) for pid, total, _ in task_rows}
|
||
task_done_map = {int(pid): int(done or 0) for pid, _, done in task_rows}
|
||
|
||
items: list[dict[str, Any]] = []
|
||
for row in project_rows:
|
||
pid = int(row.id)
|
||
task_total = int(task_count_map.get(pid, 0))
|
||
done_total = int(task_done_map.get(pid, 0))
|
||
completion_rate = round((done_total / task_total) * 100, 2) if task_total > 0 else 0.0
|
||
title = str(row.title or row.name or f"Project#{pid}")
|
||
items.append(
|
||
{
|
||
"id": pid,
|
||
"name": title,
|
||
"status": str(row.status or "unknown"),
|
||
"current_stage": str(row.status or "unknown"),
|
||
"owner_id": _safe_int(row.owner_id, 0) or None,
|
||
"owner_name": str(row.owner_name or "未知"),
|
||
"signal_count": int(signal_count_map.get(pid, 0)),
|
||
"task_count": task_total,
|
||
"completion_rate": completion_rate,
|
||
}
|
||
)
|
||
|
||
payload = {
|
||
"items": items,
|
||
"count": len(items),
|
||
"snapshot_at": datetime.now(timezone.utc).isoformat(),
|
||
}
|
||
await self._set_json(key, payload, PROJECT_LIST_TTL_SECONDS)
|
||
return payload
|
||
|
||
async def _build_team_members_snapshot(self, *, db: AsyncSession, tenant_id: int) -> list[dict[str, Any]]:
|
||
users = (
|
||
await db.execute(
|
||
select(User.id, User.name, User.role, User.workload).where(
|
||
and_(
|
||
User.tenant_id == tenant_id,
|
||
User.is_active.is_(True),
|
||
)
|
||
)
|
||
)
|
||
).all()
|
||
if not users:
|
||
return []
|
||
|
||
user_ids = [int(u.id) for u in users]
|
||
workload_rows = (
|
||
await db.execute(
|
||
select(UserWorkload.user_id, UserWorkload.workload_ratio).where(
|
||
and_(
|
||
UserWorkload.tenant_id == tenant_id,
|
||
UserWorkload.user_id.in_(user_ids),
|
||
)
|
||
)
|
||
)
|
||
).all()
|
||
workload_map = {int(uid): float(ratio or 0.0) for uid, ratio in workload_rows}
|
||
|
||
project_rows = (
|
||
await db.execute(
|
||
select(UserProject.user_id, UserProject.project_id).where(
|
||
and_(
|
||
UserProject.tenant_id == tenant_id,
|
||
UserProject.user_id.in_(user_ids),
|
||
)
|
||
)
|
||
)
|
||
).all()
|
||
projects_map: dict[int, list[int]] = {}
|
||
for uid, pid in project_rows:
|
||
projects_map.setdefault(int(uid), []).append(int(pid))
|
||
|
||
result: list[dict[str, Any]] = []
|
||
for row in users:
|
||
uid = int(row.id)
|
||
ratio = workload_map.get(uid)
|
||
if ratio is None:
|
||
ratio = round(float(row.workload or 0) / 100.0, 2)
|
||
result.append(
|
||
{
|
||
"id": uid,
|
||
"name": str(row.name or f"User#{uid}"),
|
||
"role": str(row.role or "unknown"),
|
||
"workload_ratio": float(ratio),
|
||
"assigned_projects": projects_map.get(uid, []),
|
||
}
|
||
)
|
||
return result
|
||
|
||
async def _get_pending_signal_cached(self, *, db: AsyncSession, tenant_id: int) -> dict[str, Any]:
|
||
key = self._signal_pending_key(tenant_id)
|
||
cached = await self._get_json(key)
|
||
if cached is not None:
|
||
return cached
|
||
|
||
pending_filter = or_(
|
||
Signal.processed.is_(False),
|
||
func.lower(Signal.status).in_(PENDING_SIGNAL_STATUSES),
|
||
)
|
||
p0_case = case(
|
||
(
|
||
func.lower(Signal.priority).in_({"critical", "p0", "urgent", "highest"}),
|
||
1,
|
||
),
|
||
else_=0,
|
||
)
|
||
p1_case = case((func.lower(Signal.priority).in_({"high", "p1"}), 1), else_=0)
|
||
p2_case = case((func.lower(Signal.priority).in_({"medium", "p2", "normal"}), 1), else_=0)
|
||
|
||
row = (
|
||
await db.execute(
|
||
select(
|
||
func.count(Signal.id),
|
||
func.sum(p0_case),
|
||
func.sum(p1_case),
|
||
func.sum(p2_case),
|
||
).where(
|
||
and_(
|
||
Signal.tenant_id == tenant_id,
|
||
pending_filter,
|
||
)
|
||
)
|
||
)
|
||
).first()
|
||
total, p0_count, p1_count, p2_count = row or (0, 0, 0, 0)
|
||
|
||
payload = {
|
||
"total": int(total or 0),
|
||
"p0_count": int(p0_count or 0),
|
||
"p1_count": int(p1_count or 0),
|
||
"p2_count": int(p2_count or 0),
|
||
"snapshot_at": datetime.now(timezone.utc).isoformat(),
|
||
}
|
||
await self._set_json(key, payload, SIGNAL_PENDING_TTL_SECONDS)
|
||
return payload
|
||
|
||
async def _build_user_snapshot(
|
||
self,
|
||
*,
|
||
db: AsyncSession,
|
||
tenant_id: int,
|
||
user_id: int,
|
||
) -> dict[str, Any]:
|
||
owned_rows = (
|
||
await db.execute(
|
||
select(Project.id).where(
|
||
and_(
|
||
Project.tenant_id == tenant_id,
|
||
Project.owner_id == user_id,
|
||
)
|
||
)
|
||
)
|
||
).scalars().all()
|
||
member_rows = (
|
||
await db.execute(
|
||
select(UserProject.project_id).where(
|
||
and_(
|
||
UserProject.tenant_id == tenant_id,
|
||
UserProject.user_id == user_id,
|
||
)
|
||
)
|
||
)
|
||
).scalars().all()
|
||
project_ids = sorted({_safe_int(pid, 0) for pid in [*owned_rows, *member_rows] if _safe_int(pid, 0) > 0})
|
||
|
||
project_rows: list[Any] = []
|
||
if project_ids:
|
||
project_rows = (
|
||
await db.execute(
|
||
select(Project.id, Project.name, Project.title, Project.status).where(
|
||
and_(
|
||
Project.tenant_id == tenant_id,
|
||
Project.id.in_(project_ids),
|
||
)
|
||
)
|
||
)
|
||
).all()
|
||
|
||
open_tasks = (
|
||
await db.execute(
|
||
select(Task.id, Task.project_id, Task.title, Task.status, Task.due_date).where(
|
||
and_(
|
||
Task.tenant_id == tenant_id,
|
||
Task.assignee_id == user_id,
|
||
func.lower(Task.status).notin_(DONE_TASK_STATUSES),
|
||
)
|
||
)
|
||
)
|
||
).all()
|
||
|
||
pending_signals: list[dict[str, Any]] = []
|
||
if project_ids:
|
||
pending_rows = (
|
||
await db.execute(
|
||
select(Signal.id, Signal.title, Signal.priority, Signal.status, Signal.matched_project_id).where(
|
||
and_(
|
||
Signal.tenant_id == tenant_id,
|
||
Signal.matched_project_id.in_(project_ids),
|
||
or_(
|
||
Signal.processed.is_(False),
|
||
func.lower(Signal.status).in_(PENDING_SIGNAL_STATUSES),
|
||
),
|
||
)
|
||
).limit(60)
|
||
)
|
||
).all()
|
||
pending_signals = [
|
||
{
|
||
"id": int(row.id),
|
||
"title": str(row.title or ""),
|
||
"priority": str(row.priority or ""),
|
||
"status": str(row.status or ""),
|
||
"project_id": _safe_int(row.matched_project_id, 0) or None,
|
||
}
|
||
for row in pending_rows
|
||
]
|
||
|
||
workload_row = (
|
||
await db.execute(
|
||
select(UserWorkload.workload_ratio).where(
|
||
and_(
|
||
UserWorkload.tenant_id == tenant_id,
|
||
UserWorkload.user_id == user_id,
|
||
)
|
||
)
|
||
)
|
||
).scalar_one_or_none()
|
||
if workload_row is None:
|
||
fallback = (
|
||
await db.execute(
|
||
select(User.workload).where(
|
||
and_(
|
||
User.tenant_id == tenant_id,
|
||
User.id == user_id,
|
||
)
|
||
)
|
||
)
|
||
).scalar_one_or_none()
|
||
workload_ratio = round(float(fallback or 0) / 100.0, 2)
|
||
else:
|
||
workload_ratio = float(workload_row or 0.0)
|
||
|
||
return {
|
||
"user_id": user_id,
|
||
"projects": [
|
||
{
|
||
"id": int(row.id),
|
||
"name": str(row.title or row.name or f"Project#{int(row.id)}"),
|
||
"status": str(row.status or "unknown"),
|
||
}
|
||
for row in project_rows
|
||
],
|
||
"assigned_tasks": [
|
||
{
|
||
"id": int(row.id),
|
||
"project_id": int(row.project_id),
|
||
"title": str(row.title or ""),
|
||
"status": str(row.status or ""),
|
||
"due_date": row.due_date.isoformat() if row.due_date else None,
|
||
}
|
||
for row in open_tasks
|
||
],
|
||
"pending_signals": pending_signals,
|
||
"workload_ratio": workload_ratio,
|
||
"snapshot_at": datetime.now(timezone.utc).isoformat(),
|
||
}
|
||
|
||
async def get_session_messages(self, *, tenant_id: int, session_id: Optional[int]) -> list[dict[str, str]]:
|
||
if session_id is None:
|
||
return []
|
||
sid = _safe_int(session_id, 0)
|
||
if sid <= 0:
|
||
return []
|
||
|
||
redis = await self._get_redis()
|
||
if redis is None:
|
||
return []
|
||
key = self._session_key(_safe_int(tenant_id, 1), sid)
|
||
try:
|
||
raw_rows = await redis.lrange(key, -SESSION_MAX_MESSAGES, -1)
|
||
except Exception:
|
||
return []
|
||
messages: list[dict[str, str]] = []
|
||
for raw in raw_rows:
|
||
row = _json_loads(raw, None)
|
||
if not isinstance(row, dict):
|
||
continue
|
||
role = str(row.get("role") or "").strip().lower()
|
||
content = str(row.get("content") or "").strip()
|
||
if role in {"user", "assistant"} and content:
|
||
messages.append({"role": role, "content": content})
|
||
return messages
|
||
|
||
async def append_session_messages(
|
||
self,
|
||
*,
|
||
tenant_id: int,
|
||
session_id: Optional[int],
|
||
question: str,
|
||
answer: str,
|
||
) -> None:
|
||
if session_id is None:
|
||
return
|
||
sid = _safe_int(session_id, 0)
|
||
if sid <= 0:
|
||
return
|
||
|
||
redis = await self._get_redis()
|
||
if redis is None:
|
||
return
|
||
|
||
key = self._session_key(_safe_int(tenant_id, 1), sid)
|
||
user_payload = json.dumps({"role": "user", "content": str(question or "")[:3000]}, ensure_ascii=False)
|
||
assistant_payload = json.dumps({"role": "assistant", "content": str(answer or "")[:4000]}, ensure_ascii=False)
|
||
try:
|
||
pipe = redis.pipeline()
|
||
pipe.rpush(key, user_payload, assistant_payload)
|
||
pipe.ltrim(key, -SESSION_MAX_MESSAGES, -1)
|
||
pipe.expire(key, SESSION_TTL_SECONDS)
|
||
await pipe.execute()
|
||
except Exception:
|
||
return
|
||
|
||
async def invalidate_system_context(self, *, tenant_id: int) -> None:
|
||
redis = await self._get_redis()
|
||
if redis is None:
|
||
return
|
||
tid = _safe_int(tenant_id, 1)
|
||
keys = [
|
||
self._system_key(tid),
|
||
self._project_list_key(tid),
|
||
self._signal_pending_key(tid),
|
||
]
|
||
try:
|
||
await redis.delete(*keys)
|
||
except Exception:
|
||
pass
|
||
|
||
async def invalidate_user_context(self, *, tenant_id: int, user_id: int) -> None:
|
||
redis = await self._get_redis()
|
||
if redis is None:
|
||
return
|
||
uid = _safe_int(user_id, 0)
|
||
if uid <= 0:
|
||
return
|
||
try:
|
||
await redis.delete(self._user_key(_safe_int(tenant_id, 1), uid))
|
||
except Exception:
|
||
pass
|
||
|
||
@staticmethod
|
||
def messages_to_turns(messages: list[dict[str, str]]) -> list[dict[str, str]]:
|
||
turns: list[dict[str, str]] = []
|
||
pending_question: Optional[str] = None
|
||
for row in messages:
|
||
role = str(row.get("role") or "").lower()
|
||
content = str(row.get("content") or "")
|
||
if role == "user":
|
||
if pending_question:
|
||
turns.append({"question": pending_question, "answer": ""})
|
||
pending_question = content
|
||
continue
|
||
if role == "assistant":
|
||
if pending_question is None:
|
||
continue
|
||
turns.append({"question": pending_question, "answer": content})
|
||
pending_question = None
|
||
if pending_question:
|
||
turns.append({"question": pending_question, "answer": ""})
|
||
return turns
|
||
|
||
|
||
class ContextCacheInvalidator:
|
||
def __init__(self, redis_url: Optional[str] = None) -> None:
|
||
self.redis_url = redis_url or os.getenv("REDIS_URL")
|
||
self._redis: Optional[Any] = None
|
||
|
||
def _get_redis(self):
|
||
if not REDIS_AVAILABLE or not self.redis_url or RedisSync is None:
|
||
return None
|
||
if self._redis is None:
|
||
self._redis = RedisSync.from_url(
|
||
self.redis_url,
|
||
decode_responses=True,
|
||
socket_connect_timeout=1,
|
||
socket_timeout=1,
|
||
)
|
||
return self._redis
|
||
|
||
@staticmethod
|
||
def _system_key(tenant_id: int) -> str:
|
||
return ContextCacheService._system_key(_safe_int(tenant_id, 1))
|
||
|
||
@staticmethod
|
||
def _project_list_key(tenant_id: int) -> str:
|
||
return ContextCacheService._project_list_key(_safe_int(tenant_id, 1))
|
||
|
||
@staticmethod
|
||
def _signal_pending_key(tenant_id: int) -> str:
|
||
return ContextCacheService._signal_pending_key(_safe_int(tenant_id, 1))
|
||
|
||
@staticmethod
|
||
def _user_key(tenant_id: int, user_id: int) -> str:
|
||
return ContextCacheService._user_key(_safe_int(tenant_id, 1), _safe_int(user_id, 0))
|
||
|
||
def invalidate(
|
||
self,
|
||
*,
|
||
tenant_id: int,
|
||
invalidate_system: bool,
|
||
invalidate_project_list: bool,
|
||
invalidate_signal_pending: bool,
|
||
user_ids: Optional[set[int]] = None,
|
||
) -> None:
|
||
redis = self._get_redis()
|
||
if redis is None:
|
||
return
|
||
|
||
tid = _safe_int(tenant_id, 1)
|
||
keys: list[str] = []
|
||
if invalidate_system:
|
||
keys.append(self._system_key(tid))
|
||
if invalidate_project_list:
|
||
keys.append(self._project_list_key(tid))
|
||
if invalidate_signal_pending:
|
||
keys.append(self._signal_pending_key(tid))
|
||
if user_ids:
|
||
for uid in user_ids:
|
||
if _safe_int(uid, 0) > 0:
|
||
keys.append(self._user_key(tid, uid))
|
||
if not keys:
|
||
return
|
||
try:
|
||
redis.delete(*keys)
|
||
except Exception:
|
||
return
|
||
|
||
|
||
def register_context_cache_invalidation_hooks() -> None:
|
||
if getattr(register_context_cache_invalidation_hooks, "_registered", False):
|
||
return
|
||
|
||
invalidator = ContextCacheInvalidator()
|
||
|
||
@event.listens_for(Session, "after_flush")
|
||
def _collect_cache_invalidation(session: Session, _flush_context) -> None: # pragma: no cover
|
||
payload = session.info.get("_pmflow_cache_invalidation")
|
||
if not isinstance(payload, dict):
|
||
payload = {
|
||
"tenant_ids": set(),
|
||
"invalidate_system": False,
|
||
"invalidate_project_list": False,
|
||
"invalidate_signal_pending": False,
|
||
"user_ids": set(),
|
||
}
|
||
session.info["_pmflow_cache_invalidation"] = payload
|
||
|
||
objects = set(session.new).union(session.dirty).union(session.deleted)
|
||
for obj in objects:
|
||
tenant_id = _safe_int(getattr(obj, "tenant_id", 0), 0)
|
||
if tenant_id > 0:
|
||
payload["tenant_ids"].add(tenant_id)
|
||
|
||
if isinstance(obj, Project):
|
||
payload["invalidate_system"] = True
|
||
payload["invalidate_project_list"] = True
|
||
continue
|
||
|
||
if isinstance(obj, ProjectSignalLink):
|
||
payload["invalidate_system"] = True
|
||
payload["invalidate_project_list"] = True
|
||
continue
|
||
|
||
if isinstance(obj, Signal):
|
||
payload["invalidate_system"] = True
|
||
payload["invalidate_signal_pending"] = True
|
||
continue
|
||
|
||
if isinstance(obj, Task):
|
||
payload["invalidate_system"] = True
|
||
state = inspect(obj)
|
||
assignee_hist = state.attrs.assignee_id.history if hasattr(state.attrs, "assignee_id") else None
|
||
if assignee_hist is not None:
|
||
for old_value in assignee_hist.deleted:
|
||
uid = _safe_int(old_value, 0)
|
||
if uid > 0:
|
||
payload["user_ids"].add(uid)
|
||
for new_value in assignee_hist.added:
|
||
uid = _safe_int(new_value, 0)
|
||
if uid > 0:
|
||
payload["user_ids"].add(uid)
|
||
uid = _safe_int(getattr(obj, "assignee_id", 0), 0)
|
||
if uid > 0:
|
||
payload["user_ids"].add(uid)
|
||
continue
|
||
|
||
if isinstance(obj, UserProject):
|
||
payload["invalidate_system"] = True
|
||
payload["invalidate_project_list"] = True
|
||
uid = _safe_int(getattr(obj, "user_id", 0), 0)
|
||
if uid > 0:
|
||
payload["user_ids"].add(uid)
|
||
continue
|
||
|
||
if isinstance(obj, User):
|
||
payload["invalidate_system"] = True
|
||
uid = _safe_int(getattr(obj, "id", 0), 0)
|
||
if uid > 0:
|
||
payload["user_ids"].add(uid)
|
||
continue
|
||
|
||
if isinstance(obj, UserWorkload):
|
||
payload["invalidate_system"] = True
|
||
uid = _safe_int(getattr(obj, "user_id", 0), 0)
|
||
if uid > 0:
|
||
payload["user_ids"].add(uid)
|
||
continue
|
||
|
||
@event.listens_for(Session, "after_commit")
|
||
def _flush_cache_invalidation(session: Session) -> None: # pragma: no cover
|
||
payload = session.info.pop("_pmflow_cache_invalidation", None)
|
||
if not isinstance(payload, dict):
|
||
return
|
||
tenant_ids = payload.get("tenant_ids") or set()
|
||
if not tenant_ids:
|
||
tenant_ids = {_safe_int(os.getenv("DEFAULT_TENANT_ID", "1"), 1)}
|
||
for tenant_id in tenant_ids:
|
||
invalidator.invalidate(
|
||
tenant_id=_safe_int(tenant_id, 1),
|
||
invalidate_system=bool(payload.get("invalidate_system")),
|
||
invalidate_project_list=bool(payload.get("invalidate_project_list")),
|
||
invalidate_signal_pending=bool(payload.get("invalidate_signal_pending")),
|
||
user_ids=set(payload.get("user_ids") or set()),
|
||
)
|
||
|
||
@event.listens_for(Session, "after_rollback")
|
||
def _clear_cache_invalidation(session: Session) -> None: # pragma: no cover
|
||
session.info.pop("_pmflow_cache_invalidation", None)
|
||
|
||
setattr(register_context_cache_invalidation_hooks, "_registered", True)
|
||
|
||
|
||
context_cache_service = ContextCacheService()
|