Merge branch 'awen' into shiy

This commit is contained in:
2025-04-11 21:08:58 +08:00
34 changed files with 10590 additions and 54 deletions
+458
View File
@@ -0,0 +1,458 @@
/**
* 评查详情页面
*
* 功能概述:
* - 显示文档评查结果和详细信息
* - 支持查看文档内容及评查点高亮标记
* - 提供评查点列表,分为通过、警告和错误三种类型
* - 支持评查点处理,如一键替换、人工审核等功能
* - 支持导出评查报告和下载原文件
*
* 组件结构:
* - FileInfo: 显示文件基本信息和操作按钮
* - ReviewTabs: 页面选项卡,包括评查结果、AI智能分析和文件信息
* - FilePreview: 文档预览组件,显示文档内容及高亮问题
* - ReviewPointsList: 评查点列表组件,显示所有评查结果
* - AIAnalysis: AI智能分析结果,提供综合评价
* - FileDetails: 文件详情信息
*
* 数据流转:
* 1. 页面加载时从API获取评查详情数据
* 2. 根据评查点ID关联文档中的高亮区域
* 3. 点击评查点时在文档中定位对应位置
* 4. 处理评查点时更新状态并反馈到UI
*
* @author 中国烟草AI合同及卷宗审核系统开发团队
*/
import { type MetaFunction } from "@remix-run/node";
import { useState, useEffect } from "react";
import { useNavigate } from "@remix-run/react";
import reviewsStyles from "~/styles/reviews.css?url";
// 导入评查详情页面组件
import {
FileInfo,
ReviewTabs,
FilePreview,
ReviewPointsList,
AIAnalysis,
FileDetails
} from "~/components/reviews";
// 定义评查点类型
interface ReviewPoint {
id: string;
title: string;
location: string;
status: string;
content: string;
suggestion: string;
needsHumanReview?: boolean;
humanReviewNote?: string;
humanReviewBy?: string;
humanReviewTime?: string;
position?: {
section: string;
index: number;
};
}
// 定义统计数据类型
interface Statistics {
total: number;
success: number;
warning: number;
error: number;
score: number;
}
// 定义文件信息类型
interface FileInfo {
fileName: string;
contractNumber: string;
fileSize: string;
fileFormat: string;
pageCount: number;
uploadTime: string;
uploadUser: string;
}
// 定义合同信息类型
interface ContractInfo {
contractType: string;
signDate: string;
parties: {
partyA: string;
partyB: string;
};
amount: string;
period: string;
}
// 定义评查信息类型
interface ReviewInfo {
reviewTime: string;
reviewModel: string;
ruleGroup: string;
result: string;
issueCount: number;
}
// 定义文档内容类型
interface FileContent {
title: string;
contractNumber: string;
parties: {
partyA: {
name: string;
address: string;
representative: string;
phone: string;
};
partyB: {
name: string;
address: string;
representative: string;
phone: string;
};
};
sections: {
title: string;
content: string;
}[];
}
// 定义分析项类型
interface AnalysisItem {
title: string;
content: string;
description: string;
}
// 定义分析数据类型
interface AnalysisData {
riskAlerts: AnalysisItem[];
suggestions: AnalysisItem[];
summary: string;
}
// 定义评查数据类型
interface ReviewData {
fileInfo: FileInfo;
contractInfo: ContractInfo;
reviewInfo: ReviewInfo;
statistics: Statistics;
fileContent: FileContent;
reviewPoints: ReviewPoint[];
aiAnalysis: AnalysisData;
}
export const meta: MetaFunction = () => {
return [
{ title: "评查详情 - 中国烟草AI合同及卷宗审核系统" },
{
name: "description",
content: "查看文档评查结果,处理问题点,确认评查结果"
}
];
};
export function links() {
return [{ rel: "stylesheet", href: reviewsStyles }];
}
export const handle = {
breadcrumb: "评查详情"
};
export default function ReviewDetails() {
const navigate = useNavigate();
const [isLoading, setIsLoading] = useState(true);
const [activeTab, setActiveTab] = useState<string>('preview'); // 'preview', 'analysis', 'fileinfo'
const [reviewData, setReviewData] = useState<ReviewData | null>(null);
const [activeReviewPointId, setActiveReviewPointId] = useState<string | null>(null);
// 模拟获取评查数据
useEffect(() => {
// 模拟API请求延迟
const timer = setTimeout(() => {
// 模拟评查数据
const mockData = getMockReviewData();
setReviewData(mockData);
setIsLoading(false);
// 默认选中第一个评查点
if (mockData.reviewPoints.length > 0) {
setActiveReviewPointId(mockData.reviewPoints[0].id);
}
}, 800);
return () => clearTimeout(timer);
}, []);
const handleTabChange = (tabKey: string) => {
setActiveTab(tabKey);
};
const handleReviewPointSelect = (reviewPointId: string) => {
setActiveReviewPointId(reviewPointId);
};
const handleReviewPointStatusChange = (reviewPointId: string, newStatus: string) => {
// 更新评查点状态
if (reviewData) {
const updatedReviewPoints = reviewData.reviewPoints.map(point =>
point.id === reviewPointId ? { ...point, status: newStatus } : point
);
setReviewData({
...reviewData,
reviewPoints: updatedReviewPoints,
statistics: calculateStatistics(updatedReviewPoints)
});
}
};
const handleConfirmResults = () => {
alert('评查结果已确认');
navigate('/reviews'); // 假设评查列表页面路径为 /reviews
};
return (
<div className="container">
{isLoading ? (
<div className="flex justify-center items-center p-12">
<div className="loading-spinner"></div>
<span className="ml-3">...</span>
</div>
) : reviewData && (
<>
{/* 文件信息和操作按钮 */}
<FileInfo
fileInfo={reviewData.fileInfo}
onConfirmResults={handleConfirmResults}
/>
{/* 选项卡 */}
<ReviewTabs
activeTab={activeTab}
onTabChange={handleTabChange}
>
{/* 评查结果选项卡内容 */}
{activeTab === 'preview' && (
<div className="flex flex-col lg:flex-row space-y-4 lg:space-y-0 lg:space-x-4">
{/* 左侧:文件预览 */}
<div className="w-full lg:w-2/3">
<FilePreview
fileContent={reviewData.fileContent}
reviewPoints={reviewData.reviewPoints}
activeReviewPointId={activeReviewPointId}
/>
</div>
{/* 右侧:评查结果 */}
<div className="w-full lg:w-1/3">
<ReviewPointsList
reviewPoints={reviewData.reviewPoints}
statistics={reviewData.statistics}
activeReviewPointId={activeReviewPointId}
onReviewPointSelect={handleReviewPointSelect}
onStatusChange={handleReviewPointStatusChange}
/>
</div>
</div>
)}
{/* AI智能分析选项卡内容 */}
{activeTab === 'analysis' && (
<AIAnalysis
analysisData={reviewData.aiAnalysis}
score={reviewData.statistics.score}
onConfirmResults={handleConfirmResults}
/>
)}
{/* 文件信息选项卡内容 */}
{activeTab === 'fileinfo' && (
<FileDetails
fileInfo={reviewData.fileInfo}
contractInfo={reviewData.contractInfo}
reviewInfo={reviewData.reviewInfo}
/>
)}
</ReviewTabs>
</>
)}
</div>
);
}
// 计算评查统计数据
function calculateStatistics(reviewPoints: ReviewPoint[]): Statistics {
const total = reviewPoints.length;
const success = reviewPoints.filter(point => point.status === 'success').length;
const warning = reviewPoints.filter(point => point.status === 'warning').length;
const error = reviewPoints.filter(point => point.status === 'error').length;
// 计算评分:通过占总数的百分比,错误项有额外惩罚
const score = Math.round((success / total) * 100 - (error * 5));
return {
total,
success,
warning,
error,
score: Math.max(0, Math.min(100, score)) // 确保分数在0-100之间
};
}
// 模拟评查数据
function getMockReviewData(): ReviewData {
return {
fileInfo: {
fileName: "烟草产品销售合同(2023版).docx",
contractNumber: "XS-2023-1025-001",
fileSize: "5.2MB",
fileFormat: "DOCX",
pageCount: 5,
uploadTime: "2023-10-25 14:30:45",
uploadUser: "张三"
},
contractInfo: {
contractType: "销售合同",
signDate: "2023年10月20日",
parties: {
partyA: "XX烟草公司",
partyB: "YY贸易有限公司"
},
amount: "¥ 1,580,000.00",
period: "2023年11月1日至2024年10月31日"
},
reviewInfo: {
reviewTime: "2023-10-25 14:35:12",
reviewModel: "DeepSeek",
ruleGroup: "合同标准规则组",
result: "warning",
issueCount: 9
},
statistics: {
total: 15,
success: 6,
warning: 7,
error: 2,
score: 75
},
fileContent: {
title: "烟草产品销售合同",
contractNumber: "XS-2023-1025-001",
parties: {
partyA: {
name: "XX烟草公司",
address: "XX省XX市XX区XX路XX号",
representative: "张XX",
phone: "123-4567-8901"
},
partyB: {
name: "YY贸易有限公司",
address: "XX省XX市XX区YY路YY号",
representative: "李YY",
phone: "123-4567-8902"
}
},
sections: [
{
title: "总则",
content: "1.1 本合同适用于甲乙双方之间的烟草制品买卖事宜。\n1.2 双方应本着平等互利、诚实信用的原则履行本合同。"
},
{
title: "合同标的物",
content: "2.1 产品名称:烟草制品\n2.2 规格型号:如附件所列\n2.3 数量:5000箱\n2.4 质量要求:符合国家标准GB/T XXXXX-XXXX"
},
{
title: "交货与付款",
content: "3.1 交货时间:自合同签订之日起30日内。\n3.2 乙方应在收到货物之日起5个工作日内支付合同款项,甲方应在收到乙方全部付款后开具增值税专用发票,乙方应在收到发票后支付剩余款项。\n3.3 交货地点:乙方指定的仓库。\n3.4 运输方式:陆运,运费由甲方承担。"
},
{
title: "合同文本",
content: "本合同一式两份,甲乙双方各执一份,具有同等法律效力。"
}
]
},
reviewPoints: [
{
id: "1",
title: "付款条件描述不明确",
location: "付款条款清晰性",
status: "error",
content: "乙方应在收到货物之日起5个工作日内支付合同款项,甲方应在收到乙方全部付款后开具增值税专用发票,乙方应在收到发票后支付剩余款项。",
suggestion: "乙方应在收到货物验收合格之日起5个工作日内支付合同总额的70%,甲方收到该部分款项后3个工作日内向乙方开具等额增值税专用发票;乙方应在收到发票之日起5个工作日内支付剩余30%款项。",
position: { section: "交货与付款", index: 2 }
},
{
id: "2",
title: "违约责任条款缺失",
location: "合同权利义务对等性",
status: "warning",
content: "如合同发生纠纷,双方应协商解决。",
suggestion: "如合同发生纠纷,双方应友好协商解决;协商不成的,任何一方均有权向甲方所在地人民法院提起诉讼。任何一方未能履行本合同约定义务,应向守约方支付合同总金额的10%作为违约金;给对方造成损失的,还应赔偿由此产生的全部损失。",
position: { section: "争议解决", index: 0 }
},
{
id: "3",
title: "签章不完整",
location: "合同签署规范性",
status: "warning",
content: "乙方(盖章):YY贸易有限公司\n代表人签字:李YY\n日期:2023年10月20日",
suggestion: "需要联系甲方补充公章",
needsHumanReview: true,
humanReviewNote: "需要联系甲方补充公章",
position: { section: "签章", index: 0 }
},
{
id: "9",
title: "交货方式描述模糊",
location: "履行条款明确性",
status: "success",
content: "3.4 运输方式:陆运,运费由甲方承担。",
suggestion: "建议补充具体的运输方式和时间",
needsHumanReview: true,
humanReviewNote: "经核实,该交货方式虽然描述不够详细,但符合行业惯例且双方已经多次合作,不会造成实际履行障碍。",
humanReviewBy: "王法务",
humanReviewTime: "2023-11-05 14:30:22",
position: { section: "交货与付款", index: 4 }
},
{
id: "10",
title: "法律适用条款缺失",
location: "争议解决条款完整性",
status: "error",
content: "",
suggestion: "第十三条 法律适用\n本合同的订立、效力、解释、履行及争议的解决均适用中华人民共和国法律。因本合同引起的或与本合同有关的任何争议,双方应友好协商解决。协商不成的,提交甲方所在地人民法院诉讼解决。",
position: { section: "缺失", index: 0 }
}
],
aiAnalysis: {
riskAlerts: [
{
title: "风险提示",
content: "本合同缺少违约责任条款,可能导致权责不明。",
description: "根据《中华人民共和国民法典》第五百七十七条规定,建议增加违约责任条款,明确双方违约责任及赔偿方式。"
},
{
title: "完整性检查",
content: "本合同缺少法律适用条款。",
description: "根据行业惯例,销售合同应明确约定适用法律和纠纷解决方式,以避免后续争议解决时的不确定性。"
}
],
suggestions: [
{
title: "优化建议",
content: "建议完善付款条件描述。",
description: "目前合同中关于付款条件的描述存在歧义,可能导致付款时间和条件不明确。建议按系统修改建议优化。"
}
],
summary: "本合同基本结构完整,主体内容清晰,但存在多处条款描述不完善的问题,主要体现在支付条件、违约责任、不可抗力、保密条款、合同终止条件等方面。这些问题虽不影响合同的基本合规性,但可能在合同履行过程中引发争议和纠纷。同时,合同签章不完整,也影响了合同的法律效力。建议对上述问题进行修改完善后再行签署。"
}
};
}
+103
View File
@@ -0,0 +1,103 @@
import { type MetaFunction, LinksFunction } from "@remix-run/node";
import { useState } 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";
export const meta: MetaFunction = () => {
return [
{ title: "新增评查点 - 中国烟草AI合同及卷宗审核系统" },
{
name: "description",
content: "创建新的评查点,设置规则参数"
}
];
};
export const links: LinksFunction = () => [
{ rel: "stylesheet", href: rulesStyles }
];
export const handle = {
breadcrumb: "新增评查点"
};
export default function RuleNew() {
// 用于保存抽取字段的状态,在抽取设置和评查设置组件之间共享
const [extractionFields, setExtractionFields] = useState<string[]>([]);
const updateExtractionFields = (fields: string[]) => {
setExtractionFields(fields);
};
const handleSave = () => {
// 实现保存逻辑
console.log('保存评查点');
};
const handleSaveDraft = () => {
// 实现保存草稿逻辑
console.log('保存为草稿');
};
const handleExtractionChange = (data: Record<string, unknown>) => {
// 使用合并后的所有字段列表
if (data.allFields && Array.isArray(data.allFields)) {
updateExtractionFields(data.allFields);
return;
}
// 旧版本兼容逻辑
if (data.fields) {
// 尝试获取合并的字段列表
if (Array.isArray(data.fields)) {
updateExtractionFields(data.fields);
} else {
const fieldData = data.fields as Record<string, string[]>;
const currentMethod = data.extractionMethod as string;
// 提取当前抽取方法的字段
if (fieldData[currentMethod]) {
updateExtractionFields(fieldData[currentMethod]);
}
}
} else if (data.regexFields) {
// 处理正则字段情况
const regexFields = data.regexFields as { id: string; fieldName: string; regex: string }[];
const fieldNames = regexFields
.map(field => field.fieldName)
.filter(name => name.trim() !== '');
updateExtractionFields(fieldNames);
}
};
return (
<RuleContext.Provider value={{ extractionFields, updateExtractionFields }}>
<div className="px-4 py-6 bg-white border-b border-gray-200 shadow-sm">
<PageHeader
title="新增评查点"
onSave={handleSave}
/>
</div>
<div className="container py-6">
<div className="px-4">
<BasicInfo />
<ExtractionSettings onChange={handleExtractionChange} />
<ReviewSettings />
<ActionButtons
onSave={handleSave}
onSaveDraft={handleSaveDraft}
/>
</div>
</div>
</RuleContext.Provider>
);
}
+766
View File
@@ -0,0 +1,766 @@
/**
* 评查点管理页面 - 创建或编辑评查点规则
*
* 功能概述:
* - 支持创建新的评查点规则或编辑现有规则
* - 评查点包含基本信息、抽取设置和评查设置三大部分
* - 支持使用三种抽取方式: 大模型(LLM)抽取、多模态(VLM)抽取和正则表达式抽取
* - 支持配置各种类型的评查规则,如存在性检查、内容一致性检查等
* - 支持保存评查规则和保存草稿功能
*
* 组件结构:
* - PageHeader: 页面标题和保存按钮
* - BasicInfo: 评查点的基本信息设置,如名称、编码、风险级别等
* - ExtractionSettings: 抽取设置,配置从文档中抽取哪些字段及抽取方式
* - ReviewSettings: 评查设置,基于抽取字段配置评查规则、评查结果消息等
* - ActionButtons: 页面底部的操作按钮,包括保存、保存草稿和返回
*
* 数据流转:
* 1. 页面加载时检查URL参数,确定是新建还是编辑模式
* 2. 编辑模式下从API获取评查点数据并填充表单
* 3. ExtractionSettings通过RuleContext将抽取的字段传递给ReviewSettings
* 4. 各组件的onChange回调收集表单变更并更新formData状态
* 5. 保存时将formData转换为API需要的格式并提交
*
* @author 中国烟草AI合同及卷宗审核系统开发团队
*/
import { type MetaFunction } from "@remix-run/node";
import { useState, useEffect, useCallback } from "react";
import { BasicInfo } from "~/components/rules/new/BasicInfo";
import { ExtractionSettings } from "~/components/rules/new/ExtractionSettings";
import { ReviewSettings } 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";
// 导入评查点模型定义和常量
import type {
EvaluationPoint,
LogicOperator,
CompareMethod,
FormatType,
ComparisonOperator,
MatchType,
ProgrammingLanguage
} from "~/models/evaluation_points";
import { EVALUATION_OPTIONS } from "~/models/evaluation_points";
import type { EvaluationPointGroup } from "~/models/evaluation_point_groups";
// 导入RuleContext上下文
import { RuleContext } from "~/contexts/RuleContext";
export const meta: MetaFunction = () => {
return [
{ title: "评查点管理 - 中国烟草AI合同及卷宗审核系统" },
{
name: "description",
content: "创建或修改评查点,设置规则参数"
}
];
};
export function links() {
return [{ rel: "stylesheet", href: rulesStyles }];
}
export const handle = {
breadcrumb: "评查点管理"
};
// 添加规则配置接口
interface BaseRuleConfig {
availableFields?: string[];
}
interface ExistsRuleConfig extends BaseRuleConfig {
fields: string[];
logic: LogicOperator;
selectedFields?: string[];
existsLogic?: string;
}
interface ConsistencyRuleConfig extends BaseRuleConfig {
pairs: Array<{sourceField: string; targetField: string; compareMethod: CompareMethod}>;
logic: LogicOperator;
logicRelation?: string;
initialSourceField?: string;
initialTargetField?: string;
initialCompareMethod?: string;
}
interface FormatRuleConfig extends BaseRuleConfig {
field: string;
formatType: FormatType;
parameters: string;
checkField?: string;
formatParams?: string;
}
interface LogicRuleConfig extends BaseRuleConfig {
conditions: {
field: string;
operator: ComparisonOperator;
value: string;
}[];
logic: LogicOperator;
logicRelation?: string;
initialField?: string;
initialOperator?: string;
initialValue?: string;
}
interface RegexRuleConfig extends BaseRuleConfig {
field: string;
pattern: string;
matchType: MatchType;
checkField?: string;
regexPattern?: string;
}
interface AIRuleConfig extends BaseRuleConfig {
model: string;
temperature: number;
prompt: string;
}
interface CodeRuleConfig extends BaseRuleConfig {
language: ProgrammingLanguage;
code: string;
}
type RuleConfig = ExistsRuleConfig | ConsistencyRuleConfig | FormatRuleConfig | LogicRuleConfig | RegexRuleConfig | AIRuleConfig | CodeRuleConfig;
export default function RuleNew() {
const navigate = useNavigate();
const location = useLocation();
const [isEditMode, setIsEditMode] = useState(false);
const [isLoading, setIsLoading] = useState(false);
const [instanceKey, setInstanceKey] = useState<string>('new');
const [formData, setFormData] = useState<EvaluationPoint>({});
const [evaluationPointGroups, setEvaluationPointGroups] = useState<EvaluationPointGroup[]>([]);
// 添加用于共享的字段数据状态
const [extractionFields, setExtractionFields] = useState<string[]>([]);
/**
* 从表单数据中提取所有字段
* 用于编辑模式下初始化字段数据
*/
const extractFieldsFromFormData = useCallback((data: EvaluationPoint) => {
if (!data || !data.extraction_config) return [];
const fields: string[] = [];
const config = data.extraction_config;
// 提取LLM字段
if (config.llm && Array.isArray(config.llm.fields)) {
fields.push(...config.llm.fields);
}
// 提取VLM字段
if (config.vlm && Array.isArray(config.vlm.fields)) {
const vlmFields = config.vlm.fields.map((f: string | { name: string, type: string }) =>
typeof f === 'string' ? f : f.name
);
fields.push(...vlmFields);
}
// 提取正则字段
if (config.regex && Array.isArray(config.regex.fields)) {
const regexFields = config.regex.fields.map((f: { field: string, pattern: string }) => f.field).filter(Boolean);
fields.push(...regexFields);
}
return fields;
}, []);
/**
* 重置表单数据到默认状态
*/
const resetFormData = useCallback(() => {
console.log("重置表单数据到默认状态");
setFormData({
name: '',
code: '',
risk: 'low',
is_enabled: true,
description: '',
references_laws: { name: '', articles: [], content: '' },
evaluation_point_groups_pid: null,
evaluation_point_groups_id: null,
extraction_config: {
llm: {
fields: [],
prompt_setting: {
type: 'system',
template: ''
}
},
vlm: {
fields: [],
prompt_setting: {
type: 'system',
template: ''
}
},
regex: {
fields: []
}
},
evaluation_config: {
logicType: 'and',
customLogic: '',
rules: []
},
pass_message: '文档检查通过,符合规范要求。',
fail_message: '文档存在以下问题,请修改后重新提交。',
suggestion_message: '',
suggestion_message_type: 'warning',
post_action: 'none',
action_config: '',
score: 0
});
setExtractionFields([]);
// 生成新的实例键,强制所有子组件重新渲染
setInstanceKey(`new_${Date.now()}`);
}, []);
/**
* 获取评查点数据
* 编辑模式下从API获取指定ID的评查点数据
* @param id 评查点ID
*/
const fetchEvaluationPoint = useCallback(async (id: number) => {
try {
setIsLoading(true);
console.log(`获取评查点数据,ID: ${id}`);
const response = await fetch(`http://172.16.0.119:9000/admin/evaluation_points?id=eq.${id}`, {
method: 'GET',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json'
}
});
console.log(response);
if (response.ok) {
const data = await response.json();
if (data.data && data.data[0]) {
setFormData(data.data[0]);
// 初始化extractionFields
const extractedFields = extractFieldsFromFormData(data.data[0]);
setExtractionFields(extractedFields);
// 设置编辑模式的实例键
setInstanceKey(`edit_${id}_${Date.now()}`);
} else {
console.error('获取数据失败: 返回数据为空');
alert('获取数据失败: 返回数据为空');
resetFormData();
navigate('/rules');
}
} else {
throw new Error(`响应状态: ${response.status}`);
}
} catch (error) {
console.error('获取评查点数据失败:', error);
alert(`获取评查点数据失败: ${error instanceof Error ? error.message : '未知错误'}`);
// 获取数据失败时返回上一页
resetFormData();
navigate('/rules');
} finally {
setIsLoading(false);
}
}, [navigate, extractFieldsFromFormData, resetFormData]);
/**
* 获取评查点组数据
* 从API获取所有评查点组,用于基本信息表单中选择
*/
const fetchEvaluationPointGroups = useCallback(async () => {
try {
console.log("获取评查点组数据");
const response = await fetch("http://172.16.0.119:9000/admin/evaluation_point_groups", {
method: 'GET',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json'
}
});
console.log(response);
if (response.ok) {
const data = await response.json();
setEvaluationPointGroups(data.data);
}
} catch (error) {
console.error('获取评查点组数据失败:', error);
// 显示错误提示但不影响应用继续使用
alert(`获取评查点组数据失败: ${error instanceof Error ? error.message : '未知错误'}\n将使用默认数据`);
}
}, []);
const handleSave = () => {
console.log("保存评查点", formData);
// 验证必填字段
if (!formData.name?.trim()) {
alert("评查点名称不能为空");
return;
}
if (!formData.code?.trim()) {
alert("评查点编码不能为空");
return;
}
// 显示保存中状态
setIsLoading(true);
// 根据模式决定是创建还是更新
const apiMethod = isEditMode ? 'PATCH' : 'POST';
const apiUrl = isEditMode
? `http://172.16.0.119:9000/admin/evaluation_points?id=eq.${formData.id}`
: 'http://172.16.0.119:9000/admin/evaluation_points';
try {
// 创建一个符合数据库模式的数据副本
const cleanedData = {
id: formData.id,
name: formData.name?.trim(),
code: formData.code?.trim(),
risk: formData.risk || 'low',
is_enabled: formData.is_enabled !== undefined ? formData.is_enabled : true,
description: formData.description || '',
references_laws: formData.references_laws || null,
evaluation_point_groups_pid: formData.evaluation_point_groups_pid || null,
evaluation_point_groups_id: formData.evaluation_point_groups_id || null,
extraction_config: {
llm: {
fields: Array.isArray(formData.extraction_config?.llm?.fields) ?
[...formData.extraction_config.llm.fields] : [],
prompt_setting: {
type: formData.extraction_config?.llm?.prompt_setting?.type || 'system',
template: formData.extraction_config?.llm?.prompt_setting?.template || ''
}
},
vlm: {
fields: Array.isArray(formData.extraction_config?.vlm?.fields) ?
[...formData.extraction_config.vlm.fields] : [],
prompt_setting: {
type: formData.extraction_config?.vlm?.prompt_setting?.type || 'system',
template: formData.extraction_config?.vlm?.prompt_setting?.template || ''
}
},
regex: {
fields: Array.isArray(formData.extraction_config?.regex?.fields) ?
[...formData.extraction_config.regex.fields] : []
}
},
evaluation_config: {
logicType: formData.evaluation_config?.logicType || 'and',
customLogic: formData.evaluation_config?.customLogic || '',
rules: Array.isArray(formData.evaluation_config?.rules) ?
formData.evaluation_config.rules.map(rule => ({
id: rule.id || '1',
type: rule.type || '',
config: rule.config || {}
})) : []
},
pass_message: formData.pass_message || '文档检查通过,符合规范要求。',
fail_message: formData.fail_message || '文档存在以下问题,请修改后重新提交。',
suggestion_message: formData.suggestion_message || '',
suggestion_message_type: formData.suggestion_message_type || 'warning',
post_action: formData.post_action || 'none',
action_config: formData.action_config || '',
score: formData.score !== undefined ? Number(formData.score) : 0
};
// 确保rules中的每个配置对象都被正确处理
if (cleanedData.evaluation_config && Array.isArray(cleanedData.evaluation_config.rules)) {
cleanedData.evaluation_config.rules = cleanedData.evaluation_config.rules
.filter(rule => rule && rule.type) // 确保规则有类型
.map(rule => {
// 根据规则类型确保config中有必要的字段
const config = { ...rule.config } as RuleConfig;
switch (rule.type) {
case 'exists':
if (!Array.isArray((config as ExistsRuleConfig).fields)) (config as ExistsRuleConfig).fields = [];
if (!(config as ExistsRuleConfig).logic) (config as ExistsRuleConfig).logic = 'and';
// 删除不必要的字段
delete (config as ExistsRuleConfig & {availableFields?: string}).availableFields;
delete (config as ExistsRuleConfig).selectedFields;
delete (config as ExistsRuleConfig).existsLogic;
break;
case 'consistency':
if (!Array.isArray((config as ConsistencyRuleConfig).pairs)) (config as ConsistencyRuleConfig).pairs = [];
if (!(config as ConsistencyRuleConfig).logic) (config as ConsistencyRuleConfig).logic = 'and';
delete (config as ConsistencyRuleConfig & {availableFields?: string}).availableFields;
delete (config as ConsistencyRuleConfig).logicRelation;
delete (config as ConsistencyRuleConfig).initialSourceField;
delete (config as ConsistencyRuleConfig).initialTargetField;
delete (config as ConsistencyRuleConfig).initialCompareMethod;
break;
case 'format':
if (!(config as FormatRuleConfig).field) (config as FormatRuleConfig).field = '';
if (!(config as FormatRuleConfig).formatType) (config as FormatRuleConfig).formatType = 'date';
if (!(config as FormatRuleConfig).parameters) (config as FormatRuleConfig).parameters = '';
delete (config as FormatRuleConfig & {availableFields?: string}).availableFields;
delete (config as FormatRuleConfig).checkField;
delete (config as FormatRuleConfig).formatParams;
break;
case 'logic':
if (!Array.isArray((config as LogicRuleConfig).conditions)) (config as LogicRuleConfig).conditions = [];
if (!(config as LogicRuleConfig).logic) (config as LogicRuleConfig).logic = 'and';
delete (config as LogicRuleConfig & {availableFields?: string}).availableFields;
delete (config as LogicRuleConfig).logicRelation;
delete (config as LogicRuleConfig).initialField;
delete (config as LogicRuleConfig).initialOperator;
delete (config as LogicRuleConfig).initialValue;
break;
case 'regex':
if (!(config as RegexRuleConfig).field) (config as RegexRuleConfig).field = '';
if (!(config as RegexRuleConfig).pattern) (config as RegexRuleConfig).pattern = '';
if (!(config as RegexRuleConfig).matchType) (config as RegexRuleConfig).matchType = 'match';
delete (config as RegexRuleConfig & {availableFields?: string}).availableFields;
delete (config as RegexRuleConfig).checkField;
delete (config as RegexRuleConfig).regexPattern;
break;
case 'ai':
if (!(config as AIRuleConfig).model) (config as AIRuleConfig).model = 'qwen14b';
if (typeof (config as AIRuleConfig).temperature !== 'number') (config as AIRuleConfig).temperature = 0.1;
if (!(config as AIRuleConfig).prompt) (config as AIRuleConfig).prompt = '';
delete (config as AIRuleConfig & {availableFields?: string}).availableFields;
break;
case 'code':
if (!(config as CodeRuleConfig).language) (config as CodeRuleConfig).language = 'javascript';
if (!(config as CodeRuleConfig).code) (config as CodeRuleConfig).code = '';
delete (config as CodeRuleConfig & {availableFields?: string}).availableFields;
break;
}
return {
id: rule.id,
type: rule.type,
config
};
});
}
// 如果是新建模式,则删除id字段
if (!isEditMode) {
delete cleanedData.id;
}
// 确保extraction_config和evaluation_config是有效的JSON对象
// 通过先序列化再解析来验证
try {
JSON.parse(JSON.stringify(cleanedData.extraction_config));
} catch (e) {
throw new Error("extraction_config 格式无效");
}
try {
JSON.parse(JSON.stringify(cleanedData.evaluation_config));
} catch (e) {
throw new Error("evaluation_config 格式无效");
}
// 检查JSON字符串长度,如果太长可能会被截断
const jsonData = JSON.stringify(cleanedData);
const maxLength = 65536; // 通常PostgreSQL的jsonb列可以存储的最大长度
if (jsonData.length > maxLength) {
throw new Error(`数据大小超过限制 (${jsonData.length} > ${maxLength})`);
}
console.log("准备提交到API的数据:", cleanedData);
console.log("JSON数据长度:", jsonData.length);
// 发送数据到API
fetch(apiUrl, {
method: apiMethod,
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json'
},
body: JSON.stringify(cleanedData)
})
.then(async response => {
// 尝试解析响应内容
let responseData;
try {
responseData = await response.json();
} catch (e) {
responseData = { code: 500, msg: "响应解析失败" };
}
// 根据响应码处理不同情况
if (responseData.code === 0) {
// 成功情况
console.log("保存成功:", responseData);
// 获取新创建或更新的评查点ID
const savedPointId = responseData.data[0]?.id;
if (savedPointId) {
// 显示成功消息
alert(`评查点${isEditMode ? '更新' : '创建'}成功!`);
// 保存成功后跳转到编辑页面,加载刚保存的数据
navigate(`/rules/new?id=${savedPointId}`);
} else {
// 无法获取ID的情况
alert(`评查点${isEditMode ? '更新' : '创建'}成功,但无法获取ID。正在返回列表页面。`);
navigate('/rules');
}
} else {
// 处理各种错误情况
console.error("API错误:", responseData);
// 根据错误码显示不同的错误消息
switch (responseData.code) {
case 400:
alert(`参数错误: ${responseData.msg}`);
break;
case 401:
alert(`未授权: ${responseData.msg}`);
break;
case 403:
alert(`禁止访问: ${responseData.msg}`);
break;
case 404:
alert(`未找到资源: ${responseData.msg}`);
break;
case 409:
alert(`资源冲突: ${responseData.msg}`);
break;
case 500:
alert(`服务器错误: ${responseData.msg}`);
break;
default:
alert(`保存失败: ${responseData.msg || '未知错误'}`);
}
}
})
.catch(error => {
console.error("网络或解析错误:", error);
alert(`网络或解析错误: ${error.message || '未知错误'}`);
})
.finally(() => {
setIsLoading(false);
});
} catch (error) {
console.error("数据处理错误:", error);
alert(`数据处理错误: ${error instanceof Error ? error.message : '未知错误'}`);
setIsLoading(false);
}
}
const handleSaveDraft = () => {
console.log("保存草稿");
}
const handleBasicInfoChange = (data: Record<string, unknown>) => {
setFormData(prev => ({ ...prev, ...data }));
}
const handleExtractionSettingsChange = (data: Record<string, unknown>) => {
setFormData(prev => ({ ...prev, ...data }));
// 提取并处理字段数据
const processFields = () => {
// 使用类型断言处理字段访问
const extractionConfig = data.extraction_config as {
llm?: { fields?: string[] };
vlm?: { fields?: Array<string | { name: string, type: string }> };
regex?: { fields?: Array<{ field: string, pattern: string }> };
} | undefined;
if (!extractionConfig) return;
const llmFields = extractionConfig.llm?.fields || [];
const vlmFields = extractionConfig.vlm?.fields || [];
const regexFields = (extractionConfig.regex?.fields || []).map((f: { field: string }) => f.field);
// 合并所有字段
const allFields = [
...llmFields,
...vlmFields.map((f: string | { name: string }) => typeof f === 'string' ? f : f.name),
...regexFields
].filter(Boolean);
setExtractionFields(allFields);
};
// 处理字段数据
if (data.extraction_config) {
processFields();
}
};
const handleReviewSettingsChange = (data: Record<string, unknown>) => {
console.log("评查设置变更:", data);
// 检查数据中是否包含evaluation_config对象
if (data.evaluation_config) {
// 确保formData.evaluation_config存在并具有必要的默认属性
const currentConfig = formData.evaluation_config || {
logicType: 'and',
customLogic: '',
rules: []
};
// 合并评查配置数据
const mergedConfig = {
...currentConfig,
...(data.evaluation_config as object)
};
// 更新表单数据
setFormData(prev => ({
...prev,
evaluation_config: mergedConfig
}));
} else {
// 处理其他普通字段
setFormData(prev => ({ ...prev, ...data }));
}
}
/**
* 添加事件监听,处理抽取字段更新
*/
useEffect(() => {
// 定义事件处理函数
const handleExtractionFieldsUpdated = (event: CustomEvent<{fields: string[]}>) => {
const { fields } = event.detail;
if (Array.isArray(fields) && fields.length > 0) {
// 更新字段数据
setExtractionFields(fields);
}
};
// 添加事件监听
window.addEventListener('extraction-fields-updated', handleExtractionFieldsUpdated as EventListener);
// 清理函数
return () => {
window.removeEventListener('extraction-fields-updated', handleExtractionFieldsUpdated as EventListener);
};
}, []);
/**
* 页面加载时初始化处理
* 1. 检查URL参数,判断是新建还是编辑模式
* 2. 编辑模式下获取评查点数据
* 3. 获取评查点组数据(用于表单选择项)
*/
useEffect(() => {
const searchParams = new URLSearchParams(location.search);
const id = searchParams.get('id');
// 设置编辑模式
const newIsEditMode = !!id;
setIsEditMode(newIsEditMode);
if (id) {
// 编辑模式:获取数据
fetchEvaluationPoint(parseInt(id));
} else {
// 新建模式:重置表单数据
resetFormData();
}
// 获取评查点组数据
fetchEvaluationPointGroups();
}, [location.search, fetchEvaluationPoint, fetchEvaluationPointGroups, resetFormData]);
// 渲染页面内容
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>
) : (
<RuleContext.Provider value={{
extractionFields,
updateFields: setExtractionFields
}}>
{/* 使用key属性强制在模式切换时重新渲染所有组件 */}
<div key={instanceKey}>
{/* 评查点基本信息设置 */}
<div className="mb-8">
<BasicInfo
onChange={handleBasicInfoChange}
initialData={formData}
evaluationPointGroups={evaluationPointGroups}
riskOptions={EVALUATION_OPTIONS.riskLevelOptions}
/>
</div>
{/* 抽取设置 - 配置从文档中提取的字段 */}
<div className="mb-8">
<ExtractionSettings
onChange={handleExtractionSettingsChange}
initialData={formData}
promptTypeOptions={EVALUATION_OPTIONS.promptTypeOptions}
vlmFieldTypeOptions={EVALUATION_OPTIONS.vlmFieldTypeOptions}
/>
</div>
{/* 评查设置 - 配置评查规则、消息等 */}
<div className="mb-8">
<ReviewSettings
onChange={handleReviewSettingsChange}
initialData={{
rules: formData.evaluation_config?.rules || [],
combinationLogic: formData.evaluation_config?.logicType || 'and',
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 || 'warning',
post_action: formData.post_action || 'none',
action_config: formData.action_config || '',
score: formData.score !== undefined ? formData.score : 0
}}
ruleTypeOptions={EVALUATION_OPTIONS.ruleTypeOptions}
logicTypeOptions={EVALUATION_OPTIONS.logicTypeOptions}
logicOperatorOptions={EVALUATION_OPTIONS.logicOperatorOptions}
compareMethodOptions={EVALUATION_OPTIONS.compareMethodOptions}
formatTypeOptions={EVALUATION_OPTIONS.formatTypeOptions}
comparisonOperatorOptions={EVALUATION_OPTIONS.comparisonOperatorOptions}
matchTypeOptions={EVALUATION_OPTIONS.matchTypeOptions}
suggestionMessageTypeOptions={EVALUATION_OPTIONS.suggestionMessageTypeOptions}
postActionOptions={EVALUATION_OPTIONS.postActionOptions}
/>
</div>
{/* 底部操作按钮区域 */}
<ActionButtons
onSave={handleSave}
onSaveDraft={handleSaveDraft}
isEditMode={isEditMode}
/>
</div>
</RuleContext.Provider>
)}
</div>
);
}
File diff suppressed because it is too large Load Diff