init:first commit of plus-ui

src/utils/auth.ts

@@ -0,0 +1,35 @@
+import { getLocal } from '.';
+
+const TokenKey = 'Admin-Token';
+
+const tokenStorage = useStorage<null | string>(TokenKey, null);
+
+export const getToken = () => tokenStorage.value;
+
+export const setToken = (access_token: string) => (tokenStorage.value = access_token);
+
+export const removeToken = () => (tokenStorage.value = null);
+
+export const getDockSocketUrl = () => {
+  return getLocal('dockSocketUrl');
+};
+
+export const getHost = () => {
+  return getLocal('host');
+};
+
+export const getRtmpPort = () => {
+  return getLocal('rtmpPort');
+};
+
+export const getRtcPort = () => {
+  return getLocal('rtcPort');
+};
+
+export const getDockAir = () => {
+  return getLocal('dockAir');
+};
+
+export const getAiUrl = () => {
+  return getLocal('aiUrl');
+};

src/utils/bus.ts

@@ -0,0 +1,22 @@
+import mitt from 'mitt';
+
+const emitter = mitt();
+
+export default {
+  install(app) {
+    // 发送事件
+    app.config.globalProperties.$sendChanel = (event, payload) => {
+      emitter.emit(event, payload);
+    };
+
+    // 监听事件（返回取消函数）
+    app.config.globalProperties.$recvChanel = (event, handler) => {
+      emitter.on(event, handler);
+
+      // 可选：返回解绑函数，方便使用
+      return () => {
+        emitter.off(event, handler);
+      };
+    };
+  }
+};

src/utils/createCustomNameComponent.tsx

@@ -0,0 +1,39 @@
+/**
+ * 后台返回的路由动态生成name 解决缓存问题
+ * 感谢 @fourteendp
+ * 详见 https://github.com/vbenjs/vue-vben-admin/issues/3927
+ */
+import { Component, defineComponent, h } from 'vue';
+
+interface Options {
+  name?: string;
+}
+
+export function createCustomNameComponent(loader: () => Promise<any>, options: Options = {}): () => Promise<Component> {
+  const { name } = options;
+  let component: Component | null = null;
+
+  const load = async () => {
+    try {
+      const { default: loadedComponent } = await loader();
+      component = loadedComponent;
+    } catch (error) {
+      console.error(`Cannot resolve component ${name}, error:`, error);
+    }
+  };
+
+  return async () => {
+    if (!component) {
+      await load();
+    }
+
+    return Promise.resolve(
+      defineComponent({
+        name,
+        render() {
+          return h(component as Component);
+        }
+      })
+    );
+  };
+}

src/utils/crypto.ts

