droboticflow/internal/api/deleted_annotator.go
2026-11-11 03:51:18 -08:00

280 lines
9.7 KiB
Go

package api
import (
"context"
"errors"
"fmt"
"log"
"os"
"strings"
"sync"
"time"
"droboticflow/internal/domain"
)
func accountHandoffPolicyEnabled() bool {
return strings.EqualFold(strings.TrimSpace(os.Getenv("DELETED_ANNOTATOR_HANDOFF")), "true")
}
// The request is durable before sessions/claims are removed. Only new explicit
// deletions carry this marker; a restart does not bulk-rewrite historical users.
func (s *server) finishAccountDeletion(ctx context.Context, user domain.UserRecord) error {
if err := s.store.DeleteSessionsByUser(ctx, user.ID); err != nil {
return err
}
if user.Role == domain.UserRoleAnnotator && user.DeletionRequestedAt != "" {
if err := s.releaseDeletedAnnotatorTasks(ctx, user); err != nil {
return err
}
} else if _, err := s.releaseUserClaimedTasks(ctx, user.OrganizationID, user.ID, user.DeletionActorID); err != nil {
return err
}
members, err := s.store.ListProjectMembers(ctx, user.OrganizationID, "")
if err != nil {
return err
}
for _, member := range members {
if member.UserID == user.ID {
if _, err := s.store.DeleteProjectMember(ctx, member.ID); err != nil {
return err
}
}
}
current, err := s.store.GetUser(ctx, user.ID)
if err != nil {
return err
}
if current == nil || current.DeletedAt != "" {
return nil
}
before := *current
current.DeletedAt, current.DeletedBy, current.PasswordHash = nowISO(), user.DeletionActorID, ""
current.UpdatedAt = current.DeletedAt
return s.store.UpdateUser(ctx, *current, before)
}
func (s *server) releaseDeletedAnnotatorTasks(ctx context.Context, user domain.UserRecord) error {
items, err := s.store.ListHumanItems(ctx, user.OrganizationID, domain.HumanItemQuery{ActorUserID: user.ID})
if err != nil {
return err
}
var pending error
for _, item := range items {
if item.AssignedUserID != user.ID || !humanItemPending(item.Status) {
continue
}
if item.LegacyTaskID == "" {
previous := item.Version
item.AssignedUserID = ""
item.ClaimedAt = ""
if item.Status == domain.HumanItemClaimed || item.Status == domain.HumanItemInProgress {
item.Status = domain.HumanItemReady
}
item.Version++
ok, err := s.store.UpdateHumanItemVersioned(ctx, item, previous)
if err != nil {
pending = errors.Join(pending, err)
continue
}
if !ok {
pending = errors.Join(pending, fmt.Errorf("任务状态已变化,请重试"))
}
continue
}
if item.CurrentStageID != domain.FanyuV58StageAnnotationCombined {
switch item.CurrentStageID {
case "split_annotation", "cut_adjustment", "semantic_annotation":
pending = errors.Join(pending, fmt.Errorf("历史标注阶段需要核对交接,内容已保留"))
continue
default:
// Never turn an existing review-stage task into annotation.
continue
}
}
if err := s.handoffDeletedAnnotatorTask(ctx, item.ID, user); err != nil {
pending = errors.Join(pending, err)
}
}
return pending
}
func (s *server) handoffDeletedAnnotatorTask(ctx context.Context, id string, user domain.UserRecord) error {
for attempt := 0; attempt < 8; attempt++ {
item, err := s.store.GetHumanItem(ctx, id)
if err != nil {
return err
}
if item == nil || item.AssignedUserID != user.ID || item.CurrentStageID != domain.FanyuV58StageAnnotationCombined || !humanItemPending(item.Status) {
return nil
}
task, err := s.store.GetAnnotationTask(ctx, item.LegacyTaskID)
if err != nil {
return err
}
if task == nil {
return fmt.Errorf("删除交接的标注任务缺失")
}
if task.OrganizationID != item.OrganizationID || task.ProjectID != item.ProjectID || (task.SupplierID != "" && item.SupplierID != "" && task.SupplierID != item.SupplierID) {
return fmt.Errorf("删除交接的任务范围不一致,内容已保留")
}
if item.AccountHandoff == nil || !item.AccountHandoff.Pending {
// Successful submission/decision evidence wins over the current page.
reviewed := item.SubmittedAt != "" || item.ReviewRound > 0 || item.LatestAuthorUserID != ""
reviews, err := s.store.ListAnnotationReviews(ctx, item.OrganizationID, task.ID)
if err != nil {
return err
}
reviewed = reviewed || len(reviews) > 0
attempts, err := s.store.ListHumanStageAttempts(ctx, item.OrganizationID, item.ID)
if err != nil {
return err
}
for _, attempt := range attempts {
if attempt.StageID == domain.FanyuV58StageQualityReview || attempt.StageID == "acceptance" || attempt.StageID == "prepackage_acceptance" {
reviewed = true
}
}
annotations, err := s.store.ListAnnotationRevisions(ctx, item.OrganizationID, task.ID)
if err != nil {
return err
}
// A legacy published revision without a trustworthy handoff marker is
// ambiguous. Preserve it instead of guessing that it is safe to erase.
ambiguousRevision := task.CurrentRevision > 0
for _, revision := range annotations {
if revision.Revision > 0 && revision.AuthorUserID != "system" {
ambiguousRevision = true
}
}
knownSubmissionAttempt := item.ProcessingJob != nil && item.ProcessingJob.Kind == "submit"
if !reviewed && ambiguousRevision && item.PendingCombinedSubmissionID == "" && !knownSubmissionAttempt {
return fmt.Errorf("历史任务的送检阶段无法确认,已保留内容")
}
floor := max(task.AnnotationRevisionFloor, task.CurrentRevision, item.CurrentRevision, intValue(mapValue(item.Subject.Payload["sliceWorkflow"])["revision"]))
for _, revision := range annotations {
floor = max(floor, revision.Revision)
}
slices, err := s.store.ListSliceRevisions(ctx, item.OrganizationID, task.ID)
if err != nil {
return err
}
for _, revision := range slices {
floor = max(floor, revision.Revision)
}
if item.ProcessingJob != nil {
floor = max(floor, item.ProcessingJob.Revision)
}
previous := item.Version
item.AccountHandoff = &domain.AccountTaskHandoff{UserID: user.ID, ActorID: user.DeletionActorID, Reset: !reviewed, Pending: true, RevisionFloor: floor, At: nowISO()}
if !reviewed {
item.AnnotationEpoch++
// Source identity/configuration is retained; only editable results,
// local archives and classification choices are reset.
for _, key := range []string{"annotationWorkspace", "annotationDraft", "materialization", "sliceResetHistory", "sliceDispositionHistory", sliceRestoreEvidenceKey, sliceArchiveEditsKey, sliceMergeEvidenceKey, "dictionarySelectionHistory", "unconfirmedSliceNames", "lastSliceEditApplication", "preserveAnnotationRevisionHistory"} {
delete(item.Subject.Payload, key)
}
if item.Subject.Payload == nil {
item.Subject.Payload = map[string]any{}
}
item.Subject.Payload["sliceWorkflow"] = map[string]any{"status": "editing", "phase": "slice", "resetAt": item.AccountHandoff.At, "discardedWorkspace": true, "revision": floor}
item.CurrentRevision = 0
} else {
item.InheritedRework = true
}
// Removing the job ID fences heartbeat, completion and queued retries.
item.ProcessingJob = nil
item.PendingCombinedSubmissionID = ""
item.PendingCombinedPayloadSHA = ""
item.ClaimRequestID = ""
item.Version++
item.UpdatedAt = nowISO()
ok, err := s.store.UpdateHumanItemVersioned(ctx, *item, previous)
if err != nil {
return err
}
if !ok {
continue
}
}
h := item.AccountHandoff
if h.UserID != user.ID {
return fmt.Errorf("删除交接归属已变化")
}
if h.Reset {
task.AnnotationEpoch = item.AnnotationEpoch
task.AnnotationRevisionFloor = h.RevisionFloor
task.CurrentRevision = 0
task.AssignedUserID = ""
task.Status = domain.AnnotationTaskStatusPendingAnnotation
if err := s.store.ResetDeletedAnnotatorTask(ctx, *task); err != nil {
return err
}
}
// A deterministic audit key makes crash/retry idempotent.
if err := s.store.AppendHumanEvent(ctx, domain.HumanEventRecord{ID: fmt.Sprintf("deleted-annotator:%s:%s:%d", user.ID, id, item.AnnotationEpoch), OrganizationID: item.OrganizationID, BatchID: item.BatchID, ItemID: id, StageID: item.CurrentStageID, Round: item.ReviewRound, EventType: "deleted_annotator_handoff", ActorUserID: user.DeletionActorID, ItemVersion: item.Version, CreatedAt: h.At, Payload: map[string]any{"reset": h.Reset, "deletedUserId": user.ID}}); err != nil {
return err
}
previous := item.Version
item.AssignedUserID = ""
item.ClaimedAt = ""
item.AccountHandoff.Pending = false
if h.Reset {
item.Status = domain.HumanItemReady
} else {
item.Status = domain.HumanItemRework
}
item.Version++
item.UpdatedAt = nowISO()
ok, err := s.store.UpdateHumanItemVersioned(ctx, *item, previous)
if err != nil {
return err
}
if ok {
return nil
}
}
return fmt.Errorf("删除交接任务状态持续变化,请重试")
}
func (s *server) recoverAccountHandoffs(ctx context.Context) error {
users, err := s.store.ListUsers(ctx)
if err != nil {
return err
}
var first error
for _, user := range users {
if user.DeletionRequestedAt != "" && user.DeletedAt == "" && user.Status == domain.UserStatusDisabled {
if err := s.finishAccountDeletion(ctx, user); err != nil && first == nil {
first = err
}
}
}
if err := s.dispatchDeletedAuthorReworks(ctx); err != nil && first == nil {
first = err
}
return first
}
var accountHandoffRecoveryOnce sync.Once
func (s *server) startAccountHandoffRecovery() {
if !accountHandoffPolicyEnabled() || strings.HasSuffix(os.Args[0], ".test") {
return
}
accountHandoffRecoveryOnce.Do(func() {
go func() {
ticker := time.NewTicker(30 * time.Second)
defer ticker.Stop()
for range ticker.C {
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
if s.recoverAccountHandoffs(ctx) != nil {
log.Printf("[account-handoff] recovery incomplete")
}
cancel()
}
}()
})
}