From b3f7b8494b5471e025eb6de62f6f22f648e49627 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=85=AC=E6=98=8E?=
<83812544+Ed1s0nZ@users.noreply.github.com>
Date: Tue, 9 Jun 2026 21:06:14 +0800
Subject: [PATCH] Delete web/static/js/knowledge.js.bak
---
web/static/js/knowledge.js.bak | 2216 --------------------------------
1 file changed, 2216 deletions(-)
delete mode 100644 web/static/js/knowledge.js.bak
diff --git a/web/static/js/knowledge.js.bak b/web/static/js/knowledge.js.bak
deleted file mode 100644
index 00ece303..00000000
--- a/web/static/js/knowledge.js.bak
+++ /dev/null
@@ -1,2216 +0,0 @@
-// 知识库管理相关功能
-let knowledgeCategories = [];
-let knowledgeItems = [];
-let currentEditingItemId = null;
-let isSavingKnowledgeItem = false; // 防止重复提交
-let retrievalLogsData = []; // 存储检索日志数据，用于详情查看
-let knowledgePagination = {
- currentPage: 1,
- pageSize: 10, // 每页分类数（改为按分类分页）
- total: 0,
- currentCategory: ''
-};
-let knowledgeSearchTimeout = null; // 搜索防抖定时器
-
-// 加载知识分类
-async function loadKnowledgeCategories() {
- try {
- // 添加时间戳参数避免缓存
- const timestamp = Date.now();
- const response = await apiFetch(`/api/knowledge/categories?_t=${timestamp}`, {
- method: 'GET',
- headers: {
- 'Cache-Control': 'no-cache, no-store, must-revalidate',
- 'Pragma': 'no-cache',
- 'Expires': '0'
- }
- });
- if (!response.ok) {
- throw new Error('获取分类失败');
- }
- const data = await response.json();
-
- // 检查知识库功能是否启用
- if (data.enabled === false) {
- // 功能未启用，显示友好提示
- const container = document.getElementById('knowledge-items-list');
- if (container) {
- container.innerHTML = `
-
-
📚
-
知识库功能未启用
-
${data.message || '请前往系统设置启用知识检索功能'}
-
-
全部
';
- knowledgeCategories.forEach(category => {
- const option = document.createElement('div');
- option.className = 'custom-select-option';
- option.setAttribute('data-value', category);
- option.textContent = category;
- option.onclick = function() {
- selectKnowledgeCategory(category);
- };
- filterDropdown.appendChild(option);
- });
- }
-
- return knowledgeCategories;
- } catch (error) {
- console.error('加载分类失败:', error);
- // 只在非功能未启用的情况下显示错误
- if (!error.message.includes('知识库功能未启用')) {
- showNotification('加载分类失败: ' + error.message, 'error');
- }
- return [];
- }
-}
-
-// 加载知识项列表（支持按分类分页，默认不加载完整内容）
-async function loadKnowledgeItems(category = '', page = 1, pageSize = 10) {
- try {
- // 更新分页状态
- knowledgePagination.currentCategory = category;
- knowledgePagination.currentPage = page;
- knowledgePagination.pageSize = pageSize;
-
- // 构建URL（按分类分页模式，不包含完整内容）
- const timestamp = Date.now();
- const offset = (page - 1) * pageSize;
- let url = `/api/knowledge/items?categoryPage=true&limit=${pageSize}&offset=${offset}&_t=${timestamp}`;
- if (category) {
- url += `&category=${encodeURIComponent(category)}`;
- }
-
- const response = await apiFetch(url, {
- method: 'GET',
- headers: {
- 'Cache-Control': 'no-cache, no-store, must-revalidate',
- 'Pragma': 'no-cache',
- 'Expires': '0'
- }
- });
-
- if (!response.ok) {
- throw new Error('获取知识项失败');
- }
- const data = await response.json();
-
- // 检查知识库功能是否启用
- if (data.enabled === false) {
- // 功能未启用，显示友好提示（如果还没有显示的话）
- const container = document.getElementById('knowledge-items-list');
- if (container && !container.querySelector('.empty-state')) {
- container.innerHTML = `
-
-
📚
-
知识库功能未启用
-
${data.message || '请前往系统设置启用知识检索功能'}
-
-
暂无知识项
';
- return;
- }
-
- // 计算总项数和分类数
- const totalItems = categoriesWithItems.reduce((sum, cat) => sum + (cat.items?.length || 0), 0);
- const categoryCount = categoriesWithItems.length;
-
- // 更新统计信息
- updateKnowledgeStats(categoriesWithItems, categoryCount);
-
- // 渲染分类及知识项
- let html = '';
-
- categoriesWithItems.forEach(categoryData => {
- const category = categoryData.category || '未分类';
- const categoryItems = categoryData.items || [];
- const categoryCount = categoryData.itemCount || categoryItems.length;
-
- html += `
-
-
-
- ${categoryItems.map(item => renderKnowledgeItemCard(item)).join('')}
-
-
- `;
- });
-
- html += '
暂无知识项
';
- return;
- }
-
- // 按分类分组
- const groupedByCategory = {};
- items.forEach(item => {
- const category = item.category || '未分类';
- if (!groupedByCategory[category]) {
- groupedByCategory[category] = [];
- }
- groupedByCategory[category].push(item);
- });
-
- // 更新统计信息
- updateKnowledgeStats(items, Object.keys(groupedByCategory).length);
-
- // 渲染分组后的内容
- const categories = Object.keys(groupedByCategory).sort();
- let html = '';
-
- categories.forEach(category => {
- const categoryItems = groupedByCategory[category];
- const categoryCount = categoryItems.length;
-
- html += `
-
-
-
- ${categoryItems.map(item => renderKnowledgeItemCard(item)).join('')}
-
-
- `;
- });
-
- html += '
-
- ${previewText ? `
-
-
${escapeHtml(previewText)}
-
- ` : ''}
-
-
- 总分类数
- ${totalCategories}
-
-
- 当前页分类
- ${categoryCount} 个
-
-
- 当前页知识项
- ${currentPageItemCount} 项
-
- `;
-
- // 更新索引进度
- updateIndexProgress();
-}
-
-// 更新索引进度
-let indexProgressInterval = null;
-
-async function updateIndexProgress() {
- try {
- const response = await apiFetch('/api/knowledge/index-status', {
- method: 'GET',
- headers: {
- 'Cache-Control': 'no-cache, no-store, must-revalidate',
- 'Pragma': 'no-cache',
- 'Expires': '0'
- }
- });
-
- if (!response.ok) {
- return; // 静默失败，不影响主界面
- }
-
- const status = await response.json();
- const progressContainer = document.getElementById('knowledge-index-progress');
- if (!progressContainer) return;
-
- // 检查知识库功能是否启用
- if (status.enabled === false) {
- // 功能未启用，隐藏进度条
- progressContainer.style.display = 'none';
- if (indexProgressInterval) {
- clearInterval(indexProgressInterval);
- indexProgressInterval = null;
- }
- return;
- }
-
- const totalItems = status.total_items || 0;
- const indexedItems = status.indexed_items || 0;
- const progressPercent = status.progress_percent || 0;
- const isComplete = status.is_complete || false;
- const lastError = status.last_error || '';
-
- if (totalItems === 0) {
- // 没有知识项，隐藏进度条
- progressContainer.style.display = 'none';
- if (indexProgressInterval) {
- clearInterval(indexProgressInterval);
- indexProgressInterval = null;
- }
- return;
- }
-
- // 显示进度条
- progressContainer.style.display = 'block';
-
- // 如果有错误信息，显示错误
- if (lastError) {
- progressContainer.innerHTML = `
-
-
- ❌
- 索引构建失败
-
-
- ${escapeHtml(lastError)}
-
-
- 可能的原因：嵌入模型配置错误、API密钥无效、余额不足等。请检查配置后重试。
-
-
-
-
-
-
- ✅
- 索引构建完成 (${indexedItems}/${totalItems})
-
- `;
- // 完成后停止轮询
- if (indexProgressInterval) {
- clearInterval(indexProgressInterval);
- indexProgressInterval = null;
- }
- } else {
- progressContainer.innerHTML = `
-
-
-
-
索引构建完成后，语义搜索功能将可用
-
-
- ⚠️
- 无法获取索引状态
-
-
- 无法连接到服务器获取索引状态，请检查网络连接或刷新页面。
-
-
-
📚
-
知识库功能未启用
-
${data.message || '请前往系统设置启用知识检索功能'}
-
-
-
🔍
-
未找到匹配的知识项
-
关键词 "${escapeHtml(searchTerm)}" 在所有数据中没有匹配结果
-
请尝试其他关键词，或使用分类筛选功能
-
-
-
-
索引构建完成后，语义搜索功能将可用
-
刷新中...
';
- }
-
- try {
- // 先刷新分类，再刷新知识项
- console.log('开始刷新知识库数据...');
- await loadKnowledgeCategories();
- console.log('分类刷新完成，开始刷新知识项...');
-
- // 如果新添加的知识项不在当前筛选的分类中，切换到该分类显示
- let categoryToShow = selectedCategory;
- if (!currentEditingItemId && selectedCategory && selectedCategory !== '' && newItemCategory !== selectedCategory) {
- // 新添加的知识项，如果当前筛选的不是该分类，切换到新知识项的分类
- categoryToShow = newItemCategory;
- // 更新筛选器显示（不触发加载，因为我们下面会手动加载）
- const trigger = document.getElementById('knowledge-category-filter-trigger');
- const wrapper = document.getElementById('knowledge-category-filter-wrapper');
- const dropdown = document.getElementById('knowledge-category-filter-dropdown');
- if (trigger && wrapper && dropdown) {
- trigger.querySelector('span').textContent = newItemCategory || '全部';
- dropdown.querySelectorAll('.custom-select-option').forEach(opt => {
- opt.classList.remove('selected');
- if (opt.getAttribute('data-value') === newItemCategory) {
- opt.classList.add('selected');
- }
- });
- }
- showNotification(`✅ ${action}成功！已切换到分类"${newItemCategory}"查看新添加的知识项。`, 'success');
- }
-
- // 刷新知识项列表（重置到第一页）
- await loadKnowledgeItems(categoryToShow, 1, knowledgePagination.pageSize);
- console.log('知识项刷新完成');
- } catch (err) {
- console.error('刷新数据失败:', err);
- // 如果刷新失败，恢复原内容
- if (itemsListContainer && originalContent) {
- itemsListContainer.innerHTML = originalContent;
- }
- showNotification('⚠️ 知识项已保存，但刷新列表失败，请手动刷新页面查看', 'warning');
- }
-
- } catch (error) {
- console.error('保存知识项失败:', error);
- showNotification('❌ 保存知识项失败: ' + error.message, 'error');
-
- // 如果通知系统不可用，使用alert
- if (typeof window.showNotification !== 'function') {
- alert('❌ 保存知识项失败: ' + error.message);
- }
-
- // 恢复输入字段和按钮状态（错误时不关闭模态框，让用户修改后重试）
- if (categoryInput) categoryInput.disabled = false;
- if (titleInput) titleInput.disabled = false;
- if (contentInput) contentInput.disabled = false;
- if (cancelButton) cancelButton.disabled = false;
- if (saveButton) {
- saveButton.disabled = false;
- saveButton.style.opacity = '';
- saveButton.style.cursor = '';
- saveButton.textContent = originalButtonText;
- }
- } finally {
- // 清除保存中标志
- isSavingKnowledgeItem = false;
- }
-}
-
-// 删除知识项
-async function deleteKnowledgeItem(id) {
- if (!confirm('确定要删除这个知识项吗？')) {
- return;
- }
-
- // 找到要删除的知识项卡片和删除按钮
- const itemCard = document.querySelector(`.knowledge-item-card[data-id="${id}"]`);
- const deleteButton = itemCard ? itemCard.querySelector('.knowledge-item-delete-btn') : null;
- const categorySection = itemCard ? itemCard.closest('.knowledge-category-section') : null;
- let originalDisplay = '';
- let originalOpacity = '';
- let originalButtonOpacity = '';
-
- // 设置删除按钮的加载状态
- if (deleteButton) {
- originalButtonOpacity = deleteButton.style.opacity;
- deleteButton.style.opacity = '0.5';
- deleteButton.style.cursor = 'not-allowed';
- deleteButton.disabled = true;
-
- // 添加加载动画
- const svg = deleteButton.querySelector('svg');
- if (svg) {
- svg.style.animation = 'spin 1s linear infinite';
- }
- }
-
- // 立即从UI中移除该项（乐观更新）
- if (itemCard) {
- originalDisplay = itemCard.style.display;
- originalOpacity = itemCard.style.opacity;
- itemCard.style.transition = 'opacity 0.3s ease-out, transform 0.3s ease-out';
- itemCard.style.opacity = '0';
- itemCard.style.transform = 'translateX(-20px)';
-
- // 等待动画完成后移除
- setTimeout(() => {
- if (itemCard.parentElement) {
- itemCard.remove();
-
- // 检查分类是否还有项目，如果没有则隐藏分类标题
- if (categorySection) {
- const remainingItems = categorySection.querySelectorAll('.knowledge-item-card');
- if (remainingItems.length === 0) {
- categorySection.style.transition = 'opacity 0.3s ease-out';
- categorySection.style.opacity = '0';
- setTimeout(() => {
- if (categorySection.parentElement) {
- categorySection.remove();
- }
- }, 300);
- } else {
- // 更新分类计数
- const categoryCount = categorySection.querySelector('.knowledge-category-count');
- if (categoryCount) {
- const newCount = remainingItems.length;
- categoryCount.textContent = `${newCount} 项`;
- }
- }
- }
-
- // 不在这里更新统计信息，等待重新加载数据后由正确的逻辑更新
- }
- }, 300);
- }
-
- try {
- const response = await apiFetch(`/api/knowledge/items/${id}`, {
- method: 'DELETE'
- });
-
- if (!response.ok) {
- const errorData = await response.json().catch(() => ({}));
- throw new Error(errorData.error || '删除知识项失败');
- }
-
- // 显示成功通知
- showNotification('✅ 删除成功！知识项已从系统中移除。', 'success');
-
- // 重新加载数据以确保数据同步（保持当前页码）
- await loadKnowledgeCategories();
- await loadKnowledgeItems(knowledgePagination.currentCategory, knowledgePagination.currentPage, knowledgePagination.pageSize);
-
- } catch (error) {
- console.error('删除知识项失败:', error);
-
- // 如果删除失败，恢复该项显示
- if (itemCard && originalDisplay !== 'none') {
- itemCard.style.display = originalDisplay || '';
- itemCard.style.opacity = originalOpacity || '1';
- itemCard.style.transform = '';
- itemCard.style.transition = '';
-
- // 如果分类被移除了，需要恢复
- if (categorySection && !categorySection.parentElement) {
- // 需要重新加载来恢复（保持当前分页状态）
- await loadKnowledgeItems(knowledgePagination.currentCategory, knowledgePagination.currentPage, knowledgePagination.pageSize);
- }
- }
-
- // 恢复删除按钮状态
- if (deleteButton) {
- deleteButton.style.opacity = originalButtonOpacity || '';
- deleteButton.style.cursor = '';
- deleteButton.disabled = false;
- const svg = deleteButton.querySelector('svg');
- if (svg) {
- svg.style.animation = '';
- }
- }
-
- showNotification('❌ 删除知识项失败: ' + error.message, 'error');
- }
-}
-
-// 临时更新统计信息（删除后）
-function updateKnowledgeStatsAfterDelete() {
- const statsContainer = document.getElementById('knowledge-stats');
- if (!statsContainer) return;
-
- const allItems = document.querySelectorAll('.knowledge-item-card');
- const allCategories = document.querySelectorAll('.knowledge-category-section');
-
- const totalItems = allItems.length;
- const categoryCount = allCategories.length;
-
- // 计算总内容大小（这里简化处理，实际应该从服务器获取）
- const statsItems = statsContainer.querySelectorAll('.knowledge-stat-item');
- if (statsItems.length >= 2) {
- const totalItemsSpan = statsItems[0].querySelector('.knowledge-stat-value');
- const categoryCountSpan = statsItems[1].querySelector('.knowledge-stat-value');
-
- if (totalItemsSpan) {
- totalItemsSpan.textContent = totalItems;
- }
- if (categoryCountSpan) {
- categoryCountSpan.textContent = categoryCount;
- }
- }
-}
-
-// 关闭知识项模态框
-function closeKnowledgeItemModal() {
- const modal = document.getElementById('knowledge-item-modal');
- if (modal) {
- modal.style.display = 'none';
- }
-
- // 重置编辑状态
- currentEditingItemId = null;
- isSavingKnowledgeItem = false;
-
- // 恢复所有输入字段和按钮状态
- const categoryInput = document.getElementById('knowledge-item-category');
- const titleInput = document.getElementById('knowledge-item-title');
- const contentInput = document.getElementById('knowledge-item-content');
- const saveButton = document.querySelector('#knowledge-item-modal .modal-footer .btn-primary');
- const cancelButton = document.querySelector('#knowledge-item-modal .modal-footer .btn-secondary');
-
- if (categoryInput) {
- categoryInput.disabled = false;
- categoryInput.value = '';
- }
- if (titleInput) {
- titleInput.disabled = false;
- titleInput.value = '';
- }
- if (contentInput) {
- contentInput.disabled = false;
- contentInput.value = '';
- }
- if (saveButton) {
- saveButton.disabled = false;
- saveButton.style.opacity = '';
- saveButton.style.cursor = '';
- saveButton.textContent = '保存';
- }
- if (cancelButton) {
- cancelButton.disabled = false;
- }
-}
-
-// 加载检索日志
-async function loadRetrievalLogs(conversationId = '', messageId = '') {
- try {
- let url = '/api/knowledge/retrieval-logs?limit=100';
- if (conversationId) {
- url += `&conversationId=${encodeURIComponent(conversationId)}`;
- }
- if (messageId) {
- url += `&messageId=${encodeURIComponent(messageId)}`;
- }
-
- const response = await apiFetch(url);
- if (!response.ok) {
- throw new Error('获取检索日志失败');
- }
- const data = await response.json();
- renderRetrievalLogs(data.logs || []);
- } catch (error) {
- console.error('加载检索日志失败:', error);
- // 即使加载失败，也显示空状态而不是一直显示"加载中..."
- renderRetrievalLogs([]);
- // 只在非空筛选条件下才显示错误通知（避免在没有数据时显示错误）
- if (conversationId || messageId) {
- showNotification('加载检索日志失败: ' + error.message, 'error');
- }
- }
-}
-
-// 渲染检索日志
-function renderRetrievalLogs(logs) {
- const container = document.getElementById('retrieval-logs-list');
- if (!container) return;
-
- // 更新统计信息（即使为空数组也要更新）
- updateRetrievalStats(logs);
-
- if (logs.length === 0) {
- container.innerHTML = '暂无检索记录
';
- retrievalLogsData = [];
- return;
- }
-
- // 保存日志数据供详情查看使用
- retrievalLogsData = logs;
-
- container.innerHTML = logs.map((log, index) => {
- // 处理retrievedItems：可能是数组、字符串数组，或者特殊标记
- let itemCount = 0;
- let hasResults = false;
-
- if (log.retrievedItems) {
- if (Array.isArray(log.retrievedItems)) {
- // 过滤掉特殊标记
- const realItems = log.retrievedItems.filter(id => id !== '_has_results');
- itemCount = realItems.length;
- // 如果有特殊标记，表示有结果但ID未知，显示为"有结果"
- if (log.retrievedItems.includes('_has_results')) {
- hasResults = true;
- // 如果有真实ID，使用真实数量；否则显示为"有结果"（不显示具体数量）
- if (itemCount === 0) {
- itemCount = -1; // -1 表示有结果但数量未知
- }
- } else {
- hasResults = itemCount > 0;
- }
- } else if (typeof log.retrievedItems === 'string') {
- // 如果是字符串，尝试解析JSON
- try {
- const parsed = JSON.parse(log.retrievedItems);
- if (Array.isArray(parsed)) {
- const realItems = parsed.filter(id => id !== '_has_results');
- itemCount = realItems.length;
- if (parsed.includes('_has_results')) {
- hasResults = true;
- if (itemCount === 0) {
- itemCount = -1;
- }
- } else {
- hasResults = itemCount > 0;
- }
- }
- } catch (e) {
- // 解析失败，忽略
- }
- }
- }
-
- const timeAgo = getTimeAgo(log.createdAt);
-
- return `
-
-
-
-
- ${log.conversationId ? `
-
- 对话ID
- ${escapeHtml(log.conversationId)}
-
- ` : ''}
- ${log.messageId ? `
-
- 消息ID
- ${escapeHtml(log.messageId)}
-
- ` : ''}
-
- 检索结果
-
- ${hasResults ? (itemCount > 0 ? `找到 ${itemCount} 个相关知识项` : '找到相关知识项（数量未知）') : '未找到匹配的知识项'}
-
-
-
- ${hasResults && log.retrievedItems && log.retrievedItems.length > 0 ? `
-
-
检索到的知识项:
-
- ${log.retrievedItems.slice(0, 3).map((itemId, idx) => `
- ${idx + 1}
- `).join('')}
- ${log.retrievedItems.length > 3 ? `+${log.retrievedItems.length - 3}` : ''}
-
-
- ` : ''}
-
-
-
-
-
-
- 总检索次数
- ${totalLogs}
-
-
- 成功检索
- ${successfulLogs}
-
-
- 成功率
- ${successRate}%
-
-
- 检索到知识项
- ${totalItems}
-
- `;
-}
-
-// 获取相对时间
-function getTimeAgo(timeStr) {
- if (!timeStr) return '';
-
- // 处理时间字符串，支持多种格式
- let date;
- if (typeof timeStr === 'string') {
- // 首先尝试直接解析（支持RFC3339/ISO8601格式）
- date = new Date(timeStr);
-
- // 如果解析失败，尝试其他格式
- if (isNaN(date.getTime())) {
- // SQLite格式: "2006-01-02 15:04:05" 或带时区
- const sqliteMatch = timeStr.match(/(\d{4}-\d{2}-\d{2}[\sT]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[+-]\d{2}:\d{2}|Z)?)/);
- if (sqliteMatch) {
- let timeStr2 = sqliteMatch[1].replace(' ', 'T');
- // 如果没有时区信息，添加Z表示UTC
- if (!timeStr2.includes('Z') && !timeStr2.match(/[+-]\d{2}:\d{2}$/)) {
- timeStr2 += 'Z';
- }
- date = new Date(timeStr2);
- }
- }
-
- // 如果还是失败，尝试更宽松的格式
- if (isNaN(date.getTime())) {
- // 尝试匹配 "YYYY-MM-DD HH:MM:SS" 格式
- const match = timeStr.match(/(\d{4})-(\d{2})-(\d{2})[\sT](\d{2}):(\d{2}):(\d{2})/);
- if (match) {
- date = new Date(
- parseInt(match[1]),
- parseInt(match[2]) - 1,
- parseInt(match[3]),
- parseInt(match[4]),
- parseInt(match[5]),
- parseInt(match[6])
- );
- }
- }
- } else {
- date = new Date(timeStr);
- }
-
- // 检查日期是否有效
- if (isNaN(date.getTime())) {
- return formatTime(timeStr);
- }
-
- // 检查日期是否合理（不在1970年之前，不在未来太远）
- const year = date.getFullYear();
- if (year < 1970 || year > 2100) {
- return formatTime(timeStr);
- }
-
- const now = new Date();
- const diff = now - date;
-
- // 如果时间差为负数或过大（可能是解析错误），返回格式化时间
- if (diff < 0 || diff > 365 * 24 * 60 * 60 * 1000 * 10) { // 超过10年认为是错误
- return formatTime(timeStr);
- }
-
- const seconds = Math.floor(diff / 1000);
- const minutes = Math.floor(seconds / 60);
- const hours = Math.floor(minutes / 60);
- const days = Math.floor(hours / 24);
-
- if (days > 0) return `${days}天前`;
- if (hours > 0) return `${hours}小时前`;
- if (minutes > 0) return `${minutes}分钟前`;
- return '刚刚';
-}
-
-// 截断ID显示
-function truncateId(id) {
- if (!id || id.length <= 16) return id;
- return id.substring(0, 8) + '...' + id.substring(id.length - 8);
-}
-
-// 筛选检索日志
-function filterRetrievalLogs() {
- const conversationId = document.getElementById('retrieval-logs-conversation-id').value.trim();
- const messageId = document.getElementById('retrieval-logs-message-id').value.trim();
- loadRetrievalLogs(conversationId, messageId);
-}
-
-// 刷新检索日志
-function refreshRetrievalLogs() {
- filterRetrievalLogs();
-}
-
-// 删除检索日志
-async function deleteRetrievalLog(id, index) {
- if (!confirm('确定要删除这条检索记录吗？')) {
- return;
- }
-
- // 找到要删除的日志卡片和删除按钮
- const logCard = document.querySelector(`.retrieval-log-card[data-index="${index}"]`);
- const deleteButton = logCard ? logCard.querySelector('.retrieval-log-delete-btn') : null;
- let originalButtonOpacity = '';
- let originalButtonDisabled = false;
-
- // 设置删除按钮的加载状态
- if (deleteButton) {
- originalButtonOpacity = deleteButton.style.opacity;
- originalButtonDisabled = deleteButton.disabled;
- deleteButton.style.opacity = '0.5';
- deleteButton.style.cursor = 'not-allowed';
- deleteButton.disabled = true;
-
- // 添加加载动画
- const svg = deleteButton.querySelector('svg');
- if (svg) {
- svg.style.animation = 'spin 1s linear infinite';
- }
- }
-
- // 立即从UI中移除该项（乐观更新）
- if (logCard) {
- logCard.style.transition = 'opacity 0.3s ease-out, transform 0.3s ease-out';
- logCard.style.opacity = '0';
- logCard.style.transform = 'translateX(-20px)';
-
- // 等待动画完成后移除
- setTimeout(() => {
- if (logCard.parentElement) {
- logCard.remove();
-
- // 更新统计信息（临时更新，稍后会重新加载）
- updateRetrievalStatsAfterDelete();
- }
- }, 300);
- }
-
- try {
- const response = await apiFetch(`/api/knowledge/retrieval-logs/${id}`, {
- method: 'DELETE'
- });
-
- if (!response.ok) {
- const errorData = await response.json().catch(() => ({}));
- throw new Error(errorData.error || '删除检索日志失败');
- }
-
- // 显示成功通知
- showNotification('✅ 删除成功！检索记录已从系统中移除。', 'success');
-
- // 从内存中移除该项
- if (retrievalLogsData && index >= 0 && index < retrievalLogsData.length) {
- retrievalLogsData.splice(index, 1);
- }
-
- // 重新加载数据以确保数据同步
- const conversationId = document.getElementById('retrieval-logs-conversation-id')?.value.trim() || '';
- const messageId = document.getElementById('retrieval-logs-message-id')?.value.trim() || '';
- await loadRetrievalLogs(conversationId, messageId);
-
- } catch (error) {
- console.error('删除检索日志失败:', error);
-
- // 如果删除失败，恢复该项显示
- if (logCard) {
- logCard.style.opacity = '1';
- logCard.style.transform = '';
- logCard.style.transition = '';
- }
-
- // 恢复删除按钮状态
- if (deleteButton) {
- deleteButton.style.opacity = originalButtonOpacity || '';
- deleteButton.style.cursor = '';
- deleteButton.disabled = originalButtonDisabled;
- const svg = deleteButton.querySelector('svg');
- if (svg) {
- svg.style.animation = '';
- }
- }
-
- showNotification('❌ 删除检索日志失败: ' + error.message, 'error');
- }
-}
-
-// 临时更新统计信息（删除后）
-function updateRetrievalStatsAfterDelete() {
- const statsContainer = document.getElementById('retrieval-stats');
- if (!statsContainer) return;
-
- const allLogs = document.querySelectorAll('.retrieval-log-card');
- const totalLogs = allLogs.length;
-
- // 计算成功检索数
- const successfulLogs = Array.from(allLogs).filter(card => {
- return card.classList.contains('has-results');
- }).length;
-
- // 计算总知识项数（简化处理，实际应该从服务器获取）
- const totalItems = Array.from(allLogs).reduce((sum, card) => {
- const badge = card.querySelector('.retrieval-log-result-badge');
- if (badge && badge.classList.contains('success')) {
- const text = badge.textContent.trim();
- const match = text.match(/(\d+)\s*项/);
- if (match) {
- return sum + parseInt(match[1]);
- } else if (text === '有结果') {
- return sum + 1; // 简化处理，假设为1
- }
- }
- return sum;
- }, 0);
-
- const successRate = totalLogs > 0 ? ((successfulLogs / totalLogs) * 100).toFixed(1) : 0;
-
- statsContainer.innerHTML = `
-
- 总检索次数
- ${totalLogs}
-
-
- 成功检索
- ${successfulLogs}
-
-
- 成功率
- ${successRate}%
-
-
- 检索到知识项
- ${totalItems}
-
- `;
-}
-
-// 显示检索日志详情
-async function showRetrievalLogDetails(index) {
- if (!retrievalLogsData || index < 0 || index >= retrievalLogsData.length) {
- showNotification('无法获取检索详情', 'error');
- return;
- }
-
- const log = retrievalLogsData[index];
-
- // 获取检索到的知识项详情
- let retrievedItemsDetails = [];
- if (log.retrievedItems && Array.isArray(log.retrievedItems)) {
- const realItemIds = log.retrievedItems.filter(id => id !== '_has_results');
- if (realItemIds.length > 0) {
- try {
- // 批量获取知识项详情
- const itemPromises = realItemIds.map(async (itemId) => {
- try {
- const response = await apiFetch(`/api/knowledge/items/${itemId}`);
- if (response.ok) {
- return await response.json();
- }
- return null;
- } catch (err) {
- console.error(`获取知识项 ${itemId} 失败:`, err);
- return null;
- }
- });
-
- const items = await Promise.all(itemPromises);
- retrievedItemsDetails = items.filter(item => item !== null);
- } catch (err) {
- console.error('批量获取知识项详情失败:', err);
- }
- }
- }
-
- // 显示详情模态框
- showRetrievalLogDetailsModal(log, retrievedItemsDetails);
-}
-
-// 显示检索日志详情模态框
-function showRetrievalLogDetailsModal(log, retrievedItems) {
- // 创建或获取模态框
- let modal = document.getElementById('retrieval-log-details-modal');
- if (!modal) {
- modal = document.createElement('div');
- modal.id = 'retrieval-log-details-modal';
- modal.className = 'modal';
- modal.innerHTML = `
-
- `;
- document.body.appendChild(modal);
- }
-
- // 填充内容
- const content = document.getElementById('retrieval-log-details-content');
- const timeAgo = getTimeAgo(log.createdAt);
- const fullTime = formatTime(log.createdAt);
-
- let itemsHtml = '';
- if (retrievedItems.length > 0) {
- itemsHtml = retrievedItems.map((item, idx) => {
- // 提取内容预览
- let preview = item.content || '';
- preview = preview.replace(/^#+\s+/gm, '');
- preview = preview.replace(/```[\s\S]*?```/g, '');
- preview = preview.replace(/`[^`]+`/g, '');
- preview = preview.replace(/\[([^\]]+)\]\([^\)]+\)/g, '$1');
- preview = preview.replace(/\n+/g, ' ').replace(/\s+/g, ' ').trim();
- const previewText = preview.length > 200 ? preview.substring(0, 200) + '...' : preview;
-
- return `
-
-
-
${idx + 1}. ${escapeHtml(item.title || '未命名')}
- ${escapeHtml(item.category || '未分类')}
-
- ${item.filePath ? `
📁 ${escapeHtml(item.filePath)}
` : ''}
-
- ${escapeHtml(previewText || '无内容预览')}
-
-
未找到知识项详情
';
- }
-
- content.innerHTML = `
-
-
-
查询信息
-
-
查询内容:
-
${escapeHtml(log.query || '无查询内容')}
-
-
-
-
-
检索信息
-
- ${log.riskType ? `
-
-
风险类型
-
${escapeHtml(log.riskType)}
-
- ` : ''}
-
-
-
检索结果
-
${retrievedItems.length} 个知识项
-
-
-
-
- ${log.conversationId || log.messageId ? `
-
-
关联信息
-
- ${log.conversationId ? `
-
-
对话ID
-
${escapeHtml(log.conversationId)}
-
- ` : ''}
- ${log.messageId ? `
-
-
消息ID
-
${escapeHtml(log.messageId)}
-
- ` : ''}
-
-
- ` : ''}
-
-
-
检索到的知识项 (${retrievedItems.length})
- ${itemsHtml}
-
-