✨ Unify review opinions by target with contextual cards and safe legacy recovery

This commit is contained in:
d-robotics 2026-09-29 02:32:45 -07:00
parent 97a5fdf455
commit b0ae24c0cd
30 changed files with 2242 additions and 1285 deletions

View File

@ -1,3 +1,5 @@
> 2026-09-29:同对象多条、F 新建、全列表快捷键导航与删空不清除等规则由 [唯一审核意见方案](../review-single-opinion/spec.md) 取代;其他历史/权限/恢复约束继续适用。
# 审查批注流畅编辑、多问题与默认连续审查
Status: implementing

View File

@ -0,0 +1,45 @@
# 唯一审核意见实施与本地验收
日期:2026-09-29。授权范围:执行已确认计划;本次未部署公司集群、未提交 PR、未推送。
## 行为
- 质检和终审共享整体/当前切片/当前动作三张意见卡片。卡片按稳定来源、切片、动作 ID 绑定,不按名称或序号归并。
- F 先选范围,进入已有意见;Ctrl/⌘上下只选三卡片,Enter 编辑。Ctrl/⌘Enter 保存后返回工作台。Shift+Delete(Mac 另支持 Shift+Backspace)确认清除选中意见;输入框内保持原生删除和导航。
- 主动切换对象将旧对象修改排入串行队列;播放跨动作边界只更新观看位置,输入仍固定在原对象。迟到响应不清除后来新输入;未知结果保留操作身份并核对后重试。
- 多条旧意见在卡片分段全文呈现,编辑带入全部原文;逐对象确认后才能正式提交,不猜测哪条正确。清空已有意见需确认;旧历史不重新成为有效意见。
- 全任务意见仍保存,右侧三卡片不限制全任务问题数。正式决定确认框可以展开全部意见。
- 后端从当前已保存意见生成新格式退回 comment 与关联切片;清除后不会提交旧文字。终审通过时的姿态排除说明保持现有语义。
## 兼容与备份
新草稿 modelVersion=2;旧正式审核历史、返工记录、动作 JSON、媒体和任务状态没有迁移。
首次转换旧草稿前,在独立 reviewDraftArchives 集合插入不可变快照,键为旧草稿 ID 加旧版本。转换使用原版本 CAS;备份失败不转换,重启使用同一操作恢复。快照不嵌入正式决定回执,避免扩大大文档。历史读取仍按本账号、当前任务与被审版本鉴权。
旧单条草稿可直接读取;未转换的旧单条客户端写入保留兼容。旧客户端新增重复意见、或写入已经转换的草稿时要求更新页面。已接受的旧正式操作继续遵循原回执恢复协议。
**回退边界**:旧镜像可以读取当前 problems 内容,但不知道新唯一性约束及归档指针。不能声称旧镜像继续编辑仍满足新合同。若必须回退,需先暂停审查草稿写入;优先前向修复。恢复单份旧草稿须对照其快照和当前版本审查,不能整库恢复覆盖后续工作。上线前需单独批准部署并备份目标配置、版本和草稿;不自动执行历史批量迁移。
## 验证
证据目录:`local-data/verification/review-single-opinion/`,包含测试日志及质检/终审 1413×615 专注页截图。
- Go 新增意见测试:同对象唯一、来源隔离、旧重复逐步整理、清除不复活、保留原文与任务、旧客户端拒绝、正式提交拦截重复/生成正确 comment、备份失败与重启重试。
- 本地 Mongo 新建临时库:归档重复重试、断点恢复、CAS 拒绝旧版本、清除后原快照仍完整。测试完成仅删除该临时库。
- `tests/browser/review-opinions.mjs`:真实 Vite5173 + API3001 + Mongo27018,本地独立质检/终审账号;反复编辑同一对象保持同一 ID、切卡自动保存、快捷键选卡、清除取消/确认、普通及专注布局。终审额外验证不同来源相同切片 ID 不串意见,舍弃切片禁用动作意见。
- `tests/browser/review-opinion-races.mjs`:真实 hook/panel,传输层注入延迟、写入成功但响应丢失、409;验证 A/B 串行保存、新输入不被旧响应清空、自动播放不换绑、空白清除取消、原操作核对、冲突保留原文、旧重复提交门禁。
- `npm run lint:web`、`npm run build:web` 通过;构建保留已有分块体积提示。
- `npm run test:frontend` 623 项,14 项既有失败;与修改前基线逐项比对,均为原有页面文案/源码结构断言,没有新增失败。
- 相关 Go Review 测试:与修改前基线同为两项失败:`TestFanyuV5GenericDecisionCanReturnSemanticReviewToCutAdjustment`(缺项目人工作业成员授权)及 `TestHumanPoolsFollowAnnotatorReviewerStageOwnership`(旧四阶段任务池可见性预期)。旧多条协议用例按新合同替换,定位锚点、规范时间和回执幂等覆盖保留。
本地旧快照启动新版 API 时遇到历史账号空手机号唯一索引冲突;仅修复 27018 本地副本,原记录存入本地 `localReviewOpinionUserBackup`,未更改公司账号。
`go test ./... -run '^$'` 会扫描未跟踪 local-data 中的旧一次性 Go 脚本,因重复 main 等原因失败;产品编译范围改为 cmd/ 与 internal/,未修改这些历史脚本。
## 未覆盖与发布前条件
- 公司浏览器/网络环境、公司构建产物和部署后业务验收尚未执行,需单独授权。
- 本轮未对全部 Go/Python 业务测试做全量运行;编译 cmd/ 与 internal/ Go 包并执行相关审查测试。
- 未承诺断电或刷新保留尚未发送文字;离开提示和同页恢复继续适用。
- 发布时使用独立合成任务,客户记录只读;正式通过/退回的线上验收写入需明确限定测试对象,不能使用客户任务试验。

View File

@ -1,7 +1,9 @@
> 实施状态(2026-09-29):已在本地实现并核验,详见 [实施与验收](implementation.md)。尚未部署公司集群。
# 审查意见按对象唯一、三卡片联动方案
日期:2026-09-29
状态:计划已整理,产品行为与 Q1–Q3 已确认;尚未开始实施。本轮只授权制定计划,不包含部署或提交 PR。
状态:产品行为与 Q1–Q3 已确认,按“执行计划”完成本地实现与核验;不包含公司部署、推送或提交 PR。
范围:质检与最终验收,普通布局与专注布局。维持现有播放器、时间轴、当前切片/画面标注与审查决定布局;改动集中在右侧意见区及草稿处理。
## 1. 目标与当前事实
@ -12,7 +14,7 @@
- 最近线上只读核对版本 bf030dbb:目前选中问题后可用“编辑选中问题”或 Enter 编辑;F/记录当前画面问题会创建独立 ID,因此同一对象可以有多条。
- 线上最近 30 份客户草稿的只读抽样中,6 份存在同对象多条;抽查正式退回记录同时包含结构化 problems、文字 comment 和相关切片 ID。抽样不等于全量数据盘点。
- 旧规格 `.scratch/review-problem-flow/spec.md` 中每次 F 新建、同对象多条、全列表问题导航、空白不删除的规则需要局部替代;正式历史只读、权限、版本隔离、输入焦点和未知结果保护继续保留。
- 本文是待实施的新合同;实施前不把 CONTEXT.md 的当前系统定义改写为已上线行为。确认后更新相关合同并标明被替代条款,不改写历史讨论。
- 本文是已确认的新合同;本地实现状态见实施记录,不代表已上线。旧规格中被替代条款已加说明,历史讨论不改写。
## 2. 已确认的产品行为

View File

