droboticflow/internal/api/human_display.go

284 lines
7.4 KiB
Go

package api
import (
"context"
"sort"
"strings"
"droboticflow/internal/domain"
)
type humanDisplayResolver struct {
server *server
projects map[string]string
workflows map[string]string
runDisplays map[string]*domain.HumanRunDisplay
runs map[string]*domain.RunRecord
annotation map[string]*domain.AnnotationTaskRecord
captures map[string]*domain.CaptureRecord
}
func newHumanDisplayResolver(server *server) *humanDisplayResolver {
return &humanDisplayResolver{
server: server, projects: map[string]string{}, workflows: map[string]string{},
runDisplays: map[string]*domain.HumanRunDisplay{}, runs: map[string]*domain.RunRecord{}, annotation: map[string]*domain.AnnotationTaskRecord{},
captures: map[string]*domain.CaptureRecord{},
}
}
// primeRuns batches only this response's IDs; missing IDs are negatively cached
// for the request, just like the previous GetRun resolver.
func (resolver *humanDisplayResolver) primeRuns(ctx context.Context, items []domain.HumanItemRecord) error {
ids := []string{}
seen := map[string]bool{}
for _, item := range items {
id := strings.TrimSpace(item.RunID)
if id == "" || seen[id] {
continue
}
seen[id] = true
if _, ok := resolver.runDisplays[id]; !ok {
ids = append(ids, id)
}
}
if len(ids) == 0 {
return nil
}
rows, err := resolver.server.store.ListHumanRunDisplays(ctx, ids)
if err != nil {
return err
}
for _, id := range ids {
resolver.runDisplays[id] = nil
}
for i := range rows {
resolver.runDisplays[rows[i].ID] = &rows[i]
}
return nil
}
func (resolver *humanDisplayResolver) runDisplay(ctx context.Context, id string) (*domain.HumanRunDisplay, error) {
id = strings.TrimSpace(id)
if id == "" {
return nil, nil
}
if err := resolver.primeRuns(ctx, []domain.HumanItemRecord{{RunID: id}}); err != nil {
return nil, err
}
return resolver.runDisplays[id], nil
}
func (resolver *humanDisplayResolver) captureRecord(ctx context.Context, id string) (*domain.CaptureRecord, error) {
id = strings.TrimSpace(id)
if id == "" {
return nil, nil
}
if item, ok := resolver.captures[id]; ok {
return item, nil
}
item, err := resolver.server.store.GetCaptureRecord(ctx, id)
if err != nil {
return nil, err
}
resolver.captures[id] = item
return item, nil
}
func (resolver *humanDisplayResolver) projectName(ctx context.Context, id string) (string, error) {
id = strings.TrimSpace(id)
if id == "" {
return "", nil
}
if name, ok := resolver.projects[id]; ok {
return name, nil
}
item, err := resolver.server.store.GetProject(ctx, id)
if err != nil {
return "", err
}
name := ""
if item != nil {
name = strings.TrimSpace(item.Name)
}
resolver.projects[id] = name
return name, nil
}
func (resolver *humanDisplayResolver) workflowName(ctx context.Context, id string) (string, error) {
id = strings.TrimSpace(id)
if id == "" {
return "", nil
}
if name, ok := resolver.workflows[id]; ok {
return name, nil
}
item, err := resolver.server.store.GetWorkflow(ctx, id)
if err != nil {
return "", err
}
name := ""
if item != nil {
name = strings.TrimSpace(item.Name)
}
resolver.workflows[id] = name
return name, nil
}
func (resolver *humanDisplayResolver) run(ctx context.Context, id string) (*domain.RunRecord, error) {
id = strings.TrimSpace(id)
if id == "" {
return nil, nil
}
if item, ok := resolver.runs[id]; ok {
return item, nil
}
item, err := resolver.server.store.GetRun(ctx, id)
if err != nil {
return nil, err
}
resolver.runs[id] = item
return item, nil
}
func (resolver *humanDisplayResolver) annotationTask(ctx context.Context, id string) (*domain.AnnotationTaskRecord, error) {
id = strings.TrimSpace(id)
if id == "" {
return nil, nil
}
if item, ok := resolver.annotation[id]; ok {
return item, nil
}
item, err := resolver.server.store.GetAnnotationTask(ctx, id)
if err != nil {
return nil, err
}
resolver.annotation[id] = item
return item, nil
}
func appendCaptureDirectory(values *[]string, candidate string) {
candidate = strings.TrimSpace(candidate)
if candidate != "" {
*values = append(*values, candidate)
}
}
func humanCaptureDirectoriesFromPayload(value any, values *[]string) {
domain.AppendCaptureDirectoriesFromPayload(value, values)
}
func uniqueCaptureDirectories(values []string) []string {
seen := map[string]struct{}{}
items := make([]string, 0, len(values))
for _, value := range values {
value = strings.TrimSpace(value)
if value == "" {
continue
}
key := strings.ToLower(value)
if _, exists := seen[key]; exists {
continue
}
seen[key] = struct{}{}
items = append(items, value)
}
sort.Strings(items)
return items
}
func (resolver *humanDisplayResolver) enrichItem(ctx context.Context, item *domain.HumanItemRecord) error {
if item == nil {
return nil
}
run, err := resolver.runDisplay(ctx, item.RunID)
if err != nil {
return err
}
projectName, err := resolver.projectName(ctx, item.ProjectID)
if err != nil {
return err
}
workflowName, err := resolver.workflowName(ctx, item.WorkflowID)
if err != nil {
return err
}
if run != nil {
if projectName == "" {
projectName = strings.TrimSpace(run.ProjectName)
}
if workflowName == "" {
workflowName = strings.TrimSpace(run.WorkflowName)
}
}
values := make([]string, 0)
if run != nil && run.TaskID != "" {
capture, err := resolver.captureRecord(ctx, run.TaskID)
if err != nil {
return err
}
if capture != nil {
appendCaptureDirectory(&values, capture.CaptureID)
if len(values) == 0 {
appendCaptureDirectory(&values, domain.CaptureDirectoryFromDirectoryValue(capture.Prefix))
}
}
}
if len(values) == 0 {
appendCaptureDirectory(&values, domain.CaptureDirectoryFromArtifactValue(item.Subject.ItemKey))
if item.PoolSearchCurrent() {
values = append(values, item.PoolSearch.PayloadDirectories...)
} else {
humanCaptureDirectoriesFromPayload(item.Subject.Payload, &values)
}
}
// Task artifacts are a legacy fallback, not another source to merge with
// an already resolved capture. Avoid fetching the full annotation document
// (including its workspace) when its fields cannot affect the display.
if len(values) == 0 {
task, err := resolver.annotationTask(ctx, item.LegacyTaskID)
if err != nil {
return err
}
if task != nil {
appendCaptureDirectory(&values, domain.CaptureDirectoryFromArtifactValue(task.ArtifactID))
appendCaptureDirectory(&values, domain.CaptureDirectoryFromArtifactValue(task.SourceVideo))
}
}
if run != nil && len(values) == 0 {
values = append(values, uniqueCaptureDirectories(run.CaptureDirectories)...)
if len(values) == 0 {
full, err := resolver.run(ctx, item.RunID)
if err != nil {
return err
}
if full != nil {
values = append(values, domain.CaptureDirectoriesFromRun(*full)...)
}
}
}
item.Display = &domain.HumanTaskDisplayContext{
ProjectName: projectName, WorkflowName: workflowName, CaptureDirectories: uniqueCaptureDirectories(values),
}
return nil
}
func (resolver *humanDisplayResolver) enrichReject(ctx context.Context, reject *domain.HumanRejectRecord) error {
if reject == nil {
return nil
}
item, err := resolver.server.store.GetHumanItem(ctx, reject.ItemID)
if err != nil {
return err
}
if item == nil {
item = &domain.HumanItemRecord{
OrganizationID: reject.OrganizationID, ProjectID: reject.ProjectID,
WorkflowID: reject.WorkflowID, RunID: reject.RunID,
}
}
if err := resolver.enrichItem(ctx, item); err != nil {
return err
}
reject.Display = item.Display
return nil
}