@skyfox2000/webui 1.3.4 → 1.3.6

package/src/utils/form-excel.ts

@@ -7,7 +7,7 @@ import message from 'vue-m-message';
 import { ValidateRule } from '@/typings/form';
 import { validMessages } from './form-validate';
 import { UploadFile } from '@/typings/upload';
-import { toExcel, type ExcelMarkInfo } from './excel-view';
+import { toExcel, type ExcelMarkInfo, excelToNormalized } from './excel-view';
 
 // ExcelMarkCell 和 ExcelMarkInfo 类型已移至 excel-view.ts 统一管理
 
@@ -17,105 +17,31 @@ import { toExcel, type ExcelMarkInfo } from './excel-view';
  * @returns 包含工作簿、工作表、表头和数据的对象
  */
 export const processExcelFile = async (excelBuffer: ArrayBuffer) => {
-   // 动态导入 exceljs
-   const ExcelJS = await import('exceljs');
-   const workbook = new ExcelJS.default.Workbook();
-   await workbook.xlsx.load(excelBuffer);
-
-   // 获取第一个工作表
-   const worksheet = workbook.worksheets[0];
-   if (!worksheet) {
+   // 使用excel-view.ts中的统一方法
+   const normalized = await excelToNormalized(excelBuffer);
+
+   if (normalized.headers.length === 0) {
       message.error('Excel文件不包含工作表');
       return null;
    }
 
-   // 提取表头和数据
-   const headers: string[] = [];
-   // 表头对象数据行
+   // 转换为原有格式以保持兼容性
    const excelData: Record<string, any>[] = [];
-   // 纯数据行
-   const excelRows: any[][] = [];
-
-   // 提取表头（第一行）
-   worksheet.getRow(1).eachCell((cell) => {
-      // 处理不同类型的单元格值，确保对象类型值被正确转换为字符串
-      let headerValue = '';
-      if (cell.value !== null && cell.value !== undefined) {
-         // 处理不同类型的单元格值
-         if (typeof cell.value === 'object') {
-            // 处理RichText类型
-            if ('richText' in cell.value && Array.isArray(cell.value.richText)) {
-               headerValue = cell.value.richText.map((rt: any) => rt.text || '').join('');
-            }
-            // 处理带有text属性的对象
-            else if ('text' in cell.value && typeof cell.value.text === 'string') {
-               headerValue = cell.value.text;
-            }
-            // 处理日期类型
-            else if (cell.value instanceof Date) {
-               headerValue = cell.value.toLocaleDateString();
-            }
-            // 其他对象类型，尝试获取有意义的字符串表示
-            else {
-               try {
-                  headerValue = JSON.stringify(cell.value);
-               } catch {
-                  headerValue = String(cell.value);
-               }
-            }
-         } else {
-            // 非对象类型直接转字符串
-            headerValue = String(cell.value);
+   normalized.rows.forEach((row) => {
+      const rowData: Record<string, any> = {};
+      normalized.headers.forEach((header, idx) => {
+         if (header) {
+            rowData[header] = row[idx];
          }
-      }
-      headers.push(headerValue);
-   });
-
-   // 提取数据行
-   worksheet.eachRow((row, rowNumber) => {
-      if (rowNumber > 1) {
-         // 跳过表头
-         const rowData: Record<string, any> = {};
-         const rowDataArray: any[] = [];
-         headers.forEach((header, idx) => {
-            if (header) {
-               const cell = row.getCell(idx + 1);
-               const cellValue = cell.value;
-
-               // 使用与表头处理相同的逻辑来提取单元格值
-               if (cellValue !== null && cellValue !== undefined) {
-                  if (typeof cellValue === 'object') {
-                     // 处理RichText类型
-                     if ('richText' in cellValue && Array.isArray(cellValue.richText)) {
-                        rowData[header] = cellValue.richText.map((rt: any) => rt.text || '').join('');
-                     }
-                     // 处理带有text属性的对象
-                     else if ('text' in cellValue && typeof cellValue.text === 'string') {
-                        rowData[header] = cellValue.text;
-                     }
-                     // 日期类型保留原样，便于验证处理
-                     else if (cellValue instanceof Date) {
-                        rowData[header] = cellValue;
-                     }
-                     // 其他对象类型
-                     else {
-                        rowData[header] = cellValue;
-                     }
-                  } else {
-                     rowData[header] = cellValue;
-                  }
-               } else {
-                  rowData[header] = null;
-               }
-               rowDataArray.push(rowData[header]);
-            }
-         });
-         excelData.push(rowData);
-         excelRows.push(rowDataArray);
-      }
+      });
+      excelData.push(rowData);
    });
 
-   return { workbook, worksheet, headers, excelData, excelRows };
+   return {
+      headers: normalized.headers,
+      excelData,
+      excelRows: normalized.rows,
+   };
 };
 
 /**
@@ -170,7 +96,8 @@ export const validateExcel = async (
    rules?: Record<string, ValidateRule>,
 ): Promise<{
    hasError: boolean;
-   errBlob?: Blob;
+   markCells?: Array<{ row: number; col: number; color: string }>;
+   markHeaders?: string[];
 }> => {
    if (!rules || isEmpty(rules)) {
       return { hasError: false };
@@ -203,7 +130,7 @@ export const validateExcel = async (
    // 验证数据（仅验证非缺失字段）
    const validationErrors = await validateExcelData(headers, excelJson, validator);
 
-   // 如果有验证错误或缺失字段，标记错误单元格和表头
+   // 如果有验证错误或缺失字段，返回标记信息
    if (validationErrors.length > 0 || missingFields.length > 0) {
       // 准备需要标记的单元格
       const markCells = validationErrors.map((error) => ({
@@ -212,27 +139,14 @@ export const validateExcel = async (
          color: 'FFFF0000', // 红色
       }));
 
-      // 使用excel-view统一创建标记Excel
-      const markResult = await createMarkedExcelView(
-         excelBuffer,
-         {
-            markCells,
-            markHeaders: missingFields,
-         },
-         'validation_errors.xlsx',
-      );
-
-      if (markResult.success && markResult.blobUrl) {
-         // 从blob URL创建blob对象
-         const response = await fetch(markResult.blobUrl);
-         const errBlob = await response.blob();
-         return { hasError: true, errBlob };
-      } else {
-         return { hasError: true };
-      }
+      return {
+         hasError: true,
+         markCells,
+         markHeaders: missingFields,
+      };
    }
 
-   return { hasError: false }; // 没有错误时返回null
+   return { hasError: false };
 };
 
 type ExcelValidationError = ValidateError & {
@@ -296,7 +210,8 @@ export const checkExcelDuplicates = async (
    url?: IUrlInfo,
 ): Promise<{
    hasError: boolean;
-   errBlob?: Blob;
+   markCells?: Array<{ row: number; col: number; color: string }>;
+   markHeaders?: string[];
 }> => {
    if (!duplicateRules || duplicateRules.length === 0) {
       return { hasError: false };
@@ -328,14 +243,18 @@ export const checkExcelDuplicates = async (
 
    rows.forEach((rowData, index) => {
       // 构建唯一键，将所有重复规则字段的值连接起来
-      const uniqueKey = duplicateRules.map((field) => rowData[field]).join('|');
+      const keyValues = duplicateRules.map((field) => rowData[field]);
+      const uniqueKey = keyValues.join('|');
       allKeys.push(uniqueKey);
 
-      if (uniqueValues.has(uniqueKey)) {
+      // 只检测非空值的重复，避免多个空行被误判为重复
+      const hasValidValue = keyValues.some((value) => value !== null && value !== undefined && value !== '');
+
+      if (hasValidValue && uniqueValues.has(uniqueKey)) {
          // 找到重复行，记录当前索引和第一次出现的索引
          duplicateIndices.add(index); // 添加当前重复行
          duplicateIndices.add(uniqueValues.get(uniqueKey)!); // 添加第一次出现的行
-      } else {
+      } else if (hasValidValue) {
          uniqueValues.set(uniqueKey, index);
       }
    });
@@ -367,33 +286,120 @@ export const checkExcelDuplicates = async (
                markCells.push({
                   row: rowIndex + 2, // Excel行号 = 数组索引 + 2（表头和1-based索引）
                   col: colIndex + 1, // Excel列号 = 数组索引 + 1（1-based索引）
-                  color: 'FFFF0000', // 红色
+                  color: 'FFA500', // 黄橙色
                });
             }
          });
       });
 
-      // 使用excel-view统一创建标记Excel
+      return {
+         hasError: true,
+         markCells,
+         markHeaders: missingDuplicateFields,
+      };
+   }
+
+   return { hasError: false }; // 没有重复数据
+};
+
+/**
+ * 统一验证Excel数据（格式验证和重复验证）
+ * @param excelBuffer Excel文件的ArrayBuffer
+ * @param rules 验证规则
+ * @param duplicateRules 重复规则
+ * @param duplicateUrl 重复检查URL
+ * @returns 统一验证结果
+ */
+export const validateExcelUnified = async (
+   excelBuffer: ArrayBuffer,
+   rules?: Record<string, ValidateRule>,
+   duplicateRules?: string[],
+   duplicateUrl?: IUrlInfo,
+): Promise<{
+   hasError: boolean;
+   errBlob?: Blob;
+   validationMsg: string;
+   duplicateMsg: string;
+}> => {
+   const allMarkCells: Array<{ row: number; col: number; color: string }> = [];
+   const allMarkHeaders: string[] = [];
+   let hasValidationError = false;
+   let hasDuplicateError = false;
+   let validationMsg = '数据验证成功';
+   let duplicateMsg = '数据验证通过';
+
+   // 1. 格式验证
+   const validationResult = await validateExcel(excelBuffer, rules);
+   if (validationResult.hasError) {
+      hasValidationError = true;
+      validationMsg = '数据验证失败';
+      if (validationResult.markCells) {
+         allMarkCells.push(...validationResult.markCells);
+      }
+      if (validationResult.markHeaders) {
+         allMarkHeaders.push(...validationResult.markHeaders);
+      }
+   }
+
+   // 2. 重复验证
+   if (duplicateRules && duplicateRules.length > 0) {
+      const duplicateResult = await checkExcelDuplicates(excelBuffer, duplicateRules, duplicateUrl);
+      if (duplicateResult.hasError) {
+         hasDuplicateError = true;
+         duplicateMsg = '检测到重复数据';
+         if (duplicateResult.markCells) {
+            // 检查是否有重复标记的单元格，如果有则改为深红色
+            duplicateResult.markCells.forEach((duplicateCell) => {
+               const existingCell = allMarkCells.find(
+                  (cell) => cell.row === duplicateCell.row && cell.col === duplicateCell.col,
+               );
+               if (existingCell) {
+                  existingCell.color = '8B0000'; // 深红色
+               } else {
+                  allMarkCells.push(duplicateCell);
+               }
+            });
+         }
+         if (duplicateResult.markHeaders) {
+            allMarkHeaders.push(...duplicateResult.markHeaders);
+         }
+      }
+   }
+
+   // 3. 如果有任何错误，创建统一的标记Excel
+   if (hasValidationError || hasDuplicateError) {
       const markResult = await createMarkedExcelView(
          excelBuffer,
          {
-            markCells,
-            markHeaders: missingDuplicateFields,
+            markCells: allMarkCells,
+            markHeaders: allMarkHeaders,
          },
-         'duplicate_errors.xlsx',
+         'validation_errors.xlsx',
       );
 
       if (markResult.success && markResult.blobUrl) {
-         // 从blob URL创建blob对象
          const response = await fetch(markResult.blobUrl);
          const errBlob = await response.blob();
-         return { hasError: true, errBlob };
+         return {
+            hasError: true,
+            errBlob,
+            validationMsg,
+            duplicateMsg,
+         };
       } else {
-         return { hasError: true };
+         return {
+            hasError: true,
+            validationMsg,
+            duplicateMsg,
+         };
       }
    }
 
-   return { hasError: false }; // 没有重复数据
+   return {
+      hasError: false,
+      validationMsg,
+      duplicateMsg,
+   };
 };
 
 /**

package/src/utils/options.ts

@@ -179,25 +179,77 @@ const queryOptions = <T>(
 
 /**
  * 获取选中的选项对象或对象数组
+ * - 支持单选或者多选
+ * - 支持子级选项
  * @param values 当前选择的值
  * @param options 所有选项对象数组
+ * @param keepChildren 是否保留子选项，默认为 true
  * @returns 选中的选项对象或对象数组
  */
 export const getSelectedValues = (
    values: undefined | string | number | (string | number | undefined)[],
    options: OptionItemProps[],
+   keepChildren?: boolean,
 ): OptionItemProps | OptionItemProps[] | undefined => {
    // 如果 values 为 undefined，直接返回 undefined
    if (values === undefined) return undefined;
 
+   // 深拷贝选项以确保数据隔离
+   const deepCloneOption = (option: OptionItemProps): OptionItemProps => {
+      const cloned = { ...option };
+      if (keepChildren && option.children && option.children.length > 0) {
+         cloned.children = option.children.map((child: OptionItemProps) => deepCloneOption(child));
+      } else {
+         delete cloned.children;
+      }
+      return cloned;
+   };
+
+   // 递归查找匹配的选项
+   const findMatchedOptions = (
+      searchValues: (string | number | undefined)[],
+      searchOptions: OptionItemProps[],
+   ): OptionItemProps[] => {
+      const matched: OptionItemProps[] = [];
+
+      for (const option of searchOptions) {
+         // 检查当前选项是否匹配
+         if (searchValues.includes(option.value)) {
+            matched.push(deepCloneOption(option));
+         }
+
+         // 递归检查子选项
+         if (option.children && option.children.length > 0) {
+            const childMatched = findMatchedOptions(searchValues, option.children);
+            matched.push(...childMatched);
+         }
+      }
+
+      return matched;
+   };
+
    // 如果 values 是数组，返回所有匹配的选项对象数组
    if (Array.isArray(values)) {
-      return options.filter((option) => values.includes(option.value));
+      return findMatchedOptions(values, options);
    }
    // 如果 values 是单个值，返回匹配的单个选项对象
    else {
-      return options.find((option) => option.value === values);
+      const matched = findMatchedOptions([values], options);
+      return matched.length > 0 ? matched[0] : undefined;
+   }
+};
+
+/**
+ * 获取选中的选项文字内容
+ * @param selectedValues 选中的选项对象或对象数
+ * @returns 选中的选项文字内容
+ */
+export const getSelectedLabels = (selectedValues: OptionItemProps | OptionItemProps[] | undefined): string[] => {
+   if (selectedValues === undefined) return [];
+   if (Array.isArray(selectedValues)) {
+      return selectedValues.map((option) => option.label);
    }
+   return [selectedValues.label];
 };
 
 // 辅助函数：根据路径设置值
@@ -216,7 +268,10 @@ const setNestedValue = (obj: Record<string, any>, path: string, value: any) => {
 
 /**
  * 将选中的值根据 outFields 映射到 formData 上
- * @param formData 需要更新的数据对象
+ * @param formData 需要更新的数据对
+ * 输出字段转换控制
+ * - Key：目的字段，支持 "." 嵌套
+ * - Value：源字段，支持模板 ${} 或者 ${index} 或者 ${index}.${key}
  * @param outFields 输出字段转换映射关系
  * @param selectedValues 选中的选项对象或对象数组
  */
@@ -235,12 +290,28 @@ export const outFormDataFields = (
 
    // 如果 selectedValues 是数组
    if (Array.isArray(selectedValues)) {
-      // selectedValues.forEach((selectedValue) => {
-      //    Object.entries(outFields).forEach(([targetKey, sourceKey]) => {
-      //       const value = selectedValue[sourceKey];
-      //       setNestedValue(formData, targetKey, value);
-      //    });
-      // });
+      Object.entries(outFields).forEach(([targetKey, sourceKey]) => {
+         // 必须是 ${index} 或者 ${index}.${key}，否则输出错误并跳过
+         const reg = /^\$\{\d+\}/;
+         // 第一个必须是 ${index}，否则输出错误并跳过
+         if (reg.test(sourceKey)) {
+            try {
+               const index = parseInt(sourceKey.match(/\$\{(\d+)\}/)?.[1] ?? '0');
+               const targetValue = selectedValues[index];
+               const restKey = sourceKey.replace(/\$\{\d+\}\./, '');
+               if (restKey && targetValue) {
+                  const value = parseFieldTemplate(restKey, targetValue);
+                  setNestedValue(formData, targetKey, value);
+               } else {
+                  setNestedValue(formData, targetKey, targetValue);
+               }
+            } catch (error) {
+               console.error('outFields 格式错误：' + sourceKey, '必须是 ${index} 或者 ${index}.${key}');
+            }
+         } else {
+            console.error('outFields 格式错误：' + sourceKey, '必须是 ${index} 或者 ${index}.${key}');
+         }
+      });
    }
    // 如果 selectedValues 是单个对象
    else {
@@ -320,16 +391,3 @@ export const onOptionChanged = (
    }
    return selectedValues;
 };
-
-/**
- * 获取选中的选项文字内容
- * @param selectedValues 选中的选项对象或对象数
- * @returns 选中的选项文字内容
- */
-export const getSelectedLabels = (selectedValues: OptionItemProps | OptionItemProps[] | undefined): string[] => {
-   if (selectedValues === undefined) return [];
-   if (Array.isArray(selectedValues)) {
-      return selectedValues.map((option) => option.label);
-   }
-   return [selectedValues.label];
-};

package/src/utils/table.ts

@@ -25,8 +25,9 @@ interface TableColumn {
  */
 export const filterColumns = (columns: TableColumn[], toolCtl?: boolean) => {
    const userInfoStore = useUserInfo();
-
-   return columns.filter((column) => {
+   // 检查是否存在enabled:false的列
+   // 并且设置没有权限的列为enabled:false
+   const enabledColumns = columns.filter((column) => {
       // 角色权限检查
       if (column.role && !userInfoStore.hasRole(column.role)) {
          return false;
@@ -37,6 +38,18 @@ export const filterColumns = (columns: TableColumn[], toolCtl?: boolean) => {
          return false;
       }
 
+      if (column.enabled === false) {
+         return false;
+      }
+
+      if (typeof column.enabled === 'function') {
+         return column.enabled();
+      }
+
+      return true;
+   });
+
+   return enabledColumns.filter((column) => {
       if (!toolCtl) {
          // 可见性检查
          if (column.visible === false) {