@fmdevui/fm-dev 1.0.4 → 1.0.6

package/es/packages/core/api/base/index.mjs

@@ -0,0 +1,179 @@
+import { cancelRequest, service } from '../utils/request.mjs';
+
+const useBaseApi = (module) => {
+  const baseUrl = `/api/${module}/`;
+  const request = (config, cancel = false) => {
+    if (cancel) {
+      cancelRequest(config.url || "");
+      return Promise.resolve({});
+    }
+    return service(config);
+  };
+  return {
+    baseUrl,
+    request,
+    pcomm: function(data, action, cancel = false) {
+      return request(
+        {
+          url: baseUrl + action,
+          method: "post",
+          data
+        },
+        cancel
+      );
+    },
+    gcomm: function(params, action, cancel = false) {
+      return request(
+        {
+          url: baseUrl + action,
+          method: "get",
+          params
+        },
+        cancel
+      );
+    },
+    page: function(data, cancel = false) {
+      return request(
+        {
+          url: baseUrl + "page",
+          method: "post",
+          data
+        },
+        cancel
+      );
+    },
+    detail: function(id, cancel = false) {
+      return request(
+        {
+          url: baseUrl + "detail",
+          method: "get",
+          data: { id }
+        },
+        cancel
+      );
+    },
+    dropdownData: function(data, cancel = false) {
+      return request(
+        {
+          url: baseUrl + "dropdownData",
+          method: "post",
+          data
+        },
+        cancel
+      );
+    },
+    add: function(data, cancel = false) {
+      return request(
+        {
+          url: baseUrl + "add",
+          method: "post",
+          data
+        },
+        cancel
+      );
+    },
+    update: function(data, cancel = false) {
+      return request(
+        {
+          url: baseUrl + "update",
+          method: "post",
+          data
+        },
+        cancel
+      );
+    },
+    setStatus: function(data, cancel = false) {
+      return request(
+        {
+          url: baseUrl + "setStatus",
+          method: "post",
+          data
+        },
+        cancel
+      );
+    },
+    delete: function(data, cancel = false) {
+      return request(
+        {
+          url: baseUrl + "delete",
+          method: "post",
+          data
+        },
+        cancel
+      );
+    },
+    batchDelete: function(data, cancel = false) {
+      return request(
+        {
+          url: baseUrl + "batchDelete",
+          method: "post",
+          data
+        },
+        cancel
+      );
+    },
+    exportData: function(data, cancel = false) {
+      return request(
+        {
+          responseType: "arraybuffer",
+          url: baseUrl + "export",
+          method: "post",
+          data
+        },
+        cancel
+      );
+    },
+    downloadTemplate: function(cancel = false) {
+      return request(
+        {
+          responseType: "arraybuffer",
+          url: baseUrl + "import",
+          method: "get"
+        },
+        cancel
+      );
+    },
+    importData: function(file, cancel = false) {
+      const formData = new FormData();
+      formData.append("file", file);
+      return request(
+        {
+          headers: { "Content-Type": "multipart/form-data;charset=UTF-8" },
+          responseType: "arraybuffer",
+          url: baseUrl + "import",
+          method: "post",
+          data: formData
+        },
+        cancel
+      );
+    },
+    uploadFile: function(params, action, cancel = false) {
+      const formData = new FormData();
+      formData.append("file", params.file);
+      if (params.data) {
+        Object.keys(params.data).forEach((key) => {
+          const value = params.data[key];
+          if (Array.isArray(value)) {
+            value.forEach((item) => formData.append(`${key}[]`, item));
+            return;
+          }
+          formData.append(key, params.data[key]);
+        });
+      }
+      return request(
+        {
+          url: baseUrl + action,
+          method: "POST",
+          data: formData,
+          headers: {
+            "Content-Type": "multipart/form-data;charset=UTF-8",
+            ignoreCancelToken: true
+          }
+        },
+        cancel
+      );
+    }
+  };
+};
+
+export { useBaseApi };

