@jiangood/open-admin 2.5.2 → 2.5.6

package/src/framework/utils/StringUtils.js

@@ -0,0 +1,107 @@
+export class StringUtils {
+
+    static ISO_SPLITTER = "/";
+
+    static removePrefix(str, ch) {
+        if (str != null && str.startsWith(ch)) {
+            return str.substring(ch.length);
+        }
+        return str ?? '';
+    }
+
+    static removeSuffix(str, ch) {
+        if (str != null && str.endsWith(ch)) {
+            return str.substring(0, str.length - ch.length);
+        }
+        return str ?? '';
+    }
+
+    static random(length) {
+        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += characters.charAt(Math.floor(Math.random() * characters.length));
+        }
+        return result;
+    }
+
+    static contains(str, subStr) {
+        if (!str) return false;
+        return str.includes(subStr);
+    }
+
+    static subAfter(source, str) {
+        if (source == null) return '';
+        const index = source.indexOf(str);
+        return index === -1 ? source : source.substring(index + str.length);
+    }
+
+    static subAfterLast(source, str) {
+        if (source == null) return '';
+        const index = source.lastIndexOf(str);
+        return index === -1 ? source : source.substring(index + str.length);
+    }
+
+    static subBefore(str, sub) {
+        if (str == null) return "";
+        const index = str.indexOf(sub);
+        return index === -1 ? str : str.substring(0, index);
+    }
+
+    static pad(input, totalLen, padChar = '0') {
+        if (input == null) return padChar.repeat(totalLen);
+        let str = String(input);
+        const charsNeeded = totalLen - str.length;
+        if (charsNeeded > 0) {
+            str = padChar.repeat(charsNeeded) + str;
+        }
+        return str;
+    }
+
+    static getWidth(str) {
+        if (str == null || str.length === 0) return 0;
+        return str.split('').reduce((pre, cur) => {
+            const charCode = cur.charCodeAt(0);
+            return pre + (charCode >= 0 && charCode <= 128 ? 1 : 2);
+        }, 0);
+    }
+
+    static cutByWidth(str, maxWidth) {
+        let showLength = 0;
+        return str.split('').reduce((pre, cur) => {
+            const charCode = cur.charCodeAt(0);
+            const charWidth = (charCode >= 0 && charCode <= 128) ? 1 : 2;
+            if (showLength + charWidth <= maxWidth) {
+                showLength += charWidth;
+                return pre + cur;
+            }
+            return pre;
+        }, '');
+    }
+
+    static ellipsis(str, len, suffix = '...') {
+        if (str == null) return '';
+        if (!StringUtils.isString(str)) return '';
+        if (str.length * 2 < len) return str;
+        const fullLength = StringUtils.getWidth(str);
+        if (fullLength <= len) return str;
+        return StringUtils.cutByWidth(str, len) + suffix;
+    }
+
+    static isString(value) {
+        return typeof value === 'string';
+    }
+
+    static split(str, sp) {
+        if (str == null || str.length === 0) return [];
+        if (Array.isArray(str)) return str;
+        return str.split(sp);
+    }
+
+    static join(arr, sp) {
+        if (arr == null || !Array.isArray(arr)) {
+            return '';
+        }
+        return arr.join(sp);
+    }
+}

package/src/framework/utils/TreeUtils.d.ts

@@ -0,0 +1,13 @@
+export interface TreeNode<T = any> {
+    id: string | number;
+    pid: string | number | null;
+    children?: TreeNode<T>[];
+    [key: string]: any;
+}
+
+export class TreeUtils {
+    static walk<T extends TreeNode>(tree: T[], callback: (node: T) => void): void;
+    static findByKey<T extends TreeNode>(key: string | number, list: T[], keyName?: keyof T | 'id'): T | undefined;
+    static flattenTree<T extends TreeNode>(treeNodeList: T[]): T[];
+    static getKeyList<T extends TreeNode>(tree: T[], value: string | number): (string | number)[];
+}

package/src/framework/utils/TreeUtils.js

