droboticflow/internal/api/human_loop.go
2026-08-19 03:08:37 +08:00

1011 lines
39 KiB
Go

package api
import (
"context"
"net/http"
"sort"
"strconv"
"strings"
"time"
"droboticflow/internal/domain"
"github.com/go-chi/chi/v5"
)
type humanVersionRequest struct {
Version int `json:"version"`
}
type humanSubmissionRequest struct {
Version int `json:"version"`
SubmissionRef string `json:"submissionRef"`
Revision int `json:"revision"`
DurationSeconds int64 `json:"durationSeconds"`
}
type humanDecisionRequest struct {
Version int `json:"version"`
Decision domain.HumanDecision `json:"decision"`
ReviewedRevision int `json:"reviewedRevision"`
RejectTargets []string `json:"rejectTargets"`
ReasonCodes []string `json:"reasonCodes"`
Comment string `json:"comment"`
}
type humanReopenRequest struct {
ItemVersion int `json:"itemVersion"`
RejectVersion int `json:"rejectVersion"`
TargetStageID string `json:"targetStageId"`
Comment string `json:"comment"`
}
func parseHumanBatchQuery(request *http.Request) domain.HumanBatchQuery {
query := request.URL.Query()
return domain.HumanBatchQuery{
PluginID: query.Get("pluginId"), ProjectID: query.Get("projectId"), WorkflowID: query.Get("workflowId"),
RunID: query.Get("runId"), Status: domain.HumanBatchStatus(query.Get("status")),
}
}
func parseHumanItemQuery(request *http.Request) domain.HumanItemQuery {
query := request.URL.Query()
return domain.HumanItemQuery{
PluginID: query.Get("pluginId"), BatchID: query.Get("batchId"), ProjectID: query.Get("projectId"),
WorkflowID: query.Get("workflowId"), RunID: query.Get("runId"), CurrentStageID: query.Get("stageId"),
Status: domain.HumanItemStatus(query.Get("status")),
}
}
func parseHumanRejectQuery(request *http.Request) domain.HumanRejectQuery {
query := request.URL.Query()
return domain.HumanRejectQuery{
BatchID: query.Get("batchId"), ItemID: query.Get("itemId"), ProjectID: query.Get("projectId"),
WorkflowID: query.Get("workflowId"), RunID: query.Get("runId"), Status: domain.HumanRejectStatus(query.Get("status")),
}
}
func (server *server) handleHumanBatchesList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListHumanBatches(request.Context(), server.requestOrganizationID(request), parseHumanBatchQuery(request))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
for index := range items {
if err := server.flushHumanReleasePartitions(request.Context(), &items[index], false); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleHumanItemsList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListHumanItems(request.Context(), server.requestOrganizationID(request), parseHumanItemQuery(request))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
filtered := make([]domain.HumanItemRecord, 0, len(items))
for _, item := range items {
if server.canAccessHumanItem(request.Context(), request, item, "") {
filtered = append(filtered, item)
}
}
renderJSON(writer, http.StatusOK, map[string]any{"items": filtered})
}
func (server *server) humanItemDetail(ctx context.Context, item domain.HumanItemRecord) (map[string]any, error) {
batch, err := server.store.GetHumanBatch(ctx, item.BatchID)
if err != nil {
return nil, err
}
attempts, err := server.store.ListHumanStageAttempts(ctx, item.OrganizationID, item.ID)
if err != nil {
return nil, err
}
events, err := server.store.ListHumanEvents(ctx, item.OrganizationID, item.ID)
if err != nil {
return nil, err
}
rejects, err := server.store.ListHumanRejects(ctx, item.OrganizationID, domain.HumanRejectQuery{ItemID: item.ID})
if err != nil {
return nil, err
}
return map[string]any{"item": item, "batch": batch, "attempts": attempts, "events": events, "rejects": rejects}, nil
}
func (server *server) handleHumanItemGet(writer http.ResponseWriter, request *http.Request) {
item, ok := server.loadHumanItemForRequest(writer, request)
if !ok {
return
}
detail, err := server.humanItemDetail(request.Context(), *item)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, detail)
}
func (server *server) loadHumanItemForRequest(writer http.ResponseWriter, request *http.Request) (*domain.HumanItemRecord, bool) {
item, err := server.store.GetHumanItem(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return nil, false
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Human item not found"})
return nil, false
}
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "Human item") {
return nil, false
}
if !server.canAccessHumanItem(request.Context(), request, *item, "") {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "human workgroup access is required"})
return nil, false
}
return item, true
}
func humanStage(batch *domain.HumanBatchRecord, stageID string) (domain.HumanStageDefinition, int, bool) {
if batch == nil {
return domain.HumanStageDefinition{}, -1, false
}
for index, stage := range batch.Stages {
if stage.ID == stageID {
return stage, index, true
}
}
return domain.HumanStageDefinition{}, -1, false
}
func annotationRoleForHumanStage(stage domain.HumanStageDefinition) domain.AnnotationAssignmentRole {
switch stage.RequiredRole {
case "quality_reviewer":
return domain.AnnotationRoleQualityReviewer
case "acceptance_reviewer":
return domain.AnnotationRoleAcceptanceReviewer
default:
return domain.AnnotationRoleAnnotator
}
}
func (server *server) canAccessHumanItem(ctx context.Context, request *http.Request, item domain.HumanItemRecord, requiredRole domain.AnnotationAssignmentRole) bool {
principal, ok := currentPrincipal(request)
if !ok || principal == nil {
return false
}
if item.PluginID == "human-loop-core" {
return principal.User.Role == domain.UserRoleAdmin || principal.User.Role == domain.UserRoleQualityReviewer || principal.User.Role == domain.UserRoleAcceptanceReviewer || principal.User.Role == domain.UserRoleQAReviewer || principal.User.Role == domain.UserRoleAuditor
}
if annotationManager(principal) {
return true
}
memberships, err := server.annotationMembershipsForUser(ctx, item.OrganizationID, item.ProjectID, principal.User.ID)
if err != nil {
return false
}
legacy := domain.AnnotationTaskRecord{ProjectID: item.ProjectID, WorkgroupID: item.WorkgroupID, VendorID: item.VendorID}
if requiredRole != "" {
return membershipHasRole(memberships, legacy, requiredRole)
}
return membershipAllowsTask(memberships, legacy)
}
func (server *server) appendHumanEvent(ctx context.Context, item domain.HumanItemRecord, eventType string, actorID string, payload map[string]any) error {
return server.store.AppendHumanEvent(ctx, domain.HumanEventRecord{
OrganizationID: item.OrganizationID, BatchID: item.BatchID, ItemID: item.ID, StageID: item.CurrentStageID,
Round: item.ReviewRound, EventType: eventType, ActorUserID: actorID, ItemVersion: item.Version, Payload: payload,
})
}
func (server *server) humanItemForLegacyTask(ctx context.Context, task domain.AnnotationTaskRecord) (*domain.HumanItemRecord, error) {
items, err := server.store.ListHumanItems(ctx, task.OrganizationID, domain.HumanItemQuery{
PluginID: "annotation-qa", ProjectID: task.ProjectID, WorkflowID: task.WorkflowID, RunID: task.RunID,
})
if err != nil {
return nil, err
}
for index := range items {
if items[index].LegacyTaskID == task.ID {
copy := items[index]
return &copy, nil
}
}
return nil, nil
}
func (server *server) syncLegacyTaskFromHumanItem(ctx context.Context, item domain.HumanItemRecord) error {
if item.LegacyTaskID == "" {
return nil
}
task, err := server.store.GetAnnotationTask(ctx, item.LegacyTaskID)
if err != nil || task == nil {
return err
}
task.CurrentRevision = item.CurrentRevision
switch {
case item.Status == domain.HumanItemAccepted:
task.Status = domain.AnnotationTaskStatusAccepted
case item.Status == domain.HumanItemRejected:
task.Status = domain.AnnotationTaskStatusRejected
case item.Status == domain.HumanItemEscalated:
task.Status = domain.AnnotationTaskStatusRejected
case item.Status == domain.HumanItemRework:
task.Status = domain.AnnotationTaskStatusRework
case item.CurrentStageID == "quality_review":
task.Status = domain.AnnotationTaskStatusPendingQuality
case item.CurrentStageID == "acceptance":
task.Status = domain.AnnotationTaskStatusPendingAcceptance
default:
task.Status = domain.AnnotationTaskStatusPendingAnnotation
}
if err := server.store.UpsertAnnotationTask(ctx, *task); err != nil {
return err
}
if task.Status == domain.AnnotationTaskStatusAccepted {
return server.queueAcceptedAnnotationGateRun(ctx, *task)
}
return nil
}
func allowedHumanReopenStages(batch *domain.HumanBatchRecord, rejectedStageID string) []string {
_, rejectedIndex, found := humanStage(batch, rejectedStageID)
if !found {
return nil
}
items := make([]string, 0, rejectedIndex+1)
for index, stage := range batch.Stages {
if index > rejectedIndex {
break
}
if stage.Kind == domain.HumanStageAcceptance || stage.Kind == domain.HumanStageApproval {
continue
}
items = append(items, stage.ID)
}
return items
}
func containsHumanStage(items []string, target string) bool {
for _, item := range items {
if item == target {
return true
}
}
return false
}
func (server *server) syncLegacyAuditTaskFromHumanItem(ctx context.Context, item domain.HumanItemRecord) error {
if item.LegacyAuditTaskID == "" || (item.Status != domain.HumanItemAccepted && item.Status != domain.HumanItemRejected) {
return nil
}
task, err := server.store.GetAuditTask(ctx, item.LegacyAuditTaskID)
if err != nil || task == nil {
return err
}
if item.Status == domain.HumanItemAccepted {
task.Status = domain.AuditStatusApproved
} else {
task.Status = domain.AuditStatusRejected
}
task.UpdatedAt = nowISO()
if err := server.store.UpsertAuditTask(ctx, *task); err != nil {
return err
}
run, err := server.store.GetRun(ctx, task.RunID)
if err != nil || run == nil {
return err
}
run.Status = domain.RunStatusQueued
run.UpdatedAt = nowISO()
return server.store.UpsertRun(ctx, *run)
}
func (server *server) syncHumanItemFromLegacyRevision(ctx context.Context, task domain.AnnotationTaskRecord, revision domain.AnnotationRevisionRecord) error {
item, err := server.humanItemForLegacyTask(ctx, task)
if err != nil || item == nil {
return err
}
previousVersion := item.Version
item.CurrentRevision = revision.Revision
item.LatestAuthorUserID = revision.AuthorUserID
item.CurrentStageID = "quality_review"
item.Status = domain.HumanItemSubmitted
item.SubmittedAt = nowISO()
item.AssignedUserID = ""
item.Version++
updated, err := server.store.UpdateHumanItemVersioned(ctx, *item, previousVersion)
if err != nil || !updated {
return err
}
_ = server.store.UpsertHumanStageAttempt(ctx, domain.HumanStageAttemptRecord{
OrganizationID: item.OrganizationID, ItemID: item.ID, StageID: "semantic_annotation", Round: item.ReviewRound,
Status: domain.HumanItemSubmitted, AssigneeUserID: revision.AuthorUserID, SubmissionRef: revision.ID,
})
return server.appendHumanEvent(ctx, *item, "submitted", revision.AuthorUserID, map[string]any{
"submissionRef": revision.ID, "revision": revision.Revision, "stage": "semantic_annotation",
})
}
func (server *server) syncHumanItemFromLegacyReview(ctx context.Context, task domain.AnnotationTaskRecord, review domain.AnnotationReviewRecord, rejectTargets []string, reasonCodes []string) error {
item, err := server.humanItemForLegacyTask(ctx, task)
if err != nil || item == nil {
return err
}
batch, err := server.store.GetHumanBatch(ctx, item.BatchID)
if err != nil || batch == nil {
return err
}
previousVersion := item.Version
stageID := "quality_review"
if review.Stage == domain.AnnotationReviewStageAcceptance {
stageID = "acceptance"
}
item.CurrentStageID = stageID
if review.Decision == domain.AnnotationReviewApproved {
if review.Stage == domain.AnnotationReviewStageQuality {
item.Status = domain.HumanItemAccepted
item.AcceptedAt = nowISO()
} else {
item.Status = domain.HumanItemAccepted
item.AcceptedAt = nowISO()
}
} else {
allowed := allowedHumanReopenStages(batch, stageID)
if len(rejectTargets) == 0 {
rejectTargets = allowed
}
for _, target := range rejectTargets {
if !containsHumanStage(allowed, target) {
return nil
}
}
item.Status = domain.HumanItemRejected
item.RejectedAt = nowISO()
}
if item.Status != domain.HumanItemRejected {
item.AssignedUserID = ""
}
item.Version++
updated, err := server.store.UpdateHumanItemVersioned(ctx, *item, previousVersion)
if err != nil || !updated {
return err
}
_ = server.store.UpsertHumanBatch(ctx, *batch)
if len(reasonCodes) == 0 && review.Decision == domain.AnnotationReviewRejected {
reasonCodes = []string{"legacy_reject"}
}
_ = server.store.UpsertHumanStageAttempt(ctx, domain.HumanStageAttemptRecord{
OrganizationID: item.OrganizationID, ItemID: item.ID, StageID: stageID, Round: item.ReviewRound,
Status: item.Status, AssigneeUserID: review.ReviewerUserID, ReviewedRevision: review.Revision,
Decision: domain.HumanDecision(review.Decision), RejectTargets: rejectTargets, ReasonCodes: reasonCodes, Comment: review.Comment,
})
if review.Decision == domain.AnnotationReviewRejected {
_ = server.store.UpsertHumanReject(ctx, domain.HumanRejectRecord{
OrganizationID: item.OrganizationID, BatchID: item.BatchID, ItemID: item.ID, ProjectID: item.ProjectID,
WorkflowID: item.WorkflowID, RunID: item.RunID, StageID: stageID, AttemptRound: item.ReviewRound,
ReviewedRevision: review.Revision, RejectedByUserID: review.ReviewerUserID, ReasonCodes: reasonCodes,
Comment: review.Comment, AllowedReopenStages: allowedHumanReopenStages(batch, stageID), Status: domain.HumanRejectOpen,
})
}
eventType := string(review.Decision)
if err := server.appendHumanEvent(ctx, *item, eventType, review.ReviewerUserID, map[string]any{
"reviewedRevision": review.Revision, "rejectTargets": rejectTargets, "reasonCodes": reasonCodes,
"comment": review.Comment, "source": "annotation-qa",
}); err != nil {
return err
}
if item.Status == domain.HumanItemAccepted {
return server.flushHumanReleasePartitions(ctx, batch, false)
}
return nil
}
func (server *server) handleHumanItemClaim(writer http.ResponseWriter, request *http.Request) {
item, ok := server.loadHumanItemForRequest(writer, request)
if !ok {
return
}
var payload humanVersionRequest
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Version != item.Version {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item version conflict", "code": "version_conflict"})
return
}
batch, err := server.store.GetHumanBatch(request.Context(), item.BatchID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if batch == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Human batch not found"})
return
}
stage, _, found := humanStage(batch, item.CurrentStageID)
if !found {
renderJSON(writer, http.StatusUnprocessableEntity, map[string]string{"error": "Human stage is not configured"})
return
}
if !server.canAccessHumanItem(request.Context(), request, *item, annotationRoleForHumanStage(stage)) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "human stage role is required"})
return
}
if item.Status != domain.HumanItemReady && item.Status != domain.HumanItemRework && item.Status != domain.HumanItemSubmitted {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item cannot be claimed from current status"})
return
}
principal, _ := currentPrincipal(request)
previousVersion := item.Version
item.AssignedUserID = principal.User.ID
item.Status = domain.HumanItemClaimed
item.ClaimedAt = nowISO()
item.Version++
updated, err := server.store.UpdateHumanItemVersioned(request.Context(), *item, previousVersion)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if !updated {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item version conflict", "code": "version_conflict"})
return
}
attempt := domain.HumanStageAttemptRecord{
OrganizationID: item.OrganizationID, ItemID: item.ID, StageID: item.CurrentStageID, Round: item.ReviewRound,
Status: domain.HumanItemClaimed, AssigneeUserID: principal.User.ID,
}
if err := server.store.UpsertHumanStageAttempt(request.Context(), attempt); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
_ = server.appendHumanEvent(request.Context(), *item, "claimed", principal.User.ID, nil)
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleHumanItemSubmission(writer http.ResponseWriter, request *http.Request) {
item, ok := server.loadHumanItemForRequest(writer, request)
if !ok {
return
}
var payload humanSubmissionRequest
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Version != item.Version {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item version conflict", "code": "version_conflict"})
return
}
batch, err := server.store.GetHumanBatch(request.Context(), item.BatchID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if batch == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Human batch not found"})
return
}
stage, stageIndex, found := humanStage(batch, item.CurrentStageID)
if !found || stage.Kind != domain.HumanStageAnnotation {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Current human stage does not accept annotation submissions"})
return
}
principal, _ := currentPrincipal(request)
if !server.canAccessHumanItem(request.Context(), request, *item, annotationRoleForHumanStage(stage)) || (item.AssignedUserID != "" && item.AssignedUserID != principal.User.ID && !annotationManager(principal)) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "Human item assignee permission required"})
return
}
if item.Status != domain.HumanItemClaimed && item.Status != domain.HumanItemInProgress && item.Status != domain.HumanItemRework {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item cannot be submitted from current status"})
return
}
if strings.TrimSpace(payload.SubmissionRef) == "" || payload.Revision <= 0 {
renderValidationError(writer,
validationIssue{Field: "submissionRef", Message: "submissionRef is required"},
validationIssue{Field: "revision", Message: "revision must be positive"},
)
return
}
previousStage := item.CurrentStageID
previousVersion := item.Version
item.CurrentRevision = payload.Revision
item.LatestAuthorUserID = principal.User.ID
item.SubmittedAt = nowISO()
if stageIndex+1 >= len(batch.Stages) {
item.Status = domain.HumanItemAccepted
item.AcceptedAt = nowISO()
} else {
item.CurrentStageID = batch.Stages[stageIndex+1].ID
item.Status = domain.HumanItemReady
if batch.Stages[stageIndex+1].Kind == domain.HumanStageReview || batch.Stages[stageIndex+1].Kind == domain.HumanStageAcceptance {
item.Status = domain.HumanItemSubmitted
}
}
item.AssignedUserID = ""
item.Version++
updated, err := server.store.UpdateHumanItemVersioned(request.Context(), *item, previousVersion)
if err != nil || !updated {
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
} else {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item version conflict", "code": "version_conflict"})
}
return
}
_ = server.store.UpsertHumanStageAttempt(request.Context(), domain.HumanStageAttemptRecord{
OrganizationID: item.OrganizationID, ItemID: item.ID, StageID: previousStage, Round: item.ReviewRound,
Status: domain.HumanItemSubmitted, AssigneeUserID: principal.User.ID, SubmissionRef: payload.SubmissionRef,
})
_ = server.appendHumanEvent(request.Context(), *item, "submitted", principal.User.ID, map[string]any{
"submissionRef": payload.SubmissionRef, "revision": payload.Revision, "durationSeconds": payload.DurationSeconds,
})
if err := server.syncLegacyTaskFromHumanItem(request.Context(), *item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, item)
}
func earliestRejectTarget(batch *domain.HumanBatchRecord, allowed []string, requested []string) (string, bool) {
allowedSet := make(map[string]struct{}, len(allowed))
for _, item := range allowed {
allowedSet[item] = struct{}{}
}
requestedSet := make(map[string]struct{}, len(requested))
for _, item := range requested {
if _, ok := allowedSet[item]; !ok {
return "", false
}
requestedSet[item] = struct{}{}
}
for _, stage := range batch.Stages {
if _, ok := requestedSet[stage.ID]; ok {
return stage.ID, true
}
}
return "", false
}
func (server *server) handleHumanItemDecision(writer http.ResponseWriter, request *http.Request) {
item, ok := server.loadHumanItemForRequest(writer, request)
if !ok {
return
}
var payload humanDecisionRequest
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Version != item.Version {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item version conflict", "code": "version_conflict"})
return
}
batch, err := server.store.GetHumanBatch(request.Context(), item.BatchID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if batch == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Human batch not found"})
return
}
stage, stageIndex, found := humanStage(batch, item.CurrentStageID)
if !found || (stage.Kind != domain.HumanStageReview && stage.Kind != domain.HumanStageAcceptance && stage.Kind != domain.HumanStageApproval) {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Current human stage does not accept decisions"})
return
}
principal, _ := currentPrincipal(request)
if !server.canAccessHumanItem(request.Context(), request, *item, annotationRoleForHumanStage(stage)) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "Human review role is required"})
return
}
if item.LatestAuthorUserID != "" && item.LatestAuthorUserID == principal.User.ID {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "A submitter cannot review their own annotation", "code": "separation_of_duties"})
return
}
if item.Status != domain.HumanItemSubmitted && item.Status != domain.HumanItemClaimed {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item cannot be reviewed from current status"})
return
}
if payload.Decision != domain.HumanDecisionApproved && payload.Decision != domain.HumanDecisionRejected {
renderValidationError(writer, validationIssue{Field: "decision", Message: "decision must be approved or rejected"})
return
}
previousStage := item.CurrentStageID
previousVersion := item.Version
eventType := string(payload.Decision)
if payload.Decision == domain.HumanDecisionApproved {
if stageIndex+1 >= len(batch.Stages) {
item.Status = domain.HumanItemAccepted
item.AcceptedAt = nowISO()
} else {
item.CurrentStageID = batch.Stages[stageIndex+1].ID
item.Status = domain.HumanItemSubmitted
if batch.Stages[stageIndex+1].Kind == domain.HumanStageAnnotation {
item.Status = domain.HumanItemReady
}
}
} else {
if len(payload.ReasonCodes) == 0 || strings.TrimSpace(payload.Comment) == "" {
renderValidationError(writer,
validationIssue{Field: "reasonCodes", Message: "at least one reason code is required for rejection"},
validationIssue{Field: "comment", Message: "comment is required for rejection"},
)
return
}
allowedReopenStages := allowedHumanReopenStages(batch, previousStage)
for _, target := range payload.RejectTargets {
if !containsHumanStage(allowedReopenStages, target) {
renderValidationError(writer, validationIssue{Field: "rejectTargets", Message: "rejectTargets must contain only current or earlier reopen stages"})
return
}
}
item.Status = domain.HumanItemRejected
item.RejectedAt = nowISO()
}
item.Version++
updated, err := server.store.UpdateHumanItemVersioned(request.Context(), *item, previousVersion)
if err != nil || !updated {
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
} else {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item version conflict", "code": "version_conflict"})
}
return
}
_ = server.store.UpsertHumanBatch(request.Context(), *batch)
_ = server.store.UpsertHumanStageAttempt(request.Context(), domain.HumanStageAttemptRecord{
OrganizationID: item.OrganizationID, ItemID: item.ID, StageID: previousStage, Round: item.ReviewRound,
Status: item.Status, AssigneeUserID: principal.User.ID, ReviewedRevision: payload.ReviewedRevision,
Decision: payload.Decision, RejectTargets: payload.RejectTargets, ReasonCodes: payload.ReasonCodes, Comment: strings.TrimSpace(payload.Comment),
})
if payload.Decision == domain.HumanDecisionRejected {
allowedReopenStages := allowedHumanReopenStages(batch, previousStage)
if err := server.store.UpsertHumanReject(request.Context(), domain.HumanRejectRecord{
OrganizationID: item.OrganizationID, BatchID: item.BatchID, ItemID: item.ID, ProjectID: item.ProjectID,
WorkflowID: item.WorkflowID, RunID: item.RunID, StageID: previousStage, AttemptRound: item.ReviewRound,
ReviewedRevision: payload.ReviewedRevision, RejectedByUserID: principal.User.ID, ReasonCodes: payload.ReasonCodes,
Comment: strings.TrimSpace(payload.Comment), AllowedReopenStages: allowedReopenStages, Status: domain.HumanRejectOpen,
}); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
}
_ = server.appendHumanEvent(request.Context(), *item, eventType, principal.User.ID, map[string]any{
"decision": payload.Decision, "reviewedRevision": payload.ReviewedRevision, "rejectTargets": payload.RejectTargets,
"reasonCodes": payload.ReasonCodes, "comment": strings.TrimSpace(payload.Comment),
})
if err := server.syncLegacyTaskFromHumanItem(request.Context(), *item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if err := server.syncLegacyAuditTaskFromHumanItem(request.Context(), *item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item.Status == domain.HumanItemAccepted {
_ = server.flushHumanReleasePartitions(request.Context(), batch, false)
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleHumanRejectsList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListHumanRejects(request.Context(), server.requestOrganizationID(request), parseHumanRejectQuery(request))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) handleHumanRejectGet(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetHumanReject(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Human reject record not found"})
return
}
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "Human reject record") {
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleHumanRejectReopen(writer http.ResponseWriter, request *http.Request) {
reject, err := server.store.GetHumanReject(request.Context(), chi.URLParam(request, "id"))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if reject == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Human reject record not found"})
return
}
if !server.ensureTenantAccess(writer, request, reject.OrganizationID, "Human reject record") {
return
}
var payload humanReopenRequest
if !decodeJSON(writer, request, &payload) {
return
}
if reject.Version != payload.RejectVersion {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human reject version conflict", "code": "version_conflict"})
return
}
if reject.Status != domain.HumanRejectOpen {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human reject record is not open", "code": "reject_not_open"})
return
}
if !containsHumanStage(reject.AllowedReopenStages, strings.TrimSpace(payload.TargetStageID)) {
renderValidationError(writer, validationIssue{Field: "targetStageId", Message: "targetStageId must be an allowed current or earlier stage"})
return
}
if strings.TrimSpace(payload.Comment) == "" {
renderValidationError(writer, validationIssue{Field: "comment", Message: "comment is required when reopening rejected work"})
return
}
item, err := server.store.GetHumanItem(request.Context(), reject.ItemID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
server.reopenRejectedDeliveryPackage(writer, request, reject, payload)
return
}
if item.Version != payload.ItemVersion {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item version conflict", "code": "version_conflict"})
return
}
if item.Status != domain.HumanItemRejected {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item is not in the reject zone", "code": "item_not_rejected"})
return
}
principal, _ := currentPrincipal(request)
previousItemVersion := item.Version
item.ReviewRound++
item.Version++
item.RejectedAt = ""
eventType := "reopened"
if item.ReviewRound > item.MaxReworkRounds {
item.Status = domain.HumanItemEscalated
reject.Status = domain.HumanRejectEscalated
eventType = "escalated"
if batch, loadErr := server.store.GetHumanBatch(request.Context(), item.BatchID); loadErr == nil && batch != nil {
batch.Status = domain.HumanBatchBlocked
_ = server.store.UpsertHumanBatch(request.Context(), *batch)
}
} else {
item.CurrentStageID = strings.TrimSpace(payload.TargetStageID)
item.Status = domain.HumanItemRework
item.AssignedUserID = item.LatestAuthorUserID
reject.Status = domain.HumanRejectReopened
}
updated, err := server.store.UpdateHumanItemVersioned(request.Context(), *item, previousItemVersion)
if err != nil || !updated {
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
} else {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item version conflict", "code": "version_conflict"})
}
return
}
previousRejectVersion := reject.Version
reject.Version++
reject.ReopenCount++
reject.ReopenedByUserID = principal.User.ID
reject.ReopenTargetStageID = strings.TrimSpace(payload.TargetStageID)
reject.ReopenComment = strings.TrimSpace(payload.Comment)
reject.ReopenedAt = nowISO()
updated, err = server.store.UpdateHumanRejectVersioned(request.Context(), *reject, previousRejectVersion)
if err != nil || !updated {
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
} else {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human reject version conflict", "code": "version_conflict"})
}
return
}
_ = server.store.UpsertHumanStageAttempt(request.Context(), domain.HumanStageAttemptRecord{
OrganizationID: item.OrganizationID, ItemID: item.ID, StageID: item.CurrentStageID, Round: item.ReviewRound,
Status: item.Status, AssigneeUserID: item.AssignedUserID,
})
_ = server.appendHumanEvent(request.Context(), *item, eventType, principal.User.ID, map[string]any{
"rejectId": reject.ID, "targetStageId": payload.TargetStageID, "comment": strings.TrimSpace(payload.Comment),
})
if err := server.syncLegacyTaskFromHumanItem(request.Context(), *item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"item": item, "reject": reject})
}
func (server *server) reopenRejectedDeliveryPackage(writer http.ResponseWriter, request *http.Request, reject *domain.HumanRejectRecord, payload humanReopenRequest) {
item, err := server.store.GetDeliveryPackage(request.Context(), reject.ItemID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if item == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Rejected human item or delivery package not found"})
return
}
if item.Version != payload.ItemVersion {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Delivery package version conflict", "code": "version_conflict"})
return
}
if item.Status != domain.DeliveryPackageRejected {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Delivery package is not rejected", "code": "package_not_rejected"})
return
}
principal, _ := currentPrincipal(request)
reopened := make([]string, 0, len(item.ItemIDs))
for _, itemID := range item.ItemIDs {
humanItem, loadErr := server.store.GetHumanItem(request.Context(), itemID)
if loadErr != nil {
renderError(writer, http.StatusInternalServerError, loadErr)
return
}
if humanItem == nil {
continue
}
previousVersion := humanItem.Version
humanItem.ReviewRound++
humanItem.Version++
humanItem.AcceptedAt = ""
humanItem.ReleasePartitionID = ""
if humanItem.ReviewRound > humanItem.MaxReworkRounds {
humanItem.Status = domain.HumanItemEscalated
reject.Status = domain.HumanRejectEscalated
} else {
humanItem.CurrentStageID = strings.TrimSpace(payload.TargetStageID)
humanItem.Status = domain.HumanItemRework
humanItem.AssignedUserID = humanItem.LatestAuthorUserID
reject.Status = domain.HumanRejectReopened
}
updated, updateErr := server.store.UpdateHumanItemVersioned(request.Context(), *humanItem, previousVersion)
if updateErr != nil || !updated {
if updateErr != nil {
renderError(writer, http.StatusInternalServerError, updateErr)
} else {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human item version conflict", "code": "version_conflict"})
}
return
}
_ = server.appendHumanEvent(request.Context(), *humanItem, "reopened", principal.User.ID, map[string]any{"rejectId": reject.ID, "deliveryPackageId": item.ID, "targetStageId": payload.TargetStageID})
_ = server.syncLegacyTaskFromHumanItem(request.Context(), *humanItem)
reopened = append(reopened, humanItem.ID)
}
previousRejectVersion := reject.Version
reject.Version++
reject.ReopenCount++
reject.ReopenedByUserID = principal.User.ID
reject.ReopenTargetStageID = strings.TrimSpace(payload.TargetStageID)
reject.ReopenComment = strings.TrimSpace(payload.Comment)
reject.ReopenedAt = nowISO()
updated, err := server.store.UpdateHumanRejectVersioned(request.Context(), *reject, previousRejectVersion)
if err != nil || !updated {
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
} else {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Human reject version conflict", "code": "version_conflict"})
}
return
}
renderJSON(writer, http.StatusOK, map[string]any{"package": item, "reject": reject, "reopenedItemIds": reopened})
}
func (server *server) handleHumanItemEvents(writer http.ResponseWriter, request *http.Request) {
item, ok := server.loadHumanItemForRequest(writer, request)
if !ok {
return
}
items, err := server.store.ListHumanEvents(request.Context(), item.OrganizationID, item.ID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func parseISOTime(value string) time.Time {
parsed, _ := time.Parse(time.RFC3339Nano, value)
return parsed
}
func (server *server) flushHumanReleasePartitions(ctx context.Context, batch *domain.HumanBatchRecord, force bool) error {
if batch == nil || batch.Status == domain.HumanBatchBlocked {
return nil
}
items, err := server.store.ListHumanItems(ctx, batch.OrganizationID, domain.HumanItemQuery{BatchID: batch.ID})
if err != nil {
return err
}
accepted := make([]domain.HumanItemRecord, 0)
allTerminal := len(items) > 0
for _, item := range items {
if item.Status != domain.HumanItemAccepted && item.Status != domain.HumanItemRejected && item.Status != domain.HumanItemEscalated {
allTerminal = false
}
if item.Status == domain.HumanItemAccepted && item.ReleasePartitionID == "" {
accepted = append(accepted, item)
}
}
if len(accepted) == 0 {
return nil
}
sort.Slice(accepted, func(i, j int) bool { return accepted[i].AcceptedAt < accepted[j].AcceptedAt })
if batch.ReleasePolicy == domain.HumanReleaseAllAccepted && !allTerminal && !force {
return nil
}
oldest := parseISOTime(accepted[0].AcceptedAt)
waitExpired := !oldest.IsZero() && time.Since(oldest) >= time.Duration(batch.PartitionMaxWaitSeconds)*time.Second
if batch.ReleasePolicy == domain.HumanReleaseAcceptedPartition && len(accepted) < batch.PartitionMaxItems && !waitExpired && !allTerminal && !force {
return nil
}
limit := batch.PartitionMaxItems
if limit <= 0 || batch.ReleasePolicy == domain.HumanReleaseAllAccepted {
limit = len(accepted)
}
for len(accepted) > 0 {
count := limit
if count > len(accepted) {
count = len(accepted)
}
chunk := accepted[:count]
accepted = accepted[count:]
itemIDs := make([]string, 0, len(chunk))
for _, item := range chunk {
itemIDs = append(itemIDs, item.ID)
}
sort.Strings(itemIDs)
digest := domain.HumanReleaseManifestDigest(itemIDs)
sequence := batch.NextPartitionSequence + 1
uniqueKey := strings.Join([]string{batch.GateNodeID, strconv.Itoa(sequence), digest}, ":")
existing, err := server.store.GetReleasePartitionByUniqueKey(ctx, batch.OrganizationID, uniqueKey)
if err != nil {
return err
}
partition := domain.ReleasePartitionRecord{
OrganizationID: batch.OrganizationID, BatchID: batch.ID, GateNodeID: batch.GateNodeID, Sequence: sequence,
UniqueKey: uniqueKey, ManifestDigest: digest, ItemIDs: itemIDs, Status: domain.ReleasePartitionPending,
}
if existing != nil {
partition = *existing
} else if err := server.store.UpsertReleasePartition(ctx, partition); err != nil {
return err
}
stored, err := server.store.GetReleasePartitionByUniqueKey(ctx, batch.OrganizationID, uniqueKey)
if err != nil {
return err
}
if stored != nil {
partition = *stored
}
for index := range chunk {
previousVersion := chunk[index].Version
chunk[index].ReleasePartitionID = partition.ID
chunk[index].Version++
if _, err := server.store.UpdateHumanItemVersioned(ctx, chunk[index], previousVersion); err != nil {
return err
}
}
batch.NextPartitionSequence = sequence
batch.ReleasedCount += len(chunk)
}
batch.AcceptedCount = 0
for _, item := range items {
if item.Status == domain.HumanItemAccepted {
batch.AcceptedCount++
}
}
if allTerminal {
batch.Status = domain.HumanBatchCompleted
}
return server.store.UpsertHumanBatch(ctx, *batch)
}