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() } }() }) }