package qaopsorg import ( "context" "encoding/json" "github.com/jackc/pgx/v5" "sort" "strings" ) type PersonAttribution struct { Name string `json:"name"` DepartmentIDs []string `json:"-"` State string `json:"state"` PersonID string `json:"-"` Departments []string `json:"departments"` Region string `json:"region"` } type Attribution struct { Metadata State people map[string]PersonAttribution unions map[string]string } func (p *Attribution) Members() []PersonAttribution { result := []PersonAttribution{} if p == nil { return result } for _, person := range p.people { result = append(result, person) } sort.Slice(result, func(i, j int) bool { return result[i].PersonID < result[j].PersonID }) return result } func BuildAttribution(state State, directory Directory) (*Attribution, error) { p := &Attribution{Metadata: state, people: map[string]PersonAttribution{}, unions: map[string]string{}} if state.State == "empty" { return p, nil } if state.State != "ready" || state.DirectoryID == "" { return nil, ErrUnavailable } view, err := PreviewRegions(directory, state.Rules, state.RegionDefinitions()) if err != nil { return nil, ErrUnavailable } p.Metadata.View = view departments := map[string]DepartmentView{} for _, d := range view.Departments { departments[d.ID] = d } for _, person := range directory.People { paths, regions := map[string]bool{}, map[string]bool{} for _, id := range person.DepartmentIDs { d := departments[id] paths[d.Path] = true if d.Region != "" { regions[d.Region] = true } } item := PersonAttribution{Name: person.Name, DepartmentIDs: append([]string{}, person.DepartmentIDs...), State: "unassigned", PersonID: person.ID, Departments: []string{}} for path := range paths { item.Departments = append(item.Departments, path) } sort.Strings(item.Departments) if len(regions) == 1 { item.State = "matched" for region := range regions { item.Region = state.RegionLabel(region) } } else if len(regions) > 1 { item.State = "cross_region" } p.people[person.ID] = item if person.UnionID != "" { if !validID(person.UnionID) { return nil, ErrUnavailable } if _, ok := p.unions[person.UnionID]; ok { p.unions[person.UnionID] = "" } else { p.unions[person.UnionID] = person.ID } } } return p, nil } func (p *Attribution) Resolve(staff, union string, evidence ...string) PersonAttribution { none := PersonAttribution{State: "unmatched", Departments: []string{}} if p == nil || p.Metadata.State != "ready" { none.State = "directory_missing" return none } if len(evidence) >= 2 { asker, raw := strings.TrimSpace(evidence[0]), strings.TrimSpace(evidence[1]) if strings.HasPrefix(raw, "{") || strings.HasPrefix(raw, "[") { var legacy map[string]json.RawMessage if json.Unmarshal([]byte(raw), &legacy) != nil || legacy == nil { none.State = "identity_conflict" return none } read := func(key string) (string, bool) { value, present := legacy[key] if !present { return "", true } var text string if json.Unmarshal(value, &text) != nil { return "", false } return strings.TrimSpace(text), true } legacyStaff, validStaff := read("staffId") legacyUnion, validUnion := read("unionId") if !validStaff || !validUnion || staff != "" && legacyStaff != "" && staff != legacyStaff || union != "" && legacyUnion != "" && union != legacyUnion { none.State = "identity_conflict" return none } if staff == "" { staff = legacyStaff } if union == "" { union = legacyUnion } } if staff == "" && union == "" && asker != "" { var match *PersonAttribution for _, person := range p.people { if strings.TrimSpace(person.Name) == asker { if match != nil { none.State = "identity_conflict" return none } copy := person match = © } } if match != nil { return *match } } } if staff == "" && union == "" { none.State = "no_identity" return none } byUnion, unionKnown := p.unions[union] if person, ok := p.people[staff]; ok { if unionKnown && (byUnion == "" || byUnion != staff) { none.State = "identity_conflict" return none } return person } if unionKnown { if byUnion == "" { none.State = "identity_conflict" return none } return p.people[byUnion] } return none } func (s *Store) GetAttributionInTx(ctx context.Context, tx pgx.Tx) (*Attribution, error) { if !s.available() { return nil, ErrUnavailable } state, directory, err := s.read(ctx, tx, false) if err != nil { return nil, err } return BuildAttribution(state, directory) } func (s *Store) GetAttribution(ctx context.Context) (*Attribution, error) { if !s.available() { return nil, ErrUnavailable } state, directory, err := s.read(ctx, s.pool, false) if err != nil { return nil, err } return BuildAttribution(state, directory) }