yinghe-lowcode-zln/src/utils/util.js

基于vue、ant-design-vue,datagrid的低代码平台

import Vue from 'vue'
import store from '@/store'
import {
  ORG_ID,
  OPERATOR,
  PERSON_ID,
  DATA_FLAG
} from '@/store/mutation-types'

/**
 * 首页显示时间段
 */
export function timeFix() {
  const time = new Date()
  const hour = time.getHours()
  return hour < 9 ? '早上好' : hour <= 11 ? '上午好' : hour <= 13 ? '中午好' : hour < 20 ? '下午好' : '晚上好'
}

/**
 * 首页显示欢迎语句
 */
export function welcome() {
  const arr = ['天生我材必有用', '准备吃什么呢?', '要不要喝一瓶肥佬水', '我猜你可能累了']
  const index = Math.floor(Math.random() * arr.length)
  return arr[index]
}

/**
 * 判断宿主是否为IE环境
 */
export function isIE() {
  const bw = window.navigator.userAgent
  const compare = s => bw.indexOf(s) >= 0
  const ie11 = (() => 'ActiveXObject' in window)()
  return compare('MSIE') || ie11
}

/**
 * 定时移除页面中加载动画
 */
export function removeLoadingAnimate(id = '', timeout = 1500) {
  if (id) {
    setTimeout(() => {
      document.body.removeChild(document.getElementById(id))
    }, timeout)
  }
}

/**
 * 触发window窗口大小更改
 */
export function triggerWindowResizeEvent() {
  const event = document.createEvent('HTMLEvents')
  event.initEvent('resize', true, true)
  event.eventType = 'message'
  window.dispatchEvent(event)
}

/**
 * 触发滚动事件、执行回调函数(参数-滚动方向)
 */
export function handleScrollHeader(callback) {
  let timer = 0
  let beforeScrollTop = window.pageYOffset
  window.addEventListener(
    'scroll',
    () => {
      clearTimeout(timer)
      timer = setTimeout(() => {
        let direction = 'up'
        const afterScrollTop = window.pageYOffset
        const delta = afterScrollTop - beforeScrollTop
        if (delta === 0) {
          return false
        }
        direction = delta > 0 ? 'down' : 'up'
        callback && callback(direction)
        beforeScrollTop = afterScrollTop
      }, 50)
    },
    false
  )
}

/**
 * 封装接口传参统一格式
 * zhouji 2020-3-20
 */
export const requestBuilder = (action = '', param = {}, pageNo = 0, pageSize = 10, sortField = '', sortOrder = '') => {
  const toSortField = (field, order) => {
    const sortField = field && field.replace(/(^|\B)([A-Z])/g, '_$2').toLowerCase()
    const sortOrder = order && order.replace(/end$/i, '')
    return (sortOrder && sortField) || undefined
  }
  const toSortOrder = (field, order) => {
    const sortField = field && field.replace(/(^|\B)([A-Z])/g, '_$2').toLowerCase()
    const sortOrder = order && order.replace(/end$/i, '')
    return (sortField && sortOrder) || undefined
  }
  return {
    param: param,
    action: action,
    orgId: Vue.ls.get(ORG_ID),
    operator: Vue.ls.get(OPERATOR),
    personId: Vue.ls.get(PERSON_ID),
    dataFlag: Vue.ls.get(DATA_FLAG),
    sortField: toSortField(sortField, sortOrder),
    sortOrder: toSortOrder(sortField, sortOrder),
    pageSize: pageSize,
    pageNo: pageNo
  }
}

/**
 * 根据 actions 判断当前账号权限
 * lin pengteng 2020-3-31
 */
export const getPermission = (context, actions, every = false) => {
  const roles = store.getters.roles
  const permission = context.$route.meta.permission
  const permissionIds = (permission instanceof String && [permission]) || permission
  for (const permission of roles.permissions) {
    if (!permissionIds.includes(permission.permissionId)) {
      continue
    }
    for (const action of actions) {
      if (!permission.actionList) {
        // 强校验
        return false
      }
      if (every === false && permission.actionList.includes(action)) {
        return true
      }
      if (every !== false && !permission.actionList.includes(action)) {
        return false
      }
    }
    return every !== false
  }
  // 强校验
  return false
}

