mirror of
https://github.com/ThearchyHelios/AgentLab.git
synced 2026-11-15 23:51:59 +00:00
使用者选人(后端):按用途给候选池,开登录时入口表单、待办表单的选人控件按同一个池核对
为什么:使用者在选人控件里没有候选(名录只给搭建者),服务端也不核对。填错的名字原样派下去,待办给了一个不存在的人,
没人能处理、也不报错(05-已知遗留 (b))。名录又不能整份放开给使用者(只读与最小可见)。
做了什么:
- auth/directory 新增候选池:form 用途缺省是「能用这个应用的人」——使用及以上的授权(人;组列出组本身并展开成员),
加上管理它的人(管理员、建应用的人);应用授权给了所有人时池是全部启用的人(open),不带前缀 q 不列(needs_query)。
字段可以声明 x-principal: {pool: app | group:<组> | slot:<岗位>}(slot 按这次用到的应用版本的 bindings 展开)。
review 用途是启用的搭建者和管理员(同 personal._review_targets)。停用的人一律不列。
- GET /api/directory/candidates(任何登录的人;main.py 路由清单只加一行):purpose=form 带 app_id+entry 或 task_id、field,
调用的人不能用这个应用 403;只回 {users:[{username, display_name}], groups, truncated, needs_query?},不给停用、角色、
邮箱、组成员;q 按用户名或显示名开头筛,limit 最多 50。/api/directory 仍只给搭建者。
- 开了登录时 start_entry 和待办表单提交按同一个池核对,不在池里 422,errors 的 code=principal(FORM_ERROR_CODES 加一项),
话写成「「x」不在可选的人里,请从候选中选择」(单点登录另说要先登录一次才进名录)。直接生效(遗留-Q4 按推荐)。
关登录照旧手填、不核对;不属于应用的待办(试运行、画布)没有池,不核对。
- apps/forms:x-principal 进 _FIELD_KEYS,validate_form_schema 查写法(只能写在选人控件上、只能是三种池)。
搭建者没有授权时按 apps/access 只能「查看全部实例」,不算池里的人——池按「能用」算,这一点写进了 app_pool 的说明。
测试:test_directory_candidates(只给名字、停用的不列、前缀筛、没使用权 403、名录仍 403;授权给所有人要前缀、截断;review
只出搭建者和管理员;入口表单不在池 422、停用的 422、组名和池里的人放行;待办表单同一个池;声明 group:<组> 收窄;关登录
任何名字照收;x-principal 写法校验)。
This commit is contained in:
@@ -27,6 +27,9 @@ router = APIRouter(prefix="/api", tags=["identity"])
|
||||
#: 人和组的名录(GET /api/directory):只读、给搭建者及以上(main.py 挂 require_role("builder")),岗位绑定、应用授权的
|
||||
#: 选人控件据此给候选、核对填的名字在不在。只有用户名、显示名、是否停用和组名,不含邮箱、角色、登录时间
|
||||
directory_router = APIRouter(prefix="/api", tags=["identity"])
|
||||
#: 使用者选人的候选(GET /api/directory/candidates,05-已知遗留 (b)):任何登录的人都能调(main.py 挂 require_role("user")),
|
||||
#: 按用途给候选池,只有用户名和显示名
|
||||
candidates_router = APIRouter(prefix="/api", tags=["identity"])
|
||||
|
||||
|
||||
def _iso(value: Any) -> str | None:
|
||||
@@ -224,6 +227,56 @@ async def directory(session: AsyncSession = Depends(get_session)) -> dict[str, A
|
||||
"groups": [{"name": g.name, "label": g.label} for g in known.groups.values()]}
|
||||
|
||||
|
||||
@candidates_router.get("/directory/candidates")
|
||||
async def candidates(purpose: str, app_id: str | None = None, entry: str | None = None, task_id: str | None = None,
|
||||
field: str | None = None, q: str | None = None, limit: int = 20,
|
||||
session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
|
||||
"""使用者选人时的候选:{users: [{username, display_name}], groups: [{name, label}], truncated, needs_query?}。
|
||||
|
||||
不给是否停用(停用的直接不列)、角色、邮箱、组成员。purpose=form:表单里的选人控件,带 app_id 和 entry(入口表单)
|
||||
或 task_id(待办表单)、field(哪个控件),池按字段的 x-principal 算、缺省是能用这个应用的人,要求调用的人能用这个
|
||||
应用(否则 403);应用授权给了所有人时不带前缀 q 不列(needs_query)。purpose=review:个人应用提交审核,启用的搭建者
|
||||
和管理员。q 按用户名或显示名的开头筛,limit 最多 50。开了登录时提交的值按同一个池核对(auth/directory.principal_errors)。"""
|
||||
from app.api.coded import CodedHTTPException
|
||||
from app.api.deps import current_principal
|
||||
from app.apps.access import app_role, at_least
|
||||
from app.apps.tree import entry_of, resolve_form
|
||||
from app.auth.directory import PURPOSES, field_pool, principal_fields, review_pool
|
||||
from app.db.models_apps import App, AppVersion
|
||||
from app.db.models_process import Task
|
||||
|
||||
if purpose not in PURPOSES:
|
||||
raise CodedHTTPException(422, f"候选的用途只能是 {' / '.join(PURPOSES)}", "candidates_purpose")
|
||||
if purpose == "review":
|
||||
return (await review_pool(session)).pick(q, limit) | {"groups": []}
|
||||
principal = current_principal()
|
||||
bindings: dict[str, Any] | None = None
|
||||
form: Any = None
|
||||
task = await session.get(Task, task_id) if task_id else None
|
||||
app = await session.get(App, task.app_id if task is not None else app_id) if (task or app_id) else None
|
||||
if app is None or (task_id and task is None):
|
||||
raise CodedHTTPException(404, "应用或待办不存在", "candidates_not_found")
|
||||
if not at_least(await app_role(session, principal, app), "use"):
|
||||
raise CodedHTTPException(403, "你没有这个应用的使用权限,看不到它的候选人", "candidates_forbidden")
|
||||
if task is not None:
|
||||
form = task.form
|
||||
if task.app_version is not None:
|
||||
bindings = await session.scalar(select(AppVersion.bindings).where(
|
||||
AppVersion.app_id == app.id, AppVersion.version == task.app_version))
|
||||
else:
|
||||
version = (await session.execute(select(AppVersion).where(
|
||||
AppVersion.app_id == app.id, AppVersion.version == app.published_version))).scalar_one_or_none() \
|
||||
if app.published_version else None
|
||||
spec = version.spec if version is not None else {}
|
||||
found = entry_of(spec or {}, entry or "") if entry else None
|
||||
form = resolve_form(spec or {}, found.get("form")) if found else None
|
||||
bindings = version.bindings if version is not None else None
|
||||
target = principal_fields(form).get(field or "")
|
||||
if target is None:
|
||||
raise CodedHTTPException(404, "表单里没有这个选人控件", "candidates_not_found")
|
||||
return (await field_pool(session, app, bindings, target)).pick(q, limit)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- 审计
|
||||
|
||||
|
||||
|
||||
@@ -113,6 +113,13 @@ async def start_entry(app_id: str, entry_id: str, values: dict[str, Any], princi
|
||||
form = resolve_form(spec, entry.get("form")) or {"type": "object", "properties": {}}
|
||||
if errors := validate_form(form, values if isinstance(values, dict) else None):
|
||||
raise FormRejected(errors)
|
||||
# 选人控件:开了登录时按候选池核对(auth/directory.py,05-已知遗留 (b))。以前原样传下去,填错的名字会把待办
|
||||
# 派给一个不存在的人——没人能处理,也不报错
|
||||
from app.auth.directory import principal_errors
|
||||
|
||||
if errors := await principal_errors(session, app, version.bindings, form, values,
|
||||
getattr(principal, "mode", "off")):
|
||||
raise FormRejected(errors)
|
||||
# 表单里的文件(docs/design/normal-user-apps.md N9):核对是提交人在这个入口传的、还没用过,先占住;表单值换成
|
||||
# 登记的那一份引用(连同 sha256 进运行输入、随封存固定)。发起成功绑到这次运行,发起不成放回去
|
||||
values, claimed = await _claim_files(form, values, principal, app.id, entry_id)
|
||||
|
||||
@@ -28,6 +28,8 @@ _FIELD_KEYS = frozenset({
|
||||
"minLength", "maxLength", "maxItems", "format", "items", "x-widget",
|
||||
# 文件控件的限制:accept(类型或扩展名的列表)、max_mb(docs/design/normal-user-apps.md §3.8)
|
||||
"x-file",
|
||||
# 选人控件的候选池:{pool: app | group:<组> | slot:<岗位>}(auth/directory.py,05-已知遗留 (b))
|
||||
"x-principal",
|
||||
})
|
||||
#: 文件控件只认这几项写法
|
||||
_FILE_FIELD_KEYS = frozenset({"type", "title", "description", "readOnly", "x-widget", "x-file"})
|
||||
@@ -88,6 +90,13 @@ def _field_problems(field: Any) -> list[str]:
|
||||
return out + _file_field_problems(field)
|
||||
if "x-file" in field:
|
||||
out.append("不是文件控件,不能写文件的限制")
|
||||
if "x-principal" in field:
|
||||
from app.auth.directory import pool_problem
|
||||
|
||||
if field.get("x-widget") != "principal":
|
||||
out.append("不是选人控件,不能写候选范围")
|
||||
elif problem := pool_problem(field["x-principal"]):
|
||||
out.append(problem)
|
||||
if kind not in FORM_TYPES:
|
||||
out.append(f"的类型只能是 {' / '.join(FORM_TYPES)}")
|
||||
if "format" in field and field["format"] not in FORM_FORMATS:
|
||||
@@ -153,7 +162,7 @@ def _clean_schema(form: dict[str, Any]) -> dict[str, Any]:
|
||||
continue
|
||||
props[name] = {k: v for k, v in field.items()
|
||||
if k in _FIELD_KEYS and k not in ("format", "x-widget", "x-enum-labels", "title",
|
||||
"description", "readOnly", "default")}
|
||||
"description", "readOnly", "default", "x-principal")}
|
||||
return {"type": "object", "properties": props, "required": [r for r in form.get("required") or [] if r in props]}
|
||||
|
||||
|
||||
|
||||
@@ -47,9 +47,10 @@ FILE_FIELD_TYPE = "object"
|
||||
FILE_REF_KEYS = ("file_id", "name", "size", "sha256", "type")
|
||||
#: 表单字段能用的 format。不支持 pattern:JS 和 Python 的正则语义不同,会出现前端放行、后端拒收
|
||||
FORM_FORMATS = ("date", "date-time", "email", "uri")
|
||||
#: 表单校验错误的 code。file:文件控件的值不对(没上传、不是本人传的、已经用过、类型或大小不符,app/files/store.py)
|
||||
#: 表单校验错误的 code。file:文件控件的值不对(没上传、不是本人传的、已经用过、类型或大小不符,app/files/store.py);
|
||||
#: principal:开了登录时选人控件的值不在候选池里(auth/directory.principal_errors)
|
||||
FORM_ERROR_CODES = ("required", "type", "enum", "minimum", "maximum", "min_length", "max_length", "max_items", "format",
|
||||
"file")
|
||||
"file", "principal")
|
||||
|
||||
|
||||
class _Strict(BaseModel):
|
||||
|
||||
@@ -1,6 +1,10 @@
|
||||
"""人和组的名录:选人控件的候选(GET /api/directory)、应用检查核对岗位绑定和授权、改授权时核对填的名字,同一处取、
|
||||
同一个口径(停用的人也在名录里,标 disabled:已经绑着他的岗位、授权要能认出「这个人停用了」,不是「没有这个人」)。
|
||||
|
||||
使用者选人(表单里的选人控件、个人应用提交审核)不拿整份名录,拿按用途算的候选池(candidates,GET
|
||||
/api/directory/candidates):只有这件事能选的人,只给用户名和显示名,停用的不列;开了登录时提交的值按同一个池核对
|
||||
(docs/design/next-round/05-已知遗留.md (b))。名录整份仍只给搭建者。
|
||||
|
||||
名录里对不上怎么算看登录方式(同前端 PrincipalPicker):
|
||||
- 账号密码登录:人和组都在本系统里建,名录里没有就是填错了(或人被删了),停用的人处理不了待办——都算错;
|
||||
- 单点登录:人和组第一次登录后才进名录,名录里没有的照实提醒、不拒收;停用的人名录里认得出,照样算错;
|
||||
@@ -10,7 +14,7 @@ from __future__ import annotations
|
||||
|
||||
from collections.abc import Iterable
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Literal
|
||||
from typing import Any, Literal
|
||||
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
@@ -95,3 +99,175 @@ def mismatch(directory: Directory, mode: str, kind: str, name: str) -> Mismatch
|
||||
return Mismatch(kind, name, problem, False,
|
||||
f"{what}名录里还没有:单点登录的人和组第一次登录后才进名录,名字要和身份提供方里的一致才生效")
|
||||
return Mismatch(kind, name, problem, True, f"{what}名录里没有")
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# 候选池:使用者选人时能选谁(05-已知遗留 (b))
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
#: 候选池的用途:form 表单里的选人控件(入口表单、待办表单);review 个人应用提交审核选审核的人
|
||||
PURPOSES = ("form", "review")
|
||||
#: 一次最多给几位候选
|
||||
CANDIDATES_MAX = 50
|
||||
#: 表单字段声明候选池(x-principal.pool):app 能用这个应用的人(缺省);group:<组> 这个组的成员;slot:<岗位> 这个岗位
|
||||
#: 绑定的人和组(按应用版本的 bindings)
|
||||
POOL_APP = "app"
|
||||
POOL_GROUP = "group:"
|
||||
POOL_SLOT = "slot:"
|
||||
|
||||
|
||||
def pool_problem(value: Any) -> str | None:
|
||||
"""x-principal 的写法对不对:只能是 {pool: app | group:<组> | slot:<岗位>}。没问题为 None。"""
|
||||
if not isinstance(value, dict) or set(value) != {"pool"} or not isinstance(value.get("pool"), str):
|
||||
return "的候选范围只能写 {\"pool\": \"app\"}、{\"pool\": \"group:组名\"} 或 {\"pool\": \"slot:岗位\"}"
|
||||
pool = value["pool"].strip()
|
||||
if pool == POOL_APP:
|
||||
return None
|
||||
for prefix in (POOL_GROUP, POOL_SLOT):
|
||||
if pool.startswith(prefix) and pool[len(prefix):].strip():
|
||||
return None
|
||||
return "的候选范围只能是 app(能用这个应用的人)、group:组名 或 slot:岗位"
|
||||
|
||||
|
||||
def pool_of(field: Any) -> str:
|
||||
"""表单字段声明的候选池;没声明、写法不对的按缺省(能用这个应用的人)。"""
|
||||
setting = field.get("x-principal") if isinstance(field, dict) else None
|
||||
if isinstance(setting, dict) and pool_problem(setting) is None:
|
||||
return setting["pool"].strip()
|
||||
return POOL_APP
|
||||
|
||||
|
||||
@dataclass
|
||||
class Pool:
|
||||
"""一个候选池。open:池就是全部启用的人(应用授权给了所有人)——不带前缀不列,免得等于发通讯录。"""
|
||||
users: dict[str, DirectoryUser] = field(default_factory=dict)
|
||||
groups: dict[str, DirectoryGroup] = field(default_factory=dict)
|
||||
open: bool = False
|
||||
|
||||
def has(self, name: str) -> bool:
|
||||
"""提交的这个名字在不在池里(用户名或组名)。"""
|
||||
return name in self.users or name in self.groups
|
||||
|
||||
def pick(self, q: str | None, limit: int = CANDIDATES_MAX) -> dict[str, Any]:
|
||||
"""接口给的那一份:{users: [{username, display_name}], groups: [{name, label}], truncated};按前缀筛
|
||||
(用户名或显示名,不分大小写)。池是 open 的、又没带前缀:什么都不给,needs_query 为真。"""
|
||||
prefix = (q or "").strip().lower()
|
||||
if self.open and not prefix:
|
||||
return {"users": [], "groups": [], "truncated": False, "needs_query": True}
|
||||
limit = max(1, min(int(limit or CANDIDATES_MAX), CANDIDATES_MAX))
|
||||
|
||||
def hit(*names: str) -> bool:
|
||||
return not prefix or any(n.lower().startswith(prefix) for n in names if n)
|
||||
|
||||
users = [u for u in sorted(self.users.values(), key=lambda u: u.username) if hit(u.username, u.display_name)]
|
||||
groups = [g for g in sorted(self.groups.values(), key=lambda g: g.name) if hit(g.name, g.label)]
|
||||
return {"users": [{"username": u.username, "display_name": u.display_name} for u in users[:limit]],
|
||||
"groups": [{"name": g.name, "label": g.label} for g in groups[:limit]],
|
||||
"truncated": len(users) > limit or len(groups) > limit}
|
||||
|
||||
|
||||
async def _members(session: AsyncSession, group: str) -> dict[str, DirectoryUser]:
|
||||
from app.db.models import Group, GroupMember, User
|
||||
|
||||
rows = (await session.execute(
|
||||
select(User).join(GroupMember, GroupMember.user_id == User.id).join(Group, Group.id == GroupMember.group_id)
|
||||
.where(Group.name == group, User.disabled.is_(False)))).scalars()
|
||||
return {u.username: DirectoryUser(u.username, u.display_name or u.username, False) for u in rows}
|
||||
|
||||
|
||||
async def _people(session: AsyncSession, items: Iterable[tuple[str, str]]) -> Pool:
|
||||
"""一组(种类, 名字)展开成池:人按名录认(停用的、名录里没有的不列),组列出组本身、再展开成员。"""
|
||||
from app.db.models import Group, User
|
||||
|
||||
pool = Pool()
|
||||
items = list(items)
|
||||
names = sorted({n for k, n in items if k == "user" and n})
|
||||
if names:
|
||||
for u in (await session.execute(select(User).where(User.username.in_(names), User.disabled.is_(False))))\
|
||||
.scalars():
|
||||
pool.users[u.username] = DirectoryUser(u.username, u.display_name or u.username, False)
|
||||
groups = sorted({n for k, n in items if k == "group" and n})
|
||||
if groups:
|
||||
for g in (await session.execute(select(Group).where(Group.name.in_(groups)))).scalars():
|
||||
pool.groups[g.name] = DirectoryGroup(g.name, g.label or g.name)
|
||||
pool.users.update(await _members(session, g.name))
|
||||
return pool
|
||||
|
||||
|
||||
async def _everyone(session: AsyncSession) -> Pool:
|
||||
from app.db.models import Group, User
|
||||
|
||||
pool = Pool(open=True)
|
||||
for u in (await session.execute(select(User).where(User.disabled.is_(False)))).scalars():
|
||||
pool.users[u.username] = DirectoryUser(u.username, u.display_name or u.username, False)
|
||||
for g in (await session.execute(select(Group))).scalars():
|
||||
pool.groups[g.name] = DirectoryGroup(g.name, g.label or g.name)
|
||||
return pool
|
||||
|
||||
|
||||
async def app_pool(session: AsyncSession, app: Any) -> Pool:
|
||||
"""能用这个应用的人:使用及以上的授权(人、组展开成员),加上管理它的人(管理员、建它的人)。授权给了所有人的,池就是
|
||||
全部启用的人(open)。按 apps/access 的口径:搭建者没有授权时只能查看全部实例,不算「能用」的候选。"""
|
||||
from app.apps.access import RANK, grants_of
|
||||
from app.db.models import User
|
||||
|
||||
grants = [g for g in await grants_of(session, app.id) if RANK.get(g.role, 0) >= RANK["use"]]
|
||||
if any(g.principal_kind == "everyone" for g in grants):
|
||||
return await _everyone(session)
|
||||
admins = (await session.execute(select(User.username).where(User.role == "admin"))).scalars()
|
||||
items = [(g.principal_kind, g.principal) for g in grants] + [("user", a) for a in admins]
|
||||
if getattr(app, "created_by", None):
|
||||
items.append(("user", app.created_by))
|
||||
return await _people(session, items)
|
||||
|
||||
|
||||
async def field_pool(session: AsyncSession, app: Any, bindings: dict[str, Any] | None, field: Any) -> Pool:
|
||||
"""表单里一个选人控件的候选池(按字段的 x-principal,缺省能用这个应用的人)。bindings 是这次用到的应用版本的绑定。"""
|
||||
pool = pool_of(field)
|
||||
if pool.startswith(POOL_GROUP):
|
||||
name = pool[len(POOL_GROUP):].strip()
|
||||
return Pool(users=await _members(session, name))
|
||||
if pool.startswith(POOL_SLOT):
|
||||
bound = ((bindings or {}).get("slots") or {}).get(pool[len(POOL_SLOT):].strip())
|
||||
items = [(str(b.get("kind") or "user"), str(b.get("name") or "")) for b in bound or [] if isinstance(b, dict)]
|
||||
if any(k == "everyone" for k, _ in items):
|
||||
return await _everyone(session)
|
||||
return await _people(session, items)
|
||||
return await app_pool(session, app)
|
||||
|
||||
|
||||
async def review_pool(session: AsyncSession) -> Pool:
|
||||
"""个人应用提交审核能交给谁:启用的搭建者和管理员(同 blueprints/personal._review_targets 的规则)。"""
|
||||
from app.db.models import User
|
||||
|
||||
rows = (await session.execute(select(User).where(User.role.in_(("builder", "admin")),
|
||||
User.disabled.is_(False)))).scalars()
|
||||
return Pool(users={u.username: DirectoryUser(u.username, u.display_name or u.username, False) for u in rows})
|
||||
|
||||
|
||||
def principal_fields(form: Any) -> dict[str, dict[str, Any]]:
|
||||
"""表单里的选人控件:{字段名: 字段}。"""
|
||||
props = form.get("properties") if isinstance(form, dict) else None
|
||||
return {name: f for name, f in (props or {}).items() if isinstance(f, dict) and f.get("x-widget") == "principal"}
|
||||
|
||||
|
||||
#: 选人控件的值不在候选池里时表单错误的 code(apps/spec.FORM_ERROR_CODES 的 principal)
|
||||
PRINCIPAL_ERROR_CODE = "principal"
|
||||
|
||||
|
||||
async def principal_errors(session: AsyncSession, app: Any, bindings: dict[str, Any] | None, form: Any,
|
||||
values: Any, mode: str) -> list[dict[str, str]]:
|
||||
"""开了登录时按候选池核对表单里选人控件的值:不在池里的按表单错误交回(code=principal),话写成「「x」不在可选的人里」。
|
||||
关登录不核对:没有用户表,签批记的是各自填的署名。没填的不在这里报(必填由表单校验报)。"""
|
||||
if mode == "off" or not isinstance(values, dict):
|
||||
return []
|
||||
out: list[dict[str, str]] = []
|
||||
for name, f in principal_fields(form).items():
|
||||
value = values.get(name)
|
||||
if value in (None, "") or not isinstance(value, str):
|
||||
continue
|
||||
pool = await field_pool(session, app, bindings, f)
|
||||
if not pool.has(value.strip()):
|
||||
hint = ":单点登录的人要先登录一次才进名录" if mode == "oidc" else ",请从候选中选择"
|
||||
out.append({"path": name, "code": PRINCIPAL_ERROR_CODE, "message": f"「{value.strip()}」不在可选的人里{hint}"})
|
||||
return out
|
||||
|
||||
@@ -238,6 +238,7 @@ for router, guard in (
|
||||
(identity_api.router, _ADMIN),
|
||||
# 选人用的名录(用户名、显示名、是否停用、组名):岗位绑定、应用授权由搭建者做,只读
|
||||
(identity_api.directory_router, _BUILDER),
|
||||
(identity_api.candidates_router, _USER),
|
||||
# 能力登记、端点:搭建者只读,改动在接口里要管理员
|
||||
(capabilities_api.router, _BUILDER),
|
||||
# 普通用户建应用:个人应用的接口共用 /api/apps 前缀,要在 apps_api 之前登记;蓝图助手共用 /api/copilot 前缀,
|
||||
|
||||
@@ -406,6 +406,22 @@ def _check_hash(card: dict[str, Any], given: Any, *, approving: bool) -> None:
|
||||
status_code=422, code="payload_hash_mismatch")
|
||||
|
||||
|
||||
async def _check_principals(session: AsyncSession, task: Task, principal: Any, values: dict[str, Any]) -> None:
|
||||
"""待办表单里的选人控件:开了登录时按候选池核对(同入口表单,auth/directory.principal_errors)。不属于应用的待办
|
||||
(试运行、画布)没有池,不核对。"""
|
||||
from app.auth.directory import principal_errors
|
||||
|
||||
if not task.app_id or getattr(principal, "mode", "off") == "off":
|
||||
return
|
||||
app = await session.get(App, task.app_id)
|
||||
if app is None:
|
||||
return
|
||||
bindings = await session.scalar(select(AppVersion.bindings).where(
|
||||
AppVersion.app_id == task.app_id, AppVersion.version == task.app_version)) if task.app_version else None
|
||||
if errors := await principal_errors(session, app, bindings, task.form, values, principal.mode):
|
||||
raise FormInvalid(errors)
|
||||
|
||||
|
||||
def _validated(form: dict[str, Any], values: dict[str, Any]) -> dict[str, Any]:
|
||||
from app.apps.forms import validate_form
|
||||
|
||||
@@ -491,6 +507,8 @@ async def respond(task_id: str, principal: Any, *, decision: Any, values: dict[s
|
||||
rows = (await _assignments(session, [task.id])).get(task.id, [])
|
||||
mine = _pick(task, rows, principal)
|
||||
response, verdict = _engine_response(task, approval, decision, values, note, payload_hash)
|
||||
if task.form and verdict in ("approve", "submit") and values:
|
||||
await _check_principals(session, task, principal, values)
|
||||
response = await _bind_files(session, task, principal, response)
|
||||
now = utcnow()
|
||||
marked = await session.execute(
|
||||
|
||||
@@ -0,0 +1,266 @@
|
||||
"""使用者选人:按用途给的候选池 + 开登录时服务端核对(docs/design/next-round/05-已知遗留.md (b))。
|
||||
|
||||
以前使用者在入口表单、待办表单的选人控件里没有候选(名录只给搭建者),服务端也不核对:填错的名字会把待办派给一个不存在
|
||||
的人,没人能处理,也不报错。现在:
|
||||
- GET /api/directory/candidates 按用途给候选池,只有用户名和显示名,停用的不列;form 用途缺省是能用这个应用的人(使用
|
||||
及以上的授权展开组成员,加上管理员和建应用的人),字段可以用 x-principal 声明别的池;应用授权给了所有人时不带前缀不列;
|
||||
调用的人不能用这个应用时 403;review 用途是启用的搭建者和管理员;
|
||||
- 开了登录时,入口表单和待办表单的选人控件按同一个池核对,不在池里 422(errors 的 code=principal);关登录照旧手填;
|
||||
- /api/directory 仍然只给搭建者。
|
||||
|
||||
名字都是虚构的。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import uuid
|
||||
|
||||
import pytest
|
||||
from sqlalchemy import delete, select
|
||||
|
||||
from app.apps.forms import validate_form_schema
|
||||
from app.core.artifact_store import graph_hash
|
||||
from app.db.base import SessionLocal, utcnow
|
||||
from app.db.models import App, AppGrant, Group, GroupMember, Run, Task, User, Workflow, WorkflowVersion
|
||||
from app.engine.runner import run_manager
|
||||
from tests.fakes import auth_env
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
async def engine_up():
|
||||
await run_manager.setup()
|
||||
yield
|
||||
await run_manager.shutdown()
|
||||
|
||||
|
||||
def node(nid, ntype, label=None, **config):
|
||||
return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0}, "data": {"label": label or nid, "config": config}}
|
||||
|
||||
|
||||
def chain(*nodes):
|
||||
return {"nodes": list(nodes), "edges": [{"source": a["id"], "target": b["id"]} for a, b in zip(nodes, nodes[1:])]}
|
||||
|
||||
|
||||
PICK = {"type": "string", "title": "审批人", "x-widget": "principal"}
|
||||
|
||||
GRAPH = chain(
|
||||
node("start", "input", "开始", fields=[{"name": "approver"}, {"name": "reviewer"}]),
|
||||
node("review", "human", "复核", mode="input", title="请指定复核人",
|
||||
form={"type": "object", "properties": {"reviewer": {**PICK, "title": "复核人"}}}),
|
||||
node("out", "output", "成果", fields=[{"name": "r", "value": "{{ input.approver }}"}]))
|
||||
|
||||
|
||||
async def _workflow() -> tuple[str, str]:
|
||||
async with SessionLocal() as session:
|
||||
wf = Workflow(name=f"选人-{uuid.uuid4().hex[:6]}", graph=GRAPH, status="published", published_version=1,
|
||||
version=1)
|
||||
session.add(wf)
|
||||
await session.flush()
|
||||
session.add(WorkflowVersion(workflow_id=wf.id, version=1, graph=GRAPH, graph_hash=graph_hash(GRAPH),
|
||||
level="published", published_at=utcnow()))
|
||||
await session.commit()
|
||||
return wf.id, graph_hash(GRAPH)
|
||||
|
||||
|
||||
def _spec(wf: str, hash_: str, approver: dict | None = None) -> dict:
|
||||
return {
|
||||
"format": "agentlab.app/1", "name": "选人",
|
||||
"pins": [{"alias": "main", "workflow_id": wf, "version": 1, "graph_hash": hash_, "use": "entry"}],
|
||||
"entries": [{"id": "apply", "label": "发起", "pin": "main", "form": {"$ref": "#/forms/apply"},
|
||||
"map": {"approver": "form.approver"}}],
|
||||
"forms": {"apply": {"type": "object", "properties": {"approver": approver or PICK}}},
|
||||
"pages": [{"id": "home", "title": "首页", "body": [
|
||||
{"id": "new", "type": "entry_button", "props": {"entry": "apply"}}]}],
|
||||
}
|
||||
|
||||
|
||||
async def _new_app(root, spec: dict) -> str:
|
||||
"""root 建一个应用并发布,授权使用给 uma、停用的 dan 和组「财务」。"""
|
||||
res = await root.post("/api/apps", json={"name": f"选人-{uuid.uuid4().hex[:4]}", "spec": spec})
|
||||
assert res.status_code == 201, res.text
|
||||
app_id = res.json()["id"]
|
||||
published = (await root.post(f"/api/apps/{app_id}/publish", json={})).json()
|
||||
assert published["ok"], published
|
||||
async with SessionLocal() as session:
|
||||
session.add_all([AppGrant(app_id=app_id, principal_kind="user", principal="uma", role="use"),
|
||||
AppGrant(app_id=app_id, principal_kind="user", principal="dan", role="use"),
|
||||
AppGrant(app_id=app_id, principal_kind="group", principal="财务", role="use")])
|
||||
await session.commit()
|
||||
return app_id
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
async def world():
|
||||
"""开账号密码登录:管理员 root(建应用)、搭建者 bob、使用者 uma(授权使用)、ulf(没授权)、停用的 dan(授权使用);
|
||||
组「财务」(fay、fin),整组授权使用。"""
|
||||
await auth_env.reset()
|
||||
root = await auth_env.turn_on_local("root")
|
||||
try:
|
||||
await auth_env.make_user("bob", "builder")
|
||||
await auth_env.make_user("uma", "user")
|
||||
await auth_env.make_user("ulf", "user")
|
||||
await auth_env.make_user("dan", "user", disabled=True)
|
||||
fay = await auth_env.make_user("fay", "user")
|
||||
fin = await auth_env.make_user("fin", "user")
|
||||
async with SessionLocal() as session:
|
||||
for username, shown in (("uma", "乌玛"), ("fay", "费伊"), ("bob", "鲍勃")):
|
||||
user = (await session.execute(select(User).where(User.username == username))).scalar_one()
|
||||
user.display_name = shown
|
||||
group = Group(name="财务", label="财务组", source="local")
|
||||
session.add(group)
|
||||
await session.flush()
|
||||
session.add_all([GroupMember(group_id=group.id, user_id=fay.id), GroupMember(group_id=group.id, user_id=fin.id)])
|
||||
await session.commit()
|
||||
wf, hash_ = await _workflow()
|
||||
app_id = await _new_app(root, _spec(wf, hash_))
|
||||
yield {"root": root, "app_id": app_id, "wf": wf, "hash": hash_}
|
||||
finally:
|
||||
await root.aclose()
|
||||
async with SessionLocal() as session:
|
||||
for model in (AppGrant, App):
|
||||
await session.execute(delete(model))
|
||||
await session.commit()
|
||||
await auth_env.reset()
|
||||
|
||||
|
||||
def _params(app_id: str, **more) -> dict:
|
||||
return {"purpose": "form", "app_id": app_id, "entry": "apply", "field": "approver", **more}
|
||||
|
||||
|
||||
async def test_users_get_the_people_who_can_use_the_app_and_only_their_names(world):
|
||||
uma = await auth_env.login("uma")
|
||||
r = await uma.get("/api/directory/candidates", params=_params(world["app_id"]))
|
||||
assert r.status_code == 200, r.text
|
||||
body = r.json()
|
||||
assert [u["username"] for u in body["users"]] == ["fay", "fin", "root", "uma"]
|
||||
assert all(set(u) == {"username", "display_name"} for u in body["users"]), "不给停用、角色、邮箱"
|
||||
assert {u["username"]: u["display_name"] for u in body["users"]}["uma"] == "乌玛"
|
||||
assert body["groups"] == [{"name": "财务", "label": "财务组"}] and body["truncated"] is False
|
||||
# 前缀按用户名或显示名筛
|
||||
assert [u["username"] for u in (await uma.get("/api/directory/candidates",
|
||||
params=_params(world["app_id"], q="费"))).json()["users"]] == ["fay"]
|
||||
# 名录整份仍然只给搭建者
|
||||
assert (await uma.get("/api/directory")).status_code == 403
|
||||
# 不能用这个应用的人拿不到它的候选
|
||||
ulf = await auth_env.login("ulf")
|
||||
assert (await ulf.get("/api/directory/candidates", params=_params(world["app_id"]))).status_code == 403
|
||||
for c in (uma, ulf):
|
||||
await c.aclose()
|
||||
|
||||
|
||||
async def test_an_app_granted_to_everyone_needs_a_prefix(world):
|
||||
async with SessionLocal() as session:
|
||||
session.add(AppGrant(app_id=world["app_id"], principal_kind="everyone", principal="", role="use"))
|
||||
await session.commit()
|
||||
ulf = await auth_env.login("ulf")
|
||||
body = (await ulf.get("/api/directory/candidates", params=_params(world["app_id"]))).json()
|
||||
assert body["users"] == [] and body["needs_query"] is True
|
||||
found = (await ulf.get("/api/directory/candidates", params=_params(world["app_id"], q="u"))).json()
|
||||
assert [u["username"] for u in found["users"]] == ["ulf", "uma"], "停用的 dan 不列"
|
||||
capped = (await ulf.get("/api/directory/candidates", params=_params(world["app_id"], q="f", limit=1))).json()
|
||||
assert len(capped["users"]) == 1 and capped["truncated"] is True
|
||||
await ulf.aclose()
|
||||
|
||||
|
||||
async def test_review_candidates_are_builders_and_admins(world):
|
||||
uma = await auth_env.login("uma")
|
||||
body = (await uma.get("/api/directory/candidates", params={"purpose": "review"})).json()
|
||||
assert [u["username"] for u in body["users"]] == ["bob", "root"] and body["groups"] == []
|
||||
assert (await uma.get("/api/directory/candidates", params={"purpose": "nope"})).status_code == 422
|
||||
await uma.aclose()
|
||||
|
||||
|
||||
async def test_starting_with_a_name_outside_the_pool_is_refused(world):
|
||||
uma = await auth_env.login("uma")
|
||||
url = f"/api/apps/{world['app_id']}/entries/apply"
|
||||
bad = await uma.post(url, json={"values": {"approver": "wangwu"}})
|
||||
assert bad.status_code == 422, bad.text
|
||||
[error] = bad.json()["errors"]
|
||||
assert (error["path"], error["code"]) == ("approver", "principal")
|
||||
assert error["message"].startswith("「wangwu」不在可选的人里")
|
||||
disabled = await uma.post(url, json={"values": {"approver": "dan"}})
|
||||
assert disabled.status_code == 422 and disabled.json()["errors"][0]["code"] == "principal"
|
||||
for ok in ("fay", "财务"):
|
||||
good = await uma.post(url, json={"values": {"approver": ok}})
|
||||
assert good.status_code == 201, good.text
|
||||
await uma.aclose()
|
||||
|
||||
|
||||
async def test_a_task_form_is_checked_against_the_same_pool(world):
|
||||
uma = await auth_env.login("uma")
|
||||
started = await uma.post(f"/api/apps/{world['app_id']}/entries/apply", json={"values": {"approver": "fay"}})
|
||||
assert started.status_code == 201, started.text
|
||||
run_id = started.json()["run_id"]
|
||||
task = None
|
||||
for _ in range(200):
|
||||
async with SessionLocal() as session:
|
||||
task = (await session.execute(select(Task).where(Task.run_id == run_id, Task.status == "pending")))\
|
||||
.scalars().first()
|
||||
if task is not None:
|
||||
break
|
||||
await asyncio.sleep(0.05)
|
||||
assert task is not None
|
||||
cands = await uma.get("/api/directory/candidates", params={"purpose": "form", "task_id": task.id,
|
||||
"field": "reviewer"})
|
||||
assert cands.status_code == 200 and "fin" in [u["username"] for u in cands.json()["users"]]
|
||||
root = world["root"]
|
||||
bad = await root.post(f"/api/tasks/{task.id}/respond", json={"decision": "submit", "values": {"reviewer": "wangwu"}})
|
||||
assert bad.status_code == 422, bad.text
|
||||
assert bad.json()["errors"][0]["code"] == "principal"
|
||||
good = await root.post(f"/api/tasks/{task.id}/respond", json={"decision": "submit", "values": {"reviewer": "fin"}})
|
||||
assert good.status_code == 200, good.text
|
||||
await uma.aclose()
|
||||
|
||||
|
||||
async def test_a_declared_pool_narrows_the_candidates(world):
|
||||
"""x-principal 声明了 group:财务:候选只有组里的人,提交组外的人也拒。"""
|
||||
app_id = await _new_app(world["root"], _spec(world["wf"], world["hash"],
|
||||
{**PICK, "x-principal": {"pool": "group:财务"}}))
|
||||
uma = await auth_env.login("uma")
|
||||
body = (await uma.get("/api/directory/candidates", params=_params(app_id))).json()
|
||||
assert [u["username"] for u in body["users"]] == ["fay", "fin"] and body["groups"] == []
|
||||
refused = await uma.post(f"/api/apps/{app_id}/entries/apply", json={"values": {"approver": "uma"}})
|
||||
assert refused.status_code == 422 and refused.json()["errors"][0]["code"] == "principal"
|
||||
await uma.aclose()
|
||||
|
||||
|
||||
async def test_login_off_takes_any_name():
|
||||
await auth_env.reset()
|
||||
wf, hash_ = await _workflow()
|
||||
from httpx import ASGITransport, AsyncClient
|
||||
|
||||
from app.main import app as asgi
|
||||
|
||||
async with AsyncClient(transport=ASGITransport(app=asgi), base_url="http://test") as c:
|
||||
res = await c.post("/api/apps", json={"name": f"关登录-{uuid.uuid4().hex[:4]}", "spec": _spec(wf, hash_)})
|
||||
app_id = res.json()["id"]
|
||||
assert (await c.post(f"/api/apps/{app_id}/publish", json={})).json()["ok"]
|
||||
started = await c.post(f"/api/apps/{app_id}/entries/apply", json={"values": {"approver": "随手填的名字"}})
|
||||
assert started.status_code == 201, started.text
|
||||
async with SessionLocal() as session:
|
||||
await session.execute(delete(Run).where(Run.id == started.json()["run_id"]))
|
||||
await session.execute(delete(App).where(App.id == app_id))
|
||||
await session.commit()
|
||||
|
||||
|
||||
def test_x_principal_is_checked_in_the_form_schema():
|
||||
ok = {"type": "object", "properties": {"a": {**PICK, "x-principal": {"pool": "slot:finance"}}}}
|
||||
assert validate_form_schema(ok) == []
|
||||
bad = {"type": "object", "properties": {
|
||||
"a": {**PICK, "x-principal": {"pool": "everyone"}},
|
||||
"b": {"type": "string", "x-principal": {"pool": "app"}},
|
||||
"c": {**PICK, "x-principal": "app"}}}
|
||||
problems = validate_form_schema(bad)
|
||||
assert len(problems) == 3, problems
|
||||
assert any("「b」不是选人控件" in p for p in problems)
|
||||
|
||||
|
||||
async def test_users_table_is_untouched_by_candidates(world):
|
||||
"""候选接口只读:不建用户、不改名录。"""
|
||||
async with SessionLocal() as session:
|
||||
before = len((await session.execute(select(User.id))).all())
|
||||
uma = await auth_env.login("uma")
|
||||
await uma.get("/api/directory/candidates", params=_params(world["app_id"], q="zz"))
|
||||
await uma.aclose()
|
||||
async with SessionLocal() as session:
|
||||
assert len((await session.execute(select(User.id))).all()) == before
|
||||
Reference in New Issue
Block a user