@spacecorexdev/core 0.0.2 → 0.0.5

package/src/utils/CachePermissionInfo.ts

@@ -0,0 +1,235 @@
+'use strict';
+
+import Dexie, { Table } from 'dexie';
+import { API } from "../api";
+import { ResponseCode } from "../api/_base";
+import { CacheUserInfo } from './CacheUserInfo';
+
+/**
+ * 系统权限标识常量（统一存放点）
+ * 权限 key 需与后端权限配置（permissions.const.ts 中 URL → 权限映射）保持一致；
+ * 后续新增权限标识统一在此扩展，业务代码直接 import 使用，避免硬编码散落各处。
+ */
+/** 发票列表查看权限（/api/approval/invoice/list） */
+export const PERMISSION_INVOICE_LIST = 'approver:approvalinvoice:getInvoiceList';
+
+/** 项目文件夹打包下载权限 （/api/project/files/downloadFolder）*/
+export const PERMISSION_FOLDER_DOWNLOAD = 'project:projectfile:downloadFolderPermission';
+
+/** CRM 新建客户权限（/api/crm/customer/createCustomer） */
+export const PERMISSION_CRM_CREATE = 'crm:customer:createCustomer';
+/** CRM 编辑客户权限（/api/crm/customer/updateCustomer） */
+export const PERMISSION_CRM_UPDATE = 'crm:customer:updateCustomer';
+/** CRM 删除客户权限（/api/crm/customer/deleteCustomer） */
+export const PERMISSION_CRM_DELETE = 'crm:customer:deleteCustomer';
+/** CRM 查看客户联系方式明文权限（/api/crm/customer/viewContact）；客户负责业务员无需此权限 */
+export const PERMISSION_CRM_VIEW_CONTACT = 'crm:customer:viewContact';
+/** CRM 客户移交权限（/api/crm/customer/transferCustomer） */
+export const PERMISSION_CRM_TRANSFER = 'crm:customer:transferCustomer';
+/** CRM 客户文件查看权限（/api/crm/file/viewFile）；客户负责人无需此权限 */
+export const PERMISSION_CRM_VIEW_FILE = 'crm:file:viewFile';
+/** CRM 客户文件管理权限（/api/crm/file/manageFile）：上传、重命名、移动、删除；客户负责人无需此权限 */
+export const PERMISSION_CRM_MANAGE_FILE = 'crm:file:manageFile';
+
+const CACHE_EXPIRATION_MS = 10 * 60 * 1000;
+
+export interface PermissionInfo {
+  permission: string;
+  descs: string;
+}
+
+interface PermissionCache {
+  id: string;
+  data: PermissionInfo[];
+  timestamp: number;
+}
+
+class PermissionInfoDatabase extends Dexie {
+  permissionCache!: Table<PermissionCache, string>;
+
+  constructor() {
+    super('PermissionInfoDB');
+    this.version(1).stores({
+      permissionCache: 'id, timestamp'
+    });
+  }
+}
+
+const db = new PermissionInfoDatabase();
+
+const getFromCache = async (userId: string): Promise<PermissionInfo[] | null> => {
+  try {
+    const cached = await db.permissionCache.get(`PERMISSION_${userId}`);
+    if (cached) {
+      const now = Date.now();
+      if (now - cached.timestamp < CACHE_EXPIRATION_MS) {
+        return cached.data;
+      }
+      await db.permissionCache.delete(`PERMISSION_${userId}`);
+    }
+    return null;
+  } catch (error) {
+    console.error('读取权限缓存失败:', error);
+    return null;
+  }
+};
+
+const setToCache = async (userId: string, data: PermissionInfo[]): Promise<void> => {
+  try {
+    await db.permissionCache.put({
+      id: `PERMISSION_${userId}`,
+      data,
+      timestamp: Date.now()
+    });
+  } catch (error) {
+    console.error('写入权限缓存失败:', error);
+  }
+};
+
+const clearCache = async (userId?: string): Promise<void> => {
+  try {
+    if (userId) {
+      await db.permissionCache.delete(`PERMISSION_${userId}`);
+    } else {
+      await db.permissionCache.clear();
+    }
+  } catch (error) {
+    console.error('清除权限缓存失败:', error);
+  }
+};
+
+const getUserPermissions = async (
+  {
+    userId,
+    forceRefresh = false
+  }: {
+    userId?: string,
+    forceRefresh?: boolean
+  }
+): Promise<PermissionInfo[] | null> => {
+  const user = userId ? { id: userId } : await CacheUserInfo.getUserInfo({});
+  if (!user) {
+    return null;
+  }
+
+  const uid = user.id;
+
+  if (!forceRefresh) {
+    const cachedPermissions = await getFromCache(uid);
+    if (cachedPermissions) {
+      return cachedPermissions;
+    }
+  }
+
+  const res = await API.user.role.listUserPermissions({ user_id: uid });
+
+  if (res?.code !== ResponseCode.SUCCESS) {
+    return null;
+  }
+
+  const permissions = res.data || [];
+
+  await setToCache(uid, permissions);
+
+  return permissions;
+};
+
+const hasPermission = async (
+  {
+    permission,
+    userId,
+    forceRefresh = false
+  }: {
+    permission: string,
+    userId?: string,
+    forceRefresh?: boolean
+  }
+): Promise<boolean> => {
+  const permissions = await getUserPermissions({ userId, forceRefresh });
+
+  if (!permissions) {
+    return false;
+  }
+
+  return permissions.some(p => p.permission === permission);
+};
+
+const hasPermissions = async (
+  {
+    permissions,
+    userId,
+    forceRefresh = false,
+    allRequired = true
+  }: {
+    permissions: string[],
+    userId?: string,
+    forceRefresh?: boolean,
+    allRequired?: boolean
+  }
+): Promise<boolean> => {
+  const userPermissions = await getUserPermissions({ userId, forceRefresh });
+
+  if (!userPermissions) {
+    return false;
+  }
+
+  const userPermSet = new Set(userPermissions.map(p => p.permission));
+
+  if (allRequired) {
+    return permissions.every(p => userPermSet.has(p));
+  }
+
+  return permissions.some(p => userPermSet.has(p));
+};
+
+const getPermissionDesc = async (
+  {
+    permission,
+    userId,
+    forceRefresh = false
+  }: {
+    permission: string,
+    userId?: string,
+    forceRefresh?: boolean
+  }
+): Promise<string> => {
+  const permissions = await getUserPermissions({ userId, forceRefresh });
+
+  if (!permissions) {
+    return '';
+  }
+
+  const found = permissions.find(p => p.permission === permission);
+  return found?.descs || '';
+};
+
+const clearPermissionCache = async (userId?: string): Promise<void> => {
+  await clearCache(userId);
+};
+
+const getCacheStats = async (): Promise<{ count: number; oldest: number | null; newest: number | null }> => {
+  try {
+    const all = await db.permissionCache.toArray();
+    if (all.length === 0) {
+      return { count: 0, oldest: null, newest: null };
+    }
+    const timestamps = all.map(item => item.timestamp);
+    return {
+      count: all.length,
+      oldest: Math.min(...timestamps),
+      newest: Math.max(...timestamps)
+    };
+  } catch (error) {
+    console.error('获取权限缓存统计失败:', error);
+    return { count: 0, oldest: null, newest: null };
+  }
+};
+
+export const CachePermissionInfo = {
+  getUserPermissions,
+  hasPermission,
+  hasPermissions,
+  getPermissionDesc,
+  clearPermissionCache,
+  getCacheStats
+};