/**
 * 递归更新 Object/Array 属性值
 * lin pengteng 2020-3-26
 */
export const deepUpdate = (...array) => {
  function isArray(arr) {
    return itType(arr) === 'Array'
  }

  function isObject(obj) {
    return itType(obj) === 'Object'
  }

  function isOwnProperty(context, property) {
    return Object.prototype.hasOwnProperty.call(context, property)
  }

  function itType(val) {
    return Object.prototype.toString.call(val).replace(/^\[[^\s\]]+\s*([^\s\]]+)]$/, '$1')
  }

  function isAllArray(oldArr, newArr) {
    return isArray(oldArr) && isArray(newArr)
  }

  function isAllObject(oldObj, newObj) {
    return isObject(oldObj) && isObject(newObj)
  }
  if (array.length > 1) {
    const oldData = array[0]
    const newArrs = array.slice(1)
    for (const newData of newArrs) {
      if (isAllArray(oldData, newData) || isAllObject(oldData, newData)) {
        for (const key in oldData) {
          if (isOwnProperty(oldData, key) && isOwnProperty(newData, key)) {
            if ((isArray(oldData[key]) && isArray(newData[key])) || (isObject(oldData[key]) && isObject(newData[key]))) {
              deepUpdate(oldData[key], newData[key])
              continue
            }
            oldData[key] = newData[key]
          }
        }
      }
    }
  }
  return array[0]
}

/**
 * 根据 key 取出 tree 中节点数据
 * lin pengteng 2020-3-27
 */
export const takeTreeByKey = (tree, key, value = 'value', children = 'children') => {
  function isArray(arr) {
    return itType(arr) === 'Array'
  }

  function isString(obj) {
    return itType(obj) === 'String'
  }

  function itType(val) {
    return Object.prototype.toString.call(val).replace(/^\[[^\s\]]+\s*([^\s\]]+)]$/, '$1')
  }

  function isOwnProperty(context, property) {
    return Object.prototype.hasOwnProperty.call(context, property)
  }
  if (isArray(key)) {
    const result = []
    for (const k of key) {
      result.push(takeTreeByKey(tree, k, value, children))
    }
    return result
  }
  if (isArray(tree) && isString(key)) {
    for (let i = 0, l = tree.length; i < l; i++) {
      if (isOwnProperty(tree[i], value) && key === tree[i][value]) {
        return tree[i]
      }
      if (isArray(tree[i][children]) && tree[i][children].length > 0) {
        const result = takeTreeByKey(tree[i][children], key, value, children)
        if (result !== null) {
          return result
        }
      }
    }
    return null
  }
}

// 将当前时间转化为yyyy--mm--dd
export function getNowDate() {
  let date = new Date()
  const f1 = '/'
  const year = date.getFullYear()
  let month = date.getMonth() + 1
  const day = date.getDate()
  if (month >= 1 && month <= 9) {
    month = '0' + month
  }
  if (date >= 0 && date <= 9) {
    date = '0' + date
  }
  var currentdate = year + f1 + month + f1 + day
  return currentdate
}

// 添加日期范围
export function addDateRange(params, dateRange, propName) {
  const search = { ...params }
  if (dateRange !== null && dateRange !== '' && dateRange.length === 2) {
    search.params = {}
    if (typeof (propName) === 'undefined') {
      search['beginTime'] = dateRange[0]
      search['endTime'] = dateRange[1]
    } else {
      search[propName + 'BeginTime'] = dateRange[0]
      search[propName + 'EndTime'] = dateRange[1]
    }
  }
  return search
}

// 日期格式化
export function parseTime(time, pattern) {
  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), '/')
    }
    if ((typeof time === 'number') && (time.toString().length === 10)) {
      time = time * 1000
    }
    date = new Date(time)
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay()
  }
  const timeStr = format.replace(/{(y|m|d|h|i|s|a)+}/g, (result, key) => {
    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
  })
  return timeStr
}

