wisdomcity-office/src/libs/util.js

/*
 * @Author: WangQiBiao
 * @LastEditors: LiZhiWei
 * @Description:
 * @Date: 2019-04-16 11:44:25
 * @LastEditTime: 2025-04-15 15:44:32
 */
import html2canvas from 'html2canvas'
import { saveAs } from 'file-saver'
import Cookies from 'js-cookie'
// cookie保存的天数
import config from '@/config'
import { hasOneOf, objEqual } from './tools'

// import beforeClose from '@/router/before-close'

export * from './file'

export const TOKEN_KEY = 'token'

// 缓存表格列宽
export const setTableHeaderDragend = (name, newWidth, column) => {
  const tableHeaderData = JSON.parse(window.localStorage.getItem(name)) || []
  if (tableHeaderData.length) {
    if (tableHeaderData.some(h => h.property === column.property)) {
      tableHeaderData[tableHeaderData.findIndex(i => i.property === column.property)].width = newWidth
    } else {
      tableHeaderData.push({ property: column.property, width: newWidth })
    }
  } else {
    tableHeaderData.push({ property: column.property, width: newWidth })
  }
  window.localStorage.setItem(name, JSON.stringify(tableHeaderData))
}
// 获取表格列宽
export const getTableHeaderDragend = (name) => {
  return JSON.parse(window.localStorage.getItem(name)) || []
}

export const getTableColumnWidth = (name, property) => {
  const tableHeaderData = JSON.parse(window.localStorage.getItem(name)) || []
  if (tableHeaderData.some(h => h.property === property)) {
    return tableHeaderData[tableHeaderData.findIndex(i => i.property === property)].width
  } else {
    return 150
  }
}

export const setToken = token => {
  Cookies.set(TOKEN_KEY, token, { expires: config.cookieExpires || 1 })
}

export const removeToken = () => {
  Cookies.remove(TOKEN_KEY)
}

export const getToken = () => {
  const token = Cookies.get(TOKEN_KEY)
  if (token) return token
  else return false
}

export const getCookie = (key) => {
  return Cookies.get(key)
}

export const removeCookie = (key, options = {}) => {
  Cookies.remove(key, options)
}

export const removeAllCookie = () => {
  Object.keys(Cookies.get()).forEach(key => Cookies.remove(key))
}

export const hasChild = item => {
  return item.children && item.children.length !== 0
}

const showThisMenuEle = (item, access) => {
  if (item.meta && item.meta.access && item.meta.access.length) {
    if (hasOneOf(item.meta.access, access)) return true
    else return false
  } else return true
}

/**
 * 根据接口返回的路由配置权限路由
 * @param {Array} asyncRouter 本地路由
 * @param {Array} menus 接口返回的经过格式化的路由
 * @returns newMenu 新的权限路由
 */
export const asyncRouterMap = (asyncRouter = [], menus = []) => {
  const newMenu = []
  asyncRouter.forEach(route => {
    if (route.name && (route && route.meta && (route.meta.hideInMenu || route.meta.authorized))) {
      // 对于一级路由设置隐藏且没有对应菜单的路由
      newMenu.push(route)
    } else {
      menus.forEach(menu => {
        if (route.name === menu.name && menu.meta.type !== 'button') {
          if (route.children && (menu.children && menu.children.length > 0)) {
            // 经过和菜单比较后得到的菜单路由
            const compareChild = route.children.filter(item => {
              const mChild = menu.children.find(mChild => mChild.name === item.name)
              if (mChild) {
                return item
              } else if (item && item.meta && (item.meta.hideInMenu || item.meta.authorized)) {
                return item
              }
            })
            let newRoute = {}
            const { children, ...reset } = route
            newRoute = reset
            newRoute.children = compareChild
            newMenu.push(newRoute)
          } else {
            // 只有一级路由，没有二级路由
            const { redirect } = route
            newMenu.push({ ...menu, redirect })
          }
        }
      })
    }
  })
  return newMenu
}

