From c344954779b33c0a6e2a6258af5c8812c736adf3 Mon Sep 17 00:00:00 2001
From: LHD_HY <2872546851@qq.com>
Date: Wed, 26 Nov 2025 18:25:40 +0800
Subject: [PATCH] =?UTF-8?q?bug=E4=BF=AE=E5=A4=8D?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../analysisRuleSet/analysisRuleSet.js        |   59 +
 .../templateInfo/components/AnalysisRule.vue  | 1149 +++++++++++++++++
 .../templateInfo/components/TemplateForm.vue  |    4 +-
 .../components/child/SectionFile.vue          |    7 +-
 src/views/template/templateInfo/index.vue     |   21 +-
 5 files changed, 1225 insertions(+), 15 deletions(-)
 create mode 100644 src/api/template/analysisRuleSet/analysisRuleSet.js
 create mode 100644 src/views/template/templateInfo/components/AnalysisRule.vue

diff --git a/src/api/template/analysisRuleSet/analysisRuleSet.js b/src/api/template/analysisRuleSet/analysisRuleSet.js
new file mode 100644
index 0000000..4db2df3
--- /dev/null
+++ b/src/api/template/analysisRuleSet/analysisRuleSet.js
@@ -0,0 +1,59 @@
+import request from '@/utils/request'
+
+/**
+ * 解析规则配置接口（统一处理解析规则相关数据交互）
+ */
+
+// 1. 查询解析规则配置列表（支持按模板ID、规则类型等筛选）
+export function listAnalysisRuleSet(query) {
+  return request({
+    url: '/smartBid/analysisRuleSet/list',
+    method: 'get',
+    params: query
+  })
+}
+
+// 2. 查询解析规则配置详情（携带解析规则ID，包含关联定位查询规则信息）
+export function getAnalysisRuleSetDetail(params) {
+  return request({
+    url: '/smartBid/analysisRuleSet/detail',
+    method: 'get',
+    params: params
+  })
+}
+
+// 3. 新增解析规则配置（携带解析名称、模板ID等基础信息）
+export function addAnalysisRuleSet(data) {
+  return request({
+    url: '/smartBid/analysisRuleSet/add',
+    method: 'post',
+    data: data
+  })
+}
+
+// 4. 修改解析规则配置（携带解析规则ID，更新配置信息）
+export function updateAnalysisRuleSet(data) {
+  return request({
+    url: '/smartBid/analysisRuleSet/edit',
+    method: 'post',
+    data: data
+  })
+}
+
+// 5. 删除解析规则配置（携带解析规则ID，级联删除关联的定位查询规则）
+export function delAnalysisRuleSet(params) {
+  return request({
+    url: '/smartBid/analysisRuleSet/delete',
+    method: 'post',
+    data: params
+  })
+}
+
+// 6. 校验解析规则名称唯一性（新增/编辑时使用，避免重复）
+export function checkAnalysisNameUnique(params) {
+  return request({
+    url: '/smartBid/analysisRuleSet/checkNameUnique',
+    method: 'get',
+    params: params
+  })
+}
diff --git a/src/views/template/templateInfo/components/AnalysisRule.vue b/src/views/template/templateInfo/components/AnalysisRule.vue
new file mode 100644
index 0000000..8d9281d
--- /dev/null
+++ b/src/views/template/templateInfo/components/AnalysisRule.vue
@@ -0,0 +1,1149 @@
+<template>
+  <el-card class="analysis-rule-container">
+    <!-- 返回按钮 -->
+    <!-- 保存按钮 -->
+    <div class="back-container">
+      <el-button
+        type="primary"
+        @click="handleSaveRules"
+        :disabled="!selectedLabelItemId || ruleSets.length === 0 || contentSources.length === 0"
+        class="save-btn"
+      >
+        保存
+      </el-button>
+      <el-button
+        type="default"
+        size="small"
+        @click="handleBack"
+        class="back-btn">
+        返回
+      </el-button>
+    </div>
+
+    <el-row :gutter="20">
+      <!-- 左侧树状图区域 -->
+      <el-col :span="4">
+        <div class="tree-container" style="height: calc(100vh - 205px)">
+          <el-input
+            placeholder="搜索标签项"
+            v-model="treeSearchKey"
+            class="tree-search"
+            clearable
+            size="small"
+          />
+
+          <el-tree
+            ref="labelItemTree"
+            :data="treeData"
+            :props="treeProps"
+            node-key="analysisLabelItemId"
+            :filter-node-method="filterTreeNode"
+            :highlight-current="true"
+            default-expand-all
+            @node-click="handleTreeNodeClick"
+            @current-change="handleTreeNodeChange"
+          >
+            <template #default="{ node, data }">
+              <span class="tree-node-content">
+                <span
+                  :style="{
+                    color: data.analysisLevel === 3 ? '#1F72EA' : '#333',
+                    fontWeight: data.analysisLevel === 3 ? '500' : 'normal'
+                  }"
+                >
+                  {{ node.label }}
+                </span>
+              </span>
+            </template>
+          </el-tree>
+        </div>
+      </el-col>
+
+      <!-- 右侧解析规则配置区域 -->
+      <el-col :span="19">
+        <div class="rule-config-container">
+          <!-- 显示模板名称 -->
+          <div class="template-info">
+            <h3>模板名称: {{ templateName }}</h3>
+          </div>
+
+          <!-- 规则配置区域 - 添加 ElForm 包裹 -->
+          <el-form ref="ruleForm" :model="ruleForm" label-width="100px" class="rule-sets">
+            <!-- 添加规则按钮 -->
+            <div class="add-rule-container">
+              <el-button
+                type="primary"
+                icon="el-icon-plus"
+                @click="handleAddRuleSet"
+              >
+                添加规则
+              </el-button>
+            </div>
+
+            <!-- 规则集列表 -->
+            <div v-for="(ruleSet, index) in ruleSets" :key="index" class="rule-set-item">
+              <div class="rule-set-header">
+                <span class="rule-set-index">规则 {{ index + 1 }}</span>
+                <div class="rule-set-actions">
+                  <el-button
+                    icon="el-icon-copy"
+                    type="primary"
+                    size="mini"
+                    @click="handleCopyRuleSet(index)"
+                  >复制</el-button>
+                  <el-button
+                    size="mini"
+                    type="danger"
+                    @click="handleDeleteRuleSet(index)"
+                  >删除</el-button>
+                </div>
+              </div>
+
+              <div class="rule-set-content">
+                <!-- 内容来源单选 - 动态生成选项 -->
+                <el-form-item label="内容来源">
+                  <el-radio-group
+                    v-model="ruleSet.contentSource.compositionName"
+                    class="content-source-radios"
+                  >
+                    <el-radio
+                      v-for="source in contentSources"
+                      :key="source.compositionId"
+                      :label="source.compositionName"
+                    >
+                      {{ source.compositionName }}
+                    </el-radio>
+                  </el-radio-group>
+                </el-form-item>
+
+                <!-- 定位查询规则 -->
+                <div class="position-rules">
+                  <el-form-item label="定位规则查询" class="position-rule-label">
+                  </el-form-item>
+                  <div v-for="(positionRule, posIndex) in ruleSet.positionRules" :key="posIndex" class="position-rule-item">
+                    <el-form-item>
+                      <!-- 规则类型选择下拉框 - 绑定字典表数据 -->
+                      <el-select
+                        v-model="positionRule.ruleSetType"
+                        @change="handleRuleTypeChange(positionRule, posIndex, index)"
+                        placeholder="请选择规则类型"
+                        style="width: 280px;"
+                      >
+                        <el-option
+                          v-for="option in ruleSetTypeOptions"
+                          :key="option.value"
+                          :label="option.label"
+                          :value="option.value"
+                        ></el-option>
+                      </el-select>
+
+                      <!-- 1. 头部开始，指定字数 (headSpecifyLength) -->
+                      <div class="rule-fields" v-if="positionRule.ruleSetType === 'headSpecifyLength'">
+                        <el-input
+                          v-model="positionRule.specifiedWordCount"
+                          placeholder="指定字数"
+                          type="number"
+                          style="width: 150px; margin-left: 10px;"
+                        ></el-input>
+                      </div>
+
+                      <!-- 2. 文档开始，到指定文字结尾 (docToSpecifyText) -->
+                      <div class="rule-fields" v-if="positionRule.ruleSetType === 'docToSpecifyText'">
+                        <el-input
+                          v-model="positionRule.specifiedText"
+                          placeholder="指定文字"
+                          style="width: 200px; margin-left: 10px;"
+                        ></el-input>
+                      </div>
+
+                      <!-- 3. 尾部开始，往前指定字数 (tailSpecifyLength) -->
+                      <div class="rule-fields" v-if="positionRule.ruleSetType === 'tailSpecifyLength'">
+                        <el-input
+                          v-model="positionRule.specifiedWordCount"
+                          placeholder="指定字数"
+                          type="number"
+                          style="width: 150px; margin-left: 10px;"
+                        ></el-input>
+                      </div>
+
+                      <!-- 4. 指定文字开始，到结尾 (specifyTextToEnd) -->
+                      <div class="rule-fields" v-if="positionRule.ruleSetType === 'specifyTextToEnd'">
+                        <el-input
+                          v-model="positionRule.specifiedText"
+                          placeholder="指定文字"
+                          style="width: 200px; margin-left: 10px;"
+                        ></el-input>
+                      </div>
+
+                      <!-- 5. 指定关键词，前后多少字 (keywordAround) -->
+                      <div class="rule-fields" v-if="positionRule.ruleSetType === 'keywordAround'">
+                        <el-input
+                          v-model="positionRule.beforeCharactersNum"
+                          placeholder="前面字数"
+                          type="number"
+                          style="width: 120px; margin-left: 10px;"
+                        ></el-input>
+                        <el-input
+                          v-model="positionRule.specifiedKeywords"
+                          placeholder="指定关键词"
+                          style="width: 180px; margin-left: 10px;"
+                        ></el-input>
+                        <el-input
+                          v-model="positionRule.afterCharactersNum"
+                          placeholder="后面字数"
+                          type="number"
+                          style="width: 120px; margin-left: 10px;"
+                        ></el-input>
+                      </div>
+
+                      <!-- 6. 指定文字开始，指定字数长度结束 (specifyTextToLength) -->
+                      <div class="rule-fields" v-if="positionRule.ruleSetType === 'specifyTextToLength'">
+                        <el-input
+                          v-model="positionRule.specifiedText"
+                          placeholder="指定文字"
+                          style="width: 200px; margin-left: 10px;"
+                        ></el-input>
+                        <el-input
+                          v-model="positionRule.specifiedWordCountLength"
+                          placeholder="指定字数长度"
+                          type="number"
+                          style="width: 150px; margin-left: 10px;"
+                        ></el-input>
+                      </div>
+
+                      <!-- 7. 指定文字结尾，指定前方字数结束 (specifyTextEndToLength) -->
+                      <div class="rule-fields" v-if="positionRule.ruleSetType === 'specifyTextEndToLength'">
+                        <el-input
+                          v-model="positionRule.beforeSpecifiedCharactersNum"
+                          placeholder="指定文字前方字数"
+                          type="number"
+                          style="width: 180px; margin-left: 10px;"
+                        ></el-input>
+                        <el-input
+                          v-model="positionRule.specifiedText"
+                          placeholder="指定文字"
+                          style="width: 200px; margin-left: 10px;"
+                        ></el-input>
+                      </div>
+
+                      <!-- 8. 首尾文字范围提取内容 (headTailRange) -->
+                      <div class="rule-fields" v-if="positionRule.ruleSetType === 'headTailRange'">
+                        <el-input
+                          v-model="positionRule.firstText"
+                          placeholder="首部文字"
+                          style="width: 150px; margin-left: 10px;"
+                        ></el-input>
+                        <el-input
+                          v-model="positionRule.shouldIncludeCharactersNum"
+                          placeholder="需要包含的字数"
+                          type="number"
+                          style="width: 150px; margin-left: 10px;"
+                        ></el-input>
+                        <el-input
+                          v-model="positionRule.endText"
+                          placeholder="尾部文字"
+                          style="width: 150px; margin-left: 10px;"
+                        ></el-input>
+                      </div>
+
+                      <el-button
+                        icon="el-icon-minus"
+                        size="mini"
+                        type="danger"
+                        @click="handleRemovePositionRule(index, posIndex)"
+                        style="margin-left: 10px;"
+                      ></el-button>
+                      <el-button
+                        icon="el-icon-plus"
+                        size="mini"
+                        type="primary"
+                        @click="handleAddPositionRule(index)"
+                      ></el-button>
+                    </el-form-item>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </el-form>
+        </div>
+      </el-col>
+    </el-row>
+  </el-card>
+</template>
+
+<script>
+import { columnsRuleList } from '../config'
+import {
+  listAnalysisLabelItem,
+} from '@/api/template/analysisLabelItem/analysisLabelItem'
+import {
+  listAnalysisRuleSet,
+  delAnalysisRuleSet,
+  addAnalysisRuleSet
+} from '@/api/template/analysisRuleSet/analysisRuleSet'
+import { getTemplateInfoDetail } from '@/api/template/templateInfo/templateInfo'
+import { encryptWithSM4, decryptWithSM4 } from '@/utils/sm'
+
+export default {
+  name: 'AnalysisRuleSet',
+  components: {
+
+  },
+  data() {
+    return {
+      ruleForm: {},
+      // 表格列配置
+      columnsRuleList,
+
+      // 树状图配置
+      treeData: [],
+      treeProps: {
+        label: 'analysisName',
+        children: 'children'
+      },
+      treeSearchKey: '',
+      labelItemMap: new Map(), // 存储所有标签项的ID与名称映射
+
+      // 表格传递参数
+      tableSendParams: {
+        templateId: '',       // 模板ID
+        analysisLabelItemId: '' // 标签项ID（三级）
+      },
+
+      // 路由参数
+      templateId: '',
+      analysisLabelId: '',
+      templateName: '', // 模板名称
+      contentSources: [], // 动态获取的内容来源列表
+
+      // 选中的标签项信息
+      selectedLabelItemId: '',
+      selectedLabelLevel: 0,
+      analysisCode: '',
+      analysisLevel: '',
+      analysisName: '',
+      analysisSort: '',
+      parentId: '',
+
+      // 规则集数据
+      ruleSets: [],
+      ruleSetTypeOptions: [] // 规则类型下拉选项（从字典表加载）
+    }
+  },
+
+  created() {
+    this.loadRuleSetTypeDict()
+    // 解密路由参数
+    this.templateId = decryptWithSM4(this.$route.query.templateId) || ''
+    this.analysisLabelId = decryptWithSM4(this.$route.query.analysisLabelId) || ''
+
+    // 初始化表格参数
+    this.tableSendParams.templateId = this.templateId
+
+    // 加载模板信息获取templateName和contentSources
+    this.loadTemplateInfo()
+
+    // 加载树形数据
+    this.loadTreeData()
+  },
+
+  methods: {
+    /**
+     * 加载规则类型字典表数据
+     */
+    loadRuleSetTypeDict() {
+      this.getDicts('rule_set_type').then(response => {
+        this.ruleSetTypeOptions = response.data.map(item => ({
+          label: item.dictLabel,
+          value: item.dictValue
+        }))
+      }).catch(error => {
+        console.error('加载查询规则类型字典失败：', error)
+      })
+    },
+
+    /**
+     * 返回上一页
+     */
+    handleBack() {
+      const obj = { path: "/templateInfo/index" };
+      this.$tab.closeOpenPage(obj);
+    },
+
+    /**
+     * 加载模板信息获取templateName和contentSources
+     */
+    loadTemplateInfo() {
+      if (this.templateId) {
+        getTemplateInfoDetail({templateId: this.templateId})
+          .then(res => {
+            if (res.code === 200) {
+              this.templateName = res.data.templateName || '';
+
+              // 从接口响应中提取contentSources
+              const compositionList = res.data.compositionList || [];
+
+              // 去重处理
+              const uniqueSources = [];
+              const seenIds = new Set();
+
+              compositionList.forEach(source => {
+                if (source.compositionId && !seenIds.has(source.compositionId)) {
+                  seenIds.add(source.compositionId);
+                  uniqueSources.push({
+                    compositionId: source.compositionId,
+                    compositionName: source.fileName
+                  });
+                }
+              });
+
+              this.contentSources = uniqueSources;
+
+              // 如果已经有选中的标签项，重新加载规则集以应用新的内容来源
+              if (this.selectedLabelItemId) {
+                this.loadRuleSets();
+              }
+            }
+          })
+          .catch(err => {
+            console.error('加载模板信息失败:', err);
+          });
+      }
+    },
+
+    /**
+     * 加载树形结构数据
+     */
+    loadTreeData() {
+      listAnalysisLabelItem({
+        analysisId: this.analysisLabelId
+      }).then(res => {
+        if (res.code === 200) {
+          // 构建树形结构并过滤出三级及以上节点
+          this.treeData = this.buildTree(res.rows)
+          this.buildLabelItemMap(res.rows)
+        }
+      })
+    },
+
+    /**
+     * 构建树形结构
+     */
+    buildTree(list) {
+      const tree = []
+      const map = {}
+
+      // 先将所有节点存入map
+      list.forEach(item => {
+        map[item.analysisLabelItemId] = { ...item, children: [] }
+      })
+
+      // 构建树形关系
+      list.forEach(item => {
+        if (item.parentId && map[item.parentId]) {
+          map[item.parentId].children.push(map[item.analysisLabelItemId])
+        } else {
+          tree.push(map[item.analysisLabelItemId])
+        }
+      })
+
+      return tree
+    },
+
+    /**
+     * 构建标签项ID与名称映射表
+     */
+    buildLabelItemMap(list) {
+      this.labelItemMap.clear()
+      list.forEach(item => {
+        this.labelItemMap.set(String(item.analysisLabelItemId), {
+          name: item.analysisName,
+          level: item.analysisLevel
+        })
+      })
+    },
+
+    /**
+     * 树形节点过滤
+     */
+    filterTreeNode(value, data) {
+      if (!value) return true
+      return data.analysisName.includes(value) ||
+        (data.analysisCode && data.analysisCode.includes(value))
+    },
+
+    /**
+     * 树形节点点击事件
+     */
+    handleTreeNodeClick(data) {
+      // 只处理三级节点
+      if (data.analysisLevel === 3) {
+        this.analysisLevel = data.analysisLevel
+        this.analysisName = data.analysisName
+        this.analysisCode = data.analysisCode
+        this.analysisSort = data.analysisSort
+        this.parentId = data.parentId
+        this.selectedLabelItemId = data.analysisLabelItemId
+        this.selectedLabelLevel = data.analysisLevel
+        this.tableSendParams.analysisLabelItemId = data.analysisLabelItemId
+        this.loadRuleSets() // 加载该标签项的规则集
+      } else {
+        this.$modal.msgInfo('请选择三级标签项进行操作')
+      }
+    },
+
+    /**
+     * 树形节点切换事件
+     */
+    handleTreeNodeChange(currentNode) {
+      if (currentNode && currentNode.analysisLevel === 3) {
+        this.selectedLabelItemId = currentNode.analysisLabelItemId
+        this.selectedLabelLevel = currentNode.analysisLevel
+        this.tableSendParams.analysisLabelItemId = currentNode.analysisLabelItemId
+        this.loadRuleSets() // 加载该标签项的规则集
+      } else if (currentNode) {
+        this.$modal.msgInfo('请选择三级标签项进行操作')
+        // 取消选中状态
+        this.$refs.labelItemTree.setCurrentKey(null)
+        this.selectedLabelItemId = ''
+        this.selectedLabelLevel = 0
+        this.tableSendParams.analysisLabelItemId = ''
+        this.ruleSets = [] // 清空规则集
+      } else {
+        this.selectedLabelItemId = ''
+        this.selectedLabelLevel = 0
+        this.tableSendParams.analysisLabelItemId = ''
+        this.ruleSets = [] // 清空规则集
+      }
+    },
+
+    /**
+     * 加载规则集
+     */
+    loadRuleSets() {
+      if (this.selectedLabelItemId && this.templateId) {
+        listAnalysisRuleSet({
+          templateId: this.templateId,
+          analysisLabelItemId: this.selectedLabelItemId
+        }).then(res => {
+          console.log('res',res)
+          if (res.code === 200) {
+            // 清空现有规则集
+            this.ruleSets = [];
+
+            // 遍历所有返回的规则集（可能有多个）
+            res.rows.forEach(ruleSet => {
+              // 按subRuleId对定位规则进行分组
+              const positionGroups = {};
+
+              // 处理定位规则，按subRuleId分组
+              (ruleSet.positions || []).forEach(pos => {
+                const subRuleId = pos.subRuleId || 1; // 默认为1组
+                if (!positionGroups[subRuleId]) {
+                  positionGroups[subRuleId] = [];
+                }
+                positionGroups[subRuleId].push(pos);
+              });
+
+              // 将分组后的定位规则转换为前端需要的ruleSets结构
+              Object.values(positionGroups).forEach((positions, index) => {
+                // 查找对应的contentSource对象
+                let sourceObj = { compositionId: '', compositionName: '' };
+                // 从规则集或定位规则中获取内容来源信息
+                const compositionName = ruleSet.compositionName ||
+                  positions[0]?.compositionName || '';
+
+                if (compositionName) {
+                  const foundSource = this.contentSources.find(
+                    s => s.compositionName === compositionName
+                  );
+                  sourceObj = foundSource ? foundSource : { compositionName };
+                } else if (this.contentSources.length > 0) {
+                  sourceObj = this.contentSources[0];
+                }
+
+                this.ruleSets.push({
+                  ruleSetId: ruleSet.ruleSetId, // 保留主规则ID
+                  contentSource: sourceObj,
+                  positionRules: positions.length > 0
+                    ? positions.map(pos => ({...pos}))
+                    : [this.createEmptyPositionRule()]
+                });
+              });
+            });
+
+            // 如果没有规则集，添加一个默认的
+            if (this.ruleSets.length === 0 && this.contentSources.length > 0) {
+              this.handleAddRuleSet();
+            }
+          }
+        });
+      }
+    },
+
+    /**
+     * 添加规则集
+     */
+    handleAddRuleSet() {
+      // 初始化 contentSource 为一个对象
+      const defaultSource = this.contentSources.length > 0
+        ? {
+          compositionId: this.contentSources[0].compositionId,
+          compositionName: this.contentSources[0].compositionName
+        }
+        : { compositionId: '', compositionName: '' };
+
+      this.ruleSets.push({
+        contentSource: defaultSource,
+        positionRules: [this.createEmptyPositionRule()]
+      });
+    },
+
+    /**
+     * 复制规则集
+     */
+    handleCopyRuleSet(index) {
+      const copiedRuleSet = JSON.parse(JSON.stringify(this.ruleSets[index]));
+      // 清除可能存在的ID
+      delete copiedRuleSet.ruleSetId;
+      this.ruleSets.splice(index + 1, 0, copiedRuleSet);
+    },
+
+    /**
+     * 删除规则集
+     */
+    handleDeleteRuleSet(index) {
+      this.ruleSets.splice(index, 1);
+    },
+
+    /**
+     * 添加定位规则
+     */
+    handleAddPositionRule(ruleSetIndex) {
+      this.ruleSets[ruleSetIndex].positionRules.push(this.createEmptyPositionRule());
+    },
+
+    /**
+     * 移除定位规则
+     */
+    handleRemovePositionRule(ruleSetIndex, posIndex) {
+      // 确保至少保留一个定位规则
+      if (this.ruleSets[ruleSetIndex].positionRules.length > 1) {
+        this.ruleSets[ruleSetIndex].positionRules.splice(posIndex, 1);
+      } else {
+        this.$message.warning('至少保留一个定位规则');
+      }
+    },
+
+    /**
+     * 规则类型改变事件
+     */
+    handleRuleTypeChange(positionRule, posIndex, ruleSetIndex) {
+      // 定义所有可能的字段
+      const allFields = [
+        'specifiedWordCount', 'specifiedText', 'specifiedKeywords',
+        'beforeCharactersNum', 'afterCharactersNum', 'specifiedWordCountLength',
+        'beforeSpecifiedCharactersNum', 'firstText', 'shouldIncludeCharactersNum', 'endText'
+      ];
+
+      // 清空所有字段，确保旧数据不残留
+      allFields.forEach(field => {
+        if (positionRule.hasOwnProperty(field)) {
+          this.$set(positionRule, field, '');
+        }
+      });
+
+      const ruleType = positionRule.ruleSetType;
+
+      // 根据新选择的规则类型，初始化所需字段
+      switch (ruleType) {
+        case 'headSpecifyLength':
+        case 'tailSpecifyLength':
+          this.$set(positionRule, 'specifiedWordCount', '');
+          break;
+        case 'docToSpecifyText':
+        case 'specifyTextToEnd':
+          this.$set(positionRule, 'specifiedText', '');
+          break;
+        case 'keywordAround':
+          this.$set(positionRule, 'beforeCharactersNum', '');
+          this.$set(positionRule, 'specifiedKeywords', '');
+          this.$set(positionRule, 'afterCharactersNum', '');
+          break;
+        case 'specifyTextToLength':
+          this.$set(positionRule, 'specifiedText', '');
+          this.$set(positionRule, 'specifiedWordCountLength', '');
+          break;
+        case 'specifyTextEndToLength':
+          this.$set(positionRule, 'beforeSpecifiedCharactersNum', '');
+          this.$set(positionRule, 'specifiedText', '');
+          break;
+        case 'headTailRange':
+          this.$set(positionRule, 'firstText', '');
+          this.$set(positionRule, 'shouldIncludeCharactersNum', '');
+          this.$set(positionRule, 'endText', '');
+          break;
+      }
+    },
+
+    /**
+     * 创建空的定位规则
+     */
+    createEmptyPositionRule() {
+      return {
+        ruleSetType: '', // 规则类型（对应后端的ruleSetType）
+      };
+    },
+
+    /**
+     * 保存规则
+     */
+    handleSaveRules() {
+      // 验证规则（保持不变）
+      if (!this.validateRules()) {
+        return;
+      }
+
+      // 准备提交的数据，适配后端接口要求
+      const submitData = {
+        analysisLevel: this.analysisLevel,
+        analysisName: this.analysisName,
+        analysisCode: this.analysisCode,
+        analysisSort: this.analysisSort,
+        parentId: this.parentId,
+        templateId: this.templateId,
+        analysisLabelItemId: this.selectedLabelItemId,
+
+        subRules: this.ruleSets.map((ruleSet, subIndex) => ({
+          // 子规则基本信息
+          compositionId: ruleSet.contentSource.compositionId,
+          compositionName: ruleSet.contentSource.compositionName,
+          // 可以添加其他子规则需要的字段
+        })),
+
+        // 所有定位规则统一放在一个数组，通过subRuleId关联
+        positions: []
+      };
+
+      // 为每个定位规则添加subRuleId关联
+      this.ruleSets.forEach((ruleSet, subIndex) => {
+        ruleSet.positionRules.forEach(posRule => {
+          submitData.positions.push({
+            subRuleId: subIndex + 1, // 子规则索引（后端会处理实际ID）
+            queryRuleId: posRule.queryRuleId,
+            ruleSetType: posRule.ruleSetType,
+            specifiedWordCount: posRule.specifiedWordCount,
+            specifiedText: posRule.specifiedText,
+            specifiedKeywords: posRule.specifiedKeywords,
+            beforeCharactersNum: posRule.beforeCharactersNum,
+            afterCharactersNum: posRule.afterCharactersNum,
+            specifiedWordCountLength: posRule.specifiedWordCountLength,
+            beforeSpecifiedCharactersNum: posRule.beforeSpecifiedCharactersNum,
+            firstText: posRule.firstText,
+            shouldIncludeCharactersNum: posRule.shouldIncludeCharactersNum,
+            endText: posRule.endText
+          });
+        });
+      });
+
+      // 调用保存接口（保持不变）
+      addAnalysisRuleSet(submitData)
+        .then(res => {
+          if (res.code === 200) {
+            this.$message.success('规则保存成功');
+          } else {
+            this.$message.error(res.msg || '规则保存失败');
+          }
+        })
+        .catch(err => {
+          console.error('保存规则失败:', err);
+          this.$message.error('规则保存失败');
+        });
+    },
+    /**
+     * 验证规则
+     */
+    validateRules() {
+      // 验证每个规则集
+      for (let i = 0; i < this.ruleSets.length; i++) {
+        const ruleSet = this.ruleSets[i];
+
+        // 验证内容来源
+        if (!ruleSet.contentSource.compositionId) {
+          this.$message.warning(`规则 ${i + 1}：请选择内容来源`);
+          return false;
+        }
+
+        // 验证每个定位规则
+        for (let j = 0; j < ruleSet.positionRules.length; j++) {
+          const posRule = ruleSet.positionRules[j];
+
+          // 验证规则类型
+          if (!posRule.ruleSetType) {
+            this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请选择规则类型`);
+            return false;
+          }
+
+          // 根据规则类型验证必填项
+          if (posRule.ruleSetType === 'headSpecifyLength' && !posRule.specifiedWordCount) {
+            this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入指定字数`);
+            return false;
+          }
+
+          if (posRule.ruleSetType === 'docToSpecifyText' && !posRule.specifiedText) {
+            this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入指定文字`);
+            return false;
+          }
+
+          if (posRule.ruleSetType === 'tailSpecifyLength' && !posRule.specifiedWordCount) {
+            this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入指定字数`);
+            return false;
+          }
+
+          if (posRule.ruleSetType === 'specifyTextToEnd' && !posRule.specifiedText) {
+            this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入指定文字`);
+            return false;
+          }
+
+          if (posRule.ruleSetType === 'keywordAround') {
+            if (!posRule.beforeCharactersNum) {
+              this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入前面字数`);
+              return false;
+            }
+            if (!posRule.specifiedKeywords) {
+              this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入指定关键词`);
+              return false;
+            }
+            if (!posRule.afterCharactersNum) {
+              this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入后面字数`);
+              return false;
+            }
+          }
+
+          if (posRule.ruleSetType === 'specifyTextToLength') {
+            if (!posRule.specifiedText) {
+              this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入指定文字`);
+              return false;
+            }
+            if (!posRule.specifiedWordCountLength) {
+              this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入指定字数长度`);
+              return false;
+            }
+          }
+
+          if (posRule.ruleSetType === 'specifyTextEndToLength') {
+            if (!posRule.beforeSpecifiedCharactersNum) {
+              this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入指定文字前方字数`);
+              return false;
+            }
+            if (!posRule.specifiedText) {
+              this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入指定文字`);
+              return false;
+            }
+          }
+
+          if (posRule.ruleSetType === 'headTailRange') {
+            if (!posRule.firstText) {
+              this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入首部文字`);
+              return false;
+            }
+            if (!posRule.shouldIncludeCharactersNum) {
+              this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入需要包含的字数`);
+              return false;
+            }
+            if (!posRule.endText) {
+              this.$message.warning(`规则 ${i + 1}，定位规则 ${j + 1}：请输入尾部文字`);
+              return false;
+            }
+          }
+        }
+      }
+
+      return true;
+    },
+
+    /**
+     * 获取字典标签
+     */
+    getDictLabel(dictType, dictValue) {
+      const dictItem = this.dictCache[dictType]?.find(item => item.dictValue === dictValue)
+      return dictItem ? dictItem.dictLabel : dictValue
+    }
+  },
+
+  watch: {
+    // 监听树搜索关键词变化
+    treeSearchKey(val) {
+      this.$refs.labelItemTree.filter(val)
+    },
+
+    // 监听路由参数变化
+    '$route.query.analysisLabelId'(val) {
+      this.analysisLabelId = decryptWithSM4(val) || ''
+      this.loadTreeData()
+    },
+    '$route.query.templateId'(val) {
+      this.templateId = decryptWithSM4(val) || ''
+      this.tableSendParams.templateId = this.templateId
+      this.loadTemplateInfo() // 重新加载模板信息
+      if (this.selectedLabelItemId) {
+        this.loadRuleSets() // 重新加载规则集
+      }
+    }
+  }
+}
+</script>
+
+<style scoped lang="scss">
+/* 保持原始样式不变 */
+.back-container {
+  display: flex;
+  justify-content: flex-end;
+  align-items: center;
+  margin-bottom: 20px;
+  padding: 0 20px;
+
+  .back-btn {
+    width: 98px;
+    height: 36px;
+    background: #FFFFFF;
+    box-shadow: 0px 4px 8px 0px rgba(76, 76, 76, 0.2);
+    border-radius: 4px;
+    border: none;
+    color: #666;
+    font-size: 14px;
+    transition: all 0.3s ease;
+
+    &:hover {
+      background: #f5f5f5;
+      color: #409EFF;
+      box-shadow: 0px 6px 12px 0px rgba(76, 76, 76, 0.3);
+    }
+  }
+
+  .save-btn {
+    width: 98px;
+    height: 36px;
+    box-shadow: 0px 4px 8px 0px rgba(76, 76, 76, 0.2);
+    border-radius: 4px;
+    border: none;
+    font-size: 14px;
+    transition: all 0.3s ease;
+
+    &:hover {
+      box-shadow: 0px 6px 12px 0px rgba(76, 76, 76, 0.3);
+    }
+  }
+}
+
+.analysis-rule-container {
+  height: calc(100vh - 84px);
+  overflow: hidden;
+  background: linear-gradient(180deg, #F1F6FF 20%, #E5EFFF 100%);
+  padding: 16px;
+}
+
+// 树形图样式
+.tree-container {
+  margin-top: 6px;
+  height: 100%;
+  background: #fff;
+  border: 1px solid #ebeef5;
+  border-radius: 4px;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.06);
+  padding: 16px;
+  display: flex;
+  flex-direction: column;
+  box-sizing: border-box;
+
+  .tree-search {
+    margin-bottom: 16px;
+    ::v-deep .el-input__inner {
+      border-color: #dcdfe6;
+      border-radius: 4px;
+      &:focus {
+        border-color: #1f72ea;
+        box-shadow: 0 0 0 2px rgba(31, 114, 234, 0.2);
+      }
+    }
+  }
+
+  .el-tree {
+    flex: 1;
+    overflow-y: auto;
+    &::-webkit-scrollbar {
+      width: 6px;
+      height: 6px;
+    }
+    &::-webkit-scrollbar-thumb {
+      background-color: #ddd;
+      border-radius: 3px;
+    }
+    &::-webkit-scrollbar-track {
+      background-color: #f5f5f5;
+    }
+
+    ::v-deep .el-tree-node__content {
+      height: 40px;
+      &:hover {
+        background-color: #f5f7fa;
+      }
+    }
+
+    ::v-deep .el-tree-node.is-current > .el-tree-node__content {
+      background-color: #e6f7ff;
+      font-weight: 500;
+    }
+  }
+
+  .tree-node-content {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    width: 100%;
+    height: 100%;
+  }
+}
+
+// 规则配置区域样式
+.rule-config-container {
+  background: #fff;
+  border-radius: 4px;
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.06);
+  padding: 20px;
+  height: calc(100vh - 205px);
+  overflow-y: auto;
+  box-sizing: border-box;
+}
+
+.template-info {
+  margin-bottom: 20px;
+  padding-bottom: 10px;
+  border-bottom: 1px solid #eee;
+
+  h3 {
+    margin: 0;
+    color: #1F72EA;
+    font-size: 16px;
+  }
+}
+
+.rule-sets {
+  ::v-deep .el-form-item {
+  }
+
+  ::v-deep .el-form-item__label {
+    text-align: left;
+
+  }
+
+  ::v-deep .el-form-item__content {
+  }
+}
+
+.add-rule-container {
+  margin-bottom: 20px;
+  text-align: right;
+}
+
+.rule-set-item {
+  background: #f9f9f9;
+  border-radius: 6px;
+  padding: 15px;
+  margin-bottom: 20px;
+  position: relative;
+}
+
+.rule-set-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 15px;
+  padding-bottom: 10px;
+  border-bottom: 1px dashed #e0e0e0;
+
+  .rule-set-index {
+    font-weight: bold;
+    color: #333;
+  }
+}
+
+.rule-set-actions {
+  display: flex;
+  gap: 5px;
+}
+
+.rule-set-content {
+  margin-top: 15px;
+}
+
+.content-source-radios {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 15px;
+  margin-top: 5px;
+}
+
+.position-rules {
+  margin-top: 15px;
+}
+
+.position-rule-item {
+  margin-bottom: 15px;
+  background: #f9f9f9;
+}
+
+.position-rule-item ::v-deep .el-form-item__content {
+  margin-left: 0 !important;
+}
+
+.rule-fields {
+  display: inline-flex;
+  align-items: center;
+  margin-top: 10px;
+}
+
+.add-position-rule {
+  color: #409EFF;
+  margin-top: 10px;
+  display: inline-block;
+}
+
+.save-rule-container {
+  margin-top: 30px;
+  text-align: right;
+}
+
+// 按钮样式
+.add-btn {
+  width: 121px;
+  height: 36px;
+  background: #1F72EA;
+  box-shadow: 0px 4px 8px 0px rgba(51, 135, 255, 0.5);
+  border-radius: 4px;
+  border: none;
+  color: #fff;
+  font-size: 14px;
+  transition: all 0.3s;
+  margin-right: 10px;
+
+  &:hover {
+    background: #4A8BFF;
+    box-shadow: 0px 6px 12px 0px rgba(51, 135, 255, 0.6);
+  }
+
+  &:disabled {
+    background: #a0cfff;
+    box-shadow: none;
+    cursor: not-allowed;
+  }
+}
+
+.action-btn {
+  margin-right: 8px;
+
+  &:last-child {
+    margin-right: 0;
+  }
+}
+</style>
diff --git a/src/views/template/templateInfo/components/TemplateForm.vue b/src/views/template/templateInfo/components/TemplateForm.vue
index ee23c4c..b72b3af 100644
--- a/src/views/template/templateInfo/components/TemplateForm.vue
+++ b/src/views/template/templateInfo/components/TemplateForm.vue
@@ -48,6 +48,7 @@
           <ProjectFile
             ref="projectFileRef"
             title="项目文件"
