@pubinfo/core 2.0.0-beta.1

package/src/stores/modules/user.ts

@@ -0,0 +1,210 @@
+import type { AxiosRequestHeaders } from 'axios';
+import type { LocationQueryValue } from 'vue-router';
+import { postAuthChangeLoginOrg, postAuthLogin } from '@/api/modules/auth';
+import { getRbacResourceGrantedResources, getRbacUserUserEntireInfo, putRbacUserChangePassword } from '@/api/modules/rbac';
+import { usePubinfoContext } from '@/context';
+import { getEncryptedData } from '@/utils';
+import { find } from 'lodash-es';
+import { defineStore } from 'pinia';
+import { STORE_NAME } from '../enum';
+
+const useUserStore = defineStore(
+  STORE_NAME.USER,
+  () => {
+    const { router } = usePubinfoContext();
+
+    const user = reactive<User>({
+      account: '',
+      userId: '',
+      token: '',
+      avatar: '',
+      refreshToken: '',
+      orgList: [],
+      orgId: '',
+      permissions: [],
+      department: '',
+    });
+
+    /**
+     * @description
+     * 判断用户是否已登录
+     * @returns {boolean} 返回一个布尔值，表示用户是否已登录
+     */
+    const isLogin = computed(() => !!user.token);
+
+    /**
+     * 计算属性，返回用户的组织名称。
+     * 如果用户有 orgId，则在 orgList 中找到对应的 orgName。
+     * 如果用户没有 orgId，则找到 orgList 中主要组织的 orgName。
+     * 如果找不到 orgName，则返回空字符串。
+     */
+    const userOrgName = computed(() => {
+      let orgName: string | undefined;
+      if (user.orgId) {
+        const check = find(user.orgList, ['orgId', user.orgId]);
+        orgName = check?.orgName;
+      }
+      else {
+        const main = find(user.orgList, ['main', true]);
+        orgName = main?.orgName;
+      }
+      return orgName || '';
+    });
+
+    /**
+     * 用户登录函数
+     * @param data 登录所需的数据
+     * @param data.account 账号
+     * @param data.password 密码
+     * @param data.captchas 验证码
+     * @param data.captchaHash 验证码哈希值
+     * @param data.loginType 登录类型，默认为 'password'
+     */
+    async function login(data: {
+      account: string
+      password: string
+      captchas: string
+      captchaHash: string
+      loginType?: 'password'
+    }) {
+      const {
+        account: loginName,
+        password,
+        captchaHash: codeHash,
+        captchas: code,
+        loginType = 'password',
+      } = data;
+      const loginPwd = await getEncryptedData(password);
+      const result = await postAuthLogin({
+        loginType,
+        loginName,
+        loginPwd,
+        codeHash,
+        code,
+      });
+      const { accessToken, refreshToken } = result.data as Required<API.LoginTokenVo>;
+      await setToken(accessToken, refreshToken);
+    }
+
+    /**
+     * 执行用户注销操作，并跳转到登录页面。
+     * @param _redirect - 注销后的重定向路径，默认为当前页面的完整路径。
+     */
+    async function logout(_redirect = router?.currentRoute.value.fullPath) {
+      router?.push({
+        name: 'Login',
+      });
+    }
+
+    /**
+     * 清空用户信息和相关状态。
+     */
+    function clean() {
+      user.account = '';
+      user.userId = '';
+      user.token = '';
+      user.refreshToken = '';
+      user.avatar = '';
+      user.permissions = [];
+      user.orgId = '';
+      user.orgList = [];
+    }
+
+    /**
+     * 获取用户信息
+     */
+    async function getUserInfo() {
+      const res = await getRbacUserUserEntireInfo();
+      const userData = res.data as Required<API.PubUserBo>;
+      user.account = userData.realName || userData.loginName;
+      user.avatar = userData.userPic;
+      user.userId = userData.id;
+      user.orgList = userData.userOrgList!;
+      if (userData.userOrgList?.length && !user.orgId) {
+        user.orgId = find(userData.userOrgList, ['main', true])!.orgId!;
+      }
+    }
+
+    /**
+     * 修改用户密码
+     * @param form - 包含要修改的密码和令牌的表单数据
+     * @returns 修改密码的结果
+     */
+    async function changeUserPassword(form: API.putRbacUserChangePasswordParams & { token?: LocationQueryValue | LocationQueryValue[] }) {
+      const headers = {} as AxiosRequestHeaders;
+      if (form.token) {
+        headers.authorization = form.token;
+      }
+      const encryptedOldpassword = await getEncryptedData(form.oldPassword);
+      const encryptedNewpassword = await getEncryptedData(form.newPassword);
+      const res = await putRbacUserChangePassword({
+        oldPassword: encryptedOldpassword,
+        newPassword: encryptedNewpassword,
+      }, {
+        headers,
+      });
+      return res;
+    }
+
+    /**
+     * 设置令牌
+     * @param accessToken 访问令牌
+     * @param refreshToken 刷新令牌数据
+     */
+    async function setToken(accessToken: string, refreshToken: string) {
+      user.token = accessToken;
+      user.refreshToken = refreshToken;
+    }
+
+    /**
+     * 获取用户权限列表
+     * @returns 用户权限列表
+     */
+    async function getPermissions() {
+      const res = await getRbacResourceGrantedResources();
+      user.permissions = res.data!;
+      return user.permissions;
+    }
+
+    /**
+     * 更改组织
+     * @param changeOrgId - 要更改的组织ID
+     */
+    async function changeOrg(changeOrgId: string) {
+      const res = await postAuthChangeLoginOrg({ orgId: changeOrgId });
+      const { accessToken, refreshToken } = res.data as Required<API.LoginTokenVo>;
+      await setToken(accessToken, refreshToken);
+      user.orgId = changeOrgId;
+      router?.push({
+        path: '/',
+      });
+    }
+
+    async function phoneLogin(phone: string, verify: string) {
+      // message.success(`${phone}登录成功`);
+      // await setToken(accessToken, refreshTokenData);
+      // await getUserInfo();
+    }
+
+    return {
+      user,
+      isLogin,
+      login,
+      logout,
+      phoneLogin,
+      getPermissions,
+      changeUserPassword,
+      userOrgName,
+      changeOrg,
+      setToken,
+      getUserInfo,
+      clean,
+      ...toRefs(user),
+    };
+  },
+  {
+    persist: true,
+  },
+);
+
+export default useUserStore;

