adtec-core-package 2.2.3 → 2.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adtec-core-package",
-  "version": "2.2.3",
+  "version": "2.2.4",
   "private": false,
   "type": "module",
   "scripts": {

package/src/hooks/useOpenNewMenu.ts

@@ -0,0 +1,30 @@
+import frameworkUtils from '../utils/FrameworkUtils.ts'
+import usePermissionHooks from '../hooks/usePermissionHooks'
+import { userInfoStore } from '../stores/userInfoStore'
+import commonUtils from '../utils/commonUtils'
+
+export default function useOpenNewMenu(menuCode: string, module: { getModules: Function }) {
+  const usePermission = usePermissionHooks(module)
+  const userInfo = userInfoStore()
+  const handleView = async (businessId: string,menuName?: string, params: any = '') => {
+    const newId = menuCode + businessId
+    let menu = frameworkUtils.getOpenMenuInfoWujie().find((item: any) => item.id === newId)
+    if (!menu) {
+      menu = JSON.parse(
+        JSON.stringify(userInfo.getUserInfo.menuList.find((item) => item.code === menuCode)),
+      )
+      if (menu) {
+        menu.code = menuCode + commonUtils.jsonToUrlQuery(params)
+        menu.id = newId
+        menu.name = menuName??menu.name
+        await usePermission.openMenuByFramework(menu, params)
+      }
+    } else {
+      await usePermission.openMenuByFramework(menu)
+    }
+  }
+
+  return {
+    handleView,
+  }
+}

package/src/hooks/usePermissionHooks.ts

@@ -0,0 +1,139 @@
+import {useRouter} from 'vue-router'
+import {h} from 'vue'
+import type {ISysMenuInfoVo} from '../interface/ISysMenuInfoVo.ts'
+import {permissionStore} from '../stores/permissionStore.ts'
+import WujieVue from 'wujie-vue3'
+import frameworkUtil from '../utils/FrameworkUtils.ts'
+import { ElMessage } from 'element-plus'
+import { userInfoStore } from '../stores/userInfoStore'
+
+export default function usePermissionHooks(module:{getModules:Function}) {
+  const router = useRouter()
+  const permission = permissionStore()
+  /**
+   * 获取当前路由菜单信息
+   */
+  const getRouteMenuInfo = (): ISysMenuInfoVo => {
+    return router.currentRoute.value.meta.sysMenuData as ISysMenuInfoVo
+  }
+  /**
+   * 新增菜单路由
+   * @param sysMenu
+   */
+  const addRoute = async (sysMenu: ISysMenuInfoVo,params?:any): Promise<string> => {
+    const rootRoute = router.getRoutes().find((c) => c.name === '/')
+    if (!rootRoute?.children.find((c: any) => c.name === sysMenu.code)) {
+      // const comp = modules[sysMenu.component]
+      // console.log(comp, text)
+      let comp = null
+      if (sysMenu.isLink !== 1 && sysMenu.applicationModule !== 'system') {
+        comp = module.getModules(sysMenu.path)
+      }
+      if (comp) {
+        const r = {
+          name: sysMenu.code,
+          path: '/' + sysMenu.code,
+          meta: {
+            sysMenuData: sysMenu,
+            params:params,
+            link: sysMenu.isLink === 1,
+            applicationModule: sysMenu.applicationModule,
+          },
+          component: async () => {
+            const cpn = await comp()
+            cpn.default.__name = sysMenu.code
+            return h(cpn.default)
+          },
+        }
+
+        // rootRoute?.children.push(r)
+        //@ts-ignore
+        // router.addRoute(rootRoute)
+        router.addRoute('/', r)
+        return sysMenu.code
+      } else {
+        const r1 = {
+          name: sysMenu.code,
+          path: '/' + sysMenu.code,
+          meta: {
+            sysMenuData: sysMenu,
+            params:params,
+            link: sysMenu.isLink === 1,
+            applicationModule: sysMenu.applicationModule,
+          },
+          component: null,
+        }
+        //@ts-ignore
+        rootRoute?.children.push(r1)
+        //@ts-ignore
+        router.addRoute(rootRoute)
+        return sysMenu.code
+      }
+    } else {
+      return sysMenu.code
+    }
+  }
+  /**
+   * 打开菜单
+   * @param sysMenu
+   */
+  const openMenu = async (sysMenu: ISysMenuInfoVo, params?: any) => {
+    // permission.setOpenMenuInfo(sysMenu)
+    const name = await addRoute(sysMenu,params)
+    router.push({ name: name })
+  }
+  /**
+   * 通过框架打开菜单
+   * @param sysMenu
+   */
+  const openMenuByFramework = async (sysMenu: ISysMenuInfoVo,params?: any) => {
+    WujieVue.bus.$emit('openMenu', sysMenu,params)
+  }
+  /**
+   * 通过随机数打开菜单
+   * @param menuId 菜单id(用于判断是否打开过)
+   * @param menuCode 菜单code
+   * @param name 菜单tab显示名称
+   * @param param 菜单参数 route.meta.params
+   */
+  const openMenuByRandom = async (menuId: string, menuCode: string, name: string,  param?: any) => {
+    if (!menuId || !menuCode || !name) {
+      ElMessage.error('菜单打开参数缺失')
+      return ''
+    }
+    let menu = frameworkUtil.getOpenMenuInfoWujie().find((item:any)=>item.id === menuId)
+    if (!menu) {
+      const userInfo = userInfoStore()
+      menu = JSON.parse(JSON.stringify(userInfo.getUserInfo.menuList.find(item => item.code === menuCode)))
+      if (menu) {
+        const random = (Math.random() * 100000).toFixed(0)
+        menu.code = menu.code + random
+        menu.name = name
+        menu.id = menuId
+        await openMenuByFramework(menu, param)
+        return menu.code
+      } else {
+        ElMessage.error('无"'+ name +'"权限')
+      }
+    } else {
+      await openMenuByFramework(menu, param)
+      return menu.code
+    }
+    return ''
+  }
+  /**
+   * 关闭当前菜单
+   * @param sysMenu
+   */
+  const closeMenu = (sysMenu: ISysMenuInfoVo) => {
+    if (sysMenu.id === permission.getActiveMenuInfo?.id) {
+      WujieVue.bus.$emit('close-sonPage')
+    }
+
+  }
+  const closeCurrentMenu = () => {
+    closeMenu(getRouteMenuInfo())
+  }
+
+  return {openMenu, getRouteMenuInfo, openMenuByFramework, closeMenu, closeCurrentMenu, openMenuByRandom}
+}

package/src/utils/commonUtils.ts

@@ -1,3 +1,5 @@
+import {ElMessageBox} from 'element-plus'
+
 export default {
   /**
    * 校验身份证号码
@@ -111,5 +113,223 @@ export default {
       birthday: '',
       sex: ''
     }
+  },
+  /**
+   * 判断数组中是否有props相同的对象
+   * @param arr
+   * @param props
+   */
+  hasDuplicate(arr: any[], props: string[]): boolean {
+    const map = new Map()
+    for (const obj of arr) {
+      let key = ''
+      for (const prop of props) {
+        key += obj[prop] + '|'
+      }
+      if (map.has(key)) {
+        return true
+      }
+      map.set(key, true)
+    }
+    return false
+  },
+  /**
+   * 删除确认函数
+   * @param fun
+   * @param args
+   */
+  deleteFun(fun: Function, ...args: any[]): void {
+    ElMessageBox.confirm(`是否确认删除该数据？`, '删除提示', {
+      confirmButtonText: '确定',
+      cancelButtonText: '取消',
+      type: 'warning',
+    }).then(async () => {
+      fun(...args)
+    })
+  },
+  calculateAge(birthDateStr: string | undefined): number | undefined {
+    if (!birthDateStr) return undefined
+    const birthDate = new Date(birthDateStr)
+    const currentDate = new Date()
+
+    let age = currentDate.getFullYear() - birthDate.getFullYear()
+    const monthDiff = currentDate.getMonth() - birthDate.getMonth()
+
+    if (monthDiff < 0 || (monthDiff === 0 && currentDate.getDate() < birthDate.getDate())) {
+      age--
+    }
+
+    return age
+  },
+  formatCurrency(amount: number): number {
+    return (Math.round(amount * 100) / 100).toFixed(2) as unknown as number;
+  },
+  stripRichText(html: string): string {
+    // 如果输入不是字符串或为空，直接返回空字符串
+    if (typeof html !== 'string' || html.trim() === '') {
+      return '';
+    }
+
+    // 1. 移除所有HTML标签
+    let text = html.replace(/<[^>]*>?/gm, '');
+
+    // 2. 处理HTML实体（如&nbsp; &amp; &lt; &gt;等）
+    const entities: Record<string, string> = {
+      '&nbsp;': ' ',
+      '&amp;': '&',
+      '&lt;': '<',
+      '&gt;': '>',
+      '&quot;': '"',
+      '&#39;': "'",
+      '&#160;': ' '
+    };
+
+    text = text.replace(/&[a-zA-Z0-9#]+;/g, match => {
+      return entities[match] || match;
+    });
+
+    // 3. 去除多余的空格和空行
+    text = text
+      .replace(/\s+/g, ' ') // 将多个空格/换行符替换为单个空格
+      .trim(); // 去除首尾空格
+
+    return text;
+  },
+  isRichTextEmpty(content: string | undefined): boolean {
+    if (!content) return true;
+    const textContent = this.stripRichText(content);
+    return !textContent;
+  },
+  /**
+   * 解析数学不等式规则，判断x是否满足规则
+   * @param {string} rule - 不等式规则，如"x=100"、"x≤50"、"10<x<20"等
+   * @param {string|number} xValue - 变量x的值，可为字符串或数字
+   * @returns {boolean} - x是否满足规则
+   */
+  isValueValidForRule(rule: string, xValue: number | string): boolean {
+    // 去除规则中的空格，统一格式
+    rule = rule.replace(/\s/g, '');
+
+    // 将字符串类型的数值转换为数字，若转换失败则设为NaN
+    const x = typeof xValue === 'string' ? parseFloat(xValue) : xValue;
+
+    // 检查转换后的值是否为有效数字
+    if (isNaN(x)) {
+      throw new Error(`Invalid xValue: ${xValue}`);
+    }
+
+    // 解析规则中的数值并进行匹配
+    try {
+      // 处理 "x=a" 类型规则
+      if (rule.includes('=')) {
+        const match = rule.match(/^x=([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x === a;
+        }
+      }
+
+      // 处理 "x<a" 类型规则
+      if (rule.includes('<') && !rule.includes('≤') && !rule.includes('±')) {
+        // 先尝试匹配 "a<x<b" 类型
+        const rangeMatch = rule.match(/^([+-]?\d+(\.\d+)?)<x<([+-]?\d+(\.\d+)?)$/);
+        if (rangeMatch) {
+          const a = parseFloat(rangeMatch[1]);
+          const b = parseFloat(rangeMatch[3]);
+          if (isNaN(a) || isNaN(b)) {
+            throw new Error(`Invalid rule values: ${rangeMatch[1]} or ${rangeMatch[3]}`);
+          }
+          return x > a && x < b;
+        }
+
+        // 再尝试匹配 "x<a" 类型
+        const match = rule.match(/^x<([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x < a;
+        }
+      }
+
+      // 处理 "x≤a" 类型规则
+      if (rule.includes('≤')) {
+        const match = rule.match(/^x≤([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x <= a;
+        }
+      }
+
+      // 处理 "x>a" 类型规则
+      if (rule.includes('>') && !rule.includes('≥')) {
+        const match = rule.match(/^x>([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x > a;
+        }
+      }
+
+      // 处理 "x≥a" 类型规则
+      if (rule.includes('≥')) {
+        const match = rule.match(/^x≥([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x >= a;
+        }
+      }
+
+      // 处理 "x±a" 类型规则
+      if (rule.includes('±')) {
+        const match = rule.match(/^x±([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          if (isNaN(a)) {
+            throw new Error(`Invalid rule value: ${match[1]}`);
+          }
+          return x >= a - Math.abs(a) && x <= a + Math.abs(a);
+        }
+      }
+
+      // 处理 "a≤x<b" 类型规则
+      if (rule.includes('≤x<')) {
+        const match = rule.match(/^([+-]?\d+(\.\d+)?)≤x<([+-]?\d+(\.\d+)?)$/);
+        if (match) {
+          const a = parseFloat(match[1]);
+          const b = parseFloat(match[3]);
+          if (isNaN(a) || isNaN(b)) {
+            throw new Error(`Invalid rule values: ${match[1]} or ${match[3]}`);
+          }
+          return x >= a && x < b;
+        }
+      }
+
+    } catch (error) {
+      throw new Error(`Rule parsing error: ${(error as Error).message}`);
+    }
+
+    throw new Error(`Unsupported rule format: ${rule}`);
+  },
+  parseUrlParams: (queryStr: string):Record<string, any> => {
+    return Object.fromEntries(new URLSearchParams(queryStr.slice(queryStr.indexOf('?') + 1)));
+  },
+  jsonToUrlQuery: (jsonObj: Record<string, string>) => {
+    const keyValuePairs = Object.entries(jsonObj).map(([key, value]) => {
+      return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`
+    })
+    return keyValuePairs.length > 0 ? `?${keyValuePairs.join('&')}` : ''
   }
 }