package/src/utils/CacheRoleInfo.ts

@@ -0,0 +1,303 @@
+'use strict';
+
+/**
+ * Copyright (c) 2025 SPACECORE Co.,Ltd. All Rights Reserved.
+ * Author: brian.li
+ * Date: 2025-04-02 11:43
+ * Desc: 角色信息工具类 - 支持Dexie缓存
+ *
+ * @example 使用方法
+ *
+ * // 1. 获取所有角色信息
+ * import { getRoleInfo } from './CacheRoleInfo';
+ * const roles = await getRoleInfo({});
+ * console.log(roles);
+ *
+ * // 2. 强制刷新缓存（不使用缓存）
+ * const roles = await getRoleInfo({ forceRefresh: true });
+ *
+ * // 3. 清除角色缓存
+ * import { clearRoleCache } from './CacheRoleInfo';
+ * await clearRoleCache();
+ *
+ * // 4. 获取缓存统计信息
+ * import { getCacheStats } from './CacheRoleInfo';
+ * const stats = await getCacheStats();
+ * console.log(`缓存数量: ${stats.count}`);
+ */
+
+import Dexie, { Table } from 'dexie';
+import { API } from "../api";
+import { ResponseCode } from "../api/_base";
+
+/** 角色信息缓存时间（毫秒）1小时 */
+const CACHE_EXPIRATION_MS = 1 * 60 * 60 * 1000;
+
+/** 角色信息数据类型 */
+export interface RoleInfo {
+  id: string;
+  name: string;
+  descs: string;
+  created_at: Date;
+  admin_id: string;
+  parent_id: string;
+}
+
+/** 角色信息缓存数据结构 */
+interface RoleCache {
+  id: string;
+  data: RoleInfo[];
+  timestamp: number;
+}
+
+/** Dexie 数据库类 */
+class RoleInfoDatabase extends Dexie {
+  roleCache!: Table<RoleCache, string>;
+
+  constructor() {
+    super('RoleInfoDB');
+    this.version(1).stores({
+      roleCache: 'id, timestamp'
+    });
+  }
+}
+
+/** 单例数据库实例 */
+const db = new RoleInfoDatabase();
+
+/**
+ * 从缓存获取角色信息
+ * @returns 缓存的角色信息或null
+ */
+const getFromCache = async (): Promise<RoleInfo[] | null> => {
+  try {
+    const cached = await db.roleCache.get('ROLE_ALL');
+    if (cached) {
+      const now = Date.now();
+      if (now - cached.timestamp < CACHE_EXPIRATION_MS) {
+        return cached.data;
+      }
+      await db.roleCache.delete('ROLE_ALL');
+    }
+    return null;
+  } catch (error) {
+    console.error('读取角色缓存失败:', error);
+    return null;
+  }
+};
+
+/**
+ * 设置角色信息到缓存
+ * @param data 角色信息数组
+ */
+const setToCache = async (data: RoleInfo[]): Promise<void> => {
+  try {
+    await db.roleCache.put({
+      id: 'ROLE_ALL',
+      data,
+      timestamp: Date.now()
+    });
+  } catch (error) {
+    console.error('写入角色缓存失败:', error);
+  }
+};
+
+/**
+ * 清除所有角色缓存
+ */
+const clearCache = async (): Promise<void> => {
+  try {
+    await db.roleCache.clear();
+  } catch (error) {
+    console.error('清除角色缓存失败:', error);
+  }
+};
+
+/**
+ * 获取所有角色信息
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 角色信息数组
+ */
+const getRoleList = async (
+  {
+    forceRefresh = false
+  }: {
+    forceRefresh?: boolean
+  }
+): Promise<RoleInfo[] | null> => {
+
+  if (!forceRefresh) {
+    const cachedRoleInfo = await getFromCache();
+    if (cachedRoleInfo) {
+      return cachedRoleInfo;
+    }
+  }
+
+  const res = await API.user.role.listRoles();
+
+  if (res?.code !== ResponseCode.SUCCESS) {
+    return null;
+  }
+
+  const roles = res.data || [];
+
+  await setToCache(roles);
+
+  return roles;
+};
+
+/**
+ * 根据角色ID获取角色信息
+ * @param roleId 角色ID
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 角色信息或null
+ */
+const getRoleById = async (
+  {
+    roleId,
+    forceRefresh = false
+  }: {
+    roleId: string,
+    forceRefresh?: boolean
+  }
+): Promise<RoleInfo | null> => {
+  const roles = await getRoleList({ forceRefresh });
+
+  if (!roles) {
+    return null;
+  }
+
+  return roles.find(role => role.id === roleId) || null;
+};
+
+/**
+ * 根据角色ID获取角色名称
+ * @param roleId 角色ID
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 角色名称或空字符串
+ */
+const getRoleNameById = async (
+  {
+    roleId,
+    forceRefresh = false
+  }: {
+    roleId: string,
+    forceRefresh?: boolean
+  }
+): Promise<string> => {
+  const role = await getRoleById({ roleId, forceRefresh });
+  return role?.name || '';
+};
+
+/**
+ * 获取角色ID到角色名称的映射
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 角色ID -> 角色名称
+ */
+const getRoleNameMap = async (
+  {
+    forceRefresh = false
+  }: {
+    forceRefresh?: boolean
+  } = {}
+): Promise<Record<string, string>> => {
+  const roles = await getRoleList({ forceRefresh });
+  const map: Record<string, string> = {};
+  (roles || []).forEach((role) => {
+    map[role.id] = role.name;
+  });
+  return map;
+};
+
+/**
+ * 获取指定角色ID的名称映射；若缓存中缺失部分角色，强制刷新一次后重试
+ * @param roleIds 需要解析的角色ID数组
+ * @returns 角色ID -> 角色名称
+ */
+const getRoleNameMapForIds = async (
+  {
+    roleIds
+  }: {
+    roleIds: string[]
+  }
+): Promise<Record<string, string>> => {
+  let map = await getRoleNameMap();
+  const missing = (roleIds || []).filter((id) => !!id && !map[id]);
+  if (missing.length > 0) {
+    map = await getRoleNameMap({ forceRefresh: true });
+  }
+  return map;
+};
+
+/**
+ * 清除角色缓存
+ */
+const clearRoleCache = async (): Promise<void> => {
+  await clearCache();
+};
+
+/**
+ * 获取缓存统计信息
+ * @returns 缓存统计信息
+ */
+const getCacheStats = async (): Promise<{ count: number; oldest: number | null; newest: number | null }> => {
+  try {
+    const all = await db.roleCache.toArray();
+    if (all.length === 0) {
+      return { count: 0, oldest: null, newest: null };
+    }
+    const timestamps = all.map(item => item.timestamp);
+    return {
+      count: all.length,
+      oldest: Math.min(...timestamps),
+      newest: Math.max(...timestamps)
+    };
+  } catch (error) {
+    console.error('获取缓存统计失败:', error);
+    return { count: 0, oldest: null, newest: null };
+  }
+};
+
+export const CacheRoleInfo = {
+  /**
+ * 获取所有角色信息
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 角色信息数组
+ */
+  getRoleList,
+  /**
+ * 根据角色ID获取角色信息
+ * @param roleId 角色ID
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 角色信息或null
+ */
+  getRoleById,
+  /**
+ * 根据角色ID获取角色名称
+ * @param roleId 角色ID
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 角色名称或空字符串
+ */
+  getRoleNameById,
+  /**
+ * 获取角色ID到角色名称的映射
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 角色ID -> 角色名称
+ */
+  getRoleNameMap,
+  /**
+ * 获取指定角色ID的名称映射；若缓存中缺失部分角色，强制刷新一次后重试
+ * @param roleIds 需要解析的角色ID数组
+ * @returns 角色ID -> 角色名称
+ */
+  getRoleNameMapForIds,
+  /**
+ * 清除角色缓存
+ */
+  clearRoleCache,
+  /**
+ * 获取缓存统计信息
+ * @returns 缓存统计信息
+ */
+  getCacheStats
+}