@bit-sun/business-component 4.2.0-alpha.28 → 4.2.0-alpha.29

package/src/components/Business/ImportExport/index.tsx

@@ -0,0 +1,170 @@
+import React, { useCallback, useMemo, useState } from 'react';
+import { Button, Space, message } from 'antd';
+import ExportButton from './ExportButton';
+import ImportWizard from './ImportWizard';
+import TaskDrawer from './TaskDrawer';
+import TaskProgress from './TaskProgress';
+import type {
+  FileTask,
+  ImportExportActionsProps,
+  ImportExportOperationType,
+  ImportExportRequestContext,
+} from './types';
+import { createRequestContext } from './types';
+import { resolveBusinessFunctionCode } from './businessFunction';
+import { resolveImportExportServices } from './services/importExport';
+import { authFunc } from '@/utils';
+
+const BUSINESS_FUNCTION_UNAVAILABLE =
+  '业务功能未配置或已停用，请联系管理员维护业务功能档案';
+
+/**
+ * 统一承载导入、快速导出、模板导出和文件任务入口。
+ */
+export const ImportExportActions: React.FC<ImportExportActionsProps> = ({
+  config,
+  services: serviceOverrides,
+  importCode,
+  quickExportCode,
+  templateExportCode,
+  taskCenterPath = '/configure/importExport/taskCenter',
+  showTaskDrawer = true,
+  onNavigateTaskCenter,
+}) => {
+  const [importVisible, setImportVisible] = useState(false);
+  const [importRouteLoading, setImportRouteLoading] = useState(false);
+  const [importContext, setImportContext] =
+    useState<ImportExportRequestContext>();
+  const [tasks, setTasks] = useState<FileTask[]>([]);
+  const services = useMemo(
+    () => resolveImportExportServices(serviceOverrides),
+    [serviceOverrides],
+  );
+  const showImport = !!authFunc(importCode);
+  const showQuickExport = !!authFunc(quickExportCode);
+  const showTemplateExport = !!authFunc(templateExportCode);
+  const authCodes = {
+    importCode,
+    quickExportCode,
+    templateExportCode,
+  };
+  const taskBusinessFunctionCodes = Array.from(
+    new Set(
+      [
+        resolveBusinessFunctionCode('IMPORT', authCodes),
+        resolveBusinessFunctionCode('EXPORT', authCodes),
+      ].filter(Boolean),
+    ),
+  );
+
+  /**
+   * 解析当前操作使用的业务功能和服务上下文。
+   */
+  const resolveRequestContext = async (
+    operationType: ImportExportOperationType,
+  ) => {
+    const businessFunctionCode = resolveBusinessFunctionCode(
+      operationType,
+      authCodes,
+    );
+    if (!businessFunctionCode) {
+      message.warning(BUSINESS_FUNCTION_UNAVAILABLE);
+      return undefined;
+    }
+    try {
+      const response = await services.resolveBusinessFunction(
+        businessFunctionCode,
+      );
+      const resolved = response?.data?.data || response?.data || response;
+      if (!resolved?.serviceContext || Number(resolved.status) !== 1) {
+        throw new Error(BUSINESS_FUNCTION_UNAVAILABLE);
+      }
+      return createRequestContext(
+        config,
+        businessFunctionCode,
+        resolved.serviceContext as string,
+        operationType,
+      );
+    } catch (error) {
+      message.warning(BUSINESS_FUNCTION_UNAVAILABLE);
+      return undefined;
+    }
+  };
+
+  const openImport = async () => {
+    setImportRouteLoading(true);
+    try {
+      const context = await resolveRequestContext('IMPORT');
+      if (!context) return;
+      setImportContext(context);
+      setImportVisible(true);
+    } finally {
+      setImportRouteLoading(false);
+    }
+  };
+
+  const addTask = useCallback((task: FileTask) => {
+    if (!task?.taskId) return;
+    setTasks((items) => [
+      task,
+      ...items.filter((item) => item.taskId !== task.taskId),
+    ]);
+  }, []);
+
+  return (
+    <>
+      <Space>
+        {showImport && (
+          <Button loading={importRouteLoading} onClick={openImport}>
+            导入
+          </Button>
+        )}
+        {(showQuickExport || showTemplateExport) && (
+          <ExportButton
+            config={config}
+            services={services}
+            resolveRequestContext={() => resolveRequestContext('EXPORT')}
+            showQuickExport={showQuickExport}
+            showTemplateExport={showTemplateExport}
+            onTaskCreated={addTask}
+          />
+        )}
+        {showTaskDrawer && (
+          <TaskDrawer
+            businessFunctionCodes={taskBusinessFunctionCodes}
+            services={services}
+            taskCenterPath={taskCenterPath}
+            onNavigateTaskCenter={onNavigateTaskCenter}
+          />
+        )}
+      </Space>
+      {importContext && (
+        <ImportWizard
+          visible={importVisible}
+          context={importContext}
+          documentName={config.documentName}
+          services={services}
+          onClose={() => setImportVisible(false)}
+          onTaskCreated={addTask}
+        />
+      )}
+      <TaskProgress
+        tasks={tasks}
+        services={services}
+        taskCenterPath={taskCenterPath}
+        onNavigateTaskCenter={onNavigateTaskCenter}
+        onTaskUpdated={addTask}
+        onClose={() => setTasks([])}
+      />
+    </>
+  );
+};
+
+export { default as ImportWizard } from './ImportWizard';
+export { default as ExportButton } from './ExportButton';
+export { default as TaskProgress } from './TaskProgress';
+export { default as TaskDrawer } from './TaskDrawer';
+export * from './types';
+export * from './services/importExport';
+export * from './sceneCapability';
+export * from './businessFunction';