package/src/stores/plugin/persist.ts

@@ -0,0 +1,27 @@
+import type { Pinia } from 'pinia';
+import type { PersistedStateFactoryOptions, Serializer } from 'pinia-plugin-persistedstate';
+import { storage } from '@/utils';
+import { createPersistedState } from 'pinia-plugin-persistedstate';
+
+export function customSerializer(): Serializer {
+  return {
+    deserialize: (value) => {
+      return JSON.parse(value);
+    },
+    serialize: (value) => {
+      return JSON.stringify(value);
+    },
+  };
+}
+
+export function createPersistedStateOptions(): PersistedStateFactoryOptions {
+  return {
+    storage: storage.local,
+    key: id => `_${id}`,
+    serializer: customSerializer(),
+  };
+}
+
+export function registerPiniaPersistPlugin(pinia: Pinia) {
+  pinia.use(createPersistedState(createPersistedStateOptions()));
+}

package/src/stores/plugin/sideEffect/cleanup.ts

@@ -0,0 +1,20 @@
+import type { PiniaPluginContext } from 'pinia';
+import { cleanup, cleanupWithoutUser } from '@/utils';
+import { STORE_NAME } from '../../enum';
+
+/**
+ * 登出和切换组织时，触发清理状态
+ */
+export function createCleanupPlugin({ store }: PiniaPluginContext) {
+  if (store.$id === STORE_NAME.USER) {
+    store.$onAction(({ name }) => {
+      if (name === 'logout') {
+        cleanup();
+      }
+
+      if (name === 'changeOrg') {
+        cleanupWithoutUser();
+      }
+    });
+  }
+}