@@ -0,0 +1,66 @@
+import CryptoJS from 'crypto-js';
+
+/**
+ * 随机生成32位的字符串
+ * @returns {string}
+ */
+const generateRandomString = () => {
+  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  let result = '';
+  const charactersLength = characters.length;
+  for (let i = 0; i < 32; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+};
+
+/**
+ * 随机生成aes 密钥
+ * @returns {string}
+ */
+export const generateAesKey = () => {
+  return CryptoJS.enc.Utf8.parse(generateRandomString());
+};
+
+/**
+ * 加密base64
+ * @returns {string}
+ */
+export const encryptBase64 = (str: CryptoJS.lib.WordArray) => {
+  return CryptoJS.enc.Base64.stringify(str);
+};
+
+/**
+ * 解密base64
+ */
+export const decryptBase64 = (str: string) => {
+  return CryptoJS.enc.Base64.parse(str);
+};
+
+/**
+ * 使用密钥对数据进行加密
+ * @param message
+ * @param aesKey
+ * @returns {string}
+ */
+export const encryptWithAes = (message: string, aesKey: CryptoJS.lib.WordArray) => {
+  const encrypted = CryptoJS.AES.encrypt(message, aesKey, {
+    mode: CryptoJS.mode.ECB,
+    padding: CryptoJS.pad.Pkcs7
+  });
+  return encrypted.toString();
+};
+
+/**
+ * 使用密钥对数据进行解密
+ * @param message
+ * @param aesKey
+ * @returns {string}
+ */
+export const decryptWithAes = (message: string, aesKey: CryptoJS.lib.WordArray) => {
+  const decrypted = CryptoJS.AES.decrypt(message, aesKey, {
+    mode: CryptoJS.mode.ECB,
+    padding: CryptoJS.pad.Pkcs7
+  });
+  return decrypted.toString(CryptoJS.enc.Utf8);
+};

src/utils/dict.ts

@@ -0,0 +1,27 @@
+import { getDicts } from '@/api/system/dict/data';
+import { useDictStore } from '@/store/modules/dict';
+/**
+ * 获取字典数据
+ */
+export const useDict = (...args: string[]): { [key: string]: DictDataOption[] } => {
+  const res = ref<{
+    [key: string]: DictDataOption[];
+  }>({});
+  return (() => {
+    args.forEach(async (dictType) => {
+      res.value[dictType] = [];
+      const dicts = useDictStore().getDict(dictType);
+      if (dicts) {
+        res.value[dictType] = dicts;
+      } else {
+        await getDicts(dictType).then((resp) => {
+          res.value[dictType] = resp.data.map(
+            (p): DictDataOption => ({ label: p.dictLabel, value: p.dictValue, elTagType: p.listClass, elTagClass: p.cssClass })
+          );
+          useDictStore().setDict(dictType, res.value[dictType]);
+        });
+      }
+    });
+    return res.value;
+  })();
+};

src/utils/dynamicTitle.ts

@@ -0,0 +1,14 @@
+import defaultSettings from '@/settings';
+import { useSettingsStore } from '@/store/modules/settings';
+
+/**
+ * 动态修改标题
+ */
+export const useDynamicTitle = () => {
+  const settingsStore = useSettingsStore();
+  if (settingsStore.dynamicTitle) {
+    document.title = settingsStore.title + ' - ' + import.meta.env.VITE_APP_TITLE;
+  } else {
+    document.title = defaultSettings.title as string;
+  }
+};

src/utils/errorCode.ts

@@ -0,0 +1,7 @@
+export const errorCode: any = {
+  '401': '认证失败，无法访问系统资源',
+  '403': '当前操作没有权限',
+  '404': '访问资源不存在',
+  default: '系统未知错误，请反馈给管理员'
+};
+export default errorCode;

src/utils/i18n.ts

@@ -0,0 +1,16 @@
+// translate router.meta.title, be used in breadcrumb sidebar tagsview
+import i18n from '@/lang/index';
+
+/**
+ * 获取国际化路由，如果不存在则原生返回
+ * @param title 路由名称
+ * @returns {string}
+ */
+export const translateRouteTitle = (title: string): string => {
+  const hasKey = i18n.global.te('route.' + title);
+  if (hasKey) {
+    const translatedTitle = i18n.global.t('route.' + title);
+    return translatedTitle;
+  }
+  return title;
+};

src/utils/index.ts

@@ -0,0 +1,328 @@
+import { parseTime } from '@/utils/ruoyi';
+import $cache from '@/plugins/cache';
+/**
+ * 表格时间格式化
+ */
+export const formatDate = (cellValue: string) => {
+  if (cellValue == null || cellValue == '') return '';
+  const date = new Date(cellValue);
+  const year = date.getFullYear();
+  const month = date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1;
+  const day = date.getDate() < 10 ? '0' + date.getDate() : date.getDate();
+  const hours = date.getHours() < 10 ? '0' + date.getHours() : date.getHours();
+  const minutes = date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes();
+  const seconds = date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds();
+  return year + '-' + month + '-' + day + ' ' + hours + ':' + minutes + ':' + seconds;
+};
+
+export const setLocal = (key, value) => {
+  return $cache.local.set(key, value);
+};
+
+export const getLocal = (key) => {
+  return $cache.local.get(key);
+};
+
+/**
+ * @param {number} time
+ * @param {string} option
+ * @returns {string}
+ */
+export const formatTime = (time: string, option: string) => {
+  let t: number;
+  if (('' + time).length === 10) {
+    t = parseInt(time) * 1000;
+  } else {
+    t = +time;
+  }
+  const d: any = new Date(t);
+  const now = Date.now();
+
+  const diff = (now - d) / 1000;
+
+  if (diff < 30) {
+    return '刚刚';
+  } else if (diff < 3600) {
+    // less 1 hour
+    return Math.ceil(diff / 60) + '分钟前';
+  } else if (diff < 3600 * 24) {
+    return Math.ceil(diff / 3600) + '小时前';
+  } else if (diff < 3600 * 24 * 2) {
+    return '1天前';
+  }
+  if (option) {
+    return parseTime(t, option);
+  } else {
+    return d.getMonth() + 1 + '月' + d.getDate() + '日' + d.getHours() + '时' + d.getMinutes() + '分';
+  }
+};
+
+/**
+ * @param {string} url
+ * @returns {Object}
+ */
+export const getQueryObject = (url: string) => {
+  url = url == null ? window.location.href : url;
+  const search = url.substring(url.lastIndexOf('?') + 1);
+  const obj: { [key: string]: string } = {};
+  const reg = /([^?&=]+)=([^?&=]*)/g;
+  search.replace(reg, (rs, $1, $2) => {
+    const name = decodeURIComponent($1);
+    let val = decodeURIComponent($2);
+    val = String(val);
+    obj[name] = val;
+    return rs;
+  });
+  return obj;
+};
+
+/**
+ * @param {string} input value
+ * @returns {number} output value
+ */
+export const byteLength = (str: string) => {
+  // returns the byte length of an utf8 string
+  let s = str.length;
+  for (let i = str.length - 1; i >= 0; i--) {
+    const code = str.charCodeAt(i);
+    if (code > 0x7f && code <= 0x7ff) s++;
+    else if (code > 0x7ff && code <= 0xffff) s += 2;
+    if (code >= 0xdc00 && code <= 0xdfff) i--;
+  }
+  return s;
+};
+
+/**
+ * @param {Array} actual
+ * @returns {Array}
+ */
+export const cleanArray = (actual: Array<any>) => {
+  const newArray: any[] = [];
+  for (let i = 0; i < actual.length; i++) {
+    if (actual[i]) {
+      newArray.push(actual[i]);
+    }
+  }
+  return newArray;
+};
+
+/**
+ * @param {Object} json
+ * @returns {Array}
+ */
+export const param = (json: any) => {
+  if (!json) return '';
+  return cleanArray(
+    Object.keys(json).map((key) => {
+      if (json[key] === undefined) return '';
+      return encodeURIComponent(key) + '=' + encodeURIComponent(json[key]);
+    })
+  ).join('&');
+};
+
+/**
+ * @param {string} url
+ * @returns {Object}
+ */
+export const param2Obj = (url: string) => {
+  const search = decodeURIComponent(url.split('?')[1]).replace(/\+/g, ' ');
+  if (!search) {
+    return {};
+  }
+  const obj: any = {};
+  const searchArr = search.split('&');
+  searchArr.forEach((v) => {
+    const index = v.indexOf('=');
+    if (index !== -1) {
+      const name = v.substring(0, index);
+      const val = v.substring(index + 1, v.length);
+      obj[name] = val;
+    }
+  });
+  return obj;
+};
+
+/**
+ * @param {string} val
+ * @returns {string}
+ */
+export const html2Text = (val: string) => {
+  const div = document.createElement('div');
+  div.innerHTML = val;
+  return div.textContent || div.innerText;
+};
+
+/**
+ * Merges two objects, giving the last one precedence
+ * @param {Object} target
+ * @param {(Object|Array)} source
+ * @returns {Object}
+ */
+export const objectMerge = (target: any, source: any | any[]) => {
+  if (typeof target !== 'object') {
+    target = {};
+  }
+  if (Array.isArray(source)) {
+    return source.slice();
+  }
+  Object.keys(source).forEach((property) => {
+    const sourceProperty = source[property];
+    if (typeof sourceProperty === 'object') {
+      target[property] = objectMerge(target[property], sourceProperty);
+    } else {
+      target[property] = sourceProperty;
+    }
+  });
+  return target;
+};
+
+/**
+ * @param {HTMLElement} element
+ * @param {string} className
+ */
+export const toggleClass = (element: HTMLElement, className: string) => {
+  if (!element || !className) {
+    return;
+  }
+  let classString = element.className;
+  const nameIndex = classString.indexOf(className);
+  if (nameIndex === -1) {
+    classString += '' + className;
+  } else {
+    classString = classString.substring(0, nameIndex) + classString.substring(nameIndex + className.length);
+  }
+  element.className = classString;
+};
+
+/**
+ * @param {string} type
+ * @returns {Date}
+ */
+export const getTime = (type: string) => {
+  if (type === 'start') {
+    return new Date().getTime() - 3600 * 1000 * 24 * 90;
+  } else {
+    return new Date(new Date().toDateString());
+  }
+};
+
+/**
+ * @param {Function} func
+ * @param {number} wait
+ * @param {boolean} immediate
+ * @return {*}
+ */
+export const debounce = (func: any, wait: number, immediate: boolean) => {
+  let timeout: any, args: any, context: any, timestamp: any, result: any;
+
+  const later = function () {
+    // 据上一次触发时间间隔
+    const last = +new Date() - timestamp;
+
+    // 上次被包装函数被调用时间间隔 last 小于设定时间间隔 wait
+    if (last < wait && last > 0) {
+      timeout = setTimeout(later, wait - last);
+    } else {
+      timeout = null;
+      // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用
+      if (!immediate) {
+        result = func.apply(context, args);
+        if (!timeout) context = args = null;
+      }
+    }
+  };
+
+  return (...args: any) => {
+    context = this;
+    timestamp = +new Date();
+    const callNow = immediate && !timeout;
+    // 如果延时不存在，重新设定延时
+    if (!timeout) timeout = setTimeout(later, wait);
+    if (callNow) {
+      result = func.apply(context, args);
+      context = args = null;
+    }
+    return result;
+  };
+};
+
+/**
+ * This is just a simple version of deep copy
+ * Has a lot of edge cases bug
+ * If you want to use a perfect deep copy, use lodash's _.cloneDeep
+ * @param {Object} source
+ * @returns {Object}
+ */
+export const deepClone = (source: any) => {
+  if (!source && typeof source !== 'object') {
+    throw new Error('error arguments', 'deepClone' as any);
+  }
+  const targetObj: any = source.constructor === Array ? [] : {};
+  Object.keys(source).forEach((keys) => {
+    if (source[keys] && typeof source[keys] === 'object') {
+      targetObj[keys] = deepClone(source[keys]);
+    } else {
+      targetObj[keys] = source[keys];
+    }
+  });
+  return targetObj;
+};
+
+/**
+ * @param {Array} arr
+ * @returns {Array}
+ */
+export const uniqueArr = (arr: any) => {
+  return Array.from(new Set(arr));
+};
+
+/**
+ * @returns {string}
+ */
+export const createUniqueString = (): string => {
+  const timestamp = +new Date() + '';
+  const num = (1 + Math.random()) * 65536;
+  const randomNum = parseInt(num + '');
+  return (+(randomNum + timestamp)).toString(32);
+};
+
+/**
+ * Check if an element has a class
+ * @param ele
+ * @param {string} cls
+ * @returns {boolean}
+ */
+export const hasClass = (ele: HTMLElement, cls: string): boolean => {
+  return !!ele.className.match(new RegExp('(\\s|^)' + cls + '(\\s|$)'));
+};
+
+/**
+ * Add class to element
+ * @param ele
+ * @param {string} cls
+ */
+export const addClass = (ele: HTMLElement, cls: string) => {
+  if (!hasClass(ele, cls)) ele.className += ' ' + cls;
+};
+
+/**
+ * Remove class from element
+ * @param ele
+ * @param {string} cls
+ */
+export const removeClass = (ele: HTMLElement, cls: string) => {
+  if (hasClass(ele, cls)) {
+    const reg = new RegExp('(\\s|^)' + cls + '(\\s|$)');
+    ele.className = ele.className.replace(reg, ' ');
+  }
+};
+
+/**
+ * @param {string} path
+ * @returns {Boolean}
+ */
+export const isExternal = (path: string) => {
+  return /^(https?:|http?:|mailto:|tel:)/.test(path);
+};
+
+export { parseTime };

src/utils/jsencrypt.ts

@@ -0,0 +1,21 @@
+import JSEncrypt from 'jsencrypt';
+// 密钥对生成 http://web.chacuo.net/netrsakeypair
+
+const publicKey = import.meta.env.VITE_APP_RSA_PUBLIC_KEY;
+
+// 前端不建议存放私钥 不建议解密数据 因为都是透明的意义不大
+const privateKey = import.meta.env.VITE_APP_RSA_PRIVATE_KEY;
+
+// 加密
+export const encrypt = (txt: string) => {
+  const encryptor = new JSEncrypt();
+  encryptor.setPublicKey(publicKey); // 设置公钥
+  return encryptor.encrypt(txt); // 对数据进行加密
+};
+
+// 解密
+export const decrypt = (txt: string) => {
+  const encryptor = new JSEncrypt();
+  encryptor.setPrivateKey(privateKey); // 设置私钥
+  return encryptor.decrypt(txt); // 对数据进行解密
+};

src/utils/moveDiv.ts

@@ -0,0 +1,40 @@
+export function setMove(downId, moveID) {
+  let moveDiv = document.getElementById(downId)
+  moveDiv.style.cssText += ';cursor:move;'
+  let informationBox = document.getElementById(moveID)
+  const sty = (() => {
+    if (window.document.currentStyle) {
+      return (dom, attr) => dom.currentStyle[attr];
+    } else {
+      return (dom, attr) => getComputedStyle(dom, false)[attr];
+    }
+  })()
+  moveDiv.onmousedown = (e) => {
+    // 鼠标按下，计算当前元素距离可视区的距离
+    const disX = e.clientX - moveDiv.offsetLeft;
+    const disY = e.clientY - moveDiv.offsetTop;
+    // 获取到的值带px 正则匹配替换
+    let styL = sty(informationBox, 'left');
+    let styT = sty(informationBox, 'top');
+    // 第一次获取到的值为组件自带50% 移动之后赋值为px
+    if (styL.includes('%')) {
+      styL = +document.body.clientWidth * (+styL.replace(/\%/g, '') / 100);
+      styT = +document.body.clientHeight * (+styT.replace(/\%/g, '') / 100);
+    } else {
+      styL = +styL.replace(/\px/g, '');
+      styT = +styT.replace(/\px/g, '');
+    }
+    document.onmousemove = function (e) {
+      // 通过事件委托，计算移动的距离
+      let left = e.clientX - disX;
+      let top = e.clientY - disY;
+      // 移动当前元素
+      informationBox.style.cssText += `;left:${left + styL}px;top:${top + styT}px;`;
+    };
+    document.onmouseup = function (e) {
+      document.onmousemove = null;
+      document.onmouseup = null;
+    };
+  }
+}
+

src/utils/permission.ts

@@ -0,0 +1,51 @@
+import useUserStore from '@/store/modules/user';
+
+/**
+ * 字符权限校验
+ * @param {Array} value 校验值
+ * @returns {Boolean}
+ */
+export const checkPermi = (value: any) => {
+  if (value && value instanceof Array && value.length > 0) {
+    const permissions = useUserStore().permissions;
+    const permissionDatas = value;
+    const all_permission = '*:*:*';
+
+    const hasPermission = permissions.some((permission) => {
+      return all_permission === permission || permissionDatas.includes(permission);
+    });
+
+    if (!hasPermission) {
+      return false;
+    }
+    return true;
+  } else {
+    console.error(`need roles! Like checkPermi="['system:user:add','system:user:edit']"`);
+    return false;
+  }
+};
+
+/**
+ * 角色权限校验
+ * @param {Array} value 校验值
+ * @returns {Boolean}
+ */
+export const checkRole = (value: any): boolean => {
+  if (value && value instanceof Array && value.length > 0) {
+    const roles = useUserStore().roles;
+    const permissionRoles = value;
+    const super_admin = 'admin';
+
+    const hasRole = roles.some((role) => {
+      return super_admin === role || permissionRoles.includes(role);
+    });
+
+    if (!hasRole) {
+      return false;
+    }
+    return true;
+  } else {
+    console.error(`need roles! Like checkRole="['admin','editor']"`);
+    return false;
+  }
+};

src/utils/projectTeam.ts

@@ -0,0 +1,19 @@
+import $cache from '@/plugins/cache';
+//获取班组列表
+import { listProjectTeam } from '@/api/project/projectTeam';
+import { ProjectTeamVO } from '@/api/project/projectTeam/types';
+export const getProjectTeam = async () => {
+  const { id } = $cache.local.getJSON('selectedProject');
+  const res = await listProjectTeam({
+    pageNum: 1,
+    pageSize: 20,
+    orderByColumn: 'createTime',
+    isAsc: 'desc',
+    projectId: id
+  });
+  const list = res.rows.map((projectTeam: ProjectTeamVO) => ({
+    value: projectTeam.id,
+    label: projectTeam.teamName
+  }));
+  $cache.local.setJSON('ProjectTeamList', list);
+};

src/utils/propTypes.ts

@@ -0,0 +1,26 @@
+import { CSSProperties } from 'vue';
+import VueTypes, { createTypes, toValidableType, VueTypeValidableDef, VueTypesInterface } from 'vue-types';
+
+type PropTypes = VueTypesInterface & {
+  readonly style: VueTypeValidableDef<CSSProperties>;
+  readonly fieldOption: VueTypeValidableDef<Array<FieldOption>>;
+};
+
+const propTypes = createTypes({
+  func: undefined,
+  bool: undefined,
+  string: undefined,
+  number: undefined,
+  object: undefined,
+  integer: undefined
+}) as PropTypes;
+
+export default class ProjectTypes extends VueTypes {
+  static get style() {
+    return toValidableType('style', {
+      type: [String, Object],
+      default: undefined
+    });
+  }
+}
+export { propTypes };

src/utils/reconnecting-websocket.js

@@ -0,0 +1,382 @@
+// MIT License:
+//
+// Copyright (c) 2010-2012, Joe Walnes
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+/**
+ * This behaves like a WebSocket in every way, except if it fails to connect,
+ * or it gets disconnected, it will repeatedly poll until it successfully connects
+ * again.
+ *
+ * It is API compatible, so when you have:
+ *   ws = new WebSocket('ws://....');
+ * you can replace with:
+ *   ws = new ReconnectingWebSocket('ws://....');
+ *
+ * The event stream will typically look like:
+ *  onconnecting
+ *  onopen
+ *  onmessage
+ *  onmessage
+ *  onclose // lost connection
+ *  onconnecting
+ *  onopen  // sometime later...
+ *  onmessage
+ *  onmessage
+ *  etc...
+ *
+ * It is API compatible with the standard WebSocket API, apart from the following members:
+ *
+ * - `bufferedAmount`
+ * - `extensions`
+ * - `binaryType`
+ *
+ * Latest version: https://github.com/joewalnes/reconnecting-websocket/
+ * - Joe Walnes
+ *
+ * Syntax
+ * ======
+ * var socket = new ReconnectingWebSocket(url, protocols, options);
+ *
+ * Parameters
+ * ==========
+ * url - The url you are connecting to.
+ * protocols - Optional string or array of protocols.
+ * options - See below
+ *
+ * Options
+ * =======
+ * Options can either be passed upon instantiation or set after instantiation:
+ *
+ * var socket = new ReconnectingWebSocket(url, null, { debug: true, reconnectInterval: 4000 });
+ *
+ * or
+ *
+ * var socket = new ReconnectingWebSocket(url);
+ * socket.debug = true;
+ * socket.reconnectInterval = 4000;
+ *
+ * debug
+ * - Whether this instance should log debug messages. Accepts true or false. Default: false.
+ *
+ * automaticOpen
+ * - Whether or not the websocket should attempt to connect immediately upon instantiation. The socket can be manually opened or closed at any time using ws.open() and ws.close().
+ *
+ * reconnectInterval
+ * - The number of milliseconds to delay before attempting to reconnect. Accepts integer. Default: 1000.
+ *
+ * maxReconnectInterval
+ * - The maximum number of milliseconds to delay a reconnection attempt. Accepts integer. Default: 30000.
+ *
+ * reconnectDecay
+ * - The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. Accepts integer or float. Default: 1.5.
+ *
+ * timeoutInterval
+ * - The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. Accepts integer. Default: 2000.
+ *
+ */
+// (function (global, factory) {
+//     if (typeof define === 'function' && define.amd) {
+//         define([], factory);
+//     } else if (typeof module !== 'undefined' && module.exports){
+//         module.exports = factory();
+//     } else {
+//         global.ReconnectingWebSocket = factory();
+//     }
+// })(this, function () {
+//
+//     if (!('WebSocket' in window)) {
+//         return;
+//     }
+
+function ReconnectingWebSocket(url, protocols, options) {
+
+  // Default settings
+  var settings = {
+
+    /** Whether this instance should log debug messages. */
+    debug: false,
+
+    /** Whether or not the websocket should attempt to connect immediately upon instantiation. */
+    automaticOpen: true,
+
+    /** The number of milliseconds to delay before attempting to reconnect. */
+    reconnectInterval: 1000,
+    /** The maximum number of milliseconds to delay a reconnection attempt. */
+    maxReconnectInterval: 30000,
+    /** The rate of increase of the reconnect delay. Allows reconnect attempts to back off when problems persist. */
+    reconnectDecay: 1.5,
+
+    /** The maximum time in milliseconds to wait for a connection to succeed before closing and retrying. */
+    timeoutInterval: 2000,
+
+    /** The maximum number of reconnection attempts to make. Unlimited if null. */
+    maxReconnectAttempts: null,
+
+    /** The binary type, possible values 'blob' or 'arraybuffer', default 'blob'. */
+    binaryType: 'blob'
+  }
+  if (!options) {
+    options = {};
+  }
+
+  // Overwrite and define settings with options if they exist.
+  for (var key in settings) {
+    if (typeof options[key] !== 'undefined') {
+      this[key] = options[key];
+    } else {
+      this[key] = settings[key];
+    }
+  }
+
+  // These should be treated as read-only properties
+
+  /** The URL as resolved by the constructor. This is always an absolute URL. Read only. */
+  this.url = url;
+
+  /** The number of attempted reconnects since starting, or the last successful connection. Read only. */
+  this.reconnectAttempts = 0;
+
+  /**
+   * The current state of the connection.
+   * Can be one of: WebSocket.CONNECTING, WebSocket.OPEN, WebSocket.CLOSING, WebSocket.CLOSED
+   * Read only.
+   */
+  this.readyState = WebSocket.CONNECTING;
+
+  /**
+   * A string indicating the name of the sub-protocol the server selected; this will be one of
+   * the strings specified in the protocols parameter when creating the WebSocket object.
+   * Read only.
+   */
+  this.protocol = null;
+
+  // Private state variables
+
+  var self = this;
+  var ws;
+  var forcedClose = false;
+  var timedOut = false;
+  var eventTarget = document.createElement('div');
+
+  // Wire up "on*" properties as event handlers
+
+  eventTarget.addEventListener('open', function (event) {
+    self.onopen(event);
+  });
+  eventTarget.addEventListener('close', function (event) {
+    self.onclose(event);
+  });
+  eventTarget.addEventListener('connecting', function (event) {
+    self.onconnecting(event);
+  });
+  eventTarget.addEventListener('message', function (event) {
+    self.onmessage(event);
+  });
+  eventTarget.addEventListener('error', function (event) {
+    self.onerror(event);
+  });
+
+  // Expose the API required by EventTarget
+
+  this.addEventListener = eventTarget.addEventListener.bind(eventTarget);
+  this.removeEventListener = eventTarget.removeEventListener.bind(eventTarget);
+  this.dispatchEvent = eventTarget.dispatchEvent.bind(eventTarget);
+
+  /**
+   * This function generates an event that is compatible with standard
+   * compliant browsers and IE9 - IE11
+   *
+   * This will prevent the error:
+   * Object doesn't support this action
+   *
+   * http://stackoverflow.com/questions/19345392/why-arent-my-parameters-getting-passed-through-to-a-dispatched-event/19345563#19345563
+   * @param s String The name that the event should use
+   * @param args Object an optional object that the event will use
+   */
+  function generateEvent(s, args) {
+    var evt = document.createEvent("CustomEvent");
+    evt.initCustomEvent(s, false, false, args);
+    return evt;
+  };
+
+  this.open = function (reconnectAttempt) {
+    ws = new WebSocket(self.url, protocols || []);
+    ws.binaryType = this.binaryType;
+
+    if (reconnectAttempt) {
+      if (this.maxReconnectAttempts && this.reconnectAttempts > this.maxReconnectAttempts) {
+        return;
+      }
+    } else {
+      eventTarget.dispatchEvent(generateEvent('connecting'));
+      this.reconnectAttempts = 0;
+    }
+
+    if (self.debug || ReconnectingWebSocket.debugAll) {
+      console.debug('ReconnectingWebSocket', 'attempt-connect', self.url);
+    }
+
+    var localWs = ws;
+    var timeout = setTimeout(function () {
+      if (self.debug || ReconnectingWebSocket.debugAll) {
+        console.debug('ReconnectingWebSocket', 'connection-timeout', self.url);
+      }
+      timedOut = true;
+      localWs.close();
+      timedOut = false;
+    }, self.timeoutInterval);
+
+    ws.onopen = function (event) {
+      clearTimeout(timeout);
+      if (self.debug || ReconnectingWebSocket.debugAll) {
+        console.debug('ReconnectingWebSocket', 'onopen', self.url);
+      }
+      self.protocol = ws.protocol;
+      self.readyState = WebSocket.OPEN;
+      self.reconnectAttempts = 0;
+      var e = generateEvent('open');
+      e.isReconnect = reconnectAttempt;
+      reconnectAttempt = false;
+      eventTarget.dispatchEvent(e);
+    };
+
+    ws.onclose = function (event) {
+      clearTimeout(timeout);
+      ws = null;
+      if (forcedClose) {
+        self.readyState = WebSocket.CLOSED;
+        eventTarget.dispatchEvent(generateEvent('close'));
+      } else {
+        self.readyState = WebSocket.CONNECTING;
+        var e = generateEvent('connecting');
+        e.code = event.code;
+        e.reason = event.reason;
+        e.wasClean = event.wasClean;
+        eventTarget.dispatchEvent(e);
+        if (!reconnectAttempt && !timedOut) {
+          if (self.debug || ReconnectingWebSocket.debugAll) {
+            console.debug('ReconnectingWebSocket', 'onclose', self.url);
+          }
+          eventTarget.dispatchEvent(generateEvent('close'));
+        }
+
+        var timeout = self.reconnectInterval * Math.pow(self.reconnectDecay, self.reconnectAttempts);
+        setTimeout(function () {
+          self.reconnectAttempts++;
+          self.open(true);
+        }, timeout > self.maxReconnectInterval ? self.maxReconnectInterval : timeout);
+      }
+    };
+    ws.onmessage = function (event) {
+      if (self.debug || ReconnectingWebSocket.debugAll) {
+        console.debug('ReconnectingWebSocket', 'onmessage', self.url, event.data);
+      }
+      var e = generateEvent('message');
+      e.data = event.data;
+      eventTarget.dispatchEvent(e);
+    };
+    ws.onerror = function (event) {
+      if (self.debug || ReconnectingWebSocket.debugAll) {
+        console.debug('ReconnectingWebSocket', 'onerror', self.url, event);
+      }
+      eventTarget.dispatchEvent(generateEvent('error'));
+    };
+  }
+
+  // Whether or not to create a websocket upon instantiation
+  if (this.automaticOpen == true) {
+    this.open(false);
+  }
+
+  /**
+   * Transmits data to the server over the WebSocket connection.
+   *
+   * @param data a text string, ArrayBuffer or Blob to send to the server.
+   */
+  this.send = function (data) {
+    if (ws) {
+      if (self.debug || ReconnectingWebSocket.debugAll) {
+        console.debug('ReconnectingWebSocket', 'send', self.url, data);
+      }
+      return ws.send(data);
+    } else {
+      throw 'INVALID_STATE_ERR : Pausing to reconnect websocket';
+    }
+  };
+
+  /**
+   * Closes the WebSocket connection or connection attempt, if any.
+   * If the connection is already CLOSED, this method does nothing.
+   */
+  this.close = function (code, reason) {
+    // Default CLOSE_NORMAL code
+    if (typeof code == 'undefined') {
+      code = 1000;
+    }
+    forcedClose = true;
+    if (ws) {
+      ws.close(code, reason);
+    }
+  };
+
+  /**
+   * Additional public API method to refresh the connection if still open (close, re-open).
+   * For example, if the app suspects bad data / missed heart beats, it can try to refresh.
+   */
+  this.refresh = function () {
+    if (ws) {
+      ws.close();
+    }
+  };
+}
+
+/**
+ * An event listener to be called when the WebSocket connection's readyState changes to OPEN;
+ * this indicates that the connection is ready to send and receive data.
+ */
+ReconnectingWebSocket.prototype.onopen = function (event) {
+};
+/** An event listener to be called when the WebSocket connection's readyState changes to CLOSED. */
+ReconnectingWebSocket.prototype.onclose = function (event) {
+};
+/** An event listener to be called when a connection begins being attempted. */
+ReconnectingWebSocket.prototype.onconnecting = function (event) {
+};
+/** An event listener to be called when a message is received from the server. */
+ReconnectingWebSocket.prototype.onmessage = function (event) {
+};
+/** An event listener to be called when an error occurs. */
+ReconnectingWebSocket.prototype.onerror = function (event) {
+};
+
+/**
+ * Whether all instances of ReconnectingWebSocket should log debug messages.
+ * Setting this to true is the equivalent of setting all instances of ReconnectingWebSocket.debug to true.
+ */
+ReconnectingWebSocket.debugAll = false;
+
+ReconnectingWebSocket.CONNECTING = WebSocket.CONNECTING;
+ReconnectingWebSocket.OPEN = WebSocket.OPEN;
+ReconnectingWebSocket.CLOSING = WebSocket.CLOSING;
+ReconnectingWebSocket.CLOSED = WebSocket.CLOSED;
+
+// return ReconnectingWebSocket;
+// });

src/utils/request.ts

@@ -0,0 +1,209 @@
+import axios, { AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+import { useUserStore } from '@/store/modules/user';
+import { getToken } from '@/utils/auth';
+import { tansParams, blobValidate } from '@/utils/ruoyi';
+import cache from '@/plugins/cache';
+import { HttpStatus } from '@/enums/RespEnum';
+import { errorCode } from '@/utils/errorCode';
+import { LoadingInstance } from 'element-plus/es/components/loading/src/loading';
+import FileSaver from 'file-saver';
+import { getLanguage } from '@/lang';
+import { encryptBase64, encryptWithAes, generateAesKey, decryptWithAes, decryptBase64 } from '@/utils/crypto';
+import { encrypt, decrypt } from '@/utils/jsencrypt';
+import router from '@/router';
+
+const encryptHeader = 'encrypt-key';
+let downloadLoadingInstance: LoadingInstance;
+// 是否显示重新登录
+export const isRelogin = { show: false };
+export const globalHeaders = () => {
+  return {
+    Authorization: 'Bearer ' + getToken(),
+    clientid: import.meta.env.VITE_APP_CLIENT_ID
+  };
+};
+
+axios.defaults.headers['Content-Type'] = 'application/json;charset=utf-8';
+axios.defaults.headers['clientid'] = import.meta.env.VITE_APP_CLIENT_ID;
+// 创建 axios 实例
+const service = axios.create({
+  baseURL: import.meta.env.VITE_APP_BASE_API,
+  timeout: 50000
+});
+
+// 请求拦截器
+service.interceptors.request.use(
+  (config: InternalAxiosRequestConfig) => {
+    // 对应国际化资源文件后缀
+    config.headers['Content-Language'] = getLanguage();
+
+    const isToken = config.headers?.isToken === false;
+    // 是否需要防止数据重复提交
+    const isRepeatSubmit = config.headers?.repeatSubmit === false;
+    // 是否需要加密
+    const isEncrypt = config.headers?.isEncrypt === 'true';
+
+    if (getToken() && !isToken) {
+      config.headers['Authorization'] = 'Bearer ' + getToken(); // 让每个请求携带自定义token 请根据实际情况自行修改
+    }
+    // get请求映射params参数
+    if (config.method === 'get' && config.params) {
+      let url = config.url + '?' + tansParams(config.params);
+      url = url.slice(0, -1);
+      config.params = {};
+      config.url = url;
+    }
+
+    if (!isRepeatSubmit && (config.method === 'post' || config.method === 'put')) {
+      const requestObj = {
+        url: config.url,
+        data: typeof config.data === 'object' ? JSON.stringify(config.data) : config.data,
+        time: new Date().getTime()
+      };
+      const sessionObj = cache.session.getJSON('sessionObj');
+      if (sessionObj === undefined || sessionObj === null || sessionObj === '') {
+        cache.session.setJSON('sessionObj', requestObj);
+      } else {
+        const s_url = sessionObj.url; // 请求地址
+        const s_data = sessionObj.data; // 请求数据
+        const s_time = sessionObj.time; // 请求时间
+        const interval = 500; // 间隔时间(ms)，小于此时间视为重复提交
+        if (s_data === requestObj.data && requestObj.time - s_time < interval && s_url === requestObj.url) {
+          const message = '数据正在处理，请勿重复提交';
+          console.warn(`[${s_url}]: ` + message);
+          return Promise.reject(new Error(message));
+        } else {
+          cache.session.setJSON('sessionObj', requestObj);
+        }
+      }
+    }
+    if (import.meta.env.VITE_APP_ENCRYPT === 'true') {
+      // 当开启参数加密
+      if (isEncrypt && (config.method === 'post' || config.method === 'put')) {
+        // 生成一个 AES 密钥
+        const aesKey = generateAesKey();
+        config.headers[encryptHeader] = encrypt(encryptBase64(aesKey));
+        config.data = typeof config.data === 'object' ? encryptWithAes(JSON.stringify(config.data), aesKey) : encryptWithAes(config.data, aesKey);
+      }
+    }
+    // FormData数据去请求头Content-Type
+    if (config.data instanceof FormData) {
+      delete config.headers['Content-Type'];
+    }
+    return config;
+  },
+  (error: any) => {
+    return Promise.reject(error);
+  }
+);
+
+// 响应拦截器
+service.interceptors.response.use(
+  (res: AxiosResponse) => {
+    if (import.meta.env.VITE_APP_ENCRYPT === 'true') {
+      // 加密后的 AES 秘钥
+      const keyStr = res.headers[encryptHeader];
+      // 加密
+      if (keyStr != null && keyStr != '') {
+        const data = res.data;
+        // 请求体 AES 解密
+        const base64Str = decrypt(keyStr);
+        // base64 解码 得到请求头的 AES 秘钥
+        const aesKey = decryptBase64(base64Str.toString());
+        // aesKey 解码 data
+        const decryptData = decryptWithAes(data, aesKey);
+        // 将结果 (得到的是 JSON 字符串) 转为 JSON
+        res.data = JSON.parse(decryptData);
+      }
+    }
+    // 未设置状态码则默认成功状态
+    const code = res.data.code || HttpStatus.SUCCESS;
+    // 获取错误信息
+    const msg = errorCode[code] || res.data.msg || errorCode['default'];
+    // 二进制数据则直接返回
+    if (res.request.responseType === 'blob' || res.request.responseType === 'arraybuffer') {
+      return res.data;
+    }
+    if (code === 401) {
+      // prettier-ignore
+      if (!isRelogin.show) {
+        isRelogin.show = true;
+        ElMessageBox.confirm('登录状态已过期，您可以继续留在该页面，或者重新登录', '系统提示', {
+          confirmButtonText: '重新登录',
+          cancelButtonText: '取消',
+          type: 'warning'
+        }).then(() => {
+          isRelogin.show = false;
+          useUserStore().logout().then(() => {
+            router.replace({
+              path: '/login',
+              query: {
+                redirect: encodeURIComponent(router.currentRoute.value.fullPath || '/')
+              }
+            })
+          });
+        }).catch(() => {
+          isRelogin.show = false;
+        });
+      }
+      return Promise.reject('无效的会话，或者会话已过期，请重新登录。');
+    } else if (code === HttpStatus.SERVER_ERROR) {
+      ElMessage({ message: msg, type: 'error' });
+      return Promise.reject(new Error(msg));
+    } else if (code === HttpStatus.WARN) {
+      ElMessage({ message: msg, type: 'warning' });
+      return Promise.reject(new Error(msg));
+    } else if (code !== HttpStatus.SUCCESS) {
+      ElNotification.error({ title: msg });
+      return Promise.reject('error');
+    } else {
+      return Promise.resolve(res.data);
+    }
+  },
+  (error: any) => {
+    let { message } = error;
+    if (message == 'Network Error') {
+      message = '后端接口连接异常';
+    } else if (message.includes('timeout')) {
+      message = '系统接口请求超时';
+    } else if (message.includes('Request failed with status code')) {
+      message = '系统接口' + message.substr(message.length - 3) + '异常';
+    }
+    ElMessage({ message: message, type: 'error', duration: 5 * 1000 });
+    return Promise.reject(error);
+  }
+);
+// 通用下载方法
+export function download(url: string, params: any, fileName: string) {
+  downloadLoadingInstance = ElLoading.service({ text: '正在下载数据，请稍候', background: 'rgba(0, 0, 0, 0.7)' });
+  // prettier-ignore
+  return service.post(url, params, {
+      transformRequest: [
+        (params: any) => {
+          
+          return tansParams(params);
+        }
+      ],
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      responseType: 'blob'
+    }).then(async (resp: any) => {
+      const isLogin = blobValidate(resp);
+      if (isLogin) {
+        console.log("🚀 ~ download ~ resp:", resp)
+        const blob = new Blob([resp]);
+        FileSaver.saveAs(blob, fileName);
+      } else {
+        const resText = await resp.data.text();
+        const rspObj = JSON.parse(resText);
+        const errMsg = errorCode[rspObj.code] || rspObj.msg || errorCode['default'];
+        ElMessage.error(errMsg);
+      }
+      downloadLoadingInstance.close();
+    }).catch((r: any) => {
+      console.error(r);
+      ElMessage.error('下载文件出现错误，请联系管理员！');
+      downloadLoadingInstance.close();
+    });
+}
+// 导出 axios 实例
+export default service;

src/utils/requset2.ts

@@ -0,0 +1,55 @@
+import $modal from '@/plugins/modal';
+import axios from 'axios';
+
+// 创建一个 Axios 实例并设置默认配置
+const axiosInstance = axios.create({
+  baseURL: import.meta.env.VITE_APP_BASE_DRONE_API,
+  timeout: 5000
+});
+
+// 请求拦截器，添加 token 到每个请求头
+axiosInstance.interceptors.request.use(
+  (config) => {
+    let air = localStorage.getItem('airToken');
+    let token = '';
+    if (air) {
+      token = JSON.parse(air).access_token; // 假设 token 存储在 localStorage 中
+    }
+    if (token) {
+      config.headers['Authorization'] = `Bearer ${token}`;
+    }
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+// 处理消息显示
+function showMessage(message, type = 'error') {
+  $modal.msg({
+    message: message,
+    type: type,
+    duration: 5 * 1000
+  });
+}
+
+export function request(params) {
+  // 如果有取消请求的需求，可以在此处添加 CancelToken
+  // const source = axios.CancelToken.source();
+  // params.cancelToken = source.token;
+
+  // 确保 URL 是完整的
+  // if (!params.url.startsWith(process.env.AIR)) {
+  //   params.url = process.env.AIR;
+  // }
+
+  return axiosInstance(params).then((res) => {
+    if (res.data.code === 200) {
+      return res.data;
+    } else {
+      if (!res.data.code) return res.data;
+      showMessage(res.data.message || res.data.msg);
+      return Promise.reject(res.data);
+    }
+  });
+}

src/utils/ruoyi.ts

@@ -0,0 +1,251 @@
+// 日期格式化
+export function parseTime(time: any, pattern?: string) {
+  if (arguments.length === 0 || !time) {
+    return null;
+  }
+  const format = pattern || '{y}-{m}-{d} {h}:{i}:{s}';
+  let date;
+  if (typeof time === 'object') {
+    date = time;
+  } else {
+    if (typeof time === 'string' && /^[0-9]+$/.test(time)) {
+      time = parseInt(time);
+    } else if (typeof time === 'string') {
+      time = time
+        .replace(new RegExp(/-/gm), '/')
+        .replace('T', ' ')
+        .replace(new RegExp(/\.[\d]{3}/gm), '');
+    }
+    if (typeof time === 'number' && time.toString().length === 10) {
+      time = time * 1000;
+    }
+    date = new Date(time);
+  }
+  const formatObj: { [key: string]: any } = {
+    y: date.getFullYear(),
+    m: date.getMonth() + 1,
+    d: date.getDate(),
+    h: date.getHours(),
+    i: date.getMinutes(),
+    s: date.getSeconds(),
+    a: date.getDay()
+  };
+  return format.replace(/{(y|m|d|h|i|s|a)+}/g, (result: string, key: string) => {
+    let value = formatObj[key];
+    // Note: getDay() returns 0 on Sunday
+    if (key === 'a') {
+      return ['日', '一', '二', '三', '四', '五', '六'][value];
+    }
+    if (result.length > 0 && value < 10) {
+      value = '0' + value;
+    }
+    return value || 0;
+  });
+}
+
+/**
+ * 添加日期范围
+ * @param params
+ * @param dateRange
+ * @param propName
+ */
+export const addDateRange = (params: any, dateRange: any[], propName?: string) => {
+  const search = params;
+  search.params = typeof search.params === 'object' && search.params !== null && !Array.isArray(search.params) ? search.params : {};
+  dateRange = Array.isArray(dateRange) ? dateRange : [];
+  if (typeof propName === 'undefined') {
+    search.params['beginTime'] = dateRange[0];
+    search.params['endTime'] = dateRange[1];
+  } else {
+    search.params['begin' + propName] = dateRange[0];
+    search.params['end' + propName] = dateRange[1];
+  }
+  return search;
+};
+
+// 回显数据字典
+export const selectDictLabel = (datas: any, value: number | string) => {
+  if (value === undefined) {
+    return '';
+  }
+  const actions: Array<string | number> = [];
+  Object.keys(datas).some((key) => {
+    if (datas[key].value == '' + value) {
+      actions.push(datas[key].label);
+      return true;
+    }
+  });
+  if (actions.length === 0) {
+    actions.push(value);
+  }
+  return actions.join('');
+};
+
+// 回显数据字典（字符串数组）
+export const selectDictLabels = (datas: any, value: any, separator: any) => {
+  if (value === undefined || value.length === 0) {
+    return '';
+  }
+  if (Array.isArray(value)) {
+    value = value.join(',');
+  }
+  const actions: any[] = [];
+  const currentSeparator = undefined === separator ? ',' : separator;
+  const temp = value.split(currentSeparator);
+  Object.keys(value.split(currentSeparator)).some((val) => {
+    let match = false;
+    Object.keys(datas).some((key) => {
+      if (datas[key].value == '' + temp[val]) {
+        actions.push(datas[key].label + currentSeparator);
+        match = true;
+      }
+    });
+    if (!match) {
+      actions.push(temp[val] + currentSeparator);
+    }
+  });
+  return actions.join('').substring(0, actions.join('').length - 1);
+};
+
+// 字符串格式化(%s )
+export function sprintf(str: string) {
+  if (arguments.length !== 0) {
+    let flag = true,
+      i = 1;
+    str = str.replace(/%s/g, function () {
+      const arg = arguments[i++];
+      if (typeof arg === 'undefined') {
+        flag = false;
+        return '';
+      }
+      return arg;
+    });
+    return flag ? str : '';
+  }
+}
+
+// 转换字符串，undefined,null等转化为""
+export const parseStrEmpty = (str: any) => {
+  if (!str || str == 'undefined' || str == 'null') {
+    return '';
+  }
+  return str;
+};
+
+// 数据合并
+export const mergeRecursive = (source: any, target: any) => {
+  for (const p in target) {
+    try {
+      if (target[p].constructor == Object) {
+        source[p] = mergeRecursive(source[p], target[p]);
+      } else {
+        source[p] = target[p];
+      }
+    } catch (e) {
+      source[p] = target[p];
+    }
+  }
+  return source;
+};
+
+/**
+ * 构造树型结构数据
+ * @param {*} data 数据源
+ * @param {*} id id字段 默认 'id'
+ * @param {*} parentId 父节点字段 默认 'parentId'
+ * @param {*} children 孩子节点字段 默认 'children'
+ */
+export const handleTree = <T>(data: any[], id?: string, parentId?: string, children?: string): T[] => {
+  const config: {
+    id: string;
+    parentId: string;
+    childrenList: string;
+  } = {
+    id: id || 'id',
+    parentId: parentId || 'parentId',
+    childrenList: children || 'children'
+  };
+
+  const childrenListMap: any = {};
+  const nodeIds: any = {};
+  const tree: T[] = [];
+
+  for (const d of data) {
+    const parentId = d[config.parentId];
+    if (childrenListMap[parentId] == null) {
+      childrenListMap[parentId] = [];
+    }
+    nodeIds[d[config.id]] = d;
+    childrenListMap[parentId].push(d);
+  }
+
+  for (const d of data) {
+    const parentId = d[config.parentId];
+    if (nodeIds[parentId] == null) {
+      tree.push(d);
+    }
+  }
+  const adaptToChildrenList = (o: any) => {
+    if (childrenListMap[o[config.id]] !== null) {
+      o[config.childrenList] = childrenListMap[o[config.id]];
+    }
+    if (o[config.childrenList]) {
+      for (const c of o[config.childrenList]) {
+        adaptToChildrenList(c);
+      }
+    }
+  };
+
+  for (const t of tree) {
+    adaptToChildrenList(t);
+  }
+
+  return tree;
+};
+
+/**
+ * 参数处理
+ * @param {*} params  参数
+ */
+export const tansParams = (params: any) => {
+  let result = '';
+  for (const propName of Object.keys(params)) {
+    const value = params[propName];
+    const 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') {
+            const params = propName + '[' + key + ']';
+            const subPart = encodeURIComponent(params) + '=';
+            result += subPart + encodeURIComponent(value[key]) + '&';
+          }
+        }
+      } else {
+        result += part + encodeURIComponent(value) + '&';
+      }
+    }
+  }
+  return result;
+};
+
+// 返回项目路径
+export const getNormalPath = (p: string): string => {
+  if (p.length === 0 || !p || p === 'undefined') {
+    return p;
+  }
+  const res = p.replace('//', '/');
+  if (res[res.length - 1] === '/') {
+    return res.slice(0, res.length - 1);
+  }
+  return res;
+};
+
+// 验证是否为blob格式
+export const blobValidate = (data: any) => {
+  return data.type !== 'application/json';
+};
+
+export default {
+  handleTree
+};