package/src/components/Business/ImportExport/sceneCapability.ts

@@ -0,0 +1,28 @@
+/**
+ * 导入导出场景能力开关。
+ */
+export interface SceneCapabilityConfig {
+  multiSheet?: boolean;
+  horizontalExport?: boolean;
+  largeFile?: boolean;
+}
+
+/**
+ * 判断是否启用多工作表能力。
+ */
+export const isMultiSheetEnabled = (config?: SceneCapabilityConfig): boolean =>
+  config?.multiSheet === true;
+
+/**
+ * 判断是否启用横向导出能力。
+ */
+export const isHorizontalExportEnabled = (
+  config?: SceneCapabilityConfig,
+): boolean => config?.horizontalExport === true;
+
+/**
+ * 判断是否启用大文件导出能力。
+ */
+export const isLargeFileExportEnabled = (
+  config?: SceneCapabilityConfig,
+): boolean => config?.largeFile === true;

package/src/components/Business/ImportExport/services/importExport.ts

@@ -0,0 +1,208 @@
+import { request as umiRequest } from 'umi';
+import type { ImportExportRequest, ImportExportServices } from '../types';
+import { buildSdkUrl } from './routing';
+export { buildSdkUrl, normalizeServiceContext } from './routing';
+
+const CONFIG_PREFIX = '/basic/import-export';
+const BUSINESS_FUNCTION_PREFIX = '/basic/business-functions';
+const OSS_UPLOAD_URL = '/basic/upload';
+
+export const concurrentLimitCode = 'IE-COM-CONCURRENT-FILE-LIMIT';
+
+/**
+ * 使用业务项目提供的请求函数创建完整导入导出服务。
+ *
+ * 请求函数由消费方注入，以复用其鉴权、租户和异常处理拦截器。
+ */
+export const createImportExportServices = (
+  request: ImportExportRequest,
+  overrides: Partial<ImportExportServices> = {},
+): ImportExportServices => {
+  if (typeof request !== 'function') {
+    throw new Error('创建导入导出服务时必须提供请求函数');
+  }
+
+  const services: ImportExportServices = {
+    resolveBusinessFunction: (businessFunctionCode) =>
+      request(
+        `${BUSINESS_FUNCTION_PREFIX}/${encodeURIComponent(
+          businessFunctionCode,
+        )}/resolve`,
+        { method: 'GET' },
+      ),
+    queryTemplates: (data) =>
+      request(`${CONFIG_PREFIX}/templates/query`, {
+        method: 'POST',
+        data,
+      }),
+    queryTemplateFields: (data) =>
+      request(`${CONFIG_PREFIX}/fields/candidates`, {
+        method: 'POST',
+        data,
+      }),
+    uploadFile: (file) => {
+      const formData = new FormData();
+      formData.append('file', file);
+      return request(OSS_UPLOAD_URL, { method: 'POST', data: formData });
+    },
+    downloadTemplate: (templateCode, data) =>
+      request(
+        `${CONFIG_PREFIX}/templates/${encodeURIComponent(
+          templateCode,
+        )}/download`,
+        {
+          method: 'GET',
+          params: data,
+          responseType: 'blob',
+        },
+      ),
+    previewImport: (serviceContext, data) =>
+      request(buildSdkUrl(serviceContext, '/imports/preview'), {
+        method: 'POST',
+        data,
+      }),
+    executeImport: (serviceContext, data) =>
+      request(buildSdkUrl(serviceContext, '/imports/execute'), {
+        method: 'POST',
+        data,
+      }),
+    downloadValidationErrorFile: (serviceContext, data) =>
+      request(buildSdkUrl(serviceContext, '/imports/error-file'), {
+        method: 'POST',
+        data,
+      }),
+    quickExport: (serviceContext, data) =>
+      request(buildSdkUrl(serviceContext, '/exports/quick'), {
+        method: 'POST',
+        data,
+      }),
+    templateExport: (serviceContext, data) =>
+      request(buildSdkUrl(serviceContext, '/exports/template'), {
+        method: 'POST',
+        data,
+      }),
+    queryRecentTasks: (data) =>
+      request(`${CONFIG_PREFIX}/tasks/recent`, {
+        method: 'POST',
+        data,
+      }),
+    queryTask: (serviceContext, taskCode) => {
+      if (!taskCode) {
+        return Promise.reject(new Error('taskId is required'));
+      }
+      return request(buildSdkUrl(serviceContext, '/tasks/progress'), {
+        method: 'POST',
+        data: { taskId: taskCode },
+      });
+    },
+  };
+
+  return {
+    ...services,
+    ...overrides,
+  };
+};
+
+/**
+ * 使用宿主项目的 Umi 请求实例创建默认导入导出服务。
+ */
+export const defaultImportExportServices = createImportExportServices(
+  (url, options) => umiRequest(url, options),
+);
+
+/**
+ * 将业务侧差异服务合并到默认导入导出服务。
+ */
+export const resolveImportExportServices = (
+  overrides?: Partial<ImportExportServices>,
+): ImportExportServices => ({
+  ...defaultImportExportServices,
+  ...(overrides || {}),
+});
+
+export const unwrapResponse = <T = any>(response: any): T =>
+  (response?.data?.data || response?.data || response) as T;
+
+export const getItems = <T = any>(response: any): T[] => {
+  const data: any = unwrapResponse(response);
+  return data?.records || data?.items || data?.list || [];
+};
+
+export const normalizeTask = (task: any) => {
+  const attributes = task?.attributes || {};
+  const result = task?.result || {};
+  const taskStatus = task?.taskStatus || task?.status || attributes?.status;
+  const completedCount =
+    attributes?.successCount != null || attributes?.failedCount != null
+      ? Number(attributes?.successCount || 0) +
+        Number(attributes?.failedCount || 0)
+      : undefined;
+  const terminal = [
+    'SUCCESS',
+    'PARTIAL_SUCCESS',
+    'PASSED',
+    'COMPLETED_WITH_ERRORS',
+    'FAILED',
+    'CANCELLED',
+  ].includes(taskStatus);
+  return {
+    ...task,
+    taskId: task?.taskId || result?.taskId || task?.taskCode,
+    taskType:
+      task?.taskType || attributes?.taskType || attributes?.operationType,
+    taskStatus,
+    progress: task?.progress ?? attributes?.percent,
+    processedCount:
+      task?.processedCount ??
+      task?.processedRows ??
+      attributes?.processedCount ??
+      completedCount ??
+      result?.rowCount,
+    totalCount:
+      task?.totalCount ??
+      task?.totalRows ??
+      attributes?.totalCount ??
+      (terminal ? completedCount ?? result?.rowCount : undefined),
+    elapsedSeconds: task?.elapsedSeconds ?? task?.durationSeconds,
+    successCount:
+      task?.successCount ??
+      task?.successRows ??
+      attributes?.successCount ??
+      result?.rowCount,
+    failedCount:
+      task?.failedCount ?? task?.failedRows ?? attributes?.failedCount,
+    skippedCount: task?.skippedCount ?? task?.skippedRows,
+    operatorName: task?.operatorName ?? task?.operator,
+    fileName: task?.fileName ?? result?.objectKey,
+    createdTime: task?.createdTime ?? task?.createTime,
+    resultDownloadUrl:
+      task?.resultDownloadUrl || task?.resultFileUrl || result?.fileUrl,
+    errorDownloadUrl: task?.errorDownloadUrl || task?.errorFileUrl,
+    errorMessage: task?.errorMessage ?? attributes?.errorMessage,
+  };
+};
+
+const taskTypeNames: Record<string, string> = {
+  IMPORT_VALIDATION: '导入校验',
+  IMPORT_EXECUTION: '导入执行',
+  IMPORT: '导入执行',
+  EXPORT: '导出',
+  TEMPLATE_DOWNLOAD: '模板下载',
+};
+
+export const taskTypeName = (taskType?: string) =>
+  taskTypeNames[String(taskType || '').toUpperCase()] || '文件任务';
+
+export const isConcurrentLimit = (response: any) => {
+  const candidates = [
+    response,
+    response?.data,
+    response?.response,
+    response?.response?.data,
+  ];
+  return candidates.some(
+    (item) =>
+      item?.code === concurrentLimitCode ||
+      String(item?.message || item?.msg || '').includes(concurrentLimitCode),
+  );
+};

