From ebdf97aebf7d6072f65e883d3700bc1c9d662a8c Mon Sep 17 00:00:00 2001
From: awen <hzven@foxmail.com>
Date: Wed, 9 Apr 2025 01:34:14 +0800
Subject: [PATCH] =?UTF-8?q?=E5=9F=BA=E7=A1=80=E7=BB=84=E4=BB=B6=E5=AE=8C?=
 =?UTF-8?q?=E5=96=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 app/components/rules/new/BasicInfo.tsx        |  330 ++--
 .../rules/new/ExtractionSettings.tsx          |  130 +-
 app/components/rules/new/ReviewSettings.tsx   |   31 +-
 app/models/evaluation_point_groups.ts         |   15 +
 app/models/evaluation_points.ts               |  308 ++++
 app/routes/rules.new.tsx                      | 1582 ++---------------
 app/routes/rules.new1.tsx                     | 1539 ++++++++++++++++
 html/评查点-新增.html                         |    2 +-
 test-api.js                                   |  158 ++
 test-api2.js                                  |  108 ++
 test-rules-api.js                             |  162 ++
 11 files changed, 2673 insertions(+), 1692 deletions(-)
 create mode 100644 app/models/evaluation_point_groups.ts
 create mode 100644 app/models/evaluation_points.ts
 create mode 100644 app/routes/rules.new1.tsx
 create mode 100644 test-api.js
 create mode 100644 test-api2.js
 create mode 100644 test-rules-api.js

diff --git a/app/components/rules/new/BasicInfo.tsx b/app/components/rules/new/BasicInfo.tsx
index a532ee3..0c7d21d 100644
--- a/app/components/rules/new/BasicInfo.tsx
+++ b/app/components/rules/new/BasicInfo.tsx
@@ -1,182 +1,57 @@
 import React, { useState, useEffect } from 'react';
-
+import type { EvaluationPoint } from '~/models/evaluation_points';
+import type { EvaluationPointGroup } from '~/models/evaluation_point_groups';
 interface BasicInfoProps {
   onChange?: (data: Record<string, unknown>) => void;
-  initialData?: FormDataType;
-  evaluationPointGroups?: Array<{id: number, pid: number, code: string, name: string, is_enabled: boolean}>;
+  initialData?: EvaluationPoint;
+  evaluationPointGroups?: EvaluationPointGroup[];
+  riskOptions?: Array<{value: string, label: string}>;
 }
 