@@ -0,0 +1,63 @@
+export class TreeUtils {
+    static walk(tree, callback) {
+        if (tree == null) return;
+        for (const node of tree) {
+            callback(node);
+            if (node.children && node.children.length > 0) {
+                TreeUtils.walk(node.children, callback);
+            }
+        }
+    }
+
+    static findByKey(key, list, keyName = 'id') {
+        for (const item of list) {
+            if (item[keyName] === key) return item;
+            if (item.children && item.children.length) {
+                const rs = TreeUtils.findByKey(key, item.children, keyName);
+                if (rs) return rs;
+            }
+        }
+        return undefined;
+    }
+
+    static _getChild(treeNode, buffer) {
+        if (treeNode.children != null && treeNode.children.length > 0) {
+            treeNode.children.forEach((c) => {
+                buffer.push(c);
+                TreeUtils._getChild(c, buffer);
+            });
+        }
+        return buffer;
+    }
+
+    static flattenTree(treeNodeList) {
+        const buffer = [];
+        if (treeNodeList != null) {
+            treeNodeList.forEach((t) => {
+                buffer.push(t);
+                TreeUtils._getChild(t, buffer);
+            });
+        }
+        return buffer;
+    }
+
+    static getKeyList(tree, value) {
+        const list = TreeUtils.flattenTree(tree);
+        const map = new Map();
+        list.forEach((t) => {
+            const key = t.key || t.id;
+            map.set(key, t);
+        });
+        const targetNode = map.get(value);
+        if (targetNode == null) return [];
+        const keys = [targetNode.key || targetNode.id];
+        let parentKey = targetNode.parentKey || targetNode.pid;
+        while (parentKey != null) {
+            const parent = map.get(parentKey);
+            if (parent == null) break;
+            keys.push(parent.key || parent.id);
+            parentKey = parent.parentKey || parent.pid;
+        }
+        return keys.reverse();
+    }
+}

package/src/framework/utils/UrlUtils.d.ts

@@ -0,0 +1,6 @@
+export class UrlUtils {
+    static getParams(url?: string | null): Record<string, string>;
+    static setParam(url: string, key: string, value: string | number | boolean | null | undefined): string;
+    static getWebsocketBaseUrl(): string;
+    static contextPath(path: string): string;
+}

package/src/framework/utils/UrlUtils.js

@@ -0,0 +1,71 @@
+import {StringUtils} from './StringUtils';
+
+export class UrlUtils {
+    static getParams(url = null) {
+        let targetUrl;
+        if (url === null || url === undefined) {
+            targetUrl = location.href;
+        } else {
+            targetUrl = url;
+        }
+
+        if (!StringUtils.contains(targetUrl, '?')) return {};
+        const search = StringUtils.subAfter(targetUrl, '?');
+        const params = new URLSearchParams(search);
+        const result = {};
+        for (const [key, value] of params.entries()) {
+            result[key] = value;
+        }
+        return result;
+    }
+
+    static getPathname(url) {
+        if (!url) return null;
+        return StringUtils.subBefore(url, '?');
+    }
+
+    static paramsToSearch(params) {
+        if (!params) return "";
+        const buffer = [];
+        for (const k in params) {
+            if (Object.prototype.hasOwnProperty.call(params, k)) {
+                const v = params[k];
+                if (v !== null && v !== undefined) {
+                    buffer.push(`${k}=${v}`);
+                }
+            }
+        }
+        return buffer.join('&');
+    }
+
+    static setParam(url, key, value) {
+        const currentParams = this.getParams(url);
+        if (value === null || value === undefined) {
+            delete currentParams[key];
+        } else {
+            currentParams[key] = String(value);
+        }
+        const pathname = this.getPathname(url);
+        const newSearch = this.paramsToSearch(currentParams);
+        if (newSearch.length > 0) {
+            return `${pathname}?${newSearch}`;
+        }
+        return pathname || url;
+    }
+
+    /**
+     * 根据当前页面协议和主机名构建 WebSocket 基础 URL
+     */
+    static getWebsocketBaseUrl() {
+        const protocol = location.protocol === 'http:' ? 'ws:' : 'wss:';
+        return `${protocol}//${location.host}`;
+    }
+
+    /**
+     * 为路径添加 SERVLET_CONTEXT 前缀
+     */
+    static contextPath(path) {
+        const base = (typeof SERVLET_CONTEXT !== 'undefined' && SERVLET_CONTEXT) || '';
+        return base + path;
+    }
+}

package/src/framework/utils/index.ts

@@ -2,14 +2,10 @@ export * from "./DateUtils";
 export * from "./ArrayUtils";
 export * from "./UrlUtils"
 export * from "./StringUtils"
-export * from "./EventBusUtils";
-export * from "./ColorsUtils"
-export * from "./DomUtils"
-export * from "./UuidUtils";
+export * from "./EventBus";
 export * from "./TreeUtils";
 export * from './StorageUtils'
 export * from './DeviceUtils'
 export * from './ObjectUtils'
