@lingxiteam/ebe-utils 0.0.25 → 0.0.29

package/lib/pcpublic/src/utils/exportCustomData/index.tsx

@@ -0,0 +1,723 @@
+import engineServices from '@/services/api/engine';
+import { messageApi } from '@/utils/messageApi';
+import { exportFileShowProgress } from './tool';
+
+const SERVICE_SOURCE = {
+  // 服务来源
+  APP: 'app',
+  // 应用内部 & 模型生成
+  QUERY: 'query',
+  // 解析服务
+  STD: 'std',
+  // 编排服务
+  INNER: 'inner',
+  // 高代码服务
+  PLATFORM: 'platform',
+  // 平台服务
+  ATOM: 'atom',
+  // 外部服务(低代码运营平台的原子服务)
+  RHIN: 'rhin',
+  // 业务运营服务
+  SCENE: 'scene',
+  // 业务运营场景服务
+  OBJECT: 'object', // 业务对象生成服务
+};
+const SERVICE_CUSTOM_EXPORT_TYPE: any = {
+  query: 'customQuery', // 解析服务
+  std: 'orchestrationService', // 编排服务
+  rhin: 'externalQuery', // 外部服务(低代码运营平台的原子服务)
+  object: 'objectService', // 业务对象生成服务
+  inner: 'internalService', // 高代码服务
+  platform: 'platformService', // 平台服务
+};
+// 表头分组的处理保持与表格组件一致
+const treeRootName = 'tree-root';
+interface ExportItem {
+  // 服务类型
+  source: any;
+  // 导出字段列表
+  objectFields: string[];
+  // 配置态记录的导出字段的标题映射即excel表头的名称，
+  // 部分服务如：外部和内部，运行态不进行字段查询，无法获取到字段标题
+  nameMap: Record<string, string>;
+  // 导出字段的父节点字段，不以根节点root开头
+  parentCode?: string;
+  // 表头分组
+  customGroup: any[];
+  // 导出时入参
+  apiRequestSetParams?: any[];
+  exportType?: 'custom' | 'field' | 'temp';
+  objectFieldsCustom?: {
+    attrName: string;
+    attrCode: string;
+    fieldData: any[];
+    // 动态列导出字段对应的父节点，以根节点root开头
+    exportNode?: string;
+    [key: string]: any;
+  };
+  // 导出模板参数
+  objectFieldsTemp?: {
+    fileCode: string;
+    maxRowSize: number;
+    rows: any[];
+  };
+  // 是否是模板导出,由 exportType与objectFieldsTemp决定
+  isTemp?: boolean;
+  // 服务信息
+  serviceData?: any;
+  // 导出excel的子表表名
+  custSheetName?: string;
+  id: string;
+  // 是否是动态导出,由 exportType与objectFieldsCustom决定
+  isCustom?: boolean;
+  // 由apiRequestSetParams转化而来
+  parameters: any;
+  // 由serviceData中获取对应的服务id
+  objValue: string;
+  // 导出服务入参中的服务类型
+  objType: typeof SERVICE_CUSTOM_EXPORT_TYPE;
+}
+// 获取分组名称，为空的向下补全
+const findGroupName = (groupList: string[], startIndex: number) => {
+  const list = groupList.slice(startIndex);
+  return list.find((g) => !!g) || '';
+};
+
+const handleMergeHeader = <
+  T extends {
+    title?: string;
+    colSpanStart?: any;
+    colSpan?: number;
+    children?: T[];
+    isHidden?: boolean;
+  },
+>(
+  columns?: Array<T>,
+) => {
+  const getRowSpan = (col: T) => {
+    let span = 1;
+    const newCol = { ...col };
+    let current: T | null = newCol;
+    while (current !== null) {
+      if (current?.children?.length === 1) {
+        const next: T = current.children?.[0];
+        if (
+          next.title === col?.title &&
+          col?.title &&
+          !next.isHidden &&
+          (col?.colSpan || 1) === (next?.colSpan || 1)
+        ) {
+          // 分组名一致，上下合并
+          span += 1;
+          next.isHidden = true;
+          current = next;
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    return {
+      ...newCol,
+      rowSpan: span,
+    };
+  };
+  const recursive = (cols: T[]) => {
+    return cols.map((col) => {
+      const newCol = {
+        ...col,
+        // 禁止分组向下合并（T：禁止向下合并；默认不传值就正常合并）
+        forbiddenMergeDown: 'T',
+      };
+      if (newCol?.title) {
+        const { rowSpan } = getRowSpan(newCol);
+        if (rowSpan > 1) {
+          return {
+            ...newCol,
+            isHidden: undefined,
+            colSpanStart: undefined,
+            colSpan: undefined,
+            forbiddenMergeDown: undefined,
+          };
+        }
+      }
+      if (newCol.children) {
+        newCol.children = recursive(newCol.children);
+      }
+      delete newCol.colSpan;
+      delete newCol.isHidden;
+      delete newCol.colSpanStart;
+      return newCol;
+    });
+  };
+  return recursive(columns || []);
+};
+const appendColumnLevel = (columnParams: any) => {
+  const { maxLen, lastLevel, column } = columnParams || {};
+  const times = new Array(maxLen - lastLevel).fill('0');
+  const newColumn = { ...column };
+  // times.reduce(p => {
+  //   p.isRowSpan = 'T';
+  //   const col = { ...column, isRowSpan: 'T' };
+  //   // 非最后的导出列部分需要去掉key和index数据
+  //   delete p.key;
+  //   delete p.index;
+  //   p.children = [col];
+  //   return p.children[0];
+  // }, newColumn);
+  let cur = newColumn;
+  times.forEach(() => {
+    const col = { ...column };
+    // 非最后的导出列部分需要去掉key和index数据
+    delete cur.key;
+    delete cur.index;
+    cur.children = [col];
+    cur = cur.children[0];
+  });
+  return newColumn;
+};
+const filterSimpleType = (arr: any[], parCode = '') => {
+  let l = arr.filter(
+    (i) => !['object', 'array', 'objectArray'].includes(i.attrType),
+  );
+  if (parCode) {
+    // 编排服务导出字段的中文名，优先取描述，没有描述时再取编码
+    l = l.map((c) => ({ ...c, parentCode: parCode, name: c.name || c.code }));
+  }
+  return l;
+};
+const generateArrayNode = (attrs: any[], parentCode?: string) => {
+  let resList: any[] = [];
+  const attrParMap: any = {};
+  if (Array.isArray(attrs)) {
+    attrs.forEach((attr) => {
+      const code = parentCode ? `${parentCode}.${attr.code}` : attr.code;
+      attrParMap[code] = attr;
+      if (attr.children?.length) {
+        if (['array', 'objectArray'].includes(attr.attrType)) {
+          // 如果array类型的子元素是对象，则视为对象数组，取出对象的字段
+          const children =
+            attr.attrType === 'array' && attr.children[0]?.attrType === 'object'
+              ? attr.children[0]?.children
+              : attr.children;
+          resList = resList.concat(filterSimpleType(children, code) || []);
+        } else if (attr.attrType === 'object') {
+          const [res, attrMap] = generateArrayNode(attr.children, code) || [];
+          resList = resList.concat(res);
+          Object.assign(attrParMap, attrMap);
+        }
+      }
+    });
+  }
+  return [resList, attrParMap];
+};
+
+const handleMultiLevelHeader = (params: any) => {
+  const { column, leftTree, parentTreeNode, maxGroupLen } = params;
+  const { group } = params;
+  const groupLen = group.length;
+  if (Array.isArray(group) && groupLen > 0) {
+    // 标记右树从哪个节点开始至最后一个都为空(undefined/null/'')
+    let groupEmptyStartIndex = groupLen - 1;
+    while (
+      typeof group[groupEmptyStartIndex] === 'undefined' ||
+      group[groupEmptyStartIndex] === null ||
+      group[groupEmptyStartIndex] === ''
+    ) {
+      // 当分组数据遍历完成 或 下一个已经不为空时，退出循环
+      if (groupEmptyStartIndex - 1 < 0 || group[groupEmptyStartIndex - 1]) {
+        break;
+      }
+      // eslint-disable-next-line no-plusplus
+      groupEmptyStartIndex--;
+    }
+
+    // 构造右树（记录左树每一层的最后一个节点）:
+    let rightLevel = 1;
+    const rightTree = {
+      title: treeRootName,
+    };
+    const rightTreeLevelMap: any = {
+      0: rightTree,
+    };
+    let tempRightTree: any = rightTree;
+    // 从第一层开始，最后一层会接入列信息
+    while (rightLevel <= groupLen) {
+      // 从当前层到最后一层都为空时：直接接入列信息，并退出循环
+      if (
+        rightLevel === groupEmptyStartIndex + 1 &&
+        !group[groupEmptyStartIndex]
+      ) {
+        let col = column;
+        // 当最后一级时，为了拉平与其他分组的层级，需要补全列数据节点的层级
+        if (rightLevel < maxGroupLen) {
+          col = appendColumnLevel({
+            maxLen: maxGroupLen,
+            column,
+            lastLevel: rightLevel,
+          });
+        }
+        // 将列数据放入最后一层分组最后一个节点的children，即再加最后一层
+        tempRightTree.children = [col];
+        // 记录最最后一层
+        rightTreeLevelMap[rightLevel] = col;
+        break;
+      }
+
+      const rightTreeCurrLevelLast: any = {
+        title: findGroupName(group, rightLevel - 1), // 为空的话，强制设置为 ''
+        // parent: tempRightTree.title === treeRootName ? leftTree : tempRightTree,
+      };
+      // 当前层为第一层时，将parent指向左树的根节点，为后续合并做准备
+      parentTreeNode.set(
+        rightTreeCurrLevelLast,
+        tempRightTree.title === treeRootName ? leftTree : tempRightTree,
+      );
+      tempRightTree.children = [rightTreeCurrLevelLast];
+      tempRightTree = rightTreeCurrLevelLast;
+      rightTreeLevelMap[rightLevel] = rightTreeCurrLevelLast;
+      // eslint-disable-next-line no-plusplus
+      rightLevel++;
+
+      // 构造到最后一层分组时：接入列信息，并退出循环
+      if (rightLevel > groupLen) {
+        let col = column;
+        // 当最后一级时，为了拉平与其他分组的层级，需要补全列数据节点的层级
+        if (rightLevel < maxGroupLen) {
+          col = appendColumnLevel({
+            maxLen: maxGroupLen,
+            column,
+            lastLevel: rightLevel,
+          });
+        }
+        // 将列数据放入最后一层分组最后一个节点的children，即再加最后一层
+        rightTreeCurrLevelLast.children = [col];
+        // 记录最最后一层
+        rightTreeLevelMap[rightLevel] = col;
+        break;
+      }
+    }
+
+    // 分析左树（记录左树每一层的最后一个节点）：
+    let leftLevel = 0;
+    const leftTreeLevelMap = {
+      [leftLevel]: leftTree,
+    };
+    let leftTreeCurrLevelLast = leftTree;
+    // 遍历左树右边侧节点（生成数据结构记录节点情况）：
+    while (leftTreeCurrLevelLast?.children) {
+      // eslint-disable-next-line no-plusplus
+      leftLevel++;
+      const leftTreeCurrLevelLastChildren = leftTreeCurrLevelLast.children;
+      // 取左树当前层的最后一个
+      leftTreeCurrLevelLast =
+        leftTreeCurrLevelLastChildren[leftTreeCurrLevelLastChildren.length - 1];
+      leftTreeLevelMap[leftLevel] = leftTreeCurrLevelLast;
+    }
+
+    for (let i = 0; i <= groupLen; i += 1) {
+      const leftTreeLast = leftTreeLevelMap[i]; // 左树第i层的最后一个
+      const current = rightTreeLevelMap[i]; // 右树第 i 层的最后一个（唯一一个）
+      if (i === 0) {
+        if (!leftTreeLast.children) {
+          leftTreeLast.children = [];
+        }
+        leftTreeLast.children.push(...(current?.children || []));
+      } else if (current && current?.title === leftTreeLast?.title) {
+        current.colSpanStart = leftTreeLast?.colSpanStart || leftTreeLast;
+        const colSpan = current?.colSpanStart?.colSpan || 1;
+        current.colSpanStart.colSpan = colSpan + 1;
+        // 被合并的单元格隐藏
+        current.isHidden = true;
+      }
+      if (current) {
+        current.colSpan = 1;
+      }
+    }
+  }
+};
+
+const handleParseGroups = (params: any) => {
+  const { list, groupMap, nameMap } = params;
+  const keys = Object.keys(groupMap || {});
+  if (!groupMap || !keys?.length) {
+    // 分组为空时，不处理
+    return undefined;
+  }
+  const finalGroup: any = {};
+  // 实际层级数，包含列数据级
+  let maxGroupLevel = 1;
+  keys.forEach((k) => {
+    let group = groupMap[k];
+    // 兼容旧版的分组数据
+    if (typeof group === 'string') {
+      group = [group];
+    }
+    // 兼容可能存在的空数据
+    if (group === '' || group === null || group === undefined) {
+      group = [''];
+    }
+    // 过滤掉空的配置
+    // group = group.filter((g: any) => g);
+    // 保留一个空配置，以进入构造
+    group = group.length === 0 ? [''] : group;
+    maxGroupLevel = Math.max(maxGroupLevel, group.length + 1);
+    finalGroup[k] = group;
+  });
+  // 用于表格头分组的数据结构：左树根节点，为第0层
+  const leftTree: any = {
+    title: treeRootName,
+  };
+  // 记录子级对应的父级
+  const parentTreeNode = new WeakMap();
+  list.forEach((col: any, i: number) => {
+    const group = finalGroup[col];
+    handleMultiLevelHeader({
+      leftTree,
+      column: { title: nameMap[col], key: col, index: col?.sort || i },
+      group,
+      parentTreeNode,
+      maxGroupLen: maxGroupLevel,
+    });
+  });
+  if (leftTree?.children?.length) {
+    return handleMergeHeader([...leftTree?.children]);
+  }
+  // 为空时不传出分组字段
+  return undefined;
+};
+const getResponseAttr = (response: {
+  code: string;
+  attrType: string;
+  children: any[];
+}) => {
+  let list: any[] = [];
+  const attrParMap: any = {};
+  const responseType = response.code === 'root' ? response.attrType : 'object';
+  if (response.code === 'root') {
+    attrParMap.root = response;
+  }
+  const responseAttrs = response.children;
+  if (responseType === 'object') {
+    const [res, attrMap] = generateArrayNode(responseAttrs, '');
+    list = list.concat(res);
+    Object.assign(attrParMap, attrMap);
+  } else if (['objectArray', 'array'].includes(responseType)) {
+    const children =
+      response.attrType === 'array' &&
+      response.children[0]?.attrType === 'object'
+        ? response.children[0]?.children
+        : responseAttrs;
+    list = filterSimpleType(children, '');
+  }
+  return { list, attrParMap };
+};
+// 根据配置态勾选的导出项，进行导出参数的组装
+const getExportColumns = (
+  item: ExportItem,
+  resultList: any,
+): Record<string, any> => {
+  const {
+    source,
+    objectFields,
+    nameMap,
+    parentCode,
+    isCustom,
+    isTemp,
+    objectFieldsTemp,
+    customGroup,
+  } = item;
+  let columns: Record<string, any> = {};
+  // 记录最新的字段和名称映射，分组表头组装时需要
+  const colNameMap = { ...nameMap };
+  switch (source) {
+    case SERVICE_SOURCE.OBJECT: {
+      const cols: any[] = [];
+      resultList.forEach((item: any) => {
+        const data = { ...item };
+        objectFields.forEach((field: any, index: any) => {
+          if (field === data.attrCode) {
+            colNameMap[data.attrCode] = data.attrName || data.attrCode;
+            if (isCustom) {
+              // 动态列导出的时候以动态列配置的字段名称解析结果为准
+              data.attrName = nameMap[data.attrCode] || data.attrName;
+            }
+            data.sort = index;
+            cols.push(data);
+          }
+        });
+      });
+      columns.pickRows = cols;
+      break;
+    }
+    case SERVICE_SOURCE.STD: {
+      const { list, attrParMap } = resultList;
+      let parent: any;
+      let parentChildren: any[] = [];
+      const listMap: any = {};
+      list.forEach((item: any) => {
+        const code = item.parentCode
+          ? `${item.parentCode}.${item.code}`
+          : item.code;
+        listMap[code] = item;
+      });
+      // 编排类服务需要前端排序
+      objectFields.forEach((field: string | number, index: any) => {
+        if (listMap[field]) {
+          const data = { ...listMap[field] };
+          if (!parent) {
+            parent = attrParMap[data.parentCode];
+            parent.children = [];
+            parentChildren = parent.children;
+            const parentList = data.parentCode.split('.');
+            if (parentList?.length) {
+              parentList.pop();
+              // 找到所有根节点,支持多层级对象下的数组节点的导出
+              parent = parentList.reduce((p: any, _: any, i: number) => {
+                const code = parentList
+                  .slice(0, parentList?.length - i)
+                  .join('.');
+                const attr = attrParMap[code];
+                const newParent = {
+                  ...attr,
+                  children: [p],
+                };
+                return newParent;
+              }, parent);
+            }
+          }
+          colNameMap[data.code] = data.name || data.code;
+          if (isCustom) {
+            // 动态列导出的时候以动态列配置的字段名称解析结果为准
+            data.name = nameMap[field];
+          }
+          data.sort = index;
+          parentChildren.push(data);
+        }
+      });
+      columns.pickColumns = parent ? [parent] : [];
+      break;
+    }
+    case SERVICE_SOURCE.RHIN:
+    case SERVICE_SOURCE.INNER:
+    case SERVICE_SOURCE.PLATFORM: {
+      // 外部集成类由于无法在运行态调用接口获取字段参数，只能在配置态记录对应字段名称
+      let cols: any[] = [];
+      const list: any[] = [];
+      objectFields.forEach((c: string, index: any) => {
+        const fields = c?.split('.');
+        list.push({
+          code: fields?.length > 1 ? fields[fields.length - 1] : c,
+          name: nameMap[c],
+          sort: index,
+        });
+      });
+      // 高代码服务和平台服务的字段使用配置时记录的名称映射
+      if (
+        parentCode ||
+        source === SERVICE_SOURCE.INNER ||
+        source === SERVICE_SOURCE.PLATFORM
+      ) {
+        const exportNode = (parentCode || '').split('.');
+        cols = exportNode.reverse().reduce((p: any, n: any, i: number) => {
+          const code = exportNode.slice(1, exportNode?.length - i).join('.');
+          if (i === 0) {
+            return [
+              {
+                code: n,
+                attrType: 'objectArray',
+                name: nameMap[code],
+                children: p,
+              },
+            ];
+          }
+          return [
+            {
+              code: n,
+              attrType: 'object',
+              name: nameMap[code] || n,
+              children: p,
+            },
+          ];
+        }, list);
+      } else {
+        cols = list;
+      }
+      if (parentCode) {
+        Object.keys(colNameMap).forEach((col) => {
+          if (col.includes(parentCode)) {
+            const key: string = col.split('.').pop() || '';
+            colNameMap[key] = colNameMap[col];
+          }
+        });
+      }
+      columns.pickColumns = cols;
+      break;
+    }
+    // SQL查询类服务
+    default: {
+      const fields = objectFields.map((c: any) => {
+        const code = c?.split('.') || [];
+        if (code?.length > 1) {
+          return code.pop();
+        }
+        return c;
+      });
+      const cols: any[] = [];
+      resultList.forEach((item: any) => {
+        const data = { ...item };
+        fields.forEach((field: any, index: any) => {
+          if (field === data.code) {
+            if (isCustom) {
+              // 动态列导出的时候以动态列配置的字段名称解析结果为准
+              data.name = nameMap[data.code] || data.name;
+            }
+            data.sort = index;
+            cols.push(data);
+          }
+        });
+      });
+      columns.pickColumns = cols;
+      break;
+    }
+  }
+  if (!isCustom && customGroup && Object.keys(customGroup)?.length > 0) {
+    // 多级出参中会记录父节点，获取分组时需要去掉父节点部分，只保留数据编码
+    let list: any[] = objectFields;
+    if (parentCode) {
+      list = list.map((col) => {
+        const code = col?.split('.');
+        if (code?.length > 1) {
+          return code.pop();
+        }
+        return code;
+      });
+    }
+    // 配置了表头分组规则的，进行头部分组组装
+    columns.groups = handleParseGroups({
+      list,
+      groupMap: customGroup,
+      nameMap: colNameMap,
+    });
+  }
+  if (isTemp && objectFieldsTemp && Object.keys(objectFieldsTemp)?.length > 0) {
+    columns = {
+      ...columns,
+      ...objectFieldsTemp,
+    };
+  }
+  return columns;
+};
+type ExportPathMapType = Record<'sql' | 'object' | 'multiExport', string>;
+const exportPathMap: ExportPathMapType = {
+  sql: engineServices.exportSqlDatasApiPath(),
+  object: engineServices.exportInstsApiPath(),
+  multiExport: engineServices.exportMultiServiceResultPath(),
+};
+const exportCustomData = (
+  exportSheet: any = [],
+  custFileName: any,
+  selectedKeyMap: { [x: string]: any },
+  async: string,
+) => {
+  // 获取到的服务出参列表
+  const selectedRowMap: any = {};
+  messageApi.loading('正在导出中，请稍候...', 0);
+  try {
+    const columnsReq = Object.keys(selectedKeyMap).map((type) => {
+      if (!selectedKeyMap[type] || !selectedKeyMap[type]?.length) {
+        return undefined;
+      }
+      // 获取不同类型服务的出参列表
+      let req;
+      if (type === SERVICE_SOURCE.QUERY) {
+        // SQL类型
+        req = engineServices
+          .getSqlQueryColumnsList({
+            serviceCodes: selectedKeyMap[type].join(','),
+          })
+          .then((res: any) => {
+            const m: any = {};
+            (res || []).forEach((c: any) => (m[c.serviceCode] = c.rowColumns));
+            return m;
+          });
+      }
+      if (type === SERVICE_SOURCE.OBJECT) {
+        // 对象类型
+        req = engineServices
+          .queryBusiObjectRowColumnsList({
+            busiObjectIds: selectedKeyMap[type].join(','),
+          })
+          .then((res: any) => {
+            const m: any = {};
+            (res || []).forEach((c: any) => (m[c.busiObjectId] = c.rowColumns));
+            return m;
+          });
+      }
+      if (type === SERVICE_SOURCE.STD) {
+        // 编排类服务
+        // @ts-ignore
+        req = engineServices
+          .queryServiceResponseColumnsList({
+            serviceVersionIds: (selectedKeyMap[type] || []).join(','),
+            appId: APPID,
+          })
+          .then((res: any) => {
+            const m: any = {};
+            (res || []).forEach(
+              (c: any) => (m[c.serviceVersionId] = getResponseAttr(c.response)),
+            );
+            return m;
+          });
+      }
+      if (req) {
+        req?.then((r: any) => {
+          selectedRowMap[type] = r;
+        });
+      }
+      return req;
+    });
+    Promise.all(columnsReq).then(async () => {
+      const sheetItemList = exportSheet;
+      const serviceExecuteParams = sheetItemList.map((sheet: ExportItem) => {
+        const { parameters, objValue, objType, custSheetName, source } = sheet;
+        const resultList = (selectedRowMap[source] || {})[objValue] || [];
+        const columns = getExportColumns(sheet, resultList);
+        return {
+          objValue,
+          objType,
+          parameters,
+          sheetName: custSheetName,
+          ...columns,
+        };
+      });
+      const exportFileName = custFileName;
+      const fileName = `${exportFileName}.xlsx`;
+      const downloadIndex = `${fileName}_${Math.random()}`;
+      await exportFileShowProgress?.({
+        downloadIndex,
+        fileName,
+        methodType: 'POST',
+        fileOrigin: 'multiExport',
+        async,
+        params: {
+          serviceExecuteParams,
+          fileName,
+        },
+        onSuccess: () => {
+          messageApi.destroy();
+        },
+        onFail: () => {
+          messageApi.destroy();
+          messageApi.error('导出失败');
+        },
+      });
+    });
+  } catch {
+    messageApi.destroy();
+    messageApi.error('导出失败');
+  }
+};
+
+export default exportCustomData;