@yy-common/shared 1.0.0-beta.6

package/utils/router.js

@@ -0,0 +1,27 @@
+
+export function navBack(router, route) {
+  console.log('navBack in router', router, route)
+  const tempTagList = _.cloneDeep(top.document.getElementsByTagName('div')[0].__vue__.$store.state.app.tagNavList || [])
+  console.log('tempTagList detailView: ', tempTagList)
+  const tagAfterRemove = tempTagList.filter((item) => {
+    console.log('对比！', item, item.uri.includes(route.path))
+    return item.name != route.name
+  })
+  if (route.query.isTodo) {
+    if (top == self) {
+      //协同办公
+      window.close()
+    } else {
+      const tempTagList = _.cloneDeep(top.document.getElementsByTagName('div')[0].__vue__.$store.state.app.tagNavList || [])
+      console.log('tempTagList detailView: ', tempTagList)
+      const tagAfterRemove = tempTagList.filter((item) => {
+        return item.name != route.name && !item.uri.includes(route.path) && item.isShow
+      })
+      console.log('tagAfterRemove detailView: ', tagAfterRemove)
+      top.document.getElementsByClassName('pro-layout-tabs-wrapper')[0].__vue__.emitTags(tagAfterRemove, tagAfterRemove[tagAfterRemove.length - 1].name)
+    }
+  } else {
+    router.back()
+  }
+}
+// 直接返回上一页面，不是返回配置的菜单上级

package/utils/storage.js

@@ -0,0 +1,51 @@
+// ============ SessionStorage ============
+export const getSessionStorage = (key) => {
+  const value = sessionStorage.getItem(key)
+  if (value) {
+    try {
+      return JSON.parse(value)
+    } catch (error) {
+      return value
+    }
+  }
+  return value
+}
+
+export const setSessionStorage = (key, value) => {
+  if (typeof value !== 'string') {
+    value = JSON.stringify(value)
+  }
+  sessionStorage.setItem(key, value)
+}
+
+export const removeSessionStorage = (key) => {
+  return sessionStorage.removeItem(key)
+}
+
+export function clearSessionStorage() {
+  sessionStorage.clear()
+}
+
+// ============ LocalStorage ============
+export const getLocalStorage = (key) => {
+  const value = localStorage.getItem(key)
+  if (value) {
+    try {
+      return JSON.parse(value)
+    } catch (error) {
+      return value
+    }
+  }
+  return value
+}
+
+export const setLocalStorage = (key, value) => {
+  if (typeof value !== 'string') {
+    value = JSON.stringify(value)
+  }
+  localStorage.setItem(key, value)
+}
+
+export const removeLocalStorage = (key) => {
+  return localStorage.removeItem(key)
+}

package/utils/table.js

