package httpapi import ( "context" "errors" "knowledge-governance/internal/dobotaiops" "knowledge-governance/internal/qaopsorg" "net/http" "strings" "time" ) var errQAOrganization = errors.New("organization attribution unavailable") type qaAttributionProvider interface { GetAttribution(context.Context) (*qaopsorg.Attribution, error) } func recordAttribution(ctx context.Context, config Config) (*qaopsorg.Attribution, error) { if config.QAOrg == nil { return qaopsorg.BuildAttribution(qaopsorg.State{State: "empty"}, qaopsorg.Directory{}) } provider, ok := config.QAOrg.(qaAttributionProvider) if !ok { return nil, errQAOrganization } p, err := provider.GetAttribution(ctx) if err != nil || p == nil { return nil, errQAOrganization } return p, nil } func attributionVersion(p *qaopsorg.Attribution) dobotaiops.OrganizationVersion { return dobotaiops.OrganizationVersion{State: p.Metadata.State, DirectoryID: p.Metadata.DirectoryID, DirectorySource: p.Metadata.DirectorySource, SyncedAt: p.Metadata.DirectorySyncedAt, RevisionID: p.Metadata.RevisionID, Basis: "current_directory", RegionNames: p.Metadata.RegionLabels()} } func enrichQARecord(item *dobotaiops.Record, p *qaopsorg.Attribution) { trigger := item.TriggerPerson if raw, ok := item.MasterFields["trigger_person"]; ok { trigger = raw } person := p.Resolve(item.Identity.StaffID, item.Identity.UnionID, item.Asker, trigger) o := &dobotaiops.RecordOrganization{Version: attributionVersion(p), State: person.State, Departments: person.Departments, Region: person.Region, SourceDepartment: item.Department, SourceRegion: item.Region, DepartmentOrigin: "unavailable", RegionOrigin: "unavailable"} if item.Department != "" { o.DepartmentOrigin = "source_snapshot" } else if len(person.Departments) > 0 { item.Department = strings.Join(person.Departments, ";") o.DepartmentOrigin = "current_directory" } if item.Region != "" { o.RegionOrigin = "source_snapshot" } else if person.Region != "" { item.Region = person.Region o.RegionOrigin = "current_directory" } item.Organization = o } func enrichQAPage(page *dobotaiops.RecordPage, p *qaopsorg.Attribution) { version := attributionVersion(p) page.Organization = &version for i := range page.Items { enrichQARecord(&page.Items[i], p) } for _, actor := range page.ScopeActors { person := p.Resolve(actor.StaffID, actor.UnionID) if len(person.Departments) > 0 { dobotaiops.AddRecordColumns(page, "department") } if person.Region != "" { dobotaiops.AddRecordColumns(page, "region") } } } type qaUsageReader interface { ReadUsageGroups(context.Context, dobotaiops.RecordQuery) (dobotaiops.UsageGroups, error) } type qaUsageRow struct { Key string `json:"key"` Questions int64 `json:"questions"` Succeeded int64 `json:"succeeded"` Failed int64 `json:"failed"` Other int64 `json:"other"` Users *int `json:"users"` RosterPeople *int `json:"roster_people"` } type qaUsage struct { Organization dobotaiops.OrganizationVersion `json:"organization"` AsOf time.Time `json:"as_of"` Start time.Time `json:"start"` End time.Time `json:"end"` Keyword string `json:"keyword"` Questions int64 `json:"questions"` IdentifiedUsers int `json:"identified_users"` Rows []qaUsageRow `json:"rows"` } func summarizeQAUsage(groups dobotaiops.UsageGroups, p *qaopsorg.Attribution, query dobotaiops.RecordQuery) qaUsage { result := qaUsage{Organization: attributionVersion(p), AsOf: groups.AsOf, Start: query.Window.Start, End: query.Window.End, Keyword: query.Keyword, Rows: []qaUsageRow{}} keys := append(append([]string{}, p.Metadata.RegionLabels()...), "unassigned", "cross_region", "unmatched", "identity_conflict", "no_identity", "directory_missing") rows := map[string]*qaUsageRow{} members := map[string]map[string]bool{} all := map[string]bool{} for _, key := range keys { row := &qaUsageRow{Key: key} if p.Metadata.State == "ready" { var n int valid := true switch key { case "unassigned": n = p.Metadata.View.UnassignedPeople case "cross_region": n = p.Metadata.View.ConflictingPeople default: var ok bool for _, region := range p.Metadata.RegionDefinitions() { if region.Name == key { n, ok = p.Metadata.View.Regions[region.ID] break } } valid = ok } if valid { row.RosterPeople = &n row.Users = new(int) } } rows[key] = row members[key] = map[string]bool{} } for _, group := range groups.Groups { person := p.Resolve(group.Identity.StaffID, group.Identity.UnionID) key := person.State if person.Region != "" { key = person.Region } row := rows[key] if row == nil { continue } row.Questions += group.Total row.Succeeded += group.Succeeded row.Failed += group.Failed row.Other += group.Total - group.Succeeded - group.Failed result.Questions += group.Total if person.PersonID != "" { members[key][person.PersonID] = true all[person.PersonID] = true } } for _, key := range keys { row := rows[key] if row.Users != nil { *row.Users = len(members[key]) } result.Rows = append(result.Rows, *row) } result.IdentifiedUsers = len(all) return result } func qaOpsUsage(w http.ResponseWriter, r *http.Request, config Config) { if !authorizeQAOps(w, r) { return } reader, ok := config.QAOps.(qaUsageReader) if !ok || config.QAOpsTenantKey == "" { qaOpsError(w, dobotaiops.ErrUnavailable) return } values := r.URL.Query() for key, items := range values { if (key != "start" && key != "end" && key != "keyword") || len(items) != 1 { qaOpsError(w, dobotaiops.ErrInvalidQuery) return } } window, err := dobotaiops.NewWindow(config.QAOpsTenantKey, values.Get("start"), values.Get("end"), 90*24*time.Hour, config.Now()) if err != nil { qaOpsError(w, err) return } p, err := recordAttribution(r.Context(), config) if err != nil { qaOpsError(w, err) return } query := dobotaiops.RecordQuery{Window: window, Keyword: values.Get("keyword")} groups, err := reader.ReadUsageGroups(r.Context(), query) if err != nil { qaOpsError(w, err) return } writeJSON(w, 200, map[string]any{"data": summarizeQAUsage(groups, p, query)}) }