src/utils/scroll-to.ts

@@ -0,0 +1,65 @@
+const easeInOutQuad = (t: number, b: number, c: number, d: number) => {
+  t /= d / 2;
+  if (t < 1) {
+    return (c / 2) * t * t + b;
+  }
+  t--;
+  return (-c / 2) * (t * (t - 2) - 1) + b;
+};
+
+// requestAnimationFrame for Smart Animating http://goo.gl/sx5sts
+const requestAnimFrame = (function () {
+  return (
+    window.requestAnimationFrame ||
+    (window as any).webkitRequestAnimationFrame ||
+    (window as any).mozRequestAnimationFrame ||
+    function (callback) {
+      window.setTimeout(callback, 1000 / 60);
+    }
+  );
+})();
+
+/**
+ * Because it's so fucking difficult to detect the scrolling element, just move them all
+ * @param {number} amount
+ */
+const move = (amount: number) => {
+  document.documentElement.scrollTop = amount;
+  (document.body.parentNode as HTMLElement).scrollTop = amount;
+  document.body.scrollTop = amount;
+};
+
+const position = () => {
+  return document.documentElement.scrollTop || (document.body.parentNode as HTMLElement).scrollTop || document.body.scrollTop;
+};
+
+/**
+ * @param {number} to
+ * @param {number} duration
+ * @param {Function} callback
+ */
+export const scrollTo = (to: number, duration: number, callback?: any) => {
+  const start = position();
+  const change = to - start;
+  const increment = 20;
+  let currentTime = 0;
+  duration = typeof duration === 'undefined' ? 500 : duration;
+  const animateScroll = function () {
+    // increment the time
+    currentTime += increment;
+    // find the value with the quadratic in-out easing function
+    const val = easeInOutQuad(currentTime, start, change, duration);
+    // move the document.body
+    move(val);
+    // do the animation unless its over
+    if (currentTime < duration) {
+      requestAnimFrame(animateScroll);
+    } else {
+      if (callback && typeof callback === 'function') {
+        // the animation is done so lets callback
+        callback();
+      }
+    }
+  };
+  animateScroll();
+};

