✨ Add supplier authorization and shared final acceptance pool

This commit is contained in:
d-robotics 2026-09-29 22:04:45 -07:00
parent a298615a3e
commit 2335bf16f3
42 changed files with 2367 additions and 154 deletions

View File

@ -100,7 +100,7 @@ _Avoid_:公共可领取任务池(其中的任务尚未归属当前标注员
**正式审查记录**:已随通过或退回决定提交的审查结果与意见,不属于当前可编辑的审查草稿;删除本轮问题批注不删除正式审查记录。
**连续审查**:审查者在当前任务所属项目与审核环节接续处理任务的工作方式;从“全部项目”进入也按该任务项目接续。单纯领取保留可领取列表,“继续处理”进入任务并启动连续审查;当前决定实际成功后才进入下一条,暂停不撤回已提交决定。
**连续审查**:审查者在当前审核环节接续处理任务的工作方式;最终验收跟随项目筛选,“全部项目”跨有权限的项目接续,指定项目仅在该项目接续,质检仍在当前任务所属项目接续。单纯领取保留可领取列表,“继续处理”进入任务并启动连续审查;当前决定实际成功后才进入下一条,暂停不撤回已提交决定。
## 账号与项目授权
@ -113,6 +113,14 @@ _Avoid_:公共可领取任务池(其中的任务尚未归属当前标注员
**项目公共任务池**:供项目已授权供应商共同领取的待处理任务集合;同一任务只允许一家供应商领取,领取后归属该供应商,其他供应商不能重复领取或查看其标注内容。
_Avoid_:供应商任务副本(公共池不为每家供应商复制同一任务)
**供应商最终验收授权**:平台管理员单独授予供应商创建最终验收员和参与同组织全部生产项目终审的资格,独立于供应商项目授权,默认未授权。
**共享验收池**:同组织生产项目待最终验收任务的共同入口,获授权供应商的验收员竞争领取同一份任务,不复制任务,也不改变生产供应商归属。
**本轮验收处理资格**:共享授权有效时成功领取任务的验收员完成该轮验收的资格;共享授权关闭不使其失效,但不延续到重新送审或改派后的下一次领取。
**历史验收资格**:升级前已有验收账号按原规则保留的权限范围,不代表获得共享验收授权;账号改为其他角色后不再保留。
**生产供应商归属**:生产任务所属的供应商,不随质检或最终验收的处理人员变化而改变;公共池尚未归属供应商的任务为未分配。撤销项目授权不抹去该供应商已归属任务的存量与历史统计。
## 内部测试

View File

@ -0,0 +1,103 @@
// Read-only pre-release backup. Initialization is intentionally left to the
// separately approved migration; this command never calls RunMigrations.
package main
import (
"context"
"crypto/sha256"
"encoding/json"
"flag"
"fmt"
"os"
"path/filepath"
"time"
"droboticflow/internal/domain"
"droboticflow/internal/store"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
func run() error {
org := flag.String("org", "", "organization ID")
out := flag.String("output", "", "new private backup JSON path")
version := flag.String("deployment-version", "", "verified currently deployed commit/image")
flag.Parse()
if *org == "" || *out == "" || *version == "" || os.Getenv("MONGO_URI") == "" || os.Getenv("MONGO_DB") == "" {
return fmt.Errorf("require --org, --output, --deployment-version, MONGO_URI and MONGO_DB (credentials only via environment)")
}
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
client, err := mongo.Connect(ctx, options.Client().ApplyURI(os.Getenv("MONGO_URI")))
if err != nil {
return fmt.Errorf("connect failed (credentials omitted)")
}
defer client.Disconnect(context.Background())
db := client.Database(os.Getenv("MONGO_DB"))
s := store.NewMongoStore(db)
users, err := s.ListUsersByOrganization(ctx, *org)
if err != nil {
return fmt.Errorf("read account identities: %w", err)
}
identities := []map[string]any{}
for _, u := range users {
if u.Role == domain.UserRoleAcceptanceReviewer {
identities = append(identities, map[string]any{"id": u.ID, "supplierId": u.SupplierID, "role": u.Role, "status": u.Status, "deletedAt": u.DeletedAt, "acceptanceAccessMode": u.AcceptanceAccessMode})
}
}
read := func(collection string, filter bson.M, projection bson.M) ([]bson.M, error) {
cursor, e := db.Collection(collection).Find(ctx, filter, options.Find().SetProjection(projection))
if e != nil {
return nil, e
}
defer cursor.Close(ctx)
rows := []bson.M{}
e = cursor.All(ctx, &rows)
return rows, e
}
grants, err := read("supplierAcceptanceAuthorizations", bson.M{"organizationId": *org}, nil)
if err != nil {
return err
}
snapshots, err := read("acceptanceCompatibilitySnapshots", bson.M{"_id": *org}, nil)
if err != nil {
return err
}
// Include every recorded shared claim with unfinished status. A conservative
// list prevents unsafe rollback even if a legacy record has a stale receipt.
claims, err := read("humanItems", bson.M{"organizationId": *org, "acceptanceClaim": bson.M{"$ne": nil}, "assignedUserId": bson.M{"$nin": bson.A{"", nil}}, "status": bson.M{"$in": bson.A{domain.HumanItemClaimed, domain.HumanItemInProgress}}}, bson.M{"_id": 0, "id": 1, "projectId": 1, "supplierId": 1, "assignedUserId": 1, "currentStageId": 1, "reviewRound": 1, "claimedAt": 1, "acceptanceClaim": 1})
if err != nil {
return err
}
data, err := json.MarshalIndent(map[string]any{"schemaVersion": 1, "capturedAt": time.Now().UTC().Format(time.RFC3339Nano), "organizationId": *org, "deploymentVersion": *version, "acceptanceAccounts": identities, "authorizations": grants, "compatibilitySnapshots": snapshots, "unfinishedSharedClaims": claims}, "", " ")
if err != nil {
return err
}
if err = os.MkdirAll(filepath.Dir(*out), 0700); err != nil {
return err
}
file, err := os.OpenFile(*out, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
if err != nil {
return err
}
if _, err = file.Write(data); err != nil {
file.Close()
return err
}
if err = file.Sync(); err != nil {
file.Close()
return err
}
if err = file.Close(); err != nil {
return err
}
fmt.Printf("Read-only backup saved: accounts=%d authorizations=%d snapshots=%d unfinishedSharedClaims=%d sha256=%x\n", len(identities), len(grants), len(snapshots), len(claims), sha256.Sum256(data))
return nil
}
func main() {
if err := run(); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}

View File

@ -63,3 +63,15 @@ MongoDB 通过数据库持久互斥保护供应商变更与所属账号创建;
在 Fanyu 使用隔离账号和两组 60 秒合成采集,实际调用线上 API、标注处理服务与 Worker:同一项目的两个供应商分别完成随机领取、提交、质检、最终验收和打包,生成两个 accepted 交付包。每组左右视频各 240 帧、IMU 480 行,证据目录可读取左右 MP4。跨角色和跨供应商质检领取被拒绝。测试完成后移除本次生成的业务项目/账号并移除测试供应商的可选入口,产物隔离保留用于验证。
同时发现 Worker 健康检查把 poll interval 当成完整循环耗时,正常约 82 秒的循环会超过固定 30 秒门槛。现按最近成功循环的耗时增加有上限的容差,并公开 `readinessWindowMs`;失败循环不延长门槛,实际 `cycleDurationMs` 保留。该修正解决误判,不代表调度循环本身已加速。
## 供应商最终验收授权(本地候选,2026-09-29)
“授权项目”上方新增默认关闭的“允许最终验收”。仅平台管理员可更改,供应商管理员可查看。开启后,该供应商可以新建最终验收员、将未领任务的员工改为该角色;验收员访问同组织全部生产项目的终审池,无需供应商项目授权。默认供应商也可设置,不改变其改名、删除限制。平台管理员创建或转入此角色同样须先开启授权;原验收员修改资料不受影响。
`GET/PUT /api/suppliers/{supplierId}/acceptance-authorization` 返回状态、版本、操作历史及已领共享任务数。PUT 必须携带当前版本,过期返回 409。关闭前显示影响与当前数量。授权、创建/转角色和共享领取使用同一组织供应商写锁;新领取以持久化权限校验为准。
关闭后禁止新建/转入验收员和新共享领取;已领取任务按本人、本轮、阶段及领取时间保留处理依据,草稿、观看、通过/退回和超时结果核对仍可继续。新一轮和重新分配不继承旧依据。该授权不扩大供应商管理员、标注员或质检员权限;通用 Run/产物接口不扩权,跨项目视频只通过验收任务绑定的证据入口读取。不同组织、内部测试池仍隔离。
首次升级前生成 `acceptanceCompatibilitySnapshots`:按组织记录当时的验收账号身份。初始化与启动重放幂等,后建账号不会加入清单。旧账号继续原权限判断(包括既有 05 账号),没有自动开启共享授权。新账号和改过角色的账号标记为 managed;旧角色改走再改回必须取得授权,重放迁移也不会恢复其旧资格。
上线前另行授权并按[共享验收发布说明](supplier-acceptance-authorization.md)备份、初始化和核验;本次没有发布或客户数据写入授权。

View File

@ -67,3 +67,11 @@ Shift + Delete(Mac:Shift + Backspace)删除列表中选中的本轮问题
刷新、直接打开地址、只读预览不会自动开启;普通与专注布局切换不算重新进入。显式暂停、提交异常、窗口过小或被接管后保持暂停,条件恢复后需要手动继续;自动进入的下一条沿用原连续会话。
同一账号在两个页面打开同一任务时,只能一个页面编辑。另一个页面可查看,并可明确接管;接管后原页面停止写入,已保存草稿保留。这项能力适用于公司普通 HTTP 入口。
## 供应商共享验收池(2026-09-29)
平台管理员开启供应商的“允许最终验收”后,所属最终验收员可处理本组织所有生产项目的验收任务。生产供应商归属、质检退回链路保持原状。关闭授权后,已领任务仍可完成当前轮次;页面会在尝试新领取时提示联系管理员。历史验收员原有权限继续有效。
最终验收连续审查跟随页面的项目筛选:“全部项目”跨项目继续,选定项目只处理该项目。两种范围都优先本人最早领取任务,再领取最早创建的可用任务;首条成功决定后才接续。连续验收运行中切换项目时,旧范围停止并自动接续新范围;已暂停时切换项目仍保持暂停。刷新、手动暂停、窗口过小、页面被接管及提交异常的暂停规则不变。质检保持原来的项目范围。
接口:`POST /api/review-continuation`,`stage=acceptance` 且明确指定 `scope=all`(不传 projectId)或 `scope=project, projectId=...`。原 `/api/projects/{id}/review-continuation` 保留兼容。领取互斥、编辑权、版本校验及正式决定去重沿用原协议。

View File

@ -0,0 +1,43 @@
# 供应商最终验收授权与共享验收池
状态:本地候选实现。此文不构成公司集群部署、PR 或客户数据写入授权。
## 权限契约
- 供应商独立开关默认关闭,缺少授权记录等同关闭。平台管理员可以修改;供应商管理员只能读本供应商状态。
- 开关开启后,该供应商可创建/转入最终验收员,该角色可从同组织全部生产项目的验收池领取任务。项目生产授权、标注和质检隔离、生产供应商归属不变。
- 关闭后停止创建/转入验收员和新共享领取;成功领取持久化本轮处理资格,绑定账号、供应商、阶段、轮次、领取时间和授权版本。原轮次可完成、保存草稿、读取绑定视频、通过/退回并核对超时提交;下一轮不继承。
- 旧验收账号按旧项目权限继续工作,没有自动扩权。旧账号改走其他角色后,再转回必须有授权。后台缺失记录或读取失败不提供共享访问。
- 任务、历史决定、标注 JSON、审核意见和统计归属不迁移;退回仍进入原生产链路的质检。
## 存储与并发
`supplierAcceptanceAuthorizations`保存组织/供应商唯一授权、版本及操作人/时间历史。PUT 校验版本,防止管理员互相覆盖。创建账号、变更角色、更新授权及共享领取在 Mongo 的现有组织供应商互斥下检查;领取保留原账号互斥与任务版本 CAS,单机和副本集使用相同契约。
`acceptanceCompatibilitySnapshots` 按组织保存首次升级时的验收账号 ID。`RunMigrations` 在其他账号迁移前初始化;后续账号创建也先确保清单已建立。清单只建立一次,重放仅标记原名单中仍为旧验收身份的账号;新账号和角色变更已标记 managed,不会被重新认作旧账号。旧缺省字段兼容保留,不能删掉此路径。
`HumanItem.acceptanceClaim` 保存本轮资格;正式提交和草稿操作回执也保留该依据,因此撤权后成功决定清除任务领取人,不会阻断原回执核对。该回执资格只允许访问本人原操作,不提供下一轮任务权限。
组织连续验收接口为 `POST /api/review-continuation`,明确 `scope=all` 或 `scope=project,projectId=...`;原项目接口兼容。运行中明确切换项目时停止旧队列并接续新范围;已手动暂停、刷新或异常暂停的页面不自动恢复。候选每页最多 100 条且排除证据正文,先本人最早领取,再最早创建。历史时间含时区、缺少领取时间也可排序;批次及权限在请求内复用。真正领取时重新从持久化存储核验。
项目/工作流筛选可以列出共享范围,但通用 Run/产物权限不扩张。验收视频与文件读取必须通过该任务绑定的证据入口。内部测试任务与其他组织不进入共享池。
## 升级前清单、备份与回退
先遵循 `docs/release/README.md`,有发布记录则先检查该记录状态。此次新增兼容标记属于数据库写入,需要上线前单独确认该精确范围,不能把普通镜像部署授权解释为所有数据迁移授权。
1. 取得实际部署 commit/镜像摘要,核对组织、Mongo 数据库、当前镜像;在账号创建/角色切换的维护窗口内生成备份,避免旧代码在清单建立后继续新建未标记的验收员。滚动升级期间不得混用旧账号写入入口;新版本就绪后再恢复该入口,授权开关保持关闭。
2. 从未跟踪环境文件加载 `MONGO_URI`、`MONGO_DB`,执行只读命令:
`go run ./cmd/acceptance-access-audit --org <组织ID> --deployment-version <已核实旧版本> --output local-data/releases/<发布ID>/acceptance-access-before.json`。
只保存验收身份、授权与操作历史、兼容清单、在途共享领取及旧版本,不包含密码、Cookie、标注正文或视频地址。文件只新建不覆盖,权限 0600,输出 SHA-256。首次升级清单可能尚不存在,备份中的验收身份列表就是升级前对照。
3. 经明确授权后部署;启动迁移建立兼容清单,不开任何供应商开关。再备份一次,核对前后验收身份与授权状态,包括现有 05 账号;不能重新生成任务或自动改派。
4. 经单独许可的隔离测试账号验证后,业务管理员才按需要开启指定供应商。线上生产验证保持只读。
5. 回退前再运行只读备份并检查 `unfinishedSharedClaims`。有跨项目已领任务时,先完成当前轮次或取得用户批准的处置方案;旧版本可能无权继续处理这些任务,禁止直接回退留下不可操作任务。不能恢复整库、覆盖客户新增内容,也不能清空兼容清单来“重建”历史权限。
## 本地验证方式
- API/存储回归:`go test ./internal/api ./internal/store -run 'TestSharedAcceptance|TestSupplierAcceptance|TestAcceptanceRevocation|TestReviewContinuation|TestReviewSession|TestReviewDecision' -count=1`。
- 真实 Mongo:`ACCEPTANCE_LOCAL_MONGO_URI=mongodb://127.0.0.1:27018 go test ./internal/store -run TestSharedAcceptanceMongo -count=1`;27028 副本集同样验证。仅临时 `acceptance_auth_test_*` 库,结束清理该库。
- 真实浏览器:先起 Vite 5173(代理本地 3001),再 `ACCEPTANCE_BROWSER_TEST=1 go test ./internal/api -run '^TestSupplierAcceptanceBrowser$' -count=1 -v`。使用 27018 的随机 `acceptance_browser_test_*` 库、合成视频、进程内随机密码和两家供应商/两个项目;真实登录与接口,不伪造业务响应。结束关闭 API、删除该隔离库。截图和结果在未跟踪的 `local-data/verification/supplier-acceptance/`。
验证证据及基线比较见 [本地验证记录](verification/supplier-acceptance-authorization-20260929.md);上线实测仍需另行授权。

View File

@ -0,0 +1,51 @@
# 供应商最终验收授权:本地验证记录(2026-09-29)
本次仅本地实施,无公司部署、PR、线上授权开关或客户数据写入。对照基线为 `a298615a3e1154f38cfc69fa11149ae2f5f29c9f`,通过 `git archive` 提取到独立临时目录运行同组测试。
## 已验证
| 检查 | 结果及覆盖 |
| --- | --- |
| TypeScript / Web 构建 | `npx tsc --noEmit`、`npm run build:web` 通过;保留现有大包体积提示 |
| Go 正式包构建 | `go build ./cmd/... ./internal/...` 通过,包含只读备份工具 |
| 权限及并发回归 | `go test ./internal/api ./internal/store -run 'TestSharedAcceptance|TestSupplierAcceptanceCreation|TestReviewContinuation|TestReviewSession' -race -count=1` 通过 |
| Mongo 单机和副本集 | `TestSharedAcceptanceMongo` 分别在本机 27018、27028 通过:两人争抢、领取与撤权并发、授权版本冲突、当前轮次凭据、新轮次拒绝、旧身份清单重放、105 条候选跨页排序 |
| 正式决定恢复 | `TestSharedAcceptanceRevokedDecisionRecovery` 通过/退回两个分支:撤权后写入、人为中断响应、重建 handler、核对原请求及重试;源任务供应商和标注 JSON 不变,退回原质检链路 |
| 账号与隔离 | 默认关闭,直接 API 创建被拒绝;授权后创建和转角色;旧账号资料可修改且原权限不扩大;改角色后不能恢复旧身份;供应商管理员与其他业务角色无跨项目扩权,内部/跨组织数据拒绝 |
| 管理员分配与多页 | 管理员分配也使用本轮资格;撤权后拒绝新分配;明确接管后旧页写入被拒绝;当前已领草稿可保存且重试不重复 |
| 浏览器完整流程 | Edge + Vite 5173 + Go 3001 + 真实 Mongo 27018,两个供应商、两个项目、合成视频;真实登录/API,无业务响应 mock。普通/专注视频可播放,意见保存/清除,通过后跨项目接续,指定项目退回后接续,运行中切换项目自动接续新范围,刷新暂停;关闭授权确认显示已领数量,当前轮次提交后明确停止领取 |
| 备份工具 | 在浏览器隔离库运行 `acceptance-access-audit`,核对验收身份、未初始化兼容记录、0600 文件权限、拒绝覆盖已有备份 |
浏览器使用随机 `acceptance_browser_test_*` 库和进程内随机密码;Mongo 并发使用随机 `acceptance_auth_test_*` 库,结束仅删除各自隔离库。浏览器无未捕获页面异常。测试实现与重跑命令见 [实现与升级说明](../supplier-acceptance-authorization.md)。
## 基线失败对照
`go test ./internal/api ./internal/store ./internal/worker -count=1`:存储包通过;API/worker 的全量套件仍有既有失败。修改前后均为 128 个失败名称(含父项和子项,不能视为 128 个独立根因),逐个名称及首条诊断比较一致,仅归一化随机 ID、临时目录、并发 worker 编号和源码行号,没有新增失败项。
典型既有原因:`TestTier5AdversarialHardening` 中旧运行入口返回 404;`TestAdversarial_ConcurrentDebugRuns_DBZeroMutationInvariant` 同为旧入口 404;`TestEmployeeSupplierFixedLifecycle` 的旧成员权限夹具与现契约不符;`TestRuntimeProcessesXPlatformPipeline` 的 Python 视频夹具缺少 `cv2`。本次涉及的三处旧账号夹具已补显式授权,并单独回归通过。
`npm run test:frontend`:共 631 项,617 通过,14 项失败与固定基线名称一致,均为现有页面源码/文案模式断言,未新增失败。具体项:
- `ProjectDetail.tsx has '运行历史' tab and resets pagination cursors on modeFilter change`
- `automation keeps advanced settings collapsed and separates saving from listener activation`
- `creation exposes Capture mode and projects can reference released templates`
- `drosync stays reachable from data storage without becoming a ninth primary module`
- `layout removes the redundant product header and keeps only a compact health control`
- `production shell keeps real users, collapsible navigation, and a persisted light-default theme`
- `project detail exposes project-scoped human roles and safe workflow deletion`
- `project detail separates released and debug workflows and opens released run history`
- `project exposes only its selected dictionary descriptions`
- `project workflow exposes complete Capture automatic processing without a scan node`
- `raw human UI gates pose controls without weakening legacy defaults`
- `three roles hide release controls while counts remain anonymous`
- `workflow default and run input surfaces use the reusable BOS browser`
- `workflow run input renders a per-run automatic HandPose switch`
完整命令输出、逐案基线诊断和截图保存在未跟踪的 `local-data/verification/supplier-acceptance/`:`baseline-cases.json`、`result.json`、各检查日志、`authorization.png`、`normal.png`、`focused.png`、`revoked-draft.png`、`revoked-continuation.png`。
## 实施边界与待上线验收
- 上线须另行许可,并按发布流程先备份实际组织的授权、兼容清单及部署版本;兼容标记写入范围需要确认。旧写入入口停用后再建立升级清单,防止混合版本创建账号。
- 尚未进行公司环境部署、真实账号 05 的现场核验或线上性能压测。本地旧身份权限测试不能替代公司业务验收。
- 回退前检查未完成共享领取;不得直接降级导致已领跨项目任务无法继续,也不得整库恢复覆盖新增客户内容。
- 工作区根目录 `go build ./...` 会扫描既有未跟踪 `local-data/verification` Go 临时程序并出现重复 main/未定义符号;本次正式构建限定 `cmd` 和 `internal`,未删除这些历史文件。

View File

@ -0,0 +1,166 @@
package api
import (
"context"
"errors"
"net/http"
"droboticflow/internal/domain"
"droboticflow/internal/store"
"github.com/go-chi/chi/v5"
)
type acceptanceAccessKey struct{}
type acceptanceAccess struct {
user *domain.UserRecord
enabled bool
active bool
projects []string
err error
}
func (s *server) acceptanceAccessCache(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
next.ServeHTTP(w, r.WithContext(context.WithValue(r.Context(), acceptanceAccessKey{}, map[string]acceptanceAccess{})))
})
}
func (s *server) acceptanceAccessFor(ctx context.Context, userID string) acceptanceAccess {
cache, _ := ctx.Value(acceptanceAccessKey{}).(map[string]acceptanceAccess)
if v, ok := cache[userID]; ok {
return v
}
v := acceptanceAccess{}
v.user, v.err = s.store.GetUser(ctx, userID)
if v.err == nil && v.user != nil && v.user.Role == domain.UserRoleAcceptanceReviewer && v.user.Status != domain.UserStatusDisabled && v.user.DeletedAt == "" && !v.user.IsSuperAdmin {
sp, err := s.store.GetSupplier(ctx, v.user.SupplierID)
v.err = err
if err == nil && sp != nil && sp.Status == "active" && tenantMatches(sp.OrganizationID, v.user.OrganizationID) {
v.active = true
grant, err := s.store.GetSupplierAcceptanceAuthorization(ctx, v.user.OrganizationID, v.user.SupplierID)
v.err = err
v.enabled = err == nil && grant.Enabled
}
}
if v.err == nil && v.active && !v.enabled {
v.projects, _, v.err = s.store.SharedAcceptanceInventory(ctx, v.user.OrganizationID, v.user.SupplierID, v.user.ID)
}
if cache != nil {
cache[userID] = v
}
return v
}
// handled means legacy membership must not be used as a fallback. Only the
// acceptance stage is expanded; evidence routes continue to bind to this item.
func (s *server) sharedAcceptanceAccess(ctx context.Context, userID string, item domain.HumanItemRecord, claim bool) (allowed, handled bool) {
a := s.acceptanceAccessFor(ctx, userID)
if a.err != nil {
return false, true
}
if a.user == nil || a.user.Role != domain.UserRoleAcceptanceReviewer {
return false, false
}
if !a.active || !tenantMatches(a.user.OrganizationID, item.OrganizationID) {
return false, true
}
batch, err := s.humanBatchForListRead(ctx, item.BatchID)
if err != nil {
return false, true
}
if domain.SharedAcceptanceItem(item, batch) {
if a.enabled {
return true, true
}
if !claim && item.AcceptanceClaim.Matches(item, *a.user) {
return true, true
}
}
return false, a.user.AcceptanceAccessMode == "managed"
}
func (s *server) handleSupplierAcceptanceAuthorization(w http.ResponseWriter, r *http.Request) {
p, ok := currentPrincipal(r)
id := chi.URLParam(r, "supplierId")
if !ok || (!isOrganizationAdmin(p) && !(isSupplierManager(p) && p.User.SupplierID == id && r.Method == http.MethodGet)) {
renderJSON(w, 403, map[string]string{"error": "仅平台管理员可修改最终验收授权"})
return
}
sp, err := s.store.GetSupplier(r.Context(), id)
if err != nil {
renderError(w, 500, err)
return
}
if sp == nil || !tenantMatches(sp.OrganizationID, s.requestOrganizationID(r)) || sp.Status != "active" {
renderJSON(w, 404, map[string]string{"error": "供应商不存在或不可用"})
return
}
var grant *domain.SupplierAcceptanceAuthorization
if r.Method == http.MethodPut {
var input struct {
Enabled *bool `json:"enabled"`
Version *int `json:"version"`
}
if !decodeJSON(w, r, &input) {
return
}
if input.Enabled == nil || input.Version == nil || *input.Version < 0 {
renderValidationError(w, validationIssue{Field: "authorization", Message: "请提供授权状态和当前版本"})
return
}
grant, err = s.store.SetSupplierAcceptanceAuthorization(r.Context(), sp.OrganizationID, id, *input.Enabled, *input.Version, p.User.ID)
} else {
grant, err = s.store.GetSupplierAcceptanceAuthorization(r.Context(), sp.OrganizationID, id)
}
if errors.Is(err, store.ErrAcceptanceAuthorizationConflict) {
renderJSON(w, 409, map[string]string{"error": err.Error(), "code": "acceptance_authorization_changed"})
return
}
if err != nil {
renderUserMutationError(w, err)
return
}
_, count, err := s.store.SharedAcceptanceInventory(r.Context(), sp.OrganizationID, id, "")
if err != nil {
renderError(w, 500, err)
return
}
renderJSON(w, 200, struct {
*domain.SupplierAcceptanceAuthorization
ClaimedCount int `json:"claimedCount"`
}{grant, count})
}
// Only project/workflow navigation lists use this expansion. Generic run,
// artifact, annotation and QC endpoints retain their existing project guards.
func (s *server) acceptanceProjectVisible(r *http.Request, org, project string) bool {
p, ok := currentPrincipal(r)
if !ok || p.User.Role != domain.UserRoleAcceptanceReviewer || !tenantMatches(org, s.requestOrganizationID(r)) {
return false
}
a := s.acceptanceAccessFor(r.Context(), p.User.ID)
if a.err != nil || !a.active {
return false
}
if a.enabled {
return true
}
for _, id := range a.projects {
if id == project {
return true
}
}
return false
}
func (s *server) acceptanceAuthorizationDenied(w http.ResponseWriter, r *http.Request) bool {
p, ok := currentPrincipal(r)
if !ok || p.User.Role != domain.UserRoleAcceptanceReviewer {
return false
}
a := s.acceptanceAccessFor(r.Context(), p.User.ID)
if a.user != nil && a.user.AcceptanceAccessMode == "managed" && !a.enabled {
renderJSON(w, http.StatusForbidden, map[string]string{"code": "acceptance_authorization_required", "error": "供应商尚未获得最终验收授权或授权已关闭;已领取任务仍可完成,请联系管理员。"})
return true
}
return false
}

View File

@ -0,0 +1,171 @@
package api
import (
"context"
"crypto/rand"
"encoding/hex"
"encoding/json"
"fmt"
"net"
"net/http"
"os"
"os/exec"
"path/filepath"
"testing"
"time"
"droboticflow/internal/config"
"droboticflow/internal/domain"
"droboticflow/internal/store"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
// Opt-in real browser/API/Mongo contract. Only a random local database and
// generated five-second videos are used; credentials live for this process.
func TestSupplierAcceptanceBrowser(t *testing.T) {
if os.Getenv("ACCEPTANCE_BROWSER_TEST") != "1" {
t.Skip("local browser opt-in")
}
ctx, cancel := context.WithTimeout(t.Context(), 8*time.Minute)
defer cancel()
client, err := mongo.Connect(ctx, options.Client().ApplyURI("mongodb://127.0.0.1:27018"))
if err != nil {
t.Fatal(err)
}
defer client.Disconnect(context.Background())
db := client.Database(fmt.Sprintf("acceptance_browser_test_%d", time.Now().UnixNano()))
defer db.Drop(context.Background())
ds := store.NewMongoStore(db)
must := func(e error) {
t.Helper()
if e != nil {
t.Fatal(e)
}
}
root := t.TempDir()
mediaDir := filepath.Join(root, "system", "runs", "acceptance-run", "slices", "slice-000001")
must(os.MkdirAll(mediaDir, 0700))
video := filepath.Join(mediaDir, "left.mp4")
output, e := exec.CommandContext(ctx, "ffmpeg", "-hide_banner", "-loglevel", "error", "-f", "lavfi", "-i", "testsrc2=size=320x240:rate=30", "-t", "5", "-c:v", "libx264", "-pix_fmt", "yuv420p", "-movflags", "+faststart", video).CombinedOutput()
if e != nil {
t.Fatalf("video: %v %s", e, output)
}
data, e := os.ReadFile(video)
must(e)
must(os.WriteFile(filepath.Join(mediaDir, "right.mp4"), data, 0600))
pts := "clip_time_ms\n"
bounds := []float64{}
for i := 0; i <= 150; i++ {
bounds = append(bounds, float64(i)/30)
if i < 150 {
pts += fmt.Sprintf("%.6f\n", float64(i)*1000/30)
}
}
for _, name := range []string{"left_pts.csv", "right_pts.csv"} {
must(os.WriteFile(filepath.Join(mediaDir, name), []byte(pts), 0600))
}
must(os.WriteFile(filepath.Join(mediaDir, "imu.csv"), []byte("timestamp_us,gx,gy,gz\n0,0,0,0\n5000000,0,0,0\n"), 0600))
syncJSON, _ := json.Marshal(map[string]any{"window": map[string]any{"startTimestampUs": 0, "endTimestampUs": 5000000}, "boundaryContract": "hardware-frame-v1", "boundarySeconds": bounds, "left": map[string]any{"pts": map[string]any{"rowCount": 150}}})
must(os.WriteFile(filepath.Join(mediaDir, "synchronized-slice.json"), syncJSON, 0600))
must(os.WriteFile(filepath.Join(mediaDir, "annotation.json"), []byte(`{"actions":[{"id":"action-1","clipStartMs":0,"clipEndMs":5000,"description":"合成验收动作"}]}`), 0600))
org := domain.DefaultOrganizationID
must(ds.UpsertOrganizationPlugin(ctx, domain.OrganizationPluginRecord{OrganizationID: org, PluginID: "annotation-qa", Enabled: true, Config: defaultAnnotationPluginConfig()}))
must(ds.UpsertOrganization(ctx, domain.OrganizationRecord{ID: org, Name: "本地共享验收验证", Slug: "acceptance-local", Status: domain.OrganizationStatusActive}))
for _, sp := range []domain.SupplierRecord{{ID: "local-producer", Name: "生产供应商", OrganizationID: org, Status: "active"}, {ID: "local-reviewer", Name: "验收供应商", OrganizationID: org, Status: "active"}} {
must(ds.UpsertSupplier(ctx, sp))
}
secret := make([]byte, 24)
_, e = rand.Read(secret)
must(e)
password := hex.EncodeToString(secret)
hash, e := hashPassword(password)
must(e)
users := []domain.UserRecord{{ID: "local-admin", Role: domain.UserRoleAdmin, Phone: "13900009001", Name: "隔离管理员"}, {ID: "local-manager", Role: domain.UserRoleSupplierManager, SupplierID: "local-reviewer", Phone: "13900009002", Name: "隔离供应商管理员"}, {ID: "local-review-user", Role: domain.UserRoleAcceptanceReviewer, SupplierID: "local-reviewer", Phone: "13900009003", Name: "隔离验收员", AcceptanceAccessMode: "managed"}}
for _, u := range users {
u.OrganizationID = org
u.Status = domain.UserStatusActive
u.PasswordHash = hash
must(ds.UpsertUser(ctx, u))
}
for projectIndex, project := range []string{"acceptance-project-a", "acceptance-project-b"} {
must(ds.UpsertProject(ctx, domain.ProjectRecord{ID: project, OrganizationID: org, Name: project}))
runID := "run-" + project
projectMediaDir := filepath.Join(root, "system", "runs", runID, "slices", "slice-000001")
must(os.MkdirAll(projectMediaDir, 0700))
for _, name := range []string{"left.mp4", "right.mp4", "left_pts.csv", "right_pts.csv", "imu.csv", "synchronized-slice.json", "annotation.json"} {
data, e := os.ReadFile(filepath.Join(mediaDir, name))
must(e)
must(os.WriteFile(filepath.Join(projectMediaDir, name), data, 0600))
}
artifact := domain.ExecutionArtifact{ID: "local-media", RunID: runID, Name: "revision.directory.index", Type: domain.PortTypeFile, Path: filepath.Dir(filepath.Dir(projectMediaDir)), Data: map[string]any{"schemaVersion": "droboticflow.directory-index/v1", "datasetType": "directory", "presentation": "collection", "rootPath": filepath.Dir(filepath.Dir(projectMediaDir))}}
must(ds.UpsertRun(ctx, domain.RunRecord{ID: runID, OrganizationID: org, ProjectID: project, Status: domain.RunStatusCompleted, NodeExecutions: []domain.NodeExecutionRecord{{NodeID: "human", Artifacts: []domain.ExecutionArtifact{artifact}}}}))
for n := 0; n < 3; n++ {
sourceID := fmt.Sprintf("source-%d-%d", projectIndex, n)
sourceBatch := domain.HumanBatchRecord{ID: "batch-" + sourceID, GateNodeID: "gate-" + sourceID, OrganizationID: org, ProjectID: project, RunID: runID, PluginID: "annotation-qa", Stages: domain.DefaultFanyuV58HumanStages(), RequirePrePackageAcceptance: true, ProcessingProfile: domain.ProcessingProfileRawHuman, Status: domain.HumanBatchActive}
batch := sourceBatch
batch.ID = fanyuV5PrePackageAcceptanceBatchID(sourceBatch.ID)
batch.SourceBatchID = sourceBatch.ID
batch.GateNodeID += "-acceptance"
batch.RequirePrePackageAcceptance = false
batch.Stages = []domain.HumanStageDefinition{{ID: "prepackage_acceptance", Kind: domain.HumanStageAcceptance, RequiredRole: "acceptance_reviewer"}}
must(ds.UpsertHumanBatch(ctx, sourceBatch))
must(ds.UpsertHumanBatch(ctx, batch))
item := domain.HumanItemRecord{ID: fanyuV5PrePackageAcceptanceItemID(sourceBatch.ID), OrganizationID: org, ProjectID: project, RunID: runID, BatchID: batch.ID, PluginID: "annotation-qa", ProcessingProfile: domain.ProcessingProfileRawHuman, CurrentStageID: "prepackage_acceptance", Status: domain.HumanItemReady, Version: 1, ReviewRound: 1, CreatedAt: fmt.Sprintf("2020-01-0%dT00:00:00Z", n*2+projectIndex+1), Subject: domain.HumanSubjectRef{ItemKey: sourceID, Payload: map[string]any{"items": []any{map[string]any{"sourceHumanItemId": sourceID, "runId": runID, "captureDirectory": sourceID, "materialization": map[string]any{"runId": runID, "artifactId": artifact.ID, "revision": 1, "sliceCount": 1, "coverage": map[string]any{"contiguous": true, "gapMicroseconds": 0, "overlapMicroseconds": 0, "durationSeconds": 5}}, "finalSlices": []domain.SliceSegment{{ID: "slice-1", Name: "合成测试切片", Start: 0, End: 5}}, "annotation": []domain.AnnotationSegment{{ID: "action-1", Start: 0, End: 5, Description: "合成验收动作"}}}}}}}
must(ds.UpsertHumanItem(ctx, item))
source := item
source.ID = sourceID
source.SupplierID = "local-producer"
source.BatchID = sourceBatch.ID
source.CurrentStageID = domain.FanyuV58StageQualityReview
source.Status = domain.HumanItemAccepted
source.AcceptedAt = nowISO()
must(ds.UpsertHumanItem(ctx, source))
}
}
must(ds.EnsureIndexes(ctx))
// Verify the shipping backup tool against these synthetic identities. It
// must not initialize compatibility records or overwrite an existing backup.
backupPath := filepath.Join(t.TempDir(), "acceptance-before.json")
backup := func() ([]byte, error) {
cmd := exec.CommandContext(ctx, "go", "run", "./cmd/acceptance-access-audit", "--org", org, "--deployment-version", "local-synthetic-fixture", "--output", backupPath)
cmd.Dir = "../.."
cmd.Env = append(os.Environ(), "MONGO_URI=mongodb://127.0.0.1:27018", "MONGO_DB="+db.Name())
return cmd.CombinedOutput()
}
backupOutput, err := backup()
if err != nil {
t.Fatalf("backup: %v %s", err, backupOutput)
}
var backupRecord struct {
AcceptanceAccounts []map[string]any `json:"acceptanceAccounts"`
CompatibilitySnapshots []map[string]any `json:"compatibilitySnapshots"`
}
backupData, err := os.ReadFile(backupPath)
must(err)
must(json.Unmarshal(backupData, &backupRecord))
if len(backupRecord.AcceptanceAccounts) != 1 || len(backupRecord.CompatibilitySnapshots) != 0 {
t.Fatalf("unexpected read-only backup: %s", backupData)
}
if info, err := os.Stat(backupPath); err != nil || info.Mode().Perm() != 0600 {
t.Fatal("backup permissions")
}
if _, err := backup(); err == nil {
t.Fatal("backup overwrote existing file")
}
t.Setenv("DROBOTICFLOW_REQUIRE_SESSION_AUTH", "true")
h := NewHandlerWithConfig(ds, nil, config.AppConfig{WorkspaceMountPath: root})
listener, e := net.Listen("tcp", "127.0.0.1:3001")
must(e)
server := &http.Server{Handler: h}
go server.Serve(listener)
defer server.Close()
cmd := exec.CommandContext(ctx, "node", "tests/browser/supplier-acceptance.mjs")
cmd.Dir = "../.."
cmd.Env = append(os.Environ(), "ACCEPTANCE_QA_PASSWORD="+password)
output, e = cmd.CombinedOutput()
t.Log(string(output))
if e != nil {
t.Fatal(e)
}
}

View File

@ -0,0 +1,367 @@
package api
import (
"encoding/json"
"net/http"
"testing"
"droboticflow/internal/domain"
)
func sharedAcceptanceFixture(t *testing.T) combinedDraftFixture {
t.Helper()
f := acceptanceReviewDraftFixture(t)
oldSupplier := f.reviewer.SupplierID
f.reviewer.ID = "shared-reviewer"
f.reviewer.SupplierID = "shared-supplier"
f.reviewer.AcceptanceAccessMode = "managed"
if err := f.store.UpsertSupplier(f.ctx, domain.SupplierRecord{ID: f.reviewer.SupplierID, OrganizationID: f.item.OrganizationID, Status: "active"}); err != nil {
t.Fatal(err)
}
if err := f.store.UpsertUser(f.ctx, f.reviewer); err != nil {
t.Fatal(err)
}
if _, err := f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.item.OrganizationID, f.reviewer.SupplierID, true, 0, f.admin.ID); err != nil {
t.Fatal(err)
}
batch, _ := f.store.GetHumanBatch(f.ctx, f.item.BatchID)
source := *batch
source.ID = "shared-source"
source.Stages = domain.DefaultFanyuV58HumanStages()
source.RequirePrePackageAcceptance = true
source.ProcessingProfile = domain.ProcessingProfileRawHuman
if err := f.store.UpsertHumanBatch(f.ctx, source); err != nil {
t.Fatal(err)
}
batch.SourceBatchID = source.ID
batch.ProcessingProfile = domain.ProcessingProfileRawHuman
if err := f.store.UpsertHumanBatch(f.ctx, *batch); err != nil {
t.Fatal(err)
}
f.item.SupplierID = oldSupplier
f.item.AssignedUserID = ""
f.item.Status = domain.HumanItemReady
f.item.ClaimedAt = ""
if err := f.store.UpsertHumanItem(f.ctx, f.item); err != nil {
t.Fatal(err)
}
return f
}
func TestSharedAcceptanceAPIAndRevocation(t *testing.T) {
f := sharedAcceptanceFixture(t)
path := "/api/suppliers/" + f.reviewer.SupplierID + "/acceptance-authorization"
manager := domain.UserRecord{ID: "manager", OrganizationID: f.item.OrganizationID, SupplierID: f.reviewer.SupplierID, Role: domain.UserRoleSupplierManager, Status: domain.UserStatusActive}
_ = f.store.UpsertUser(f.ctx, manager)
for _, tc := range []struct {
method string
user domain.UserRecord
want int
}{{"GET", manager, 200}, {"PUT", manager, 403}, {"GET", f.annotator, 403}} {
r := f.request(tc.method, path, tc.user, map[string]any{"enabled": false, "version": 1})
if r.Code != tc.want {
t.Fatalf("permission %s %d %s", tc.method, r.Code, r.Body.String())
}
}
projects := f.request("GET", "/api/projects", f.reviewer, nil)
if projects.Code != 200 || !jsonContains(projects.Body.String(), f.item.ProjectID) {
t.Fatalf("projects %d %s", projects.Code, projects.Body.String())
}
listed := f.request("GET", "/api/human-items?pluginId=annotation-qa&pool=available", f.reviewer, nil)
if listed.Code != 200 || !jsonContains(listed.Body.String(), `"canClaim":true`) {
t.Fatalf("shared pool must expose server claim capability: %d %s", listed.Code, listed.Body.String())
}
read := f.request("GET", "/api/human-items/"+f.item.ID, f.reviewer, nil)
if read.Code != 200 {
t.Fatalf("cross-project read %d %s", read.Code, read.Body.String())
}
claim := f.request("POST", "/api/human-items/"+f.item.ID+"/claim", f.reviewer, map[string]any{"version": f.item.Version})
if claim.Code != 200 {
t.Fatalf("claim %d %s", claim.Code, claim.Body.String())
}
stored, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
f.item = *stored
if !stored.AcceptanceClaim.Matches(*stored, f.reviewer) {
t.Fatal("claim receipt missing")
}
_, headers := openReviewDraftSession(t, f)
revoke := f.request("PUT", path, f.admin, map[string]any{"enabled": false, "version": 1})
if revoke.Code != 200 {
t.Fatalf("revoke %d %s", revoke.Code, revoke.Body.String())
}
read = f.request("GET", "/api/human-items/"+f.item.ID, f.reviewer, nil)
if read.Code != 200 {
t.Fatalf("owned item lost after revoke: %d %s", read.Code, read.Body.String())
}
session, _ := f.store.GetReviewSession(f.ctx, reviewSessionKey(f.item))
save := reviewSessionRequest(f, "PUT", "/api/human-items/"+f.item.ID+"/review-draft", f.reviewer, map[string]any{"version": 0, "resultVersion": session.ResultVersion, "operationId": "save-revoked", "problems": []map[string]any{{"id": "one", "scope": "task", "text": "检查整体"}}}, headers)
if save.Code != 200 {
t.Fatalf("draining draft %d %s", save.Code, save.Body.String())
}
replay := reviewSessionRequest(f, "PUT", "/api/human-items/"+f.item.ID+"/review-draft", f.reviewer, map[string]any{"version": 0, "resultVersion": session.ResultVersion, "operationId": "save-revoked", "problems": []map[string]any{{"id": "one", "scope": "task", "text": "检查整体"}}}, headers)
if replay.Code != 200 {
t.Fatalf("save retry %d %s", replay.Code, replay.Body.String())
}
other := f.item
other.ID = "other"
other.AssignedUserID = ""
other.ClaimedAt = ""
other.Status = domain.HumanItemReady
_ = f.store.UpsertHumanItem(f.ctx, other)
denied := f.request("POST", "/api/human-items/other/claim", f.reviewer, map[string]any{"version": other.Version})
if denied.Code != 403 {
t.Fatalf("revoked new claim %d", denied.Code)
}
// Reopened rounds and internal/foreign records never inherit shared access.
_, _ = f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.item.OrganizationID, f.reviewer.SupplierID, true, 2, f.admin.ID)
for _, kind := range []string{"internal", "foreign", "annotation"} {
v := other
v.ID = kind
switch kind {
case "internal":
v.ProcessingScope = "internal"
case "foreign":
v.OrganizationID = "other-org"
case "annotation":
v.CurrentStageID = "quality_review"
}
_ = f.store.UpsertHumanItem(f.ctx, v)
out := f.request("GET", "/api/human-items/"+v.ID, f.reviewer, nil)
if out.Code != 403 && out.Code != 404 {
t.Fatalf("scope leak %s %d", kind, out.Code)
}
}
}
func TestSharedAcceptanceAllProjectContinuation(t *testing.T) {
f := sharedAcceptanceFixture(t)
second := f.item
second.ID = "project-two-item"
second.ProjectID = "project-two"
second.CreatedAt = "2000-01-01T00:00:00Z"
_ = f.store.UpsertProject(f.ctx, domain.ProjectRecord{ID: second.ProjectID, OrganizationID: second.OrganizationID})
_ = f.store.UpsertHumanItem(f.ctx, second)
body := map[string]any{"action": "start", "stage": "acceptance", "scope": "all", "pageId": "all-page", "generation": 0}
out := f.request("POST", "/api/review-continuation", f.reviewer, body)
result := continuationResult(t, out)
if result.Item == nil || result.Item.ID != second.ID {
t.Fatalf("all projects did not select oldest: %s", out.Body.String())
}
body["action"] = "pause"
body["generation"] = result.Generation
if r := f.request("POST", "/api/review-continuation", f.reviewer, body); r.Code != 200 {
t.Fatal(r.Body.String())
}
body = map[string]any{"action": "start", "stage": "acceptance", "scope": "project", "projectId": f.item.ProjectID, "pageId": "project-page", "generation": 0}
out = f.request("POST", "/api/review-continuation", f.reviewer, body)
result = continuationResult(t, out)
if result.Item == nil || result.Item.ID != f.item.ID {
t.Fatalf("specific project leaked: %s", out.Body.String())
}
}
func TestSupplierAcceptanceCreationGate(t *testing.T) {
f := newCombinedDraftFixture(t)
supplier := f.annotator.SupplierID
endpoint := "/api/suppliers/" + supplier + "/acceptance-authorization"
payload := map[string]any{"name": "new reviewer", "phone": "13900999001", "password": "local-test-password", "supplierId": supplier, "role": "acceptance_reviewer"}
denied := f.request(http.MethodPost, "/api/users", f.admin, payload)
if denied.Code != 403 {
t.Fatalf("admin bypass %d %s", denied.Code, denied.Body.String())
}
grant := f.request(http.MethodPut, endpoint, f.admin, map[string]any{"enabled": true, "version": 0})
if grant.Code != 200 {
t.Fatalf("default supplier grant %d %s", grant.Code, grant.Body.String())
}
created := f.request(http.MethodPost, "/api/users", f.admin, payload)
if created.Code != 201 {
t.Fatalf("create %d %s", created.Code, created.Body.String())
}
var user domain.UserRecord
_ = json.Unmarshal(created.Body.Bytes(), &user)
if user.AcceptanceAccessMode != "managed" {
t.Fatal("new account is legacy")
}
legacy := f.reviewer
legacy.Role = domain.UserRoleAcceptanceReviewer
_ = f.store.UpsertUser(f.ctx, legacy)
_ = f.request(http.MethodPut, endpoint, f.admin, map[string]any{"enabled": false, "version": 1})
edit := f.request(http.MethodPut, "/api/users/"+legacy.ID, f.admin, map[string]any{"name": "renamed legacy"})
if edit.Code != 200 {
t.Fatalf("legacy profile edit %d %s", edit.Code, edit.Body.String())
}
}
func TestSharedAcceptanceRevokedDecisionRecovery(t *testing.T) {
for _, decision := range []string{"approved", "rejected"} {
t.Run(decision, func(t *testing.T) {
f := sharedAcceptanceFixture(t)
batch, _ := f.store.GetHumanBatch(f.ctx, f.item.BatchID)
f.item.ID = fanyuV5PrePackageAcceptanceItemID(batch.SourceBatchID)
if err := f.store.UpsertHumanItem(f.ctx, f.item); err != nil {
t.Fatal(err)
}
for _, id := range []string{"source-a", "source-b"} {
source := f.item
source.ID, source.BatchID, source.CurrentStageID = id, batch.SourceBatchID, domain.FanyuV58StageQualityReview
source.Status, source.ReviewRound, source.Version = domain.HumanItemAccepted, 4, 10
source.LegacyTaskID = "task-" + id
source.AcceptedAt = nowISO()
if err := f.store.UpsertHumanItem(f.ctx, source); err != nil {
t.Fatal(err)
}
task := f.task
task.ID, task.Status, task.SupplierID = source.LegacyTaskID, domain.AnnotationTaskStatusAccepted, source.SupplierID
if err := f.store.UpsertAnnotationTask(f.ctx, task); err != nil {
t.Fatal(err)
}
}
snapshot, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
before, _ := json.Marshal(snapshot.Subject.Payload)
base := "/api/human-items/" + f.item.ID
claim := f.request("POST", base+"/claim", f.reviewer, map[string]any{"version": f.item.Version})
if claim.Code != 200 {
t.Fatal(claim.Body.String())
}
stored, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
f.item = *stored
version, headers := openReviewDraftSession(t, f)
if _, err := f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.item.OrganizationID, f.reviewer.SupplierID, false, 1, f.admin.ID); err != nil {
t.Fatal(err)
}
f.handler = NewHandler(&interruptedReviewStore{Store: f.store, failure: "after-human-write"}, nil)
payload := map[string]any{"version": f.item.Version, "decision": decision, "comment": "需要核对", "reasonCodes": []string{"batch_problem"}, "operationId": "revoked-decision", "draftVersion": 0, "resultVersion": version}
first := reviewSessionRequest(f, "POST", base+"/decisions", f.reviewer, payload, headers)
if first.Code != 202 {
t.Fatalf("interrupted %d %s", first.Code, first.Body.String())
}
f.handler = NewHandler(f.store, nil)
retry := f.request("POST", base+"/review-operations/revoked-decision/reconcile", f.reviewer, nil)
if retry.Code != 200 {
t.Fatalf("reconcile %d %s", retry.Code, retry.Body.String())
}
replay := reviewSessionRequest(f, "POST", base+"/decisions", f.reviewer, payload, headers)
if replay.Code != 200 {
t.Fatalf("replay %d %s", replay.Code, replay.Body.String())
}
current, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
after, _ := json.Marshal(current.Subject.Payload)
if string(before) != string(after) || current.SupplierID != f.item.SupplierID {
t.Fatalf("annotation/production ownership changed: before=%s after=%s suppliers=%s/%s", before, after, current.SupplierID, f.item.SupplierID)
}
for _, id := range []string{"source-a", "source-b"} {
source, _ := f.store.GetHumanItem(f.ctx, id)
if source.SupplierID != f.item.SupplierID {
t.Fatal("rejection changed supplier")
}
if decision == "rejected" && (source.CurrentStageID != domain.FanyuV58StageQualityReview || source.Status != domain.HumanItemSubmitted || source.ReviewRound != 5) {
t.Fatalf("wrong return route %+v", source)
}
}
current.ReviewRound++
current.Status = domain.HumanItemReady
current.AssignedUserID = ""
current.ClaimedAt = ""
_ = f.store.UpsertHumanItem(f.ctx, *current)
denied := f.request("POST", base+"/claim", f.reviewer, map[string]any{"version": current.Version})
if denied.Code != 403 {
t.Fatalf("next round inherited access: %d", denied.Code)
}
oldReceipt := f.request("GET", base+"/review-operations/revoked-decision", f.reviewer, nil)
if oldReceipt.Code != 200 {
t.Fatalf("lost historical receipt %d", oldReceipt.Code)
}
})
}
}
func TestSharedAcceptanceLegacyScopeAndPageTakeover(t *testing.T) {
t.Run("legacy scope stays unchanged", func(t *testing.T) {
f := acceptanceReviewDraftFixture(t)
own := f.request("GET", "/api/human-items/"+f.item.ID, f.reviewer, nil)
if own.Code != 200 {
t.Fatalf("legacy own scope: %d %s", own.Code, own.Body.String())
}
foreign := f.item
foreign.ID, foreign.ProjectID, foreign.SupplierID = "outside-legacy", "outside-project", "outside-supplier"
foreign.AssignedUserID = ""
if err := f.store.UpsertHumanItem(f.ctx, foreign); err != nil {
t.Fatal(err)
}
denied := f.request("GET", "/api/human-items/"+foreign.ID, f.reviewer, nil)
if denied.Code != 403 {
t.Fatalf("legacy scope expanded: %d %s", denied.Code, denied.Body.String())
}
grant, err := f.store.GetSupplierAcceptanceAuthorization(f.ctx, f.reviewer.OrganizationID, f.reviewer.SupplierID)
if err != nil || grant.Enabled {
t.Fatalf("legacy migration enabled shared pool: %v", err)
}
})
t.Run("revoked owner can take over current page only", func(t *testing.T) {
f := sharedAcceptanceFixture(t)
base := "/api/human-items/" + f.item.ID
if r := f.request("POST", base+"/claim", f.reviewer, map[string]any{"version": f.item.Version}); r.Code != 200 {
t.Fatal(r.Body.String())
}
item, _ := f.store.GetHumanItem(f.ctx, f.item.ID)
f.item = *item
_, headers := openReviewDraftSession(t, f)
if _, err := f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.item.OrganizationID, f.reviewer.SupplierID, false, 1, f.admin.ID); err != nil {
t.Fatal(err)
}
readOnly := f.request("POST", base+"/review-session", f.reviewer, map[string]any{"action": "acquire", "pageId": "other-page", "generation": 0})
if readOnly.Code != 200 || !jsonContains(readOnly.Body.String(), `"writable":false`) {
t.Fatal(readOnly.Body.String())
}
takeover := f.request("POST", base+"/review-session", f.reviewer, map[string]any{"action": "takeover", "pageId": "other-page", "generation": 0})
if takeover.Code != 200 || !jsonContains(takeover.Body.String(), `"writable":true`) {
t.Fatal(takeover.Body.String())
}
stale := reviewSessionRequest(f, "PUT", base+"/review-draft", f.reviewer, map[string]any{"version": 0, "operationId": "stale-page", "problems": []any{}}, headers)
if stale.Code != 409 {
t.Fatalf("old page still writes: %d %s", stale.Code, stale.Body.String())
}
})
}
func TestSharedAcceptanceAdminAssignmentAndIsolation(t *testing.T) {
f := sharedAcceptanceFixture(t)
// Ordinary run access remains project-scoped even when bound evidence is shared.
if err := f.store.UpsertRun(f.ctx, domain.RunRecord{ID: "shared-evidence-run", OrganizationID: f.item.OrganizationID, ProjectID: f.item.ProjectID}); err != nil {
t.Fatal(err)
}
out := f.request("GET", "/api/runs/shared-evidence-run", f.reviewer, nil)
if out.Code != 403 {
t.Fatalf("generic run access expanded: %d %s", out.Code, out.Body.String())
}
// A supplier manager receives no shared business access from the switch.
manager := f.reviewer
manager.ID, manager.Role = "shared-manager", domain.UserRoleSupplierManager
if err := f.store.UpsertUser(f.ctx, manager); err != nil {
t.Fatal(err)
}
out = f.request("GET", "/api/human-items/"+f.item.ID, manager, nil)
if out.Code != 403 {
t.Fatalf("supplier manager expanded: %d %s", out.Code, out.Body.String())
}
// Admin assignment uses the same durable receipt as ordinary/continuous claims.
out = f.request("PATCH", "/api/human-items/"+f.item.ID+"/assignment", f.admin, map[string]any{"version": f.item.Version, "assignedUserId": f.reviewer.ID})
if out.Code != 200 {
t.Fatalf("assign shared reviewer: %d %s", out.Code, out.Body.String())
}
assigned, err := f.store.GetHumanItem(f.ctx, f.item.ID)
if err != nil || !assigned.AcceptanceClaim.Matches(*assigned, f.reviewer) || assigned.SupplierID != f.item.SupplierID {
t.Fatalf("assignment lost receipt/ownership: %v", err)
}
if _, err := f.store.SetSupplierAcceptanceAuthorization(f.ctx, f.item.OrganizationID, f.reviewer.SupplierID, false, 1, f.admin.ID); err != nil {
t.Fatal(err)
}
other := f.item
other.ID = "cannot-assign-after-revoke"
if err := f.store.UpsertHumanItem(f.ctx, other); err != nil {
t.Fatal(err)
}
out = f.request("PATCH", "/api/human-items/"+other.ID+"/assignment", f.admin, map[string]any{"version": other.Version, "assignedUserId": f.reviewer.ID})
if out.Code != 400 {
t.Fatalf("admin bypassed revoked authorization: %d %s", out.Code, out.Body.String())
}
}

