@jiangood/open-admin 2.5.5 → 2.5.6

package/src/framework/utils/UrlUtils.ts

@@ -1,152 +0,0 @@
-// 假设 StrUtil 已经转换为 StrUtils 或有一个对应的类型定义
-// 如果 StrUtil 是一个工具对象，这里可能需要导入它
-import {StringUtils} from "./StringUtils";
-
-/**
- * URL 相关操作的工具类
- */
-export class UrlUtils {
-
-    /**
-     * 定义一个类型别名，用于 URL 参数对象
-     */
-    public type
-    ParamsObject = Record<string, string | number | boolean | null | undefined>;
-
-    /**
-     * 获取 URL 的参数对象。
-     * 如果不传参数，则使用当前路径 (location.href)。
-     * @param url 完整的 URL 字符串，可选。
-     * @returns 包含 URL 参数的键值对对象。
-     */
-    public static getParams(url: string | null = null): UrlUtils.ParamsObject {
-        // 1. 确定要解析的 URL
-        let targetUrl: string;
-        if (url === null || url === undefined) {
-            targetUrl = location.href;
-        } else {
-            targetUrl = url;
-        }
-
-        // 2. 检查是否有查询参数
-        if (!StringUtils.contains(targetUrl, '?')) {
-            return {};
-        }
-
-        // 3. 提取查询字符串 (问号后面的部分)
-        // 假设 StrUtil.subAfter 能够正确获取 '?' 之后的部分
-        const search = StringUtils.subAfter(targetUrl, '?');
-
-        // 4. 使用 URLSearchParams 进行解析 (现代浏览器环境)
-        // 注意：在某些旧环境或非浏览器环境中，可能需要不同的解析逻辑
-        const params = new URLSearchParams(search);
-
-        // 5. 转换为普通对象
-        const result: UrlUtils.ParamsObject = {} as UrlUtils.ParamsObject;
-        for (const [key, value] of params.entries()) {
-            // URLSearchParams 的值总是 string，因此这里赋值为 string
-            result[key] = value;
-        }
-
-        return result;
-    }
-
-    /**
-     * 获取不带参数的基础 URL (pathname)。
-     * @param url 完整的 URL 字符串。
-     * @returns 不包含查询参数的 URL 部分，如果 url 为 null/undefined，则返回 null。
-     */
-    public static getPathname(url: string | null | undefined): string | null {
-        if (!url) {
-            return null;
-        }
-        // 假设 StrUtil.subBefore 能够正确获取 '?' 之前的部分
-        return StringUtils.subBefore(url, '?');
-    }
-
-    /**
-     * 将参数对象转换为 URL 中的查询字符串（例如 k1=v1&k2=v2）。
-     * @param params 包含参数的键值对对象。
-     * @returns 查询字符串，不包含开头的问号 (?)。如果 params 为空，则返回空字符串。
-     */
-    public static paramsToSearch(params: UrlUtils.ParamsObject | null | undefined): string {
-        if (!params) {
-            return "";
-        }
-
-        const buffer: string[] = [];
-        // 迭代对象的自身属性
-        for (const k in params) {
-            // 确保只处理对象自身的属性，排除原型链上的属性
-            if (Object.prototype.hasOwnProperty.call(params, k)) {
-                const v = params[k];
-                // 忽略值为 null 或 undefined 的参数，或根据需要进行编码
-                if (v !== null && v !== undefined) {
-                    // 这里对值进行简单的连接，实际应用中建议使用 encodeURIComponent
-                    buffer.push(`${k}=${v}`);
-                }
-            }
-        }
-        return buffer.join('&');
-    }
-
-    /**
-     * 设置或删除 URL 中的一个参数，并返回新的 URL。
-     * @param url 原始 URL 字符串。
-     * @param key 要设置或删除的参数名。
-     * @param value 要设置的参数值。如果传入 null 或 undefined，则删除该参数。
-     * @returns 带有新参数的新 URL 字符串。
-     */
-    public static setParam(url: string, key: string, value: string | number | boolean | null | undefined): string {
-        // 1. 获取现有参数
-        const currentParams = this.getParams(url);
-
-        // 2. 根据 value 设置或删除参数
-        if (value === null || value === undefined) {
-            delete currentParams[key];
-        } else {
-            // 强制转换为 string 存储，以符合 URL 参数的惯例
-            currentParams[key] = String(value);
-        }
-
-        // 3. 获取基础路径
-        const pathname = this.getPathname(url);
-
-        // 4. 将新的参数对象转换为查询字符串
-        const newSearch = this.paramsToSearch(currentParams);
-
-        // 5. 组合新的 URL
-        if (newSearch.length > 0) {
-            return `${pathname}?${newSearch}`;
-        }
-        // 如果没有参数，则不带问号
-        return pathname || url; // 如果 pathname 为 null，则返回原始 url
-    }
-
-    /**
-     * @deprecated 使用 setParam 代替。
-     * 设置或替换 URL 中的一个参数，功能与 setParam 相同。
-     * @param url 原始 URL 字符串。
-     * @param key 要替换的参数名。
-     * @param value 要替换的参数值。
-     * @returns 带有新参数的新 URL 字符串。
-     */
-    public static replaceParam(url: string, key: string, value: string | number | boolean | null | undefined): string {
-        // 直接调用 setParam，并返回结果
-        return this.setParam(url, key, value);
-    }
-
-    /**
-     * 连接两个路径片段，确保中间只有一个斜杠 (/)。
-     * @param path1 第一个路径片段。
-     * @param path2 第二个路径片段。
-     * @returns 连接后的路径字符串。
-     */
-    public static join(path1: string, path2: string): string {
-        // 假设 StrUtil.removeSuffix/removePrefix 能够处理字符串前后的斜杠
-        const cleanPath1 = StringUtils.removeSuffix(path1, "/");
-        const cleanPath2 = StringUtils.removePrefix(path2, "/");
-
-        return `${cleanPath1}/${cleanPath2}`;
-    }
-}