@@ -0,0 +1,348 @@
+/*
+ * @Author: huxuetong
+ * @Date: 2023-10-27 15:05:25
+ * @Last Modified by: huxuetong
+ * @Last Modified time: 2024-11-25 11:09:00
+ */
+
+import _ from 'lodash'
+import { isFunction, isNil, isString } from './is-type'
+
+const GROUP_SEP = '__'
+const VALUE_SEP = '--'
+
+function renderHeaderTooltip({
+  tooltip,
+  item,
+  parents,
+  title,
+}) {
+  let text = null
+  if (tooltip) {
+    if (isFunction(tooltip)) {
+      text = tooltip(item, parents)
+    } else if (tooltip === true) {
+      text = title
+    } else {
+      text = tooltip
+    }
+  }
+  return text
+}
+
+// 根据各层分组定义组织出表头
+function renderColumnTree(
+  data,
+  columnGroup,
+  option = {},
+) {
+  const {
+    key,
+    keyProp,
+    title,
+    titleProp,
+    titleFormatter,
+    sortProp,
+    sortOrder = 'asc',
+    keyLastSuffix,
+    isLimitChildren,
+    headerTooltip,
+    children,
+    ...args
+  } = columnGroup
+  const { keyPropName = 'key', titlePropName = 'title', keyPrefix = '', parents = [] } = option
+
+  // 动态列
+  if (keyProp) {
+    let columnUniqData =
+      _.uniqBy(data, columnGroup.keyProp)?.filter((item) => !isNil(item[columnGroup.keyProp])) || []
+    if (sortProp) {
+      const unSortData = columnUniqData.filter((item) => isNil(item[sortProp]))
+      const sortData = columnUniqData.filter((item) => !isNil(item[sortProp]))
+      columnUniqData = _.orderBy(sortData, [sortProp], [sortOrder]).concat(unSortData)
+    }
+
+    return columnUniqData.map((item) => {
+      const columnTitle = titleFormatter ? titleFormatter(item[titleProp]) : item[titleProp]
+
+      // 不是最后一层，继续组织tree
+      if (children && children.length) {
+        // 前缀加__ 和下一层做分割
+        const prefix = `${keyPrefix}${keyProp}${VALUE_SEP}${item[keyProp]}${GROUP_SEP}`
+        const columnChildren = children.map((child) => {
+          let nextData = isLimitChildren
+            ? data.filter((temp) => temp[keyProp] === item[keyProp])
+            : data
+          return renderColumnTree(nextData, child, {
+            ...option,
+            keyPrefix: prefix,
+            parents: [...parents, item],
+          })
+        })
+
+        return {
+          ...args,
+          [titlePropName]: columnTitle,
+          headerTooltip: renderHeaderTooltip({
+            tooltip: headerTooltip,
+            item,
+            parents,
+            title: columnTitle,
+          }),
+          children: _.flatten(columnChildren), // 多层动态列下，上面的层级拿到的是个二维数组，flatten一下
+        }
+      }
+
+      // 最后一层 返回key、title
+      const suffix = keyLastSuffix ? `${GROUP_SEP}${keyLastSuffix}` : ''
+      return {
+        ...args,
+        [keyPropName]: `${keyPrefix}${keyProp}${VALUE_SEP}${item[keyProp]}${suffix}`,
+        [titlePropName]: columnTitle,
+        headerTooltip: renderHeaderTooltip({
+          tooltip: headerTooltip,
+          item,
+          parents,
+          title: columnTitle,
+        }),
+      }
+    })
+  }
+
+  const headerTooltipText = renderHeaderTooltip({
+    tooltip: headerTooltip,
+    item: {},
+    parents,
+    title,
+  })
+
+  // 非动态列 不是最后一层
+  if (children && children.length) {
+    // 非动态列的下一层一般都是在一行数据上的，所以拼接key时不加__做不同层级的分割，而是和下一层一起作为属性名
+    const prefix = `${keyPrefix}${key || ''}`
+    const columnChildren = children.map((child) => {
+      return renderColumnTree(data, child, { ...option, keyPrefix: prefix })
+    })
+
+    return {
+      ...args,
+      [titlePropName]: title,
+      headerTooltip: headerTooltipText,
+      children: _.flatten(columnChildren),
+    }
+  }
+  return {
+    ...args,
+    [keyPropName]: `${keyPrefix}${key || ''}`,
+    [titlePropName]: title,
+    headerTooltip: headerTooltipText,
+  }
+}
+
+// 获取最后一层的表头
+function getLeafColumns(columns = []) {
+  if (!columns || !columns.length) return []
+  return columns.reduce((rlt, column) => {
+    if (column.children) {
+      return [...rlt, ...getLeafColumns(column.children)]
+    } else {
+      return [...rlt, column]
+    }
+  }, [])
+}
+
+// 组织行转列结果的每一行数据
+function renderRowData(data, keys) {
+  if (!keys.length) return
+  const key = keys[0]
+  keys = keys.slice(1)
+
+  if (key.includes(VALUE_SEP) && keys.length) {
+    // 这个分组是动态列的分组，且不是最后一层
+    const [keyProp, keyValue] = key.split(VALUE_SEP)
+    // 一层一层往下找，筛选符合该分组的数据
+    const matchData = _.filter(data, { [keyProp]: keyValue })
+    return renderRowData(matchData, keys)
+  }
+
+  if (keys.length) {
+    console.error('怎么会不是最后一层分组呢，请联系开发人员查看！')
+  }
+  // 最后一层，固定指标，赋值
+  const value = data?.[0]?.[key]
+  return value
+}
+
+function getRowKeyValue(item, rowKey) {
+  if (!item) return ''
+  if (isString(rowKey)) return item[rowKey] || ''
+  for (const key of rowKey) {
+    if (item[key]) {
+      return item[key]
+    }
+  }
+  return ''
+}
+
+function renderSumColumn(keys, titles, idx, columns, def) {
+  if (idx >= keys.length) return
+
+  const key = keys[idx]
+  let header = _.find(columns, { key })
+  if (!header) {
+    header = { key, title: titles[idx], children: [] }
+    columns.push(header)
+
+    if (idx === keys.length - 1) {
+      Object.assign(header, def, { title: titles[idx] })
+      return
+    }
+  }
+
+  renderSumColumn(keys, titles, idx + 1, header.children, def)
+}
+
+function renderSumColumns({ sumColumnDefs }) {
+  const columns = []
+
+  for (const def of sumColumnDefs) {
+    const { key, title } = def
+    const keys = key.split(GROUP_SEP)
+    const titles = title.split(GROUP_SEP)
+
+    renderSumColumn(keys, titles, 0, columns, def)
+  }
+
+  return columns
+}
+
+/**
+ * 行转列公共方法
+ * ! 目前是根据非动态列下全是非动态列的分组来组织的，若动态列和非动态列相互穿插分组，那就糟糕了
+ *
+ * @param data 所有行数据
+ * @param columnGroups 分组定义
+ * @param rowKey 行转列目标结果的行主键
+ * @param option 一些参数
+ * @returns 行转列后的表头和数据
+ */
+export function row2column(
+  data = [],
+  columnGroups = [],
+  rowKey,
+  option = {},
+) {
+  // 组织表头
+  const columns = []
+  if (option.sumColumnDefs && option.sumColumnDefs.length) {
+    columns.push(...renderSumColumns(option))
+  }
+  const groupColumns =
+    _.flatten(columnGroups.map((group) => renderColumnTree(data, group, option))) || []
+  columns.push(...groupColumns)
+  const leafColumns = getLeafColumns(columns)
+
+  // 组织数据
+  const rowKeyUniqData =
+    _.uniqBy(data, (item) => getRowKeyValue(item, rowKey))?.filter(
+      (item) => !isNil(getRowKeyValue(item, rowKey)),
+    ) || []
+  const groupData = _.groupBy(data, (item) => getRowKeyValue(item, rowKey))
+  const rltData = rowKeyUniqData.map((item) => {
+    const rowKeyValue = getRowKeyValue(item, rowKey)
+    const rowGroupData = groupData[rowKeyValue] || []
+    const newItem = { ...item }
+
+    if (option.sumColumnDefs && option.sumColumnDefs.length) {
+      option.sumColumnDefs.forEach((def) => {
+        const { key } = def
+        const keys = key.split(GROUP_SEP) || []
+        const code = keys?.[0] || ''
+        const indexCol = keys?.[keys.length - 1] || ''
+        const { sumColKeyProp = 'sumColCode' } = option
+        const itemData = _.find(rowGroupData, { [sumColKeyProp]: code }) || {}
+        newItem[key] = itemData[indexCol]
+      })
+    }
+
+    leafColumns.forEach((column) => {
+      const columnKey = column[option.keyPropName || 'key'] || ''
+      const keys = columnKey.split(GROUP_SEP) || []
+      const value = renderRowData(rowGroupData, keys)
+      newItem[columnKey] = value
+      // 去掉原始数据的字段
+      delete newItem[keys[keys.length - 1]]
+    })
+    return newItem
+  })
+
+  return { data: rltData, columns }
+}
+
+// -----------------------------------------------------------------------------
+
+// 将每一行转回行数据
+function flattenRowData(
+  rowData = {},
+  leafColumns = [],
+  option = {},
+) {
+  const rlt = []
+  // 取出所有非动态列
+  const newItem = {}
+  const keys = Object.keys(rowData)
+  keys.forEach((key) => {
+    if (!key.includes(GROUP_SEP)) {
+      newItem[key] = rowData[key]
+    }
+  })
+
+  leafColumns.forEach((column) => {
+    const cellData = {}
+    const columnKey = column[option.keyPropName || 'key'] || ''
+
+    if (columnKey.includes(GROUP_SEP)) {
+      // 动态列
+      const keys = columnKey.split(GROUP_SEP)
+      keys.forEach((key, idx) => {
+        if (key.includes(VALUE_SEP) && keys.length) {
+          // 这个分组是动态列的分组，且不是最后一层
+          const [keyProp, keyValue] = key.split(VALUE_SEP)
+          cellData[keyProp] = keyValue
+        } else if (keys.length !== idx + 1) {
+          console.error('columns有问题，请检查！')
+        } else {
+          // 如果结果集里有该分组对应的数据，在其中加上这个列对应的指标数据，如果没有，增加一条该分组的数据
+          const item = _.find(rlt, cellData)
+          if (!item) {
+            rlt.push({ ...newItem, ...cellData, [key]: rowData[columnKey] })
+          } else {
+            item[key] = rowData[columnKey]
+          }
+        }
+      })
+    }
+  })
+
+  return rlt
+}
+
+/**
+ * 从行转列的数据转回行数据
+ *
+ * @param data 行转列后数据
+ * @param columns 行转列后的列定义
+ * @param option 一些参数
+ * @returns 行数据
+ */
+export function flattenRow2ColumnData(
+  data = [],
+  columns = [],
+  option = {},
+) {
+  const leafColumns = getLeafColumns(columns)
+  return data.reduce(
+    (rlt, rowData) => [...rlt, ...flattenRowData(rowData, leafColumns, option)],
+    [],
+  )
+}