package/es/packages/core/api/index.mjs

@@ -0,0 +1,4 @@
+export { useBaseApi } from './base/index.mjs';
+export { feature, useSysApi } from './sys/index.mjs';
+export { useLoginApi } from './login/index.mjs';
+export { accessTokenKey, axiosInstance, cancelAllRequest, cancelRequest, clearAccessTokens, clearTokens, decryptJWT, getJWTDate, getToken, refreshAccessTokenKey, request2, service, tansParams } from './utils/request.mjs';

package/es/packages/core/api/login/index.mjs

@@ -0,0 +1,35 @@
+import { service } from '../utils/request.mjs';
+
+function useLoginApi() {
+  return {
+    signIn: (data) => {
+      return service({
+        url: "/fmauth/sysauth/login",
+        method: "post",
+        data
+      });
+    },
+    loginPhonenumber: (data) => {
+      return service({
+        url: "/fmauth/sysauth/loginPhone",
+        method: "post",
+        data
+      });
+    },
+    getCaptcha: () => {
+      return service({
+        url: "/fmauth/sysauth/captcha",
+        method: "get"
+      });
+    },
+    signOut: (data) => {
+      return service({
+        url: "/fmauth/sysauth/signOut",
+        method: "post",
+        data
+      });
+    }
+  };
+}
+
+export { useLoginApi };

package/es/packages/core/api/sys/index.mjs

