154b0b62ad
build / build (push) Successful in 1m20s
新增北京时间自然周校验与缓存隔离,默认展开到业务二级部门。 选中部门在统计页就地绑定;区域名称列表原位增删改,双版本锁、自动预览、独立读回及删除确认。 筛选和两张区域看板使用同一已保存目录,删除失效筛选回全部。 验证:完整 make verify、全 mirror 隔离 PostgreSQL race、自然周边界与缓存键负例通过;真实恢复库327部门逐行对拍及六项浏览器验收通过。 schema57无迁移,不改真实公司区域绑定或原始问答,不连接DobotAI生产源库;PNG导出本轮不冒充已验证。
240 lines
8.7 KiB
TypeScript
240 lines
8.7 KiB
TypeScript
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
|
||
)
|