package/utils/token.js

@@ -0,0 +1,51 @@
+import { getLocalStorage, getSessionStorage, setLocalStorage } from './storage';
+const TOKEN_KEY = 'v8-token';
+const TOKEN_KEY_IBP = 'lambo-token';
+// 要从门户跳转过来，sessionStorage不能带token过来，改成localStorage
+export function setToken(token) {
+    setLocalStorage(TOKEN_KEY, token);
+    Cookie.set('TOKEN_KEY', token, 1);
+}
+export function getToken() {
+    let token = getSessionStorage(TOKEN_KEY_IBP);
+    if (!token) {
+        token = Cookie.get('lambo-sso-key');
+    }
+    if (!token) {
+        token = Cookie.get('TOKEN_KEY');
+    }
+    if (!token) {
+        token = getLocalStorage(TOKEN_KEY);
+    }
+    return token || false;
+}
+const Cookie = {
+    set: function (key, value, exdays) {
+        //校验Key, key中不能有等号【=】
+        if (key.indexOf('=') !== -1) {
+            throw new Error('Cookie不支持key中使用等号【=】, key:' + key);
+        }
+        let exdate = new Date(); // 获取时间
+        exdate.setTime(exdate.getTime() + 24 * 60 * 60 * 1000 * exdays); // 保存的天数
+        // 字符串拼接cookie
+        // eslint-disable-next-line camelcase
+        window.document.cookie = key + '=' + value + ';path=/;expires=' + exdate.toGMTString();
+    },
+    get: function (key) {
+        if (document.cookie.length > 0) {
+            // 这里显示的格式需要切割一下自己可输出看下
+            var arr = document.cookie.split('; ');
+            for (let i = 0; i < arr.length; i++) {
+                let arr2 = arr[i].split('='); // 再次切割
+                // 判断查找相对应的值
+                if (arr2[0] === key) {
+                    var value = arr2[1];
+                    for (let j = 2; j < arr2.length; j++) {
+                        value += '=' + arr2[j];
+                    }
+                    return value;
+                }
+            }
+        }
+    },
+};