// 回显数据字典
export function selectDictLabel(datas, value) {
  var actions = []
  Object.keys(datas).some(key => {
    if (datas[key].dictValue === ('' + value)) {
      actions.push(datas[key].dictLabel)
      return true
    }
  })
  return actions.join('')
}

// 回显数据字典（字符串数组）
export function selectDictLabels(datas, value, separator) {
  var actions = []
  var currentSeparator = undefined === separator ? ',' : separator
  var temp = value.split(currentSeparator)
  Object.keys(value.split(currentSeparator)).some(val => {
    Object.keys(datas).some(key => {
      if (datas[key].dictValue === ('' + temp[val])) {
        actions.push(datas[key].dictLabel + currentSeparator)
      }
    })
  })
  return actions.join('').substring(0, actions.join('').length - 1)
}

/**
 * 构造树型结构数据
 * @param {*} data 数据源
 * @param {*} id id字段 默认 'id'
 * @param {*} parentId 父节点字段 默认 'parentId'
 * @param {*} children 孩子节点字段 默认 'children'
 * @param {*} rootId 根Id 默认 0
 */
export function handleTree(data, id, parentId, children, rootId) {
  id = id || 'id'
  parentId = parentId || 'parentId'
  children = children || 'children'
  rootId = rootId || Math.min.apply(Math, data.map(item => {
    return item[parentId]
  })) || 0
  // 对源数据深度克隆
  const cloneData = JSON.parse(JSON.stringify(data))
  // 循环所有项
  const treeData = cloneData.filter(father => {
    var branchArr = cloneData.filter(child => {
      // 返回每一项的子级数组
      return father[id] === child[parentId]
    })
    if (branchArr.length > 0) {
      father.children = branchArr
    } else {
      father.children = ''
    }
    // 返回第一层
    return father[parentId] === rootId
  })
  return treeData !== '' ? treeData : data
}

/**
 * 递归删除children空数组
 * @param {*} list 
 * @returns 
 */
export function removeEmptyChildren(list) {
  const result = list.map((item) => {
    return {
      ...item,
      children: item.children && item.children.length > 0 ? removeEmptyChildren(item.children) : undefined
    }
  })

  return result
}

/**
 * 获取uuid
 */
export function getUUID() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
    return (c === 'x' ? (Math.random() * 16 | 0) : ('r&0x3' | '0x8')).toString(16)
  })
}

/**
 * 根据类名获取页面组件名称
 * @param className
 * @returns {*}
 */
export function getPageIdByClassName(className) {
  const arr = className.split('.')
  const pageId = arr[arr.length - 1]
  return toLowerLine(pageId).toUpperCase()
}

/**
 * 过滤对象中为空的属性
 * @param obj
 * @returns {*}
 */
export function filterObj(obj) {
  if (!(typeof obj === 'object')) {
    return
  }

  for (const key in obj) {
    if (obj.hasOwnProperty(key) &&
      (obj[key] === null || obj[key] === undefined || obj[key] === '')) {
      delete obj[key]
    }
  }
  return obj
}
/**
 * 如果值不存在就 push 进数组，反之不处理
 * @param array 要操作的数据
 * @param value 要添加的值
 * @param key 可空，如果比较的是对象，可能存在地址不一样但值实际上是一样的情况，可以传此字段判断对象中唯一的字段，例如 id。不传则直接比较实际值
 * @returns {boolean} 成功 push 返回 true，不处理返回 false
 */
export function pushIfNotExist(array, value, key) {
  for (const item of array) {
    if (key && (item[key] === value[key])) {
      return false
    } else if (item === value) {
      return false
    }
  }
  array.push(value)
  return true
}

/**
 * 深度克隆对象、数组
 * @param obj 被克隆的对象
 * @return 克隆后的对象
 */
export function cloneObject(obj) {
  return JSON.parse(JSON.stringify(obj))
}

/**
 * 随机生成字符串
 * @param length 字符串的长度
 * @param chats 可选字符串区间（只会生成传入的字符串中的字符）
 * @return string 生成的字符串
 */
