@yy-common/shared 1.0.0-beta.6

package/router/guard.js

@@ -0,0 +1,283 @@
+import LamboDesign from "@lambo-design/core";
+const { LoadingBar, Message, Spin } = LamboDesign;
+
+import config from "@lambo-design/shared/config/config";
+// import { getToken } from "@lambo-design/shared/utils/platform";
+import { getToken } from "../utils/token";
+import _ from "lodash";
+import { PageLayout } from "../../components";
+import {
+  constantRouterComponents,
+  generator,
+  getPermissionType,
+  generatorRouteByPermission,
+  permission2Router,
+} from "./generator-routers";
+import { getPermissionCache } from "@lambo-design/shared/utils/n/permission-cache.js";
+import { filterMicroPermissionList } from "@lambo-design/shared/utils/n-generator-routers.js";
+
+const isAdded = (router, route) => {
+  let rlt = router.resolve(route);
+  return !!rlt?.resolved?.matched?.length;
+};
+
+const pageRoute = {
+  path: "/page",
+  name: "page",
+  meta: { hideInMenu: true, notCache: true },
+  component: PageLayout,
+  children: [],
+};
+
+/**
+ * 根据权限及微应用类型，组织动态路由表
+ *
+ * @param {DynamicRouterByPermissionOptions} params
+ * @param {VueRouter} params.router VueRouter实例
+ * @param {VueX.Store} params.store Store实例
+ * @param {string} microType 微应用类型
+ * @param {Array} allowPermissionList 不需要权限控制的权限数据
+ * @param {Object} routerOptionsBak 原始基础路由
+ */
+async function renderRoutes({
+  router,
+  store,
+  microType,
+  allowPermissionList,
+  routerOptionsBak,
+  to,
+}) {
+  // 是否首次调用
+  let isInitilaze = !store.state.user.userName;
+
+  // 已经加入到路由中，直接返回
+  if (isAdded(router, to) && !isInitilaze) {
+    return;
+  }
+
+  // 首次组织路由，系统初始化的逻辑
+  if (isInitilaze) {
+    // store.dispatch('getIndexInfo') // 获取指标描述信息
+    await store.dispatch("getUserInfo");
+    await store.dispatch("getAppListData");
+    await store.dispatch("getPermissionData", {
+      constantRouterComponents,
+      permissionStoreKeyParams: "ibp-sc-permission",
+    });
+
+    // 只有首次调用重置路由，后面只往里添加路由了
+    router.options = _.cloneDeep(routerOptionsBak);
+  }
+
+  // 获取权限缓存数据，第二次组织路由的时候，不要dispatch了
+  const permissionData = getPermissionCache();
+  const microPermissionData = filterMicroPermissionList(
+    microType,
+    permissionData
+  );
+
+  const rootRoute = router.options.routes.find((item) => item.path === "/");
+  if (isInitilaze) {
+    // 把pageRoute加入到根路由下,不然keepalive不起效果
+    router.addRoute(rootRoute.name, pageRoute);
+    rootRoute.children.push(pageRoute);
+  }
+
+  // 未加入路由
+  if (!isAdded(router, to)) {
+    //获取跳转权限类型
+    let tempPer = microPermissionData.find((item) => {
+      return item.permissionValue == to.name || item.name == to.name;
+    });
+    if (!tempPer && to.path != "/") {
+      tempPer = microPermissionData.find((item) => {
+        // 有在uri里加参数的场景，需要兼容一下，至于为什么不都用includes，忘了。。。，好像是有什么问题
+        return item?.uri?.includes("?")
+          ? item?.uri?.includes(to.path)
+          : item?.uri?.endsWith(to.path);
+      });
+    }
+    const perType = getPermissionType(tempPer.type || "");
+    let tmpRoute = generatorRouteByPermission(
+      permission2Router([tempPer], microType)[0]
+    );
+    //跳转的是页面
+    if (perType == "PAGE") {
+      router.addRoute(pageRoute.name, {
+        ...tmpRoute,
+        meta: { ...tmpRoute.meta, notCache: true },
+      });
+      pageRoute.children.push(tmpRoute);
+    }
+
+    //跳转的是菜单
+    if (perType == "MENU") {
+      router.addRoute(rootRoute.name, tmpRoute);
+      rootRoute.children.push(tmpRoute);
+    }
+  }
+  // }
+
+  // 首次组织路由，系统初始化的逻辑
+  if (isInitilaze) {
+    // TODO 这里有必要吗
+    // 明细页面不加权限控制，如果没有权限，加上去
+    // 保证只有本微应用的路由
+    const microAllowPermissionList = filterMicroPermissionList(
+      microType,
+      allowPermissionList
+    );
+    const needAddRoutes = microAllowPermissionList.filter((permission) => {
+      return (
+        router.options.routes.findIndex(
+          (route) => permission.name === route.name
+        ) === -1
+      );
+    });
+    needAddRoutes.forEach((item) => {
+      item.component = item.name;
+      item.meta = {
+        hideInMenu: true,
+        title: item.label,
+        activeName: item.name,
+      };
+    });
+    const dynamicDetailRouters = generator(needAddRoutes);
+    // 加到根路由的子路由里去
+    for (const item of dynamicDetailRouters) {
+      router.addRoute(config.rootRouteName, item);
+    }
+  }
+}
+
+// 路由统一处理
+export function addRouterGuards({
+  router,
+  store,
+  microType,
+  allowPermissionList,
+}) {
+  const LOGIN_PAGE_NAME = config.loginRouteName;
+  const routerOptionsBak = _.cloneDeep(router.options);
+
+  // 会话失效钩子，@indfnd/utils里axios拦截器调用
+  window.sessionNotValidHandler = function () {
+    // 在登录页就不用再跳转了
+    let url = location.href;
+    const searchIdx = url.indexOf("?");
+    if (searchIdx !== -1) {
+      url = url.substring(0, searchIdx);
+    }
+    if (url.endsWith("/login")) return;
+
+    if (window.confirm("会话已失效，是否重新登录？")) {
+      top.location = "/ibp-sc/login";
+    }
+  };
+
+  // 接口报错钩子，@indfnd/utils里axios拦截器调用
+  window.apiErrorHandler = function (msg) {
+    Message.error({ content: msg, duration: 10, closable: true });
+  };
+
+  window.getQueryVariable = function getQueryVariable(variable) {
+    var query = window.location.search.substring(1);
+    var vars = query.split("&");
+    for (let i = 0; i < vars.length; i++) {
+      let pair = vars[i].split("=");
+      if (pair[0] == variable) {
+        return pair.slice(1).join("=");
+      }
+    }
+    let routeHash = window.location.hash.substring(2);
+    if (routeHash.includes("?")) {
+      query = routeHash.split("?")[1];
+    }
+    vars = query.split("&");
+    for (let i = 0; i < vars.length; i++) {
+      let pair = vars[i].split("=");
+      if (pair[0] == variable) {
+        return pair.slice(1).join("=");
+      }
+    }
+    return false;
+  };
+  // 前置逻辑，判断会话是否失效，判断动态路由是否已初始化
+  router.beforeEach(async (to, from, next) => {
+    //from有isTodo to没有isTodo, 从代办返回
+    LoadingBar.start();
+    let token = getToken();
+    let search = location.search;
+    //杰哥说token赋true影响编译 换个变量试试
+    let tempToken = false;
+    if (search) {
+      let rlt = getQueryVariable("token");
+      if (rlt) {
+        // 如果已经单点登录过了，这里不应再重新初始化状态了
+        if (token !== rlt) {
+          token = rlt;
+          store.dispatch("loginSuccess", token);
+        }
+      }
+
+      let ssoToken =
+        getQueryVariable("sso_token") || sessionStorage.getItem("sso_token");
+      if (ssoToken) {
+        tempToken = true; // token只是标识有会话，并不作为会话的凭证了
+        sessionStorage.setItem("sso_token", ssoToken);
+      }
+    }
+
+    let isInitilaze = !store.state.user.userName;
+    if (!tempToken && !token && to.name !== LOGIN_PAGE_NAME) {
+      // 未登录且要跳转的页面不是登录页，跳转到登录页
+      next({ name: LOGIN_PAGE_NAME });
+    } else if (to.name === LOGIN_PAGE_NAME) {
+      // 要跳转的页面是登录页
+      next();
+    } else if (
+      isInitilaze ||
+      top !== self ||
+      location.href.includes("imarket-analysis")
+    ) {
+      Spin.show();
+      try {
+        // 去处理动态路由
+        await renderRoutes({
+          router,
+          store,
+          microType,
+          allowPermissionList,
+          routerOptionsBak,
+          to,
+        });
+
+        if (isInitilaze || !to.matched?.length) {
+          console.log("路由没有匹配到", to);
+          if (to.name && to.path == "/") {
+            next({ name: to.name, query: to.query /*, replace: true*/ });
+          } else {
+            console.log("路由匹配到，跳", to);
+            next({ ...to /*, replace: true */ });
+          }
+        } else {
+          console.log("路由匹配到，跳2", to);
+          next();
+        }
+      } catch (error) {
+        console.log("router.beforeeach err", error);
+        next({ name: LOGIN_PAGE_NAME });
+      }
+      Spin.hide();
+    } else {
+      next();
+    }
+  });
+
+  // 后置逻辑
+  router.afterEach((to) => {
+    // setTitle(to)
+    LoadingBar.finish();
+    window.scrollTo(0, 0);
+  });
+}