-export * from './ValidateUtils'
 export * from './system'
 export * from './MessageUtils'

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

@@ -0,0 +1,20 @@
+import React from 'react';
+import {Tag} from 'antd';
+
+export interface DictItem {
+    code: string | number;
+    label: string;
+    color?: string;
+}
+
+export interface DictOption {
+    value: string | number;
+    label: string;
+}
+
+export class DictUtils {
+    static dictList(code: string): DictItem[];
+    static dictOptions(typeCode: string): DictOption[];
+    static dictLabel(typeCode: string, code: string | number): string | undefined;
+    static dictTag(typeCode: string, code: string | number): React.ReactElement | string | null;
+}

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

@@ -0,0 +1,31 @@
+import {GlobalData} from '../../GlobalData';
+import {Tag} from 'antd';
+import React from 'react';
+
+export class DictUtils {
+    static dictList(code) {
+        const info = GlobalData.getDictInfo();
+        if (!info) return [];
+        return info.filter(e => e.typeCode === code);
+    }
+
+    static dictOptions(typeCode) {
+        const list = DictUtils.dictList(typeCode);
+        return list.map(i => ({ value: i.code, label: i.label }));
+    }
+
+    static dictLabel(typeCode, code) {
+        const items = DictUtils.dictList(typeCode);
+        const item = items.find(i => i.code === code);
+        return item ? item.label : undefined;
+    }
+
+    static dictTag(typeCode, code) {
+        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/FormRegistry.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+
+export class FormRegistry {
+    static register(formKey: string, formComponent: React.ComponentType<any>): void;
+    static get(formKey: string): React.ComponentType<any> | null;
+    static has(formKey: string): boolean;
+    static getAllKeys(): string[];
+}

package/src/framework/utils/system/FormRegistry.js

@@ -0,0 +1,31 @@
+import * as React from 'react';
+
+export class FormRegistry {
+    static forms = new Map();
+
+    static register(formKey, formComponent) {
+        if (!formKey || !formComponent) {
+            throw new Error("表单 Key 和组件不能为空！");
+        }
+        if (FormRegistry.forms.has(formKey)) {
+            console.warn(`表单 "${formKey}" 已存在，将被覆盖！`);
+        }
+        FormRegistry.forms.set(formKey, formComponent);
+    }
+
+    static get(formKey) {
+        const formComponent = FormRegistry.forms.get(formKey);
+        if (!formComponent) {
+            console.warn(`表单 "${formKey}" 未注册！`);
+        }
+        return formComponent ?? null;
+    }
+
+    static has(formKey) {
+        return FormRegistry.forms.has(formKey);
+    }
+
+    static getAllKeys() {
+        return Array.from(FormRegistry.forms.keys());
+    }
+}

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

@@ -0,0 +1,14 @@
+import {AxiosRequestConfig} from "axios";
+
+declare const SERVLET_CONTEXT: string | undefined;
+
+interface RequestOptions extends AxiosRequestConfig {
+    showError?: boolean;
+}
+
+export class HttpUtils {
+    static coreRequest<T = any>(config: RequestOptions, transformData?: boolean): Promise<T>;
+    static get<T = any>(url: string, params?: any, options?: Partial<RequestOptions>): Promise<T>;
+    static post<T = any>(url: string, data?: any, params?: any, options?: Partial<RequestOptions>): Promise<T>;
+    static postForm<T = any>(url: string, data: any, options?: Partial<RequestOptions>): Promise<T>;
+}

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

@@ -0,0 +1,87 @@
+import axios from "axios";
+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' },
+    paramsSerializer: (params) => qs.stringify(params, {indices: false})
+});
+
+export class HttpUtils {
+    static coreRequest(config, transformData = true) {
+        const url = config.url;
+        config.url = url.startsWith('admin') ? '/' + url : url;
+
+        return new Promise((resolve, reject) => {
+            axiosInstance(config).then((response) => {
+                const body = response.data;
+                let {success, message, data} = body;
+                if (success == undefined) {
+                    resolve(response);
+                    return;
+                }
+                if (!success) {
+                    console.error(`[HttpUtils] 请求失败: ${url}`, {code: body.code, message, data: body});
+                    if (config.showError !== false) {
+                        MessageUtils.error(message || '操作失败');
+                    }
+                    reject(message || '操作失败');
+                    return;
+                }
+                if (message) {
+                    MessageUtils.success(message);
+                }
+                resolve(transformData ? data : response);
+            }).catch((e) => {
+                console.error(`[HttpUtils] 请求异常: ${url}`, e);
+                if (axios.isAxiosError(e) && e.response?.status === 401) {
+                    MessageUtils.confirm('登录已过期，请重新登录').then(() => {
+                        PageUtils.redirectToLogin();
+                    });
+                    reject('登录过期');
+                    return;
+                }
+                const msg = HttpUtils.extractErrorMessage(e);
+                if (config.showError !== false) {
+                    MessageUtils.error(msg);
+                }
+                reject(msg);
+            });
+        });
+    }
+
+    static extractErrorMessage(e, defaultMsg = '操作失败') {
+        if (axios.isAxiosError(e)) {
+            const responseData = e.response?.data;
+            const status = e.response?.status;
+            if (status === 504) return '504 请求后端服务失败';
+            if (responseData && responseData.message) return responseData.message;
+            if (e.message) return e.message;
+            return defaultMsg;
+        }
+        if (e instanceof Error) return e.message || defaultMsg;
+        return defaultMsg;
+    }
+
+    static get(url, params = null, options = {}) {
+        return HttpUtils.coreRequest({...options, url, method: 'GET', params});
+    }
+
+    static post(url, data = null, params = null, options = {}) {
+        return HttpUtils.coreRequest({...options, url, method: 'POST', data, params});
+    }
+
+    static postForm(url, data, options = {}) {
+        return HttpUtils.coreRequest({
+            ...options,
+            url,
+            method: 'POST',
+            data: qs.stringify(data),
+            headers: {'Content-Type': 'application/x-www-form-urlencoded'}
+        });
+    }
+
+}

