@skyfox2000/webui 1.0.13 → 1.2.0

package/src/utils/form-excel.ts

@@ -0,0 +1,523 @@
+import Validator, { ValidateError } from 'async-validator';
+
+import { httpPost, IUrlInfo, ResStatus } from '@skyfox2000/fapi';
+import { isEmpty } from './isEmpty';
+
+import message from 'vue-m-message';
+import { ValidateRule } from '@/typings/form';
+import { validMessages } from './form-validate';
+
+/**
+ * Excel数据处理需要标记的单元格
+ */
+export type ExcelMarkCell = {
+   row: number;
+   col: number;
+   color?: string;
+};
+
+/**
+ * Excel标记类型
+ */
+export type ExcelMarkInfo = {
+   markCells: ExcelMarkCell[];
+   markHeaders?: string[];
+};
+
+/**
+ * 处理Excel文件的通用函数，用于提取表头和数据
+ * @param excelBuffer Excel文件的ArrayBuffer
+ * @returns 包含工作簿、工作表、表头和数据的对象
+ */
+export const processExcelFile = async (excelBuffer: ArrayBuffer) => {
+   // 动态导入 exceljs
+   const ExcelJS = await import('exceljs');
+   const workbook = new ExcelJS.Workbook();
+   await workbook.xlsx.load(excelBuffer);
+
+   // 获取第一个工作表
+   const worksheet = workbook.worksheets[0];
+   if (!worksheet) {
+      message.error('Excel文件不包含工作表');
+      return null;
+   }
+
+   // 提取表头和数据
+   const headers: string[] = [];
+   const excelData: Record<string, 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);
+         }
+      }
+      headers.push(headerValue);
+   });
+
+   // 提取数据行
+   worksheet.eachRow((row, rowNumber) => {
+      if (rowNumber > 1) {
+         // 跳过表头
+         const rowData: Record<string, 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;
+               }
+            }
+         });
+         excelData.push(rowData);
+      }
+   });
+
+   return { workbook, worksheet, headers, excelData };
+};
+
+/**
+ * 生成标记了错误/重复数据的Excel文件
+ * @param excelBuffer 原始Excel文件的ArrayBuffer
+ * @param markInfo 标记信息，包含要标记的单元格和表头
+ * @returns 标记后的Excel文件Blob
+ */
+export const createMarkedExcelBlob = async (
+   excelBuffer: ArrayBuffer,
+   markInfo: ExcelMarkInfo,
+): Promise<{
+   hasError: boolean;
+   errBlob?: Blob;
+}> => {
+   const ExcelJS = await import('exceljs');
+   // 处理Excel文件
+   const excelData = await processExcelFile(excelBuffer);
+   if (!excelData) return { hasError: true };
+
+   const { worksheet, headers: originalHeaders } = excelData;
+   const { markCells, markHeaders } = markInfo;
+
+   if (markCells.length === 0 && (!markHeaders || markHeaders.length === 0)) {
+      return { hasError: false }; // 没有需要标记的内容
+   }
+
+   // 处理缺失字段，将缺失字段添加到headers中
+   const headers = [...originalHeaders];
+   if (markHeaders && markHeaders.length > 0) {
+      markHeaders.forEach((field) => {
+         if (!headers.includes(field)) {
+            headers.push(field);
+         }
+      });
+   }
+
+   // 创建一个新的工作簿和工作表
+   const newWorkbook = new ExcelJS.Workbook();
+   const newWorksheet = newWorkbook.addWorksheet('Sheet1');
+
+   // 默认列宽
+   const defaultColumnWidth = 15;
+
+   // 创建错误单元格位置的查询表，用于快速检查
+   const cellMarkMap = new Map<string, string>();
+   markCells.forEach(({ row, col, color }) => {
+      const cellKey = `${row}-${col}`;
+      cellMarkMap.set(cellKey, color || 'FFFF0000'); // 默认红色
+   });
+
+   // 复制列宽并应用于新工作表
+   for (let i = 0; i < headers.length; i++) {
+      const column = newWorksheet.getColumn(i + 1);
+
+      if (i < worksheet.columnCount && i < originalHeaders.length) {
+         const originalCol = worksheet.getColumn(i + 1);
+         if (originalCol && originalCol.width) {
+            column.width = originalCol.width;
+         } else {
+            column.width = defaultColumnWidth;
+         }
+      } else {
+         column.width = defaultColumnWidth;
+      }
+   }
+
+   // 复制表头行
+   const headerRow = newWorksheet.getRow(1);
+   headers.forEach((header, index) => {
+      const headerCell = headerRow.getCell(index + 1);
+      headerCell.value = header;
+
+      const isOriginalHeader = index < originalHeaders.length;
+      if (isOriginalHeader && index < worksheet.columnCount) {
+         // 复制原表头样式
+         const originalCell = worksheet.getRow(1).getCell(index + 1);
+
+         // 复制样式
+         if (originalCell.style) headerCell.style = JSON.parse(JSON.stringify(originalCell.style));
+         if (originalCell.font) headerCell.font = JSON.parse(JSON.stringify(originalCell.font));
+         if (originalCell.alignment) headerCell.alignment = JSON.parse(JSON.stringify(originalCell.alignment));
+         if (originalCell.border) headerCell.border = JSON.parse(JSON.stringify(originalCell.border));
+         if (originalCell.numFmt) headerCell.numFmt = originalCell.numFmt;
+         if (originalCell.fill) headerCell.fill = JSON.parse(JSON.stringify(originalCell.fill));
+      }
+
+      // 仅标记缺失的表头字段，不标记数据重复的表头
+      if (markHeaders && markHeaders.includes(header) && !isOriginalHeader) {
+         headerCell.fill = {
+            type: 'pattern',
+            pattern: 'solid',
+            fgColor: { argb: 'FFFF0000' }, // 红色背景
+         };
+
+         // 添加白色文字
+         headerCell.font = {
+            name: 'Arial',
+            size: 10,
+            bold: true,
+            color: { argb: 'FFFFFFFF' }, // 白色文字
+         };
+      }
+   });
+   headerRow.commit();
+
+   // 处理数据行
+   worksheet.eachRow((row, rowNumber) => {
+      if (rowNumber > 1) {
+         // 跳过表头行
+         const newRow = newWorksheet.getRow(rowNumber);
+
+         // 使用表头长度来循环每个单元格
+         for (let colIndex = 0; colIndex < headers.length; colIndex++) {
+            const newCell = newRow.getCell(colIndex + 1);
+            const isOriginalHeader = colIndex < originalHeaders.length;
+
+            if (isOriginalHeader && colIndex < worksheet.columnCount) {
+               // 对原始数据中存在的列
+               const originalCell = row.getCell(colIndex + 1);
+
+               // 复制值
+               newCell.value = originalCell.value;
+
+               // 处理对象类型的单元格值，确保正确显示
+               if (newCell.value !== null && newCell.value !== undefined && typeof newCell.value === 'object') {
+                  // 对于RichText，保留原格式
+                  if (
+                     !('richText' in newCell.value) &&
+                     !('formula' in newCell.value) &&
+                     !('hyperlink' in newCell.value) &&
+                     !(newCell.value instanceof Date)
+                  ) {
+                     // 尝试转换为字符串显示
+                     try {
+                        if ('text' in newCell.value && typeof newCell.value.text === 'string') {
+                           newCell.value = newCell.value.text;
+                        } else {
+                           // 其他对象类型尝试JSON序列化
+                           newCell.value = JSON.stringify(newCell.value);
+                        }
+                     } catch {
+                        // 如果转换失败，使用toString
+                        newCell.value = String(newCell.value);
+                     }
+                  }
+               }
+
+               // 复制样式
+               if (originalCell.style) newCell.style = JSON.parse(JSON.stringify(originalCell.style));
+               if (originalCell.font) newCell.font = JSON.parse(JSON.stringify(originalCell.font));
+               if (originalCell.alignment) newCell.alignment = JSON.parse(JSON.stringify(originalCell.alignment));
+               if (originalCell.border) newCell.border = JSON.parse(JSON.stringify(originalCell.border));
+               if (originalCell.numFmt) newCell.numFmt = originalCell.numFmt;
+               if (originalCell.fill) newCell.fill = JSON.parse(JSON.stringify(originalCell.fill));
+
+               // 检查是否为需要标记的单元格
+               const cellKey = `${rowNumber}-${colIndex + 1}`;
+               if (cellMarkMap.has(cellKey)) {
+                  // 设置背景颜色
+                  newCell.fill = {
+                     type: 'pattern',
+                     pattern: 'solid',
+                     fgColor: { argb: cellMarkMap.get(cellKey) },
+                  };
+               }
+            } else {
+               // 为新增列设置空值
+               newCell.value = null;
+            }
+         }
+
+         // 复制行属性
+         if (row.height) newRow.height = row.height;
+         if (row.outlineLevel) newRow.outlineLevel = row.outlineLevel;
+
+         newRow.commit();
+      }
+   });
+
+   // 生成Excel文件Buffer
+   const excelOutput = await newWorkbook.xlsx.writeBuffer();
+
+   // 创建Blob对象
+   const excelBlob = new Blob([excelOutput], {
+      type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+   });
+
+   return { hasError: true, errBlob: excelBlob };
+};
+
+/**
+ * 验证Excel数据
+ * @param excelBuffer Excel数据
+ * @param rules 规则
+ * @returns 验证结果
+ */
+export const validateExcel = async (
+   excelBuffer: ArrayBuffer,
+   rules?: Record<string, ValidateRule>,
+): Promise<{
+   hasError: boolean;
+   errBlob?: Blob;
+}> => {
+   if (!rules || isEmpty(rules)) {
+      return { hasError: false };
+   }
+
+   // 处理Excel文件
+   const excelData = await processExcelFile(excelBuffer);
+   if (!excelData) return { hasError: true };
+
+   const { headers, excelData: excelJson } = excelData;
+
+   // 检查rules中的字段是否在表头中存在
+   const missingFields: string[] = [];
+   Object.keys(rules).forEach((field) => {
+      if (!headers.includes(field)) {
+         missingFields.push(field);
+      }
+   });
+
+   if (headers.length === 0 || excelJson.length === 0) {
+      message.error('Excel文件不包含足够的数据');
+      return { hasError: true };
+   }
+
+   // 设置验证器
+   const validator = new Validator({});
+   validator.messages(validMessages.messages());
+   validator.define(rules);
+
+   // 验证数据（仅验证非缺失字段）
+   const validationErrors = await validateExcelData(headers, excelJson, validator);
+
+   // 如果有验证错误或缺失字段，标记错误单元格和表头
+   if (validationErrors.length > 0 || missingFields.length > 0) {
+      // 准备需要标记的单元格
+      const markCells = validationErrors.map((error) => ({
+         row: error.row + 2, // 转为Excel行号（+2是因为表头占一行，且是1-based索引）
+         col: error.col + 1, // 转为Excel列号（+1是因为是1-based索引）
+         color: 'FFFF0000', // 红色
+      }));
+
+      // 创建标记过的Excel文件，确保传入所有表头（包括缺失的）
+      return createMarkedExcelBlob(excelBuffer, {
+         markCells,
+         markHeaders: missingFields,
+      });
+   }
+
+   return { hasError: false }; // 没有错误时返回null
+};
+
+type ExcelValidationError = ValidateError & {
+   row: number;
+   col: number;
+   header: string;
+};
+
+// 保留原有的validateExcelData方法，但根据规则进行调整
+const validateExcelData = async (headers: string[], excelJson: Record<string, any>[], validator: Validator) => {
+   const validationErrors: ExcelValidationError[] = [];
+
+   // 遍历数据行
+   for (let i = 0; i < excelJson.length; i++) {
+      const rowData = excelJson[i];
+
+      try {
+         // 验证行数据
+         await validator.validate(rowData).catch(({ errors }) => {
+            // 记录验证错误，过滤掉重复的错误
+            const rowErrors: ExcelValidationError[] = [];
+
+            errors.forEach((err: any) => {
+               // 确保只有当列索引有效时才添加到验证错误中
+               const colIndex = headers.indexOf(err.field);
+               if (colIndex >= 0) {
+                  // 检查是否已经有相同位置的错误
+                  const exists = rowErrors.some((e) => e.row === i && e.col === colIndex);
+
+                  if (!exists) {
+                     rowErrors.push({
+                        row: i,
+                        col: colIndex,
+                        header: err.field,
+                        message: err.message.replace('${label}', headers[colIndex]),
+                     });
+                  }
+               }
+            });
+
+            validationErrors.push(...rowErrors);
+         });
+      } catch (error) {
+         console.error('验证表格数据时发生错误:', error);
+         message.error('验证表格数据时发生错误:' + error);
+      }
+   }
+
+   return validationErrors;
+};
+
+/**
+ * 检测Excel数据重复项
+ * @param excelBuffer Excel文件的ArrayBuffer
+ * @param duplicateRules 重复规则配置，字段名数组，必须在这些字段组合上唯一
+ * @returns 如果有重复项，返回标记了重复项的Excel Blob，否则返回null
+ */
+export const checkExcelDuplicates = async (
+   excelBuffer: ArrayBuffer,
+   duplicateRules: string[],
+   url?: IUrlInfo,
+): Promise<{
+   hasError: boolean;
+   errBlob?: Blob;
+}> => {
+   if (!duplicateRules || duplicateRules.length === 0) {
+      return { hasError: false };
+   }
+
+   // 处理Excel文件
+   const excelData = await processExcelFile(excelBuffer);
+   if (!excelData) return { hasError: true };
+
+   const { headers, excelData: rows } = excelData;
+
+   // 检查duplicateRules中的字段是否在表头中存在
+   const missingDuplicateFields: string[] = [];
+   duplicateRules.forEach((field) => {
+      if (!headers.includes(field)) {
+         missingDuplicateFields.push(field);
+      }
+   });
+
+   if (missingDuplicateFields.length > 0) {
+      message.error(`表头缺少重复检测所需字段: ${missingDuplicateFields.join(', ')}`);
+      return { hasError: true };
+   }
+
+   // 检测重复行
+   const uniqueValues = new Map<string, number>(); // 记录唯一键和它第一次出现的行索引
+   const duplicateIndices = new Set<number>(); // 记录所有重复行的索引
+   const allKeys = new Array<string>();
+
+   rows.forEach((rowData, index) => {
+      // 构建唯一键，将所有重复规则字段的值连接起来
+      const uniqueKey = duplicateRules.map((field) => rowData[field]).join('|');
+      allKeys.push(uniqueKey);
+
+      if (uniqueValues.has(uniqueKey)) {
+         // 找到重复行，记录当前索引和第一次出现的索引
+         duplicateIndices.add(index); // 添加当前重复行
+         duplicateIndices.add(uniqueValues.get(uniqueKey)!); // 添加第一次出现的行
+      } else {
+         uniqueValues.set(uniqueKey, index);
+      }
+   });
+
+   if (url) {
+      const duplicateRows = await httpPost(url, {
+         Data: allKeys,
+      });
+      if (duplicateRows?.data) {
+         (duplicateRows.data as number[]).forEach((index) => {
+            duplicateIndices.add(index);
+         });
+      }
+      if (duplicateRows?.status === ResStatus.ERROR) {
+         throw new Error(duplicateRows.msg);
+      }
+   }
+
+   // 如果有重复行，标记这些行中的重复字段
+   if (duplicateIndices.size > 0) {
+      // 准备需要标记的单元格
+      const markCells: Array<{ row: number; col: number; color: string }> = [];
+
+      // 对于所有重复行，标记其中的重复字段列
+      duplicateIndices.forEach((rowIndex) => {
+         duplicateRules.forEach((field) => {
+            const colIndex = headers.indexOf(field);
+            if (colIndex >= 0) {
+               markCells.push({
+                  row: rowIndex + 2, // Excel行号 = 数组索引 + 2（表头和1-based索引）
+                  col: colIndex + 1, // Excel列号 = 数组索引 + 1（1-based索引）
+                  color: 'FFFF0000', // 红色
+               });
+            }
+         });
+      });
+
+      // 创建标记过的Excel文件
+      return createMarkedExcelBlob(excelBuffer, { markCells, markHeaders: missingDuplicateFields });
+   }
+
+   return { hasError: false }; // 没有重复数据
+};