export function randomString(length, chats) {
  if (!length) length = 1
  if (!chats) chats = '0123456789qwertyuioplkjhgfdsazxcvbnm'
  let str = ''
  for (let i = 0; i < length; i++) {
    const num = randomNumber(0, chats.length - 1)
    str += chats[num]
  }
  return str
}

export function parseCondition(condition) {
  switch (condition) {
    case '=':
      return 'andEq'
    case '<':
      return 'andLess'
    case '<=':
      return 'andLessEq'
    case '>=':
      return 'andGreatEq'
    case '>':
      return 'andGreat'
    case 'contains':
      return 'andLike'
    case 'notcontains':
      return 'andNotLike'
    case 'startswith':
      return 'andLeftLike'
    case 'endswith':
      return 'andRightLike'
    case '<>':
      return 'andNotEq'
    case 'and':
      return 'andBetween'
    default:
      return 'andLike'
  }
}

/**
 * 随机生成数字
 *
 * 示例：生成长度为 12 的随机数：randomNumber(12)
 * 示例：生成 3~23 之间的随机数：randomNumber(3, 23)
 *
 * @param1 最小值 | 长度
 * @param2 最大值
 * @return var 生成后的数字
 */
export function randomNumber() {
  // 生成 最小值 到 最大值 区间的随机数
  const random = (min, max) => {
    return Math.floor(Math.random() * (max - min + 1) + min)
  }
  if (arguments.length === 1) {
    const [length] = arguments
    // 生成指定长度的随机数字，首位一定不是 0
    const nums = [...Array(length).keys()].map(i => (i > 0 ? random(0, 9) : random(1, 9)))
    return parseInt(nums.join(''))
  } else if (arguments.length >= 2) {
    const [min, max] = arguments
    return random(min, max)
  } else {
    return Number.NaN
  }
}
/**
 * 随机生成uuid
 * @return string 生成的uuid
 */
export function randomUUID() {
  const chats = '0123456789abcdef'
  return randomString(32, chats)
}

/**
 * 下划线转驼峰
 * @param string
 * @returns {*}
 */
export function underLine2CamelCase(string) {
  return string.replace(/_([a-z])/g, function (all, letter) {
    return letter.toUpperCase()
  })
}
export function toUpperCaseLine(str) {
  var temp = str.replace(/[A-Z]/g, function (match) {
    return '_' + match.toLowerCase()
  })
  if (temp.slice(0, 1) === '_') { // 如果首字母是大写，执行replace时会多一个_，这里需要去掉
    temp = temp.slice(1)
  }
  return temp.toUpperCase()
}
// 驼峰转换下划线
export function toLowerLine(str) {
  var temp = str.replace(/[A-Z]/g, function (match) {
    return '_' + match.toLowerCase()
  })
  if (temp.slice(0, 1) === '_') { // 如果首字母是大写，执行replace时会多一个_，这里需要去掉
    temp = temp.slice(1)
  }
  return temp
}

export function toClassName(string) {
  var temp = string.replace(/_([a-z])/g, function (all, letter) {
    return letter.toUpperCase()
  })
  return temp.slice(0, 1).toUpperCase() + temp.slice(1)
}

function getWindowClientHeight() {
  let winHeight = 0
  if (window.innerHeight) {
    winHeight = window.innerHeight
  } else if ((document.body) && (document.body.clientHeight)) {
    winHeight = document.body.clientHeight
  }
  return winHeight
}

function getWindowClientWidth() {
  let winWidth = 0
  if (window.innerHeight) {
    winWidth = window.innerWidth
  } else if ((document.body) && (document.body.clientWidth)) {
    winWidth = document.body.clientWidth
  }
  return winWidth
}

export function getClientHeight() {
  return getWindowClientHeight()
}

/**
 * 表格高度
 */
export function getTableHeight() {
  return getWindowClientHeight() - 155
}

export function getClientWidth() {
  return getWindowClientWidth()
}

/**
 * 组装中间层参数
 * @param value 参数数组
 * @returns {*}
 */