/**
 * @param {Array} list 通过路由列表得到菜单列表
 * @returns {Array}
 */
export const getMenuByRouter = (list = [], access) => {
  let res = []
  const getMenus = (l, a) => {
    l.forEach(item => {
      if (!item.meta || (item.meta && !item.meta.hideInMenu)) {
        let obj = {
          icon: (item.meta && item.meta.icon) || '',
          name: item.path.replace(/\//, '') || '_', // 过滤 '/'
          meta: item.meta,
          path: item.path
        }
        if ((hasChild(item) || (item.meta && item.meta.showAlways)) && showThisMenuEle(item, a)) {
          obj.children = getMenuByRouter(item.children, a)
        }
        if (item.meta && item.meta.href) obj.href = item.meta.href
        if (showThisMenuEle(item, a)) res.push(obj)
      }
    })
  }
  getMenus(list, access)
  return res
}
/**
 * 根据权限匹配路由
 * @param {Array} permission 权限路由
 * @param {Array} asyncRouter 异步路由
 */
export const routerByMatch = (permission, asyncRouter) => {
  permission = JSON.parse(permission)
  // 菜单路由表
  const router = []
  function createRouter (permission) {
    // 根据路由名称匹配到router对象添加到router中
    permission && permission.forEach(item => {
      if (item.children && item.children.length) {
        createRouter(item.children)
      }
      let routerName = item.route
      // 过滤路由名称为null的情况
      if (routerName) {
        // 循环异步路由，将符合权限列表路由加入路由表中
        asyncRouter.find(s => {
          if (s.name === routerName) {
            router.push(s)
          }
        })
      }
    })
  }
  createRouter(permission)
  return router
}

/**
 * @param {Array} routeMetched 当前路由metched
 * @returns {Array}
 */
export const getBreadCrumbList = (route) => {
  let routeMetched = route.matched
  let res = routeMetched
    .filter(item => {
      return item.meta === undefined || !item.meta.hide
    })
    .map(item => {
      let meta = { ...item.meta }
      if (meta.title && typeof meta.title === 'function') meta.title = meta.title(route)
      let obj = {
        icon: (item.meta && item.meta.icon) || '',
        name: item.name,
        meta: meta
      }
      return obj
    })
  res = res.filter(item => {
    return !item.meta.hideInMenu
  })
  // return [Object.assign(homeRoute, { to: homeRoute.path }), ...res]
  return res
}

export const getRouteTitleHandled = route => {
  let router = { ...route }
  let meta = { ...route.meta }
  if (meta.title && typeof meta.title === 'function') meta.title = meta.title(router)
  router.meta = meta
  return router
}

export const showTitle = (item, vm) => {
  return vm.$config.useI18n ? vm.$t(item.name) : (item.meta && item.meta.title) || item.name
}

/**
 * @description 本地存储和获取标签导航列表
 */
export const setTagNavListInLocalstorage = list => {
  localStorage.tagNavList = JSON.stringify(list)
}
/**
 * @returns {Array} 其中的每个元素只包含路由原信息中的name, path, meta三项
 */
export const getTagNavListFromLocalstorage = () => {
  const list = localStorage.tagNavList
  return list ? JSON.parse(list) : []
}

/**
 * @param {Array} routers 路由列表数组
 * @description 用于找到路由列表中name为home的对象
 */
export const getHomeRoute = routers => {
  if (!routers) {
    return
  }
  let i = -1
  let len = routers.length
  let homeRoute = {}
  while (++i < len) {
    let item = routers[i]
    if (item.children && item.children.length) {
      let res = getHomeRoute(item.children)
      if (res.name) return res
    } else {
      // if (item.name === 'home') homeRoute = item
      // 目前没有主页、判断为第一个路由、后期加上主页  把这行去掉  取消上行注释
      if (item.name === routers[0].name) homeRoute = item
    }
  }
  return homeRoute
}

/**
 * @param {*} list 现有标签导航列表
 * @param {*} newRoute 新添加的路由原信息对象
 * @description 如果该newRoute已经存在则不再添加
 */
export const getNewTagList = (list, newRoute) => {
  const { name, path, meta } = newRoute
  let newList = [...list]
  if (newList.findIndex(item => item.name === name) >= 0) return newList
  else newList.push({ name, path, meta })
  return newList
}

/**
 * @param {*} access 用户权限数组，如 ['super_admin', 'admin']
 * @param {*} route 路由列表
 */
const hasAccess = (access, route) => {
  if (route.meta && route.meta.access) return hasOneOf(access, route.meta.access)
  else return true
}

/**
 * 权鉴
 * @param {*} name 即将跳转的路由name
 * @param {*} access 用户权限数组
 * @param {*} routes 路由列表
 * @description 用户是否可跳转到该页
 */
export const canTurnTo = (name, access, routes) => {
  const routePermissionJudge = list => {
    return list.some(item => {
      if (item.children && item.children.length) {
        return routePermissionJudge(item.children)
      } else if (item.name === name) {
        return hasAccess(access, item)
      }
    })
  }

  return routePermissionJudge(routes)
}

/**
 * @param {String} url
 * @description 从URL中解析参数
 */
export const getParams = url => {
  const keyValueArr = url.split('?')[1].split('&')
  let paramObj = {}
  keyValueArr.forEach(item => {
    const keyValue = item.split('=')
    paramObj[keyValue[0]] = keyValue[1]
  })
  return paramObj
}

/**
 * @param {Array} list 标签列表
 * @param {String} name 当前关闭的标签的name
 */
export const getNextRoute = (list, route) => {
  let res = {}
  if (list.length === 2) {
    res = getHomeRoute(list)
  } else {
    const index = list.findIndex(item => routeEqual(item, route))
    if (index === list.length - 1) res = list[list.length - 2]
    else res = list[index + 1]
  }
  return res
}

/**
 * @param {Number} times 回调函数需要执行的次数
 * @param {Function} callback 回调函数
 */
export const doCustomTimes = (times, callback) => {
  let i = -1
  while (++i < times) {
    callback(i)
  }
}

/**
 * @param {Object} file 从上传组件得到的文件对象
 * @returns {Promise} resolve参数是解析后的二维数组
 * @description 从Csv文件中解析出表格，解析成二维数组
 */
export const getArrayFromFile = file => {
  let nameSplit = file.name.split('.')
  let format = nameSplit[nameSplit.length - 1]
  return new Promise((resolve, reject) => {
    let reader = new FileReader()
    reader.readAsText(file) // 以文本格式读取
    let arr = []
    reader.onload = function (evt) {
      let data = evt.target.result // 读到的数据
      let pasteData = data.trim()
      arr = pasteData
        .split(/[\n\u0085\u2028\u2029]|\r\n?/g)
        .map(row => {
          return row.split('\t')
        })
        .map(item => {
          return item[0].split(',')
        })
      if (format === 'csv') resolve(arr)
      else reject(new Error('[Format Error]:你上传的不是Csv文件'))
    }
  })
}

/**
 * @param {Array} array 表格数据二维数组
 * @returns {Object} { columns, tableData }
 * @description 从二维数组中获取表头和表格数据，将第一行作为表头，用于在iView的表格中展示数据
 */
export const getTableDataFromArray = array => {
  let columns = []
  let tableData = []
  if (array.length > 1) {
    let titles = array.shift()
    columns = titles.map(item => {
      return {
        title: item,
        key: item
      }
    })
    tableData = array.map(item => {
      let res = {}
      item.forEach((col, i) => {
        res[titles[i]] = col
      })
      return res
    })
  }
  return {
    columns,
    tableData
  }
}

export const findNodeUpper = (ele, tag) => {
  if (ele.parentNode) {
    if (ele.parentNode.tagName === tag.toUpperCase()) {
      return ele.parentNode
    } else {
      return findNodeUpper(ele.parentNode, tag)
    }
  }
}

export const findNodeUpperByClasses = (ele, classes) => {
  let parentNode = ele.parentNode
  if (parentNode) {
    let classList = parentNode.classList
    if (classList && classes.every(className => classList.contains(className))) {
      return parentNode
    } else {
      return findNodeUpperByClasses(parentNode, classes)
    }
  }
}

export const findNodeDownward = (ele, tag) => {
  const tagName = tag.toUpperCase()
  if (ele.childNodes.length) {
    let i = -1
    let len = ele.childNodes.length
    while (++i < len) {
      let child = ele.childNodes[i]
      if (child.tagName === tagName) return child
      else return findNodeDownward(child, tag)
    }
  }
}

export const showByAccess = (access, canViewAccess) => {
  return hasOneOf(canViewAccess, access)
}

/**
 * @description 根据name/params/query判断两个路由对象是否相等
 * @param {*} route1 路由对象
 * @param {*} route2 路由对象
 */
export const routeEqual = (route1, route2) => {
  const query1 = route1.query || {}
  const query2 = route2.query || {}
  return route1.name === route2.name
}

/**
 * 判断打开的标签列表里是否已存在这个新添加的路由对象
 */
export const routeHasExist = (tagNavList, routeItem) => {
  let len = tagNavList.length
  let res = false
  doCustomTimes(len, index => {
    if (routeEqual(tagNavList[index], routeItem)) res = true
  })
  return res
}

export const showLoadingFunc = (obj, flag) => {
  let arr = obj.$root.$children
  if (arr.length > 0) {
    arr[0].isShowLoading = flag
  }
}

export const dateFormat = (obj, fmt) => {
  if (typeof obj === 'string') {
    return obj
  }
  if (obj && obj.getFullYear) {
    var o = {
      'M+': obj.getMonth() + 1, // 月份
      'd+': obj.getDate(), // 日
      'H+': obj.getHours(), // 小时
      'h+': obj.getHours(), // 小时
      'm+': obj.getMinutes(), // 分
      's+': obj.getSeconds(), // 秒
      'q+': Math.floor((obj.getMonth() + 3) / 3), // 季度
      S: obj.getMilliseconds() // 毫秒
    }
    if (/(y+)/.test(fmt)) {
      fmt = fmt.replace(/(y+)/, (match, p1) => (obj.getFullYear() + '').substring(4 - p1.length))
    }
    for (var k in o) {
      let reg = new RegExp('(' + k + ')')
      if (reg.test(fmt)) {
        fmt = fmt.replace(reg, (match, p1) => p1.length === 1 ? o[k] : ('00' + o[k]).substring(('' + o[k]).length))
      }
    }
    return fmt
  } else {
    return ''
  }
}

export const getYearWeek = (date) => {
  /*
      dateNow是当前日期
      dateFirst是当年第一天
      dataNumber是当前日期是今年第多少天
      用dataNumber + 当前年的第一天的周差距的和在除以7就是本年第几周
  */
  let dateNow = date instanceof Date ? date : convertDateFromString(date, 'yyyy-MM-dd')
  let dateFirst = new Date(dateNow.getFullYear(), 0, 1)
  let dataNumber = Math.round((dateNow.valueOf() - dateFirst.valueOf()) / 86400000)
  return Math.ceil((dataNumber + ((dateFirst.getDay() + 1) - 1)) / 7)
}

// 天-小时-分钟
export const dateRule = (value) => {
  // 需要转换的时间-秒单位
  /**
   * var theTime = parseInt(value);
   */
  var theTime1 = 0 // 分
  var theTime2 = 0 // 小时
  var theTime3 = 0 // 天
  if (value > 60) {
    theTime1 = parseInt(value / 60)
    /**
       * theTime = parseInt(theTime % 60);
       */
    if (theTime1 > 60) {
      theTime2 = parseInt(theTime1 / 60)
      theTime1 = parseInt(theTime1 % 60)
      if (theTime2 > 24) {
        // 大于24小时
        theTime3 = parseInt(theTime2 / 24)
        theTime2 = parseInt(theTime2 % 24)
      }
    }
  }
  var result = ''
  /**
   *  if (theTime > 0) {
      result = "" + parseInt(theTime) + "秒";
      }
   */

  if (theTime1 > 0) {
    if (theTime2 > 0 || theTime3 > 0) {
      result = '' + parseInt(theTime1) + '分' + result
    } else {
      result = '' + parseInt(theTime1) + '分钟' + result
    }
  }
  if (theTime2 > 0) {
    result = '' + parseInt(theTime2) + '小时' + result
  }
  if (theTime3 > 0) {
    result = '' + parseInt(theTime3) + '天' + result
  }
  return result
}
export const convertDateFromString = (dateString, fmt) => {
  if (dateString) {
    if (fmt === 'yyyy-MM-dd' || fmt === 'yyyy-MM-dd hh:mm:ss') {
      return new Date(dateString.replace(/-/g, '/'))
    } else {
      return null
    }
  } else {
    return null
  }
}

/**
 * @description 日期去掉时分秒
 * @param string value 日期
 */
export const dateRemoveTime = dateString => {
  return dateString && dateString.split(' ')[0]
}

export const ObjectNone = object => {
  if (JSON.stringify(object) === '{}') return true
  else return false
}

/**
 * @description 校验邮编号码 长度6位数字
 * @param string value 值
 */
export const testPostal = value => {
  return !/^\d{6}$/.test(value)
}

/**
 * @description 校验手机号码
 * @param string value 值
 */
export const testMobile = value => {
  return !/^1[3|4|5|6|7|8|9][0-9]\d{8}$/.test(value)
}

/**
 * @description 校验邮箱
 * @param string value 值
 */
export const checkEmail = value => {
  return !/^[a-zA-Z0-9]+([a-zA-Z0-9-_.]*)@([a-zA-Z0-9]+[-|_|.]?)*[a-zA-Z0-9]+\.[a-zA-Z]{2,4}$/g.test(value)
}

/**
 * @description 校验固定电话
 * @param string value 值
 */
export const testPhone = value => {
  return !/^(\(\d{3,4}\)|\d{3,4}-|\s)?\d{7,14}$/.test(value)
}

/**
 * @description 校验银行卡
 * @param string value 值
 */
export const testBankNo = value => {
  // 陈曦说8到30 2020年7月10日
  return !/^(\d{8,30})$/.test(value)
}
/**
 * @description 校验5位数短号 10086、95119
 * @param string value 值
 */
export const test5ShortPhone = value => {
  return !/^(1|9){1}\d{4}$/.test(value)
}

/**
 * @description 校验3位数短号， 110、120
 * @param string value 值
 */
export const test3ShortPhone = value => {
  return !/^1\d{2}$/.test(value)
}

/**
 * @description 校验400虚拟号， 400-600-7709
 * @param string value 值
 */
export const test400Phone = value => {
  return !/^(400)-(\d{3})-(\d{4}$)/.test(value)
}

/**
 * @description 校验800虚拟号， 800-600-7709
 * @param string value 值
 */
export const test800Phone = value => {
  return !/^(800)-(\d{3})-(\d{4}$)/.test(value)
}

/**
 * @description 校验身份证18位
 * @param string value 值
 */
export const testIdCard = value => {
  return !/^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/.test(value)
}

/**
 * @description 纳税人识别号 统一社会信用代码
 * @param string value 值
 */
export const testUniformSocialCreditCode = value => {
  return /^[^_IOZSVa-z\W]{2}\d{6}[^_IOZSVa-z\W]{10}$|^[1-9][0-9A-Z]{14}$|^[A-Z0-9]{20}$/.test(value)
}

/**
 * @description 自定义导航标签名
 * @param vm 组件实例
 * @param title 导航名称
 */
export const customTagNavList = (vm, title) => {
  vm.$store.state.app.tagNavList.forEach(item => {
    if (routeEqual(item, vm.$route)) {
      let { meta } = item
      vm.$set(
        meta,
        'title',
        title
      )
    }
  })
  if (vm.$store.state.app.tagNavList.length) {
    setTagNavListInLocalstorage(vm.$store.state.app.tagNavList)
  }
}

/**
 * @description 替换同路由导航标签
 * @param vm 组件实例
 * @param route 当前路由
 */
export const replaceTagNavItem = (vm, { name, query, params }) => {
  query = query || {}
  params = params || {}
  vm.$store.state.app.tagNavList.forEach(item => {
    if (item.name === name && (!objEqual(item.query, query) || !objEqual(item.params, params))) {
      vm.$set(
        item,
        'query',
        query
      )
      vm.$set(
        item,
        'params',
        params
      )
    }
  })

  if (vm.$store.state.app.tagNavList.length) {
    setTagNavListInLocalstorage(vm.$store.state.app.tagNavList)
  }
}

/**
 * @description 手动关闭导航标签
 * @param vm 组件实例
 * @param route 当前路由
 * @param callback 回调函数
 */
// export const handleTagNavClose = (vm, route, callback) => {
//   let list = JSON.parse(JSON.stringify(vm.$store.state.app.tagNavList))
//   if (route.meta && route.meta.beforeCloseName && route.meta.beforeCloseName in beforeClose) {
//     new Promise(beforeClose[route.meta.beforeCloseName]).then(close => {
//       if (close) {
//         vm.$store.state.app.tagNavList = list.filter(item => !routeEqual(route, item))
//       }
//     })
//   } else {
//     vm.$store.state.app.tagNavList = list.filter(item => !routeEqual(route, item))
//   }

//   if (vm.$store.state.app.tagNavList.length) {
//     setTagNavListInLocalstorage(vm.$store.state.app.tagNavList)
//   }

//   callback && callback()
// }

/**
 * 递归格式化tree
 * 返回满足要的tree结构
 * @param dataArr {array} tree数据
 * @param options.value {string} 值
 * @param options.children {array} 子孙节点
 * @param options.label {string} 显示内容
 * @param expand {boolean} 是否展开
 * @param selected {string} 要选中的元素
 */
export const recursionFormatTreeJson = (data, opt = { value: 'id', valueKey: 'value', label: 'label', labelKey: 'label', children: 'children', special: true }, selected) => {
  const res = []
  let obj = {}
  data.forEach(row => {
    const tmp = { ...row }
    if (tmp.children) {
      tmp.children = recursionFormatTreeJson(tmp.children, opt, selected)
      obj = {
        [opt.valueKey]: opt.special ? tmp[opt.value] : `${tmp[opt.value]},${tmp[opt.label]}`,
        [opt.labelKey]: tmp[opt.label],
        label: tmp[opt.label],
        expand: true,
        id: tmp[opt.value],
        type: tmp['type'] || null,
        selected: (tmp[opt.value] === selected),
        [opt.children]: tmp[opt.children] && tmp[opt.children].length > 0 ? tmp[opt.children] : null
      }
    }
    res.push(obj)
  })
  return res
}

/**
 * 递归初始化tree
 * 返回初始化tree，默认展开选择selected
 * @param data {array} tree数据
 * @param selected {string} 要选中的元素
 */
export const recursionInitTreeJson = (data, selected) => {
  let res = false
  for (let i = 0, len = data.length; i < len; i++) {
    if (data[i].value === selected) {
      data[i].selected = true
      data[i].expand = true
      return true
    }

    if (data[i].children) {
      if ((i === 0) || (data[i - 1] && !data[i - 1].expand)) {
        res = recursionInitTreeJson(data[i].children, selected)
        data[i].expand = res
      } else {
        return true
      }
    }
  }
  return res
}
/**
 * 获取当前选中地址单元描述信息
 * @param data {array} 地址单元信息
 * @param row {object} 当前地址信息
 */
export const getCommunityTitleInfo = (data, row) => {
  let resInfo = []
  data.filter(item => {
    // 小区名称
    if (item.communityId === row.communityId) {
      resInfo.push(item.title)
      // 栋名称
      item.children.filter(itemBuild => {
        if (itemBuild.buildId === row.buildId) {
          resInfo.push(itemBuild.title)
          // 单元名称
          itemBuild.children.filter(itemUnit => {
            if (itemUnit.unitId === row.unitId) {
              resInfo.push(itemUnit.title)
              // 房屋号
              itemUnit.children.filter(itemHouse => {
                if (itemHouse.houseId === row.houseId) {
                  resInfo.push(itemHouse.title)
                }
              })
            }
          })
        }
      })
    }
  })
  return resInfo.join(' / ')
}
/**
 * 函数节流
 */
export const throttle = (callback, delay) => {
  let timer = null
  let previous = new Date()

  return function () {
    let now = new Date()
    let remaining = now - previous
    let args = arguments
    let context = this

    if (remaining >= delay) {
      if (timer) {
        clearTimeout(timer)
      }

      callback.apply(context, args)
      previous = now
    } else {
      if (!timer) {
        timer = setTimeout(function () {
          callback.apply(context, args)
          previous = new Date()
        }, delay - remaining)
      }
    }
  }
}
/**
 * 防抖
 */
export const debounce = (callback, delay) => {
  let timer = null

  return function () {
    let args = arguments
    let context = this
    if (timer) {
      clearTimeout(timer)
    }
    timer = setTimeout(function () {
      callback.apply(context, args)
    }, delay)
  }
}
/**
 * js导出xlsx文件
 * @param data {array} 表头描述;列标题，逗号隔开，每一个逗号(英文逗号)就是隔开一个单元格
 * @param columns {array} 表格内容;数组包含对象，每个对象单元为一个表格单元格
 * @param fileName {string} 表个名称
 */
export const jsExportXlsxFile = (columns = [], data = [], fileName = '数据表') => {
  let str = columns.join(',')
  str += `\n`
  // 增加\t为了不让表格显示科学计数法或者其他格式、正则是为了去掉回车
  for (let i = 0; i < data.length; i++) {
    for (let item in data[i]) {
      str += `${data[i][item].replace(/[\n\r]/g, '') + '\t'},`
    }
    str += '\n'
  }
  // encodeURIComponent解决中文乱码
  let uri = 'data:text/csv;charset=utf-8,\ufeff' + encodeURIComponent(str)
  // 通过创建a标签实现
  let link = document.createElement('a')
  link.href = uri
  // 对下载的文件命名
  link.download = `${fileName}.csv`
  document.body.appendChild(link)
  link.click()
  document.body.removeChild(link)
}
/**
 * 文件名称路径拼接
 */
export function fileToPath () {
  let baseUrl = '/api/'
  if (process.env.NODE_ENV === 'production') {
    baseUrl = config.baseUrl.files
  }
  return baseUrl
}
// 资产树选择楼栋，单元，房屋
export const assetTreeFilter = (data, type) => {
  let result = []
  let item = {}
  if (type === 'build') {
    data.forEach(build => {
      item = Object.assign({}, build)
      item.children = []
      result.push(item)
    })
    return result
  }
  if (type === 'unit') {
    let unitItem = {}
    data.forEach(build => {
      item = Object.assign({}, build)
      item.children = []
      build.children.forEach(unit => {
        unitItem = Object.assign({}, unit)
        unitItem.children = []
        item.children.push(unitItem)
      })
      result.push(item)
    })
    return result
  }
  if (type === 'house') {
    return data
  }
}

/**
 * 将dom转为图片dataUrl 和 blob
 * @param {dom} dom 对象
 * @param {string} type default: 获取dataUrl,blob; image: 获取dataUrl; download 自动下载并获取blob
 * @param {Number} quality 图片质量 0~1
 * @param {string} fileName 保存的图片名称
 * @returns Promise
 */
export const dom2Image = (dom, type = 'default', quality = 0.9, fileName = '', imagetype = 'image/jpeg', options = {}) => {
  return new Promise((resolve, reject) => {
    html2canvas(dom, {
      backgroundColor: null,
      dpi: window.devicePixelRatio * 2,
      scale: 10,
      useCORS: true,
      ...options
    })
      .then((canvas) => {
        let dataUrl = canvas.toDataURL(imagetype, quality)
        if (type === 'image') {
          resolve(dataUrl)
        } else {
          canvas.toBlob((blob) => {
            if (type === 'download') {
              saveAs(blob, fileName)
            }
            resolve({
              dataUrl,
              blob
            })
          }, imagetype, quality)
        }
      })
      .catch(err => {
        reject(err)
      })
  })
}

/* 图片压缩方法-canvas压缩 */
export const compressPhoto = (image, maxSize = 0, quality = 0.7) => {
  let canvas = document.createElement('canvas')
  let ctx = canvas.getContext('2d')
  // let initSize = image.src.length
  let { width, height } = image
  let per = 0
  if (width > height) {
    per = maxSize / width
  } else {
    per = maxSize / height
  }
  canvas.width = width * per || width
  canvas.height = height * per || height
  ctx.fillStyle = '#fff'
  ctx.fillRect(0, 0, canvas.width, canvas.height)
  ctx.drawImage(image, 0, 0, canvas.width, canvas.height)

  // 进行压缩0.7
  let compressData = canvas.toDataURL('image/jpeg', quality)

  // 压缩后调用方法进行base64转Blob
  // let blobImg = dataURItoBlob(compressData)
  return compressData
}

/* base64转Blob对象 */
export const dataURItoBlob = (data) => {
  let byteString
  if (data.split(',')[0].indexOf('base64') >= 0) {
    byteString = atob(data.split(',')[1])
  } else {
    byteString = unescape(data.split(',')[1])
  }
  let mimeString = data
    .split(',')[0]
    .split(':')[1]
    .split(';')[0]
  let ia = new Uint8Array(byteString.length)
  for (let i = 0; i < byteString.length; i += 1) {
    ia[i] = byteString.charCodeAt(i)
  }
  return new Blob([ia], { type: mimeString })
}
// 枚举转换
export const enumForMat = (data) => {
  let enumArr = []
  if (data && data.length > 0) {
    enumArr = data.map(item => {
      return {
        text: item.name,
        value: item.code
      }
    })
  }
  return enumArr
}

export function toHump (str = '') {
  return str.replace(/^\w|_\w/g, (match) => match.toUpperCase()).replace(/_/g, '')
}

// 表头统计模板数据转换
export function statisitsChange (data, res) {
  for (let item of data) {
    item.value = res[item.key]
  }
  return data
}

// 金额转换大写
export function priceToUpper (n) {
  if (Number(n) === 0) {
    return '零元整'
  }
  if (!/^(\+|-)?(0|[1-9]\d*)(\.\d+)?$/.test(n)) { return '数据非法' }
  let unit = '仟佰拾亿仟佰拾万仟佰拾元角分'
  let str = ''
  n += '00'
  let a = parseFloat(n)
  if (a < 0) {
    n = n.substr(1)
  }
  let p = n.indexOf('.')
  if (p >= 0) {
    n = n.substring(0, p) + n.substr(p + 1, 2)
  }

  unit = unit.substr(unit.length - n.length)

  for (let i = 0; i < n.length; i++) { str += '零壹贰叁肆伍陆柒捌玖'.charAt(n.charAt(i)) + unit.charAt(i) }
  if (a > 0) {
    return str.replace(/零(仟|佰|拾|角)/g, '零').replace(/(零)+/g, '零').replace(/零(万|亿|元)/g, '$1').replace(/(亿)万/g, '$1').replace(/^元零?|零分/g, '').replace(/元$/g, '元整')
  } else {
    return '负' + str.replace(/零(仟|佰|拾|角)/g, '零').replace(/(零)+/g, '零').replace(/零(万|亿|元)/g, '$1').replace(/(亿)万|壹(拾)/g, '$1$2').replace(/^元零?|零分/g, '').replace(/元$/g, '元整')
  }
}