@infly/libs 2.0.26 → 2.0.36

package/module/Permission.js

@@ -17,21 +17,23 @@ import TokenService from "./TokenService";
  * * @returns {void}
  */
 export function initPermission({
-  whiteList = ["/login"],
+  whiteList = ["/login", "/404", "/403", "/error/401", "/error/404"],
   getUserInfoAction = "user/getInfo",
   resetTokenAction = "user/resetToken",
   refreshTokenAction = "user/refreshToken",
   pagePathCacheKey, // 页面路径缓存
   router,
   store,
-  defaultSettings = {},
+  defaultSettings,
+  settings = defaultSettings || {},
   NProgress,
   Message,
   getUserInfo,
   resetToken,
   showMessage
 }) {
-  const { title: projectTitle } = defaultSettings || {};
+  const { title: projectTitle, projectConfig } = settings || {};
+  const { initRoutePath = "/" } = projectConfig || {};
   const { dispatch } = store || {};
 
   const redirectToLogin = (to, next) => {
@@ -78,56 +80,113 @@ export function initPermission({
 
   NProgress.configure({ showSpinner: false });
 
-  router.beforeEach(async (to, from, next) => {
-    NProgress.start();
-    document.title = handlePageTitle(to.meta.title);
+  // 辅助函数：处理 URL token 参数
+  const handleUrlTokenParam = async (to, next, accessTokenKey, accessToken) => {
+    if (!to.query[accessTokenKey]) return false;
+
+    const newQuery = { ...to.query };
 
-    if (!whiteList.includes(to.path) && pagePathCacheKey) {
-      localStorage.setItem(pagePathCacheKey, window.location.href);
+    // 优先从地址栏获取token, 更新存储token值
+    if (accessToken && Uts.isFunction(dispatch)) {
+      try {
+        await dispatch(refreshTokenAction, { token: accessToken });
+      } catch (error) {
+        console.error("[Token Refresh Error]:", error);
+      }
     }
 
-    const Token = TokenService.getToken();
-    const accessTokenKey = TokenService.getUrlTokenKey();
-    const accessToken = TokenService.getUrlToken();
+    delete newQuery[accessTokenKey];
+    next({ path: to.path, query: newQuery, replace: true });
+    return true;
+  };
 
-    // 处理 URL 中的 accessToken 参数
-    if (to.query[accessTokenKey]) {
-      const newQuery = { ...to.query };
+  // 辅助函数：检查权限
+  const checkPermission = (permission) => {
+    if (!permission) return true;
 
-      // 优先从地址栏获取token, 更新存储token值
-      if (accessToken && Uts.isFunction(dispatch)) {
-        await dispatch(refreshTokenAction, { token: accessToken });
-      }
+    const hasPermission = Uts.getPM(permission);
 
-      delete newQuery[accessTokenKey];
-      NProgress.done();
-      return next({ path: to.path, query: newQuery, replace: true });
+    if (!hasPermission) {
+      console.warn(`[权限不足] 需要权限: ${permission}`);
     }
 
-    // 检查白名单路径
-    if (whiteList.includes(to.path)) {
-      NProgress.done();
-      return next();
+    return hasPermission;
+  };
+
+  // 辅助函数：处理已认证用户的路由
+  const handleAuthenticatedRoute = async (to, next, permission) => {
+    // 已登录用户访问登录页，重定向到首页
+    if (to.path === "/login") {
+      return next({ path: "/" });
+    }
+
+    try {
+      // 获取用户信息
+      const { PMRedirectPath } = await handleGetUserInfo();
+
+      // 如果是进入初始化配置的path:""重定向路由且没权限（PMRedirectPath !== initRoutePath），则重定向到指定有权限的第一条菜单路由
+      if (initRoutePath && to.path === initRoutePath && PMRedirectPath !== initRoutePath) {
+        return next({ path: PMRedirectPath || "/" });
+      }
+
+      // 检查页面权限
+      if (permission && !checkPermission(permission) && !whiteList.includes(to.path)) {
+        return next({ path: "/error/403" });
+      }
+
+      next();
+    } catch (error) {
+      const { message = "" } = error || {};
+      console.error("[认证失败]:", message || error);
+
+      // 可选：显示错误消息
+      // handleShowMessage(message || "验证失败，请重新登录");
+
+      await handleResetToken();
+      redirectToLogin(to, next);
     }
+  };
+
+  router.beforeEach(async (to, from, next) => {
+    NProgress.start();
+
+    try {
+      const Token = TokenService.getToken();
+      const accessTokenKey = TokenService.getUrlTokenKey();
+      const accessToken = TokenService.getUrlToken();
+      const { meta = {} } = to || {};
+      const { permission } = meta || {};
+
+      // 设置页面标题
+      document.title = handlePageTitle(to.meta.title);
 
-    if (Token) {
-      // 如果已登录，但尝试访问登录页，则重定向到首页
-      if (to.path === "/login") {
-        NProgress.done();
-        next({ path: "/" });
-      } else {
-        try {
-          await handleGetUserInfo();
-          NProgress.done();
-          next();
-        } catch (error) {
-          const { message = "" } = error || {};
-          // handleShowMessage(message || error || "验证失败, 请重新登录");
-          await handleResetToken();
-          redirectToLogin(to, next);
-        }
+      // 缓存页面路径（非白名单页面）
+      if (!whiteList.includes(to.path) && pagePathCacheKey) {
+        localStorage.setItem(pagePathCacheKey, window.location.href);
       }
-    } else {
+
+      // 1. 处理 URL token 参数
+      if (await handleUrlTokenParam(to, next, accessTokenKey, accessToken)) {
+        return;
+      }
+
+      // 2. 检查白名单路径
+      if (whiteList.includes(to.path)) {
+        return next();
+      }
+
+      // 3. 未登录用户，重定向到登录页
+      if (!Token) {
+        return redirectToLogin(to, next);
+      }
+
+      // 4. 已登录用户的路由处理
+      await handleAuthenticatedRoute(to, next, permission);
+    } catch (error) {
+      console.error("[路由守卫错误]:", error);
+
+      // 发生未预期的错误时，重定向到登录页
+      await handleResetToken();
       redirectToLogin(to, next);
     }
   });

package/module/REST.js

@@ -17,11 +17,15 @@ const isProdAPI = Uts.contain(["https://api.sutpay.com"], baseURL);
  */
 export function createService(config) {
   const {
+    baseURL: customBaseURL,
+    defaultField = "admin",
+    serviceField = defaultField,
     logoutAction = "user/logout", // 退出登录的action方法
     onLogout,
-    onNotify
+    onNotify,
+    getTokenFunc = "getToken"
   } = config || {};
-  const service = axios.create({ baseURL });
+  const service = axios.create({ baseURL: customBaseURL || baseURL });
 
   /**
    * 发送通知
@@ -37,13 +41,13 @@ export function createService(config) {
   // 涉及到store和request循环依赖，导致store为undefined，所以不要引入store来处理而是通过闭包形式
   const handleLogout = () => {
     if (Uts.isFunction(onLogout)) {
-      onLogout(logoutAction);
+      onLogout(logoutAction, { redirectLogin: true });
     }
   };
 
   service.interceptors.request.use(
-    config => {
-      const Token = TokenService.getToken();
+    (config) => {
+      const Token = TokenService[getTokenFunc]();
 
       if (Token) {
         config.headers["Authorization"] = " JWT " + Token;
@@ -57,30 +61,73 @@ export function createService(config) {
         });
       }
 
+      // 鼓励金接口特殊处理
+      if (customBaseURL) {
+        config.url = config.url.replace("https://auth.sutpay.cn/", customBaseURL);
+      }
+
+      if (serviceField !== defaultField) {
+        config.url = config.url.replace(`/${defaultField}/`, `/${serviceField}/`);
+      }
+
+      Uts.filterCommaFields(config?.data);
+
+      Uts.filterCommaFields(config?.params);
+
       return config;
     },
-    error => {
+    (error) => {
       return Promise.reject(error);
     }
   );
 
   service.interceptors.response.use(
-    response => {
+    (response) => {
       return response.data || {};
     },
-    error => {
-      const { response } = error || {};
-      const { status } = response || {};
+    (error) => {
+      const { response, request } = error || {};
+      const { status, data } = response || {};
+      const { error: dataError, detail, message } = data || {};
+
+      // 添加标识，表示错误已被拦截器处理
+      error.handledByInterceptor = true;
 
-      if ([401, 403].includes(status)) {
+      // HTTP 状态码错误处理映射
+      const STATUS_HANDLERS = {
+        401: { message: "登录信息已过期，请重新登录", action: () => handleLogout() },
+        403: { message: "您没有权限访问，请联系管理员" },
+        500: { message: "服务器内部错误，请联系开发人员" },
+        502: { message: "网关错误，请稍后重试或联系开发人员" },
+        503: { message: "服务暂时不可用，请稍后重试" },
+        504: { message: "网关超时，请稍后重试或联系开发人员" }
+      };
+
+      // 处理特定状态码
+      const handler = STATUS_HANDLERS[status];
+      if (handler) {
+        handleNotify({
+          message: handler.message,
+          type: "error"
+        });
+        handler.action?.();
+      } else if (response) {
+        // 其他 HTTP 错误响应，优先使用后端返回的错误信息
+        const errorMsg = dataError || detail || message || `请求失败(${status})`;
+        handleNotify({
+          message: errorMsg,
+          type: "error"
+        });
+      } else if (request) {
+        // 请求已发送但无响应（网络问题）
         handleNotify({
-          message: `登录信息已过期(${status}), 请重新登录！`,
+          message: "网络请求失败，请检查网络连接",
           type: "error"
         });
-        handleLogout();
-      } else if ([500, 502].includes(status)) {
+      } else {
+        // 请求配置错误
         handleNotify({
-          message: `服务器异常(${status})，请联系开发人员`,
+          message: error.message || "请求配置错误",
           type: "error"
         });
       }

package/module/Router.js

@@ -0,0 +1,15 @@
+export const resetRouter = (RouterInstance, router, constantRoutes) => {
+  const newRouter = createRouter(RouterInstance, constantRoutes);
+  router.matcher = newRouter.matcher; // reset router
+};
+
+export const updateRouter = resetRouter
+
+export const createRouter = (RouterInstance, constantRoutes) =>
+  new RouterInstance({
+    // mode: 'history', // require service support
+    scrollBehavior: () => ({
+      y: 0
+    }),
+    routes: constantRoutes || []
+  });