package/src/stores/plugin/sideEffect/favoritesStorage.ts

@@ -0,0 +1,62 @@
+import type { PiniaPluginContext } from 'pinia';
+import type useFavoritesStore from '../../modules/favorites';
+import { GetAPIFavorites, GetAPIFavoritesEdit } from '@/api/system/user';
+import { storage } from '@/utils';
+import { STORE_NAME } from '../../enum';
+import { getfavoritesMemoryKey } from '../../helper';
+import useSettingsStore from '../../modules/settings';
+import useUserStore from '../../modules/user';
+
+/**
+ * 收藏夹持久化插件
+ */
+export function createFavoritesStoragePlugin({ store }: PiniaPluginContext) {
+  if (store.$id === STORE_NAME.FAVORITES) {
+    const favoritesStore = store as ReturnType<typeof useFavoritesStore>;
+    const favoritesId = computed(() => useUserStore().account);
+    const settingsStore = useSettingsStore();
+
+    // list 变化时更新存储
+    watch(
+      () => favoritesStore.list,
+      () => {
+        updateStorage();
+      },
+      { deep: true },
+    );
+
+    /** 更新存储 */
+    async function updateStorage() {
+      if (settingsStore.settings.favorites.storageTo === 'local') {
+        const favoritesMemoryKey = getfavoritesMemoryKey();
+        const favoritesData = storage.local.has(favoritesMemoryKey) ? JSON.parse(storage.local.get(favoritesMemoryKey) as string) : {};
+        favoritesData[favoritesId.value] = favoritesStore.list;
+        storage.local.set(favoritesMemoryKey, JSON.stringify(favoritesData));
+      }
+      else if (settingsStore.settings.favorites.storageTo === 'server') {
+        await GetAPIFavoritesEdit(JSON.stringify(favoritesStore.list));
+      }
+    }
+
+    /** 从存储中恢复收藏夹数据 */
+    async function recoveryStorage() {
+      if (!settingsStore.settings.favorites.enable) {
+        return;
+      }
+
+      if (settingsStore.settings.favorites.storageTo === 'local') {
+        const favoritesMemoryKey = getfavoritesMemoryKey();
+        if (storage.local.has(favoritesMemoryKey)) {
+          favoritesStore.list = JSON.parse(storage.local.get(favoritesMemoryKey) as string)[favoritesId.value] || [];
+        }
+      }
+      else if (settingsStore.settings.favorites.storageTo === 'server') {
+        const res = await GetAPIFavorites();
+        favoritesStore.list = JSON.parse(res.data.favorites || '[]');
+      }
+    }
+
+    // 给 favoritesStore 增加方法
+    store.recoveryStorage = recoveryStorage;
+  }
+}

package/src/stores/plugin/sideEffect/iframeCache.ts

@@ -0,0 +1,32 @@
+import type { PiniaPluginContext } from 'pinia';
+import type useIframeStore from '../../modules/iframe';
+import { STORE_NAME } from '../../enum';
+import useSettingsStore from '../../modules/settings';
+
+/**
+ * 最大缓存数量检测，超过缓存数量则关闭最早打开的 iframe
+ */
+export function createIframeCachePlugin({ store }: PiniaPluginContext) {
+  if (store.$id === STORE_NAME.IFRAME) {
+    const iframeStore = store as ReturnType<typeof useIframeStore>;
+    const settingsStore = useSettingsStore();
+
+    store.$onAction(({ name }) => {
+      if (name === 'open') {
+        let count = 0;
+        iframeStore.recentPathList.forEach((item) => {
+          if (iframeStore.list.find(v => v.path === item)?.isOpen) {
+            count++;
+          }
+          if (count > settingsStore.settings.mainPage.iframeCacheMax) {
+            const idx = iframeStore.list.findIndex(v => v.path === item);
+            if (~idx) {
+              iframeStore.list[idx].isOpen = false;
+              iframeStore.list[idx].isLoading = true;
+            }
+          }
+        });
+      }
+    });
+  }
+}

