@jari-ace/element-plus-component 0.3.1 → 0.3.3

package/packages/components/userGroupTree/src/userGroupTree.vue

@@ -18,7 +18,7 @@
 import {computed, ref, shallowReactive, watch} from "vue";
 import {
     createAxiosWithoutCache,
-    type Group,
+    type Group, type ProjectedGroup,
     useAppApi,
     useLoading,
     useUserGroupApi,
@@ -26,20 +26,47 @@ import {
 import {type TreeNodeType, useTreeData} from "../../../hooks/useTreeData";
 import {ElOption, ElSelect, ElTree, vLoading} from "element-plus";
 import type {TreeNodeData} from "element-plus/es/components/tree/src/tree.type";
+import {useAppInstances} from "../../../hooks/useAppInstances";
+import {useGroups} from "../../../hooks/useGroups";
 
 interface Props {
+    /**
+     * 用户域ID
+     */
     realmId?: string;
+    /**
+     * 是否多选
+     */
     multiple?: boolean;
+    /**
+     * 是否显示控制台应用
+     */
     showConsoleApp?: boolean
+    /**
+     * 只显示指定应用下的用户组（不可自选应用）
+     */
     appId?: string;
+    /**
+     * 节点高度
+     */
     nodeHeight?: string;
+    /**
+     * 业务类别
+     */
+    category?: string;
+    /**
+     * 是否全局用户组
+     */
+    global?: boolean;
+    /**
+     * 是否显示所有分类
+     */
+    showAllCategory? :boolean;
 }
 
 const groupTree = ref<typeof ElTree>();
 const axios = createAxiosWithoutCache()
 const loading = useLoading(axios);
-const departmentApi = useUserGroupApi(axios);
-const appApi = useAppApi(axios);
 const props = withDefaults(defineProps<Props>(), {nodeHeight: 'auto'});
 const emits = defineEmits(["change", "loaded"]);
 const selected = defineModel<Group | null>();
@@ -53,23 +80,28 @@ const id = computed({
     }
 })
 
-const [globalApp, apps] = await Promise.all([
-    appApi.getGlobalApp(),
-    appApi.getAccessible()
+const {getGlobal, getAccessible} = useAppInstances()
+const {getGroups, getGlobalGroups} = useGroups()
+
+let [globalApp, _apps] = await Promise.all([
+    getGlobal(),
+    getAccessible(),
 ])
+_apps = [..._apps];
+_apps.unshift(globalApp);
 
-apps.unshift(globalApp);
 if (!props.showConsoleApp) {
-    const index = apps.findIndex(a => a.name == "ace-app-manage");
+    const index = _apps.findIndex(a => a.name == "ace-app-manage");
     if (index >= 0) {
-        apps.splice(index, 1);
+        _apps.splice(index, 1);
     }
 }
+const apps = ref(_apps)
+
 if (!currentApp.value) {
     currentApp.value = globalApp.id;
 }
 
-
 const state = shallowReactive<{
     groups: (TreeNodeType & Group)[];
 }>({
@@ -78,7 +110,12 @@ const state = shallowReactive<{
 
 const getList = async () => {
     if (!props.realmId || !currentApp.value) return;
-    const res = await departmentApi.getByAppIdAndRealm(currentApp.value, props.realmId);
+    let res: ProjectedGroup[]
+    if (props.global) {
+        res = await getGlobalGroups(props.realmId);
+    } else {
+        res = await getGroups(currentApp.value, props.realmId, props.category, props.showAllCategory);
+    }
     state.groups = [
         ...useTreeData<Group>(res, "name"),
     ];
@@ -94,25 +131,25 @@ const currentChange = (data: TreeNodeType & Group) => {
 };
 
 watch(
-    () => props.realmId,
+    () => (
+        {appId: props.appId, realmId: props.realmId, category: props.category}
+    ),
     () => {
         //重新获取
         getList();
+    }, {
+        deep: true,
+        immediate: true,
     }
 );
 watch(() => props.appId, () => {
     currentApp.value = props.appId;
 })
-watch(currentApp, () => {
-    getList();
-})
 
 defineExpose({
     reload: getList,
     elTree: groupTree
 });
-
-getList();
 </script>
 
 <style lang="scss" scoped>

package/packages/components/userSelectDialog/src/userSelectDialog.vue

@@ -351,7 +351,7 @@ defineExpose({
                 </el-tab-pane>
                 <el-tab-pane name="group" label="按用户组">
                     <el-scrollbar height="400">
-                        <ja-user-group-tree v-model="currentGroup"
+                        <ja-user-group-tree v-model="currentGroup" show-all-category
                                             :realm-id="localRealmId"></ja-user-group-tree>
                     </el-scrollbar>
                 </el-tab-pane>

package/packages/hooks/useAppInstances.ts

@@ -1,34 +1,130 @@
-import {type AppInstance, createAxiosWithoutCache, useAppApi} from "@jari-ace/app-bolts";
+import {
+    type AppInstance,
+    createAxiosWithoutCache,
+    type IAceAxios,
+    useAppApi
+} from "@jari-ace/app-bolts";
+import {ref, readonly, type Ref} from 'vue'; // 1. 引入 ref 和 readonly
 
+type LoadType = "all" | "accessible" | "manageable" | "global"
+const appCache: Map<LoadType, AppInstance[]> = new Map()
+const promises: Map<LoadType, Promise<AppInstance[]>> = new Map();
 
-let appCache: AppInstance[] = [];
+let axios: IAceAxios = null
+let api: ReturnType<typeof useAppApi>
 
-export async function useAppInstances() {
-    const axios = createAxiosWithoutCache()
-    const api = useAppApi(axios)
-    if (appCache.length === 0) {
-        appCache = await api.getAll(true);
+async function loadApps(load: () => Promise<AppInstance[]>, loadType: LoadType): Promise<AppInstance[]> {
+    let result = appCache.get(loadType)
+    // 如果已经有数据或正在加载，则直接返回
+    if (result) {
+        return result;
     }
-    return {
-        async getById(appId: string) {
-            let app = appCache.find(a => a.id === appId);
-            if (!app) {
-                app = await api.getById(appId);
-                if (app) {
-                    appCache.push(app);
-                }
+    let promise = promises.get(loadType)
+    if (promise) {
+        return await promise;
+    }
+    promise = load()
+        .then(data => {
+            appCache.set(loadType, data)
+            return data;
+        })
+        .finally(() => {
+            // 成功后也重置，但保留数据
+            promises.delete(loadType)
+        });
+    promises.set(loadType, promise)
+    return await promise;
+}
+
+async function getAll(includeConsoleApp?: boolean) {
+    if (!api) {
+        axios = axios || createAxiosWithoutCache();
+        api = api || useAppApi(axios);
+    }
+    const apps =await loadApps(() => api.getAll(true), "all");
+    if (includeConsoleApp) {
+        return apps
+    } else {
+        return apps.filter(a=>a.name !== 'ace-app-manage')
+    }
+}
+async function getById(appId: string) {
+    if (!api) {
+        axios = axios || createAxiosWithoutCache();
+        api = api || useAppApi(axios);
+    }
+    await loadApps(() => api.getAll(true), "all")
+    let app = appCache.get("all").find(a => a.id === appId);
+    if (!app) {
+        axios = axios || createAxiosWithoutCache();
+        api = api || useAppApi(axios);
+        app = await api.getById(appId);
+        if (app) {
+            if (!appCache.get("all").find(a => a.id === app.id)) {
+                appCache.get("all").push(app); // 这将触发UI更新
             }
-            return app;
-        },
-        async getByName(appName: string) {
-            let app = appCache.find(a => a.name === appName);
-            if (!app) {
-                app = await api.getByName(appName);
-                if (app) {
-                    appCache.push(app);
-                }
+        }
+    }
+    return app;
+}
+async function getByName(appName: string) {
+    if (!api) {
+        axios = axios || createAxiosWithoutCache();
+        api = api || useAppApi(axios);
+    }
+    await loadApps(() => api.getAll(true), "all")
+    let app = appCache.get("all").find(a => a.name === appName);
+    if (!app) {
+        axios = axios || createAxiosWithoutCache();
+        api = api || useAppApi(axios);
+        app = await api.getByName(appName);
+        if (app) {
+            if (!appCache.get("all").find(a => a.id === app.id)) {
+                appCache.get("all").push(app);
             }
-            return app;
         }
     }
+    return app;
+}
+
+async function getManageable() {
+    if (!api) {
+        axios = axios || createAxiosWithoutCache();
+        api = api || useAppApi(axios);
+    }
+    return await loadApps(api.getManageable, "manageable")
+}
+
+async function getAccessible() {
+    if (!api) {
+        axios = axios || createAxiosWithoutCache();
+        api = api || useAppApi(axios);
+    }
+    return await loadApps(api.getAccessible, "accessible")
+}
+
+async function getGlobal() {
+    if (!api) {
+        axios = axios || createAxiosWithoutCache();
+        api = api || useAppApi(axios);
+    }
+    return (await loadApps(()=> api.getGlobalApp().then(a=>[a]), "global"))[0]
+}
+
+async function refresh() {
+    appCache.clear()
+    await Promise.all([getAll(), getManageable(), getAccessible(), getGlobal()])
+}
+
+// --- 导出的 Hook (非 async) ---
+export function useAppInstances() {
+    return {
+        getAll,
+        getByName,
+        getById,
+        getManageable,
+        getAccessible,
+        getGlobal,
+        refresh
+    };
 }

package/packages/hooks/useClassificationLevels.ts

@@ -5,15 +5,38 @@ import {
 } from "@jari-ace/app-bolts";
 import {ref} from "vue";
 
-const levelList = ref<ClassificationLevelList>()
+let levelList = ref<ClassificationLevelList>()
+let loadingPromise: Promise<ClassificationLevelList> = undefined
 
 async function loadLevels(serviceName: string) {
-    if (!levelList.value) {
-        if (!serviceName) serviceName = 'ace-global-app'
-        const axios = createAxiosWithoutCache()
-        const api = useAppServiceApi(axios)
-        levelList.value = await api.getClassificationLevels(serviceName)
+    if (levelList.value) {
+        return levelList.value
     }
+    if (loadingPromise) {
+        return await loadingPromise
+    }
+    if (!serviceName) serviceName = 'ace-global-app'
+    const axios = createAxiosWithoutCache()
+    const api = useAppServiceApi(axios)
+    loadingPromise = api.getClassificationLevels(serviceName)
+                        .then(levels => {
+                            if (levels) {
+                                // 检查并按 value 倒序排序 system 数组
+                                if (levels.system) {
+                                    // 修改点：b.value - a.value 实现降序
+                                    levels.system.sort((a, b) => b.value - a.value);
+                                }
+                                // 检查并按 value 倒序排序 user 数组
+                                if (levels.user) {
+                                    // 修改点：b.value - a.value 实现降序
+                                    levels.user.sort((a, b) => b.value - a.value);
+                                }
+                            }
+                            levelList.value = levels
+                            return levels
+                        })
+                        .finally(() => loadingPromise = undefined)
+    return await loadingPromise;
 }
 
 /**
@@ -47,11 +70,12 @@ export async function useUserClassificationLevelMap(serviceName?: string) {
     }
     return map;
 }
+
 /**
  * 获取系统密级反向映射，可以根据密级获取密级对应的中文标签
  * @param serviceName 服务名
  */
-export async function useSystemClassificationLevelMap(serviceName?: string){
+export async function useSystemClassificationLevelMap(serviceName?: string) {
     await loadLevels(serviceName);
     const map = new Map<number, string>()
     for (let i = 0; i < levelList.value.system.length; i++) {

package/packages/hooks/useConstraintProviders.ts

@@ -0,0 +1,36 @@
+import {
+    type ConstraintProvider,
+    createAxiosWithoutCache, useConstraintApi
+} from "@jari-ace/app-bolts";
+
+let cache: ConstraintProvider[] = null
+let loadingPromise:Promise<ConstraintProvider[]> =  undefined
+
+export function useConstraintProviders() {
+    return {
+        async getConstraintProviders() {
+            let dataTypes = cache;
+            if (dataTypes) {
+                return dataTypes;
+            }
+            if (loadingPromise) {
+                return await loadingPromise
+            }
+            // 3. 没有缓存，也没有正在进行的请求，创建新请求
+            const axios = createAxiosWithoutCache();
+            const api = useConstraintApi(axios);
+
+            // 创建 Promise
+            loadingPromise = api.getConstraintProviders()
+                                .then(result => {
+                                    // 缓存结果
+                                    cache = result
+                                    return result;
+                                })
+                                .finally(() => {
+                                    loadingPromise = undefined
+                                });
+            return await loadingPromise;
+        }
+    }
+}

package/packages/hooks/useEntities.ts

@@ -0,0 +1,44 @@
+import {
+    createAxiosWithoutCache, type EntityDefinitionReference, useEntityApi
+} from "@jari-ace/app-bolts";
+
+const cache: Map<string, EntityDefinitionReference[] | undefined> = new Map()
+let loadingPromises: Map<string, Promise<EntityDefinitionReference[]>> = new Map()
+
+/**
+ * 实体定义信息加载Hooks
+ */
+export function useEntities() {
+    return {
+        refreshEntitiesCache(datasourceId: string) {
+            cache.delete(datasourceId)
+        },
+        async getEntities(datasourceId: string) {
+            let entities = cache.get(datasourceId);
+            if (entities) {
+                return entities;
+            }
+            let loadingPromise = loadingPromises.get(datasourceId);
+            if (loadingPromise) {
+                return await loadingPromise
+            }
+            // 3. 没有缓存，也没有正在进行的请求，创建新请求
+            const axios = createAxiosWithoutCache();
+            const api = useEntityApi(axios);
+
+            // 创建 Promise
+            loadingPromise = api.getAll(datasourceId)
+                                .then(result => {
+                                    cache.set(datasourceId, result);
+                                    return result;
+                                })
+                                .finally(() => {
+                                    loadingPromises.delete(datasourceId);
+                                });
+            // 4. 将新创建的 Promise 存入 Map
+            loadingPromises.set(datasourceId, loadingPromise);
+            // 5. 等待这个新的 Promise 完成并返回
+            return await loadingPromise;
+        }
+    }
+}

package/packages/hooks/useEntityPropDataTypes.ts

@@ -0,0 +1,37 @@
+
+
+import {
+    createAxiosWithoutCache, type PropertyDataType, useEntityApi
+} from "@jari-ace/app-bolts";
+
+let cache: Partial<Record<PropertyDataType, string>> = null
+let loadingPromise:Promise<Partial<Record<PropertyDataType, string>>> =  undefined
+
+export function useEntityPropDataTypes() {
+    return {
+        async getDataTypes() {
+            let dataTypes = cache;
+            if (dataTypes) {
+                return dataTypes;
+            }
+            if (loadingPromise) {
+                return await loadingPromise
+            }
+            // 3. 没有缓存，也没有正在进行的请求，创建新请求
+            const axios = createAxiosWithoutCache();
+            const api = useEntityApi(axios);
+
+            // 创建 Promise
+            loadingPromise = api.getPropertyDataTypes()
+                                .then(result => {
+                                    // 缓存结果
+                                    cache = result
+                                    return result;
+                                })
+                                .finally(() => {
+                                    loadingPromise = undefined
+                                });
+            return await loadingPromise;
+        }
+    }
+}

package/packages/hooks/useFileConfigurations.ts

@@ -0,0 +1,41 @@
+import {
+    createAxiosWithoutCache, type ProjectedFileConfiguration, useFileConfigurationApi,
+} from "@jari-ace/app-bolts";
+
+const cache: Map<string, ProjectedFileConfiguration[] | undefined> = new Map()
+let loadingPromises: Map<string, Promise<ProjectedFileConfiguration[]>> = new Map()
+
+export function useFileConfigurations() {
+    return {
+        refreshFileConfigurationCache(serviceName: string) {
+            cache.delete(serviceName)
+        },
+        async getFileConfigurations(serviceName: string) {
+            let roles = cache.get(serviceName);
+            if (roles) {
+                return roles;
+            }
+            let loadingPromise = loadingPromises.get(serviceName);
+            if (loadingPromise) {
+                return await loadingPromise
+            }
+            // 3. 没有缓存，也没有正在进行的请求，创建新请求
+            const axios = createAxiosWithoutCache();
+            const api = useFileConfigurationApi(axios);
+
+            // 创建 Promise
+            loadingPromise = api.getByAppService(serviceName, 0, 9999999)
+                                .then(result => {
+                                    cache.set(serviceName, result.content);
+                                    return result.content;
+                                })
+                                .finally(() => {
+                                    loadingPromises.delete(serviceName);
+                                });
+            // 4. 将新创建的 Promise 存入 Map
+            loadingPromises.set(serviceName, loadingPromise);
+            // 5. 等待这个新的 Promise 完成并返回
+            return await loadingPromise;
+        }
+    }
+}

package/packages/hooks/useGroups.ts

@@ -0,0 +1,81 @@
+import {
+    createAxiosWithoutCache, type ProjectedGroup,
+    useUserGroupApi
+} from "@jari-ace/app-bolts";
+
+const rolesCache: Map<string, ProjectedGroup[] | undefined> = new Map()
+let loadingPromises: Map<string, Promise<ProjectedGroup[]>> = new Map()
+
+function getKey(appId: string, realmId: string, category?: string, showAllCategory?: boolean) {
+    return appId +":" + realmId + ":" + (category ?? "") + ":" + (showAllCategory ? "all" : "by-category");
+}
+
+export function useGroups() {
+    return {
+        refreshGroupsCache() {
+            rolesCache.clear();
+        },
+        async getGroups(appId: string, realmId: string, category?: string, showAllCategory?: boolean) {
+            const key = getKey(appId, realmId, category, showAllCategory);
+            let groups = rolesCache.get(key);
+            if (groups) {
+                return groups;
+            }
+            let loadingPromise = loadingPromises.get(key);
+            if (loadingPromise) {
+                return await loadingPromise
+            }
+            // 3. 没有缓存，也没有正在进行的请求，创建新请求
+            const axios = createAxiosWithoutCache();
+            const api = useUserGroupApi(axios);
+
+            // 创建 Promise
+            if (showAllCategory) {
+                loadingPromise = api.getAll(appId, realmId)
+            } else {
+                loadingPromise = api.getByAppIdAndRealm(appId, realmId, category)
+            }
+            loadingPromise = loadingPromise
+                                .then(result => {
+                                    rolesCache.set(key, result);
+                                    return result;
+                                })
+                                .finally(() => {
+                                    loadingPromises.delete(key);
+                                });
+            // 4. 将新创建的 Promise 存入 Map
+            loadingPromises.set(key, loadingPromise);
+            // 5. 等待这个新的 Promise 完成并返回
+            return await loadingPromise;
+        },
+        async getGlobalGroups(realmId: string, category?: string) {
+            const appId = "[global-app]"
+            const key = getKey(appId, realmId, category, true);
+            let groups = rolesCache.get(key);
+            if (groups) {
+                return groups;
+            }
+            let loadingPromise = loadingPromises.get(key);
+            if (loadingPromise) {
+                return await loadingPromise
+            }
+            // 3. 没有缓存，也没有正在进行的请求，创建新请求
+            const axios = createAxiosWithoutCache();
+            const api = useUserGroupApi(axios);
+
+            // 创建 Promise
+            loadingPromise = api.getGlobalGroups(realmId, category)
+                                .then(result => {
+                                    rolesCache.set(key, result);
+                                    return result;
+                                })
+                                .finally(() => {
+                                    loadingPromises.delete(key);
+                                });
+            // 4. 将新创建的 Promise 存入 Map
+            loadingPromises.set(key, loadingPromise);
+            // 5. 等待这个新的 Promise 完成并返回
+            return await loadingPromise;
+        }
+    }
+}

package/packages/hooks/useNumberTemplates.ts

@@ -0,0 +1,43 @@
+import {
+    createAxiosWithoutCache, type ProjectedFileConfiguration,
+    type ProjectedStringIdTemplate, useFileConfigurationApi,
+    useStringIdTemplateApi,
+} from "@jari-ace/app-bolts";
+
+const cache: Map<string, ProjectedStringIdTemplate[] | undefined> = new Map()
+let loadingPromises: Map<string, Promise<ProjectedStringIdTemplate[]>> = new Map()
+
+export function useNumberTemplates() {
+    return {
+        refreshNumberTemplatesCache(appName: string) {
+            cache.delete(appName)
+        },
+        async getNumberTemplates(appName: string) {
+            let roles = cache.get(appName);
+            if (roles) {
+                return roles;
+            }
+            let loadingPromise = loadingPromises.get(appName);
+            if (loadingPromise) {
+                return await loadingPromise
+            }
+            // 3. 没有缓存，也没有正在进行的请求，创建新请求
+            const axios = createAxiosWithoutCache();
+            const api = useStringIdTemplateApi(axios);
+
+            // 创建 Promise
+            loadingPromise = api.getByApp(appName, 0, 9999999)
+                                .then(result => {
+                                    cache.set(appName, result.content);
+                                    return result.content;
+                                })
+                                .finally(() => {
+                                    loadingPromises.delete(appName);
+                                });
+            // 4. 将新创建的 Promise 存入 Map
+            loadingPromises.set(appName, loadingPromise);
+            // 5. 等待这个新的 Promise 完成并返回
+            return await loadingPromise;
+        }
+    }
+}