401 lines
17 KiB
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})
|
|
}
|