@ -72,7 +72,9 @@ _Avoid_:公共可领取任务池(其中的任务尚未归属当前标注员
**最终验收**:对质检通过的待交付结果进行最终检查的环节,与质检审核是不同的决定;泛宇三角色流程中不通过的结果退回质检环节。
**问题批注**:审查者对结果中问题位置、问题内容及修改要求的一条独立记录;同一动作、切片或整体任务可以有多条问题批注。它不改变原标注判断,也不等于已提交退回决定。
**审核意见**:审查者对整体任务、某个切片或某个动作的问题与修改要求。同一轮、同一被审版本中,每个对象只有一份当前有效意见,可编辑或清除;无意见不表示已经核对或通过。终审的整体意见属于整个终审任务,切片和动作意见按来源区分。它不改变原标注判断,也不等于已提交退回决定。
**旧版问题批注**:旧规则下同一对象的多条独立问题记录;尚未提交的重复意见需明确整理为一份最终意见,原文保留为历史。已正式提交的历史批注不因新规则而改写。
**审查字幕**:随当前播放位置展示被审动作描述、语义留空、无效或切片舍弃判断的文字,呈现原结果,不包含审查者正在填写的问题批注。

View File

@ -164,6 +164,20 @@ func (s *server) prepareReviewDecision(w http.ResponseWriter, r *http.Request, i
return r, false
}
data, digest := reviewDecisionDigest(input)
// Already accepted legacy intents retain their original recovery contract.
existing, err := s.store.GetReviewOperation(r.Context(), reviewOperationID(item, p.User.ID, meta.OperationID))
if err != nil {
renderError(w, 500, err)
return r, false
}
if existing == nil && duplicateReviewOpinions(draft.Problems) {
renderJSON(w, 409, map[string]string{"code": "review_opinion_confirmation_required", "error": "有同一对象的多条旧意见,请先确认最终意见再提交"})
return r, false
}
if existing == nil && draft.ModelVersion == 2 && decision == "rejected" && len(draft.Problems) == 0 {
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}}
if session.WriteID != "" && session.WriteID != op.ID {
reviewSessionFailure(w, "review_write_in_progress")

View File

@ -19,6 +19,15 @@ func (s *server) planQualityReviewDecision(w http.ResponseWriter, r *http.Reques
}
op := operationFromRequest(r)
now := op.CreatedAt
if op.Draft.ModelVersion == 2 {
evidence, err := s.reviewTargetEvidenceForItem(r.Context(), item)
if err != nil {
renderError(w, 500, err)
return
}
payload.Comment = reviewOpinionComment(op.Draft.Problems, evidence)
payload.ProblemSliceIDs = reviewOpinionSliceIDs(op.Draft.Problems, evidence)
}
beforeTask, beforeItem := task, item
review := domain.AnnotationReviewRecord{ID: op.ID + ":review", OrganizationID: task.OrganizationID, TaskID: task.ID, Revision: task.CurrentRevision, ReviewRound: item.ReviewRound, Stage: domain.AnnotationReviewStageQuality, Decision: payload.Decision, ReviewerUserID: op.UserID, Comment: strings.TrimSpace(payload.Comment), VideoQuality: strings.TrimSpace(payload.VideoQuality), AnnotationAccuracy: payload.AnnotationAccuracy, AnnotationCompleteness: payload.AnnotationCompleteness, OverallGrade: strings.TrimSpace(payload.OverallGrade), ReasonCodes: payload.ReasonCodes, ProblemSliceIDs: payload.ProblemSliceIDs, CreatedAt: now}
task.AssignedUserID = ""
@ -72,6 +81,14 @@ func (s *server) planQualityReviewDecision(w http.ResponseWriter, r *http.Reques
func (s *server) planAcceptanceReviewDecision(w http.ResponseWriter, r *http.Request, before, item domain.HumanItemRecord, batch, source *domain.HumanBatchRecord, payload humanDecisionRequest) {
op := operationFromRequest(r)
now := op.CreatedAt
if op.Draft.ModelVersion == 2 && payload.Decision == domain.HumanDecisionRejected {
evidence, err := s.reviewTargetEvidenceForItem(r.Context(), item)
if err != nil {
renderError(w, 500, err)
return
}
payload.Comment = reviewOpinionComment(op.Draft.Problems, evidence)
}
sources, err := s.store.ListHumanItems(r.Context(), source.OrganizationID, domain.HumanItemQuery{BatchID: source.ID})
if err != nil {
renderError(w, 500, err)

View File

@ -248,8 +248,8 @@ func canonicalReviewProblems(problems []domain.ReviewProblem, evidence []reviewT
}
p.ViewAnchor = anchor
}
// Multiple independent problems may target the same action/slice/task;
// identity and uniqueness stay on p.ID while input order is preserved.
// Preserve legacy order and canonical evidence here; the write contract
// separately enforces one effective opinion per target.
out = append(out, p)
}
return out, nil
@ -265,6 +265,19 @@ func (server *server) handleReviewDraft(w http.ResponseWriter, r *http.Request)
renderError(w, 500, e)
return
}
if r.Method == http.MethodGet && r.URL.Query().Get("history") == "1" {
history, err := server.store.GetReviewDraftArchive(r.Context(), draft.LegacyBackupID)
if err != nil {
renderError(w, 500, err)
return
}
problems := []domain.ReviewProblem{}
if history != nil {
problems = history.Problems
}
renderJSON(w, 200, map[string]any{"problems": problems})
return
}
if r.Method == http.MethodGet {
renderJSON(w, 200, map[string]any{"draft": draft})
return

View File

@ -28,54 +28,47 @@ func assertGlobalTaskTarget(t *testing.T, p domain.ReviewProblem) {
// evidence basis, clamps out-of-window time like problem records, and stays
// absent for legacy saves.
func TestQualityReviewDraftTaskViewAnchorPersistsClampsAndKeepsLegacy(t *testing.T) {
f := qualityReviewDraftFixture(t)
resultVersion, headers := openReviewDraftSession(t, f)
endpoint := "/api/human-items/" + f.item.ID + "/review-draft"
problems := []map[string]any{
plainTaskProblem("task-legacy", "整体历史问题"),
anchoredTaskProblem("task-anchor-clamped", "整体问题带锚点", map[string]any{"sliceId": "right", "atSeconds": 12, "timeBasis": "capture-seconds"}),
anchoredTaskProblem("task-anchor-converted", "整体问题锚点换算", map[string]any{"sliceId": "right", "atSeconds": 2, "timeBasis": "slice-seconds"}),
{"id": "action-bookmark", "scope": "action", "sliceId": "left", "actionId": "left-action", "text": "动作问题带画面书签", "atSeconds": 1, "viewAnchor": map[string]any{"sliceId": "right", "atSeconds": 6, "timeBasis": "capture-seconds"}},
}
saved := putReviewDraft(t, f, endpoint, resultVersion, "anchor-save", 0, problems, headers)
if saved.Code != 200 {
t.Fatalf("anchor save %d %s", saved.Code, saved.Body.String())
}
if got := strings.Count(saved.Body.String(), "viewAnchor"); got != 3 {
t.Fatalf("wire format persisted %d anchors want 3: %s", got, saved.Body.String())
}
draft := readReviewDraft(t, f, endpoint)
if len(draft.Problems) != 4 {
t.Fatalf("problem count %d want 4", len(draft.Problems))
}
legacy := draft.Problems[0]
if legacy.ViewAnchor != nil {
t.Fatalf("legacy task problem invented an anchor: %+v", legacy.ViewAnchor)
}
assertGlobalTaskTarget(t, legacy)
clamped := draft.Problems[1].ViewAnchor
if clamped == nil || clamped.SliceID != "right" || clamped.SourceItemID != "" || clamped.AtSeconds != 5 || clamped.TimeBasis != "capture-seconds" {
t.Fatalf("clamped anchor: %+v", clamped)
}
assertGlobalTaskTarget(t, draft.Problems[1])
converted := draft.Problems[2].ViewAnchor
if converted == nil || converted.SliceID != "right" || converted.AtSeconds != 7 || converted.TimeBasis != "capture-seconds" {
t.Fatalf("converted anchor: %+v", converted)
}
bookmark := draft.Problems[3]
if bookmark.ViewAnchor == nil || bookmark.ViewAnchor.SliceID != "right" || bookmark.ViewAnchor.AtSeconds != 6 || bookmark.ViewAnchor.TimeBasis != "capture-seconds" {
t.Fatalf("action bookmark anchor: %+v", bookmark.ViewAnchor)
}
if bookmark.Start != 0 || bookmark.End != 5 || bookmark.ActionID != "left-action" || bookmark.TimeBasis != "capture-seconds" {
t.Fatalf("anchor leaked into action target: %+v", bookmark)
}
replay := putReviewDraft(t, f, endpoint, resultVersion, "anchor-save", 0, problems, headers)
if replay.Code != 200 {
t.Fatalf("anchor replay %d %s", replay.Code, replay.Body.String())
}
if draft = readReviewDraft(t, f, endpoint); draft.Version != 1 || len(draft.Problems) != 4 {
t.Fatalf("anchor replay mutated draft: version %d problems %d", draft.Version, len(draft.Problems))
expected := []float64{-1, 5, 7, 6}
for i, problem := range problems {
t.Run(problem["id"].(string), func(t *testing.T) {
f := qualityReviewDraftFixture(t)
rv, headers := openReviewDraftSession(t, f)
endpoint := "/api/human-items/" + f.item.ID + "/review-draft"
input := []map[string]any{problem}
w := putReviewDraft(t, f, endpoint, rv, "anchor-save", 0, input, headers)
if w.Code != 200 {
t.Fatalf("save: %d %s", w.Code, w.Body.String())
}
draft := readReviewDraft(t, f, endpoint)
p := checkProblemList(t, draft, problem["id"].(string))[0]
if i < 3 {
assertGlobalTaskTarget(t, p)
}
if i == 0 {
if p.ViewAnchor != nil {
t.Fatal("invented legacy anchor")
}
} else if p.ViewAnchor == nil || p.ViewAnchor.SliceID != "right" || p.ViewAnchor.AtSeconds != expected[i] || p.ViewAnchor.TimeBasis != "capture-seconds" {
t.Fatalf("anchor: %+v", p.ViewAnchor)
}
if i == 3 && (p.Start != 0 || p.End != 5 || p.ActionID != "left-action") {
t.Fatal("anchor changed target")
}
if w := putReviewDraft(t, f, endpoint, rv, "anchor-save", 0, input, headers); w.Code != 200 {
t.Fatal(w.Body.String())
}
if readReviewDraft(t, f, endpoint).Version != 1 {
t.Fatal("replay mutated draft")
}
})
}
}
func TestQualityReviewDraftRejectsInvalidViewAnchors(t *testing.T) {
@ -113,40 +106,37 @@ func TestAcceptanceReviewDraftTaskViewAnchorIsolatesAggregateSources(t *testing.
plainTaskProblem("task-none", "历史整体问题"),
anchoredTaskProblem("task-converted", "锚点换算", map[string]any{"sourceItemId": "source-a", "sliceId": "same", "atSeconds": 12, "timeBasis": "capture-seconds"}),
}
saved := putReviewDraft(t, f, endpoint, resultVersion, "aggregate-anchor", 0, problems, headers)
if saved.Code != 200 {
t.Fatalf("aggregate anchor save %d %s", saved.Code, saved.Body.String())
}
draft := readReviewDraft(t, f, endpoint)
if len(draft.Problems) != 4 {
t.Fatalf("problem count %d want 4", len(draft.Problems))
}
a, b := draft.Problems[0].ViewAnchor, draft.Problems[1].ViewAnchor
if a == nil || a.SourceItemID != "source-a" || a.SliceID != "same" || a.AtSeconds != 2 || a.TimeBasis != "slice-seconds" {
t.Fatalf("source-a anchor: %+v", a)
}
if b == nil || b.SourceItemID != "source-b" || b.SliceID != "same" || b.AtSeconds != 3 || b.TimeBasis != "slice-seconds" {
t.Fatalf("source-b anchor: %+v", b)
}
if a.SourceItemID == b.SourceItemID {
t.Fatalf("anchors aliased across aggregate sources: %+v %+v", a, b)
}
if draft.Problems[2].ViewAnchor != nil {
t.Fatalf("legacy aggregate task problem invented an anchor: %+v", draft.Problems[2].ViewAnchor)
}
for _, p := range draft.Problems {
expected := []float64{2, 3, -1, 2}
for i, problem := range problems {
f := acceptanceReviewDraftFixture(t)
rv, h := openReviewDraftSession(t, f)
ep := "/api/human-items/" + f.item.ID + "/review-draft"
if w := putReviewDraft(t, f, ep, rv, "anchor", 0, []map[string]any{problem}, h); w.Code != 200 {
t.Fatal(w.Body.String())
}
p := readReviewDraft(t, f, ep).Problems[0]
assertGlobalTaskTarget(t, p)
if i == 2 {
if p.ViewAnchor != nil {
t.Fatal("invented anchor")
}
continue
}
wantSource := "source-a"
if i == 1 {
wantSource = "source-b"
}
if p.ViewAnchor == nil || p.ViewAnchor.SourceItemID != wantSource || p.ViewAnchor.AtSeconds != expected[i] || p.ViewAnchor.TimeBasis != "slice-seconds" {
t.Fatalf("anchor: %+v", p.ViewAnchor)
}
}
converted := draft.Problems[3].ViewAnchor
if converted == nil || converted.SourceItemID != "source-a" || converted.AtSeconds != 2 || converted.TimeBasis != "slice-seconds" {
t.Fatalf("converted aggregate anchor: %+v", converted)
}
bad := [][]map[string]any{
{anchoredTaskProblem("bad-outside", "外来来源", map[string]any{"sourceItemId": "outsider", "sliceId": "same", "atSeconds": 1, "timeBasis": "slice-seconds"})},
{anchoredTaskProblem("bad-slice", "外来切片", map[string]any{"sourceItemId": "source-b", "sliceId": "left", "atSeconds": 1, "timeBasis": "slice-seconds"})},
}
for i, problems := range bad {
if w := putReviewDraft(t, f, endpoint, resultVersion, "aggregate-bad-"+strings.Repeat("x", i+1), 1, problems, headers); w.Code != 400 {
if w := putReviewDraft(t, f, endpoint, resultVersion, "aggregate-bad-"+strings.Repeat("x", i+1), 0, problems, headers); w.Code != 400 {
t.Fatalf("invalid aggregate anchor %d accepted %d %s", i, w.Code, w.Body.String())
}
}

View File

@ -45,134 +45,3 @@ func checkProblemList(t *testing.T, draft domain.ReviewDraft, wantIDs ...string)
}
return draft.Problems
}
// Same action/slice/task target must accept several independent problems,
// keep input order and canonical fields, and allow editing/removing one
// entry while the sibling survives untouched.
func TestQualityReviewDraftMultipleProblemsShareTarget(t *testing.T) {
f := qualityReviewDraftFixture(t)
resultVersion, headers := openReviewDraftSession(t, f)
endpoint := "/api/human-items/" + f.item.ID + "/review-draft"
sameAction := func(id, text string, at float64) map[string]any {
return problemEntry(id, "action", "", "left", "left-action", text, at)
}
sameSlice := func(id, text string, at float64) map[string]any {
return problemEntry(id, "slice", "", "right", "", text, at)
}
first := []map[string]any{
sameAction("problem-a1", "左段第一条", 1),
sameAction("problem-a2", "左段第二条", 2),
sameSlice("problem-s1", "右片第一条", 6),
sameSlice("problem-s2", "右片第二条", 7),
problemEntry("problem-task1", "task", "", "", "", "整体第一条", 0),
problemEntry("problem-task2", "task", "", "", "", "整体第二条", 0),
}
saved := putReviewDraft(t, f, endpoint, resultVersion, "multi-save", 0, first, headers)
if saved.Code != 200 {
t.Fatalf("same-target save %d %s", saved.Code, saved.Body.String())
}
draft := readReviewDraft(t, f, endpoint)
problems := checkProblemList(t, draft, "problem-a1", "problem-a2", "problem-s1", "problem-s2", "problem-task1", "problem-task2")
if draft.Version != 1 {
t.Fatalf("draft version %d want 1", draft.Version)
}
for i, want := range [][2]float64{{0, 5}, {0, 5}, {5, 10}, {5, 10}, {0, 0}, {0, 0}} {
if problems[i].Start != want[0] || problems[i].End != want[1] {
t.Fatalf("problem %d canonical span %v-%v want %v-%v", i, problems[i].Start, problems[i].End, want[0], want[1])
}
}
if problems[0].TimeBasis != "capture-seconds" || problems[4].TimeBasis != "task" {
t.Fatalf("time basis %q/%q", problems[0].TimeBasis, problems[4].TimeBasis)
}
duplicate := []map[string]any{sameAction("problem-dup", "重复身份一", 1), sameAction("problem-dup", "重复身份二", 2)}
if w := putReviewDraft(t, f, endpoint, resultVersion, "dup-id", 1, duplicate, headers); w.Code != 400 {
t.Fatalf("duplicate id accepted %d %s", w.Code, w.Body.String())
}
edited := []map[string]any{
sameAction("problem-a1", "左段第一条已修改", 1),
sameAction("problem-a2", "左段第二条", 2),
sameSlice("problem-s1", "右片第一条", 6),
sameSlice("problem-s2", "右片第二条", 7),
problemEntry("problem-task1", "task", "", "", "", "整体第一条", 0),
problemEntry("problem-task2", "task", "", "", "", "整体第二条", 0),
}
if w := putReviewDraft(t, f, endpoint, resultVersion, "edit-a1", 1, edited, headers); w.Code != 200 {
t.Fatalf("edit one %d %s", w.Code, w.Body.String())
}
draft = readReviewDraft(t, f, endpoint)
problems = checkProblemList(t, draft, "problem-a1", "problem-a2", "problem-s1", "problem-s2", "problem-task1", "problem-task2")
if problems[0].Text != "左段第一条已修改" || problems[1].Text != "左段第二条" || problems[3].Text != "右片第二条" || draft.Version != 2 {
t.Fatalf("edit only one entry: %+v", problems)
}
deleted := []map[string]any{
sameAction("problem-a1", "左段第一条已修改", 1),
sameSlice("problem-s1", "右片第一条", 6),
sameSlice("problem-s2", "右片第二条", 7),
problemEntry("problem-task1", "task", "", "", "", "整体第一条", 0),
problemEntry("problem-task2", "task", "", "", "", "整体第二条", 0),
}
if w := putReviewDraft(t, f, endpoint, resultVersion, "delete-a2", 2, deleted, headers); w.Code != 200 {
t.Fatalf("delete one %d %s", w.Code, w.Body.String())
}
draft = readReviewDraft(t, f, endpoint)
problems = checkProblemList(t, draft, "problem-a1", "problem-s1", "problem-s2", "problem-task1", "problem-task2")
if problems[0].Text != "左段第一条已修改" || problems[1].Text != "右片第一条" || draft.Version != 3 {
t.Fatalf("delete only one entry: %+v", problems)
}
replay := putReviewDraft(t, f, endpoint, resultVersion, "delete-a2", 2, deleted, headers)
if replay.Code != 200 {
t.Fatalf("replay %d %s", replay.Code, replay.Body.String())
}
draft = readReviewDraft(t, f, endpoint)
checkProblemList(t, draft, "problem-a1", "problem-s1", "problem-s2", "problem-task1", "problem-task2")
if draft.Version != 3 {
t.Fatalf("replay changed version %d want 3", draft.Version)
}
mutated := []map[string]any{sameAction("problem-a1", "迟到的不同内容", 1)}
if w := putReviewDraft(t, f, endpoint, resultVersion, "delete-a2", 2, mutated, headers); w.Code != 409 {
t.Fatalf("replayed operation with new content accepted %d %s", w.Code, w.Body.String())
}
draft = readReviewDraft(t, f, endpoint)
checkProblemList(t, draft, "problem-a1", "problem-s1", "problem-s2", "problem-task1", "problem-task2")
}
// The aggregate acceptance target keeps isolated sources and also allows
// several independent problems on one source member.
func TestAcceptanceReviewDraftMultipleProblemsShareTarget(t *testing.T) {
f := acceptanceReviewDraftFixture(t)
resultVersion, headers := openReviewDraftSession(t, f)
endpoint := "/api/human-items/" + f.item.ID + "/review-draft"
entry := func(id, text string) map[string]any {
return problemEntry(id, "action", "source-a", "same", "same-action", text, 1)
}
problems := []map[string]any{entry("problem-a1", "来源A第一条"), entry("problem-a2", "来源A第二条")}
saved := putReviewDraft(t, f, endpoint, resultVersion, "aggregate-multi", 0, problems, headers)
if saved.Code != 200 {
t.Fatalf("aggregate multi save %d %s", saved.Code, saved.Body.String())
}
draft := readReviewDraft(t, f, endpoint)
list := checkProblemList(t, draft, "problem-a1", "problem-a2")
for i, p := range list {
if p.SourceItemID != "source-a" || p.TimeBasis != "slice-seconds" || p.Start != 0 || p.End != 5 {
t.Fatalf("member %d lost canonical source span: %+v", i, p)
}
}
duplicate := []map[string]any{entry("problem-dup", "重复身份一"), entry("problem-dup", "重复身份二")}
if w := putReviewDraft(t, f, endpoint, resultVersion, "aggregate-dup", 1, duplicate, headers); w.Code != 400 {
t.Fatalf("aggregate duplicate id accepted %d %s", w.Code, w.Body.String())
}
replay := putReviewDraft(t, f, endpoint, resultVersion, "aggregate-multi", 0, problems, headers)
if replay.Code != 200 {
t.Fatalf("aggregate replay %d %s", replay.Code, replay.Body.String())
}
draft = readReviewDraft(t, f, endpoint)
checkProblemList(t, draft, "problem-a1", "problem-a2")
if draft.Version != 1 {
t.Fatalf("aggregate replay changed version %d", draft.Version)
}
}

View File

@ -15,6 +15,7 @@ import (
var errDraftIntentStale = errors.New("草稿已有新版本,原保存操作不会覆盖新内容")
type reviewDraftSaveInput struct {
ModelVersion int `json:"modelVersion,omitempty"`
Version int `json:"version"`
ResultVersion string `json:"resultVersion"`
OperationID string `json:"operationId"`
@ -93,6 +94,20 @@ func (s *server) saveRecoverableReviewDraft(w http.ResponseWriter, r *http.Reque
renderJSON(w, 409, map[string]string{"code": "review_draft_version_conflict", "error": "已保存草稿已有新版本,请核对后再保存"})
return
}
if input.ModelVersion != 0 && input.ModelVersion != 2 || (input.ModelVersion != 2 && (draft.ModelVersion == 2 || duplicateReviewOpinions(problems))) {
renderJSON(w, 409, map[string]string{"code": "review_client_outdated", "error": "请更新页面后继续,未保存文字请先保留"})
return
}
if err := validateReviewOpinionChange(draft, problems, input.ModelVersion); err != nil {
renderJSON(w, 409, map[string]string{"code": "review_opinion_duplicate", "error": err.Error()})
return
}
if input.ModelVersion == 2 {
if draft.ModelVersion < 2 && draft.Version > 0 {
draft.LegacyBackupID = fmt.Sprintf("%s:v%d", draft.ID, draft.Version)
}
draft.ModelVersion = 2
}
draft.Problems = problems
draft.LastOperationID = input.OperationID
draft.LastOperationDigest = problemDigest
@ -159,6 +174,13 @@ func (s *server) applyDraftReviewOperation(ctx context.Context, op *domain.Revie
if current != nil && current.Version != target.Version {
return errDraftIntentStale
}
if current != nil && current.ModelVersion < 2 && target.ModelVersion == 2 && current.Version > 0 {
snapshot := *current
snapshot.ID = target.LegacyBackupID
if err := s.store.ArchiveReviewDraft(ctx, snapshot); err != nil {
return err
}
}
saved, err := s.store.CompareAndSwapReviewDraft(ctx, target, target.Version)
if err != nil {
return err

View File

@ -0,0 +1,124 @@
package api
import (
"droboticflow/internal/domain"
"encoding/json"
"fmt"
"reflect"
"strings"
)
func reviewOpinionKey(p domain.ReviewProblem) string {
source, slice, action := p.SourceItemID, p.SliceID, p.ActionID
if p.Scope == "task" {
source, slice, action = "", "", ""
} else if p.Scope == "slice" {
action = ""
}
b, _ := json.Marshal([]string{p.Scope, source, slice, action})
return string(b)
}
func reviewOpinionGroups(problems []domain.ReviewProblem) map[string][]domain.ReviewProblem {
groups := map[string][]domain.ReviewProblem{}
for _, p := range problems {
key := reviewOpinionKey(p)
groups[key] = append(groups[key], p)
}
return groups
}
func duplicateReviewOpinions(problems []domain.ReviewProblem) bool {
for _, group := range reviewOpinionGroups(problems) {
if len(group) > 1 {
return true
}
}
return false
}
// Existing duplicate groups may be carried unchanged while another group is
// resolved. New duplicates and partial edits within a duplicate group are not
// accepted. Reading legacy data never mutates it.
func validateReviewOpinionChange(old domain.ReviewDraft, next []domain.ReviewProblem, model int) error {
before := reviewOpinionGroups(old.Problems)
for key, group := range reviewOpinionGroups(next) {
prior := before[key]
if len(group) > 1 && (model != 2 || len(prior) < 2 || !reflect.DeepEqual(prior, group)) {
return fmt.Errorf("同一对象只能保留一份意见,请整理后保存")
}
if len(group) == 1 && len(prior) > 0 && group[0].ID != prior[0].ID {
return fmt.Errorf("请修改该对象已有意见,不要重复新增")
}
}
// An ID cannot be moved to a different target.
ids := map[string]string{}
for _, p := range old.Problems {
ids[p.ID] = reviewOpinionKey(p)
}
for _, p := range next {
if key, ok := ids[p.ID]; ok && key != reviewOpinionKey(p) {
return fmt.Errorf("意见所属对象不能改变,请重新选择范围")
}
}
return nil
}
func reviewOpinionComment(problems []domain.ReviewProblem, evidence []reviewTargetEvidence) string {
lines := make([]string, 0, len(problems))
for _, p := range problems {
label := "整体任务"
if p.Scope != "task" {
label = "切片"
for sourceIndex, source := range evidence {
if source.sourceID != p.SourceItemID {
continue
}
for i, slice := range source.slices {
if slice.ID != p.SliceID {
continue
}
label = fmt.Sprintf("切片 %d", i+1)
if p.SourceItemID != "" {
label = fmt.Sprintf("来源 %d · %s", sourceIndex+1, label)
}
if p.Scope == "action" {
n := 0
for _, a := range source.actions {
if a.Start >= slice.Start-0.000001 && a.End <= slice.End+0.000001 {
n++
if a.ID == p.ActionID {
label += fmt.Sprintf(" · 动作 %d", n)
break
}
}
}
}
break
}
}
}
lines = append(lines, label+":"+p.Text)
}
return strings.Join(lines, "\n")
}
func reviewOpinionSliceIDs(problems []domain.ReviewProblem, evidence []reviewTargetEvidence) []string {
ids := []string{}
seen := map[string]bool{}
add := func(id string) {
if id != "" && !seen[id] {
seen[id] = true
ids = append(ids, id)
}
}
for _, p := range problems {
if p.Scope == "task" {
for _, e := range evidence {
for _, s := range e.slices {
add(s.ID)
}
}
} else {
add(p.SliceID)
}
}
return ids
}

View File

@ -0,0 +1,216 @@
package api
import (
"context"
"droboticflow/internal/domain"
"droboticflow/internal/store"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"reflect"
"strings"
"testing"
)
func TestReviewOpinionRejectsDuplicateTargets(t *testing.T) {
for _, fixture := range []struct {
name string
create func(*testing.T) combinedDraftFixture
source, slice, action string
}{
{"quality", qualityReviewDraftFixture, "", "left", "left-action"},
{"acceptance", acceptanceReviewDraftFixture, "source-a", "same", "same-action"},
} {
t.Run(fixture.name, func(t *testing.T) {
f := fixture.create(t)
rv, h := openReviewDraftSession(t, f)
endpoint := "/api/human-items/" + f.item.ID + "/review-draft"
for _, scope := range []string{"task", "slice", "action"} {
p := []map[string]any{problemEntry("one", scope, fixture.source, fixture.slice, fixture.action, "first", 1), problemEntry("two", scope, fixture.source, fixture.slice, fixture.action, "second", 2)}
w := reviewSessionRequest(f, http.MethodPut, endpoint, f.reviewer, map[string]any{"modelVersion": 2, "version": 0, "resultVersion": rv, "operationId": "duplicate-" + scope, "problems": p}, h)
if w.Code != 409 || !strings.Contains(w.Body.String(), "review_opinion_duplicate") {
t.Fatalf("duplicate %s accepted: %d %s", scope, w.Code, w.Body.String())
}
}
if d := readReviewDraft(t, f, endpoint); len(d.Problems) != 0 {
t.Fatal("invalid save mutated draft")
}
})
}
}
// Seed historical records at the storage seam, never by weakening the new API.
func seedLegacyOpinionDraft(t *testing.T, f combinedDraftFixture, endpoint string, problems []domain.ReviewProblem) domain.ReviewDraft {
t.Helper()
d := readReviewDraft(t, f, endpoint)
d.ID = reviewDraftKey(f.item, f.reviewer.ID, d.ResultVersion)
d.Problems = problems
ok, err := f.store.CompareAndSwapReviewDraft(f.ctx, d, 0)
if err != nil || !ok {
t.Fatalf("seed: %v %v", ok, err)
}
return readReviewDraft(t, f, endpoint)
}
func TestReviewOpinionLegacyConsolidationAndClear(t *testing.T) {
f := qualityReviewDraftFixture(t)
rv, h := openReviewDraftSession(t, f)
ep := "/api/human-items/" + f.item.ID + "/review-draft"
legacy := []domain.ReviewProblem{
{ID: "s1", Scope: "slice", SliceID: "left", Text: "第一条\n完整原文", AtSeconds: 1, Start: 0, End: 5, TimeBasis: "capture-seconds"},
{ID: "s2", Scope: "slice", SliceID: "left", Text: "更正,原片没有问题", AtSeconds: 2, Start: 0, End: 5, TimeBasis: "capture-seconds"},
{ID: "t1", Scope: "task", Text: "整体一", TimeBasis: "task"},
{ID: "t2", Scope: "task", Text: "整体二", TimeBasis: "task"},
}
seedLegacyOpinionDraft(t, f, ep, legacy)
beforeTask, _ := f.store.GetAnnotationTask(f.ctx, f.task.ID)
beforeAnnotations, _ := f.store.ListAnnotationRevisions(f.ctx, f.task.OrganizationID, f.task.ID)
beforeSlices, _ := f.store.ListSliceRevisions(f.ctx, f.task.OrganizationID, f.task.ID)
save := func(id string, version int, p []domain.ReviewProblem) *httptest.ResponseRecorder {
return reviewSessionRequest(f, http.MethodPut, ep, f.reviewer, map[string]any{"modelVersion": 2, "version": version, "resultVersion": rv, "operationId": id, "problems": p}, h)
}
partial := append([]domain.ReviewProblem{}, legacy...)
partial[0].Text = "只改第一条"
if w := save("partial", 1, partial); w.Code != 409 {
t.Fatal(w.Body.String())
}
merged := append([]domain.ReviewProblem{legacy[0]}, legacy[2:]...)
merged[0].Text = "已核实的最终意见"
if w := save("merge", 1, merged); w.Code != 200 {
t.Fatal(w.Body.String())
}
d := readReviewDraft(t, f, ep)
checkProblemList(t, d, "s1", "t1", "t2")
if d.ModelVersion != 2 || d.LegacyBackupID == "" {
t.Fatal("missing model/archive")
}
archived, err := f.store.GetReviewDraftArchive(f.ctx, d.LegacyBackupID)
if err != nil || archived == nil || !reflect.DeepEqual(archived.Problems, legacy) {
t.Fatalf("lost original: %+v %v", archived, err)
}
if w := save("merge", 1, merged); w.Code != 200 {
t.Fatal("replay", w.Body.String())
}
if readReviewDraft(t, f, ep).Version != 2 {
t.Fatal("replay advanced version")
}
if w := putReviewDraft(t, f, ep, rv, "old-browser", 2, nil, h); w.Code != 409 || !strings.Contains(w.Body.String(), "review_client_outdated") {
t.Fatal("old client accepted", w.Body.String())
}
// Clear the entire slice opinion, keep the unrelated old task group untouched.
if w := save("clear-slice", 2, legacy[2:]); w.Code != 200 {
t.Fatal(w.Body.String())
}
if w := save("clear-task", 3, []domain.ReviewProblem{}); w.Code != 200 {
t.Fatal(w.Body.String())
}
d = readReviewDraft(t, f, ep)
if len(d.Problems) != 0 {
t.Fatal("cleared opinions resurrected")
}
w := f.request(http.MethodGet, ep+"?history=1", f.reviewer, nil)
var history struct {
Problems []domain.ReviewProblem `json:"problems"`
}
json.Unmarshal(w.Body.Bytes(), &history)
if w.Code != 200 || !reflect.DeepEqual(history.Problems, legacy) {
t.Fatal("history lost", w.Body.String())
}
afterTask, _ := f.store.GetAnnotationTask(f.ctx, f.task.ID)
if !reflect.DeepEqual(beforeTask, afterTask) {
t.Fatal("opinion edits mutated task")
}
afterAnnotations, _ := f.store.ListAnnotationRevisions(f.ctx, f.task.OrganizationID, f.task.ID)
afterSlices, _ := f.store.ListSliceRevisions(f.ctx, f.task.OrganizationID, f.task.ID)
if !reflect.DeepEqual(beforeAnnotations, afterAnnotations) || !reflect.DeepEqual(beforeSlices, afterSlices) {
t.Fatal("opinion edits mutated annotation evidence")
}
}
func TestReviewOpinionAcceptanceSourceIsolation(t *testing.T) {
f := acceptanceReviewDraftFixture(t)
rv, h := openReviewDraftSession(t, f)
ep := "/api/human-items/" + f.item.ID + "/review-draft"
p := []map[string]any{problemEntry("a", "action", "source-a", "same", "same-action", "A", 1), problemEntry("b", "action", "source-b", "same", "same-action", "B", 1), problemEntry("all", "task", "source-a", "same", "same-action", "整体", 0)}
w := reviewSessionRequest(f, http.MethodPut, ep, f.reviewer, map[string]any{"modelVersion": 2, "version": 0, "resultVersion": rv, "operationId": "sources", "problems": p}, h)
if w.Code != 200 {
t.Fatal(w.Body.String())
}
d := readReviewDraft(t, f, ep)
checkProblemList(t, d, "a", "b", "all")
assertGlobalTaskTarget(t, d.Problems[2])
}
func TestReviewOpinionDecisionRequiresConfirmationAndUsesCurrentText(t *testing.T) {
f := decisionFixture(t)
rv, h := openReviewDraftSession(t, f)
ep := "/api/human-items/" + f.item.ID + "/review-draft"
seedLegacyOpinionDraft(t, f, ep, []domain.ReviewProblem{{ID: "p1", Scope: "task", Text: "旧一", TimeBasis: "task"}, {ID: "p2", Scope: "task", Text: "旧二", TimeBasis: "task"}})
endpoint := "/api/plugins/annotation-qa/tasks/" + f.task.ID + "/reviews"
input := map[string]any{"stage": "quality", "decision": "rejected", "comment": "过期内容不应出现", "reasonCodes": []string{"manual_review_reject"}, "problemSliceIds": []string{"left"}, "operationId": "decision", "draftVersion": 1, "resultVersion": rv}
if w := reviewSessionRequest(f, http.MethodPost, endpoint, f.reviewer, input, h); w.Code != 409 || !strings.Contains(w.Body.String(), "review_opinion_confirmation_required") {
t.Fatal("unconfirmed", w.Body.String())
}
p := []domain.ReviewProblem{{ID: "p1", Scope: "task", Text: "最终确认意见", TimeBasis: "task"}}
w := reviewSessionRequest(f, http.MethodPut, ep, f.reviewer, map[string]any{"modelVersion": 2, "version": 1, "resultVersion": rv, "operationId": "resolve", "problems": p}, h)
if w.Code != 200 {
t.Fatal(w.Body.String())
}
input["draftVersion"] = 2
w = reviewSessionRequest(f, http.MethodPost, endpoint, f.reviewer, input, h)
if w.Code != 201 {
t.Fatalf("decision: %d %s", w.Code, w.Body.String())
}
if strings.Contains(w.Body.String(), "过期内容") || !strings.Contains(w.Body.String(), "最终确认意见") {
t.Fatal("decision retained stale comment", w.Body.String())
}
if w := reviewSessionRequest(f, http.MethodPost, endpoint, f.reviewer, input, h); w.Code != 201 {
t.Fatal("replay", w.Body.String())
}
}
type archiveFailureStore struct {
store.Store
fail bool
}
func (s *archiveFailureStore) ArchiveReviewDraft(ctx context.Context, d domain.ReviewDraft) error {
if s.fail {
return fmt.Errorf("injected backup interruption")
}
return s.Store.ArchiveReviewDraft(ctx, d)
}
func TestReviewOpinionArchiveInterruptionAndRetry(t *testing.T) {
f := qualityReviewDraftFixture(t)
rv, h := openReviewDraftSession(t, f)
ep := "/api/human-items/" + f.item.ID + "/review-draft"
old := []domain.ReviewProblem{{ID: "p1", Scope: "task", Text: "一", TimeBasis: "task"}, {ID: "p2", Scope: "task", Text: "二", TimeBasis: "task"}}
seedLegacyOpinionDraft(t, f, ep, old)
wrapped := &archiveFailureStore{Store: f.store, fail: true}
f.handler = NewHandler(wrapped, nil)
payload := map[string]any{"modelVersion": 2, "version": 1, "resultVersion": rv, "operationId": "retry-backup", "problems": []domain.ReviewProblem{old[0]}}
w := reviewSessionRequest(f, http.MethodPut, ep, f.reviewer, payload, h)
if w.Code < 400 {
t.Fatal("backup failure should block", w.Body.String())
}
if d := readReviewDraft(t, f, ep); d.Version != 1 || !reflect.DeepEqual(d.Problems, old) {
t.Fatal("conversion preceded backup")
}
// New handler simulates process restart; persistent operation must resume safely.
wrapped.fail = false
f.handler = NewHandler(wrapped, nil)
w = reviewSessionRequest(f, http.MethodPut, ep, f.reviewer, payload, h)
if w.Code != 200 {
t.Fatal("retry", w.Body.String())
}
d := readReviewDraft(t, f, ep)
if d.Version != 2 || len(d.Problems) != 1 {
t.Fatal("retry lost conversion")
}
backup, _ := f.store.GetReviewDraftArchive(f.ctx, d.LegacyBackupID)
if backup == nil || !reflect.DeepEqual(backup.Problems, old) {
t.Fatal("retry lost backup")
}
}

View File

@ -25,6 +25,8 @@ type ReviewProblem struct {
ViewAnchor *ReviewViewAnchor `json:"viewAnchor,omitempty" bson:"viewAnchor,omitempty"`
}
type ReviewDraft struct {
ModelVersion int `json:"modelVersion,omitempty" bson:"modelVersion,omitempty"`
LegacyBackupID string `json:"legacyBackupId,omitempty" bson:"legacyBackupId,omitempty"`
ID string `json:"-" bson:"_id"`
OrganizationID string `json:"-" bson:"organizationId"`
ProjectID string `json:"-" bson:"projectId"`

View File

@ -15,6 +15,7 @@ type MemoryStore struct {
reviewContinuations map[string]domain.ReviewContinuation
reviewOperations map[string]domain.ReviewOperation
reviewDrafts map[string]domain.ReviewDraft
reviewDraftArchives map[string]domain.ReviewDraft
reviewSessions map[string]domain.ReviewSession
annotationBufferCapacities map[string]int
supplierDeletions map[string]domain.SupplierDeletionTask

View File

@ -15,7 +15,7 @@ func (s *MemoryStore) GetReviewDraft(_ context.Context, key string) (*domain.Rev
if !ok {
return nil, nil
}
v.Problems = append([]domain.ReviewProblem{}, v.Problems...)
v.Problems = cloneReviewProblems(v.Problems)
return &v, nil
}
func (s *MemoryStore) CompareAndSwapReviewDraft(_ context.Context, next domain.ReviewDraft, expected int) (bool, error) {
@ -29,7 +29,7 @@ func (s *MemoryStore) CompareAndSwapReviewDraft(_ context.Context, next domain.R
return false, nil
}
next.Version = expected + 1
next.Problems = append([]domain.ReviewProblem{}, next.Problems...)
next.Problems = cloneReviewProblems(next.Problems)
s.reviewDrafts[next.ID] = next
return true, nil
}
@ -57,3 +57,58 @@ func (s *MongoStore) CompareAndSwapReviewDraft(ctx context.Context, next domain.
r, e := c.ReplaceOne(ctx, bson.M{"_id": next.ID, "version": expected}, next)
return e == nil && r.MatchedCount == 1, e
}
// Archives are immutable and separate from active drafts/decision receipts.
// Insert-before-CAS is deliberately retryable; a failed CAS leaves a harmless
// historical snapshot, never an unbacked conversion.
func (s *MemoryStore) ArchiveReviewDraft(_ context.Context, draft domain.ReviewDraft) error {
s.mu.Lock()
defer s.mu.Unlock()
if s.reviewDraftArchives == nil {
s.reviewDraftArchives = map[string]domain.ReviewDraft{}
}
if _, ok := s.reviewDraftArchives[draft.ID]; !ok {
draft.Problems = cloneReviewProblems(draft.Problems)
s.reviewDraftArchives[draft.ID] = draft
}
return nil
}
func (s *MemoryStore) GetReviewDraftArchive(_ context.Context, key string) (*domain.ReviewDraft, error) {
s.mu.Lock()
defer s.mu.Unlock()
v, ok := s.reviewDraftArchives[key]
if !ok {
return nil, nil
}
v.Problems = cloneReviewProblems(v.Problems)
return &v, nil
}
func (s *MongoStore) ArchiveReviewDraft(ctx context.Context, draft domain.ReviewDraft) error {
_, err := s.db.Collection("reviewDraftArchives").InsertOne(ctx, draft)
if mongo.IsDuplicateKeyError(err) {
return nil
}
return err
}
func (s *MongoStore) GetReviewDraftArchive(ctx context.Context, key string) (*domain.ReviewDraft, error) {
var draft domain.ReviewDraft
err := s.db.Collection("reviewDraftArchives").FindOne(ctx, bson.M{"_id": key}).Decode(&draft)
if errors.Is(err, mongo.ErrNoDocuments) {
return nil, nil
}
if err != nil {
return nil, err
}
return &draft, nil
}
func cloneReviewProblems(problems []domain.ReviewProblem) []domain.ReviewProblem {
out := append([]domain.ReviewProblem{}, problems...)
for i := range out {
if out[i].ViewAnchor != nil {
anchor := *out[i].ViewAnchor
out[i].ViewAnchor = &anchor
}
}
return out
}

View File

@ -0,0 +1,73 @@
package store
import (
"context"
"droboticflow/internal/domain"
"fmt"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
"os"
"reflect"
"strings"
"testing"
"time"
)
func TestReviewOpinionMongoArchiveSurvivesRestart(t *testing.T) {
uri := os.Getenv("REVIEW_OPINION_TEST_MONGO")
if uri == "" {
t.Skip("set REVIEW_OPINION_TEST_MONGO to localhost test Mongo")
}
if !strings.HasPrefix(uri, "mongodb://127.0.0.1:") {
t.Fatal("local Mongo only")
}
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
client, err := mongo.Connect(ctx, options.Client().ApplyURI(uri))
if err != nil {
t.Fatal(err)
}
defer client.Disconnect(ctx)
db := client.Database(fmt.Sprintf("review_opinion_test_%d", time.Now().UnixNano()))
defer db.Drop(context.Background())
s := &MongoStore{db: db}
old := domain.ReviewDraft{ID: "draft", Problems: []domain.ReviewProblem{{ID: "one", Scope: "task", Text: "完整旧原文"}, {ID: "two", Scope: "task", Text: "相反的更正意见"}}}
if ok, err := s.CompareAndSwapReviewDraft(ctx, old, 0); err != nil || !ok {
t.Fatal(ok, err)
}
old.Version = 1
archive := old
archive.ID = "draft:v1"
if err := s.ArchiveReviewDraft(ctx, archive); err != nil {
t.Fatal(err)
}
// Reconnect after a simulated interruption before conversion. Archive is immutable.
restarted := &MongoStore{db: db}
if err := restarted.ArchiveReviewDraft(ctx, archive); err != nil {
t.Fatal(err)
}
next := old
next.ModelVersion = 2
next.LegacyBackupID = archive.ID
next.Problems = old.Problems[:1]
if ok, err := restarted.CompareAndSwapReviewDraft(ctx, next, 1); err != nil || !ok {
t.Fatal(ok, err)
}
if ok, err := restarted.CompareAndSwapReviewDraft(ctx, old, 1); err != nil || ok {
t.Fatal("stale writer", ok, err)
}
read, _ := restarted.GetReviewDraft(ctx, "draft")
backup, _ := restarted.GetReviewDraftArchive(ctx, read.LegacyBackupID)
if read.ModelVersion != 2 || read.Version != 2 || backup == nil || !reflect.DeepEqual(backup.Problems, old.Problems) {
t.Fatal("conversion/archive lost", read, backup)
}
clear := *read
clear.Problems = []domain.ReviewProblem{}
if ok, err := restarted.CompareAndSwapReviewDraft(ctx, clear, 2); err != nil || !ok {
t.Fatal(ok, err)
}
backup2, _ := s.GetReviewDraftArchive(ctx, archive.ID)
if !reflect.DeepEqual(backup, backup2) {
t.Fatal("clear mutated archive")
}
}

View File

@ -28,6 +28,8 @@ type Store interface {
UpdateAnnotationTaskForReview(context.Context, domain.AnnotationTaskRecord, domain.AnnotationTaskRecord) (bool, error)
UpdateHumanItemForReview(context.Context, domain.HumanItemRecord, int) (bool, error)
GetReviewDraft(context.Context, string) (*domain.ReviewDraft, error)
ArchiveReviewDraft(context.Context, domain.ReviewDraft) error
GetReviewDraftArchive(context.Context, string) (*domain.ReviewDraft, error)
CompareAndSwapReviewDraft(context.Context, domain.ReviewDraft, int) (bool, error)
GetReviewContinuation(context.Context, string) (*domain.ReviewContinuation, error)
CompareAndSwapReviewContinuation(context.Context, domain.ReviewContinuation, int, *domain.ReviewSession) (bool, error)

View File

@ -267,6 +267,7 @@ export function CaptureAnnotationWorkbench({
reviewCaption: providedReviewCaption,
reviewCaptionStatus,
reviewNavigation,
onReviewNavigate,
onReviewPositionChange,
onReviewController,
onReviewProblem,
@ -867,11 +868,13 @@ export function CaptureAnnotationWorkbench({
const sliderDragging = useRef(false);
const sliderEvents = {
onPointerDown: (event: ReactPointerEvent<HTMLInputElement>) => {
if (isReviewViewing) onReviewNavigate?.();
sliderDragging.current = true;
event.currentTarget.setPointerCapture(event.pointerId);
transport.beginScrub();
},
onChange: (event: { currentTarget: HTMLInputElement }) => {
if (isReviewViewing) onReviewNavigate?.();
const next = snap(Number(event.currentTarget.value));
if (sliderDragging.current) previewSeek(next);
else seek(next); // keyboard and click/programmatic positioning remain exact
@ -939,6 +942,7 @@ export function CaptureAnnotationWorkbench({
setEditingAnnotation(restored?.annotation ?? null);
setEndSelection(restored?.endSelection ?? null);
}
if (isReviewViewing && slice.id !== selectedSlice.id) onReviewNavigate?.();
setSelectedSliceId(slice.id);
setSelectedBoundary(null);
setSelectedAnnotationBoundary(null);
@ -978,6 +982,7 @@ export function CaptureAnnotationWorkbench({
}, [historyReveal, slices, phase]);
const reviewSlice = () => {
if (saving || !timelineReady || phase === "materializing") return;
if (isReviewViewing) onReviewNavigate?.();
setWorkPosition((original) => original ?? currentTime);
endTrackingSuspended.current = true;
pausePlayback();
@ -1030,6 +1035,7 @@ export function CaptureAnnotationWorkbench({
const step = (direction: -1 | 1) => {
if (!selectedSlice || !timelineReady || saving || phase === "materializing") return;
if (isReviewViewing) onReviewNavigate?.();
pausePlayback();
const selection = endSelectionRef.current;
if (selection && !selection.confirmed && !reviewPlayback) {
@ -1773,6 +1779,7 @@ export function CaptureAnnotationWorkbench({
return;
}
if (!selectDescription(segment)) return;
if (isReviewViewing) onReviewNavigate?.();
descriptionNavigationRef.current = segment.id !== editingAnnotation?.id;
setWorkPosition((original) => original ?? currentTime);
pausePlayback();
@ -1823,8 +1830,17 @@ export function CaptureAnnotationWorkbench({
// flushes its recorded frame through that controller.
const frame = requestAnimationFrame(() => reviewPositionCallback.current?.(reviewPosition));
return () => cancelAnimationFrame(frame);
}, [isReviewViewing, currentTime, selectedSlice.id, reviewPosition.actionId, reviewSelectedActionId, timelineReady]);
}, [
isReviewViewing,
currentTime,
selectedSlice.id,
reviewPosition.actionId,
reviewSelectedActionId,
timelineReady,
onReviewPositionChange,
]);
const selectReviewAction = (id: string) => {
onReviewNavigate?.();
const action = reviewActions.find((candidate) => candidate.id === id);
if (!action || saving || !timelineReady) return false;
if (reviewNavigation) {
@ -3586,6 +3602,7 @@ export function CaptureAnnotationWorkbench({
descriptionTimelineStart,
descriptionTimelineEnd,
);
if (isReviewViewing) onReviewNavigate?.();
seek(snap(point.time));
}}
data-testid="slice-annotation-timeline"

View File

@ -66,6 +66,7 @@ export function FinalAcceptanceWorkspace({
onApprove,
onReject,
onRelease,
onReviewNavigate,
onReviewPositionChange,
onReviewController,
onReviewProblem,
@ -339,6 +340,7 @@ export function FinalAcceptanceWorkspace({
const target = groups.find((group) => group.id === id);
if (!target) return false;
mediaControllerRef.current?.pause();
if (target.id !== active?.id) onReviewNavigate?.();
setActiveId(target.id);
setSelectedActionId("");
// The media workbench remounts for each slice; retain keyboard focus on
@ -349,6 +351,7 @@ export function FinalAcceptanceWorkspace({
const chooseAction = (id: string) => {
if (id !== selectedActionId && actionNoteDirty) return false;
if (!actions.some((action) => action.id === id) || saving) return false;
if (id !== selectedActionId) onReviewNavigate?.();
setSelectedActionId(id);
return true;
};
@ -364,11 +367,14 @@ export function FinalAcceptanceWorkspace({
sourceItemId: active?.entry.sourceHumanItemId || "",
artifactId: active?.entry.materialization?.artifactId || "",
});
const mappedPosition = (position: ReviewPosition) => {
const result = mapReviewPosition(position);
currentReviewPosition.current = result;
onReviewPositionChange?.(result);
};
const mappedPosition = useCallback(
(position: ReviewPosition) => {
const result = mapReviewPosition(position);
currentReviewPosition.current = result;
onReviewPositionChange?.(result);
},
[active, onReviewPositionChange],
);
const finalControllerCurrent = useRef<ReviewViewingController | null>(null);
finalControllerCurrent.current = {
pause: () => mediaControllerRef.current?.pause(),
@ -603,6 +609,7 @@ export function FinalAcceptanceWorkspace({
onNavigateSlice: navigateSlice,
}}
onReviewController={attachMediaController}
onReviewNavigate={onReviewNavigate}
onReviewPositionChange={mappedPosition}
onReviewProblem={(position) => onReviewProblem?.(mapReviewPosition(position))}
onReviewSave={onReviewSave}

View File

@ -1,11 +1,18 @@
import type { ReviewProblem } from "../services/api/review-draft";
import { useEffect, useRef } from "react";
import type { useReviewDecision } from "../hooks/useReviewDecision";
export function ReviewDecisionDialog({
decision,
canSubmit,
problems = [],
problemLabel,
onProblem,
}: {
decision: ReturnType<typeof useReviewDecision>;
canSubmit: boolean;
problems?: ReviewProblem[];
problemLabel?: (problem: ReviewProblem) => string;
onProblem?: (problem: ReviewProblem) => void;
}) {
const confirm = useRef<HTMLButtonElement>(null);
useEffect(() => {
@ -28,6 +35,7 @@ export function ReviewDecisionDialog({
decision.cancel();
}
if (event.key === "Enter" && !event.ctrlKey && !event.metaKey && !event.altKey && !event.shiftKey) {
if ((event.target as HTMLElement).closest("details")) return;
event.preventDefault();
if (canSubmit && !decision.busy) decision.confirm();
}
@ -36,6 +44,24 @@ export function ReviewDecisionDialog({
<h2 className="font-semibold">{request.decision === "approved" ? "确认通过" : "确认退回"}</h2>
<p className="my-3 break-words text-sm">{request.title}</p>
<p className="text-sm">{request.scopeText}</p>
{problems.length > 0 && (
<details className="mt-2 text-sm">
<summary>查看全部 {problems.length} 处意见</summary>
<div className="max-h-60 overflow-y-auto">
{problems.map((p) => (
<button
type="button"
key={p.id}
onClick={() => onProblem?.(p)}
className="my-1 block w-full whitespace-pre-wrap break-words rounded border p-2 text-left"
>
<strong>{problemLabel?.(p)}</strong>
<p>{p.text}</p>
</button>
))}
</div>
</details>
)}
<p className="mt-2 text-xs text-slate-500">正式决定提交后不能通过撤销快捷键撤回。</p>
{!canSubmit && (
<p role="alert" className="mt-2 text-sm text-amber-700">

View File

@ -1,66 +1,33 @@
import { useEffect, useLayoutEffect, useRef } from "react";
import { useLayoutEffect, useRef } from "react";
import type { useReviewDraft } from "../hooks/useReviewDraft";
import type { ReviewProblem } from "../services/api/review-draft";
import { opinionKey } from "../lib/review-opinions";
type Props = {
writeLocked?: boolean;
review: ReturnType<typeof useReviewDraft>;
label: (problem: ReviewProblem) => string;
navigationSliceId?: (problem: ReviewProblem) => string | undefined;
};
const problemTime = (seconds: number) =>
`${Math.floor(seconds / 60)
.toString()
.padStart(2, "0")}:${(seconds % 60).toFixed(3).padStart(6, "0")}`;
const SCOPE_LABELS: Record<ReviewProblem["scope"], string> = { action: "动作", slice: "切片", task: "整体" };
const names = { task: "整体意见", slice: "当前切片意见", action: "当前动作意见" };
const scopes = { task: "整体", slice: "切片", action: "动作" };
export function ReviewProblemPanel({ review, label, navigationSliceId, writeLocked = false }: Props) {
const locked = writeLocked || !review.writable || review.loading;
const picker = review.scopePicker;
const scopeOptions = review.scopeOptions(picker);
const pickerTarget: ReviewProblem | null = picker
? {
id: "",
scope: picker.scope,
sourceItemId: picker.scope === "task" ? undefined : picker.position.sourceItemId,
sliceId: picker.scope === "task" ? undefined : picker.position.sliceId,
actionId: picker.scope === "action" ? picker.position.actionId || undefined : undefined,
text: "",
atSeconds: picker.scope === "task" ? 0 : picker.position.time,
timeBasis: picker.scope === "task" ? "task" : picker.position.timeBasis,
}
: null;
const scopeGroupRef = useRef<HTMLDivElement>(null);
const deleteBarRef = useRef<HTMLDivElement>(null);
// Focus the checked scope option synchronously with its first paint so a fast
// F→Enter sequence can never leak Enter to the workbench's edit command.
const locked = writeLocked || !review.writable || review.loading || !review.draft;
const scopeRef = useRef<HTMLDivElement>(null),
clearRef = useRef<HTMLDivElement>(null);
useLayoutEffect(() => {
if (!picker) return;
const group = scopeGroupRef.current;
const option =
group?.querySelector<HTMLElement>(`[data-scope="${picker.scope}"]`) ||
group?.querySelector<HTMLElement>("[role='radio']:not([disabled])");
option?.focus();
}, [picker]);
useEffect(() => {
if (!review.confirmDeleteId) return;
const bar = deleteBarRef.current;
window.requestAnimationFrame(() =>
(bar?.querySelector<HTMLElement>("[data-cancel-delete]") || bar?.querySelector<HTMLElement>("button"))?.focus(),
);
}, [review.confirmDeleteId]);
const selectedProblem = review.draft?.problems.find((p) => p.id === review.selectedId) || null;
const confirmProblem = review.draft?.problems.find((p) => p.id === review.confirmDeleteId) || null;
const editingTarget: ReviewProblem | null = review.editor
? { ...review.editor, text: review.editor.text }
: pickerTarget;
scopeRef.current?.querySelector<HTMLButtonElement>('[aria-checked="true"]')?.focus();
}, [review.scopePicker]);
useLayoutEffect(() => {
if (review.confirmClear) clearRef.current?.querySelector<HTMLButtonElement>("[data-cancel]")?.focus();
}, [review.confirmClear]);
const duplicates = review.groups.filter((g) => g.length > 1);
return (
<section
aria-label="审查问题草稿"
className="review-problem-panel min-h-0 space-y-2 rounded border border-slate-200 p-2 text-sm"
>
<div className="flex flex-wrap items-center justify-between gap-2">
<strong>审查问题</strong>
<div className="flex items-center justify-between gap-2">
<strong>审核意见</strong>
<span role="status" className="text-xs text-slate-500">
{review.loading
? "正在加载"
@ -71,231 +38,285 @@ export function ReviewProblemPanel({ review, label, navigationSliceId, writeLock
: review.message || (review.draft ? "已保存" : "尚未加载")}
</span>
</div>
<div className="flex items-center gap-2">
<div role="listbox" aria-label="审核意见范围" className="space-y-1">
{review.cards.map((card) => (
<button
type="button"
role="option"
key={card.scope}
data-opinion-scope={card.scope}
aria-selected={review.selectedScope === card.scope}
disabled={locked || !card.target}
onClick={() => review.selectScope(card.scope, true)}
className="block w-full rounded border p-2 text-left aria-selected:border-orange-500 aria-selected:bg-orange-50/50 disabled:opacity-60 dark:aria-selected:bg-orange-950/20"
>
<span className="flex items-center justify-between gap-1 font-semibold">
<span>{names[card.scope]}</span>
{card.pending && <span className="text-xs text-amber-700">未保存</span>}
</span>
{card.target && card.scope !== "task" && (
<span className="block text-xs text-slate-500">{label(card.target)}</span>
)}
{review.loading || !review.draft ? (
<span className="block text-slate-500">{review.loading ? "正在加载…" : "意见尚未加载"}</span>
) : !card.target ? (
<span className="block text-slate-500">{card.scope === "action" ? "当前无动作" : "当前无切片"}</span>
) : card.problems.length === 0 ? (
<span className="block text-slate-500">无</span>
) : (
<span className="block max-h-44 space-y-2 overflow-y-auto whitespace-pre-wrap break-words font-normal">
{card.problems.length > 1 && (
<span className="block text-xs text-amber-700">
旧版有 {card.problems.length} 条意见,请确认最终内容
</span>
)}
{card.problems.map((p, i) => (
<span key={p.id} className="block">
{card.problems.length > 1 ? `${i + 1}. ` : ""}
{p.text}
{card.problems.length > 1 && p.scope !== "task" && (
<span className="block text-xs text-slate-500">记录位置:{p.atSeconds.toFixed(3)} 秒</span>
)}
</span>
))}
</span>
)}
</button>
))}
</div>
<div className="flex flex-wrap justify-between gap-2 text-xs">
<button
type="button"
disabled={locked}
title="暂停当前画面并记录新问题(F)"
aria-keyshortcuts="f"
onClick={() => review.beginProblem()}
className="rounded border px-2 py-1"
>
记录当前画面问题
编辑当前画面意见
</button>
<button
type="button"
disabled={locked || !review.selectedScope || review.saving}
onClick={() => review.requestDelete()}
className="text-rose-600 disabled:text-slate-400"
>
清除意见
</button>
</div>
{picker && (
{review.scopePicker && (
<div
ref={scopeGroupRef}
ref={scopeRef}
role="radiogroup"
aria-label="问题范围"
className="space-y-1 rounded border border-orange-300 p-2"
onKeyDown={(event) => {
if (event.nativeEvent.isComposing || event.keyCode === 229) return;
event.stopPropagation();
if (event.key === "ArrowUp" || event.key === "ArrowDown") {
event.preventDefault();
review.moveScope(event.key === "ArrowUp" ? -1 : 1);
} else if (event.key === "Enter" || event.key === " ") {
event.preventDefault();
className="rounded border border-orange-300 p-2"
onKeyDown={(e) => {
if (e.nativeEvent.isComposing || e.keyCode === 229 || e.repeat) return;
e.stopPropagation();
if (e.key === "ArrowUp" || e.key === "ArrowDown") {
e.preventDefault();
review.moveScope(e.key === "ArrowUp" ? -1 : 1);
} else if (e.key === "Enter" || e.key === " ") {
e.preventDefault();
review.confirmScope();
} else if (event.key === "Escape") {
event.preventDefault();
} else if (e.key === "Escape") {
e.preventDefault();
review.cancelScope();
}
}}
>
{(["action", "slice", "task"] as const).map((scope) => {
const available = scopeOptions.includes(scope);
return (
<button
key={scope}
type="button"
role="radio"
data-scope={scope}
disabled={!available}
aria-checked={picker.scope === scope}
onClick={() => review.confirmScope(scope)}
className="block w-full rounded border px-2 py-1 text-left text-xs aria-checked:border-orange-500 aria-checked:bg-orange-50 disabled:opacity-40 dark:aria-checked:bg-orange-950/30"
>
{SCOPE_LABELS[scope]}
{scope === "action" && !available ? "(当前画面无动作)" : ""}
</button>
);
})}
{review.cards.map((c) => (
<button
key={c.scope}
type="button"
role="radio"
aria-checked={review.scopePicker?.scope === c.scope}
disabled={!review.scopeOptions(review.scopePicker).includes(c.scope)}
onClick={() => review.confirmScope(c.scope)}
className="block w-full rounded border px-2 py-1 text-left aria-checked:border-orange-500 disabled:opacity-40"
>
{scopes[c.scope]}
</button>
))}
</div>
)}
{editingTarget && (
<p aria-label="批注对象" className="truncate text-xs text-slate-500" title={label(editingTarget)}>
{label(editingTarget)}
</p>
)}
<textarea
ref={review.inputRef}
aria-label="审查问题说明"
value={review.editor?.text || ""}
readOnly={locked || !review.editor}
rows={3}
maxLength={10000}
onChange={(e) => review.setText(e.target.value)}
onKeyDown={(e) => {
if (e.repeat || e.nativeEvent.isComposing || e.keyCode === 229) return;
if ((e.ctrlKey || e.metaKey) && e.key === "Enter") {
e.preventDefault();
e.stopPropagation();
if (!locked) void review.save();
}
}}
placeholder="记录问题位置和修改要求"
className="w-full resize-none rounded border bg-transparent p-2 text-sm"
/>
{review.guard && (
<div
role="alert"
className="space-y-2 rounded border border-amber-300 bg-amber-50 p-2 text-xs dark:bg-amber-950/30"
>
<p>当前批注文字尚未保存。</p>
<div className="flex gap-2">
{review.editor && (
<>
<p aria-label="批注对象" className="text-xs text-slate-500">
正在编辑:{label(review.editor)}
</p>
{review.editor.legacy && (
<p className="text-xs text-amber-700">请整理下方分段原文;保存即确认一份最终意见,原文会保留。</p>
)}
<textarea
ref={review.inputRef}
aria-label="审查问题说明"
value={review.editor.text}
readOnly={locked}
rows={3}
onChange={(e) => review.setText(e.target.value)}
onKeyDown={(e) => {
if (e.nativeEvent.isComposing || e.keyCode === 229 || e.repeat) return;
if ((e.ctrlKey || e.metaKey) && e.key === "Enter") {
e.preventDefault();
e.stopPropagation();
if (!locked) void review.save();
} else if (e.key === "Escape") {
e.preventDefault();
e.stopPropagation();
review.escape();
}
}}
placeholder="填写问题与修改要求"
className="w-full resize-y rounded border bg-transparent p-2 text-sm"
/>
{Array.from(review.editor.text).length > 10000 && (
<p role="alert" className="text-xs text-amber-700">
原文已完整保留,请整理到 10000 字以内再保存。
</p>
)}
<div className="flex justify-end gap-2">
<button type="button" onClick={review.escape} className="rounded border px-2 py-1">
取消修改
</button>
<button
type="button"
onClick={() => void review.guardSave()}
className="rounded bg-orange-500 px-2 py-1 font-semibold text-white"
disabled={locked || review.saving || Array.from(review.editor.text).length > 10000}
onClick={() => void review.save()}
className="rounded bg-orange-500 px-3 py-1.5 font-semibold text-white disabled:opacity-50"
>
保存并继续
</button>
<button type="button" onClick={review.guardDiscard} className="rounded border px-2 py-1">
放弃文字
</button>
<button type="button" onClick={review.guardCancel} className="rounded border px-2 py-1">
继续编辑
保存批注
</button>
</div>
</div>
</>
)}
{confirmProblem && (
{review.confirmClear && (
<div
ref={deleteBarRef}
ref={clearRef}
role="alertdialog"
aria-label="确认删除问题"
className="space-y-2 rounded border border-rose-300 bg-rose-50 p-2 text-xs dark:bg-rose-950/30"
onKeyDown={(event) => {
event.stopPropagation();
if (event.key === "Escape") {
event.preventDefault();
aria-label="确认清除意见"
className="space-y-2 rounded border border-rose-300 p-2"
onKeyDown={(e) => {
if (e.nativeEvent.isComposing || e.keyCode === 229 || e.repeat) return;
e.stopPropagation();
if (e.key === "Escape") {
e.preventDefault();
review.cancelDelete();
} else if (e.key === "Enter") {
e.preventDefault();
if (!locked) void review.confirmDelete();
}
}}
>
<p className="truncate">删除「{confirmProblem.text}」?删除后立即保存,不再要求再次确认。</p>
<p>清除「{label(review.confirmClear)}」的意见?该对象未保存的修改也会放弃,历史记录保留。</p>
<div className="flex gap-2">
<button
type="button"
onClick={review.confirmDelete}
className="rounded bg-rose-600 px-2 py-1 font-semibold text-white"
disabled={locked || review.saving}
onClick={() => void review.confirmDelete()}
className="rounded bg-rose-600 px-2 py-1 text-white"
>
确认删除
确认清除
</button>
<button type="button" data-cancel-delete onClick={review.cancelDelete} className="rounded border px-2 py-1">
<button type="button" data-cancel onClick={review.cancelDelete} className="rounded border px-2 py-1">
取消
</button>
</div>
</div>
)}
{review.recoverable && (
<div className="flex items-center justify-between gap-2 rounded border border-amber-300 p-2 text-xs text-amber-700">
<span className="truncate">这些文字可能还没保存:{review.recoverable.text.slice(0, 40)}</span>
<button type="button" onClick={review.restoreRecoverable} className="shrink-0 underline">
恢复未保存内容
</button>
{review.guard && (
<div role="alert" className="rounded border border-amber-300 p-2 text-xs">
<p>还有意见未保存,请先处理后再离开。</p>
<div className="mt-1 flex gap-2">
<button type="button" onClick={() => void review.guardSave()}>
保存全部修改
</button>
<button type="button" onClick={review.guardDiscard}>
放弃未保存修改
</button>
<button type="button" onClick={review.guardCancel}>
继续编辑
</button>
</div>
</div>
)}
<div className="flex flex-wrap items-center justify-between gap-2">
<div className="flex gap-3">
{review.unsaved
.filter((e) => opinionKey(e) !== (review.editor ? opinionKey(review.editor) : ""))
.map((e) => (
<button
type="button"
disabled={locked || !selectedProblem}
onClick={() => review.editSelected()}
className="text-xs text-slate-600 disabled:text-slate-400"
key={opinionKey(e)}
disabled={locked}
onClick={() => review.restore(e)}
className="block text-left text-xs text-amber-700"
>
编辑选中问题
{label(e)}:有未保存文字,点击继续编辑
</button>
<button
type="button"
disabled={locked || !selectedProblem}
title="删除选中的已保存问题(Shift + Delete)"
onClick={() => review.requestDelete()}
className="text-xs text-rose-600 disabled:text-slate-400"
>
删除选中问题
</button>
</div>
<button
type="button"
disabled={locked || !review.editor || !review.editor.text.trim()}
onClick={() => void review.save()}
className="rounded bg-orange-500 px-3 py-1.5 text-xs font-semibold text-white disabled:opacity-50"
>
保存批注
</button>
</div>
{review.previousText && (
<details className="text-xs text-amber-700">
<summary>标注已更新,查看之前未保存的文字</summary>
<p className="whitespace-pre-wrap">{review.previousText}</p>
</details>
)}
))}
{review.error && (
<p role="alert" className="text-xs text-rose-600">
{review.error}
<button type="button" onClick={() => void review.reload()} className="ml-2 underline">
更新问题列表
<button
type="button"
disabled={review.saving}
onClick={() => void review.reload()}
className="ml-2 underline"
>
更新意见
</button>
</p>
)}
{!review.error && /请先|之前的文字已保存/.test(review.message) && (
<p role="alert" className="text-xs text-amber-700">
{review.message}
</p>
)}
<div className="min-h-0 max-h-36 overflow-y-auto border-t pt-2" aria-label="本次问题列表">
<p className="mb-1 text-xs text-slate-500">
{review.loading
? "正在加载问题列表…"
: review.draft
? `${review.draft.problems.length} 个已保存问题`
: "问题列表尚未加载"}
</p>
<div role="listbox" aria-label="已保存问题" aria-orientation="vertical">
{(review.draft?.problems || []).map((problem) => (
<button
type="button"
onClick={() => review.setShowSummary(!review.showSummary)}
className="text-xs text-slate-500 underline"
>
全任务 {review.groups.length} 处意见{duplicates.length ? ` · ${duplicates.length} 处旧意见待确认` : ""}
</button>
{review.showSummary && (
<div aria-label="全任务意见汇总" className="max-h-64 space-y-1 overflow-y-auto border-t pt-2">
{review.groups.map((group) => (
<button
type="button"
role="option"
key={problem.id}
data-problem-id={problem.id}
aria-selected={problem.id === review.selectedId}
aria-current={problem.id === review.editor?.id || undefined}
onMouseDown={(event) => {
// Selecting must keep keyboard ownership on the workbench.
event.preventDefault();
}}
onClick={() => review.selectProblem(problem, navigationSliceId?.(problem))}
className="mb-1 block w-full rounded border p-2 text-left text-xs aria-selected:border-orange-500 aria-selected:bg-orange-50/50 dark:aria-selected:bg-orange-950/20"
key={opinionKey(group[0])}
onClick={() => review.selectProblem(group[0], navigationSliceId?.(group[0]))}
className="block w-full rounded border p-2 text-left text-xs"
>
<span className="flex items-center justify-between gap-1 font-medium">
<span className="truncate">{label(problem)}</span>
{(problem.scope !== "task" || problem.viewAnchor) && (
<span
className="shrink-0 font-mono text-[10px]"
title={problem.timeBasis === "slice-seconds" ? "片内时间" : "原视频时间"}
>
{problemTime(problem.scope === "task" ? problem.viewAnchor!.atSeconds : problem.atSeconds)}
</span>
)}
</span>
<span className="block truncate text-slate-500">{problem.text}</span>
<strong>
{label(group[0])}
{group.length > 1 ? " · 请确认最终意见" : ""}
</strong>
{group.map((p, i) => (
<span key={p.id} className="block whitespace-pre-wrap break-words">
{group.length > 1 ? `${i + 1}. ` : ""}
{p.text}
</span>
))}
</button>
))}
</div>
</div>
)}
{review.previousText && (
<details className="text-xs">
<summary>查看之前未保存的文字</summary>
<p className="whitespace-pre-wrap break-words">{review.previousText}</p>
</details>
)}
{review.draft?.legacyBackupId && (
<details
className="text-xs"
onToggle={(e) => {
if (e.currentTarget.open && review.history === null && !review.historyLoading) void review.loadHistory();
}}
>
<summary>旧版意见原文(只读)</summary>
{review.historyLoading
? "正在加载…"
: review.history?.map((p) => (
<p key={p.id} className="my-1 whitespace-pre-wrap break-words">
{label(p)}:{p.text}
</p>
))}
</details>
)}
</section>
);
}

View File

@ -27,6 +27,8 @@ export type ReviewViewingController = {
};
export type ReviewViewingProps = {
reviewProblemPanel?: ReactNode;
/** Explicit viewing navigation; playback position updates do not trigger autosave. */
onReviewNavigate?: () => void;
onReviewPositionChange?: (position: ReviewPosition) => void;
onReviewController?: (controller: ReviewViewingController | null) => void;
onReviewProblem?: (position: ReviewPosition) => void;

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,76 @@
import type { ReviewProblem } from "../services/api/review-draft";
import type { ReviewPosition } from "../components/review-viewing";
export type OpinionScope = ReviewProblem["scope"];
export const opinionScopes: OpinionScope[] = ["task", "slice", "action"];
export function opinionKey(p: Pick<ReviewProblem, "scope" | "sourceItemId" | "sliceId" | "actionId">) {
return JSON.stringify([
p.scope,
p.scope === "task" ? "" : p.sourceItemId || "",
p.scope === "task" ? "" : p.sliceId || "",
p.scope === "action" ? p.actionId || "" : "",
]);
}
export function opinionGroups(problems: ReviewProblem[]) {
const groups = new Map<string, ReviewProblem[]>();
for (const p of problems) {
const key = opinionKey(p);
groups.set(key, [...(groups.get(key) || []), p]);
}
return groups;
}
export function groupSignature(problems: ReviewProblem[]) {
return JSON.stringify(problems.map((p) => [p.id, opinionKey(p), p.text, p.atSeconds, p.viewAnchor || null]));
}
export function opinionTarget(scope: OpinionScope, position: ReviewPosition | null): ReviewProblem | null {
if ((scope !== "task" && !position?.sliceId) || (scope === "action" && !position?.actionId)) return null;
return {
id: "",
scope,
text: "",
atSeconds: scope === "task" ? 0 : position!.time,
sourceItemId: scope === "task" ? undefined : position?.sourceItemId,
sliceId: scope === "task" ? undefined : position?.sliceId,
actionId: scope === "action" ? position?.actionId || undefined : undefined,
timeBasis: scope === "task" ? "task" : position?.timeBasis,
viewAnchor:
scope === "task" && position?.sliceId
? {
sourceItemId: position.sourceItemId,
sliceId: position.sliceId,
atSeconds: position.time,
timeBasis: position.timeBasis,
}
: undefined,
};
}
/** Replace one target, preserving every other object (including unresolved legacy groups). */
export function replaceOpinion(problems: ReviewProblem[], target: ReviewProblem, text: string) {
const key = opinionKey(target),
result: ReviewProblem[] = [];
let inserted = false;
for (const p of problems) {
if (opinionKey(p) !== key) result.push(p);
else if (!inserted) {
if (text.trim()) result.push({ ...p, text: text.trim() });
inserted = true;
}
}
if (!inserted && text.trim()) {
// Editor recovery state is local-only; never embed old drafts in a write intent.
const { id, scope, sourceItemId, sliceId, actionId, atSeconds, start, end, timeBasis, viewAnchor } = target;
result.push({
id,
scope,
sourceItemId,
sliceId,
actionId,
atSeconds,
start,
end,
timeBasis,
viewAnchor,
text: text.trim(),
});
}
return result;
}

View File

@ -46,11 +46,11 @@ export const reviewShortcutHelp = [
{ keys: "Ctrl / ⌘ + ← / →", label: "上一片/下一片;到首尾停止" },
{ keys: "↑ / ↓", label: "上一个/下一个动作;暂停在起始帧,到首尾停止" },
{ keys: "B", label: "从当前片头复查,片尾暂停" },
{ keys: "F", label: "暂停当前画面并记录新问题:先选动作/切片/整体范围,Enter 进入文字" },
{ keys: "Ctrl / ⌘ + ↑ / ↓", label: "选择已保存问题并回看记录画面;到首尾停止" },
{ keys: "Enter", label: "编辑选中的已保存问题;点击列表同样只回看选中" },
{ keys: "Ctrl / ⌘ + Enter", label: "保存非空批注;不会通过或退回任务" },
{ keys: "Shift + Delete(Mac 也可用 Shift + Backspace)", label: "删除选中的本轮问题,短确认后立即保存" },
{ keys: "Esc", label: "关闭帮助或删除确认;退出范围选择或文字输入并返回工作台" },
{ keys: "F", label: "暂停并选择意见范围;编辑已有意见,没有则填写" },
{ keys: "Ctrl / ⌘ + ↑ / ↓", label: "选择整体/当前切片/当前动作意见;到首尾停止" },
{ keys: "Enter", label: "编辑选中的意见卡片;点击卡片也可编辑" },
{ keys: "Ctrl / ⌘ + Enter", label: "保存当前意见;删空已有内容后确认清除,不会提交审核决定" },
{ keys: "Shift + Delete(Mac 也可用 Shift + Backspace)", label: "清除选中卡片的本轮意见,确认后保存为“无”" },
{ keys: "Esc", label: "关闭帮助或清除确认;退出范围选择或文字输入并返回工作台" },
{ keys: "?", label: "打开快捷键帮助" },
];

View File

@ -3359,23 +3359,30 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
rejectTarget?: "cut_adjustment" | "semantic_annotation",
) => {
if (!detail) return;
if (!reviewDraft.canLeave()) return;
const scope = reviewActionScopeRef.current;
if (!(await reviewDraft.prepareSubmit())) return;
if (scope !== reviewActionScopeRef.current) return;
const preparedDraft = reviewDraft.currentDraft();
const currentComment =
preparedDraft?.modelVersion === 2
? preparedDraft.problems.map((p) => `${reviewProblemLabel(p)}:${p.text}`).join("\n")
: reviewComment;
if (reviewSessionItem && !reviewSession.writable) {
setError("本页没有审查编辑权,请接管后继续。");
return;
}
if (decision === "approved" && (reviewDraft.draft?.problems.length || 0) > 0) {
if (decision === "approved" && (preparedDraft?.problems.length || 0) > 0) {
setError("请先处理已保存的问题,再通过审核。");
return;
}
if (decision === "rejected" && !reviewComment.trim()) {
if (decision === "rejected" && !preparedDraft?.problems.length && !currentComment.trim()) {
setError("打回必须填写原因,便于操作员按轮次返工。");
return;
}
let effectiveProblemSliceIds = [...problemSliceIds];
if (decision === "rejected" && effectiveProblemSliceIds.length === 0) {
const parsed = parseSegmentCommentsFromText(reviewComment);
const parsed = parseSegmentCommentsFromText(currentComment);
const matchedFromComment = sliceSegments
.filter((s, idx) => parsed.segmentComments.some((c) => c.sliceName === (s.name || `切片 ${idx + 1}`)))
.map((s) => s.id);
@ -3390,7 +3397,6 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
}
}
const scope = reviewActionScopeRef.current;
setSaving(true);
setError("");
try {
@ -3406,7 +3412,7 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
...{
stage,
decision,
comment: reviewComment,
comment: currentComment,
rejectTargets:
decision === "rejected"
? selectedHumanItem?.currentStageId === "cut_review"
@ -3429,8 +3435,8 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
annotationCompleteness: isV5CombinedQuality ? undefined : Number(qualityDraft.annotationCompleteness),
overallGrade: isV5CombinedQuality ? undefined : qualityDraft.overallGrade,
},
draftVersion: reviewDraft.draft?.version ?? 0,
resultVersion: reviewDraft.draft?.resultVersion || "",
draftVersion: preparedDraft?.version ?? 0,
resultVersion: preparedDraft?.resultVersion || "",
},
};
const result = reviewReceiptSupported
@ -3747,12 +3753,17 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
strictThreeRole: boolean,
acceptanceComment = reviewComment,
) => {
if (!reviewDraft.canLeave()) return;
const scope = reviewActionScopeRef.current;
if (!(await reviewDraft.prepareSubmit())) return;
if (scope !== reviewActionScopeRef.current) return;
const preparedDraft = reviewDraft.currentDraft();
if (preparedDraft?.modelVersion === 2)
acceptanceComment = preparedDraft.problems.map((p) => `${reviewProblemLabel(p)}:${p.text}`).join("\n");
if (reviewSessionItem && !reviewSession.writable) {
setError("本页没有审查编辑权,请接管后继续。");
return;
}
if (decision === "approved" && (reviewDraft.draft?.problems.length || 0) > 0) {
if (decision === "approved" && (preparedDraft?.problems.length || 0) > 0) {
setError("请先处理已保存的问题,再通过验收。");
return;
}
@ -3765,11 +3776,10 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
setError("请填写视频质量、总体等级,以及 0–100 的标注准确性和完整性后再确认。");
return;
}
if (decision === "rejected" && !acceptanceComment.trim()) {
if (decision === "rejected" && !preparedDraft?.problems.length && !acceptanceComment.trim()) {
setError("整包验收不通过必须填写问题说明。");
return;
}
const scope = reviewActionScopeRef.current;
setSaving(true);
setError("");
try {
@ -3814,8 +3824,8 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
}
: undefined,
},
draftVersion: reviewDraft.draft?.version ?? 0,
resultVersion: reviewDraft.draft?.resultVersion || "",
draftVersion: preparedDraft?.version ?? 0,
resultVersion: preparedDraft?.resultVersion || "",
},
};
const result = reviewReceiptSupported
@ -5466,6 +5476,7 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
mine={mine}
writeLocked={reviewWriteLocked || Boolean(reviewDecision.pending)}
reviewProblemPanel={reviewProblemPanel}
onReviewNavigate={reviewDraft.onNavigate}
onReviewPositionChange={reviewDraft.onPosition}
onReviewController={reviewDraft.onController}
onReviewProblem={reviewDraft.beginProblem}
@ -5753,6 +5764,7 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
reviewMode={workspaceMode === "acceptance" ? "acceptance" : "quality"}
reviewWriteLocked={reviewWriteLocked || Boolean(reviewDecision.pending)}
reviewProblemPanel={reviewProblemPanel}
onReviewNavigate={reviewDraft.onNavigate}
onReviewPositionChange={reviewDraft.onPosition}
onReviewController={reviewDraft.onController}
onReviewProblem={reviewDraft.beginProblem}
@ -6132,6 +6144,12 @@ export default function AnnotationOperations({ workPage = false }: { workPage?:
<ReviewDecisionDialog
decision={reviewDecision}
canSubmit={reviewSession.writable && !viewportPaused && !reviewDraft.dirty}
problems={reviewDraft.draft?.problems || []}
problemLabel={reviewProblemLabel}
onProblem={(problem) => {
reviewDecision.cancel();
reviewDraft.selectProblem(problem, reviewProblemNavigationSlice(problem));
}}
/>
</>
);

View File

@ -23,6 +23,8 @@ export type ReviewProblem = {
};
};
export type ReviewDraft = {
modelVersion?: number;
legacyBackupId?: string;
itemId: string;
stageId: string;
reviewRound: number;
@ -33,11 +35,19 @@ export type ReviewDraft = {
updatedAt: string;
};
export const reviewDraftApi = {
history: (itemId: string) =>
apiRequest<{ problems: ReviewProblem[] }>(`/api/human-items/${encodeURIComponent(itemId)}/review-draft?history=1`),
get: (itemId: string) =>
apiRequest<{ draft: ReviewDraft }>(`/api/human-items/${encodeURIComponent(itemId)}/review-draft`),
save: (
itemId: string,
payload: { version: number; resultVersion: string; operationId: string; problems: ReviewProblem[] },
payload: {
modelVersion?: number;
version: number;
resultVersion: string;
operationId: string;
problems: ReviewProblem[];
},
headers: HeadersInit,
) =>
apiRequest<{ draft: ReviewDraft }>(

View File

@ -0,0 +1,93 @@
import { useEffect, useRef, useState } from "react";
import { useReviewDraft } from "../../../src/hooks/useReviewDraft";
import { ReviewProblemPanel } from "../../../src/components/ReviewProblemPanel";
import type { ReviewPosition, ReviewViewingController } from "../../../src/components/review-viewing";
import { reviewShortcut } from "../../../src/lib/review-shortcuts.js";
const position = (id: string): ReviewPosition => ({
time: id === "a" ? 1 : 6,
timeBasis: "capture-seconds",
sliceId: id,
actionId: id + "-action",
navigationSliceId: id,
selectedActionId: id + "-action",
});
export function ReviewOpinionHarness() {
const work = useRef<HTMLDivElement>(null),
pos = useRef(position("a"));
const [result, setResult] = useState("");
const review = useReviewDraft("synthetic-opinion", "synthetic-user", true, {
writable: true,
snapshot: {
itemId: "synthetic-opinion",
stageId: "quality_review",
reviewRound: 1,
resultVersion: "v1",
generation: 1,
expiresAt: "",
writable: true,
busy: false,
},
headers: () => ({}),
handleError: () => {},
});
const latest = useRef(review);
latest.current = review;
useEffect(() => {
const c: ReviewViewingController = {
pause: () => {},
focus: () => work.current?.focus(),
pauseAndLocate: () => pos.current,
playPause: () => {},
step: () => {},
navigateSlice: () => {},
navigateAction: () => {},
reviewSlice: () => {},
showHelp: () => {},
seekAction: () => true,
seekSlice: (id) => {
pos.current = position(id);
queueMicrotask(() => latest.current.onPosition(pos.current));
return true;
},
seekTime: () => {},
};
review.onController(c);
review.onPosition(pos.current);
}, [review.onPosition]);
const navigate = (id: string, user = true) => {
if (user) review.onNavigate();
pos.current = position(id);
review.onPosition(pos.current);
work.current?.focus();
};
return (
<div
ref={work}
tabIndex={-1}
data-testid="opinion-workbench"
onKeyDown={(e) => {
const editable = (e.target as HTMLElement).matches("textarea,input");
const command = reviewShortcut(e.nativeEvent, { editable, noteInput: editable });
if (!command) return;
e.preventDefault();
if (command === "problem") review.beginProblem();
if (command === "previous-problem") review.navigateSelection(-1);
if (command === "next-problem") review.navigateSelection(1);
if (command === "edit-problem") review.editSelected();
if (command === "delete-problem") review.requestDelete();
if (command === "escape") review.escape();
}}
>
<button onClick={() => navigate("a")}>观看 A</button>
<button onClick={() => navigate("b")}>观看 B</button>
<button onClick={() => navigate("b", false)}>播放经过 B</button>
<button onClick={async () => setResult((await review.prepareSubmit()) ? "ready" : "blocked")}>准备提交</button>
<output>{result}</output>
<ReviewProblemPanel
review={review}
label={(p) => (p.scope === "task" ? "整体" : `${p.scope}:${p.sliceId}:${p.actionId || ""}`)}
/>
</div>
);
}

View File

@ -0,0 +1,195 @@
// Real React hook/panel with deterministic transport interruptions; no customer data.
import { chromium } from "playwright";
import assert from "node:assert/strict";
const browser = await chromium.launch({
executablePath: "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
headless: true,
});
const page = await browser.newPage();
page.on("pageerror", (e) => console.error(e.message));
page.on("console", (m) => {
if (m.type() === "error") console.error(m.text());
});
page.setDefaultTimeout(30000);
let draft = {
itemId: "synthetic-opinion",
stageId: "quality_review",
reviewRound: 1,
resultVersion: "v1",
version: 0,
problems: [],
};
let writes = [],
hold = null,
fail = false,
unknown = false;
let reached;
await page.route("**/api/human-items/synthetic-opinion/review-draft", async (route) => {
if (route.request().method() === "GET") return route.fulfill({ json: { draft } });
const p = route.request().postDataJSON();
writes.push(p);
if (reached) reached();
if (hold) await hold;
if (fail) {
fail = false;
return route.fulfill({ status: 409, json: { code: "review_draft_version_conflict", error: "意见已更新" } });
}
if (p.version !== draft.version)
return route.fulfill({ status: 409, json: { code: "review_draft_version_conflict", error: "意见已更新" } });
draft = { ...draft, ...p, version: draft.version + 1 };
if (unknown) {
unknown = false;
return route.abort();
}
return route.fulfill({ json: { draft } });
});
await page.route("**/opinion-harness", (route) =>
route.fulfill({
contentType: "text/html",
body: `<html><body><div id="root"></div><script type="module">import RefreshRuntime from '/@react-refresh';RefreshRuntime.injectIntoGlobalHook(window);window.$RefreshReg$=()=>{};window.$RefreshSig$=()=>type=>type;window.__vite_plugin_react_preamble_installed__=true;const React=await import('/node_modules/.vite/deps/react.js');const D=await import('/node_modules/.vite/deps/react-dom_client.js');const {ReviewOpinionHarness}=await import('/tests/browser/fixtures/review-opinion-harness.tsx');(D.createRoot||D.default.createRoot)(document.getElementById('root')).render((React.createElement||React.default.createElement)(ReviewOpinionHarness));</script></body></html>`,
}),
);
const input = page.getByRole("textbox", { name: "审查问题说明" });
const card = (scope) => page.locator(`[data-opinion-scope=${scope}]`);
const wait = async (fn) => {
for (let i = 0; i < 100; i++) {
if (fn()) return;
await page.waitForTimeout(30);
}
throw Error("condition timeout");
};
try {
await page.goto("http://127.0.0.1:5173/opinion-harness", { waitUntil: "domcontentloaded" });
await card("slice").waitFor();
await card("slice").click();
await input.fill("A first");
let release;
hold = new Promise((r) => (release = r));
const sent = new Promise((r) => (reached = r));
await page.getByRole("button", { name: "观看 B", exact: true }).click();
await sent;
reached = null;
await card("slice").click();
await input.fill("B second");
await input.press("Control+Enter");
assert.equal(writes.length, 1, "serialized writer");
release();
hold = null;
await wait(() => draft.problems.length === 2);
await input.waitFor({ state: "hidden" });
assert.deepEqual(
draft.problems.map((p) => [p.sliceId, p.text]),
[
["a", "A first"],
["b", "B second"],
],
);
// While A is saving, further A typing must survive its old response.
await page.getByRole("button", { name: "观看 A", exact: true }).click();
await card("slice").click();
await input.fill("A sent");
hold = new Promise((r) => (release = r));
const sent2 = new Promise((r) => (reached = r));
await input.press("Control+Enter");
await sent2;
reached = null;
await input.fill("A newer");
release();
hold = null;
await wait(() => draft.problems.find((p) => p.sliceId === "a")?.text === "A sent");
await page.waitForTimeout(80);
assert.equal(await input.inputValue(), "A newer");
await input.press("Control+Enter");
await input.waitFor({ state: "hidden" });
assert.equal(draft.problems.find((p) => p.sliceId === "a").text, "A newer");
// Playback changes displayed cards but never retargets entered text.
await card("slice").click();
await input.fill("A playback");
await page.getByRole("button", { name: "播放经过 B" }).click();
assert.equal(await input.inputValue(), "A playback");
await input.press("Control+Enter");
await input.waitFor({ state: "hidden" });
assert.equal(draft.problems.find((p) => p.sliceId === "a").text, "A playback");
assert.equal(draft.problems.find((p) => p.sliceId === "b").text, "B second");
// Explicitly blank existing opinions require clear confirmation; cancel/Esc preserves server.
await card("slice").click();
await input.fill("");
await input.press("Control+Enter");
await page.getByRole("alertdialog").waitFor();
await page.keyboard.press("Escape");
assert.equal(draft.problems.find((p) => p.sliceId === "b").text, "B second");
await input.press("Escape");
// Network response lost after write: retry reads back success and does not repeat new IDs.
await card("task").click();
await input.fill("lost response");
unknown = true;
await input.press("Control+Enter");
await page.getByRole("alert").waitFor();
const count = writes.length;
await input.press("Escape");
await page.getByRole("button", { name: /有未保存文字/ }).click();
await input.press("Control+Enter");
await input.waitFor({ state: "hidden" });
assert.equal(writes.length, count);
// Same-object 409 preserves local text and waits for explicit confirmation.
await card("task").click();
await input.fill("my conflict");
fail = true;
draft = {
...draft,
version: draft.version + 1,
problems: draft.problems.map((p) => (p.scope === "task" ? { ...p, text: "other page" } : p)),
};
await input.press("Control+Enter");
await page.getByRole("alert").waitFor();
assert.equal(await input.inputValue(), "my conflict");
assert.equal(draft.problems.find((p) => p.scope === "task").text, "other page");
await input.press("Control+Enter");
await input.waitFor({ state: "hidden" });
assert.equal(draft.problems.find((p) => p.scope === "task").text, "my conflict");
// Legacy groups stay fully visible, cannot be submitted unconfirmed, no auto last-wins.
draft = {
...draft,
version: 30,
modelVersion: 0,
problems: [
{ id: "old1", scope: "task", text: "第一条完整原文", atSeconds: 0 },
{ id: "old2", scope: "task", text: "更正,实际没有问题", atSeconds: 0 },
],
};
await page.reload();
await page.getByText("第一条完整原文", { exact: false }).first().waitFor();
await page.getByRole("button", { name: "准备提交" }).click();
assert.equal(await page.locator("output").innerText(), "blocked");
await card("task").click();
assert.equal(await input.inputValue(), "第一条完整原文\n\n更正,实际没有问题");
await input.fill("核对后的最终意见");
await input.press("Control+Enter");
await input.waitFor({ state: "hidden" });
assert.equal(draft.problems.length, 1);
assert.equal(draft.problems[0].id, "old1");
await page.getByTestId("opinion-workbench").focus();
await page.keyboard.press("f");
await page.getByRole("radio", { name: "整体", exact: true }).click();
assert.equal(await input.inputValue(), "核对后的最终意见");
await input.press("Meta+Enter");
await input.waitFor({ state: "hidden" });
assert.equal(draft.problems.length, 1);
assert.equal(draft.problems[0].id, "old1");
console.log(
JSON.stringify({
passed: true,
checks: [
"queued A/B",
"newer text survives",
"playback fixed target",
"blank clear cancellation",
"unknown result recovery",
"409 explicit confirmation",
"legacy consolidation gate",
],
}),
);
} finally {
await browser.close();
}

View File

@ -0,0 +1,172 @@
// Actual HTTP application/API with transport failure injection only.
import { chromium } from "playwright";
import fs from "node:fs/promises";
import assert from "node:assert/strict";
const dir = process.env.REVIEW_DRAFT_FIXTURES || "local-data/verification/review-focused-20260922";
const base = process.env.REVIEW_DRAFT_URL || "http://127.0.0.1:5173";
const mode = process.env.REVIEW_DRAFT_MODE || "quality";
const hostname = new URL(base).hostname;
assert.ok(
["127.0.0.1", "localhost"].includes(hostname) || hostname.endsWith(".test"),
"This writer is limited to local test fixtures",
);
const fixtures = JSON.parse(await fs.readFile(`${dir}/fixture-index.json`, "utf8"));
const item = fixtures[mode][0];
const state = JSON.parse(
await fs.readFile(`${dir}/fixture-${mode === "quality" ? "qc" : "acceptance"}-auth.json`, "utf8"),
);
state.cookies = state.cookies.map((cookie) => ({ ...cookie, domain: hostname }));
const browser = await chromium.launch({
executablePath: process.env.BROWSER_EXECUTABLE || "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
headless: true,
args: [`--host-resolver-rules=MAP ${hostname} 127.0.0.1`, "--no-proxy-server"],
});
try {
const context = await browser.newContext({ storageState: state, viewport: { width: 1600, height: 1000 } });
const page = await context.newPage();
page.setDefaultTimeout(20000);
const errors = [];
page.on("pageerror", (e) => errors.push(e.message));
const url = `${base}/plugins/annotation-qa/workflows/all/${mode}?projectId=${fixtures.projectId}${item.taskId ? `&taskId=${item.taskId}` : ""}`;
const open = async (p) => {
await p.goto(url);
await p.getByRole("button", { name: /^我的任务/ }).click();
if (mode === "acceptance")
await p
.getByTestId("acceptance-task-card")
.first()
.getByRole("button", { name: "继续处理", exact: true })
.click();
await p
.getByRole("status")
.filter({ hasText: /本页可编辑审查意见|本页只读/ })
.waitFor();
const take = p.getByRole("button", { name: "在本页接管审查", exact: true });
if (await take.count()) await take.click();
await p.getByText("本页可编辑审查意见", { exact: true }).waitFor();
await p.locator("[data-opinion-scope=task]").waitFor();
};
await open(page);
const waitForPicture = async () => {
await page.waitForFunction(() => {
const videos = [...document.querySelectorAll("video")].filter((video) => video.getBoundingClientRect().width > 0);
return videos.length > 0 && videos.every((video) => video.readyState >= 2 && !video.seeking);
});
// 04 removed the raw-record JSON block; wait for the caption full text instead.
await page.getByLabel("当前画面标注原文").locator("p").first().waitFor();
};
const panel = page.getByRole("region", { name: "审查问题草稿" });
const input = page.getByRole("textbox", { name: "审查问题说明", exact: true });
const read = () =>
page.evaluate(async (id) => {
const r = await fetch(`/api/human-items/${id}/review-draft`);
if (!r.ok) throw Error(`readback ${r.status}`);
return r.json();
}, item.humanItemId);
const cards = panel.getByRole("option");
assert.equal(await cards.count(), 3);
await waitForPicture();
const text = "唯一意见 " + Date.now();
const save = async (value) => {
await input.fill(value);
await input.press("Control+Enter");
await input.waitFor({ state: "hidden" });
await page.waitForFunction(() => !document.querySelector('[aria-label="审查问题说明"]'));
};
await panel.locator("[data-opinion-scope=task]").click();
await save(text);
const first = (await read()).draft;
assert.equal(first.modelVersion, 2);
const taskOpinion = first.problems.filter((p) => p.scope === "task");
assert.equal(taskOpinion.length, 1);
const id = taskOpinion[0].id;
await panel.locator("[data-opinion-scope=task]").click();
assert.equal(await input.inputValue(), text);
await save(text + " revised");
const second = (await read()).draft;
assert.equal(second.problems.filter((p) => p.scope === "task").length, 1);
assert.equal(second.problems.find((p) => p.scope === "task").id, id);
// Selecting/editing another card saves the previous object in the background.
await panel.locator("[data-opinion-scope=task]").click();
await input.fill(text + " automatic");
await panel.locator("[data-opinion-scope=slice]").click();
await input.fill("切片意见 " + text);
await save("切片意见 " + text);
await page.waitForTimeout(300);
let draft = (await read()).draft;
assert.equal(draft.problems.find((p) => p.scope === "task").text, text + " automatic");
assert.ok(draft.problems.some((p) => p.scope === "slice" && p.text === "切片意见 " + text));
// Keyboard selection acts on cards without changing playback.
await page
.getByTestId("capture-annotation-workbench")
.first()
.getByRole("button", { name: "上一帧", exact: true })
.focus();
await page.keyboard.press("Control+ArrowUp");
await page.keyboard.press("Control+ArrowUp");
assert.equal(await panel.locator("[data-opinion-scope=task]").getAttribute("aria-selected"), "true");
await page.keyboard.press("Shift+Delete");
const confirm = panel.getByRole("alertdialog", { name: "确认清除意见" });
await confirm.waitFor();
await page.keyboard.press("Escape");
await confirm.waitFor({ state: "hidden" });
assert.ok((await read()).draft.problems.some((p) => p.id === id));
await page.keyboard.press("Shift+Delete");
await confirm.waitFor();
await confirm.getByRole("button", { name: "确认清除", exact: true }).click();
await page.waitForFunction(
async (id) =>
!(await (await fetch("/api/human-items/" + id + "/review-draft")).json()).draft.problems.some(
(p) => p.scope === "task",
),
item.humanItemId,
);
draft = (await read()).draft;
assert.ok(draft.problems.some((p) => p.scope === "slice"));
assert.match(await panel.locator("[data-opinion-scope=task]").innerText(), /无/);
if (mode === "acceptance") {
const nav = page.getByLabel("验收切片选择").getByRole("button");
await nav.nth(3).click();
await waitForPicture();
await page.waitForFunction(() =>
document.querySelector("[data-opinion-scope=slice]")?.textContent.includes("来源 2"),
);
await panel.locator("[data-opinion-scope=slice]").click();
await save("来源二独立意见 " + text);
draft = (await read()).draft;
const matching = draft.problems.filter((p) => p.scope === "slice" && p.sliceId === "review-slice-1");
assert.equal(new Set(matching.map((p) => p.sourceItemId)).size, 2, "same slice ID sources isolated");
await nav.nth(2).click();
await waitForPicture();
await page.waitForFunction(() =>
document.querySelector("[data-opinion-scope=action]")?.textContent.includes("当前无动作"),
);
assert.ok(await panel.locator("[data-opinion-scope=action]").isDisabled());
await nav.nth(0).click();
await waitForPicture();
}
await page.setViewportSize({ width: 1413, height: 615 });
const focus = page.getByRole("button", { name: "进入专注审查", exact: true });
if (await focus.count()) await focus.click();
assert.equal(await cards.count(), 3);
await page.screenshot({ path: `local-data/verification/review-single-opinion/${mode}-focus.png` });
assert.equal(errors.length, 0, errors.join("\n"));
console.log(
JSON.stringify({
mode,
passed: true,
version: draft.version,
checks: [
"unique-edit",
"auto-save-switch",
"three-cards",
"clear-cancel-confirm",
"focus-layout",
...(mode === "acceptance" ? ["cross-source-isolation", "discard-no-action"] : []),
],
}),
);
} finally {
await browser.close();
}