735 lines
22 KiB
JavaScript
735 lines
22 KiB
JavaScript
const API_BASE = '/api/v1/knowledge'
|
||
|
||
// 用户认证信息（实际应用中应该从登录获取）
|
||
const USER_ID = 'user1'
|
||
const USER_NAME = '42tr'
|
||
const ROLE = 'admin'
|
||
|
||
const getHeaders = (contentType = true) => {
|
||
const headers = {
|
||
'x-user-id': USER_ID,
|
||
'x-user-name': USER_NAME,
|
||
'x-role': ROLE,
|
||
}
|
||
if (contentType) {
|
||
headers['Content-Type'] = 'application/json'
|
||
}
|
||
return headers
|
||
}
|
||
|
||
const readErrorMessage = async (response, fallback) => {
|
||
try {
|
||
const payload = await response.json()
|
||
if (payload?.error) return payload.error
|
||
if (payload?.message) return payload.message
|
||
} catch (_) {
|
||
// ignore json parse error
|
||
}
|
||
return fallback
|
||
}
|
||
|
||
export const api = {
|
||
// 搜索
|
||
async search(query, kbId = null, fileId = null, options = {}) {
|
||
const { advanced = false } = options
|
||
let url = `${API_BASE}/search/?query=${encodeURIComponent(query)}`
|
||
if (kbId) {
|
||
url += `&kb_id=${kbId}`
|
||
}
|
||
if (fileId) {
|
||
url += `&file_id=${fileId}`
|
||
}
|
||
if (advanced) {
|
||
url += '&advanced=true'
|
||
}
|
||
const response = await fetch(url, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('搜索失败')
|
||
const data = await response.json()
|
||
return data.results || []
|
||
},
|
||
|
||
advancedSearchStream(params, handlers = {}) {
|
||
const {
|
||
query,
|
||
kbId = null,
|
||
fileId = null,
|
||
maxSubQueries = 3,
|
||
perQueryLimit = 10,
|
||
contextChars = 2000,
|
||
debug = false,
|
||
} = params
|
||
|
||
const searchParams = new URLSearchParams()
|
||
searchParams.set('query', query)
|
||
searchParams.set('max_sub_queries', maxSubQueries)
|
||
searchParams.set('per_query_limit', perQueryLimit)
|
||
searchParams.set('context_chars', contextChars)
|
||
if (debug) searchParams.set('debug', 'true')
|
||
if (kbId) searchParams.set('kb_id', kbId)
|
||
if (fileId) searchParams.set('file_id', fileId)
|
||
|
||
const controller = new AbortController()
|
||
const url = `${API_BASE}/search/advanced/stream?${searchParams.toString()}`
|
||
const headers = getHeaders(false)
|
||
const decoder = new TextDecoder('utf-8')
|
||
|
||
const parseEvent = (chunk) => {
|
||
const lines = chunk.split('\n')
|
||
let eventType = 'message'
|
||
let dataLines = []
|
||
for (const line of lines) {
|
||
const trimmed = line.trim()
|
||
if (trimmed.startsWith('event:')) {
|
||
eventType = trimmed.slice(6).trim()
|
||
} else if (trimmed.startsWith('data:')) {
|
||
dataLines.push(trimmed.slice(5).trim())
|
||
}
|
||
}
|
||
const dataStr = dataLines.join('\n')
|
||
let parsedData = null
|
||
if (dataStr) {
|
||
try {
|
||
parsedData = JSON.parse(dataStr)
|
||
} catch (err) {
|
||
parsedData = dataStr
|
||
}
|
||
}
|
||
return { eventType, data: parsedData }
|
||
}
|
||
|
||
const streamPromise = (async () => {
|
||
try {
|
||
const response = await fetch(url, {
|
||
headers,
|
||
signal: controller.signal,
|
||
})
|
||
if (!response.ok) {
|
||
throw new Error('高级搜索连接失败')
|
||
}
|
||
const reader = response.body.getReader()
|
||
let buffer = ''
|
||
while (true) {
|
||
const { value, done } = await reader.read()
|
||
if (done) break
|
||
buffer += decoder.decode(value, { stream: true })
|
||
let boundary
|
||
while ((boundary = buffer.indexOf('\n\n')) !== -1) {
|
||
const rawEvent = buffer.slice(0, boundary).trim()
|
||
buffer = buffer.slice(boundary + 2)
|
||
if (!rawEvent) continue
|
||
const { eventType, data } = parseEvent(rawEvent)
|
||
switch (eventType) {
|
||
case 'status':
|
||
handlers.onStatus?.(data)
|
||
break
|
||
case 'plan':
|
||
handlers.onPlan?.(data)
|
||
break
|
||
case 'step':
|
||
handlers.onStep?.(data)
|
||
break
|
||
case 'candidate':
|
||
handlers.onCandidate?.(data)
|
||
break
|
||
case 'filtered':
|
||
handlers.onFiltered?.(data)
|
||
break
|
||
case 'result':
|
||
handlers.onResult?.(data)
|
||
break
|
||
case 'error':
|
||
handlers.onErrorEvent?.(data)
|
||
break
|
||
case 'done':
|
||
handlers.onDone?.()
|
||
break
|
||
default:
|
||
handlers.onMessage?.({ eventType, data })
|
||
}
|
||
}
|
||
}
|
||
handlers.onComplete?.()
|
||
} catch (err) {
|
||
if (controller.signal.aborted) {
|
||
handlers.onAbort?.()
|
||
} else {
|
||
handlers.onError?.(err)
|
||
}
|
||
} finally {
|
||
handlers.onFinally?.()
|
||
}
|
||
})()
|
||
|
||
return {
|
||
cancel: () => controller.abort(),
|
||
finished: streamPromise,
|
||
}
|
||
},
|
||
async searchFull(query, kbId = null, fileId = null) {
|
||
let url = `${API_BASE}/search/full?query=${encodeURIComponent(query)}`
|
||
if (kbId) {
|
||
url += `&kb_id=${kbId}`
|
||
}
|
||
if (fileId) {
|
||
url += `&file_id=${fileId}`
|
||
}
|
||
const response = await fetch(url, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('全文搜索失败')
|
||
const data = await response.json()
|
||
return data.results || []
|
||
},
|
||
async searchImage(file, text = '', kbId = null, fileId = null) {
|
||
const formData = new FormData()
|
||
formData.append('file', file)
|
||
formData.append('text', text)
|
||
let url = `${API_BASE}/search/image`
|
||
const params = []
|
||
if (kbId) {
|
||
params.push(`kb_id=${kbId}`)
|
||
}
|
||
if (fileId) {
|
||
params.push(`file_id=${fileId}`)
|
||
}
|
||
if (params.length > 0) {
|
||
url += `?${params.join('&')}`
|
||
}
|
||
const response = await fetch(url, {
|
||
method: 'POST',
|
||
headers: getHeaders(false),
|
||
body: formData,
|
||
})
|
||
if (!response.ok) throw new Error('图片搜索失败')
|
||
const data = await response.json()
|
||
return data.results || []
|
||
},
|
||
|
||
// 词表
|
||
async listLexicons(params = {}) {
|
||
const searchParams = new URLSearchParams()
|
||
if (params.q) searchParams.set('q', params.q)
|
||
if (params.enabled === true) searchParams.set('enabled', 'true')
|
||
if (params.enabled === false) searchParams.set('enabled', 'false')
|
||
if (params.limit) searchParams.set('limit', String(params.limit))
|
||
if (params.offset) searchParams.set('offset', String(params.offset))
|
||
const query = searchParams.toString()
|
||
const url = `${API_BASE}/search/lexicons${query ? `?${query}` : ''}`
|
||
const response = await fetch(url, { headers: getHeaders() })
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '获取词表失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async createLexicon(data) {
|
||
const response = await fetch(`${API_BASE}/search/lexicons`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify(data),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '创建词条失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async updateLexicon(id, data) {
|
||
const response = await fetch(`${API_BASE}/search/lexicons/${id}`, {
|
||
method: 'PUT',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify(data),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '更新词条失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async deleteLexicon(id) {
|
||
const response = await fetch(`${API_BASE}/search/lexicons/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '删除词条失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async toggleLexiconEnabled(id, enabled) {
|
||
const response = await fetch(`${API_BASE}/search/lexicons/${id}/enabled`, {
|
||
method: 'PUT',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify({ enabled }),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '更新词条状态失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async reloadLexicon() {
|
||
const response = await fetch(`${API_BASE}/search/lexicons/reload`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '重载词表失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async publishLexicon() {
|
||
const response = await fetch(`${API_BASE}/search/lexicons/publish`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '发布词表失败'))
|
||
return response.json()
|
||
},
|
||
|
||
// 同义词
|
||
async listSynonyms(params = {}) {
|
||
const searchParams = new URLSearchParams()
|
||
if (params.q) searchParams.set('q', params.q)
|
||
if (params.enabled === true) searchParams.set('enabled', 'true')
|
||
if (params.enabled === false) searchParams.set('enabled', 'false')
|
||
if (params.limit) searchParams.set('limit', String(params.limit))
|
||
if (params.offset) searchParams.set('offset', String(params.offset))
|
||
const query = searchParams.toString()
|
||
const url = `${API_BASE}/search/synonyms${query ? `?${query}` : ''}`
|
||
const response = await fetch(url, { headers: getHeaders() })
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '获取同义词失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async createSynonym(data) {
|
||
const response = await fetch(`${API_BASE}/search/synonyms`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify(data),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '创建同义词失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async updateSynonym(id, data) {
|
||
const response = await fetch(`${API_BASE}/search/synonyms/${id}`, {
|
||
method: 'PUT',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify(data),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '更新同义词失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async deleteSynonym(id) {
|
||
const response = await fetch(`${API_BASE}/search/synonyms/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '删除同义词失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async toggleSynonymEnabled(id, enabled) {
|
||
const response = await fetch(`${API_BASE}/search/synonyms/${id}/enabled`, {
|
||
method: 'PUT',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify({ enabled }),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '更新同义词状态失败'))
|
||
return response.json()
|
||
},
|
||
|
||
// 系统
|
||
async getIndexRebuildStatus() {
|
||
const response = await fetch(`${API_BASE}/system/index/rebuild/status`, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '获取重建状态失败'))
|
||
return response.json()
|
||
},
|
||
|
||
// 知识库
|
||
async getKnowledgeBases(parentId = null) {
|
||
let url = `${API_BASE}/knowledge_base/`;
|
||
const params = new URLSearchParams();
|
||
// A null parentId fetches top-level KBs by default on the backend.
|
||
if (parentId) {
|
||
params.append('parent_id', parentId);
|
||
}
|
||
const queryString = params.toString();
|
||
if (queryString) {
|
||
url += `?${queryString}`;
|
||
}
|
||
const response = await fetch(url, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('获取知识库列表失败')
|
||
return response.json()
|
||
},
|
||
|
||
async getKnowledgeBase(id) {
|
||
const response = await fetch(`${API_BASE}/knowledge_base/${id}`, {
|
||
headers: getHeaders(),
|
||
});
|
||
if (!response.ok) throw new Error('获取知识库详情失败');
|
||
return response.json();
|
||
},
|
||
|
||
async getKnowledgeBaseFiles(id, params = {}) {
|
||
const searchParams = new URLSearchParams()
|
||
if (params.page) searchParams.set('page', String(params.page))
|
||
if (params.size) searchParams.set('size', String(params.size))
|
||
if (params.filename) searchParams.set('filename', params.filename)
|
||
if (params.tag) searchParams.set('tag', params.tag)
|
||
const query = searchParams.toString()
|
||
const response = await fetch(
|
||
`${API_BASE}/knowledge_base/${id}/files${query ? `?${query}` : ''}`,
|
||
{ headers: getHeaders() }
|
||
)
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '获取知识库文件失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async createKnowledgeBase(data) { // data may include { name, description, parent_id }
|
||
const response = await fetch(`${API_BASE}/knowledge_base/`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify(data),
|
||
})
|
||
if (!response.ok) throw new Error('创建知识库失败')
|
||
return response.json()
|
||
},
|
||
|
||
async updateKnowledgeBase(id, data) { // data may include { name, description, parent_id, is_public }
|
||
const response = await fetch(`${API_BASE}/knowledge_base/${id}`, {
|
||
method: 'PUT',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify(data),
|
||
})
|
||
if (!response.ok) throw new Error('更新知识库失败')
|
||
return response.json()
|
||
},
|
||
|
||
async deleteKnowledgeBase(id) {
|
||
const response = await fetch(`${API_BASE}/knowledge_base/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('删除知识库失败')
|
||
return
|
||
},
|
||
|
||
async reparseKnowledgeBases() {
|
||
const response = await fetch(`${API_BASE}/knowledge_base/reparse`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '重新解析失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async reparseKnowledgeBase(id) {
|
||
const response = await fetch(`${API_BASE}/knowledge_base/${id}/reparse`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '重新解析指定知识库失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async exportKnowledgeBases(kbIds, includeChildren = false) {
|
||
const response = await fetch(`${API_BASE}/knowledge_base/export`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify({ kb_ids: kbIds, include_children: includeChildren }),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '导出知识库失败'))
|
||
return response.json()
|
||
},
|
||
|
||
// 知识库权限管理
|
||
async getKbPermissions(kbId) {
|
||
const response = await fetch(`${API_BASE}/knowledge_base/${kbId}/permissions`, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('获取权限列表失败')
|
||
return response.json()
|
||
},
|
||
|
||
async addKbPermission(kbId, userId, permission) {
|
||
const response = await fetch(`${API_BASE}/knowledge_base/${kbId}/permissions`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify({ user_id: userId, permission }),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '添加权限失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async removeKbPermission(kbId, userId) {
|
||
const response = await fetch(`${API_BASE}/knowledge_base/${kbId}/permissions/${userId}`, {
|
||
method: 'DELETE',
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '删除权限失败'))
|
||
return response.json()
|
||
},
|
||
|
||
// 文件
|
||
async uploadFiles(knowledgeBaseId, files, tags = [], isPublic = false, sliceType = 'smart') {
|
||
const formData = new FormData()
|
||
if (knowledgeBaseId) {
|
||
formData.append('kb_id', knowledgeBaseId)
|
||
}
|
||
if (tags.length > 0) {
|
||
formData.append('tags', JSON.stringify(tags))
|
||
}
|
||
formData.append('is_public', isPublic ? 'true' : 'false')
|
||
formData.append('slice_type', sliceType)
|
||
for (const file of files) {
|
||
formData.append('file', file)
|
||
}
|
||
|
||
const response = await fetch(`${API_BASE}/files/`, {
|
||
method: 'POST',
|
||
headers: getHeaders(false),
|
||
body: formData,
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '上传文件失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async deleteFile(id) {
|
||
const response = await fetch(`${API_BASE}/files/${id}`, {
|
||
method: 'DELETE',
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('删除文件失败')
|
||
return
|
||
},
|
||
|
||
async batchDeleteFiles(ids, options = {}) {
|
||
const {
|
||
strict = false,
|
||
allowProcessing = false,
|
||
} = options
|
||
|
||
const response = await fetch(`${API_BASE}/files/batch-delete`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify({
|
||
ids,
|
||
strict,
|
||
allow_processing: allowProcessing,
|
||
}),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '批量删除文件失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async getFiles(kbId, tag = null, pagination = {}) {
|
||
let url = `${API_BASE}/files/`
|
||
const params = []
|
||
if (kbId === null) {
|
||
// 明确传递null时，获取未分配知识库的文件
|
||
params.push('kb_id=null')
|
||
} else if (kbId !== undefined) {
|
||
// 传递具体的知识库ID
|
||
params.push(`kb_id=${kbId}`)
|
||
}
|
||
if (tag) {
|
||
params.push(`tag=${encodeURIComponent(tag)}`)
|
||
}
|
||
if (pagination.page) params.push(`page=${pagination.page}`)
|
||
if (pagination.size) params.push(`size=${pagination.size}`)
|
||
if (params.length > 0) {
|
||
url += `?${params.join('&')}`
|
||
}
|
||
const response = await fetch(url, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('获取文件列表失败')
|
||
return response.json()
|
||
},
|
||
|
||
async getFileStats(options = {}) {
|
||
const {
|
||
kbId = undefined,
|
||
includeDescendants = true,
|
||
includeUnassigned = true,
|
||
} = options
|
||
const params = new URLSearchParams()
|
||
if (kbId === null) {
|
||
params.append('kb_id', 'null')
|
||
} else if (kbId !== undefined) {
|
||
params.append('kb_id', kbId)
|
||
}
|
||
if (!includeDescendants) {
|
||
params.append('include_descendants', 'false')
|
||
}
|
||
if (!includeUnassigned) {
|
||
params.append('include_unassigned', 'false')
|
||
}
|
||
const query = params.toString()
|
||
const response = await fetch(
|
||
`${API_BASE}/files/stats${query ? `?${query}` : ''}`,
|
||
{ headers: getHeaders() }
|
||
)
|
||
if (!response.ok) throw new Error('获取文件状态统计失败')
|
||
return response.json()
|
||
},
|
||
|
||
async reparseFailedFiles(options = {}) {
|
||
const {
|
||
kbId = undefined,
|
||
includeDescendants = true,
|
||
includeUnassigned = true,
|
||
unassignedOnly = false,
|
||
} = options
|
||
|
||
const payload = {
|
||
include_descendants: includeDescendants,
|
||
include_unassigned: includeUnassigned,
|
||
unassigned_only: unassignedOnly,
|
||
}
|
||
if (kbId !== undefined) {
|
||
payload.kb_id = kbId ?? null
|
||
}
|
||
|
||
const response = await fetch(`${API_BASE}/files/reparse-failed`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify(payload),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '重新解析失败文件失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async getFile(id) {
|
||
const response = await fetch(`${API_BASE}/files/${id}`, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('获取文件失败')
|
||
return response.json()
|
||
},
|
||
|
||
async downloadFile(id) {
|
||
const response = await fetch(`${API_BASE}/files/${id}/download`, {
|
||
headers: getHeaders(false),
|
||
})
|
||
if (!response.ok) throw new Error('下载文件失败')
|
||
return response.blob()
|
||
},
|
||
|
||
async updateFile(id, data) {
|
||
const response = await fetch(`${API_BASE}/files/${id}`, {
|
||
method: 'PUT',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify(data),
|
||
})
|
||
if (!response.ok) throw new Error('更新文件失败')
|
||
return response.json()
|
||
},
|
||
|
||
async moveFile(id, targetKbId) {
|
||
const response = await fetch(`${API_BASE}/files/${id}/move`, {
|
||
method: 'PUT',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify({
|
||
target_kb_id: targetKbId ?? null,
|
||
}),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '移动文件失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async getFileSlices(fileId) {
|
||
const response = await fetch(`${API_BASE}/files/${fileId}/slices`, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('获取切片失败')
|
||
return response.json()
|
||
},
|
||
|
||
async updateSlices(fileId, slices) {
|
||
const response = await fetch(`${API_BASE}/files/${fileId}/slices`, {
|
||
method: 'PUT',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify({ slices }),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '更新切片失败'))
|
||
return response.json()
|
||
},
|
||
|
||
// 压缩文件
|
||
async getArchiveEntries(id) {
|
||
const response = await fetch(`${API_BASE}/files/${id}/archive-entries`, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('获取压缩文件列表失败')
|
||
return response.json()
|
||
},
|
||
|
||
async extractArchive(id, password = null) {
|
||
const response = await fetch(`${API_BASE}/files/${id}/archive-extract`, {
|
||
method: 'POST',
|
||
headers: getHeaders(),
|
||
body: JSON.stringify({ password }),
|
||
})
|
||
if (!response.ok) throw new Error(await readErrorMessage(response, '解压失败'))
|
||
return response.json()
|
||
},
|
||
|
||
async downloadArchiveEntry(id, path) {
|
||
const encodedPath = encodeURIComponent(path)
|
||
const response = await fetch(`${API_BASE}/files/${id}/archive-download?path=${encodedPath}`, {
|
||
headers: getHeaders(false),
|
||
})
|
||
if (!response.ok) throw new Error('下载文件失败')
|
||
return response.blob()
|
||
},
|
||
|
||
// 知识图谱
|
||
async searchEntities(query = null, entityType = null, kbId = null, limit = 100, fileId = null) {
|
||
let url = `${API_BASE}/graph/entities?limit=${limit}`
|
||
if (query) {
|
||
url += `&q=${encodeURIComponent(query)}`
|
||
}
|
||
if (entityType) {
|
||
url += `&entity_type=${encodeURIComponent(entityType)}`
|
||
}
|
||
if (kbId) {
|
||
url += `&kb_id=${kbId}`
|
||
}
|
||
if (fileId) {
|
||
url += `&file_id=${fileId}`
|
||
}
|
||
const response = await fetch(url, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('搜索实体失败')
|
||
return response.json()
|
||
},
|
||
|
||
async getEntity(id) {
|
||
const response = await fetch(`${API_BASE}/graph/entities/${id}`, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('获取实体详情失败')
|
||
return response.json()
|
||
},
|
||
|
||
async getGraphStats(kbId = null, fileId = null) {
|
||
let url = `${API_BASE}/graph/stats`
|
||
const params = []
|
||
if (kbId) {
|
||
params.push(`kb_id=${kbId}`)
|
||
}
|
||
if (fileId) {
|
||
params.push(`file_id=${fileId}`)
|
||
}
|
||
if (params.length > 0) {
|
||
url += '?' + params.join('&')
|
||
}
|
||
const response = await fetch(url, {
|
||
headers: getHeaders(),
|
||
})
|
||
if (!response.ok) throw new Error('获取图谱统计失败')
|
||
return response.json()
|
||
},
|
||
}
|