export function packageRpcParam(value, orderBys = [], columns = [], limit) {
  if (!limit) {
    limit = 1000
  }
  const rpcParams = []
  const queryParamWrapList = []
  const subWheres = []
  for (const item in value) {
    if (value[item] && item) {
      if (item.indexOf('_') >= 0) {
        let column = toLowerLine(item.split('_')[0])
        let condition = item.split('_')[1]
        const queryParamWrap = {}
        if (condition.substr(0, 3) === 'sub') {
          subWheres.push({
            column: column,
            condition: condition.substr(3),
            v1: value[item]
          })
          continue
        }
        // 子表查询 #变.
        if (item.indexOf('#') >= 0) {
          column = toLowerLine(item.split('_')[0].replace('#', '.'))
          condition = item.split('_')[1]
        } else {
          column = toLowerLine(item.split('_')[0])
          condition = item.split('_')[1]
        }
        if (condition === 'andIsNull' || condition === 'andIsNotNull') {
          queryParamWrap.condition = condition
          queryParamWrap.column = column
        } else {
          queryParamWrap.condition = condition
          queryParamWrap.column = column
          // 下拉多选不行了，将单条数据组成数组
          queryParamWrap.v1 = condition === 'andIn' ? (value[item] instanceof Array ? value[item] : value[item].split(';')) : value[item]
        }
        if (Array.isArray(queryParamWrap.v1)) {
          if (queryParamWrap.v1.length > 0) {
            if (queryParamWrap.condition === 'andBetween') {
              queryParamWrap.v1 = value[item][0]
              queryParamWrap.v2 = value[item][1]
            }
            queryParamWrapList.push(queryParamWrap)
          }
        } else {
          queryParamWrapList.push(queryParamWrap)
        }
      } else {
        const queryParamWrap = {}
        queryParamWrap.column = toLowerLine(item)
        // 未指定下默认是like查询
        queryParamWrap.condition = 'andLike'
        queryParamWrap.v1 = value[item]
        if (Array.isArray(queryParamWrap.v1)) {
          if (queryParamWrap.v1.length > 0) {
            queryParamWrapList.push(queryParamWrap)
          }
        } else {
          queryParamWrapList.push(queryParamWrap)
        }
      }
    }
  }
  var andSubWhere = {
    'condition': 'and',
    'andSubWheres': subWheres
  }
  queryParamWrapList.push(andSubWhere)
  rpcParams.push(queryParamWrapList)
  // add orderBys
  rpcParams.push(orderBys)
  // add columns 为了优化sql性能，查询部分字段
  rpcParams.push(columns)
  // add pageInfo
  rpcParams.push({
    pageNumber: 1,
    pageSize: limit
  })
  return rpcParams
}

/**
 * 箱号校验
 * @param str 参数数组
 * @returns {*}
 */
export function checkCntNo(str) {
  var arg1 = /[A-Z]{4}[0-9]{7}/
  if (str.match(arg1) === null) {
    return false
  }
  if (str.length !== 11) {
    return false
  }
  var tot = 0
  var arrayOfConter = [10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 34, 35, 36, 37, 38]
  for (var i = 1; i < 11; i++) {
    var dxsz
    var vcon = str.substring(i - 1, i)
    if (isNaN(vcon)) {
      dxsz = arrayOfConter[vcon.charCodeAt() - 'A'.charCodeAt()]
    } else {
      dxsz = vcon
    }
    var j = 1
    var k = 1
    while (j < i) {
      k = k * 2
      j = j + 1
    }
    tot = tot + dxsz * k
  }
  var rester = tot % 11
  var hdsz = '012345678910'
  var res
  if (rester === 10) {
    res = '0'
  } else {
    res = hdsz.substring(rester, rester + 1)
  }
  if (res === str.substring(10, 11)) {
    return true
  } else {
    return false
  }
}
// 批量处理对象属性空格
export function batchTrim(obj) {
  Object.keys(obj).forEach(key => {
    // 去空格
    if (typeof obj[key] === 'string') {
      let str = obj[key]
      // str = str.replace(/\s+/g, '') // 去除 空格
      str = str.replace(/[\r\n]/g, '') // 去除 换行符
      str = str.trim() // 去除 前后空格
      // str = str.toUpperCase() // 转成大写
      obj[key] = str
    }
  })
  return obj
}