package/src/stores/plugin/sideEffect/index.ts

@@ -0,0 +1,15 @@
+import type { Pinia } from 'pinia';
+import { createCleanupPlugin } from './cleanup';
+import { createFavoritesStoragePlugin } from './favoritesStorage';
+import { createIframeCachePlugin } from './iframeCache';
+import { createTabbarStoragePlugin } from './tabbarStorage';
+
+/**
+ * 各个store的副作用插件集合
+ */
+export function registerPiniaSideEffectPlugin(pinia: Pinia) {
+  pinia.use(createCleanupPlugin);
+  pinia.use(createFavoritesStoragePlugin);
+  pinia.use(createIframeCachePlugin);
+  pinia.use(createTabbarStoragePlugin);
+}

package/src/stores/plugin/sideEffect/tabbarStorage.ts

@@ -0,0 +1,98 @@
+import type { PiniaPluginContext } from 'pinia';
+import type useTabbarStore from '../../modules/tabbar';
+import { GetAPITabbar, GetAPITabbarEdit } from '@/api/system/user';
+import { storage } from '@/utils';
+import { cloneDeep } from 'lodash-es';
+import { STORE_NAME } from '../../enum';
+import { getTabbarMemoryKey } from '../../helper';
+import useSettingsStore from '../../modules/settings';
+import useUserStore from '../../modules/user';
+
+/**
+ * 选项卡持久化插件
+ */
+export function createTabbarStoragePlugin({ store }: PiniaPluginContext) {
+  if (store.$id === STORE_NAME.TABBAR) {
+    const tabbarStore = store as ReturnType<typeof useTabbarStore>;
+    const tabbarId = computed(() => useUserStore().account);
+    const settingsStore = useSettingsStore();
+
+    // list 变化时更新存储
+    watch(
+      () => tabbarStore.list,
+      () => {
+        updateStorage();
+      },
+      { deep: true },
+    );
+
+    /**
+     * 更新存储
+     */
+    async function updateStorage() {
+      if (settingsStore.settings.tabbar.storageTo === 'local') {
+        const tabbarMemoryKey = getTabbarMemoryKey();
+        const pinData = storage.local.has(tabbarMemoryKey) ? JSON.parse(storage.local.get(tabbarMemoryKey) as string) : {};
+        pinData[tabbarId.value] = cloneDeep(tabbarStore.list.filter((item) => {
+          return item.isPin;
+        })).map((item) => {
+          // 不存储自定义标题
+          item.customTitleList = [];
+          return item;
+        });
+        storage.local.set(tabbarMemoryKey, JSON.stringify(pinData));
+      }
+      else if (settingsStore.settings.tabbar.storageTo === 'server') {
+        await GetAPITabbarEdit(JSON.stringify(cloneDeep(tabbarStore.list.filter((item) => {
+          return item.isPin;
+        })).map((item) => {
+          // 不存储自定义标题
+          item.customTitleList = [];
+          return item;
+        })));
+      }
+
+      if (settingsStore.settings.tabbar.enableMemory) {
+        // 将非固定和非常驻标签页记录到 sessionStorage
+        const tabbarMemoryKey = getTabbarMemoryKey();
+        const unpinData = storage.session.has(tabbarMemoryKey) ? JSON.parse(storage.session.get(tabbarMemoryKey) as string) : {};
+        unpinData[tabbarId.value] = cloneDeep(tabbarStore.list.filter((item) => {
+          return !item.isPin && !item.isPermanent;
+        })).map((item) => {
+          // 不存储自定义标题
+          item.customTitleList = [];
+          return item;
+        });
+        storage.session.set(tabbarMemoryKey, JSON.stringify(unpinData));
+      }
+    }
+
+    /**
+     * 从存储中恢复标签栏数据
+     */
+    async function recoveryStorage() {
+      if (!settingsStore.settings.tabbar.enable) {
+        return;
+      }
+
+      const tabbarMemoryKey = getTabbarMemoryKey();
+
+      if (settingsStore.settings.tabbar.storageTo === 'local') {
+        if (storage.local.has(tabbarMemoryKey)) {
+          tabbarStore.list.push(...(JSON.parse(storage.local.get(tabbarMemoryKey) as string)[tabbarId.value] || []));
+        }
+      }
+      else if (settingsStore.settings.tabbar.storageTo === 'server') {
+        const res = await GetAPITabbar();
+        tabbarStore.list.push(...(JSON.parse(res.data.tabbar || '[]')));
+      }
+
+      if (settingsStore.settings.tabbar.enableMemory && storage.session.has(tabbarMemoryKey)) {
+        tabbarStore.list.push(...(JSON.parse(storage.session.get(tabbarMemoryKey) as string)[tabbarId.value] || []));
+      }
+    }
+
+    // 给 tabbarStore 增加方法
+    store.recoveryStorage = recoveryStorage;
+  }
+}