@@ -0,0 +1,201 @@
+import { service } from '../utils/request.mjs';
+
+function useSysApi() {
+  return {
+    getSysInfo: (id) => {
+      return service({
+        url: `/api/sysTenant/sysInfo/${id}`,
+        method: "GET"
+      });
+    },
+    getSmPublicKey: () => {
+      return service({
+        url: `/api/sysConfig/smPublicKey`,
+        method: "GET"
+      });
+    },
+    getMenuTree: () => {
+      return service({
+        url: `/api/sysMenu/loginMenuTree`,
+        method: "GET"
+      });
+    },
+    getMenuUserMenuList: () => {
+      return service({
+        url: `/api/sysUserMenu/userMenuList`,
+        method: "GET"
+      });
+    },
+    addUserMenu: (data) => {
+      return service({
+        url: `/api/sysUserMenu/add`,
+        method: "POST",
+        data
+      });
+    },
+    setNoticeRead: (data) => {
+      return service({
+        url: `/api/sysNotice/setRead`,
+        method: "POST",
+        data
+      });
+    },
+    getNoticeTitle: () => {
+      return service({
+        url: `/api/sysNotice/noticeTitle`,
+        method: "GET"
+      });
+    },
+    getNoticeUnReadList: () => {
+      return service({
+        url: `/api/sysNotice/unReadList`,
+        method: "GET"
+      });
+    },
+    NoticePageReceived: (data) => {
+      return service({
+        url: `/api/sysNotice/pageReceived`,
+        method: "POST",
+        data
+      });
+    },
+    getUpgradeLastUnRead: () => {
+      return service({
+        url: `/api/sysUpgrade/lastUnRead`,
+        method: "GET"
+      });
+    },
+    // 获取用户信息
+    getUserInfo: () => {
+      return service({
+        url: `/api/sysAuth/userInfo`,
+        method: "GET"
+      });
+    },
+    getUserRoleTableList: () => {
+      return service({
+        url: `/api/sysRole/userRoleTableList`,
+        method: "GET"
+      });
+    },
+    getConstList: () => {
+      return service({
+        url: `/api/sysConst/list`,
+        method: "GET"
+      });
+    },
+    getPosList: () => {
+      return service({
+        url: `/api/sysPos/list`,
+        method: "GET"
+      });
+    },
+    getOwnRoleListById: (userid) => {
+      return service({
+        url: `/api/sysUser/ownRoleList/${userid}`,
+        method: "GET"
+      });
+    },
+    getRoleList: () => {
+      return service({
+        url: `/api/sysRole/list`,
+        method: "GET"
+      });
+    },
+    getSysOrgChildTreePidLevel: (pid, level) => {
+      return service({
+        url: `/api/sysOrg/childTree/${pid}/${level}`,
+        method: "GET"
+      });
+    },
+    getOrgList: (params) => {
+      return service({
+        url: `/api/sysOrg/list`,
+        method: "GET",
+        params
+      });
+    },
+    getUserBaseInfo: () => {
+      return service({
+        url: `/api/sysUser/baseInfo`,
+        method: "GET"
+      });
+    },
+    getOwnExtOrgListByid: (userid) => {
+      return service({
+        url: `/api/sysUser/ownExtOrgList/${userid}`,
+        method: "GET"
+      });
+    },
+    getAllDictList: () => {
+      return service({
+        url: `/api/sysDictType/allDictList`,
+        method: "GET"
+      });
+    },
+    verifyPwdExpirationTime: () => {
+      return service({
+        url: `/api/sysUser/verifyPwdExpirationTime`,
+        method: "POST"
+      });
+    },
+    changePwd: (data) => {
+      return service({
+        url: `/fmauth/sysauth/changePwd`,
+        method: "POST",
+        data
+      });
+    },
+    resetPwd: (data) => {
+      return service({
+        url: `/fmauth/sysauth/resetPwd`,
+        method: "POST",
+        data
+      });
+    },
+    unlockLogin: (data) => {
+      return service({
+        url: `/fmauth/sysauth/unlockLogin`,
+        method: "POST",
+        data
+      });
+    },
+    changeToken: (data) => {
+      return service({
+        url: `/fmauth/sysauth/changeToken`,
+        method: "POST",
+        data
+      });
+    },
+    Logout: () => {
+      return service({
+        url: `/fmauth/sysauth/logout`,
+        method: "POST"
+      });
+    },
+    unLockScreen: (password) => {
+      return service({
+        url: `/fmauth/sysauth/unlockScreen/?password=${password}`,
+        method: "POST"
+      });
+    },
+    getOnlineUserList: (data) => {
+      return service({
+        url: `/fmauth/sysOnlineUser/page`,
+        method: "POST",
+        data
+      });
+    }
+  };
+}
+function feature(promise, errorExt) {
+  return promise.then((data) => [null, data]).catch((err) => {
+    if (errorExt) {
+      const parsedError = Object.assign({}, err, errorExt);
+      return [parsedError, void 0];
+    }
+    return [err, void 0];
+  });
+}
+
+export { feature, useSysApi };

package/es/packages/core/api/types/global.d.mjs

@@ -0,0 +1 @@
+

package/es/packages/core/api/utils/request.mjs

