矩阵填充可仅选标题行或索引列

src/components/DesignForm/formControlPropertiNew.vue

@@ -2910,7 +2910,10 @@ function mergeArrays(a, b) {
 
 //选项批量编辑  liwenxuan 20251212 end
 
-//自动填充设置 liwenxuan 20251230 start
+
+
+
+// 自动填充设置 liwenxuan 20251230 start
 
 let datapropsformList = JSON.parse(JSON.stringify(props.formList))
 
@@ -2919,28 +2922,23 @@ const zdtcszTree = computed(()=>{
     datapropsformList = JSON.parse(JSON.stringify(props.formList))
   }
   
-  //console.log(datapropsformList)
   if(associatedFormsCurrentFormFieldTreeForGlxxszExceptSelf && associatedFormsCurrentFormFieldTreeForGlxxszExceptSelf.value[0].children && associatedFormsCurrentFormFieldTreeForGlxxszExceptSelf.value[0].children.length>0){
-
-    
     let datab = JSON.parse(JSON.stringify(associatedFormsCurrentFormFieldTreeForGlxxszExceptSelf.value[0].children))
     let currentCompId = controlData.value.name
     const treeC = mergeAndFilterFormTrees(datapropsformList, datab,currentCompId);
-    //console.log(treeC)
     return treeC
   }else{
     return []
   }
   
 })
+
 // 使用 ref 替代 computed，使其可写
 const zdtcszTableData = ref([])
 
 // 获取当前正在设置自动填充的组件（"结果"组件）的选项
 const currentComponentOptions = computed(() => {
-
     return controlData.value.options
-
 })
 
 // 获取当前选择的索引列节点（用于获取label）