src/utils/snowflake.ts

@@ -0,0 +1,68 @@
+export class SnowflakeIdGenerator {
+  private readonly startTimeStamp = 1609459200000; // 起始时间戳，这里设置为 2021-01-01 00:00:00
+  private readonly workerIdBits = 5;
+  private readonly dataCenterIdBits = 5;
+  private readonly sequenceBits = 12;
+
+  private readonly maxWorkerId = -1 ^ (-1 << this.workerIdBits);
+  private readonly maxDataCenterId = -1 ^ (-1 << this.dataCenterIdBits);
+
+  private readonly workerIdShift = this.sequenceBits;
+  private readonly dataCenterIdShift = this.sequenceBits + this.workerIdBits;
+  private readonly timestampLeftShift = this.sequenceBits + this.workerIdBits + this.dataCenterIdBits;
+  private readonly sequenceMask = -1 ^ (-1 << this.sequenceBits);
+
+  private workerId: number;
+  private dataCenterId: number;
+  private sequence = 0;
+  private lastTimestamp = -1;
+
+  constructor(workerId: number, dataCenterId: number) {
+    if (workerId > this.maxWorkerId || workerId < 0) {
+      throw new Error(`Worker ID 必须在 0 到 ${this.maxWorkerId} 之间`);
+    }
+    if (dataCenterId > this.maxDataCenterId || dataCenterId < 0) {
+      throw new Error(`数据中心 ID 必须在 0 到 ${this.maxDataCenterId} 之间`);
+    }
+    this.workerId = workerId;
+    this.dataCenterId = dataCenterId;
+  }
+
+  private waitNextMillis(lastTimestamp: number): number {
+    let timestamp = this.getCurrentTimestamp();
+    while (timestamp <= lastTimestamp) {
+      timestamp = this.getCurrentTimestamp();
+    }
+    return timestamp;
+  }
+
+  private getCurrentTimestamp(): number {
+    return Date.now();
+  }
+
+  nextId(): number {
+    let timestamp = this.getCurrentTimestamp();
+
+    if (timestamp < this.lastTimestamp) {
+      throw new Error('时钟回拨，拒绝生成 ID 达 ' + (this.lastTimestamp - timestamp) + ' 毫秒');
+    }
+
+    if (timestamp === this.lastTimestamp) {
+      this.sequence = (this.sequence + 1) & this.sequenceMask;
+      if (this.sequence === 0) {
+        timestamp = this.waitNextMillis(this.lastTimestamp);
+      }
+    } else {
+      this.sequence = 0;
+    }
+
+    this.lastTimestamp = timestamp;
+
+    return (
+      ((timestamp - this.startTimeStamp) << this.timestampLeftShift) |
+      (this.dataCenterId << this.dataCenterIdShift) |
+      (this.workerId << this.workerIdShift) |
+      this.sequence
+    );
+  }
+}