export function deepCopy(obj, weakmap = new WeakMap()) {
  if (weakmap.has(obj)) {
    return weakmap.get(obj)
  }
  if (obj === null) {
    return null
  }
  if (obj instanceof RegExp) {
    return new RegExp(obj)
  }
  if (obj instanceof Date) {
    return new Date(obj)
  }
  // 基本数据类型或者函数，直接返回
  // 这样处理函数就不是深拷贝了
  const type = typeof obj
  if (type !== 'object') {
    return obj
  }
  /**
   * 如果obj是数组，那么 obj.constructor 是 [Function: Array]
   * 如果obj是对象，那么 obj.constructor 是 [Function: Object]
   */
  const res = new obj.constructor()
  // 当对象的一个属性引用自身时，要避免相互引用造成死循环，如obj1.a=obj1
  // 可使用 WeakMap 来存储这个引用自身的属性
  weakmap.set(obj, res)

  // 拷贝对象上的可遍历属性
  for (const key in obj) {
    res[key] = deepCopy(obj[key], weakmap)
  }
  return res
}
/**
 *
 * @param {数组} array
 * @param {删除元素} value
 */
export function arrayRemove(array, value) {
  const index = array.indexOf(value)
  if (index !== -1) {
    array.splice(index, 1)
  }
}
/**
 * 数组去重（对象数组）
 * @param {数组} arr
 */
export function unique(arr) {
  var arr1 = []
  var arr2 = []
  for (let index = 0; index < arr.length; index++) {
    const element = arr[index]
    if (!arr2.includes(element.value)) {
      arr2.push(element.value)
      arr1.push(element)
    }
  }
  return arr1
}
/**
 * 数组去重（字符串数组）
 * @param {数组} arr
 */
export function unique2(arr) {
  var arr1 = []
  for (let index = 0; index < arr.length; index++) {
    const element = arr[index]
    if (arr1.indexOf(element) < 0) {
      arr1.push(element)
    }
  }
  return arr1
}
export function getJsonTree(data) {
  var itemArr = []
  const map = new Map()
  for (var i = 0; i < data.length; i++) {
    var node = data[i]
    var newNode = {}
    if (node.parentModel) {
      newNode.value = node.model
      newNode.label = node.label ? node.label : node.model
      if (map.has(node.parentModel)) {
        map.get(node.parentModel).children.push(newNode)
      } else {
        newNode.children = [newNode]
        map.set(node.parentModel, newNode)
      }
    } else {
      newNode.value = node.model
      newNode.label = node.label
      newNode.children = []
      itemArr.push(newNode)
    }
  }
  for (const key of map.keys()) {
    newNode.value = key
    newNode.label = key
    newNode.children = map.get(key)
    itemArr.push(newNode)
  }
  console.log(itemArr)
  return itemArr
};
export function getJsonTree2(data, itemArr = []) {
  data.forEach(item => {
    if (!item.list || item.type === 'batch') {
      console.log('model值: ' + item.model, 'parentModel: ' + item.parentModel)
      var newNode = {}
      if (item.parentModel) {
        newNode.value = item.parentModel
        newNode.label = item.parentModel
      } else {
        newNode.value = item.model
        newNode.label = item.label
      }
      itemArr.push(newNode)
    } else {
      getJsonTree2(item.list, itemArr)
    }
  })
};
// 数字转字符前补0
export function pad(num, n) {
  num = String(num)
  var len = String(num).length
  while (len < n) {
    num = '0' + num
    len++
  }
  return num
}
// 将2个数字转为字符串20170101,0800 -> 20170101080000
export function dateToStr(date, time) {
  var timeStr = pad(time, 4) + '00'
  return String(date) + timeStr
}