package/src/framework/utils/UuidUtils.ts

@@ -1,88 +0,0 @@
-/**
- * 基于 https://github.com/jchook/uuid-random 的工作进行封装
- */
-export class UuidUtils {
-    // 静态属性用于存储随机字节缓冲区和索引
-    private static buf: Uint8Array | undefined = undefined;
-    private static bufIdx: number = 0;
-
-    // 预计算 toString(16) 以提高速度
-    private static readonly hexBytes: string[] = (() => {
-        const bytes = new Array<string>(256);
-        for (let i = 0; i < 256; i++) {
-            // (i + 0x100).toString(16).substring(1) 确保总是两位十六进制
-            bytes[i] = (i + 0x100).toString(16).substring(1);
-        }
-        return bytes;
-    })();
-
-    // 缓冲区大小，可调整
-    private static readonly BUFFER_SIZE: number = 4096;
-
-    // 随机字节生成函数，使用最佳可用 PRNG
-    private static readonly randomBytes = ((n: number): Uint8Array => {
-        // Node & Browser 支持
-        const lib = typeof crypto !== 'undefined'
-            ? crypto
-            : (
-                typeof window !== 'undefined'
-                    ? window.crypto || (window as any).msCrypto // window.msCrypto 在 TypeScript 中可能不存在
-                    : undefined
-            );
-
-        if (lib !== undefined) {
-            // Node.js 支持
-            if ((lib as any).randomBytes !== undefined) {
-                return (lib as any).randomBytes(n);
-            }
-// 浏览器支持
-            if (lib.getRandomValues !== undefined) {
-                return (() => {
-                    const bytes = new Uint8Array(n);
-                    lib.getRandomValues(bytes);
-                    return bytes;
-                })();
-            }
-        }
-
-// 降级使用 Math.random
-        const r = new Uint8Array(n);
-        for (let i = 0; i < n; i++) {
-            r[i] = Math.floor(Math.random() * 256);
-        }
-        return r;
-    });
-
-    /**
-     * 生成一个符合 v4 标准的 UUID。
-     * @returns 一个 UUID 字符串。
-     */
-    public static uuidV4(): string {
-        // 为加速而缓冲一些随机字节
-        if (UuidUtils.buf === undefined || (UuidUtils.bufIdx + 16 > UuidUtils.BUFFER_SIZE)) {
-            UuidUtils.bufIdx = 0;
-            // randomBytes 的返回类型已确定为 Uint8Array
-            UuidUtils.buf = UuidUtils.randomBytes(UuidUtils.BUFFER_SIZE);
-        }
-
-        // 提取 16 个字节。使用 Array.prototype.slice.call 转化为 Array 并不能保证性能，
-        // 且 TypeScript 中操作 Uint8Array 更直接。我们直接使用 subarray 提取，性能更优。
-        const b = UuidUtils.buf.subarray(UuidUtils.bufIdx, (UuidUtils.bufIdx += 16));
-
-        // 设置 UUID 版本 (Version 4: 0100)
-        b[6] = (b[6] & 0x0f) | 0x40;
-        // 设置时钟序列高位 (Variant 1: 10xx)
-        b[8] = (b[8] & 0x3f) | 0x80;
-
-        // 将字节转换为十六进制字符串格式
-        const h = UuidUtils.hexBytes;
-        return h[b[0]] + h[b[1]]
-            + h[b[2]] + h[b[3]] + '-'
-            + h[b[4]] + h[b[5]] + '-'
-            + h[b[6]] + h[b[7]] + '-'
-            + h[b[8]] + h[b[9]] + '-'
-            + h[b[10]] + h[b[11]]
-            + h[b[12]] + h[b[13]]
-            + h[b[14]] + h[b[15]];
-    }
-}