@@ -0,0 +1,173 @@
+import axios from 'axios';
+import '../../utils/index.mjs';
+import { ElMessage } from 'element-plus';
+import { PUB } from '../../utils/const/index.mjs';
+import { Local, Session } from '../../utils/storage/index.mjs';
+
+const abortControllerMap = /* @__PURE__ */ new Map();
+const service = axios.create({
+  baseURL: window.__env__.VITE_API_URL,
+  timeout: 5e4
+  // headers: { 'Content-Type': 'application/json' },
+});
+const accessTokenKey = PUB.accessTokenKey;
+const refreshAccessTokenKey = PUB.refreshAccessTokenKey;
+const getToken = () => {
+  return Local.get(accessTokenKey);
+};
+const clearTokens = () => {
+  Local.remove(accessTokenKey);
+  Local.remove(refreshAccessTokenKey);
+  Session.clear();
+};
+const clearAccessTokens = () => {
+  clearTokens();
+  window.location.reload();
+};
+const axiosInstance = axios;
+service.interceptors.request.use(
+  (config) => {
+    const controller = new AbortController();
+    config.signal = controller.signal;
+    const url = config.url || "";
+    abortControllerMap.set(url, controller);
+    const accessToken = Local.get(accessTokenKey);
+    if (accessToken) {
+      config.headers["Authorization"] = `Bearer ${accessToken}`;
+      const jwt = decryptJWT(accessToken);
+      const exp = getJWTDate(jwt.exp);
+      if (/* @__PURE__ */ new Date() >= exp) {
+        const refreshAccessToken = Local.get(refreshAccessTokenKey);
+        if (refreshAccessToken) {
+          config.headers["X-Authorization"] = `Bearer ${refreshAccessToken}`;
+        }
+      }
+      if (config.method?.toLowerCase() === "get" && config.data) {
+        let url2 = config.url + "?" + tansParams(config.data);
+        url2 = url2.slice(0, -1);
+        config.data = {};
+        config.url = url2;
+      }
+    }
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+service.interceptors.response.use(
+  (res) => {
+    const url = res.config.url || "";
+    abortControllerMap.delete(url);
+    var status = res.status;
+    var serve = res.data;
+    if (status === 401) {
+      clearAccessTokens();
+    }
+    if (status >= 400) {
+      throw new Error(res.statusText || "Request Error.");
+    }
+    if (serve && serve.hasOwnProperty("errors") && serve.errors) {
+      throw new Error(JSON.stringify(serve.errors || "Request Error."));
+    }
+    var accessToken = res.headers[accessTokenKey];
+    var refreshAccessToken = res.headers[refreshAccessTokenKey];
+    if (accessToken === "invalid_token") {
+      clearAccessTokens();
+    } else if (refreshAccessToken && accessToken) {
+      Local.set(accessTokenKey, accessToken);
+      Local.set(refreshAccessTokenKey, refreshAccessToken);
+    }
+    if (serve.code === 401) {
+      clearAccessTokens();
+    } else if (serve.code === void 0) {
+      return Promise.resolve(res);
+    } else if (serve.code !== 200) {
+      var message;
+      if (serve.message && typeof serve.message == "object") {
+        message = JSON.stringify(serve.message);
+      } else {
+        message = serve.message;
+      }
+      ElMessage.error(message);
+      throw new Error(message);
+    }
+    return res;
+  },
+  (error) => {
+    if (error.response) {
+      if (error.response.status === 401) {
+        clearAccessTokens();
+      } else if (error.response.statusCode === 404) {
+        ElMessage.error("\u63A5\u53E3\u5F02\u5E38\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458");
+      }
+    }
+    if (error.message.indexOf("timeout") != -1) {
+      ElMessage.error("\u7F51\u7EDC\u8D85\u65F6");
+    } else if (error.message == "Network Error") {
+      ElMessage.error("\u7F51\u7EDC\u8FDE\u63A5\u9519\u8BEF");
+    } else {
+      if (error.response.data) ElMessage.error(error.response.statusText);
+      else ElMessage.error("\u63A5\u53E3\u8DEF\u5F84\u627E\u4E0D\u5230");
+    }
+    return Promise.reject(error);
+  }
+);
+const cancelRequest = (url) => {
+  const urlList = Array.isArray(url) ? url : [url];
+  for (const _url of urlList) {
+    abortControllerMap.get(_url)?.abort();
+    abortControllerMap.delete(_url);
+  }
+};
+const cancelAllRequest = () => {
+  for (const [_, controller] of abortControllerMap) {
+    controller.abort();
+  }
+  abortControllerMap.clear();
+};
+function tansParams(params) {
+  let result = "";
+  for (const propName of Object.keys(params)) {
+    const value = params[propName];
+    var part = encodeURIComponent(propName) + "=";
+    if (value !== null && value !== "" && typeof value !== "undefined") {
+      if (typeof value === "object") {
+        for (const key of Object.keys(value)) {
+          if (value[key] !== null && value[key] !== "" && typeof value[key] !== "undefined") {
+            let params2 = propName + "[" + key + "]";
+            var subPart = encodeURIComponent(params2) + "=";
+            result += subPart + encodeURIComponent(value[key]) + "&";
+          }
+        }
+      } else {
+        result += part + encodeURIComponent(value) + "&";
+      }
+    }
+  }
+  return result;
+}
+function decryptJWT(token) {
+  token = token.replace(/_/g, "/").replace(/-/g, "+");
+  var json = decodeURIComponent(escape(window.atob(token.split(".")[1])));
+  return JSON.parse(json);
+}
+function getJWTDate(timestamp) {
+  return new Date(timestamp * 1e3);
+}
+function request2(config) {
+  return new Promise((resolve, reject) => {
+    service(config).then((res) => {
+      if (res.data.type == "success") {
+        resolve(res.data.result);
+      } else {
+        ElMessage.success(res.data.message);
+      }
+    }).catch((res) => {
+      ElMessage.error(res);
+      reject(res);
+    });
+  });
+}
+
+export { accessTokenKey, axiosInstance, cancelAllRequest, cancelRequest, clearAccessTokens, clearTokens, decryptJWT, service as default, getJWTDate, getToken, refreshAccessTokenKey, request2, service, tansParams };

package/es/packages/core/auth/index.mjs

@@ -0,0 +1,34 @@
+import '../stores/index.mjs';
+import { judgementSameArr } from '../utils/array/index.mjs';
+import { withDirectives, resolveDirective } from 'vue';
+import { useUserInfo } from '../stores/userInfo.mjs';
+
+function auth(value) {
+  const stores = useUserInfo();
+  return stores.userInfos.authApiList.some((v) => v === value);
+}
+function auths(value) {
+  let flag = false;
+  const stores = useUserInfo();
+  stores.userInfos.authApiList.map((val) => {
+    value.map((v) => {
+      if (val === v) flag = true;
+    });
+  });
+  return flag;
+}
+function authAll(value) {
+  const stores = useUserInfo();
+  return judgementSameArr(value, stores.userInfos.authApiList);
+}
+function hAuth(el, value) {
+  return withDirectives(el, [[resolveDirective("auth"), value]]);
+}
+function hAuths(el, value) {
+  return withDirectives(el, [[resolveDirective("auths"), value]]);
+}
+function hAuthAll(el, value) {
+  return withDirectives(el, [[resolveDirective("auth-all"), value]]);
+}
+
+export { auth, authAll, auths, hAuth, hAuthAll, hAuths };

package/es/packages/core/directive/authDirective.mjs

@@ -0,0 +1,38 @@
+import '../stores/index.mjs';
+import '../utils/index.mjs';
+import { useUserInfo } from '../stores/userInfo.mjs';
+import { judgementSameArr } from '../utils/array/index.mjs';
+
+function authDirective(app) {
+  app.directive("auth", {
+    mounted(el, binding) {
+      const stores = useUserInfo();
+      if (!stores.userInfos.authApiList) {
+        el.parentNode.removeChild(el);
+      } else {
+        if (!stores.userInfos.authApiList.some((v) => v === binding.value)) el.parentNode.removeChild(el);
+      }
+    }
+  });
+  app.directive("auths", {
+    mounted(el, binding) {
+      let flag = false;
+      const stores = useUserInfo();
+      stores.userInfos.authApiList.map((val) => {
+        binding.value.map((v) => {
+          if (val === v) flag = true;
+        });
+      });
+      if (!flag) el.parentNode.removeChild(el);
+    }
+  });
+  app.directive("auth-all", {
+    mounted(el, binding) {
+      const stores = useUserInfo();
+      const flag = judgementSameArr(binding.value, stores.userInfos.authApiList);
+      if (!flag) el.parentNode.removeChild(el);
+    }
+  });
+}
+
+export { authDirective };