-// 定义表单数据类型
-interface FormDataType {
-  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;
-  evaluation_point_groups_pid: number | null;
-  type: string;
-  id?: number;
-}
-
-export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }: BasicInfoProps) {
-  const [formData, setFormData] = useState<FormDataType>({
-    name: '',
-    code: '',
-    risk: 'medium',
-    is_enabled: true,
-    description: '',
-    references_laws: {
-      name: '',
-      articles: [],
-      content: ''
-    },
-    evaluation_point_groups_id: null,
-    evaluation_point_groups_pid: null,
-    type: ''
+// 评查点基本信息组件
+export function BasicInfo({ onChange, initialData, evaluationPointGroups = [], riskOptions = [] }: BasicInfoProps) {
+  const [formData, setFormData] = useState<EvaluationPoint>({
+    risk: 'medium', // 风险等级 默认中风险
+    is_enabled: true, // 是否启用 默认启用
+    ...(initialData || {}) // 合并初始数据
   });
 
+  // 找到当前评查点类型对应的code
+  const getCheckpointTypeCode = () => {
+    if (!formData.evaluation_point_groups_pid) return "";
+    
+    const typeGroup = evaluationPointGroups.find(
+      group => group.id === formData.evaluation_point_groups_pid && group.pid === 0
+    );
+    
+    return typeGroup?.code || "";
+  };
+
+  // 评查点描述与法律依据 展开状态
   const [isDescExpanded, setIsDescExpanded] = useState(false);
-  const [lawArticlesInput, setLawArticlesInput] = useState('');
-  const [filteredRuleGroups, setFilteredRuleGroups] = useState<Array<{id: number, pid: number, code: string, name: string, is_enabled: boolean}>>([]);
+  
+  // 条款号临时输入字符串（不会触发自动分割）
+  const [lawArticlesText, setLawArticlesText] = useState('');
 
-  // 当initialData变化时更新表单数据
-  useEffect(() => {
-    if (initialData) {
-      const newFormData = {
-        name: initialData.name || '',
-        code: initialData.code || '',
-        risk: initialData.risk || 'medium',
-        is_enabled: initialData.is_enabled !== undefined ? initialData.is_enabled : true,
-        description: initialData.description || '',
-        references_laws: initialData.references_laws || {
-          name: '',
-          articles: [],
-          content: ''
-        },
-        evaluation_point_groups_id: initialData.evaluation_point_groups_id || null,
-        evaluation_point_groups_pid: initialData.evaluation_point_groups_pid || null,
-        type: initialData.type || ''
-      };
-      
-      setFormData(newFormData);
-      
-      // 更新法律条款输入框
-      if (initialData.references_laws && Array.isArray(initialData.references_laws.articles)) {
-        setLawArticlesInput(initialData.references_laws.articles.join(','));
-      }
-      
-      // 如果有描述或法律依据，默认展开详细信息
-      if (initialData.description || 
-          (initialData.references_laws && 
-           (initialData.references_laws.name || 
-            initialData.references_laws.content || 
-            (initialData.references_laws.articles && initialData.references_laws.articles.length > 0)))) {
-        setIsDescExpanded(true);
-      }
-    }
-  }, [initialData]);
-
-  // 当评查点类型或评查点组数据变化时，过滤规则组列表
-  useEffect(() => {
-    if (evaluationPointGroups && evaluationPointGroups.length > 0) {
-      console.log("评查点组数据更新，当前类型:", formData.type);
-      console.log("评查点组数据:", evaluationPointGroups);
-      
-      if (formData.type) {
-        // 获取所选评查点类型的组ID
-        const typeGroup = evaluationPointGroups.find(group => 
-          group.pid === 0 && 
-          group.code === formData.type
-        );
-        
-        console.log("找到的类型组:", typeGroup);
-        
-        if (typeGroup) {
-          // 更新评查点类型组ID
-          if (formData.evaluation_point_groups_pid !== typeGroup.id) {
-            const newData = { 
-              ...formData, 
-              evaluation_point_groups_pid: typeGroup.id 
-            };
-            setFormData(newData);
-            if (onChange) onChange(newData);
-          }
-          
-          // 过滤出属于该类型的规则组（pid等于类型组ID的项）
-          const groups = evaluationPointGroups.filter(group => 
-            group.pid === typeGroup.id && 
-            group.is_enabled
-          );
-          console.log("过滤后的规则组:", groups);
-          setFilteredRuleGroups(groups);
-          
-          // 如果当前选择的规则组不在过滤结果中，重置选择
-          if (formData.evaluation_point_groups_id && 
-              !groups.some(group => group.id === formData.evaluation_point_groups_id)) {
-            console.log("当前选择的规则组不在过滤结果中，重置选择");
-            const newData = { 
-              ...formData, 
-              evaluation_point_groups_id: null 
-            };
-            setFormData(newData);
-            if (onChange) onChange(newData);
-          }
-        } else {
-          console.log("未找到对应的类型组");
-          setFilteredRuleGroups([]);
-          
-          // 重置评查点类型组ID
-          if (formData.evaluation_point_groups_pid !== null) {
-            const newData = { 
-              ...formData, 
-              evaluation_point_groups_pid: null 
-            };
-            setFormData(newData);
-            if (onChange) onChange(newData);
-          }
-        }
-      } else {
-        console.log("未选择评查点类型");
-        setFilteredRuleGroups([]);
-        
-        // 重置评查点类型组ID
-        if (formData.evaluation_point_groups_pid !== null) {
-          const newData = { 
-            ...formData, 
-            evaluation_point_groups_pid: null 
-          };
-          setFormData(newData);
-          if (onChange) onChange(newData);
-        }
-      }
-    }
-  }, [formData.type, evaluationPointGroups, formData.evaluation_point_groups_id, formData.evaluation_point_groups_pid, onChange]);
+  // 根据选择的评查点类型筛选可用的规则组
+  const filteredRuleGroups = evaluationPointGroups.filter(group => 
+    formData.evaluation_point_groups_pid && 
+    group.pid === formData.evaluation_point_groups_pid && 
+    group.is_enabled
+  );
 
   // 获取评查点类型选项（pid=0的数据）
   const getCheckpointTypeOptions = () => {
     if (!evaluationPointGroups || evaluationPointGroups.length === 0) {
-      console.log("无评查点组数据，使用默认类型选项");
       return (
         <>
           <option value="">请选择评查点类型</option>
-          <option value="essential">基本要素类</option>
-          <option value="content">内容合规类</option>
-          <option value="format">格式规范类</option>
-          <option value="legal">法律风险类</option>
-          <option value="business">业务专项类</option>
         </>
       );
     }
     
     const typeGroups = evaluationPointGroups.filter(group => group.pid === 0 && group.is_enabled);
-    console.log("可用的评查点类型:", typeGroups);
-    
+
     return (
       <>
         <option value="">请选择评查点类型</option>
@@ -189,14 +64,15 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
     );
   };
 
+  // 评查点描述与法律依据 展开状态
   const handleToggleDescription = () => {
     setIsDescExpanded(!isDescExpanded);
   };
 
+  // 处理表单输入变化
   const handleInputChange = (e: React.ChangeEvent<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>) => {
     const { id, value } = e.target;
     const newData = { ...formData };
-    
     // 映射id到表单字段名
     switch(id) {
       case 'rule-name': 
@@ -214,32 +90,32 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
       case 'rule-description': 
         newData.description = value;
         break;
-      case 'law-name': 
-        newData.references_laws.name = value;
+      case 'law-name':
+        newData.references_laws = {
+          ...formData.references_laws,
+          name: value
+        };
         break;
-      case 'law-content': 
-        newData.references_laws.content = value;
-        break;
-      case 'law-articles':
-        setLawArticlesInput(value);
+      case 'law-content':
+        newData.references_laws = {
+          ...formData.references_laws,
+          content: value
+        };
         break;
       case 'evaluation-point-group':
         newData.evaluation_point_groups_id = value ? parseInt(value) : null;
         break;
       case 'checkpoint-type':
-        newData.type = value;
-        // 重置规则组选择
-        newData.evaluation_point_groups_id = null;
-        
-        // 设置评查点类型组ID
+        // 处理评查点类型选择
         if (value) {
-          const typeGroup = evaluationPointGroups.find(group => 
-            group.pid === 0 && 
-            group.code === value
-          );
-          newData.evaluation_point_groups_pid = typeGroup ? typeGroup.id : null;
+          // 找到选中的类型组
+          const selectedType = evaluationPointGroups.find(group => group.code === value && group.pid === 0);
+          if (selectedType) {
+            newData.evaluation_point_groups_pid = selectedType.id;
+          }
         } else {
           newData.evaluation_point_groups_pid = null;
+          newData.evaluation_point_groups_id = null; // 清空规则组选择
         }
         break;
     }
@@ -251,18 +127,32 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
     }
   };
 
-  const handleLawArticlesChange = (value: string) => {
-    setLawArticlesInput(value);
-    const articles = value.split(',')
+  // 处理条款号输入框变化
+  const handleLawArticlesChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    // 设置临时字符串状态，这样不会触发任何处理
+    setLawArticlesText(e.target.value);
+  };
+
+  // 处理条款号输入框失去焦点
+  const handleLawArticlesBlur = () => {
+    if (!lawArticlesText) return;
+    
+    // 将输入的文本转换为数组
+    const articles = lawArticlesText
+      .split(',')
       .map(article => article.trim())
       .filter(article => article !== '');
-      
+    
+    // 创建一个新的引用法律对象，保留现有字段
+    const referencesLaws = {
+      ...(formData.references_laws || {}),
+      articles: articles.length > 0 ? articles : []
+    };
+    
+    // 更新表单数据
     const newData = {
       ...formData,
-      references_laws: {
-        ...formData.references_laws,
-        articles
-      }
+      references_laws: referencesLaws
     };
     
     setFormData(newData);
@@ -272,6 +162,33 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
     }
   };
 
+  // 初始化条款号文本字段
+  useEffect(() => {
+    if (formData.references_laws?.articles && formData.references_laws.articles.length > 0) {
+      setLawArticlesText(formData.references_laws.articles.join(','));
+    }
+  }, [formData.references_laws?.articles]);
+
+  // 检查是否需要自动展开描述区域
+  useEffect(() => {
+    // 如果描述或法律依据相关字段有值，则自动展开
+    if (
+      formData.description || 
+      formData.references_laws?.name || 
+      (formData.references_laws?.articles && formData.references_laws.articles.length > 0) || 
+      formData.references_laws?.content
+    ) {
+      setIsDescExpanded(true);
+    }
+  }, [formData]);
+
+  useEffect(() => {
+    // 可以在这里通知父组件
+    if (onChange && filteredRuleGroups.length === 1) {
+      onChange({ evaluation_point_groups_id: filteredRuleGroups[0].id });
+    }
+  }, [filteredRuleGroups, onChange]);
+
   return (
     <div className="ant-card">
       <div className="ant-card-header">
@@ -317,9 +234,19 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
               value={formData.risk}
               onChange={handleInputChange}
             >
-              <option value="high">高风险</option>
-              <option value="medium">中风险</option>
-              <option value="low">低风险</option>
+              {riskOptions.length > 0 ? (
+                riskOptions.map(option => (
+                  <option key={option.value} value={option.value}>
+                    {option.label}
+                  </option>
+                ))
+              ) : (
+                <>
+                  <option value="high">高风险</option>
+                  <option value="medium">中风险</option>
+                  <option value="low">低风险</option>
+                </>
+              )}
             </select>
             <div className="form-tip">请定义评查点的风险等级</div>
           </div>
@@ -330,7 +257,7 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
             <select 
               id="checkpoint-type" 
               className="form-select"
-              value={formData.type}
+              value={getCheckpointTypeCode()}
               onChange={handleInputChange}
             >
               {getCheckpointTypeOptions()}
@@ -343,13 +270,13 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
             </label>
             <select 
               id="evaluation-point-group" 
-              className={`form-select ${!formData.type || filteredRuleGroups.length === 0 ? 'bg-gray-100 cursor-not-allowed' : ''}`}
+              className={`form-select ${!formData.evaluation_point_groups_pid || filteredRuleGroups.length === 0 ? 'bg-gray-100 cursor-not-allowed' : ''}`}
               value={formData.evaluation_point_groups_id?.toString() || ""}
               onChange={handleInputChange}
-              disabled={!formData.type || filteredRuleGroups.length === 0}
+              disabled={!formData.evaluation_point_groups_pid || filteredRuleGroups.length === 0}
             >
               <option value="">
-                {!formData.type ? "请先选择评查点类型" : 
+                {!formData.evaluation_point_groups_pid ? "请先选择评查点类型" : 
                  filteredRuleGroups.length === 0 ? "该类型下暂无可用规则组" : 
                  "请选择规则组"}
               </option>
@@ -360,7 +287,7 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
               ))}
             </select>
             <div className="form-tip">
-              {!formData.type ? "请先选择评查点类型" : 
+              {!formData.evaluation_point_groups_pid ? "请先选择评查点类型" : 
                filteredRuleGroups.length === 0 ? "该类型下暂无可用规则组" : 
                "选择评查点所属的规则组"}
             </div>
@@ -420,20 +347,23 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
                   className="form-input" 
                   placeholder="例如：《中华人民共和国民法典》" 
                   id="law-name" 
-                  value={formData.references_laws.name}
+                  value={formData.references_laws?.name || ''}
                   onChange={handleInputChange}
                 />
               </div>
               
               <div className="mb-3">
-                <label className="text-sm text-gray-600 mb-1 block" htmlFor="law-articles">条款号 <span className="text-xs text-gray-400">(多个条款请用逗号分隔)</span></label>
+                <label className="text-sm text-gray-600 mb-1 block" htmlFor="law-articles">
+                  条款号 <span className="text-xs text-gray-400">(多个条款请用逗号分隔)</span>
+                </label>
                 <input 
                   type="text" 
                   className="form-input" 
                   placeholder="例如：第五百八十五条,第五百八十六条" 
                   id="law-articles" 
-                  value={lawArticlesInput}
-                  onChange={(e) => handleLawArticlesChange(e.target.value)}
+                  value={lawArticlesText}
+                  onChange={handleLawArticlesChange}
+                  onBlur={handleLawArticlesBlur}
                 />
                 <div className="form-tip">多个条款用逗号分隔，将自动转换为数组格式</div>
               </div>
@@ -445,7 +375,7 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
                   style={{ minHeight: '60px' }} 
                   placeholder="例如：当事人应当按照约定全面履行自己的义务。" 
                   id="law-content"
-                  value={formData.references_laws.content}
+                  value={formData.references_laws?.content || ''}
                   onChange={handleInputChange}
                 ></textarea>
               </div>
@@ -459,10 +389,10 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
                 <div className="text-sm font-medium mb-2">预览效果</div>
                 <div className="law-reference">
                   <div className="law-reference-title" id="preview-law-name">
-                    {formData.references_laws.name || '《中华人民共和国民法典》'}
+                    {formData.references_laws?.name || '《中华人民共和国民法典》'}
                   </div>
                   <div className="law-reference-articles" id="preview-law-articles">
-                    {formData.references_laws.articles.length > 0 ? 
+                    {formData.references_laws?.articles && formData.references_laws.articles.length > 0 ? 
                       formData.references_laws.articles.map((article, index) => (
                         <span key={index} className="law-article">{article}</span>
                       )) : (
@@ -473,7 +403,7 @@ export function BasicInfo({ onChange, initialData, evaluationPointGroups = [] }:
                     )}
                   </div>
                   <div className="law-reference-content" id="preview-law-content">
-                    {formData.references_laws.content || '当事人应当按照约定全面履行自己的义务。'}
+                    {formData.references_laws?.content || '当事人应当按照约定全面履行自己的义务。'}
                   </div>
                 </div>
               </div>
diff --git a/app/components/rules/new/ExtractionSettings.tsx b/app/components/rules/new/ExtractionSettings.tsx
index d433f1c..e8e8b3a 100644
--- a/app/components/rules/new/ExtractionSettings.tsx
+++ b/app/components/rules/new/ExtractionSettings.tsx
@@ -1,6 +1,7 @@
 import { useState, KeyboardEvent, FormEvent, useContext, useEffect, useCallback, useRef } from 'react';
 import { RuleContext } from '~/contexts/RuleContext';
 import { processFieldName } from '~/utils';
+import type { PromptType, VLMFieldType } from '~/models/evaluation_points';
 
 // 定义通知函数的类型
 type NotifyFn = (data: Record<string, unknown>) => void;
@@ -41,7 +42,7 @@ interface RegexField {
 
 interface VlmField {
   name: string;
-  type: string;
+  type: VLMFieldType | string;
 }
 
 interface PromptTemplate {
@@ -72,9 +73,16 @@ interface ExtractionSettingsProps {
       fields?: RegexField[];
     };
   };
+  promptTypeOptions?: Array<{value: string, label: string}>;
+  vlmFieldTypeOptions?: Array<{value: string, label: string}>;
 }
 
-export function ExtractionSettings({ onChange, initialData }: ExtractionSettingsProps) {
+export function ExtractionSettings({ 
+  onChange, 
+  initialData,
+  promptTypeOptions = [], 
+  vlmFieldTypeOptions = [] 
+}: ExtractionSettingsProps) {
   const ruleContext = useContext(RuleContext);
   const lastUpdateTimeRef = useRef(0); // 添加一个ref来记录上次更新时间
   const lastEventFieldsRef = useRef<string[]>([]);
@@ -884,6 +892,62 @@ export function ExtractionSettings({ onChange, initialData }: ExtractionSettings
     setSelectedFieldType(e.currentTarget.value);
   };
 
+  // 在渲染选择模态字段类型的下拉列表时使用vlmFieldTypeOptions
+  const renderVlmFieldTypeSelect = (field: string, index: number) => {
+    return (
+      <select
+        className="form-select"
+        value={selectedFieldType}
+        onChange={handleFieldTypeChange}
+      >
+        {vlmFieldTypeOptions.length > 0 ? (
+          vlmFieldTypeOptions.map(option => (
+            <option key={option.value} value={option.value}>
+              {option.label}
+            </option>
+          ))
+        ) : (
+          // 默认选项，如果没有提供字段类型选项
+          <>
+            <option value="default">默认</option>
+            <option value="currency">货币</option>
+            <option value="print">打印</option>
+            <option value="seal">印章</option>
+            <option value="cross-seal">骑缝章</option>
+            <option value="english">英文</option>
+            <option value="number">数字</option>
+            <option value="handwriting">手写</option>
+          </>
+        )}
+      </select>
+    );
+  };
+  
+  // 在渲染提示词类型的选择器时使用promptTypeOptions
+  const renderPromptTypeSelect = (type: string, promptType: 'llm' | 'vlm') => {
+    return (
+      <select
+        className="form-select"
+        value={type}
+        onChange={(e) => handlePromptTypeChange(e, promptType)}
+      >
+        {promptTypeOptions.length > 0 ? (
+          promptTypeOptions.map(option => (
+            <option key={option.value} value={option.value}>
+              {option.label}
+            </option>
+          ))
+        ) : (
+          // 默认选项，如果没有提供提示词类型选项
+          <>
+            <option value="system">使用系统默认提示词</option>
+            <option value="custom">使用自定义提示词</option>
+          </>
+        )}
+      </select>
+    );
+  };
+
   return (
     <div className="ant-card">
       <div className="ant-card-header">
@@ -970,28 +1034,7 @@ export function ExtractionSettings({ onChange, initialData }: ExtractionSettings
                 提示词设置
               </label>
               <div className="flex items-center mb-2" id="llm-prompt-settings">
-                <label className="inline-flex items-center mr-6">
-                  <input
-                    type="radio"
-                    name="llm-prompt-type"
-                    value="system"
-                    checked={promptType.llm === 'system'}
-                    onChange={(e) => handlePromptTypeChange(e, 'llm')}
-                    className="form-radio"
-                  />
-                  <span className="ml-2">使用系统默认提示词</span>
-                </label>
-                <label className="inline-flex items-center">
-                  <input
-                    type="radio"
-                    name="llm-prompt-type"
-                    value="custom"
-                    checked={promptType.llm === 'custom'}
-                    onChange={(e) => handlePromptTypeChange(e, 'llm')}
-                    className="form-radio"
-                  />
-                  <span className="ml-2">使用自定义提示词</span>
-                </label>
+                {renderPromptTypeSelect(promptType.llm, 'llm')}
               </div>
 
               <div
@@ -1084,21 +1127,7 @@ export function ExtractionSettings({ onChange, initialData }: ExtractionSettings
                   onChange={(e) => handleFieldInputChange(e, 'vlm')}
                   onKeyDown={(e) => handleKeyDown(e, 'vlm')}
                 />
-                <select
-                  className="form-select mr-2"
-                  id="field-type-vlm"
-                  value={selectedFieldType}
-                  onChange={handleFieldTypeChange}
-                >
-                  <option value="default">默认</option>
-                  <option value="seal">印章</option>
-                  <option value="cross-seal">骑缝章</option>
-                  <option value="handwriting">手写体</option>
-                  <option value="print">印刷体</option>
-                  <option value="english">英文</option>
-                  <option value="number">数字</option>
-                  <option value="currency">货币</option>
-                </select>
+                {renderVlmFieldTypeSelect(inputValue.vlm, 0)}
                 <button
                   className="ant-btn ant-btn-default"
                   id="add-field-btn-vlm"
@@ -1143,28 +1172,7 @@ export function ExtractionSettings({ onChange, initialData }: ExtractionSettings
                 提示词设置
               </label>
               <div className="flex items-center mb-2" id="multimodal-prompt-settings">
-                <label className="inline-flex items-center mr-6">
-                  <input
-                    type="radio"
-                    name="multimodal-prompt-type"
-                    value="system"
-                    checked={promptType.vlm === 'system'}
-                    onChange={(e) => handlePromptTypeChange(e, 'vlm')}
-                    className="form-radio"
-                  />
-                  <span className="ml-2">使用系统默认提示词</span>
-                </label>
-                <label className="inline-flex items-center">
-                  <input
-                    type="radio"
-                    name="multimodal-prompt-type"
-                    value="custom"
-                    checked={promptType.vlm === 'custom'}
-                    onChange={(e) => handlePromptTypeChange(e, 'vlm')}
-                    className="form-radio"
-                  />
-                  <span className="ml-2">使用自定义提示词</span>
-                </label>
+                {renderPromptTypeSelect(promptType.vlm, 'vlm')}
               </div>
               <div
                 className="bg-gray-50 p-2 rounded text-xs text-gray-600 mb-2"
diff --git a/app/components/rules/new/ReviewSettings.tsx b/app/components/rules/new/ReviewSettings.tsx
index 71e8fda..1e99dd8 100644
--- a/app/components/rules/new/ReviewSettings.tsx
+++ b/app/components/rules/new/ReviewSettings.tsx
@@ -2,6 +2,13 @@ import React, { useState, useEffect, useContext, useCallback, useRef } from 'rea
 import { SimpleCodeEditor } from './SimpleCodeEditor';
 import { RuleContext } from '~/contexts/RuleContext';
 import { processFieldNames, areArraysDifferent, getArrayDifference, debounce } from '~/utils';
+import type {
+  Rule as ModelRule,
+  RuleType as ModelRuleType,
+  LogicType,
+  SuggestionMessageType,
+  PostActionType
+} from '~/models/evaluation_points';
 
 interface RuleType {
   id: string;
@@ -38,9 +45,31 @@ interface ReviewSettingsProps {
     score?: number;
     scoreDisplay?: string;
   };
+  // 添加选项数据参数
+  ruleTypeOptions?: Array<{ value: string; label: string }>;
+  logicTypeOptions?: Array<{ value: string; label: string }>;
+  logicOperatorOptions?: Array<{ value: string; label: string }>;
+  compareMethodOptions?: Array<{ value: string; label: string }>;
+  formatTypeOptions?: Array<{ value: string; label: string }>;
+  comparisonOperatorOptions?: Array<{ value: string; label: string }>;
+  matchTypeOptions?: Array<{ value: string; label: string }>;
+  suggestionMessageTypeOptions?: Array<{ value: string; label: string }>;
+  postActionOptions?: Array<{ value: string; label: string }>;
 }
 
-export function ReviewSettings({ onChange, initialData }: ReviewSettingsProps) {
+export function ReviewSettings({ 
+  onChange, 
+  initialData,
+  ruleTypeOptions = [],
+  logicTypeOptions = [],
+  logicOperatorOptions = [],
+  compareMethodOptions = [],
+  formatTypeOptions = [],
+  comparisonOperatorOptions = [],
+  matchTypeOptions = [],
+  suggestionMessageTypeOptions = [],
+  postActionOptions = []
+}: ReviewSettingsProps) {
   const [rules, setRules] = useState<RuleType[]>([
     { id: '1', type: '', config: {} }
   ]);
diff --git a/app/models/evaluation_point_groups.ts b/app/models/evaluation_point_groups.ts
new file mode 100644
index 0000000..0805d1d
--- /dev/null
+++ b/app/models/evaluation_point_groups.ts
@@ -0,0 +1,15 @@
+/**
+ * 评查点分组表
+ */
+interface EvaluationPointGroup {
+    id: number;                // 主键，自增
+    pid: number | null;        // 所属分组ID，外键引用本表，可为空
+    code: string;              // 分组编码，唯一且非空
+    name: string;              // 分组名称，非空
+    description?: string;      // 分组描述，可为空
+    is_enabled: boolean;       // 是否启用，默认true
+    created_at: string;        // 创建时间，带时区，默认当前时间
+    updated_at: string;        // 更新时间，带时区，默认当前时间
+}
+
+export type { EvaluationPointGroup };
diff --git a/app/models/evaluation_points.ts b/app/models/evaluation_points.ts
new file mode 100644
index 0000000..578c2d3
--- /dev/null
+++ b/app/models/evaluation_points.ts
@@ -0,0 +1,308 @@
+/**
+ * 评查点数据类型定义
+ */
+interface EvaluationPoint {
+    id?: number;
+    name?: string;                         // 评查点名称
+    code?: string;                         // 评查点编码
+    risk?: string;                         // 风险级别
+    is_enabled?: boolean;                  // 是否启用
+    description?: string;                  // 描述
+    references_laws?: {                    // 法律法规引用
+        name?: string;                       // 法规名称
+        articles?: string[];                 // 条款列表
+        content?: string;                    // 法规内容
+    };
+    evaluation_point_groups_pid?: number | null;   // 评查点类型组ID
+    evaluation_point_groups_id?: number | null;    // 所属评查组ID
+    extraction_config?: ExtactionConfigType;       // 抽取配置
+    evaluation_config?: EvaluationConfigType;      // 评查配置
+    pass_message?: string;                 // 通过消息
+    fail_message?: string;                 // 失败消息
+    suggestion_message?: string;           // 建议消息
+    suggestion_message_type?: SuggestionMessageType;      // 建议消息类型 默认warning（info/warning/error）
+    post_action?: PostActionType;          // 评查后动作 可为空（none/manual/replace）
+    action_config?: string;                // 动作配置
+    score?: number;                        // 分数
+}
+
+/**
+ * 风险级别类型定义
+ */
+type RiskLevelType = 'high' | 'medium' | 'low';
+
+/**
+ * 建议消息类型定义
+ */
+type SuggestionMessageType = 'info' | 'warning' | 'error';
+
+/**
+ * 评查后动作类型定义
+ */
+type PostActionType = 'none' | 'manual' | 'replace';
+
+/**
+ * 抽取配置类型定义
+ */
+interface ExtactionConfigType {
+    llm: {
+        fields: string[];
+        prompt_setting: PromptSetting;
+    };
+    vlm: {
+        fields: Array<{
+            name: string;
+            type: VLMFieldType; // 多模态字段类型 默认、货币、打印、印章、骑缝章、英文、数字、手写
+        }>;
+        prompt_setting: PromptSetting;
+    };
+    regex: {
+        fields: Array<{
+            field: string;
+            pattern: string;
+        }>;
+    };
+}
+
+/**
+ * VLM字段类型定义
+ */
+type VLMFieldType = 'default' | 'currency' | 'print' | 'seal' | 'cross-seal' | 'english' | 'number' | 'handwriting';
+
+/**
+ * 提示配置类型定义
+ */
+interface PromptSetting {
+    type: PromptType; // "system" or "custom" 如果为 "custom" 则为自定义提示
+    template: string; // 提示模板
+}
+
+/**
+ * 提示类型定义
+ */
+type PromptType = 'system' | 'custom';
+
+/**
+ * 评查配置类型定义
+ */
+interface EvaluationConfigType {
+    logicType: LogicType;
+    customLogic: string; // 自定义逻辑:(规则1 AND 规则2) OR 规则3
+    rules: Rule[];
+}
+
+/**
+ * 逻辑类型定义
+ */
+type LogicType = 'and' | 'or' | 'custom';
+
+interface Rule {
+    id: string;
+    type: RuleType; // 规则类型 有无、一致性、格式、逻辑、正则、AI、代码
+    config: {
+        // exists 规则配置 
+        fields?: string[];
+        logic?: LogicOperator;
+
+        // consistency 规则配置 
+        pairs?: Array<{
+            sourceField: string;
+            targetField: string; 
+            compareMethod: CompareMethod; // 比较方法 包含、精确、大模型语义
+        }>;
+
+        // format 规则配置
+        field?: string;
+        formatType?: FormatType; // 格式类型 日期格式、数字格式、电话号码、电子邮箱、银行卡号、身份证号码、邮政编码、统一社会信用代码
+        parameters?: string;
+
+        // logic 规则配置
+        conditions?: Array<{
+            field: string;
+            operator: ComparisonOperator; // 比较运算符 等于、不等于、大于、大于等于、小于、小于等于、包含、不包含
+            value: string;
+        }>;
+
+        // regex 规则配置
+        pattern?: string;
+        matchType?: MatchType; // 匹配类型 必须匹配（符合为通过）、不得匹配（不符合为通过）
+
+        // ai 规则配置
+        model?: string; // 大模型名称 
+        temperature?: number; // 温度
+        prompt?: string; // 提示
+
+        // code 规则配置
+        language?: ProgrammingLanguage;
+        code?: string;
+    }
+}
+
+/**
+ * 规则类型定义
+ */
+type RuleType = 'exists' | 'consistency' | 'format' | 'logic' | 'regex' | 'ai' | 'code';
+
+/**
+ * 逻辑操作符定义
+ */
+type LogicOperator = 'and' | 'or';
+
+/**
+ * 比较方法定义
+ */
+type CompareMethod = 'contains' | 'exact' | 'semantic';
+
+/**
+ * 格式类型定义
+ */
+type FormatType = 'date' | 'number' | 'phone' | 'email' | 'bank' | 'id' | 'postal' | 'credit';
+
+/**
+ * 比较运算符定义
+ */
+type ComparisonOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'contains' | 'not_contains';
+
+/**
+ * 匹配类型定义
+ */
+type MatchType = 'match' | 'not_match';
+
+/**
+ * 编程语言定义
+ */
+type ProgrammingLanguage = 'python' | 'javascript';
+
+/**
+ * 下拉选项数据集
+ */
+export const EVALUATION_OPTIONS = {
+    // 风险级别选项
+    riskLevelOptions: [
+        { value: 'high', label: '高风险' },
+        { value: 'medium', label: '中风险' },
+        { value: 'low', label: '低风险' }
+    ],
+    
+    // 建议消息类型选项
+    suggestionMessageTypeOptions: [
+        { value: 'info', label: '提示' },
+        { value: 'warning', label: '警告' },
+        { value: 'error', label: '错误' }
+    ],
+    
+    // 评查后动作选项
+    postActionOptions: [
+        { value: 'none', label: '无' },
+        { value: 'manual', label: '人工确认' },
+        { value: 'replace', label: '内容替换' }
+    ],
+    
+    // VLM字段类型选项
+    vlmFieldTypeOptions: [
+        { value: 'default', label: '默认' },
+        { value: 'currency', label: '货币' },
+        { value: 'print', label: '打印' },
+        { value: 'seal', label: '印章' },
+        { value: 'cross-seal', label: '骑缝章' },
+        { value: 'english', label: '英文' },
+        { value: 'number', label: '数字' },
+        { value: 'handwriting', label: '手写' }
+    ],
+    
+    // 提示类型选项
+    promptTypeOptions: [
+        { value: 'system', label: '使用系统默认提示词' },
+        { value: 'custom', label: '使用自定义提示词' }
+    ],
+    
+    // 逻辑类型选项
+    logicTypeOptions: [
+        { value: 'and', label: '全部满足（AND）' },
+        { value: 'or', label: '任一满足（OR）' },
+        { value: 'custom', label: '自定义组合' }
+    ],
+    
+    // 规则类型选项
+    ruleTypeOptions: [
+        { value: 'exists', label: '有无判断' },
+        { value: 'consistency', label: '一致性判断' },
+        { value: 'format', label: '格式判断' },
+        { value: 'logic', label: '逻辑判断' },
+        { value: 'regex', label: '正则表达式' },
+        { value: 'ai', label: '大模型判断' },
+        { value: 'code', label: '自定义代码' }
+    ],
+    
+    // 逻辑操作符选项
+    logicOperatorOptions: [
+        { value: 'and', label: 'AND（所有条件都满足）' },
+        { value: 'or', label: 'OR（任一条件满足）' }
+    ],
+    
+    // 比较方法选项
+    compareMethodOptions: [
+        { value: 'contains', label: '包含关系' },
+        { value: 'exact', label: '精确匹配' },
+        { value: 'semantic', label: '大模型语义匹配' }
+    ],
+    
+    // 格式类型选项
+    formatTypeOptions: [
+        { value: 'date', label: '日期格式' },
+        { value: 'number', label: '数字格式' },
+        { value: 'phone', label: '电话号码' },
+        { value: 'email', label: '电子邮箱' },
+        { value: 'bank', label: '银行卡号' },
+        { value: 'id', label: '身份证号码' },
+        { value: 'postal', label: '邮政编码' },
+        { value: 'credit', label: '统一社会信用代码' }
+    ],
+    
+    // 比较运算符选项
+    comparisonOperatorOptions: [
+        { value: 'eq', label: '等于(=)' },
+        { value: 'neq', label: '不等于(≠)' },
+        { value: 'gt', label: '大于(>)' },
+        { value: 'gte', label: '大于等于(≥)' },
+        { value: 'lt', label: '小于(<)' },
+        { value: 'lte', label: '小于等于(≤)' },
+        { value: 'contains', label: '包含' },
+        { value: 'not_contains', label: '不包含' }
+    ],
+    
+    // 匹配类型选项
+    matchTypeOptions: [
+        { value: 'match', label: '必须匹配（符合为通过）' },
+        { value: 'not_match', label: '不得匹配（不符合为通过）' }
+    ],
+    
+    // 编程语言选项
+    programmingLanguageOptions: [
+        { value: 'python', label: 'Python' },
+        { value: 'javascript', label: 'JavaScript' }
+    ]
+};
+
+// 导出类型定义供其他模块使用
+export type {
+    EvaluationPoint,
+    RiskLevelType,
+    SuggestionMessageType,
+    PostActionType,
+    ExtactionConfigType,
+    VLMFieldType,
+    PromptSetting,
+    PromptType,
+    EvaluationConfigType,
+    LogicType,
+    Rule,
+    RuleType,
+    LogicOperator,
+    CompareMethod,
+    FormatType,
+    ComparisonOperator,
+    MatchType,
+    ProgrammingLanguage
+};
+
diff --git a/app/routes/rules.new.tsx b/app/routes/rules.new.tsx
index d4d56df..110465e 100644
--- a/app/routes/rules.new.tsx
+++ b/app/routes/rules.new.tsx
@@ -26,22 +26,26 @@
  */
 
 import { type MetaFunction } from "@remix-run/node";
-import { useState, useEffect } from "react";
+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 { RuleContext } from "~/contexts/RuleContext";
 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
+} from "~/models/evaluation_points";
+import { EVALUATION_OPTIONS } from "~/models/evaluation_points";
+import type { EvaluationPointGroup } from "~/models/evaluation_point_groups";
 export const meta: MetaFunction = () => {
   return [
     { title: "评查点管理 - 中国烟草AI合同及卷宗审核系统" },
-    { 
-      name: "description", 
-      content: "创建或修改评查点，设置规则参数" 
+    {
+      name: "description",
+      content: "创建或修改评查点，设置规则参数"
     }
   ];
 };
@@ -54,313 +58,92 @@ export const handle = {
   breadcrumb: "评查点管理"
 };
 
-// 定义类型
-/**
- * 正则表达式字段定义
- * @property field - 字段名称
- * @property pattern - 正则表达式模式
- */
-interface RegexField {
-  field: string;
-  pattern: string;
-}
-
-/**
- * 多模态(VLM)字段定义，包含字段名和类型
- * @property name - 字段名称
- * @property type - 字段类型，如"default"、"table"等
- */
-interface ApiVlmField {
-  name: string;
-  type: string;
-}
-
-/**
- * 提示词设置
- * @property type - 提示词类型，如"system"、"user"等
- * @property template - 提示词模板内容
- */
-interface PromptSetting {
-  type: string;
-  template: string;
-}
-
-/**
- * 抽取配置，包含三种抽取方式
- * @property llm - 大模型抽取配置
- * @property vlm - 多模态抽取配置
- * @property regex - 正则表达式抽取配置
- */
-interface ExtactionConfigType {
-  llm: {
-    fields: string[];
-    prompt_setting: PromptSetting;
-  };
-  vlm: {
-    fields: (ApiVlmField | string)[];
-    prompt_setting: PromptSetting;
-  };
-  regex: {
-    fields: RegexField[];
-  };
-}
-
-/**
- * API请求使用的抽取配置，字段可选
- */
-interface ApiExtactionConfigType {
-  llm?: {
-    fields?: string[];
-    prompt_setting?: {
-      type?: string;
-      template?: string;
-    }
-  };
-  vlm?: {
-    fields?: ApiVlmField[];
-    prompt_setting?: {
-      type?: string;
-      template?: string;
-    }
-  };
-  regex?: {
-    fields?: RegexField[];
-  };
-}
-
-/**
- * 规则配置类型，使用索引签名支持不同类型规则的不同配置项
- */
-interface RuleConfigType {
-  [key: string]: unknown;
-}
-
-/**
- * 评查规则定义
- * @property id - 规则唯一标识
- * @property type - 规则类型，如"exists"、"consistency"等
- * @property config - 规则配置，根据规则类型不同而不同
- */
-interface Rule {
-  id: string;
-  type: string;
-  config: RuleConfigType;
-}
-
-/**
- * 评查配置
- * @property logicType - 规则组合逻辑，如"and"、"or"、"custom"
- * @property customLogic - 自定义逻辑表达式
- * @property rules - 规则列表
- */
-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;    // 所属评查组ID
-  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;                         // 评查点类型
-  evaluation_point_groups_pid: number | null;   // 评查点类型组ID
-  score: number;                        // 分数
-  scoreDisplay?: string;                // 分数显示值
-}
-
-/**
- * API返回的评查点数据
- */
-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;
-  evaluation_point_groups_pid?: 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;
-  meta?: {
-    type: string;
-    pid?: number;
-    [key: string]: unknown;
-  };
-  score?: number;
-  scoreDisplay?: string;
-}
-
-/**
- * API响应数据类型
- */
-interface ApiResponse {
-  code?: number;
-  msg?: string;
-  data?: Array<Record<string, unknown>> | Record<string, unknown>;
-  [key: string]: unknown;
-}
-
-/**
- * API提交数据格式
- */
-interface ApiRuleData {
-  id?: number;
-  name: string;
-  version?: string;
-  description: string;
-  doc_type?: string[];
-  extraction_config: {
-    llm: {
-      fields: string[];
-      prompt_setting: PromptSetting;
-    };
-    vlm: {
-      fields: ApiVlmField[];
-      prompt_setting: PromptSetting;
-    };
-    regex: {
-      fields: RegexField[];
-    };
-  };
-  evaluation_config: {
-    logic?: string;
-    auto_check?: boolean;
-    output_items?: string[];
-    points?: Array<Record<string, unknown>>;
-    [key: string]: unknown;
-  };
-}
-
-/**
- * 深拷贝工具函数
- * 用于创建对象的深拷贝，避免引用类型导致的意外修改
- * @param obj 要复制的对象
- * @returns 深拷贝后的对象
- */
-function deepClone<T>(obj: T): T {
-  if (obj === null || obj === undefined || typeof obj !== 'object') {
-    return obj;
-  }
-  
-  try {
-    return JSON.parse(JSON.stringify(obj));
-  } catch (err) {
-    console.error('深拷贝对象失败:', err);
-    return obj;
-  }
-}
 
 export default function RuleNew() {
   const navigate = useNavigate();
   const location = useLocation();
-  // 保存从抽取设置中获取的字段列表，用于评查规则选择
-  const [extractionFields, setExtractionFields] = useState<string[]>([]);
-  // 标记是否为编辑模式（通过URL参数判断）
-  const [isEditMode, setIsEditMode] = useState<boolean>(false);
-  // 标记数据加载状态
-  const [isLoading, setIsLoading] = useState<boolean>(false);
-  // 保存评查点组数据，用于基本信息表单中选择
-  const [evaluationPointGroups, setEvaluationPointGroups] = useState<Array<{id: number, pid: number, code: string, name: string, is_enabled: boolean}>>([]);
-  // 表单数据，包含评查点的所有信息
-  const [formData, setFormData] = useState<FormDataType>({
-    // 基本信息字段
-    name: '',
-    code: '',
-    risk: 'medium',
-    is_enabled: true,
-    description: '',
-    references_laws: {
-      name: '',
-      articles: [],
-      content: ''
-    },
-    evaluation_point_groups_id: null,
-    type: '',
-    evaluation_point_groups_pid: null,
-    
-    // 抽取设置
-    extraction_config: {
-      llm: {
-        fields: [],
-        prompt_setting: {
-          type: 'system',
-          template: ''
+  const [isEditMode, setIsEditMode] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const [formData, setFormData] = useState<EvaluationPoint>({});
+  const [evaluationPointGroups, setEvaluationPointGroups] = useState<EvaluationPointGroup[]>([]);
+
+  /**
+   * 获取评查点数据
+   * 编辑模式下从API获取指定ID的评查点数据
+   * @param id 评查点ID
+   */
+  const fetchEvaluationPoint = useCallback(async (id: number) => {
+    try {
+      setIsLoading(true);
+      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',
+          'Content-Type': 'application/json'
         }
-      },
-      vlm: {
-        fields: [],
-        prompt_setting: {
-          type: 'system',
-          template: ''
-        }
-      },
-      regex: {
-        fields: [{ field: '', pattern: '' }]
+      });
+      console.log(response);
+      if (response.ok) {
+        const data = await response.json();
+        setFormData(data.data[0]);
       }
-    },
-    
-    // 评查设置
-    evaluation_config: {
-      logicType: 'and',
-      customLogic: '',
-      rules: []
-    },
-    
-    // 评查结果消息
-    pass_message: '文档检查通过，符合规范要求。',
-    fail_message: '文档存在以下问题，请修改后重新提交。',
-    suggestion_message: '',
-    suggestion_message_type: 'warning',
-    
-    // 评查后动作
-    post_action: 'none',
-    action_config: '',
-    
-    // 分数
-    score: 0
-  });
+    } catch (error) {
+      console.error('获取评查点数据失败:', error);
+      alert(`获取评查点数据失败: ${error instanceof Error ? error.message : '未知错误'}`);
+      // 获取数据失败时返回上一页
+      navigate(-1);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [navigate]);
+
+  /**
+   * 获取评查点组数据
+   * 从API获取所有评查点组，用于基本信息表单中选择
+   */
+  const fetchEvaluationPointGroups = useCallback(async () => {
+    try {
+      console.log("获取评查点组数据");
+      const response = await fetch("http://127.0.0.1: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);
+  }
+
+  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 handleReviewSettingsChange = (data: Record<string, unknown>) => {
+    setFormData(prev => ({ ...prev, ...data }));
+  }
 
   /**
    * 页面加载时初始化处理
@@ -372,1106 +155,26 @@ export default function RuleNew() {
     const searchParams = new URLSearchParams(location.search);
     const id = searchParams.get('id');
     
+    // 设置编辑模式
+    setIsEditMode(!!id);
+    
     if (id) {
-      setIsEditMode(true);
       fetchEvaluationPoint(parseInt(id));
     }
 
     // 获取评查点组数据
     fetchEvaluationPointGroups();
-  }, [location.search]);
-
-  /**
-   * 获取评查点组数据
-   * 从API获取所有评查点组，用于基本信息表单中选择
-   */
-  const fetchEvaluationPointGroups = async () => {
-    try {
-      console.log("获取评查点组数据");
-      const response = await fetch("http://127.0.0.1:9000/admin/evaluation_point_groups", {
-        method: 'GET',
-        headers: {
-          'Accept': 'application/json',
-          'Content-Type': '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("评查点组数据原始响应:", responseData);
-      
-      // 适配API响应格式
-      let groupsData: Array<{id: number, pid: number, code: string, name: string, is_enabled: boolean}> = [];
-      if (responseData && typeof responseData === 'object') {
-        if (responseData.code === 0 && responseData.data) {
-          // 新API格式
-          groupsData = Array.isArray(responseData.data) ? responseData.data : [responseData.data];
-        } else if (Array.isArray(responseData)) {
-          // 旧API格式
-          groupsData = responseData;
-        } else if (responseData.data && Array.isArray(responseData.data)) {
-          // 旧API格式
-          groupsData = responseData.data;
-        }
-      }
-      
-      // 确保所有项都有必需的字段
-      groupsData = groupsData.filter(item => 
-        item && typeof item === 'object' && 
-        'id' in item && 
-        'pid' in item && 
-        'code' in item && 
-        'name' in item
-      );
-      
-      console.log("处理后的评查点组数据:", groupsData);
-      console.log("根级评查点类型:", groupsData.filter(group => group.pid === 0));
-      setEvaluationPointGroups(groupsData);
-      
-      // 如果表单数据已加载但类型未设置，尝试根据evaluation_point_groups_pid设置类型
-      if (formData.id && !formData.type && formData.evaluation_point_groups_pid) {
-        console.log("评查点组数据加载后更新类型，当前pid:", formData.evaluation_point_groups_pid);
-        
-        const typeGroup = groupsData.find(group => group.id === formData.evaluation_point_groups_pid);
-        if (typeGroup) {
-          console.log("找到对应的类型组:", typeGroup);
-          setFormData(prevData => ({
-            ...prevData,
-            type: typeGroup.code
-          }));
-          console.log("根据评查点类型ID更新类型为:", typeGroup.code);
-        } else if (formData.evaluation_point_groups_id) {
-          // 通过规则组查找类型
-          const selectedGroup = groupsData.find(group => group.id === formData.evaluation_point_groups_id);
-          if (selectedGroup && selectedGroup.pid !== 0) {
-            const parentTypeGroup = groupsData.find(group => group.id === selectedGroup.pid);
-            if (parentTypeGroup) {
-              console.log("通过规则组找到类型组:", parentTypeGroup);
-              setFormData(prevData => ({
-                ...prevData,
-                type: parentTypeGroup.code,
-                evaluation_point_groups_pid: parentTypeGroup.id
-              }));
-              console.log("根据规则组更新类型为:", parentTypeGroup.code);
-            }
-          }
-        }
-      }
-    } catch (error) {
-      console.error('获取评查点组数据失败:', error);
-      // 显示错误提示但不影响应用继续使用
-      alert(`获取评查点组数据失败: ${error instanceof Error ? error.message : '未知错误'}\n将使用默认数据`);
-    }
-  };
-
-  /**
-   * 获取评查点数据
-   * 编辑模式下从API获取指定ID的评查点数据
-   * @param id 评查点ID
-   */
-  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',
-          'Content-Type': '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);
-      
-      // 新的API响应格式适配
-      if (responseData && typeof responseData === 'object') {
-        if (responseData.code === 0 && responseData.data) {
-          // 符合新的API响应格式
-          if (Array.isArray(responseData.data)) {
-            if (responseData.data.length > 0) {
-              console.log("处理数组数据的第一项");
-              processPointData(responseData.data[0]);
-            } else {
-              console.error("数据数组为空");
-              throw new Error(`未找到ID为${id}的评查点数据`);
-            }
-          } else if (typeof responseData.data === 'object') {
-            console.log("处理单个对象数据");
-            processPointData(responseData.data);
-          }
-        } else if (responseData.code !== 0) {
-          // API返回错误
-          throw new Error(responseData.msg || `获取数据失败，错误码: ${responseData.code}`);
-        } else if (Array.isArray(responseData)) {
-          // 处理旧API格式：数组形式
-          if (responseData.length > 0) {
-            console.log("数组格式响应，使用第一项");
-            processPointData(responseData[0]);
-          } else {
-            console.error("数组为空，未找到数据");
-            throw new Error(`未找到ID为${id}的评查点数据`);
-          }
-        } else if (responseData.data) {
-          // 处理旧API格式：包含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) {
-          // 处理旧API格式：直接返回的对象
-          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 : '未知错误'}`);
-      // 获取数据失败时返回上一页
-      navigate(-1);
-    } finally {
-      setIsLoading(false);
-    }
-  };
-  
-  /**
-   * 处理获取到的评查点数据
-   * 将API返回的数据格式转换为表单数据格式
-   * @param pointData API返回的评查点数据
-   */
-  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);
-      console.log("评查规则详细信息:", JSON.stringify(evaluationConfig.rules || [], null, 2));
-      
-      // 提取字段列表，用于规则设置
-      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.type !== 'default' ? `${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);
-      
-      // 提取评查点类型ID
-      let pointGroupPid: number | null = null;
-      if (pointData.evaluation_point_groups_pid !== undefined && pointData.evaluation_point_groups_pid !== null) {
-        // 直接使用字段值
-        pointGroupPid = typeof pointData.evaluation_point_groups_pid === 'number' 
-          ? pointData.evaluation_point_groups_pid 
-          : null;
-        console.log("从evaluation_point_groups_pid获取类型ID:", pointGroupPid);
-      } else if (pointData.meta && typeof pointData.meta === 'object' && pointData.meta.pid !== undefined) {
-        // 从meta中提取
-        pointGroupPid = typeof pointData.meta.pid === 'number' 
-          ? pointData.meta.pid 
-          : null;
-        console.log("从meta.pid获取类型ID:", pointGroupPid);
-      }
-      
-      console.log("最终确定的类型ID:", pointGroupPid);
-      
-      // 处理分数
-      let pointScore = 0;
-      if (pointData.score !== undefined && pointData.score !== null) {
-        pointScore = typeof pointData.score === 'number' ? pointData.score : 0;
-        console.log("从score字段获取分数:", pointScore);
-      } else if (pointData.meta && typeof pointData.meta === 'object' && pointData.meta.score !== undefined) {
-        pointScore = typeof pointData.meta.score === 'number' ? pointData.meta.score : 0;
-        console.log("从meta.score获取分数:", pointScore);
-      }
-      
-      // 将API数据格式转换为内部使用的格式
-      setFormData({
-        id: pointData.id,
-        name: pointData.name || '',
-        code: pointData.code || '',
-        risk: pointData.risk || 'medium',
-        is_enabled: pointData.is_enabled !== undefined ? pointData.is_enabled : true,
-        description: pointData.description || '',
-        references_laws: pointData.references_laws || {
-          name: '',
-          articles: [],
-          content: ''
-        },
-        evaluation_point_groups_id: pointData.evaluation_point_groups_id || null,
-        evaluation_point_groups_pid: pointGroupPid,
-        type: pointData.type || (pointData.meta && pointData.meta.type ? pointData.meta.type : ''),
-        
-        // 将API数据格式转换为内部使用的格式
-        extraction_config: {
-          llm: {
-            fields: extractionConfig.llm?.fields || [],
-            prompt_setting: {
-              type: extractionConfig.llm?.prompt_setting?.type || 'system',
-              template: extractionConfig.llm?.prompt_setting?.template || ''
-            }
-          },
-          vlm: {
-            fields: extractionConfig.vlm?.fields?.map(field => {
-              if (typeof field === 'string') {
-                return { name: field, type: 'default' };
-              }
-              return field;
-            }) || [],
-            prompt_setting: {
-              type: extractionConfig.vlm?.prompt_setting?.type || 'system',
-              template: extractionConfig.vlm?.prompt_setting?.template || ''
-            }
-          },
-          regex: {
-            fields: (extractionConfig.regex?.fields || []).map((field) => ({
-              field: field.field || '',
-              pattern: field.pattern || ''
-            }))
-          }
-        },
-        
-        // 将API评查配置转换为内部使用的格式
-        evaluation_config: {
-          logicType: evaluationConfig.logicType || 'and',
-          customLogic: evaluationConfig.customLogic || '',
-          rules: (evaluationConfig.rules || []).map(rule => {
-            // 规则ID处理
-            if (!rule.id) {
-              rule.id = `rule_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-            }
-            
-            // 根据规则类型调整config字段
-            if (rule.config) {
-              switch (rule.type) {
-                case 'exists':
-                  if (rule.config.fields) {
-                    // 确保config中有fields字段
-                    console.log(`[调试] API数据转UI - exists规则 ${rule.id} 字段: ${JSON.stringify(rule.config.fields)}`);
-                  } else if (rule.config.selectedFields) {
-                    // 兼容旧字段名
-                    rule.config.fields = rule.config.selectedFields;
-                    delete rule.config.selectedFields;
-                    console.log(`[调试] API数据转UI - exists规则 ${rule.id} 从selectedFields映射到fields`);
-                  }
-                  
-                  // 确保config中有logic字段
-                  if (rule.config.existsLogic && !rule.config.logic) {
-                    rule.config.logic = rule.config.existsLogic;
-                    delete rule.config.existsLogic;
-                    console.log(`[调试] API数据转UI - exists规则 ${rule.id} 从existsLogic映射到logic`);
-                  }
-                  break;
-                  
-                case 'consistency':
-                case 'logic':
-                  // 将logicRelation转换为标准的logic
-                  if (rule.config.logicRelation && !rule.config.logic) {
-                    rule.config.logic = rule.config.logicRelation;
-                    delete rule.config.logicRelation;
-                    console.log(`[调试] API数据转UI - ${rule.type}规则 ${rule.id} 从logicRelation映射到logic`);
-                  }
-                  break;
-              }
-            }
-            
-            return rule;
-          })
-        },
-        
-        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 || '',
-        score: typeof pointData.score === 'number' ? pointData.score : 0
-      });
-      
-      console.log("已成功解析并加载评查点数据");
-    } catch (error) {
-      console.error("处理评查点数据时出错:", error);
-      throw error;
-    }
-  };
-
-  /**
-   * 更新抽取字段列表
-   * 在抽取设置和评查设置之间共享字段列表信息
-   * @param fields 更新后的字段列表
-   */
-  const updateExtractionFields = (fields: string[]) => {
-    setExtractionFields(fields);
-  };
-
-  /**
-   * 处理BasicInfo组件数据变更
-   * 更新基本信息相关的表单数据
-   * @param data 基本信息组件传回的数据
-   */
-  const handleBasicInfoChange = (data: Record<string, unknown>) => {
-    setFormData(prevData => ({
-      ...prevData,
-      ...data
-    }));
-  };
-
-  /**
-   * 处理ExtractionSettings组件数据变更
-   * 更新抽取设置相关的表单数据
-   * @param data 抽取设置组件传回的数据
-   */
-  const handleExtractionSettingsChange = (data: Record<string, unknown>) => {
-    console.log("抽取设置更新:", data);
-    
-    setFormData(prevData => {
-      // 深拷贝以避免不可预期的状态更新
-      const updatedExtractionConfig = { ...prevData.extraction_config };
-      
-      // 根据不同类型的数据进行处理
-      // 处理regexFields数据 - 保留正则表达式配置
-      if (data.regexFields) {
-        const regexFields = data.regexFields as Array<{ field: string; pattern: string }>;
-        
-        // 检查是否有 activeFieldId 标记，表示正在编辑中
-        const activeFieldId = data.activeFieldId as string;
-        if (activeFieldId) {
-          console.log("检测到正在编辑的正则字段，保留所有字段");
-          updatedExtractionConfig.regex.fields = regexFields;
-        } else {
-          // 正常更新模式，过滤掉空字段名的项
-          updatedExtractionConfig.regex.fields = regexFields
-            .filter(field => field.field && field.field.trim() !== '')
-            .map(field => ({
-              field: field.field,
-              pattern: field.pattern || ''
-            }));
-        }
-      }
-      
-      // 处理字段数据 - 保留提取的字段名称
-      if (data.fields) {
-        const extractionFields = data.fields as { llm?: string[], vlm?: string[] };
-        const activeFieldId = data.activeFieldId as string;
-        
-        if (activeFieldId) {
-          // 检测到正在编辑的大模型或多模态字段，保留所有字段
-          console.log("检测到正在编辑的大模型或多模态字段，保留所有字段");
-          if (extractionFields.llm) {
-            updatedExtractionConfig.llm.fields = extractionFields.llm;
-          }
-          if (extractionFields.vlm) {
-            // 保存字符串形式的字段，在提交API时再进行处理
-            updatedExtractionConfig.vlm.fields = extractionFields.vlm;
-          }
-        } else {
-          // 正常更新模式，过滤掉空字段
-          if (extractionFields.llm) {
-            updatedExtractionConfig.llm.fields = extractionFields.llm.filter(field => field && field.trim() !== '');
-          }
-          if (extractionFields.vlm) {
-            // 保存字符串形式的字段，在提交API时再进行处理
-            updatedExtractionConfig.vlm.fields = extractionFields.vlm.filter(field => field && field.trim() !== '');
-          }
-        }
-      }
-      
-      // 处理提示词设置
-      if (data.promptSettings) {
-        const promptSettings = data.promptSettings as Record<string, { type: string; content: string; template: string }>;
-        
-        // 更新大模型抽取提示词设置
-        if (promptSettings.llm) {
-          updatedExtractionConfig.llm.prompt_setting = {
-            type: promptSettings.llm.type as string || 'system',
-            template: promptSettings.llm.content as string || ''
-          };
-        }
-        
-        // 更新多模态抽取提示词设置
-        if (promptSettings.vlm) {
-          updatedExtractionConfig.vlm.prompt_setting = {
-            type: promptSettings.vlm.type as string || 'system',
-            template: promptSettings.vlm.content as string || ''
-          };
-        }
-      }
-      
-      // 单独处理promptType，确保提示词设置类型正确
-      if (data.promptType) {
-        const promptType = data.promptType as Record<string, string>;
-        if (promptType.llm) {
-          updatedExtractionConfig.llm.prompt_setting.type = promptType.llm;
-        }
-        if (promptType.vlm) {
-          updatedExtractionConfig.vlm.prompt_setting.type = promptType.vlm;
-        }
-      }
-      
-      // 单独处理promptContent，确保提示词内容保存正确
-      if (data.promptContent) {
-        const promptContent = data.promptContent as Record<string, string>;
-        if (promptContent.llm) {
-          updatedExtractionConfig.llm.prompt_setting.template = promptContent.llm;
-        }
-        if (promptContent.vlm) {
-          updatedExtractionConfig.vlm.prompt_setting.template = promptContent.vlm;
-        }
-      }
-      
-      // 更新或调试其他字段数据
-      console.log("更新抽取配置:", {
-        pendingUpdate: data.pendingUpdate,
-        fieldsCount: extractionFields ? {
-          llm: extractionFields.llm?.length || 0,
-          vlm: extractionFields.vlm?.length || 0
-        } : 'unchanged',
-        regexFieldsCount: data.regexFields ? (data.regexFields as any[]).length : 0,
-        activeFieldId: data.activeFieldId,
-        promptTypeChanged: !!data.promptType,
-        promptContentChanged: !!data.promptContent,
-        promptSettingsChanged: !!data.promptSettings
-      });
-      
-      // 生成所有字段列表，保存到状态中供评查设置使用
-      if (data.allFields) {
-        console.log("更新字段列表:", data.allFields);
-        // 将新字段列表保存到状态中
-        updateExtractionFields(data.allFields as string[]);
-      }
-      
-      // 返回更新后的表单数据
-      return {
-        ...prevData,
-        extraction_config: updatedExtractionConfig
-      };
-    });
-  };
-
-  /**
-   * 处理ReviewSettings组件数据变更
-   * 更新评查设置相关的表单数据
-   * @param data 评查设置组件传回的数据
-   */
-  const handleReviewSettingsChange = (data: Record<string, unknown>) => {
-    setFormData(prevData => {
-      const updatedData = { ...prevData };
-      
-      // 记录所有收到的数据
-      console.log("评查设置更新数据:", data);
-      
-      // 更新规则 - 只有当明确提供了rules数据时才更新
-      if (data.rules) {
-        // 验证并修复规则数据
-        const validatedRules = validateAndFixRules(data.rules as Rule[]);
-        console.log("规则数据验证后:", validatedRules);
-        updatedData.evaluation_config.rules = validatedRules;
-      }
-      
-      // 更新组合逻辑
-      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;
-      }
-      
-      // 更新分数
-      if (data.score !== undefined) {
-        const scoreValue = parseFloat(data.score as string);
-        updatedData.score = isNaN(scoreValue) ? 0 : scoreValue;
-      }
-      
-      // 更新分数显示值
-      if (data.scoreDisplay !== undefined) {
-        updatedData.scoreDisplay = data.scoreDisplay as string;
-      }
-      
-      return updatedData;
-    });
-  };
-
-  /**
-   * 检查并修复评查规则数据
-   * 确保数据的完整性和有效性
-   * @param rules 原始规则数据
-   * @returns 验证和修复后的规则数据
-   */
-  const validateAndFixRules = (rules: Rule[] | undefined): Rule[] => {
-    if (!rules || !Array.isArray(rules)) {
-      console.log("规则数据无效或为空，返回空数组");
-      return [];
-    }
-    
-    // 过滤无效规则，确保每个规则都有type字段
-    const validRules = rules.filter(rule => {
-      if (!rule || typeof rule !== 'object') {
-        console.log("发现无效规则对象:", rule);
-        return false;
-      }
-      
-      if (!rule.type || typeof rule.type !== 'string' || rule.type.trim() === '') {
-        console.log("发现无效规则类型:", rule);
-        return false;
-      }
-      
-      if (!rule.id || typeof rule.id !== 'string') {
-        console.log("发现缺少ID的规则:", rule);
-        // 为缺少ID的规则自动生成ID
-        rule.id = `rule_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-      }
-      
-      // 确保config存在
-      if (!rule.config || typeof rule.config !== 'object') {
-        console.log("规则缺少配置对象，自动创建:", rule);
-        rule.config = {};
-      }
-      
-      return true;
-    });
-    
-    console.log(`规则验证结果: 输入${rules.length}条，有效${validRules.length}条`);
-    return validRules;
-  };
-
-  /**
-   * 格式化数据，准备提交到接口
-   * 将内部表单数据转换为API期望的格式
-   * @param data 表单数据
-   * @returns 格式化后的API数据
-   */
-  const formatDataForApi = (data: FormDataType): ApiRuleData => {
-    console.log('格式化数据用于API提交:', data);
-    
-    // 基本信息处理
-    const formattedData: ApiRuleData = {
-      name: data.name || '',
-      version: '', // 从FormDataType中获取或使用默认值
-      description: data.description || '',
-      doc_type: [], // 从FormDataType中获取或使用默认值
-      extraction_config: {
-        llm: {
-          fields: data.extraction_config.llm.fields || [],
-          prompt_setting: data.extraction_config.llm.prompt_setting || {
-            type: 'system',
-            template: ''
-          }
-        },
-        vlm: {
-          fields: Array.isArray(data.extraction_config.vlm.fields) 
-            ? data.extraction_config.vlm.fields.map((field: string | ApiVlmField) => {
-                // 如果是字符串，处理为对象
-                if (typeof field === 'string') {
-                  if (field.includes('_')) {
-                    const [name, type] = field.split('_');
-                    return { name, type: type || 'default' };
-                  }
-                  return { name: field, type: 'default' };
-                }
-                // 如果已经是对象，直接返回
-                return field;
-              })
-            : [],
-          prompt_setting: data.extraction_config.vlm.prompt_setting || {
-            type: 'system',
-            template: ''
-          }
-        },
-        regex: {
-          fields: data.extraction_config.regex.fields.filter(f => f.field && f.field.trim() !== '').map(f => ({
-            field: f.field,
-            pattern: f.pattern || ''
-          }))
-        }
-      },
-      evaluation_config: {
-        // 默认值或从当前数据中转换
-        logic: 'and', // 默认值
-        auto_check: true, // 默认值
-        output_items: [], // 默认值
-        points: [] // 默认值
-      }
-    };
-    
-    console.log('API数据格式化完成:', formattedData);
-    return formattedData;
-  };
-
-  /**
-   * 确定使用的HTTP方法和URL
-   * 根据是否为编辑模式返回不同的HTTP方法和端点
-   * @param id 评查点ID，编辑模式下存在
-   * @returns HTTP方法和端点
-   */
-  const getEndpointAndMethod = (id?: number) => {
-    let method = 'POST';
-    let endpoint = 'http://127.0.0.1:9000/admin/evaluation_points';
-  
-    // 如果是编辑模式，使用PATCH更新现有记录
-    if (id) {
-      method = 'PATCH';
-      endpoint = `http://127.0.0.1:9000/admin/evaluation_points?id=eq.${id}`;
-    }
-
-    return { method, endpoint };
-  };
-
-  /**
-   * 保存评查点
-   * 验证数据并提交到API
-   */
-  const handleSave = async () => {
-    try {
-      setIsLoading(true);
-      
-      // 记录当前评查规则状态
-      console.log("保存前评查规则状态:", formData.evaluation_config.rules);
-      
-      // 基本验证
-      if (!formData.name || !formData.code) {
-        alert("请填写评查点名称和编码，这些是必填项");
-        setIsLoading(false);
-        return;
-      }
-      
-      // 检查评查点类型
-      if (!formData.type) {
-        alert("请选择评查点类型");
-        setIsLoading(false);
-        return;
-      }
-      
-      // 检查所属规则组
-      if (!formData.evaluation_point_groups_id) {
-        alert("请选择所属规则组");
-        setIsLoading(false);
-        return;
-      }
-      
-      // 检查评查规则 - 只在新增模式下检查规则是否为空
-      if (!isEditMode && 
-          (!formData.evaluation_config.rules || 
-           formData.evaluation_config.rules.length === 0 ||
-           !formData.evaluation_config.rules.some(rule => rule.type && rule.type.trim() !== ''))) {
-        console.log("规则验证失败，当前规则:", formData.evaluation_config.rules);
-        console.log("规则数量:", formData.evaluation_config.rules?.length || 0);
-        console.log("规则有效性:", formData.evaluation_config.rules?.some(rule => rule.type && rule.type.trim() !== ''));
-        alert("请至少添加一条有效的评查规则");
-        setIsLoading(false);
-        return;
-      }
-      
-      // 编辑模式下，只有当规则数组不为空时才验证规则有效性
-      if (isEditMode && 
-          formData.evaluation_config.rules && 
-          formData.evaluation_config.rules.length > 0 &&
-          !formData.evaluation_config.rules.some(rule => rule.type && rule.type.trim() !== '')) {
-        console.log("编辑模式下规则无效，当前规则:", formData.evaluation_config.rules);
-        console.log("编辑模式-规则数量:", formData.evaluation_config.rules.length);
-        console.log("编辑模式-规则详情:", JSON.stringify(formData.evaluation_config.rules, null, 2));
-        console.log("编辑模式-规则有效性:", formData.evaluation_config.rules.some(rule => rule.type && rule.type.trim() !== ''));
-        alert("请至少添加一条有效的评查规则或清空规则列表");
-        setIsLoading(false);
-        return;
-      }
-      
-      const evaluationPointData = formatDataForApi(formData);
-      console.log("保存数据:", evaluationPointData);
-      
-      const { method, endpoint } = getEndpointAndMethod(formData.id);
-      console.log(`发送${method}请求到`, endpoint);
-      
-      // 发送数据到API
-      const response = await fetch(endpoint, {
-        method: method,
-        headers: {
-          'Content-Type': 'application/json',
-          'Accept': 'application/json'
-        },
-        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(`保存失败: ${errorJson.msg || response.statusText}`);
-        } catch (parseError) {
-          // 如果无法解析为JSON，使用原始文本
-          throw new Error(`保存失败: ${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);
-        
-        // 处理响应
-        await handleApiResponse(responseData, isEditMode);
-      } 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);
-    }
-  };
-  
-  /**
-   * 保存为草稿
-   * 验证基本数据并提交到API，与保存正式版相比校验更宽松
-   */
-  const handleSaveDraft = async () => {
-    try {
-      setIsLoading(true);
-      
-      // 基本验证
-      if (!formData.name || !formData.code) {
-        alert("请填写评查点名称和编码，这些是必填项");
-        setIsLoading(false);
-        return;
-      }
-      
-      // 检查评查点类型
-      if (!formData.type) {
-        alert("请选择评查点类型");
-        setIsLoading(false);
-        return;
-      }
-      
-      // 检查所属规则组
-      if (!formData.evaluation_point_groups_id) {
-        alert("请选择所属规则组");
-        setIsLoading(false);
-        return;
-      }
-      
-      // 编辑模式下不检查评查规则是否为空
-      // 草稿模式下规则可以为空
-      
-      const draftData = formatDataForApi(formData);
-      console.log("保存草稿数据:", draftData);
-      
-      const { method, endpoint } = getEndpointAndMethod(formData.id);
-      console.log(`发送${method}请求到`, endpoint);
-      
-      // 发送数据到API
-      const response = await fetch(endpoint, {
-        method: method,
-        headers: {
-          'Content-Type': 'application/json',
-          'Accept': 'application/json'
-        },
-        body: JSON.stringify(draftData)
-      });
-      
-      // 输出完整响应信息
-      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(`保存失败: ${errorJson.msg || response.statusText}`);
-        } catch (parseError) {
-          // 如果无法解析为JSON，使用原始文本
-          throw new Error(`保存失败: ${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);
-        
-        // 处理响应
-        await handleApiResponse(responseData, isEditMode, true);
-      } 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);
-    }
-  };
-
-  /**
-   * 处理API响应
-   * 根据API响应结果进行页面跳转等后续操作
-   * @param responseData API响应数据
-   * @param isEditMode 是否为编辑模式
-   * @param isDraft 是否为草稿模式
-   */
-  const handleApiResponse = async (
-    responseData: 
-      | ApiResponse
-      | Array<{ id: number; [key: string]: unknown }>,
-    isEditMode: boolean, 
-    isDraft: boolean = false
-  ) => {
-    // 适配新的API响应格式
-    if (responseData && typeof responseData === 'object') {
-      // 符合新的API规范
-      if ('code' in responseData && responseData.code === 0) {
-        console.log(`${isDraft ? '草稿' : ''}保存成功 (新API格式):`, responseData.data);
-        alert(`${isDraft ? '草稿' : ''}保存成功!`);
-        
-        // 根据操作类型重定向
-        if (isEditMode) {
-          // 编辑模式，保留在当前编辑页面
-          navigate(`/rules/new?id=${formData.id}`);
-        } else {
-          // 创建模式，跳转到新创建数据的编辑页面
-          let newId: number | undefined;
-          
-          if (responseData.data && Array.isArray(responseData.data) && responseData.data.length > 0) {
-            newId = responseData.data[0].id as number;
-          } else if (responseData.data && typeof responseData.data === 'object' && 'id' in responseData.data) {
-            newId = responseData.data.id as number;
-          }
-          
-          if (newId) {
-            navigate(`/rules/new?id=${newId}`);
-          } else {
-            // 无法获取ID，返回列表页
-            navigate('/rules');
-          }
-        }
-        return;
-      } else if ('code' in responseData && responseData.code !== 0) {
-        // API返回错误
-        console.warn("API返回错误:", responseData.msg);
-        throw new Error(responseData.msg as string || "操作失败");
-      }
-    }
-    
-    // 兼容处理旧的响应格式
-    if (Array.isArray(responseData)) {
-      if (responseData.length > 0) {
-        console.log(`${isDraft ? '草稿' : ''}保存成功 (数组响应):`, responseData[0]);
-        alert(`${isDraft ? '草稿' : ''}保存成功!`);
-        
-        // 如果是创建，跳转到编辑页面
-        if (!isEditMode && responseData[0].id) {
-          navigate(`/rules/new?id=${responseData[0].id}`);
-        } else {
-          navigate('/rules');
-        }
-      } else {
-        console.warn("响应数组为空");
-        alert("操作已完成，但服务器未返回数据");
-        navigate('/rules');
-      }
-    } else if (responseData && typeof responseData === 'object') {
-      if ('data' in responseData && responseData.data) {
-        console.log(`${isDraft ? '草稿' : ''}保存成功 (带data字段):`, responseData.data);
-        alert(`${isDraft ? '草稿' : ''}保存成功!`);
-        
-        let newId: number | undefined;
-        if (Array.isArray(responseData.data) && responseData.data.length > 0 && 'id' in responseData.data[0]) {
-          newId = responseData.data[0].id as number;
-        } else if (typeof responseData.data === 'object' && 'id' in responseData.data) {
-          newId = responseData.data.id as number;
-        }
-        
-        if (!isEditMode && newId) {
-          navigate(`/rules/new?id=${newId}`);
-        } else {
-          navigate('/rules');
-        }
-      } else if ('id' in responseData && responseData.id) {
-        console.log(`${isDraft ? '草稿' : ''}保存成功 (直接对象):`, responseData);
-        alert(`${isDraft ? '草稿' : ''}保存成功!`);
-        
-        if (!isEditMode) {
-          navigate(`/rules/new?id=${responseData.id as number}`);
-        } else {
-          navigate('/rules');
-        }
-      } else {
-        console.warn("响应对象格式不符合预期", responseData);
-        alert("操作已完成，但返回的数据格式不符合预期");
-        navigate('/rules');
-      }
-    } else {
-      console.warn("响应不是数组或对象", responseData);
-      alert("操作已完成，但返回的数据格式不符合预期");
-      navigate('/rules');
-    }
-  };
-
-  /**
-   * 当评查点组数据和表单数据都加载完成后，确保类型信息被正确设置
-   */
-  useEffect(() => {
-    // 仅在编辑模式下，且表单数据已加载，评查点组数据也已加载的情况下执行
-    if (
-      isEditMode && 
-      formData.id && 
-      evaluationPointGroups.length > 0 && 
-      (!formData.type || formData.type === '')
-    ) {
-      console.log("检测到编辑模式下类型未设置，尝试自动设置类型");
-      
-      // 首先尝试通过evaluation_point_groups_pid设置类型
-      if (formData.evaluation_point_groups_pid) {
-        const typeGroup = evaluationPointGroups.find(
-          group => group.id === formData.evaluation_point_groups_pid
-        );
-        
-        if (typeGroup) {
-          console.log("通过评查点类型ID找到类型组:", typeGroup);
-          setFormData(prevData => ({
-            ...prevData,
-            type: typeGroup.code
-          }));
-          console.log("自动设置类型为:", typeGroup.code);
-          return;
-        }
-      }
-      
-      // 如果无法通过evaluation_point_groups_pid设置，尝试通过evaluation_point_groups_id设置
-      if (formData.evaluation_point_groups_id) {
-        const ruleGroup = evaluationPointGroups.find(
-          group => group.id === formData.evaluation_point_groups_id
-        );
-        
-        if (ruleGroup && ruleGroup.pid && ruleGroup.pid !== 0) {
-          const parentGroup = evaluationPointGroups.find(
-            group => group.id === ruleGroup.pid
-          );
-          
-          if (parentGroup) {
-            console.log("通过规则组找到父级类型组:", parentGroup);
-            setFormData(prevData => ({
-              ...prevData,
-              type: parentGroup.code,
-              evaluation_point_groups_pid: parentGroup.id
-            }));
-            console.log("自动设置类型为:", parentGroup.code);
-          }
-        }
-      }
-    }
-  }, [isEditMode, formData.id, formData.type, formData.evaluation_point_groups_id, formData.evaluation_point_groups_pid, evaluationPointGroups]);
+  }, [location.search, fetchEvaluationPoint, fetchEvaluationPointGroups]);
 
   // 渲染页面内容
   return (
     <div className="container">
       {/* 页面标题和右上角保存按钮 */}
-      <PageHeader 
-        title={isEditMode ? "编辑评查点" : "新增评查点"} 
-        onSave={handleSave} 
+      <PageHeader
+        title={isEditMode ? "编辑评查点" : "新增评查点"}
+        onSave={handleSave}
       />
-      
+
       {/* 加载状态显示 */}
       {isLoading ? (
         <div className="flex justify-center items-center p-12">
@@ -1482,52 +185,73 @@ export default function RuleNew() {
         <>
           {/* 评查点基本信息设置 */}
           <div className="mb-8">
-            <BasicInfo 
-              onChange={handleBasicInfoChange} 
-              initialData={formData} 
+            <BasicInfo
+              onChange={handleBasicInfoChange}
+              initialData={formData}
               evaluationPointGroups={evaluationPointGroups}
+              riskOptions={EVALUATION_OPTIONS.riskLevelOptions}
             />
           </div>
-          
+
           {/* 抽取设置 - 配置从文档中提取的字段 */}
           <div className="mb-8">
-            <RuleContext.Provider value={{ extractionFields, updateFields: updateExtractionFields }}>
-              <ExtractionSettings 
-                onChange={handleExtractionSettingsChange} 
-                initialData={{
-                  llm: formData.extraction_config.llm,
-                  vlm: formData.extraction_config.vlm,
-                  regex: formData.extraction_config.regex
-                }} 
-              />
-            </RuleContext.Provider>
+            <ExtractionSettings
+              onChange={handleExtractionSettingsChange}
+              initialData={{
+                llm: {
+                  fields: formData.extraction_config?.llm?.fields,
+                  prompt_setting: {
+                    type: formData.extraction_config?.llm?.prompt_setting?.type,
+                    template: formData.extraction_config?.llm?.prompt_setting?.template
+                  }
+                },
+                vlm: {
+                  fields: formData.extraction_config?.vlm?.fields,
+                  prompt_setting: {
+                    type: formData.extraction_config?.vlm?.prompt_setting?.type,
+                    template: formData.extraction_config?.vlm?.prompt_setting?.template
+                  }
+                },
+                regex: {
+                  fields: formData.extraction_config?.regex?.fields
+                }
+              }}
+              promptTypeOptions={EVALUATION_OPTIONS.promptTypeOptions}
+              vlmFieldTypeOptions={EVALUATION_OPTIONS.vlmFieldTypeOptions}
+            />
           </div>
-          
+
           {/* 评查设置 - 配置评查规则、消息等 */}
           <div className="mb-8">
-            <RuleContext.Provider value={{ extractionFields, updateFields: updateExtractionFields }}>
-              <ReviewSettings 
-                key={`review-settings-${isEditMode ? formData.id : 'new'}`}
-                onChange={handleReviewSettingsChange} 
-                initialData={{
-                  rules: deepClone(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,
+            <ReviewSettings
+              key={`review-settings-${isEditMode ? formData.id : 'new'}`}
+              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,
-                  score: formData.score,
-                  scoreDisplay: formData.scoreDisplay
-                }} 
-              />
-            </RuleContext.Provider>
+                  score: formData.score
+                }}
+                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 
+          <ActionButtons
             onSave={handleSave}
             onSaveDraft={handleSaveDraft}
             isEditMode={isEditMode}
diff --git a/app/routes/rules.new1.tsx b/app/routes/rules.new1.tsx
new file mode 100644
index 0000000..d4d56df
--- /dev/null
+++ b/app/routes/rules.new1.tsx
@@ -0,0 +1,1539 @@
+/**
+ * 评查点管理页面 - 创建或编辑评查点规则
+ * 
+ * 功能概述:
+ * - 支持创建新的评查点规则或编辑现有规则
+ * - 评查点包含基本信息、抽取设置和评查设置三大部分
+ * - 支持使用三种抽取方式: 大模型(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 } from "react";
+import { BasicInfo } from "~/components/rules/new/BasicInfo";
+import { ExtractionSettings } from "~/components/rules/new/ExtractionSettings";
+import { ReviewSettings } from "~/components/rules/new/ReviewSettings";
+import { RuleContext } from "~/contexts/RuleContext";
+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: "评查点管理"
+};
+
+// 定义类型
+/**
+ * 正则表达式字段定义
+ * @property field - 字段名称
+ * @property pattern - 正则表达式模式
+ */
+interface RegexField {
+  field: string;
+  pattern: string;
+}
+
+/**
+ * 多模态(VLM)字段定义，包含字段名和类型
+ * @property name - 字段名称
+ * @property type - 字段类型，如"default"、"table"等
+ */
+interface ApiVlmField {
+  name: string;
+  type: string;
+}
+
+/**
+ * 提示词设置
+ * @property type - 提示词类型，如"system"、"user"等
+ * @property template - 提示词模板内容
+ */
+interface PromptSetting {
+  type: string;
+  template: string;
+}
+
+/**
+ * 抽取配置，包含三种抽取方式
+ * @property llm - 大模型抽取配置
+ * @property vlm - 多模态抽取配置
+ * @property regex - 正则表达式抽取配置
+ */
+interface ExtactionConfigType {
+  llm: {
+    fields: string[];
+    prompt_setting: PromptSetting;
+  };
+  vlm: {
+    fields: (ApiVlmField | string)[];
+    prompt_setting: PromptSetting;
+  };
+  regex: {
+    fields: RegexField[];
+  };
+}
+
+/**
+ * API请求使用的抽取配置，字段可选
+ */
+interface ApiExtactionConfigType {
+  llm?: {
+    fields?: string[];
+    prompt_setting?: {
+      type?: string;
+      template?: string;
+    }
+  };
+  vlm?: {
+    fields?: ApiVlmField[];
+    prompt_setting?: {
+      type?: string;
+      template?: string;
+    }
+  };
+  regex?: {
+    fields?: RegexField[];
+  };
+}
+
+/**
+ * 规则配置类型，使用索引签名支持不同类型规则的不同配置项
+ */
+interface RuleConfigType {
+  [key: string]: unknown;
+}
+
+/**
+ * 评查规则定义
+ * @property id - 规则唯一标识
+ * @property type - 规则类型，如"exists"、"consistency"等
+ * @property config - 规则配置，根据规则类型不同而不同
+ */
+interface Rule {
+  id: string;
+  type: string;
+  config: RuleConfigType;
+}
+
+/**
+ * 评查配置
+ * @property logicType - 规则组合逻辑，如"and"、"or"、"custom"
+ * @property customLogic - 自定义逻辑表达式
+ * @property rules - 规则列表
+ */
+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;    // 所属评查组ID
+  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;                         // 评查点类型
+  evaluation_point_groups_pid: number | null;   // 评查点类型组ID
+  score: number;                        // 分数
+  scoreDisplay?: string;                // 分数显示值
+}
+
+/**
+ * API返回的评查点数据
+ */
+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;
+  evaluation_point_groups_pid?: 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;
+  meta?: {
+    type: string;
+    pid?: number;
+    [key: string]: unknown;
+  };
+  score?: number;
+  scoreDisplay?: string;
+}
+
+/**
+ * API响应数据类型
+ */
+interface ApiResponse {
+  code?: number;
+  msg?: string;
+  data?: Array<Record<string, unknown>> | Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+/**
+ * API提交数据格式
+ */
+interface ApiRuleData {
+  id?: number;
+  name: string;
+  version?: string;
+  description: string;
+  doc_type?: string[];
+  extraction_config: {
+    llm: {
+      fields: string[];
+      prompt_setting: PromptSetting;
+    };
+    vlm: {
+      fields: ApiVlmField[];
+      prompt_setting: PromptSetting;
+    };
+    regex: {
+      fields: RegexField[];
+    };
+  };
+  evaluation_config: {
+    logic?: string;
+    auto_check?: boolean;
+    output_items?: string[];
+    points?: Array<Record<string, unknown>>;
+    [key: string]: unknown;
+  };
+}
+
+/**
+ * 深拷贝工具函数
+ * 用于创建对象的深拷贝，避免引用类型导致的意外修改
+ * @param obj 要复制的对象
+ * @returns 深拷贝后的对象
+ */
+function deepClone<T>(obj: T): T {
+  if (obj === null || obj === undefined || typeof obj !== 'object') {
+    return obj;
+  }
+  
+  try {
+    return JSON.parse(JSON.stringify(obj));
+  } catch (err) {
+    console.error('深拷贝对象失败:', err);
+    return obj;
+  }
+}
+
+export default function RuleNew() {
+  const navigate = useNavigate();
+  const location = useLocation();
+  // 保存从抽取设置中获取的字段列表，用于评查规则选择
+  const [extractionFields, setExtractionFields] = useState<string[]>([]);
+  // 标记是否为编辑模式（通过URL参数判断）
+  const [isEditMode, setIsEditMode] = useState<boolean>(false);
+  // 标记数据加载状态
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+  // 保存评查点组数据，用于基本信息表单中选择
+  const [evaluationPointGroups, setEvaluationPointGroups] = useState<Array<{id: number, pid: number, code: string, name: string, is_enabled: boolean}>>([]);
+  // 表单数据，包含评查点的所有信息
+  const [formData, setFormData] = useState<FormDataType>({
+    // 基本信息字段
+    name: '',
+    code: '',
+    risk: 'medium',
+    is_enabled: true,
+    description: '',
+    references_laws: {
+      name: '',
+      articles: [],
+      content: ''
+    },
+    evaluation_point_groups_id: null,
+    type: '',
+    evaluation_point_groups_pid: null,
+    
+    // 抽取设置
+    extraction_config: {
+      llm: {
+        fields: [],
+        prompt_setting: {
+          type: 'system',
+          template: ''
+        }
+      },
+      vlm: {
+        fields: [],
+        prompt_setting: {
+          type: 'system',
+          template: ''
+        }
+      },
+      regex: {
+        fields: [{ field: '', pattern: '' }]
+      }
+    },
+    
+    // 评查设置
+    evaluation_config: {
+      logicType: 'and',
+      customLogic: '',
+      rules: []
+    },
+    
+    // 评查结果消息
+    pass_message: '文档检查通过，符合规范要求。',
+    fail_message: '文档存在以下问题，请修改后重新提交。',
+    suggestion_message: '',
+    suggestion_message_type: 'warning',
+    
+    // 评查后动作
+    post_action: 'none',
+    action_config: '',
+    
+    // 分数
+    score: 0
+  });
+
+  /**
+   * 页面加载时初始化处理
+   * 1. 检查URL参数，判断是新建还是编辑模式
+   * 2. 编辑模式下获取评查点数据
+   * 3. 获取评查点组数据（用于表单选择项）
+   */
+  useEffect(() => {
+    const searchParams = new URLSearchParams(location.search);
+    const id = searchParams.get('id');
+    
+    if (id) {
+      setIsEditMode(true);
+      fetchEvaluationPoint(parseInt(id));
+    }
+
+    // 获取评查点组数据
+    fetchEvaluationPointGroups();
+  }, [location.search]);
+
+  /**
+   * 获取评查点组数据
+   * 从API获取所有评查点组，用于基本信息表单中选择
+   */
+  const fetchEvaluationPointGroups = async () => {
+    try {
+      console.log("获取评查点组数据");
+      const response = await fetch("http://127.0.0.1:9000/admin/evaluation_point_groups", {
+        method: 'GET',
+        headers: {
+          'Accept': 'application/json',
+          'Content-Type': '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("评查点组数据原始响应:", responseData);
+      
+      // 适配API响应格式
+      let groupsData: Array<{id: number, pid: number, code: string, name: string, is_enabled: boolean}> = [];
+      if (responseData && typeof responseData === 'object') {
+        if (responseData.code === 0 && responseData.data) {
+          // 新API格式
+          groupsData = Array.isArray(responseData.data) ? responseData.data : [responseData.data];
+        } else if (Array.isArray(responseData)) {
+          // 旧API格式
+          groupsData = responseData;
+        } else if (responseData.data && Array.isArray(responseData.data)) {
+          // 旧API格式
+          groupsData = responseData.data;
+        }
+      }
+      
+      // 确保所有项都有必需的字段
+      groupsData = groupsData.filter(item => 
+        item && typeof item === 'object' && 
+        'id' in item && 
+        'pid' in item && 
+        'code' in item && 
+        'name' in item
+      );
+      
+      console.log("处理后的评查点组数据:", groupsData);
+      console.log("根级评查点类型:", groupsData.filter(group => group.pid === 0));
+      setEvaluationPointGroups(groupsData);
+      
+      // 如果表单数据已加载但类型未设置，尝试根据evaluation_point_groups_pid设置类型
+      if (formData.id && !formData.type && formData.evaluation_point_groups_pid) {
+        console.log("评查点组数据加载后更新类型，当前pid:", formData.evaluation_point_groups_pid);
+        
+        const typeGroup = groupsData.find(group => group.id === formData.evaluation_point_groups_pid);
+        if (typeGroup) {
+          console.log("找到对应的类型组:", typeGroup);
+          setFormData(prevData => ({
+            ...prevData,
+            type: typeGroup.code
+          }));
+          console.log("根据评查点类型ID更新类型为:", typeGroup.code);
+        } else if (formData.evaluation_point_groups_id) {
+          // 通过规则组查找类型
+          const selectedGroup = groupsData.find(group => group.id === formData.evaluation_point_groups_id);
+          if (selectedGroup && selectedGroup.pid !== 0) {
+            const parentTypeGroup = groupsData.find(group => group.id === selectedGroup.pid);
+            if (parentTypeGroup) {
+              console.log("通过规则组找到类型组:", parentTypeGroup);
+              setFormData(prevData => ({
+                ...prevData,
+                type: parentTypeGroup.code,
+                evaluation_point_groups_pid: parentTypeGroup.id
+              }));
+              console.log("根据规则组更新类型为:", parentTypeGroup.code);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.error('获取评查点组数据失败:', error);
+      // 显示错误提示但不影响应用继续使用
+      alert(`获取评查点组数据失败: ${error instanceof Error ? error.message : '未知错误'}\n将使用默认数据`);
+    }
+  };
+
+  /**
+   * 获取评查点数据
+   * 编辑模式下从API获取指定ID的评查点数据
+   * @param id 评查点ID
+   */
+  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',
+          'Content-Type': '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);
+      
+      // 新的API响应格式适配
+      if (responseData && typeof responseData === 'object') {
+        if (responseData.code === 0 && responseData.data) {
+          // 符合新的API响应格式
+          if (Array.isArray(responseData.data)) {
+            if (responseData.data.length > 0) {
+              console.log("处理数组数据的第一项");
+              processPointData(responseData.data[0]);
+            } else {
+              console.error("数据数组为空");
+              throw new Error(`未找到ID为${id}的评查点数据`);
+            }
+          } else if (typeof responseData.data === 'object') {
+            console.log("处理单个对象数据");
+            processPointData(responseData.data);
+          }
+        } else if (responseData.code !== 0) {
+          // API返回错误
+          throw new Error(responseData.msg || `获取数据失败，错误码: ${responseData.code}`);
+        } else if (Array.isArray(responseData)) {
+          // 处理旧API格式：数组形式
+          if (responseData.length > 0) {
+            console.log("数组格式响应，使用第一项");
+            processPointData(responseData[0]);
+          } else {
+            console.error("数组为空，未找到数据");
+            throw new Error(`未找到ID为${id}的评查点数据`);
+          }
+        } else if (responseData.data) {
+          // 处理旧API格式：包含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) {
+          // 处理旧API格式：直接返回的对象
+          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 : '未知错误'}`);
+      // 获取数据失败时返回上一页
+      navigate(-1);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  
+  /**
+   * 处理获取到的评查点数据
+   * 将API返回的数据格式转换为表单数据格式
+   * @param pointData API返回的评查点数据
+   */
+  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);
+      console.log("评查规则详细信息:", JSON.stringify(evaluationConfig.rules || [], null, 2));
+      
+      // 提取字段列表，用于规则设置
+      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.type !== 'default' ? `${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);
+      
+      // 提取评查点类型ID
+      let pointGroupPid: number | null = null;
+      if (pointData.evaluation_point_groups_pid !== undefined && pointData.evaluation_point_groups_pid !== null) {
+        // 直接使用字段值
+        pointGroupPid = typeof pointData.evaluation_point_groups_pid === 'number' 
+          ? pointData.evaluation_point_groups_pid 
+          : null;
+        console.log("从evaluation_point_groups_pid获取类型ID:", pointGroupPid);
+      } else if (pointData.meta && typeof pointData.meta === 'object' && pointData.meta.pid !== undefined) {
+        // 从meta中提取
+        pointGroupPid = typeof pointData.meta.pid === 'number' 
+          ? pointData.meta.pid 
+          : null;
+        console.log("从meta.pid获取类型ID:", pointGroupPid);
+      }
+      
+      console.log("最终确定的类型ID:", pointGroupPid);
+      
+      // 处理分数
+      let pointScore = 0;
+      if (pointData.score !== undefined && pointData.score !== null) {
+        pointScore = typeof pointData.score === 'number' ? pointData.score : 0;
+        console.log("从score字段获取分数:", pointScore);
+      } else if (pointData.meta && typeof pointData.meta === 'object' && pointData.meta.score !== undefined) {
+        pointScore = typeof pointData.meta.score === 'number' ? pointData.meta.score : 0;
+        console.log("从meta.score获取分数:", pointScore);
+      }
+      
+      // 将API数据格式转换为内部使用的格式
+      setFormData({
+        id: pointData.id,
+        name: pointData.name || '',
+        code: pointData.code || '',
+        risk: pointData.risk || 'medium',
+        is_enabled: pointData.is_enabled !== undefined ? pointData.is_enabled : true,
+        description: pointData.description || '',
+        references_laws: pointData.references_laws || {
+          name: '',
+          articles: [],
+          content: ''
+        },
+        evaluation_point_groups_id: pointData.evaluation_point_groups_id || null,
+        evaluation_point_groups_pid: pointGroupPid,
+        type: pointData.type || (pointData.meta && pointData.meta.type ? pointData.meta.type : ''),
+        
+        // 将API数据格式转换为内部使用的格式
+        extraction_config: {
+          llm: {
+            fields: extractionConfig.llm?.fields || [],
+            prompt_setting: {
+              type: extractionConfig.llm?.prompt_setting?.type || 'system',
+              template: extractionConfig.llm?.prompt_setting?.template || ''
+            }
+          },
+          vlm: {
+            fields: extractionConfig.vlm?.fields?.map(field => {
+              if (typeof field === 'string') {
+                return { name: field, type: 'default' };
+              }
+              return field;
+            }) || [],
+            prompt_setting: {
+              type: extractionConfig.vlm?.prompt_setting?.type || 'system',
+              template: extractionConfig.vlm?.prompt_setting?.template || ''
+            }
+          },
+          regex: {
+            fields: (extractionConfig.regex?.fields || []).map((field) => ({
+              field: field.field || '',
+              pattern: field.pattern || ''
+            }))
+          }
+        },
+        
+        // 将API评查配置转换为内部使用的格式
+        evaluation_config: {
+          logicType: evaluationConfig.logicType || 'and',
+          customLogic: evaluationConfig.customLogic || '',
+          rules: (evaluationConfig.rules || []).map(rule => {
+            // 规则ID处理
+            if (!rule.id) {
+              rule.id = `rule_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            }
+            
+            // 根据规则类型调整config字段
+            if (rule.config) {
+              switch (rule.type) {
+                case 'exists':
+                  if (rule.config.fields) {
+                    // 确保config中有fields字段
+                    console.log(`[调试] API数据转UI - exists规则 ${rule.id} 字段: ${JSON.stringify(rule.config.fields)}`);
+                  } else if (rule.config.selectedFields) {
+                    // 兼容旧字段名
+                    rule.config.fields = rule.config.selectedFields;
+                    delete rule.config.selectedFields;
+                    console.log(`[调试] API数据转UI - exists规则 ${rule.id} 从selectedFields映射到fields`);
+                  }
+                  
+                  // 确保config中有logic字段
+                  if (rule.config.existsLogic && !rule.config.logic) {
+                    rule.config.logic = rule.config.existsLogic;
+                    delete rule.config.existsLogic;
+                    console.log(`[调试] API数据转UI - exists规则 ${rule.id} 从existsLogic映射到logic`);
+                  }
+                  break;
+                  
+                case 'consistency':
+                case 'logic':
+                  // 将logicRelation转换为标准的logic
+                  if (rule.config.logicRelation && !rule.config.logic) {
+                    rule.config.logic = rule.config.logicRelation;
+                    delete rule.config.logicRelation;
+                    console.log(`[调试] API数据转UI - ${rule.type}规则 ${rule.id} 从logicRelation映射到logic`);
+                  }
+                  break;
+              }
+            }
+            
+            return rule;
+          })
+        },
+        
+        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 || '',
+        score: typeof pointData.score === 'number' ? pointData.score : 0
+      });
+      
+      console.log("已成功解析并加载评查点数据");
+    } catch (error) {
+      console.error("处理评查点数据时出错:", error);
+      throw error;
+    }
+  };
+
+  /**
+   * 更新抽取字段列表
+   * 在抽取设置和评查设置之间共享字段列表信息
+   * @param fields 更新后的字段列表
+   */
+  const updateExtractionFields = (fields: string[]) => {
+    setExtractionFields(fields);
+  };
+
+  /**
+   * 处理BasicInfo组件数据变更
+   * 更新基本信息相关的表单数据
+   * @param data 基本信息组件传回的数据
+   */
+  const handleBasicInfoChange = (data: Record<string, unknown>) => {
+    setFormData(prevData => ({
+      ...prevData,
+      ...data
+    }));
+  };
+
+  /**
+   * 处理ExtractionSettings组件数据变更
+   * 更新抽取设置相关的表单数据
+   * @param data 抽取设置组件传回的数据
+   */
+  const handleExtractionSettingsChange = (data: Record<string, unknown>) => {
+    console.log("抽取设置更新:", data);
+    
+    setFormData(prevData => {
+      // 深拷贝以避免不可预期的状态更新
+      const updatedExtractionConfig = { ...prevData.extraction_config };
+      
+      // 根据不同类型的数据进行处理
+      // 处理regexFields数据 - 保留正则表达式配置
+      if (data.regexFields) {
+        const regexFields = data.regexFields as Array<{ field: string; pattern: string }>;
+        
+        // 检查是否有 activeFieldId 标记，表示正在编辑中
+        const activeFieldId = data.activeFieldId as string;
+        if (activeFieldId) {
+          console.log("检测到正在编辑的正则字段，保留所有字段");
+          updatedExtractionConfig.regex.fields = regexFields;
+        } else {
+          // 正常更新模式，过滤掉空字段名的项
+          updatedExtractionConfig.regex.fields = regexFields
+            .filter(field => field.field && field.field.trim() !== '')
+            .map(field => ({
+              field: field.field,
+              pattern: field.pattern || ''
+            }));
+        }
+      }
+      
+      // 处理字段数据 - 保留提取的字段名称
+      if (data.fields) {
+        const extractionFields = data.fields as { llm?: string[], vlm?: string[] };
+        const activeFieldId = data.activeFieldId as string;
+        
+        if (activeFieldId) {
+          // 检测到正在编辑的大模型或多模态字段，保留所有字段
+          console.log("检测到正在编辑的大模型或多模态字段，保留所有字段");
+          if (extractionFields.llm) {
+            updatedExtractionConfig.llm.fields = extractionFields.llm;
+          }
+          if (extractionFields.vlm) {
+            // 保存字符串形式的字段，在提交API时再进行处理
+            updatedExtractionConfig.vlm.fields = extractionFields.vlm;
+          }
+        } else {
+          // 正常更新模式，过滤掉空字段
+          if (extractionFields.llm) {
+            updatedExtractionConfig.llm.fields = extractionFields.llm.filter(field => field && field.trim() !== '');
+          }
+          if (extractionFields.vlm) {
+            // 保存字符串形式的字段，在提交API时再进行处理
+            updatedExtractionConfig.vlm.fields = extractionFields.vlm.filter(field => field && field.trim() !== '');
+          }
+        }
+      }
+      
+      // 处理提示词设置
+      if (data.promptSettings) {
+        const promptSettings = data.promptSettings as Record<string, { type: string; content: string; template: string }>;
+        
+        // 更新大模型抽取提示词设置
+        if (promptSettings.llm) {
+          updatedExtractionConfig.llm.prompt_setting = {
+            type: promptSettings.llm.type as string || 'system',
+            template: promptSettings.llm.content as string || ''
+          };
+        }
+        
+        // 更新多模态抽取提示词设置
+        if (promptSettings.vlm) {
+          updatedExtractionConfig.vlm.prompt_setting = {
+            type: promptSettings.vlm.type as string || 'system',
+            template: promptSettings.vlm.content as string || ''
+          };
+        }
+      }
+      
+      // 单独处理promptType，确保提示词设置类型正确
+      if (data.promptType) {
+        const promptType = data.promptType as Record<string, string>;
+        if (promptType.llm) {
+          updatedExtractionConfig.llm.prompt_setting.type = promptType.llm;
+        }
+        if (promptType.vlm) {
+          updatedExtractionConfig.vlm.prompt_setting.type = promptType.vlm;
+        }
+      }
+      
+      // 单独处理promptContent，确保提示词内容保存正确
+      if (data.promptContent) {
+        const promptContent = data.promptContent as Record<string, string>;
+        if (promptContent.llm) {
+          updatedExtractionConfig.llm.prompt_setting.template = promptContent.llm;
+        }
+        if (promptContent.vlm) {
+          updatedExtractionConfig.vlm.prompt_setting.template = promptContent.vlm;
+        }
+      }
+      
+      // 更新或调试其他字段数据
+      console.log("更新抽取配置:", {
+        pendingUpdate: data.pendingUpdate,
+        fieldsCount: extractionFields ? {
+          llm: extractionFields.llm?.length || 0,
+          vlm: extractionFields.vlm?.length || 0
+        } : 'unchanged',
+        regexFieldsCount: data.regexFields ? (data.regexFields as any[]).length : 0,
+        activeFieldId: data.activeFieldId,
+        promptTypeChanged: !!data.promptType,
+        promptContentChanged: !!data.promptContent,
+        promptSettingsChanged: !!data.promptSettings
+      });
+      
+      // 生成所有字段列表，保存到状态中供评查设置使用
+      if (data.allFields) {
+        console.log("更新字段列表:", data.allFields);
+        // 将新字段列表保存到状态中
+        updateExtractionFields(data.allFields as string[]);
+      }
+      
+      // 返回更新后的表单数据
+      return {
+        ...prevData,
+        extraction_config: updatedExtractionConfig
+      };
+    });
+  };
+
+  /**
+   * 处理ReviewSettings组件数据变更
+   * 更新评查设置相关的表单数据
+   * @param data 评查设置组件传回的数据
+   */
+  const handleReviewSettingsChange = (data: Record<string, unknown>) => {
+    setFormData(prevData => {
+      const updatedData = { ...prevData };
+      
+      // 记录所有收到的数据
+      console.log("评查设置更新数据:", data);
+      
+      // 更新规则 - 只有当明确提供了rules数据时才更新
+      if (data.rules) {
+        // 验证并修复规则数据
+        const validatedRules = validateAndFixRules(data.rules as Rule[]);
+        console.log("规则数据验证后:", validatedRules);
+        updatedData.evaluation_config.rules = validatedRules;
+      }
+      
+      // 更新组合逻辑
+      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;
+      }
+      
+      // 更新分数
+      if (data.score !== undefined) {
+        const scoreValue = parseFloat(data.score as string);
+        updatedData.score = isNaN(scoreValue) ? 0 : scoreValue;
+      }
+      
+      // 更新分数显示值
+      if (data.scoreDisplay !== undefined) {
+        updatedData.scoreDisplay = data.scoreDisplay as string;
+      }
+      
+      return updatedData;
+    });
+  };
+
+  /**
+   * 检查并修复评查规则数据
+   * 确保数据的完整性和有效性
+   * @param rules 原始规则数据
+   * @returns 验证和修复后的规则数据
+   */
+  const validateAndFixRules = (rules: Rule[] | undefined): Rule[] => {
+    if (!rules || !Array.isArray(rules)) {
+      console.log("规则数据无效或为空，返回空数组");
+      return [];
+    }
+    
+    // 过滤无效规则，确保每个规则都有type字段
+    const validRules = rules.filter(rule => {
+      if (!rule || typeof rule !== 'object') {
+        console.log("发现无效规则对象:", rule);
+        return false;
+      }
+      
+      if (!rule.type || typeof rule.type !== 'string' || rule.type.trim() === '') {
+        console.log("发现无效规则类型:", rule);
+        return false;
+      }
+      
+      if (!rule.id || typeof rule.id !== 'string') {
+        console.log("发现缺少ID的规则:", rule);
+        // 为缺少ID的规则自动生成ID
+        rule.id = `rule_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      }
+      
+      // 确保config存在
+      if (!rule.config || typeof rule.config !== 'object') {
+        console.log("规则缺少配置对象，自动创建:", rule);
+        rule.config = {};
+      }
+      
+      return true;
+    });
+    
+    console.log(`规则验证结果: 输入${rules.length}条，有效${validRules.length}条`);
+    return validRules;
+  };
+
+  /**
+   * 格式化数据，准备提交到接口
+   * 将内部表单数据转换为API期望的格式
+   * @param data 表单数据
+   * @returns 格式化后的API数据
+   */
+  const formatDataForApi = (data: FormDataType): ApiRuleData => {
+    console.log('格式化数据用于API提交:', data);
+    
+    // 基本信息处理
+    const formattedData: ApiRuleData = {
+      name: data.name || '',
+      version: '', // 从FormDataType中获取或使用默认值
+      description: data.description || '',
+      doc_type: [], // 从FormDataType中获取或使用默认值
+      extraction_config: {
+        llm: {
+          fields: data.extraction_config.llm.fields || [],
+          prompt_setting: data.extraction_config.llm.prompt_setting || {
+            type: 'system',
+            template: ''
+          }
+        },
+        vlm: {
+          fields: Array.isArray(data.extraction_config.vlm.fields) 
+            ? data.extraction_config.vlm.fields.map((field: string | ApiVlmField) => {
+                // 如果是字符串，处理为对象
+                if (typeof field === 'string') {
+                  if (field.includes('_')) {
+                    const [name, type] = field.split('_');
+                    return { name, type: type || 'default' };
+                  }
+                  return { name: field, type: 'default' };
+                }
+                // 如果已经是对象，直接返回
+                return field;
+              })
+            : [],
+          prompt_setting: data.extraction_config.vlm.prompt_setting || {
+            type: 'system',
+            template: ''
+          }
+        },
+        regex: {
+          fields: data.extraction_config.regex.fields.filter(f => f.field && f.field.trim() !== '').map(f => ({
+            field: f.field,
+            pattern: f.pattern || ''
+          }))
+        }
+      },
+      evaluation_config: {
+        // 默认值或从当前数据中转换
+        logic: 'and', // 默认值
+        auto_check: true, // 默认值
+        output_items: [], // 默认值
+        points: [] // 默认值
+      }
+    };
+    
+    console.log('API数据格式化完成:', formattedData);
+    return formattedData;
+  };
+
+  /**
+   * 确定使用的HTTP方法和URL
+   * 根据是否为编辑模式返回不同的HTTP方法和端点
+   * @param id 评查点ID，编辑模式下存在
+   * @returns HTTP方法和端点
+   */
+  const getEndpointAndMethod = (id?: number) => {
+    let method = 'POST';
+    let endpoint = 'http://127.0.0.1:9000/admin/evaluation_points';
+  
+    // 如果是编辑模式，使用PATCH更新现有记录
+    if (id) {
+      method = 'PATCH';
+      endpoint = `http://127.0.0.1:9000/admin/evaluation_points?id=eq.${id}`;
+    }
+
+    return { method, endpoint };
+  };
+
+  /**
+   * 保存评查点
+   * 验证数据并提交到API
+   */
+  const handleSave = async () => {
+    try {
+      setIsLoading(true);
+      
+      // 记录当前评查规则状态
+      console.log("保存前评查规则状态:", formData.evaluation_config.rules);
+      
+      // 基本验证
+      if (!formData.name || !formData.code) {
+        alert("请填写评查点名称和编码，这些是必填项");
+        setIsLoading(false);
+        return;
+      }
+      
+      // 检查评查点类型
+      if (!formData.type) {
+        alert("请选择评查点类型");
+        setIsLoading(false);
+        return;
+      }
+      
+      // 检查所属规则组
+      if (!formData.evaluation_point_groups_id) {
+        alert("请选择所属规则组");
+        setIsLoading(false);
+        return;
+      }
+      
+      // 检查评查规则 - 只在新增模式下检查规则是否为空
+      if (!isEditMode && 
+          (!formData.evaluation_config.rules || 
+           formData.evaluation_config.rules.length === 0 ||
+           !formData.evaluation_config.rules.some(rule => rule.type && rule.type.trim() !== ''))) {
+        console.log("规则验证失败，当前规则:", formData.evaluation_config.rules);
+        console.log("规则数量:", formData.evaluation_config.rules?.length || 0);
+        console.log("规则有效性:", formData.evaluation_config.rules?.some(rule => rule.type && rule.type.trim() !== ''));
+        alert("请至少添加一条有效的评查规则");
+        setIsLoading(false);
+        return;
+      }
+      
+      // 编辑模式下，只有当规则数组不为空时才验证规则有效性
+      if (isEditMode && 
+          formData.evaluation_config.rules && 
+          formData.evaluation_config.rules.length > 0 &&
+          !formData.evaluation_config.rules.some(rule => rule.type && rule.type.trim() !== '')) {
+        console.log("编辑模式下规则无效，当前规则:", formData.evaluation_config.rules);
+        console.log("编辑模式-规则数量:", formData.evaluation_config.rules.length);
+        console.log("编辑模式-规则详情:", JSON.stringify(formData.evaluation_config.rules, null, 2));
+        console.log("编辑模式-规则有效性:", formData.evaluation_config.rules.some(rule => rule.type && rule.type.trim() !== ''));
+        alert("请至少添加一条有效的评查规则或清空规则列表");
+        setIsLoading(false);
+        return;
+      }
+      
+      const evaluationPointData = formatDataForApi(formData);
+      console.log("保存数据:", evaluationPointData);
+      
+      const { method, endpoint } = getEndpointAndMethod(formData.id);
+      console.log(`发送${method}请求到`, endpoint);
+      
+      // 发送数据到API
+      const response = await fetch(endpoint, {
+        method: method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json'
+        },
+        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(`保存失败: ${errorJson.msg || response.statusText}`);
+        } catch (parseError) {
+          // 如果无法解析为JSON，使用原始文本
+          throw new Error(`保存失败: ${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);
+        
+        // 处理响应
+        await handleApiResponse(responseData, isEditMode);
+      } 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);
+    }
+  };
+  
+  /**
+   * 保存为草稿
+   * 验证基本数据并提交到API，与保存正式版相比校验更宽松
+   */
+  const handleSaveDraft = async () => {
+    try {
+      setIsLoading(true);
+      
+      // 基本验证
+      if (!formData.name || !formData.code) {
+        alert("请填写评查点名称和编码，这些是必填项");
+        setIsLoading(false);
+        return;
+      }
+      
+      // 检查评查点类型
+      if (!formData.type) {
+        alert("请选择评查点类型");
+        setIsLoading(false);
+        return;
+      }
+      
+      // 检查所属规则组
+      if (!formData.evaluation_point_groups_id) {
+        alert("请选择所属规则组");
+        setIsLoading(false);
+        return;
+      }
+      
+      // 编辑模式下不检查评查规则是否为空
+      // 草稿模式下规则可以为空
+      
+      const draftData = formatDataForApi(formData);
+      console.log("保存草稿数据:", draftData);
+      
+      const { method, endpoint } = getEndpointAndMethod(formData.id);
+      console.log(`发送${method}请求到`, endpoint);
+      
+      // 发送数据到API
+      const response = await fetch(endpoint, {
+        method: method,
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json'
+        },
+        body: JSON.stringify(draftData)
+      });
+      
+      // 输出完整响应信息
+      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(`保存失败: ${errorJson.msg || response.statusText}`);
+        } catch (parseError) {
+          // 如果无法解析为JSON，使用原始文本
+          throw new Error(`保存失败: ${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);
+        
+        // 处理响应
+        await handleApiResponse(responseData, isEditMode, true);
+      } 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);
+    }
+  };
+
+  /**
+   * 处理API响应
+   * 根据API响应结果进行页面跳转等后续操作
+   * @param responseData API响应数据
+   * @param isEditMode 是否为编辑模式
+   * @param isDraft 是否为草稿模式
+   */
+  const handleApiResponse = async (
+    responseData: 
+      | ApiResponse
+      | Array<{ id: number; [key: string]: unknown }>,
+    isEditMode: boolean, 
+    isDraft: boolean = false
+  ) => {
+    // 适配新的API响应格式
+    if (responseData && typeof responseData === 'object') {
+      // 符合新的API规范
+      if ('code' in responseData && responseData.code === 0) {
+        console.log(`${isDraft ? '草稿' : ''}保存成功 (新API格式):`, responseData.data);
+        alert(`${isDraft ? '草稿' : ''}保存成功!`);
+        
+        // 根据操作类型重定向
+        if (isEditMode) {
+          // 编辑模式，保留在当前编辑页面
+          navigate(`/rules/new?id=${formData.id}`);
+        } else {
+          // 创建模式，跳转到新创建数据的编辑页面
+          let newId: number | undefined;
+          
+          if (responseData.data && Array.isArray(responseData.data) && responseData.data.length > 0) {
+            newId = responseData.data[0].id as number;
+          } else if (responseData.data && typeof responseData.data === 'object' && 'id' in responseData.data) {
+            newId = responseData.data.id as number;
+          }
+          
+          if (newId) {
+            navigate(`/rules/new?id=${newId}`);
+          } else {
+            // 无法获取ID，返回列表页
+            navigate('/rules');
+          }
+        }
+        return;
+      } else if ('code' in responseData && responseData.code !== 0) {
+        // API返回错误
+        console.warn("API返回错误:", responseData.msg);
+        throw new Error(responseData.msg as string || "操作失败");
+      }
+    }
+    
+    // 兼容处理旧的响应格式
+    if (Array.isArray(responseData)) {
+      if (responseData.length > 0) {
+        console.log(`${isDraft ? '草稿' : ''}保存成功 (数组响应):`, responseData[0]);
+        alert(`${isDraft ? '草稿' : ''}保存成功!`);
+        
+        // 如果是创建，跳转到编辑页面
+        if (!isEditMode && responseData[0].id) {
+          navigate(`/rules/new?id=${responseData[0].id}`);
+        } else {
+          navigate('/rules');
+        }
+      } else {
+        console.warn("响应数组为空");
+        alert("操作已完成，但服务器未返回数据");
+        navigate('/rules');
+      }
+    } else if (responseData && typeof responseData === 'object') {
+      if ('data' in responseData && responseData.data) {
+        console.log(`${isDraft ? '草稿' : ''}保存成功 (带data字段):`, responseData.data);
+        alert(`${isDraft ? '草稿' : ''}保存成功!`);
+        
+        let newId: number | undefined;
+        if (Array.isArray(responseData.data) && responseData.data.length > 0 && 'id' in responseData.data[0]) {
+          newId = responseData.data[0].id as number;
+        } else if (typeof responseData.data === 'object' && 'id' in responseData.data) {
+          newId = responseData.data.id as number;
+        }
+        
+        if (!isEditMode && newId) {
+          navigate(`/rules/new?id=${newId}`);
+        } else {
+          navigate('/rules');
+        }
+      } else if ('id' in responseData && responseData.id) {
+        console.log(`${isDraft ? '草稿' : ''}保存成功 (直接对象):`, responseData);
+        alert(`${isDraft ? '草稿' : ''}保存成功!`);
+        
+        if (!isEditMode) {
+          navigate(`/rules/new?id=${responseData.id as number}`);
+        } else {
+          navigate('/rules');
+        }
+      } else {
+        console.warn("响应对象格式不符合预期", responseData);
+        alert("操作已完成，但返回的数据格式不符合预期");
+        navigate('/rules');
+      }
+    } else {
+      console.warn("响应不是数组或对象", responseData);
+      alert("操作已完成，但返回的数据格式不符合预期");
+      navigate('/rules');
+    }
+  };
+
+  /**
+   * 当评查点组数据和表单数据都加载完成后，确保类型信息被正确设置
+   */
+  useEffect(() => {
+    // 仅在编辑模式下，且表单数据已加载，评查点组数据也已加载的情况下执行
+    if (
+      isEditMode && 
+      formData.id && 
+      evaluationPointGroups.length > 0 && 
+      (!formData.type || formData.type === '')
+    ) {
+      console.log("检测到编辑模式下类型未设置，尝试自动设置类型");
+      
+      // 首先尝试通过evaluation_point_groups_pid设置类型
+      if (formData.evaluation_point_groups_pid) {
+        const typeGroup = evaluationPointGroups.find(
+          group => group.id === formData.evaluation_point_groups_pid
+        );
+        
+        if (typeGroup) {
+          console.log("通过评查点类型ID找到类型组:", typeGroup);
+          setFormData(prevData => ({
+            ...prevData,
+            type: typeGroup.code
+          }));
+          console.log("自动设置类型为:", typeGroup.code);
+          return;
+        }
+      }
+      
+      // 如果无法通过evaluation_point_groups_pid设置，尝试通过evaluation_point_groups_id设置
+      if (formData.evaluation_point_groups_id) {
+        const ruleGroup = evaluationPointGroups.find(
+          group => group.id === formData.evaluation_point_groups_id
+        );
+        
+        if (ruleGroup && ruleGroup.pid && ruleGroup.pid !== 0) {
+          const parentGroup = evaluationPointGroups.find(
+            group => group.id === ruleGroup.pid
+          );
+          
+          if (parentGroup) {
+            console.log("通过规则组找到父级类型组:", parentGroup);
+            setFormData(prevData => ({
+              ...prevData,
+              type: parentGroup.code,
+              evaluation_point_groups_pid: parentGroup.id
+            }));
+            console.log("自动设置类型为:", parentGroup.code);
+          }
+        }
+      }
+    }
+  }, [isEditMode, formData.id, formData.type, formData.evaluation_point_groups_id, formData.evaluation_point_groups_pid, evaluationPointGroups]);
+
+  // 渲染页面内容
+  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} 
+              evaluationPointGroups={evaluationPointGroups}
+            />
+          </div>
+          
+          {/* 抽取设置 - 配置从文档中提取的字段 */}
+          <div className="mb-8">
+            <RuleContext.Provider value={{ extractionFields, updateFields: updateExtractionFields }}>
+              <ExtractionSettings 
+                onChange={handleExtractionSettingsChange} 
+                initialData={{
+                  llm: formData.extraction_config.llm,
+                  vlm: formData.extraction_config.vlm,
+                  regex: formData.extraction_config.regex
+                }} 
+              />
+            </RuleContext.Provider>
+          </div>
+          
+          {/* 评查设置 - 配置评查规则、消息等 */}
+          <div className="mb-8">
+            <RuleContext.Provider value={{ extractionFields, updateFields: updateExtractionFields }}>
+              <ReviewSettings 
+                key={`review-settings-${isEditMode ? formData.id : 'new'}`}
+                onChange={handleReviewSettingsChange} 
+                initialData={{
+                  rules: deepClone(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,
+                  score: formData.score,
+                  scoreDisplay: formData.scoreDisplay
+                }} 
+              />
+            </RuleContext.Provider>
+          </div>
+          
+          {/* 底部操作按钮区域 */}
+          <ActionButtons 
+            onSave={handleSave}
+            onSaveDraft={handleSaveDraft}
+            isEditMode={isEditMode}
+          />
+        </>
+      )}
+    </div>
+  );
+}
diff --git a/html/评查点-新增.html b/html/评查点-新增.html
index 3287b16..51a78b7 100644
--- a/html/评查点-新增.html
+++ b/html/评查点-新增.html
@@ -1771,7 +1771,7 @@
                                                     <label class="form-label text-sm">运算符</label>
                                                     <select class="form-select">
                                                         <option value="eq">等于 (=)</option>
-                                                        <option value="neq">不等于 (≠)</option>
+                                                        <option value="neq"> (≠)</option>
                                                         <option value="gt">大于 (>)</option>
                                                         <option value="gte">大于等于 (≥)</option>
                                                         <option value="lt">小于 (<)</option>
diff --git a/test-api.js b/test-api.js
new file mode 100644
index 0000000..19a8efc
--- /dev/null
+++ b/test-api.js
@@ -0,0 +1,158 @@
+// 使用原生Node.js http模块发送请求
+import http from 'http';
+import { Buffer } from 'buffer';
+
+// 测试GET请求 - 检查API服务器是否正常运行
+function testApiConnection() {
+  console.log('测试API连接...');
+  
+  // 设置请求选项
+  const options = {
+    hostname: '127.0.0.1',
+    port: 9000,
+    path: '/admin/evaluation_points',
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'Authorization': '1234567890'
+    }
+  };
+  
+  // 创建请求
+  const req = http.request(options, (res) => {
+    console.log(`状态码: ${res.statusCode}`);
+    console.log('响应头:', res.headers);
+    
+    let data = '';
+    
+    res.on('data', (chunk) => {
+      data += chunk;
+    });
+    
+    res.on('end', () => {
+      console.log('响应数据:');
+      try {
+        const parsedData = JSON.parse(data);
+        console.log(JSON.stringify(parsedData, null, 2));
+      } catch (e) {
+        console.log('无法解析响应为JSON:', data);
+      }
+    });
+  });
+  
+  req.on('error', (error) => {
+    console.error('请求错误:', error.message);
+    if (error.code === 'ECONNREFUSED') {
+      console.error('无法连接到API服务器 - 请确保服务器已启动并监听端口9000');
+    }
+  });
+  
+  // 完成请求
+  req.end();
+}
+
+// 测试POST请求 - 尝试创建一个测试评查点
+function testPostRequest() {
+  console.log('\n测试POST请求...');
+  
+  // 创建测试数据
+  const testData = {
+    code: 'TEST_CODE',
+    name: '测试评查点',
+    risk: 'low',
+    is_enabled: false,
+    is_draft: true,
+    description: '这是一个测试评查点',
+    references_laws: {
+      name: '测试法规',
+      articles: ['第一条'],
+      content: '测试内容'
+    },
+    extraction_config: {
+      llm: {
+        fields: ['测试字段1', '测试字段2'],
+        prompt_setting: {
+          type: 'system',
+          template: '测试提示词'
+        }
+      },
+      vlm: {
+        fields: [
+          { name: '图片字段1', type: 'default' }
+        ],
+        prompt_setting: {
+          type: 'system',
+          template: '测试图片提示词'
+        }
+      },
+      regex: {
+        fields: [
+          { field: '正则字段1', pattern: '\\d+' }
+        ]
+      }
+    },
+    evaluation_config: {
+      logicType: 'and',
+      customLogic: '',
+      rules: []
+    }
+  };
+  
+  // 将数据转换为JSON字符串
+  const postData = JSON.stringify(testData);
+  
+  // 设置请求选项
+  const options = {
+    hostname: '127.0.0.1',
+    port: 9000,
+    path: '/admin/evaluation_points',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'Authorization': '1234567890',
+      'Content-Length': Buffer.byteLength(postData)
+    }
+  };
+  
+  // 创建请求
+  const req = http.request(options, (res) => {
+    console.log(`状态码: ${res.statusCode}`);
+    console.log('响应头:', res.headers);
+    
+    let data = '';
+    
+    res.on('data', (chunk) => {
+      data += chunk;
+    });
+    
+    res.on('end', () => {
+      console.log('响应数据:');
+      try {
+        const parsedData = JSON.parse(data);
+        console.log(JSON.stringify(parsedData, null, 2));
+      } catch (e) {
+        console.log('无法解析响应为JSON:', data);
+      }
+    });
+  });
+  
+  req.on('error', (error) => {
+    console.error('请求错误:', error.message);
+  });
+  
+  // 发送数据
+  req.write(postData);
+  
+  // 完成请求
+  req.end();
+}
+
+// 执行测试
+testApiConnection();
+
+// 等待3秒后执行POST测试
+setTimeout(() => {
+  testPostRequest();
+}, 3000); 
\ No newline at end of file
diff --git a/test-api2.js b/test-api2.js
new file mode 100644
index 0000000..86d406f
--- /dev/null
+++ b/test-api2.js
@@ -0,0 +1,108 @@
+// 使用原生Node.js http模块发送请求
+import http from 'http';
+import { Buffer } from 'buffer';
+
+// 测试POST请求 - 尝试创建一个测试评查点
+function testPostRequest() {
+  console.log('测试POST请求...');
+  
+  // 创建测试数据
+  const testData = {
+    code: 'TEST_CODE_' + Date.now(),
+    name: '测试评查点',
+    risk: 'low',
+    is_enabled: false,
+    description: '这是一个测试评查点',
+    references_laws: {
+      name: '测试法规',
+      articles: ['第一条'],
+      content: '测试内容'
+    },
+    extraction_config: {
+      llm: {
+        fields: ['测试字段1', '测试字段2'],
+        prompt_setting: {
+          type: 'system',
+          template: '测试提示词'
+        }
+      },
+      vlm: {
+        fields: [
+          { name: '图片字段1', type: 'default' }
+        ],
+        prompt_setting: {
+          type: 'system',
+          template: '测试图片提示词'
+        }
+      },
+      regex: {
+        fields: [
+          { field: '正则字段1', pattern: '\\d+' }
+        ]
+      }
+    },
+    evaluation_config: {
+      logicType: 'and',
+      customLogic: '',
+      rules: []
+    },
+    pass_message: '通过消息',
+    fail_message: '失败消息',
+    suggestion_message: '建议消息',
+    suggestion_message_type: 'warning',
+    post_action: 'none',
+    action_config: ''
+  };
+  
+  // 将数据转换为JSON字符串
+  const postData = JSON.stringify(testData);
+  
+  // 设置请求选项
+  const options = {
+    hostname: '127.0.0.1',
+    port: 9000,
+    path: '/admin/evaluation_points',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+      'Authorization': '1234567890',
+      'Content-Length': Buffer.byteLength(postData)
+    }
+  };
+  
+  // 创建请求
+  const req = http.request(options, (res) => {
+    console.log(`状态码: ${res.statusCode}`);
+    console.log('响应头:', res.headers);
+    
+    let data = '';
+    
+    res.on('data', (chunk) => {
+      data += chunk;
+    });
+    
+    res.on('end', () => {
+      console.log('响应数据:');
+      try {
+        const parsedData = JSON.parse(data);
+        console.log(JSON.stringify(parsedData, null, 2));
+      } catch (e) {
+        console.log('无法解析响应为JSON:', data);
+      }
+    });
+  });
+  
+  req.on('error', (error) => {
+    console.error('请求错误:', error.message);
+  });
+  
+  // 发送数据
+  req.write(postData);
+  
+  // 完成请求
+  req.end();
+}
+
+// 执行测试
+testPostRequest(); 
\ No newline at end of file
diff --git a/test-rules-api.js b/test-rules-api.js
new file mode 100644
index 0000000..e194512
--- /dev/null
+++ b/test-rules-api.js
@@ -0,0 +1,162 @@
+import http from 'http';
+import { Buffer } from 'buffer';
+
+// 测试评查点列表接口
+function testGetEvaluationPoints() {
+  const options = {
+    hostname: '127.0.0.1',
+    port: 9000,
+    path: '/admin/evaluation_points',
+    method: 'GET',
+    headers: {
+      'Accept': 'application/json'
+    }
+  };
+
+  const req = http.request(options, (res) => {
+    console.log(`状态码: ${res.statusCode}`);
+    console.log(`响应头: ${JSON.stringify(res.headers)}`);
+    
+    let data = '';
+    
+    res.on('data', (chunk) => {
+      data += chunk;
+    });
+    
+    res.on('end', () => {
+      console.log('获取评查点列表成功!');
+      try {
+        const jsonData = JSON.parse(data);
+        console.log(`共获取 ${jsonData.length} 条评查点数据`);
+        console.log('第一条数据:', JSON.stringify(jsonData[0], null, 2).substring(0, 200) + '...');
+      } catch (e) {
+        console.error('解析JSON数据失败:', e.message);
+        console.log('原始数据:', data);
+      }
+    });
+  });
+  
+  req.on('error', (e) => {
+    console.error(`获取评查点列表请求失败: ${e.message}`);
+  });
+  
+  req.end();
+}
+
+// 测试创建评查点接口
+function testCreateEvaluationPoint() {
+  const testData = {
+    name: '测试评查点',
+    code: 'TEST_RULE_001',
+    risk: 'medium',
+    is_enabled: true,
+    description: '这是一个用于测试接口的评查点',
+    type: 'content',
+    references_laws: {
+      name: '《中华人民共和国民法典》',
+      articles: ['第五百八十五条', '第五百八十六条'],
+      content: '当事人应当按照约定全面履行自己的义务。'
+    },
+    evaluation_point_groups_id: 1,
+    extraction_config: {
+      llm: {
+        fields: ['合同名称', '合同编号', '签订日期'],
+        prompt_setting: {
+          type: 'system',
+          template: '请从文档中提取以下字段信息：合同名称、合同编号、签订日期'
+        }
+      },
+      vlm: {
+        fields: [
+          { name: '公章', type: 'seal' },
+          { name: '签名', type: 'handwriting' }
+        ],
+        prompt_setting: {
+          type: 'system',
+          template: '请识别文档中的公章和签名'
+        }
+      },
+      regex: {
+        fields: [
+          { field: '合同编号', pattern: 'HT-\\d{4}-\\d{6}' }
+        ]
+      }
+    },
+    evaluation_config: {
+      logicType: 'and',
+      customLogic: '',
+      rules: [
+        {
+          id: '1',
+          type: 'exists',
+          config: {
+            fields: ['合同名称', '合同编号', '签订日期'],
+            logic: 'and'
+          }
+        }
+      ]
+    },
+    pass_message: '文档检查通过，符合规范要求。',
+    fail_message: '文档存在以下问题，请修改后重新提交。',
+    suggestion_message: '',
+    suggestion_message_type: 'warning',
+    post_action: 'none',
+    action_config: ''
+  };
+
+  const postData = JSON.stringify(testData);
+  
+  const options = {
+    hostname: '127.0.0.1',
+    port: 9000,
+    path: '/admin/evaluation_points',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(postData),
+      'Accept': 'application/json',
+      'Prefer': 'return=representation'
+    }
+  };
+
+  const req = http.request(options, (res) => {
+    console.log(`状态码: ${res.statusCode}`);
+    console.log(`响应头: ${JSON.stringify(res.headers)}`);
+    
+    let data = '';
+    
+    res.on('data', (chunk) => {
+      data += chunk;
+    });
+    
+    res.on('end', () => {
+      console.log('创建评查点成功!');
+      try {
+        const jsonData = JSON.parse(data);
+        console.log('创建的评查点ID:', jsonData.id);
+        console.log('创建的评查点数据:', JSON.stringify(jsonData, null, 2).substring(0, 200) + '...');
+      } catch (e) {
+        console.error('解析JSON数据失败:', e.message);
+        console.log('原始数据:', data);
+      }
+    });
+  });
+  
+  req.on('error', (e) => {
+    console.error(`创建评查点请求失败: ${e.message}`);
+  });
+  
+  req.write(postData);
+  req.end();
+}
+
+// 运行测试
+console.log('开始测试评查点API...');
+console.log('1. 测试获取评查点列表...');
+testGetEvaluationPoints();
+
+// 等待3秒后测试创建评查点
+setTimeout(() => {
+  console.log('\n2. 测试创建评查点...');
+  testCreateEvaluationPoint();
+}, 3000); 
\ No newline at end of file