src/utils/sse.ts

@@ -0,0 +1,42 @@
+import { getToken } from '@/utils/auth';
+import { ElNotification } from 'element-plus';
+import useNoticeStore from '@/store/modules/notice';
+
+// 初始化
+export const initSSE = (url: any) => {
+  if (import.meta.env.VITE_APP_SSE === 'false') {
+    return;
+  }
+
+  url = url + '?Authorization=Bearer ' + getToken() + '&clientid=' + import.meta.env.VITE_APP_CLIENT_ID;
+  const { data, error } = useEventSource(url, [], {
+    autoReconnect: {
+      retries: 10,
+      delay: 3000,
+      onFailed() {
+        console.log('Failed to connect after 10 retries');
+      }
+    }
+  });
+
+  watch(error, () => {
+    console.log('SSE connection error:', error.value);
+    error.value = null;
+  });
+
+  watch(data, () => {
+    if (!data.value) return;
+    useNoticeStore().addNotice({
+      message: data.value,
+      read: false,
+      time: new Date().toLocaleString()
+    });
+    ElNotification({
+      title: '消息',
+      message: data.value,
+      type: 'success',
+      duration: 3000
+    });
+    data.value = null;
+  });
+};

src/utils/theme.ts

@@ -0,0 +1,52 @@
+// 处理主题样式
+export const handleThemeStyle = (theme: string) => {
+  document.documentElement.style.setProperty('--el-color-primary', theme);
+  for (let i = 1; i <= 9; i++) {
+    document.documentElement.style.setProperty(`--el-color-primary-light-${i}`, `${getLightColor(theme, i / 10)}`);
+  }
+  for (let i = 1; i <= 9; i++) {
+    document.documentElement.style.setProperty(`--el-color-primary-dark-${i}`, `${getDarkColor(theme, i / 10)}`);
+  }
+};
+
+// hex颜色转rgb颜色
+export const hexToRgb = (str: string): string[] => {
+  str = str.replace('#', '');
+  const hexs = str.match(/../g);
+  for (let i = 0; i < 3; i++) {
+    if (hexs) {
+      hexs[i] = String(parseInt(hexs[i], 16));
+    }
+  }
+  return hexs ? hexs : [];
+};
+
+// rgb颜色转Hex颜色
+export const rgbToHex = (r: string, g: string, b: string) => {
+  const hexs = [Number(r).toString(16), Number(g).toString(16), Number(b).toString(16)];
+  for (let i = 0; i < 3; i++) {
+    if (hexs[i].length == 1) {
+      hexs[i] = `0${hexs[i]}`;
+    }
+  }
+  return `#${hexs.join('')}`;
+};
+
+// 变浅颜色值
+export const getLightColor = (color: string, level: number) => {
+  const rgb = hexToRgb(color);
+  for (let i = 0; i < 3; i++) {
+    const s = (255 - Number(rgb[i])) * level + Number(rgb[i]);
+    rgb[i] = String(Math.floor(s));
+  }
+  return rgbToHex(rgb[0], rgb[1], rgb[2]);
+};
+
+// 变深颜色值
+export const getDarkColor = (color: string, level: number) => {
+  const rgb = hexToRgb(color);
+  for (let i = 0; i < 3; i++) {
+    rgb[i] = String(Math.floor(Number(rgb[i]) * (1 - level)));
+  }
+  return rgbToHex(rgb[0], rgb[1], rgb[2]);
+};

