q792602257/DataMate
0
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

feat(knowledge): 添加知识条目文件上传和下载功能

Browse Source 
- 新增文件上传接口支持批量上传知识条目文件
- 实现文件存储路径管理和安全验证机制
- 添加文件下载功能支持知识条目文件导出
- 扩展知识内容类型枚举增加FILE类型
- 扩展知识来源类型枚举增加FILE_UPLOAD类型
- 新增上传请求DTO定义文件验证和元数据配置
- 实现文件上传目录管理和文件名安全处理
- 添加文件扩展名识别和内容类型转换逻辑
This commit is contained in:
Jerry Yan
2026-01-29 11:17:15 +08:00
parent 3c4b66b451
commit d0b5473068
10 changed files with 511 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
backend/services/data-management-service/src/main/java/com/datamate/datamanagement/application/KnowledgeItemApplicationService.java
View File

@@ -15,6 +15,7 @@ import com.datamate.datamanagement.domain.model.dataset.DatasetFile;
import com.datamate.datamanagement.domain.model.dataset.Tag;
import com.datamate.datamanagement.domain.model.knowledge.KnowledgeItem;
import com.datamate.datamanagement.domain.model.knowledge.KnowledgeSet;
import com.datamate.datamanagement.infrastructure.config.DataManagementProperties;
import com.datamate.datamanagement.infrastructure.exception.DataManagementErrorCode;
import com.datamate.datamanagement.infrastructure.persistence.mapper.TagMapper;
import com.datamate.datamanagement.infrastructure.persistence.repository.DatasetFileRepository;
@@ -27,6 +28,7 @@ import com.datamate.datamanagement.interfaces.dto.ImportKnowledgeItemsRequest;
import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPagingQuery;
import com.datamate.datamanagement.interfaces.dto.KnowledgeItemResponse;
import com.datamate.datamanagement.interfaces.dto.UpdateKnowledgeItemRequest;
import com.datamate.datamanagement.interfaces.dto.UploadKnowledgeItemsRequest;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -37,8 +39,12 @@ import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
import org.springframework.http.HttpHeaders;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
@@ -69,12 +75,16 @@ public class KnowledgeItemApplicationService {
private static final String EXPORT_FILE_SUFFIX = ".zip";
private static final String EXPORT_CONTENT_TYPE = "application/zip";
private static final int MAX_FILE_BASE_LENGTH = 120;
private static final int MAX_TITLE_LENGTH = 200;
private static final String KNOWLEDGE_ITEM_UPLOAD_DIR = "knowledge-items";
private static final String DEFAULT_FILE_EXTENSION = "bin";
private final KnowledgeItemRepository knowledgeItemRepository;
private final KnowledgeSetRepository knowledgeSetRepository;
private final DatasetRepository datasetRepository;
private final DatasetFileRepository datasetFileRepository;
private final TagMapper tagMapper;
private final DataManagementProperties dataManagementProperties;
public KnowledgeItem createKnowledgeItem(String setId, CreateKnowledgeItemRequest request) {
KnowledgeSet knowledgeSet = requireKnowledgeSet(setId);
@@ -106,6 +116,73 @@ public class KnowledgeItemApplicationService {
return knowledgeItem;
}
public List<KnowledgeItem> uploadKnowledgeItems(String setId, UploadKnowledgeItemsRequest request) {
KnowledgeSet knowledgeSet = requireKnowledgeSet(setId);
BusinessAssert.isTrue(!isReadOnlyStatus(knowledgeSet.getStatus()),
DataManagementErrorCode.KNOWLEDGE_SET_STATUS_ERROR);
List<MultipartFile> files = request.getFiles();
BusinessAssert.isTrue(CollectionUtils.isNotEmpty(files), CommonErrorCode.PARAM_ERROR);
Path uploadRoot = resolveUploadRootPath();
Path setDir = uploadRoot.resolve(KNOWLEDGE_ITEM_UPLOAD_DIR).resolve(setId).normalize();
BusinessAssert.isTrue(setDir.startsWith(uploadRoot), CommonErrorCode.PARAM_ERROR);
createDirectories(setDir);
boolean singleFile = files.size() == 1;
String overrideTitle = StringUtils.trimToNull(request.getTitle());
List<KnowledgeItem> items = new ArrayList<>();
for (MultipartFile file : files) {
BusinessAssert.notNull(file, CommonErrorCode.PARAM_ERROR);
BusinessAssert.isTrue(!file.isEmpty(), CommonErrorCode.PARAM_ERROR);
String originalName = resolveOriginalFileName(file);
String safeOriginalName = sanitizeFileName(originalName);
if (StringUtils.isBlank(safeOriginalName)) {
safeOriginalName = "file";
}
String extension = getFileExtension(safeOriginalName);
String storedName = UUID.randomUUID().toString() +
(StringUtils.isBlank(extension) ? "" : "." + extension);
Path targetPath = setDir.resolve(storedName).normalize();
BusinessAssert.isTrue(targetPath.startsWith(setDir), CommonErrorCode.PARAM_ERROR);
saveMultipartFile(file, targetPath);
KnowledgeItem knowledgeItem = new KnowledgeItem();
knowledgeItem.setId(UUID.randomUUID().toString());
knowledgeItem.setSetId(setId);
String title = singleFile && StringUtils.isNotBlank(overrideTitle)
? overrideTitle
: stripExtension(safeOriginalName);
if (StringUtils.isBlank(title)) {
title = "未命名文件";
}
knowledgeItem.setTitle(trimToLength(title, MAX_TITLE_LENGTH));
knowledgeItem.setContent(buildRelativeFilePath(setId, storedName));
knowledgeItem.setContentType(KnowledgeContentType.FILE);
knowledgeItem.setSourceType(KnowledgeSourceType.FILE_UPLOAD);
knowledgeItem.setSourceFileId(trimToLength(safeOriginalName, MAX_TITLE_LENGTH));
knowledgeItem.setStatus(request.getStatus() == null ? KnowledgeStatusType.DRAFT : request.getStatus());
applyDefaultsFromSet(knowledgeItem, knowledgeSet, request.getTags(), request.getDomain(),
request.getBusinessLine(), request.getOwner(), request.getSensitivity(),
request.getValidFrom(), request.getValidTo(), request.getMetadata());
validateEffectivePeriod(knowledgeItem.getValidFrom(), knowledgeItem.getValidTo());
validatePublishable(knowledgeItem);
items.add(knowledgeItem);
}
if (CollectionUtils.isNotEmpty(items)) {
knowledgeItemRepository.saveBatch(items, items.size());
}
return items;
}
public KnowledgeItem updateKnowledgeItem(String setId, String itemId, UpdateKnowledgeItemRequest request) {
KnowledgeSet knowledgeSet = requireKnowledgeSet(setId);
KnowledgeItem knowledgeItem = knowledgeItemRepository.getById(itemId);
@@ -245,8 +322,7 @@ public class KnowledgeItemApplicationService {
String entryName = buildItemEntryName(item, nameCounter);
ZipArchiveEntry entry = new ZipArchiveEntry(entryName);
zos.putArchiveEntry(entry);
byte[] contentBytes = (item.getContent() == null ? "" : item.getContent())
.getBytes(StandardCharsets.UTF_8);
byte[] contentBytes = resolveExportContent(item);
zos.write(contentBytes);
zos.closeArchiveEntry();
}
@@ -257,6 +333,126 @@ public class KnowledgeItemApplicationService {
}
}
@Transactional(readOnly = true)
public void downloadKnowledgeItemFile(String setId, String itemId, HttpServletResponse response) {
BusinessAssert.notNull(response, CommonErrorCode.PARAM_ERROR);
KnowledgeItem knowledgeItem = knowledgeItemRepository.getById(itemId);
BusinessAssert.notNull(knowledgeItem, DataManagementErrorCode.KNOWLEDGE_ITEM_NOT_FOUND);
BusinessAssert.isTrue(Objects.equals(knowledgeItem.getSetId(), setId), CommonErrorCode.PARAM_ERROR);
BusinessAssert.isTrue(knowledgeItem.getContentType() == KnowledgeContentType.FILE
|| knowledgeItem.getSourceType() == KnowledgeSourceType.FILE_UPLOAD,
CommonErrorCode.PARAM_ERROR);
String relativePath = knowledgeItem.getContent();
BusinessAssert.isTrue(StringUtils.isNotBlank(relativePath), CommonErrorCode.PARAM_ERROR);
Path filePath = resolveKnowledgeItemStoragePath(relativePath);
BusinessAssert.isTrue(Files.exists(filePath) && Files.isRegularFile(filePath), CommonErrorCode.PARAM_ERROR);
String downloadName = StringUtils.isNotBlank(knowledgeItem.getSourceFileId())
? knowledgeItem.getSourceFileId()
: filePath.getFileName().toString();
response.setContentType("application/octet-stream");
response.setCharacterEncoding(StandardCharsets.UTF_8.name());
response.setHeader(HttpHeaders.CONTENT_DISPOSITION,
"attachment; filename=\"" + URLEncoder.encode(downloadName, StandardCharsets.UTF_8) + "\"");
try (InputStream inputStream = Files.newInputStream(filePath)) {
inputStream.transferTo(response.getOutputStream());
response.flushBuffer();
} catch (IOException e) {
log.error("download knowledge item file error, itemId: {}", itemId, e);
throw BusinessException.of(SystemErrorCode.FILE_SYSTEM_ERROR);
}
}
private byte[] resolveExportContent(KnowledgeItem item) {
if (item.getContentType() == KnowledgeContentType.FILE) {
String relativePath = item.getContent();
BusinessAssert.isTrue(StringUtils.isNotBlank(relativePath), CommonErrorCode.PARAM_ERROR);
Path filePath = resolveKnowledgeItemStoragePath(relativePath);
BusinessAssert.isTrue(Files.exists(filePath) && Files.isRegularFile(filePath), CommonErrorCode.PARAM_ERROR);
try {
return Files.readAllBytes(filePath);
} catch (IOException e) {
log.error("export knowledge item file error, itemId: {}", item.getId(), e);
throw BusinessException.of(SystemErrorCode.FILE_SYSTEM_ERROR);
}
}
return (item.getContent() == null ? "" : item.getContent()).getBytes(StandardCharsets.UTF_8);
}
private String resolveExportExtension(KnowledgeItem item) {
if (item.getContentType() == KnowledgeContentType.MARKDOWN) {
return "md";
}
if (item.getContentType() == KnowledgeContentType.FILE) {
String extension = getFileExtension(item.getSourceFileId());
if (StringUtils.isBlank(extension)) {
extension = getFileExtensionFromPath(item.getContent());
}
return StringUtils.isBlank(extension) ? DEFAULT_FILE_EXTENSION : extension;
}
return "txt";
}
private String getFileExtensionFromPath(String path) {
if (StringUtils.isBlank(path)) {
return "";
}
Path fileName = Paths.get(path).getFileName();
return fileName == null ? "" : getFileExtension(fileName.toString());
}
private Path resolveUploadRootPath() {
String uploadDir = dataManagementProperties.getFileStorage().getUploadDir();
BusinessAssert.isTrue(StringUtils.isNotBlank(uploadDir), CommonErrorCode.PARAM_ERROR);
return Paths.get(uploadDir).toAbsolutePath().normalize();
}
private Path resolveKnowledgeItemStoragePath(String relativePath) {
String normalizedRelativePath = relativePath.replace("/", File.separator);
Path root = resolveUploadRootPath();
Path target = root.resolve(normalizedRelativePath).toAbsolutePath().normalize();
BusinessAssert.isTrue(target.startsWith(root), CommonErrorCode.PARAM_ERROR);
return target;
}
private String buildRelativeFilePath(String setId, String storedName) {
String relativePath = Paths.get(KNOWLEDGE_ITEM_UPLOAD_DIR, setId, storedName).toString();
return relativePath.replace(File.separatorChar, '/');
}
private void createDirectories(Path path) {
try {
Files.createDirectories(path);
} catch (IOException e) {
log.error("create knowledge item upload dir error, path: {}", path, e);
throw BusinessException.of(SystemErrorCode.FILE_SYSTEM_ERROR);
}
}
private void saveMultipartFile(MultipartFile file, Path targetPath) {
try (InputStream inputStream = file.getInputStream()) {
Files.copy(inputStream, targetPath);
} catch (IOException e) {
log.error("save knowledge item file error, target: {}", targetPath, e);
throw BusinessException.of(SystemErrorCode.FILE_SYSTEM_ERROR);
}
}
private String resolveOriginalFileName(MultipartFile file) {
String originalName = file.getOriginalFilename();
if (StringUtils.isBlank(originalName)) {
originalName = file.getName();
}
if (originalName == null) {
return "";
}
Path fileName = Paths.get(originalName).getFileName();
return fileName == null ? originalName : fileName.toString();
}
private KnowledgeSet requireKnowledgeSet(String setId) {
KnowledgeSet knowledgeSet = knowledgeSetRepository.getById(setId);
BusinessAssert.notNull(knowledgeSet, DataManagementErrorCode.KNOWLEDGE_SET_NOT_FOUND);
@@ -275,7 +471,7 @@ public class KnowledgeItemApplicationService {
}
baseName = trimToLength(baseName, MAX_FILE_BASE_LENGTH);
String extension = item.getContentType() == KnowledgeContentType.MARKDOWN ? "md" : "txt";
String extension = resolveExportExtension(item);
String baseKey = baseName + "." + extension;
int count = nameCounter.getOrDefault(baseKey, 0);
nameCounter.put(baseKey, count + 1);
@@ -325,6 +521,17 @@ public class KnowledgeItemApplicationService {
: KnowledgeContentType.TEXT;
}
private String getFileExtension(String fileName) {
if (StringUtils.isBlank(fileName)) {
return "";
}
int dotIndex = fileName.lastIndexOf('.');
if (dotIndex <= 0 || dotIndex >= fileName.length() - 1) {
return "";
}
return fileName.substring(dotIndex + 1);
}
private String getFileExtension(DatasetFile datasetFile) {
String fileName = datasetFile.getFileName();
if (StringUtils.isNotBlank(fileName) && fileName.contains(".")) {

6
backend/services/data-management-service/src/main/java/com/datamate/datamanagement/common/enums/KnowledgeContentType.java
View File

@@ -11,5 +11,9 @@ public enum KnowledgeContentType {
/**
* Markdown
*/
MARKDOWN
MARKDOWN,
/**
* 文件（不解析内容）
*/
FILE
}

6
backend/services/data-management-service/src/main/java/com/datamate/datamanagement/common/enums/KnowledgeSourceType.java
View File

@@ -11,5 +11,9 @@ public enum KnowledgeSourceType {
/**
* 数据集文件导入
*/
DATASET_FILE
DATASET_FILE,
/**
* 文件上传
*/
FILE_UPLOAD
}

72
backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/dto/UploadKnowledgeItemsRequest.java Normal file
View File

@@ -0,0 +1,72 @@
package com.datamate.datamanagement.interfaces.dto;
import com.datamate.datamanagement.common.enums.KnowledgeStatusType;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.Size;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.multipart.MultipartFile;
import java.time.LocalDate;
import java.util.List;
/**
* 上传知识条目请求DTO（基于文件）
*/
@Getter
@Setter
public class UploadKnowledgeItemsRequest {
/**
* 上传文件列表
*/
@NotEmpty(message = "文件列表不能为空")
private List<MultipartFile> files;
/**
* 标题（单文件时可指定）
*/
@Size(min = 1, max = 200)
private String title;
/**
* 状态
*/
private KnowledgeStatusType status;
/**
* 标签列表
*/
private List<String> tags;
/**
* 领域
*/
@Size(max = 100)
private String domain;
/**
* 业务线
*/
@Size(max = 100)
private String businessLine;
/**
* 负责人
*/
@Size(max = 100)
private String owner;
/**
* 有效期开始
*/
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
private LocalDate validFrom;
/**
* 有效期结束
*/
@DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
private LocalDate validTo;
/**
* 敏感级别
*/
@Size(max = 50)
private String sensitivity;
/**
* 扩展元数据
*/
private String metadata;
}

17
backend/services/data-management-service/src/main/java/com/datamate/datamanagement/interfaces/rest/KnowledgeItemController.java
View File

@@ -10,10 +10,12 @@ import com.datamate.datamanagement.interfaces.dto.ImportKnowledgeItemsRequest;
import com.datamate.datamanagement.interfaces.dto.KnowledgeItemPagingQuery;
import com.datamate.datamanagement.interfaces.dto.KnowledgeItemResponse;
import com.datamate.datamanagement.interfaces.dto.UpdateKnowledgeItemRequest;
import com.datamate.datamanagement.interfaces.dto.UploadKnowledgeItemsRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@@ -48,12 +50,27 @@ public class KnowledgeItemController {
return KnowledgeConverter.INSTANCE.convertItemResponses(items);
}
@PostMapping(value = "/upload", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
public List<KnowledgeItemResponse> uploadKnowledgeItems(@PathVariable("setId") String setId,
@Valid UploadKnowledgeItemsRequest request) {
List<KnowledgeItem> items = knowledgeItemApplicationService.uploadKnowledgeItems(setId, request);
return KnowledgeConverter.INSTANCE.convertItemResponses(items);
}
@IgnoreResponseWrap
@GetMapping("/export")
public void exportKnowledgeItems(@PathVariable("setId") String setId, HttpServletResponse response) {
knowledgeItemApplicationService.exportKnowledgeItems(setId, response);
}
@IgnoreResponseWrap
@GetMapping("/{itemId}/file")
public void downloadKnowledgeItemFile(@PathVariable("setId") String setId,
@PathVariable("itemId") String itemId,
HttpServletResponse response) {
knowledgeItemApplicationService.downloadKnowledgeItemFile(setId, itemId, response);
}
@GetMapping("/{itemId}")
public KnowledgeItemResponse getKnowledgeItemById(@PathVariable("setId") String setId,
@PathVariable("itemId") String itemId) {

62
frontend/src/pages/KnowledgeManagement/Detail/KnowledgeSetDetail.tsx
View File

@@ -19,12 +19,14 @@ import useFetchData from "@/hooks/useFetchData";
import {
deleteKnowledgeItemByIdUsingDelete,
deleteKnowledgeSetByIdUsingDelete,
downloadKnowledgeItemFileUsingGet,
exportKnowledgeItemsUsingGet,
queryKnowledgeItemsUsingGet,
queryKnowledgeSetByIdUsingGet,
} from "../knowledge-management.api";
import {
knowledgeContentTypeOptions,
knowledgeSourceTypeOptions,
knowledgeStatusMap,
mapKnowledgeItem,
KnowledgeItemView,
@@ -33,6 +35,7 @@ import {
KnowledgeItem,
KnowledgeSet,
KnowledgeContentType,
KnowledgeSourceType,
KnowledgeStatusType,
} from "../knowledge-management.model";
import CreateKnowledgeSet from "../components/CreateKnowledgeSet";
@@ -108,6 +111,12 @@ const KnowledgeSetDetail = () => {
};
const isReadableItem = (record: KnowledgeItemView) => {
if (
record.contentType === KnowledgeContentType.FILE ||
record.sourceType === KnowledgeSourceType.FILE_UPLOAD
) {
return false;
}
return (
record.contentType === KnowledgeContentType.TEXT ||
record.contentType === KnowledgeContentType.MARKDOWN
@@ -115,6 +124,13 @@ const KnowledgeSetDetail = () => {
};
const handleReadItem = async (record: KnowledgeItemView) => {
if (
record.contentType === KnowledgeContentType.FILE ||
record.sourceType === KnowledgeSourceType.FILE_UPLOAD
) {
message.info("该条目为文件，请使用下载查看");
return;
}
setReadItemId(record.id);
setReadTitle(record.title || "知识条目");
@@ -156,6 +172,16 @@ const KnowledgeSetDetail = () => {
}
};
const handleDownloadItem = async (record: KnowledgeItemView) => {
if (!id) return;
try {
await downloadKnowledgeItemFileUsingGet(id, record.id, record.sourceFileId);
} catch (error) {
console.error("下载知识条目文件失败", error);
message.error("下载失败，请稍后重试");
}
};
const statusMeta = knowledgeSet?.status
? knowledgeStatusMap[knowledgeSet.status]
: undefined;
@@ -218,6 +244,10 @@ const KnowledgeSetDetail = () => {
key: "sourceType",
width: 140,
ellipsis: true,
render: (sourceType: string) =>
knowledgeSourceTypeOptions.find((opt) => opt.value === sourceType)?.label ||
sourceType ||
"-",
},
{
title: "更新时间",
@@ -232,16 +262,28 @@ const KnowledgeSetDetail = () => {
width: 200,
render: (_: unknown, record: KnowledgeItemView) => (
<div className="flex items-center gap-2">
<Tooltip title="阅读">
<Button
type="text"
icon={<EyeOutlined />}
onClick={() => handleReadItem(record)}
disabled={!isReadableItem(record)}
loading={readItemId === record.id}
aria-label="阅读"
/>
</Tooltip>
{isReadableItem(record) && (
<Tooltip title="阅读">
<Button
type="text"
icon={<EyeOutlined />}
onClick={() => handleReadItem(record)}
loading={readItemId === record.id}
aria-label="阅读"
/>
</Tooltip>
)}
{(record.contentType === KnowledgeContentType.FILE ||
record.sourceType === KnowledgeSourceType.FILE_UPLOAD) && (
<Tooltip title="下载文件">
<Button
type="text"
icon={<DownloadOutlined />}
onClick={() => handleDownloadItem(record)}
aria-label="下载文件"
/>
</Tooltip>
)}
<Button
type="text"
icon={<EditOutlined />}

208
frontend/src/pages/KnowledgeManagement/components/KnowledgeItemEditor.tsx
View File

@@ -3,29 +3,21 @@ import { Button, DatePicker, Form, Input, message, Modal, Select, Upload, Upload
import { UploadOutlined } from "@ant-design/icons";
import dayjs from "dayjs";
import {
createKnowledgeItemUsingPost,
downloadKnowledgeItemFileUsingGet,
updateKnowledgeItemByIdUsingPut,
uploadKnowledgeItemsUsingPost,
} from "../knowledge-management.api";
import {
knowledgeContentTypeOptions,
knowledgeStatusOptions,
} from "../knowledge-management.const";
import {
KnowledgeContentType,
KnowledgeItem,
KnowledgeSourceType,
KnowledgeStatusType,
} from "../knowledge-management.model";
import { queryDatasetTagsUsingGet } from "@/pages/DataManagement/dataset.api";
const FILE_UPLOAD_ACCEPT = ".txt,.md,.markdown";
const SUPPORTED_FILE_EXTENSIONS = new Set(["txt", "md", "markdown"]);
const MARKDOWN_FILE_EXTENSIONS = new Set(["md", "markdown"]);
const getFileExtension = (fileName: string) => {
const dotIndex = fileName.lastIndexOf(".");
return dotIndex > -1 ? fileName.slice(dotIndex + 1).toLowerCase() : "";
};
const stripFileExtension = (fileName: string) => {
const dotIndex = fileName.lastIndexOf(".");
if (dotIndex <= 0) {
@@ -34,9 +26,6 @@ const stripFileExtension = (fileName: string) => {
return fileName.slice(0, dotIndex);
};
const resolveContentType = (extension: string) =>
MARKDOWN_FILE_EXTENSIONS.has(extension) ? KnowledgeContentType.MARKDOWN : KnowledgeContentType.TEXT;
export default function KnowledgeItemEditor({
open,
setId,
@@ -55,6 +44,17 @@ export default function KnowledgeItemEditor({
const [form] = Form.useForm();
const [tagOptions, setTagOptions] = useState<{ label: string; value: string }[]>([]);
const [fileList, setFileList] = useState<UploadFile[]>([]);
const isMultiFile = fileList.length > 1;
const isFileItem =
data?.contentType === KnowledgeContentType.FILE ||
data?.sourceType === KnowledgeSourceType.FILE_UPLOAD;
const contentTypeLabel = !data?.id
? "文件"
: data?.contentType === KnowledgeContentType.MARKDOWN
? "Markdown"
: data?.contentType === KnowledgeContentType.TEXT
? "文本"
: "文件";
const fetchTags = async () => {
try {
@@ -79,8 +79,6 @@ export default function KnowledgeItemEditor({
if (data?.id) {
form.setFieldsValue({
title: data.title,
content: data.content,
contentType: data.contentType ?? KnowledgeContentType.TEXT,
status: data.status ?? KnowledgeStatusType.DRAFT,
domain: data.domain,
businessLine: data.businessLine,
@@ -94,7 +92,6 @@ export default function KnowledgeItemEditor({
} else {
form.resetFields();
form.setFieldsValue({
contentType: KnowledgeContentType.TEXT,
status: KnowledgeStatusType.DRAFT,
tags: [],
});
@@ -105,45 +102,60 @@ export default function KnowledgeItemEditor({
}
}, [open, data, form]);
const handleFileBeforeUpload = async (file: File) => {
const extension = getFileExtension(file.name);
if (!SUPPORTED_FILE_EXTENSIONS.has(extension)) {
message.error("仅支持 .txt/.md/.markdown 文件");
return Upload.LIST_IGNORE;
}
try {
const textContent = await file.text();
const currentTitle = form.getFieldValue("title");
form.setFieldsValue({
title: currentTitle || stripFileExtension(file.name),
content: textContent,
contentType: resolveContentType(extension),
});
setFileList([
const handleFileBeforeUpload = (file: File) => {
setFileList((prev) => {
const nextList = [
...prev,
{
uid: `${Date.now()}-${file.name}`,
name: file.name,
status: "done",
originFileObj: file,
},
]);
message.success("文件已读取，可继续编辑内容");
return false;
} catch (error) {
console.error("读取文件失败", error);
message.error("读取文件失败，请重试");
return Upload.LIST_IGNORE;
}
];
if (nextList.length === 1) {
const currentTitle = form.getFieldValue("title");
if (!currentTitle) {
form.setFieldsValue({
title: stripFileExtension(file.name),
});
}
}
return nextList;
});
message.success("文件已就绪，可提交创建条目");
return false;
};
const handleFileRemove = () => {
setFileList([]);
const handleFileRemove = (removedFile: UploadFile) => {
setFileList((prev) => {
const nextList = prev.filter((file) => file.uid !== removedFile.uid);
if (!data?.id && nextList.length === 0) {
form.setFieldsValue({ title: undefined });
}
return nextList;
});
return true;
};
const handleDownloadFile = async () => {
if (!data?.id) {
return;
}
try {
await downloadKnowledgeItemFileUsingGet(setId, data.id, data.sourceFileId);
} catch (error) {
console.error("下载文件失败", error);
message.error("下载失败，请稍后重试");
}
};
const handleSubmit = async () => {
try {
if (!data?.id && fileList.length === 0) {
message.warning("请先选择文件");
return;
}
const values = await form.validateFields();
const validFrom = values.validFrom ? values.validFrom.format("YYYY-MM-DD") : undefined;
const validTo = values.validTo ? values.validTo.format("YYYY-MM-DD") : undefined;
@@ -153,19 +165,61 @@ export default function KnowledgeItemEditor({
return;
}
const payload = {
...values,
validFrom,
validTo,
tags: values.tags || [],
};
if (data?.id) {
const payload = {
...values,
validFrom,
validTo,
tags: values.tags || [],
};
await updateKnowledgeItemByIdUsingPut(setId, data.id, payload);
message.success("知识条目更新成功");
} else {
await createKnowledgeItemUsingPost(setId, payload);
message.success("知识条目创建成功");
if (fileList.length === 0) {
message.warning("请先选择文件");
return;
}
const formData = new FormData();
fileList.forEach((file) => {
const origin = file.originFileObj as File | undefined;
if (origin) {
formData.append("files", origin);
}
});
if (fileList.length === 1 && values.title) {
formData.append("title", values.title);
}
if (values.status) {
formData.append("status", values.status);
}
if (values.tags && Array.isArray(values.tags)) {
values.tags.forEach((tag) => formData.append("tags", tag));
}
if (values.domain) {
formData.append("domain", values.domain);
}
if (values.businessLine) {
formData.append("businessLine", values.businessLine);
}
if (values.owner) {
formData.append("owner", values.owner);
}
if (values.sensitivity) {
formData.append("sensitivity", values.sensitivity);
}
if (validFrom) {
formData.append("validFrom", validFrom);
}
if (validTo) {
formData.append("validTo", validTo);
}
if (values.metadata) {
formData.append("metadata", values.metadata);
}
await uploadKnowledgeItemsUsingPost(setId, formData);
message.success(`已创建 ${fileList.length} 个知识条目`);
}
form.resetFields();
@@ -195,44 +249,54 @@ export default function KnowledgeItemEditor({
<Form.Item
label="标题"
name="title"
rules={[{ required: true, message: "请输入标题" }]}
rules={[{ required: !isMultiFile, message: "请输入标题" }]}
>
<Input placeholder="请输入标题" />
<Input
placeholder={isMultiFile ? "多文件将按文件名自动生成" : "请输入标题"}
disabled={readOnly || (!data?.id && isMultiFile)}
/>
</Form.Item>
<Form.Item label="状态" name="status">
<Select options={knowledgeStatusOptions} />
</Form.Item>
</div>
<div className="grid grid-cols-2 gap-4">
<Form.Item label="内容类型" name="contentType">
<Select options={knowledgeContentTypeOptions} />
</Form.Item>
<Form.Item label="敏感级别" name="sensitivity">
<Input placeholder="请输入敏感级别" />
</Form.Item>
</div>
<Form.Item
label="内容"
name="content"
rules={[{ required: true, message: "请输入内容" }]}
>
<Input.TextArea rows={8} placeholder="请输入内容" />
</Form.Item>
{!data?.id && (
<Form.Item label="上传文件" extra="支持 .txt/.md/.markdown，将自动填充标题与内容">
<Form.Item label="上传文件" required>
<Upload
accept={FILE_UPLOAD_ACCEPT}
beforeUpload={handleFileBeforeUpload}
fileList={fileList}
maxCount={1}
multiple
onRemove={handleFileRemove}
showUploadList={{ showPreviewIcon: false }}
disabled={readOnly}
>
<Button icon={<UploadOutlined />}>选择文件</Button>
</Upload>
<div className="text-xs text-gray-500 mt-1">
支持多格式文件；多文件将自动拆分为多个条目
</div>
</Form.Item>
)}
{data?.id && isFileItem && (
<Form.Item label="文件">
<div className="flex items-center gap-2">
<span className="truncate" title={data.sourceFileId || data.title}>
{data.sourceFileId || data.title || "-"}
</span>
<Button size="small" onClick={handleDownloadFile} disabled={readOnly}>
下载
</Button>
</div>
</Form.Item>
)}
<div className="grid grid-cols-2 gap-4">
<Form.Item label="内容类型">
<Input value={contentTypeLabel} disabled />
</Form.Item>
<Form.Item label="敏感级别" name="sensitivity">
<Input placeholder="请输入敏感级别" />
</Form.Item>
</div>
<div className="grid grid-cols-2 gap-4">
<Form.Item label="领域" name="domain">
<Input placeholder="请输入领域" />

10
frontend/src/pages/KnowledgeManagement/knowledge-management.api.ts
View File

@@ -55,6 +55,16 @@ export function deleteKnowledgeItemByIdUsingDelete(setId: string, itemId: string
return del(`/api/data-management/knowledge-sets/${setId}/items/${itemId}`);
}
// 上传知识条目文件
export function uploadKnowledgeItemsUsingPost(setId: string, data: FormData) {
return post(`/api/data-management/knowledge-sets/${setId}/items/upload`, data);
}
// 下载知识条目文件
export function downloadKnowledgeItemFileUsingGet(setId: string, itemId: string, fileName?: string) {
return download(`/api/data-management/knowledge-sets/${setId}/items/${itemId}/file`, null, fileName || "");
}
// 导出知识条目
export function exportKnowledgeItemsUsingGet(setId: string) {
return download(`/api/data-management/knowledge-sets/${setId}/items/export`);

2
frontend/src/pages/KnowledgeManagement/knowledge-management.const.tsx
View File

@@ -57,11 +57,13 @@ export const knowledgeStatusOptions = Object.values(knowledgeStatusMap).map((ite
export const knowledgeContentTypeOptions = [
{ label: "文本", value: KnowledgeContentType.TEXT },
{ label: "Markdown", value: KnowledgeContentType.MARKDOWN },
{ label: "文件", value: KnowledgeContentType.FILE },
];
export const knowledgeSourceTypeOptions = [
{ label: "手工录入", value: KnowledgeSourceType.MANUAL },
{ label: "数据集文件导入", value: KnowledgeSourceType.DATASET_FILE },
{ label: "文件上传", value: KnowledgeSourceType.FILE_UPLOAD },
];
export type KnowledgeSetView = {

2
frontend/src/pages/KnowledgeManagement/knowledge-management.model.ts
View File

@@ -8,11 +8,13 @@ export enum KnowledgeStatusType {
export enum KnowledgeContentType {
TEXT = "TEXT",
MARKDOWN = "MARKDOWN",
FILE = "FILE",
}
export enum KnowledgeSourceType {
MANUAL = "MANUAL",
DATASET_FILE = "DATASET_FILE",
FILE_UPLOAD = "FILE_UPLOAD",
}
export interface KnowledgeTag {