droboticflow-new/internal/api/admin_annotation_pool.go

159 lines
5.3 KiB
Go

package api
import (
"droboticflow/internal/domain"
"droboticflow/internal/store"
"encoding/json"
"net/http"
"net/url"
"strings"
"time"
)
func (s *server) adminAnnotationPoolQuery(w http.ResponseWriter, r *http.Request) (store.AdminAnnotationPoolQuery, bool) {
p, _ := currentPrincipal(r)
if !annotationManager(p) {
renderJSON(w, 403, map[string]string{"error": "administrator annotation pool required"})
return store.AdminAnnotationPoolQuery{}, false
}
v := r.URL.Query()
q := store.AdminAnnotationPoolQuery{ProjectID: v.Get("projectId"), WorkflowID: v.Get("workflowId"), RunID: v.Get("runId"), NodeID: v.Get("nodeId"), ArtifactID: v.Get("artifactId"), Capture: strings.TrimSpace(v.Get("capture")), Search: strings.TrimSpace(v.Get("search")), Category: v.Get("category"), Pool: v.Get("pool"), UserID: p.User.ID}
if q.Pool == "" {
q.Pool = "available"
}
if q.Pool != "available" && q.Pool != "mine" && q.Pool != "all" {
renderValidationError(w, validationIssue{Field: "pool", Message: "pool must be available, mine, or all"})
return q, false
}
if len(q.Search) > 256 || len(q.Capture) > 1024 {
renderValidationError(w, validationIssue{Field: "search", Message: "search is too long"})
return q, false
}
switch q.Category {
case "", "all", "available", "pending_slice", "slicing", "pending_annotation", "rework", "pending_quality", "rework_review", "pending_acceptance", "accepted", "submitting", "submission_conflicted", "source_failed":
default:
renderValidationError(w, validationIssue{Field: "category", Message: "unknown task category"})
return q, false
}
limit, issue := parseDatabaseBrowserPageQuery(v.Get("limit"), "limit", 200, 1, 200)
if issue != nil {
renderValidationError(w, *issue)
return q, false
}
q.Limit = limit
cursor, err := decodeHumanItemCursor(v.Get("cursor"))
if err != nil {
renderValidationError(w, validationIssue{Field: "cursor", Message: "cursor must be a valid opaque human item cursor"})
return q, false
}
q.Cursor = cursor
return q, true
}
// Counts use the existing bounded per-actor cache; list criteria and cursor are
// deliberately excluded from its key. Permission is checked before cache hits.
func (s *server) adminAnnotationCounts(w http.ResponseWriter, r *http.Request, q store.AdminAnnotationPoolQuery) (*store.AdminAnnotationPoolCounts, bool) {
countRequest := r.Clone(r.Context())
copyURL := *r.URL
countRequest.URL = &copyURL
values := url.Values{}
for _, key := range []string{"projectId", "workflowId", "runId", "nodeId", "artifactId", "nodeId", "capture"} {
if value := r.URL.Query().Get(key); value != "" {
values.Set(key, value)
}
}
countRequest.URL.RawQuery = values.Encode()
key := s.dashboardCacheKey("admin-annotation-pool-counts", countRequest)
if entry := s.dashboardResponses.get(key); entry != nil {
var counts store.AdminAnnotationPoolCounts
if json.Unmarshal(entry.body, &counts) == nil {
return &counts, true
}
}
counts, err := s.store.CountAdminAnnotationPools(r.Context(), s.requestOrganizationID(r), q)
if err != nil {
renderError(w, 500, err)
return nil, false
}
body, err := json.Marshal(counts)
if err != nil {
renderError(w, 500, err)
return nil, false
}
// Five seconds bounds cross-pod/background changes. Existing API write
// invalidation clears these entries immediately on this process.
s.dashboardResponses.setTTL(key, 200, "application/json", body, 5*time.Second)
return &counts, true
}
func (s *server) handleAdminAnnotationPool(w http.ResponseWriter, r *http.Request) {
r = r.WithContext(store.WithQueryReplicaPoolRead(r.Context()))
q, ok := s.adminAnnotationPoolQuery(w, r)
if !ok {
return
}
counts, ok := s.adminAnnotationCounts(w, r, q)
if !ok {
return
}
size := q.Limit
q.Limit++
items, err := s.store.ListAdminAnnotationPool(r.Context(), s.requestOrganizationID(r), q)
if err != nil {
renderError(w, 500, err)
return
}
page := humanItemListPage{Items: items}
if len(items) > size {
page.Items = items[:size]
last := page.Items[len(page.Items)-1]
page.HasMore = true
page.NextCursor = encodeHumanItemCursor(&domain.HumanItemCursor{CreatedAt: last.CreatedAt, ID: last.ID})
}
resolver := newHumanDisplayResolver(s)
if err := resolver.primeRuns(r.Context(), page.Items); err != nil {
renderError(w, 500, err)
return
}
for i := range page.Items {
if err := resolver.enrichItem(r.Context(), &page.Items[i]); err != nil {
renderError(w, 500, err)
return
}
}
// Join only the page's task IDs, never an independent newest-first window.
tasks := []annotationTaskListRecord{}
ids := []string{}
seen := map[string]bool{}
for _, item := range page.Items {
if item.LegacyTaskID != "" && !seen[item.LegacyTaskID] {
ids = append(ids, item.LegacyTaskID)
seen[item.LegacyTaskID] = true
}
}
if len(ids) > 0 {
ctx, err := s.withHumanListReads(r.Context(), s.requestOrganizationID(r), q.ProjectID, page.Items)
if err != nil {
renderError(w, 500, err)
return
}
request := r.Clone(ctx)
u := *r.URL
request.URL = &u
v := url.Values{"ids": {strings.Join(ids, ",")}}
if q.ProjectID != "" {
v.Set("projectId", q.ProjectID)
}
request.URL.RawQuery = v.Encode()
joined := s.readAnnotationTasksList(w, request)
if joined == nil {
return
}
tasks = joined.Items
}
result := page.response()
result["counts"] = counts
result["tasks"] = tasks
renderJSON(w, 200, result)
}