agilebuilder-ui 1.1.65-tmp7 → 1.1.65-tmp9

package/packages/super-grid/src/utils.js

@@ -1,946 +0,0 @@
-import * as Vue from 'vue'
-import { getToken } from '../../../src/utils/auth'
-import { isPlateSys, isShowMenuRoute } from '../../../src/utils/common-util'
-import { getEntityFieldValue } from '../../../src/utils/util'
-import { doFormatWithValueSet } from './formatter'
-
-import store from './store'
-import { parseSubTablePermissionCondition } from '../../../src/utils/calculator/calculator-util'
-export function getColumnValues(data, prop) {
-  const values = []
-  for (const obj of data) {
-    values.push(obj[prop])
-  }
-  return values
-}
-/**
- * 返回的数组表示当前列每行的合并情况：[3,0,0,1,1]表示1到3行合并，四五行不合并
- * @param {Array} data 列表数据
- * @param {String} prop 列名
- */
-export function getSpanValuesForColumn(data, prop, mergerCellBasis) {
-  const spanArr = []
-  let pos = 0
-  for (let i = 0; i < data.length; i++) {
-    if (i === 0) {
-      spanArr.push(1)
-      pos = 0
-    } else {
-      if (mergerCellBasis && mergerCellBasis !== '') {
-        // 判断当前元素与上一个元素是否相同
-        let compareValue1 = ''
-        let compareValue2 = ''
-        const arr = mergerCellBasis.split(',')
-        for (let k = 0; k < arr.length; k++) {
-          compareValue1 += data[i][arr[k]]
-          compareValue2 += data[i - 1][arr[k]]
-        }
-        if (compareValue1 === compareValue2) {
-          spanArr[pos] += 1
-          spanArr.push(0)
-        } else {
-          spanArr.push(1)
-          pos = i
-        }
-      } else {
-        // 判断当前元素与上一个元素是否相同
-        if (data[i][prop] === data[i - 1][prop]) {
-          spanArr[pos] += 1
-          spanArr.push(0)
-        } else {
-          spanArr.push(1)
-          pos = i
-        }
-      }
-    }
-  }
-  return spanArr
-}
-
-export function getFirstEditableColumn(listCode) {
-  if (!listCode) {
-    listCode = store.get('_list_code')
-  }
-  for (const column of store.get(listCode).columns) {
-    if (column.editable) {
-      return column.prop
-    }
-  }
-  return null
-}
-
-const ArrowKeyAction = {
-  getIndex(prop) {
-    let i = 0
-    for (const column of store.columns) {
-      if (column.prop === prop) {
-        return i
-      } else {
-        i++
-      }
-    }
-  },
-  getLeftColumn(prop) {
-    const index = ArrowKeyAction.getIndex(prop)
-    let i = 0
-    for (i = index - 1; i >= 0; i--) {
-      if (store.columns[i].editable) {
-        return store.columns[i].prop
-      } else {
-        return null
-      }
-    }
-  }
-}
-export { ArrowKeyAction }
-
-// 行编辑时设置当前选中行
-export function setCurrentRow(rowIndex, listCode) {
-  if (!listCode) {
-    listCode = store.get('_list_code')
-  }
-  const gridParams = store.get(listCode)
-  if (rowIndex < gridParams.gridData.length) {
-    // 新建时会传过来比记录条数大的行号
-    if (gridParams.isMulitiSelect) {
-      gridParams.superGrid.clearSelection()
-      gridParams.superGrid.toggleRowSelection(gridParams.gridData[rowIndex], true)
-    } else {
-      gridParams.superGrid.setCurrentRow(gridParams.gridData[rowIndex])
-    }
-  }
-}
-
-// 判断两个对象内容是否相等
-export function isObjectValueEqual(a, b) {
-  if (!a && !b) {
-    return true
-  }
-  if (a && b) {
-    var aProps = getProps(a)
-    var bProps = getProps(b)
-    let forProps = aProps
-    if (aProps.length > bProps.length) {
-      forProps = aProps
-    } else {
-      forProps = bProps
-    }
-
-    for (var i = 0; i < forProps.length; i++) {
-      var propName = forProps[i]
-      if (propName === '$editing') {
-        continue
-      }
-      var propA = a[propName]
-      var propB = b[propName]
-      if (propA !== propB) {
-        return false
-      }
-    }
-    return true
-  }
-  return false
-}
-
-function getProps(obj) {
-  const props = []
-  for (var name in obj) {
-    props.push(name)
-  }
-  return props
-}
-
-// 最后编辑的行是否保存
-export function isLastEditRowSave(listCode) {
-  if (!listCode) {
-    listCode = store.get('_list_code')
-  }
-  const gridParams = store.get(listCode)
-  if (gridParams.isEditRow !== undefined && gridParams.isEditRow === true) {
-    // 表示有正在编辑的行，不能编辑其他行
-    return false
-  }
-  if (typeof gridParams.$rowIndex === 'undefined' || gridParams.$rowIndex === null) {
-    // 表示没有在该列表编辑任何行，可以编辑行
-    return true
-  }
-  if (typeof gridParams.$lastSaveRowIndex === 'undefined' || gridParams.$lastSaveRowIndex === null) {
-    // 表示没有在该列表保存任何行，可以编辑行
-    return true
-  }
-  if (gridParams.$rowIndex === gridParams.$lastSaveRowIndex) {
-    // 当前编辑行 等于  最后保存的行号，则表示最后编辑的行已保存
-    return true
-  }
-  return false
-}
-
-// 是否可以刷新列表
-export function isCanRefreshGrid(listCode) {
-  if (!listCode) {
-    listCode = store.get('_list_code')
-  }
-  const gridParams = store.get(listCode)
-  if (gridParams.isEditRow !== undefined && gridParams.isEditRow === true) {
-    // 表示有正正编辑的行，不能刷新列表
-    return false
-  }
-  const isEditRowSave = isLastEditRowSave()
-  if (!isEditRowSave) {
-    // 如果最后编辑行没有保存或撤销编辑，则表示当前列表中有编辑行，不能刷新列表数据
-    return false
-  }
-
-  if (typeof gridParams.isCreateRow !== 'undefined' && gridParams.isCreateRow === true) {
-    // 说明刚刚新建的行还没有保存 或 撤销编辑，表示当前列表中有编辑行，不能刷新列表数据
-    return false
-  }
-  return true
-}
-
-function getEntityId(row) {
-  if (row && row.id) {
-    return row.id
-  } else if (row && row.ID) {
-    return row.ID
-  }
-}
-
-// 行编辑时，是否有权限编辑某字段
-export function isDisableEdit(prop, listCode, row, rowIndex) {
-  if (!listCode) {
-    listCode = store.get('_list_code')
-  }
-  // 默认是可编辑的
-  let isDiabled = false
-  const gridParams = store.get(listCode)
-  const disableEditProps = isHasEditOption('disableEditProps', listCode)
-    ? gridParams.options.lineEditOptions.disableEditProps
-    : null
-  if (disableEditProps) {
-    const disableEditPropsArr = disableEditProps.split(',')
-    if (disableEditPropsArr && disableEditPropsArr.indexOf(prop) >= 0) {
-      isDiabled = true
-    }
-  }
-  const rowId = getEntityId(row)
-  if (isDiabled === false && gridParams.options) {
-    const fieldPermissions = gridParams.options.validateRules
-    if (fieldPermissions) {
-      const fieldRule = fieldPermissions.filter(
-        (item) => item.name && (item.name === prop || item.name === 'all_fields')
-      )
-      let canEdit = true
-      if (fieldRule && fieldRule.length > 0) {
-        for (let i = 0; i < fieldRule.length; i++) {
-          if (fieldRule[i].rowIndexes === undefined || fieldRule[i].rowIndexes === null) {
-            canEdit = fieldRule[i].canEdit
-          } else if (fieldRule[i].rowIndexes.indexOf(rowId) >= 0) {
-            canEdit = fieldRule[i].canEdit
-          } else {
-            canEdit = true
-          }
-        }
-        if (canEdit === false) {
-          isDiabled = true
-        }
-        // const fieldPermission = fieldRule[0]
-        // const canEdit = fieldPermission.canEdit
-        // if (typeof canEdit !== 'undefined' && canEdit === false) {
-        //   // 表示禁止编辑
-        //   if (fieldPermission.rowIndexes === undefined || (rowId !== undefined && fieldPermission.rowIndexes && fieldPermission.rowIndexes.indexOf(rowId) >= 0)) {
-        //     // 表示是子表记录，需要验证当前行是否需要禁止编辑
-        //     isDiabled = true
-        //   }
-        // }
-      }
-    }
-    if (isDiabled === false) {
-      // 根据子表的修改权限来判断是否可编辑，如果不能修改，则该行记录禁止编辑
-      const actionPermission = gridParams.options.actionPermission
-      const isOneRowCanUpdate = isRowCanUpdate(actionPermission, rowId)
-      if (isOneRowCanUpdate === false) {
-        // 如果当前行是禁止修改的，则当前行所有字段都禁止编辑
-        isDiabled = true
-      }
-    }
-    if (isDiabled === false) {
-      // 表示不是禁止编辑的，继续校验自定义规则中是否是禁止编辑的
-      if (
-        gridParams.options.customRules &&
-        (gridParams.options.customRules[prop] || gridParams.options.customRules['_all_fields'])
-      ) {
-        const columnRules = gridParams.options.customRules[prop]
-          ? gridParams.options.customRules[prop]
-          : gridParams.options.customRules['_all_fields']
-        let beforeValidateResult = true
-        // if (columnRules.beforeValidate) {
-        //   beforeValidateResult = rowBeforeValidate(columnRules, gridParams, row, rowIndex)
-        // }
-        if (columnRules && columnRules.disabled && beforeValidateResult !== false) {
-          isDiabled = true
-        }
-      }
-    }
-  }
-  return isDiabled
-}
-
-export function rowBeforeValidate(columnRules, gridParams, row, rowIndex) {
-  const params = {
-    parent: gridParams.options.extraParam.entityMap,
-    row: row,
-    pageContext: gridParams.options.pageContext,
-    configure: gridParams.options.configureObj,
-    rowIndex
-  }
-  return columnRules.beforeValidate(params)
-}
-
-// 行编辑时，是否必填某字段, 如果是流程表单子表， 需要将列表管理里配置的必填字段去掉，使用流程内的子表编辑权限控制
-export function isRequiredEdit(column, listCode) {
-  const prop = column.prop
-  if (!listCode) {
-    listCode = store.get('_list_code')
-  }
-  // 默认是不必填的
-  let isRequired = false
-  // 表示是可以编辑的，不是禁止编辑的字段，才判断是否必填
-  const gridParams = store.get(listCode)
-  if (gridParams && gridParams.options) {
-    const fieldPermissions = gridParams.options.validateRules
-    if (fieldPermissions) {
-      const fieldRule = fieldPermissions.filter(
-        (item) =>
-          item.name &&
-          (item.name === prop || item.name === 'all_fields') &&
-          item.canEdit !== undefined &&
-          item.canEdit === true
-      )
-      if (fieldRule && fieldRule.length > 0) {
-        isRequired = true
-      }
-    } else if (column.validations) {
-      const validations = JSON.parse(column.validations)
-      const fieldRule = validations.filter((item) => item.required === true)
-      if (fieldRule && fieldRule.length > 0) {
-        isRequired = true
-      }
-    }
-  }
-  return isRequired
-}
-
-// 当前行是否可修改
-function isRowCanUpdate(tableActionPermission, rowId) {
-  let canUpdate = true
-  const oneTableActionPermission = tableActionPermission
-  if (
-    oneTableActionPermission &&
-    oneTableActionPermission.canUpdate !== undefined &&
-    oneTableActionPermission.canUpdate === false &&
-    rowId !== undefined &&
-    oneTableActionPermission.updateRowIndexes &&
-    oneTableActionPermission.updateRowIndexes.indexOf(rowId) >= 0
-  ) {
-    // 表示是子表字段，且新建的记录（未保存的）可以修改 或 指定行不能修改
-    canUpdate = false
-  }
-  return canUpdate
-}
-
-/**
- * 是否是行编辑时的属性
- * @param {*} event
- */
-export function isHasEditOption(event, listCode) {
-  if (!listCode) {
-    listCode = store.get('_list_code')
-  }
-  const gridParams = store.get(listCode)
-  if (gridParams.options.lineEditOptions && gridParams.options.lineEditOptions[event]) {
-    return true
-  }
-  return false
-}
-
-export function isEditOptionFunction(event, listCode) {
-  if (!listCode) {
-    listCode = store.get('_list_code')
-  }
-  const gridParams = store.get(listCode)
-  if (gridParams.options.lineEditOptions && typeof gridParams.options.lineEditOptions[event] === 'function') {
-    return true
-  }
-  return false
-}
-
-/**
- * 是否是行编辑时的属性
- * @param {*} event
- */
-export function isHasOptionFunction(event, listCode) {
-  if (!listCode) {
-    listCode = store.get('_list_code')
-  }
-  const gridParams = store.get(listCode)
-  if (gridParams.options && typeof gridParams.options[event] === 'function') {
-    return true
-  }
-  return false
-}
-
-export function isOptionFunction(props, listCode) {
-  if (!listCode) {
-    listCode = store.get('_list_code')
-  }
-  const gridParams = store.get(listCode)
-  if (props && props.indexOf('.') > 0) {
-    let optionProp = gridParams.options
-    const propsArr = props.split('.')
-    for (let i = 0; i < propsArr.length; i++) {
-      const event = propsArr[i]
-      if (optionProp) {
-        if (typeof optionProp[event] === 'function') {
-          return true
-        } else {
-          optionProp = optionProp[event]
-        }
-      } else {
-        return false
-      }
-    }
-  } else {
-    if (gridParams.options && typeof gridParams.options[event] === 'function') {
-      return true
-    }
-  }
-}
-
-/**
- * 获得控制表格需要的参数
- */
-export function getGridParams() {
-  const gridParams = {
-    columns: [],
-    gridData: [],
-    orgGridData: [], // 行编辑保存时使用
-    canSaveRow: true, // 行编辑时是否可以保存行记录的状态为
-    showValidateError: true, // 是否可以显示验证信息，防止同时弹出两个验证信息的
-    defaultLineEditOptions: {
-      aftersaveIsCreateRow: true, // 保存成功后，是否自动新增一行
-      autoSave: true, // 失去焦点时，是否自动保存
-      isSaveByEnter: true, // 点击enter时，是否自动保存
-      isRestoreByEsc: true, // 点击ESC时，是否撤销编辑,
-      aftersaveIsCancelEditState: true, // 保存后，是否取消编辑状态
-      afterRestoreIsCancelEditState: true, // 撤销编辑后，是否取消编辑状态
-      input: function () {} // 数据改变时触发
-      // 'beforeSave': function() { return true }, // 保存行数据前的回调
-      // 'saveSuccess': function() {}, // 保存行数据成功的回调
-      // 'saveError': function() {}, // 保存行数据发生异常的回调
-      // 'beforeRestore': function() { return true }, // 撤销编辑前
-      // 'afterRestore': function() {}, // 撤销编辑后
-      // 'input': function() {}, // 数据改变时触发
-      // 'enter': function() {}, // enter回调
-      // 'esc': function() {}, // ESC回调
-      // 'focus': function() {}, // 获得焦点
-      // 'change': function() {}, // 值发生变化
-      // 'clear': function() {}, // 清空组件数据
-      // 'blur': function() {}, // 失去焦点
-      // 'remove-tag': function() {}, // select 多选模式下移除tag时触发
-      // 'visible-tag': function() {}, // 下拉框出现/隐藏时触发
-      // 'select-value': function() {}, // 组织树关闭时回调
-      // 'disableEditProps': '', // 字段配置的是可编辑的，但是当前用户没有权限禁止编辑的字段属性名，多个属性名之间以逗号隔开，例如：name,address
-      // 'beforeInsertRow': function(gridData, rowIndex) { return true }, // 插入行前的回调
-      // 'afterInsertRow': function(gridData, rowIndex) {}, // 插入行后的回调
-      // 'beforeEdit': function(gridData, rowIndex) { return true } // 编辑当前行前
-    },
-    options: {
-      // 行编辑需要的一些回调事件
-      lineEditOptions: {
-        // urlToSaveRow:'', // 保存行记录的url，如果设置了以该设置的为准
-        // isEnableValidate: true, // 保存行记录时，是否启用必填验证
-        // saveRow: function(){return new Promise((resolve, reject) => {...resolve(data)})} // 需要返回的是保存后的行记录的值
-      }
-      // 自定义行编辑
-      // customFormatter: {
-      // },
-      // 动态列
-      // dynamicColumns: [],
-      // 附加参数
-      // extraParam: {},
-      // 表头渲染设置
-      // 格式为：{'props':'fieldName,fieldName,fieldName','color':'表头的背景色。样式表支持的颜色'}
-      // renderHeader: {},
-      // 渲染行数据，格式为：{rowIndex:'color',rowIndex:'color'},rowIndex的从0开始计数
-      // renderRow: {},
-      // 渲染行的回调方法，返回值是个对象，如：{'background': 'red'}，详情见element-ui的官方文档
-      // rowStyleRender({row, rowIndex}){},
-      // 表格及数据均加载完成后
-      // gridComplete: function(gridData, columns) {}, // gridData, columns
-      // 刚请求到字段配置，没有请求数据时，可以通过该方法修改表头或添加自定义表头
-      // loadBeforeSend: function(columns, settings) { return true }, // columns, settings(列表所有设置，包括字段设置、分页设置、查询设置、行编辑设置)
-      // 数据加载失败的回调方法
-      // loadError: function(code, error) {}, // code, error
-      // 数据请求成功后，表格记录显示前的回调方法，该方法主要是处理业务数据，比如：处理xss攻击
-      // gridDataLoaded: function(data) { return data },
-      // 查询组件需要的一些参数
-      // search: {
-      //   // 属性自定义组件，当不是行编辑时，查询框需要自定义控件时
-      //   customSearchElements: function(column) { return null },
-      //   labelWidth: '150px',
-      //   fieldNum: 4, // 查询的每行排放的字段个数，默认是4个字段
-      // },
-      // isDargColumn: false, // 是否可以拖动列顺序，true表示可以拖动，false表示不能拖动，默认是false不可以拖动
-      // showColumns: '', // 要显示的属性名集合，多个属性之间以逗号隔开
-      // subRowUrl: '', // 树形数据时，获得子数据集合的请求url路径，例如：http://localhost:90902/cm/ecn-sub-list
-      // loadChildrenComplete: function(parentRow, childrenData, columns) {}, // parentRow, childrenData, columns
-      // isSql:false, // 是否是sql查询数据内容。在使用sql语句查询表内容时，否则会导致列表字段的值不显示，都显示为空
-      // initSearchForm: [], // 初始查询条件，格式同“查询”按钮封装的json格式
-      // multiple: true/false,// 是否多选，默认以列表管理中配置的为准
-      // showIndex: true/false,// 是否显示序号，默认以列表管理中配置的为准
-      // initSortInfo: {prop:'',order: 'ASC/DESC'},// 默认排序字段，和排序方式
-      // pageSizes: '20,30,50,100',// 可选行数
-      // initSearch: true/false, // 初始化时是否查询，默认是查询
-      // parentProp: 'parentId', // 树状结构数据时，父字段名，默认是parentId
-      // operations:{ // 对象名为属性名，值为该列所具有的组件信息
-      //    'operation':[ // 例如操作列，按钮组
-      //       {props:{elementType:'button',label:'删除',size:'mini',type:'danger',icon:'el-icon-delete',style:{marginLeft:'10px'}},isShow:function(originalValue, formatValue, row, column, rowIndex){},onClick:function(originalValue, formatValue, row, this.column, rowIndex){}}
-      //    ],
-      //    'name':[ // 例如：名称列,超链接
-      //        {props:{elementType:'link',type:'primary'},onClick:function(originalValue, formatValue, row, column, rowIndex){},isShow:function(originalValue, formatValue, row, column, rowIndex){}}
-      //     ]
-      // },
-      // 'eventCallBack':{// 行编辑控件事件对应的回调方法，funName1、funName2是自定义的方法名，自己定义即可
-      //   funName1:function({event,value,row,column,prop,originalValue, appendValue,newValue}){},
-      //   funName2:function({event,value,row,column,prop,originalValue, appendValue,newValue}){}
-      // },
-      // isHiddenSearchForm: false, //查询时，是否隐藏查询区域，不配置默认是显示的
-      // align:left/center/right, //记录对齐方式，默认是left
-      // headerAlign: left/center/right, // 表头对齐方式，若不设置该项，则使用表格的对齐方式
-      // showOverflowTooltip: true, // 内容过长是否省略号显示，不换行，默认是true，显示省略号
-      // isDefaultShowEdit: false, // 行编辑时，当表格没有记录时，是否默认创建一行空记录，默认时false，不创建
-      // system: {}, // 当前系统对象，链接跳转页面时使用
-      // additionalParamMap: '{}', // 附加参数json字符串
-      // validateRules: {prop1:{name:'prop1',canEdit:true/false,dataType:'xxx',label:'xxx',rowIndexes:[10,11,13]},prop2:{name:'prop2',canEdit:true/false,dataType:'xxx',label:'xxx',rowIndexes:[10,11,13]}},//流程编辑器的验证规则或用户自己定义的规则
-      // actionPermission: { 'canAdd': true, 'canUpdate': true, 'canDelete': true }, // 列表行编辑时控制按钮的权限
-      // formData: {}, // 主表单的实体信息
-      // hiddenColumns:['operation','xx]
-    }
-  }
-  return Vue.reactive(gridParams)
-}
-
-export function addDynamicProp(target, prop, propValue) {
-  const nestedProp = prop.split('.')
-  if (nestedProp.length === 1) {
-    if (propValue !== undefined) {
-      target[prop] = propValue
-    } else {
-      target[prop] = null
-    }
-    return
-  }
-  // 如果是嵌套属性，就要逐层添加空对象，起点是searchForm，属性每多一层嵌套，parent就前进一层，到倒数第二层为止
-  let parent = target
-  for (let i = 0; i < nestedProp.length - 1; i++) {
-    if (parent[nestedProp[i]] === undefined) {
-      parent[nestedProp[i]] = {}
-    }
-    parent = parent[nestedProp[i]]
-  }
-  if (propValue !== undefined) {
-    parent[nestedProp[nestedProp.length - 1]] = propValue
-  } else {
-    parent[nestedProp[nestedProp.length - 1]] = null
-  }
-}
-
-export function addDynamicPropDateSection(target, prop, propValue) {
-  const nestedProp = prop.split('.')
-  if (nestedProp.length === 1) {
-    if (propValue !== undefined) {
-      target[prop] = propValue
-    } else {
-      target[prop] = [new Date(), new Date()]
-    }
-    return
-  }
-  // 如果是嵌套属性，就要逐层添加空对象，起点是searchForm，属性每多一层嵌套，parent就前进一层，到倒数第二层为止
-  let parent = target
-  for (let i = 0; i < nestedProp.length - 1; i++) {
-    if (parent[nestedProp[i]] === undefined) {
-      parent[nestedProp[i]] = {}
-    }
-    parent = parent[nestedProp[i]]
-  }
-  if (propValue !== undefined) {
-    parent[nestedProp[nestedProp.length - 1]] = propValue
-  } else {
-    parent[nestedProp[nestedProp.length - 1]] = [new Date(), new Date()]
-  }
-}
-
-export function getTableHeight(superGrid, listCode, pageHeight, isInDialog) {
-  let rect
-  if (superGrid) {
-    rect = superGrid.$el.getBoundingClientRect()
-  }
-  let minusPx = isInDialog ? 115 : 85
-  if (isPlateSys(window.$vueApp.config.globalProperties.systemCode)) {
-    minusPx = 130
-  }
-  const totalHeight = window.innerHeight - (rect?.y ?? 0) - minusPx
-  return totalHeight
-
-  // let topDivHeight = 120
-  // const boxCard = document.querySelector('.box-card')
-  // if (boxCard && boxCard !== null) {
-  //   // 表示是配置系统的列表页面
-  //   //  16 .gray .app-container .box-card，
-  //   // 20为内容区域的padding 20
-  //   // 34 + 5为翻页 height 和margin-top
-  //   topDivHeight = 16 * 2 + 20 + 34 + 5
-  // }
-
-  // if (isShowMenuRoute() === true) {
-  //   // 如果显示菜单层级，列表高度需要减少50
-  //   topDivHeight = topDivHeight + 50
-  // }
-
-  // const listGrid = document.querySelector('.el-tabs__content .' + listCode)
-  // if (listGrid) {
-  //   // 表示当前列表在tab页签内容，需要减去tab的高度
-  //   topDivHeight = topDivHeight + 80
-  // }
-  // if (pageHeight === undefined || pageHeight === null || pageHeight === '') {
-  //   pageHeight = window.innerHeight
-  // } else {
-  //   // 表示弹框页面的高度
-  //   topDivHeight = 0
-  // }
-  // let totalHeight = pageHeight - topDivHeight
-  // if (superGrid) {
-  //   totalHeight = pageHeight - superGrid.$el.offsetTop - topDivHeight
-  // }
-  // return totalHeight
-}
-
-export function getExtraParam(searchParam, gridParams) {
-  const param = {
-    searchParam: searchParam
-  }
-  param.withDataPermission = gridParams.options.isWithDataPermission
-  param.isWorkflowEntity = gridParams.options.isWorkflowEntity
-  if (gridParams.options.extraParam) {
-    for (const paramName in gridParams.options.extraParam) {
-      param[paramName] = gridParams.options.extraParam[paramName]
-    }
-  }
-  return param
-}
-
-export function analysisFileSetObj(fileSetObj, isSql) {
-  let showName = ''
-  let serverPath = ''
-  if (fileSetObj) {
-    if (fileSetObj.showNameData) {
-      if (isSql) {
-        if (fileSetObj.showNameData.dbName) {
-          showName = fileSetObj.showNameData.dbName
-        }
-      } else {
-        if (fileSetObj.showNameData.name) {
-          showName = fileSetObj.showNameData.name
-        }
-      }
-    }
-    if (fileSetObj.serverNameData) {
-      if (isSql) {
-        if (fileSetObj.serverNameData.dbName) {
-          serverPath = fileSetObj.serverNameData.dbName
-        }
-      } else {
-        if (fileSetObj.serverNameData.name) {
-          serverPath = fileSetObj.serverNameData.name
-        }
-      }
-    }
-  }
-  return {
-    showName: showName,
-    serverPath: serverPath
-  }
-}
-
-export function otherFilesToStandard(fileSetObj, keyValueParam, files, filesStringData) {
-  const standardFiles = []
-  if (files) {
-    if (files && files.length > 0) {
-      for (var i = 0; i < files.length; i++) {
-        const file = files[i]
-        const standardFile = packageFile(file[keyValueParam.showName], file[keyValueParam.serverPath])
-        standardFiles.push(standardFile)
-      }
-    }
-  } else if (filesStringData) {
-    const showNameStr = filesStringData.showName
-    const serverNameStr = filesStringData.serverPath
-    if (showNameStr && serverNameStr) {
-      const showNameArr = showNameStr.split(',')
-      const serverNameArr = serverNameStr.split(',')
-      for (var k = 0; k < showNameArr.length; k++) {
-        const standardFile = packageFile(showNameArr[k], serverNameArr[k])
-        standardFiles.push(standardFile)
-      }
-    }
-  }
-  return standardFiles
-}
-
-export function packageFile(showName, serverPath) {
-  if (showName) {
-    showName = showName.replace('#', '~~').replace('?', '~$').replace('&', '$')
-  }
-  const standardFile = {}
-  standardFile.showName = showName
-  standardFile.serverPath = serverPath
-
-  if (standardFile.showName && /\.(jpg|JPG|jpeg|JPEG|png|PNG|gif|GIF|bmp|BMP|psd|PSD|tif|TIF)$/.test(showName)) {
-    standardFile.isImg = true
-  }
-  const token = getToken()
-  let url = window.$vueApp.config.globalProperties.baseURL + '/common/super-form/downloads?jwt=' + token
-  if (isPlateSys(window.$vueApp.config.globalProperties.systemCode)) {
-    url = window.$vueApp.config.globalProperties.baseAPI + '/component/super-form/downloads?jwt=' + token
-  }
-  const src = url + '&showName=' + encodeURI(standardFile.showName) + '&serverPath=' + standardFile.serverPath
-  standardFile.src = src
-  return standardFile
-}
-
-export function getFileList(row, column, isSql) {
-  let fileList = []
-  if (
-    column.fileSet &&
-    column.fileSet !== '' &&
-    (column.componentType === 'annex' || column.componentType === 'multipartUpload')
-  ) {
-    const fileSetObj = JSON.parse(column.fileSet)
-    const keyValueParam = analysisFileSetObj(fileSetObj, isSql)
-    if (fileSetObj && fileSetObj.multiple) {
-      if (fileSetObj.childAnnexDataTableCode) {
-        // const lowerStr = fileSetObj.childAnnexDataTableCode.toLowerCase()
-        const fileArr = row[column.prop]
-        // 子表
-        fileList = otherFilesToStandard(fileSetObj, keyValueParam, fileArr, null)
-      } else {
-        const filesStringData = {
-          showName: getEntityFieldValue(row, keyValueParam.showName),
-          serverPath: getEntityFieldValue(row, keyValueParam.serverPath)
-        }
-        fileList = otherFilesToStandard(fileSetObj, keyValueParam, null, filesStringData)
-      }
-    } else {
-      const showName = getEntityFieldValue(row, keyValueParam.showName)
-      const serverPath = getEntityFieldValue(row, keyValueParam.serverPath)
-      fileList.push(packageFile(showName, serverPath))
-    }
-  }
-  return fileList
-}
-
-export function getDynamicDataSourceOptions(column, isSql, additionalParamMap, baseURL) {
-  let additionalParameter
-  if (additionalParamMap) {
-    console.log('getDynamicDataSourceOptions--additionalParamMap=', additionalParamMap)
-    if (additionalParamMap && typeof additionalParamMap === 'object') {
-      additionalParameter = JSON.stringify(additionalParamMap)
-    } else if (additionalParamMap && additionalParamMap !== '') {
-      additionalParameter = additionalParamMap
-    }
-  }
-  const options = {
-    isSql: isSql,
-    additionalParameter: additionalParameter,
-    backendUrl: baseURL
-  }
-  // 如果是多选文件类型，需要解析（需要设置临时字段，判断文件还是图片，图片需要预览）
-  if (column.valueSetOptions) {
-    const valueSetOptionsObj = JSON.parse(column.valueSetOptions)
-    if (valueSetOptionsObj && valueSetOptionsObj.valueSetOptions) {
-      options.valueSetOptions = valueSetOptionsObj.valueSetOptions
-    }
-    if (valueSetOptionsObj.dynamicDataSourceCode && valueSetOptionsObj.dynamicDataSourceCode !== '') {
-      options.dynamicDataSourceCode = valueSetOptionsObj.dynamicDataSourceCode
-    }
-  }
-  options.controlConfig = getControlConfig(column)
-  return options
-}
-
-// 值设置是否是动态数据源类型的数据源
-export function isDynamicDataSourceSource(column) {
-  if (column.valueSetOptions) {
-    const valueSetOptionsObj = JSON.parse(column.valueSetOptions)
-    if (
-      (valueSetOptionsObj.type && valueSetOptionsObj.type === 'dynamicData') ||
-      valueSetOptionsObj.dynamicDataSourceCode
-    ) {
-      // 表示是动态数据源
-      return true
-    }
-  }
-  if (column.valueSet && column.valueSet.length > 0 && column.valueSet[0].value === 'dynamicDataSource') {
-    // 表示是动态数据源
-    return true
-  } else {
-    return false
-  }
-}
-// 获得最后一页的页数
-export function getLastPageNum(total, rowsPerPage) {
-  if (total === undefined || total === null || total === 0) {
-    return 1
-  } else if (rowsPerPage === undefined || rowsPerPage === null || rowsPerPage === 0) {
-    return 1
-  } else {
-    return Math.ceil(total / rowsPerPage)
-  }
-}
-
-// 获得指定记录索引所属的页码
-export function getRowIndexPage(rowsPerPage, addRowIndex) {
-  if (rowsPerPage === undefined || rowsPerPage === null || rowsPerPage === 0) {
-    return 1
-  } else if (addRowIndex === undefined || addRowIndex === null || addRowIndex === 0) {
-    return 1
-  } else {
-    return Math.ceil(addRowIndex / rowsPerPage)
-  }
-}
-// 纵向滚动条滚动最底部功能
-export function scrollYToBottom(listCode) {
-  const scrollDivElement = document.querySelector('.' + listCode + ' .el-table--scrollable-y .el-table__body-wrapper')
-  if (scrollDivElement && scrollDivElement !== null) {
-    // 表示有滚动条，需要将滚动条滚动最底部
-    scrollDivElement.scrollTop = scrollDivElement.scrollHeight
-  }
-}
-
-export function getAdditionalParamMap(gridParams) {
-  let additionalParamMap = null
-  if (gridParams.additionalParamMap && typeof gridParams.additionalParamMap === 'object') {
-    additionalParamMap = gridParams.additionalParamMap
-  } else if (gridParams.additionalParamMap && gridParams.additionalParamMap !== '') {
-    additionalParamMap = JSON.parse(gridParams.additionalParamMap)
-  }
-  return additionalParamMap
-}
-
-// 获得控件的配置信息，例如：自定义控件的附加配置等
-export function getControlConfig(column) {
-  let controlConfig = {}
-  if (column && column.controlConfig) {
-    controlConfig = JSON.parse(column.controlConfig)
-  }
-  return controlConfig
-}
-
-export function getContentAlign(column, gridParams) {
-  let align
-  if (gridParams.options?.align && gridParams.options.align !== '') {
-    align = gridParams.options.align
-  } else if (column.contAlign && column.contAlign !== '') {
-    align = column.contAlign
-  }
-  return align
-}
-
-export function getHeaderAlign(column, gridParams) {
-  let headerAlign
-  if (gridParams.options?.headerAlign && gridParams.options.headerAlign !== '') {
-    headerAlign = gridParams.options.headerAlign
-  } else if (column.titleAlign && column.titleAlign !== '') {
-    headerAlign = column.titleAlign
-  }
-  return headerAlign
-}
-
-export function getHeaderLable(column) {
-  let label = column.label
-  if (!column.titleValueSet) {
-    label = label.replace(/\\n/g, '</br>')
-  } else {
-    label = formatHeader(column)
-  }
-  if (label === null || label === undefined || label === '') {
-    label = column.prop
-  }
-  return label
-}
-
-function formatHeader(column) {
-  return doFormatWithValueSet(column.titleValueSetValue, column.label)
-}
-
-export function parseSubTableActionCondition(gridParams, parentFormData, row, actionCondition) {
-  if (!actionCondition) {
-    return
-  }
-  let canAction = true
-  if (actionCondition.parentCondition) {
-    // 主表条件
-    // ${field[xx]}会被解析为子表字段，所以替换父级字段
-    canAction = parseSubTablePermissionCondition(
-      actionCondition.parentCondition.replaceAll('${field[', '${parent['),
-      gridParams.pageContext?.dataTypeMaps,
-      parentFormData,
-      row,
-      gridParams.additionalParamMap,
-      gridParams.pageContext?.entity?.task,
-      gridParams.pageContext?.contextParam || gridParams.contextParameter
-    )
-  }
-  if (canAction === false) {
-    return false
-  }
-  if (actionCondition.condition) {
-    // 有子表条件时
-    return parseSubTablePermissionCondition(
-      actionCondition.condition,
-      gridParams.$dataTypeMap,
-      parentFormData,
-      row,
-      gridParams.additionalParamMap,
-      gridParams.pageContext?.entity?.task,
-      gridParams.pageContext?.contextParam || gridParams.contextParameter
-    )
-  }
-  return true
-}
-
-export function getClassOptionTitleCommon(val, options) {
-  if (val !== null && val !== undefined && val !== '' && val.length > 0) {
-    let selectTittle = ''
-    if (typeof val === 'string') {
-      // 单选
-      options?.forEach((item) => {
-        if (item.value === val) {
-          selectTittle = item.label
-        }
-      })
-    } else {
-      // 多选
-      options?.forEach((item) => {
-        val.forEach((Vtem) => {
-          if (item.value === Vtem) {
-            selectTittle = selectTittle + item.label + ','
-          }
-        })
-      })
-      selectTittle = selectTittle.slice(0, selectTittle.length - 1)
-    }
-    return selectTittle
-  }
-}