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(), names = new Set() 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 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 { if (!value || typeof value !== 'object' || Array.isArray(value)) return invalid() return value as Record } 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 { 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).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 { 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 { 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 )