forked from longtao.wu/droboticflow
159 lines
5.3 KiB
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 = ©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)
|
|
}
|