@gadmin2n/schematics 0.0.64 → 0.0.66

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/helpers/utils.tsx

@@ -0,0 +1,5 @@
+import React from "react";
+
+export const renderLongColumnValue = (value: string) => {
+  return <div style={{ whiteSpace: "pre-wrap", wordBreak: "break-word" }}>{value}</div>;
+};

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/hooks/useDynamicResources.tsx

@@ -0,0 +1,211 @@
+import { useMemo, useRef } from "react";
+import type { IResourceItem, ResourceProps } from "@refinedev/core";
+import {
+  DashboardOutlined,
+  SettingOutlined,
+} from "@ant-design/icons";
+import { getRoutePath } from "config/routeRegistry";
+import { useUserPageAccess } from "./useUserPageAccess";
+import generatedResources from "generated/resources";
+
+/**
+ * Dynamic Resources Hook for erp-backend/web
+ *
+ * Features:
+ * 1. Get user accessible page resources from backend (via useUserPageAccess)
+ * 2. Convert backend data to Refine's IResourceItem[] format
+ * 3. Auto-generate show/edit/create paths for all pages
+ *
+ * Data Flow:
+ * useUserPageAccess → Accessible Pages → Resources → Sider Menu
+ *
+ * Performance:
+ * - Uses module-level cache - computed ONCE per page load
+ * - Returns same reference on every call after initial computation
+ * - Does NOT rebuild on route navigation or component re-renders
+ * - Permission changes require page refresh (handled by user)
+ */
+
+// Module-level cache - computed once per page load
+let cachedResources: IResourceItem[] | null = null;
+let isComputing = false;
+
+// 将 snake_case 转换为 camelCase
+function snakeToCamel(str: string): string {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+// Icon 映射：page.code 到 React Icon 组件
+export const iconMapping: Record<string, React.ReactNode> = {
+  dashboard: <DashboardOutlined />,
+  administration: <SettingOutlined />,
+};
+
+// Pages whose children are tabs (not separate menu items)
+const PAGES_WITH_TABS: string[] = [];
+
+export const useDynamicResources = (): IResourceItem[] => {
+  // Use shared page access data (single call, reused below)
+  const { accessiblePageIds, pagesData, pageMap, isLoading, roleNames } = useUserPageAccess();
+
+  // If we already have cached resources, return immediately
+  if (cachedResources !== null) {
+    return cachedResources;
+  }
+
+  // Return empty array while loading (will retry on next render)
+  if (isLoading || !pagesData || isComputing) {
+    return [];
+  }
+
+  // Mark as computing to prevent concurrent computation
+  isComputing = true;
+
+  if (import.meta.env.DEV) {
+    console.log('[useDynamicResources] 🔨 Computing resources (first time)');
+  }
+
+  // Filter accessible pages and build hierarchical sorted list
+  const accessiblePages = pagesData.filter(page => accessiblePageIds.has(page.id));
+
+  // Group pages by parentId
+  const pagesByParent = new Map<number | null, typeof accessiblePages>();
+  accessiblePages.forEach(page => {
+    const parentId = page.parentId ?? null;
+    if (!pagesByParent.has(parentId)) {
+      pagesByParent.set(parentId, []);
+    }
+    pagesByParent.get(parentId)!.push(page);
+  });
+
+  // Sort each group by sortOrder
+  pagesByParent.forEach(pages => {
+    pages.sort((a, b) => (a.sortOrder ?? Infinity) - (b.sortOrder ?? Infinity));
+  });
+
+  // Build sorted list using depth-first traversal
+  const sortedAccessiblePages: typeof accessiblePages = [];
+  const visited = new Set<number>();
+
+  const addPageWithChildren = (parentId: number | null) => {
+    const children = pagesByParent.get(parentId) || [];
+    children.forEach(page => {
+      if (visited.has(page.id)) return;
+      visited.add(page.id);
+      sortedAccessiblePages.push(page);
+      addPageWithChildren(page.id);
+    });
+  };
+
+  // Start from root level (parentId = null)
+  addPageWithChildren(null);
+
+  // Add any orphaned pages
+  accessiblePages.forEach(page => {
+    if (!visited.has(page.id)) {
+      sortedAccessiblePages.push(page);
+    }
+  });
+
+  // 检测哪些父页面有"index 子页面"（子页面路径与父页面相同，即 path: "" 的 index 路由）
+  // 这类父页面应作为纯分组节点（不注册 list 路径），否则 Refine 会优先选中父节点
+  // 导致 "全部" 等 index 子菜单项无法高亮
+  const parentIdsWithIndexChild = new Set<number>();
+  accessiblePages.forEach(childPage => {
+    if (!childPage.parentId) return;
+    const childPath = getRoutePath(childPage.code);
+    if (!childPath) return;
+    const parentPage = pageMap.get(childPage.parentId);
+    if (!parentPage) return;
+    const parentPath = getRoutePath(parentPage.code);
+    if (childPath === parentPath) {
+      parentIdsWithIndexChild.add(childPage.parentId);
+    }
+  });
+
+  // Build resources
+  const resultResources: IResourceItem[] = [];
+  const addedResourceNames = new Set<string>();
+
+  sortedAccessiblePages.forEach(page => {
+    if (!page) return;
+
+    // Skip virtual pages
+    if (page.isVirtual) return;
+
+    // Skip children of pages that use tabs
+    if (page.parentId) {
+      const parentPage = pageMap.get(page.parentId);
+      if (parentPage && PAGES_WITH_TABS.includes(parentPage.code)) {
+        return;
+      }
+    }
+
+    const permissionRes = snakeToCamel(page.code);
+
+    // Avoid duplicates
+    if (addedResourceNames.has(permissionRes)) return;
+
+    let parentPermissionRes: string | undefined;
+    if (page.parentId) {
+      const parentPage = pageMap.get(page.parentId);
+      if (parentPage) {
+        parentPermissionRes = snakeToCamel(parentPage.code);
+      }
+    }
+
+    // 优先从 routeRegistry 获取路径
+    // fallback 到 page.path（用于 gadmin2 页面）
+    const registryPath = getRoutePath(page.code);
+    const dbPath = page.path
+      ? page.path.startsWith("/") ? page.path : `/${page.path}`
+      : undefined;
+    const normalizedPath = registryPath ?? dbPath;
+
+    // 如果该页面是"有 index 子页面的父节点"，则不注册 list/show/edit/create
+    // 使其成为纯分组节点（SubMenu），子页面（如"全部"）的路径才负责 URL 匹配与菜单高亮
+    const isGroupParent = parentIdsWithIndexChild.has(page.id);
+
+    // Build resource item with auto-generated CRUD paths
+    // Store both zhLabel/enLabel in meta; Sider resolves at render time
+    const resource: IResourceItem = {
+      name: permissionRes,
+      ...(!isGroupParent && normalizedPath && {
+        list: normalizedPath,
+        show: `${normalizedPath}/show/:id`,
+        edit: `${normalizedPath}/edit/:id`,
+        create: `${normalizedPath}/create`,
+      }),
+      meta: {
+        label: page.enName || page.code,
+        zhLabel: page.zhName || page.code,
+        enLabel: page.enName || page.code,
+        icon: iconMapping[page.code] || "",
+        parent: parentPermissionRes,
+        route: normalizedPath,
+        pageCode: page.code,
+        parentPageCode: page.parentId
+          ? pageMap.get(page.parentId)?.code
+          : undefined,
+      },
+    };
+
+    resultResources.push(resource);
+    addedResourceNames.add(permissionRes);
+  });
+
+  // Build final resources array with auto-crud if needed
+  const dynamicResources = resultResources;
+  const allResources = dynamicResources;
+
+  // Cache the result - will be used for all subsequent calls
+  cachedResources = allResources;
+  isComputing = false;
+
+  if (import.meta.env.DEV) {
+    console.log('[useDynamicResources] ✅ Resources cached. Count:', cachedResources.length);
+    console.log('[useDynamicResources] 📌 This reference will be reused for all future calls');
+  }
+
+  return cachedResources;
+};

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/hooks/useFetchData.ts

@@ -0,0 +1,33 @@
+import { useEffect, useState } from "react";
+
+import { customRequest } from "helpers/login";
+
+export const useFetchData = (
+  url: string,
+  type: "post" | "get",
+  defaultQuery?: any,
+  disableReq?: any,
+  errorCallBack?: () => void
+) => {
+  const [data, setData] = useState<any>();
+  const [reqQuery, setReqQuery] = useState<any>(defaultQuery);
+  const [loading, setLoading] = useState<boolean>(false);
+  const fetchData = async (query?: any) => {
+    if (!url) return;
+    setLoading(true);
+    try {
+      const res = await customRequest(url, type, query);
+      setData(res);
+      setReqQuery(query);
+    } catch (error) {
+      console.error(error);
+      errorCallBack && errorCallBack();
+    }
+    setLoading(false);
+  };
+
+  useEffect(() => {
+    !disableReq && url && fetchData(defaultQuery);
+  }, []);
+  return { data, loading, fetchData, reqQuery };
+};

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/hooks/useRoles.ts

@@ -0,0 +1,30 @@
+import { useEffect, useState } from "react";
+
+import { useFetchData } from "./useFetchData";
+
+export interface RoleOption {
+  label: string;
+  value: string;
+}
+
+export const useRoles = () => {
+  const { data: rolesData, loading } = useFetchData("role/findMany", "post", {});
+  const [roleOptions, setRoleOptions] = useState<RoleOption[]>([]);
+
+  useEffect(() => {
+    if (rolesData?.data) {
+      const roles = Array.isArray(rolesData.data) ? rolesData.data : [];
+      const options = roles.map((role: any) => ({
+        label: `${role.name} (${role.description || ""})`,
+        value: role.name,
+      }));
+      setRoleOptions(options);
+    }
+  }, [rolesData]);
+
+  return {
+    roleOptions,
+    loading: loading || !rolesData,
+    rolesData,
+  };
+};

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/hooks/useUserPageAccess.ts

@@ -0,0 +1,339 @@
+import { useMemo, useState, useEffect, useRef, useCallback } from "react";
+import { customRequest } from "helpers/login";
+import type { Role } from "types/role";
+
+const RoleCacheKey = "oiterproles";
+const PagesCacheKey = "oiterpages";
+const RolePagesCacheKey = "oiterprolepages";
+const RolesDataCacheKey = "oiterprolesdatacache";
+
+/**
+ * Base Hook: User Page Access Data
+ *
+ * This hook fetches and provides user's accessible page data.
+ * It's designed to be reused by:
+ * - useDynamicResources (for menu generation)
+ * - Any other component that needs page access info
+ *
+ * Data Flow:
+ * SessionStorage(roles) → Role IDs → RolePages → Accessible Page IDs → Page Codes
+ */
+
+export interface Page {
+  id: number;
+  code: string;
+  name: string;
+  description?: string;
+  zhName?: string;
+  enName?: string;
+  iframeUrl?: string;
+  externalRedirectUrl?: string;
+  icon?: string;
+  path: string;
+  parentId?: number | null;
+  isVirtual?: boolean;
+  sortOrder: number;
+}
+
+interface RolePage {
+  id: number;
+  roleId: number;
+  pageId: number;
+}
+
+export interface UseUserPageAccessResult {
+  /** Set of page IDs the user can access */
+  accessiblePageIds: Set<number>;
+  /** Set of page codes the user can access */
+  accessiblePageCodes: Set<string>;
+  /** All pages data from backend */
+  pagesData: Page[] | null;
+  /** Role pages mapping data */
+  rolePagesData: RolePage[] | null;
+  /** Map of pageId -> Page object */
+  pageMap: Map<number, Page>;
+  /** Map of pageCode -> Page object */
+  pageCodeMap: Map<string, Page>;
+  /** User's role names */
+  roleNames: string[];
+  /** User's role IDs */
+  roleIds: number[];
+  /** Whether data is still loading */
+  isLoading: boolean;
+  /** Check if user can access a page by code */
+  canAccessPage: (pageCode: string) => boolean;
+}
+
+function readCache<T>(key: string): T | null {
+  try {
+    const raw = sessionStorage.getItem(key);
+    return raw ? (JSON.parse(raw) as T) : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(key: string, value: unknown): void {
+  try {
+    sessionStorage.setItem(key, JSON.stringify(value));
+  } catch {
+    // ignore quota errors
+  }
+}
+
+export const useUserPageAccess = (): UseUserPageAccessResult => {
+  // Role names — initialise from cache so first render is non-empty
+  const [roleNames, setRoleNames] = useState<string[]>(
+    () => readCache<string[]>(RoleCacheKey) ?? []
+  );
+  // isRoleLoading only stays true while we wait for the live /userinfo response
+  const [isRoleLoading, setIsRoleLoading] = useState(true);
+
+  // Data states — initialise from cache for instant first render
+  const [rolesData, setRolesData] = useState<Role[] | null>(
+    () => readCache<Role[]>(RolesDataCacheKey)
+  );
+  const [rolePagesData, setRolePagesData] = useState<RolePage[] | null>(
+    () => readCache<RolePage[]>(RolePagesCacheKey)
+  );
+  const [pagesData, setPagesData] = useState<Page[] | null>(
+    () => readCache<Page[]>(PagesCacheKey)
+  );
+
+  // Track previous roles to detect changes
+  const prevRolesRef = useRef<string>("");
+
+  // Function to update roles in state and sessionStorage
+  const updateRoles = useCallback((newRoles: string[]) => {
+    const rolesKey = JSON.stringify(newRoles.sort());
+    if (rolesKey !== prevRolesRef.current) {
+      console.log("[useUserPageAccess] Roles changed:", newRoles);
+      prevRolesRef.current = rolesKey;
+      setRoleNames(newRoles);
+      writeCache(RoleCacheKey, newRoles);
+    }
+  }, []);
+
+  // Step 1: Fetch roles directly from backend to ensure fresh data
+  useEffect(() => {
+    const fetchRolesFromBackend = async () => {
+      try {
+        const res = await customRequest<any>("userinfo", "GET", {});
+        const roles = res?.configPerms?.roles;
+        if (roles && Array.isArray(roles)) {
+          updateRoles(roles as string[]);
+        }
+      } catch (error) {
+        console.error("[useUserPageAccess] Failed to fetch roles from backend:", error);
+        // Fallback to sessionStorage if backend request fails
+        try {
+          const cached = readCache<string[]>(RoleCacheKey);
+          if (cached) {
+            updateRoles(cached);
+          }
+        } catch (e) {
+          console.error("[useUserPageAccess] Failed to parse cached roles:", e);
+        }
+      } finally {
+        setIsRoleLoading(false);
+      }
+    };
+
+    fetchRolesFromBackend();
+  }, [updateRoles]);
+
+  // Step 2: Fetch all page definitions
+  useEffect(() => {
+    const fetchPages = async () => {
+      try {
+        const res = await customRequest<any>("page/findMany", "post", {});
+        const pages = res?.data as Page[];
+        // Keep existing reference if page IDs haven't changed — prevents
+        // downstream memos (accessiblePageIds, dynamicResources, allResources)
+        // from rebuilding and giving Refine a new resources prop.
+        setPagesData(prev => {
+          if (prev && prev.length === pages.length &&
+              prev.every((p, i) => p.id === pages[i].id)) {
+            return prev;
+          }
+          writeCache(PagesCacheKey, pages);
+          return pages;
+        });
+      } catch (error) {
+        console.error("[useUserPageAccess] Failed to fetch pages:", error);
+      }
+    };
+    fetchPages();
+  }, []);
+
+  // Step 3: Fetch role IDs when roleNames are available
+  useEffect(() => {
+    if (roleNames.length === 0) {
+      setRolesData(null);
+      return;
+    }
+
+    const fetchRoles = async () => {
+      try {
+        const query = {
+          where: { name: { in: roleNames } },
+          select: { id: true, name: true },
+        };
+        const res = await customRequest<any>("role/findMany", "post", query);
+        const roles = res?.data as Role[];
+        setRolesData(roles);
+        writeCache(RolesDataCacheKey, roles);
+      } catch (error) {
+        console.error("[useUserPageAccess] Failed to fetch roles:", error);
+      }
+    };
+    fetchRoles();
+  }, [roleNames.join(",")]);
+
+  // Calculate roleIds
+  const roleIds = useMemo(() => {
+    if (!rolesData) return [];
+    return rolesData.map(role => role.id);
+  }, [rolesData]);
+
+  // Step 4: Fetch role-page relationships when roleIds are available
+  useEffect(() => {
+    if (roleIds.length === 0) {
+      setRolePagesData(null);
+      return;
+    }
+
+    const fetchRolePages = async () => {
+      try {
+        const query = { where: { roleId: { in: roleIds } } };
+        const res = await customRequest<any>("rolePages/findMany", "post", query);
+        const rolePages = res?.data as RolePage[];
+        // Same stable-reference trick: keep existing ref if content unchanged.
+        setRolePagesData(prev => {
+          if (prev && prev.length === rolePages.length &&
+              prev.every((rp, i) => rp.id === rolePages[i].id)) {
+            return prev;
+          }
+          writeCache(RolePagesCacheKey, rolePages);
+          return rolePages;
+        });
+      } catch (error) {
+        console.error("[useUserPageAccess] Failed to fetch rolePages:", error);
+      }
+    };
+
+    fetchRolePages();
+  }, [roleIds.join(",")]);
+
+  // Build page maps
+  const { pageMap, pageCodeMap } = useMemo(() => {
+    const idMap = new Map<number, Page>();
+    const codeMap = new Map<string, Page>();
+
+    if (pagesData) {
+      pagesData.forEach(page => {
+        idMap.set(page.id, page);
+        codeMap.set(page.code, page);
+      });
+    }
+
+    return { pageMap: idMap, pageCodeMap: codeMap };
+  }, [pagesData]);
+
+  // Track previous accessiblePageIds to prevent unnecessary reference changes
+  const prevAccessiblePageIdsRef = useRef<Set<number>>(new Set());
+
+  // Build accessible page IDs (with ancestor pages)
+  const accessiblePageIds = useMemo(() => {
+    const ids = new Set<number>();
+
+    if (!rolePagesData || !pagesData) {
+      return prevAccessiblePageIdsRef.current;
+    }
+
+    // Add directly accessible pages
+    rolePagesData.forEach(rolePage => {
+      ids.add(rolePage.pageId);
+    });
+
+    // Recursively add ancestor pages
+    const addAncestorPages = (pageId: number, visited: Set<number>) => {
+      if (visited.has(pageId)) return;
+      visited.add(pageId);
+
+      const page = pageMap.get(pageId);
+      if (!page) return;
+
+      if (page.parentId) {
+        ids.add(page.parentId);
+        addAncestorPages(page.parentId, visited);
+      }
+    };
+
+    const originalIds = Array.from(ids);
+    const visited = new Set<number>();
+    originalIds.forEach(pageId => {
+      addAncestorPages(pageId, visited);
+    });
+
+    // Keep existing reference if IDs haven't changed
+    const prev = prevAccessiblePageIdsRef.current;
+    if (prev.size === ids.size && Array.from(ids).every(id => prev.has(id))) {
+      return prev;
+    }
+
+    prevAccessiblePageIdsRef.current = ids;
+    return ids;
+  }, [rolePagesData, pagesData, pageMap]);
+
+  // Build accessible page codes
+  const accessiblePageCodes = useMemo(() => {
+    const codes = new Set<string>();
+
+    accessiblePageIds.forEach(pageId => {
+      const page = pageMap.get(pageId);
+      if (page) {
+        codes.add(page.code);
+      }
+    });
+
+    return codes;
+  }, [accessiblePageIds, pageMap]);
+
+  // Check if user can access a specific page
+  const canAccessPage = useMemo(() => {
+    return (pageCode: string): boolean => {
+      return accessiblePageCodes.has(pageCode);
+    };
+  }, [accessiblePageCodes]);
+
+  // Calculate loading state
+  // If we have cached data, isLoading is false even while background-refreshing
+  const hasCache = useMemo(
+    () => !!(readCache(PagesCacheKey) && readCache(RolePagesCacheKey)),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
+
+  const isLoading = useMemo(() => {
+    // If cache was available on mount, never block rendering
+    if (hasCache && pagesData && rolePagesData) return false;
+    if (isRoleLoading) return true;
+    if (!pagesData) return true;
+    if (roleNames.length > 0 && roleIds.length > 0 && !rolePagesData) return true;
+    return false;
+  }, [isRoleLoading, pagesData, roleNames, roleIds, rolePagesData, hasCache]);
+
+  return {
+    accessiblePageIds,
+    accessiblePageCodes,
+    pagesData,
+    rolePagesData,
+    pageMap,
+    pageCodeMap,
+    roleNames,
+    roleIds,
+    isLoading,
+    canAccessPage,
+  };
+};

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/i18n.ts

@@ -1,19 +1,23 @@
 import i18n from "i18next";
 import { initReactI18next } from "react-i18next";
-import Backend from "i18next-xhr-backend";
 import detector from "i18next-browser-languagedetector";
+import en from "./locales/en/common.json";
+import zh_CN from "./locales/zh_CN/common.json";
 
 i18n
-  .use(Backend)
   .use(detector)
   .use(initReactI18next)
   .init({
     supportedLngs: ["en", "zh_CN"],
-    backend: {
-      loadPath: "/locales/{{lng}}/{{ns}}.json",
+    resources: {
+      en: { common: en },
+      zh_CN: { common: zh_CN },
     },
     defaultNS: "common",
     fallbackLng: ["en", "zh_CN"],
+    react: {
+      useSuspense: false,
+    },
   });
 
 export default i18n;

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/index.tsx

@@ -1,7 +1,6 @@
 import React from 'react';
 import { createRoot } from 'react-dom/client';
 
-import reportWebVitals from './reportWebVitals';
 import App from './App';
 import './i18n';
 
@@ -14,15 +13,8 @@ if (!checkLogin()) {
   const root = createRoot(container);
 
   root.render(
-    <React.StrictMode>
-      <React.Suspense fallback='loading'>
-        <App />
-      </React.Suspense>
-    </React.StrictMode>
+    <React.Suspense fallback='loading'>
+      <App />
+    </React.Suspense>
   );
 }
-
-// If you want to start measuring performance in your app, pass a function
-// to log results (for example: reportWebVitals(console.log))
-// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
-reportWebVitals();

package/dist/lib/application/files/gadmin2-game-angle-demo/web/{public → src}/locales/en/common.json

@@ -15,7 +15,7 @@
       "buttons": {
         "submit": "Login",
         "forgotPassword": "Forgot password?",
-        "noAccount": "Don’t have an account?",
+        "noAccount": "Don't have an account?",
         "rememberMe": "Remember me"
       }
     },

package/dist/lib/application/files/gadmin2-game-angle-demo/web/{public → src}/locales/zh_CN/common.json

@@ -15,7 +15,7 @@
       "buttons": {
         "submit": "Login",
         "forgotPassword": "Forgot password?",
-        "noAccount": "Don’t have an account?",
+        "noAccount": "Don't have an account?",
         "rememberMe": "Remember me"
       }
     },

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/audit/components/action-cell.css

@@ -0,0 +1,3 @@
+.highlight-changed-row {
+  background-color: #fff2f0;
+}