package/src/utils/cleanup.ts

@@ -0,0 +1,20 @@
+import { useMenuStore, useRouteStore, useTabbarStore, useUserStore } from '@/stores';
+
+/**
+ * 清理所有 store 中的状态
+ */
+export function cleanup() {
+  useUserStore().clean();
+  useTabbarStore().clean();
+  useRouteStore().removeRoutes();
+  useMenuStore().setActived(0);
+}
+
+/**
+ * 清理 userStore 以外的所有 store 状态
+ */
+export function cleanupWithoutUser() {
+  useTabbarStore().clean();
+  useRouteStore().removeRoutes();
+  useMenuStore().setActived(0);
+}

package/src/utils/crypto.ts

@@ -0,0 +1,27 @@
+import { getAuthLoginKey } from '@/api/modules/auth';
+import JSEncrypt from 'jsencrypt';
+import { template } from 'lodash-es';
+
+export function compilePublicKey(key: string) {
+  const compiled = template('-----BEGIN PUBLIC KEY-----\n<%= publickKey %>\n-----END PUBLIC KEY-----');
+  return compiled({ publickKey: key });
+}
+
+export async function getPem() {
+  const { data } = await getAuthLoginKey();
+  const key = compilePublicKey(data!);
+  return key;
+}
+
+export async function encryptWithPublicKey(publicKey: string, data: string) {
+  const encryptor = new JSEncrypt();
+  encryptor.setPublicKey(publicKey);
+  const encrypted = encryptor.encrypt(data);
+  return encrypted as string;
+}
+
+export async function getEncryptedData(str: string) {
+  const key = await getPem();
+  const value = await encryptWithPublicKey(key, str);
+  return value;
+}

package/src/utils/eventBus.ts

@@ -0,0 +1,15 @@
+/*
+ * @Description:
+ * @Author: wsy
+ * @Date: 2023-11-20 09:08:32
+ * @LastEditTime: 2024-12-03 10:24:57
+ * @LastEditors: Werheng vhang97@163.com
+ */
+// TODO 优化掉
+import mitt from 'mitt';
+
+interface MittTypes {
+  [key: PropertyKey]: any
+}
+
+export default mitt<MittTypes>();

package/src/utils/index.ts