package/utils/tree.js

@@ -0,0 +1,39 @@
+/**
+ * 获取当前节点的全路径数组 [p1,p2,p3,curNode]
+ * @param treeData  树型数据
+ * @param currNode  当前节点 或 节点id
+ *
+ * @returns {Array} 全路径节点数组，未找到返回空数组
+ */
+
+export function getFullPathNodeById(treeData = [], curNode) {
+  if (!Array.isArray(treeData) || treeData.length === 0) {
+    return [];
+  }
+
+  if (curNode == null) {
+    return [];
+  }
+
+  const targetId = typeof curNode === "object" ? curNode["id"] : curNode;
+
+  function treeDeep(nodes, path) {
+    for (const node of nodes) {
+      const currentPath = [...path, node];
+
+      if (node["id"] === targetId) {
+        return currentPath;
+      }
+
+      if (node["children"] && node["children"].length > 0) {
+        const res = treeDeep(node["children"], currentPath);
+        if (res.length > 0) {
+          return res;
+        }
+      }
+    }
+    return [];
+  }
+
+  return treeDeep(treeData, []);
+}

package/utils/user.js

@@ -0,0 +1,8 @@
+import { axios } from './request/index'
+import config from '../config/config'
+
+const UC_CONTEXT = config.ucExtServerContext
+
+export function listUserTreeApi(params) {
+  return axios.get(`${UC_CONTEXT}/tree/uc-user/listUserTree`, { params })
+}

package/utils/wps.js

@@ -0,0 +1,16 @@
+const addScript = function (src, cb) {
+  const script = document.createElement('script')
+  script.src = src
+  document.getElementsByTagName('head')[0].appendChild(script)
+  script.onload = function () {
+    if (!!cb) {
+      cb()
+    }
+  }
+}
+
+export function initWps() {
+  addScript(
+    `${location.protocol}//${location.host}/ind-uc-ext/vendor/openSDK-0.0.6/open-jssdk-v0.0.6.umd.js`,
+  )
+}