diff --git a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/api/knowledge-review.test.ts b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/api/knowledge-review.test.ts new file mode 100644 index 000000000..d060cbc7c --- /dev/null +++ b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/api/knowledge-review.test.ts @@ -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 }); + }); +}); diff --git a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/api/knowledge.ts b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/api/knowledge.ts index 3bf73f594..1af7afc19 100644 --- a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/api/knowledge.ts +++ b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/api/knowledge.ts @@ -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; + +export type KnowledgeReviewDraft = Pick; + +export type MyKnowledgeReview = KnowledgeReviewDraft & Pick & { + review_assignment: { id: string; assigned_at: string }; + sources?: Pick[]; +}; + +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; settings: null | { enabled: boolean; updated_at: string }; semantic_configured: boolean; @@ -55,18 +88,38 @@ function path(resource: string, accountId: number, extra: Record requestClient.get(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(path(`items/${item}`, id)); export const saveKnowledgeItem = (id: number, item: KnowledgeItem) => requestClient.put(path(`items/${item.id}`, id), item); export const knowledgeItemAction = (id: number, item: KnowledgeItem, action: string, confirmed = false, restoreRevision = 0) => requestClient.post(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(`/knowledge/my-reviews/${item}`); +export const saveMyKnowledgeReview = (item: string, body: KnowledgeReviewDraft & { assignment_id: string; revision: number }) => + requestClient.put(`/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('/knowledge/review-policy'); +export const setKnowledgeReviewPolicy = (allowSelfReview: boolean) => + requestClient.put('/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(path('search', id), { query }); +export const searchKnowledge = (id: number, query: string, signal?: AbortSignal) => + requestClient.post(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('/knowledge/runs/preview', scope, { timeout: 120000 }); +export const previewKnowledgeRun = (scope: KnowledgeRunScope, signal?: AbortSignal) => + requestClient.post('/knowledge/runs/preview', scope, { timeout: 120000, signal }); export const createKnowledgeRun = (body: KnowledgeRunScope & KnowledgeWashOptions & { auto_watch: boolean; staff_confirmed: boolean }) => requestClient.post('/knowledge/runs', body, { timeout: 120000 }); export const fetchKnowledgeRuns = (signal?: AbortSignal) => @@ -189,9 +242,10 @@ export const testKnowledgeModel = (modelProviderId: string, timeout = 90) => requestClient.post('/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(path('review-tasks/preview', accountId), {}, { timeout: 120000 }); +export const previewKnowledgeReview = (accountId: number, mode: KnowledgeReviewMode = 'approve') => + requestClient.post(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) => diff --git a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/components/archive-account-selector.test.ts b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/components/archive-account-selector.test.ts new file mode 100644 index 000000000..5b904a322 --- /dev/null +++ b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/components/archive-account-selector.test.ts @@ -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) => + 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'); + }); +}); diff --git a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/components/archive-account-selector.vue b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/components/archive-account-selector.vue index e9f3d56ee..2d90d16bf 100644 --- a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/components/archive-account-selector.vue +++ b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/components/archive-account-selector.vue @@ -1,14 +1,14 @@ + + diff --git a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch-dialog.test.ts b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch-dialog.test.ts new file mode 100644 index 000000000..9efbec70e --- /dev/null +++ b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch-dialog.test.ts @@ -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() { + let resolve!: (value: T) => void; + const promise = new Promise((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('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(); 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(); 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(), deferred(), deferred()]; + 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(); const current = deferred(); + 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(); 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'); + }); + +}); diff --git a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch-dialog.vue b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch-dialog.vue index b3be197a2..af6e87be8 100644 --- a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch-dialog.vue +++ b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch-dialog.vue @@ -1,32 +1,56 @@ diff --git a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch.test.ts b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch.test.ts index c47c9ba3a..2fe166a5b 100644 --- a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch.test.ts +++ b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch.test.ts @@ -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() { + let resolve!: (value: T) => void; + const promise = new Promise((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()); + 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()); + 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()); + 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']); + }); + }); diff --git a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch.ts b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch.ts index 6207fe759..85db36cf0 100644 --- a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch.ts +++ b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/batch.ts @@ -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, +/** Keep the first selected revision when repeated IDs arrive from a caller. */ +export function uniqueKnowledgeItems(items: T[]): T[] { + const seen = new Set(); + 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( + entries: T[], action: BatchAction, fetch: (item: T) => Promise, + stopped: () => boolean, +) { + const selected = uniqueKnowledgeItems(entries); + const details = [...selected]; + const problems: Record = {}; + const editableIds = new Set(); + 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( + items: T[], execute: (item: T) => Promise, 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; } diff --git a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/center.vue b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/center.vue index 43cd01ffc..8e803dd2d 100644 --- a/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/center.vue +++ b/.pnpm-store/v11/projects/a46d6327308ec23b0167cf73344b78d4/apps/web-antd/src/views/knowledge/center.vue @@ -1,50 +1,78 @@