@@ -0,0 +1,44 @@
+import type { Primitive } from 'type-fest';
+import { isArray, isEmpty, isObject, reduce } from 'lodash-es';
+import path from 'path-browserify';
+
+type ConditionalExceptType<T extends Record<PropertyKey, any>, Type> = {
+  [P in keyof T]: Exclude<T[P], Type>
+};
+
+export function resolveRoutePath(basePath?: string, routePath?: string) {
+  return basePath ? path.resolve(basePath, routePath ?? '') : routePath ?? '';
+}
+
+export function normalizePrimitiveToFunction<T extends Record<PropertyKey, any>>(options: T): ConditionalExceptType<T, Primitive> {
+  for (const key in options) {
+    if (typeof options[key] !== 'function') {
+      const value = options[key]
+      ;(options[key] as () => typeof value) = () => value;
+    }
+  }
+  return options;
+}
+
+export function objectToPaths(obj: Record<string, any>, prefix = '') {
+  return reduce(obj, (result, value, key) => {
+    const fullPath = prefix.length ? `${prefix}.${key}` : key;
+    if (isObject(value) && !isArray(value) && !isEmpty(value)) {
+      // 如果是非空对象，递归调用
+      result = result.concat(objectToPaths(value, fullPath));
+    }
+    else {
+      // 否则，添加当前路径到结果数组
+      result.push(fullPath);
+    }
+    return result;
+  }, [] as string[]);
+}
+
+export * from './cleanup';
+export * from './crypto';
+export { default as eventBus } from './eventBus';
+export * from './injectionKeys';
+export { default as storage } from './storage';
+export * from './utils';
+export { default as watermark } from './watermark';

package/src/utils/injectionKeys.ts

@@ -0,0 +1,5 @@
+import type { InjectionKey } from 'vue';
+
+export function createInjectionKey<T = any>(key: string): InjectionKey<T> {
+  return key as unknown as InjectionKey<T>;
+}

package/src/utils/storage.ts

@@ -0,0 +1,57 @@
+import { getSettings } from '@/config';
+
+function getStoragePrefix() {
+  const settings = getSettings();
+  return settings?.app?.storagePrefix;
+}
+
+const storage = {
+  local: {
+    has: (key: string) => {
+      return Object.prototype.hasOwnProperty.call(localStorage, `${getStoragePrefix()}${key}`);
+    },
+    get: (key: string) => {
+      return localStorage.getItem(`${getStoragePrefix()}${key}`);
+    },
+    set: (key: string, value: string) => {
+      localStorage.setItem(`${getStoragePrefix()}${key}`, value);
+    },
+    remove: (key: string) => {
+      localStorage.removeItem(`${getStoragePrefix()}${key}`);
+    },
+    clear: () => {
+      localStorage.clear();
+    },
+    getItem: (key: string) => {
+      return localStorage.getItem(`${getStoragePrefix()}${key}`);
+    },
+    setItem: (key: string, value: string) => {
+      localStorage.setItem(`${getStoragePrefix()}${key}`, value);
+    },
+  },
+  session: {
+    has: (key: string) => {
+      return Object.prototype.hasOwnProperty.call(sessionStorage, `${getStoragePrefix()}${key}`);
+    },
+    get: (key: string) => {
+      return sessionStorage.getItem(`${getStoragePrefix()}${key}`);
+    },
+    set: (key: string, value: string) => {
+      sessionStorage.setItem(`${getStoragePrefix()}${key}`, value);
+    },
+    remove: (key: string) => {
+      sessionStorage.removeItem(`${getStoragePrefix()}${key}`);
+    },
+    clear: () => {
+      sessionStorage.clear();
+    },
+    getItem: (key: string) => {
+      return sessionStorage.getItem(`${getStoragePrefix()}${key}`);
+    },
+    setItem: (key: string, value: string) => {
+      sessionStorage.setItem(`${getStoragePrefix()}${key}`, value);
+    },
+  },
+};
+
+export default storage;

package/src/utils/utils.ts

@@ -0,0 +1,12 @@
+type AsyncFlatten<T extends unknown[]> = T extends (infer U)[]
+  ? Exclude<Awaited<U>, U[]>[]
+  : never;
+
+export async function asyncFlatten<T extends unknown[]>(
+  arr: T,
+): Promise<AsyncFlatten<T>> {
+  do {
+    arr = (await Promise.all(arr)).flat(Infinity) as any;
+  } while (arr.some((v: any) => v?.then));
+  return arr as unknown[] as AsyncFlatten<T>;
+}