src/utils/validate.ts

@@ -0,0 +1,108 @@
+/**
+ * 路径匹配器
+ * @param {string} pattern
+ * @param {string} path
+ * @returns {Boolean}
+ */
+export function isPathMatch(pattern: string, path: string) {
+  const regexPattern = pattern
+    .replace(/\//g, '\\/')
+    .replace(/\*\*/g, '__DOUBLE_STAR__')
+    .replace(/\*/g, '[^\\/]*')
+    .replace(/__DOUBLE_STAR__/g, '.*');
+  const regex = new RegExp(`^${regexPattern}$`);
+  return regex.test(path);
+}
+
+/**
+ * 判断url是否是http或https
+ * @returns {Boolean}
+ * @param url
+ */
+export const isHttp = (url: string): boolean => {
+  return url.indexOf('http://') !== -1 || url.indexOf('https://') !== -1;
+};
+
+/**
+ * 判断path是否为外链
+ * @param {string} path
+ * @returns {Boolean}
+ */
+export const isExternal = (path: string) => {
+  return /^(https?:|mailto:|tel:)/.test(path);
+};
+
+/**
+ * @param {string} str
+ * @returns {Boolean}
+ */
+export const validUsername = (str: string) => {
+  const valid_map = ['admin', 'editor'];
+  return valid_map.indexOf(str.trim()) >= 0;
+};
+
+/**
+ * @param {string} url
+ * @returns {Boolean}
+ */
+export const validURL = (url: string) => {
+  const reg =
+    /^(https?|ftp):\/\/([a-zA-Z0-9.-]+(:[a-zA-Z0-9.&%$-]+)*@)*((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{2}))(:[0-9]+)*(\/($|[a-zA-Z0-9.,?'\\+&%$#=~_-]+))*$/;
+  return reg.test(url);
+};
+
+/**
+ * @param {string} str
+ * @returns {Boolean}
+ */
+export const validLowerCase = (str: string) => {
+  const reg = /^[a-z]+$/;
+  return reg.test(str);
+};
+
+/**
+ * @param {string} str
+ * @returns {Boolean}
+ */
+export const validUpperCase = (str: string) => {
+  const reg = /^[A-Z]+$/;
+  return reg.test(str);
+};
+
+/**
+ * @param {string} str
+ * @returns {Boolean}
+ */
+export const validAlphabets = (str: string) => {
+  const reg = /^[A-Za-z]+$/;
+  return reg.test(str);
+};
+
+/**
+ * @param {string} email
+ * @returns {Boolean}
+ */
+export const validEmail = (email: string) => {
+  const reg =
+    /^(([^<>()\]\\.,;:\s@"]+(\.[^<>()\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+  return reg.test(email);
+};
+
+/**
+ * @param {string} str
+ * @returns {Boolean}
+ */
+export const isString = (str: any) => {
+  return typeof str === 'string' || str instanceof String;
+};
+
+/**
+ * @param {Array} arg
+ * @returns {Boolean}
+ */
+export const isArray = (arg: string | string[]) => {
+  if (typeof Array.isArray === 'undefined') {
+    return Object.prototype.toString.call(arg) === '[object Array]';
+  }
+  return Array.isArray(arg);
+};

src/utils/websocket.ts

@@ -0,0 +1,51 @@
+import { getToken } from '@/utils/auth';
+import { ElNotification } from 'element-plus';
+import useNoticeStore from '@/store/modules/notice';
+
+// 初始化socket
+export const initWebSocket = (url: any) => {
+  if (import.meta.env.VITE_APP_WEBSOCKET === 'false') {
+    return;
+  }
+  url = url + '?Authorization=Bearer ' + getToken() + '&clientid=' + import.meta.env.VITE_APP_CLIENT_ID;
+  useWebSocket(url, {
+    autoReconnect: {
+      // 重连最大次数
+      retries: 3,
+      // 重连间隔
+      delay: 1000,
+      onFailed() {
+        console.log('websocket重连失败');
+      }
+    },
+    heartbeat: {
+      message: JSON.stringify({ type: 'ping' }),
+      // 发送心跳的间隔
+      interval: 10000,
+      // 接收到心跳response的超时时间
+      pongTimeout: 2000
+    },
+    onConnected() {
+      console.log('websocket已经连接');
+    },
+    onDisconnected() {
+      console.log('websocket已经断开');
+    },
+    onMessage: (_, e) => {
+      if (e.data.indexOf('ping') > 0) {
+        return;
+      }
+      useNoticeStore().addNotice({
+        message: e.data,
+        read: false,
+        time: new Date().toLocaleString()
+      });
+      ElNotification({
+        title: '消息',
+        message: e.data,
+        type: 'success',
+        duration: 3000
+      });
+    }
+  });
+};