feat: 新增岗位管理、提示词模板与资源标签,完善用户提示词与推荐问题接口

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
吉鑫升andClaude Opus 4.8 committed 2026-06-16 10:49:36 +08:00
1 parent 2f414c6e08
commit 3855c30edd
52 files changed
+3143 -57

No files matched your search

@@ -50,6 +50,7 @@ from app.gateway.routers import (
notifications,
parallel_agent_tasks,
parallel_agents,
positions,
public_embed,
public_leaderboard,
public_scheduled_tasks,
@@ -1397,6 +1398,9 @@ This gateway provides custom endpoints for models, MCP configuration, skills, an
# Tags API is mounted at /api/tags
app.include_router(tags.router)
# 岗位 (position) management API is mounted at /api/positions
app.include_router(positions.router)
# Thread Runs API (LangGraph Platform-compatible runs lifecycle)
app.include_router(thread_runs.router)
@@ -133,6 +133,14 @@ async def langgraph_runtime(app: FastAPI) -> AsyncGenerator[None, None]:
app.state.tag_store = make_tag_store(sf)
from deerflow.persistence.positions import make_position_store
app.state.position_store = make_position_store(sf)
from deerflow.services.position_sync import PositionSyncService
app.state.position_sync = PositionSyncService(sf, app.state.position_store, app.state.tag_store)
from deerflow.persistence.thread_shares import make_thread_share_store
app.state.thread_share_store = make_thread_share_store(sf)
@@ -371,6 +379,22 @@ def get_tag_store(request: Request) -> TagStore:
return val
def get_position_store(request: Request):
"""Return the 岗位 (position) store."""
val = getattr(request.app.state, "position_store", None)
if val is None:
raise HTTPException(status_code=503, detail="Position store not available")
return val
def get_position_sync(request: Request):
"""Return the position → subscription sync service."""
val = getattr(request.app.state, "position_sync", None)
if val is None:
raise HTTPException(status_code=503, detail="Position sync service not available")
return val
def get_thread_share_store(request: Request):
"""Return the conversation share-link store."""
val = getattr(request.app.state, "thread_share_store", None)
@@ -202,6 +202,21 @@ def _username_to_email(username: str) -> str:
return f"{local}@{domain}"
async def _sync_user_position(request: Request, user_id: str) -> None:
"""Best-effort: materialize the user's 岗位 (position) grants on login.
Ensures a user who has never been synced — e.g. a brand-new account that
inherits the ``is_default`` position — gets the default agents / tasks /
prompts loaded into their "我的" tables. Failures never block login.
"""
try:
sync = getattr(request.app.state, "position_sync", None)
if sync is not None:
await sync.sync_user(str(user_id))
except Exception:
logger.debug("position sync on login failed for user %s", user_id, exc_info=True)
async def _get_or_create_user_by_username(username: str):
"""Resolve a username to a local user, auto-registering when absent.
@@ -476,6 +491,7 @@ async def login_local(
_record_login_success(client_ip)
token = create_access_token(str(user.id), token_version=user.token_version)
_set_session_cookie(response, token, request)
await _sync_user_position(request, user.id)
return LoginResponse(
expires_in=get_auth_config().token_expiry_days * 24 * 3600,
@@ -520,6 +536,7 @@ async def login_by_username(
token = create_access_token(str(user.id), token_version=user.token_version)
_set_session_cookie(response, token, request)
await _sync_user_position(request, user.id)
return UsernameLoginResponse(
access_token=token,
@@ -570,6 +587,7 @@ async def login_by_token(
access_token = create_access_token(str(user.id), token_version=user.token_version)
_set_session_cookie(response, access_token, request)
await _sync_user_position(request, user.id)
return UsernameLoginResponse(
access_token=access_token,
@@ -600,6 +618,7 @@ async def register(request: Request, response: Response, body: RegisterRequest):
token = create_access_token(str(user.id), token_version=user.token_version)
_set_session_cookie(response, token, request)
await _sync_user_position(request, user.id)
return UserResponse(id=str(user.id), email=user.email, system_role=user.system_role)
@@ -0,0 +1,311 @@
"""岗位 (position) management API — admin only.
A position aggregates, per resource type, the tags whose resources are granted
to its members. Assigning a user to a position (1:1) materializes those grants
into the user's "我的" tables via the sync engine; recommended-question and
skill visibility are filtered live elsewhere.
All endpoints require ``system_role == "admin"`` (auth-disabled mode lets calls
through, matching the other admin routers).
"""
from __future__ import annotations
import logging
import uuid
from fastapi import APIRouter, Depends, HTTPException, Request
from pydantic import BaseModel, Field
from app.gateway.deps import get_optional_user_from_request, get_position_store, get_position_sync, get_tag_store
from deerflow.persistence.positions import POSITION_RESOURCE_TYPES, PositionStore
from deerflow.persistence.tags import TagStore
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/api/positions", tags=["positions"])
async def _require_admin(request: Request) -> None:
user = await get_optional_user_from_request(request)
if user is None:
return
if getattr(user, "system_role", None) != "admin":
raise HTTPException(status_code=403, detail="岗位管理仅限管理员")
def _validate_bindings(bindings: dict[str, list[str]]) -> dict[str, list[str]]:
out: dict[str, list[str]] = {}
for resource_type, tag_ids in bindings.items():
if resource_type not in POSITION_RESOURCE_TYPES:
raise HTTPException(status_code=422, detail=f"Invalid resource type '{resource_type}'. Allowed: {', '.join(POSITION_RESOURCE_TYPES)}")
out[resource_type] = list(tag_ids or [])
return out
# ------------------------------------------------------------------ schemas
class PositionResponse(BaseModel):
id: str
name: str
description: str = ""
is_default: bool = False
member_count: int = 0
created_at: str | None = None
updated_at: str | None = None
class PositionListResponse(BaseModel):
positions: list[PositionResponse]
resource_types: list[str] = Field(default_factory=lambda: list(POSITION_RESOURCE_TYPES))
class PositionCreateRequest(BaseModel):
name: str = Field(..., min_length=1, max_length=191)
description: str = Field(default="", max_length=1024)
is_default: bool = False
class PositionUpdateRequest(BaseModel):
name: str | None = Field(default=None, min_length=1, max_length=191)
description: str | None = Field(default=None, max_length=1024)
is_default: bool | None = None
class TagBindingsResponse(BaseModel):
position_id: str
bindings: dict[str, list[str]]
class TagBindingsRequest(BaseModel):
bindings: dict[str, list[str]] = Field(default_factory=dict, description="resource_type -> [tag_id]; omitted/empty type = default set")
class MemberResponse(BaseModel):
id: str
email: str = ""
class MembersResponse(BaseModel):
members: list[MemberResponse]
class MembersMutationRequest(BaseModel):
user_ids: list[str] = Field(..., min_length=1)
class UserPositionRequest(BaseModel):
position_id: str | None = Field(default=None, description="null clears the user's position")
class PositionUserResponse(BaseModel):
id: str
email: str = ""
system_role: str = "user"
position_id: str | None = None
class PositionUsersResponse(BaseModel):
users: list[PositionUserResponse]
# ----------------------------------------------------------------- position CRUD
@router.get("", response_model=PositionListResponse, summary="List Positions")
async def list_positions(request: Request, store: PositionStore = Depends(get_position_store)) -> PositionListResponse:
await _require_admin(request)
records = await store.list_positions()
return PositionListResponse(positions=[PositionResponse(**r) for r in records])
@router.get("/users", response_model=PositionUsersResponse, summary="List All Users + Their Position")
async def list_position_users(request: Request, store: PositionStore = Depends(get_position_store)) -> PositionUsersResponse:
await _require_admin(request)
users = await store.list_all_users()
return PositionUsersResponse(users=[PositionUserResponse(**u) for u in users])
@router.post("", response_model=PositionResponse, status_code=201, summary="Create Position")
async def create_position(request: Request, body: PositionCreateRequest, store: PositionStore = Depends(get_position_store)) -> PositionResponse:
await _require_admin(request)
try:
record = await store.create_position({"id": uuid.uuid4().hex, "name": body.name.strip(), "description": body.description, "is_default": body.is_default})
return PositionResponse(**record)
except ValueError as e:
raise HTTPException(status_code=409, detail=str(e))
@router.put("/{position_id}", response_model=PositionResponse, summary="Update Position")
async def update_position(
request: Request,
position_id: str,
body: PositionUpdateRequest,
store: PositionStore = Depends(get_position_store),
sync=Depends(get_position_sync),
) -> PositionResponse:
await _require_admin(request)
update_data = body.model_dump(exclude_unset=True)
if update_data.get("name"):
update_data["name"] = update_data["name"].strip()
try:
record = await store.update_position(position_id, update_data)
except ValueError as e:
raise HTTPException(status_code=409, detail=str(e))
if record is None:
raise HTTPException(status_code=404, detail="Position not found")
# Becoming the default changes what unassigned users inherit.
if update_data.get("is_default"):
await sync.sync_default_members()
return PositionResponse(**record)
@router.delete("/{position_id}", status_code=204, summary="Delete Position")
async def delete_position(
request: Request,
position_id: str,
store: PositionStore = Depends(get_position_store),
sync=Depends(get_position_sync),
) -> None:
await _require_admin(request)
member_ids = await store.list_member_ids(position_id)
deleted = await store.delete_position(position_id)
if not deleted:
raise HTTPException(status_code=404, detail="Position not found")
# Former members now fall back to the default position; re-sync them.
for uid in member_ids:
await sync.sync_user(uid)
# ----------------------------------------------------------------- tag bindings
@router.get("/{position_id}/tag-bindings", response_model=TagBindingsResponse, summary="Get Tag Bindings")
async def get_tag_bindings(request: Request, position_id: str, store: PositionStore = Depends(get_position_store)) -> TagBindingsResponse:
await _require_admin(request)
if await store.get_position(position_id) is None:
raise HTTPException(status_code=404, detail="Position not found")
bindings = await store.get_tag_bindings(position_id)
return TagBindingsResponse(position_id=position_id, bindings=bindings)
@router.put("/{position_id}/tag-bindings", response_model=TagBindingsResponse, summary="Set Tag Bindings")
async def set_tag_bindings(
request: Request,
position_id: str,
body: TagBindingsRequest,
store: PositionStore = Depends(get_position_store),
tag_store: TagStore = Depends(get_tag_store),
sync=Depends(get_position_sync),
) -> TagBindingsResponse:
await _require_admin(request)
if await store.get_position(position_id) is None:
raise HTTPException(status_code=404, detail="Position not found")
cleaned = _validate_bindings(body.bindings)
# Validate every tag id exists and matches its resource type.
for resource_type, tag_ids in cleaned.items():
if not tag_ids:
continue
known = {t["id"] for t in await tag_store.list_tags(resource_type)}
for tid in tag_ids:
if tid not in known:
raise HTTPException(status_code=422, detail=f"Tag '{tid}' is not a '{resource_type}' tag")
bindings = await store.set_tag_bindings(position_id, cleaned)
await sync.sync_position(position_id)
return TagBindingsResponse(position_id=position_id, bindings=bindings)
# --------------------------------------------------------------------- members
@router.get("/{position_id}/members", response_model=MembersResponse, summary="List Position Members")
async def list_members(request: Request, position_id: str, store: PositionStore = Depends(get_position_store)) -> MembersResponse:
await _require_admin(request)
if await store.get_position(position_id) is None:
raise HTTPException(status_code=404, detail="Position not found")
members = await store.list_members(position_id)
return MembersResponse(members=[MemberResponse(**m) for m in members])
@router.post("/{position_id}/members", response_model=MembersResponse, summary="Add Position Members")
async def add_members(
request: Request,
position_id: str,
body: MembersMutationRequest,
store: PositionStore = Depends(get_position_store),
sync=Depends(get_position_sync),
) -> MembersResponse:
await _require_admin(request)
if await store.get_position(position_id) is None:
raise HTTPException(status_code=404, detail="Position not found")
# Re-sync users leaving their previous position too, so its grants are dropped.
prev_positions = {uid: await store.get_user_position_id(uid) for uid in body.user_ids}
await store.assign_users(position_id, body.user_ids)
for uid in body.user_ids:
await sync.sync_user(uid)
prev = prev_positions.get(uid)
if prev and prev != position_id:
logger.debug("user %s moved from position %s to %s", uid, prev, position_id)
members = await store.list_members(position_id)
return MembersResponse(members=[MemberResponse(**m) for m in members])
@router.delete("/{position_id}/members", response_model=MembersResponse, summary="Remove Position Members")
async def remove_members(
request: Request,
position_id: str,
body: MembersMutationRequest,
store: PositionStore = Depends(get_position_store),
sync=Depends(get_position_sync),
) -> MembersResponse:
await _require_admin(request)
if await store.get_position(position_id) is None:
raise HTTPException(status_code=404, detail="Position not found")
# Only unassign users that are actually in this position.
member_ids = set(await store.list_member_ids(position_id))
victims = [uid for uid in body.user_ids if uid in member_ids]
await store.unassign_users(victims)
for uid in victims:
await sync.sync_user(uid)
members = await store.list_members(position_id)
return MembersResponse(members=[MemberResponse(**m) for m in members])
@router.post("/{position_id}/resync", summary="Re-sync Position Members")
async def resync_position(
request: Request,
position_id: str,
store: PositionStore = Depends(get_position_store),
sync=Depends(get_position_sync),
) -> dict:
await _require_admin(request)
if await store.get_position(position_id) is None:
raise HTTPException(status_code=404, detail="Position not found")
count = await sync.sync_position(position_id)
return {"synced": count}
# --------------------------------------------------- per-user position (1:1)
@router.put("/users/{user_id}", response_model=PositionResponse | None, summary="Set User Position")
async def set_user_position(
request: Request,
user_id: str,
body: UserPositionRequest,
store: PositionStore = Depends(get_position_store),
sync=Depends(get_position_sync),
) -> PositionResponse | None:
await _require_admin(request)
if body.position_id:
if await store.get_position(body.position_id) is None:
raise HTTPException(status_code=404, detail="Position not found")
await store.assign_users(body.position_id, [user_id])
else:
await store.unassign_users([user_id])
await sync.sync_user(user_id)
if not body.position_id:
return None
record = await store.get_position(body.position_id)
return PositionResponse(**record) if record else None
@@ -6,13 +6,22 @@ import logging
from datetime import datetime
from uuid import uuid4
from fastapi import APIRouter, HTTPException, Request
from fastapi import APIRouter, HTTPException, Query, Request
from pydantic import BaseModel, Field
from deerflow.runtime.user_context import get_effective_user_id
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/api", tags=["recommended-questions"])
def _current_user_id(request: Request) -> str:
user = getattr(request.state, "user", None)
if user is not None:
return str(user.id)
return get_effective_user_id()
class RecommendedQuestionResponse(BaseModel):
id: str
title: str
@@ -50,9 +59,25 @@ def _get_store(request: Request):
@router.get("/recommended-questions", response_model=RecommendedQuestionsListResponse)
async def list_recommended_questions(request: Request) -> RecommendedQuestionsListResponse:
async def list_recommended_questions(
request: Request,
all: bool = Query(default=False, description="Admin management view: return every question, unfiltered by 岗位."),
) -> RecommendedQuestionsListResponse:
store = _get_store(request)
rows = await store.list_all()
if not all:
# Filter by the caller's 岗位 (position) visibility. ``None`` =
# unrestricted (no skill/question tag binding → show all default
# questions); a set = show only the questions carrying the bound tags.
sync = getattr(request.app.state, "position_sync", None)
if sync is not None:
try:
visible = await sync.resolve_visible(_current_user_id(request), "recommended_question")
except Exception:
logger.debug("recommended-question visibility resolve failed", exc_info=True)
visible = None
if visible is not None:
rows = [r for r in rows if r["id"] in visible]
return RecommendedQuestionsListResponse(questions=[RecommendedQuestionResponse(**r) for r in rows])
@@ -777,6 +777,7 @@ async def list_skills(
search: str | None = Query(default=None, description="Case-insensitive fuzzy match on skill name or Chinese name (name_zh)"),
tag_ids: list[str] | None = Query(default=None, description="Keep skills carrying any of these tags (OR)"),
square: str | None = Query(default=None, description="Keep only skills filed under this publish square (发布广场). Omit for all squares."),
scope: str | None = Query(default=None, description="``mine`` filters to the skills the caller's 岗位 (position) makes visible."),
sort: str = Query(
default="time_desc",
pattern="^(time_desc|time_asc|activity_desc|activity_asc|usage_desc|usage_asc|name_asc|name_desc)$",
@@ -846,6 +847,19 @@ async def list_skills(
for r in responses
if (r.square_id or "") == square_id or (square_is_default and not (r.square_id or ""))
]
# 岗位 (position) visibility: when the caller asks for "我的技能",
# restrict to the skills their position grants. ``None`` from the sync
# service = unrestricted (no skill tag binding → all skills visible).
if scope == "mine" and not admin:
sync = getattr(request.app.state, "position_sync", None)
if sync is not None:
try:
visible = await sync.resolve_visible(user_id, "skill")
except Exception:
logger.debug("skill visibility resolve failed", exc_info=True)
visible = None
if visible is not None:
responses = [r for r in responses if r.name in visible]
responses = _sort_skill_responses(responses, sort)
return SkillsListResponse(skills=responses)
except HTTPException:
@@ -13,12 +13,21 @@ from uuid import uuid4
from fastapi import APIRouter, HTTPException, Request
from pydantic import BaseModel, Field
from app.gateway.deps import get_optional_user_from_request
from deerflow.runtime.user_context import get_effective_user_id
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/api/user-prompts", tags=["user-prompts"])
async def _require_admin(request: Request) -> None:
user = await get_optional_user_from_request(request)
if user is None:
return
if getattr(user, "system_role", None) != "admin":
raise HTTPException(status_code=403, detail="提示词模板管理仅限管理员")
class UserPromptResponse(BaseModel):
id: str
title: str = ""
@@ -26,10 +35,40 @@ class UserPromptResponse(BaseModel):
sort_order: int = 0
# Optional single-agent association. NULL = global (shown for every agent).
agent_id: str | None = None
# ``"user"`` (the user's own) or ``"position"`` (granted by their 岗位).
origin: str = "user"
created_at: datetime | str | None = None
updated_at: datetime | str | None = None
class PromptTemplateResponse(BaseModel):
id: str
title: str = ""
content: str
sort_order: int = 0
agent_id: str | None = None
created_at: datetime | str | None = None
updated_at: datetime | str | None = None
class PromptTemplatesListResponse(BaseModel):
templates: list[PromptTemplateResponse]
class PromptTemplateCreateRequest(BaseModel):
title: str = Field(default="", max_length=255)
content: str = Field(..., min_length=1)
sort_order: int = Field(default=0)
agent_id: str | None = Field(default=None, max_length=64)
class PromptTemplateUpdateRequest(BaseModel):
title: str | None = Field(default=None, max_length=255)
content: str | None = Field(default=None, min_length=1)
sort_order: int | None = None
agent_id: str | None = Field(default=None, max_length=64)
class UserPromptsListResponse(BaseModel):
prompts: list[UserPromptResponse]
@@ -118,3 +157,72 @@ async def delete_user_prompt(request: Request, prompt_id: str) -> None:
deleted = await store.delete(prompt_id, user_id)
if not deleted:
raise HTTPException(status_code=404, detail="Prompt not found")
# --------------------------------------------------- admin prompt templates
#
# Templates are admin-maintained prompts that carry tags (target_type
# ``user_prompt`` via /api/tags/assignments). The 岗位 (position) sync engine
# clones the templates whose tags a user's position grants into that user's own
# prompts (origin='position'). Tagging itself reuses the generic tags API.
def _require_template_store(request: Request):
store = _get_store(request)
if not hasattr(store, "list_templates"):
raise HTTPException(status_code=503, detail="Prompt templates require a database backend")
return store
@router.get("/templates", response_model=PromptTemplatesListResponse)
async def list_prompt_templates(request: Request) -> PromptTemplatesListResponse:
await _require_admin(request)
store = _require_template_store(request)
rows = await store.list_templates()
return PromptTemplatesListResponse(templates=[PromptTemplateResponse(**r) for r in rows])
@router.post("/templates", response_model=PromptTemplateResponse, status_code=201)
async def create_prompt_template(request: Request, body: PromptTemplateCreateRequest) -> PromptTemplateResponse:
await _require_admin(request)
store = _require_template_store(request)
admin_id = _current_user_id(request)
row = await store.create_template(
admin_id,
{
"id": uuid4().hex,
"title": (body.title or "").strip(),
"content": body.content,
"sort_order": body.sort_order,
"agent_id": (body.agent_id or "").strip() or None,
},
)
return PromptTemplateResponse(**row)
@router.put("/templates/{template_id}", response_model=PromptTemplateResponse)
async def update_prompt_template(request: Request, template_id: str, body: PromptTemplateUpdateRequest) -> PromptTemplateResponse:
await _require_admin(request)
store = _require_template_store(request)
data: dict = {}
if body.title is not None:
data["title"] = body.title.strip()
if body.content is not None:
data["content"] = body.content
if body.sort_order is not None:
data["sort_order"] = body.sort_order
if "agent_id" in body.model_fields_set:
data["agent_id"] = (body.agent_id or "").strip() or None
row = await store.update_template(template_id, data)
if row is None:
raise HTTPException(status_code=404, detail="Template not found")
return PromptTemplateResponse(**row)
@router.delete("/templates/{template_id}", status_code=204)
async def delete_prompt_template(request: Request, template_id: str) -> None:
await _require_admin(request)
store = _require_template_store(request)
deleted = await store.delete_template(template_id)
if not deleted:
raise HTTPException(status_code=404, detail="Template not found")