forked from longtao.wu/droboticflow
284 lines
7.4 KiB
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
|
|
}
|