Files
knowledge-governance/web/src/qaOrg.ts
T
姚章浩 154b0b62ad
build / build (push) Successful in 1m20s
feat(qaops): 完成区域统计与部门绑定六项联动
新增北京时间自然周校验与缓存隔离,默认展开到业务二级部门。
选中部门在统计页就地绑定;区域名称列表原位增删改,双版本锁、自动预览、独立读回及删除确认。
筛选和两张区域看板使用同一已保存目录,删除失效筛选回全部。

验证:完整 make verify、全 mirror 隔离 PostgreSQL race、自然周边界与缓存键负例通过;真实恢复库327部门逐行对拍及六项浏览器验收通过。
schema57无迁移,不改真实公司区域绑定或原始问答,不连接DobotAI生产源库;PNG导出本轮不冒充已验证。
2026-10-19 23:41:01 +08:00

240 lines
8.7 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { applyBulkRegionRules } from './qaRegionSelection'
export const regionNames = ['国内工业', 'APAC', 'EMEA', 'America'] as const
export interface RegionDefinition {
id: string
name: string
}
export const defaultRegions = (): RegionDefinition[] => regionNames.map((name) => ({ id: name, name }))
const reservedRegions = [
'unassigned',
'cross_region',
'unmatched',
'identity_conflict',
'no_identity',
'directory_missing',
'__proto__',
'constructor',
'prototype',
]
export function parseRegionDefinitions(raw: unknown): RegionDefinition[] {
if (!Array.isArray(raw) || raw.length > 100) return invalid()
const ids = new Set<string>(),
names = new Set<string>()
return raw.map((item) => {
const r = obj(item),
id = str(r.id),
name = str(r.name)
for (const value of [id, name])
if (
!value ||
value.trim() !== value ||
new TextEncoder().encode(value).length > 256 ||
/[\x00\r\n]/.test(value) ||
reservedRegions.includes(value)
)
return invalid()
if (ids.has(id) || names.has(name)) return invalid()
ids.add(id)
names.add(name)
return { id, name }
})
}
export const organizationRegions = (state: Organization | null): RegionDefinition[] =>
state?.regions ?? defaultRegions()
export interface RegionRule {
department_id: string
region: string
}
export interface DepartmentRegion {
id: string
parent_id: string
name: string
path: string
region: string
explicit: boolean
inherited_from: string
}
export interface Organization {
regions?: RegionDefinition[]
state: 'empty' | 'ready'
directory_id: string
directory_source: string
directory_synced_at: string | null
revision_id: string
updated_by: string
updated_at: string | null
rules: RegionRule[]
view: {
departments: DepartmentRegion[]
regions: Record<string, number>
total_people: number
unassigned_people: number
conflicting_people: number
missing_departments: string[]
}
}
export function invalid(): never {
throw new Error('通讯录或区域配置响应格式无效')
}
export function obj(value: unknown): Record<string, unknown> {
if (!value || typeof value !== 'object' || Array.isArray(value)) return invalid()
return value as Record<string, unknown>
}
export function str(value: unknown): string {
return typeof value === 'string' ? value : invalid()
}
export function count(value: unknown): number {
return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : invalid()
}
export function instant(value: unknown): string | null {
return value === null ? null : typeof value === 'string' && Number.isFinite(Date.parse(value)) ? value : invalid()
}
export function parseOrganization(value: unknown): Organization {
const s = obj(value),
v = obj(s.view),
regions = obj(v.regions),
definitions = s.regions === undefined ? defaultRegions() : parseRegionDefinitions(s.regions),
regionIDs = definitions.map((r) => r.id)
if (
(s.state !== 'empty' && s.state !== 'ready') ||
!Array.isArray(s.rules) ||
!Array.isArray(v.departments) ||
!Array.isArray(v.missing_departments)
)
return invalid()
const rules = s.rules.map((raw) => {
const r = obj(raw)
const region = str(r.region)
if (!regionIDs.includes(region)) return invalid()
return { department_id: str(r.department_id), region }
})
const departments = v.departments.map((raw) => {
const d = obj(raw)
if (typeof d.explicit !== 'boolean' || (d.region !== '' && !regionIDs.includes(String(d.region)))) return invalid()
return {
id: str(d.id),
parent_id: str(d.parent_id),
name: str(d.name),
path: str(d.path),
region: str(d.region),
explicit: d.explicit,
inherited_from: str(d.inherited_from),
}
})
if (
departments.some((d) => !d.id || !d.path) ||
new Set(departments.map((d) => d.id)).size !== departments.length ||
new Set(rules.map((r) => r.department_id)).size !== rules.length
)
return invalid()
const total = count(v.total_people),
unassigned = count(v.unassigned_people),
conflicting = count(v.conflicting_people)
if (Object.keys(regions).length !== regionIDs.length || Object.keys(regions).some((id) => !regionIDs.includes(id)))
return invalid()
const regionCounts = Object.fromEntries(regionIDs.map((r) => [r, count(regions[r])]))
if (Object.values(regionCounts).reduce((a, b) => a + b, 0) + unassigned + conflicting !== total) return invalid()
const result: Organization = {
regions: definitions,
state: s.state,
directory_id: str(s.directory_id),
directory_source: str(s.directory_source),
directory_synced_at: instant(s.directory_synced_at),
revision_id: str(s.revision_id),
updated_by: str(s.updated_by),
updated_at: instant(s.updated_at),
rules,
view: {
departments,
regions: regionCounts,
total_people: total,
unassigned_people: unassigned,
conflicting_people: conflicting,
missing_departments: v.missing_departments.map(str),
},
}
if (s.state === 'ready' && (!result.directory_id || !result.directory_synced_at || !departments.length || !total))
return invalid()
return result
}
export function changeRegionRule(rules: RegionRule[], id: string, region: string, checked: boolean): RegionRule[] {
return [...rules.filter((r) => r.department_id !== id), ...(checked ? [{ department_id: id, region }] : [])]
}
async function requestOrganization(
path: string,
method: string,
body: unknown,
signal?: AbortSignal
): Promise<Organization> {
const response = await fetch(`/api/v1/qa-ops/organization${path}`, {
method,
credentials: 'same-origin',
cache: 'no-store',
signal,
headers:
method === 'GET' ? undefined : { 'Content-Type': 'application/json', 'X-Governance-Action': 'qa-organization' },
body: body === undefined ? undefined : JSON.stringify(body),
})
const raw: unknown = await response.json().catch(() => null)
if (!response.ok) {
const error = raw && typeof raw === 'object' ? (raw as Record<string, unknown>).error : undefined
throw new Error(typeof error === 'string' ? error : `区域配置读取失败(HTTP ${response.status})`)
}
return parseOrganization(obj(raw).data)
}
export const fetchOrganization = (signal?: AbortSignal) => requestOrganization('', 'GET', undefined, signal)
export const previewOrganization = (state: Organization, rules: RegionRule[], signal?: AbortSignal) =>
requestOrganization(
'/preview',
'POST',
{ directory_id: state.directory_id, base_revision: state.revision_id, regions: organizationRegions(state), rules },
signal
)
export async function bindOrganizationDepartments(
expected: { directory_id: string; revision_id: string },
ids: string[],
region: string,
signal?: AbortSignal
): Promise<Organization> {
const state = await fetchOrganization(signal),
catalog = organizationRegions(state)
if (state.directory_id !== expected.directory_id || state.revision_id !== expected.revision_id)
throw new Error('通讯录或区域版本已变化,请重新读取统计后绑定')
const known = new Set(state.view.departments.map((d) => d.id))
if (!ids.length || ids.some((id) => !known.has(id)) || !catalog.some((r) => r.id === region))
throw new Error('选中部门或目标区域无效,请重新读取')
return commitOrganization(state, catalog, applyBulkRegionRules(state.rules, ids, region), signal)
}
const organizationCommitSignature = (regions: RegionDefinition[], rules: RegionRule[]) =>
JSON.stringify({
regions: [...regions].sort((a, b) => a.id.localeCompare(b.id)),
rules: [...rules].sort((a, b) => a.department_id.localeCompare(b.department_id)),
})
export async function commitOrganization(
state: Organization,
regions: RegionDefinition[],
rules: RegionRule[],
signal?: AbortSignal
): Promise<Organization> {
const catalog = parseRegionDefinitions(regions),
base = { ...state, regions: catalog }
await previewOrganization(base, rules, signal)
const saved = await saveOrganization(base, rules, signal),
readback = await fetchOrganization(signal)
if (
readback.directory_id !== state.directory_id ||
readback.revision_id !== saved.revision_id ||
organizationCommitSignature(organizationRegions(readback), readback.rules) !==
organizationCommitSignature(catalog, rules)
)
throw new Error('保存后配置再次变化,未将旧结果标为成功,请重新读取核对')
return readback
}
export const saveOrganization = (state: Organization, rules: RegionRule[], signal?: AbortSignal) =>
requestOrganization(
'/regions',
'PUT',
{ directory_id: state.directory_id, base_revision: state.revision_id, regions: organizationRegions(state), rules },
signal
)