124 lines
3.2 KiB
Go
124 lines
3.2 KiB
Go
package qaopsorg
|
|
|
|
import (
|
|
"context"
|
|
"sort"
|
|
)
|
|
|
|
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 := Preview(directory, state.Rules)
|
|
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 = 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) PersonAttribution {
|
|
none := PersonAttribution{State: "unmatched", Departments: []string{}}
|
|
if p == nil || p.Metadata.State != "ready" {
|
|
none.State = "directory_missing"
|
|
return none
|
|
}
|
|
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) 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)
|
|
}
|