This commit is contained in:
gr
2026-11-16 09:28:25 +08:00
parent 6a2b387edc
commit 44f26dc038
152 changed files with 15331 additions and 1538 deletions
@@ -0,0 +1,17 @@
import { beforeEach, describe, expect, it, vi } from 'vitest';
const post = vi.hoisted(() => vi.fn());
vi.mock('#/api/request', () => ({ requestClient: { post } }));
import { previewKnowledgeReview } from './knowledge';
describe('knowledge full review preview mode', () => {
beforeEach(() => { post.mockReset(); });
it('keeps approve as the backwards-compatible default', async () => {
await previewKnowledgeReview(-1);
expect(post).toHaveBeenCalledExactlyOnceWith('/knowledge/review-tasks/preview?account_id=-1&mode=approve', {}, { timeout: 120000 });
});
it('sends the immutable combined mode with the chosen account', async () => {
await previewKnowledgeReview(7, 'approve_publish');
expect(post).toHaveBeenCalledExactlyOnceWith('/knowledge/review-tasks/preview?account_id=7&mode=approve_publish', {}, { timeout: 120000 });
});
});
+64 -10
View File
@@ -1,5 +1,7 @@
import { requestClient } from '#/api/request';
export type KnowledgeContentType = 'daily_communication' | 'medical' | 'standard_answer';
export interface KnowledgeItem {
id: string;
tenant_id: string;
@@ -11,6 +13,7 @@ export interface KnowledgeItem {
answer: string;
conditions: string;
category: string;
content_type?: KnowledgeContentType | null;
kind: 'case' | 'procedure' | 'qa';
status: string;
revision: number;
@@ -18,13 +21,43 @@ export interface KnowledgeItem {
flags: string[];
updated_at: string;
vector_status: string;
sources?: { content: string; message_id: string; role: string; sent_at: string; version_no: number }[];
review_assignment?: KnowledgeReviewAssignment | null;
self_review_blocked?: boolean;
sources?: KnowledgeSource[];
history?: { action: string; actor_id: number; created_at: string; revision: number }[];
}
export interface KnowledgeSource {
content: string;
message_id: string;
role: string;
sent_at: string;
version_no: number;
}
export interface KnowledgeReviewAssignment {
assignee_id: number;
assignee_name: string;
assigned_at: string;
}
export interface KnowledgeReviewAssignee { id: number; username: string; name: string }
export const MAX_KNOWLEDGE_REVIEW_ASSIGNMENTS = 100;
type KnowledgeReviewEntry = Pick<KnowledgeItem, 'id' | 'revision'>;
export type KnowledgeReviewDraft = Pick<KnowledgeItem, 'answer' | 'category' | 'conditions' | 'content_type' | 'kind' | 'question' | 'title' | 'valid_until'>;
export type MyKnowledgeReview = KnowledgeReviewDraft & Pick<KnowledgeItem, 'flags' | 'id' | 'revision' | 'self_review_blocked' | 'status'> & {
review_assignment: { id: string; assigned_at: string };
sources?: Pick<KnowledgeSource, 'content' | 'role' | 'sent_at'>[];
};
export interface KnowledgeReviewPolicy { allow_self_review: boolean }
export interface KnowledgeModel { id: string; name: string; model: string; kind: string; default: boolean }
export interface KnowledgeOverview {
knowledge_scope: { mode: 'existing' | 'zyt_account'; account_ids: number[] };
counts: Record<string, number>;
settings: null | { enabled: boolean; updated_at: string };
semantic_configured: boolean;
@@ -55,18 +88,38 @@ function path(resource: string, accountId: number, extra: Record<string, number
export const fetchKnowledgeOverview = (id: number, signal?: AbortSignal) =>
requestClient.get<KnowledgeOverview>(path('overview', id), { signal });
export const fetchKnowledgeItems = (id: number, status: string, query: string, page: number, signal?: AbortSignal) =>
requestClient.get<{ items: KnowledgeItem[]; total: number }>(path('items', id, { page, query, status }), { signal });
export const fetchKnowledgeItems = (id: number, status: string, query: string, page: number, pageSize: number, signal?: AbortSignal) =>
requestClient.get<{ items: KnowledgeItem[]; total: number }>(path('items', id, { page, page_size: pageSize, query, status }), { signal });
export const fetchKnowledgeItem = (id: number, item: string) =>
requestClient.get<KnowledgeItem>(path(`items/${item}`, id));
export const saveKnowledgeItem = (id: number, item: KnowledgeItem) =>
requestClient.put<KnowledgeItem>(path(`items/${item.id}`, id), item);
export const knowledgeItemAction = (id: number, item: KnowledgeItem, action: string, confirmed = false, restoreRevision = 0) =>
requestClient.post<KnowledgeItem>(path(`items/${item.id}/${action}`, id), { confirmed, restore_revision: restoreRevision, revision: item.revision });
export const fetchKnowledgeReviewAssignees = (id: number, items: KnowledgeReviewEntry[]) =>
requestClient.post<{ items: KnowledgeReviewAssignee[] }>(path('review-assignees', id), { items });
export const setKnowledgeReviewAssignee = (id: number, items: KnowledgeReviewEntry[], assigneeId: number | null) =>
requestClient.put<{ updated: number }>(path('review-assignments', id), { assignee_id: assigneeId, items });
export const fetchMyKnowledgeReviews = (page: number, signal?: AbortSignal) =>
requestClient.get<{ items: MyKnowledgeReview[]; total: number }>(`/knowledge/my-reviews?page=${page}`, { signal });
export const fetchMyKnowledgeReview = (item: string) =>
requestClient.get<MyKnowledgeReview>(`/knowledge/my-reviews/${item}`);
export const saveMyKnowledgeReview = (item: string, body: KnowledgeReviewDraft & { assignment_id: string; revision: number }) =>
requestClient.put<MyKnowledgeReview>(`/knowledge/my-reviews/${item}`, body);
export const decideMyKnowledgeReview = (item: MyKnowledgeReview, action: 'approve' | 'approve_publish' | 'reject') =>
requestClient.post<{ status: string }>(`/knowledge/my-reviews/${item.id}/${action}`, {
assignment_id: item.review_assignment.id, revision: item.revision, confirmed: true,
});
export const fetchKnowledgeReviewPolicy = () =>
requestClient.get<KnowledgeReviewPolicy>('/knowledge/review-policy');
export const setKnowledgeReviewPolicy = (allowSelfReview: boolean) =>
requestClient.put<KnowledgeReviewPolicy>('/knowledge/review-policy', { allow_self_review: allowSelfReview });
export const fetchKnowledgeModels = (id = -1) =>
requestClient.get<{ items: KnowledgeModel[] }>(path('models', id));
export const searchKnowledge = (id: number, query: string) =>
requestClient.post<KnowledgeSearch>(path('search', id), { query });
export const searchKnowledge = (id: number, query: string, signal?: AbortSignal) =>
requestClient.post<KnowledgeSearch>(path('search', id), { query }, { signal });
export const setKnowledgeEnabled = (id: number, enabled: boolean) =>
requestClient.put(path('settings', id), { enabled });
export const fetchKnowledgeTraces = (id: number, signal?: AbortSignal) =>
@@ -173,8 +226,8 @@ export interface KnowledgeModelTest {
export interface KnowledgeRunScope { account_ids: number[]; date_from: string; date_to: string }
export const previewKnowledgeRun = (scope: KnowledgeRunScope) =>
requestClient.post<KnowledgeRunPreview>('/knowledge/runs/preview', scope, { timeout: 120000 });
export const previewKnowledgeRun = (scope: KnowledgeRunScope, signal?: AbortSignal) =>
requestClient.post<KnowledgeRunPreview>('/knowledge/runs/preview', scope, { timeout: 120000, signal });
export const createKnowledgeRun = (body: KnowledgeRunScope & KnowledgeWashOptions & { auto_watch: boolean; staff_confirmed: boolean }) =>
requestClient.post<KnowledgeRun>('/knowledge/runs', body, { timeout: 120000 });
export const fetchKnowledgeRuns = (signal?: AbortSignal) =>
@@ -189,9 +242,10 @@ export const testKnowledgeModel = (modelProviderId: string, timeout = 90) =>
requestClient.post<KnowledgeModelTest>('/knowledge/models/test',
{ model_provider_id: modelProviderId, model_timeout_seconds: timeout }, { timeout: 200000 });
export type KnowledgeReviewMode = 'approve' | 'approve_publish';
export interface KnowledgeReviewJob {
id: string; account_id: number; scope_label: string; status: string; total: number; processed: number;
approved: number; skipped: number; error: string; created_at: string; progress_percent: number;
mode: KnowledgeReviewMode; approved: number; published: number; skipped: number; error: string; created_at: string; progress_percent: number;
preview: { total: number; eligible: number; blocked: number; snapshot_at: string;
reasons: { code: string; reason: string; count: number }[];
accounts: { tenant_id: string; name: string; total: number; eligible: number }[] };
@@ -200,8 +254,8 @@ export interface KnowledgeReviewResult {
item_id: string; tenant_id: string; revision: number; result: string; reason: string; reason_text: string;
title: string; account_id: number; account_name: string;
}
export const previewKnowledgeReview = (accountId: number) =>
requestClient.post<KnowledgeReviewJob>(path('review-tasks/preview', accountId), {}, { timeout: 120000 });
export const previewKnowledgeReview = (accountId: number, mode: KnowledgeReviewMode = 'approve') =>
requestClient.post<KnowledgeReviewJob>(path('review-tasks/preview', accountId, { mode }), {}, { timeout: 120000 });
export const fetchKnowledgeReviewJobs = (signal?: AbortSignal) =>
requestClient.get<{ items: KnowledgeReviewJob[] }>('/knowledge/review-tasks', { signal });
export const knowledgeReviewAction = (jobId: string, action: string, confirmed = false) =>
@@ -0,0 +1,57 @@
import { createApp, defineComponent, h, nextTick, ref } from 'vue';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
const api = vi.hoisted(() => ({ fetchDesktopAccounts: vi.fn() }));
vi.mock('#/api/console', () => ({ ALL_ACCOUNTS: -1, fetchDesktopAccounts: api.fetchDesktopAccounts }));
vi.mock('#/locales/t', () => ({ t: (value: string, args?: Record<string, string>) =>
args ? `${args.name} (${args.code})` : value }));
vi.mock('ant-design-vue', () => {
const plain = defineComponent({ setup: (_props, { slots }) => () => h('div', slots.default?.()) });
return { Select: Object.assign(plain, { Option: plain }) };
});
import Selector from './archive-account-selector.vue';
let cleanup: (() => void) | undefined;
const response = { can_view_legacy: true, accounts: [
{ id: 1, nickname: 'own client', zyt_sn: 'own' }, { id: 2, nickname: 'other client', zyt_sn: 'other' },
] };
async function settle() { for (let i = 0; i < 8; i++) { await Promise.resolve(); await nextTick(); } }
function mount(allowed?: number[]) {
const ids = ref(allowed); const selected = ref(-1); const changed = vi.fn();
const host = document.createElement('div'); document.body.append(host);
const app = createApp(defineComponent({ setup: () => () => h(Selector, {
modelValue: selected.value, allowedIds: ids.value,
'onUpdate:modelValue': (value: number) => { selected.value = value; }, onChange: changed,
}) }));
app.mount(host); cleanup = () => { app.unmount(); host.remove(); };
return { host, ids, selected, changed };
}
describe('optional knowledge account restrictions', () => {
beforeEach(() => { localStorage.clear(); api.fetchDesktopAccounts.mockResolvedValue(response); });
afterEach(() => cleanup?.());
it('keeps all authorized archive choices and legacy data when the prop is omitted', async () => {
const { host } = mount(); await settle();
expect(host.textContent).toContain('own client'); expect(host.textContent).toContain('other client');
expect(host.textContent).toContain('旧版未归属数据');
});
it('hides other clients and legacy data and resets a remembered account outside knowledge scope', async () => {
localStorage.setItem('wecom-archive-account-scope', '2');
const { host, selected, changed } = mount([1]); await settle();
expect(host.textContent).toContain('own client'); expect(host.textContent).not.toContain('other client');
expect(host.textContent).not.toContain('旧版未归属数据'); expect(selected.value).toBe(-1);
expect(changed).toHaveBeenCalledWith(-1);
});
it('treats an empty allowed list as empty and resets an account when the scope narrows', async () => {
localStorage.setItem('wecom-archive-account-scope', '1');
const { host, ids, selected, changed } = mount([1]); await settle(); expect(selected.value).toBe(1);
ids.value = []; await settle();
expect(selected.value).toBe(-1); expect(changed).toHaveBeenLastCalledWith(-1);
expect(host.textContent).toContain('全部账号'); expect(host.textContent).not.toMatch(/own client|other client|旧版未归属数据/);
});
it('does not expose other accounts when their request finishes before scope resolution', async () => {
const { host, ids } = mount([]); await settle();
expect(host.textContent).not.toMatch(/own client|other client|旧版未归属数据/);
ids.value = [1]; await settle();
expect(host.textContent).toContain('own client'); expect(host.textContent).not.toContain('other client');
});
});
@@ -1,14 +1,14 @@
<script setup lang="ts">
import type { DesktopAccountItem } from '#/api/console';
import { onMounted, ref } from 'vue';
import { computed, onMounted, ref, watch } from 'vue';
import { Select } from 'ant-design-vue';
import { ALL_ACCOUNTS, fetchDesktopAccounts } from '#/api/console';
import { t } from '#/locales/t';
const props = defineProps<{ modelValue: number; disabled?: boolean }>();
const props = defineProps<{ modelValue: number; disabled?: boolean; allowedIds?: number[] }>();
const emit = defineEmits<{
change: [value: number];
'update:modelValue': [value: number];
@@ -17,6 +17,11 @@ const accounts = ref<DesktopAccountItem[]>([]);
const canViewLegacy = ref(false);
const loading = ref(false);
const dropdownOpen = ref(false);
const visibleAccounts = computed(() => props.allowedIds === undefined ? accounts.value
: accounts.value.filter((account) => props.allowedIds!.includes(account.id)));
const showLegacy = computed(() => canViewLegacy.value && props.allowedIds === undefined);
const allowed = (value: number) => value === ALL_ACCOUNTS
|| (value === 0 && showLegacy.value) || visibleAccounts.value.some((item) => item.id === value);
defineExpose({ open: () => { dropdownOpen.value = true; } });
// 换了 key(原来是 wecom-archive-account-id)。不换的话,所有老浏览器里都
@@ -26,12 +31,18 @@ defineExpose({ open: () => { dropdownOpen.value = true; } });
const STORAGE_KEY = 'wecom-archive-account-scope';
function choose(value: number) {
if (!allowed(value)) value = ALL_ACCOUNTS;
dropdownOpen.value = false;
localStorage.setItem(STORAGE_KEY, String(value));
emit('update:modelValue', value);
emit('change', value);
}
// Knowledge may narrow this shared selector; other archive pages omit allowedIds.
watch(() => props.allowedIds, () => {
if (!allowed(props.modelValue)) choose(ALL_ACCOUNTS);
}, { flush: 'sync' });
onMounted(async () => {
loading.value = true;
try {
@@ -42,7 +53,7 @@ onMounted(async () => {
// 记住的账号可能已经被停用或移出授权范围,这时退回「全部」,而不是把人
// 卡在一个查不出数据的账号上。
const value =
saved === ALL_ACCOUNTS || (saved === 0 && canViewLegacy.value) || accounts.value.some((item) => item.id === saved)
allowed(saved)
? saved
: ALL_ACCOUNTS;
if (value !== props.modelValue) emit('update:modelValue', value);
@@ -64,8 +75,8 @@ onMounted(async () => {
@change="(value) => choose(Number(value))"
>
<Select.Option :value="ALL_ACCOUNTS">{{ t('全部账号') }}</Select.Option>
<Select.Option v-if="canViewLegacy" :value="0">{{ t('旧版未归属数据') }}</Select.Option>
<Select.Option v-for="item in accounts" :key="item.id" :value="item.id">
<Select.Option v-if="showLegacy" :value="0">{{ t('旧版未归属数据') }}</Select.Option>
<Select.Option v-for="item in visibleAccounts" :key="item.id" :value="item.id">
{{ t('{name}({code})', { code: item.zyt_sn, name: item.nickname || item.zyt_sn }) }}
</Select.Option>
</Select>
@@ -6,6 +6,15 @@
export default {
// ── 知识中心(center.vue) ──────────────────────────────────────────
'知识中心': 'Knowledge',
'内容标记': 'Content label',
'标准答案': 'Standard answer',
'日常生活沟通': 'Everyday communication',
'医疗': 'Medical',
'未标注': 'Unlabeled',
'清除标记': 'Clear label',
'需要知识审核权限才能查看知识与审核记录。': 'Knowledge review permission is required to view managed knowledge and review records.',
'本人 ZYT 账号暂无可用客户端。': 'Your ZYT account has no available client accounts.',
'当前仅显示本人 ZYT 账号名下的知识,包含管理员代为清洗的数据;操作仍按角色权限': 'Only knowledge under your ZYT account is shown, including data processed by an administrator on your behalf; actions still follow your role permissions.',
'把历史聊天整理成可追溯的知识,审核发布后供客服回答时参考。': 'Turn chat history into traceable knowledge. Once reviewed and published, it is used as a reference when answering customers.',
'点「整理聊天记录」可一次整理全部账号的聊天;点知识标题可直接查看、审核和发布。': 'Click "Process chat history" to process the chats of all accounts at once; click a knowledge title to view, review and publish it.',
'当前账号尚无聊天归档,请先上传归档或更换账号。': 'This account has no chat archive yet. Upload an archive first or switch accounts.',
@@ -147,6 +156,8 @@ export default {
'预览后知识版本或状态已变化': 'Version or status changed after the preview',
'知识已删除': 'Knowledge deleted',
'该账号已不在当前授权范围': 'This account is no longer within your authorized scope',
'搜索索引写入失败;草稿保留,请排查后重新预览': 'Search indexing failed; the draft is preserved. Resolve the issue and preview again',
'发布校验失败;草稿保留,请编辑后重新预览': 'Publication checks failed; the draft is preserved. Edit it and preview again',
// ── 整理任务(runs-panel.vue、run-format.ts) ───────────────────────
'已取消,已生成的草稿保留': 'Cancelled; drafts already generated are kept',
@@ -332,6 +343,9 @@ export default {
'有效期:{date}': 'Valid until: {date}',
'已核对本条来源、事实、脱敏和适用条件;涉及医疗内容已完成专业审核。': 'I have checked the source, facts, redaction and conditions of this item; any medical content has passed professional review.',
'打开单条审核与编辑': 'Open to review and edit',
'编辑草稿': 'Edit draft',
'取消编辑': 'Cancel editing',
'请保存草稿或取消编辑,再继续批量审核。': 'Save the draft or cancel editing before continuing the batch review.',
'当前操作完成后停止': 'Stopping after the current item',
'停止后续操作': 'Stop the rest',
'完成': 'Done',
@@ -345,4 +359,81 @@ export default {
'新聊天自动整理用': 'Auto-processing of new chats uses',
'规则提取(不花模型费用)': 'Rule extraction (no model cost)',
'模型清洗(用上面的默认模型,每段新对话调用一次)': 'Model cleaning (the default model above, one call per new conversation)',
// Review actions and scope confirmation.
'批量审核并发布 · {count} 条': 'Batch review and publish · {count} items',
'确认审核并发布 {count} 条': 'Confirm review and publish {count} items',
'请核对所选知识的来源、事实、脱敏和适用条件。点击下方确认按钮后执行,可展开查看详情;不符合条件的条目会跳过。': 'Check the sources, facts, redaction and conditions of the selected knowledge. Use the confirmation button below to proceed. Expand an item for details; ineligible items will be skipped.',
'审核通过后进入待发布,发布后才可检索。': 'Approved items move to Awaiting publication. They become searchable after publication.',
'等待进行中的操作完成后停止': 'Waiting for in-flight actions before stopping',
'保存并审核发布': 'Save, review and publish',
'保存并审核通过': 'Save and approve',
'审核并发布': 'Review and publish',
'审核通过,已进入待发布': 'Approved and awaiting publication',
'已审核并发布': 'Reviewed and published',
'审核全部草稿': 'Review all drafts',
'审核并发布选中': 'Review and publish selected',
'审核选中': 'Review selected',
'更多操作': 'More actions',
'审核操作会先保存修改,再按保存后的版本执行;失败时不会自动重试。': 'The review action saves your changes first, then uses the saved revision. Failed actions are not retried automatically.',
'请核对来源、事实、脱敏与适用条件,点击审核按钮即确认当前内容。': 'Check the sources, facts, redaction and conditions. Clicking the review button confirms the current content.',
'正在统计所选范围的待审草稿…': 'Counting pending drafts in the selected scope…',
'重新统计范围': 'Recount scope',
'请确认以上账号范围和数量,并核对事实、脱敏与适用条件。点击下方按钮后,符合条件的草稿将进入待发布。': 'Confirm the account scope and count above, and check the facts, redaction and conditions. The button below moves eligible drafts to Awaiting publication.',
'确认审核 {count} 条并进入待发布': 'Confirm review of {count} items and mark ready for publication',
'上一项操作仍在完成,请稍候。': 'The previous action is still finishing. Please wait.',
'审核并发布全部草稿': 'Review and publish all drafts',
'全量审核并发布': 'Full review and publication',
'当前范围包含已整理出的全部待审核知识草稿,覆盖所有页面,不受列表搜索与勾选影响。符合条件的草稿将审核并发布,可供客服检索使用。': 'The current scope includes all processed drafts pending review, across every page, regardless of list search and selection. Eligible drafts will be reviewed and published for customer service retrieval.',
'当前预览范围:': 'Current preview scope: ',
'审核通过后进入待发布': 'Approve as ready for publication',
'可审核并发布': 'Ready to review and publish',
'请核对以上账号范围、数量及知识内容。点击下方按钮后执行审核并发布;全部成功后自动关闭此弹窗并刷新知识列表,需处理的条目会保留结果。': 'Check the account scope, count and knowledge content above. The button below reviews and publishes the drafts. When all succeed, this dialog closes and the knowledge list refreshes. Results stay visible for items that need attention.',
'一键审核并发布 {count} 条': 'Review and publish {count} items',
'已审核并发布 {count} 条': 'Reviewed and published {count} items',
'已发布 {published} · 已审核 {approved} · 需处理 {skipped}': 'Published {published} · Reviewed {approved} · Need attention {skipped}',
'已发布的知识保留发布状态,尚未处理的草稿保持原状态。': 'Published knowledge stays published. Unprocessed drafts keep their current status.',
'待我审核': 'My reviews',
'搜索标题': 'Search titles',
'每页条数': 'Rows per page',
'自定义每页条数': 'Custom rows per page',
'应用': 'Apply',
'请输入 1 到 2000 之间的整数。': 'Enter an integer from 1 to 2000.',
'每次最多指派或撤回 {limit} 条草稿。': 'You can assign or withdraw up to {limit} drafts at a time.',
'指派给我的草稿': 'Drafts assigned to me',
'审核全部指派草稿': 'Review all assigned drafts',
'审核并发布全部指派草稿': 'Review and publish all assigned drafts',
'此任务只处理指派给你的待审核草稿,覆盖所有页面。': 'This task covers all pages of drafts assigned to you for review.',
'请核对草稿数量、事实、脱敏与适用条件后再确认。': 'Check the draft count, facts, redaction and conditions before confirming.',
'结果清单仅显示此任务处理的指派草稿。': 'Results show drafts assigned to you that were included in this task.',
'审核范围': 'Review scope',
'知识详情与来源': 'Knowledge details and sources',
'打开知识详情': 'Open knowledge details',
'整理聊天记录后,可在指派管理中选择草稿和审核人。': 'After processing chat history, select drafts and reviewers in Assignment management.',
'点「整理聊天记录」生成草稿,再指派审核人。': 'Process chat history to generate drafts, then assign reviewers.',
'审核人在「待我审核」中核对草稿与来源。审核通过的知识可以发布。': 'Reviewers check drafts and sources in My reviews. Approved knowledge is ready to publish.',
'当前显示全部授权账号的指派和发布状态。检索测试、导出和「客服使用知识」开关需选择具体账号。': 'Assignments and publication status cover all authorized accounts. Select an account to test retrieval, export, or enable knowledge for customer service.',
'指派审核': 'Assign review',
'审核人': 'Reviewer',
'未指派': 'Unassigned',
'指派审核 · {count} 条草稿': 'Assign review · {count} drafts',
'请只选择待审核草稿': 'Select only drafts awaiting review',
'请选择审核人': 'Select a reviewer',
'当前没有能审核所选草稿的用户': 'No eligible reviewer for the selected drafts',
'选择审核人后,所选草稿将由此人审核。': 'The selected reviewer will review these drafts.',
'确认指派': 'Confirm assignment',
'撤回指派': 'Withdraw assignment',
'已撤回 {count} 条指派': 'Withdrew {count} assignments',
'已指派 {count} 条草稿': 'Assigned {count} drafts',
'指派时间': 'Assigned at',
'这里只显示指派给你的待审核草稿。审核通过后进入待发布。': 'Drafts assigned to you for review appear here. Approved drafts await publication.',
'暂无指派给你的待审核草稿': 'No drafts assigned to you for review',
'请先保存草稿再审核。': 'Save the draft before reviewing it.',
'确认驳回': 'Confirm rejection',
'自己的知识须由他人审核': 'Knowledge from your account requires another reviewer',
'审核设置': 'Review settings',
'审核设置已保存': 'Review settings saved',
'允许审核本人账号的知识': 'Allow users to review knowledge from their own accounts',
'此设置适用于所有账号。关闭后,本人账号下的知识必须由其他审核人通过或驳回。': 'Applies to all accounts. When disabled, another reviewer must approve or reject knowledge from a user’s own account.',
} as Record<string, string>;
@@ -7,6 +7,9 @@ export default {
'账号与授权': 'Account and authorization',
'知识中心': 'Knowledge',
'知识加工与检索': 'Knowledge Workbench',
'指派管理': 'Assignment Management',
'整理任务': 'Processing jobs',
'检索测试': 'Search test',
'AI 模型': 'AI Models',
'模型清单': 'Model List',
'角色编排': 'Role Orchestration',
@@ -68,6 +68,15 @@ export default {
// ── 条目类型与来源 permission-menu.ts ───────────────────────────────────────
'按钮': 'Button',
'数据权限': 'Data scope',
'ZYT 账号或客服本地账号': 'ZYT account or local customer service account',
'请输入账号': 'Enter your account',
'ZYT 密码或客服本地密码': 'ZYT password or local customer service password',
'ZYT 首次登录为基础用户,业务权限由客服管理员分配。': 'First-time ZYT users start with the basic role. A customer service administrator assigns business permissions.',
'管理员保留全部功能权限和全量数据范围,不能修改。': 'Administrators retain all functional permissions and the full data scope; this role cannot be edited.',
'数据权限:仅本人账号的知识': 'Data scope: only knowledge under my account',
'数据权限:勾选「仅本人账号的知识」后,仅显示本人 ZYT 账号名下的知识,包含管理员代为清洗的数据。未勾选沿用原范围;勾选整个知识中心也会包含此限制。操作权限仍需单独授权,管理员不受此限制。':
'Data scope: selecting "Only knowledge under my account" shows knowledge under your ZYT account, including data processed by an administrator on your behalf. Leaving it unchecked keeps the current scope. Selecting the whole Knowledge group also selects this restriction. Actions need separate grants; administrators are exempt.',
'菜单链接': 'Menu link',
'页面': 'Page',
'权限点': 'Permission point',
@@ -77,15 +86,18 @@ export default {
// ── 角色权限页 roles.vue ────────────────────────────────────────────────────
'角色编码不能为空': 'Role code is required',
'已保存,权限立即生效(无需重启,也无需重新登录)':
'Saved. Permissions take effect immediately (no restart or re-login needed)',
'已保存,后端权限立即生效;在线用户的菜单和按钮将在数秒内自动更新。':
'Saved. Backend permissions take effect immediately; menus and buttons for signed-in users update automatically within seconds.',
'编码': 'Code',
'权限(按菜单)': 'Permissions (by menu)',
'在用人数': 'Users',
'权限按左侧菜单组织:菜单 → 页面 → 页面里的每个按钮':
'Permissions follow the left menu: menu → page → each button on the page',
'改完立刻生效——不用重启服务,用户也不用重新登录。管理员角色不可削权(削了就没人能加回来),内置角色和仍有人在用的角色不可删除。要新增权限点或左侧菜单链接,去「系统管理 → 权限菜单」。':
'Changes take effect immediately: no service restart, and users do not need to sign in again. The administrator role cannot lose permissions (nobody could add them back), and built-in roles or roles still in use cannot be deleted. To add permission points or left-menu links, go to "System → Permission Menu".',
'后端权限修改后立即生效,无需重启或重新登录;在线用户的菜单和按钮将在数秒内自动更新,切回窗口时立即同步。管理员角色只读,内置角色和仍有人在用的角色不可删除。要新增权限点或左侧菜单链接,去「系统管理 → 权限菜单」。':
'Backend permission changes take effect immediately without a restart or sign-in. Menus and buttons for signed-in users update automatically within seconds and sync immediately when they return to the window. The administrator role is read-only; built-in roles and roles still in use cannot be deleted. To add permission points or left-menu links, go to "System → Permission Menu".',
'此角色的权限对所有使用它的账号生效;新集团账号默认使用此角色。':
'This role’s permissions apply to every account using it. New group accounts use this role by default.',
'集团基础用户': 'Group basic user',
'角色与权限': 'Roles and permissions',
'全部权限': 'All permissions',
'无权限': 'No permissions',
@@ -218,7 +230,7 @@ export default {
'保存存储配置': 'Save storage settings',
'测试连接': 'Test connection',
'导入聊天记录': 'Import chat records',
'查看知识中心(知识列表、详情、整理任务)': 'View knowledge (list, details, curation jobs)',
'查看知识中心(知识列表、详情)': 'View knowledge (list and details)',
'整理聊天记录(新建整理)': 'Curate chat records (new curation)',
'暂停 / 继续 / 取消整理、换模型': 'Pause / resume / cancel curation, switch model',
'修改整理设置': 'Change curation settings',
@@ -14,8 +14,7 @@ export default {
'账号与授权': 'Account and authorization',
'我的账号': 'My account',
',您已登录真羊 AI 客服管理后台。': ', you are signed in to the Zhenyang AI customer service console.',
'当前角色:集团基础用户': 'Current role: Group basic user',
'您的账号已建立,当前尚未获得业务权限。请联系本系统管理员分配角色。': 'Your account has been created but has no business permissions yet. Please contact the system administrator to assign a role.',
'您的账号已建立,当前尚未获得业务权限。请联系本系统管理员配置角色权限或分配其他业务角色。': 'Your account has been created but has no business permissions yet. Please contact the system administrator to configure role permissions or assign another business role.',
'您的角色已授权,可从左侧菜单进入相应功能。': 'Your role is authorized. Open the available features from the left menu.',
'刷新授权': 'Refresh authorization',
@@ -1,8 +1,10 @@
import type { RouteRecordRaw } from 'vue-router';
import { cloneDeep, generateRoutesByFrontend } from '@vben/utils';
import { describe, expect, it } from 'vitest';
import { firstMenuPath, parentPaths, pruneEmptyMenus } from './menu-access';
import consoleRoutes from './routes/modules/console';
const routes = [
{ children: [{ path: 'catalog' }], path: '/model' },
@@ -29,4 +31,22 @@ describe('menus after button-level filtering', () => {
])).toBe('/knowledge/center');
expect(firstMenuPath([])).toBeUndefined();
});
it.each([
[['knowledge:review:assign'], ['assignments']],
[['knowledge:read', 'knowledge:review', 'im:content:read'], ['center']],
[['knowledge:read', 'knowledge:review:assign'], ['center', 'assignments']],
[['knowledge:tasks:read'], ['tasks']],
[['knowledge:search'], ['search']],
[['knowledge:tasks:read', 'knowledge:search'], ['tasks', 'search']],
[['knowledge:review', 'knowledge:run', 'knowledge:run:control', 'knowledge:watch', 'im:content:read'], []],
])('filters the actual knowledge routes with %j', async (codes, visible) => {
const filtered = await generateRoutesByFrontend(cloneDeep(consoleRoutes), codes);
const knowledge = filtered.find((route) => route.path === '/knowledge');
expect(knowledge?.children?.map((route) => route.path) ?? []).toEqual(visible);
const knowledgeParent = consoleRoutes.find((route) => route.path === '/knowledge');
expect(knowledgeParent?.meta?.authority).toEqual([
'knowledge:read', 'knowledge:review:assign', 'knowledge:tasks:read', 'knowledge:search',
]);
});
});
@@ -13,6 +13,33 @@ import type { RouteRecordRaw } from 'vue-router';
* 角色界面才能按菜单勾选;漏了的话「系统管理 → 权限菜单」页会标出来。
* 多个码是"任一即可"。
*/
const knowledgePages = [
{
name: 'KnowledgeWorkspace',
path: 'center',
component: () => import('#/views/knowledge/center.vue'),
meta: { icon: 'lucide:library', title: '知识加工与检索', authority: ['knowledge:read'] },
},
{
name: 'KnowledgeAssignments',
path: 'assignments',
component: () => import('#/views/knowledge/assignments.vue'),
meta: { icon: 'lucide:clipboard-list', title: '指派管理', authority: ['knowledge:review:assign'] },
},
{
name: 'KnowledgeTasks',
path: 'tasks',
component: () => import('#/views/knowledge/tasks.vue'),
meta: { icon: 'lucide:list-todo', title: '整理任务', authority: ['knowledge:tasks:read'] },
},
{
name: 'KnowledgeSearch',
path: 'search',
component: () => import('#/views/knowledge/search.vue'),
meta: { icon: 'lucide:search', title: '检索测试', authority: ['knowledge:search'] },
},
];
const routes: RouteRecordRaw[] = [
{
name: 'GroupAccount',
@@ -27,13 +54,13 @@ const routes: RouteRecordRaw[] = [
{
name: 'KnowledgeCenter',
path: '/knowledge',
meta: { icon: 'lucide:book-open-check', order: 3, title: '知识中心', authority: ['knowledge:read'] },
children: [{
name: 'KnowledgeWorkspace',
path: 'center',
component: () => import('#/views/knowledge/center.vue'),
meta: { icon: 'lucide:library', title: '知识加工与检索', authority: ['knowledge:read'] },
}],
meta: {
icon: 'lucide:book-open-check',
order: 3,
title: '知识中心',
authority: knowledgePages.flatMap((page) => page.meta.authority),
},
children: knowledgePages,
},
{
meta: {
@@ -10,6 +10,7 @@ import {
branchKeys,
checkCode,
groupPermissions,
kindLabel,
pageMissing,
permissionTree,
REQUIRES,
@@ -38,6 +39,16 @@ const catalog = [
];
describe('permission menu grouping', () => {
it('labels own knowledge scope as data permission and preserves independent action grants', () => {
const own = item('knowledge:scope:own', '知识中心', '知识加工与检索');
const items = [...catalog, own];
expect(kindLabel(own.kind, own.code)).toBe('数据权限');
expect(checkCode([], own.code, true, items).sort()).toEqual(['knowledge:read', 'knowledge:scope:own']);
expect(checkCode(['knowledge:read', own.code], own.code, false, items)).toEqual(['knowledge:read']);
const all = groupPermissions(items).find((group) => group.group === '知识中心')!.codes;
expect(applyTreeCheck([], all, all, items)).toContain(own.code);
});
it('keeps the backend order and groups by menu then page', () => {
const groups = groupPermissions(catalog);
expect(groups.map((g) => g.group)).toEqual(['桌面端', '聊天归档', '知识中心', '常用链接']);
@@ -63,6 +74,11 @@ describe('permission menu grouping', () => {
expect(checkCode(['release:read', 'release:write'], 'release:read', false, catalog)).toEqual(['release:write']);
});
it.each(['knowledge:run', 'knowledge:run:control', 'knowledge:watch'])('grants the task page and source access with %s', (code) => {
const items = [...catalog, item('knowledge:tasks:read', '知识中心', '整理任务', 'page'), item(code, '知识中心', '整理任务')];
expect(checkCode([], code, true, items).sort()).toEqual(['im:content:read', code, 'knowledge:tasks:read'].sort());
});
it('flags a page whose actions are granted without the page itself', () => {
const page = groupPermissions(catalog)[0]!.pages[0]!;
expect(pageMissing(page, ['release:write'])).toBe(true);
@@ -134,10 +150,10 @@ describe('route ↔ permission menu sync check', () => {
'im:read', 'im:content:read', 'im:export', 'im:export:create', 'im:export:download', 'im:identity:read',
'im:identity:write', 'im:patient:bind', 'im:patient:unbind', 'im:storage:read', 'im:storage:write',
'im:storage:test', 'im:import',
'knowledge:read', 'knowledge:run', 'knowledge:run:control', 'knowledge:settings', 'knowledge:watch',
'knowledge:read', 'knowledge:tasks:read', 'knowledge:run', 'knowledge:run:control', 'knowledge:settings', 'knowledge:watch',
'knowledge:write', 'knowledge:restore', 'knowledge:delete', 'knowledge:review', 'knowledge:reject',
'knowledge:review:auto', 'knowledge:publish', 'knowledge:disable', 'knowledge:enable', 'knowledge:search',
'knowledge:export',
'knowledge:review:auto', 'knowledge:review:assign', 'knowledge:review:settings', 'knowledge:publish', 'knowledge:disable', 'knowledge:enable', 'knowledge:search',
'knowledge:export', 'knowledge:scope:own',
'role:read', 'role:create', 'role:write', 'role:delete', 'permission:read', 'permission:create',
'permission:write', 'permission:delete', 'user:read', 'user:create', 'user:write', 'user:status', 'audit:read',
];
@@ -23,7 +23,8 @@ export interface PermissionGroup {
}
// 写成函数而不是常量:t() 每次调用时读当前语言,切换语言后标签跟着变
export function kindLabel(kind: PermissionItem['kind']): string {
export function kindLabel(kind: PermissionItem['kind'], code?: string): string {
if (code === 'knowledge:scope:own') return t('数据权限');
const labels: Record<PermissionItem['kind'], string> = {
action: t('按钮'),
link: t('菜单链接'),
@@ -82,7 +83,7 @@ export function summarizeRole(
/** 知识中心里碰到聊天原文(来源证据)的按钮:后端同时要求能看正文。 */
const KNOWLEDGE_WITH_SOURCES = [
'knowledge:run', 'knowledge:run:control', 'knowledge:watch', 'knowledge:write', 'knowledge:restore',
'knowledge:write', 'knowledge:restore',
'knowledge:delete', 'knowledge:review', 'knowledge:reject', 'knowledge:review:auto', 'knowledge:publish',
'knowledge:disable',
];
@@ -91,9 +92,12 @@ const KNOWLEDGE_WITH_SOURCES = [
* 后端同时要求的码(缺一个就 403)。勾按钮时顺手勾上,免得配出"看得见、点不动"的角色。
* 同一页面的「页面」码由 checkCode 自动带上,这里只写跨页面的。
*/
export const REQUIRES: Record<string, string[]> = Object.fromEntries(
KNOWLEDGE_WITH_SOURCES.map((code) => [code, ['knowledge:read', 'im:content:read']]),
);
export const REQUIRES: Record<string, string[]> = {
...Object.fromEntries(KNOWLEDGE_WITH_SOURCES.map((code) => [code, ['knowledge:read', 'im:content:read']])),
'knowledge:run': ['im:content:read'],
'knowledge:run:control': ['im:content:read'],
'knowledge:watch': ['im:content:read'],
};
/**
* 勾上一个码:同一页面的「页面」码(能打开页面才谈得上操作)和 REQUIRES 里的码一起勾上。
@@ -248,7 +248,7 @@ onMounted(load);
</template>
<template v-else-if="column.key === 'kind' && record.item">
<Tag :color="record.item.kind === 'page' ? 'blue' : record.item.kind === 'link' ? 'purple' : undefined">
{{ kindLabel(record.item.kind as PermissionItem['kind']) }}
{{ kindLabel(record.item.kind as PermissionItem['kind'], record.item.code) }}
</Tag>
</template>
<template v-else-if="column.key === 'source' && record.item">
@@ -27,9 +27,10 @@ const open = ref(false);
const isNew = ref(false);
const form = reactive({ code: '', name: '', permissions: [] as string[] });
const protectedRole = (code: string) => code === 'admin' || code === 'zyt_basic';
const readonlyRole = (code: string) => code === 'admin';
const protectedRole = (code: string) => readonlyRole(code) || code === 'zyt_basic';
// 新增和修改是两个按钮:只能新增的人打开已有角色只能看
const readonly = computed(() => !(isNew.value ? canCreate.value : canWrite.value) || protectedRole(form.code));
const readonly = computed(() => !(isNew.value ? canCreate.value : canWrite.value) || readonlyRole(form.code));
/** 一级菜单 → 页面 → 权限码,和左侧菜单一一对应。 */
const grouped = computed(() => groupPermissions(permissions.value));
@@ -128,7 +129,7 @@ onMounted(load);
type="info"
show-icon
:message="t('权限按左侧菜单组织:菜单 → 页面 → 页面里的每个按钮')"
:description="t('后端权限修改后立即生效,无需重启或重新登录;在线用户的菜单和按钮将在数秒内自动更新,切回窗口时立即同步。管理员和集团基础用户角色只读,内置角色和仍有人在用的角色不可删除。要新增权限点或左侧菜单链接,去「系统管理 → 权限菜单」。')"
:description="t('后端权限修改后立即生效,无需重启或重新登录;在线用户的菜单和按钮将在数秒内自动更新,切回窗口时立即同步。管理员角色只读,内置角色和仍有人在用的角色不可删除。要新增权限点或左侧菜单链接,去「系统管理 → 权限菜单」。')"
/>
<Card :title="t('角色与权限')">
<template #extra>
@@ -161,7 +162,7 @@ onMounted(load);
</template>
<template v-else-if="column.key === 'action'">
<Button type="link" size="small" @click="openEdit(record as RoleItem)">
{{ canWrite && !protectedRole(record.code) ? t('编辑') : t('查看') }}
{{ canWrite && !readonlyRole(record.code) ? t('编辑') : t('查看') }}
</Button>
<Popconfirm :title="t('确定删除这个角色?')" @confirm="remove(record as RoleItem)">
<Button
@@ -191,10 +192,10 @@ onMounted(load);
</div>
<FormItem :label="t('权限')">
<p v-if="form.code === 'admin'" class="mb-2 text-xs text-gray-500">
{{ t('管理员始终拥有全部权限(包括以后新增的),不能修改。') }}
{{ t('管理员保留全部功能权限和全量数据范围,不能修改。') }}
</p>
<p v-else-if="form.code === 'zyt_basic'" class="mb-2 text-xs text-gray-500">
{{ t('集团基础用户固定无业务权限,不能修改。请到「系统管理 → 用户管理」为账号分配其他业务角色。') }}
{{ t('此角色的权限对所有使用它的账号生效;新集团账号默认使用此角色。') }}
</p>
<div class="mb-2 flex flex-wrap items-center gap-2">
<Input v-model:value="keyword" allow-clear size="small" class="w-60" :placeholder="t('搜索按钮名称或权限码')"
@@ -213,7 +214,8 @@ onMounted(load);
<template #title="{ dataRef }">
<span v-if="dataRef.item" class="inline-flex flex-wrap items-center gap-x-2">
<span>{{ dataRef.title }}</span>
<Tag v-if="dataRef.item.kind === 'page'" class="m-0" color="blue">{{ t('页面') }}</Tag>
<Tag v-if="dataRef.item.code === 'knowledge:scope:own'" class="m-0" color="orange">{{ t('数据权限') }}</Tag>
<Tag v-else-if="dataRef.item.kind === 'page'" class="m-0" color="blue">{{ t('页面') }}</Tag>
<Tag v-else-if="dataRef.item.kind === 'link'" class="m-0" color="purple">{{ t('菜单链接') }}</Tag>
<code class="text-xs text-gray-400">{{ dataRef.item.code }}</code>
</span>
@@ -231,6 +233,9 @@ onMounted(load);
<p class="mt-1 text-xs text-gray-500">
{{ t('勾菜单或页面 = 勾它下面全部按钮;提交的是最终状态,取消勾选就是收回该权限。勾选按钮时会自动带上它所在的页面和必需的权限。') }}
</p>
<p v-if="names.has('knowledge:scope:own')" class="mt-1 text-xs text-gray-500">
{{ t('数据权限:勾选「仅本人账号的知识」后,仅显示本人 ZYT 账号名下的知识,包含管理员代为清洗的数据。未勾选沿用原范围;勾选整个知识中心也会包含此限制。操作权限仍需单独授权,管理员不受此限制。') }}
</p>
<p
v-if="form.permissions.some((code) => !names.has(code))"
class="mt-1 text-xs text-orange-500"
@@ -13,9 +13,8 @@ function reloadAuthorization() { window.location.reload(); }
<div class="p-5">
<Card :title="t('账号与授权')">
<p class="mb-4">{{ user.userInfo?.realName || user.userInfo?.username }}{{ t(',您已登录真羊 AI 客服管理后台。') }}</p>
<p v-if="user.userInfo?.desc === 'zyt_basic'" class="mb-4">{{ t('当前角色:集团基础用户') }}</p>
<Alert v-if="!hasPermissions" type="info" show-icon
:message="t('您的账号已建立,当前尚未获得业务权限。请联系本系统管理员分配角色。')" />
:message="t('您的账号已建立,当前尚未获得业务权限。请联系本系统管理员配置角色权限或分配其他业务角色。')" />
<Alert v-else type="success" show-icon :message="t('您的角色已授权,可从左侧菜单进入相应功能。')" />
<Button class="mt-5" @click="reloadAuthorization">{{ t('刷新授权') }}</Button>
</Card>
@@ -0,0 +1,7 @@
<script setup lang="ts">
import KnowledgeCenter from './center.vue';
</script>
<template>
<KnowledgeCenter assignment-mode />
</template>
@@ -0,0 +1,218 @@
import type { MyKnowledgeReview } from '#/api/knowledge';
import type { BatchAction } from './batch';
import { createApp, defineComponent, h, KeepAlive, nextTick, ref } from 'vue';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
const api = vi.hoisted(() => ({ fetchMyKnowledgeReview: vi.fn(), decideMyKnowledgeReview: vi.fn(), saveMyKnowledgeReview: vi.fn(), fetchKnowledgeItem: vi.fn(), knowledgeItemAction: vi.fn() }));
vi.mock('#/api/knowledge', () => api);
vi.mock('#/locales/t', () => ({ t: (value: string) => value }));
vi.mock('ant-design-vue', async () => {
const { defineComponent, h } = await import('vue');
const plain = defineComponent({ setup: (_props, { slots }) => () => h('div', [slots.header?.(), slots.default?.()]) });
const textarea = defineComponent({
props: ['value', 'autofocus', 'disabled'],
emits: ['update:value'],
setup: (props, { emit }) => () => h('textarea', {
...props, onInput: (event: Event) => emit('update:value', (event.target as HTMLTextAreaElement).value),
}),
});
return {
Alert: defineComponent({ props: ['message'], setup: (props) => () => h('p', props.message) }),
Modal: defineComponent({ props: ['open'], setup: (props, { slots }) => () => props.open
? h('section', [slots.default?.(), slots.footer?.()]) : null }),
Button: defineComponent({ props: ['disabled'], setup: (props, { slots }) => () => h('button', { disabled: props.disabled }, slots.default?.()) }),
Collapse: Object.assign({}, plain, { Panel: plain }), Progress: plain, Space: plain, Spin: plain, Tag: plain, Empty: plain,
Form: Object.assign({}, plain, { Item: plain }), Input: Object.assign({}, plain, { TextArea: textarea }),
Radio: Object.assign({}, plain, { Group: plain }), Select: plain,
};
});
import KnowledgeBatchDialog from './batch-dialog.vue';
const item = (id: string): MyKnowledgeReview => ({ id, title: id, question: 'question', answer: 'answer', conditions: 'condition',
category: '', kind: 'qa', status: 'draft', revision: 1, valid_until: '', flags: [], sources: [],
review_assignment: { id: 'assigned-' + id, assigned_at: '' } });
const settle = async () => { for (let index = 0; index < 10; index++) { await Promise.resolve(); await nextTick(); } };
function deferred<T>() {
let resolve!: (value: T) => void;
const promise = new Promise<T>((done) => { resolve = done; });
return { promise, resolve };
}
let cleanup: (() => void) | undefined;
function mount(entries: MyKnowledgeReview[], action: BatchAction = 'approve', editAllowed = false) {
const open = ref(true); const visible = ref(true); const selection = ref(entries); const child = ref();
const canEdit = ref(editAllowed);
const finished = vi.fn(); const closed = vi.fn(); const saved = vi.fn();
const host = document.createElement('div'); document.body.append(host);
const app = createApp(defineComponent({ setup: () => () => h(KeepAlive, null, {
default: () => visible.value ? h(KnowledgeBatchDialog, { ref: child, open: open.value, entries: selection.value,
accountId: -1, action, canExecute: true, canEdit: canEdit.value,
'onUpdate:open': (value: boolean) => { open.value = value; closed(value); }, onFinished: finished, onSaved: saved }) : null,
}) }));
app.mount(host); cleanup = () => { app.unmount(); host.remove(); };
return { open, visible, selection, child, canEdit, finished, closed, saved, host };
}
function button(host: HTMLElement, label: string) {
const match = [...host.querySelectorAll('button')].find((element) => element.textContent === label);
if (!match) throw new Error(`Missing button: ${label}`);
return match;
}
describe('knowledge batch dialog lifecycle', () => {
beforeEach(() => {
vi.resetAllMocks();
api.fetchMyKnowledgeReview.mockImplementation(async (id) => item(id));
api.decideMyKnowledgeReview.mockImplementation(async (entry) => ({ ...entry, status: 'approved', revision: 2 }));
});
afterEach(() => { cleanup?.(); cleanup = undefined; });
it.each([
['approve', '确认审核通过 {count} 条'],
['approve_publish', '确认审核并发布 {count} 条'],
] as const)('saves inside %s and approves only the returned revision', async (action, confirmLabel) => {
const missing = { ...item('needs-conditions'), conditions: '',
sources: [{ message_id: 'source', role: 'staff', sent_at: '', version_no: 1, content: 'source evidence' }] };
api.fetchMyKnowledgeReview.mockResolvedValueOnce(missing);
const ui = mount([missing, item('other')], action, true); await settle();
const state = ui.child.value.$.setupState;
const untouched = state.details[1];
expect(state.ready).toEqual([untouched]);
button(ui.host, '编辑草稿').click(); await settle();
expect(ui.host.textContent).toContain('source evidence');
expect(button(ui.host, confirmLabel).disabled).toBe(true);
const conditions = ui.host.querySelector<HTMLTextAreaElement>('textarea[autofocus]')!;
conditions.value = 'Only for existing customers';
conditions.dispatchEvent(new Event('input'));
state.draft.content_type = 'daily_communication';
await state.start();
expect(api.decideMyKnowledgeReview).not.toHaveBeenCalled();
const gate = deferred<MyKnowledgeReview>(); api.saveMyKnowledgeReview.mockReturnValueOnce(gate.promise);
button(ui.host, '保存草稿').click(); await settle();
expect(api.saveMyKnowledgeReview).toHaveBeenCalledWith(missing.id, expect.objectContaining({
assignment_id: missing.review_assignment.id, conditions: 'Only for existing customers', revision: 1, content_type: 'daily_communication',
}));
expect(state.details[0].conditions).toBe('');
await state.start(); expect(api.decideMyKnowledgeReview).not.toHaveBeenCalled();
expect(button(ui.host, confirmLabel).disabled).toBe(true);
gate.resolve({ ...missing, title: 'Saved title', conditions: 'Redacted conditions', content_type: 'daily_communication', revision: 2 });
await settle();
expect(state.ready).toHaveLength(2); expect(state.details[1]).toBe(untouched);
expect(ui.host.textContent).toContain('Saved title · v2');
expect(ui.host.textContent).toContain('日常生活沟通');
expect(state.details[0]).toMatchObject({ review_assignment: missing.review_assignment, revision: 2 });
expect(ui.open.value).toBe(true); expect(ui.selection.value[0]?.revision).toBe(1);
expect(ui.saved).toHaveBeenCalledTimes(1); expect(api.fetchMyKnowledgeReview).toHaveBeenCalledTimes(2);
expect(api.decideMyKnowledgeReview).not.toHaveBeenCalled();
button(ui.host, confirmLabel).click(); await settle();
expect(api.decideMyKnowledgeReview.mock.calls).toMatchObject([
[{ id: missing.id, revision: 2, conditions: 'Redacted conditions', review_assignment: missing.review_assignment }, action],
[{ id: 'other', revision: 1, review_assignment: item('other').review_assignment }, action],
]);
});
it('keeps failed draft edits local and only allows batch confirmation after canceling them', async () => {
const ui = mount([item('a')], 'approve', true); await settle();
const state = ui.child.value.$.setupState;
button(ui.host, '编辑草稿').click(); state.draft.conditions = 'unsaved';
api.saveMyKnowledgeReview.mockRejectedValueOnce({ response: { data: { detail: '保存未完成' } } });
await state.saveDraft(); await settle();
expect(ui.host.textContent).toContain('保存未完成'); expect(state.draft.conditions).toBe('unsaved');
expect(state.details[0]).toMatchObject({ conditions: 'condition', revision: 1 });
expect(ui.saved).not.toHaveBeenCalled();
await state.start(); expect(api.decideMyKnowledgeReview).not.toHaveBeenCalled();
button(ui.host, '取消编辑').click(); await settle();
expect(ui.host.textContent).not.toContain('保存未完成');
expect(button(ui.host, '确认审核通过 {count} 条').disabled).toBe(false);
});
it('rejects stale, failed and non-draft rows and discards a pending save after edit permission is revoked', async () => {
let editable = item('editable');
api.fetchMyKnowledgeReview.mockImplementation(async (id: string) => {
if (id === 'failed') throw new Error('fetch failed');
if (id === 'stale') return { ...item(id), revision: 2 };
if (id === 'approved') return { ...item(id), status: 'approved' };
return editable;
});
const ui = mount(['stale', 'failed', 'approved', 'editable'].map(item)); await settle();
const state = ui.child.value.$.setupState;
expect(ui.host.textContent).not.toContain('编辑草稿');
ui.canEdit.value = true; await settle();
for (const entry of state.details.slice(0, 3)) state.beginEdit(entry);
expect(state.draft).toBeNull();
button(ui.host, '编辑草稿').click();
const gate = deferred<MyKnowledgeReview>(); api.saveMyKnowledgeReview.mockReturnValueOnce(gate.promise);
const pending = state.saveDraft();
ui.canEdit.value = false; await settle();
expect(state.draft).toBeNull(); expect(state.details).toEqual([]);
ui.canEdit.value = true; await settle();
await state.start(); expect(api.decideMyKnowledgeReview).not.toHaveBeenCalled();
editable = { ...editable, revision: 2, title: 'Refreshed details' };
gate.resolve({ ...editable, title: 'stale save response' });
await pending; await settle();
expect(ui.saved).not.toHaveBeenCalled(); expect(api.fetchMyKnowledgeReview).toHaveBeenCalledTimes(8);
expect(ui.host.textContent).not.toContain('stale save response');
expect(state.ready).toEqual([]);
expect(state.details[3]).toMatchObject({ id: 'editable', revision: 1, title: 'editable' });
expect(ui.host.textContent).not.toContain('Refreshed details');
});
it('closes on deactivation, drains only in-flight mutations and reopens without stale results or finished events', async () => {
const ui = mount([item('a'), item('a'), item('b'), item('c'), item('unscheduled')]); await settle();
const state = ui.child.value.$.setupState;
expect(api.fetchMyKnowledgeReview).toHaveBeenCalledTimes(4); expect(state.ready).toHaveLength(4);
const gates = [deferred<MyKnowledgeReview>(), deferred<MyKnowledgeReview>(), deferred<MyKnowledgeReview>()];
let sent = 0;
api.decideMyKnowledgeReview.mockImplementationOnce(() => gates[sent++]!.promise)
.mockImplementationOnce(() => gates[sent++]!.promise).mockImplementationOnce(() => gates[sent++]!.promise);
const oldRun = state.start(); await settle();
expect(state.running).toBe(true); expect(api.decideMyKnowledgeReview).toHaveBeenCalledTimes(3);
ui.visible.value = false; await settle();
expect(ui.closed).toHaveBeenCalledWith(false); expect(ui.open.value).toBe(false);
expect(state.running).toBe(false); expect(state.executionActive).toBe(true); expect(state.results).toBeNull();
ui.selection.value = [item('fresh')]; ui.visible.value = true; ui.open.value = true; await settle();
expect(ui.child.value.$.setupState).toBe(state); expect(state.ready).toEqual([]);
expect(ui.host.textContent).toContain('等待进行中的操作完成后停止');
await state.start(); expect(api.decideMyKnowledgeReview).toHaveBeenCalledTimes(3);
gates[0]!.resolve({ ...item('a'), status: 'approved', revision: 2 }); await settle();
expect(state.executionActive).toBe(true); expect(state.results).toBeNull(); expect(ui.finished).not.toHaveBeenCalled();
expect(api.fetchMyKnowledgeReview).toHaveBeenCalledTimes(4);
gates[1]!.resolve({ ...item('b'), status: 'approved', revision: 2 });
gates[2]!.resolve({ ...item('c'), status: 'approved', revision: 2 }); await oldRun; await settle();
expect(state.executionActive).toBe(false); expect(state.running).toBe(false);
expect(state.results).toBeNull(); expect(state.ready.map((entry: MyKnowledgeReview) => entry.id)).toEqual(['fresh']);
expect(ui.finished).not.toHaveBeenCalled(); expect(api.decideMyKnowledgeReview).toHaveBeenCalledTimes(3);
await state.start(); await settle();
expect(api.decideMyKnowledgeReview).toHaveBeenCalledTimes(4);
expect(api.decideMyKnowledgeReview.mock.calls[3]).toMatchObject([{ id: 'fresh', revision: 1, review_assignment: item('fresh').review_assignment }, 'approve']);
expect(state.results).toMatchObject([{ id: 'fresh', status: 'success' }]);
expect(state.running).toBe(false); expect(state.executionActive).toBe(false); expect(ui.finished).toHaveBeenCalledTimes(1);
});
it('reloads details after activation even when the cached open prop never toggled', async () => {
const old = deferred<MyKnowledgeReview>(); const current = deferred<MyKnowledgeReview>();
api.fetchMyKnowledgeReview.mockImplementationOnce(() => old.promise).mockImplementationOnce(() => current.promise);
const ui = mount([item('a')]); await settle(); const state = ui.child.value.$.setupState;
expect(state.loading).toBe(true); ui.visible.value = false; await settle(); expect(ui.open.value).toBe(false);
ui.visible.value = true; ui.open.value = true; await settle(); expect(state.loading).toBe(true);
old.resolve(item('old')); await settle(); expect(state.loading).toBe(true); expect(state.details).toEqual([]);
current.resolve(item('a')); await settle(); expect(state.loading).toBe(false); expect(state.ready[0].id).toBe('a');
await state.start(); expect(state.results).toMatchObject([{ id: 'a', status: 'success' }]);
expect(ui.finished).toHaveBeenCalledTimes(1);
});
it('does not reload hidden state when a mutation settles before the cached component is activated', async () => {
const ui = mount([item('a')]); await settle(); const state = ui.child.value.$.setupState;
const gate = deferred<MyKnowledgeReview>(); api.decideMyKnowledgeReview.mockImplementationOnce(() => gate.promise);
const pending = state.start(); await settle(); ui.visible.value = false; await settle();
const reads = api.fetchMyKnowledgeReview.mock.calls.length;
gate.resolve({ ...item('a'), status: 'approved', revision: 2 }); await pending; await settle();
expect(state.executionActive).toBe(false); expect(state.results).toBeNull(); expect(state.details).toEqual([]);
expect(api.fetchMyKnowledgeReview).toHaveBeenCalledTimes(reads); expect(ui.finished).not.toHaveBeenCalled();
await state.start(); expect(api.decideMyKnowledgeReview).toHaveBeenCalledTimes(1);
ui.visible.value = true; ui.open.value = true; await settle();
expect(api.fetchMyKnowledgeReview).toHaveBeenCalledTimes(reads + 1); expect(state.ready[0].id).toBe('a');
});
});
@@ -1,32 +1,56 @@
<script setup lang="ts">
import type { KnowledgeItem } from '#/api/knowledge';
import type { BatchAction, BatchResult } from './batch';
import { computed, onBeforeUnmount, onDeactivated, ref, watch } from 'vue';
import { Alert, Button, Checkbox, Collapse, Modal, Progress, Space, Spin, Tag } from 'ant-design-vue';
import { fetchKnowledgeItem, knowledgeItemAction } from '#/api/knowledge';
import type { BatchAction, BatchResult, KnowledgeBatchItem } from './batch';
import { computed, onActivated, onBeforeUnmount, onDeactivated, ref, watch } from 'vue';
import { Alert, Button, Collapse, Modal, Progress, Space, Spin, Tag } from 'ant-design-vue';
import { decideMyKnowledgeReview, fetchKnowledgeItem, fetchMyKnowledgeReview, knowledgeItemAction, saveMyKnowledgeReview } from '#/api/knowledge';
import { t } from '#/locales/t';
import { actionProblem, failureText, runKnowledgeBatch } from './batch';
import { actionProblem, failureText, isReviewAction, prepareKnowledgeBatch, runKnowledgeBatch, uniqueKnowledgeItems } from './batch';
import KnowledgeContentTypeTag from './content-type-tag.vue';
import { draftContent } from './draft-content';
import KnowledgeItemFields from './item-fields.vue';
import KnowledgeItemSources from './item-sources.vue';
const props = defineProps<{ open: boolean; accountId: number; entries: KnowledgeItem[]; action: BatchAction }>();
const emit = defineEmits<{ 'update:open': [value: boolean]; finished: []; edit: [id: string] }>();
const details = ref<KnowledgeItem[]>([]);
const props = defineProps<{ open: boolean; accountId: number; entries: KnowledgeBatchItem[]; action: BatchAction; canExecute: boolean; canEdit: boolean }>();
const emit = defineEmits<{
'update:open': [value: boolean]; finished: [results: BatchResult[]]; saved: [item: KnowledgeBatchItem];
edit: [id: string]; processing: [action: 'run' | 'save' | null];
}>();
const details = ref<KnowledgeBatchItem[]>([]);
const problems = ref<Record<string, string>>({});
const checked = ref<Record<string, boolean>>({});
const editableIds = ref(new Set<string>());
const draft = ref<KnowledgeBatchItem | null>(null);
const editorError = ref('');
const saving = ref(false);
const loading = ref(false);
const running = ref(false);
// This lock survives dialog invalidation until every already-sent mutation settles.
const executionActive = ref(false);
let executionToken = 0;
const stopRequested = ref(false);
const results = ref<BatchResult[] | null>(null);
let generation = 0;
function stop() { stopRequested.value = true; generation++; }
onBeforeUnmount(stop); onDeactivated(stop);
let viewActive = true;
function stop() {
stopRequested.value = true; generation++;
running.value = false; loading.value = false; results.value = null;
details.value = []; problems.value = {};
editableIds.value.clear(); draft.value = null; editorError.value = '';
}
onBeforeUnmount(() => { viewActive = false; stop(); });
onDeactivated(() => { viewActive = false; stop(); emit('update:open', false); });
const ready = computed(() => details.value.filter((item) => !problems.value[item.id]));
const confirmed = computed(() => props.action !== 'approve' || ready.value.every((item) => checked.value[item.id]));
const reviewing = computed(() => isReviewAction(props.action));
const assigned = (item: KnowledgeBatchItem): item is Extract<KnowledgeBatchItem, { review_assignment: { id: string } }> =>
!!item.review_assignment && 'id' in item.review_assignment;
const canEditBatch = computed(() => reviewing.value && props.canExecute && props.canEdit);
const canStart = computed(() => props.open && props.canExecute && !loading.value && !executionActive.value
&& !draft.value && !saving.value && !results.value && ready.value.length > 0);
const completed = computed(() => results.value?.filter((row) => row.status !== 'pending').length || 0);
// 标题和确认按钮按操作分别写整句,英文语序才自然
const title = computed(() => {
const count = props.entries.length;
const count = uniqueKnowledgeItems(props.entries).length;
return {
delete: t('批量删除 · {count} 条', { count }), approve: t('批量审核通过 · {count} 条', { count }),
delete: t('批量删除 · {count} 条', { count }), approve: t('批量审核通过 · {count} 条', { count }), approve_publish: t('批量审核并发布 · {count} 条', { count }),
publish: t('批量发布 · {count} 条', { count }), reject: t('批量驳回 · {count} 条', { count }),
disable: t('批量停用 · {count} 条', { count }),
}[props.action];
@@ -34,74 +58,180 @@ const title = computed(() => {
const confirmText = computed(() => {
const count = ready.value.length;
return {
delete: t('确认删除 {count} 条', { count }), approve: t('确认审核通过 {count} 条', { count }),
delete: t('确认删除 {count} 条', { count }), approve: t('确认审核通过 {count} 条', { count }), approve_publish: t('确认审核并发布 {count} 条', { count }),
publish: t('确认发布 {count} 条', { count }), reject: t('确认驳回 {count} 条', { count }),
disable: t('确认停用 {count} 条', { count }),
}[props.action];
});
watch(() => [props.open, props.accountId, props.action], async () => {
const current = ++generation;
if (!props.open) return;
details.value = []; problems.value = {}; checked.value = {}; results.value = null;
async function loadDetails() {
stop();
const current = generation;
if (!viewActive || !props.open || executionActive.value || saving.value) return;
loading.value = true;
// Keep the selected revision, even if the source changes while this dialog loads.
for (const entry of props.entries) {
try {
const item = await fetchKnowledgeItem(props.accountId, entry.id);
if (current !== generation) return;
details.value.push(item);
const problem = item.revision !== entry.revision ? t('版本已更新,请关闭后重新选择,避免审核旧内容') : actionProblem(item, props.action);
if (problem) problems.value[item.id] = problem;
} catch (error) {
if (current !== generation) return;
details.value.push(entry); problems.value[entry.id] = failureText(error);
}
}
if (current === generation) loading.value = false;
const account = props.accountId;
const prepared = await prepareKnowledgeBatch(props.entries.map((item) => ({ ...item })), props.action,
async (entry) => {
if (reviewing.value && !assigned(entry)) throw new Error('Assignment is required');
if (assigned(entry)) {
const item = await fetchMyKnowledgeReview(entry.id);
if (item.status !== 'draft' || item.review_assignment?.id !== entry.review_assignment.id) {
throw new Error('Assignment changed');
}
return item;
}
return fetchKnowledgeItem(account, entry.id);
}, () => current !== generation);
if (current !== generation) return;
details.value = prepared.details; problems.value = prepared.problems; editableIds.value = prepared.editableIds;
loading.value = false;
}
watch(() => [props.open, props.accountId, props.action, props.entries], loadDetails, { immediate: true });
onActivated(() => {
viewActive = true;
if (props.open && !loading.value && !executionActive.value && !saving.value && !details.value.length && !results.value) void loadDetails();
});
async function start() {
if (running.value || !confirmed.value || !ready.value.length) return;
watch([executionActive, saving], ([executing, savingDraft]) => {
if (!executing && !savingDraft && viewActive && props.open && !loading.value && !details.value.length && !results.value) void loadDetails();
});
function canEditRow(item: KnowledgeBatchItem) {
return assigned(item) && canEditBatch.value && !loading.value && !executionActive.value && !results.value
&& editableIds.value.has(item.id) && item.status === 'draft';
}
function beginEdit(item: KnowledgeBatchItem) {
if (!viewActive || !props.open || saving.value || draft.value || !canEditRow(item)) return;
draft.value = { ...item };
}
function cancelEdit() {
if (saving.value) return;
draft.value = null;
editorError.value = '';
}
watch(canEditBatch, (allowed) => {
if (!allowed && draft.value) {
// Reload before any further batch action if an invalidated save may have changed a revision.
if (saving.value) void loadDetails();
else cancelEdit();
}
});
async function saveDraft() {
const item = draft.value;
if (!viewActive || !props.open || saving.value || !item || !assigned(item) || !canEditRow(item)) return;
const current = generation;
const account = props.accountId;
const action = props.action;
const work = ready.value.map((item) => ({ ...item }));
running.value = true; stopRequested.value = false;
const isCurrent = () => current === generation && viewActive && props.open && canEditBatch.value
&& props.accountId === account && props.action === action && draft.value === item;
saving.value = true;
emit('processing', 'save');
editorError.value = '';
try {
const saved = await saveMyKnowledgeReview(item.id, {
...draftContent(item), assignment_id: item.review_assignment.id, revision: item.revision,
});
if (!isCurrent()) return;
if (saved.id !== item.id || saved.revision <= item.revision
|| saved.review_assignment?.id !== item.review_assignment.id || saved.status !== 'draft') {
editorError.value = failureText(null);
return;
}
details.value = details.value.map((entry) => entry.id === item.id ? saved : entry);
const problem = actionProblem(saved, action);
if (problem) problems.value[item.id] = problem;
else delete problems.value[item.id];
draft.value = null;
emit('saved', saved);
} catch (error) {
if (isCurrent()) editorError.value = failureText(error);
} finally {
saving.value = false;
emit('processing', null);
}
}
async function start() {
if (!viewActive || !canStart.value) return;
const current = generation;
const token = ++executionToken;
const account = props.accountId;
const action = props.action;
const work = uniqueKnowledgeItems(ready.value).map((item) => ({ ...item }));
if (work.some(assigned)) { details.value = []; editableIds.value.clear(); }
executionActive.value = true; running.value = true; stopRequested.value = false;
emit('processing', 'run');
results.value = work.map((item) => ({ id: item.id, title: item.title, status: 'pending', error: '' }));
try {
results.value = await runKnowledgeBatch(work,
(item) => knowledgeItemAction(account, item, action, action === 'delete' || (action === 'approve' && !!checked.value[item.id])),
(value) => { results.value = value; }, () => stopRequested.value);
} finally { running.value = false; emit('finished'); }
const finished = await runKnowledgeBatch(work,
(item) => {
if (assigned(item) && (action === 'approve' || action === 'approve_publish' || action === 'reject')) {
return decideMyKnowledgeReview(item, action);
}
if (!assigned(item) && (action === 'delete' || action === 'disable' || action === 'publish')) {
return knowledgeItemAction(account, item, action, action === 'delete');
}
throw new Error('Invalid batch action');
},
(value) => { if (current === generation) results.value = value; }, () => stopRequested.value || current !== generation || !props.canExecute);
if (current === generation) results.value = finished;
} finally {
if (token === executionToken) executionActive.value = false;
if (current === generation) {
running.value = false;
emit('processing', null);
emit('finished', results.value || []);
}
}
}
</script>
<template>
<Modal :open="open" :title="title" width="960px" :closable="!running" :keyboard="!running" :mask-closable="false" @cancel="emit('update:open', false)">
<Modal :open="open" :title="title" width="960px" :closable="!running && !saving" :keyboard="!running && !saving" :mask-closable="false" @cancel="emit('update:open', false)">
<Alert v-if="executionActive && !running" class="mb-3" type="info" :message="t('等待进行中的操作完成后停止')" />
<Spin :spinning="loading">
<Alert class="mb-4" show-icon type="info" :message="action === 'approve' ? t('请逐条展开,核对来源、事实、脱敏和适用条件,再勾选确认。通过审核后仍需发布才可检索。') : t('每条知识分别校验版本和当前状态。操作结果逐条显示,失败条目不会自动重试。')" />
<Alert class="mb-4" show-icon type="info" :message="reviewing ? t('请核对所选知识的来源、事实、脱敏和适用条件。点击下方确认按钮后执行,可展开查看详情;不符合条件的条目会跳过。') : t('每条知识分别校验版本和当前状态。操作结果逐条显示,失败条目不会自动重试。')" />
<Alert v-if="action === 'delete'" class="mb-4" type="warning" show-icon :message="t('仅删除已驳回知识及其来源快照和版本记录;原始聊天归档保留。删除后无法恢复,请确认所选条目。')" />
<Alert v-if="action === 'approve'" class="mb-3" type="info" :message="t('审核通过后进入待发布,发布后才可检索。')" />
<p v-if="!loading">{{ t('可操作 {ready} 条 · 需先处理 {blocked} 条', { ready: ready.length, blocked: Object.keys(problems).length }) }}</p>
<Alert v-if="draft" class="mb-3" type="info" :message="t('请保存草稿或取消编辑,再继续批量审核。')" />
<div v-if="results" class="mb-4 rounded border p-3">
<Progress :percent="results.length ? Math.round(completed * 100 / results.length) : 0" :status="running ? 'active' : undefined" />
<p>{{ t('成功 {success} · 失败 {failed} · 未执行 {pending}', { success: results.filter((row) => row.status === 'success').length, failed: results.filter((row) => row.status === 'failed').length, pending: results.filter((row) => row.status === 'pending').length }) }}</p>
<div v-for="row in results" :key="row.id" class="mb-2"><Tag :color="row.status === 'success' ? 'green' : row.status === 'failed' ? 'red' : 'default'">{{ row.status === 'success' ? t('成功') : row.status === 'failed' ? t('失败') : t('未执行') }}</Tag>{{ row.title }}<p v-if="row.error" class="text-red-500">{{ row.error }}</p></div>
</div>
<Collapse v-if="!results">
<Collapse.Panel v-for="item in details" :key="item.id" :header="`${item.title} · v${item.revision}`">
<Collapse>
<Collapse.Panel v-for="item in details" :key="item.id">
<template #header><span class="mr-2">{{ item.title }} · v{{ item.revision }}</span><KnowledgeContentTypeTag :value="item.content_type" /><Tag v-if="problems[item.id]" color="orange">{{ problems[item.id] }}</Tag></template>
<Alert v-if="problems[item.id]" :message="problems[item.id]" type="warning" class="mb-3" />
<div class="grid gap-4 md:grid-cols-2">
<div><h4 class="mb-2 font-semibold">{{ t('来源对话(已自动脱敏)') }}</h4><div v-for="source in item.sources" :key="source.message_id" class="mb-2 rounded border p-2"><span class="text-xs text-gray-500">{{ source.role === 'staff' ? t('客服') : t('客户') }} · {{ source.sent_at }}</span><p class="whitespace-pre-wrap break-words">{{ source.content }}</p></div></div>
<div><p class="whitespace-pre-wrap">{{ t('问题:{question}', { question: item.question }) }}</p><p class="whitespace-pre-wrap">{{ t('答案:{answer}', { answer: item.answer }) }}</p><p class="whitespace-pre-wrap">{{ t('适用条件:{conditions}', { conditions: item.conditions || t('尚未填写') }) }}</p><Alert v-for="flag in item.flags" :key="flag" :message="t(flag)" type="warning" class="mb-2" /><p v-if="item.valid_until">{{ t('有效期:{date}', { date: item.valid_until }) }}</p></div>
<KnowledgeItemSources :sources="item.sources" />
<div>
<template v-if="draft && draft.id === item.id">
<Space class="mb-3">
<Button type="primary" :loading="saving" @click="saveDraft">{{ t('保存草稿') }}</Button>
<Button :disabled="saving" @click="cancelEdit">{{ t('取消编辑') }}</Button>
</Space>
<Alert v-if="editorError" class="mb-3" type="error" show-icon :message="editorError" />
<KnowledgeItemFields v-model="draft" :disabled="saving" focus-conditions />
</template>
<template v-else>
<Button v-if="canEditRow(item)" class="mb-2" :disabled="!!draft || saving" @click="beginEdit(item)">{{ t('编辑草稿') }}</Button>
<p class="whitespace-pre-wrap">{{ t('问题:{question}', { question: item.question }) }}</p>
<p class="whitespace-pre-wrap">{{ t('答案:{answer}', { answer: item.answer }) }}</p>
<p class="whitespace-pre-wrap">{{ t('适用条件:{conditions}', { conditions: item.conditions || t('尚未填写') }) }}</p>
<p v-if="item.valid_until">{{ t('有效期:{date}', { date: item.valid_until }) }}</p>
</template>
<Alert v-for="flag in item.flags" :key="flag" :message="t(flag)" type="warning" class="mb-2" />
</div>
</div>
<Checkbox v-if="action === 'approve' && !problems[item.id]" v-model:checked="checked[item.id]">{{ t('已核对本条来源、事实、脱敏和适用条件;涉及医疗内容已完成专业审核。') }}</Checkbox>
<Button type="link" @click="emit('edit', item.id)">{{ t('打开单条审核与编辑') }}</Button>
<Button v-if="!reviewing" type="link" :disabled="running" @click="emit('edit', item.id)">{{ t('打开知识详情') }}</Button>
</Collapse.Panel>
</Collapse>
</Spin>
<template #footer><Space>
<Button v-if="running" :disabled="stopRequested" @click="stopRequested = true">{{ stopRequested ? t('当前操作完成后停止') : t('停止后续操作') }}</Button>
<Button v-else @click="emit('update:open', false)">{{ results ? t('完成') : t('取消') }}</Button>
<Button v-if="!results" :danger="action === 'delete'" type="primary" :disabled="loading || !ready.length || !confirmed" @click="start">{{ confirmText }}</Button>
<Button v-if="running" :disabled="stopRequested" @click="stopRequested = true">{{ stopRequested ? t('等待进行中的操作完成后停止') : t('停止后续操作') }}</Button>
<Button v-else :disabled="saving" @click="emit('update:open', false)">{{ results ? t('完成') : t('取消') }}</Button>
<Button v-if="!results" :danger="action === 'delete'" type="primary" :disabled="!canStart" @click="start">{{ confirmText }}</Button>
</Space></template>
</Modal>
</template>
@@ -1,23 +1,67 @@
import { describe, expect, it } from 'vitest';
import { describe, expect, it, vi } from 'vitest';
import type { KnowledgeItem } from '#/api/knowledge';
import { actionProblem, runKnowledgeBatch } from './batch';
import { actionProblem, prepareKnowledgeBatch, runKnowledgeBatch } from './batch';
const item = (id: string, status = 'draft') => ({ id, title: id, revision: 4, status, conditions: '通用预约流程' } as KnowledgeItem);
const settle = async () => { for (let index = 0; index < 8; index++) await Promise.resolve(); };
function deferred<T>() {
let resolve!: (value: T) => void;
const promise = new Promise<T>((done) => { resolve = done; });
return { promise, resolve };
}
describe('knowledge batch workflow', () => {
it('preserves revisions, reports partial failures and continues to other items', async () => {
const seen: number[] = [];
const result = await runKnowledgeBatch([item('a'), item('b'), item('c')], async (entry) => {
seen.push(entry.revision);
it('preserves revisions, reports partial failures and never retries ambiguous mutations', async () => {
const execute = vi.fn(async (entry: KnowledgeItem) => {
if (entry.id === 'b') throw { response: { data: { detail: '知识版本已变化,请刷新' } } };
}, () => {}, () => false);
expect(seen).toEqual([4, 4, 4]);
});
const result = await runKnowledgeBatch([item('a'), item('b'), item('c')], execute, () => {}, () => false);
expect(execute.mock.calls.map(([entry]) => entry.revision)).toEqual([4, 4, 4]);
expect(execute).toHaveBeenCalledTimes(3);
expect(result.map((row) => row.status)).toEqual(['success', 'failed', 'success']);
expect(result[1]?.error).toContain('版本已变化');
});
it('stops only subsequent requests after an in-flight mutation completes', async () => {
let stop = false;
const result = await runKnowledgeBatch([item('a'), item('b')], async () => { stop = true; }, () => {}, () => stop);
expect(result.map((row) => row.status)).toEqual(['success', 'pending']);
it('limits mutations to three in flight and stops unscheduled rows while finishing the in-flight requests', async () => {
const gates = Array.from({ length: 6 }, () => deferred<void>());
let stop = false; let active = 0; let maximum = 0;
const seen: string[] = [];
const pending = runKnowledgeBatch(Array.from({ length: 6 }, (_, index) => item(String(index))), async (entry) => {
seen.push(entry.id); active++; maximum = Math.max(maximum, active);
await gates[Number(entry.id)]!.promise; active--;
}, () => {}, () => stop);
await settle(); expect(seen).toEqual(['0', '1', '2']);
gates[0]!.resolve(); await settle(); expect(seen).toEqual(['0', '1', '2', '3']);
stop = true; gates[1]!.resolve(); gates[2]!.resolve(); gates[3]!.resolve();
const result = await pending;
expect(maximum).toBe(3); expect(active).toBe(0);
expect(result.map((row) => row.status)).toEqual(['success', 'success', 'success', 'success', 'pending', 'pending']);
expect(seen).toEqual(['0', '1', '2', '3']);
});
it('fetches at most four details at once, preserves selection order, and blocks newer or invalid revisions', async () => {
const entries = Array.from({ length: 7 }, (_, index) => item(String(index)));
const gates = entries.map(() => deferred<KnowledgeItem>());
let active = 0; let maximum = 0;
const fetch = vi.fn(async (entry: KnowledgeItem) => {
active++; maximum = Math.max(maximum, active);
const value = await gates[Number(entry.id)]!.promise; active--; return value;
});
const pending = prepareKnowledgeBatch(entries, 'approve_publish', fetch, () => false);
expect(fetch).toHaveBeenCalledTimes(4);
gates[2]!.resolve({ ...entries[2]!, revision: 5 }); await settle(); expect(fetch).toHaveBeenCalledTimes(5);
gates[0]!.resolve(entries[0]!); gates[1]!.resolve({ ...entries[1]!, conditions: '' });
gates[3]!.resolve(entries[3]!); await settle();
gates[4]!.resolve(entries[4]!); gates[5]!.resolve(entries[5]!); gates[6]!.resolve(entries[6]!);
const result = await pending;
expect(maximum).toBe(4); expect(result.details.map((entry) => entry.id)).toEqual(entries.map((entry) => entry.id));
expect(result.problems['2']).toContain('版本已更新'); expect(result.problems['1']).toContain('适用条件');
expect(entries[2]!.revision).toBe(4);
});
it('does not schedule more detail requests after its scope is invalidated', async () => {
let stopped = false;
const gates = Array.from({ length: 4 }, () => deferred<KnowledgeItem>());
const fetch = vi.fn((entry: KnowledgeItem) => gates[Number(entry.id)]!.promise);
const pending = prepareKnowledgeBatch(Array.from({ length: 8 }, (_, index) => item(String(index))), 'approve', fetch, () => stopped);
stopped = true; gates.forEach((gate, index) => gate.resolve(item(String(index)))); await pending;
expect(fetch).toHaveBeenCalledTimes(4);
});
it('only permits deletion of rejected knowledge', () => {
expect(actionProblem(item('a', 'rejected'), 'delete')).toBe('');
@@ -25,10 +69,25 @@ describe('knowledge batch workflow', () => {
expect(actionProblem(item('a', status), 'delete')).toBeTruthy();
}
});
it('does not approve missing conditions or publish drafts', () => {
expect(actionProblem({ ...item('a'), conditions: ' ' }, 'approve')).toContain('适用条件');
it('requires draft status and conditions for either review action and never directly publishes drafts', () => {
for (const action of ['approve', 'approve_publish'] as const) {
expect(actionProblem({ ...item('a'), conditions: ' ' }, action)).toContain('适用条件');
expect(actionProblem(item('a', 'stale'), action)).toBeTruthy();
expect(actionProblem(item('a'), action)).toBe('');
}
expect(actionProblem(item('a'), 'publish')).toBeTruthy();
expect(actionProblem(item('a', 'approved'), 'publish')).toBe('');
expect(actionProblem(item('a', 'stale'), 'approve')).toBeTruthy();
});
it('deduplicates IDs before detail preparation and mutation while retaining the first selected revision', async () => {
const first = item('same'); const duplicate = { ...first, revision: 9 };
const fetch = vi.fn(async (entry: KnowledgeItem) => ({ ...entry }));
const prepared = await prepareKnowledgeBatch([first, duplicate, item('other')], 'approve', fetch, () => false);
expect(fetch.mock.calls.map(([entry]) => [entry.id, entry.revision])).toEqual([['same', 4], ['other', 4]]);
expect(prepared.details).toHaveLength(2); expect(prepared.problems).toEqual({});
const execute = vi.fn(async () => {});
const result = await runKnowledgeBatch([first, duplicate, item('other')], execute, () => {}, () => false);
expect(execute.mock.calls).toHaveLength(2);
expect(result.map((row) => row.id)).toEqual(['same', 'other']);
});
});
@@ -1,14 +1,20 @@
import type { KnowledgeItem } from '#/api/knowledge';
import type { KnowledgeItem, MyKnowledgeReview } from '#/api/knowledge';
import { t } from '#/locales/t';
export type BatchAction = 'approve' | 'delete' | 'disable' | 'publish' | 'reject';
export type BatchAction = 'approve' | 'approve_publish' | 'delete' | 'disable' | 'publish' | 'reject';
export type KnowledgeBatchItem = KnowledgeItem | MyKnowledgeReview;
export interface BatchResult { id: string; title: string; status: 'failed' | 'pending' | 'success'; error: string }
export function actionProblem(item: KnowledgeItem, action: BatchAction): string {
const allowed = { delete: ['rejected'], approve: ['draft'], publish: ['approved'], reject: ['draft', 'approved'], disable: ['published'] };
export function isReviewAction(action: BatchAction): boolean {
return action === 'approve' || action === 'approve_publish';
}
export function actionProblem(item: KnowledgeBatchItem, action: BatchAction): string {
const allowed = { delete: ['rejected'], approve: ['draft'], approve_publish: ['draft'], publish: ['approved'], reject: ['draft', 'approved'], disable: ['published'] };
if (!allowed[action].includes(item.status)) return t('当前状态不支持此操作,请刷新或重新选择');
if (action === 'approve' && !item.conditions.trim()) return t('请先编辑并补充适用条件');
if (item.self_review_blocked && (isReviewAction(action) || action === 'reject')) return t('自己的知识须由他人审核');
if (isReviewAction(action) && !item.conditions.trim()) return t('请先编辑并补充适用条件');
return '';
}
@@ -17,22 +23,67 @@ export function failureText(error: unknown): string {
return typeof detail === 'string' ? detail : t('请求未完成,请刷新确认状态后再操作');
}
/** Each request retains the selected revision; never retry ambiguous mutations automatically. */
export async function runKnowledgeBatch(
items: KnowledgeItem[], execute: (item: KnowledgeItem) => Promise<unknown>,
/** Keep the first selected revision when repeated IDs arrive from a caller. */
export function uniqueKnowledgeItems<T extends KnowledgeBatchItem>(items: T[]): T[] {
const seen = new Set<string>();
return items.filter((item) => {
if (seen.has(item.id)) return false;
seen.add(item.id); return true;
});
}
/** Fetch at most four details at a time and keep the selected revision as the action gate. */
export async function prepareKnowledgeBatch<T extends KnowledgeBatchItem>(
entries: T[], action: BatchAction, fetch: (item: T) => Promise<T>,
stopped: () => boolean,
) {
const selected = uniqueKnowledgeItems(entries);
const details = [...selected];
const problems: Record<string, string> = {};
const editableIds = new Set<string>();
let next = 0;
await Promise.all(Array.from({ length: Math.min(4, selected.length) }, async () => {
while (!stopped() && next < selected.length) {
const index = next++;
const entry = selected[index]!;
try {
const item = await fetch(entry);
if (stopped()) return;
const sameVersion = item.id === entry.id && item.revision === entry.revision;
if (sameVersion) details[index] = item;
const problem = sameVersion ? actionProblem(item, action)
: t('版本已更新,请关闭后重新选择,避免审核旧内容');
if (problem) problems[entry.id] = problem;
if (sameVersion && isReviewAction(action) && item.status === 'draft') editableIds.add(entry.id);
} catch (error) {
if (stopped()) return;
problems[entry.id] = failureText(error);
}
}
}));
return { details, problems, editableIds };
}
/** At most three requests are in flight. Stop leaves unscheduled rows pending; mutations never retry. */
export async function runKnowledgeBatch<T extends KnowledgeBatchItem>(
items: T[], execute: (item: T) => Promise<unknown>,
update: (results: BatchResult[]) => void, stopped: () => boolean,
) {
const results: BatchResult[] = items.map(({ id, title }) => ({ id, title, status: 'pending', error: '' }));
for (let index = 0; index < items.length; index++) {
if (stopped()) break;
const item = items[index]!;
try {
await execute(item);
results[index] = { id: item.id, title: item.title, status: 'success', error: '' };
} catch (error) {
results[index] = { id: item.id, title: item.title, status: 'failed', error: failureText(error) };
const work = uniqueKnowledgeItems(items);
const results: BatchResult[] = work.map(({ id, title }) => ({ id, title, status: 'pending', error: '' }));
let next = 0;
await Promise.all(Array.from({ length: Math.min(3, work.length) }, async () => {
while (!stopped() && next < work.length) {
const index = next++;
const item = work[index]!;
try {
await execute(item);
results[index] = { id: item.id, title: item.title, status: 'success', error: '' };
} catch (error) {
results[index] = { id: item.id, title: item.title, status: 'failed', error: failureText(error) };
}
update(results.map((row) => ({ ...row })));
}
update(results.map((row) => ({ ...row })));
}
}));
return results;
}
@@ -1,50 +1,78 @@
<script setup lang="ts">
import type { KnowledgeAutoSummary, KnowledgeItem, KnowledgeReviewJob, KnowledgeOverview, KnowledgeRun, KnowledgeSearch, KnowledgeTrace } from '#/api/knowledge';
import { computed, onActivated, onDeactivated, onUnmounted, ref } from 'vue';
import { computed, onActivated, onDeactivated, onMounted, onUnmounted, ref, watch } from 'vue';
import { useAccess } from '@vben/access';
import { downloadFileFromBlob } from '@vben/utils';
import { Alert, Button, Card, Checkbox, Empty, Form, Input, message, Modal, Select, Space, Steps, Switch, Table, Tabs, Tag } from 'ant-design-vue';
import { Alert, Button, Card, Dropdown, Empty, Input, message, Menu, Modal, Select, Space, Switch, Table, Tabs, Tag } from 'ant-design-vue';
import { ALL_ACCOUNTS } from '#/api/console';
import { requestErrorMessage } from '#/api/error-message';
import { exportKnowledge, fetchKnowledgeReviewJobs, fetchKnowledgeItem, fetchKnowledgeItems, fetchKnowledgeOverview, fetchKnowledgeRuns, fetchKnowledgeTraces, knowledgeItemAction, saveKnowledgeItem, searchKnowledge, setKnowledgeEnabled, setKnowledgeWatch } from '#/api/knowledge';
import { MAX_KNOWLEDGE_REVIEW_ASSIGNMENTS, exportKnowledge, fetchKnowledgeReviewJobs, fetchKnowledgeItem, fetchKnowledgeItems, fetchKnowledgeOverview, fetchKnowledgeRuns, fetchKnowledgeTraces, knowledgeItemAction, saveKnowledgeItem, searchKnowledge, setKnowledgeEnabled, setKnowledgeWatch } from '#/api/knowledge';
import ArchiveAccountSelector from '#/components/archive-account-selector.vue';
import { t } from '#/locales/t';
import KnowledgeRunDialog from './run-dialog.vue';
import KnowledgeRunsPanel from './runs-panel.vue';
import KnowledgeSettingsDialog from './settings-dialog.vue';
import KnowledgeBatchDialog from './batch-dialog.vue';
import KnowledgeContentTypeTag from './content-type-tag.vue';
import KnowledgeItemFields from './item-fields.vue';
import KnowledgeItemSources from './item-sources.vue';
import KnowledgeMyReviews from './my-reviews.vue';
import KnowledgeReviewAssignmentDialog from './review-assignment-dialog.vue';
import KnowledgeReviewPolicyDialog from './review-policy-dialog.vue';
import KnowledgeReviewAll from './review-all.vue';
import type { BatchAction } from './batch';
import { actionProblem } from './batch';
import { draftContent } from './draft-content';
import { shortTime } from './run-format';
import { useArchiveLoad } from '#/views/archive/use-archive-load';
const props = defineProps<{ assignmentMode?: boolean; tasksMode?: boolean; searchMode?: boolean }>();
const workbenchMode = computed(() => !props.assignmentMode && !props.tasksMode && !props.searchMode);
const { hasAccessByCodes } = useAccess();
const hasAll = (codes: string[]) => codes.every((code) => hasAccessByCodes([code]));
const canReadKnowledge = computed(() => hasAccessByCodes(['knowledge:read']));
const canAssign = computed(() => hasAccessByCodes(['knowledge:review:assign']));
const canReadTasks = computed(() => hasAccessByCodes(['knowledge:tasks:read']));
const canSearch = computed(() => hasAccessByCodes(['knowledge:search']));
const canReadPage = computed(() => {
if (props.assignmentMode) return canAssign.value;
if (props.tasksMode) return canReadTasks.value;
if (props.searchMode) return canSearch.value;
return canReadKnowledge.value;
});
const canReadMyReviews = computed(() => workbenchMode.value && hasAll(['knowledge:read', 'knowledge:review', 'im:content:read']));
const canMaintain = computed(() => !props.tasksMode && canAssign.value && hasAll(['knowledge:read', 'im:content:read']));
// 每个按钮一个权限码;碰到聊天原文(来源证据)的操作还要能看正文,和后端判法一致
const withContent = (code: string) => computed(() => hasAll([code, 'im:content:read']));
const canRun = withContent('knowledge:run');
const canControl = withContent('knowledge:run:control');
const canSettings = computed(() => hasAccessByCodes(['knowledge:settings']));
const canWatch = withContent('knowledge:watch');
const taskAction = (code: string) => computed(() => props.tasksMode && canReadTasks.value && hasAll([code, 'im:content:read']));
const canRun = taskAction('knowledge:run');
const canControl = taskAction('knowledge:run:control');
const canSettings = computed(() => (workbenchMode.value || props.tasksMode) && hasAccessByCodes(['knowledge:settings']));
const canWatch = taskAction('knowledge:watch');
const canEdit = withContent('knowledge:write');
const canRestore = withContent('knowledge:restore');
const canDelete = withContent('knowledge:delete');
const canReview = withContent('knowledge:review');
const canReject = withContent('knowledge:reject');
const canAutoReview = withContent('knowledge:review:auto');
const canSetReviewPolicy = computed(() => workbenchMode.value && hasAll(['knowledge:read', 'knowledge:review:settings']));
const canAutoReview = computed(() => canReadMyReviews.value && hasAccessByCodes(['knowledge:review:auto']));
const canPublish = withContent('knowledge:publish');
const canDisable = withContent('knowledge:disable');
const canEnable = computed(() => hasAccessByCodes(['knowledge:enable']));
const canSearch = computed(() => hasAccessByCodes(['knowledge:search']));
const canExport = computed(() => hasAccessByCodes(['knowledge:export']));
const canTrace = computed(() => hasAccessByCodes(['stats:read']));
const canBatch = computed(() => canReview.value || canReject.value || canPublish.value || canDisable.value || canDelete.value);
const canExport = computed(() => workbenchMode.value && canMaintain.value && hasAccessByCodes(['knowledge:export']));
const canTrace = computed(() => workbenchMode.value && canMaintain.value && hasAccessByCodes(['stats:read']));
const ownScopeFlag = computed(() => hasAccessByCodes(['knowledge:scope:own']));
const knowledgeScope = ref<KnowledgeOverview['knowledge_scope'] | null>(null);
const scopeSignature = (scope: KnowledgeOverview['knowledge_scope']) =>
JSON.stringify([scope.mode, [...new Set(scope.account_ids)].sort((left, right) => left - right)]);
const ownScope = computed(() => knowledgeScope.value?.mode === 'zyt_account'
|| (ownScopeFlag.value && !knowledgeScope.value));
const allowedAccountIds = computed(() => ownScope.value ? knowledgeScope.value?.account_ids || [] : undefined);
const scopeVersion = ref(0);
type MaintenanceAction = Extract<BatchAction, 'delete' | 'disable' | 'publish'>;
const accountId = ref(ALL_ACCOUNTS);
const single = computed(() => accountId.value !== ALL_ACCOUNTS);
const tab = ref('items');
const tab = ref(canReadMyReviews.value ? 'my-reviews' : 'traces');
const overview = ref<KnowledgeOverview | null>(null);
const items = ref<KnowledgeItem[]>([]);
const runs = ref<KnowledgeRun[]>([]);
@@ -52,83 +80,260 @@ const autoSummary = ref<KnowledgeAutoSummary | null>(null);
const reviewJobs = ref<KnowledgeReviewJob[]>([]);
const reviewOpen = ref(false);
const reviewTab = ref('new');
function openFullReview(view: string) { reviewTab.value = view; reviewOpen.value = true; }
async function inspectReviewed(itemId: string, targetAccount: number) {
reviewOpen.value = false; accountId.value = targetAccount;
await accountChanged();
if (accountId.value === targetAccount) await inspect(itemId);
function openFullReview(view: string) {
if (!canAutoReview.value || tab.value !== 'my-reviews') return;
reviewTab.value = view; reviewOpen.value = true;
}
const reviewRefresh = ref(0);
function assignedReviewsChanged() {
reviewRefresh.value++;
void load();
}
const traces = ref<KnowledgeTrace[]>([]);
const total = ref(0);
const page = ref(1);
const pageSizePresets = [30, 50, 100, 300, 500, 1000, 2000];
const pageSizeKey = 'wecom-knowledge-assignment-page-size';
const validPageSize = (value: number) => Number.isInteger(value) && value >= 1 && value <= 2000;
function savedPageSize() {
try {
const saved = Number(localStorage.getItem(pageSizeKey));
if (validPageSize(saved)) return saved;
} catch {
// Keep the default when browser storage is unavailable.
}
return 30;
}
const pageSize = ref(props.assignmentMode ? savedPageSize() : 30);
const sizeOption = ref<number | 'custom'>(pageSizePresets.includes(pageSize.value) ? pageSize.value : 'custom');
const customSize = ref(String(pageSize.value));
const pageSizeError = ref(false);
const pageSizeOptions = computed(() => [
...pageSizePresets.map((value) => ({ label: String(value), value })),
{ label: t('自定义'), value: 'custom' },
]);
const filter = ref('');
const query = ref('');
const queryInput = ref('');
const testQuery = ref('');
const searchError = ref('');
const result = ref<KnowledgeSearch | null>(null);
const selected = ref<KnowledgeItem | null>(null);
const savedContent = ref('');
const contentSignature = (item: KnowledgeItem) => JSON.stringify([item.title, item.question, item.answer, item.conditions, item.category, item.kind, item.valid_until]);
const contentSignature = (item: KnowledgeItem) => JSON.stringify(draftContent(item));
const dirty = computed(() => !!selected.value && contentSignature(selected.value) !== savedContent.value);
const editorOpen = ref(false);
const createOpen = ref(false);
const settingsOpen = ref(false);
const policyOpen = ref(false);
const selectedKeys = ref<string[]>([]);
const batchOpen = ref(false);
const batchAction = ref<BatchAction>('approve');
const batchAction = ref<MaintenanceAction>('publish');
const batchEntries = ref<KnowledgeItem[]>([]);
const selectedRows = computed(() => items.value.filter((item) => selectedKeys.value.includes(item.id)));
const rowSelection = computed(() => canBatch.value ? {
const assignmentEntries = ref<KnowledgeItem[]>([]);
const selectedRows = computed(() => {
const keys = new Set(selectedKeys.value);
return items.value.filter((item) => keys.has(item.id));
});
const assignmentTooLarge = computed(() => selectedKeys.value.length > MAX_KNOWLEDGE_REVIEW_ASSIGNMENTS);
const canAssignSelected = computed(() => canAssign.value && !assignmentTooLarge.value && selectedRows.value.length > 0
&& selectedRows.value.length === selectedKeys.value.length && selectedRows.value.every((item) => item.status === 'draft'));
const rowSelection = computed(() => canAssign.value ? {
selectedRowKeys: selectedKeys.value,
getCheckboxProps: (item: KnowledgeItem) => ({ disabled: item.status !== 'draft'
&& !(['delete', 'disable', 'publish'] as const).some((action) => actionPermission(action) && !actionProblem(item, action)) }),
onChange: (keys: (number | string)[]) => { selectedKeys.value = keys.map(String); },
} : undefined);
const guideStep = computed(() => !single.value ? 0 : (overview.value?.counts.published || 0) > 0 ? 3
: (overview.value?.counts.draft || 0) + (overview.value?.counts.approved || 0) > 0 ? 2 : 1);
const guideText = computed(() => !single.value ? t('点「整理聊天记录」可一次整理全部账号的聊天;点知识标题可直接查看、审核和发布。')
: !overview.value?.source_accounts.length ? t('当前账号尚无聊天归档,请先上传归档或更换账号。')
: guideStep.value === 1 ? t('点「整理聊天记录」生成草稿,再逐条核对来源和适用条件。')
: guideStep.value === 2 ? t('草稿补全适用条件后审核,通过后发布;也可以勾选列表中的多条知识集中处理。')
: t('已发布知识可在检索测试中验证;确认结果后开启客服使用知识。'));
function batchAllowed(action: BatchAction) {
return selectedRows.value.length > 0 && selectedRows.value.every((item) => !actionProblem(item, action));
function actionPermission(action: MaintenanceAction) {
return canMaintain.value && { publish: canPublish.value, disable: canDisable.value, delete: canDelete.value }[action];
}
function openBatch(action: BatchAction) {
const batchPermission = computed(() => actionPermission(batchAction.value));
function batchAllowed(action: MaintenanceAction) {
return actionPermission(action) && selectedRows.value.some((item) => !actionProblem(item, action));
}
function openBatch(action: MaintenanceAction) {
if (!batchAllowed(action) || busy.value) return;
batchAction.value = action;
batchEntries.value = selectedRows.value.map((item) => ({ ...item }));
batchEntries.value = selectedRows.value.filter((item) => !actionProblem(item, action)).map((item) => ({ ...item }));
batchOpen.value = true;
}
function batchFinished() { selectedKeys.value = []; void load(); }
function startCreate() { createOpen.value = true; }
function created() { tab.value = 'jobs'; void load(); }
function listChanged() { selectedKeys.value = []; void load(); }
const confirmed = ref(false);
function openAssignment() {
if (busy.value || loading.value || !canAssignSelected.value) return;
assignmentEntries.value = selectedRows.value.map((item) => ({ ...item }));
}
function closeAssignment() { assignmentEntries.value = []; }
function assignmentSaved() { closeAssignment(); selectedKeys.value = []; void load(); }
function policySaved() {
policyOpen.value = false;
message.success(t('审核设置已保存'));
void load();
}
function startCreate() {
if (active && canRun.value && knowledgeScope.value) createOpen.value = true;
}
function changeWatch(sourceId: string, enabled: boolean) {
if (active && canWatch.value && single.value) void mutate(() => setKnowledgeWatch(accountId.value, sourceId, enabled));
}
function listChanged(currentPage = 1) {
closeEditor();
closeAssignment();
page.value = currentPage;
items.value = [];
selectedKeys.value = [];
void load();
}
function searchItems() {
query.value = queryInput.value.trim();
listChanged();
}
function setPageSize(value: number) {
if (pageSize.value === value) return;
pageSize.value = value;
try {
localStorage.setItem(pageSizeKey, String(value));
} catch {
// The current view can still use the new size.
}
listChanged();
}
function choosePageSize(value: unknown) {
pageSizeError.value = false;
if (value === 'custom') {
sizeOption.value = value;
customSize.value = String(pageSize.value);
} else if (typeof value === 'number' && pageSizePresets.includes(value)) {
sizeOption.value = value;
setPageSize(value);
}
}
function applyCustomPageSize() {
const text = customSize.value.trim();
const value = Number(text);
pageSizeError.value = !/^\d+$/.test(text) || !validPageSize(value);
if (!pageSizeError.value) setPageSize(value);
}
const busy = ref(false);
const request = useArchiveLoad();
const { loading } = request;
let active = true;
let timer: ReturnType<typeof setTimeout> | undefined;
let detailGeneration = 0;
let searchRequest: AbortController | undefined;
const searching = ref(false);
let scopeReloadPending = false;
function closeEditor() {
detailGeneration++;
selected.value = null; savedContent.value = ''; editorOpen.value = false;
}
function clearReviewData() {
closeEditor();
items.value = []; total.value = 0; page.value = 1; reviewJobs.value = []; traces.value = [];
selectedKeys.value = []; batchEntries.value = []; batchOpen.value = false; reviewOpen.value = false;
closeAssignment();
}
// /me polling updates access codes in place. Clear the previous scope before
// rendering, and invalidate requests and dialogs that still carry old items.
function clearSearch() {
searchRequest?.abort();
searchRequest = undefined;
searching.value = false;
result.value = null;
searchError.value = '';
}
function clearScopeData() {
if (timer) clearTimeout(timer);
clearSearch(); scopeVersion.value++;
clearReviewData();
overview.value = null; runs.value = []; autoSummary.value = null;
policyOpen.value = false;
createOpen.value = false;
settingsOpen.value = false;
}
watch(ownScopeFlag, () => {
request.cancel();
clearScopeData(); knowledgeScope.value = null;
scopeReloadPending = !active;
if (active && canReadPage.value) void load();
}, { flush: 'sync' });
watch(accountId, () => {
closeAssignment(); closeEditor(); clearSearch();
if (props.tasksMode) {
overview.value = null;
if (active && knowledgeScope.value) void load();
}
}, { flush: 'sync' });
watch(canRun, (allowed) => { if (!allowed) createOpen.value = false; }, { flush: 'sync' });
watch(canSettings, (allowed) => { if (!allowed) settingsOpen.value = false; }, { flush: 'sync' });
watch(canWatch, (allowed) => {
if (!allowed && props.tasksMode) accountId.value = ALL_ACCOUNTS;
}, { flush: 'sync' });
watch(tab, () => {
closeAssignment(); closeEditor();
batchOpen.value = false;
if (tab.value !== 'my-reviews') reviewOpen.value = false;
}, { flush: 'sync' });
watch(canAutoReview, (allowed) => {
if (!allowed) { reviewOpen.value = false; reviewJobs.value = []; }
}, { flush: 'sync' });
watch(canSetReviewPolicy, (allowed) => { if (!allowed) policyOpen.value = false; }, { flush: 'sync' });
watch([canReadPage, canReadMyReviews, canMaintain, canAssign, canTrace], ([canRead, reviews]) => {
request.cancel();
if (canRead) {
clearReviewData();
overview.value = null;
} else {
clearScopeData(); knowledgeScope.value = null;
}
if (workbenchMode.value) {
if (!reviews) tab.value = 'traces';
else if (!canTrace.value) tab.value = 'my-reviews';
}
scopeReloadPending = !active;
if (active && canRead) void load();
}, { flush: 'sync' });
// 文案随语言切换:包成 computed(模板里自动解包)
const labels = computed<Record<string, string>>(() => ({ draft: t('待审核'), approved: t('待发布'), published: t('已发布'), rejected: t('已驳回'), disabled: t('已停用'), stale: t('来源已变化'), queued: t('等待处理'), running: t('处理中'), paused: t('已暂停'), completed: t('已完成'), failed: t('失败'), cancelled: t('已取消') }));
const colors: Record<string, string> = { draft: 'orange', approved: 'blue', published: 'green', rejected: 'red', stale: 'red', completed: 'green', failed: 'red', running: 'blue' };
const modes = computed<Record<string, string>>(() => ({ lexical: t('关键词检索'), hybrid: t('关键词与语义检索'), lexical_fallback: t('语义服务暂不可用,已使用关键词'), unavailable: t('检索暂不可用') }));
const statusOptions = computed(() => [{ value: '', label: t('全部状态') }, ...['draft', 'approved', 'published', 'rejected', 'disabled', 'stale'].map((value) => ({ value, label: labels.value[value] }))]);
const kindOptions = computed(() => [{ value: 'qa', label: t('标准问答') }, { value: 'procedure', label: t('业务流程') }, { value: 'case', label: t('对话案例') }]);
const sourceOptions = computed(() => (overview.value?.source_accounts || []).map((a) => ({ value: a.id, label: a.display_name || a.external_account_id })));
async function load() {
if (!active || !canReadPage.value) return;
await request.run(async (signal) => {
// Resolve the trusted knowledge scope before using a remembered archive account.
const allSummary = await fetchKnowledgeOverview(ALL_ACCOUNTS, signal);
if (signal.aborted) throw new DOMException('Aborted', 'AbortError');
if (knowledgeScope.value && scopeSignature(knowledgeScope.value) !== scopeSignature(allSummary.knowledge_scope)) clearScopeData();
knowledgeScope.value = allSummary.knowledge_scope;
if (signal.aborted) throw new DOMException('Aborted', 'AbortError');
if (knowledgeScope.value?.mode === 'zyt_account' && accountId.value !== ALL_ACCOUNTS
&& !knowledgeScope.value.account_ids.includes(accountId.value)) {
clearScopeData(); accountId.value = ALL_ACCOUNTS;
}
if (signal.aborted) throw new DOMException('Aborted', 'AbortError');
const id = accountId.value;
const [summary, entries, tasks, logs, reviews] = await Promise.all([
fetchKnowledgeOverview(id, signal), fetchKnowledgeItems(id, filter.value, query.value, page.value, signal),
fetchKnowledgeRuns(signal), canTrace.value ? fetchKnowledgeTraces(id, signal) : Promise.resolve({ items: [] }),
id === ALL_ACCOUNTS || props.searchMode ? Promise.resolve(allSummary) : fetchKnowledgeOverview(id, signal),
props.assignmentMode ? fetchKnowledgeItems(id, filter.value, query.value, page.value, pageSize.value, signal) : Promise.resolve({ items: [], total: 0 }),
props.tasksMode ? fetchKnowledgeRuns(signal) : Promise.resolve({ items: [], auto: null }),
canTrace.value ? fetchKnowledgeTraces(id, signal) : Promise.resolve({ items: [] }),
canAutoReview.value ? fetchKnowledgeReviewJobs(signal) : Promise.resolve({ items: [] }),
]);
return { summary, entries, tasks, logs, reviews };
}, (data) => {
overview.value = data.summary; items.value = data.entries.items; total.value = data.entries.total;
runs.value = data.tasks.items; autoSummary.value = data.tasks.auto; reviewJobs.value = data.reviews.items; traces.value = data.logs.items;
overview.value = data.summary;
runs.value = data.tasks.items; autoSummary.value = data.tasks.auto;
if (props.assignmentMode) {
items.value = data.entries.items; total.value = data.entries.total;
if (selected.value && items.value.some((item) => item.id === selected.value?.id && isSummary(item.status))) closeEditor();
}
if (canAutoReview.value) reviewJobs.value = data.reviews.items;
if (canTrace.value) traces.value = data.logs.items;
});
schedule();
}
@@ -138,19 +343,24 @@ function schedule() {
timer = setTimeout(() => { if (document.visibilityState === 'visible' && !busy.value) void load(); else schedule(); }, 5000);
}
async function accountChanged() {
const currentAccount = accountId.value;
detailGeneration++; selected.value = null; editorOpen.value = false;
items.value = []; traces.value = []; result.value = null; searchError.value = ''; overview.value = null;
closeEditor(); clearSearch();
items.value = []; traces.value = []; overview.value = null;
selectedKeys.value = []; batchOpen.value = false; batchEntries.value = []; page.value = 1;
await load();
if (currentAccount !== accountId.value) return;
}
// 「全部账号」下也能直接打开:后端按知识自己的账号处理,并检查在授权范围内
function isSummary(status: string) {
return status === 'draft' || status === 'stale';
}
async function inspect(id: string) {
if (!canMaintain.value || items.value.some((item) => item.id === id && isSummary(item.status))) return;
const generation = ++detailGeneration;
const entry = await fetchKnowledgeItem(accountId.value, id);
if (generation !== detailGeneration) return;
selected.value = entry; savedContent.value = contentSignature(entry); confirmed.value = false; editorOpen.value = true;
try {
const entry = await fetchKnowledgeItem(accountId.value, id);
if (generation !== detailGeneration || !canMaintain.value || isSummary(entry.status)) return;
selected.value = entry; savedContent.value = contentSignature(entry); editorOpen.value = true;
} catch {
// RequestClient reports the error. The item may now be an unreviewed revision.
}
}
async function mutate(action: () => Promise<unknown>) {
if (busy.value) return;
@@ -159,33 +369,39 @@ async function mutate(action: () => Promise<unknown>) {
}
async function save() {
const item = selected.value;
if (!item) return;
if (!item || !canMaintain.value || !canEdit.value || !dirty.value || isSummary(item.status)) return;
const id = accountId.value;
const generation = detailGeneration;
await mutate(async () => {
const saved = await saveKnowledgeItem(id, item);
if (generation === detailGeneration) { selected.value = { ...saved, account_id: item.account_id, account_label: item.account_label }; savedContent.value = contentSignature(saved); confirmed.value = false; }
await saveKnowledgeItem(id, item);
if (generation === detailGeneration) closeEditor();
message.success(t('已保存为草稿,需要重新审核后发布'));
});
}
async function act(action: string, restoreRevision = 0) {
async function act(action: 'disable' | 'publish' | 'restore', restoreRevision = 0) {
const item = selected.value;
if (!item) return;
if (!canMaintain.value || !item || isSummary(item.status) || dirty.value) return;
if (action === 'restore' ? !canRestore.value || restoreRevision <= 0 || restoreRevision >= item.revision
: !actionPermission(action) || actionProblem(item, action)) return;
const id = accountId.value;
const generation = detailGeneration;
await mutate(async () => {
const changed = await knowledgeItemAction(id, item, action, confirmed.value, restoreRevision);
if (generation === detailGeneration) { selected.value = { ...changed, account_id: item.account_id, account_label: item.account_label }; savedContent.value = contentSignature(changed); confirmed.value = false; }
const changed = await knowledgeItemAction(id, item, action, false, restoreRevision);
if (generation === detailGeneration) {
if (action === 'restore' || isSummary(changed.status)) closeEditor();
else { selected.value = { ...changed, account_id: item.account_id, account_label: item.account_label }; savedContent.value = contentSignature(changed); }
}
message.success(action === 'restore' ? t('已恢复为草稿,请审核后重新发布') : t('操作成功'));
});
}
function deleteSelected() {
if (!selected.value) return;
if (!canMaintain.value || !canDelete.value || selected.value?.status !== 'rejected') return;
const item = { ...selected.value }; const id = accountId.value; const generation = detailGeneration;
Modal.confirm({ title: t('删除这条已驳回知识?'), content: t('将删除知识及其来源快照和版本记录,原始聊天归档保留。删除后无法恢复。'),
okText: t('确认删除'), okType: 'danger', cancelText: t('取消'), onOk: () => mutate(async () => {
if (generation !== detailGeneration || !canMaintain.value || !canDelete.value) return;
await knowledgeItemAction(id, item, 'delete', true);
if (generation === detailGeneration) { editorOpen.value = false; selected.value = null; }
if (generation === detailGeneration) closeEditor();
selectedKeys.value = selectedKeys.value.filter((key) => key !== item.id);
message.success(t('已删除'));
}) });
@@ -195,8 +411,8 @@ async function toggleEnabled(enabled: boolean) {
await mutate(() => setKnowledgeEnabled(id, enabled));
}
async function test() {
if (busy.value) return;
result.value = null; searchError.value = '';
if (!active || !props.searchMode || !canSearch.value || !knowledgeScope.value) return;
clearSearch();
if (!single.value) { searchError.value = t('请先选择具体账号'); return; }
const text = testQuery.value.trim();
const length = Array.from(text).length;
@@ -204,110 +420,192 @@ async function test() {
if (length > 2000) { searchError.value = t('检索问题不能超过 2000 个字符'); return; }
testQuery.value = text;
const id = accountId.value;
const generation = detailGeneration;
busy.value = true;
if (allowedAccountIds.value && !allowedAccountIds.value.includes(id)) {
searchError.value = t('请先选择具体账号'); return;
}
const current = new AbortController();
searchRequest = current;
searching.value = true;
try {
const found = await searchKnowledge(id, text);
if (generation === detailGeneration) result.value = found;
const found = await searchKnowledge(id, text, current.signal);
if (searchRequest === current) result.value = found;
} catch (error) {
if (generation === detailGeneration) searchError.value = requestErrorMessage(error, t('检索失败,请稍后重试'));
} finally { busy.value = false; }
if (searchRequest === current) searchError.value = requestErrorMessage(error, t('检索失败,请稍后重试'));
} finally {
if (searchRequest === current) {
searchRequest = undefined;
searching.value = false;
}
}
}
async function download() {
if (!canExport.value) return;
const id = accountId.value;
await mutate(async () => { const blob = await exportKnowledge(id); downloadFileFromBlob({ fileName: 'knowledge.jsonl', source: blob }); });
const generation = detailGeneration;
await mutate(async () => {
const blob = await exportKnowledge(id);
if (generation === detailGeneration && canExport.value) downloadFileFromBlob({ fileName: 'knowledge.jsonl', source: blob });
});
}
function stop() { active = false; detailGeneration++; request.cancel(); if (timer) clearTimeout(timer); }
onActivated(() => { active = true; schedule(); });
function stop() {
active = false; closeEditor(); clearSearch(); request.cancel(); closeAssignment();
policyOpen.value = false; createOpen.value = false; settingsOpen.value = false;
if (timer) clearTimeout(timer);
}
onMounted(() => { if (props.tasksMode || props.searchMode) void load(); });
onActivated(() => {
const returning = !active;
active = true;
if (scopeReloadPending || returning) {
scopeReloadPending = false;
reviewRefresh.value++;
void load();
} else {
schedule();
}
});
onDeactivated(stop); onUnmounted(stop);
</script>
<template>
<div class="space-y-4 p-5">
<Card :title="t('知识中心')">
<template #extra><ArchiveAccountSelector v-model="accountId" :disabled="busy || createOpen || batchOpen || settingsOpen || reviewOpen" @change="accountChanged" /></template>
<p class="mb-4 text-gray-500">{{ t('把历史聊天整理成可追溯的知识,审核发布后供客服回答时参考。') }}</p>
<div class="mb-5 rounded-lg border p-4">
<Steps size="small" :current="guideStep" :items="[{ title: t('整理聊天记录') }, { title: t('生成草稿') }, { title: t('审核知识') }, { title: t('发布并测试使用') }]" />
<p class="mb-0 mt-3 text-gray-500">{{ guideText }}</p>
</div>
<div v-if="canReadPage" class="space-y-4 p-5">
<Card v-if="assignmentMode" :title="t('指派管理')">
<template #extra>
<Space wrap>
<ArchiveAccountSelector v-model="accountId" :allowed-ids="allowedAccountIds"
:disabled="busy || batchOpen || !!assignmentEntries.length" @change="accountChanged" />
<Button :loading="loading" @click="load">{{ t('刷新') }}</Button>
</Space>
</template>
<Alert v-if="ownScope" class="mb-4" type="info" show-icon :message="t('当前仅显示本人 ZYT 账号名下的知识,包含管理员代为清洗的数据;操作仍按角色权限')" />
<Alert v-if="knowledgeScope?.mode === 'zyt_account' && !knowledgeScope.account_ids.length" class="mb-4" type="info" show-icon :message="t('本人 ZYT 账号暂无可用客户端。')" />
<div class="mb-5 grid grid-cols-2 gap-3 md:grid-cols-4">
<div v-for="key in ['draft', 'approved', 'published', 'stale']" :key="key" class="rounded-lg border p-4">
<div class="text-gray-500">{{ labels[key] }}</div><div class="mt-2 text-2xl font-semibold">{{ overview?.counts[key] || 0 }}</div>
</div>
</div>
<div class="mb-4 flex flex-wrap items-center gap-3">
<Select v-model:value="filter" :options="statusOptions" style="width: 150px" @change="() => listChanged()" />
<Input.Search v-model:value="queryInput" :placeholder="canMaintain ? t('搜索标题或问题') : t('搜索标题')" class="w-full sm:!w-72" @search="searchItems" />
<label for="knowledge-assignment-page-size">{{ t('每页条数') }}</label>
<Select id="knowledge-assignment-page-size" :value="sizeOption" :options="pageSizeOptions" class="min-w-24" @change="choosePageSize" />
<template v-if="sizeOption === 'custom'">
<Input v-model:value="customSize" inputmode="numeric" :aria-label="t('自定义每页条数')"
:status="pageSizeError ? 'error' : undefined" class="!w-28" @change="pageSizeError = false" @press-enter="applyCustomPageSize" />
<Button @click="applyCustomPageSize">{{ t('应用') }}</Button>
</template>
</div>
<Alert v-if="pageSizeError" class="mb-4" type="error" show-icon :message="t('请输入 1 到 2000 之间的整数。')" />
<div v-if="selectedKeys.length" class="mb-4 flex flex-wrap items-center gap-2 rounded border bg-gray-50 p-3 dark:bg-gray-900">
<span class="mr-2">{{ t('已选 {count} 条(当前页)', { count: selectedKeys.length }) }}</span>
<Button :disabled="!canAssignSelected || busy || loading" :title="!canAssignSelected && !assignmentTooLarge ? t('请只选择待审核草稿') : undefined" @click="openAssignment">{{ t('指派审核') }}</Button>
<Button v-if="canMaintain && canPublish" :disabled="!batchAllowed('publish') || busy" @click="openBatch('publish')">{{ t('发布选中') }}</Button>
<Dropdown v-if="canMaintain && (canDisable || canDelete)">
<Button :disabled="busy">{{ t('更多操作') }}</Button>
<template #overlay><Menu>
<Menu.Item v-if="canDisable" :disabled="!batchAllowed('disable')" danger @click="openBatch('disable')">{{ t('停用选中') }}</Menu.Item>
<Menu.Item v-if="canDelete" :disabled="!batchAllowed('delete')" danger @click="openBatch('delete')">{{ t('删除已驳回') }}</Menu.Item>
</Menu></template>
</Dropdown>
<Button type="link" @click="selectedKeys = []">{{ t('清空选择') }}</Button>
</div>
<Alert v-if="assignmentTooLarge" class="mb-4" type="warning" show-icon :message="t('每次最多指派或撤回 {limit} 条草稿。', { limit: MAX_KNOWLEDGE_REVIEW_ASSIGNMENTS })" />
<!-- 固定列宽并保留横向滚动,窄屏也能阅读账号和审核人。 -->
<Table :row-selection="rowSelection" :data-source="items" row-key="id" :loading="loading" :pagination="{ current: page, pageSize, total, showSizeChanger: false }" @change="(p) => listChanged(p.current || 1)"
:scroll="{ x: 1200 }"
:columns="[{ title: t('问题 / 标题'), dataIndex: 'title', key: 'title' }, ...(single ? [] : [{ title: t('账号'), dataIndex: 'account_label', key: 'account', width: 160 }]), { title: t('分类'), dataIndex: 'category', key: 'category', width: 120 }, { title: t('内容标记'), key: 'content_type', width: 140 }, { title: t('状态'), key: 'status', width: 130 }, { title: t('审核人'), key: 'assignee', width: 140 }, { title: t('版本'), dataIndex: 'revision', width: 75 }, { title: t('更新时间'), key: 'updated_at', width: 150 }]">
<template #emptyText><Empty :description="query || filter ? t('没有符合筛选条件的知识,可调整筛选后重试。') : t('还没有知识,先从历史聊天整理出待审草稿。')" /></template>
<template #bodyCell="{ column, record }">
<template v-if="column.key === 'title'">
<span v-if="!canMaintain || isSummary(record.status)">{{ record.title }}</span>
<Button v-else type="link" class="!h-auto whitespace-normal text-left" @click="inspect(record.id)">{{ record.title }}</Button>
</template>
<KnowledgeContentTypeTag v-else-if="column.key === 'content_type'" :value="record.content_type" />
<template v-else-if="column.key === 'status'">
<Tag :color="colors[record.status]">{{ labels[record.status] }}</Tag>
<div v-if="record.self_review_blocked && ['draft', 'approved'].includes(record.status)" class="mt-1 text-xs text-gray-500">{{ t('自己的知识须由他人审核') }}</div>
</template>
<span v-else-if="column.key === 'assignee'">{{ record.review_assignment?.assignee_name || (record.status === 'draft' ? t('未指派') : '—') }}</span>
<span v-else-if="column.key === 'updated_at'" class="whitespace-nowrap">{{ shortTime(record.updated_at) }}</span>
<template v-else-if="column.key === 'account'">{{ t(record.account_label) }}</template>
<template v-else-if="column.key === 'category'">{{ t(record.category) }}</template>
</template>
</Table>
</Card>
<Card v-else-if="tasksMode" :title="t('整理任务')">
<template #extra>
<Space wrap>
<ArchiveAccountSelector v-if="canWatch && knowledgeScope" v-model="accountId" :allowed-ids="allowedAccountIds"
:disabled="busy || createOpen || settingsOpen" />
<Button v-if="canRun" type="primary" :disabled="busy || !knowledgeScope" @click="startCreate">{{ t('整理聊天记录') }}</Button>
<Button :loading="loading" @click="load">{{ t('刷新') }}</Button>
</Space>
</template>
<Alert v-if="ownScope" class="mb-4" type="info" show-icon :message="t('当前仅显示本人 ZYT 账号名下的知识,包含管理员代为清洗的数据;操作仍按角色权限')" />
<Alert v-if="knowledgeScope?.mode === 'zyt_account' && !knowledgeScope.account_ids.length" class="mb-4" type="info" show-icon :message="t('本人 ZYT 账号暂无可用客户端。')" />
<div v-if="single && overview?.watches.length" class="mb-4 space-y-2">
<div v-for="watch in overview.watches" :key="watch.source_account_id" class="flex items-center gap-3">
<span>{{ sourceOptions.find((s) => s.value === watch.source_account_id)?.label }} · {{ t('新聊天自动整理') }}</span>
<Switch :checked="!!watch.enabled" :disabled="!canWatch || busy" @change="(value) => changeWatch(watch.source_account_id, Boolean(value))" />
</div>
</div>
<KnowledgeRunsPanel :key="scopeVersion" :runs="runs" :auto="autoSummary" :can-create="canRun && !!knowledgeScope" :can-control="canControl"
:can-settings="canSettings" :loading="loading"
@changed="load" @create="startCreate" @settings="settingsOpen = true" />
</Card>
<Card v-else-if="searchMode" :title="t('检索测试')">
<template #extra>
<ArchiveAccountSelector v-if="knowledgeScope" v-model="accountId" :allowed-ids="allowedAccountIds" />
</template>
<Alert v-if="ownScope" class="mb-4" type="info" show-icon :message="t('当前仅显示本人 ZYT 账号名下的知识,包含管理员代为清洗的数据;操作仍按角色权限')" />
<Alert v-if="knowledgeScope?.mode === 'zyt_account' && !knowledgeScope.account_ids.length" class="mb-4" type="info" show-icon :message="t('本人 ZYT 账号暂无可用客户端。')" />
<p class="text-gray-500">{{ t('测试只检索已发布知识,不发送客服消息。相关度是排序参考,不代表事实正确率。') }}</p>
<Input.Search v-model:value="testQuery" :placeholder="t('输入一个真实业务问题(2–2000 个字符)')" :enter-button="t('检索')" :disabled="!single || !knowledgeScope" :loading="searching" @search="test" @change="searchError = ''" />
<Alert v-if="searchError" class="mt-3" type="error" show-icon :message="searchError" />
<template v-if="result">
<p class="my-4">{{ modes[result.mode] || result.mode }} · {{ result.elapsed_ms }} ms · {{ t('{count} 条命中', { count: result.hits.length }) }}</p>
<Empty v-if="!result.hits.length" :description="t('没有可靠命中。请补充问题信息,或发布相应知识。')" />
<Card v-for="hit in result.hits" :key="hit.id" class="mb-3" :title="hit.title">
<template v-if="canMaintain" #extra><Button type="link" @click="inspect(hit.id)">{{ t('查看来源') }}</Button></template>
<p class="whitespace-pre-wrap">{{ hit.answer }}</p><p class="text-gray-500">{{ t('适用条件:{conditions}', { conditions: hit.conditions }) }}</p>
<KnowledgeContentTypeTag :value="hit.content_type" /><Tag>{{ t('版本 {revision}', { revision: hit.revision }) }}</Tag><Tag>{{ t('相关度 {score}', { score: hit.score }) }}</Tag>
</Card>
</template>
</Card>
<Card v-else v-show="tab !== 'my-reviews'" :title="t('知识中心')">
<template #extra>
<Space wrap>
<Button v-if="canSetReviewPolicy" @click="policyOpen = true">{{ t('审核设置') }}</Button>
<ArchiveAccountSelector v-model="accountId" :allowed-ids="allowedAccountIds" :disabled="busy || settingsOpen || reviewOpen || policyOpen" @change="accountChanged" />
</Space>
</template>
<p class="mb-4 text-gray-500">{{ t('把历史聊天整理成可追溯的知识,审核发布后供客服回答时参考。') }}</p>
<Alert v-if="ownScope" class="mb-4" type="info" show-icon :message="t('当前仅显示本人 ZYT 账号名下的知识,包含管理员代为清洗的数据;操作仍按角色权限')" />
<Alert v-if="knowledgeScope?.mode === 'zyt_account' && !knowledgeScope.account_ids.length" class="mb-4" type="info" show-icon :message="t('本人 ZYT 账号暂无可用客户端。')" />
<Space wrap>
<Tag>{{ overview?.semantic_configured ? t('支持语义与关键词检索') : t('关键词检索已就绪') }}</Tag>
<span>{{ t('客服使用知识') }}</span>
<Switch :checked="!!overview?.settings?.enabled" :disabled="!single || !canEnable || busy || (!overview?.settings?.enabled && !overview?.counts.published)" @change="(v) => toggleEnabled(Boolean(v))" />
<Button v-if="canRun" type="primary" :disabled="busy" @click="startCreate">{{ t('整理聊天记录') }}</Button>
<Switch :checked="!!overview?.settings?.enabled" :disabled="!single || !canEnable || busy || (canAssign && !overview?.settings?.enabled && !overview?.counts.published)" @change="(v) => toggleEnabled(Boolean(v))" />
<Button v-if="canSettings" @click="settingsOpen = true">{{ t('整理设置') }}</Button>
<Button v-if="canExport" :disabled="!single || busy" @click="download">{{ t('导出已发布知识') }}</Button>
<Button :loading="loading" @click="load">{{ t('刷新') }}</Button>
</Space>
<Alert v-if="!single" class="mt-4" type="info" show-icon :message="t('当前汇总全部授权账号:整理聊天、查看和审核知识都可以直接进行;检索测试、导出和「客服使用知识」开关需选择具体账号。')" />
<Alert v-if="!canReadMyReviews" class="mt-4" type="info" show-icon :message="t('需要知识审核权限才能查看知识与审核记录。')" />
</Card>
<Card>
<Card v-if="workbenchMode && (canReadMyReviews || canTrace)">
<Tabs v-model:active-key="tab">
<Tabs.TabPane key="items" :tab="t('知识与审核')">
<Space class="mb-4" wrap>
<Select v-model:value="filter" :options="statusOptions" style="width: 150px" @change="() => { page = 1; listChanged(); }" />
<Input.Search v-model:value="query" :placeholder="t('搜索标题或问题')" style="width: 300px" @search="() => { page = 1; listChanged(); }" />
</Space>
<Space v-if="canAutoReview" class="mb-4 flex" wrap>
<Button type="primary" :disabled="busy" @click="openFullReview('new')">{{ single ? t('一键审核此账号全部草稿') : t('一键审核全部授权账号') }}</Button>
<Button @click="openFullReview('jobs')">{{ t('审核任务与结果') }}</Button>
<Tag v-if="reviewJobs.some((job) => ['queued', 'running'].includes(job.status))" color="blue">{{ t('后台审核进行中') }}</Tag>
</Space>
<Space v-if="canBatch" class="mb-4 flex" wrap>
<span>{{ t('已选 {count} 条(当前页)', { count: selectedKeys.length }) }}</span>
<Button v-if="canReview" :disabled="!selectedKeys.length || busy" @click="openBatch('approve')">{{ t('批量审核') }}</Button>
<Button v-if="canPublish" type="primary" :disabled="!batchAllowed('publish') || busy" @click="openBatch('publish')">{{ t('发布选中') }}</Button>
<Button v-if="canReject" :disabled="!batchAllowed('reject') || busy" @click="openBatch('reject')">{{ t('驳回选中') }}</Button>
<Button v-if="canDisable" danger :disabled="!batchAllowed('disable') || busy" @click="openBatch('disable')">{{ t('停用选中') }}</Button>
<Button v-if="canDelete" danger :disabled="!batchAllowed('delete') || busy" @click="openBatch('delete')">{{ t('删除已驳回') }}</Button>
<Button v-if="selectedKeys.length" type="link" @click="selectedKeys = []">{{ t('清空选择') }}</Button>
</Space>
<!-- 固定列宽 + 最小 1000px:窗口窄时整表横向滚动,标题列不会把账号、状态挤成一个字一行 -->
<Table :row-selection="rowSelection" :data-source="items" row-key="id" :loading="loading" :pagination="{ current: page, pageSize: 30, total, showSizeChanger: false }" @change="(p) => { page = p.current || 1; listChanged(); }"
:scroll="{ x: 1000 }"
:columns="[{ title: t('问题 / 标题'), dataIndex: 'title', key: 'title' }, ...(single ? [] : [{ title: t('账号'), dataIndex: 'account_label', key: 'account', width: 160 }]), { title: t('分类'), dataIndex: 'category', key: 'category', width: 120 }, { title: t('状态'), key: 'status', width: 130 }, { title: t('版本'), dataIndex: 'revision', width: 75 }, { title: t('更新时间'), key: 'updated_at', width: 150 }]">
<template #emptyText><Empty :description="query || filter ? t('没有符合筛选条件的知识,可调整筛选后重试。') : t('还没有知识,先从历史聊天整理出待审草稿。')"><Button v-if="canRun && !query && !filter" type="primary" @click="startCreate">{{ t('整理聊天记录') }}</Button></Empty></template>
<template #bodyCell="{ column, record }">
<Button v-if="column.key === 'title'" type="link" class="!h-auto whitespace-normal text-left" @click="inspect(record.id)">{{ record.title }}</Button>
<Tag v-else-if="column.key === 'status'" :color="colors[record.status]">{{ labels[record.status] }}</Tag>
<span v-else-if="column.key === 'updated_at'" class="whitespace-nowrap">{{ shortTime(record.updated_at) }}</span>
<template v-else-if="column.key === 'account'">{{ t(record.account_label) }}</template>
<template v-else-if="column.key === 'category'">{{ t(record.category) }}</template>
<Tabs.TabPane v-if="canReadMyReviews" key="my-reviews" :tab="t('待我审核')">
<KnowledgeMyReviews :key="scopeVersion" :active="tab === 'my-reviews'" :refresh-version="reviewRefresh" @reviewed="load">
<template #actions>
<Button v-if="canAutoReview" type="primary" :disabled="busy" @click="openFullReview('new')">{{ canPublish ? t('审核并发布全部指派草稿') : t('审核全部指派草稿') }}</Button>
<Button v-if="canAutoReview" @click="openFullReview('jobs')">{{ t('审核任务与结果') }}</Button>
<Tag v-if="reviewJobs.some((job) => ['queued', 'running'].includes(job.status))" color="blue">{{ t('后台审核进行中') }}</Tag>
</template>
</Table>
</Tabs.TabPane>
<Tabs.TabPane key="jobs" :tab="t('整理任务')">
<div v-if="single && overview?.watches.length" class="mb-4 space-y-2">
<div v-for="watch in overview.watches" :key="watch.source_account_id" class="flex items-center gap-3">
<span>{{ sourceOptions.find((s) => s.value === watch.source_account_id)?.label }} · {{ t('新聊天自动整理') }}</span>
<Switch :checked="!!watch.enabled" :disabled="!canWatch || busy" @change="(value) => mutate(() => setKnowledgeWatch(accountId, watch.source_account_id, Boolean(value)))" />
</div>
</div>
<KnowledgeRunsPanel :runs="runs" :auto="autoSummary" :can-create="canRun" :can-control="canControl"
:can-settings="canSettings" :loading="loading"
@changed="load" @create="startCreate" @settings="settingsOpen = true" />
</Tabs.TabPane>
<Tabs.TabPane v-if="canSearch" key="test" :tab="t('检索测试')">
<p class="text-gray-500">{{ t('测试只检索已发布知识,不发送客服消息。相关度是排序参考,不代表事实正确率。') }}</p>
<Alert v-if="single && overview && !overview.counts.published" class="mb-3" type="info" show-icon :message="t('当前账号暂无已发布知识,请先审核并发布知识后再测试检索。')" />
<Input.Search v-model:value="testQuery" :placeholder="t('输入一个真实业务问题(2–2000 个字符)')" :enter-button="t('检索')" :disabled="!single" :loading="busy" @search="test" @change="searchError = ''" />
<Alert v-if="searchError" class="mt-3" type="error" show-icon :message="searchError" />
<template v-if="result">
<p class="my-4">{{ modes[result.mode] || result.mode }} · {{ result.elapsed_ms }} ms · {{ t('{count} 条命中', { count: result.hits.length }) }}</p>
<Empty v-if="!result.hits.length" :description="overview && !overview.counts.published ? t('当前账号没有已发布知识,审核通过后还需发布才能检索。') : t('没有可靠命中。请补充问题信息,或发布相应知识。')" />
<Card v-for="hit in result.hits" :key="hit.id" class="mb-3" :title="hit.title">
<template #extra><Button type="link" @click="inspect(hit.id)">{{ t('查看来源') }}</Button></template>
<p class="whitespace-pre-wrap">{{ hit.answer }}</p><p class="text-gray-500">{{ t('适用条件:{conditions}', { conditions: hit.conditions }) }}</p>
<Tag>{{ t('版本 {revision}', { revision: hit.revision }) }}</Tag><Tag>{{ t('相关度 {score}', { score: hit.score }) }}</Tag>
</Card>
</template>
</KnowledgeMyReviews>
</Tabs.TabPane>
<Tabs.TabPane v-if="canTrace" key="traces" :tab="t('引用记录')">
<Table :data-source="traces" row-key="id" :pagination="{ pageSize: 15 }" :columns="[{ title: t('时间'), dataIndex: 'created_at' }, { title: t('问题'), dataIndex: 'query' }, { title: t('知识来源'), key: 'hits' }, { title: t('检索方式'), key: 'mode' }, { title: t('耗时 ms'), dataIndex: 'elapsed_ms' }]">
@@ -320,46 +618,32 @@ onDeactivated(stop); onUnmounted(stop);
</Tabs>
</Card>
<KnowledgeRunDialog v-model:open="createOpen" :account-id="accountId" :can-watch="canWatch" @created="created" />
<KnowledgeSettingsDialog v-model:open="settingsOpen" />
<KnowledgeReviewAll v-model:open="reviewOpen" :account-id="accountId" :initial-tab="reviewTab" @changed="load" @inspect="inspectReviewed" />
<KnowledgeBatchDialog v-model:open="batchOpen" :account-id="accountId" :entries="batchEntries" :action="batchAction" @finished="batchFinished" @edit="(id) => { batchOpen = false; inspect(id); }" />
<KnowledgeRunDialog v-if="canRun" :key="'create-' + scopeVersion" v-model:open="createOpen" :account-id="accountId" :can-watch="canWatch" :allowed-account-ids="allowedAccountIds" @created="load" />
<KnowledgeSettingsDialog v-if="canSettings" v-model:open="settingsOpen" />
<KnowledgeReviewAll v-if="canAutoReview" :key="'review-' + scopeVersion" v-model:open="reviewOpen" :account-id="ALL_ACCOUNTS" :initial-tab="reviewTab" assigned-only @changed="assignedReviewsChanged" />
<KnowledgeBatchDialog v-if="assignmentMode && canMaintain" :key="'batch-' + scopeVersion" v-model:open="batchOpen" :account-id="accountId" :entries="batchEntries" :action="batchAction" :can-execute="batchPermission" :can-edit="false" @finished="batchFinished" @edit="(id) => { batchOpen = false; inspect(id); }" />
<KnowledgeReviewAssignmentDialog v-if="assignmentMode && canAssign && assignmentEntries.length" :account-id="accountId"
:entries="assignmentEntries" @close="closeAssignment" @saved="assignmentSaved" />
<KnowledgeReviewPolicyDialog v-if="canSetReviewPolicy && policyOpen" @close="policyOpen = false" @saved="policySaved" />
<Modal v-model:open="editorOpen" :title="t('知识审核与来源')" width="1100px" :footer="null" :destroy-on-close="true">
<Modal v-if="canMaintain" :open="editorOpen" :title="t('知识详情与来源')" width="1100px" :footer="null" :destroy-on-close="true" @cancel="closeEditor">
<template v-if="selected">
<Space class="mb-4"><Tag :color="colors[selected.status]">{{ labels[selected.status] }}</Tag><Tag>{{ t('版本 {revision}', { revision: selected.revision }) }}</Tag><Tag v-if="selected.account_label" color="blue">{{ t('账号:{account}', { account: t(selected.account_label) }) }}</Tag></Space>
<Space class="mb-4"><Tag :color="colors[selected.status]">{{ labels[selected.status] }}</Tag><KnowledgeContentTypeTag :value="selected.content_type" /><Tag>{{ t('版本 {revision}', { revision: selected.revision }) }}</Tag><Tag v-if="selected.account_label" color="blue">{{ t('账号:{account}', { account: t(selected.account_label) }) }}</Tag></Space>
<Alert v-for="flag in selected.flags" :key="flag" :message="t(flag)" type="warning" class="mb-2" />
<div class="mt-4 grid gap-6 md:grid-cols-2">
<div><h3 class="mb-3 font-semibold">{{ t('来源对话(已自动脱敏)') }}</h3>
<Empty v-if="!selected.sources?.length" :description="t('暂无可查看的来源,请检查正文查看权限')" />
<div v-for="source in selected.sources" :key="source.message_id" class="mb-3 rounded border p-3">
<div class="mb-1 text-xs text-gray-500">{{ source.role === 'staff' ? t('客服') : t('客户') }} · {{ source.sent_at }} · v{{ source.version_no }}</div>
<p class="m-0 whitespace-pre-wrap break-words">{{ source.content }}</p>
</div>
</div>
<Form layout="vertical">
<Form.Item :label="t('标题')"><Input v-model:value="selected.title" :maxlength="160" :disabled="!canEdit" /></Form.Item>
<Space><Form.Item :label="t('类型')"><Select v-model:value="selected.kind" :options="kindOptions" :disabled="!canEdit" style="width: 140px" /></Form.Item><Form.Item :label="t('分类')"><Input v-model:value="selected.category" :disabled="!canEdit" /></Form.Item></Space>
<Form.Item :label="t('完整问题')"><Input.TextArea v-model:value="selected.question" :rows="3" :maxlength="4000" :disabled="!canEdit" /></Form.Item>
<Form.Item :label="t('标准答案 / 步骤')"><Input.TextArea v-model:value="selected.answer" :rows="7" :maxlength="8000" :disabled="!canEdit" /></Form.Item>
<Form.Item :label="t('适用条件(必填)')"><Input.TextArea v-model:value="selected.conditions" :rows="3" :maxlength="2000" :disabled="!canEdit" /></Form.Item>
<Form.Item :label="t('有效期截止日期(可选)')"><Input v-model:value="selected.valid_until" type="date" :disabled="!canEdit" /></Form.Item>
</Form>
<KnowledgeItemSources :sources="selected.sources" />
<KnowledgeItemFields v-model="selected" :disabled="!canEdit || busy" />
</div>
<Alert v-if="dirty" class="my-3" type="info" :message="t('修改尚未保存。请先保存草稿,再审核或发布。')" />
<Checkbox v-if="selected.status === 'draft' && canReview" v-model:checked="confirmed" class="my-4">{{ t('已核对客服身份、事实、适用条件和脱敏;内容可作为通用经验。涉及医疗内容已完成专业审核。') }}</Checkbox>
<Space wrap>
<Button v-if="canEdit" :loading="busy" :disabled="selected.status === 'stale'" @click="save">{{ t('保存草稿') }}</Button>
<Button v-if="canReview && selected.status === 'draft'" type="primary" :disabled="!confirmed || busy || dirty || !selected.conditions.trim()" @click="act('approve')">{{ t('审核通过') }}</Button>
<Button v-if="canReject && ['draft', 'approved'].includes(selected.status)" danger :disabled="busy" @click="act('reject')">{{ t('驳回') }}</Button>
<Button v-if="canPublish && selected.status === 'approved'" type="primary" :loading="busy" :disabled="dirty" @click="act('publish')">{{ t('发布到知识库') }}</Button>
<Button v-if="canEdit" :loading="busy" :disabled="!dirty" @click="save">{{ t('保存草稿') }}</Button>
<Button v-if="canPublish && selected.status === 'approved' && !dirty" type="primary" :loading="busy" :disabled="dirty" @click="act('publish')">{{ t('发布到知识库') }}</Button>
<Button v-if="canDelete && selected.status === 'rejected'" danger :disabled="busy" @click="deleteSelected">{{ t('删除已驳回知识') }}</Button>
<Button v-if="canDisable && selected.status === 'published'" danger :disabled="busy" @click="act('disable')">{{ t('停用') }}</Button>
</Space>
<div class="mt-5 border-t pt-3"><h3 class="font-semibold">{{ t('版本与操作记录') }}</h3>
<div v-for="(history, index) in selected.history" :key="index" class="flex items-center justify-between py-1 text-sm">
<span>v{{ history.revision }} · {{ history.action }} · {{ history.created_at }}</span>
<Button v-if="canRestore && history.revision < selected.revision" type="link" :disabled="busy" @click="act('restore', history.revision)">{{ t('恢复为草稿') }}</Button>
<Button v-if="canRestore && history.revision < selected.revision" type="link" :disabled="busy || dirty" @click="act('restore', history.revision)">{{ t('恢复为草稿') }}</Button>
</div>
</div>
</template>
@@ -0,0 +1,17 @@
<script setup lang="ts">
import type { KnowledgeContentType } from '#/api/knowledge';
import { Tag } from 'ant-design-vue';
import { t } from '#/locales/t';
import { contentTypes } from './content-type';
defineProps<{ value?: KnowledgeContentType | null }>();
</script>
<template>
<Tag :color="value ? contentTypes[value]?.color : undefined">
{{ (value && contentTypes[value]?.label()) || t('未标注') }}
</Tag>
</template>
@@ -0,0 +1,9 @@
import type { KnowledgeContentType } from '#/api/knowledge';
import { t } from '#/locales/t';
export const contentTypes = {
standard_answer: { label: () => t('标准答案'), color: 'green' },
daily_communication: { label: () => t('日常生活沟通'), color: 'gold' },
medical: { label: () => t('医疗'), color: 'red' },
} satisfies Record<KnowledgeContentType, { label: () => string; color: string }>;
@@ -0,0 +1,5 @@
import type { KnowledgeReviewDraft } from '#/api/knowledge';
export function draftContent({ title, question, answer, conditions, category, content_type, kind, valid_until }: KnowledgeReviewDraft): KnowledgeReviewDraft {
return { title, question, answer, conditions, category, content_type, kind, valid_until };
}
@@ -0,0 +1,46 @@
import type { KnowledgeReviewDraft } from '#/api/knowledge';
import { createApp, defineComponent, h, nextTick, ref } from 'vue';
import { expect, it, vi } from 'vitest';
import { draftContent } from './draft-content';
import KnowledgeItemFields from './item-fields.vue';
vi.mock('#/locales/t', () => ({ t: (text: string) => text }));
it('selects and clears one colored content label independently of the category', async () => {
const item = ref<KnowledgeReviewDraft>({
title: 'Title', question: 'Question', answer: 'Answer', conditions: 'Applicable',
category: 'Free text', kind: 'qa', valid_until: '',
});
const host = document.createElement('div');
document.body.append(host);
const app = createApp(defineComponent({ setup: () => () => h(KnowledgeItemFields, {
disabled: false, modelValue: item.value,
}) }));
app.mount(host);
try {
const group = host.querySelector('[role="radiogroup"]')!;
const options = Array.from(group.querySelectorAll<HTMLInputElement>('input[type="radio"]'));
expect(options.map((option) => option.value)).toEqual(['standard_answer', 'daily_communication', 'medical']);
expect(group.querySelector('.ant-tag-green')?.textContent?.trim()).toBe('标准答案');
expect(group.querySelector('.ant-tag-gold')?.textContent?.trim()).toBe('日常生活沟通');
expect(group.querySelector('.ant-tag-red')?.textContent?.trim()).toBe('医疗');
expect(options.some((option) => option.checked)).toBe(false);
expect(JSON.stringify(draftContent(item.value))).not.toContain('content_type');
options[0]!.click(); await nextTick();
expect(item.value.content_type).toBe('standard_answer');
options[2]!.click(); await nextTick();
expect(item.value.content_type).toBe('medical');
expect(options.filter((option) => option.checked).map((option) => option.value)).toEqual(['medical']);
const clear = Array.from(host.querySelectorAll('button')).find((button) => button.textContent?.trim() === '清除标记')!;
clear.click(); await nextTick();
expect(options.some((option) => option.checked)).toBe(false);
expect(draftContent(item.value)).toMatchObject({ content_type: null, category: 'Free text' });
} finally {
app.unmount();
host.remove();
}
});
@@ -0,0 +1,56 @@
<script setup lang="ts" generic="T extends KnowledgeReviewDraft">
import type { KnowledgeReviewDraft } from '#/api/knowledge';
import { computed } from 'vue';
import { Button, Form, Input, Radio, Select, Space, Tag } from 'ant-design-vue';
import { t } from '#/locales/t';
import { contentTypes } from './content-type';
defineProps<{ disabled: boolean; focusConditions?: boolean }>();
const item = defineModel<T>({ required: true });
const kindOptions = computed(() => [
{ value: 'qa', label: t('标准问答') },
{ value: 'procedure', label: t('业务流程') },
{ value: 'case', label: t('对话案例') },
]);
</script>
<template>
<Form layout="vertical">
<Form.Item :label="t('标题')">
<Input v-model:value="item.title" :maxlength="160" :disabled="disabled" />
</Form.Item>
<Space>
<Form.Item :label="t('类型')">
<Select v-model:value="item.kind" :options="kindOptions" :disabled="disabled" style="width: 140px" />
</Form.Item>
<Form.Item :label="t('分类')">
<Input v-model:value="item.category" :disabled="disabled" />
</Form.Item>
</Space>
<Form.Item :label="t('内容标记')">
<Radio.Group v-model:value="item.content_type" name="knowledge-content-type" role="radiogroup" :aria-label="t('内容标记')" :disabled="disabled">
<Space wrap>
<Radio v-for="(option, value) in contentTypes" :key="value" :value="value">
<Tag :color="option.color">{{ option.label() }}</Tag>
</Radio>
</Space>
</Radio.Group>
<Button v-if="item.content_type && !disabled" type="link" size="small" @click="item.content_type = null">{{ t('清除标记') }}</Button>
</Form.Item>
<Form.Item :label="t('完整问题')">
<Input.TextArea v-model:value="item.question" :rows="3" :maxlength="4000" :disabled="disabled" />
</Form.Item>
<Form.Item :label="t('标准答案 / 步骤')">
<Input.TextArea v-model:value="item.answer" :rows="7" :maxlength="8000" :disabled="disabled" />
</Form.Item>
<Form.Item :label="t('适用条件(必填)')">
<Input.TextArea v-model:value="item.conditions" :rows="3" :maxlength="2000" :disabled="disabled" :autofocus="focusConditions" />
</Form.Item>
<Form.Item :label="t('有效期截止日期(可选)')">
<Input v-model:value="item.valid_until" type="date" :disabled="disabled" />
</Form.Item>
</Form>
</template>
@@ -0,0 +1,24 @@
<script setup lang="ts">
import type { KnowledgeSource } from '#/api/knowledge';
import { Empty } from 'ant-design-vue';
import { t } from '#/locales/t';
type Source = Pick<KnowledgeSource, 'content' | 'role' | 'sent_at'> & Partial<Pick<KnowledgeSource, 'message_id' | 'version_no'>>;
defineProps<{ sources?: Source[] }>();
</script>
<template>
<div>
<h3 class="mb-3 font-semibold">{{ t('来源对话(已自动脱敏)') }}</h3>
<Empty v-if="!sources?.length" :description="t('暂无可查看的来源,请检查正文查看权限')" />
<div v-for="(source, index) in sources" :key="source.message_id ?? index" class="mb-3 rounded border p-3">
<div class="mb-1 text-xs text-gray-500">
{{ source.role === 'staff' ? t('客服') : t('客户') }} · {{ source.sent_at }}
<template v-if="source.version_no !== undefined"> · v{{ source.version_no }}</template>
</div>
<p class="m-0 whitespace-pre-wrap break-words">{{ source.content }}</p>
</div>
</div>
</template>
@@ -0,0 +1,316 @@
<script setup lang="ts">
import type { KnowledgeReviewMode, MyKnowledgeReview } from '#/api/knowledge';
import { computed, onActivated, onBeforeUnmount, onDeactivated, onMounted, ref, watch } from 'vue';
import { useAccess } from '@vben/access';
import { Alert, Button, Empty, Modal, Space, Spin, Table, Tag, message } from 'ant-design-vue';
import { requestErrorMessage } from '#/api/error-message';
import { decideMyKnowledgeReview, fetchMyKnowledgeReview, fetchMyKnowledgeReviews, saveMyKnowledgeReview } from '#/api/knowledge';
import { t } from '#/locales/t';
import { useArchiveLoad } from '#/views/archive/use-archive-load';
import type { BatchResult, KnowledgeBatchItem } from './batch';
import KnowledgeBatchDialog from './batch-dialog.vue';
import KnowledgeContentTypeTag from './content-type-tag.vue';
import { draftContent } from './draft-content';
import KnowledgeItemFields from './item-fields.vue';
import KnowledgeItemSources from './item-sources.vue';
import { shortTime } from './run-format';
const props = defineProps<{ active: boolean; refreshVersion?: number }>();
const emit = defineEmits<{ reviewed: [] }>();
const { hasAccessByCodes } = useAccess();
const canRead = computed(() => ['knowledge:read', 'knowledge:review', 'im:content:read']
.every((code) => hasAccessByCodes([code])));
const canEdit = computed(() => canRead.value && hasAccessByCodes(['knowledge:write']));
const canPublish = computed(() => canRead.value && hasAccessByCodes(['knowledge:publish']));
const canReject = computed(() => canRead.value && hasAccessByCodes(['knowledge:reject']));
const visible = ref(false);
const active = computed(() => visible.value && props.active && canRead.value);
const pageSize = 30;
const items = ref<MyKnowledgeReview[]>([]);
const page = ref(1);
const total = ref(0);
const request = useArchiveLoad();
const { loading } = request;
const selectedKeys = ref<string[]>([]);
const selectedRows = computed(() => items.value.filter((item) => selectedKeys.value.includes(item.id)));
const rowSelection = computed(() => ({
selectedRowKeys: selectedKeys.value,
onChange: (keys: (number | string)[]) => { selectedKeys.value = keys.map(String); },
}));
const batchAction = ref<KnowledgeReviewMode>('approve');
const batchEntries = ref<MyKnowledgeReview[]>([]);
const batchOpen = ref(false);
const batchRevisions = new Map<string, number>();
const batchSuccesses = new Set<string>();
const batchProcessing = ref<'run' | 'save' | null>(null);
const canBatch = computed(() => active.value && (batchAction.value === 'approve' || canPublish.value));
const detailOpen = ref(false);
const detailLoading = ref(false);
const detailError = ref('');
const selected = ref<MyKnowledgeReview | null>(null);
const savedDraft = ref<ReturnType<typeof draftContent>>();
const busy = ref(false);
const dirty = computed(() => !!selected.value && JSON.stringify(draftContent(selected.value)) !== JSON.stringify(savedDraft.value));
let detailGeneration = 0;
let pendingDetail: MyKnowledgeReview | undefined;
const matchesAssignment = (item: MyKnowledgeReview, original: MyKnowledgeReview) =>
item.id === original.id && item.status === 'draft' && !!item.review_assignment?.id
&& item.review_assignment.id === original.review_assignment.id;
const matchesRevision = (item: MyKnowledgeReview, original: MyKnowledgeReview) =>
matchesAssignment(item, original) && item.revision === original.revision;
const isCurrent = (generation: number) => generation === detailGeneration && active.value && detailOpen.value;
const errorText = (error: unknown) => requestErrorMessage(error, t('请求未完成,请刷新确认状态后再操作'));
async function load() {
if (!active.value) return;
const current = page.value;
await request.run(async (signal) => {
const result = await fetchMyKnowledgeReviews(current, signal);
const lastPage = Math.max(1, Math.ceil(result.total / pageSize));
if (current <= lastPage || signal.aborted) return { result, current };
return { result: await fetchMyKnowledgeReviews(lastPage, signal), current: lastPage };
}, ({ result, current }) => {
const rows = result.items.filter((item) => item.status === 'draft' && !!item.review_assignment?.id);
const detail = selected.value || pendingDetail;
if (detail && !rows.some((item) => matchesAssignment(item, detail))) closeDetail();
else if (detail && !busy.value && !rows.some((item) => matchesRevision(item, detail))) closeDetail();
if (batchProcessing.value !== 'run' && batchEntries.value.some((entry) => !batchSuccesses.has(entry.id)
&& !rows.some((item) => matchesAssignment(item, entry)
&& (batchProcessing.value === 'save' || item.revision === batchRevisions.get(item.id))))) closeBatch();
selectedKeys.value = selectedKeys.value.filter((id) => {
const before = items.value.find((item) => item.id === id);
return before && rows.some((item) => matchesRevision(item, before));
});
page.value = current;
items.value = rows;
total.value = result.total;
});
}
function closeDetail() {
detailGeneration++;
pendingDetail = undefined;
detailOpen.value = false;
selected.value = null;
savedDraft.value = undefined;
detailLoading.value = false;
detailError.value = '';
busy.value = false;
}
async function inspect(id: string) {
const original = items.value.find((item) => item.id === id);
if (!active.value || !original || batchOpen.value) return;
closeDetail();
pendingDetail = original;
const generation = detailGeneration;
detailOpen.value = true;
detailLoading.value = true;
try {
const detail = await fetchMyKnowledgeReview(id);
if (!isCurrent(generation)) return;
if (!matchesRevision(detail, original)) {
closeDetail();
await load();
return;
}
selected.value = detail;
savedDraft.value = draftContent(detail);
} catch {
if (isCurrent(generation)) {
closeDetail();
await load();
}
} finally {
if (isCurrent(generation)) detailLoading.value = false;
}
}
async function mutate(action: (current: () => boolean) => Promise<void>) {
const generation = detailGeneration;
const current = () => isCurrent(generation);
if (!current() || busy.value) return;
busy.value = true;
detailError.value = '';
try {
await action(current);
} catch (error) {
if (current()) {
detailError.value = errorText(error);
await load();
}
} finally {
if (current()) busy.value = false;
}
}
async function save() {
const item = selected.value;
if (!item || !canEdit.value || !dirty.value) return;
await mutate(async (current) => {
const saved = await saveMyKnowledgeReview(item.id, {
...draftContent(item), assignment_id: item.review_assignment.id, revision: item.revision,
});
if (!current() || !canEdit.value) return;
if (saved.id !== item.id || saved.revision <= item.revision || saved.status !== 'draft'
|| saved.review_assignment?.id !== item.review_assignment.id) {
closeDetail();
await load();
return;
}
selected.value = { ...item, ...saved };
savedDraft.value = draftContent(saved);
message.success(t('已保存为草稿,需要重新审核后发布'));
void load();
});
}
async function decide(action: KnowledgeReviewMode | 'reject') {
const item = selected.value;
if (!item || item.self_review_blocked || dirty.value
|| (action === 'reject' ? !canReject.value : !item.conditions.trim())
|| (action === 'approve_publish' && !canPublish.value)) return;
await mutate(async (current) => {
const result = await decideMyKnowledgeReview(item, action);
if (!current()) return;
closeDetail();
message.success(result.status === 'published' ? t('已审核并发布') : result.status === 'approved' ? t('审核通过,已进入待发布') : t('已驳回'));
emit('reviewed');
await load();
});
}
function openBatch() {
if (!active.value || batchOpen.value || detailOpen.value || !selectedRows.value.length) return;
batchAction.value = canPublish.value ? 'approve_publish' : 'approve';
batchEntries.value = selectedRows.value.map((item) => ({
...item, answer: '', question: '', conditions: '', flags: [], sources: undefined,
}));
for (const item of batchEntries.value) batchRevisions.set(item.id, item.revision);
batchOpen.value = true;
}
function closeBatch() {
batchOpen.value = false;
batchEntries.value = [];
batchRevisions.clear();
batchSuccesses.clear();
batchProcessing.value = null;
}
function batchSaved(item: KnowledgeBatchItem) {
batchRevisions.set(item.id, item.revision);
void load();
}
function batchFinished(results: BatchResult[]) {
for (const result of results) {
if (result.status === 'success') batchSuccesses.add(result.id);
}
selectedKeys.value = [];
emit('reviewed');
void load();
}
function pageChanged(current?: number) {
selectedKeys.value = [];
page.value = current || 1;
void load();
}
function refreshVisible() {
if (active.value && !loading.value && document.visibilityState === 'visible') void load();
}
watch(canBatch, (allowed) => { if (!allowed) closeBatch(); }, { flush: 'sync' });
watch(() => props.refreshVersion, () => { if (active.value) void load(); });
watch([detailOpen, batchOpen], ([detail, batch], _before, cleanup) => {
if (!detail && !batch) return;
const timer = setInterval(refreshVisible, 5000);
cleanup(() => clearInterval(timer));
});
watch(canEdit, (allowed) => {
if (allowed || !dirty.value || !selected.value || !savedDraft.value) return;
if (busy.value) void inspect(selected.value.id);
else Object.assign(selected.value, savedDraft.value);
}, { flush: 'sync' });
watch(active, (show) => {
if (show) void load();
else {
request.cancel();
items.value = [];
total.value = 0;
page.value = 1;
selectedKeys.value = [];
closeDetail();
closeBatch();
}
}, { flush: 'sync' });
onMounted(() => {
visible.value = true;
document.addEventListener('visibilitychange', refreshVisible);
window.addEventListener('focus', refreshVisible);
});
onActivated(() => { visible.value = true; });
onDeactivated(() => { visible.value = false; });
onBeforeUnmount(() => {
visible.value = false;
document.removeEventListener('visibilitychange', refreshVisible);
window.removeEventListener('focus', refreshVisible);
});
</script>
<template>
<div v-if="active">
<div class="mb-4 flex flex-wrap items-center justify-between gap-3">
<p class="mb-0 text-gray-500">{{ t('这里只显示指派给你的待审核草稿。审核通过后进入待发布。') }}</p>
<Space wrap><slot name="actions" /><Button :loading="loading" @click="load">{{ t('刷新') }}</Button></Space>
</div>
<Space v-if="selectedRows.length" class="mb-4" wrap>
<span>{{ t('已选 {count} 条(当前页)', { count: selectedRows.length }) }}</span>
<Button type="primary" :disabled="batchOpen || detailOpen" @click="openBatch">{{ canPublish ? t('审核并发布选中') : t('审核选中') }}</Button>
<Button type="link" @click="selectedKeys = []">{{ t('清空选择') }}</Button>
</Space>
<Table :row-selection="rowSelection" :data-source="items" row-key="id" :loading="loading" :scroll="{ x: 480 }"
:pagination="{ current: page, pageSize, total, showSizeChanger: false }"
:columns="[{ title: t('问题 / 标题'), key: 'title' }, { title: t('版本'), dataIndex: 'revision', width: 95 }, { title: t('指派时间'), key: 'assigned_at', width: 180 }]"
@change="(p) => pageChanged(p.current)">
<template #emptyText><Empty :description="t('暂无指派给你的待审核草稿')" /></template>
<template #bodyCell="{ column, record }">
<div v-if="column.key === 'title'">
<Button type="link" class="!h-auto whitespace-normal text-left" @click="inspect(record.id)">{{ record.title }}</Button>
<KnowledgeContentTypeTag :value="record.content_type" />
<Tag v-if="record.self_review_blocked">{{ t('自己的知识须由他人审核') }}</Tag>
</div>
<span v-else-if="column.key === 'assigned_at'">{{ shortTime(record.review_assignment?.assigned_at || '') }}</span>
</template>
</Table>
<Modal :open="detailOpen" :title="t('知识审核与来源')" width="1100px" :footer="null"
:closable="!busy" :keyboard="!busy" :mask-closable="false" destroy-on-close @cancel="closeDetail">
<Spin :spinning="detailLoading">
<div v-if="detailLoading" class="min-h-24"></div>
<template v-if="selected">
<Space class="mb-4">
<Tag color="orange">{{ t('待审核') }}</Tag>
<KnowledgeContentTypeTag :value="selected.content_type" />
<Tag>{{ t('版本 {revision}', { revision: selected.revision }) }}</Tag>
</Space>
<Alert v-for="flag in selected.flags" :key="flag" :message="t(flag)" type="warning" class="mb-2" />
<div class="mt-4 grid gap-6 md:grid-cols-2">
<KnowledgeItemSources :sources="selected.sources" />
<KnowledgeItemFields v-model="selected" :disabled="!canEdit || busy" />
</div>
<Alert v-if="selected.self_review_blocked" class="my-3" type="warning" :message="t('自己的知识须由他人审核')" />
<p v-else class="my-3 text-gray-500">{{ dirty ? t('请先保存草稿再审核。') : t('请核对来源、事实、脱敏与适用条件,点击审核按钮即确认当前内容。') }}</p>
<Space wrap>
<Button v-if="canEdit" :disabled="busy || !dirty" @click="save">{{ t('保存草稿') }}</Button>
<Button type="primary" :disabled="busy || dirty || selected.self_review_blocked || !selected.conditions.trim()" @click="decide('approve')">{{ t('审核通过') }}</Button>
<Button v-if="canPublish" :disabled="busy || dirty || selected.self_review_blocked || !selected.conditions.trim()" @click="decide('approve_publish')">{{ t('审核并发布') }}</Button>
<Button v-if="canReject" danger :disabled="busy || dirty || selected.self_review_blocked" @click="decide('reject')">{{ t('确认驳回') }}</Button>
</Space>
</template>
<Alert v-if="detailError" class="my-3" type="error" show-icon :message="detailError" />
</Spin>
</Modal>
<KnowledgeBatchDialog :open="batchOpen" :account-id="-1" :entries="batchEntries" :action="batchAction"
:can-execute="canBatch" :can-edit="canEdit" @update:open="(open) => { if (!open) closeBatch(); }" @processing="(action) => { batchProcessing = action; }" @saved="batchSaved" @finished="batchFinished" />
</div>
</template>
@@ -0,0 +1,518 @@
import { createApp, defineComponent, h, nextTick, onMounted, ref } from 'vue';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
const api = vi.hoisted(() => ({
MAX_KNOWLEDGE_REVIEW_ASSIGNMENTS: 100,
fetchKnowledgeOverview: vi.fn(), fetchKnowledgeItems: vi.fn(), fetchKnowledgeRuns: vi.fn(),
fetchKnowledgeTraces: vi.fn(), fetchKnowledgeReviewJobs: vi.fn(), fetchKnowledgeItem: vi.fn(),
fetchKnowledgeReviewResults: vi.fn(), previewKnowledgeReview: vi.fn(), knowledgeReviewAction: vi.fn(),
fetchKnowledgeReviewAssignees: vi.fn(), fetchMyKnowledgeReviews: vi.fn(),
exportKnowledge: vi.fn(), knowledgeItemAction: vi.fn(), saveKnowledgeItem: vi.fn(), searchKnowledge: vi.fn(),
setKnowledgeEnabled: vi.fn(), setKnowledgeWatch: vi.fn(),
}));
const accessCodes = ref<string[]>([]);
vi.mock('@vben/access', () => ({ useAccess: () => ({
hasAccessByCodes: (codes: string[]) => codes.some((code) => accessCodes.value.includes(code)),
}) }));
vi.mock('@vben/utils', () => ({ downloadFileFromBlob: vi.fn() }));
vi.mock('#/api/knowledge', () => api);
vi.mock('#/api/console', () => ({ ALL_ACCOUNTS: -1,
fetchDesktopAccounts: async () => ({ accounts: [], can_view_legacy: false }),
}));
vi.mock('#/api/error-message', () => ({ requestErrorMessage: () => 'error' }));
vi.mock('#/locales/t', () => ({ t: (value: string) => value }));
vi.mock('#/components/archive-account-selector.vue', () => ({ default: defineComponent({
emits: ['change'], setup(_props, { emit }) { onMounted(() => emit('change', -1)); return () => h('div'); },
}) }));
vi.mock('./run-dialog.vue', () => ({ default: defineComponent({ setup: () => () => null }) }));
vi.mock('./runs-panel.vue', () => ({ default: defineComponent({ setup: () => () => null }) }));
vi.mock('./settings-dialog.vue', () => ({ default: defineComponent({ setup: () => () => null }) }));
vi.mock('./batch-dialog.vue', () => ({ default: defineComponent({ setup: () => () => null }) }));
vi.mock('ant-design-vue', async () => {
const { defineComponent, h } = await import('vue');
const plain = defineComponent({ setup: (_props, { slots }) => () => h('div', [slots.extra?.(), slots.default?.()]) });
const input = Object.assign({}, plain, { Search: plain, TextArea: plain });
return {
Alert: defineComponent({ props: ['message'], setup: (props) => () => h('p', props.message) }),
Modal: Object.assign(defineComponent({ props: ['open'], setup: (props, { slots }) =>
() => props.open ? h('section', slots.default?.()) : null }), { confirm: vi.fn() }),
Table: defineComponent({ props: ['dataSource', 'columns'], setup: (props, { slots }) => () =>
h('div', (props.dataSource || []).length ? (props.dataSource || []).map((row: { title?: string }) =>
h('span', slots.bodyCell?.({ column: { key: 'title' }, record: row }) || row.title)) : slots.emptyText?.()) }),
Form: Object.assign({}, plain, { Item: plain }), Tabs: Object.assign({}, plain, { TabPane: defineComponent({ props: ['tab'],
setup: (props, { slots }) => () => h('section', { 'data-tab': props.tab }, slots.default?.()),
}) }),
Input: input, Button: defineComponent({ props: ['type'], setup: (props, { slots }) => () => h('button', { 'data-type': props.type }, slots.default?.()) }), Card: defineComponent({ props: ['title'], setup: (props, { slots }) => () =>
h('article', { 'data-card': props.title }, [slots.extra?.(), slots.default?.()]) }), Dropdown: plain, Spin: plain, Menu: Object.assign({}, plain, { Item: plain }), Empty: defineComponent({ props: ['description'], setup: (props) => () => h('p', props.description) }), Radio: Object.assign({}, plain, { Group: plain }), Select: plain, Space: plain,
Steps: plain, Switch: plain, Tag: plain, Progress: plain, message: { success: vi.fn() },
};
});
import KnowledgeCenter from './center.vue';
let cleanup: (() => void) | undefined;
const item = (id: string) => ({ id, title: id, question: 'question', answer: 'answer', conditions: 'condition',
category: '', kind: 'qa', status: 'approved', revision: 1, flags: [], sources: [], history: [] });
async function settle() { for (let index = 0; index < 12; index++) { await Promise.resolve(); await nextTick(); } }
function mount(mode: boolean | 'search' | 'tasks' = false) {
const host = document.createElement('div'); document.body.append(host);
const app = createApp(KnowledgeCenter, { assignmentMode: mode === true, searchMode: mode === 'search', tasksMode: mode === 'tasks' }); const vm = app.mount(host);
cleanup = () => { app.unmount(); host.remove(); };
return { host, state: (vm.$ as unknown as { setupState: Record<string, any> }).setupState, instance: vm.$ };
}
function findReview(node: any): any {
if (node?.component?.type.__file?.endsWith('review-all.vue')) return node.component;
const nested = node?.component && findReview(node.component.subTree);
return nested || (Array.isArray(node?.children) && node.children.map(findReview).find(Boolean));
}
describe('knowledge own scope updates', () => {
beforeEach(() => {
vi.resetAllMocks();
localStorage.removeItem('wecom-knowledge-assignment-page-size');
accessCodes.value = ['knowledge:read', 'knowledge:review', 'knowledge:review:auto', 'knowledge:review:assign', 'im:content:read', 'knowledge:search'];
api.fetchKnowledgeOverview.mockImplementation(async () => ({ counts: { draft: 1 }, source_accounts: [], watches: [], settings: null,
knowledge_scope: accessCodes.value.includes('knowledge:scope:own')
? { mode: 'zyt_account', account_ids: [1] } : { mode: 'existing', account_ids: [] } }));
api.fetchKnowledgeItems.mockResolvedValue({ items: [item('other-knowledge')], total: 1 });
api.fetchKnowledgeRuns.mockResolvedValue({ items: [], auto: null });
api.fetchKnowledgeTraces.mockResolvedValue({ items: [] });
api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [] });
api.fetchKnowledgeReviewResults.mockResolvedValue({ items: [], total: 0 });
api.fetchKnowledgeItem.mockResolvedValue(item('other-knowledge'));
api.fetchMyKnowledgeReviews.mockResolvedValue({ items: [], total: 0 });
api.previewKnowledgeReview.mockResolvedValue({ id: 'preview', account_id: -1, scope_label: 'scope', total: 1,
mode: 'approve', published: 0, preview: { snapshot_at: '', eligible: 1, blocked: 0, accounts: [], reasons: [] } });
});
afterEach(() => { cleanup?.(); cleanup = undefined; });
it('clears old assignment rows, detail and selections immediately, then reloads both scope changes', async () => {
const { host, state } = mount(true); await settle();
expect(host.textContent).toContain('other-knowledge');
await state.inspect('other-knowledge');
state.selectedKeys = ['other-knowledge']; state.batchEntries = [item('other-knowledge')];
state.batchOpen = true;
const version = state.scopeVersion;
let resolveRows!: (value: unknown) => void;
api.fetchKnowledgeItems.mockImplementationOnce(() => new Promise((resolve) => { resolveRows = resolve; }));
accessCodes.value = [...accessCodes.value, 'knowledge:scope:own'];
expect(state.items).toEqual([]); expect(state.selected).toBeNull();
expect(state.selectedKeys).toEqual([]); expect(state.batchEntries).toEqual([]);
expect(state.editorOpen).toBe(false); expect(state.batchOpen).toBe(false);
expect(state.scopeVersion).toBe(version + 1);
await settle();
expect(host.textContent).toContain('当前仅显示本人 ZYT 账号名下的知识,包含管理员代为清洗的数据;操作仍按角色权限');
expect(host.textContent).not.toContain('other-knowledge');
resolveRows({ items: [item('own-knowledge')], total: 1 }); await settle();
expect(host.textContent).toContain('own-knowledge');
api.fetchKnowledgeItems.mockResolvedValue({ items: [item('all-knowledge')], total: 1 });
accessCodes.value = accessCodes.value.filter((code) => code !== 'knowledge:scope:own'); await settle();
expect(host.textContent).toContain('all-knowledge');
expect(host.textContent).not.toContain('当前仅显示本人 ZYT 账号名下的知识,包含管理员代为清洗的数据;操作仍按角色权限');
});
it('ignores in-flight assignment list and detail results from the previous scope', async () => {
const { host, state } = mount(true); await settle();
let resolveRows!: (value: unknown) => void;
let resolveDetail!: (value: unknown) => void;
api.fetchKnowledgeItems.mockImplementationOnce(() => new Promise((resolve) => { resolveRows = resolve; }));
api.fetchKnowledgeItem.mockImplementationOnce(() => new Promise((resolve) => { resolveDetail = resolve; }));
const oldLoad = state.load(); const oldInspect = state.inspect('old-detail');
await settle();
api.fetchKnowledgeItems.mockResolvedValue({ items: [item('own-knowledge')], total: 1 });
accessCodes.value = [...accessCodes.value, 'knowledge:scope:own']; await settle();
resolveRows({ items: [item('old-list')], total: 1 });
resolveDetail(item('old-detail'));
await Promise.all([oldLoad, oldInspect]); await settle();
expect(host.textContent).toContain('own-knowledge');
expect(host.textContent).not.toMatch(/old-list|old-detail/);
expect(state.selected).toBeNull(); expect(state.editorOpen).toBe(false);
});
it('aborts a search request from the previous scope', async () => {
accessCodes.value = ['knowledge:search'];
const { host, state } = mount('search'); await settle();
let resolveSearch!: (value: unknown) => void;
api.searchKnowledge.mockImplementationOnce(() => new Promise((resolve) => { resolveSearch = resolve; }));
state.accountId = 1; state.testQuery = 'query'; const oldSearch = state.test();
const signal = api.searchKnowledge.mock.lastCall![2] as AbortSignal;
accessCodes.value.push('knowledge:scope:own');
expect(signal.aborted).toBe(true);
await settle();
resolveSearch({ hits: [item('old-search')] });
await oldSearch; await settle();
expect(host.textContent).not.toContain('old-search');
expect(state.result).toBeNull();
});
it('cannot restore a previous review preview from an in-flight response after scope narrowing', async () => {
const { host, state, instance } = mount(); await settle();
state.reviewOpen = true; await settle();
const previous = findReview(instance.subTree);
let resolvePreview!: (value: unknown) => void;
api.previewKnowledgeReview.mockImplementationOnce(() => new Promise((resolve) => { resolvePreview = resolve; }));
const pending = previous.setupState.inspectScope();
await settle();
accessCodes.value = [...accessCodes.value, 'knowledge:scope:own']; await settle();
resolvePreview({ scope_label: 'old-review-preview', total: 1,
mode: 'approve', published: 0, preview: { snapshot_at: '', eligible: 1, blocked: 0, accounts: [], reasons: [] } });
await pending; await settle();
expect(previous.isUnmounted).toBe(true); expect(findReview(instance.subTree).setupState.preview).toBeNull();
expect(host.textContent).not.toContain('old-review-preview'); expect(state.reviewOpen).toBe(false);
});
it('does not grant review or source access when only the scope flag is held', async () => {
accessCodes.value = ['knowledge:read', 'knowledge:scope:own'];
const { host, state } = mount(); await settle();
expect(state.canReadMyReviews).toBe(false); expect(state.canAutoReview).toBe(false); expect(state.canEdit).toBe(false);
expect(host.textContent).toContain('当前仅显示本人 ZYT 账号名下的知识,包含管理员代为清洗的数据;操作仍按角色权限');
expect(host.textContent).not.toContain('批量审核');
expect(api.fetchKnowledgeItems).not.toHaveBeenCalled();
expect(api.fetchKnowledgeRuns).not.toHaveBeenCalled();
});
it('lets an assign-only role select drafts, without inbox or content access', async () => {
accessCodes.value = ['knowledge:review:assign'];
api.fetchKnowledgeItems.mockResolvedValue({ items: [{ ...item('draft'), status: 'draft' }, { ...item('published'), status: 'published' }], total: 2 });
api.fetchKnowledgeReviewAssignees.mockResolvedValue({ items: [] });
const { host, state } = mount(true); await settle();
expect(state.canReadMyReviews).toBe(false);
expect(state.canMaintain).toBe(false);
expect(state.rowSelection).toBeDefined();
expect(host.textContent).toContain('published');
expect([...host.querySelectorAll('button')].map((button) => button.textContent)).not.toContain('published');
expect(host.querySelector('[data-tab="待我审核"]')).toBeNull();
expect(api.fetchMyKnowledgeReviews).not.toHaveBeenCalled();
expect(api.fetchKnowledgeRuns).not.toHaveBeenCalled();
await state.inspect('published');
expect(api.fetchKnowledgeItem).not.toHaveBeenCalled();
state.selectedKeys = ['draft', 'published'];
state.openAssignment();
expect(state.assignmentEntries).toEqual([]);
state.selectedKeys = ['draft'];
state.openAssignment();
expect(state.assignmentEntries).toEqual([{ ...item('draft'), status: 'draft' }]);
accessCodes.value.push('knowledge:scope:own');
expect(state.assignmentEntries).toEqual([]);
});
it('limits account choices from the trusted overview and resets an inaccessible selected account before loading its data', async () => {
accessCodes.value.push('knowledge:scope:own');
const { state } = mount(true); await settle();
expect(state.allowedAccountIds).toEqual([1]);
await state.inspect('old-detail'); state.selectedKeys = ['old-detail'];
state.accountId = 2;
api.fetchKnowledgeItems.mockClear(); api.fetchKnowledgeOverview.mockClear();
await state.load(); await settle();
expect(state.accountId).toBe(-1); expect(state.selected).toBeNull(); expect(state.selectedKeys).toEqual([]);
expect(api.fetchKnowledgeOverview.mock.calls.every(([id]) => id === -1)).toBe(true);
expect(api.fetchKnowledgeItems.mock.calls.every(([id]) => id === -1)).toBe(true);
});
it('keeps choices empty before scope resolves and for an account with no eligible client', async () => {
accessCodes.value.push('knowledge:scope:own');
let resolveScope!: (value: unknown) => void;
api.fetchKnowledgeOverview.mockImplementationOnce(() => new Promise((resolve) => { resolveScope = resolve; }));
const { host, state } = mount(true); await settle();
expect(state.allowedAccountIds).toEqual([]); expect(api.fetchKnowledgeItems).not.toHaveBeenCalled();
resolveScope({ counts: {}, source_accounts: [], watches: [], settings: null,
knowledge_scope: { mode: 'zyt_account', account_ids: [] } });
await settle();
expect(state.allowedAccountIds).toEqual([]); expect(host.textContent).toContain('本人 ZYT 账号暂无可用客户端。');
});
it('uses the backend existing scope for administrators even when the scope code is present', async () => {
accessCodes.value.push('knowledge:scope:own');
api.fetchKnowledgeOverview.mockResolvedValue({ counts: {}, source_accounts: [], watches: [], settings: null,
knowledge_scope: { mode: 'existing', account_ids: [] } });
const { host, state } = mount(); await settle();
expect(state.ownScope).toBe(false); expect(state.allowedAccountIds).toBeUndefined();
expect(host.textContent).not.toContain('当前仅显示本人 ZYT 账号名下的知识');
});
it('ignores an old overview response after permissions narrow', async () => {
const { state } = mount(); await settle();
let resolveScope!: (value: unknown) => void;
api.fetchKnowledgeOverview.mockImplementationOnce(() => new Promise((resolve) => { resolveScope = resolve; }));
const pending = state.load();
accessCodes.value.push('knowledge:scope:own'); await settle();
resolveScope({ knowledge_scope: { mode: 'existing', account_ids: [] } }); await pending; await settle();
expect(state.ownScope).toBe(true); expect(state.allowedAccountIds).toEqual([1]);
});
it('clears assignment details and selection when eligible clients disappear without a flag change', async () => {
accessCodes.value.push('knowledge:scope:own');
const { state } = mount(true); await settle();
await state.inspect('previous-detail'); state.selectedKeys = ['previous-detail'];
state.batchEntries = [item('previous-detail')];
let resolveDetail!: (value: unknown) => void;
api.fetchKnowledgeItem.mockImplementationOnce(() => new Promise((resolve) => { resolveDetail = resolve; }));
const oldDetail = state.inspect('in-flight-detail');
api.fetchKnowledgeOverview.mockResolvedValue({ counts: {}, source_accounts: [], watches: [], settings: null,
knowledge_scope: { mode: 'zyt_account', account_ids: [] } });
api.fetchKnowledgeItems.mockResolvedValue({ items: [], total: 0 });
await state.load(); await settle();
resolveDetail(item('in-flight-detail')); await oldDetail; await settle();
expect(state.accountId).toBe(-1); expect(state.ownScopeFlag).toBe(true); expect(state.selected).toBeNull();
expect(state.selectedKeys).toEqual([]); expect(state.batchEntries).toEqual([]);
});
it('does not discard an open detail for an equivalent reordered account set', async () => {
accessCodes.value.push('knowledge:scope:own');
api.fetchKnowledgeOverview.mockResolvedValue({ counts: {}, source_accounts: [], watches: [], settings: null,
knowledge_scope: { mode: 'zyt_account', account_ids: [1, 2] } });
const { state } = mount(); await settle();
api.fetchKnowledgeItem.mockResolvedValueOnce(item('still-visible')); await state.inspect('still-visible');
const version = state.scopeVersion;
api.fetchKnowledgeOverview.mockResolvedValue({ counts: {}, source_accounts: [], watches: [], settings: null,
knowledge_scope: { mode: 'zyt_account', account_ids: [2, 1, 2] } });
await state.load(); await settle();
expect(state.scopeVersion).toBe(version); expect(state.selected.id).toBe('still-visible');
});
it('opens My reviews by default with an empty inbox and never loads management data for a reviewer', async () => {
accessCodes.value = ['knowledge:read', 'knowledge:review', 'im:content:read', 'knowledge:publish', 'knowledge:export', 'stats:read'];
const { host, state } = mount(); await settle();
expect(state.tab).toBe('my-reviews');
expect(host.querySelector('[data-tab="待我审核"]')?.textContent).toContain('暂无指派给你的待审核草稿');
expect(host.querySelector('[data-tab="指派管理"]')).toBeNull();
expect(api.fetchMyKnowledgeReviews).toHaveBeenCalledWith(1, expect.any(AbortSignal));
await state.inspect('other-knowledge'); await state.download();
expect(api.fetchKnowledgeItems).not.toHaveBeenCalled();
expect(api.fetchKnowledgeItem).not.toHaveBeenCalled();
expect(api.fetchKnowledgeTraces).not.toHaveBeenCalled();
expect(api.exportKnowledge).not.toHaveBeenCalled();
});
it('keeps draft and stale management rows as summaries and uses the post-review publish action', async () => {
accessCodes.value.push('knowledge:publish', 'knowledge:reject', 'knowledge:write');
const draft = { ...item('Draft summary'), status: 'draft' };
const stale = { ...item('Stale summary'), status: 'stale' };
const approved = item('Approved detail');
api.fetchKnowledgeItems.mockResolvedValue({ items: [draft, stale, approved], total: 3 });
accessCodes.value = accessCodes.value.filter((code) => code !== 'knowledge:review');
const { host, state } = mount(true); await settle();
const table = host.querySelector('[data-card="指派管理"]')!;
expect(table.textContent).toContain(draft.title);
expect(table.textContent).toContain(stale.title);
expect([...table.querySelectorAll('button')].map((button) => button.textContent)).not.toContain(draft.title);
expect([...table.querySelectorAll('button')].map((button) => button.textContent)).not.toContain(stale.title);
await state.inspect(draft.id); await state.inspect(stale.id);
expect(api.fetchKnowledgeItem).not.toHaveBeenCalled();
state.selectedKeys = [draft.id, approved.id]; state.openBatch('publish');
expect(state.batchEntries).toEqual([approved]);
api.fetchKnowledgeItem.mockResolvedValueOnce(approved);
await state.inspect(approved.id); await settle();
expect(host.textContent).toContain('发布到知识库');
expect(host.textContent).not.toMatch(/审核并发布选中|确认驳回|驳回选中/);
api.knowledgeItemAction.mockResolvedValueOnce({ ...approved, status: 'published' });
await state.act('publish');
expect(api.knowledgeItemAction).toHaveBeenCalledWith(-1, approved, 'publish', false, 0);
});
it('clears the manager editor when saving reviewed content creates a draft revision', async () => {
accessCodes.value.push('knowledge:write', 'knowledge:restore');
const { state } = mount(true); await settle(); await state.inspect('other-knowledge');
state.selected.answer = 'edited';
api.saveKnowledgeItem.mockResolvedValueOnce({ ...item('other-knowledge'), status: 'draft', revision: 2 });
await state.save();
expect(state.editorOpen).toBe(false);
expect(state.selected).toBeNull();
expect(api.knowledgeItemAction).not.toHaveBeenCalled();
});
it('previews only assigned drafts even for a reviewer with no eligible own-scope clients', async () => {
accessCodes.value.push('knowledge:scope:own');
api.fetchKnowledgeOverview.mockResolvedValue({ counts: {}, source_accounts: [], watches: [], settings: null,
knowledge_scope: { mode: 'zyt_account', account_ids: [] } });
const { state, instance, host } = mount(); await settle();
state.reviewOpen = true; await settle();
const review = findReview(instance.subTree).setupState;
expect(findReview(instance.subTree).props.assignedOnly).toBe(true);
expect(host.textContent).not.toContain('审核账号');
expect(api.previewKnowledgeReview).toHaveBeenCalledExactlyOnceWith(-1, 'approve');
review.scopeId = 19; await settle();
expect(api.previewKnowledgeReview).toHaveBeenCalledTimes(1);
expect(api.knowledgeReviewAction).not.toHaveBeenCalled();
api.knowledgeReviewAction.mockResolvedValueOnce({ id: 'job', status: 'queued' });
await review.start();
expect(api.knowledgeReviewAction).toHaveBeenCalledWith('preview', 'start', true);
});
it('closes a successful combined full-review dialog and refreshes the personal inbox', async () => {
accessCodes.value.push('knowledge:publish');
api.previewKnowledgeReview.mockImplementation(async (account, mode) => ({ id: 'combined-preview', account_id: account, mode,
published: 0, scope_label: 'all', total: 1, preview: { eligible: 1, blocked: 0, snapshot_at: '', accounts: [], reasons: [] } }));
const { state, instance, host } = mount(); await settle();
expect(host.textContent).toContain('审核并发布全部指派草稿');
state.reviewOpen = true; await settle();
const review = findReview(instance.subTree).setupState;
expect(api.previewKnowledgeReview).toHaveBeenLastCalledWith(-1, 'approve_publish');
let resolveStart!: (value: unknown) => void;
api.knowledgeReviewAction.mockImplementationOnce(() => new Promise((resolve) => { resolveStart = resolve; }));
const pending = review.start(); await settle(); expect(state.reviewOpen).toBe(true);
const inboxReads = api.fetchMyKnowledgeReviews.mock.calls.length;
resolveStart({ id: 'combined-job', mode: 'approve_publish', status: 'completed', total: 1, processed: 1, published: 1, approved: 1, skipped: 0, error: '' });
await pending; await settle();
expect(state.reviewOpen).toBe(false); expect(state.editorOpen).toBe(false); expect(state.selected).toBeNull();
expect(state.accountId).toBe(-1); expect(api.fetchMyKnowledgeReviews.mock.calls.length).toBeGreaterThan(inboxReads);
expect(api.fetchKnowledgeItems).not.toHaveBeenCalled();
expect(api.fetchKnowledgeItem).not.toHaveBeenCalled(); expect(api.knowledgeItemAction).not.toHaveBeenCalled();
});
it('keeps task and search data off the workbench even when both permissions are held', async () => {
accessCodes.value = ['knowledge:read', 'knowledge:tasks:read', 'knowledge:search'];
const { state, host } = mount(); await settle();
expect(host.querySelector('[data-tab="整理任务"]')).toBeNull();
expect(host.querySelector('[data-tab="检索测试"]')).toBeNull();
expect(api.fetchKnowledgeRuns).not.toHaveBeenCalled();
state.accountId = 1; state.testQuery = 'published search';
await state.test();
expect(api.searchKnowledge).not.toHaveBeenCalled();
});
it('loads only task data with the task page grant and gates mutations separately', async () => {
accessCodes.value = ['knowledge:tasks:read', 'knowledge:run', 'knowledge:run:control', 'knowledge:watch'];
const { host, state } = mount('tasks'); await settle();
expect(host.querySelector('[data-card="整理任务"]')).not.toBeNull();
expect(api.fetchKnowledgeRuns).toHaveBeenCalledExactlyOnceWith(expect.any(AbortSignal));
expect(api.fetchKnowledgeItems).not.toHaveBeenCalled();
expect(api.fetchKnowledgeReviewJobs).not.toHaveBeenCalled();
expect(api.fetchKnowledgeTraces).not.toHaveBeenCalled();
expect(state.canRun).toBe(false); expect(state.canControl).toBe(false); expect(state.canWatch).toBe(false);
accessCodes.value.push('im:content:read'); await settle();
expect(state.canRun).toBe(true); expect(state.canControl).toBe(true); expect(state.canWatch).toBe(true);
state.startCreate(); expect(state.createOpen).toBe(true);
accessCodes.value = ['knowledge:tasks:read'];
expect(state.createOpen).toBe(false);
expect(state.canRun).toBe(false); expect(state.canControl).toBe(false); expect(state.canWatch).toBe(false);
});
it('aborts an in-flight task list when its standalone grant is revoked and loads again when granted', async () => {
accessCodes.value = [];
const { host, state } = mount('tasks'); await settle();
expect(api.fetchKnowledgeOverview).not.toHaveBeenCalled();
let resolveRuns!: (value: unknown) => void;
api.fetchKnowledgeRuns.mockImplementationOnce(() => new Promise((resolve) => { resolveRuns = resolve; }));
accessCodes.value = ['knowledge:tasks:read']; await settle();
const signal = api.fetchKnowledgeRuns.mock.lastCall![0] as AbortSignal;
accessCodes.value = [];
expect(signal.aborted).toBe(true);
resolveRuns({ items: [{ id: 'stale-task', status: 'completed' }], auto: null }); await settle();
expect(state.runs).toEqual([]);
expect(host.querySelector('[data-card="整理任务"]')).toBeNull();
accessCodes.value = ['knowledge:tasks:read']; await settle();
expect(host.querySelector('[data-card="整理任务"]')).not.toBeNull();
expect(api.fetchKnowledgeRuns).toHaveBeenCalledTimes(2);
});
it('allows search alone and shows the published hit without maintenance controls', async () => {
accessCodes.value = ['knowledge:search', 'knowledge:scope:own'];
const { state, host } = mount('search'); await settle();
expect(host.querySelector('[data-card="检索测试"]')).not.toBeNull();
expect(state.allowedAccountIds).toEqual([1]);
expect(api.fetchKnowledgeOverview).toHaveBeenCalledExactlyOnceWith(-1, expect.any(AbortSignal));
expect(api.fetchKnowledgeRuns).not.toHaveBeenCalled();
expect(api.fetchKnowledgeItems).not.toHaveBeenCalled();
expect(api.fetchMyKnowledgeReviews).not.toHaveBeenCalled();
expect(api.fetchKnowledgeTraces).not.toHaveBeenCalled();
state.accountId = 2; state.testQuery = 'published search';
await state.test();
expect(api.searchKnowledge).not.toHaveBeenCalled();
state.accountId = 1;
api.searchKnowledge.mockResolvedValueOnce({ hits: [{ ...item('public-result'), content_type: 'standard_answer', status: 'published' }] });
await state.test(); await settle();
expect(api.searchKnowledge).toHaveBeenCalledExactlyOnceWith(1, 'published search', expect.any(AbortSignal));
expect(host.textContent).toContain('标准答案'); expect(host.textContent).not.toContain('查看来源');
});
it.each(['account change', 'permission revocation'])('aborts search on %s', async (change) => {
accessCodes.value = ['knowledge:search'];
const { host, state } = mount('search'); await settle();
let resolveSearch!: (value: unknown) => void;
api.searchKnowledge.mockImplementationOnce(() => new Promise((resolve) => { resolveSearch = resolve; }));
state.accountId = 1; state.testQuery = 'query'; const pending = state.test();
const signal = api.searchKnowledge.mock.lastCall![2] as AbortSignal;
if (change === 'account change') state.accountId = 2;
else accessCodes.value = ['knowledge:tasks:read'];
expect(signal.aborted).toBe(true);
resolveSearch({ hits: [item('old-search')] }); await pending; await settle();
expect(host.textContent).not.toContain('old-search');
expect(state.result).toBeNull();
expect(state.searching).toBe(false);
});
it.each(['knowledge:read', 'im:content:read', 'knowledge:review:assign'])('drops stale maintenance data when %s is revoked', async (code) => {
const { host, state } = mount(true); await settle();
await state.inspect('old-open'); await settle();
let resolveRows!: (value: unknown) => void;
let resolveDetail!: (value: unknown) => void;
api.fetchKnowledgeItems.mockImplementationOnce(() => new Promise((resolve) => { resolveRows = resolve; }));
api.fetchKnowledgeItem.mockImplementationOnce(() => new Promise((resolve) => { resolveDetail = resolve; }));
const oldLoad = state.load(); const oldInspect = state.inspect('old-detail'); await settle();
const managedReads = api.fetchKnowledgeItems.mock.calls.length;
accessCodes.value = accessCodes.value.filter((entry) => entry !== code);
expect(state.items).toEqual([]); expect(state.selected).toBeNull(); expect(state.editorOpen).toBe(false);
resolveRows({ items: [item('old-list')], total: 1 }); resolveDetail(item('old-detail'));
await Promise.all([oldLoad, oldInspect]); await settle();
expect(api.fetchKnowledgeItems).toHaveBeenCalledTimes(managedReads + (code === 'knowledge:review:assign' ? 0 : 1));
expect(host.textContent).not.toMatch(/old-list|old-open|old-detail/);
accessCodes.value.push(code); await settle();
expect(host.textContent).toContain('other-knowledge');
expect(state.selected).toBeNull();
});
it('requests actual preset and custom sizes with the applied filter and rejects stale pages', async () => {
accessCodes.value = ['knowledge:review:assign'];
const { host, state } = mount(true); await settle();
expect(api.fetchKnowledgeItems).toHaveBeenLastCalledWith(-1, '', '', 1, 30, expect.any(AbortSignal));
expect(state.pageSizeOptions.map(({ value }: { value: number | string }) => value))
.toEqual([30, 50, 100, 300, 500, 1000, 2000, 'custom']);
state.filter = 'draft'; state.queryInput = 'follow-up'; state.searchItems(); await settle();
state.queryInput = 'unsent search';
let resolveOld!: (value: unknown) => void;
api.fetchKnowledgeItems.mockImplementationOnce(() => new Promise((resolve) => { resolveOld = resolve; }));
state.listChanged(2); await settle();
const oldSignal = api.fetchKnowledgeItems.mock.lastCall![5] as AbortSignal;
expect(api.fetchKnowledgeItems).toHaveBeenLastCalledWith(-1, 'draft', 'follow-up', 2, 30, oldSignal);
state.selectedKeys = ['obsolete'];
api.fetchKnowledgeItems.mockResolvedValue({ items: [item('new-page')], total: 2400 });
state.choosePageSize(2000); await settle();
expect(oldSignal.aborted).toBe(true);
expect(state.selectedKeys).toEqual([]);
expect(api.fetchKnowledgeItems).toHaveBeenLastCalledWith(-1, 'draft', 'follow-up', 1, 2000, expect.any(AbortSignal));
resolveOld({ items: [item('old-page')], total: 1 }); await settle();
expect(host.textContent).toContain('new-page');
expect(host.textContent).not.toContain('old-page');
state.choosePageSize('custom'); await settle();
expect(state.customSize).toBe('2000');
const reads = api.fetchKnowledgeItems.mock.calls.length;
for (const invalid of ['0', '2001', '1.5', '']) {
state.customSize = invalid; state.applyCustomPageSize(); await settle();
expect(host.textContent).toContain('请输入 1 到 2000 之间的整数。');
}
expect(api.fetchKnowledgeItems).toHaveBeenCalledTimes(reads);
state.customSize = '137'; state.applyCustomPageSize(); await settle();
expect(api.fetchKnowledgeItems).toHaveBeenLastCalledWith(-1, 'draft', 'follow-up', 1, 137, expect.any(AbortSignal));
expect(localStorage.getItem('wecom-knowledge-assignment-page-size')).toBe('137');
expect(host.textContent).not.toContain('请输入 1 到 2000 之间的整数。');
cleanup?.();
mount(true); await settle();
expect(api.fetchKnowledgeItems).toHaveBeenLastCalledWith(-1, '', '', 1, 137, expect.any(AbortSignal));
});
it('shows the assignment limit and refuses to open an oversized request', async () => {
accessCodes.value = ['knowledge:review:assign'];
const items = Array.from({ length: 101 }, (_, index) => ({ ...item(String(index)), status: 'draft' }));
api.fetchKnowledgeItems.mockResolvedValue({ items, total: items.length });
const { host, state } = mount(true); await settle();
state.choosePageSize(300); await settle();
state.rowSelection.onChange(items.map(({ id }) => id)); await settle();
expect(host.textContent).toContain('每次最多指派或撤回');
expect(state.canAssignSelected).toBe(false);
state.openAssignment();
expect(state.assignmentEntries).toEqual([]);
expect(api.fetchKnowledgeReviewAssignees).not.toHaveBeenCalled();
});
});
@@ -0,0 +1,378 @@
import type { KnowledgeReviewJob, KnowledgeReviewMode } from '#/api/knowledge';
import { createApp, defineComponent, h, KeepAlive, nextTick, ref } from 'vue';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { message, Modal } from 'ant-design-vue';
const api = vi.hoisted(() => ({ fetchDesktopAccounts: vi.fn(), fetchKnowledgeReviewJobs: vi.fn(),
fetchKnowledgeReviewResults: vi.fn(), knowledgeReviewAction: vi.fn(), previewKnowledgeReview: vi.fn() }));
vi.mock('#/api/knowledge', () => api);
vi.mock('#/api/console', () => ({ fetchDesktopAccounts: api.fetchDesktopAccounts }));
const accessCodes = ref<string[]>([]);
const baseCodes = ['knowledge:read', 'knowledge:review:auto', 'im:content:read', 'knowledge:review'];
const fullCodes = [...baseCodes, 'knowledge:publish'];
vi.mock('@vben/access', () => ({ useAccess: () => ({
hasAccessByCodes: (codes: string[]) => codes.some((code) => accessCodes.value.includes(code)),
}) }));
vi.mock('#/locales/t', () => ({ t: (value: string, vars: Record<string, string | number> = {}) =>
value.replace(/\{(\w+)\}/g, (match, key) => String(vars[key] ?? match)) }));
vi.mock('ant-design-vue', async () => {
const { defineComponent, h } = await import('vue');
const plain = defineComponent({ setup: (_props, { slots }) => () => h('div', slots.default?.()) });
return {
Alert: defineComponent({ props: ['message'], setup: (props) => () => h('p', props.message) }),
Modal: Object.assign(defineComponent({ props: ['open'], setup: (props, { slots }) => () => props.open
? h('section', slots.default?.()) : null }), { confirm: vi.fn() }),
Button: defineComponent({ props: ['disabled'], setup: (props, { slots }) => () => h('button', { disabled: props.disabled }, slots.default?.()) }),
Tabs: Object.assign({}, plain, { TabPane: plain }), Table: plain, Progress: plain, Select: plain,
Space: plain, Tag: plain, message: { success: vi.fn() },
};
});
import KnowledgeReviewAll from './review-all.vue';
const preview = (account: number, id = `preview-${account}`, mode: KnowledgeReviewMode = 'approve'): KnowledgeReviewJob => ({ id, account_id: account, mode, published: 0,
scope_label: `account-${account}`, status: 'preview', total: 1, processed: 0, approved: 0, skipped: 0,
error: '', created_at: '', progress_percent: 0,
preview: { total: 1, eligible: 1, blocked: 0, snapshot_at: '', accounts: [], reasons: [] } });
const accountList = { can_view_legacy: false, accounts: [] };
const settle = async () => { for (let index = 0; index < 12; index++) { await Promise.resolve(); await nextTick(); } };
function deferred<T>() {
let resolve!: (value: T) => void; let reject!: (error: unknown) => void;
const promise = new Promise<T>((done, fail) => { resolve = done; reject = fail; });
return { promise, resolve, reject };
}
let cleanup: (() => void) | undefined;
function mount(initialTab = 'new') {
const open = ref(true); const visible = ref(true); const child = ref(); const changed = vi.fn();
const allowedAccountIds = ref<number[] | undefined>(); const ownScope = ref(false); const updateOpen = vi.fn(); const inspect = vi.fn();
const host = document.createElement('div'); document.body.append(host);
const app = createApp(defineComponent({ setup: () => () => h(KeepAlive, null, {
default: () => visible.value ? h(KnowledgeReviewAll, { ref: child, open: open.value, accountId: 1, initialTab,
allowedAccountIds: allowedAccountIds.value, ownScope: ownScope.value,
'onUpdate:open': (value: boolean) => { updateOpen(value); open.value = value; }, onChanged: changed, onInspect: inspect }) : null,
}) }));
app.mount(host); cleanup = () => { app.unmount(); host.remove(); };
return { open, visible, child, changed, host, allowedAccountIds, ownScope, updateOpen, inspect };
}
describe('knowledge full review preview and lifecycle', () => {
beforeEach(() => {
vi.resetAllMocks(); accessCodes.value = [...baseCodes]; api.fetchDesktopAccounts.mockResolvedValue(accountList);
api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [] });
api.fetchKnowledgeReviewResults.mockResolvedValue({ items: [], total: 0 });
api.previewKnowledgeReview.mockImplementation(async (account, mode) => preview(account, undefined, mode));
api.knowledgeReviewAction.mockResolvedValue({ id: 'started', status: 'completed' });
});
afterEach(() => { cleanup?.(); cleanup = undefined; vi.useRealTimers(); });
it('serializes preview POSTs and coalesces rapid scope changes so the displayed latest snapshot stays valid', async () => {
const first = deferred<KnowledgeReviewJob>(); const latest = deferred<KnowledgeReviewJob>();
let active = 0; let maximum = 0; let serverCurrent = '';
api.previewKnowledgeReview.mockImplementation(async (account) => {
active++; maximum = Math.max(maximum, active);
const result = await (account === 1 ? first.promise : latest.promise);
active--; serverCurrent = result.id; return result;
});
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
expect(api.previewKnowledgeReview.mock.calls).toEqual([[1, 'approve']]);
state.scopeId = 2; state.scopeId = 3; await settle();
expect(api.previewKnowledgeReview.mock.calls).toEqual([[1, 'approve']]); expect(state.preview).toBeNull();
await state.start(); expect(api.knowledgeReviewAction).not.toHaveBeenCalled();
first.resolve(preview(1, 'old')); await settle();
expect(api.previewKnowledgeReview.mock.calls).toEqual([[1, 'approve'], [3, 'approve']]); expect(state.preview).toBeNull();
latest.resolve(preview(3, 'latest')); await settle();
expect(maximum).toBe(1); expect(active).toBe(0); expect(serverCurrent).toBe('latest');
expect(state.preview.id).toBe(serverCurrent); expect(state.previewAccount).toBe(3); expect(state.previewLoading).toBe(false);
await state.start(); expect(api.knowledgeReviewAction).toHaveBeenCalledWith('latest', 'start', true);
});
it('closes and resets during a pending start, blocks actions while draining and reopens without stale errors', async () => {
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
const gate = deferred<KnowledgeReviewJob>(); api.knowledgeReviewAction.mockImplementationOnce(() => gate.promise);
const pending = state.start(); await settle(); expect(state.busy).toBe(true);
ui.visible.value = false; await settle();
expect(ui.open.value).toBe(false); expect(state.busy).toBe(false); expect(state.previewLoading).toBe(false);
expect(state.actionActive).toBe(true); expect(state.preview).toBeNull();
ui.visible.value = true; ui.open.value = true; await settle();
expect(ui.child.value.$.setupState).toBe(state); expect(state.busy).toBe(false);
expect(ui.host.textContent).toContain('上一项操作仍在完成,请稍候。');
await state.start(); await state.act('old-job', 'pause'); expect(api.knowledgeReviewAction).toHaveBeenCalledTimes(1);
const reads = api.fetchKnowledgeReviewJobs.mock.calls.length;
gate.reject({ response: { data: { detail: 'stale action error' } } }); await pending; await settle();
expect(state.actionActive).toBe(false); expect(state.busy).toBe(false); expect(state.error).toBe('');
expect(state.tab).toBe('new'); expect(state.preview.id).toBe('preview-1');
expect(api.fetchKnowledgeReviewJobs).toHaveBeenCalledTimes(reads + 1);
await state.start(); await settle(); expect(api.knowledgeReviewAction).toHaveBeenCalledTimes(2);
expect(state.busy).toBe(false); expect(state.tab).toBe('jobs');
});
it('ignores an invalidated job action completion and refreshes only for the reopened view', async () => {
const ui = mount('jobs'); await settle(); const state = ui.child.value.$.setupState;
const gate = deferred<KnowledgeReviewJob>(); api.knowledgeReviewAction.mockImplementationOnce(() => gate.promise);
const pending = state.act('job', 'pause'); await settle();
ui.visible.value = false; await settle(); ui.visible.value = true; ui.open.value = true; await settle();
const reads = api.fetchKnowledgeReviewJobs.mock.calls.length; ui.changed.mockClear();
gate.resolve({ ...preview(1), id: 'job', status: 'paused' }); await pending; await settle();
expect(state.actionActive).toBe(false); expect(state.busy).toBe(false); expect(state.error).toBe('');
expect(api.fetchKnowledgeReviewJobs).toHaveBeenCalledTimes(reads + 1); expect(ui.changed).toHaveBeenCalledTimes(1);
expect(state.selectedId).toBe(''); expect(state.rows).toEqual([]);
});
it('does not let an old opening request reset a reopened view that is still loading', async () => {
const old = deferred<typeof accountList>(); const current = deferred<typeof accountList>();
api.fetchDesktopAccounts.mockImplementationOnce(() => old.promise).mockImplementationOnce(() => current.promise);
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
expect(state.busy).toBe(true); ui.visible.value = false; await settle(); expect(state.busy).toBe(false);
ui.visible.value = true; ui.open.value = true; await settle(); expect(state.busy).toBe(true);
old.resolve(accountList); await settle(); expect(state.busy).toBe(true); expect(state.accountList).toBeNull();
current.resolve(accountList); await settle(); expect(state.busy).toBe(false); expect(state.preview.id).toBe('preview-1');
expect(api.fetchKnowledgeReviewJobs).toHaveBeenCalledTimes(1);
});
it('keeps stopped state empty when an action settles while still deactivated, then initializes on activation', async () => {
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
const gate = deferred<KnowledgeReviewJob>(); api.knowledgeReviewAction.mockImplementationOnce(() => gate.promise);
const pending = state.start(); await settle(); ui.visible.value = false; await settle();
const accounts = api.fetchDesktopAccounts.mock.calls.length; const jobs = api.fetchKnowledgeReviewJobs.mock.calls.length;
const previews = api.previewKnowledgeReview.mock.calls.length; ui.changed.mockClear();
gate.resolve({ ...preview(1), id: 'old-start', status: 'completed' }); await pending; await settle();
expect(state.actionActive).toBe(false); expect(state.busy).toBe(false); expect(state.accountList).toBeNull();
expect(state.preview).toBeNull(); expect(state.jobs).toEqual([]); expect(state.selectedId).toBe('');
expect(api.fetchDesktopAccounts).toHaveBeenCalledTimes(accounts); expect(api.fetchKnowledgeReviewJobs).toHaveBeenCalledTimes(jobs);
expect(api.previewKnowledgeReview).toHaveBeenCalledTimes(previews); expect(ui.changed).not.toHaveBeenCalled();
await state.act('old-job', 'pause'); expect(api.knowledgeReviewAction).toHaveBeenCalledTimes(1);
ui.visible.value = true; ui.open.value = true; await settle();
expect(api.fetchDesktopAccounts).toHaveBeenCalledTimes(accounts + 1); expect(state.preview.id).toBe('preview-1');
});
it('previews combined mode and waits for the explicit final button, then closes after its own deferred start completes', async () => {
accessCodes.value = [...fullCodes];
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
expect(api.previewKnowledgeReview).toHaveBeenCalledWith(1, 'approve_publish');
expect(ui.host.textContent).toContain('当前预览范围:'); expect(ui.host.textContent).toContain('一键审核并发布 1 条');
expect(api.knowledgeReviewAction).not.toHaveBeenCalled();
const gate = deferred<KnowledgeReviewJob>(); api.knowledgeReviewAction.mockImplementationOnce(() => gate.promise);
ui.changed.mockClear(); const reads = api.fetchKnowledgeReviewJobs.mock.calls.length;
const button = [...ui.host.querySelectorAll('button')].find((entry) => entry.textContent === '一键审核并发布 1 条');
button!.click(); await settle(); expect(ui.open.value).toBe(true); expect(state.busy).toBe(true);
gate.resolve({ ...preview(1, 'launched', 'approve_publish'), status: 'completed', processed: 1, approved: 1, published: 1 }); await settle();
expect(api.knowledgeReviewAction).toHaveBeenCalledWith('preview-1', 'start', true);
expect(ui.open.value).toBe(false); expect(ui.updateOpen).toHaveBeenCalledExactlyOnceWith(false);
expect(ui.changed).toHaveBeenCalledTimes(1); expect(ui.inspect).not.toHaveBeenCalled();
expect(message.success).toHaveBeenCalledExactlyOnceWith('已审核并发布 1 条');
expect(api.fetchKnowledgeReviewJobs).toHaveBeenCalledTimes(reads);
expect(state.busy).toBe(false); expect(state.actionActive).toBe(false);
});
it('closes exactly once when polling observes completion and ignores another already pending refresh', async () => {
vi.useFakeTimers(); accessCodes.value = [...fullCodes];
const running = { ...preview(1, 'launched', 'approve_publish'), status: 'running' };
api.knowledgeReviewAction.mockResolvedValue(running);
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [running] });
await state.start(); await settle(); expect(ui.open.value).toBe(true); expect(state.tab).toBe('jobs');
const poll = deferred<{ items: KnowledgeReviewJob[] }>(); const stale = deferred<{ items: KnowledgeReviewJob[] }>();
api.fetchKnowledgeReviewJobs.mockImplementationOnce(() => poll.promise).mockImplementationOnce(() => stale.promise);
await vi.advanceTimersByTimeAsync(2500); await settle(); const oldRefresh = state.refresh(); await settle();
ui.changed.mockClear();
const complete = { ...running, status: 'completed', processed: 1, approved: 1, published: 1 };
poll.resolve({ items: [complete] }); await settle();
stale.resolve({ items: [complete] }); await oldRefresh; await settle();
expect(ui.open.value).toBe(false); expect(ui.updateOpen).toHaveBeenCalledExactlyOnceWith(false);
expect(ui.changed).toHaveBeenCalledTimes(1); expect(message.success).toHaveBeenCalledExactlyOnceWith('已审核并发布 1 条');
const reads = api.fetchKnowledgeReviewJobs.mock.calls.length;
await vi.advanceTimersByTimeAsync(10000); expect(api.fetchKnowledgeReviewJobs).toHaveBeenCalledTimes(reads);
});
it.each([
{ status: 'completed', processed: 1, published: 1, skipped: 1 },
{ status: 'completed', published: 0, skipped: 0 },
{ status: 'failed', published: 1, skipped: 0 },
{ status: 'paused', published: 1, skipped: 0 },
{ status: 'cancelled', published: 1, skipped: 0 },
])('keeps $status with published=$published skipped=$skipped visible for inspection', async (result) => {
accessCodes.value = [...fullCodes];
const job = { ...preview(1, 'launched', 'approve_publish'), processed: 1, approved: 1, ...result, error: result.status === 'failed' ? 'publish failed' : '' };
api.knowledgeReviewAction.mockResolvedValue(job);
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [job] });
api.fetchKnowledgeReviewResults.mockResolvedValue({ items: [{ item_id: 'blocked', reason_text: 'source changed' }], total: 1 });
await state.start(); await settle();
expect(ui.open.value).toBe(true); expect(ui.updateOpen).not.toHaveBeenCalled(); expect(message.success).not.toHaveBeenCalled();
expect(state.selectedId).toBe('launched'); expect(state.jobs[0]).toMatchObject(result);
expect(state.rows[0].reason_text).toBe('source changed');
expect(api.fetchKnowledgeReviewResults).toHaveBeenLastCalledWith('launched', 'skipped', 1);
state.resultType = 'published'; await state.loadResults();
expect(api.fetchKnowledgeReviewResults).toHaveBeenLastCalledWith('launched', 'published', 1);
});
it.each([
{ name: 'a task error', counters: { error: 'publish completion failed' } },
{ name: 'unprocessed items', counters: { processed: 0 } },
{ name: 'unpublished items', counters: { total: 2, processed: 2 } },
{ name: 'an empty scope', counters: { total: 0, processed: 0, published: 0 } },
{ name: 'a fractional total', counters: { total: 1.5, processed: 1.5, published: 1.5 } },
{ name: 'a nonfinite published count', counters: { published: Number.POSITIVE_INFINITY } },
{ name: 'a fractional published count', counters: { published: 1.5 } },
{ name: 'too many processed items', counters: { processed: 2 } },
].flatMap((entry) => ['direct', 'poll'].map((source) => ({ ...entry, source }))))(
'keeps $source completion with $name open without a success toast', async ({ counters, source }) => {
accessCodes.value = [...fullCodes];
const running = { ...preview(1, 'launched', 'approve_publish'), status: 'running' };
const completed = { ...running, status: 'completed', processed: 1, approved: 1, published: 1, ...counters };
api.knowledgeReviewAction.mockResolvedValue(source === 'direct' ? completed : running);
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [source === 'direct' ? completed : running] });
api.fetchKnowledgeReviewResults.mockResolvedValue({ items: [{ item_id: 'result', reason_text: 'needs inspection' }], total: 1 });
await state.start(); await settle();
if (source === 'poll') { api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [completed] }); await state.refresh(); await settle(); }
expect(ui.open.value).toBe(true); expect(ui.updateOpen).not.toHaveBeenCalled(); expect(message.success).not.toHaveBeenCalled();
expect(state.selectedId).toBe('launched'); expect(state.jobs[0]).toMatchObject(completed);
expect(state.rows[0].reason_text).toBe('needs inspection');
},
);
it('does not close for a successful historical job or a different job while this dialog has launched work', async () => {
accessCodes.value = [...fullCodes];
const historical = { ...preview(1, 'historical', 'approve_publish'), status: 'completed', processed: 1, published: 1 };
api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [historical] });
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
expect(ui.open.value).toBe(true); expect(ui.updateOpen).not.toHaveBeenCalled(); expect(message.success).not.toHaveBeenCalled();
const own = { ...preview(1, 'own', 'approve_publish'), status: 'running' };
api.knowledgeReviewAction.mockResolvedValue(own); await state.start(); await settle();
expect(ui.open.value).toBe(true); expect(state.selectedId).toBe('own'); expect(message.success).not.toHaveBeenCalled();
});
it('allows closing during background work and never closes a reopened dialog for that old job', async () => {
accessCodes.value = [...fullCodes];
const own = { ...preview(1, 'own', 'approve_publish'), status: 'running' };
api.knowledgeReviewAction.mockResolvedValue(own);
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [own] }); await state.start(); await settle();
expect(state.busy).toBe(false); state.close(); await settle(); expect(ui.open.value).toBe(false);
api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [{ ...own, status: 'completed', processed: 1, published: 1 }] });
ui.open.value = true; ui.updateOpen.mockClear(); await settle();
expect(ui.open.value).toBe(true); expect(ui.updateOpen).not.toHaveBeenCalled(); expect(message.success).not.toHaveBeenCalled();
});
it('serializes mode changes with scope changes and never submits an outdated preview mode', async () => {
accessCodes.value = [...fullCodes];
const first = deferred<KnowledgeReviewJob>(); const latest = deferred<KnowledgeReviewJob>();
api.previewKnowledgeReview.mockImplementationOnce(() => first.promise).mockImplementationOnce(() => latest.promise);
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
accessCodes.value = [...baseCodes]; state.scopeId = 2; state.scopeId = 3; await settle();
expect(state.preview).toBeNull(); expect(api.previewKnowledgeReview).toHaveBeenCalledTimes(1);
first.resolve(preview(1, 'combined-old', 'approve_publish')); await settle();
expect(api.previewKnowledgeReview.mock.calls).toEqual([[1, 'approve_publish'], [3, 'approve']]);
await state.start(); expect(api.knowledgeReviewAction).not.toHaveBeenCalled();
latest.resolve(preview(3, 'review-new')); await settle();
expect(state.preview.id).toBe('review-new'); expect(state.previewMode).toBe('approve');
expect(ui.host.textContent).toContain('确认审核 1 条并进入待发布');
await state.start(); expect(api.knowledgeReviewAction).toHaveBeenCalledExactlyOnceWith('review-new', 'start', true);
});
it.each(baseCodes)('blocks stale previews and queued POSTs when %s is revoked', async (code) => {
accessCodes.value = [...fullCodes];
const first = deferred<KnowledgeReviewJob>(); api.previewKnowledgeReview.mockImplementationOnce(() => first.promise);
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
state.scopeId = 2; accessCodes.value = fullCodes.filter((entry) => entry !== code); await settle();
first.resolve(preview(1, 'stale', 'approve_publish')); await settle();
expect(state.preview).toBeNull(); expect(state.previewLoading).toBe(false);
expect(api.previewKnowledgeReview).toHaveBeenCalledTimes(1);
await state.start(); expect(api.knowledgeReviewAction).not.toHaveBeenCalled();
});
it.each(['knowledge:publish', 'knowledge:review'])('ignores a successful pending start after losing %s', async (code) => {
accessCodes.value = [...fullCodes];
const gate = deferred<KnowledgeReviewJob>(); api.knowledgeReviewAction.mockImplementationOnce(() => gate.promise);
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
const pending = state.start(); await settle(); accessCodes.value = fullCodes.filter((entry) => entry !== code); await settle();
gate.resolve({ ...preview(1, 'old-start', 'approve_publish'), status: 'completed', processed: 1, published: 1 }); await pending; await settle();
expect(ui.open.value).toBe(true); expect(ui.updateOpen).not.toHaveBeenCalled(); expect(message.success).not.toHaveBeenCalled();
expect(state.selectedId).toBe('');
if (code === 'knowledge:review') expect(state.preview).toBeNull();
else expect(state.preview.mode).toBe('approve');
});
it('ignores a completed in-flight poll after own scope narrows, including stale selected result rows', async () => {
accessCodes.value = [...fullCodes];
const own = { ...preview(1, 'own', 'approve_publish'), status: 'running' };
api.knowledgeReviewAction.mockResolvedValue(own);
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [own] }); await state.start(); await settle();
const poll = deferred<{ items: KnowledgeReviewJob[] }>(); api.fetchKnowledgeReviewJobs.mockImplementationOnce(() => poll.promise);
const pending = state.refresh(); await settle(); api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [] });
ui.ownScope.value = true; ui.allowedAccountIds.value = []; await settle();
poll.resolve({ items: [{ ...own, status: 'completed', processed: 1, published: 1 }] }); await pending; await settle();
expect(ui.open.value).toBe(true); expect(ui.updateOpen).not.toHaveBeenCalled(); expect(message.success).not.toHaveBeenCalled();
expect(state.jobs).toEqual([]); expect(state.rows).toEqual([]); expect(state.selectedId).toBe('');
expect(state.accounts).toEqual([]); expect(state.scopeAllowed).toBe(false);
const previews = api.previewKnowledgeReview.mock.calls.length; state.tab = 'new'; await settle(); await state.start();
expect(api.previewKnowledgeReview).toHaveBeenCalledTimes(previews); expect(api.knowledgeReviewAction).toHaveBeenCalledTimes(1);
});
it('requires full permissions to resume combined work, retains pause/cancel, and invalidates a queued cancellation on scope change', async () => {
const job = { ...preview(1, 'combined', 'approve_publish'), status: 'paused' };
api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [job] });
const ui = mount('jobs'); await settle(); const state = ui.child.value.$.setupState;
await state.act('combined', 'resume'); expect(api.knowledgeReviewAction).not.toHaveBeenCalled();
await state.act('combined', 'pause'); expect(api.knowledgeReviewAction).toHaveBeenLastCalledWith('combined', 'pause');
state.cancel('combined');
const confirm = vi.mocked(Modal.confirm).mock.calls.at(-1)![0];
ui.allowedAccountIds.value = [2]; await settle();
await (confirm.onOk as () => unknown)(); expect(api.knowledgeReviewAction).toHaveBeenCalledTimes(1);
await state.refresh(); state.cancel('combined');
const nextConfirm = vi.mocked(Modal.confirm).mock.calls.at(-1)![0]; await (nextConfirm.onOk as () => unknown)();
expect(api.knowledgeReviewAction).toHaveBeenLastCalledWith('combined', 'cancel');
});
it('keeps a pending start invalid after publish permission is revoked and restored', async () => {
accessCodes.value = [...fullCodes];
const gate = deferred<KnowledgeReviewJob>(); api.knowledgeReviewAction.mockImplementationOnce(() => gate.promise);
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
const pending = state.start(); await settle();
accessCodes.value = [...baseCodes]; accessCodes.value = [...fullCodes]; await settle();
gate.resolve({ ...preview(1, 'invalidated', 'approve_publish'), status: 'completed', processed: 1, published: 1 });
await pending; await settle();
expect(ui.open.value).toBe(true); expect(ui.updateOpen).not.toHaveBeenCalled(); expect(message.success).not.toHaveBeenCalled();
expect(state.selectedId).toBe(''); expect(state.preview.mode).toBe('approve_publish');
});
it('keeps a poll and cancellation invalid after a scope changes and returns to the same account set', async () => {
accessCodes.value = [...fullCodes];
const own = { ...preview(1, 'own', 'approve_publish'), status: 'running' };
api.knowledgeReviewAction.mockResolvedValue(own);
const ui = mount(); await settle(); const state = ui.child.value.$.setupState;
api.fetchKnowledgeReviewJobs.mockResolvedValue({ items: [own] }); await state.start(); await settle();
state.cancel('own'); const confirmation = vi.mocked(Modal.confirm).mock.calls.at(-1)![0];
const gate = deferred<{ items: KnowledgeReviewJob[] }>(); api.fetchKnowledgeReviewJobs.mockImplementationOnce(() => gate.promise);
const pending = state.refresh(); await settle();
ui.allowedAccountIds.value = [1]; await settle(); ui.allowedAccountIds.value = undefined; await settle();
gate.resolve({ items: [{ ...own, status: 'completed', processed: 1, published: 1 }] }); await pending; await settle();
await (confirmation.onOk as () => unknown)();
expect(api.knowledgeReviewAction).toHaveBeenCalledTimes(1); expect(ui.open.value).toBe(true);
expect(ui.updateOpen).not.toHaveBeenCalled(); expect(message.success).not.toHaveBeenCalled();
});
it('serializes preview POSTs across destroyed dialogs and drops an invalid queued scope before sending', async () => {
const old = deferred<KnowledgeReviewJob>(); const latest = deferred<KnowledgeReviewJob>();
let active = 0; let maximum = 0; let serverCurrent = '';
api.previewKnowledgeReview.mockImplementation(async (account) => {
active++; maximum = Math.max(maximum, active);
const result = await (account === 3 ? latest.promise : old.promise);
active--; serverCurrent = result.id; return result;
});
const original = mount(); await settle(); expect(api.previewKnowledgeReview).toHaveBeenCalledTimes(1);
cleanup!(); cleanup = undefined;
const current = mount(); await settle(); const state = current.child.value.$.setupState;
expect(original.host.isConnected).toBe(false); expect(api.previewKnowledgeReview).toHaveBeenCalledTimes(1);
state.scopeId = 2; state.scopeId = 3; await settle();
old.resolve(preview(1, 'expired-old')); await settle();
expect(api.previewKnowledgeReview.mock.calls).toEqual([[1, 'approve'], [3, 'approve']]);
expect(state.preview).toBeNull(); expect(maximum).toBe(1);
latest.resolve(preview(3, 'valid-latest')); await settle();
expect(active).toBe(0); expect(state.preview.id).toBe(serverCurrent); expect(state.preview.id).toBe('valid-latest');
await state.start(); expect(api.knowledgeReviewAction).toHaveBeenCalledExactlyOnceWith('valid-latest', 'start', true);
});
});
@@ -1,24 +1,44 @@
<script setup lang="ts">
import type { KnowledgeReviewJob, KnowledgeReviewResult } from '#/api/knowledge';
import { computed, onBeforeUnmount, onDeactivated, ref, watch } from 'vue';
import { Alert, Button, Checkbox, Modal, Progress, Select, Space, Table, Tabs, Tag, message } from 'ant-design-vue';
import type { KnowledgeReviewJob, KnowledgeReviewMode, KnowledgeReviewResult } from '#/api/knowledge';
import { computed, onActivated, onBeforeUnmount, onDeactivated, ref, watch } from 'vue';
import { useAccess } from '@vben/access';
import { Alert, Button, Modal, Progress, Select, Space, Table, Tabs, Tag, message } from 'ant-design-vue';
import { fetchDesktopAccounts } from '#/api/console';
import { fetchKnowledgeReviewJobs, fetchKnowledgeReviewResults, knowledgeReviewAction, previewKnowledgeReview } from '#/api/knowledge';
import { t } from '#/locales/t';
import { failureText } from './batch';
import { serializeReviewPreview } from './review-preview';
const props = defineProps<{ open: boolean; accountId: number; initialTab: string }>();
const props = defineProps<{ open: boolean; accountId: number; initialTab: string; ownScope?: boolean; allowedAccountIds?: number[]; assignedOnly?: boolean }>();
const emit = defineEmits<{ 'update:open': [value: boolean]; changed: []; inspect: [itemId: string, accountId: number] }>();
const { hasAccessByCodes } = useAccess();
const permissionCodes = ['knowledge:read', 'knowledge:review:auto', 'im:content:read', 'knowledge:review', 'knowledge:publish'];
const hasAll = (codes: string[]) => codes.every((code) => hasAccessByCodes([code]));
const canReview = computed(() => hasAll(permissionCodes.slice(0, -1)));
const canPublish = computed(() => hasAll(permissionCodes));
const mode = computed<KnowledgeReviewMode>(() => canPublish.value ? 'approve_publish' : 'approve');
const permissionKey = computed(() => JSON.stringify(permissionCodes.map((code) => hasAccessByCodes([code]))));
const tab = ref('new');
const scopeId = ref(-1);
const accountList = ref<Awaited<ReturnType<typeof fetchDesktopAccounts>> | null>(null);
const scopeReady = computed(() => props.assignedOnly || !!accountList.value);
const requestAccount = computed(() => props.assignedOnly ? -1 : scopeId.value);
// 下拉选项随语言切换:存原始数据,选项用 computed 生成
const accounts = computed(() => !accountList.value ? [] : [
{ value: -1, label: t('全部授权账号') }, ...(accountList.value.can_view_legacy ? [{ value: 0, label: t('旧版未归属数据') }] : []),
...accountList.value.accounts.map((item) => ({ value: item.id, label: t('{name}({code})', { name: item.nickname || item.zyt_sn, code: item.zyt_sn }) }))]);
const accounts = computed(() => !accountList.value || (props.allowedAccountIds !== undefined && !props.allowedAccountIds.length) ? [] : [
{ value: -1, label: t('全部授权账号') }, ...(accountList.value.can_view_legacy && props.allowedAccountIds === undefined ? [{ value: 0, label: t('旧版未归属数据') }] : []),
...accountList.value.accounts.filter((item) => props.allowedAccountIds === undefined || props.allowedAccountIds.includes(item.id))
.map((item) => ({ value: item.id, label: t('{name}({code})', { name: item.nickname || item.zyt_sn, code: item.zyt_sn }) }))]);
const preview = ref<KnowledgeReviewJob | null>(null);
const confirmed = ref(false);
const previewLoading = ref(false);
const previewAccount = ref<number | null>(null);
const previewMode = ref<KnowledgeReviewMode | null>(null);
const scopeAllowed = computed(() => props.assignedOnly || props.allowedAccountIds === undefined
|| (scopeId.value === -1 ? props.allowedAccountIds.length > 0 : props.allowedAccountIds.includes(scopeId.value)));
const busy = ref(false);
const actionActive = ref(false);
let actionToken = 0;
let previewInFlight = false;
let previewQueued = false;
const error = ref('');
const jobs = ref<KnowledgeReviewJob[]>([]);
const selectedId = ref('');
@@ -30,72 +50,161 @@ const selectedJob = computed(() => jobs.value.find((job) => job.id === selectedI
const labels = computed<Record<string, string>>(() => ({ queued: t('等待审核'), running: t('审核中'), paused: t('已暂停'), failed: t('需处理'), completed: t('已完成'), cancelled: t('已取消') }));
let timer: ReturnType<typeof setTimeout> | undefined;
let generation = 0;
let viewActive = true;
let resultGeneration = 0;
function stop() { generation++; resultGeneration++; if (timer) clearTimeout(timer); }
onBeforeUnmount(stop); onDeactivated(stop);
watch(scopeId, () => { preview.value = null; confirmed.value = false; });
watch(() => props.open, async (open) => {
stop(); if (!open) return;
let previewGeneration = 0;
let contextRevision = 0;
let launchedJob: { id: string; revision: number } | null = null;
function stop() {
generation++; resultGeneration++; previewGeneration++; previewQueued = false;
launchedJob = null;
if (timer) clearTimeout(timer);
busy.value = false; previewLoading.value = false; preview.value = null; previewAccount.value = null; previewMode.value = null;
accountList.value = null; jobs.value = []; rows.value = []; selectedId.value = ''; resultTotal.value = 0; error.value = '';
}
onBeforeUnmount(() => { viewActive = false; stop(); });
onDeactivated(() => { viewActive = false; stop(); emit('update:open', false); });
const allowedScopeKey = computed(() => JSON.stringify(props.allowedAccountIds === undefined
? null : [...new Set(props.allowedAccountIds)].sort((left, right) => left - right)));
const contextKey = computed(() => JSON.stringify([requestAccount.value, allowedScopeKey.value, props.ownScope, props.assignedOnly, permissionKey.value]));
watch(contextKey, () => {
contextRevision++;
launchedJob = null; resultGeneration++;
previewGeneration++; previewQueued = false; preview.value = null; previewAccount.value = null; previewMode.value = null; previewLoading.value = false;
jobs.value = []; rows.value = []; selectedId.value = ''; resultTotal.value = 0;
if (timer) clearTimeout(timer);
if (props.open && scopeReady.value && !busy.value && !actionActive.value) {
if (tab.value === 'new') void inspectScope(); else void refresh();
}
}, { flush: 'sync' });
watch(tab, (value) => {
if (value === 'new' && props.open && scopeReady.value && !busy.value && !preview.value) void inspectScope();
});
watch(() => props.allowedAccountIds, (ids) => {
if (ids !== undefined && scopeId.value !== -1 && !ids.includes(scopeId.value)) scopeId.value = -1;
}, { flush: 'sync' });
async function initializeOpen() {
stop(); if (!viewActive || !props.open || !canReview.value || actionActive.value) return;
const current = generation;
scopeId.value = props.accountId; tab.value = props.initialTab;
preview.value = null; confirmed.value = false; error.value = ''; rows.value = []; selectedId.value = '';
accountList.value = null;
scopeId.value = props.assignedOnly || (props.allowedAccountIds !== undefined && !props.allowedAccountIds.includes(props.accountId))
? -1 : props.accountId;
tab.value = props.initialTab;
preview.value = null; previewAccount.value = null; previewLoading.value = false; error.value = ''; rows.value = []; selectedId.value = '';
busy.value = true;
try {
const result = await fetchDesktopAccounts(false);
if (current !== generation) return;
accountList.value = result;
if (!props.assignedOnly) {
const result = await fetchDesktopAccounts(false);
if (current !== generation || !canReview.value) return;
accountList.value = result;
}
await refresh();
} catch (cause) { if (current === generation) error.value = failureText(cause); }
finally { if (current === generation) busy.value = false; }
if (current === generation && tab.value === 'new') await inspectScope();
}
watch(() => props.open, initializeOpen, { immediate: true });
onActivated(() => { viewActive = true; if (props.open && !busy.value && !actionActive.value && !accountList.value) void initializeOpen(); });
watch(actionActive, (active) => {
if (!active && viewActive && props.open && !accountList.value && !busy.value) void initializeOpen();
else if (!active && viewActive && props.open && tab.value === 'new' && !busy.value && !preview.value) void inspectScope();
else if (!active && viewActive && props.open && tab.value === 'jobs' && !busy.value && !jobs.value.length) void refresh();
});
function finishPublished(job: KnowledgeReviewJob) {
if (!viewActive || !props.open || !canPublish.value || !launchedJob || launchedJob.id !== job.id
|| launchedJob.revision !== contextRevision || job.mode !== 'approve_publish'
|| job.status !== 'completed' || job.error || !Number.isInteger(job.total) || job.total <= 0
|| job.processed !== job.total || !Number.isInteger(job.published) || job.published !== job.total || job.skipped !== 0) return false;
launchedJob = null;
message.success(t('已审核并发布 {count} 条', { count: job.published.toLocaleString() }));
close(); return true;
}
async function refresh() {
const current = generation;
if (!viewActive || !props.open || !canReview.value) return;
const current = generation; const revision = contextRevision;
if (timer) clearTimeout(timer);
try {
const data = await fetchKnowledgeReviewJobs();
if (current !== generation || !props.open) return;
if (current !== generation || revision !== contextRevision || !props.open) return;
jobs.value = data.items;
const completed = launchedJob && data.items.find((job) => job.id === launchedJob?.id);
if (completed && finishPublished(completed)) return;
if (selectedId.value) await loadResults();
emit('changed');
} catch (cause) { if (current === generation) error.value = failureText(cause); }
if (current === generation && revision === contextRevision && props.open) emit('changed');
} catch (cause) { if (current === generation && revision === contextRevision) error.value = failureText(cause); }
finally {
if (current === generation && props.open && jobs.value.some((job) => ['queued', 'running'].includes(job.status)))
if (current === generation && revision === contextRevision && props.open && jobs.value.some((job) => ['queued', 'running'].includes(job.status)))
timer = setTimeout(() => { void refresh(); }, 2500);
}
}
// The server expires previous previews. Serialize POSTs and coalesce scope changes to the latest request.
async function inspectScope() {
if (busy.value) return;
const current = generation; const account = scopeId.value;
busy.value = true; error.value = ''; preview.value = null; confirmed.value = false;
if (!viewActive || busy.value || actionActive.value || !props.open || !canReview.value) return;
previewGeneration++; error.value = ''; preview.value = null; previewAccount.value = null; previewMode.value = null;
previewQueued = scopeAllowed.value; previewLoading.value = scopeAllowed.value;
if (!previewQueued || previewInFlight) return;
previewInFlight = true;
try {
const result = await previewKnowledgeReview(account);
if (current === generation && account === scopeId.value) preview.value = result;
} catch (cause) { if (current === generation) error.value = failureText(cause); }
finally { if (current === generation) busy.value = false; }
while (previewQueued) {
previewQueued = false;
const current = previewGeneration; const owner = generation; const account = requestAccount.value; const requestMode = mode.value;
if (!viewActive || !props.open || busy.value || actionActive.value || !scopeAllowed.value || !canReview.value) continue;
try {
const result = await serializeReviewPreview(() => previewKnowledgeReview(account, requestMode),
() => current === previewGeneration && owner === generation && viewActive && props.open && canReview.value && scopeAllowed.value);
if (result && current === previewGeneration && owner === generation && props.open && account === requestAccount.value && scopeAllowed.value
&& canReview.value && requestMode === mode.value && result.mode === requestMode) {
preview.value = result; previewAccount.value = account; previewMode.value = requestMode;
}
} catch (cause) {
if (current === previewGeneration && owner === generation && props.open) error.value = failureText(cause);
}
}
} finally { previewInFlight = false; previewLoading.value = false; }
}
async function start() {
if (busy.value || !preview.value || !confirmed.value) return;
busy.value = true; error.value = '';
if (!viewActive || !props.open || busy.value || actionActive.value || previewLoading.value || !canReview.value || !scopeAllowed.value
|| !preview.value?.preview.eligible || previewAccount.value !== requestAccount.value || previewMode.value !== mode.value || preview.value.mode !== mode.value) return;
const current = generation; const revision = contextRevision; const snapshot = preview.value; const token = ++actionToken;
actionActive.value = true; busy.value = true; error.value = '';
try {
const job = await knowledgeReviewAction(preview.value.id, 'start', true);
selectedId.value = job.id; resultPage.value = 1; tab.value = 'jobs'; preview.value = null; confirmed.value = false;
message.success(t('全量审核任务已提交,关闭页面后仍会继续')); await refresh();
} catch (cause) { error.value = failureText(cause); }
finally { busy.value = false; }
const job = await knowledgeReviewAction(snapshot.id, 'start', true);
if (current !== generation || revision !== contextRevision || !props.open) return;
if (snapshot.mode === 'approve_publish' && job.mode === 'approve_publish') launchedJob = { id: job.id, revision };
selectedId.value = job.id; resultPage.value = 1; tab.value = 'jobs'; preview.value = null; previewAccount.value = null; previewMode.value = null;
if (finishPublished(job)) return;
if (snapshot.mode === 'approve') message.success(t('全量审核任务已提交,关闭页面后仍会继续'));
await refresh();
} catch (cause) { if (current === generation && revision === contextRevision && props.open) error.value = failureText(cause); }
finally {
if (token === actionToken) actionActive.value = false;
if (current === generation) busy.value = false;
}
}
async function act(jobId: string, action: string) {
if (busy.value) return;
busy.value = true; error.value = '';
try { await knowledgeReviewAction(jobId, action); await refresh(); }
catch (cause) { error.value = failureText(cause); }
finally { busy.value = false; }
const job = jobs.value.find((entry) => entry.id === jobId);
if (!viewActive || !props.open || busy.value || actionActive.value || !canReview.value
|| (action === 'resume' && job?.mode === 'approve_publish' && !canPublish.value)) return;
const current = generation; const revision = contextRevision; const token = ++actionToken;
actionActive.value = true; busy.value = true; error.value = '';
try {
await knowledgeReviewAction(jobId, action);
if (current === generation && revision === contextRevision && props.open) await refresh();
} catch (cause) { if (current === generation && revision === contextRevision && props.open) error.value = failureText(cause); }
finally {
if (token === actionToken) actionActive.value = false;
if (current === generation) busy.value = false;
}
}
function cancel(jobId: string) {
Modal.confirm({ title: t('停止剩余审核?'), content: t('已通过的知识保留在待发布,尚未处理的草稿保持原状态。'),
okText: t('停止剩余审核'), cancelText: t('返回'), onOk: () => act(jobId, 'cancel') });
const revision = contextRevision; const current = generation;
const job = jobs.value.find((entry) => entry.id === jobId);
Modal.confirm({ title: t('停止剩余审核?'), content: job?.mode === 'approve_publish'
? t('已发布的知识保留发布状态,尚未处理的草稿保持原状态。') : t('已通过的知识保留在待发布,尚未处理的草稿保持原状态。'),
okText: t('停止剩余审核'), cancelText: t('返回'), onOk: () => current === generation && revision === contextRevision && act(jobId, 'cancel') });
}
async function loadResults() {
if (!selectedId.value) return;
if (!viewActive || !props.open || !canReview.value || !selectedId.value) return;
const current = ++resultGeneration;
try {
const data = await fetchKnowledgeReviewResults(selectedId.value, resultType.value, resultPage.value);
@@ -104,51 +213,64 @@ async function loadResults() {
} catch (cause) { if (current === resultGeneration && props.open) error.value = failureText(cause); }
}
function showResults(id: string) { selectedId.value = id; resultPage.value = 1; void loadResults(); }
function close() { emit('update:open', false); emit('changed'); }
function close() { stop(); emit('update:open', false); emit('changed'); }
</script>
<template>
<Modal :open="open" :title="t('全量审核')" width="1050px" :footer="null" :closable="!busy" :keyboard="!busy" :mask-closable="false" @cancel="close">
<Modal :open="open" :title="mode === 'approve_publish' ? t('全量审核并发布') : t('全量审核')" width="1050px" :footer="null" :closable="!busy" :keyboard="!busy" :mask-closable="false" @cancel="close">
<Alert v-if="actionActive && !busy" class="mb-3" type="info" :message="t('上一项操作仍在完成,请稍候。')" />
<Alert v-if="ownScope && !assignedOnly" class="mb-3" type="info" show-icon :message="t('当前仅显示本人 ZYT 账号名下的知识,包含管理员代为清洗的数据;操作仍按角色权限')" />
<Alert v-if="error" class="mb-3" type="error" show-icon :message="error" />
<Tabs v-model:active-key="tab">
<Tabs.TabPane key="new" :tab="t('指定范围审核')">
<Alert class="mb-4" type="info" show-icon :message="t('审核范围是已整理出的待审核知识草稿,覆盖全部页面,不受列表搜索与勾选影响。通过后进入待发布,原始聊天归档不会被修改。')" />
<Space class="mb-4" wrap><span>{{ t('审核账号') }}</span><Select v-model:value="scopeId" :disabled="busy" :options="accounts" style="min-width: 320px" /><Button :loading="busy" @click="inspectScope">{{ t('预览全部待审草稿') }}</Button></Space>
<Tabs.TabPane key="new" :tab="assignedOnly ? t('审核全部指派草稿') : t('指定范围审核')">
<Alert class="mb-4" type="info" show-icon :message="assignedOnly ? t('此任务只处理指派给你的待审核草稿,覆盖所有页面。') : mode === 'approve_publish'
? t('当前范围包含已整理出的全部待审核知识草稿,覆盖所有页面,不受列表搜索与勾选影响。符合条件的草稿将审核并发布,可供客服检索使用。')
: t('审核范围是已整理出的待审核知识草稿,覆盖全部页面,不受列表搜索与勾选影响。通过后进入待发布,原始聊天归档不会被修改。')" />
<Space v-if="!assignedOnly" class="mb-4" wrap><span>{{ t('审核账号') }}</span><Select v-model:value="scopeId" :disabled="busy || actionActive" :options="accounts" class="w-full sm:!w-80" /></Space>
<p v-if="previewLoading" class="mb-4 text-gray-500" role="status">{{ t('正在统计所选范围的待审草稿…') }}</p>
<Alert v-if="!scopeAllowed" class="mb-4" type="info" :message="t('本人 ZYT 账号暂无可用客户端。')" />
<Button v-if="error && !busy && !previewLoading" class="mb-4" @click="inspectScope">{{ t('重新统计范围') }}</Button>
<template v-if="preview">
<p>{{ t('范围:') }}<strong>{{ t(preview.scope_label) }}</strong> · {{ t('快照时间 {time}', { time: preview.preview.snapshot_at }) }}</p>
<p>{{ t('当前预览范围:') }}<strong>{{ assignedOnly ? t('指派给我的草稿') : t(preview.scope_label) }}</strong> · {{ t('快照时间 {time}', { time: preview.preview.snapshot_at }) }} · {{ preview.mode === 'approve_publish' ? t('审核并发布') : t('审核通过后进入待发布') }}</p>
<div class="mb-4 grid grid-cols-3 gap-3 rounded border p-4">
<div>{{ t('待审核') }} <strong>{{ preview.total.toLocaleString() }}</strong> {{ t('条') }}</div>
<div>{{ t('可通过') }} <strong>{{ preview.preview.eligible.toLocaleString() }}</strong> {{ t('条') }}</div>
<div>{{ mode === 'approve_publish' ? t('可审核并发布') : t('可通过') }} <strong>{{ preview.preview.eligible.toLocaleString() }}</strong> {{ t('条') }}</div>
<div>{{ t('需处理') }} <strong>{{ preview.preview.blocked.toLocaleString() }}</strong> {{ t('条') }}</div>
</div>
<Table size="small" :data-source="preview.preview.accounts" row-key="tenant_id" :pagination="{ pageSize: 5, showSizeChanger: false }" :columns="[{ title: t('账号'), dataIndex: 'name', key: 'name' }, { title: t('待审核'), dataIndex: 'total' }, { title: t('可通过'), dataIndex: 'eligible' }]">
<Table v-if="!assignedOnly" size="small" :data-source="preview.preview.accounts" row-key="tenant_id" :pagination="{ pageSize: 5, showSizeChanger: false }" :columns="[{ title: t('账号'), dataIndex: 'name', key: 'name' }, { title: t('待审核'), dataIndex: 'total' }, { title: t('可通过'), dataIndex: 'eligible' }]">
<template #bodyCell="{ column, record }"><template v-if="column.key === 'name'">{{ t(record.name) }}</template></template>
</Table>
<Alert v-for="reason in preview.preview.reasons" :key="reason.code" class="mb-2" type="warning" :message="t('{reason}:{count} 条', { reason: t(reason.reason), count: reason.count })" />
<p class="my-3 text-gray-500">{{ t('预览固定当前草稿与版本,30 分钟内可提交。执行时会再次校验来源、版本和权限;不合格条目保持原状态并列出原因。') }}</p>
<Checkbox v-model:checked="confirmed" :disabled="busy || !preview.preview.eligible">{{ t('确认所选范围已完成必要的事实、脱敏和适用性审核;涉及医疗内容已完成专业审核。批量通过符合校验条件的草稿,之后另行发布。') }}</Checkbox>
<div class="mt-4"><Button type="primary" :loading="busy" :disabled="!confirmed || !preview.preview.eligible" @click="start">{{ t('一键审核 {count} 条并进入待发布', { count: preview.preview.eligible.toLocaleString() }) }}</Button></div>
<p class="my-3 text-gray-500">{{ assignedOnly ? t('请核对草稿数量、事实、脱敏与适用条件后再确认。') : mode === 'approve_publish'
? t('请核对以上账号范围、数量及知识内容。点击下方按钮后执行审核并发布;全部成功后自动关闭此弹窗并刷新知识列表,需处理的条目会保留结果。')
: t('请确认以上账号范围和数量,并核对事实、脱敏与适用条件。点击下方按钮后,符合条件的草稿将进入待发布。') }}</p>
<div class="mt-4"><Button type="primary" :loading="busy" :disabled="busy || actionActive || previewLoading || !canReview || !scopeAllowed || !preview.preview.eligible" @click="start">{{ mode === 'approve_publish'
? t('一键审核并发布 {count} 条', { count: preview.preview.eligible.toLocaleString() })
: t('确认审核 {count} 条并进入待发布', { count: preview.preview.eligible.toLocaleString() }) }}</Button></div>
</template>
</Tabs.TabPane>
<Tabs.TabPane key="jobs" :tab="t('我的审核任务')">
<Space class="mb-3"><span>{{ t('后台分批执行,关闭页面不影响进度。') }}</span><Button :disabled="busy" @click="refresh">{{ t('刷新任务') }}</Button></Space>
<Table size="small" :data-source="jobs" row-key="id" :pagination="{ pageSize: 5, showSizeChanger: false }" :columns="[{ title: t('账号范围'), dataIndex: 'scope_label', key: 'scope' }, { title: t('状态 / 进度'), key: 'progress' }, { title: t('审核结果'), key: 'result' }, { title: t('操作'), key: 'actions' }]">
<Table size="small" :data-source="jobs" row-key="id" :pagination="{ pageSize: 5, showSizeChanger: false }" :columns="[{ title: assignedOnly ? t('审核范围') : t('账号范围'), dataIndex: 'scope_label', key: 'scope' }, { title: t('状态 / 进度'), key: 'progress' }, { title: t('审核结果'), key: 'result' }, { title: t('操作'), key: 'actions' }]">
<template #bodyCell="{ column, record }">
<template v-if="column.key === 'scope'">{{ t(record.scope_label) }}</template>
<template v-if="column.key === 'scope'">{{ assignedOnly ? t('指派给我的草稿') : t(record.scope_label) }}<div class="text-gray-500">{{ record.mode === 'approve_publish' ? t('审核并发布') : t('审核通过后进入待发布') }}</div></template>
<template v-else-if="column.key === 'progress'"><Tag>{{ labels[record.status] }}</Tag><div>{{ t('{processed} / {total} 条', { processed: record.processed, total: record.total }) }}</div><Progress :percent="record.progress_percent" size="small" /><div class="text-red-500">{{ record.error }}</div></template>
<template v-else-if="column.key === 'result'">{{ t('通过 {approved} · 未通过 {skipped}', { approved: record.approved, skipped: record.skipped }) }}</template>
<template v-else-if="column.key === 'result'">{{ record.mode === 'approve_publish'
? t('已发布 {published} · 已审核 {approved} · 需处理 {skipped}', { published: record.published || 0, approved: record.approved, skipped: record.skipped })
: t('通过 {approved} · 未通过 {skipped}', { approved: record.approved, skipped: record.skipped }) }}</template>
<Space v-else-if="column.key === 'actions'" wrap>
<Button size="small" @click="showResults(record.id)">{{ t('查看结果') }}</Button>
<Button v-if="['queued', 'running'].includes(record.status)" size="small" :disabled="busy" @click="act(record.id, 'pause')">{{ t('暂停') }}</Button>
<Button v-if="['paused', 'failed'].includes(record.status)" size="small" :disabled="busy" @click="act(record.id, 'resume')">{{ t('继续') }}</Button>
<Button v-if="['queued', 'running', 'paused', 'failed'].includes(record.status)" size="small" danger :disabled="busy" @click="cancel(record.id)">{{ t('停止') }}</Button>
<Button v-if="['queued', 'running'].includes(record.status)" size="small" :disabled="busy || actionActive || !canReview" @click="act(record.id, 'pause')">{{ t('暂停') }}</Button>
<Button v-if="['paused', 'failed'].includes(record.status)" size="small" :disabled="busy || actionActive || !canReview || (record.mode === 'approve_publish' && !canPublish)" @click="act(record.id, 'resume')">{{ t('继续') }}</Button>
<Button v-if="['queued', 'running', 'paused', 'failed'].includes(record.status)" size="small" danger :disabled="busy || actionActive || !canReview" @click="cancel(record.id)">{{ t('停止') }}</Button>
</Space>
</template>
</Table>
<template v-if="selectedId">
<Space class="my-4"><strong>{{ t('结果清单 · {scope}', { scope: t(selectedJob?.scope_label || '') }) }}</strong><Select v-model:value="resultType" style="width: 140px" :options="[{ value: 'skipped', label: t('未通过') }, { value: 'approved', label: t('已通过') }, { value: 'pending', label: t('未处理') }]" @change="() => { resultPage = 1; loadResults(); }" /></Space>
<p class="mb-2 text-gray-500">{{ t('结果清单仅显示当前仍有权限的账号。') }}</p>
<Table size="small" :data-source="rows" row-key="item_id" :pagination="{ current: resultPage, pageSize: 30, total: resultTotal, showSizeChanger: false }" :columns="[{ title: t('账号'), dataIndex: 'account_name', key: 'account' }, { title: t('知识标题'), dataIndex: 'title', key: 'title' }, { title: t('原因'), dataIndex: 'reason_text', key: 'reason' }, { title: t('操作'), key: 'open' }]" @change="(p) => { resultPage = p.current || 1; loadResults(); }">
<Space class="my-4"><strong>{{ t('结果清单 · {scope}', { scope: assignedOnly ? t('指派给我的草稿') : t(selectedJob?.scope_label || '') }) }}</strong><Select v-model:value="resultType" style="width: 140px" :options="[{ value: 'skipped', label: t('未通过') }, { value: 'published', label: t('已发布') }, { value: 'approved', label: t('已通过') }, { value: 'pending', label: t('未处理') }]" @change="() => { resultPage = 1; loadResults(); }" /></Space>
<p class="mb-2 text-gray-500">{{ assignedOnly ? t('结果清单仅显示此任务处理的指派草稿。') : t('结果清单仅显示当前仍有权限的账号。') }}</p>
<Table size="small" :data-source="rows" row-key="item_id" :pagination="{ current: resultPage, pageSize: 30, total: resultTotal, showSizeChanger: false }" :columns="[...(assignedOnly ? [] : [{ title: t('账号'), dataIndex: 'account_name', key: 'account' }]), { title: t('知识标题'), dataIndex: 'title', key: 'title' }, { title: t('原因'), dataIndex: 'reason_text', key: 'reason' }, ...(assignedOnly ? [] : [{ title: t('操作'), key: 'open' }])]" @change="(p) => { resultPage = p.current || 1; loadResults(); }">
<template #bodyCell="{ column, record }">
<template v-if="column.key === 'account'">{{ t(record.account_name) }}</template>
<template v-else-if="column.key === 'title'">{{ t(record.title) }}</template>
@@ -0,0 +1,97 @@
<script setup lang="ts">
import type { KnowledgeItem, KnowledgeReviewAssignee } from '#/api/knowledge';
import { computed, onDeactivated, onMounted, onScopeDispose, ref } from 'vue';
import { useAccess } from '@vben/access';
import { Alert, Button, Modal, Select, Space, message } from 'ant-design-vue';
import { requestErrorMessage } from '#/api/error-message';
import { MAX_KNOWLEDGE_REVIEW_ASSIGNMENTS, fetchKnowledgeReviewAssignees, setKnowledgeReviewAssignee } from '#/api/knowledge';
import { t } from '#/locales/t';
const props = defineProps<{ accountId: number; entries: KnowledgeItem[] }>();
const emit = defineEmits<{ close: []; saved: [] }>();
const { hasAccessByCodes } = useAccess();
const canAssign = computed(() => hasAccessByCodes(['knowledge:review:assign']));
const selected = ref<number>();
const assignees = ref<KnowledgeReviewAssignee[]>([]);
const options = computed(() => assignees.value.map(({ id, name, username }) => ({
value: id, label: name && name !== username ? `${name} (${username})` : username,
})));
const loading = ref(true);
const saving = ref(false);
const loadError = ref('');
const saveError = ref('');
const hasAssignment = computed(() => props.entries.some((item) => item.review_assignment));
const account = props.accountId;
const entries = props.entries;
const items = entries.map(({ id, revision }) => ({ id, revision }));
let active = true;
const isCurrent = () => active && canAssign.value && items.length > 0
&& items.length <= MAX_KNOWLEDGE_REVIEW_ASSIGNMENTS && props.accountId === account && props.entries === entries;
async function loadAssignees() {
if (!isCurrent()) return;
loading.value = true;
loadError.value = '';
try {
const result = await fetchKnowledgeReviewAssignees(account, items);
if (isCurrent()) assignees.value = result.items;
} catch (error) {
if (isCurrent()) loadError.value = requestErrorMessage(error, t('请求未完成,请刷新确认状态后再操作'));
} finally {
if (isCurrent()) loading.value = false;
}
}
async function submit(assigneeId: number | null) {
if (!isCurrent() || loading.value || saving.value) return;
if (assigneeId === null ? !hasAssignment.value : !assignees.value.some(({ id }) => id === assigneeId)) return;
saving.value = true;
saveError.value = '';
try {
const { updated } = await setKnowledgeReviewAssignee(account, items, assigneeId);
if (!isCurrent()) return;
message.success(assigneeId === null ? t('已撤回 {count} 条指派', { count: updated }) : t('已指派 {count} 条草稿', { count: updated }));
emit('saved');
} catch (error) {
if (isCurrent()) saveError.value = requestErrorMessage(error, t('请求未完成,请刷新确认状态后再操作'));
} finally {
if (isCurrent()) saving.value = false;
}
}
onMounted(loadAssignees);
onDeactivated(() => { active = false; });
onScopeDispose(() => { active = false; });
</script>
<template>
<Modal :open="canAssign" :title="t('指派审核 · {count} 条草稿', { count: entries.length })"
:closable="!saving" :keyboard="!saving" :mask-closable="false" @cancel="emit('close')">
<ul class="mb-4 max-h-52 list-none overflow-auto rounded border p-3">
<li v-for="item in entries" :key="item.id" class="flex flex-wrap justify-between gap-x-3 py-1">
<span>{{ item.title }}</span>
<span class="text-gray-500">{{ item.review_assignment?.assignee_name || t('未指派') }}</span>
</li>
</ul>
<label for="knowledge-review-assignee" class="mb-2 block font-medium">{{ t('审核人') }}</label>
<Select id="knowledge-review-assignee" v-model:value="selected" class="w-full"
:options="options" :loading="loading" :disabled="saving || loading || !options.length"
:placeholder="t('请选择审核人')" show-search option-filter-prop="label" />
<Alert v-if="loadError" class="mt-3" type="error" show-icon :message="loadError">
<template #action><Button size="small" @click="loadAssignees">{{ t('刷新') }}</Button></template>
</Alert>
<p v-else-if="!loading && !options.length" class="mt-3 text-gray-500">{{ t('当前没有能审核所选草稿的用户') }}</p>
<p v-else-if="hasAssignment" class="mt-3 text-gray-500">{{ t('选择审核人后,所选草稿将由此人审核。') }}</p>
<Alert v-if="saveError" class="mt-3" type="error" show-icon :message="saveError" />
<template #footer>
<Space wrap>
<Button :disabled="saving" @click="emit('close')">{{ t('取消') }}</Button>
<Button v-if="hasAssignment" danger :disabled="loading || saving" @click="submit(null)">{{ t('撤回指派') }}</Button>
<Button type="primary" :disabled="loading || selected === undefined || saving"
@click="selected !== undefined && submit(selected)">{{ t('确认指派') }}</Button>
</Space>
</template>
</Modal>
</template>
@@ -0,0 +1,251 @@
import { createApp, nextTick, ref } from 'vue';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { actionProblem } from './batch';
import MyReviews from './my-reviews.vue';
import AssignmentDialog from './review-assignment-dialog.vue';
import ReviewPolicyDialog from './review-policy-dialog.vue';
const request = vi.hoisted(() => ({ get: vi.fn(), post: vi.fn(), put: vi.fn() }));
vi.mock('#/api/request', () => ({ requestClient: request }));
vi.mock('#/locales/t', () => ({ t: (text: string) => text }));
const access = ref<string[]>([]);
vi.mock('@vben/access', () => ({
useAccess: () => ({ hasAccessByCodes: (codes: string[]) => codes.some((code) => access.value.includes(code)) }),
}));
vi.mock('ant-design-vue', async () => {
const { defineComponent, h } = await import('vue');
const plain = defineComponent({ setup: (_props, { slots }) => () => h('div', [slots.default?.(), slots.footer?.(), slots.action?.()]) });
return {
Alert: defineComponent({ props: ['message'], setup: (props) => () => h('p', props.message) }),
Button: plain, Empty: plain, Collapse: Object.assign({}, plain, { Panel: plain }), Progress: plain, Input: Object.assign({}, plain, { TextArea: plain }),
Form: Object.assign({}, plain, { Item: plain }), Modal: defineComponent({
props: ['open'], setup: (props, { slots }) => () => props.open ? h('section', [slots.default?.(), slots.footer?.()]) : null,
}),
Radio: Object.assign({}, plain, { Group: plain }), Select: plain, Space: plain, Spin: plain, Switch: plain, Table: plain, Tag: plain, message: { success: vi.fn() },
};
});
const basePermissions = ['knowledge:read', 'knowledge:review', 'im:content:read'];
const assigned = {
id: 'draft', title: 'Draft', question: 'Question', answer: 'Answer', conditions: 'Applicable', category: '',
kind: 'qa', valid_until: '', status: 'draft', revision: 2, flags: [],
review_assignment: { id: 'assignment-1', assigned_at: '2026-11-05T01:00:00Z' },
sources: [{ role: 'staff', content: 'Redacted evidence', sent_at: '2026-11-04T01:00:00Z' }],
};
let cleanup: (() => void) | undefined;
function mount(component: Parameters<typeof createApp>[0], props: Record<string, unknown> = {}) {
const app = createApp(component, props);
const host = document.createElement('div');
document.body.append(host);
const vm = app.mount(host);
cleanup = () => { app.unmount(); host.remove(); };
return { host, state: (vm.$ as unknown as { setupState: Record<string, any> }).setupState };
}
async function settle() { await Promise.resolve(); await nextTick(); await nextTick(); }
beforeEach(() => {
vi.resetAllMocks();
access.value = [...basePermissions];
request.get.mockImplementation(async (url: string) => url.includes('?page=')
? { items: [structuredClone(assigned)], total: 1 } : structuredClone(assigned));
});
afterEach(() => { cleanup?.(); cleanup = undefined; });
describe('knowledge review assignment', () => {
it('serializes the chosen list page size separately from the inbox page size', async () => {
const { fetchKnowledgeItems, fetchMyKnowledgeReviews } = await import('#/api/knowledge');
const signal = new AbortController().signal;
await fetchKnowledgeItems(7, 'draft', 'redacted question', 2, 137, signal);
await fetchMyKnowledgeReviews(2, signal);
expect(request.get.mock.calls).toEqual([
['/knowledge/items?account_id=7&page=2&page_size=137&query=redacted+question&status=draft', { signal }],
['/knowledge/my-reviews?page=2', { signal }],
]);
});
it.each([7, null])('updates the exact selected versions with reviewer %s', async (assigneeId) => {
access.value = ['knowledge:review:assign'];
const entries = [
{ id: 'first', revision: 3, title: 'First', review_assignment: { assignee_id: 4, assignee_name: 'Former reviewer' } },
{ id: 'second', revision: 8, title: 'Second' },
];
request.post.mockResolvedValue({ items: [{ id: 7, name: 'Reviewer', username: 'reviewer' }] });
request.put.mockResolvedValue({ updated: 2 });
const onSaved = vi.fn();
const { host, state } = mount(AssignmentDialog, { accountId: -1, entries, onSaved });
await settle();
const items = [{ id: 'first', revision: 3 }, { id: 'second', revision: 8 }];
expect(request.post).toHaveBeenCalledWith('/knowledge/review-assignees?account_id=-1', { items });
expect(host.textContent).toContain('Former reviewer');
await state.submit(99);
expect(request.put).not.toHaveBeenCalled();
await state.submit(assigneeId);
expect(request.put).toHaveBeenCalledWith('/knowledge/review-assignments?account_id=-1', { items, assignee_id: assigneeId });
expect(onSaved).toHaveBeenCalledOnce();
});
it('discards a delayed assignee list after assignment permission is removed', async () => {
access.value.push('knowledge:review:assign');
let resolveCandidates!: (value: unknown) => void;
request.post.mockReturnValue(new Promise((resolve) => { resolveCandidates = resolve; }));
const { state } = mount(AssignmentDialog, { accountId: 8, entries: [{ id: 'draft', revision: 2 }] });
access.value = [...basePermissions];
resolveCandidates({ items: [{ id: 7, name: 'Reviewer', username: 'reviewer' }] });
await settle();
expect(state.options).toEqual([]);
await state.submit(7);
expect(request.put).not.toHaveBeenCalled();
});
});
describe('my assigned knowledge reviews', () => {
it('uses the saved revision and exact assignment ID, then refreshes the independent inbox', async () => {
access.value.push('knowledge:write', 'knowledge:publish');
const onReviewed = vi.fn();
const { host, state } = mount(MyReviews, { active: true, onReviewed });
await settle();
expect(request.get.mock.calls.map(([url]) => url)).toEqual(['/knowledge/my-reviews?page=1']);
await state.inspect('draft');
await nextTick();
expect(host.textContent).toContain('Redacted evidence');
expect(host.textContent).not.toContain('发布到知识库');
state.selected.content_type = 'standard_answer';
await state.decide('approve');
expect(request.post).not.toHaveBeenCalled();
const saved = { ...assigned, revision: 3, content_type: 'standard_answer' };
request.put.mockResolvedValueOnce(saved);
request.get.mockResolvedValueOnce({ items: [saved], total: 1 });
await state.save();
expect(request.put).toHaveBeenCalledWith('/knowledge/my-reviews/draft', {
assignment_id: 'assignment-1', revision: 2, title: 'Draft', question: 'Question', answer: 'Answer',
conditions: 'Applicable', category: '', content_type: 'standard_answer', kind: 'qa', valid_until: '',
});
request.post.mockResolvedValueOnce({ status: 'approved' });
request.get.mockResolvedValueOnce({ items: [], total: 0 });
await state.decide('approve');
expect(request.post).toHaveBeenCalledWith('/knowledge/my-reviews/draft/approve', {
assignment_id: 'assignment-1', revision: 3, confirmed: true,
});
expect(onReviewed).toHaveBeenCalledOnce();
expect(state.detailOpen).toBe(false);
expect(state.items).toEqual([]);
expect(request.get.mock.calls.every(([url]) => !url.includes('account_id'))).toBe(true);
});
it('uses approve_publish only for an assigned reviewer with publish permission', async () => {
const { state } = mount(MyReviews, { active: true });
await settle(); await state.inspect('draft');
await state.decide('approve_publish');
expect(request.post).not.toHaveBeenCalled();
access.value.push('knowledge:publish');
request.post.mockResolvedValueOnce({ status: 'published' });
request.get.mockResolvedValueOnce({ items: [], total: 0 });
await state.decide('approve_publish');
expect(request.post).toHaveBeenCalledWith('/knowledge/my-reviews/draft/approve_publish', {
assignment_id: 'assignment-1', revision: 2, confirmed: true,
});
expect(state.detailOpen).toBe(false);
expect(state.items).toEqual([]);
});
it('closes the source dialog and clears selection when a refresh finds the assignment withdrawn', async () => {
const { host, state } = mount(MyReviews, { active: true });
await settle(); await state.inspect('draft'); await nextTick();
expect(host.textContent).toContain('Redacted evidence');
state.selectedKeys = ['draft'];
request.get.mockResolvedValueOnce({ items: [], total: 0 });
await state.load(); await nextTick();
expect(state.detailOpen).toBe(false);
expect(state.selectedKeys).toEqual([]);
expect(host.textContent).not.toContain('Redacted evidence');
const reads = request.get.mock.calls.length;
await state.inspect('draft');
expect(request.get).toHaveBeenCalledTimes(reads);
});
it('discards a delayed detail from a replaced assignment of the same draft revision', async () => {
const { state } = mount(MyReviews, { active: true });
await settle();
let resolveDetail!: (value: unknown) => void;
request.get.mockReturnValueOnce(new Promise((resolve) => { resolveDetail = resolve; }));
const pending = state.inspect('draft');
const replacement = { ...assigned, review_assignment: { ...assigned.review_assignment, id: 'new-assignment' } };
request.get.mockResolvedValueOnce({ items: [replacement], total: 1 });
await state.load();
resolveDetail(assigned);
await pending;
expect(state.detailOpen).toBe(false);
expect(state.selected).toBeNull();
expect(state.items[0].review_assignment.id).toBe('new-assignment');
});
it('keeps a running batch open when a completed row disappears from the inbox', async () => {
const { state } = mount(MyReviews, { active: true });
await settle();
state.selectedKeys = ['draft'];
state.openBatch();
await settle();
state.batchProcessing = 'run';
request.get.mockResolvedValueOnce({ items: [], total: 0 });
await state.load();
expect(state.batchOpen).toBe(true);
state.batchProcessing = null;
request.get.mockResolvedValueOnce({ items: [], total: 0 });
state.batchFinished([{ id: 'draft', title: 'Draft', status: 'success', error: '' }]);
await settle();
expect(state.batchOpen).toBe(true);
});
it('invalidates a pending detail when content access is removed', async () => {
const { state } = mount(MyReviews, { active: true });
await settle();
let resolveDetail!: (value: unknown) => void;
request.get.mockReturnValueOnce(new Promise((resolve) => { resolveDetail = resolve; }));
const pending = state.inspect('draft');
access.value = ['knowledge:read', 'knowledge:review'];
resolveDetail(assigned);
await pending;
expect(state.selected).toBeNull();
expect(state.detailOpen).toBe(false);
expect(state.items).toEqual([]);
});
it('allows editing while blocking both review decisions for an own-account draft', async () => {
access.value.push('knowledge:write', 'knowledge:reject');
const { host, state } = mount(MyReviews, { active: true });
await settle();
request.get.mockResolvedValueOnce({ ...assigned, self_review_blocked: true });
await state.inspect('draft');
await nextTick();
expect(host.textContent).toContain('自己的知识须由他人审核');
expect(state.canEdit).toBe(true);
await state.decide('approve');
await state.decide('reject');
expect(request.post).not.toHaveBeenCalled();
expect(actionProblem(state.selected, 'approve_publish')).toBe('自己的知识须由他人审核');
expect(actionProblem(state.selected, 'reject')).toBe('自己的知识须由他人审核');
});
});
describe('knowledge self-review policy', () => {
it('loads and saves the global boolean only when its dedicated permission is held', async () => {
access.value.push('knowledge:review:settings');
request.get.mockResolvedValueOnce({ allow_self_review: true });
request.put.mockResolvedValueOnce({ allow_self_review: false });
const onSaved = vi.fn();
const { state } = mount(ReviewPolicyDialog, { onSaved });
await settle();
expect(request.get).toHaveBeenCalledWith('/knowledge/review-policy');
expect(state.allowSelfReview).toBe(true);
state.allowSelfReview = false;
await state.save();
expect(request.put).toHaveBeenCalledWith('/knowledge/review-policy', { allow_self_review: false });
expect(onSaved).toHaveBeenCalledOnce();
access.value = [...basePermissions];
await state.save();
expect(request.put).toHaveBeenCalledOnce();
});
});
@@ -0,0 +1,60 @@
<script setup lang="ts">
import { computed, onDeactivated, onMounted, onScopeDispose, ref } from 'vue';
import { useAccess } from '@vben/access';
import { Alert, Modal, Space, Switch } from 'ant-design-vue';
import { requestErrorMessage } from '#/api/error-message';
import { fetchKnowledgeReviewPolicy, setKnowledgeReviewPolicy } from '#/api/knowledge';
import { t } from '#/locales/t';
const emit = defineEmits<{ close: []; saved: [] }>();
const { hasAccessByCodes } = useAccess();
const allowed = computed(() => hasAccessByCodes(['knowledge:read']) && hasAccessByCodes(['knowledge:review:settings']));
const initial = ref<boolean>();
const allowSelfReview = ref(false);
const saving = ref(false);
const errorText = ref('');
let active = true;
const isCurrent = () => active && allowed.value;
onMounted(async () => {
if (!isCurrent()) return;
try {
const policy = await fetchKnowledgeReviewPolicy();
if (isCurrent()) initial.value = allowSelfReview.value = policy.allow_self_review;
} catch (error) {
if (isCurrent()) errorText.value = requestErrorMessage(error);
}
});
async function save() {
if (!isCurrent() || initial.value === undefined || initial.value === allowSelfReview.value || saving.value) return;
saving.value = true;
errorText.value = '';
try {
await setKnowledgeReviewPolicy(allowSelfReview.value);
if (isCurrent()) emit('saved');
} catch (error) {
if (isCurrent()) errorText.value = requestErrorMessage(error);
} finally {
if (isCurrent()) saving.value = false;
}
}
onDeactivated(() => { active = false; });
onScopeDispose(() => { active = false; });
</script>
<template>
<Modal :open="allowed" :title="t('审核设置')" :mask-closable="false" :closable="!saving" :keyboard="!saving"
:cancel-text="t('取消')" :cancel-button-props="{ disabled: saving }" :ok-text="t('保存')"
:ok-button-props="{ disabled: initial === undefined || initial === allowSelfReview }" :confirm-loading="saving"
@cancel="emit('close')" @ok="save">
<Space v-if="initial !== undefined">
<Switch v-model:checked="allowSelfReview" :disabled="saving" :aria-label="t('允许审核本人账号的知识')" />
{{ t('允许审核本人账号的知识') }}
</Space>
<p class="mb-0 mt-3 text-gray-500">{{ t('此设置适用于所有账号。关闭后,本人账号下的知识必须由其他审核人通过或驳回。') }}</p>
<Alert v-if="errorText" class="mt-3" type="error" show-icon :message="errorText" />
</Modal>
</template>
@@ -0,0 +1,9 @@
// Preview POSTs expire the actor's previous snapshot. Keep this queue across
// dialog remounts, and drop requests whose view or permissions changed in line.
let pending: Promise<unknown> = Promise.resolve();
export function serializeReviewPreview<T>(request: () => Promise<T>, isCurrent: () => boolean): Promise<T | null> {
const result = pending.then(() => isCurrent() ? request() : null);
pending = result.then(() => undefined, () => undefined);
return result;
}
@@ -0,0 +1,46 @@
import { createApp, defineComponent, h, nextTick, ref } from 'vue';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
const api = vi.hoisted(() => ({ createKnowledgeRun: vi.fn(), fetchKnowledgeConfig: vi.fn(), previewKnowledgeRun: vi.fn() }));
vi.mock('#/api/knowledge', () => api);
vi.mock('#/api/console', () => ({ ALL_ACCOUNTS: -1, fetchDesktopAccounts: async () => ({ can_view_legacy: true,
accounts: [{ id: 1, nickname: 'own client', zyt_sn: 'own' }, { id: 2, nickname: 'other client', zyt_sn: 'other' }] }) }));
vi.mock('#/locales/t', () => ({ t: (value: string, args?: Record<string, string>) => args ? `${args.name} (${args.code})` : value }));
vi.mock('./wash-options.vue', () => ({ default: defineComponent({ setup: () => () => null }) }));
vi.mock('ant-design-vue', () => {
const plain = defineComponent({ setup: (_props, { slots }) => () => h('div', slots.default?.()) });
return { Alert: plain, Button: plain, Checkbox: plain, Input: plain, Modal: plain, Space: plain, Spin: plain, Table: plain,
Radio: Object.assign({}, plain, { Group: plain }), Form: Object.assign({}, plain, { Item: plain }),
Select: defineComponent({ props: ['options'], setup: (props) => () => h('div', (props.options || []).map((entry: { label: string }) => entry.label).join('|')) }),
message: { success: vi.fn() } };
});
import Dialog from './run-dialog.vue';
let cleanup: (() => void) | undefined;
async function settle() { for (let i = 0; i < 8; i++) { await Promise.resolve(); await nextTick(); } }
function mount(allowed?: number[]) {
const open = ref(false); const ids = ref(allowed); const host = document.createElement('div'); document.body.append(host);
let child: any;
const app = createApp(defineComponent({ setup: () => () => h(Dialog, { ref: (value) => { child = value; },
open: open.value, accountId: 2, allowedAccountIds: ids.value }) }));
app.mount(host); cleanup = () => { app.unmount(); host.remove(); };
return { host, open, ids, state: () => child.$.setupState };
}
describe('knowledge run account choices', () => {
beforeEach(() => { vi.useFakeTimers(); vi.clearAllMocks(); api.fetchKnowledgeConfig.mockResolvedValue(null); });
afterEach(() => { cleanup?.(); vi.useRealTimers(); });
it('keeps original options without a filter and blocks an emptied picked scope instead of submitting all accounts', async () => {
const page = mount(); page.open.value = true; await settle();
expect(page.host.textContent).toContain('own client'); expect(page.host.textContent).toContain('other client');
expect(page.host.textContent).toContain('旧版未归属数据'); expect(page.state().accountIds).toEqual([2]);
page.ids.value = [1]; await settle();
expect(page.host.textContent).toContain('own client'); expect(page.host.textContent).not.toContain('other client');
expect(page.host.textContent).not.toContain('旧版未归属数据');
expect(page.state().scopeMode).toBe('pick'); expect(page.state().accountIds).toEqual([]);
expect(page.state().blocked).toBe('请选择要整理的账号');
await page.state().submit(); await vi.runAllTimersAsync();
expect(api.createKnowledgeRun).not.toHaveBeenCalled(); expect(api.previewKnowledgeRun).not.toHaveBeenCalled();
page.ids.value = []; await settle();
expect(page.state().accountOptions).toEqual([]); expect(page.state().blocked).toBe('请选择要整理的账号');
});
});
@@ -17,7 +17,7 @@ import WashOptions from './wash-options.vue';
* 整理聊天记录:一张表单。默认整理全部授权账号的全部聊天,选好模型直接开始。
* 范围一改就自动重新统计;不用先选账号、选来源、预览、勾确认框。
*/
const props = defineProps<{ accountId: number; canWatch?: boolean; open: boolean }>();
const props = defineProps<{ accountId: number; canWatch?: boolean; open: boolean; allowedAccountIds?: number[] }>();
const emit = defineEmits<{ created: []; 'update:open': [value: boolean] }>();
const scopeMode = ref<'all' | 'pick'>('all');
@@ -33,11 +33,13 @@ const preview = ref<KnowledgeRunPreview | null>(null);
const previewing = ref(false);
const saving = ref(false);
let generation = 0;
let previewRequest: AbortController | undefined;
let timer: ReturnType<typeof setTimeout> | undefined;
const accountOptions = computed(() => [
...(canViewLegacy.value ? [{ value: 0, label: t('旧版未归属数据') }] : []),
...accounts.value.map((item) => ({ value: item.id, label: t('{name}({code})', { name: item.nickname || item.zyt_sn, code: item.zyt_sn }) })),
...(canViewLegacy.value && props.allowedAccountIds === undefined ? [{ value: 0, label: t('旧版未归属数据') }] : []),
...accounts.value.filter((item) => props.allowedAccountIds === undefined || props.allowedAccountIds.includes(item.id))
.map((item) => ({ value: item.id, label: t('{name}({code})', { name: item.nickname || item.zyt_sn, code: item.zyt_sn }) })),
]);
const scope = computed(() => ({
account_ids: scopeMode.value === 'all' ? [] : accountIds.value,
@@ -53,48 +55,71 @@ const blocked = computed(() => {
return '';
});
watch(() => props.open, async (open) => {
function stopPreview() {
generation++;
if (timer) clearTimeout(timer);
previewRequest?.abort();
previewRequest = undefined;
previewing.value = false;
}
watch(() => props.open, async (open) => {
stopPreview();
if (!open) return;
const current = generation;
ready.value = false;
preview.value = null;
dateFrom.value = '';
dateTo.value = '';
autoWatch.value = false;
scopeMode.value = props.accountId === ALL_ACCOUNTS ? 'all' : 'pick';
accountIds.value = props.accountId === ALL_ACCOUNTS ? [] : [props.accountId];
accountIds.value = props.accountId === ALL_ACCOUNTS ? [] : [props.accountId]
.filter((id) => props.allowedAccountIds === undefined || props.allowedAccountIds.includes(id));
const [config, list] = await Promise.all([fetchKnowledgeConfig().catch(() => null), fetchDesktopAccounts(false)]);
if (current !== generation) return;
wash.value = washFromConfig(config);
accounts.value = list.accounts;
canViewLegacy.value = list.can_view_legacy;
ready.value = true;
refresh();
});
watch(() => props.allowedAccountIds === undefined ? undefined : [...new Set(props.allowedAccountIds)].sort((a, b) => a - b).join(','), () => {
if (props.allowedAccountIds !== undefined) accountIds.value = accountIds.value.filter((id) => props.allowedAccountIds!.includes(id));
if (props.open && ready.value) refresh();
});
watch(scope, () => { if (props.open && ready.value) refresh(); }, { deep: true });
onBeforeUnmount(() => { generation++; if (timer) clearTimeout(timer); });
onBeforeUnmount(stopPreview);
function refresh() {
if (timer) clearTimeout(timer);
const current = ++generation;
stopPreview();
const current = generation;
preview.value = null;
if (scopeMode.value === 'pick' && !accountIds.value.length) return;
if (dateFrom.value && dateTo.value && dateFrom.value > dateTo.value) return;
timer = setTimeout(async () => {
previewRequest = new AbortController();
previewing.value = true;
try {
const data = await previewKnowledgeRun(scope.value);
const data = await previewKnowledgeRun(scope.value, previewRequest.signal);
if (current === generation) preview.value = data;
} catch {
// RequestClient reports real errors and suppresses cancellation.
} finally {
if (current === generation) previewing.value = false;
if (current === generation) {
previewRequest = undefined;
previewing.value = false;
}
}
}, 300);
}
async function submit() {
if (blocked.value || saving.value) return;
if (!props.open || blocked.value || saving.value) return;
const current = generation;
saving.value = true;
try {
const run = await createKnowledgeRun({ ...scope.value, ...wash.value, auto_watch: !!props.canWatch && autoWatch.value, staff_confirmed: true });
if (current !== generation) return;
message.success(t('已开始整理:{count} 个账号,在「整理任务」里看进度', { count: run.accounts.length }));
emit('update:open', false);
emit('created');
@@ -1,7 +1,7 @@
<script setup lang="ts">
import type { KnowledgeAutoSummary, KnowledgeRun, KnowledgeRunAccount, KnowledgeWashOptions } from '#/api/knowledge';
import { computed, ref } from 'vue';
import { computed, onActivated, onDeactivated, onScopeDispose, ref, watch } from 'vue';
import { Alert, Button, Empty, Form, message, Modal, Progress, Space, Table, Tag, Tooltip } from 'ant-design-vue';
@@ -21,9 +21,22 @@ const busy = ref(false);
const configOpen = ref(false);
const configRun = ref<KnowledgeRun | null>(null);
const configWash = ref<KnowledgeWashOptions | null>(null);
let active = true;
let cancelDialog: ReturnType<typeof Modal.confirm> | undefined;
function closeControls() {
configOpen.value = false;
cancelDialog?.destroy();
cancelDialog = undefined;
}
function deactivate() { active = false; closeControls(); }
watch(() => props.canControl, (allowed) => { if (!allowed) closeControls(); }, { flush: 'sync' });
onActivated(() => { active = true; });
onDeactivated(deactivate);
onScopeDispose(deactivate);
async function act(run: KnowledgeRun, action: 'cancel' | 'pause' | 'resume') {
if (busy.value) return;
if (!active || !props.canControl || busy.value) return;
busy.value = true;
try {
await knowledgeRunAction(run.id, action);
@@ -35,7 +48,7 @@ async function act(run: KnowledgeRun, action: 'cancel' | 'pause' | 'resume') {
}
function cancel(run: KnowledgeRun) {
Modal.confirm({
cancelDialog = Modal.confirm({
title: t('取消这个整理批次?'),
content: t('已经生成的草稿保留,剩下的聊天不再整理;正在进行的模型请求可能仍会计费。'),
okText: t('取消整理'), cancelText: t('不取消'), okType: 'danger',
@@ -51,10 +64,11 @@ function configure(run: KnowledgeRun) {
async function saveConfig() {
const run = configRun.value;
if (!run || !configWash.value || busy.value) return;
if (!active || !props.canControl || !run || !configWash.value || busy.value) return;
busy.value = true;
try {
await configureKnowledgeRun(run.id, configWash.value);
if (!active || !props.canControl) return;
await knowledgeRunAction(run.id, 'resume');
configOpen.value = false;
message.success(t('已按新配置继续;已生成的草稿保留,新配置只用于剩下的部分'));
@@ -0,0 +1,7 @@
<script setup lang="ts">
import KnowledgeCenter from './center.vue';
</script>
<template>
<KnowledgeCenter search-mode />
</template>
@@ -0,0 +1,7 @@
<script setup lang="ts">
import KnowledgeCenter from './center.vue';
</script>
<template>
<KnowledgeCenter tasks-mode />
</template>
@@ -60,16 +60,31 @@ ant.Table = vue.defineComponent({ props: ['dataSource', 'columns'], setup(props,
const catalog = [
{ code: 'user:read', name: '查看用户', group_name: '系统管理', page_name: '用户管理', kind: 'page' },
{ code: 'user:write', name: '修改用户角色', group_name: '系统管理', page_name: '用户管理', kind: 'action' },
{ code: 'custom:report', name: '自定义报表', group_name: '报表', page_name: '报表', kind: 'link' },
{ code: 'knowledge:read', name: '查看知识中心', group_name: '知识中心', page_name: '知识加工与检索', kind: 'page' },
{ code: 'knowledge:scope:own', name: '数据权限:仅本人账号的知识', group_name: '知识中心', page_name: '知识加工与检索', kind: 'action' },
];
const rows = [
{ code: 'admin', name: '管理员', permissions: ['user:read'], builtin: false, user_count: 0 },
{ code: 'zyt_basic', name: '集团基础用户', permissions: [], builtin: false, user_count: 0 },
{ code: 'reviewer', name: '审核员', permissions: ['user:read', 'custom:report', 'removed:code'], builtin: false, user_count: 0 },
{ code: 'operator', name: '操作员', permissions: ['user:read'], builtin: true, user_count: 0 },
{ code: 'viewer', name: '只读用户', permissions: ['user:read'], builtin: true, user_count: 0 },
];
async function page(codes, configure = () => {}) {
const calls = { save: [], remove: [], success: [] };
const calls = { save: [], remove: [], success: [], requests: [] };
// Exercise the actual API adapter so grant and revoke assertions cover the
// posted role payload, including an explicit empty permissions array.
const api = load(await readFile(resolve(workspace, 'apps/web-antd/src/api/console.ts'), 'utf8'), {
'#/api/request': { requestClient: {
async post(path, data) {
calls.requests.push({ path, data }); calls.save.push(data); return { roles: rows };
},
} },
'#/locales/t': translate, '#/utils/file-sha256': {},
});
let state;
const component = load(script.content, {
vue, 'vue-router': { useRouter: () => ({ push() {} }) },
@@ -78,7 +93,7 @@ async function page(codes, configure = () => {}) {
'#/locales/t': translate, './permission-menu': helpers,
'#/api/console': {
async fetchRoles() { return { roles: rows }; }, async fetchPermissions() { return { permissions: catalog }; },
async saveRole(data) { calls.save.push(data); return { roles: rows }; },
saveRole: api.saveRole,
async deleteRole(code) { calls.remove.push(code); return { roles: rows }; },
},
}).default;
@@ -95,8 +110,20 @@ async function page(codes, configure = () => {}) {
return { state, calls, html };
}
test('管理员和集团基础角色实际组件均为只读:名称/权限禁用、查看与关闭、禁止写删', async () => {
for (const row of rows.slice(0, 2)) {
test('知识数据权限按既有action协议保存,取消可撤回且不单独授予审核或正文权限', async () => {
const { state, calls, html } = await page(['role:read', 'role:write'], state => state.openEdit(rows[1]));
assert.match(html, /勾选「仅本人账号的知识」后,仅显示本人 ZYT 账号名下的知识/);
state.onCheck(['knowledge:scope:own']);
await state.submit();
assert.deepEqual([...calls.requests[0].data.permissions].sort(), ['knowledge:read', 'knowledge:scope:own']);
state.openEdit({ ...rows[1], permissions: [...state.form.permissions] });
state.onCheck(['knowledge:read']);
await state.submit();
assert.deepEqual([...calls.requests[1].data.permissions], ['knowledge:read']);
});
test('管理员实际组件仍只读:名称/权限禁用、查看与关闭、禁止写删', async () => {
for (const row of rows.slice(0, 1)) {
const { state, calls, html } = await page(['role:write', 'role:delete'], state => state.openEdit(row));
assert.equal(state.readonly.value, true);
assert.match(html, /data-modal-title="查看角色"/);
@@ -104,7 +131,6 @@ test('管理员和集团基础角色实际组件均为只读:名称/权限禁
assert.match(html, new RegExp(`value="${row.name}" disabled`));
assert.match(html, /data-permission-tree="true"/);
assert.match(html, new RegExp(`data-role="${row.code}"[\\s\\S]*?<button[^>]*>查看<\\/button>[\\s\\S]*?<button[^>]*disabled`));
if (row.code === 'zyt_basic') assert.match(html, /请到「系统管理 → 用户管理」为账号分配其他业务角色/);
const before = [...state.form.permissions];
state.onCheck(['user:read']);
assert.deepEqual([...state.form.permissions], before);
@@ -115,6 +141,57 @@ test('管理员和集团基础角色实际组件均为只读:名称/权限禁
}
});
test('集团基础角色有编辑和保存入口,选定菜单与操作会提交真实 API,空数组可全部撤销', async () => {
const row = rows[1];
const { state, calls, html } = await page(['role:read', 'role:write', 'role:delete'], state => state.openEdit(row));
assert.equal(state.readonly.value, false);
assert.match(html, /data-modal-title="编辑角色"/);
assert.match(html, /data-modal-action(?:="")?>保存/);
assert.match(html, /value="zyt_basic" disabled/);
assert.match(html, /value="集团基础用户"(?! disabled)/);
assert.match(html, /data-permission-tree="false"/);
assert.match(html, /data-role="zyt_basic"[\s\S]*?<button[^>]*>编辑<\/button>[\s\S]*?<button[^>]*disabled/);
assert.match(html, /此角色的权限对所有使用它的账号生效;新集团账号默认使用此角色/);
assert.doesNotMatch(html, /集团基础用户角色只读|固定无业务权限|不能修改。请到/);
assert.deepEqual([...state.form.permissions], [], 'opening the basic role must not grant permissions');
await state.submit();
assert.deepEqual([...calls.requests[0].data.permissions], [], 'saving an unchanged basic role must not grant permissions');
state.openEdit(row);
state.form.name = '集团客服用户';
state.onCheck(['user:write', 'custom:report']);
assert.deepEqual([...state.form.permissions].sort(), ['custom:report', 'user:read', 'user:write']);
await state.submit();
assert.equal(calls.requests[1].path, '/roles');
assert.deepEqual(JSON.parse(JSON.stringify(calls.requests[1].data)), {
code: 'zyt_basic', name: '集团客服用户', permissions: ['user:write', 'user:read', 'custom:report'],
});
state.openEdit({ ...row, permissions: [...state.form.permissions] });
state.onCheck([]);
await state.submit();
assert.equal(calls.requests[2].path, '/roles');
assert.equal(calls.requests[2].data.code, 'zyt_basic');
assert.deepEqual([...calls.requests[2].data.permissions], []);
await state.remove(row);
assert.deepEqual(calls.remove, [], 'reserved basic role cannot be deleted even if builtin metadata is missing');
});
test('内置业务角色仍可编辑但不可删除,在用角色也不可删除', async () => {
for (const row of [{ ...rows[1], builtin: true }, rows[3], rows[4], { ...rows[2], builtin: true }, { ...rows[2], user_count: 1 }]) {
const { state, calls, html } = await page(['role:write', 'role:delete'], state => state.openEdit(row));
assert.equal(state.readonly.value, false);
assert.match(html, /data-modal-title="编辑角色"/);
await state.remove(row);
assert.deepEqual(calls.remove, []);
}
});
test('有角色写权限但没有删除权限的用户仍不能删除普通角色', async () => {
const { state, calls } = await page(['role:read', 'role:write'], state => state.openEdit(rows[2]));
assert.equal(state.readonly.value, false);
await state.remove(rows[2]);
assert.deepEqual(calls.remove, []);
});
test('普通业务角色仍可编辑并保留自定义权限,保存只过滤失效码并说明在线用户自动同步', async () => {
const { state, calls, html } = await page(['role:read', 'role:write', 'role:delete'], state => state.openEdit(rows[2]));
assert.equal(state.readonly.value, false);
@@ -131,10 +208,56 @@ test('普通业务角色仍可编辑并保留自定义权限,保存只过滤
});
test('角色只读用户不能通过组件方法保存或删除业务角色', async () => {
const { state, calls } = await page(['role:read'], state => state.openEdit(rows[2]));
assert.equal(state.readonly.value, true);
await state.submit();
await state.remove(rows[2]);
assert.deepEqual(calls.save, []);
assert.deepEqual(calls.remove, []);
for (const row of [rows[1], rows[2]]) {
const { state, calls, html } = await page(['role:read', 'role:create'], state => state.openEdit(row));
assert.equal(state.readonly.value, true);
assert.match(html, /data-modal-title="查看角色"/);
assert.match(html, /data-modal-action(?:="")?>关闭/);
assert.match(html, /data-permission-tree="true"/);
assert.match(html, new RegExp(`value="${row.name}" disabled`));
const before = [...state.form.permissions];
state.onCheck(['user:write']);
assert.deepEqual([...state.form.permissions], before);
await state.submit();
await state.remove(row);
assert.deepEqual(calls.save, []);
assert.deepEqual(calls.remove, []);
}
});
test('角色编辑、共享授权说明和无权限欢迎提示都有英文映射', async () => {
const permissions = load(await readFile(new URL('../src/locales/en/permissions.ts', import.meta.url), 'utf8'), {}).default;
const users = load(await readFile(new URL('../src/locales/en/users.ts', import.meta.url), 'utf8'), {}).default;
const roleSource = descriptor.template.content;
const description = roleSource.match(/:description="t\('([^']+)'\)"/)[1];
assert.match(permissions[description], /administrator role is read-only/);
assert.match(permissions['此角色的权限对所有使用它的账号生效;新集团账号默认使用此角色。'], /every account using it/);
const welcome = await readFile(new URL('../src/views/group/welcome.vue', import.meta.url), 'utf8');
const noPermissions = welcome.match(/:message="t\('([^']+)'\)"/)[1];
assert.match(users[noPermissions], /configure role permissions or assign another business role/);
});
test('基础角色欢迎页按真实权限显示提示,不再显示可能已更名的固定角色名称', async () => {
const filename = fileURLToPath(new URL('../src/views/group/welcome.vue', import.meta.url));
const { descriptor } = parse(await readFile(filename, 'utf8'), { filename });
const script = compileScript(descriptor, { id: 'basic-role-welcome-test' });
const template = compileTemplate({ source: descriptor.template.content, filename,
id: 'basic-role-welcome-test', compilerOptions: { bindingMetadata: script.bindings } });
assert.deepEqual(template.errors, []);
for (const roles of [[], ['user:read']]) {
const component = load(script.content, {
vue, '#/locales/t': translate, 'ant-design-vue': ant,
'@vben/stores': { useUserStore: () => ({ userInfo: { username: 'fixture', desc: 'zyt_basic', roles } }) },
}).default;
component.render = load(template.code, { vue }).render;
const html = await renderToString(vue.createSSRApp(component));
assert.doesNotMatch(html, /当前角色:集团基础用户/);
if (roles.length) {
assert.match(html, /您的角色已授权,可从左侧菜单进入相应功能/);
assert.doesNotMatch(html, /当前尚未获得业务权限/);
} else {
assert.match(html, /当前尚未获得业务权限。请联系本系统管理员配置角色权限或分配其他业务角色/);
assert.doesNotMatch(html, /您的角色已授权/);
}
}
});