package/src/framework/utils/system/PageUtils.d.ts

@@ -0,0 +1,14 @@
+import {history} from "umi";
+
+export class PageUtils {
+    static redirectToLogin(): void;
+    static currentParams(): Record<string, string | undefined>;
+    static currentPathname(): string;
+    static currentUrl(): string;
+    static currentPathnameLastPart(): string | undefined;
+    static open(path: string, label?: string): void;
+    static openNoLayout(path: string): void;
+    static currentLabel(): string | undefined;
+    static closeCurrent(): void;
+    static closeCurrentAndOpenPage(alertMessage: string, path: string, label: string): void;
+}

package/src/framework/utils/system/PageUtils.js

@@ -0,0 +1,59 @@
+import {history} from "umi";
+import {StringUtils} from "../StringUtils";
+import {UrlUtils} from "../UrlUtils";
+import {MessageUtils} from "../MessageUtils";
+
+export class PageUtils {
+    static redirectToLogin() {
+        const url = PageUtils.currentUrl();
+        const encodedUrl = encodeURIComponent(url);
+        history.push(`/login?redirect=${encodedUrl}`);
+    }
+
+    static currentParams() {
+        return UrlUtils.getParams();
+    }
+
+    static currentPathname() {
+        const path = window.location.hash.substring(1);
+        return StringUtils.subBefore(path, '?');
+    }
+
+    static currentUrl() {
+        return window.location.hash.substring(1);
+    }
+
+    static currentPathnameLastPart() {
+        const path = this.currentPathname();
+        return StringUtils.subAfterLast(path, '/') || undefined;
+    }
+
+    static open(path, label = '未命名') {
+        let targetPath = path;
+        if (label) {
+            targetPath = UrlUtils.setParam(targetPath, '_label', label);
+        }
+        history.push(targetPath);
+    }
+
+    static openNoLayout(path) {
+        const targetPath = UrlUtils.setParam(path, '_noLayout', true);
+        history.push(targetPath);
+    }
+
+    static currentLabel() {
+        return this.currentParams()['_label'];
+    }
+
+    static closeCurrent() {
+        const event = new CustomEvent('close-page-event', {detail: {url: PageUtils.currentUrl()}});
+        document.dispatchEvent(event);
+    }
+
+    static closeCurrentAndOpenPage(alertMessage, path, label) {
+        MessageUtils.alert(alertMessage).then(() => {
+            this.closeCurrent();
+            this.open(path, label);
+        });
+    }
+}

package/src/framework/utils/system/PermUtils.d.ts

@@ -0,0 +1,5 @@
+export class PermUtils {
+    static hasPermission(perm: string | null | undefined): boolean;
+    static isPermitted(p: string | null | undefined): boolean;
+    static notPermitted(p: string | null | undefined): boolean;
+}

