@bit-sun/business-component 4.2.0-alpha.3 → 4.2.0-alpha.31

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

@@ -0,0 +1,208 @@
+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 =
+  '业务功能未配置或已停用，请联系管理员维护业务功能档案';
+
+/** 主应用向无界子应用注入的任务中心跳转能力。 */
+interface TaskCenterHostWindow extends Window {
+  __POWERED_BY_WUJIE__?: boolean;
+  $wujie?: {
+    props?: {
+      jump?: (route: {
+        pathname: string;
+        state: { thisHideInMenuDoNotClose: boolean };
+      }) => void;
+    };
+  };
+}
+
+/**
+ * 默认跳转到主应用中的任务中心。
+ *
+ * 无界子应用通过主应用注入的跳转能力切换页面；独立运行时打开主应用地址。
+ */
+const defaultNavigateTaskCenter = (path: string) => {
+  const hostWindow = window as TaskCenterHostWindow;
+  const jump = hostWindow.$wujie?.props?.jump;
+  if (hostWindow.__POWERED_BY_WUJIE__ && typeof jump === 'function') {
+    jump({
+      pathname: path,
+      state: {
+        thisHideInMenuDoNotClose: true,
+      },
+    });
+    return;
+  }
+
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  hostWindow.open(
+    `${hostWindow.location.origin}/main-project-front/#${normalizedPath}`,
+    '_blank',
+  );
+};
+
+/**
+ * 统一承载导入、快速导出、模板导出和文件任务入口。
+ */
+export const ImportExportActions: React.FC<ImportExportActionsProps> = ({
+  config,
+  services: serviceOverrides,
+  importCode,
+  quickExportCode,
+  templateExportCode,
+  taskCenterPath = '/configure/importExport/taskCenter',
+  showTaskDrawer = true,
+  onNavigateTaskCenter = defaultNavigateTaskCenter,
+}) => {
+  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?.() || {} }
+      : {}),
+  };
+};