droboticflow/internal/api/delivery_packages.go

401 lines
17 KiB
Go

package api
import (
"net/http"
"strings"
"droboticflow/internal/domain"
"github.com/go-chi/chi/v5"
)
type deliveryPackageDecisionRequest struct {
Version int `json:"version"`
Decision domain.HumanDecision `json:"decision"`
Comment string `json:"comment"`
VideoQuality string `json:"videoQuality,omitempty"`
AnnotationAccuracy float64 `json:"annotationAccuracy,omitempty"`
AnnotationCompleteness float64 `json:"annotationCompleteness,omitempty"`
OverallGrade string `json:"overallGrade,omitempty"`
ReasonCodes []string `json:"reasonCodes,omitempty"`
}
func parseDeliveryPackageQuery(request *http.Request) domain.DeliveryPackageQuery {
query := request.URL.Query()
return domain.DeliveryPackageQuery{
ProjectID: query.Get("projectId"),
WorkflowID: query.Get("workflowId"),
RunID: query.Get("runId"),
ReleasePartitionID: query.Get("releasePartitionId"),
Status: domain.DeliveryPackageStatus(query.Get("status")),
Mode: domain.RunMode(strings.TrimSpace(query.Get("mode"))),
}
}
func (server *server) handleDeliveryPackagesList(writer http.ResponseWriter, request *http.Request) {
items, err := server.store.ListDeliveryPackages(request.Context(), server.requestOrganizationID(request), parseDeliveryPackageQuery(request))
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
principal, _ := currentPrincipal(request)
for index := range items {
if err := server.enrichDeliveryPackageAcceptance(request, &items[index]); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
}
if !annotationManager(principal) {
filtered := items[:0]
for _, item := range items {
if server.deliveryPackageReviewer(request, item) {
filtered = append(filtered, item)
}
}
items = filtered
}
renderJSON(writer, http.StatusOK, map[string]any{"items": items})
}
func (server *server) deliveryPackageForReviewer(writer http.ResponseWriter, request *http.Request) (*domain.DeliveryPackageRecord, bool) {
item, err := server.store.GetDeliveryPackage(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": "Delivery package not found"})
return nil, false
}
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "Delivery package") {
return nil, false
}
if !server.deliveryPackageReviewer(request, *item) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "acceptance reviewer membership is required"})
return nil, false
}
return item, true
}
func deliveryPackageArtifactAllowed(item *domain.DeliveryPackageRecord, artifactID string) bool {
if item == nil || item.Status == domain.DeliveryPackageNoDeliverables || strings.TrimSpace(artifactID) == "" {
return false
}
for _, allowedID := range item.FinalExportArtifactIDs {
if allowedID == artifactID {
return true
}
}
return false
}
func (server *server) handleDeliveryPackageContents(writer http.ResponseWriter, request *http.Request) {
item, ok := server.deliveryPackageForReviewer(writer, request)
if !ok {
return
}
run, err := server.store.GetRun(request.Context(), item.ChildRunID)
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
if run == nil {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Delivery package Run not found"})
return
}
if item.Status == domain.DeliveryPackageNoDeliverables {
renderJSON(writer, http.StatusOK, map[string]any{"deliveryPackage": item, "artifacts": []domain.ExecutionArtifact{}, "manifest": map[string]any{"outcome": "no_deliverables", "message": "无可交付片段", "sliceCount": 0}})
return
}
allowed := make(map[string]struct{}, len(item.FinalExportArtifactIDs))
for _, artifactID := range item.FinalExportArtifactIDs {
allowed[artifactID] = struct{}{}
}
artifacts := make([]domain.ExecutionArtifact, 0, len(allowed))
var manifest map[string]any
for _, artifact := range run.Artifacts {
if _, exists := allowed[artifact.ID]; !exists || artifact.RunID != run.ID || domain.IsInternalDeliveryAudit(artifact) {
continue
}
copy := artifact
if copy.Data == nil {
copy.Data = make(map[string]any)
}
contentURL := "/api/delivery-packages/" + item.ID + "/artifacts/" + artifact.ID + "/content"
copy.Data["contentURL"] = contentURL
if copy.Type == domain.PortTypeVideo || (copy.Metadata != nil && strings.HasPrefix(strings.TrimSpace(copy.Metadata.MimeType), "video/")) {
preview := mapValue(copy.Data["preview"])
if preview == nil {
preview = make(map[string]any)
}
preview["kind"] = "video"
preview["url"] = contentURL
copy.Data["preview"] = preview
}
if copy.Name == "packages-manifest.json" {
manifest = artifactStructuredData(&artifact)
}
artifacts = append(artifacts, copy)
}
renderJSON(writer, http.StatusOK, map[string]any{"deliveryPackage": item, "artifacts": artifacts, "manifest": manifest})
}
func (server *server) handleDeliveryPackageArtifactContent(writer http.ResponseWriter, request *http.Request) {
item, ok := server.deliveryPackageForReviewer(writer, request)
if !ok {
return
}
artifactID := strings.TrimSpace(chi.URLParam(request, "artifactId"))
if !deliveryPackageArtifactAllowed(item, artifactID) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "artifact is not a final delivery output"})
return
}
server.serveRunArtifactContent(writer, request, item.ChildRunID, artifactID)
}
func (server *server) enrichDeliveryPackageAcceptance(request *http.Request, item *domain.DeliveryPackageRecord) error {
if item == nil || strings.TrimSpace(item.AcceptanceHumanItemID) == "" {
return nil
}
humanItem, err := server.store.GetHumanItem(request.Context(), item.AcceptanceHumanItemID)
if err != nil || humanItem == nil {
return err
}
item.AcceptanceHumanItemVersion = humanItem.Version
item.AssignedUserID = humanItem.AssignedUserID
item.ClaimedAt = humanItem.ClaimedAt
return nil
}
func (server *server) deliveryPackageReviewer(request *http.Request, item domain.DeliveryPackageRecord) bool {
principal, ok := currentPrincipal(request)
if !ok || principal == nil {
return false
}
if annotationManager(principal) {
return true
}
memberships, err := server.annotationMembershipsForUser(request.Context(), item.OrganizationID, item.ProjectID, principal.User.ID)
if err != nil {
return false
}
legacy := domain.AnnotationTaskRecord{ProjectID: item.ProjectID, SupplierID: item.SupplierID, WorkgroupID: item.WorkgroupID, VendorID: item.VendorID}
return membershipHasRole(memberships, legacy, domain.AnnotationRoleQualityReviewer)
}
func (server *server) handleDeliveryPackageClaim(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetDeliveryPackage(request.Context(), chi.URLParam(request, "id"))
if err != nil || item == nil {
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
} else {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Delivery package not found"})
}
return
}
if !server.deliveryPackageReviewer(request, *item) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "quality reviewer membership is required"})
return
}
var payload humanVersionRequest
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Version != item.Version || item.Status != domain.DeliveryPackagePendingAcceptance || item.AssignedUserID != "" {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Delivery package claim conflict", "code": "version_conflict"})
return
}
principal, _ := currentPrincipal(request)
previousVersion := item.Version
item.AssignedUserID, item.ClaimedAt, item.Version = principal.User.ID, nowISO(), item.Version+1
updated, updateErr := server.store.UpdateDeliveryPackageVersioned(request.Context(), *item, previousVersion)
if updateErr != nil || !updated {
if updateErr != nil {
renderError(writer, http.StatusInternalServerError, updateErr)
} else {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Delivery package claim conflict", "code": "version_conflict"})
}
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleDeliveryPackageRelease(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetDeliveryPackage(request.Context(), chi.URLParam(request, "id"))
if err != nil || item == nil {
if err != nil {
renderError(writer, http.StatusInternalServerError, err)
} else {
renderJSON(writer, http.StatusNotFound, map[string]string{"error": "Delivery package not found"})
}
return
}
var payload humanVersionRequest
if !decodeJSON(writer, request, &payload) {
return
}
principal, _ := currentPrincipal(request)
if principal == nil || (principal.User.Role != domain.UserRoleAdmin && item.AssignedUserID != principal.User.ID) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "only the claimant or administrator may release this package"})
return
}
if payload.Version != item.Version || item.AssignedUserID == "" {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Delivery package release conflict", "code": "version_conflict"})
return
}
previousVersion := item.Version
item.AssignedUserID, item.ClaimedAt, item.Version = "", "", item.Version+1
updated, updateErr := server.store.UpdateDeliveryPackageVersioned(request.Context(), *item, previousVersion)
if updateErr != nil || !updated {
if updateErr != nil {
renderError(writer, http.StatusInternalServerError, updateErr)
} else {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Delivery package release conflict", "code": "version_conflict"})
}
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleDeliveryPackageGet(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetDeliveryPackage(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": "Delivery package not found"})
return
}
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "Delivery package") {
return
}
if !server.deliveryPackageReviewer(request, *item) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "acceptance reviewer membership is required"})
return
}
if err := server.enrichDeliveryPackageAcceptance(request, item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
renderJSON(writer, http.StatusOK, item)
}
func (server *server) handleDeliveryPackageDecision(writer http.ResponseWriter, request *http.Request) {
item, err := server.store.GetDeliveryPackage(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": "Delivery package not found"})
return
}
if !server.ensureTenantAccess(writer, request, item.OrganizationID, "Delivery package") {
return
}
if !server.deliveryPackageReviewer(request, *item) {
renderJSON(writer, http.StatusForbidden, map[string]string{"error": "acceptance reviewer membership is required"})
return
}
if err := server.enrichDeliveryPackageAcceptance(request, item); err != nil {
renderError(writer, http.StatusInternalServerError, err)
return
}
var payload deliveryPackageDecisionRequest
if !decodeJSON(writer, request, &payload) {
return
}
if payload.Version != item.Version {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Delivery package version conflict", "code": "version_conflict"})
return
}
if item.Status != domain.DeliveryPackagePendingAcceptance {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Delivery package is not pending acceptance", "code": "package_not_pending"})
return
}
if payload.Decision != domain.HumanDecisionApproved && payload.Decision != domain.HumanDecisionRejected {
renderValidationError(writer, validationIssue{Field: "decision", Message: "decision must be approved or rejected"})
return
}
if payload.Decision == domain.HumanDecisionRejected && (strings.TrimSpace(payload.Comment) == "" || len(payload.ReasonCodes) == 0) {
renderValidationError(writer, validationIssue{Field: "rejection", Message: "reasonCodes and comment are required"})
return
}
principal, _ := currentPrincipal(request)
if item.AssignedUserID != principal.User.ID || strings.TrimSpace(item.AcceptanceHumanItemID) == "" {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "delivery package must be claimed before decision", "code": "package_not_claimed"})
return
}
acceptanceItem, acceptanceErr := server.store.GetHumanItem(request.Context(), item.AcceptanceHumanItemID)
if acceptanceErr != nil {
renderError(writer, http.StatusInternalServerError, acceptanceErr)
return
}
if acceptanceItem == nil || acceptanceItem.AssignedUserID != principal.User.ID || (acceptanceItem.Status != domain.HumanItemClaimed && acceptanceItem.Status != domain.HumanItemInProgress) {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "delivery package acceptance item must be claimed before decision", "code": "package_not_claimed"})
return
}
review := domain.DeliveryPackageAcceptanceReview{ID: domain.NewID("package-acceptance"), Decision: payload.Decision, ReviewerUserID: principal.User.ID, Comment: strings.TrimSpace(payload.Comment), VideoQuality: strings.TrimSpace(payload.VideoQuality), AnnotationAccuracy: payload.AnnotationAccuracy, AnnotationCompleteness: payload.AnnotationCompleteness, OverallGrade: strings.TrimSpace(payload.OverallGrade), ReasonCodes: payload.ReasonCodes, CreatedAt: nowISO()}
previousVersion := item.Version
item.Version++
item.AcceptanceReviews = append(item.AcceptanceReviews, review)
if payload.Decision == domain.HumanDecisionApproved {
item.Status = domain.DeliveryPackageAccepted
item.FinalExportArtifactIDs = append([]string(nil), item.ArtifactIDs...)
if strings.TrimSpace(item.FinalExportedAt) == "" {
item.FinalExportedAt = nowISO()
}
} else {
item.Status = domain.DeliveryPackageRejected
}
updated, err := server.store.UpdateDeliveryPackageVersioned(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": "Delivery package version conflict", "code": "version_conflict"})
}
return
}
previousHumanVersion := acceptanceItem.Version
acceptanceItem.AssignedUserID = ""
acceptanceItem.ClaimedAt = ""
acceptanceItem.Version++
if payload.Decision == domain.HumanDecisionApproved {
acceptanceItem.Status = domain.HumanItemAccepted
acceptanceItem.AcceptedAt = nowISO()
} else {
acceptanceItem.Status = domain.HumanItemRejected
acceptanceItem.RejectedAt = nowISO()
}
humanUpdated, humanUpdateErr := server.store.UpdateHumanItemVersioned(request.Context(), *acceptanceItem, previousHumanVersion)
if humanUpdateErr != nil || !humanUpdated {
if humanUpdateErr != nil {
renderError(writer, http.StatusInternalServerError, humanUpdateErr)
} else {
renderJSON(writer, http.StatusConflict, map[string]string{"error": "Acceptance item version conflict", "code": "version_conflict"})
}
return
}
_ = server.appendHumanEvent(request.Context(), *acceptanceItem, string(payload.Decision), principal.User.ID, map[string]any{"deliveryPackageId": item.ID})
if acceptanceBatch, batchErr := server.store.GetHumanBatch(request.Context(), acceptanceItem.BatchID); batchErr == nil && acceptanceBatch != nil {
if payload.Decision == domain.HumanDecisionApproved {
acceptanceBatch.Status = domain.HumanBatchCompleted
acceptanceBatch.AcceptedCount = 1
} else {
acceptanceBatch.Status = domain.HumanBatchBlocked
}
_ = server.store.UpsertHumanBatch(request.Context(), *acceptanceBatch)
}
_ = server.store.UpsertAnnotationWorklogEvent(request.Context(), domain.AnnotationWorklogEventRecord{
ID: domain.NewID("annotation-worklog"), OrganizationID: item.OrganizationID, ProjectID: item.ProjectID,
TaskID: item.ID, UserID: principal.User.ID, SupplierID: item.SupplierID, WorkgroupID: item.WorkgroupID, VendorID: item.VendorID,
EventType: "acceptance_" + string(payload.Decision), Mode: item.Mode, Temporary: item.Temporary || item.Mode == domain.RunModeDebug, OutputDelta: 0, CreatedAt: nowISO(),
})
if payload.Decision == domain.HumanDecisionRejected {
_ = server.store.UpsertHumanReject(request.Context(), domain.HumanRejectRecord{OrganizationID: item.OrganizationID, BatchID: item.ReleasePartitionID, ItemID: item.ID, ProjectID: item.ProjectID, WorkflowID: item.WorkflowID, RunID: item.ChildRunID, StageID: "acceptance", AttemptRound: len(item.AcceptanceReviews) - 1, ReviewedRevision: item.Version, RejectedByUserID: principal.User.ID, ReasonCodes: payload.ReasonCodes, Comment: strings.TrimSpace(payload.Comment), AllowedReopenStages: []string{"split_annotation", "semantic_annotation", "quality_review"}, Status: domain.HumanRejectOpen})
}
renderJSON(writer, http.StatusCreated, map[string]any{"package": item, "review": review})
}