package/src/framework/utils/ValidateUtils.ts

@@ -1,28 +0,0 @@
-/**
- * 验证工具类
- */
-export class ValidateUtils {
-
-    /**
-     * 检查给定的字符串是否为有效的电子邮件地址。
-     * @param emailStr 要检查的字符串。
-     * @returns 如果是有效的电子邮件地址，则返回 true；否则返回 false。
-     */
-    public static isEmail(emailStr: string): boolean {
-        // 匹配大多数常见电子邮件格式的正则表达式
-        const reg = /^([\w+.-])+@\w+([.]\w+)+$/;
-        return reg.test(emailStr);
-    }
-
-    // 可以在这里添加其他验证方法，例如：
-    /*
-    public static isPhone(phoneStr: string): boolean {
-        // ... 手机号验证逻辑
-        return /^\d{10}$/.test(phoneStr);
-    }
-    */
-}
-
-// 示例用法：
-// const isValid = ValidateUtils.isEmail("test@example.com");
-// console.log(isValid); // true

package/src/framework/utils/system/DictUtils.ts

@@ -1,96 +0,0 @@
-// 假设的类型定义，你需要确保与你的实际数据结构匹配
-import {SysUtils} from "./SysUtils";
-// 假设 SysUtil 和 StrUtil 的引入和类型
-// 实际使用时需要确保路径和模块存在
-import {Tag} from 'antd';
-import React from 'react';
-import {StringUtils} from "../StringUtils";
-
-export interface DictItem {
-    code: string | number;
-    label: string;
-    color?: string;
-}
-
-
-// 字典选项的格式
-export interface DictOption {
-    value: string | number;
-    label: string;
-}
-
-/**
- * 字典相关的工具类
- */
-export class DictUtils {
-
-    /**
-     * 根据字典类型code返回字典数据列表。
-     * code 支持 驼峰或下划线（都转为下划线进行匹配）。
-     * @param code 字典类型编码 (如 'userStatus', 'USER_STATUS')
-     * @returns 对应的字典项列表，未找到返回空数组
-     */
-    public static dictList(code: string): DictItem[] {
-        const info = SysUtils.getDictInfo();
-        if (!info) {
-            return [];
-        }
-
-        let list = info.filter(e=>e.typeCode === code);
-
-        return list
-    }
-
-    /**
-     * 将字典列表转换为 Ant Design Select/Options 格式
-     * @param typeCode 字典类型编码
-     * @returns 包含 value/label 的选项列表
-     */
-    public static dictOptions(typeCode: string): DictOption[] {
-        const list: DictItem[] = DictUtils.dictList(typeCode);
-        return list.map(i => {
-            return {
-                value: i.code,
-                label: i.label,
-            }
-        });
-    }
-
-
-    /**
-     * 根据字典类型和字典项code获取对应的名称(name)
-     * @param typeCode 字典类型编码
-     * @param code 字典项编码
-     * @returns 对应的名称，未找到返回 undefined
-     */
-    public static dictLabel(typeCode: string, code: string | number): string | undefined {
-        const items = DictUtils.dictList(typeCode);
-        const item = items.find(i => i.code === code);
-        return item ? item.label : undefined;
-    }
-
-    /**
-     * 根据字典类型和字典项code获取对应的名称，并使用 Ant Design Tag 组件包装 (如果存在 color 属性)
-     * @param typeCode 字典类型编码
-     * @param code 字典项编码
-     * @returns Antd Tag 元素或纯字符串名称或空字符串
-     */
-    public static dictTag(typeCode: string, code: string | number): React.ReactElement | string {
-        if (typeCode == null || code == null) {
-            return null;
-        }
-        const item = DictUtils.dictList(typeCode).find(i => i.code === code);
-
-        if (item == null) {
-            return null;
-        }
-        const {label, color} = item;
-
-        if (color == null) {
-            // 如果没有颜色，返回纯文本
-            return label;
-        }
-
-        return React.createElement(Tag, {color: color.toLowerCase()}, label);
-    }
-}