View File

@ -46,6 +46,9 @@ func TestAccountManagementPermissionMatrix(t *testing.T) {
t.Fatalf("promotion allowed: %d", r.Code)
}
}
if _, err := ds.SetSupplierAcceptanceAuthorization(t.Context(), org.ID, supplier.ID, true, 0, admin.ID); err != nil {
t.Fatal(err)
}
for _, role := range []string{"quality_reviewer", "acceptance_reviewer", "annotator"} {
r = serveJSONWithCookie(h, "PUT", "/api/users/"+worker.ID, []byte(`{"role":"`+role+`"}`), mc)
if r.Code != 200 {

View File

@ -298,6 +298,10 @@ func (server *server) handleHumanItemsList(writer http.ResponseWriter, request *
continue
}
}
if principal != nil && principal.User.Role == domain.UserRoleAcceptanceReviewer {
claimable := item.AssignedUserID == "" && (item.Status == domain.HumanItemReady || item.Status == domain.HumanItemRework || item.Status == domain.HumanItemSubmitted) && server.canClaimHumanItem(request.Context(), request, item, annotationRoleForHumanStage(stage))
item.CanClaim = &claimable
}
filtered = append(filtered, item)
}
if pool == "reviewed" {
@ -617,6 +621,9 @@ func (server *server) loadHumanItemForRequest(writer http.ResponseWriter, reques
return nil, false
}
if !server.canAccessHumanItem(request.Context(), request, *item, "") {
if server.acceptanceAuthorizationDenied(writer, request) {
return nil, false
}
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "project human-task membership is required"})
return nil, false
}
@ -686,6 +693,9 @@ func (server *server) canAccessHumanItem(ctx context.Context, request *http.Requ
if annotationManager(principal) {
return true
}
if allowed, handled := server.sharedAcceptanceAccess(ctx, principal.User.ID, item, false); handled {
return allowed && (requiredRole == "" || requiredRole == domain.AnnotationRoleAcceptanceReviewer)
}
memberships, err := server.annotationMembershipsForUser(ctx, item.OrganizationID, item.ProjectID, principal.User.ID)
if err != nil {
return false
@ -715,6 +725,9 @@ func (server *server) canClaimHumanItem(ctx context.Context, request *http.Reque
if item.PluginID == "human-loop-core" {
return requiredRole != "" && principal.User.Role == domain.UserRole(requiredRole)
}
if allowed, handled := server.sharedAcceptanceAccess(ctx, principal.User.ID, item, true); handled {
return allowed && requiredRole == domain.AnnotationRoleAcceptanceReviewer
}
memberships, err := server.annotationMembershipsForUser(ctx, item.OrganizationID, item.ProjectID, principal.User.ID)
if err != nil {
return false
@ -1091,6 +1104,12 @@ func (server *server) handleHumanItemClaim(writer http.ResponseWriter, request *
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item version conflict", "code": "version_conflict"})
return
}
if fresh, err := server.store.GetHumanItem(request.Context(), item.ID); err != nil || fresh == nil {
renderError(writer, 500, fmt.Errorf("领取已处理,请刷新核对"))
return
} else {
item = fresh
}
if boundSupplierID != "" {
batch.SupplierID = boundSupplierID
batch.UpdatedAt = nowISO()
@ -1304,7 +1323,7 @@ func (server *server) handleHumanItemAssignment(writer http.ResponseWriter, requ
}
legacy := domain.AnnotationTaskRecord{ID: item.LegacyTaskID, ProjectID: item.ProjectID, SupplierID: item.SupplierID, ProcessingScope: item.ProcessingScope, ProcessingProfile: item.ProcessingProfile, SupplierPool: batch.ProcessingProfile == domain.ProcessingProfileRawHuman && domain.IsFanyuV58ThreeRoleHumanLoop(batch.Stages), WorkgroupID: item.WorkgroupID, VendorID: item.VendorID}
legacy.SupplierPoolClosed = item.Status == domain.HumanItemAccepted || item.Status == domain.HumanItemRejected || item.Status == domain.HumanItemCancelled
if !membershipHasRole(memberships, legacy, requiredRole) {
if shared, handled := server.sharedAcceptanceAccess(request.Context(), user.ID, *item, true); (handled && !shared) || (!handled && !membershipHasRole(memberships, legacy, requiredRole)) {
renderValidationError(writer, validationIssue{Field: "assignedUserId", Message: "assigned user lacks the required project role"})
return
}
@ -1342,6 +1361,12 @@ func (server *server) handleHumanItemAssignment(writer http.ResponseWriter, requ
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item version conflict", "code": "version_conflict"})
return
}
if fresh, err := server.store.GetHumanItem(request.Context(), item.ID); err != nil || fresh == nil {
renderError(writer, 500, fmt.Errorf("领取已处理,请刷新核对"))
return
} else {
item = fresh
}
if boundSupplierID != "" {
batch.SupplierID = boundSupplierID
batch.UpdatedAt = nowISO()
@ -1490,15 +1515,15 @@ func (server *server) handleHumanItemDecision(writer http.ResponseWriter, reques
defer func() {
log.Printf("[api] review_latency operation=handleHumanItemDecision item=%s total_ms=%d", chi.URLParam(request, "id"), time.Since(started).Milliseconds())
}()
item, ok := server.loadHumanItemForRequest(writer, request)
if !ok {
return
}
var payload humanDecisionRequest
if !decodeJSON(writer, request, &payload) {
return
}
if server.replayReviewDecision(writer, request, item.ID, payload.ReviewDecisionInput, payload) {
if server.replayReviewDecision(writer, request, chi.URLParam(request, "id"), payload.ReviewDecisionInput, payload) {
return
}
item, ok := server.loadHumanItemForRequest(writer, request)
if !ok {
return
}
var prepared bool
@ -2247,7 +2272,7 @@ func v58AggregateSourceBatch(ctx context.Context, server *server, batch *domain.
if batch == nil || strings.TrimSpace(batch.SourceBatchID) == "" {
return nil, false, nil
}
source, err := server.store.GetHumanBatch(ctx, batch.SourceBatchID)
source, err := server.humanBatchForListRead(ctx, batch.SourceBatchID)
if err != nil || source == nil {
return source, false, err
}

View File

@ -52,7 +52,7 @@ func (server *server) continuationBind(r *http.Request, v *domain.ReviewContinua
if e != nil {
return e
}
if item == nil || item.OrganizationID != v.OrganizationID || item.ProjectID != v.ProjectID || item.AssignedUserID != v.UserID || (item.Status != domain.HumanItemClaimed && item.Status != domain.HumanItemInProgress) {
if item == nil || item.OrganizationID != v.OrganizationID || (v.ProjectID != "" && item.ProjectID != v.ProjectID) || item.AssignedUserID != v.UserID || (item.Status != domain.HumanItemClaimed && item.Status != domain.HumanItemInProgress) {
return store.ErrReviewContinuationOrigin
}
batch, e := server.store.GetHumanBatch(r.Context(), item.BatchID)
@ -119,6 +119,8 @@ func (server *server) handleReviewContinuation(w http.ResponseWriter, r *http.Re
Generation int `json:"generation"`
ItemID string `json:"itemId"`
OperationID string `json:"operationId"`
Scope string `json:"scope"`
ProjectID string `json:"projectId"`
}
if !decodeJSON(w, r, &input) {
return
@ -140,6 +142,15 @@ func (server *server) handleReviewContinuation(w http.ResponseWriter, r *http.Re
return
}
project := chi.URLParam(r, "id")
if project == "" {
if input.Stage != "acceptance" || (input.Scope != "all" && input.Scope != "project") || (input.Scope == "project" && strings.TrimSpace(input.ProjectID) == "") || (input.Scope == "all" && input.ProjectID != "") {
renderValidationError(w, validationIssue{Field: "scope", Message: "请选择全部项目或一个具体项目"})
return
}
if input.Scope == "project" {
project = strings.TrimSpace(input.ProjectID)
}
}
org := server.requestOrganizationID(r)
key := continuationKey(org, principal.User.ID, project, input.Stage)
v, e := server.store.GetReviewContinuation(r.Context(), key)
@ -175,7 +186,27 @@ func (server *server) handleReviewContinuation(w http.ResponseWriter, r *http.Re
renderError(w, 500, errors.New("无法核对审查权限"))
return
}
if user == nil || user.DeletedAt != "" || user.Status == domain.UserStatusDisabled || user.Role != expectedRole || len(memberships) == 0 {
hasAccess := len(memberships) > 0
if input.Stage == "acceptance" {
a := server.acceptanceAccessFor(r.Context(), principal.User.ID)
hasAccess = a.active && (a.enabled || (a.user.AcceptanceAccessMode != "managed" && hasAccess))
id := input.ItemID
if id == "" {
id = v.CurrentItemID
}
if !hasAccess && id != "" {
item, err := server.store.GetHumanItem(r.Context(), id)
if err != nil {
renderError(w, 500, err)
return
}
hasAccess = item != nil && a.active && item.AcceptanceClaim.Matches(*item, *a.user) && (project == "" || item.ProjectID == project)
}
}
if user == nil || user.DeletedAt != "" || user.Status == domain.UserStatusDisabled || user.Role != expectedRole || !hasAccess {
if server.acceptanceAuthorizationDenied(w, r) {
return
}
renderJSON(w, 403, map[string]string{"error": "审查权限已变化,请刷新核对", "code": "review_continuation_forbidden"})
return
}
@ -238,7 +269,7 @@ func (server *server) handleReviewContinuation(w http.ResponseWriter, r *http.Re
renderError(w, 500, err)
return
}
if op == nil || op.Status != "completed" || op.Kind != input.Stage || (op.Decision != "approved" && op.Decision != "rejected") || op.ProjectID != project || op.SessionKey != v.SessionKey || op.PageID != v.SessionPageID || op.Generation != v.SessionGeneration || op.UserID != v.UserID || op.ItemID != v.CurrentItemID {
if op == nil || op.Status != "completed" || op.Kind != input.Stage || (op.Decision != "approved" && op.Decision != "rejected") || (project != "" && op.ProjectID != project) || op.SessionKey != v.SessionKey || op.PageID != v.SessionPageID || op.Generation != v.SessionGeneration || op.UserID != v.UserID || op.ItemID != v.CurrentItemID {
continuationFailure(w, "review_decision_not_completed")
return
}
@ -277,66 +308,79 @@ func (server *server) continuationChoose(r *http.Request, v *domain.ReviewContin
if v.PendingItemID != "" {
return server.continuationFinishClaim(r, v)
}
items, e := server.store.ListHumanItems(ctx, v.OrganizationID, domain.HumanItemQuery{ProjectID: v.ProjectID, PluginID: "annotation-qa"})
if e != nil {
return e
}
candidates := make([]domain.HumanItemRecord, 0, len(items))
batches := map[string]*domain.HumanBatchRecord{}
for _, item := range items {
mine := item.AssignedUserID == v.UserID && (item.Status == domain.HumanItemClaimed || item.Status == domain.HumanItemInProgress)
available := item.AssignedUserID == "" && (item.Status == domain.HumanItemReady || item.Status == domain.HumanItemSubmitted || item.Status == domain.HumanItemRework)
if (!mine && !available) || item.LatestAuthorUserID == v.UserID {
continue
}
batch, loaded := batches[item.BatchID]
if !loaded {
batch, e = server.store.GetHumanBatch(ctx, item.BatchID)
for _, owned := range []bool{true, false} {
for offset := 0; ; offset += 100 {
items, e := server.store.ListReviewCandidates(ctx, v.OrganizationID, v.ProjectID, v.UserID, owned, offset, 100)
if e != nil {
return e
}
batches[item.BatchID] = batch
}
stage, _, found := humanStage(batch, item.CurrentStageID)
if !found || !continuationStage(stage, v.Stage) || server.reviewDecisionProtocol(ctx, item) != "receipt" || !server.canClaimHumanItem(ctx, r, item, annotationRoleForHumanStage(stage)) {
continue
}
candidates = append(candidates, item)
}
sort.Slice(candidates, func(i, j int) bool {
return continuationCandidateLess(candidates[i], candidates[j], v.UserID)
})
for _, item := range candidates {
// Re-read before admitting the one operation; the CAS also fences original page generation.
fresh, e := server.store.GetReviewContinuation(ctx, v.ID)
if e != nil {
return e
}
if fresh == nil || !fresh.Active || fresh.PageID != v.PageID || fresh.Generation != v.Generation || fresh.Revision != v.Revision {
return store.ErrReviewContinuationOrigin
}
if item.AssignedUserID == v.UserID {
latest, err := server.store.GetHumanItem(ctx, item.ID)
if err != nil {
return err
candidates := make([]domain.HumanItemRecord, 0, len(items))
listCtx, e := server.withHumanListReads(ctx, v.OrganizationID, v.ProjectID, items)
if e != nil {
return e
}
if latest == nil || latest.Version != item.Version || latest.AssignedUserID != v.UserID || (latest.Status != domain.HumanItemClaimed && latest.Status != domain.HumanItemInProgress) {
continue
pageRequest := r.WithContext(listCtx)
batches := map[string]*domain.HumanBatchRecord{}
for _, item := range items {
mine := item.AssignedUserID == v.UserID && (item.Status == domain.HumanItemClaimed || item.Status == domain.HumanItemInProgress)
available := item.AssignedUserID == "" && (item.Status == domain.HumanItemReady || item.Status == domain.HumanItemSubmitted || item.Status == domain.HumanItemRework)
if (!mine && !available) || item.LatestAuthorUserID == v.UserID {
continue
}
batch, loaded := batches[item.BatchID]
if !loaded {
batch, e = server.humanBatchForListRead(listCtx, item.BatchID)
if e != nil {
return e
}
batches[item.BatchID] = batch
}
stage, _, found := humanStage(batch, item.CurrentStageID)
if !found || !continuationStage(stage, v.Stage) || server.reviewDecisionProtocol(listCtx, item) != "receipt" || !(mine && server.canAccessHumanItem(listCtx, pageRequest, item, annotationRoleForHumanStage(stage)) || !mine && server.canClaimHumanItem(listCtx, pageRequest, item, annotationRoleForHumanStage(stage))) {
continue
}
candidates = append(candidates, item)
}
sort.Slice(candidates, func(i, j int) bool {
return continuationCandidateLess(candidates[i], candidates[j], v.UserID)
})
for _, item := range candidates {
// Re-read before admitting the one operation; the CAS also fences original page generation.
fresh, e := server.store.GetReviewContinuation(ctx, v.ID)
if e != nil {
return e
}
if fresh == nil || !fresh.Active || fresh.PageID != v.PageID || fresh.Generation != v.Generation || fresh.Revision != v.Revision {
return store.ErrReviewContinuationOrigin
}
if item.AssignedUserID == v.UserID {
latest, err := server.store.GetHumanItem(ctx, item.ID)
if err != nil {
return err
}
if latest == nil || latest.Version != item.Version || latest.AssignedUserID != v.UserID || (latest.Status != domain.HumanItemClaimed && latest.Status != domain.HumanItemInProgress) {
continue
}
v.CurrentItemID = item.ID
return server.continuationSave(ctx, v, origin)
}
v.PendingItemID = item.ID
v.PendingVersion = item.Version
if e = server.continuationSave(ctx, v, origin); e != nil {
return e
}
e = server.continuationFinishClaim(r, v)
if errors.Is(e, errContinuationCandidateChanged) {
continue
}
return e
}
if len(items) < 100 {
break
}
v.CurrentItemID = item.ID
return server.continuationSave(ctx, v, origin)
}
v.PendingItemID = item.ID
v.PendingVersion = item.Version
if e = server.continuationSave(ctx, v, origin); e != nil {
return e
}
e = server.continuationFinishClaim(r, v)
if errors.Is(e, errContinuationCandidateChanged) {
continue
}
return e
}
return nil
}

View File

@ -50,7 +50,18 @@ func (s *server) reviewOperationAccess(w http.ResponseWriter, r *http.Request, o
if strings.HasPrefix(op.Kind, "acceptance") {
role = domain.AnnotationRoleAcceptanceReviewer
}
if p == nil || p.User.ID != op.UserID || op.OrganizationID != s.requestOrganizationID(r) || item == nil || item.ProjectID != op.ProjectID || !s.canAccessHumanItem(r.Context(), r, *item, role) {
allowed := false
if p != nil && item != nil {
allowed = s.canAccessHumanItem(r.Context(), r, *item, role)
// A previously admitted operation remains recoverable after its claim
// was cleared by the decision or a later round started. This grants
// access to this immutable receipt only, never to the new task state.
if !allowed && role == domain.AnnotationRoleAcceptanceReviewer && op.AcceptanceClaim != nil {
a := s.acceptanceAccessFor(r.Context(), p.User.ID)
allowed = a.active && a.err == nil && op.AcceptanceClaim.UserID == p.User.ID && op.AcceptanceClaim.SupplierID == a.user.SupplierID && op.AcceptanceClaim.StageID == op.StageID && op.AcceptanceClaim.Round == op.ReviewRound
}
}
if p == nil || p.User.ID != op.UserID || op.OrganizationID != s.requestOrganizationID(r) || item == nil || item.ProjectID != op.ProjectID || !allowed {
renderJSON(w, 403, map[string]string{"error": "Review operation access denied"})
return false
}
@ -178,7 +189,7 @@ func (s *server) prepareReviewDecision(w http.ResponseWriter, r *http.Request, i
renderValidationError(w, validationIssue{Field: "comment", Message: "请先填写并保存退回意见"})
return r, false
}
op := &domain.ReviewOperation{ID: reviewOperationID(item, p.User.ID, meta.OperationID), OperationID: meta.OperationID, OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, UserID: p.User.ID, ItemID: item.ID, TaskID: item.LegacyTaskID, StageID: item.CurrentStageID, ReviewRound: item.ReviewRound, ResultVersion: meta.ResultVersion, DraftVersion: *meta.DraftVersion, Draft: *draft, Kind: kind, Decision: decision, Input: data, Digest: digest, SessionKey: reviewSessionKey(item), PageID: page, Generation: generation, Status: "prepared", CreatedAt: nowISO(), SourceItemIDs: []string{item.ID}}
op := &domain.ReviewOperation{AcceptanceClaim: item.AcceptanceClaim, ID: reviewOperationID(item, p.User.ID, meta.OperationID), OperationID: meta.OperationID, OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, UserID: p.User.ID, ItemID: item.ID, TaskID: item.LegacyTaskID, StageID: item.CurrentStageID, ReviewRound: item.ReviewRound, ResultVersion: meta.ResultVersion, DraftVersion: *meta.DraftVersion, Draft: *draft, Kind: kind, Decision: decision, Input: data, Digest: digest, SessionKey: reviewSessionKey(item), PageID: page, Generation: generation, Status: "prepared", CreatedAt: nowISO(), SourceItemIDs: []string{item.ID}}
if session.WriteID != "" && session.WriteID != op.ID {
reviewSessionFailure(w, "review_write_in_progress")
return r, false

View File

@ -23,7 +23,7 @@ type reviewDraftSaveInput struct {
}
func (s *server) reviewDecisionProtocol(ctx context.Context, item domain.HumanItemRecord) string {
batch, err := s.store.GetHumanBatch(ctx, item.BatchID)
batch, err := s.humanBatchForListRead(ctx, item.BatchID)
if err != nil || batch == nil {
return "legacy"
}
@ -119,7 +119,7 @@ func (s *server) saveRecoverableReviewDraft(w http.ResponseWriter, r *http.Reque
response := draft
response.Version++
responseJSON, _ := json.Marshal(map[string]any{"draft": response})
op := &domain.ReviewOperation{ID: id, OperationID: input.OperationID, OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, UserID: principal.User.ID, ItemID: item.ID, StageID: item.CurrentStageID, ReviewRound: item.ReviewRound, ResultVersion: input.ResultVersion, DraftVersion: input.Version, Draft: draft, Kind: kind, Input: data, Digest: digest, SessionKey: session.ID, PageID: page, Generation: generation, Status: "prepared", CreatedAt: nowISO(), Effects: []domain.ReviewDecisionEffect{{Draft: &draft}}, HTTPStatus: 200, Response: responseJSON}
op := &domain.ReviewOperation{AcceptanceClaim: item.AcceptanceClaim, ID: id, OperationID: input.OperationID, OrganizationID: item.OrganizationID, ProjectID: item.ProjectID, UserID: principal.User.ID, ItemID: item.ID, StageID: item.CurrentStageID, ReviewRound: item.ReviewRound, ResultVersion: input.ResultVersion, DraftVersion: input.Version, Draft: draft, Kind: kind, Input: data, Digest: digest, SessionKey: session.ID, PageID: page, Generation: generation, Status: "prepared", CreatedAt: nowISO(), Effects: []domain.ReviewDecisionEffect{{Draft: &draft}}, HTTPStatus: 200, Response: responseJSON}
saved, err := s.store.CompareAndSwapReviewOperation(r.Context(), *op, 0)
if err != nil {
renderError(w, 500, err)

View File

@ -1290,6 +1290,7 @@ func NewHandlerWithConfig(dataStore store.Store, aiService ai.Service, appConfig
router.Use(instance.csrfProtection)
router.Use(instance.projectDeletionWriteGuard)
router.Use(instance.supplierDeletionWriteGuard)
router.Use(instance.acceptanceAccessCache)
router.Get("/api/health", instance.handleHealth)
router.Get("/api/ready", instance.handleReady)
@ -1370,6 +1371,7 @@ func NewHandlerWithConfig(dataStore store.Store, aiService ai.Service, appConfig
router.Post("/api/human-items/{id}/decisions", instance.handleHumanItemDecision)
router.Post("/api/human-items/{id}/review-session", instance.handleReviewSession)
router.Post("/api/projects/{id}/review-continuation", instance.handleReviewContinuation)
router.Post("/api/review-continuation", instance.handleReviewContinuation)
router.Put("/api/human-items/{id}/review-draft", instance.handleReviewDraft)
router.Post("/api/human-items/{id}/review-operations/{operationId}/reconcile", instance.handleReviewOperation)
router.Post("/api/human-items/{id}/escalation", instance.handleHumanEscalationDecision)
@ -1506,6 +1508,8 @@ func NewHandlerWithConfig(dataStore store.Store, aiService ai.Service, appConfig
router.Post("/api/projects/{id}/members/bulk", instance.handleProjectMembersBulk)
})
router.Get("/api/suppliers", instance.handleSuppliersList)
router.Get("/api/suppliers/{supplierId}/acceptance-authorization", instance.handleSupplierAcceptanceAuthorization)
router.Put("/api/suppliers/{supplierId}/acceptance-authorization", instance.handleSupplierAcceptanceAuthorization)
router.Get("/api/suppliers/{supplierId}/deletion-preview", instance.handleSupplierDeletionPreview)
router.Post("/api/suppliers/{supplierId}/deletions", instance.handleSupplierDeletionStart)
router.Get("/api/supplier-deletions", instance.handleSupplierDeletionsList)

View File

@ -16,6 +16,10 @@ func renderOrganizationMutationError(writer http.ResponseWriter, err error) {
}
func renderUserMutationError(writer http.ResponseWriter, err error) {
if errors.Is(err, store.ErrAcceptanceAuthorizationRequired) {
renderJSON(writer, 403, map[string]string{"error": err.Error(), "code": "acceptance_authorization_required"})
return
}
if errors.Is(err, store.ErrAccountDeleted) {
renderJSON(writer, http.StatusGone, map[string]string{"error": "账号已删除,不能修改或重新启用", "code": "account_deleted"})
return

View File

@ -64,6 +64,9 @@ func TestSupplierManagerUserCRUDOperations(t *testing.T) {
t.Fatalf("annotator record mismatch: %#v", annotatorRecord)
}
if _, err := dataStore.SetSupplierAcceptanceAuthorization(ctx, organization.ID, supplierA.ID, true, 0, admin.ID); err != nil {
t.Fatal(err)
}
// 2. Manager A creates a quality_reviewer and acceptance_reviewer
for i, role := range []domain.UserRole{domain.UserRoleQualityReviewer, domain.UserRoleAcceptanceReviewer} {
createBody, _ := json.Marshal(map[string]any{

View File

@ -231,7 +231,7 @@ func (server *server) listMongoConnectionsForRequest(ctx context.Context, reques
func (server *server) filterProjectsForRequest(request *http.Request, items []domain.ProjectRecord) []domain.ProjectRecord {
return filterTenantRecords(items, func(item domain.ProjectRecord) bool {
return server.filterByTenant(request, item.OrganizationID) && server.projectVisibleToRequest(request, item.OrganizationID, item.ID)
return server.filterByTenant(request, item.OrganizationID) && (server.projectVisibleToRequest(request, item.OrganizationID, item.ID) || server.acceptanceProjectVisible(request, item.OrganizationID, item.ID))
})
}
@ -262,6 +262,7 @@ func (server *server) projectVisibleToRequest(request *http.Request, organizatio
return false
}
supplierActive := supplier != nil && tenantMatches(supplier.OrganizationID, organizationID) && strings.EqualFold(supplier.Status, "active")
grants, err := server.store.ListSupplierProjectAuthorizations(request.Context(), organizationID, projectID)
if err != nil {
return false
@ -333,7 +334,7 @@ func (server *server) ensureOperatorAccess(writer http.ResponseWriter, request *
func (server *server) filterWorkflowsForRequest(request *http.Request, items []domain.WorkflowRecord) []domain.WorkflowRecord {
return filterTenantRecords(items, func(item domain.WorkflowRecord) bool {
return server.filterByTenant(request, item.OrganizationID) && server.projectVisibleToRequest(request, item.OrganizationID, item.ProjectID)
return server.filterByTenant(request, item.OrganizationID) && (server.projectVisibleToRequest(request, item.OrganizationID, item.ProjectID) || server.acceptanceProjectVisible(request, item.OrganizationID, item.ProjectID))
})
}

View File

@ -0,0 +1,48 @@
package domain
// SupplierAcceptanceAuthorization is independent of production project grants.
// Its absence grants no shared acceptance access.
type SupplierAcceptanceAuthorization struct {
ID string `json:"id" bson:"_id"`
OrganizationID string `json:"organizationId" bson:"organizationId"`
SupplierID string `json:"supplierId" bson:"supplierId"`
Enabled bool `json:"enabled" bson:"enabled"`
Version int `json:"version" bson:"version"`
UpdatedAt string `json:"updatedAt,omitempty" bson:"updatedAt"`
History []SupplierAcceptanceAuthorizationChange `json:"history,omitempty" bson:"history"`
}
type SupplierAcceptanceAuthorizationChange struct {
Enabled bool `json:"enabled" bson:"enabled"`
ActorID string `json:"actorId" bson:"actorId"`
At string `json:"at" bson:"at"`
}
// AcceptanceClaimAccess survives revocation only for this assignee and claim.
// A new assignment, stage, or review round must obtain a new authorization.
type AcceptanceClaimAccess struct {
UserID string `json:"userId" bson:"userId"`
SupplierID string `json:"supplierId" bson:"supplierId"`
GrantVersion int `json:"grantVersion" bson:"grantVersion"`
StageID string `json:"stageId" bson:"stageId"`
Round int `json:"round" bson:"round"`
ClaimedAt string `json:"claimedAt" bson:"claimedAt"`
}
func (v *AcceptanceClaimAccess) Matches(item HumanItemRecord, user UserRecord) bool {
return v != nil && v.UserID == user.ID && v.SupplierID == user.SupplierID &&
item.AssignedUserID == user.ID && v.StageID == item.CurrentStageID &&
v.Round == item.ReviewRound && v.ClaimedAt != "" && v.ClaimedAt == item.ClaimedAt
}
func SharedAcceptanceItem(item HumanItemRecord, batch *HumanBatchRecord) bool {
if item.PluginID != "annotation-qa" || item.ProcessingScope == "internal" || batch == nil || batch.ProcessingScope == "internal" {
return false
}
for _, stage := range batch.Stages {
if stage.ID == item.CurrentStageID {
return stage.Kind == HumanStageAcceptance && stage.RequiredRole == string(UserRoleAcceptanceReviewer)
}
}
return false
}

View File

@ -133,6 +133,8 @@ type HumanBatchRecord struct {
}
type HumanItemRecord struct {
CanClaim *bool `json:"canClaim,omitempty" bson:"-"`
AcceptanceClaim *AcceptanceClaimAccess `json:"acceptanceClaim,omitempty" bson:"acceptanceClaim,omitempty"`
ReviewHistoryStatus string `json:"reviewHistoryStatus,omitempty" bson:"-"`
ReviewOperationID string `json:"reviewOperationId,omitempty" bson:"reviewOperationId,omitempty"`
ProcessingJob *AnnotationProcessingJob `json:"-" bson:"processingJob,omitempty"`

View File

@ -5,35 +5,36 @@ import "encoding/json"
// ReviewOperation is a durable intent and forward-recovery journal. The plan is
// frozen before its first effect; source rounds are never recomputed on retry.
type ReviewOperation struct {
ID string `bson:"_id"`
OperationID string `bson:"operationId"`
OrganizationID string `bson:"organizationId"`
ProjectID string `bson:"projectId"`
UserID string `bson:"userId"`
ItemID string `bson:"itemId"`
TaskID string `bson:"taskId,omitempty"`
StageID string `bson:"stageId"`
ReviewRound int `bson:"reviewRound"`
ResultVersion string `bson:"resultVersion"`
DraftVersion int `bson:"draftVersion"`
Draft ReviewDraft `bson:"draft"`
Kind string `bson:"kind"`
Decision string `bson:"decision"`
Input json.RawMessage `bson:"input"`
Digest string `bson:"digest"`
SessionKey string `bson:"sessionKey"`
PageID string `bson:"pageId"`
Generation int `bson:"generation"`
Status string `bson:"status"`
Revision int `bson:"revision"`
Step int `bson:"step"`
Effects []ReviewDecisionEffect `bson:"effects"`
SourceItemIDs []string `bson:"sourceItemIds"`
HTTPStatus int `bson:"httpStatus"`
Response json.RawMessage `bson:"response"`
Error string `bson:"error,omitempty"`
CreatedAt string `bson:"createdAt"`
CompletedAt string `bson:"completedAt,omitempty"`
AcceptanceClaim *AcceptanceClaimAccess `bson:"acceptanceClaim,omitempty"`
ID string `bson:"_id"`
OperationID string `bson:"operationId"`
OrganizationID string `bson:"organizationId"`
ProjectID string `bson:"projectId"`
UserID string `bson:"userId"`
ItemID string `bson:"itemId"`
TaskID string `bson:"taskId,omitempty"`
StageID string `bson:"stageId"`
ReviewRound int `bson:"reviewRound"`
ResultVersion string `bson:"resultVersion"`
DraftVersion int `bson:"draftVersion"`
Draft ReviewDraft `bson:"draft"`
Kind string `bson:"kind"`
Decision string `bson:"decision"`
Input json.RawMessage `bson:"input"`
Digest string `bson:"digest"`
SessionKey string `bson:"sessionKey"`
PageID string `bson:"pageId"`
Generation int `bson:"generation"`
Status string `bson:"status"`
Revision int `bson:"revision"`
Step int `bson:"step"`
Effects []ReviewDecisionEffect `bson:"effects"`
SourceItemIDs []string `bson:"sourceItemIds"`
HTTPStatus int `bson:"httpStatus"`
Response json.RawMessage `bson:"response"`
Error string `bson:"error,omitempty"`
CreatedAt string `bson:"createdAt"`
CompletedAt string `bson:"completedAt,omitempty"`
}
type ReviewDecisionEffect struct {

View File

@ -975,8 +975,10 @@ type AuditTaskRecord struct {
}
type UserRecord struct {
DeletedAt string `json:"deletedAt,omitempty" bson:"deletedAt,omitempty"`
DeletedBy string `json:"deletedBy,omitempty" bson:"deletedBy,omitempty"`
// Empty/legacy is grandfathered; every new account and role change is managed.
AcceptanceAccessMode string `json:"acceptanceAccessMode,omitempty" bson:"acceptanceAccessMode,omitempty"`
DeletedAt string `json:"deletedAt,omitempty" bson:"deletedAt,omitempty"`
DeletedBy string `json:"deletedBy,omitempty" bson:"deletedBy,omitempty"`
// Deprecated: retained for historical audit only; permissions use Role.
DefaultProjectRoles []AnnotationAssignmentRole `json:"defaultProjectRoles,omitempty" bson:"defaultProjectRoles"`
ID string `json:"id" bson:"id"`

View File

@ -0,0 +1,198 @@
package store
import (
"context"
"errors"
"sort"
"droboticflow/internal/domain"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
var ErrAcceptanceAuthorizationRequired = errors.New("请先为该供应商开启“允许最终验收”")
var ErrAcceptanceAuthorizationConflict = errors.New("授权已被其他管理员修改,请刷新后重试")
func acceptanceAuthorizationID(org, supplier string) string {
return normalizedOrganizationID(org) + ":" + supplier
}
func emptyAcceptanceAuthorization(org, supplier string) domain.SupplierAcceptanceAuthorization {
return domain.SupplierAcceptanceAuthorization{ID: acceptanceAuthorizationID(org, supplier), OrganizationID: normalizedOrganizationID(org), SupplierID: supplier}
}
func (s *MemoryStore) acceptanceAuthorizationLocked(org, supplier string) domain.SupplierAcceptanceAuthorization {
v, ok := s.acceptanceAuthorizations[acceptanceAuthorizationID(org, supplier)]
if !ok {
return emptyAcceptanceAuthorization(org, supplier)
}
return clone(v)
}
func (s *MemoryStore) GetSupplierAcceptanceAuthorization(_ context.Context, org, supplier string) (*domain.SupplierAcceptanceAuthorization, error) {
s.mu.Lock()
defer s.mu.Unlock()
v := s.acceptanceAuthorizationLocked(org, supplier)
return &v, nil
}
func (s *MemoryStore) SetSupplierAcceptanceAuthorization(_ context.Context, org, supplier string, enabled bool, version int, actor string) (*domain.SupplierAcceptanceAuthorization, error) {
s.mu.Lock()
defer s.mu.Unlock()
sp, ok := s.suppliers[supplier]
if !ok || !humanOrganizationMatches(sp.OrganizationID, org) || sp.Status != "active" {
return nil, ErrSupplierUnavailable
}
v := s.acceptanceAuthorizationLocked(org, supplier)
if v.Version != version {
return nil, ErrAcceptanceAuthorizationConflict
}
v.Enabled = enabled
v.Version++
v.UpdatedAt = nowISO()
v.History = append(v.History, domain.SupplierAcceptanceAuthorizationChange{Enabled: enabled, ActorID: actor, At: v.UpdatedAt})
if s.acceptanceAuthorizations == nil {
s.acceptanceAuthorizations = map[string]domain.SupplierAcceptanceAuthorization{}
}
s.acceptanceAuthorizations[v.ID] = clone(v)
return &v, nil
}
func (s *MongoStore) GetSupplierAcceptanceAuthorization(ctx context.Context, org, supplier string) (*domain.SupplierAcceptanceAuthorization, error) {
v := emptyAcceptanceAuthorization(org, supplier)
err := s.db.Collection("supplierAcceptanceAuthorizations").FindOne(ctx, bson.M{"_id": v.ID}).Decode(&v)
if errors.Is(err, mongo.ErrNoDocuments) {
err = nil
}
return &v, err
}
func (s *MongoStore) SetSupplierAcceptanceAuthorization(ctx context.Context, org, supplier string, enabled bool, version int, actor string) (*domain.SupplierAcceptanceAuthorization, error) {
result, err := s.withAccountMutationLock(ctx, "suppliers:"+normalizedOrganizationID(org), func(ctx context.Context) (any, error) {
sp, err := s.GetSupplier(ctx, supplier)
if err != nil {
return nil, err
}
if sp == nil || !humanOrganizationMatches(sp.OrganizationID, org) || sp.Status != "active" {
return nil, ErrSupplierUnavailable
}
v, err := s.GetSupplierAcceptanceAuthorization(ctx, org, supplier)
if err != nil {
return nil, err
}
if v.Version != version {
return nil, ErrAcceptanceAuthorizationConflict
}
v.Enabled = enabled
v.Version++
v.UpdatedAt = nowISO()
v.History = append(v.History, domain.SupplierAcceptanceAuthorizationChange{Enabled: enabled, ActorID: actor, At: v.UpdatedAt})
c := s.db.Collection("supplierAcceptanceAuthorizations")
if version == 0 {
_, err = c.InsertOne(ctx, v)
} else {
var r *mongo.UpdateResult
r, err = c.ReplaceOne(ctx, bson.M{"_id": v.ID, "version": version}, v)
if err == nil && r.MatchedCount == 0 {
err = ErrAcceptanceAuthorizationConflict
}
}
if mongo.IsDuplicateKeyError(err) {
err = ErrAcceptanceAuthorizationConflict
}
return v, err
})
if err != nil {
return nil, err
}
return result.(*domain.SupplierAcceptanceAuthorization), nil
}
// Snapshot identities once, before managed writes begin. Never rescan on restart:
// a newly-created reviewer must not accidentally become a legacy reviewer.
func (s *MongoStore) SnapshotLegacyAcceptanceAccounts(ctx context.Context, org string) error {
_, err := s.withAccountMutationLock(ctx, "suppliers:"+normalizedOrganizationID(org), func(ctx context.Context) (any, error) {
c := s.db.Collection("acceptanceCompatibilitySnapshots")
id := normalizedOrganizationID(org)
var snap struct {
UserIDs []string `bson:"userIds"`
}
err := c.FindOne(ctx, bson.M{"_id": id}).Decode(&snap)
if errors.Is(err, mongo.ErrNoDocuments) {
cursor, e := s.users.Find(ctx, bson.M{"$and": bson.A{orgCompatibilityFilter(org), bson.M{"role": domain.UserRoleAcceptanceReviewer, "acceptanceAccessMode": bson.M{"$ne": "managed"}}}}, options.Find().SetProjection(bson.M{"id": 1}))
if e != nil {
return nil, e
}
users, e := decodeMany[domain.UserRecord](ctx, cursor)
if e != nil {
return nil, e
}
snap.UserIDs = []string{}
for _, user := range users {
snap.UserIDs = append(snap.UserIDs, user.ID)
}
sort.Strings(snap.UserIDs)
_, err = c.InsertOne(ctx, bson.M{"_id": id, "organizationId": id, "userIds": snap.UserIDs, "createdAt": nowISO()})
}
if err != nil {
return nil, err
}
// Conditional writes preserve every later role change, including replay
// after a crash between snapshot creation and this compatibility marking.
_, err = s.users.UpdateMany(ctx, bson.M{"id": bson.M{"$in": snap.UserIDs}, "role": domain.UserRoleAcceptanceReviewer, "acceptanceAccessMode": bson.M{"$in": bson.A{nil, "", "legacy"}}}, bson.M{"$set": bson.M{"acceptanceAccessMode": "legacy"}})
return nil, err
})
return err
}
func stampAcceptanceClaim(item *domain.HumanItemRecord, user domain.UserRecord, grant domain.SupplierAcceptanceAuthorization) {
item.AcceptanceClaim = &domain.AcceptanceClaimAccess{UserID: user.ID, SupplierID: user.SupplierID, GrantVersion: grant.Version, StageID: item.CurrentStageID, Round: item.ReviewRound, ClaimedAt: item.ClaimedAt}
}
func currentAcceptanceClaim(item domain.HumanItemRecord, supplier, user string) bool {
v := item.AcceptanceClaim
return v != nil && (supplier == "" || v.SupplierID == supplier) && (user == "" || v.UserID == user) &&
v.UserID == item.AssignedUserID && v.StageID == item.CurrentStageID && v.Round == item.ReviewRound &&
v.ClaimedAt != "" && v.ClaimedAt == item.ClaimedAt && (item.Status == domain.HumanItemClaimed || item.Status == domain.HumanItemInProgress)
}
func (s *MemoryStore) SharedAcceptanceInventory(_ context.Context, org, supplier, user string) ([]string, int, error) {
s.mu.Lock()
defer s.mu.Unlock()
projects := map[string]bool{}
count := 0
for _, item := range s.humanItems {
if humanOrganizationMatches(item.OrganizationID, org) && currentAcceptanceClaim(item, supplier, user) {
projects[item.ProjectID] = true
count++
}
}
ids := []string{}
for id := range projects {
ids = append(ids, id)
}
sort.Strings(ids)
return ids, count, nil
}
func (s *MongoStore) SharedAcceptanceInventory(ctx context.Context, org, supplier, user string) ([]string, int, error) {
filter := bson.M{"organizationId": normalizedOrganizationID(org), "acceptanceClaim": bson.M{"$ne": nil}, "status": bson.M{"$in": bson.A{domain.HumanItemClaimed, domain.HumanItemInProgress}},
"$expr": bson.M{"$and": bson.A{bson.M{"$eq": bson.A{"$acceptanceClaim.userId", "$assignedUserId"}}, bson.M{"$eq": bson.A{"$acceptanceClaim.stageId", "$currentStageId"}}, bson.M{"$eq": bson.A{"$acceptanceClaim.round", "$reviewRound"}}, bson.M{"$eq": bson.A{"$acceptanceClaim.claimedAt", "$claimedAt"}}, bson.M{"$ne": bson.A{"$claimedAt", ""}}}}}
if supplier != "" {
filter["acceptanceClaim.supplierId"] = supplier
}
if user != "" {
filter["acceptanceClaim.userId"] = user
}
cursor, err := s.humanItems.Find(ctx, filter, options.Find().SetProjection(bson.M{"projectId": 1}))
if err != nil {
return nil, 0, err
}
items, err := decodeMany[domain.HumanItemRecord](ctx, cursor)
if err != nil {
return nil, 0, err
}
projects := map[string]bool{}
for _, item := range items {
projects[item.ProjectID] = true
}
ids := []string{}
for id := range projects {
ids = append(ids, id)
}
sort.Strings(ids)
return ids, len(items), nil
}

View File

@ -0,0 +1,285 @@
package store
import (
"context"
"errors"
"fmt"
"net/url"
"os"
"sync"
"testing"
"time"
"droboticflow/internal/domain"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
func testSharedAcceptanceStore(t *testing.T, s Store) {
t.Helper()
ctx := t.Context()
org := "acceptance-test-org"
for _, id := range []string{"producer", "reviewer"} {
if err := s.UpsertSupplier(ctx, domain.SupplierRecord{ID: id, OrganizationID: org, Status: "active"}); err != nil {
t.Fatal(err)
}
}
input := domain.CreateUserInput{OrganizationID: org, SupplierID: "reviewer", Role: domain.UserRoleAcceptanceReviewer, Phone: "13900101001", Status: domain.UserStatusActive}
if _, err := s.CreateUser(ctx, input); !errors.Is(err, ErrAcceptanceAuthorizationRequired) {
t.Fatalf("default must deny: %v", err)
}
g, err := s.SetSupplierAcceptanceAuthorization(ctx, org, "reviewer", true, 0, "admin")
if err != nil {
t.Fatal(err)
}
if _, err := s.SetSupplierAcceptanceAuthorization(ctx, org, "reviewer", false, 0, "admin"); !errors.Is(err, ErrAcceptanceAuthorizationConflict) {
t.Fatalf("stale update %v", err)
}
a, err := s.CreateUser(ctx, input)
if err != nil {
t.Fatal(err)
}
input.Phone = "13900101002"
b, err := s.CreateUser(ctx, input)
if err != nil {
t.Fatal(err)
}
if a.AcceptanceAccessMode != "managed" {
t.Fatal("new user grandfathered")
}
batch := domain.HumanBatchRecord{ID: "acceptance-batch", OrganizationID: org, ProjectID: "other-project", PluginID: "annotation-qa", Stages: []domain.HumanStageDefinition{{ID: "acceptance", Kind: domain.HumanStageAcceptance, RequiredRole: "acceptance_reviewer"}}}
if err := s.UpsertHumanBatch(ctx, batch); err != nil {
t.Fatal(err)
}
item := domain.HumanItemRecord{ID: "acceptance-item", OrganizationID: org, ProjectID: batch.ProjectID, PluginID: batch.PluginID, BatchID: batch.ID, SupplierID: "producer", CurrentStageID: "acceptance", Status: domain.HumanItemReady, Version: 1, ReviewRound: 1}
if err := s.UpsertHumanItem(ctx, item); err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
wins := make(chan string, 2)
errs := make(chan error, 2)
for _, u := range []*domain.UserRecord{a, b} {
wg.Add(1)
go func(user *domain.UserRecord) {
defer wg.Done()
next := item
next.AssignedUserID = user.ID
next.Status = domain.HumanItemClaimed
next.ClaimedAt = nowISO()
next.Version++
ok, e := s.ClaimHumanItemVersioned(ctx, next, 1, domain.UserRoleAcceptanceReviewer)
if e != nil {
errs <- e
}
if ok {
wins <- user.ID
}
}(u)
}
wg.Wait()
close(wins)
close(errs)
for e := range errs {
t.Fatal(e)
}
if len(wins) != 1 {
t.Fatalf("claim winners %d", len(wins))
}
winner := <-wins
stored, err := s.GetHumanItem(ctx, item.ID)
if err != nil {
t.Fatal(err)
}
user, _ := s.GetUser(ctx, winner)
if stored.SupplierID != "producer" || !stored.AcceptanceClaim.Matches(*stored, *user) {
t.Fatalf("receipt/ownership: %+v", stored)
}
_, err = s.SetSupplierAcceptanceAuthorization(ctx, org, "reviewer", false, g.Version, "admin")
if err != nil {
t.Fatal(err)
}
projects, count, err := s.SharedAcceptanceInventory(ctx, org, "reviewer", winner)
if err != nil || count != 1 || len(projects) != 1 {
t.Fatalf("drain inventory %v %d %v", projects, count, err)
}
item.ID = "new-round"
item.ReviewRound++
if err := s.UpsertHumanItem(ctx, item); err != nil {
t.Fatal(err)
}
next := item
next.AssignedUserID = winner
next.Status = domain.HumanItemClaimed
next.ClaimedAt = nowISO()
next.Version++
if ok, err := s.ClaimHumanItemVersioned(ctx, next, 1, domain.UserRoleAcceptanceReviewer); ok || !errors.Is(err, ErrHumanClaimConflict) {
t.Fatalf("revoked claim %v %v", ok, err)
}
copy := *stored
copy.ReviewRound++
if copy.AcceptanceClaim.Matches(copy, *user) {
t.Fatal("receipt leaked to another round")
}
// Legacy role changes invalidate the old compatibility even if changed back.
legacy := domain.UserRecord{ID: "legacy-reviewer", OrganizationID: org, SupplierID: "reviewer", Phone: "13900101003", Role: domain.UserRoleAcceptanceReviewer, Status: domain.UserStatusActive}
if err := s.UpsertUser(ctx, legacy); err != nil {
t.Fatal(err)
}
changed := legacy
changed.Role = domain.UserRoleAnnotator
if err := s.UpdateUser(ctx, changed, legacy); err != nil {
t.Fatal(err)
}
current, _ := s.GetUser(ctx, legacy.ID)
if current.AcceptanceAccessMode != "managed" {
t.Fatal("role change retained compatibility")
}
back := *current
back.Role = domain.UserRoleAcceptanceReviewer
if err := s.UpdateUser(ctx, back, *current); !errors.Is(err, ErrAcceptanceAuthorizationRequired) {
t.Fatalf("role bypass %v", err)
}
}
func TestSharedAcceptanceStore(t *testing.T) { testSharedAcceptanceStore(t, NewMemoryStore()) }
func TestSharedAcceptanceMongo(t *testing.T) {
uri := os.Getenv("ACCEPTANCE_LOCAL_MONGO_URI")
if uri == "" {
t.Skip("ACCEPTANCE_LOCAL_MONGO_URI required")
}
u, parseErr := url.Parse(uri)
if parseErr != nil || u.Scheme != "mongodb" || (u.Host != "127.0.0.1:27018" && u.Host != "127.0.0.1:27028") {
t.Fatal("only local replica/standalone Mongo allowed")
}
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
client, err := mongo.Connect(ctx, options.Client().ApplyURI(uri))
if err != nil {
t.Fatal(err)
}
defer client.Disconnect(context.Background())
db := client.Database(fmt.Sprintf("acceptance_auth_test_%d", time.Now().UnixNano()))
defer db.Drop(context.Background())
s := NewMongoStore(db)
testSharedAcceptanceStore(t, s)
testAcceptanceRevocationRaceAndQueue(t, s)
legacy := domain.UserRecord{ID: "migration-old", OrganizationID: "migration-org", Role: domain.UserRoleAcceptanceReviewer, AcceptanceAccessMode: "", Phone: "13900101111"}
if err := s.UpsertUser(ctx, legacy); err != nil {
t.Fatal(err)
}
if err := s.SnapshotLegacyAcceptanceAccounts(ctx, legacy.OrganizationID); err != nil {
t.Fatal(err)
}
old, _ := s.GetUser(ctx, legacy.ID)
if old.AcceptanceAccessMode != "legacy" {
t.Fatal("legacy snapshot missing")
}
changed := *old
changed.Role = domain.UserRoleAnnotator
if err := s.UpdateUser(ctx, changed, *old); err != nil {
t.Fatal(err)
}
if err := s.SnapshotLegacyAcceptanceAccounts(ctx, legacy.OrganizationID); err != nil {
t.Fatal(err)
}
current, _ := s.GetUser(ctx, legacy.ID)
if current.AcceptanceAccessMode != "managed" {
t.Fatal("replay revived legacy access")
}
}
func testAcceptanceRevocationRaceAndQueue(t *testing.T, s Store) {
t.Helper()
ctx := t.Context()
org := "acceptance-race-org"
if err := s.UpsertSupplier(ctx, domain.SupplierRecord{ID: "race-supplier", OrganizationID: org, Status: "active"}); err != nil {
t.Fatal(err)
}
g, err := s.SetSupplierAcceptanceAuthorization(ctx, org, "race-supplier", true, 0, "admin")
if err != nil {
t.Fatal(err)
}
u, err := s.CreateUser(ctx, domain.CreateUserInput{OrganizationID: org, SupplierID: "race-supplier", Role: domain.UserRoleAcceptanceReviewer, Phone: "13900102222"})
if err != nil {
t.Fatal(err)
}
batch := domain.HumanBatchRecord{ID: "race-batch", OrganizationID: org, PluginID: "annotation-qa", Stages: []domain.HumanStageDefinition{{ID: "acceptance", Kind: domain.HumanStageAcceptance, RequiredRole: "acceptance_reviewer"}}}
if err = s.UpsertHumanBatch(ctx, batch); err != nil {
t.Fatal(err)
}
for i := 0; i < 8; i++ {
item := domain.HumanItemRecord{ID: fmt.Sprintf("race-%d", i), OrganizationID: org, ProjectID: "project-race", PluginID: "annotation-qa", BatchID: batch.ID, CurrentStageID: "acceptance", Status: domain.HumanItemReady, Version: 1, ReviewRound: 1}
if err = s.UpsertHumanItem(ctx, item); err != nil {
t.Fatal(err)
}
next := item
next.AssignedUserID = u.ID
next.Status = domain.HumanItemClaimed
next.ClaimedAt = nowISO()
next.Version++
var won bool
var claimErr, revokeErr error
var revoked *domain.SupplierAcceptanceAuthorization
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
won, claimErr = s.ClaimHumanItemVersioned(ctx, next, 1, domain.UserRoleAcceptanceReviewer)
}()
go func() {
defer wg.Done()
revoked, revokeErr = s.SetSupplierAcceptanceAuthorization(ctx, org, u.SupplierID, false, g.Version, "admin")
}()
wg.Wait()
if revokeErr != nil {
t.Fatal(revokeErr)
}
if claimErr != nil && !errors.Is(claimErr, ErrHumanClaimConflict) {
t.Fatal(claimErr)
}
saved, _ := s.GetHumanItem(ctx, item.ID)
if won && (saved.AcceptanceClaim == nil || saved.AcceptanceClaim.GrantVersion >= revoked.Version || !saved.AcceptanceClaim.Matches(*saved, *u)) {
t.Fatal("claim after revoke or missing receipt")
}
if !won && saved.AssignedUserID != "" {
t.Fatal("failed claim wrote ownership")
}
item.ID += "-after"
if err = s.UpsertHumanItem(ctx, item); err != nil {
t.Fatal(err)
}
next.ID = item.ID
if ok, e := s.ClaimHumanItemVersioned(ctx, next, 1, domain.UserRoleAcceptanceReviewer); ok || !errors.Is(e, ErrHumanClaimConflict) {
t.Fatalf("post revoke claim %v %v", ok, e)
}
g, err = s.SetSupplierAcceptanceAuthorization(ctx, org, u.SupplierID, true, revoked.Version, "admin")
if err != nil {
t.Fatal(err)
}
}
// Mixed legacy timestamps are ordered before pagination; candidates never carry video evidence.
for i := 0; i < 105; i++ {
at := time.Date(2020, 1, 1, 0, 0, i, 0, time.UTC).Format(time.RFC3339Nano)
if i == 0 {
at = "2020-01-01T08:00:00+08:00"
}
v := domain.HumanItemRecord{ID: fmt.Sprintf("queue-%03d", i), OrganizationID: org, ProjectID: "queue-project", PluginID: "annotation-qa", Status: domain.HumanItemReady, CreatedAt: at, Subject: domain.HumanSubjectRef{Payload: map[string]any{"largeEvidence": "omitted"}}}
if e := s.UpsertHumanItem(ctx, v); e != nil {
t.Fatal(e)
}
}
for _, offset := range []int{0, 100} {
rows, e := s.ListReviewCandidates(ctx, org, "queue-project", u.ID, false, offset, 100)
if e != nil {
t.Fatal(e)
}
for i, row := range rows {
if row.ID != fmt.Sprintf("queue-%03d", offset+i) || row.Subject.Payload != nil {
t.Fatalf("bad bounded order/payload %+v", row)
}
}
}
}
func TestAcceptanceRevocationRaceAndQueue(t *testing.T) {
testAcceptanceRevocationRaceAndQueue(t, NewMemoryStore())
}

View File

@ -92,12 +92,12 @@ func (store *MongoStore) updateAdministrator(ctx context.Context, item domain.Us
// Compare security and profile fields that may be overwritten by a stale form.
func sameUserMutationSnapshot(a, b domain.UserRecord) bool {
return a.DeletedAt == b.DeletedAt && a.DeletedBy == b.DeletedBy && a.ID == b.ID && a.OrganizationID == b.OrganizationID && a.SupplierID == b.SupplierID && a.Role == b.Role && a.IsSuperAdmin == b.IsSuperAdmin && a.Status == b.Status && a.PasswordHash == b.PasswordHash && a.UpdatedAt == b.UpdatedAt && a.Name == b.Name && a.Phone == b.Phone && reflect.DeepEqual(a.DefaultProjectRoles, b.DefaultProjectRoles)
return a.AcceptanceAccessMode == b.AcceptanceAccessMode && a.DeletedAt == b.DeletedAt && a.DeletedBy == b.DeletedBy && a.ID == b.ID && a.OrganizationID == b.OrganizationID && a.SupplierID == b.SupplierID && a.Role == b.Role && a.IsSuperAdmin == b.IsSuperAdmin && a.Status == b.Status && a.PasswordHash == b.PasswordHash && a.UpdatedAt == b.UpdatedAt && a.Name == b.Name && a.Phone == b.Phone && reflect.DeepEqual(a.DefaultProjectRoles, b.DefaultProjectRoles)
}
func userMutationFilter(old domain.UserRecord) bson.M {
filter := bson.M{"id": old.ID}
for key, value := range map[string]string{"deletedAt": old.DeletedAt, "organizationId": old.OrganizationID, "supplierId": old.SupplierID, "role": string(old.Role), "status": string(old.Status), "passwordHash": old.PasswordHash, "updatedAt": old.UpdatedAt, "name": old.Name, "phone": old.Phone} {
for key, value := range map[string]string{"acceptanceAccessMode": old.AcceptanceAccessMode, "deletedAt": old.DeletedAt, "organizationId": old.OrganizationID, "supplierId": old.SupplierID, "role": string(old.Role), "status": string(old.Status), "passwordHash": old.PasswordHash, "updatedAt": old.UpdatedAt, "name": old.Name, "phone": old.Phone} {
if value == "" {
filter[key] = bson.M{"$in": bson.A{"", nil}}
} else {

View File

@ -51,14 +51,22 @@ func (s *MemoryStore) ClaimHumanItemVersioned(_ context.Context, item domain.Hum
s.mu.Lock()
defer s.mu.Unlock()
user, ok := s.users[item.AssignedUserID]
if !ok || !validClaimAccount(&user, item, role) {
grant := s.acceptanceAuthorizationLocked(item.OrganizationID, user.SupplierID)
batch := s.humanBatches[item.BatchID]
supplier := s.suppliers[user.SupplierID]
shared := ok && role == domain.UserRoleAcceptanceReviewer && grant.Enabled && supplier.Status == "active" && humanOrganizationMatches(supplier.OrganizationID, item.OrganizationID) && domain.SharedAcceptanceItem(item, &batch)
accountItem := item
if shared {
accountItem.SupplierID = ""
}
if !ok || !validClaimAccount(&user, accountItem, role) || (role == domain.UserRoleAcceptanceReviewer && user.AcceptanceAccessMode == "managed" && !shared) {
return false, ErrHumanClaimConflict
}
old, ok := s.humanItems[item.ID]
if !ok || old.Version != version {
return false, nil
}
if batch, ok := s.humanBatches[item.BatchID]; ok && batch.ProcessingProfile == domain.ProcessingProfileRawHuman && domain.IsFanyuV58ThreeRoleHumanLoop(batch.Stages) {
if batch, ok := s.humanBatches[item.BatchID]; !shared && ok && batch.ProcessingProfile == domain.ProcessingProfileRawHuman && domain.IsFanyuV58ThreeRoleHumanLoop(batch.Stages) {
grants, err := s.listSupplierProjectAuthorizationsLocked(item.OrganizationID, item.ProjectID)
if err != nil {
return false, err
@ -70,16 +78,29 @@ func (s *MemoryStore) ClaimHumanItemVersioned(_ context.Context, item domain.Hum
if j := item.ProcessingJob; j != nil && j.Owner != "" && (old.ProcessingJob == nil || old.ProcessingJob.ID != j.ID || old.ProcessingJob.Owner != j.Owner) {
return false, nil
}
item.AcceptanceClaim = nil
if shared {
stampAcceptanceClaim(&item, user, grant)
}
item = normalizeHumanItem(item)
s.humanItems[item.ID] = clone(item)
return true, nil
}
func (s *MongoStore) ClaimHumanItemVersioned(ctx context.Context, item domain.HumanItemRecord, version int, role domain.UserRole) (bool, error) {
result, e := s.withSupplierProjectLocks(ctx, []string{item.ProjectID}, func(ctx context.Context) (any, error) {
return s.claimHumanItemSupplierGuarded(ctx, item, version, role)
})
if e != nil {
return false, e
claim := func(ctx context.Context) (any, error) {
return s.withSupplierProjectLocks(ctx, []string{item.ProjectID}, func(ctx context.Context) (any, error) {
return s.claimHumanItemSupplierGuarded(ctx, item, version, role)
})
}
var result any
var err error
if role == domain.UserRoleAcceptanceReviewer {
result, err = s.withAccountMutationLock(ctx, "suppliers:"+normalizedOrganizationID(item.OrganizationID), claim)
} else {
result, err = claim(ctx)
}
if err != nil {
return false, err
}
return result.(bool), nil
}
@ -96,14 +117,34 @@ func (s *MongoStore) claimHumanItemSupplierGuarded(ctx context.Context, item dom
if e != nil {
return false, e
}
if !validClaimAccount(user, item, role) {
return false, ErrHumanClaimConflict
}
batch, e := s.GetHumanBatch(sc, item.BatchID)
if e != nil {
return false, e
}
if batch != nil && batch.ProcessingProfile == domain.ProcessingProfileRawHuman && domain.IsFanyuV58ThreeRoleHumanLoop(batch.Stages) {
shared := false
item.AcceptanceClaim = nil
if user != nil && role == domain.UserRoleAcceptanceReviewer && domain.SharedAcceptanceItem(item, batch) {
grant, err := s.GetSupplierAcceptanceAuthorization(sc, item.OrganizationID, user.SupplierID)
if err != nil {
return false, err
}
supplier, err := s.GetSupplier(sc, user.SupplierID)
if err != nil {
return false, err
}
shared = grant.Enabled && supplier != nil && supplier.Status == "active" && humanOrganizationMatches(supplier.OrganizationID, item.OrganizationID)
if shared {
stampAcceptanceClaim(&item, *user, *grant)
}
}
accountItem := item
if shared {
accountItem.SupplierID = ""
}
if !validClaimAccount(user, accountItem, role) || (role == domain.UserRoleAcceptanceReviewer && user.AcceptanceAccessMode == "managed" && !shared) {
return false, ErrHumanClaimConflict
}
if !shared && batch != nil && batch.ProcessingProfile == domain.ProcessingProfileRawHuman && domain.IsFanyuV58ThreeRoleHumanLoop(batch.Stages) {
grants, e := s.ListSupplierProjectAuthorizations(sc, item.OrganizationID, item.ProjectID)
if e != nil {
return false, e

View File

@ -636,7 +636,7 @@ func (store *MongoStore) ListHumanBatchAccessRecords(ctx context.Context, organi
if len(ids) == 0 {
return []domain.HumanBatchRecord{}, nil
}
cursor, err := store.humanBatches.Find(ctx, bson.M{"organizationId": normalizedOrganizationID(organizationID), "id": bson.M{"$in": ids}}, options.Find().SetProjection(bson.M{"_id": 0, "id": 1, "organizationId": 1, "projectId": 1, "stages": 1, "processingProfile": 1, "sourceBatchId": 1}))
cursor, err := store.humanBatches.Find(ctx, bson.M{"organizationId": normalizedOrganizationID(organizationID), "id": bson.M{"$in": ids}}, options.Find().SetProjection(bson.M{"_id": 0, "id": 1, "organizationId": 1, "projectId": 1, "stages": 1, "processingProfile": 1, "sourceBatchId": 1, "processingScope": 1, "requirePrePackageAcceptance": 1}))
if err != nil {
return nil, err
}
@ -655,7 +655,7 @@ func (store *MemoryStore) ListHumanBatchAccessRecords(ctx context.Context, organ
return nil, err
}
if b != nil && b.OrganizationID == normalizedOrganizationID(organizationID) {
items = append(items, domain.HumanBatchRecord{ID: b.ID, OrganizationID: b.OrganizationID, ProjectID: b.ProjectID, Stages: b.Stages, ProcessingProfile: b.ProcessingProfile, SourceBatchID: b.SourceBatchID})
items = append(items, domain.HumanBatchRecord{ID: b.ID, OrganizationID: b.OrganizationID, ProjectID: b.ProjectID, Stages: b.Stages, ProcessingProfile: b.ProcessingProfile, SourceBatchID: b.SourceBatchID, ProcessingScope: b.ProcessingScope, RequirePrePackageAcceptance: b.RequirePrePackageAcceptance})
}
}
return items, nil

View File

@ -13,6 +13,7 @@ import (
)
type MemoryStore struct {
acceptanceAuthorizations map[string]domain.SupplierAcceptanceAuthorization
productionStatsScopes map[string]productionstats.Scope
reviewContinuations map[string]domain.ReviewContinuation
reviewOperations map[string]domain.ReviewOperation
@ -2225,24 +2226,28 @@ func (store *MemoryStore) CreateUser(_ context.Context, input domain.CreateUserI
return nil, ErrSupplierUnavailable
}
}
if input.Role == domain.UserRoleAcceptanceReviewer && !store.acceptanceAuthorizationLocked(input.OrganizationID, input.SupplierID).Enabled {
return nil, ErrAcceptanceAuthorizationRequired
}
now := nowISO()
status := input.Status
if status == "" {
status = domain.UserStatusActive
}
user := domain.UserRecord{
DefaultProjectRoles: input.DefaultProjectRoles,
ID: domain.NewID("user"),
OrganizationID: input.OrganizationID,
Name: input.Name,
Phone: strings.TrimSpace(input.Phone),
Role: input.Role,
SupplierID: strings.TrimSpace(input.SupplierID),
IsSuperAdmin: input.IsSuperAdmin,
PasswordHash: input.PasswordHash,
Status: status,
CreatedAt: now,
UpdatedAt: now,
AcceptanceAccessMode: "managed",
DefaultProjectRoles: input.DefaultProjectRoles,
ID: domain.NewID("user"),
OrganizationID: input.OrganizationID,
Name: input.Name,
Phone: strings.TrimSpace(input.Phone),
Role: input.Role,
SupplierID: strings.TrimSpace(input.SupplierID),
IsSuperAdmin: input.IsSuperAdmin,
PasswordHash: input.PasswordHash,
Status: status,
CreatedAt: now,
UpdatedAt: now,
}
if err := store.ensureUserPhoneAvailableLocked(user.Phone, user.ID); err != nil {
return nil, err
@ -2284,6 +2289,10 @@ func (store *MemoryStore) upsertUser(_ context.Context, item domain.UserRecord,
}
}
if expected != nil && expected.Role != item.Role {
if item.Role == domain.UserRoleAcceptanceReviewer && !store.acceptanceAuthorizationLocked(item.OrganizationID, item.SupplierID).Enabled {
return ErrAcceptanceAuthorizationRequired
}
item.AcceptanceAccessMode = "managed"
for _, task := range store.humanItems {
if task.AssignedUserID == item.ID && pendingAccountItem(task.Status) {
return ErrAccountPendingTasks

View File

@ -2162,26 +2162,42 @@ func (store *MongoStore) FindUserByLegacyEmail(ctx context.Context, email string
}
func (store *MongoStore) CreateUser(ctx context.Context, input domain.CreateUserInput) (*domain.UserRecord, error) {
if input.Role == domain.UserRoleAcceptanceReviewer && strings.TrimSpace(input.SupplierID) == "" {
return nil, ErrAcceptanceAuthorizationRequired
}
if err := store.SnapshotLegacyAcceptanceAccounts(ctx, input.OrganizationID); err != nil {
return nil, err
}
now := nowISO()
item := domain.UserRecord{
DefaultProjectRoles: input.DefaultProjectRoles,
ID: domain.NewID("user"),
OrganizationID: input.OrganizationID,
Name: input.Name,
Phone: strings.TrimSpace(input.Phone),
Role: input.Role,
SupplierID: strings.TrimSpace(input.SupplierID),
IsSuperAdmin: input.IsSuperAdmin,
PasswordHash: input.PasswordHash,
Status: input.Status,
CreatedAt: now,
UpdatedAt: now,
AcceptanceAccessMode: "managed",
DefaultProjectRoles: input.DefaultProjectRoles,
ID: domain.NewID("user"),
OrganizationID: input.OrganizationID,
Name: input.Name,
Phone: strings.TrimSpace(input.Phone),
Role: input.Role,
SupplierID: strings.TrimSpace(input.SupplierID),
IsSuperAdmin: input.IsSuperAdmin,
PasswordHash: input.PasswordHash,
Status: input.Status,
CreatedAt: now,
UpdatedAt: now,
}
if item.Status == "" {
item.Status = domain.UserStatusActive
}
if item.SupplierID != "" {
_, err := store.runAccountTransaction(ctx, "suppliers:"+normalizedOrganizationID(item.OrganizationID), func(sc context.Context) (any, error) {
if item.Role == domain.UserRoleAcceptanceReviewer {
grant, err := store.GetSupplierAcceptanceAuthorization(sc, item.OrganizationID, item.SupplierID)
if err != nil {
return nil, err
}
if !grant.Enabled {
return nil, ErrAcceptanceAuthorizationRequired
}
}
result, e := store.suppliers.UpdateOne(sc, bson.M{"id": item.SupplierID, "organizationId": item.OrganizationID, "status": "active"}, bson.M{"$inc": bson.M{"referenceVersion": 1}})
if e != nil {
return nil, e
@ -2212,8 +2228,25 @@ func (store *MongoStore) UpsertUser(ctx context.Context, item domain.UserRecord)
return store.upsertUser(ctx, item, nil)
}
func (store *MongoStore) UpdateUser(ctx context.Context, item, expected domain.UserRecord) error {
if item.Role != expected.Role && !removesActiveAdmin(expected, item) {
return store.updateAccountRole(ctx, item, expected)
if item.Role != expected.Role {
_, err := store.withAccountMutationLock(ctx, "suppliers:"+normalizedOrganizationID(item.OrganizationID), func(ctx context.Context) (any, error) {
if item.Role == domain.UserRoleAcceptanceReviewer {
grant, err := store.GetSupplierAcceptanceAuthorization(ctx, item.OrganizationID, item.SupplierID)
if err != nil {
return nil, err
}
if !grant.Enabled {
return nil, ErrAcceptanceAuthorizationRequired
}
}
item.AcceptanceAccessMode = "managed"
if removesActiveAdmin(expected, item) {
_, err := store.withAccountMutationLock(ctx, "user:"+item.ID, func(ctx context.Context) (any, error) { return nil, store.upsertUser(ctx, item, &expected) })
return nil, err
}
return nil, store.updateAccountRole(ctx, item, expected)
})
return err
}
_, err := store.withAccountMutationLock(ctx, "user:"+item.ID, func(ctx context.Context) (any, error) { return nil, store.upsertUser(ctx, item, &expected) })
return err

View File

@ -227,6 +227,8 @@ func (store *MongoStore) EnsureIndexes(ctx context.Context) error {
index("organizationId_workflowId_status", bson.D{{Key: "organizationId", Value: 1}, {Key: "workflowId", Value: 1}, {Key: "status", Value: 1}}),
},
store.humanItems: {
index("review_queue_candidates", bson.D{{Key: "organizationId", Value: 1}, {Key: "pluginId", Value: 1}, {Key: "assignedUserId", Value: 1}, {Key: "status", Value: 1}, {Key: "projectId", Value: 1}}),
index("acceptance_claim_inventory", bson.D{{Key: "organizationId", Value: 1}, {Key: "acceptanceClaim.supplierId", Value: 1}, {Key: "acceptanceClaim.userId", Value: 1}, {Key: "status", Value: 1}}),
index("processingJob_status_lease", bson.D{{Key: "processingJob.status", Value: 1}, {Key: "processingJob.leaseUntil", Value: 1}, {Key: "processingJob.createdAt", Value: 1}}),
index("organizationId_legacyTaskId", bson.D{{Key: "organizationId", Value: 1}, {Key: "legacyTaskId", Value: 1}}),
uniqueIndex("id_unique", bson.D{{Key: "id", Value: 1}}),

View File

@ -63,6 +63,9 @@ func (store *MongoStore) RunMigrations(ctx context.Context) error {
return err
}
for _, organization := range organizations {
if err := store.SnapshotLegacyAcceptanceAccounts(ctx, organization.ID); err != nil {
return err
}
if err := store.backfillMissingEmployeeSuppliers(ctx, organization.ID); err != nil {
return err
}

View File

@ -0,0 +1,106 @@
package store
import (
"context"
"sort"
"time"
"droboticflow/internal/domain"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
)
// Candidate pages exclude evidence payloads. The selected item is re-read before
// admission; CAS prevents concurrent reviewers from claiming the same task.
func (s *MemoryStore) ListReviewCandidates(_ context.Context, org, project, user string, mine bool, offset, limit int) ([]domain.HumanItemRecord, error) {
s.mu.Lock()
defer s.mu.Unlock()
if limit < 1 || limit > 100 {
limit = 100
}
if offset < 0 {
offset = 0
}
items := []domain.HumanItemRecord{}
for _, v := range s.humanItems {
if !humanOrganizationMatches(v.OrganizationID, org) || v.PluginID != "annotation-qa" || (project != "" && v.ProjectID != project) {
continue
}
owned := v.AssignedUserID == user && (v.Status == domain.HumanItemClaimed || v.Status == domain.HumanItemInProgress)
available := v.AssignedUserID == "" && (v.Status == domain.HumanItemReady || v.Status == domain.HumanItemSubmitted || v.Status == domain.HumanItemRework)
if (mine && !owned) || (!mine && !available) {
continue
}
v.Subject.Payload = nil
items = append(items, v)
}
sort.Slice(items, func(i, j int) bool {
a, ak := candidateTime(items[i], mine)
b, bk := candidateTime(items[j], mine)
if ak != bk {
return ak
}
if ak && !a.Equal(b) {
return a.Before(b)
}
return items[i].ID < items[j].ID
})
if offset >= len(items) {
return []domain.HumanItemRecord{}, nil
}
end := offset + limit
if end > len(items) {
end = len(items)
}
return items[offset:end], nil
}
func (s *MongoStore) ListReviewCandidates(ctx context.Context, org, project, user string, mine bool, offset, limit int) ([]domain.HumanItemRecord, error) {
if limit < 1 || limit > 100 {
limit = 100
}
if offset < 0 {
offset = 0
}
filter := humanItemMongoFilter(org, domain.HumanItemQuery{PluginID: "annotation-qa", ProjectID: project})
if mine {
filter["assignedUserId"] = user
filter["status"] = bson.M{"$in": bson.A{domain.HumanItemClaimed, domain.HumanItemInProgress}}
} else {
filter["assignedUserId"] = bson.M{"$in": bson.A{"", nil}}
filter["status"] = bson.M{"$in": bson.A{domain.HumanItemReady, domain.HumanItemSubmitted, domain.HumanItemRework}}
}
// Parse historical offsets and missing claim dates before paging. The
// bounded cursor excludes video/annotation payloads even when many projects
// have candidates. Invalid timestamps sort last, matching the legacy queue.
date := func(field string) bson.M {
return bson.M{"$convert": bson.M{"input": "$" + field, "to": "date", "onError": nil, "onNull": nil}}
}
var order any = date("createdAt")
if mine {
order = bson.M{"$ifNull": bson.A{date("claimedAt"), date("createdAt")}}
}
cursor, err := s.humanItems.Aggregate(ctx, mongo.Pipeline{
{{Key: "$match", Value: filter}},
{{Key: "$project", Value: bson.M{"subject.payload": 0}}},
{{Key: "$set", Value: bson.M{"_queueTime": order}}},
{{Key: "$set", Value: bson.M{"_queueMissing": bson.M{"$eq": bson.A{"$_queueTime", nil}}}}},
{{Key: "$sort", Value: bson.D{{Key: "_queueMissing", Value: 1}, {Key: "_queueTime", Value: 1}, {Key: "id", Value: 1}}}},
{{Key: "$skip", Value: int64(offset)}},
{{Key: "$limit", Value: int64(limit)}},
})
if err != nil {
return nil, err
}
return decodeMany[domain.HumanItemRecord](ctx, cursor)
}
func candidateTime(item domain.HumanItemRecord, mine bool) (time.Time, bool) {
if mine {
if at, err := time.Parse(time.RFC3339Nano, item.ClaimedAt); err == nil {
return at, true
}
}
at, err := time.Parse(time.RFC3339Nano, item.CreatedAt)
return at, err == nil
}

View File

@ -214,6 +214,10 @@ type Store interface {
SupplierIndexingActive(context.Context, domain.SupplierDeletionPlan) (bool, error)
ListSuppliers(context.Context, string) ([]domain.SupplierRecord, error)
GetSupplier(context.Context, string) (*domain.SupplierRecord, error)
GetSupplierAcceptanceAuthorization(context.Context, string, string) (*domain.SupplierAcceptanceAuthorization, error)
SetSupplierAcceptanceAuthorization(context.Context, string, string, bool, int, string) (*domain.SupplierAcceptanceAuthorization, error)
ListReviewCandidates(context.Context, string, string, string, bool, int, int) ([]domain.HumanItemRecord, error)
SharedAcceptanceInventory(context.Context, string, string, string) ([]string, int, error)
UpsertSupplier(context.Context, domain.SupplierRecord) error
MutateSupplier(context.Context, string, string, string, bool) (*domain.SupplierRecord, error)
ListProjectMembers(context.Context, string, string) ([]domain.ProjectMemberRecord, error)

View File

@ -133,6 +133,9 @@ func supplierManagementContract(t *testing.T, s Store) {
if err != nil {
t.Fatal(err)
}
if _, err := s.SetSupplierAcceptanceAuthorization(ctx, org, roleSupplier.ID, true, 0, "test-admin"); err != nil {
t.Fatal(err)
}
for i := 0; i < 8; i++ {
user, err := s.CreateUser(ctx, domain.CreateUserInput{OrganizationID: org, Name: "Reviewer", Phone: fmt.Sprintf("138%08d", i), Role: domain.UserRoleQualityReviewer, SupplierID: roleSupplier.ID})
if err != nil {

View File

@ -0,0 +1,93 @@
import { useEffect, useState } from "react";
import { supplierAcceptanceApi, type SupplierAcceptanceAuthorization } from "../services/api/suppliers";
import { getActionErrorMessage } from "../lib/action-errors.js";
export function SupplierAcceptancePanel({
supplierId,
canManage,
onChange,
}: {
supplierId: string;
canManage: boolean;
onChange: (value: SupplierAcceptanceAuthorization | null) => void;
}) {
const [value, setValue] = useState<SupplierAcceptanceAuthorization | null>(null);
const [busy, setBusy] = useState(false);
const [error, setError] = useState("");
const [attempt, setAttempt] = useState(0);
useEffect(() => {
let active = true;
onChange(null);
setValue(null);
setError("");
supplierAcceptanceApi
.get(supplierId)
.then((next) => {
if (active) {
setValue(next);
onChange(next);
}
})
.catch((cause) => {
if (active) setError(getActionErrorMessage(cause, "授权状态加载失败,请重试"));
});
return () => {
active = false;
};
}, [supplierId, attempt, onChange]);
const toggle = async () => {
if (!value || busy || !canManage) return;
setBusy(true);
setError("");
try {
const latest = await supplierAcceptanceApi.get(supplierId);
if (latest.version !== value.version) {
setValue(latest);
onChange(latest);
setError("授权已更新,请核对后再操作。");
return;
}
if (
value.enabled &&
!window.confirm(
`关闭后不能新建验收员或领取新的共享任务。已领取的 ${latest.claimedCount} 条共享任务可完成当前轮次;旧验收员原有权限保留。确认关闭?`,
)
)
return;
const next = await supplierAcceptanceApi.set(supplierId, !value.enabled, value.version);
setValue(next);
onChange(next);
} catch (cause) {
setError(getActionErrorMessage(cause, "保存授权失败,请刷新核对后重试"));
} finally {
setBusy(false);
}
};
return (
<section className="space-y-2 rounded-xl border border-[color:var(--app-border)] bg-[color:var(--app-panel)] p-5 shadow-sm">
<label className="flex items-center gap-3 font-semibold">
<input
type="checkbox"
role="switch"
checked={value?.enabled ?? false}
disabled={!value || busy || !canManage}
onChange={() => void toggle()}
/>
允许最终验收
{!value && !error && <span className="text-sm font-normal text-slate-500">加载中…</span>}
</label>
<p className="text-sm text-slate-500 dark:text-gray-400">
开启后,本供应商可创建最终验收员,验收当前组织所有生产项目。
</p>
{!canManage && <p className="text-sm text-slate-500">由平台管理员设置。</p>}
{error && (
<p role="alert" className="text-sm text-red-600">
{error}{" "}
<button type="button" disabled={busy} className="underline" onClick={() => setAttempt((n) => n + 1)}>
刷新授权状态
</button>
</p>
)}
</section>
);
}

View File

@ -86,11 +86,15 @@ export function useReviewContinuation(options: Options) {
// A continuation failure does not undo a confirmed review decision. Keep
// transport errors out of the workbench without claiming the queue is empty.
pause(
cause instanceof APIError && cause.code === "review_continuation_owned_elsewhere"
? "另一页面仍在连续审查,请先在原页面暂停,或等待其退出后再继续。"
: decisionCompleted
? "审核已完成,后续任务暂未加载,请稍后点击继续审查。"
: "连续审查连接暂不可用,已暂停,请稍后点击继续。",
cause instanceof APIError && cause.code === "acceptance_authorization_required"
? decisionCompleted
? "当前验收已完成,供应商授权已关闭,连续验收已停止。"
: "供应商最终验收授权未开启或已关闭;已领取任务仍可完成,请联系管理员。"
: cause instanceof APIError && cause.code === "review_continuation_owned_elsewhere"
? "另一页面仍在连续审查,请先在原页面暂停,或等待其退出后再继续。"
: decisionCompleted
? "审核已完成,后续任务暂未加载,请稍后点击继续审查。"
: "连续审查连接暂不可用,已暂停,请稍后点击继续。",
);
setStatus("error");
};
@ -131,7 +135,7 @@ export function useReviewContinuation(options: Options) {
const start = async () => {
const o = opts.current;
if (!o.enabled || !o.userId || busyRef.current || decisionItem.current) return;
if (!o.projectId) {
if (!o.projectId && o.stage !== "acceptance") {
setMessage("请先选择项目或打开一个审查任务,再开始连续审查。");
return;
}

View File

@ -1752,16 +1752,20 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
);
const reviewEntryScope = `${currentUser?.id || ""}:${projectId}:${workspaceMode === "acceptance" ? "acceptance" : "quality"}:${reviewOnly}`;
const reviewEntryIntent = useReviewEntryIntent();
const reviewProjectResume = useRef<string | null>(null);
const reviewContinuation = useReviewContinuation({
userId: currentUser?.id || "",
projectId: reviewContinuationProjectId,
projectId: workspaceMode === "acceptance" ? projectId : reviewContinuationProjectId,
stage: workspaceMode === "acceptance" ? "acceptance" : "quality",
enabled: reviewOnly,
currentItemId: reviewSessionEnabled ? reviewSessionItem?.id || "" : "",
sessionHeaders: reviewSession.headers,
sessionWritable: reviewSession.writable,
onControlLost: reviewSession.handleError,
onPaused: () => reviewEntryIntent.latch(),
onPaused: () => {
reviewProjectResume.current = null;
reviewEntryIntent.latch();
},
onOpenItem: (item) => {
const acceptance = item.currentStageId === "prepackage_acceptance";
const taskId = acceptance ? "" : item.legacyTaskId || "";
@ -1849,6 +1853,34 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
reviewEntryIntent,
reviewContinuation,
]);
useEffect(() => {
// Only an explicit filter change made while acceptance was running may
// resume the new scope. Refresh, manual/exception pauses never set this.
const pending = reviewProjectResume.current;
if (!pending) return;
if (
pending !== reviewEntryScope ||
!reviewOnly ||
workspaceMode !== "acceptance" ||
reviewWindowUndersized ||
viewportPaused
) {
reviewProjectResume.current = null;
return;
}
if (reviewSessionEnabled || reviewContinuation.busy || reviewDecision.pending) return;
reviewProjectResume.current = null;
void reviewContinuation.start();
}, [
reviewEntryScope,
reviewOnly,
workspaceMode,
reviewWindowUndersized,
viewportPaused,
reviewSessionEnabled,
reviewContinuation,
reviewDecision.pending,
]);
useEffect(() => {
// An undersized window suspends review continuation in both layouts (the
// 1413×615 bottom line is a review requirement, not focused-only); recovery
@ -2266,6 +2298,7 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
(item: HumanItem | undefined) => {
if (!item) return false;
if (isManager) return true;
if (typeof item.canClaim === "boolean") return item.canClaim;
const requiredRole = assignmentRoleForStage(item.currentStageId || "");
const member = projectMembers.find((m) => m.userId === currentUser?.id && m.projectId === item.projectId);
return memberCanClaim(item, member, requiredRole);
@ -3900,11 +3933,22 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
setError("当前任务有未确认修改;请先放弃修改后再切换项目。");
return;
}
if (nextProjectId === projectId) return;
if (workspaceMode === "acceptance") {
const resume = reviewContinuousRunning || Boolean(reviewProjectResume.current);
reviewContinuation.pause("正在切换验收项目范围…");
if (resume) reviewProjectResume.current = `${currentUser?.id || ""}:${nextProjectId}:acceptance:${reviewOnly}`;
reviewSelectionRef.current = { task: "", acceptance: "" };
setExpandedDeliveryPackageId("");
setSelectedAnnotationTaskId("");
setDetail(null);
}
setProjectId(nextProjectId);
const next = new URLSearchParams(searchParams);
if (nextProjectId) next.set("projectId", nextProjectId);
else next.delete("projectId");
next.delete("taskId");
next.delete("acceptanceId");
next.delete("workflowId");
next.delete("capture");
next.delete("runId");

View File

@ -27,10 +27,13 @@ import {
getUserRoleLabel,
} from "../lib/user-roles";
import { CHINA_MOBILE_PHONE_PATTERN } from "../lib/phone";
import { SupplierAcceptancePanel } from "../components/SupplierAcceptancePanel";
import type { SupplierAcceptanceAuthorization } from "../services/api/suppliers";
import { SupplierAuthorizationsPanel } from "../components/SupplierAuthorizationsPanel";
export default function Users() {
const { currentUser, refreshUsers } = useUser();
const [acceptanceAuthorization, setAcceptanceAuthorization] = useState<SupplierAcceptanceAuthorization | null>(null);
const [users, setUsers] = useState<UserData[]>([]);
const [suppliers, setSuppliers] = useState<Supplier[]>([]);
const [editingUser, setEditingUser] = useState<UserData | null>(null);
@ -417,6 +420,11 @@ export default function Users() {
</div>
{selectedSupplier && (
<React.Fragment key={selectedSupplier.id}>
<SupplierAcceptancePanel
supplierId={selectedSupplier.id}
canManage={currentUser?.role === "admin"}
onChange={setAcceptanceAuthorization}
/>
<SupplierAuthorizationsPanel supplierId={selectedSupplier.id} canManage={currentUser?.role === "admin"} />
</React.Fragment>
)}
@ -707,13 +715,28 @@ export default function Users() {
onChange={(e) => setEditingUser({ ...editingUser, role: e.target.value as UserData["role"] })}
>
{roleOptions.map((option) => (
<option key={option.value} value={option.value}>
<option
key={option.value}
value={option.value}
disabled={
option.value === "acceptance_reviewer" &&
!(
acceptanceAuthorization?.supplierId === editingUser.supplierId &&
acceptanceAuthorization.enabled
) &&
!(
modalMode === "edit" &&
users.find((user) => user.id === editingUser.id)?.role === "acceptance_reviewer"
)
}
>
{option.label}
</option>
))}
</select>
<p className="text-xs leading-5 text-slate-500 dark:text-gray-500">
{getUserRoleDescription(editingUser.role)}
{!acceptanceAuthorization?.enabled && " 最终验收员需平台管理员为供应商开启授权;已有账号保留原权限。"}
</p>
</div>
{editingUser.role !== "admin" && (

View File

@ -24,8 +24,12 @@ export const reviewContinuationApi = {
keepalive = false,
) =>
apiRequest<ReviewContinuationSnapshot>(
`/api/projects/${encodeURIComponent(projectId)}/review-continuation`,
input.stage === "acceptance"
? "/api/review-continuation"
: `/api/projects/${encodeURIComponent(projectId)}/review-continuation`,
{ method: "POST", headers, keepalive },
input,
input.stage === "acceptance"
? { ...input, scope: projectId ? "project" : "all", ...(projectId ? { projectId } : {}) }
: input,
),
};

View File

@ -1,6 +1,24 @@
import type { Supplier } from "../../types";
import { apiRequest } from "./client";
export type SupplierAcceptanceAuthorization = {
supplierId: string;
enabled: boolean;
version: number;
claimedCount: number;
};
export const supplierAcceptanceApi = {
get: (id: string) =>
apiRequest<SupplierAcceptanceAuthorization>(`/api/suppliers/${encodeURIComponent(id)}/acceptance-authorization`),
set: (id: string, enabled: boolean, version: number) =>
apiRequest<SupplierAcceptanceAuthorization>(
`/api/suppliers/${encodeURIComponent(id)}/acceptance-authorization`,
{ method: "PUT" },
{ enabled, version },
),
};
export const suppliersApi = {
list: async (options?: { forProject?: boolean }) =>
(await apiRequest<{ items: Supplier[] }>("/api/suppliers" + (options?.forProject ? "?forProject=true" : ""))).items,
@ -42,7 +60,8 @@ export const supplierDeletionsApi = {
preview: (id: string, signal?: AbortSignal) =>
apiRequest<SupplierDeletionPlan>(`/api/suppliers/${encodeURIComponent(id)}/deletion-preview`, { signal }),
list: async () => (await apiRequest<{ items: SupplierDeletionTask[] }>("/api/supplier-deletions")).items,
get: (id: string, signal?: AbortSignal) => apiRequest<SupplierDeletionTask>(`/api/supplier-deletions/${encodeURIComponent(id)}`, { signal }),
get: (id: string, signal?: AbortSignal) =>
apiRequest<SupplierDeletionTask>(`/api/supplier-deletions/${encodeURIComponent(id)}`, { signal }),
start: (id: string, payload: { confirmationName: string; digest: string; stopRunning: boolean; reason: string }) =>
apiRequest<SupplierDeletionTask>(`/api/suppliers/${encodeURIComponent(id)}/deletions`, { method: "POST" }, payload),
};

View File

@ -2176,6 +2176,8 @@ export interface HumanTaskDisplayContext {
}
export interface HumanItem {
/** Server-computed acceptance claim capability; never used as a write credential. */
canClaim?: boolean;
reviewHistoryStatus?: "pending_acceptance" | "accepted";
claimedAt?: string;
processingScope?: "public" | "internal" | "supplier";

View File

@ -0,0 +1,263 @@
// Opt-in localhost synthetic API/Mongo fixture: TestSupplierAcceptanceBrowser.
import assert from "node:assert/strict";
import fs from "node:fs/promises";
import { chromium } from "playwright";
const base = "http://127.0.0.1:5173";
const out = "local-data/verification/supplier-acceptance";
await fs.mkdir(out, { recursive: true });
const browser = await chromium.launch({
executablePath: process.env.BROWSER_EXECUTABLE || "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
headless: true,
args: ["--no-proxy-server"],
});
const reports = [],
errors = [];
async function actor(phone) {
const ctx = await browser.newContext({ viewport: { width: 1600, height: 1000 } });
const res = await ctx.request.post(base + "/api/auth/login", {
data: { phone, password: process.env.ACCEPTANCE_QA_PASSWORD },
});
assert.equal(res.status(), 200, "isolated login");
const page = await ctx.newPage();
page.setDefaultTimeout(20000);
page.on("pageerror", (e) => errors.push(e.message));
return { ctx, page };
}
async function request(ctx, method, path, data) {
const csrf = (await ctx.cookies()).find((c) => c.name === "droboticflow_csrf")?.value;
const res = await ctx.request.fetch(base + path, {
method,
data,
headers: { "X-Droboticflow-CSRF-Token": csrf || "" },
});
return { status: res.status(), body: await res.json() };
}
let active;
try {
const admin = await actor("13900009001");
active = admin.page;
await admin.page.goto(base + "/users");
await admin.page.getByRole("button", { name: /^验收供应商/ }).click();
const toggle = admin.page.getByRole("switch", { name: /允许最终验收/ });
await toggle.waitFor();
await admin.page.waitForFunction(() => !document.querySelector("[role=switch]")?.disabled);
assert.equal(await toggle.isChecked(), false);
await admin.page.getByRole("button", { name: "创建账号", exact: true }).click();
assert.equal(await admin.page.locator('option[value="acceptance_reviewer"]').isDisabled(), true);
await admin.page.getByRole("button", { name: "取消", exact: true }).click();
const blocked = await request(admin.ctx, "POST", "/api/users", {
name: "禁止越权",
phone: "13900009100",
supplierId: "local-reviewer",
role: "acceptance_reviewer",
password: process.env.ACCEPTANCE_QA_PASSWORD,
});
assert.equal(blocked.status, 403);
await toggle.click();
await admin.page.waitForFunction(
() => document.querySelector("[role=switch]")?.checked && !document.querySelector("[role=switch]")?.disabled,
);
await admin.page.screenshot({ path: out + "/authorization.png", fullPage: true });
const created = await request(admin.ctx, "POST", "/api/users", {
name: "创建验收员",
phone: "13900009100",
supplierId: "local-reviewer",
role: "acceptance_reviewer",
password: process.env.ACCEPTANCE_QA_PASSWORD,
});
assert.equal(created.status, 201);
const worker = await request(admin.ctx, "POST", "/api/users", {
name: "角色切换验证",
phone: "13900009101",
supplierId: "local-reviewer",
role: "annotator",
password: process.env.ACCEPTANCE_QA_PASSWORD,
});
assert.equal(worker.status, 201);
assert.equal(
(await request(admin.ctx, "PUT", "/api/users/" + worker.body.id, { role: "acceptance_reviewer" })).status,
200,
);
const manager = await actor("13900009002");
await manager.page.goto(base + "/users");
await manager.page.getByRole("switch").waitFor();
assert.equal(await manager.page.getByRole("switch").isDisabled(), true);
assert.equal(
(
await request(manager.ctx, "PUT", "/api/suppliers/local-reviewer/acceptance-authorization", {
enabled: false,
version: 1,
})
).status,
403,
);
reports.push("default-off; admin switch; create/role change; manager read-only; server enforcement");
const review = await actor("13900009003");
const p = review.page;
active = p;
const calls = [];
p.on("request", (r) => {
if (r.method() === "POST" && r.url().endsWith("/review-continuation")) calls.push(r.postDataJSON());
});
await p.goto(base + "/plugins/annotation-qa/workflows/all/acceptance");
await p.getByLabel("1. 项目", { exact: true }).waitFor();
assert.ok(
(await p.getByLabel("1. 项目", { exact: true }).locator("option").allTextContents()).includes(
"acceptance-project-b",
),
);
await p
.getByTestId("acceptance-task-card")
.filter({ hasText: "source-0-0" })
.getByRole("button", { name: "领取任务", exact: true })
.click();
await p.getByRole("button", { name: /^我的任务/ }).click();
await p.getByTestId("acceptance-task-card").first().getByRole("button", { name: "继续处理", exact: true }).click();
await p.getByText("本页可编辑审查意见", { exact: true }).waitFor();
await p.waitForFunction(() => [...document.querySelectorAll("video")].some((v) => v.readyState >= 2));
await p.screenshot({ path: out + "/normal.png", fullPage: true });
await p.getByRole("button", { name: "进入专注审查", exact: true }).click();
await p.waitForFunction(() => document.querySelector('[data-review-focused="true"]'));
await p.waitForFunction(() =>
[...document.querySelectorAll("video")].some((v) => v.readyState >= 2 && v.getBoundingClientRect().height > 250),
);
const before = new URL(p.url()).searchParams.get("acceptanceId");
assert.ok(before);
await p.screenshot({ path: out + "/focused.png", fullPage: true });
const videoResult = await p
.locator("video")
.first()
.evaluate(async (v) => {
await v.play();
return new Promise((resolve) =>
setTimeout(() => {
v.pause();
resolve({ time: v.currentTime, error: v.error?.code || null });
}, 500),
);
});
assert.ok(videoResult.time > 0);
assert.equal(videoResult.error, null);
// Current-round revoke keeps evidence and drafts, and stops the next shared claim.
const grant = await request(admin.ctx, "GET", "/api/suppliers/local-reviewer/acceptance-authorization");
assert.ok(grant.body.claimedCount >= 1);
assert.equal(
(
await request(admin.ctx, "PUT", "/api/suppliers/local-reviewer/acceptance-authorization", {
enabled: false,
version: grant.body.version,
})
).status,
200,
);
const panel = p.getByRole("region", { name: "审查问题草稿" });
await panel.locator('[data-opinion-scope="task"]').click();
const input = p.getByRole("textbox", { name: "审查问题说明", exact: true });
await input.fill("撤权后保留的隔离测试意见");
await input.press("Control+Enter");
await input.waitFor({ state: "hidden" });
const draft = await request(review.ctx, "GET", "/api/human-items/" + before + "/review-draft");
assert.equal(draft.status, 200);
assert.equal(draft.body.draft.problems.length, 1);
await p.screenshot({ path: out + "/revoked-draft.png", fullPage: true });
await panel.locator('[data-opinion-scope="task"]').click();
await p
.getByRole("button", { name: /清除.*意见/ })
.first()
.click();
await p.getByRole("button", { name: "确认清除", exact: true }).click();
await input.waitFor({ state: "hidden" });
// Re-enable so completed decision can continue across projects.
const off = await request(admin.ctx, "GET", "/api/suppliers/local-reviewer/acceptance-authorization");
assert.equal(
(
await request(admin.ctx, "PUT", "/api/suppliers/local-reviewer/acceptance-authorization", {
enabled: true,
version: off.body.version,
})
).status,
200,
);
const start = p.getByRole("button", { name: "开始/继续审查", exact: true });
if (await start.isVisible()) await start.click();
await p.getByRole("button", { name: "验收通过", exact: true }).click();
await p.getByRole("dialog", { name: "确认审查决定", exact: true }).waitFor();
await p.keyboard.press("Enter");
await p.waitForFunction((id) => new URL(location.href).searchParams.get("acceptanceId") !== id, before);
await p.getByText("本页可编辑审查意见", { exact: true }).waitFor();
const after = new URL(p.url()).searchParams.get("acceptanceId");
const current = await request(review.ctx, "GET", "/api/human-items/" + after);
assert.equal(current.body.item.projectId, "acceptance-project-b");
assert.ok(calls.some((c) => c.scope === "all" && c.action === "next"));
reports.push("normal/focused playback; revoked current-round draft; approve then cross-project continuation");
// Refresh must pause. Selecting a project constrains the new queue.
await p.reload();
await p.getByRole("button", { name: "开始/继续审查", exact: true }).waitFor();
await p.getByRole("button", { name: "返回任务池", exact: true }).click();
await p.getByLabel("1. 项目", { exact: true }).selectOption("acceptance-project-a");
await p.getByRole("button", { name: /^可领取/ }).click();
await p.getByTestId("acceptance-task-card").first().getByRole("button", { name: "领取任务", exact: true }).click();
await p.getByRole("button", { name: /^我的任务/ }).click();
await p.getByTestId("acceptance-task-card").first().getByRole("button", { name: "继续处理", exact: true }).click();
await p.getByText("本页可编辑审查意见", { exact: true }).waitFor();
await p.waitForFunction(() => [...document.querySelectorAll("video")].some((v) => v.readyState >= 2));
const selectedA = new URL(p.url()).searchParams.get("acceptanceId");
await p.getByLabel("1. 项目", { exact: true }).selectOption("acceptance-project-b");
await p.waitForFunction((id) => new URL(location.href).searchParams.get("acceptanceId") === id, after);
await p.getByText("本页可编辑审查意见", { exact: true }).waitFor();
await p.getByLabel("1. 项目", { exact: true }).selectOption("acceptance-project-a");
await p.waitForFunction((id) => new URL(location.href).searchParams.get("acceptanceId") === id, selectedA);
await p.getByText("本页可编辑审查意见", { exact: true }).waitFor();
reports.push("active filter changes stop the old queue and resume the new project, preferring existing claims");
await p.getByRole("region", { name: "审查问题草稿" }).locator('[data-opinion-scope="task"]').click();
await input.fill("隔离测试退回原生产质检");
await input.press("Control+Enter");
await input.waitFor({ state: "hidden" });
const rejected = new URL(p.url()).searchParams.get("acceptanceId");
await p.getByRole("button", { name: "打回质检", exact: true }).click();
await p.getByRole("dialog", { name: "确认审查决定", exact: true }).waitFor();
await p.keyboard.press("Enter");
await p.waitForFunction((id) => new URL(location.href).searchParams.get("acceptanceId") !== id, rejected);
await p.getByText("本页可编辑审查意见", { exact: true }).waitFor();
const third = await request(
review.ctx,
"GET",
"/api/human-items/" + new URL(p.url()).searchParams.get("acceptanceId"),
);
assert.equal(third.body.item.projectId, "acceptance-project-a");
assert.ok(calls.some((c) => c.scope === "project" && c.projectId === "acceptance-project-a" && c.action === "next"));
reports.push("refresh pause; specific-project queue; save opinion and reject; continue within filter");
// Revoke through the actual admin confirmation, then finish the current
// round. The queue must explain why it will not claim another task.
await admin.page.reload();
await admin.page.getByRole("button", { name: /^验收供应商/ }).click();
await admin.page.waitForFunction(() => !document.querySelector("[role=switch]")?.disabled);
let revocationPrompt = "";
admin.page.once("dialog", async (d) => {
revocationPrompt = d.message();
await d.accept();
});
await admin.page.getByRole("switch", { name: /允许最终验收/ }).click();
await admin.page.waitForFunction(
() => !document.querySelector("[role=switch]")?.checked && !document.querySelector("[role=switch]")?.disabled,
);
assert.match(revocationPrompt, /已领取的 [1-9][0-9]* 条共享任务/);
await p.waitForFunction(() => [...document.querySelectorAll("video")].some((v) => v.readyState >= 2));
await p.getByRole("button", { name: "验收通过", exact: true }).click();
await p.getByRole("dialog", { name: "确认审查决定", exact: true }).waitFor();
await p.keyboard.press("Enter");
await p.getByText("当前验收已完成,供应商授权已关闭,连续验收已停止。", { exact: true }).waitFor();
await p.screenshot({ path: out + "/revoked-continuation.png", fullPage: true });
reports.push("revocation confirmation counts; current-round approve succeeds; clear stop message, no new claim");
assert.deepEqual(errors, []);
await fs.writeFile(out + "/result.json", JSON.stringify({ reports, calls, errors }, null, 2));
console.log(JSON.stringify({ reports, errors }));
} catch (e) {
if (active) {
await active.screenshot({ path: out + "/failure.png", fullPage: true });
console.log((await active.locator("body").innerText()).slice(-12000));
}
throw e;
} finally {
await browser.close();
}