Files
knowledge-governance/internal/qaopsorg/regions.go
T
2026-10-18 21:50:29 +08:00

155 lines
4.8 KiB
Go

package qaopsorg
import (
"errors"
"sort"
"strings"
)
var ErrInvalid = errors.New("invalid organization data or region rules")
var RegionNames = []string{"国内工业", "APAC", "EMEA", "America"}
type Department struct {
ID string `json:"id"`
ParentID string `json:"parent_id"`
Name string `json:"name"`
}
type Person struct {
Name string `json:"name,omitempty"`
ID string `json:"id"`
UnionID string `json:"union_id,omitempty"`
DepartmentIDs []string `json:"department_ids"`
}
type Directory struct {
Departments []Department `json:"departments"`
People []Person `json:"people"`
}
type Rule struct {
DepartmentID string `json:"department_id"`
Region string `json:"region"`
}
type DepartmentView struct {
Department
Path string `json:"path"`
Region string `json:"region"`
Explicit bool `json:"explicit"`
InheritedFrom string `json:"inherited_from"`
}
type PreviewResult struct {
Departments []DepartmentView `json:"departments"`
Regions map[string]int `json:"regions"`
TotalPeople int `json:"total_people"`
UnassignedPeople int `json:"unassigned_people"`
ConflictingPeople int `json:"conflicting_people"`
MissingDepartments []string `json:"missing_departments"`
}
// Identity is department ID. Names and legacy keyword rules never decide ownership.
func Preview(directory Directory, rules []Rule) (PreviewResult, error) {
return PreviewRegions(directory, rules, DefaultRegions())
}
func PreviewRegions(directory Directory, rules []Rule, regions []RegionDefinition) (PreviewResult, error) {
result := PreviewResult{Departments: []DepartmentView{}, Regions: map[string]int{}, MissingDepartments: []string{}, TotalPeople: len(directory.People)}
if len(directory.Departments) == 0 || len(directory.Departments) > 20000 || len(directory.People) == 0 || len(directory.People) > 100000 || len(rules) > 20000 {
return result, ErrInvalid
}
if !validRegions(regions) {
return result, ErrInvalid
}
for _, region := range regions {
result.Regions[region.ID] = 0
}
departments := make(map[string]Department, len(directory.Departments))
for _, d := range directory.Departments {
if !validID(d.ID) || d.Name == "" || len(d.Name) > 1000 || strings.ContainsRune(d.Name, 0) {
return result, ErrInvalid
}
if _, ok := departments[d.ID]; ok {
return result, ErrInvalid
}
departments[d.ID] = d
}
direct := map[string]string{}
for _, rule := range rules {
if !validID(rule.DepartmentID) {
return result, ErrInvalid
}
if _, ok := result.Regions[rule.Region]; !ok {
return result, ErrInvalid
}
if _, ok := direct[rule.DepartmentID]; ok {
return result, ErrInvalid
}
direct[rule.DepartmentID] = rule.Region
if _, ok := departments[rule.DepartmentID]; !ok {
result.MissingDepartments = append(result.MissingDepartments, rule.DepartmentID)
}
}
resolved := map[string]DepartmentView{}
for _, d := range directory.Departments {
seen := map[string]bool{}
chain := []string{}
region, from := "", ""
for cur := d.ID; cur != ""; {
node, ok := departments[cur]
if !ok || seen[cur] || len(chain) > 100 {
return result, ErrInvalid
}
seen[cur] = true
chain = append(chain, node.Name)
if region == "" && direct[cur] != "" {
region, from = direct[cur], cur
}
cur = node.ParentID
}
for left, right := 0, len(chain)-1; left < right; left, right = left+1, right-1 {
chain[left], chain[right] = chain[right], chain[left]
}
view := DepartmentView{Department: d, Path: strings.Join(chain, "/"), Region: region, Explicit: direct[d.ID] != ""}
if from != d.ID {
view.InheritedFrom = from
}
resolved[d.ID] = view
result.Departments = append(result.Departments, view)
}
people := map[string]bool{}
for _, person := range directory.People {
if !validID(person.ID) || people[person.ID] || len(person.DepartmentIDs) > 1000 || len(person.Name) > 1000 || strings.ContainsRune(person.Name, 0) {
return result, ErrInvalid
}
people[person.ID] = true
regions := map[string]bool{}
for _, id := range person.DepartmentIDs {
department, ok := resolved[id]
if !ok {
return result, ErrInvalid
}
if department.Region != "" {
regions[department.Region] = true
}
}
switch len(regions) {
case 0:
result.UnassignedPeople++
case 1:
for region := range regions {
result.Regions[region]++
}
default:
result.ConflictingPeople++
}
}
sort.Slice(result.Departments, func(i, j int) bool {
a, b := result.Departments[i], result.Departments[j]
if a.Path == b.Path {
return a.ID < b.ID
}
return a.Path < b.Path
})
sort.Strings(result.MissingDepartments)
return result, nil
}
func validID(value string) bool {
return value != "" && len(value) <= 256 && strings.TrimSpace(value) == value && !strings.ContainsAny(value, "\x00\r\n")
}