package/src/framework/utils/system/PermUtils.js

@@ -0,0 +1,27 @@
+import {GlobalData} from '../../GlobalData';
+import {ArrayUtils} from '../ArrayUtils';
+
+export class PermUtils {
+    static getPermissions() {
+        const info = GlobalData.getLoginInfo();
+        const { permissions } = info;
+        if (permissions == null || permissions.length === 0) return [];
+        return permissions;
+    }
+
+    static hasPermission(perm) {
+        if (perm === null || perm === undefined || perm === '') return false;
+        const permissions = PermUtils.getPermissions();
+        if (permissions.length === 0) return false;
+        if (ArrayUtils.contains(permissions, "*")) return true;
+        return permissions.indexOf(perm) > -1;
+    }
+
+    static isPermitted(p) {
+        return PermUtils.hasPermission(p);
+    }
+
+    static notPermitted(p) {
+        return !PermUtils.isPermitted(p);
+    }
+}

package/src/framework/utils/system/ThemeUtils.d.ts

@@ -0,0 +1,6 @@
+declare const OPEN_ADMIN_THEME: Record<string, string> | undefined;
+
+export class ThemeUtils {
+    static readonly theme: Record<string, string>;
+    static getColor(key: string): string | undefined;
+}

package/src/framework/utils/system/{ThemeUtils.ts → ThemeUtils.js}

@@ -1,9 +1,5 @@
-import {ColorsUtils} from '../ColorsUtils';
-
-declare const OPEN_ADMIN_THEME: Record<string, string> | undefined;
-
 export class ThemeUtils {
-    private static readonly defaultTheme: Record<string, string> = {
+    static defaultTheme = {
         "primary-color": "#1961AC",
         "success-color": "#52c41a",
         "warning-color": "#faad14",
@@ -13,40 +9,44 @@ export class ThemeUtils {
         "primary-color-click": "#124B93"
     };
 
-    private static cachedTheme: Record<string, string> | null = null;
+    static cachedTheme = null;
 
-    static get theme(): Record<string, string> {
+    static get theme() {
         if (this.cachedTheme) return this.cachedTheme;
         this.cachedTheme = this.loadTheme();
         return this.cachedTheme;
     }
 
-    private static loadTheme(): Record<string, string> {
-        let custom: Record<string, string> = {};
+    /** 调亮/调暗十六进制颜色 */
+    static _lightenHex(hex, percent) {
+        const num = parseInt(hex.replace('#', ''), 16);
+        const r = num >> 16 & 255, g = num >> 8 & 255, b = num & 255;
+        const t = percent < 0 ? 0 : 255;
+        const p = Math.abs(percent) / 100;
+        return '#' + (0x1000000 + (Math.round((t - r) * p) + r) * 0x10000
+            + (Math.round((t - g) * p) + g) * 0x100 + (Math.round((t - b) * p) + b)).toString(16).slice(1);
+    }
+
+    static loadTheme() {
+        let custom = {};
         try {
             if (typeof OPEN_ADMIN_THEME !== 'undefined' && OPEN_ADMIN_THEME) {
                 custom = OPEN_ADMIN_THEME;
             }
-        } catch {}
-
+        } catch (e) {}
         const result = {...this.defaultTheme, ...custom};
-
-        // Auto-derive hover/click from primary if not explicitly set
         if (custom["primary-color"]) {
             if (!custom["primary-color-hover"]) {
-                result["primary-color-hover"] = ColorsUtils.lighten(result["primary-color"], 20);
+                result["primary-color-hover"] = ThemeUtils._lightenHex(result["primary-color"], 20);
             }
             if (!custom["primary-color-click"]) {
-                result["primary-color-click"] = ColorsUtils.lighten(result["primary-color"], -10);
+                result["primary-color-click"] = ThemeUtils._lightenHex(result["primary-color"], -10);
             }
         }
-
         return result;
     }
 
-    public static getColor(key: string): string | undefined {
+    static getColor(key) {
         return ThemeUtils.theme[key];
     }
 }
-
-

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

@@ -1,7 +1,6 @@
 export * from './DictUtils'
 export * from './PermUtils'
 export * from './PageUtils'
-export * from "./SysUtils"
 export * from './HttpUtils'
-export * from './FormRegistryUtils'
+export * from './FormRegistry'
 export * from './ThemeUtils'