package/router/index.js

@@ -0,0 +1,9 @@
+import config from '@yy-common/shared/config/config'
+
+export * from './basic-routes'
+export * from './guard'
+
+export const routerOptions = {
+  mode: 'history',
+  base: config.routerBase,
+}

package/utils/column-setting.js

@@ -0,0 +1,72 @@
+import _ from "lodash";
+
+/**
+ * 处理表格列配置
+ * @param {Array} tableColumns - 业务定义的原始列配置
+ * @param {Array} columns - 用户自定义的列配置
+ * @returns {Array} - 处理后的列配置数组
+ */
+export function processColumns(tableColumns, columns) {
+  let copyColumns = _.cloneDeep(tableColumns)
+  // 创建业务组件列的映射表，以key或field为键
+  const businessColumnsMap = new Map()
+  copyColumns.forEach((col) => {
+    const key = col.key || col.field || col.title
+    if (key) {
+      businessColumnsMap.set(key, col)
+    }
+  })
+
+  let disabledColumnType = ['checkbox', 'radio', 'index', 'button']
+  const orderedColumns = columns
+      .map((col) => {
+        if (disabledColumnType.includes(col.type)) {
+          let businessCol = copyColumns.find((businessCol) => col.type === businessCol.type)
+          if (businessCol) {
+            businessCol.pinned = col.pinned
+            businessCol.fixed = col.fixed
+            businessCol.width = col.width
+            businessCol.checked = col.checked
+            businessCol.hide = col.hide
+            // 如果有子节点，递归处理
+            if (col.children && businessCol.children) {
+              businessCol.children = processColumns(businessCol.children, col.children)
+            }
+          }
+          return businessCol
+        } else {
+          const key = col.key || col.field || col.title
+          let businessCol = businessColumnsMap.get(key)
+          if (businessCol) {
+            businessCol.pinned = col.pinned
+            businessCol.fixed = col.fixed
+            businessCol.width = col.width
+            businessCol.checked = col.checked
+            businessCol.hide = col.hide
+            // 如果有子节点，递归处理
+            if (col.children && businessCol.children) {
+              businessCol.children = processColumns(businessCol.children, col.children)
+            }
+          }
+          return businessCol
+        }
+      })
+      .filter((col) => col !== undefined)
+
+  copyColumns.forEach((col, index) => {
+    const key = col.field || col.key || col.title
+    if (!key) {
+      return
+    }
+    // 检查是否已在 orderedColumns 中
+    const isInOrdered = orderedColumns.some(
+        (orderedCol) => (orderedCol.field || orderedCol.key || orderedCol.title) === key,
+    )
+    // 如果不在 orderedColumns 中，放在原位置
+    if (!isInOrdered) {
+      orderedColumns.splice(index, 0, col)
+    }
+  })
+
+  return orderedColumns
+}