package/src/components/Business/ImportExport/services/routing.ts

@@ -0,0 +1,21 @@
+const SDK_PREFIX = '/import-export';
+
+/**
+ * 校验并规范化业务功能服务上下文。
+ */
+export const normalizeServiceContext = (serviceContext: string) => {
+  const value = String(serviceContext || '').trim();
+  if (
+    !/^\/[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*$/.test(value) ||
+    value.includes('..')
+  ) {
+    throw new Error('业务功能服务上下文配置无效');
+  }
+  return value.replace(/\/+$/, '');
+};
+
+/**
+ * 拼接导入导出 SDK 接口地址。
+ */
+export const buildSdkUrl = (serviceContext: string, path: string) =>
+  `${normalizeServiceContext(serviceContext)}${SDK_PREFIX}${path}`;

package/src/components/Business/ImportExport/types.ts

@@ -0,0 +1,180 @@
+/**
+ * 导入导出的操作类型。
+ */
+export type ImportExportOperationType = 'IMPORT' | 'EXPORT';
+
+/**
+ * 导入导出功能的业务侧配置。
+ */
+export interface ImportExportConfig {
+  documentName: string;
+  getQueryParams?: () => Record<string, any>;
+  getResultCount?: () => number | undefined;
+}
+
+/**
+ * 业务功能解析结果。
+ */
+export interface ImportExportBusinessFunction {
+  functionCode: string;
+  functionName?: string;
+  serviceName: string;
+  serviceContext: string;
+  status: number;
+}
+
+/**
+ * 一次导入或导出操作所需的请求上下文。
+ */
+export interface ImportExportRequestContext {
+  businessFunctionCode: string;
+  serviceContext: string;
+  operationType: ImportExportOperationType;
+  conditions?: Record<string, any>;
+}
+
+/**
+ * 导入导出模板摘要。
+ */
+export interface ImportExportTemplate {
+  templateCode: string;
+  templateName: string;
+  visibility?: 'PUBLIC' | 'PERSONAL';
+  businessFunctionCode?: string;
+  defaultFlag?: boolean;
+  enabled?: boolean;
+  metadataEntityCode?: string;
+  fieldCount?: number;
+  fieldNames?: string[];
+}
+
+/**
+ * 模板字段定义。
+ */
+export interface ImportExportTemplateField {
+  fieldCode: string;
+  displayName?: string;
+  mapped?: boolean;
+  required?: boolean;
+  groupKey?: boolean;
+  fieldStatus?: string;
+}
+
+/**
+ * 导入导出异步任务。
+ */
+export interface FileTask {
+  taskId: string;
+  taskType: string;
+  templateName?: string;
+  taskStatus: string;
+  progress?: number;
+  processedCount?: number;
+  totalCount?: number;
+  elapsedSeconds?: number;
+  successCount?: number;
+  failedCount?: number;
+  skippedCount?: number;
+  operatorName?: string;
+  fileName?: string;
+  createdTime?: string;
+  resultDownloadUrl?: string;
+  errorDownloadUrl?: string;
+  errorMessage?: string;
+  serviceContext?: string;
+}
+
+/**
+ * 业务项目请求函数需要支持的最小请求参数。
+ */
+export interface ImportExportRequestOptions {
+  method: 'GET' | 'POST';
+  data?: any;
+  params?: Record<string, any>;
+  responseType?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'formData';
+}
+
+/**
+ * 由业务项目注入的请求函数。
+ */
+export type ImportExportRequest = (
+  url: string,
+  options: ImportExportRequestOptions,
+) => Promise<any>;
+
+/**
+ * 导入导出流程依赖的后端服务集合。
+ */
+export interface ImportExportServices {
+  resolveBusinessFunction: (businessFunctionCode: string) => Promise<any>;
+  queryTemplates: (data: Record<string, any>) => Promise<any>;
+  queryTemplateFields: (data: Record<string, any>) => Promise<any>;
+  uploadFile: (file: File) => Promise<any>;
+  downloadTemplate: (
+    templateCode: string,
+    data: Record<string, any>,
+  ) => Promise<any>;
+  previewImport: (
+    serviceContext: string,
+    data: Record<string, any>,
+  ) => Promise<any>;
+  executeImport: (
+    serviceContext: string,
+    data: Record<string, any>,
+  ) => Promise<any>;
+  downloadValidationErrorFile: (
+    serviceContext: string,
+    data: Record<string, any>,
+  ) => Promise<any>;
+  quickExport: (
+    serviceContext: string,
+    data: Record<string, any>,
+  ) => Promise<any>;
+  templateExport: (
+    serviceContext: string,
+    data: Record<string, any>,
+  ) => Promise<any>;
+  queryRecentTasks: (data: Record<string, any>) => Promise<any>;
+  queryTask: (serviceContext: string, taskCode: string) => Promise<any>;
+}
+
+/**
+ * 导入导出操作区属性。
+ */
+export interface ImportExportActionsProps {
+  /** 导入导出业务配置。 */
+  config: ImportExportConfig;
+  /** 导入导出服务集合。 */
+  services?: Partial<ImportExportServices>;
+  /** 导入按钮权限编码。 */
+  importCode: string;
+  /** 快速导出按钮权限编码。 */
+  quickExportCode: string;
+  /** 模板导出按钮权限编码。 */
+  templateExportCode: string;
+  /** 任务中心路由。 */
+  taskCenterPath?: string;
+  /** 是否显示最近任务入口。 */
+  showTaskDrawer?: boolean;
+  /** 跳转任务中心的业务侧回调。 */
+  onNavigateTaskCenter?: (path: string) => void;
+}
+
+/**
+ * 根据业务配置和后端服务上下文生成一次导入或导出请求上下文。
+ */
+export const createRequestContext = (
+  config: ImportExportConfig,
+  businessFunctionCode: string,
+  serviceContext: string,
+  operationType: ImportExportOperationType,
+): ImportExportRequestContext => {
+  return {
+    businessFunctionCode,
+    serviceContext,
+    operationType,
+    ...(operationType === 'EXPORT'
+      ? { conditions: config.getQueryParams?.() || {} }
+      : {}),
+  };
+};

package/src/components/Business/SearchSelect/BusinessUtils.tsx

@@ -940,7 +940,7 @@ export function commonFun (type?: string, prefixUrl: any, parentProps?:any) {
       ...selectConfigProps,
     }
     const tableSearchForm = handleHiddenFields([
-      { name: 'qp-code-in', label: 'SKC编码', type: 'multipleQueryInput' },
+      { name: 'qp-code-like', label: 'SKC编码' },
       { name: 'qp-skcName-like', label: 'SKC名称' },
       { name: 'qp-itemName-like', label: '商品名称' },
       { name: 'qp-colorName-in', type: 'select', label: '颜色', field: {

package/src/components/Functional/SearchSelect/utils.tsx

@@ -207,7 +207,6 @@ export const convertOrderNo = (params: any) => {
     'qp-skuCode-in',
     'qp-eancode-in',
     'qp-itemCode-in',
-    'qp-code-in',
   ];
   for (let i = 0; i < arr.length; i++) {
     if (params[arr[i]]) {

package/src/index.ts

@@ -55,4 +55,5 @@ export { default as ExtendedCollapse } from './components/Common/ExtendedCollaps
 export { default as Section } from './components/Common/Section';
 export { default as ParagraphCopier } from './components/Common/ParagraphCopier';
 
-export { default as SystemLog } from './components/Business/SystemLog';
+export { default as SystemLog } from './components/Business/SystemLog';
+export * from './components/Business/ImportExport';

package/src/typings/umi.d.ts

@@ -0,0 +1,9 @@
+declare module 'umi' {
+  /**
+   * 宿主 Umi 项目提供的请求函数。
+   */
+  export const request: (
+    url: string,
+    options?: Record<string, any>,
+  ) => Promise<any>;
+}

package/src/utils/LocalstorageUtils.ts

@@ -1,4 +1,4 @@
-import ENUM from '@/utils/enumConfig';
+import ENUM from './enumConfig';
 
 const resposne =()=> JSON.parse(localStorage.getItem(ENUM.BROWSER_CACHE.USER_INFO) || '{}');
 

package/src/utils/auth.ts

@@ -1,4 +1,41 @@
-import { getMenuAuthDataKey } from '@/utils/LocalstorageUtils';
+import { getLimitMenuDataKey, getMenuAuthDataKey } from './LocalstorageUtils';
+
+/**
+ * 根据上游权限编码获取关联的导入导出业务功能编码。
+ */
+export const getRelationTemplateCode = (authCode: string): string => {
+  if (!authCode) return '';
+
+  let menuData: any[] = [];
+  try {
+    const storedMenuData = JSON.parse(
+      localStorage.getItem(getLimitMenuDataKey()) || '[]',
+    );
+    menuData = Array.isArray(storedMenuData) ? storedMenuData : [];
+  } catch (error) {
+    return '';
+  }
+
+  let buttonDataList: any[] = [];
+  /**
+   * 递归收集叶子菜单下的按钮配置。
+   */
+  const collectButtons = (items: any[]) => {
+    items.forEach((item: any) => {
+      if (item?.children?.length) {
+        collectButtons(item.children);
+      } else {
+        buttonDataList = [...buttonDataList, ...(item?.buttons || [])];
+      }
+    });
+  };
+  collectButtons(menuData);
+
+  return (
+    buttonDataList.find((item) => item.bizCode === authCode)
+      ?.relationExcelTemplateCode || ''
+  );
+};
 
 // 判断某个按钮/菜单 是否有权限，返回布尔值
 export const authFunc = (code: string) => {
@@ -36,4 +73,4 @@ export const handleJudgeAuthButtons = (buttonCodeArray: any[]) => {
 export const shouldUseAuth = () => {
   // @ts-ignore
   return window.__POWERED_BY_WUJIE__ ? true : false;
-};
+};