293 lines
11 KiB
TypeScript
293 lines
11 KiB
TypeScript
export const qaColumns = [
|
||
{ key: 'question_chinese', label: '中文问题' },
|
||
{ key: 'answer', label: 'AI答案' },
|
||
{ key: 'coverage', label: '是否覆盖' },
|
||
{ key: 'is_correct', label: '是否正确' },
|
||
{ key: 'product_category', label: '产品分类' },
|
||
{ key: 'problem_type', label: '问题类型' },
|
||
{ key: 'root_cause', label: '根因分析' },
|
||
{ key: 'asked_at', label: '提问时间' },
|
||
{ key: 'asker', label: '提问人' },
|
||
{ key: 'question', label: '原始问题' },
|
||
{ key: 'language', label: '语言' },
|
||
{ key: 'trigger_person', label: '流程触发人员信息' },
|
||
{ key: 'department', label: '部门' },
|
||
{ key: 'region', label: '区域' },
|
||
{ key: 'feedback', label: '是否点赞' },
|
||
] as const
|
||
|
||
export type QAColumn = (typeof qaColumns)[number]['key']
|
||
export interface QAOrganizationVersion {
|
||
state: 'ready' | 'empty'
|
||
directory_id: string
|
||
directory_source: string
|
||
synced_at: string | null
|
||
revision_id: string
|
||
basis: 'current_directory'
|
||
}
|
||
export interface QARecordOrganization {
|
||
version: QAOrganizationVersion
|
||
state: string
|
||
departments: string[]
|
||
region: string
|
||
source_department: string
|
||
source_region: string
|
||
department_origin: string
|
||
region_origin: string
|
||
}
|
||
export function parseQAOrganizationVersion(value: unknown): QAOrganizationVersion {
|
||
const v = object(value)
|
||
if (!['ready', 'empty'].includes(text(v.state)) || v.basis !== 'current_directory') return invalid()
|
||
const result = {
|
||
state: v.state as QAOrganizationVersion['state'],
|
||
directory_id: text(v.directory_id),
|
||
directory_source: text(v.directory_source),
|
||
synced_at: v.synced_at === null ? null : instant(v.synced_at),
|
||
revision_id: text(v.revision_id),
|
||
basis: 'current_directory' as const,
|
||
}
|
||
if (
|
||
result.state === 'ready' &&
|
||
(!result.directory_id ||
|
||
!result.synced_at ||
|
||
!['weekly_report_live', 'weekly_report_snapshot'].includes(result.directory_source))
|
||
)
|
||
return invalid()
|
||
if (result.state === 'empty' && (result.directory_id || result.revision_id || result.synced_at !== null))
|
||
return invalid()
|
||
return result
|
||
}
|
||
export function mergeQAPages(current: QARecordPage, next: QARecordPage): QARecordPage {
|
||
if (
|
||
current.organization?.directory_id !== next.organization?.directory_id ||
|
||
current.organization?.revision_id !== next.organization?.revision_id
|
||
)
|
||
throw new Error('通讯录或区域配置已变化,请重新查询,不能混合不同版本的分页结果')
|
||
return {
|
||
...next,
|
||
items: [...current.items, ...next.items.filter((item) => !current.items.some((old) => old.id === item.id))],
|
||
}
|
||
}
|
||
export interface QARecord {
|
||
organization?: QARecordOrganization
|
||
id: string
|
||
status: string
|
||
question: string
|
||
answer: string
|
||
asked_at: string
|
||
time_source: string
|
||
asker: string
|
||
trigger_person: string
|
||
department: string
|
||
region: string
|
||
references: unknown
|
||
media: unknown
|
||
source_coverage: { verdict: string; reason_code: string; evaluator_version: string }
|
||
feedback: { asker_value: string; up: number; down: number }
|
||
coverage: { state: 'pending' | 'checked'; verdict?: 'uncovered'; rule_version: string; matched_text?: string }
|
||
question_chinese?: string
|
||
is_correct?: boolean | null
|
||
product_category?: string
|
||
problem_type?: string
|
||
root_cause?: string
|
||
language?: string
|
||
}
|
||
export interface QARecordPage {
|
||
organization?: QAOrganizationVersion
|
||
items: QARecord[]
|
||
columns: QAColumn[]
|
||
total: number
|
||
has_more: boolean
|
||
next_cursor: string
|
||
as_of: string
|
||
}
|
||
export interface QAQuery {
|
||
start: string
|
||
end: string
|
||
keyword: string
|
||
cursor: string
|
||
limit?: number
|
||
}
|
||
export interface QAStatus {
|
||
state: 'disabled' | 'unavailable' | 'blocked' | 'connected'
|
||
code: string
|
||
warnings: string[]
|
||
read_only: true
|
||
source_version: '2.0'
|
||
channel: 'dingtalk'
|
||
}
|
||
|
||
const invalid = (): never => {
|
||
throw new Error('问答运营响应无效,请联系管理员检查接口契约')
|
||
}
|
||
const object = (value: unknown): Record<string, unknown> => {
|
||
if (!value || typeof value !== 'object' || Array.isArray(value)) return invalid()
|
||
return value as Record<string, unknown>
|
||
}
|
||
const text = (value: unknown): string => (typeof value === 'string' ? value : invalid())
|
||
const count = (value: unknown): number =>
|
||
typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : invalid()
|
||
const instant = (value: unknown): string => {
|
||
const result = text(value)
|
||
if (!result || Number.isNaN(Date.parse(result))) return invalid()
|
||
return result
|
||
}
|
||
const columnKeys = new Set<string>(qaColumns.map(({ key }) => key))
|
||
|
||
export function parseQARecord(value: unknown): QARecord {
|
||
const row = object(value)
|
||
const feedback = object(row.feedback)
|
||
const source = object(row.source_coverage)
|
||
const coverage = object(row.coverage)
|
||
if (coverage.state !== 'pending' && coverage.state !== 'checked') return invalid()
|
||
if (coverage.verdict !== undefined && coverage.verdict !== 'uncovered') return invalid()
|
||
if (coverage.state === 'checked' && coverage.verdict !== 'uncovered') return invalid()
|
||
const askerValue = text(feedback.asker_value)
|
||
if (!['', 'up', 'down'].includes(askerValue)) return invalid()
|
||
const item: QARecord = {
|
||
id: text(row.id),
|
||
status: text(row.status),
|
||
question: text(row.question),
|
||
answer: text(row.answer),
|
||
asked_at: instant(row.asked_at),
|
||
time_source: text(row.time_source),
|
||
asker: text(row.asker),
|
||
trigger_person: text(row.trigger_person),
|
||
department: text(row.department),
|
||
region: text(row.region),
|
||
references: row.references,
|
||
media: row.media,
|
||
source_coverage: {
|
||
verdict: text(source.verdict),
|
||
reason_code: text(source.reason_code),
|
||
evaluator_version: text(source.evaluator_version),
|
||
},
|
||
feedback: { asker_value: askerValue, up: count(feedback.up), down: count(feedback.down) },
|
||
coverage: { state: coverage.state, verdict: coverage.verdict, rule_version: text(coverage.rule_version) },
|
||
}
|
||
if (!item.id || !item.coverage.rule_version) return invalid()
|
||
if (coverage.matched_text !== undefined) item.coverage.matched_text = text(coverage.matched_text)
|
||
for (const key of ['question_chinese', 'product_category', 'problem_type', 'root_cause', 'language'] as const) {
|
||
if (row[key] !== undefined) item[key] = text(row[key])
|
||
}
|
||
if (row.is_correct !== undefined) {
|
||
if (typeof row.is_correct !== 'boolean' && row.is_correct !== null) return invalid()
|
||
item.is_correct = row.is_correct
|
||
}
|
||
if (row.organization !== undefined) {
|
||
const o = object(row.organization)
|
||
if (
|
||
!Array.isArray(o.departments) ||
|
||
![
|
||
'matched',
|
||
'unassigned',
|
||
'cross_region',
|
||
'unmatched',
|
||
'identity_conflict',
|
||
'no_identity',
|
||
'directory_missing',
|
||
].includes(text(o.state))
|
||
)
|
||
return invalid()
|
||
const origin = (v: unknown) => {
|
||
const s = text(v)
|
||
return ['source_snapshot', 'current_directory', 'unavailable'].includes(s) ? s : invalid()
|
||
}
|
||
item.organization = {
|
||
version: parseQAOrganizationVersion(o.version),
|
||
state: text(o.state),
|
||
departments: o.departments.map(text),
|
||
region: text(o.region),
|
||
source_department: text(o.source_department),
|
||
source_region: text(o.source_region),
|
||
department_origin: origin(o.department_origin),
|
||
region_origin: origin(o.region_origin),
|
||
}
|
||
}
|
||
return item
|
||
}
|
||
|
||
export function parseQARecordPage(value: unknown): QARecordPage {
|
||
const page = object(value)
|
||
if (!Array.isArray(page.items) || !Array.isArray(page.columns) || typeof page.has_more !== 'boolean') return invalid()
|
||
const items = page.items.map(parseQARecord)
|
||
const columns = page.columns.map((key) =>
|
||
typeof key === 'string' && columnKeys.has(key) ? (key as QAColumn) : invalid()
|
||
)
|
||
const total = count(page.total)
|
||
const nextCursor = text(page.next_cursor)
|
||
if (total < items.length || (page.has_more && (!items.length || !nextCursor)) || (!page.has_more && nextCursor))
|
||
return invalid()
|
||
if (new Set(items.map(({ id }) => id)).size !== items.length || new Set(columns).size !== columns.length)
|
||
return invalid()
|
||
return {
|
||
items,
|
||
columns,
|
||
total,
|
||
has_more: page.has_more,
|
||
next_cursor: nextCursor,
|
||
as_of: instant(page.as_of),
|
||
...(page.organization === undefined ? {} : { organization: parseQAOrganizationVersion(page.organization) }),
|
||
}
|
||
}
|
||
|
||
export async function getPayload(
|
||
path: string,
|
||
signal?: AbortSignal,
|
||
request: Pick<RequestInit, 'method' | 'headers' | 'body'> = {}
|
||
): Promise<unknown> {
|
||
const response = await fetch(path, { ...request, credentials: 'same-origin', cache: 'no-store', signal })
|
||
const raw: unknown = await response.json().catch(() => null)
|
||
if (!response.ok) {
|
||
const payload = raw && typeof raw === 'object' ? (raw as Record<string, unknown>) : null
|
||
throw new Error(typeof payload?.error === 'string' ? payload.error : `问答数据读取失败(HTTP ${response.status})`)
|
||
}
|
||
return object(raw).data
|
||
}
|
||
|
||
export async function fetchQARecords(query: QAQuery, signal?: AbortSignal): Promise<QARecordPage> {
|
||
const parameters = new URLSearchParams({
|
||
start: query.start,
|
||
end: query.end,
|
||
keyword: query.keyword,
|
||
cursor: query.cursor,
|
||
limit: String(query.limit ?? 20),
|
||
})
|
||
return parseQARecordPage(await getPayload(`/api/v1/qa-ops/records?${parameters}`, signal))
|
||
}
|
||
export async function fetchQARecord(id: string, signal?: AbortSignal): Promise<QARecord> {
|
||
return parseQARecord(await getPayload(`/api/v1/qa-ops/records/${encodeURIComponent(id)}`, signal))
|
||
}
|
||
export async function fetchQAStatus(signal?: AbortSignal): Promise<QAStatus> {
|
||
const value = object(await getPayload('/api/v1/qa-ops/status', signal))
|
||
if (
|
||
!['disabled', 'unavailable', 'blocked', 'connected'].includes(text(value.state)) ||
|
||
!Array.isArray(value.warnings) ||
|
||
value.read_only !== true ||
|
||
value.source_version !== '2.0' ||
|
||
value.channel !== 'dingtalk'
|
||
)
|
||
return invalid()
|
||
return {
|
||
state: value.state as QAStatus['state'],
|
||
code: text(value.code),
|
||
warnings: value.warnings.map(text),
|
||
read_only: true,
|
||
source_version: '2.0',
|
||
channel: 'dingtalk',
|
||
}
|
||
}
|
||
|
||
export function qaCellValue(item: QARecord, column: QAColumn): string | null {
|
||
if (column === 'coverage') return item.coverage.verdict === 'uncovered' ? '否' : null
|
||
if (column === 'is_correct') return typeof item.is_correct === 'boolean' ? (item.is_correct ? '是' : '否') : null
|
||
if (column === 'feedback') {
|
||
if (item.feedback.asker_value === 'up') return '是'
|
||
if (item.feedback.asker_value === 'down') return '否(点踩)'
|
||
if (item.feedback.up || item.feedback.down) return `其他人:赞 ${item.feedback.up} / 踩 ${item.feedback.down}`
|
||
return null
|
||
}
|
||
if (column === 'asked_at') return new Date(item.asked_at).toLocaleString('zh-CN', { hour12: false })
|
||
return item[column] || null
|
||
}
|