package/utils/com.js

@@ -0,0 +1,8 @@
+import { axios } from './request/index'
+import config from '../config/config'
+
+const CONTEXT = config.ismAmServerContext
+
+export function listComTreeApi(params) {
+  return axios.get(`${CONTEXT}/tree/com/listComTree`, { params })
+}

package/utils/dict-cache.js

@@ -0,0 +1,11 @@
+import { getSessionStorage, setSessionStorage } from './storage'
+
+const DICT_KEY = 'ind-dict_'
+
+export function getDictCache(dictId) {
+  return getSessionStorage(`${DICT_KEY}${dictId}`)
+}
+
+export function setDictCache(dictId, data) {
+  setSessionStorage(`${DICT_KEY}${dictId}`, data)
+}

package/utils/dynamicSetting.js

@@ -0,0 +1,45 @@
+import _ from 'lodash'
+
+
+/**
+ * 统一处理表单字段props属性定义配置
+ *
+ * @param fieldList 表单项字段定义
+ * @param fieldProps 需要修改的表单项字段属性配置，支持多个字段，格式为 { userId: { maxlength: 32 }, userType: { maxlength: 32 } }
+ * @returns 新的表单定义
+ */
+export function renderFieldProps(fieldList = [], fieldProps = {}) {
+  const rlt = _.cloneDeep(fieldList)
+  const fieldKeys = Object.keys(fieldProps)
+  rlt.forEach((field) => {
+    const key = field.formKey
+    if (fieldKeys.includes(key)) {
+      const props = fieldProps[key]
+      field.props = {
+        ...field.props,
+        ...props,
+      }
+    }
+  })
+  return rlt
+}
+
+/**
+ * 统一处理表单字段定义配置
+ *
+ * @param fieldList 表单项字段定义
+ * @param fields 需要修改的表单项字段配置，支持多个字段，格式为 { userId: { disabled: true }, userType: {disabled: true , enumList: [{ K: '01', V: '省级' }, {K: '02', V: '市级' }]}}
+ * @returns 新的表单定义
+ */
+export function renderFields(fieldList = [], fields = {}) {
+  const rlt = _.cloneDeep(fieldList)
+  const fieldKeys = Object.keys(fields)
+  rlt.forEach((field) => {
+    const key = field.formKey
+    if (fieldKeys.includes(key)) {
+      const props = fields[key]
+      Object.assign(field, props)
+    }
+  })
+  return rlt
+}