@@ -2957,7 +2955,7 @@ const currentTitleColumnNode = computed(() => {
 
 // 索引列的标签
 const indexColumnLabel = computed(() => {
-  if (!currentIndexColumnNode.value) return "索引列"
+  if (!currentIndexColumnNode.value) return "默认行"
   return currentIndexColumnNode.value.label
 })
 
@@ -2991,8 +2989,8 @@ const zdtcszTableColumns = computed(() => {
 
 // 监听标题行和索引列的变化，重新生成表格数据
 watch([titleOptions, indexOptions], ([newTitleOptions, newIndexOptions]) => {
-  // 如果没有标题行或索引列，清空表格数据
+  // 如果都没有选择，清空表格数据
-  if (!newTitleOptions.length || !newIndexOptions.length) {
+  if (!newTitleOptions.length && !newIndexOptions.length) {
     zdtcszTableData.value = []
     return
   }
@@ -3000,12 +2998,52 @@ watch([titleOptions, indexOptions], ([newTitleOptions, newIndexOptions]) => {
   // 从 controlData 中获取之前保存的数据
   const savedData = controlData.value?.control?.zdtcsz?.tableData || {}
   
+  // 情况1：只有标题行，没有索引列
+  if (newTitleOptions.length && !newIndexOptions.length) {
+    // 创建一行默认数据
+    const defaultRowKey = 'default'
+    const rowObj = {
+      rowKey: defaultRowKey,
+      rowLabel: '默认' // 第一列显示"默认"
+    }
+    
+    // 为每个标题列生成值，如果有保存的数据则使用保存的数据
+    newTitleOptions.forEach(colItem => {
+      const colKey = colItem.value
+      const savedValue = savedData[defaultRowKey]?.[colKey] || ''
+      rowObj[`col_${colKey}`] = savedValue
+    })
+    
+    zdtcszTableData.value = [rowObj]
+  }
+  // 情况2：只有索引列，没有标题行
+  else if (!newTitleOptions.length && newIndexOptions.length) {
+    // 创建一个默认列
+    const newTableData = newIndexOptions.map(rowItem => {
+      const rowKey = rowItem.value
+      const rowObj = {
+        rowKey: rowKey,
+        rowLabel: rowItem.label
+      }
+      
+      // 创建一个默认列
+      const defaultColKey = 'default'
+      const savedValue = savedData[rowKey]?.[defaultColKey] || ''
+      rowObj[`col_${defaultColKey}`] = savedValue
+      
+      return rowObj
+    })
+    
+    zdtcszTableData.value = newTableData
+  }
+  // 情况3：标题行和索引列都有
+  else if (newTitleOptions.length && newIndexOptions.length) {
     // 生成新的表格数据
     const newTableData = newIndexOptions.map(rowItem => {
       const rowKey = rowItem.value
       const rowObj = {
         rowKey: rowKey,
-      rowLabel: rowItem.label // 使用选项的label作为第一列显示
+        rowLabel: rowItem.label
       }
       
       // 为每个标题列生成值，如果有保存的数据则使用保存的数据
@@ -3019,16 +3057,36 @@ watch([titleOptions, indexOptions], ([newTitleOptions, newIndexOptions]) => {
     })
     
     zdtcszTableData.value = newTableData
+  }
 }, { immediate: true })
 
 // 监听表格数据变化，保存到临时存储
 const handleTableDataChange = () => {
   // 将表格数据转换为更容易存储的格式
   const tableData = {}
+  
   zdtcszTableData.value.forEach(row => {
     const rowKey = row.rowKey
     tableData[rowKey] = {}
-    titleOptions.value.forEach(col => {
+    
+    // 获取当前有效的列
+    let currentColumns = []
+    if (titleOptions.value.length > 0) {
+      // 有标题行，使用标题行的选项
+      currentColumns = titleOptions.value
+    } else if (zdtcszTableData.value[0]) {
+      // 没有标题行，从第一行数据中提取所有col_开头的字段
+      const firstRow = zdtcszTableData.value[0]
+      Object.keys(firstRow).forEach(key => {
+        if (key.startsWith('col_')) {
+          const colKey = key.replace('col_', '')
+          currentColumns.push({ value: colKey })
+        }
+      })
+    }
+    
+    // 保存每一列的值
+    currentColumns.forEach(col => {
       const colKey = col.value
       tableData[rowKey][colKey] = row[`col_${colKey}`] || ''
     })
@@ -3055,6 +3113,10 @@ const handleDetermineZdtcszDialogFlag = () => {
   console.log('左上角标签:', leftTopLabel.value) */
 }
 
+
+
+
+
 /**
  * 合并两个组件树，仅保留type为radio和select的节点，并过滤掉指定compId的节点，同时保留options属性
  * @param {Array} treeA - 组件树a，包含表单结构信息
@@ -8534,9 +8596,8 @@ const formatTooltip = (val: number) => {
 
 
 
-  <!-- 自动填充设置弹窗 start -->
+<!-- 自动填充设置弹窗 start -->
-
+<el-dialog
-  <el-dialog
   v-model="ZdtcszDialogFlag"
   class="glxxsztc"
   top="150px"
@@ -8595,6 +8656,7 @@ const formatTooltip = (val: number) => {
         align="center"
       />
       <!-- 动态生成标题行对应的表格列 -->
+      <template v-if="titleOptions.length > 0">
         <el-table-column
           v-for="col in zdtcszTableColumns"
           :key="col.value"
@@ -8621,6 +8683,34 @@ const formatTooltip = (val: number) => {
             </el-select>
           </template>
         </el-table-column>
+      </template>
+      <!-- 当没有标题行时，显示一个默认列 -->
+      <template v-else-if="zdtcszTableData.length > 0">
+        <el-table-column
+          key="default"
+          label="默认列"
+          prop="col_default"
+          min-width="200"
+          align="center"
+        >
+          <template #default="scope">
+            <el-select
+              v-model="scope.row.col_default"
+              size="small"
+              placeholder="请选择"
+              style="width: 100%;"
+              @change="handleTableDataChange"
+            >
+              <el-option
+                v-for="option in currentComponentOptions"
+                :key="option.value"
+                :label="option.label"
+                :value="option.value"
+              />
+            </el-select>
+          </template>
+        </el-table-column>
+      </template>
     </el-table>
   </div>
     
@@ -8632,7 +8722,6 @@ const formatTooltip = (val: number) => {
     </div>
   </template>
 </el-dialog>
-
 <!-- 自动填充设置弹窗 end -->
 
 <!-- 

src/components/DesignForm/public/form/form.vue

@@ -1286,12 +1286,25 @@ nextTick(()=>{
     let tby=getLastColonAfterString(element.tby)
     /* console.log(tbx)
     console.log(tby) */
+
+    //console.log(element.name)
     let rowValue = model.value[tbx]
+    //console.log(rowValue)
     let columnValue = model.value[tby]
-    let cellValue = getTableCellValueV2(element.tableData, rowValue, columnValue)
+    //console.log(columnValue)
-    //console.log(cellValue);
-    //console.log(element.name)
     if(tbx!=""&&tby!=""){
+      
+      let cellValue = getTableCellValue(element.tableData, rowValue, columnValue)
+      model.value[element.name] = cellValue*1
+    }else if(tbx!=""&&tby==""){
+      //console.log("仅设置了标题行")
+      let cellValue = getTableCellValue(element.tableData, rowValue, 'default')
+      //console.log(cellValue)
+      model.value[element.name] = cellValue*1
+    }else if(tbx==""&&tby!=""){
+      //console.log("仅设置了索引列")
+      let cellValue = getTableCellValue(element.tableData, 'any', columnValue)
+      //console.log(cellValue)
       model.value[element.name] = cellValue*1
     }
     
@@ -1313,7 +1326,7 @@ nextTick(()=>{
 function getLastColonAfterString(str) {
   // 1. 输入校验：确保输入是字符串类型（处理非字符串入参）
   if (typeof str !== 'string') {
-    console.warn('输入必须为字符串类型');
+    //console.warn('输入必须为字符串类型');
     return '';
   }
 
@@ -1330,8 +1343,20 @@ function getLastColonAfterString(str) {
 }
 
 
-// 根据自动填充表格行列数据确定单元格值
+
-function getTableCellValueV2(tableData, rowValue, columnValue) {
+/**
+ * 获取表格单元格值，兼容多种tableData结构
+ * 支持三种结构：
+ * 1. 标准行列结构：{列号: {行号: 值, ...}, ...}
+ * 2. 仅一行结构：{default: {列号: 值, ...}}
+ * 3. 仅一列结构：{列号: {default: 值}, ...}
+ * 
+ * @param {Object} tableData - 表格数据
+ * @param {String|Number} rowValue - 行标识
+ * @param {String|Number} columnValue - 列标识
+ * @returns {String|undefined} - 返回对应的单元格值，如果未找到则返回undefined
+ */
+function getTableCellValueV3(tableData, rowValue, columnValue) {
   try {
     // 检查输入参数
     if (!tableData || typeof tableData !== 'object' || Array.isArray(tableData)) {
@@ -1347,8 +1372,59 @@ function getTableCellValueV2(tableData, rowValue, columnValue) {
     const rowStr = String(rowValue);
     const columnStr = String(columnValue);
     
-    // 使用可选链操作符安全地访问嵌套属性
+    // 1. 首先尝试检测是否为仅一行结构（有default行）
-    return tableData?.[columnStr]?.[rowStr];
+    if (tableData.default && typeof tableData.default === 'object') {
+      // 这是仅一行结构：{default: {列号: 值, ...}}
+      // 忽略行值，直接使用列值
+      return tableData.default?.[columnStr];
+    }
+    
+    // 2. 尝试标准结构或仅一列结构
+    const columnObj = tableData[columnStr];
+    if (columnObj && typeof columnObj === 'object') {
+      // 2.1 尝试从列对象中获取行值
+      const cellValue = columnObj[rowStr];
+      if (cellValue !== undefined) {
+        return cellValue; // 找到标准结构的值
+      }
+      
+      // 2.2 如果没找到标准结构的行值，检查是否是仅一列结构（有default值）
+      if (columnObj.default !== undefined) {
+        // 这是仅一列结构：{列号: {default: 值}, ...}
+        // 忽略行值，返回该列的default值
+        return columnObj.default;
+      }
+    }
+    
+    // 3. 如果没有匹配任何结构，尝试其他可能的查找方式
+    
+    // 3.1 如果列不存在，检查所有列是否有default值（用于仅一列结构）
+    if (!columnObj) {
+      // 遍历所有列，看是否有匹配的列号
+      for (const colKey in tableData) {
+        if (String(colKey) === columnStr) {
+          const colData = tableData[colKey];
+          if (colData && typeof colData === 'object' && colData.default !== undefined) {
+            return colData.default;
+          }
+        }
+      }
+    }
+    
+    // 3.2 检查是否有default行（可能列名不是字符串"default"）
+    for (const key in tableData) {
+      const data = tableData[key];
+      if (data && typeof data === 'object') {
+        // 检查这个对象是否是一个行数据（包含列号作为键）
+        if (data[columnStr] !== undefined) {
+          // 这可能是行数据，返回对应的列值
+          return data[columnStr];
+        }
+      }
+    }
+    
+    // 4. 所有尝试都失败，返回undefined
+    return undefined;
   } catch (error) {
     // 如果发生任何错误，返回undefined
     console.error('获取表格单元格值时发生错误:', error);
@@ -1356,6 +1432,220 @@ function getTableCellValueV2(tableData, rowValue, columnValue) {
   }
 }
 
+/**
+ * 增强版：自动检测tableData结构并获取值
+ * 支持动态结构检测
+ */
+function getTableCellValueEnhanced(tableData, rowValue, columnValue) {
+  try {
+    if (!tableData || typeof tableData !== 'object') {
+      return undefined;
+    }
+    
+    if (rowValue == null || columnValue == null) {
+      return undefined;
+    }
+    
+    const rowStr = String(rowValue);
+    const columnStr = String(columnValue);
+    
+    // 先尝试直接获取（标准结构）
+    const directValue = tableData?.[columnStr]?.[rowStr];
+    if (directValue !== undefined) {
+      return directValue;
+    }
+    
+    // 检测表格结构
+    const tableStructure = detectTableStructure(tableData);
+    
+    switch (tableStructure) {
+      case 'standard':
+        // 标准结构，已经尝试过直接获取
+        break;
+        
+      case 'singleRow':
+        // 仅一行结构
+        return getFromSingleRowStructure(tableData, columnStr);
+        
+      case 'singleColumn':
+        // 仅一列结构
+        return getFromSingleColumnStructure(tableData, columnStr);
+        
+      case 'mixed':
+        // 混合结构，尝试多种方式
+        return getFromMixedStructure(tableData, rowStr, columnStr);
+        
+      default:
+        // 未知结构，返回undefined
+        return undefined;
+    }
+    
+    return undefined;
+  } catch (error) {
+    console.error('获取表格单元格值时发生错误:', error);
+    return undefined;
+  }
+}
+
+/**
+ * 检测tableData的结构
+ * @returns {string} - 结构类型：'standard', 'singleRow', 'singleColumn', 'mixed', 'unknown'
+ */
+function detectTableStructure(tableData) {
+  if (!tableData || typeof tableData !== 'object') {
+    return 'unknown';
+  }
+  
+  const keys = Object.keys(tableData);
+  if (keys.length === 0) {
+    return 'empty';
+  }
+  
+  // 检查是否为仅一行结构（有default键）
+  if (keys.length === 1 && keys[0] === 'default') {
+    const defaultData = tableData.default;
+    if (defaultData && typeof defaultData === 'object') {
+      // 检查default对象的值是否都是简单值（不是对象）
+      const hasNestedObjects = Object.values(defaultData).some(
+        value => value && typeof value === 'object'
+      );
+      if (!hasNestedObjects) {
+        return 'singleRow';
+      }
+    }
+  }
+  
+  // 检查是否为仅一列结构
+  let isSingleColumn = true;
+  for (const key of keys) {
+    const colData = tableData[key];
+    if (!colData || typeof colData !== 'object') {
+      isSingleColumn = false;
+      break;
+    }
+    
+    // 检查是否只有default键或只有一个键
+    const colKeys = Object.keys(colData);
+    if (colKeys.length !== 1 || (colKeys.length === 1 && colKeys[0] !== 'default')) {
+      // 如果有多个键，或者唯一的键不是default，则不是仅一列结构
+      if (colKeys.length > 1 || (colKeys.length === 1 && !colKeys[0].match(/^\d+$/))) {
+        isSingleColumn = false;
+        break;
+      }
+    }
+  }
+  
+  if (isSingleColumn) {
+    return 'singleColumn';
+  }
+  
+  // 检查是否为标准结构（所有值都是对象，且对象键是行号）
+  let isStandard = true;
+  for (const key of keys) {
+    const colData = tableData[key];
+    if (!colData || typeof colData !== 'object') {
+      isStandard = false;
+      break;
+    }
+    
+    // 检查对象键是否都是数字字符串（表示行号）
+    const colKeys = Object.keys(colData);
+    if (colKeys.length === 0) {
+      isStandard = false;
+      break;
+    }
+    
+    // 允许有default键和其他键混合
+    const hasNonNumericKeys = colKeys.some(k => k !== 'default' && !k.match(/^\d+$/));
+    if (hasNonNumericKeys) {
+      isStandard = false;
+      break;
+    }
+  }
+  
+  if (isStandard) {
+    return 'standard';
+  }
+  
+  // 混合结构
+  return 'mixed';
+}
+
+/**
+ * 从仅一行结构中获取值
+ */
+function getFromSingleRowStructure(tableData, columnStr) {
+  return tableData.default?.[columnStr];
+}
+
+/**
+ * 从仅一列结构中获取值
+ */
+function getFromSingleColumnStructure(tableData, columnStr) {
+  const colData = tableData[columnStr];
+  if (colData && typeof colData === 'object') {
+    // 优先返回default值，如果没有则返回第一个值
+    return colData.default !== undefined ? colData.default : Object.values(colData)[0];
+  }
+  return undefined;
+}
+
+/**
+ * 从混合结构中获取值
+ */
+function getFromMixedStructure(tableData, rowStr, columnStr) {
+  // 尝试多种方式
+  
+  // 1. 尝试标准方式
+  const standardValue = tableData?.[columnStr]?.[rowStr];
+  if (standardValue !== undefined) {
+    return standardValue;
+  }
+  
+  // 2. 检查该列是否有default值
+  const columnData = tableData[columnStr];
+  if (columnData && typeof columnData === 'object') {
+    if (columnData.default !== undefined) {
+      return columnData.default;
+    }
+  }
+  
+  // 3. 检查是否有default行
+  if (tableData.default && typeof tableData.default === 'object') {
+    return tableData.default[columnStr];
+  }
+  
+  // 4. 遍历查找
+  for (const key in tableData) {
+    const data = tableData[key];
+    if (data && typeof data === 'object') {
+      // 如果这个对象有我们要找的列键
+      if (data[columnStr] !== undefined) {
+        return data[columnStr];
+      }
+      // 如果键名匹配列，并且有我们要找的行键
+      if (key === columnStr && data[rowStr] !== undefined) {
+        return data[rowStr];
+      }
+    }
+  }
+  
+  return undefined;
+}
+
+/**
+ * 统一方法，推荐使用这个
+ */
+function getTableCellValue(tableData, rowValue, columnValue) {
+  return getTableCellValueEnhanced(tableData, rowValue, columnValue);
+}
+
+
+
+
+
+
+
 function addStringIfNotExists(arr: string[], str: string) {
   if (!arr.includes(str)) {
     arr.push(str);