989 lines
32 KiB
TypeScript
989 lines
32 KiB
TypeScript
import { type MetaFunction } from "@remix-run/node";
|
|
import { useState, useEffect } from "react";
|
|
import { BasicInfo } from "~/components/rules/new/BasicInfo";
|
|
import { ExtractionSettings } from "~/components/rules/new/ExtractionSettings";
|
|
import { ReviewSettings, RuleContext } from "~/components/rules/new/ReviewSettings";
|
|
import { ActionButtons } from "~/components/rules/new/ActionButtons";
|
|
import { PageHeader } from "~/components/rules/new/PageHeader";
|
|
import rulesStyles from "~/styles/rules.css?url";
|
|
import { useNavigate, useLocation } from "@remix-run/react";
|
|
|
|
export const meta: MetaFunction = () => {
|
|
return [
|
|
{ title: "评查点管理 - 中国烟草AI合同及卷宗审核系统" },
|
|
{
|
|
name: "description",
|
|
content: "创建或修改评查点，设置规则参数"
|
|
}
|
|
];
|
|
};
|
|
|
|
export function links() {
|
|
return [{ rel: "stylesheet", href: rulesStyles }];
|
|
}
|
|
|
|
export const handle = {
|
|
breadcrumb: "评查点管理"
|
|
};
|
|
|
|
// 定义类型
|
|
interface RegexField {
|
|
fieldName: string;
|
|
regex: string;
|
|
}
|
|
|
|
interface ApiRegexField {
|
|
field: string;
|
|
pattern: string;
|
|
}
|
|
|
|
interface ApiVlmField {
|
|
name: string;
|
|
type: string;
|
|
}
|
|
|
|
interface PromptSetting {
|
|
type: string;
|
|
template: string;
|
|
}
|
|
|
|
interface ExtactionConfigType {
|
|
llm_ocr: {
|
|
fields: string[];
|
|
prompt_setting: PromptSetting;
|
|
};
|
|
llm_vl: {
|
|
fields: string[];
|
|
prompt_setting: PromptSetting;
|
|
};
|
|
ocr_regex: {
|
|
fields: RegexField[];
|
|
};
|
|
}
|
|
|
|
interface ApiExtactionConfigType {
|
|
llm?: {
|
|
fields?: string[];
|
|
prompt_setting?: {
|
|
type?: string;
|
|
template?: string;
|
|
}
|
|
};
|
|
vlm?: {
|
|
fields?: ApiVlmField[];
|
|
prompt_setting?: {
|
|
type?: string;
|
|
template?: string;
|
|
}
|
|
};
|
|
regex?: {
|
|
fields?: ApiRegexField[];
|
|
};
|
|
}
|
|
|
|
interface RuleConfigType {
|
|
[key: string]: unknown;
|
|
}
|
|
|
|
interface Rule {
|
|
id: string;
|
|
type: string;
|
|
config: RuleConfigType;
|
|
}
|
|
|
|
interface EvaluationConfigType {
|
|
logicType: string;
|
|
customLogic: string;
|
|
rules: Rule[];
|
|
}
|
|
|
|
interface FormDataType {
|
|
id?: number;
|
|
name: string;
|
|
code: string;
|
|
risk: string;
|
|
is_enabled: boolean;
|
|
description: string;
|
|
references_laws: {
|
|
name: string;
|
|
articles: string[];
|
|
content: string;
|
|
};
|
|
evaluation_point_groups_id: number | null;
|
|
extraction_config: ExtactionConfigType;
|
|
evaluation_config: EvaluationConfigType;
|
|
pass_message: string;
|
|
fail_message: string;
|
|
suggestion_message: string;
|
|
suggestion_message_type: string;
|
|
post_action: string;
|
|
action_config: string;
|
|
type?: string;
|
|
}
|
|
|
|
interface ApiPointData {
|
|
id: number;
|
|
name: string;
|
|
code: string;
|
|
risk: string;
|
|
is_enabled: boolean;
|
|
description: string;
|
|
references_laws: {
|
|
name: string;
|
|
articles: string[];
|
|
content: string;
|
|
};
|
|
evaluation_point_groups_id: number | null;
|
|
extraction_config: ApiExtactionConfigType;
|
|
evaluation_config: {
|
|
logicType?: string;
|
|
customLogic?: string;
|
|
rules?: Array<{
|
|
id: string;
|
|
type: string;
|
|
config: Record<string, unknown>;
|
|
}>;
|
|
};
|
|
pass_message: string;
|
|
fail_message: string;
|
|
suggestion_message: string;
|
|
suggestion_message_type: string;
|
|
post_action: string;
|
|
action_config: string;
|
|
type?: string;
|
|
}
|
|
|
|
export default function RuleNew() {
|
|
const navigate = useNavigate();
|
|
const location = useLocation();
|
|
const [extractionFields, setExtractionFields] = useState<string[]>([]);
|
|
const [isEditMode, setIsEditMode] = useState<boolean>(false);
|
|
const [isLoading, setIsLoading] = useState<boolean>(false);
|
|
const [formData, setFormData] = useState<FormDataType>({
|
|
// 基本信息字段
|
|
name: '',
|
|
code: '',
|
|
risk: 'medium',
|
|
is_enabled: true,
|
|
description: '',
|
|
references_laws: {
|
|
name: '',
|
|
articles: [],
|
|
content: ''
|
|
},
|
|
evaluation_point_groups_id: null,
|
|
type: '',
|
|
|
|
// 抽取设置
|
|
extraction_config: {
|
|
llm_ocr: {
|
|
fields: [],
|
|
prompt_setting: {
|
|
type: 'system',
|
|
template: ''
|
|
}
|
|
},
|
|
llm_vl: {
|
|
fields: [],
|
|
prompt_setting: {
|
|
type: 'system',
|
|
template: ''
|
|
}
|
|
},
|
|
ocr_regex: {
|
|
fields: []
|
|
}
|
|
},
|
|
|
|
// 评查设置
|
|
evaluation_config: {
|
|
logicType: 'and',
|
|
customLogic: '',
|
|
rules: []
|
|
},
|
|
|
|
// 评查结果消息
|
|
pass_message: '文档检查通过，符合规范要求。',
|
|
fail_message: '文档存在以下问题，请修改后重新提交。',
|
|
suggestion_message: '',
|
|
suggestion_message_type: 'warning',
|
|
|
|
// 评查后动作
|
|
post_action: 'none',
|
|
action_config: ''
|
|
});
|
|
|
|
// 页面加载时检查URL中是否有ID参数，如果有则为编辑模式
|
|
useEffect(() => {
|
|
const searchParams = new URLSearchParams(location.search);
|
|
const id = searchParams.get('id');
|
|
|
|
if (id) {
|
|
setIsEditMode(true);
|
|
fetchEvaluationPoint(parseInt(id));
|
|
}
|
|
}, [location]);
|
|
|
|
// 获取评查点数据
|
|
const fetchEvaluationPoint = async (id: number) => {
|
|
setIsLoading(true);
|
|
try {
|
|
console.log(`获取评查点数据，ID: ${id}`);
|
|
const response = await fetch(`http://127.0.0.1:9000/admin/evaluation_points?id=eq.${id}`, {
|
|
method: 'GET',
|
|
headers: {
|
|
'Accept': 'application/json'
|
|
}
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const errorText = await response.text();
|
|
console.error(`API响应错误: ${response.status}`, errorText);
|
|
throw new Error(`获取评查点数据失败: ${response.status} - ${errorText}`);
|
|
}
|
|
|
|
const responseData = await response.json();
|
|
console.log("API响应数据:", responseData);
|
|
|
|
// 处理多种可能的响应格式
|
|
if (Array.isArray(responseData)) {
|
|
if (responseData.length > 0) {
|
|
console.log("数组格式响应，使用第一项");
|
|
processPointData(responseData[0]);
|
|
} else {
|
|
console.error("数组为空，未找到数据");
|
|
throw new Error(`未找到ID为${id}的评查点数据`);
|
|
}
|
|
} else if (responseData && typeof responseData === 'object') {
|
|
// 处理可能的包装对象格式
|
|
if (responseData.data) {
|
|
console.log("包装对象格式响应，使用data字段");
|
|
if (Array.isArray(responseData.data)) {
|
|
if (responseData.data.length > 0) {
|
|
processPointData(responseData.data[0]);
|
|
} else {
|
|
console.error("data数组为空");
|
|
throw new Error(`未找到ID为${id}的评查点数据`);
|
|
}
|
|
} else if (typeof responseData.data === 'object') {
|
|
processPointData(responseData.data);
|
|
} else {
|
|
console.error("data字段格式不正确");
|
|
throw new Error('数据格式不正确: data字段不是预期的格式');
|
|
}
|
|
} else if (responseData.id) {
|
|
// 可能是直接返回的单个对象
|
|
console.log("单对象格式响应");
|
|
processPointData(responseData);
|
|
} else {
|
|
console.error("无法识别的对象格式", responseData);
|
|
throw new Error('未找到评查点数据或数据格式不正确');
|
|
}
|
|
} else {
|
|
console.error("响应格式无法识别", responseData);
|
|
throw new Error('未找到评查点数据或数据格式不正确');
|
|
}
|
|
} catch (error) {
|
|
console.error('获取评查点数据失败:', error);
|
|
alert(`获取评查点数据失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
|
} finally {
|
|
setIsLoading(false);
|
|
}
|
|
};
|
|
|
|
// 处理获取到的评查点数据
|
|
const processPointData = (pointData: ApiPointData) => {
|
|
console.log("处理评查点数据:", pointData);
|
|
|
|
if (!pointData) {
|
|
console.error("评查点数据为空");
|
|
throw new Error("评查点数据为空");
|
|
}
|
|
|
|
try {
|
|
// 转换API数据为表单数据格式
|
|
const extractionConfig = pointData.extraction_config || {};
|
|
const evaluationConfig = pointData.evaluation_config || {};
|
|
|
|
console.log("提取配置:", extractionConfig);
|
|
console.log("评查配置:", evaluationConfig);
|
|
|
|
// 提取字段列表，用于规则设置
|
|
const extractedFields: string[] = [];
|
|
|
|
// 处理LLM字段
|
|
if (extractionConfig.llm && extractionConfig.llm.fields) {
|
|
extractedFields.push(...extractionConfig.llm.fields);
|
|
}
|
|
|
|
// 处理VLM字段
|
|
if (extractionConfig.vlm && extractionConfig.vlm.fields) {
|
|
extractedFields.push(...(extractionConfig.vlm.fields || []).map((field) => {
|
|
if (typeof field === 'object' && field.name) {
|
|
return field.type ? `${field.name}_${field.type}` : field.name;
|
|
}
|
|
return '';
|
|
}).filter(Boolean));
|
|
}
|
|
|
|
// 处理正则字段
|
|
if (extractionConfig.regex && extractionConfig.regex.fields) {
|
|
extractedFields.push(...(extractionConfig.regex.fields || []).map((field) => field.field || '').filter(Boolean));
|
|
}
|
|
|
|
console.log("提取的字段:", extractedFields);
|
|
setExtractionFields(extractedFields);
|
|
|
|
// 构建表单数据
|
|
const newFormData = {
|
|
id: pointData.id,
|
|
name: pointData.name || '',
|
|
code: pointData.code || '',
|
|
risk: pointData.risk || 'medium',
|
|
is_enabled: pointData.is_enabled !== undefined ? pointData.is_enabled : false,
|
|
description: pointData.description || '',
|
|
references_laws: pointData.references_laws || {
|
|
name: '',
|
|
articles: [],
|
|
content: ''
|
|
},
|
|
evaluation_point_groups_id: pointData.evaluation_point_groups_id || null,
|
|
type: pointData.type || '',
|
|
|
|
// 将API数据格式转换为内部使用的格式
|
|
extraction_config: {
|
|
llm_ocr: {
|
|
fields: extractionConfig.llm?.fields || [],
|
|
prompt_setting: {
|
|
type: extractionConfig.llm?.prompt_setting?.type || 'system',
|
|
template: extractionConfig.llm?.prompt_setting?.template || ''
|
|
}
|
|
},
|
|
llm_vl: {
|
|
fields: (extractionConfig.vlm?.fields || []).map((field) => {
|
|
if (typeof field === 'object' && field.name) {
|
|
return field.type ? `${field.name}_${field.type}` : field.name;
|
|
}
|
|
return '';
|
|
}).filter(Boolean),
|
|
prompt_setting: {
|
|
type: extractionConfig.vlm?.prompt_setting?.type || 'system',
|
|
template: extractionConfig.vlm?.prompt_setting?.template || ''
|
|
}
|
|
},
|
|
ocr_regex: {
|
|
fields: (extractionConfig.regex?.fields || []).map((field) => ({
|
|
fieldName: field.field || '',
|
|
regex: field.pattern || ''
|
|
}))
|
|
}
|
|
},
|
|
|
|
evaluation_config: {
|
|
logicType: evaluationConfig.logicType || 'and',
|
|
customLogic: evaluationConfig.customLogic || '',
|
|
rules: (evaluationConfig.rules || []).map((rule) => {
|
|
// 将API规则格式转换为UI使用的格式
|
|
let config: RuleConfigType = {};
|
|
|
|
try {
|
|
switch (rule.type) {
|
|
case 'exists':
|
|
config = {
|
|
selectedFields: rule.config?.fields || [],
|
|
logicRelation: rule.config?.logic || 'and'
|
|
};
|
|
break;
|
|
case 'consistency':
|
|
config = {
|
|
pairs: rule.config?.pairs || [],
|
|
logicRelation: rule.config?.logic || 'and'
|
|
};
|
|
break;
|
|
case 'format':
|
|
config = {
|
|
field: rule.config?.field || '',
|
|
formatType: rule.config?.formatType || '',
|
|
parameters: rule.config?.parameters || ''
|
|
};
|
|
break;
|
|
case 'logic':
|
|
config = {
|
|
conditions: rule.config?.conditions || [],
|
|
logicRelation: rule.config?.logic || 'and'
|
|
};
|
|
break;
|
|
case 'regex':
|
|
config = {
|
|
field: rule.config?.field || '',
|
|
pattern: rule.config?.pattern || '',
|
|
matchType: rule.config?.matchType || 'match'
|
|
};
|
|
break;
|
|
case 'ai':
|
|
config = {
|
|
model: rule.config?.model || 'qwen14b',
|
|
temperature: rule.config?.temperature || 0.1,
|
|
prompt: rule.config?.prompt || ''
|
|
};
|
|
break;
|
|
case 'code':
|
|
config = {
|
|
language: rule.config?.language || 'javascript',
|
|
code: rule.config?.code || ''
|
|
};
|
|
break;
|
|
default:
|
|
config = rule.config || {};
|
|
}
|
|
} catch (error) {
|
|
console.error(`处理规则[${rule.id}]配置时出错:`, error);
|
|
config = rule.config || {};
|
|
}
|
|
|
|
return {
|
|
id: rule.id,
|
|
type: rule.type,
|
|
config
|
|
};
|
|
})
|
|
},
|
|
|
|
pass_message: pointData.pass_message || '文档检查通过，符合规范要求。',
|
|
fail_message: pointData.fail_message || '文档存在以下问题，请修改后重新提交。',
|
|
suggestion_message: pointData.suggestion_message || '',
|
|
suggestion_message_type: pointData.suggestion_message_type || 'warning',
|
|
post_action: pointData.post_action || 'none',
|
|
action_config: pointData.action_config || ''
|
|
};
|
|
|
|
console.log("设置表单数据:", newFormData);
|
|
setFormData(newFormData);
|
|
} catch (error) {
|
|
console.error("处理评查点数据时出错:", error);
|
|
throw new Error(`处理评查点数据时出错: ${error instanceof Error ? error.message : '未知错误'}`);
|
|
}
|
|
};
|
|
|
|
// 更新抽取字段列表，用于在评查规则中选择
|
|
const updateExtractionFields = (fields: string[]) => {
|
|
setExtractionFields(fields);
|
|
};
|
|
|
|
// 处理BasicInfo组件数据变更
|
|
const handleBasicInfoChange = (data: Record<string, unknown>) => {
|
|
setFormData(prevData => ({
|
|
...prevData,
|
|
...data
|
|
}));
|
|
};
|
|
|
|
// 处理ExtractionSettings组件数据变更
|
|
const handleExtractionSettingsChange = (data: Record<string, unknown>) => {
|
|
setFormData(prevData => {
|
|
// 获取数据
|
|
const extractionMethod = data.extractionMethod as string;
|
|
const regexFields = data.regexFields as Array<{ id: string; fieldName: string; regex: string }>;
|
|
const fields = data.fields as Record<string, string[]>;
|
|
|
|
// 根据抽取方法更新对应字段
|
|
const updatedExtractionConfig = { ...prevData.extraction_config };
|
|
|
|
// 更新正则抽取字段
|
|
if (regexFields) {
|
|
updatedExtractionConfig.ocr_regex.fields = regexFields
|
|
.filter(field => field.fieldName && field.regex)
|
|
.map(field => ({
|
|
fieldName: field.fieldName,
|
|
regex: field.regex
|
|
}));
|
|
}
|
|
|
|
// 更新LLM字段
|
|
if (fields) {
|
|
if (fields.llm_ocr) {
|
|
updatedExtractionConfig.llm_ocr.fields = fields.llm_ocr;
|
|
}
|
|
if (fields.llm) {
|
|
updatedExtractionConfig.llm_vl.fields = fields.llm;
|
|
}
|
|
}
|
|
|
|
// 更新提示词设置
|
|
if (data.promptSettings) {
|
|
const promptSettings = data.promptSettings as Record<string, unknown>;
|
|
|
|
// 确定当前是处理哪种类型的提示词
|
|
if (extractionMethod === 'llm_ocr') {
|
|
updatedExtractionConfig.llm_ocr.prompt_setting.type = promptSettings.type as string || 'system';
|
|
updatedExtractionConfig.llm_ocr.prompt_setting.template = promptSettings.content as string || '';
|
|
} else if (extractionMethod === 'llm') {
|
|
updatedExtractionConfig.llm_vl.prompt_setting.type = promptSettings.type as string || 'system';
|
|
updatedExtractionConfig.llm_vl.prompt_setting.template = promptSettings.content as string || '';
|
|
}
|
|
} else {
|
|
// 兼容旧的API
|
|
if (data.promptType) {
|
|
const promptType = data.promptType as Record<string, string>;
|
|
if (promptType.llm_ocr) {
|
|
updatedExtractionConfig.llm_ocr.prompt_setting.type = promptType.llm_ocr;
|
|
}
|
|
if (promptType.llm) {
|
|
updatedExtractionConfig.llm_vl.prompt_setting.type = promptType.llm;
|
|
}
|
|
}
|
|
|
|
if (data.promptContent) {
|
|
const promptContent = data.promptContent as Record<string, string>;
|
|
if (promptContent.llm_ocr) {
|
|
updatedExtractionConfig.llm_ocr.prompt_setting.template = promptContent.llm_ocr;
|
|
}
|
|
if (promptContent.llm) {
|
|
updatedExtractionConfig.llm_vl.prompt_setting.template = promptContent.llm;
|
|
}
|
|
}
|
|
}
|
|
|
|
console.log('更新的抽取设置:', updatedExtractionConfig);
|
|
|
|
return {
|
|
...prevData,
|
|
extraction_config: updatedExtractionConfig
|
|
};
|
|
});
|
|
};
|
|
|
|
// 处理ReviewSettings组件数据变更
|
|
const handleReviewSettingsChange = (data: Record<string, unknown>) => {
|
|
setFormData(prevData => {
|
|
const updatedData = { ...prevData };
|
|
|
|
// 更新规则
|
|
if (data.rules) {
|
|
updatedData.evaluation_config.rules = data.rules as Rule[];
|
|
}
|
|
|
|
// 更新组合逻辑
|
|
if (data.combinationLogic !== undefined) {
|
|
updatedData.evaluation_config.logicType = data.combinationLogic as string;
|
|
}
|
|
|
|
// 更新自定义逻辑
|
|
if (data.customLogic !== undefined) {
|
|
updatedData.evaluation_config.customLogic = data.customLogic as string;
|
|
}
|
|
|
|
// 更新通过/不通过/建议消息
|
|
if (data.pass_message !== undefined) {
|
|
updatedData.pass_message = data.pass_message as string;
|
|
}
|
|
|
|
if (data.fail_message !== undefined) {
|
|
updatedData.fail_message = data.fail_message as string;
|
|
}
|
|
|
|
if (data.suggestion_message !== undefined) {
|
|
updatedData.suggestion_message = data.suggestion_message as string;
|
|
}
|
|
|
|
if (data.suggestion_message_type !== undefined) {
|
|
updatedData.suggestion_message_type = data.suggestion_message_type as string;
|
|
}
|
|
|
|
// 更新评查后动作
|
|
if (data.post_action !== undefined) {
|
|
updatedData.post_action = data.post_action as string;
|
|
}
|
|
|
|
if (data.action_config !== undefined) {
|
|
updatedData.action_config = data.action_config as string;
|
|
}
|
|
|
|
return updatedData;
|
|
});
|
|
};
|
|
|
|
// 格式化数据，准备提交到接口
|
|
const formatDataForApi = (formData: FormDataType, isDraft: boolean = false) => {
|
|
// 转换提取配置为符合数据库格式的JSON
|
|
const extractionConfig = {
|
|
llm: {
|
|
fields: formData.extraction_config.llm_ocr.fields || [],
|
|
prompt_setting: {
|
|
type: formData.extraction_config.llm_ocr.prompt_setting.type || 'system',
|
|
template: formData.extraction_config.llm_ocr.prompt_setting.template || ''
|
|
}
|
|
},
|
|
vlm: {
|
|
fields: (formData.extraction_config.llm_vl.fields || []).map((field: string) => {
|
|
// 处理带有类型后缀的字段名 (如 "字段名_类型")
|
|
if (field.includes('_')) {
|
|
const [name, type] = field.split('_');
|
|
return {
|
|
name,
|
|
type: type || 'default'
|
|
};
|
|
}
|
|
return { name: field, type: 'default' };
|
|
}),
|
|
prompt_setting: {
|
|
type: formData.extraction_config.llm_vl.prompt_setting.type || 'system',
|
|
template: formData.extraction_config.llm_vl.prompt_setting.template || ''
|
|
}
|
|
},
|
|
regex: {
|
|
fields: (formData.extraction_config.ocr_regex.fields || []).map((field: RegexField) => {
|
|
return {
|
|
field: field.fieldName || '',
|
|
pattern: field.regex || ''
|
|
};
|
|
})
|
|
}
|
|
};
|
|
|
|
// 转换评查配置为符合数据库格式的JSON
|
|
const evaluationConfig = {
|
|
logicType: formData.evaluation_config.logicType || 'and',
|
|
customLogic: formData.evaluation_config.customLogic || '',
|
|
rules: (formData.evaluation_config.rules || []).map((rule: Rule) => {
|
|
let config = {};
|
|
|
|
// 根据不同的规则类型生成对应的配置
|
|
switch (rule.type) {
|
|
case 'exists':
|
|
config = {
|
|
fields: rule.config?.selectedFields || [],
|
|
logic: rule.config?.logicRelation || 'and'
|
|
};
|
|
break;
|
|
case 'consistency':
|
|
config = {
|
|
pairs: rule.config?.pairs || [],
|
|
logic: rule.config?.logicRelation || 'and'
|
|
};
|
|
break;
|
|
case 'format':
|
|
config = {
|
|
field: rule.config?.field || '',
|
|
formatType: rule.config?.formatType || '',
|
|
parameters: rule.config?.parameters || ''
|
|
};
|
|
break;
|
|
case 'logic':
|
|
config = {
|
|
conditions: rule.config?.conditions || [],
|
|
logic: rule.config?.logicRelation || 'and'
|
|
};
|
|
break;
|
|
case 'regex':
|
|
config = {
|
|
field: rule.config?.field || '',
|
|
pattern: rule.config?.pattern || '',
|
|
matchType: rule.config?.matchType || 'match'
|
|
};
|
|
break;
|
|
case 'ai':
|
|
config = {
|
|
model: rule.config?.model || 'qwen14b',
|
|
temperature: rule.config?.temperature || 0.1,
|
|
prompt: rule.config?.prompt || ''
|
|
};
|
|
break;
|
|
case 'code':
|
|
config = {
|
|
language: rule.config?.language || 'javascript',
|
|
code: rule.config?.code || ''
|
|
};
|
|
break;
|
|
default:
|
|
config = rule.config || {};
|
|
}
|
|
|
|
return {
|
|
id: rule.id,
|
|
type: rule.type,
|
|
config
|
|
};
|
|
})
|
|
};
|
|
|
|
// 构建完整的评查点数据
|
|
const evaluationPointData: Record<string, unknown> = {
|
|
code: formData.code,
|
|
name: formData.name,
|
|
evaluation_point_groups_id: formData.evaluation_point_groups_id,
|
|
risk: formData.risk,
|
|
description: formData.description,
|
|
is_enabled: isDraft ? false : formData.is_enabled,
|
|
references_laws: formData.references_laws,
|
|
extraction_config: extractionConfig,
|
|
evaluation_config: evaluationConfig,
|
|
pass_message: formData.pass_message,
|
|
fail_message: formData.fail_message,
|
|
suggestion_message: formData.suggestion_message,
|
|
suggestion_message_type: formData.suggestion_message_type,
|
|
post_action: formData.post_action,
|
|
action_config: formData.action_config
|
|
};
|
|
|
|
// 如果是编辑模式，添加ID
|
|
if (isEditMode && formData.id) {
|
|
evaluationPointData.id = formData.id;
|
|
}
|
|
|
|
// 打印最终发送的数据
|
|
console.log("最终API数据格式:", JSON.stringify(evaluationPointData, null, 2));
|
|
|
|
return evaluationPointData;
|
|
};
|
|
|
|
// 保存评查点
|
|
const handleSave = async () => {
|
|
try {
|
|
setIsLoading(true);
|
|
const evaluationPointData = formatDataForApi(formData);
|
|
console.log("保存数据:", evaluationPointData);
|
|
|
|
// 确定使用的HTTP方法和URL
|
|
let method = 'POST';
|
|
let endpoint = 'http://127.0.0.1:9000/admin/evaluation_points';
|
|
|
|
|
|
// 如果是编辑模式，使用PATCH更新现有记录
|
|
if (isEditMode && formData.id) {
|
|
method = 'PATCH';
|
|
endpoint = `http://127.0.0.1:9000/admin/evaluation_points?id=eq.${formData.id}`;
|
|
}
|
|
|
|
console.log(`发送${method}请求到`, endpoint);
|
|
|
|
// 发送数据到API
|
|
const response = await fetch(endpoint, {
|
|
method: method,
|
|
body: JSON.stringify(evaluationPointData)
|
|
});
|
|
|
|
// 输出完整响应信息
|
|
console.log("响应状态:", response.status, response.statusText);
|
|
|
|
if (!response.ok) {
|
|
const errorText = await response.text();
|
|
console.error(`API响应错误: ${response.status}`, errorText);
|
|
try {
|
|
// 尝试解析错误响应为JSON
|
|
const errorJson = JSON.parse(errorText);
|
|
console.error("解析的错误JSON:", errorJson);
|
|
throw new Error(`API响应错误: ${errorJson.msg || response.statusText}`);
|
|
} catch (parseError) {
|
|
// 如果无法解析为JSON，使用原始文本
|
|
throw new Error(`API响应错误: ${response.status} - ${errorText}`);
|
|
}
|
|
}
|
|
|
|
const contentType = response.headers.get('content-type');
|
|
console.log("响应Content-Type:", contentType);
|
|
|
|
// 检查是否是JSON响应
|
|
if (contentType && contentType.includes('application/json')) {
|
|
const responseData = await response.json();
|
|
console.log("API响应数据:", responseData);
|
|
|
|
// 处理多种可能的响应格式
|
|
if (Array.isArray(responseData)) {
|
|
if (responseData.length > 0) {
|
|
console.log("保存成功 (数组响应):", responseData[0]);
|
|
alert("保存成功!");
|
|
navigate('/rules');
|
|
} else {
|
|
console.warn("响应数组为空");
|
|
alert("操作已完成，但服务器未返回数据");
|
|
navigate('/rules');
|
|
}
|
|
} else if (responseData && typeof responseData === 'object') {
|
|
if (responseData.data) {
|
|
console.log("保存成功 (带data字段):", responseData.data);
|
|
alert("保存成功!");
|
|
navigate('/rules');
|
|
} else if (responseData.id) {
|
|
console.log("保存成功 (直接对象):", responseData);
|
|
alert("保存成功!");
|
|
navigate('/rules');
|
|
} else if (responseData.code === 0) {
|
|
console.log("保存成功 (带code字段):", responseData);
|
|
alert("保存成功!");
|
|
navigate('/rules');
|
|
} else {
|
|
console.warn("响应对象格式不符合预期", responseData);
|
|
alert("操作已完成，但返回的数据格式不符合预期");
|
|
navigate('/rules');
|
|
}
|
|
} else {
|
|
console.warn("响应不是数组或对象", responseData);
|
|
alert("操作已完成，但返回的数据格式不符合预期");
|
|
navigate('/rules');
|
|
}
|
|
} else {
|
|
// 非JSON响应
|
|
const text = await response.text();
|
|
console.log("非JSON响应:", text);
|
|
alert("操作已完成!");
|
|
navigate('/rules');
|
|
}
|
|
} catch (error) {
|
|
console.error('保存失败:', error);
|
|
alert(`保存失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
|
} finally {
|
|
setIsLoading(false);
|
|
}
|
|
};
|
|
|
|
// 保存为草稿
|
|
const handleSaveDraft = async () => {
|
|
try {
|
|
setIsLoading(true);
|
|
const draftData = formatDataForApi(formData, true);
|
|
console.log("保存草稿数据:", draftData);
|
|
|
|
// 确定使用的HTTP方法和URL
|
|
let method = 'POST';
|
|
let endpoint = 'http://127.0.0.1:9000/admin/evaluation_points';
|
|
|
|
|
|
// 如果是编辑模式，使用PATCH更新现有记录
|
|
if (isEditMode && formData.id) {
|
|
method = 'PATCH';
|
|
endpoint = `http://127.0.0.1:9000/admin/evaluation_points?id=eq.${formData.id}`;
|
|
}
|
|
|
|
console.log(`发送${method}请求到`, endpoint);
|
|
|
|
// 发送数据到API
|
|
const response = await fetch(endpoint, {
|
|
method: method,
|
|
body: JSON.stringify(draftData)
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const errorText = await response.text();
|
|
console.error(`API响应错误: ${response.status}`, errorText);
|
|
throw new Error(`API响应错误: ${response.status} - ${errorText}`);
|
|
}
|
|
|
|
const contentType = response.headers.get('content-type');
|
|
console.log("响应Content-Type:", contentType);
|
|
|
|
// 检查是否是JSON响应
|
|
if (contentType && contentType.includes('application/json')) {
|
|
const responseData = await response.json();
|
|
console.log("API响应数据:", responseData);
|
|
|
|
// 处理多种可能的响应格式
|
|
if (Array.isArray(responseData)) {
|
|
if (responseData.length > 0) {
|
|
console.log("保存草稿成功 (数组响应):", responseData[0]);
|
|
alert("草稿保存成功!");
|
|
navigate('/rules');
|
|
} else {
|
|
console.warn("响应数组为空");
|
|
alert("操作已完成，但服务器未返回数据");
|
|
navigate('/rules');
|
|
}
|
|
} else if (responseData && typeof responseData === 'object') {
|
|
if (responseData.data) {
|
|
console.log("保存草稿成功 (带data字段):", responseData.data);
|
|
alert("草稿保存成功!");
|
|
navigate('/rules');
|
|
} else if (responseData.id) {
|
|
console.log("保存草稿成功 (直接对象):", responseData);
|
|
alert("草稿保存成功!");
|
|
navigate('/rules');
|
|
} else if (responseData.code === 0) {
|
|
console.log("保存草稿成功 (带code字段):", responseData);
|
|
alert("草稿保存成功!");
|
|
navigate('/rules');
|
|
} else {
|
|
console.warn("响应对象格式不符合预期", responseData);
|
|
alert("操作已完成，但返回的数据格式不符合预期");
|
|
navigate('/rules');
|
|
}
|
|
} else {
|
|
console.warn("响应不是数组或对象", responseData);
|
|
alert("操作已完成，但返回的数据格式不符合预期");
|
|
navigate('/rules');
|
|
}
|
|
} else {
|
|
// 非JSON响应
|
|
const text = await response.text();
|
|
console.log("非JSON响应:", text);
|
|
alert("操作已完成!");
|
|
navigate('/rules');
|
|
}
|
|
} catch (error) {
|
|
console.error('保存草稿失败:', error);
|
|
alert(`保存草稿失败: ${error instanceof Error ? error.message : '未知错误'}`);
|
|
} finally {
|
|
setIsLoading(false);
|
|
}
|
|
};
|
|
|
|
return (
|
|
<div className="container">
|
|
<PageHeader
|
|
title={isEditMode ? "编辑评查点" : "新增评查点"}
|
|
onSave={handleSave}
|
|
/>
|
|
|
|
{isLoading ? (
|
|
<div className="flex justify-center items-center p-12">
|
|
<div className="loading-spinner"></div>
|
|
<span className="ml-3">加载中...</span>
|
|
</div>
|
|
) : (
|
|
<>
|
|
<div className="mb-8">
|
|
<BasicInfo onChange={handleBasicInfoChange} initialData={formData} />
|
|
</div>
|
|
|
|
<div className="mb-8">
|
|
<RuleContext.Provider value={{ extractionFields, updateFields: updateExtractionFields }}>
|
|
<ExtractionSettings
|
|
onChange={handleExtractionSettingsChange}
|
|
initialData={{
|
|
llm_ocr: formData.extraction_config.llm_ocr,
|
|
llm_vl: formData.extraction_config.llm_vl,
|
|
ocr_regex: formData.extraction_config.ocr_regex
|
|
}}
|
|
/>
|
|
</RuleContext.Provider>
|
|
</div>
|
|
|
|
<div className="mb-8">
|
|
<RuleContext.Provider value={{ extractionFields, updateFields: updateExtractionFields }}>
|
|
<ReviewSettings
|
|
onChange={handleReviewSettingsChange}
|
|
initialData={{
|
|
rules: formData.evaluation_config.rules,
|
|
combinationLogic: formData.evaluation_config.logicType,
|
|
customLogic: formData.evaluation_config.customLogic,
|
|
pass_message: formData.pass_message,
|
|
fail_message: formData.fail_message,
|
|
suggestion_message: formData.suggestion_message,
|
|
suggestion_message_type: formData.suggestion_message_type,
|
|
post_action: formData.post_action,
|
|
action_config: formData.action_config
|
|
}}
|
|
/>
|
|
</RuleContext.Provider>
|
|
</div>
|
|
|
|
<ActionButtons
|
|
onSave={handleSave}
|
|
onSaveDraft={handleSaveDraft}
|
|
isEditMode={isEditMode}
|
|
/>
|
|
</>
|
|
)}
|
|
</div>
|
|
);
|
|
}
|