package/utils/enum.js

@@ -0,0 +1,137 @@
+import { isArray } from './is-type'
+import _ from 'lodash'
+
+/** 是否枚举的key */
+export const IS_OR_NOT_ENUM_KEY = 'IS_ENUM'
+/** 是否枚举的map形式 */
+export const IS_OR_NOT_ENUM = { '1': '是', '0': '否' }
+/** 是否枚举的list形式 */
+export const IS_OR_NOT_ENUM_LIST = [
+  { K: '1', V: '是' },
+  { K: '0', V: '否' },
+]
+
+// 中台相关枚举，暂时写死
+export const UC_ENUM = {
+  MANAGE_UNIT_ID: '00000000000000000000000020370001', // 管理单元Id
+  ORG_CODE_ADMIN: 'default', // 行政树类型
+  ORG_CODE_MKT: '08', // 营销业务树类型
+  ORG_CODE_LOG: '08', // 物流业务树类型，之前说要分开建的，现在和营销一个树
+  ORG_CODE_ACTIVITY: '08', // 宣促业务树类型，之前说要分开建的，现在和营销一个树
+  ADMIN_LEVEL_IND: '01', // 行政树组织级别 - 工业公司
+  ADMIN_LEVEL_CENTER: '02', // 行政树组织级别 - 营销中心
+  ADMIN_LEVEL_FAC: '03', // 行政树组织级别 - 卷烟厂
+  ADMIN_LEVEL_DIST: '04', // 行政树组织级别 - 区域
+  ADMIN_LEVEL_COMMON_DEPT: '08', // 行政树组织级别 - 普通部门
+  ADMIN_LEVEL_COMMON_POST: '80', // 行政树组织级别 - 普通岗位
+  LEVEL_IND: '01', // 业务树组织级别 - 工业公司
+  LEVEL_CENTER: '02', // 业务树组织级别 - 营销中心
+  LEVEL_FAC: '02', // 业务树组织级别 - 卷烟厂
+  LEVEL_DIST: '04', // 业务树组织级别 - 普通卷烟营销的区域
+  LEVEL_CIGAR_DIST: '05', // 业务树组织级别 - 雪茄片区
+  LEVEL_COMMON_DEPT: '03', // 业务树组织级别 - 普通部门
+  LEVEL_COMMON_POST: '80', // 业务树组织级别 - 普通岗位
+  LEVEL_DIST_MANAGE_POST: '81', // 业务树组织级别 - 区域经理岗位
+  LEVEL_CUST_MANAGE_POST: '82', // 业务树组织级别 - 客户经理岗位
+  LEVEL_CIGAR_DIST_MANAGE_POST: '83', // 业务树组织级别 - 雪茄片区经理岗位
+  LEVEL_CIGAR_CUST_MANAGE_POST: '84', // 业务树组织级别 - 雪茄客户经理岗位
+  LEVEL_INTERNAL_POST: '85', // 业务树组织级别 - 内勤岗位
+}
+
+/**
+ * 将自定义的列表转换为枚举列表格式，如
+ * ```
+ * let list = [{ brandId: '0916', brandName: '泰山' }]
+ * renderEnumList(list, 'brandId', 'brandName') // 返回 [{ K: '0916', V: '泰山' }]
+ * ```
+ *
+ * @param list 枚举列表
+ * @param kProp key对应属性名
+ * @param vProp value对应属性名
+ * @returns 公共组件可直接使用的枚举列表
+ */
+export function renderEnumList(list = [], kProp = 'K', vProp = 'V') {
+  return list.map((item) => ({ K: item[kProp], V: item[vProp] }))
+}
+
+/**
+ * 将自定义的列表转换为枚举对象格式，如
+ * ```
+ * let list = [{ brandId: '0916', brandName: '泰山' }]
+ * renderEnumData(list, 'brandId', 'brandName') // 返回 { '0916': '泰山' }
+ * ```
+ * @param list 枚举列表
+ * @param kProp key对应属性名
+ * @param vProp value对应属性名
+ * @returns 公共组件可直接使用的枚举对象
+ */
+export function renderEnumData(list = [], kProp = 'K', vProp = 'V') {
+  return list.reduce((item) => ({ ...item, [item[kProp]]: item[vProp] }), {})
+}
+
+/**
+ * 统一处理表格列定义的枚举列
+ * - 由于表格组件不方便获取枚举数据，需要各业务先获取枚举数据后，重新组织列定义
+ * - 需通过特定接口获取的数据可以经 `renderEnumList` 或 `renderEnumData` 处理成枚举后使用
+ *
+ * @param columns 列定义，对type为 `enum` 或 `select` 的列进行处理
+ * @param enumRelation 枚举数据，支持多个枚举，格式为 `{ '枚举Id1': [{ K: '', V: ''}] }` 或 `{ '枚举Id1': { 'K': 'V' } }`
+ * @returns 新的列定义
+ */
+export function renderColumnEnums(columns = [], enumRelation = {}) {
+  const rlt = _.cloneDeep(columns)
+  const enumKeys = Object.keys(enumRelation)
+
+  rlt.forEach((column) => {
+    const key = column.field || column.key
+    const isType = ['enum', 'select'].includes(column.type)
+    if (enumKeys.includes(key) && isType) {
+      if (!column.cellRendererParams) {
+        column.cellRendererParams = {}
+      }
+
+      const enums = enumRelation[key]
+      if (column.type === 'enum') {
+        if (isArray(enums)) {
+          column.cellRendererParams.enumList = enums
+        } else {
+          column.cellRendererParams.enumData = enums
+        }
+      } else if (column.type === 'select') {
+        column.cellRendererParams.datas = enums
+      }
+    }
+
+    if (column.children && column.children.length) {
+      column.children = renderColumnEnums(column.children, enumRelation)
+    }
+  })
+  return rlt
+}
+
+/**
+ * 统一处理表单的类枚举列
+ * - 用于处理需特定接口获取数据的列表
+ * - 获取数据后可以经 `renderEnumList` 或 `renderEnumData` 处理成枚举后使用
+ *
+ * @param fieldList 表单项定义，其中对 `formKey` 和 `enumRelation` 的属性匹配上的表单项进行处理
+ * @param enumRelation 枚举数据，支持多个枚举，格式为 `{ '枚举Id1': [{ K: '', V: ''}] }` 或 `{ '枚举Id1': { 'K': 'V' } }`
+ * @returns 新的表单定义
+ */
+export function renderFieldEnums(fieldList = [], enumRelation = {}) {
+  const rlt = _.cloneDeep(fieldList)
+  const enumKeys = Object.keys(enumRelation)
+
+  rlt.forEach((field) => {
+    const key = field.formKey
+    if (enumKeys.includes(key)) {
+      const enums = enumRelation[key]
+      if (isArray(enums)) {
+        field.enumList = enums
+      } else {
+        field.enumData = enums
+      }
+    }
+  })
+  return rlt
+}

