@jari-ace/element-plus-component 0.3.2 → 0.3.4

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;
+        }
+    }
+}

package/packages/hooks/useProperties.ts

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

package/packages/hooks/useRoleCategories.ts

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

package/packages/hooks/useRoles.ts

@@ -0,0 +1,44 @@
+import {
+    createAxiosWithoutCache,
+    type ProjectedRole,
+    useRoleApi
+} from "@jari-ace/app-bolts";
+
+const rolesCache: Map<string, ProjectedRole[] | undefined> = new Map()
+let loadingPromises: Map<string, Promise<ProjectedRole[]>> = new Map()
+
+export function useRoles() {
+    return {
+        refreshRolesCache(appId: string) {
+            rolesCache.delete(appId)
+            console.log('roles cache cleared for app:', appId,  rolesCache.get(appId))
+        },
+        async getRoles(appId: string) {
+            let roles = rolesCache.get(appId);
+            if (roles) {
+                return roles;
+            }
+            let loadingPromise = loadingPromises.get(appId);
+            if (loadingPromise) {
+                return await loadingPromise
+            }
+            // 3. 没有缓存，也没有正在进行的请求，创建新请求
+            const axios = createAxiosWithoutCache();
+            const api = useRoleApi(axios);
+
+            // 创建 Promise
+            loadingPromise = api.getAllRole(appId)
+                                .then(result => {
+                                    rolesCache.set(appId, result);
+                                    return result;
+                                })
+                                .finally(() => {
+                                    loadingPromises.delete(appId);
+                                });
+            // 4. 将新创建的 Promise 存入 Map
+            loadingPromises.set(appId, loadingPromise);
+            // 5. 等待这个新的 Promise 完成并返回
+            return await loadingPromise;
+        }
+    }
+}

package/packages/index.ts

@@ -22,3 +22,12 @@ export * from "./hooks/useBridage"
 export * from "./hooks/useRealms"
 export * from "./hooks/useUserRefQuery"
 export * from "./hooks/useClassificationLevels"
+export * from "./hooks/useRoles"
+export * from "./hooks/useEntityPropDataTypes"
+export * from "./hooks/useConstraintProviders"
+export * from "./hooks/useFileConfigurations"
+export * from "./hooks/useNumberTemplates"
+export * from "./hooks/useEntities"
+export * from "./hooks/useGroups"
+export * from "./hooks/useRoleCategories"
+export * from "./hooks/useProperties"