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 = ©URL 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) }