package/src/framework/utils/system/FormRegistryUtils.ts

@@ -1,76 +0,0 @@
-import * as React from 'react';
-
-/**
- * 💡 类型定义同上
- */
-type FormComponent = React.ComponentType<any>;
-
-/**
- * 🛠️ FormRegistryUtils
- * 一个静态工具类，用于注册、获取和管理表单组件。
- * 调用时无需实例化，直接使用 FormRegistryUtils.methodName()。
- */
-export class FormRegistryUtils {
-  // 静态私有属性：存储表单组件的 Map
-  private static forms: Map<string, FormComponent> = new Map<string, FormComponent>();
-
-  /**
-   * 注意：
-   * 1. 私有构造函数可以防止该类被外部实例化（可选，但推荐用于纯静态类）。
-   * 2. 如果不定义构造函数，TypeScript 默认允许实例化，但因为所有成员都是静态的，实例化没有意义。
-   */
-  private constructor() {
-    // 阻止外部实例化
-  }
-
-  /**
-   * 静态方法：注册表单组件
-   * @param formKey - 表单唯一标识
-   * @param formComponent - React 表单组件
-   */
-  public static register(formKey: string, formComponent: FormComponent): void {
-    if (!formKey || !formComponent) {
-      throw new Error("【FormRegistryUtils】表单 Key 和组件不能为空！");
-    }
-
-    // 访问静态属性需要使用 'FormRegistryUtils.'
-    if (FormRegistryUtils.forms.has(formKey)) {
-      console.warn(`⚠️ 【FormRegistryUtils】表单 "${formKey}" 已存在，将被覆盖！`);
-    }
-
-    FormRegistryUtils.forms.set(formKey, formComponent);
-  }
-
-  /**
-   * 静态方法：获取表单组件
-   * @param formKey - 表单唯一标识
-   * @returns React 表单组件，如果不存在则返回 null
-   */
-  public static get(formKey: string): FormComponent | null {
-    const formComponent = FormRegistryUtils.forms.get(formKey);
-
-    if (!formComponent) {
-      console.warn(`⚠️ 【FormRegistryUtils】表单 "${formKey}" 未注册！`);
-    }
-
-    return formComponent ?? null;
-  }
-
-  /**
-   * 静态方法：检查表单是否已注册
-   * @param formKey - 表单唯一标识
-   * @returns boolean
-   */
-  public static has(formKey: string): boolean {
-    return FormRegistryUtils.forms.has(formKey);
-  }
-
-  /**
-   * 静态方法：获取所有已注册的表单 Key
-   * @returns string[] - 所有表单 Key 的数组
-   */
-  public static getAllKeys(): string[] {
-    return Array.from(FormRegistryUtils.forms.keys());
-  }
-}
-