// 将2个数字转为字符串 20170101,0800 -> date
export function convertNumToDate(date, time) {
  var pattern = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/
  var str = dateToStr(date, time)
  return str.replace(pattern, '$1/$2/$3 $4:$5:$6')
}

// 求时间差(分钟)
export function vesselMin(bgDate, bgTime, edDate, edTime) {
  var pattern = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/
  var bgStr = dateToStr(bgDate, bgTime)
  var bd = bgStr.replace(pattern, '$1/$2/$3 $4:$5:$6')
  bd = new Date(bd)
  var edStr = dateToStr(edDate, edTime)
  var ed = edStr.replace(pattern, '$1/$2/$3 $4:$5:$6')
  ed = new Date(ed)
  return (ed - bd) / 1000 / 60
}

// 将数字表示日期时间转为字符串 1月1日 12:12
export function convertDHM(date, time) {
  var pattern = /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/
  var str = dateToStr(date, time)
  return str.replace(pattern, '$2/$3 $4:$5')
}
// 日期加减
export function addDate(date, days) {
  var d = new Date(date)
  d.setDate(d.getDate() + days)
  var m = d.getMonth() + 1
  return d.getFullYear() + '-' + m + '-' + d.getDate()
}

// 小时加减
export function addHour(date, hours) {
  var d = new Date(date)
  d.setHours(d.getHours() + hours)
  var m = d.getMonth() + 1
  return m + '/' + d.getDate() + ' ' + d.getHours() + ':' + d.getMinutes()
}
// "2017-01-01"->"20170101"
export function getCompackDateStr(str) {
  var pattern = /(\d{4})-(\d{2})-(\d{2})/
  return str.replace(pattern, '$1$2$3')
}

export function groupBy(list, fn) {
  const groups = new Map()
  list.forEach(function (o) {
    const group = JSON.stringify(fn(o))
    // groups[group] = groups[group] || [];
    // groups[group].push(o);
    groups.set(group, groups.get(group) || [])
    groups.get(group).push(o)
  })
  return groups
}

export function compareUp(prop) {
  return function (obj1, obj2) {
    var val1 = obj1[prop]
    var val2 = obj2[prop]
    if (val1 < val2) {
      return -1
    } else if (val1 > val2) {
      return 1
    } else {
      return 0
    }
  }
}
export function pad2(str) {
  str = str.trim()
  if (str.length === 1) {
    str = '0' + str
  } else if (str.length === 0) {
    str = '00'
  }
  return str
}

export function dateTovar(date) {
  const Y = date.getFullYear() + ''
  const M =
    (date.getMonth() + 1 < 10 ?
      '0' + (date.getMonth() + 1) :
      date.getMonth() + 1) + ''
  const D = pad2(date.getDate() + '')
  return parseInt(Y + M + D)
}

export function conditionSetting(condition, columnValue, value) {
  switch (condition) {
    case '等于':
      return columnValue === value
    case '不等于':
      return columnValue !== value
    case '小于':
      return columnValue < value
    case '大于':
      return columnValue > value
    case '大于等于':
      return columnValue >= value
    case '小于等于':
      return columnValue <= value
    case '包含':
      columnValue = columnValue || []
      return columnValue.includes(value)
    case '不包含':
      columnValue = columnValue || []
      return !columnValue.includes(value)
    case '为空':
      return columnValue === ''
    case '不为空':
      return columnValue !== ''
      // case '属于':
      // break;
      // case '不属于':
      // break;
      // case '拥有':
      // break;
      // case '不拥有':
      // break;
      // case '位于':
      // break;
      // case '不位于':
      // break;
    default:
      return false
  }
}

export function conditionMapping(conditions, contype) {
  var initFlag, mapping
  if (contype === 'all') {
    initFlag = true
  } else {
    initFlag = false
  }
  for (var condition of conditions) {
    mapping = conditionSetting(condition.condition, condition.columnValue, condition.v1)
    if (contype === 'all') {
      initFlag = initFlag && mapping
    } else {
      initFlag = initFlag || mapping
    }
  }
  return initFlag
}