package/utils/errorLog.js

@@ -0,0 +1,39 @@
+import _ from 'lodash'
+import { axios } from '@yy-common/shared/utils'
+import { config } from "@lambo-design/shared/config/config"
+
+export function axiosResponse2Str(resp) {
+    let headerTxt = resp?.headers?.toString()
+    let responseText = resp?.request?.responseText
+    return JSON.stringify({
+        status: resp?.status,
+        headerTxt,
+        responseText,
+    })
+}
+
+export function errorLog(params) {
+    if(config.disableErrorLog){
+        return
+    }
+    let defaultParams = {
+        imsysLogsFunction: 'responseInterceptors',
+        imsysLogsInput: '',
+        imsysLogsModule: '网络请求',
+        imsysLogsRepair: '',
+        imsysLogsTitle: '网络请求错误',
+        imsysLogsType: '1',
+    }
+    let imsysErrorLogsREQ = _.merge({}, defaultParams, params)
+    // 兼容湖北企业微信
+    let preFixUrl = location.pathname.includes('scyxweb') ? '/scyxgateway' : ''
+    axios
+    .post(`${preFixUrl}/ddd-imsys-manage-server/manage/error-log/saveErrorLog`, imsysErrorLogsREQ)
+    .then((resp) => {
+      if (resp.data.code === 1) {
+        /* empty */
+      } else {
+        /* empty */
+      }
+    })
+}