package/src/framework/utils/system/HttpUtils.ts

@@ -1,251 +0,0 @@
-import axios, {AxiosRequestConfig, AxiosResponse, Method} from "axios";
-import { Modal} from "antd";
-import qs from 'qs';
-import {PageUtils} from "./PageUtils";
-import {MessageUtils} from "../MessageUtils";
-
-
-const axiosInstance = axios.create({
-    baseURL: (typeof SERVLET_CONTEXT !== 'undefined' && SERVLET_CONTEXT) || '',
-    withCredentials: true,
-    headers: {
-        'Content-Type': 'application/json'
-    },
-    // 解决get请求时，数组参数的问题
-    paramsSerializer: (params) => {
-        return qs.stringify(params, {indices: false});
-    }
-})
-
-
-/**
- * @description HTTP请求工具类
- */
-export class HttpUtils {
-
-
-    /**
-     * 核心请求函数，处理请求发送、加载状态、响应解析和错误捕获
-     * @param config AxiosRequestConfig & RequestOptions
-     * @param transformData 是否返回最总的data字段
-     * @returns Promise<any>
-     */
-    // ... existing code ...
-    private static coreRequest(config: AxiosRequestConfig, transformData: boolean = true): Promise<any> {
-        const url = config.url;
-        config.url = url.startsWith('admin') ? '/' + url : url;
-
-        return new Promise((resolve, reject) => {
-            axiosInstance(config).then((response: AxiosResponse) => {
-                const body = response.data;
-                // 假设后端响应结构为 { success: boolean | null, message: string, data: any, code: number }
-                let {success, message, data} = body;
-                if (success == undefined) { // 如果没有success字段，说明非标准接口
-                    resolve(response);
-                    return ;
-                }
-
-                if (!success) {
-                    console.error(`[HttpUtils] 请求失败: ${url}`, {code: body.code, message, data: body});
-                    MessageUtils.error(message || '操作失败');
-                    reject('操作失败');
-                    return
-                }
-
-                // 自动消息提示
-                if (message) {
-                    MessageUtils.success(message);
-                }
-                resolve(transformData ? data : response);
-            }).catch((e: unknown) => {
-                // 统一异常处理
-                console.error(`[HttpUtils] 请求异常: ${url}`, e);
-                let msg = '操作失败';
-
-                if (axios.isAxiosError(e)) {
-                    const status = e.response?.status;
-                    const responseData = e.response?.data;
-
-                    if (status === 401) {
-                        // 登录过期处理
-                        MessageUtils.confirm('登录已过期，请重新登录').then(() => {
-                            PageUtils.redirectToLogin();
-                        });
-                        // 阻止后续的错误提示，返回一个特殊 Promise.reject
-                         reject('登录过期');
-                        return
-                    }
-                    if (status === 504) {
-                        msg = '504 请求后端服务失败';
-                    } else if (responseData && responseData.message) {
-                        msg = responseData.message;
-                    } else if (e.message) {
-                        msg = e.message;
-                    }
-                } else if (e instanceof Error) {
-                    // 可能是后端success=false抛出的自定义错误
-                    msg = e.message;
-                }
-
-                MessageUtils.error(msg);
-
-                // 将原始错误或处理后的错误信息向外抛出
-                reject(e);
-            });
-        })
-
-    }
-
-
-    /**
-     * 处理文件下载后的blob流
-     * @param res AxiosResponse 文件下载响应
-     */
-    private static handleDownloadBlob(res: AxiosResponse): Promise<void> {
-        return new Promise((resolve, reject) => {
-            const {data: blob, headers} = res;
-
-            // 1. 检查是否为错误JSON
-            if (blob.type === 'application/json') {
-                const reader = new FileReader();
-                reader.readAsText(blob, 'utf-8');
-                reader.onload = function () {
-                    try {
-                        let rs = JSON.parse(reader.result as string);
-                        Modal.error({
-                            title: '下载文件失败',
-                            content: rs.message || '不支持下载'
-                        });
-                        reject(new Error(rs.message || '下载错误'));
-                    } catch (e) {
-                        Modal.error({title: '下载文件失败', content: '解析错误响应失败'});
-                        reject(e);
-                    }
-                };
-                return;
-            }
-
-            // 2. 获取文件名称
-            const contentDisposition = headers['content-disposition'] || headers['Content-Disposition'];
-            if (!contentDisposition) {
-                Modal.error({title: '获取文件名称失败', content: "缺少Content-Disposition响应头"});
-                reject(new Error("缺少Content-Disposition响应头"));
-                return;
-            }
-
-            const match = /filename\*?=(?:['"]?)(?:UTF-8''|)(.+?)(?:['"]?$|;)/i.exec(contentDisposition);
-            let filename = match && match[1] ? match[1].trim() : 'download.file';
-
-            try {
-                // 尝试进行URI解码
-                filename = decodeURIComponent(filename.replace(/"/g, ''));
-            } catch (e) {
-                // 如果解码失败，保持原样
-                filename = filename.replace(/"/g, '');
-            }
-
-            // 3. 开始下载
-            const url = window.URL.createObjectURL(new Blob([blob]));
-            const link = document.createElement('a');
-            link.style.display = 'none';
-
-            link.href = url;
-            link.download = filename;
-
-            document.body.appendChild(link);
-            link.click();
-
-            document.body.removeChild(link);
-            window.URL.revokeObjectURL(url);
-            resolve();
-        });
-    }
-
-
-    /**
-     * 发送GET请求
-     * @param url 请求地址
-     * @param params URL参数
-     * @param options 自定义配置 (transformData等)
-     * @returns Promise<any> 后端返回的 data 字段
-     */
-    public static get(url: string, params: any = null, options: Partial<AxiosRequestConfig> = {}): Promise<any> {
-        return HttpUtils.coreRequest({
-            ...options,
-            url,
-            method: 'GET',
-            params,
-        });
-    }
-
-    /**
-     * 发送POST请求 (Content-Type: application/json)
-     * @param url 请求地址
-     * @param data 请求体数据
-     * @param params URL参数
-     * @param options 自定义配置
-     * @returns Promise<any> 后端返回的 data 字段
-     */
-    public static post(url: string, data: any = null, params: any = null, options: Partial<RequestOptions> = {}): Promise<any> {
-        return HttpUtils.coreRequest({
-            ...options,
-            url,
-            method: 'POST',
-            data,
-            params,
-        });
-    }
-
-    /**
-     * 发送POST表单请求 (Content-Type: application/x-www-form-urlencoded)
-     * @param url 请求地址
-     * @param data 表单数据
-     * @param options 自定义配置
-     * @returns Promise<any> 后端返回的 data 字段
-     */
-    public static postForm(url: string, data: any, options: Partial<AxiosRequestConfig> = {}): Promise<any> {
-        return HttpUtils.coreRequest({
-            ...options,
-            url,
-            method: 'POST',
-            data: qs.stringify(data), // 转换为表单格式
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded'
-            },
-        });
-    }
-
-    /**
-     * 下载文件
-     * @param url 请求地址
-     * @param data 请求体数据 (POST时使用)
-     * @param params URL参数
-     * @param method 请求方法，默认为GET
-     * @param options 自定义配置
-     * @returns Promise<void>
-     */
-    public static async downloadFile(url: string, data: any = null, params: any = null, method: Method = 'GET', options: Partial<AxiosRequestConfig> = {}): Promise<void> {
-
-        // 下载请求默认设置：不转换数据，响应类型为 blob
-        const downloadConfig: AxiosRequestConfig = {
-            responseType: 'blob', // 关键设置
-            ...options,
-            url,
-            method,
-            params,
-            data,
-        };
-
-        try {
-            // coreRequest返回的是完整的 AxiosResponse，因此需要类型断言
-            const response = await HttpUtils.coreRequest(downloadConfig, false) as AxiosResponse;
-            await HttpUtils.handleDownloadBlob(response);
-        } catch (error) {
-            console.error('[HttpUtils] 下载文件失败:', error);
-            // coreRequest已经处理了401、504和通用的错误提示
-            return Promise.reject(error);
-        }
-    }
-
-
-}