// 分割箱号
export function splitCtnNo(values) {
  var ctnNoList = []
  if (values.indexOf(',') >= 0) {
    ctnNoList = values.split(',')
  } else if (values.indexOf('\n') >= 0) {
    ctnNoList = values.split('\n')
  } else if (values.indexOf(';') >= 0) {
    ctnNoList = values.split(';')
  } else if (values.indexOf('；') >= 0) {
    ctnNoList = values.split('；')
  } else if (values.indexOf('，') >= 0) {
    ctnNoList = values.split('，')
  } else if (values.indexOf(' ') >= 0) {
    ctnNoList = values.split(' ')
  } else if (values) {
    ctnNoList.push(values)
  }
  var ctnNoLists = []
  for (const ctnNo of ctnNoList) {
    if (ctnNo.trim() !== '') {
      ctnNoLists.push(ctnNo.trim())
    }
  }
  return ctnNoLists
}
var jsCommentReg = /("([^\\\"]*(\\.)?)*")|('([^\\\']*(\\.)?)*')|(\/{2,}.*?(\r|\n|$))|(\/\*(\n|.)*?\*\/)/g
/**
 * 去除js注释
 * @param {} script 
 * @returns {} 
 */
export function removeJsComments(script) {
  if (!script)
    return script
  return script.replace(jsCommentReg,
    function (word) {
      // 去除注释后的文本 
      return /^\/{2,}/.test(word) || /^\/\*/.test(word) ? '' : word
    })
}
/**
 * @Date: 2020-06-18 15:10:49
 * @method: 自定义事件的str转function
 * @param data{Object} 组件配置对象
 * @param event{string} 事件类型
 * @param context{Object} this 上下文
 * @return:
 * @Author: 九哥
 */
export function useCodeEvent(data = {}, event = '', context) {
  // 匹配事件名
  if (data.handleInfo) {
    const item = data.handleInfo.find(item => item.eventName === event)
    let str = item ? item.code : ''
    if (str) {
      /* eslint-disable */
      let mainFunction
      if (str.indexOf('function ()') >= 0) {
        str = str.replaceAll('function ()', 'tempFunc ()')
      }
      //去除注释
      str = removeJsComments(str);
      const funArr = str.split('function')
      for (var i = 1; i < funArr.length; i++) {
        let functionScript = funArr[i]
        if (functionScript.indexOf('tempFunc ()') >= 0) {
          functionScript = functionScript.replaceAll('tempFunc ()', 'function ()')
        }
        const functionName = functionScript.match(/(\S*)\(/)[1]
        //获取参数
        const params = functionScript.match(/\((.+?)\)/)[1].replace(/\s+/g, '').split(',')
        // 获取方法内容
        const functionBody = functionScript.replace(new RegExp(`^([\\s\\S]*)(${params[params.length - 1]})\\)[\\n|\\s]*\\{`), '').replace(/\}[.|\n|\s]*$/, '')
        // 创建function 返回
        if (i == 1) {
          mainFunction = new Function(...params, functionBody).bind(context)
        } else {
          context[functionName] = new Function(...params, functionBody).bind(context)
        }
      }
      return mainFunction
    }
  }

  return () => {}
}

export function isTimestamp(time) {
  var timestamp = /^\d{10}$|^\d{13}$/
  return timestamp.test(time.toString())
} // end FUNCTION isTimestamp()


/**
 * @Date: 2020-06-18 15:10:49
 * @method: 自定义事件的str转function
 * @param script{string} 脚本
 * @param context{Object} this 上下文
 * @return:
 * @Author: 九哥
 */
export function customCodeEvent(script, context) {
  // 匹配事件名
  if (script) {
    /* eslint-disable */
    // 获取参数
    const params = script.match(/\((.+?)\)/)[1].replace(/\s+/g, '').split(',')
    // 获取方法内容
    const functionBody = script.replace(new RegExp(`^([\\s\\S]*)(${params[params.length - 1]})\\)[\\n|\\s]*\\{`), '').replace(/\}[.|\n|\s]*$/, '')
    // 创建function 返回
    return new Function(...params, functionBody).bind(context)
  }
  return () => {}
}