+            :is-edit-mode="type === 'edit'"
           />
         </el-col>
       </el-row>
@@ -57,6 +58,7 @@
           <SectionFile
             ref="sectionFileRef"
             title="标段/标包文件"
+            :is-edit-mode="type === 'edit'"
           />
         </el-col>
       </el-row>
@@ -254,8 +256,6 @@ export default {
 
         // 向子组件传递数据
         this.$refs.basicInfoRef.setFormData(detail);
-        // 注意：这里假设 detail.projectFiles 和 detail.sectionFiles 的结构
-        // 与子组件 setFormData 期望的结构一致。
         this.$refs.projectFileRef.setFormData(detail.projectFiles || []);
         this.$refs.sectionFileRef.setFormData(detail.sectionFiles || []);
         this.$refs.analysisLabelRef.setFormData(detail);
diff --git a/src/views/template/templateInfo/components/child/SectionFile.vue b/src/views/template/templateInfo/components/child/SectionFile.vue
index 0326400..a3b0f3f 100644
--- a/src/views/template/templateInfo/components/child/SectionFile.vue
+++ b/src/views/template/templateInfo/components/child/SectionFile.vue
@@ -21,7 +21,7 @@
       type="card"
       class="file-tabs"
       @tab-remove="handleRemoveTab"
-      @tab-click="handleTabChange"
+      v-on="isEditMode ? { 'tab-click': handleTabChange } : {}"
     >
       <el-tab-pane
         v-for="(tab, index) in fileTabs"
@@ -103,6 +103,11 @@ export default {
     title: {
       type: String,
       default: '模板组成-标段/标包文件'
+    },
+
+    isEditMode: {
+      type: Boolean,
+      default: false
     }
   },
   data() {
diff --git a/src/views/template/templateInfo/index.vue b/src/views/template/templateInfo/index.vue
index c694635..c4d4a6a 100644
--- a/src/views/template/templateInfo/index.vue
+++ b/src/views/template/templateInfo/index.vue
@@ -43,7 +43,6 @@
 
         <!-- 操作按钮：调整更多按钮样式，增加菜单项 -->
         <template slot="handle" slot-scope="{ data }">
-          <!-- 解析规则按钮（保持原有样式） -->
           <el-button
             type="text"
             v-hasPermi="['template:info:detail']"
@@ -244,16 +243,14 @@ export default {
 
     // 查看模板详情
     handleDetail(data) {
-      if (data && data.templateId) {
-        console.log('关联的组成数据：', data.compositionList);
-        const encryptedId = encryptWithSM4(data.templateId.toString());
-        this.$router.push({
-          name: 'TemplateRule',
-          query: { templateId: encryptedId }
-        });
-      } else {
-        this.$modal.msgError('获取模板ID失败，请重试');
-      }
+      this.$router.push({
+        name: "AnalysisRule",
+        query: {
+          analysisLabelId: encryptWithSM4(data.analysisLabelId.toString()),
+          templateId: encryptWithSM4(data.templateId.toString())
+        },
+        title: '解析规则'
+      });
     },
 
     // 切换模板状态
@@ -280,7 +277,7 @@ export default {
       this.$modal.confirm(`是否确认删除“${row.templateName}”模板？`)
         .then(() => {
           delTemplateInfo({
-            templateId: encryptWithSM4(row.templateId.toString())
+            templateId: row.templateId
           }).then(res => {
             if (res.code === 200) {
               this.$modal.msgSuccess('删除成功');