ai-tagging/web/src/utils/util.js

import { MessageBox, Message } from 'yuwp-ui';
import { sessionStore, extend } from '@yufp/xy-utils';
import frameConfig from '@/config/frame';
import { auditlogdata } from '@xdjf/oca-web/api/monitor';
import { getAccessToken, getContrs } from '@/utils/oauth';
import router from '@/router';
import XLSX from 'xlsx';
import { ADMIN_ROLECODES, MENU_STOREOG_KEY, USER_STORE_KEY } from '@/config/constant/app.data.common';
import backend from '@/config/constant/app.data.service.js';

/**
 * 显示信息
 * @param {string} msg 待显示的信息
 * @param {String} type 显示信息类型 error|warning|info|success
 * @param {Integer} duration 显示信息长度,单位秒,默认5秒
 */
export function showMessage(msg, type = 'error', duration = 5) {
  msg &&
    Message({
      message: msg,
      type,
      duration: duration * 1000,
    });
}
/**
 * 显示信息
 * @param {string} msg 待显示的信息
 * @param {String} type 显示信息类型 error|waring|info|success
 */
export function showMessageAlert(msg, type = 'error') {
  msg &&
    MessageBox({
      message: msg,
      type,
    });
}

// 判断浏览器类型
export function getBrowserType() {
  const { userAgent } = navigator; // 取得浏览器的userAgent字符串
  if (userAgent.indexOf('OPR') > -1) {
    return 'Opera';
  } // 判断是否Opera浏览器 OPR/43.0.2442.991
  if (userAgent.indexOf('Firefox') > -1) {
    return 'FF';
  } // 判断是否Firefox浏览器  Firefox/51.0
  if (userAgent.indexOf('Trident') > -1) {
    return 'IE';
  } // 判断是否IE浏览器  Trident/7.0; rv:11.0
  if (userAgent.indexOf('Edge') > -1) {
    return 'Edge';
  } // 判断是否Edge浏览器  Edge/14.14393
  if (userAgent.indexOf('Chrome') > -1) {
    return 'Chrome';
  } // Chrome/56.0.2924.87
  if (userAgent.indexOf('Safari') > -1) {
    return 'Safari';
  } // 判断是否Safari浏览器 AppleWebKit/534.57.2 Version/5.1.7 Safari/534.57.2
}

/** *
 * 上午下午中午
 */
export function getTimeOfDay() {
  const now = new Date();
  const hour = now.getHours();

  if (hour < 12) {
    return '早上';
  }
  if (hour >= 12 && hour < 18) {
    return '下午';
  }
  return '晚上';
}
/**
 * 获取默认皮肤对象
 */
export function getDefaultTheme() {
  const themes = frameConfig.baseFrameOptions.themesList.filter((item) => {
    const themekey = window.XYWEB_SYS_CONFIG.theme || frameConfig.theme;
    return item.id === themekey;
  });
  return themes.length > 0 ? themes[0] : null;
}
/**
 * 获取默认布局对象
 */
export function getDefaultMenuModel() {
  const model = frameConfig.baseFrameOptions.modelList.filter((item) => {
    return item.id === frameConfig.menumodel;
  });
  return model.length > 0 ? model[0] : null;
}
/**
 * 获取当前选中系统名称
 */
export function getSystemName() {
  const systemName = sessionStore.get('currentApp');
  if (systemName) {
    return systemName.applicationName;
  }
  if (frameConfig.baseFrameOptions.appOptions.length > 1) {
    return frameConfig.baseFrameOptions.appOptions[0].applicationName;
  }
  return '';
}
/**
 * 获取全路径
 */
export function getUrl(param) {
  let paramUrl = param.url || param.name;
  if (!paramUrl) {
    throw new Error('Yufp.service.request: 未设置请求URL');
  }
  const reg = /^(http|https):\/\//;
  // url请求未附带http(s)://前缀，则按yufp.settings.url及ssl添加前缀
  if (!reg.test(paramUrl)) {
    let protocol;
    let prefixUrl = import.meta.env.VUE_APP_DOWNLOAD_PATH || '';
    // yufp.settings.url 非空，即非默认同源模式，计算服务端URL源路径
    if (prefixUrl) {
      if (reg.test(prefixUrl)) {
        protocol = '';
      } else {
        protocol = 'http://';
      }
      prefixUrl = protocol + prefixUrl;
    }
    paramUrl = `/${paramUrl}`.replace(/^\/\//, '/'); // 添加前缀
    paramUrl = (import.meta.env.VUE_APP_BASE_API || '') + paramUrl; // 添加basePath
    paramUrl = prefixUrl + paramUrl; // 组合origin
  }
  return paramUrl;
}

/**
 * 为url添加token信息
 * @param url
 * @returns {string}
 */
export function addTokenInfo(url) {
  const token = 'accessToken=';
  let _url = '';
  if (url === null || url === '') {
    return _url;
  }

  if (!url.indexOf(token) > -1) {
    _url = url + (url.indexOf('?') > -1 ? '&' : '?') + token + getAccessToken();
  }
  return _url;
}
/**
 * @description 从文件服务器上获取文件路径
 * @param {String} fileId 文件ID
 * @returns {String} 文件全路径,文件ID为空时，返回空字符串
 */
export function getFileUrl(fileId) {
  return (fileId && addTokenInfo(`${backend.fileService}/api/file/provider/download?fileId=${fileId}`)) || '';
}
/**
 * @description 获取文件上传路径
 * @returns {String} 文件全路径,文件ID为空时，返回空字符串
 */
export function getUploadFileUrl() {
  return addTokenInfo(`${backend.fileService}/api/file/provider/uploadfile`);
}
/**
 * 下载文件
 */
export function download(path) {
  if (path) {
    if (path.indexOf('http') <= -1) {
      // 当不包含http时拼接gateway地址
      path = getUrl({
        url: path,
      });
    }
  } else {
    showMessage('必须设置请求url!', 'warning');
  }
  // url添加token
  path = addTokenInfo(path);
  // 模拟a标签进行下载
  const a = document.createElement('a');
  a.href = path;
  console.log('href', path);
  if (window.fireEvent) {
    window.open(a.href);
  } else {
    a.click();
  }
}

/**
 * @param {HTMLElement} element
 * @param {string} className
 */
export function toggleClass(element, className, oid) {
  if (!element || !className) {
    return;
  }
  let classString = element.className;
  // 替换2个以上的空格为一个空格 解决\s+正则替换出现样式无空格问题
  classString = classString.replace(/\s{1,}/g, ' ').replace(oid, '');
  const nameIndex = classString.indexOf(className);
  if (nameIndex === -1) {
    classString += ` ${className}`;
  } else {
    // 旧id存在时，才做替换，解决空样式替换出现的主题色消失问题
    oid && (classString = classString.substr(0, nameIndex) + classString.substr(nameIndex + className.length));
  }
  element.className = classString;
}

/**
 * 切换皮肤
 * @param {String} theme 选中皮肤
 */
export function changeTheme(theme) {
  const colors = theme.colorList;
  // 改变全局变量来换肤
  document.getElementsByTagName('body')[0].style.setProperty('--main-color', colors[0]);
  document.getElementsByTagName('body')[0].style.setProperty('--second-color', colors[1]);
  document.getElementsByTagName('body')[0].style.setProperty('--third-color', colors[2]);
  document.getElementsByTagName('body')[0].style.setProperty('--fourth-color', colors[3]);
  document.getElementsByTagName('body')[0].style.setProperty('--fifth-color', colors[4]);
}
/**
 * 更新界面是否紧凑模式
 * @param {Boolean} isCompact 是否紧凑模式
 */
export function changeSizeModel(isCompact) {
  // const target = document.getElementsByTagName('link');
  const dom = document.querySelector('.yu-frame-body'); // dom结构
  const newClas = isCompact ? 'compact' : 'normal'; // 新样式
  const oldClas = !isCompact ? 'compact' : 'normal'; // 旧样式
  // 切换样式
  toggleClass(dom, newClas, oldClas);
}
/**
 * 格式化时间
 */
export function parseTime(time, cFormat) {
  if (arguments.length === 0) {
    return null;
  }
  const format = cFormat || '{y}-{m}-{d} {h}:{i}:{s}';
  let date;
  if (typeof time === 'object') {
    date = time;
  } else {
    // modify by luyq1 解决时间传参问题
    if (typeof time === 'number' && !isNaN(time) && `${time}`.length === 10) {
      time = parseInt(time) * 1000;
    }
    if (typeof time === 'string') {
      time = time.replace(/-/g, '/');
    }
    // 解决new Date 创建时间 默认是8点的问题

    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, function (result, key) {
    let value = formatObj[key];
    if (key === 'a') {
      return ['一', '二', '三', '四', '五', '六', '日'][value - 1];
    }
    if (result.length > 0 && value < 10) {
      value = `0${value}`;
    }
    return value || 0;
  });
  return timeStr;
}
/**
 * 将时间转成字符串
 */
export function formatTime(time) {
  return `${time.hours < 10 ? `0${time.hours}` : time.hours}:${time.minutes < 10 ? `0${time.minutes}` : time.minutes}`;
}
/**
 *  判断两个时间段是否相差 多少天
 * @param  {new Date(‘2023-01-13 10:14:30’)} time1 日期类型
 * @param  {new Date(‘2023-01-13 10:14:30’)} time2 日期类型
 * @param  {Number} m 天数
 */
export function completeDate(time1, time2, m) {
  let totalDays;
  let diffDate;
  // eslint-disable-next-line camelcase
  const myDate_1 = Date.parse(time1);
  // eslint-disable-next-line camelcase
  const myDate_2 = Date.parse(time2);
  // eslint-disable-next-line camelcase
  diffDate = Math.abs(myDate_1 - myDate_2);
  totalDays = diffDate / (1000 * 3600 * 24);
  return totalDays <= m;

  // var diffyear = time2.getFullYear() - time1.getFullYear() ;
  // var diffmonth = diffyear * 12 + time2.getMonth() - time1.getMonth() ;
  // if(diffmonth < 0) {
  //   return false ;
  // }
  // var diffDay = time2.getDate() - time1.getDate() ;
  // if(diffmonth < m || (diffmonth == m && diffDay <= 0)) {

  //   if(diffmonth == m && diffDay == 0) {
  //     var timeA = time1.getHours() * 3600 + 60 * time1.getMinutes() + time1.getSeconds();
  //     var timeB = time2.getHours() * 3600 + 60 * time2.getMinutes() + time2.getSeconds();
  //     if(timeB - timeA > 0) {
  //       return false;
  //     }
  //   }
  //   return true ;
  // }
  // return false ;
}
/**
 * 获取基础路径配置信息
 */
export function getBaseUrl() {
  const devEnv = import.meta.env.NODE_ENV === 'development'; // 开发环境
  const baseApi = import.meta.env.VUE_APP_BASE_API; // 应用服务前缀URL
  const proxyPrefix = import.meta.env.VUE_APP_PROXY_PREFIX || ''; // 代理API前缀
  const match = /^(https?:\/\/)([0-9a-z.]+)(:[0-9]+)?([/0-9a-z.-]+)?/i; // 匹配URL(协议+域名+端口)

  const matchResult = match.exec(baseApi);
  return devEnv && matchResult ? proxyPrefix + (matchResult[4] || '') : baseApi;
}
/**
 * 获取公钥字符串
 */
export function getRSAPublicKey() {
  return 'MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCrDUHc85ADQVxXRP4M90nqttWoZctV6JJVVdPjIle5vd9G2/4kgIhNc78Jd+ENxg+n4Gj9UMwNhJmb2jnMaW3zyGB+qi/ZrMO5dEUhW8salirzRgGg/4Arz4ObPmCWlZsws3Ij/3IEsFD3vMdIZD2j8b33DAbj47PjcCcMbtHYuQIDAQAB';
}
/**
 * @created by zhangkun6
 * @updated by 2018/01/14
 * @description 数字金额格式化(千分位)
 */
export function moneyFormatter(money, num) {
  /*
   * 参数说明：
   * money：要格式化的数字
   * num：保留几位小数
   * */
  num = num > 0 && num <= 20 ? num : 2;
  money = `${parseFloat(`${money}`.replace(/[^\d.-]/g, '')).toFixed(num)}`;
  const l = money.split('.')[0].split('').reverse();
  const r = money.split('.')[1];
  let t = '';
  for (let i = 0; i < l.length; i++) {
    t += l[i] + ((i + 1) % 3 === 0 && i + 1 !== l.length ? ',' : '');
  }
  return `${t.split('').reverse().join('')}.${r}`;
}

/**
 * @created by zhangkun6
 * @updated by 2018/05/03
 * @description 数值百分比显示
 */
export function toPercent(money, num) {
  /*
   * 参数说明：
   * money：要格式化的数字
   * num：保留几位小数
   */
  // num = num > 0 && num <= 20 ? num : 2;
  money = `${parseFloat(`${money}`)}%`;
  return money;
}

/**
 * @created by zhangkun6
 * @updated by 2018/01/14
 * @description 数字金额转汉字金额
 */
export function moneyToUpper(money) {
  /*
   * 参数说明：
   * money：要转化的数字
   */
  // 汉字的数字
  const cnNums = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
  // 基本单位
  const cnIntRadice = ['', '拾', '佰', '仟'];
  // 对应整数部分扩展单位
  const cnIntUnits = ['', '万', '亿', '兆'];
  // 对应小数部分单位
  const cnDecUnits = ['角', '分', '毫', '厘'];
  // 整数金额时后面跟的字符
  const cnInteger = '整';
  // 整型完以后的单位
  const cnIntLast = '元';
  // 最大处理的数字
  const maxNum = 999999999999999.9999;
  // 金额整数部分
  let integerNum;
  // 金额小数部分
  let decimalNum;
  // 输出的中文金额字符串
  let chineseStr = '';
  // 分离金额后用的数组，预定义
  let parts;
  if (money === '') {
    return '';
  }
  money = parseFloat(money);
  if (money >= maxNum) {
    // 超出最大处理数字
    return '';
  }
  if (money === 0) {
    chineseStr = cnNums[0] + cnIntLast + cnInteger;
    return chineseStr;
  }
  // 转换为字符串
  money = money.toString();
  if (money.indexOf('.') === -1) {
    integerNum = money;
    decimalNum = '';
  } else {
    parts = money.split('.');
    integerNum = parts[0];
    decimalNum = parts[1].substr(0, 4);
  }
  // 获取整型部分转换
  if (parseInt(integerNum, 10) > 0) {
    let zeroCount = 0;
    const IntLen = integerNum.length;
    for (let i = 0; i < IntLen; i++) {
      const n = integerNum.substr(i, 1);
      const p = IntLen - i - 1;
      const q = p / 4;
      const m = p % 4;
      if (n === '0') {
        zeroCount++;
      } else {
        if (zeroCount > 0) {
          chineseStr += cnNums[0];
        }
        // 归零
        zeroCount = 0;
        chineseStr += cnNums[parseInt(n)] + cnIntRadice[m];
      }
      if (m === 0 && zeroCount < 4) {
        chineseStr += cnIntUnits[q];
      }
    }
    chineseStr += cnIntLast;
  }
  // 小数部分
  if (decimalNum !== '') {
    const decLen = decimalNum.length;
    for (let i = 0; i < decLen; i++) {
      const n = decimalNum.substr(i, 1);
      if (n !== '0') {
        chineseStr += cnNums[Number(n)] + cnDecUnits[i];
      }
    }
  }
  if (chineseStr === '') {
    chineseStr += cnNums[0] + cnIntLast + cnInteger;
  } else if (decimalNum === '') {
    chineseStr += cnInteger;
  }
  return chineseStr;
}

/**
 * @created by zhangkun6
 * @updated by 2018/01/19
 * @description 汉字金额转数字金额
 */
export function upperToMoney(upper) {
  /*
   * 参数说明：
   * upper：要转化的汉字
   */
  // 金额数值
  const num = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
  // 汉字的数字
  const cnNums = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
  // 对应单位的乘积
  const upperMap = [10, 100, 1000];
  // 基本单位
  const cnIntRadice = ['拾', '佰', '仟'];
  // 对应整数部分扩展单位
  // var cnIntUnits = ['万', '亿', '兆'];
  // 对应小数部分单位乘积
  const cnDecMap = [0.1, 0.01];
  // 对应小数部分单位
  const cnDecUnits = ['角', '分'];
  // 金额单位亿之前的数值数组
  let maxArray = [];
  // 金额单位亿和万之间的数值数组
  let middleArray = [];
  // 金额单位万和元之间的数值数组
  let minArray = [];

  const part = upper.split('元');
  // 金额整数部分
  const integerNum = part[0];
  // 金额小数部分
  const decimalNum = part[1].split('');
  if (integerNum.indexOf('亿') !== -1) {
    maxArray = integerNum.split('亿')[0].split('');
    if (integerNum.indexOf('万') !== -1) {
      middleArray = integerNum.split('亿')[1].split('万')[0].split('');
      minArray = integerNum.split('亿')[1].split('万')[1].split('');
    } else {
      minArray = integerNum.split('亿')[1].split('');
    }
  } else if (integerNum.indexOf('万') !== -1) {
    middleArray = integerNum.split('万')[0].split('');
    minArray = integerNum.split('万')[1].split('');
  } else {
    minArray = integerNum.split('');
  }
  const getNum = function (upArray, cnNums, cnRadice, numArray, map) {
    const { length } = upArray;
    let num = 0;
    let sum = 0;
    for (let i = 0; i < length; i++) {
      const index = cnNums.indexOf(upArray[i]);
      const _index = cnRadice.indexOf(upArray[i]);
      if (index !== -1) {
        num += numArray[index];
        if (i === length - 1) {
          sum += num;
        }
      }
      if (_index !== -1) {
        num *= map[_index];
        sum += num;
        num = 0;
      }
    }
    return sum;
  };
  const maxSum = getNum(maxArray, cnNums, cnIntRadice, num, upperMap);
  const middleSun = getNum(middleArray, cnNums, cnIntRadice, num, upperMap);
  const minSun = getNum(minArray, cnNums, cnIntRadice, num, upperMap);
  const cesSum = getNum(decimalNum, cnNums, cnDecUnits, num, cnDecMap);
  // 输出的数字金额字符串
  return maxSum * 100000000 + middleSun * 10000 + minSun + cesSum;
}
/**
 * 从路径中解析查询参数
 * @param {String} url 路径
 */
export function resolveQueryParameters(url) {
  if (url) {
    const i = url.indexOf('?');
    if (i > -1) {
      const query = url.substr(i + 1);
      const vars = query.split('&');
      const queryParams = {};
      for (let i = 0; i < vars.length; i++) {
        const pair = vars[i].split('=');
        queryParams[pair[0]] = pair[1];
      }
      return queryParams;
    }
  }
  return null;
}
/**
 * @description 判断传入的节点是不是选中节点的子节点
 * @param value 当前输入信息
 * @param nodeData 当前节点属性信息
 * @param label 当前节点名称
 */
export function checkBelongToChooseNode(value, node, label) {
  const { level } = node;
  // 如果传入的节点本身就是一级节点就不用校验了
  if (level === 1) {
    return false;
  }
  // 先取当前节点的父节点
  let parentData = node.parent;
  // 遍历当前节点的父节点
  let index = 0;
  while (index < level - 1) {
    // 如果匹配到直接返回
    if (parentData.data[label] && parentData.data[label].indexOf(value) !== -1) {
      return true;
    }
    // 否则的话再往上一层做匹配
    parentData = parentData.parent;
    index++;
  }
  // 没匹配到返回false
  return false;
}
/* 监控 */
if (frameConfig.monitorAble) {
  require('./yufp.monitor');
}
/**
 * @description 上传按钮日志
 */
export function logInfo(data) {
  auditlogdata(data);
}
// 控制点公共方法
export function checkCtrl(ctrlCode, menuId, isView) {
  const ctrls = getContrs();
  const route = router.history.current;
  // 低码预览页面，路由的参数在route.params.routeId中
  menuId = menuId || route.meta.routeId || route.params.routeId;
  if (!ctrlCode || !ctrls || !menuId) {
    return false;
  }
  const ctrlItem = ctrls.filter((item) => {
    return item.funcId === menuId && item.contrCode === ctrlCode;
  });
  if (ctrls && menuId && !ctrlItem.length) {
    return true;
  }
  return false;
}
/**
 * @description 上传页面访问rizhi
 * @to 路由信息
 */
export function menuLog(to) {
  if (!to.meta) {
    return;
  }
  const zhCn = {
    menu: '菜单',
    path: '路径：',
    accessMenu: '访问菜单：',
  };
  const lang = zhCn;
  const log = {
    logCtg: '2',
    oprObj: lang.menu,
    oprCtnt: `${lang.accessMenu}${to.meta.title}，${lang.path}${to.meta.routeUrl}`,
    funcModlName: to.meta.title,
  };
  logInfo(log);
}
/**
 * 倒计时,
 * 通过当前系统时间为维度进行动态计算时间差,
 * @param {*} options
 * options: {
 *  time: Number
 *  change: Function 倒计时刷新函数
 *  finish: Function 结束倒计时函数
 * }
 */
export function countDown(options) {
  const endTime = options.time * 1000 + Date.now();
  let rafId;
  let isCounting = true;
  const getCurrentRemain = () => Math.max(endTime - Date.now(), 0);
  const isSameSecond = (time1, time2) => {
    return Math.floor(time1 / 1000) === Math.floor(time2 / 1000);
  };
  let currentTime = endTime;
  const setRemain = (value) => {
    currentTime = value;
    typeof options.change === 'function' && options.change(parseInt(currentTime / 1000));
    if (value === 0) {
      cancelAnimationFrame(rafId);
      isCounting = false;
      typeof options.finish === 'function' && options.finish();
    }
  };
  const macroTick = () => {
    rafId = requestAnimationFrame(() => {
      // in case of call reset immediately after finish
      if (isCounting) {
        const remainRemain = getCurrentRemain();

        if (!isSameSecond(remainRemain, currentTime) || remainRemain === 0) {
          setRemain(remainRemain);
        }

        if (currentTime >= 0) {
          macroTick();
        }
      }
    });
  };
  macroTick();
  return {
    stop: () => {
      cancelAnimationFrame(rafId);
      isCounting = false;
    },
  };
}

/** 补齐方法，防止校验报错 */
/**
 * 将数组转化为树
 * @param {*} data 数组数据
 * @param {*} options 映射关系，默认{ id: 'id', pid: 'pid', root: '-1 }
 * @returns
 */
export function array2tree(data, options) {
  const _options = {
    id: 'id',
    pid: 'pid',
    root: '-1',
  };
  extend(_options, options || {});
  const idField = _options.id;
  const pidField = _options.pid;
  let root;
  let children = [];
  if (typeof _options.root === 'object') {
    root = _options.root;
  } else {
    const tempObj = {};
    tempObj[idField] = _options.root;
    root = tempObj;
  }
  const rId = `${root[idField]}`;
  for (let i = 0, len = data.length; i < len; i++) {
    const d = data[i];
    if (rId === `${d[idField]}`) {
      root = d;
    } else if (rId === `${d[pidField]}`) {
      children.push(d);
    }
  }
  root.id = root[idField];
  children = root.children ? root.children.concat(children) : children;
  root.children = children;
  for (let i = 0, len = root.children.length; i < len; i++) {
    _options.root = root.children[i];
    root.children[i] = array2tree(data, _options);
  }
  return root;
}
/**
 * 将大写并且带有下划线的XX_YY设置成小驼峰
 */

export function toCamelCase(str) {
  return str
    .toLowerCase() // 将字符串转换为小写
    .replace(
      /_./g,
      (
        match, // 用正则表达式匹配下划线及其后的字符
      ) => match.charAt(1).toUpperCase(), // 将下划线后的字符转为大写
    );
}
/**
 * 通过 a 标签 download 属性结合 blob 构造函数下载
 * @param {*} res
 * @param {*} filename
 * @param {*} fileType
 */
export function fileDownloadBlob(res, filename, fileType) {
  // 添加文件类型
  let blobTypeParams = {};

  if (fileType === 'xls') {
    blobTypeParams = {
      type: 'application/vnd.ms-excel',
    };
  } else if (fileType === 'pdf') {
    blobTypeParams = {
      type: 'application/pdf',
    };
  } else if (fileType === 'xlsx') {
    blobTypeParams = {
      type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
    };
  } else if (fileType === 'zip') {
    blobTypeParams = {
      type: 'application/zip',
    };
  }
  const nFileType = fileType ? '.' + fileType : '';
  let nFileName = filename + nFileType;
  const blobData = new Blob([res.data], blobTypeParams);
  // 有可能下载失败，比如返回{code: 0},但设置了responseType: 'blob'，axios会把data强制转为blob，导致下载undefined
  // 解决：将已转为blob类型的data转回json格式，判断是否下载成功
  const reader = new window.FileReader();
  let parseObj = null;
  reader.readAsText(res.data, 'utf-8');
  reader.onload = function () {
    try {
      parseObj = JSON.parse(reader.result);
      showMessage(parseObj.message || '下载失败');
    } catch (error) {
      // filename不存在时取请求头中的文件名称
      if (!nFileName) {
        let patt = new RegExp('filename=([^;]+\\.[^\\.;]+);*');
        let contentDisposition = decodeURI(res.headers['content-disposition']);
        nFileName = patt.exec(contentDisposition)[1];
      }
      if (window.navigator.msSaveBlob) {
        window.navigator.msSaveBlob(blobData, nFileName);
      } else {
        const url = window.URL.createObjectURL(blobData);
        const link = document.createElement('a');
        link.style.display = 'none';
        link.href = url;
        link.setAttribute('download', nFileName);
        document.body.appendChild(link);
        link.click();
      }
    }
  };
}

// 对象判空
export function isNullOrUndefined(param) {
  if (param === null || param === '' || param === undefined || param.length === 0 || typeof param === 'undefined') {
    return true;
  }
  return false;
}
// 参数为空则默认某值，否则返回该参数
export function isNullOrUndefinedSetDef(param, defValue) {
  if (isNullOrUndefined(param)) {
    return defValue;
  }
  return param;
}
/**
 * js导出excel
 * 方法参数为一个Object, 包含以下属性：
 * ref: xtable对应的vue对象ref
 * importType: selected: 选中行的数据；page: 当前页面展示的所有表格数据；service：根据传递的参数从服务端获取要导出的数据
 * method: 从服务端获取要导出的数据时的请求method
 * url: 从服务端获取要导出的数据时的请求url
 * param: 从服务端获取要导出的数据时的请求参数
 * fileName: 导出文件名
 * importHidCloum: true/false 是否导出隐藏列，默认导出
 * stringifyNum: true/false 是否转换数字单元格内容为文本，以防止大数字显示为科学计数，默认为false
 * FAQ: 对于多表头的列，
 * 只有最底层的子节点可以配置prop属性，
 * 非最底层的不可以配置prop属性，
 * 整个表格的prop不可以重复，
 * 当表格使用了插槽的时候，会导致表格列的数据结构发生变化，现有方法不能满足使用插槽的表格导出
 * @author lvzl
 * @returns {*}
 */
export function exportExcelByTable(options) {
  // const {log} = console;
  options.importHidCloum = options.importHidCloum || true;
  let tableRef = options.ref;
  let colums = tableRef.tableColumns;
  let tableColumns = colums.concat([]);
  if (!options.importHidCloum) {
    removeHidCloums(tableColumns);
  }
  // 移除隐藏列
  function removeHidCloums(arr) {
    if (!arr || !Array.isArray(arr)) {
      return new Error('参数类型必须是数组');
    }
    for (let i = 0; i < arr.length; i++) {
      let element = arr[i];
      if (element.hideColumn) {
        arr.splice(i, 1);
      }
      if (element.children && Array.isArray(element.children) && element.children.length > 0) {
        removeHidCloums(element.children);
      }
    }
  }
  /** 输出计算的结果 */
  // log('初始状态的tableColumns', JSON.stringify(tableColumns));
  let collectionHtml = tableRef.$el.getElementsByClassName('el-table__header-wrapper')[0].getElementsByTagName('tr');
  /** ----------------------------------> 1.获取表头行列数，给表头每个单元格设置行列合并数rowspan/colspan <------------------------------------------ */
  // 获取表头行数和列数（包含多级表头）
  function getRowAndCol(list) {
    if (!list || !Array.isArray(list)) {
      return new Error('参数类型必须是数组');
    }
    let haveSubCellList = []; // 存储每个多级表头整体的行列数信息
    for (let i = 0; i < list.length; i++) {
      if (list[i].children) {
        haveSubCellList.push(getMaxFloor(list[i].children));
      }
    }
    // 含有多个多级表头时获取最大的行数
    let maxRow;
    if (haveSubCellList.length > 0) {
      maxRow = Math.max.apply(null, haveSubCellList) + 1;
    } else {
      maxRow = 1;
    }
    return { rowCount: maxRow, colCount: maxColCount(list) };
  }
  // 计算colCount
  function maxColCount(column) {
    if (!column || !Array.isArray(column)) {
      return new Error('参数类型必须是数组');
    }
    let colCount = 0; // colCount: 横向最底层单元格列数
    for (let i = 0; i < column.length; i++) {
      let element = column[i];
      if (element.children && Array.isArray(element.children) && element.children.length > 0) {
        let childrenColCount = maxColCount(element.children);
        colCount += childrenColCount; // 横向叠加计算总列数
      } else {
        colCount++;
      }
    }
    return colCount;
  }
  //  计算多表头的rowCount
  function getMaxFloor(treeData) {
    // let floor = 0;
    // let v = this;
    let max = 0;
    function each(data, floor) {
      data.forEach(function (e) {
        e.floor = floor;
        if (floor > max) {
          max = floor;
        }
        if (e.children && Array.isArray(e.children) && e.children.length > 0) {
          each(e.children, floor + 1);
        }
      });
    }
    each(treeData, 1);
    return max;
  }
  // 获取整个完整表头的行列数
  let cellData = getRowAndCol(tableColumns);
  /** 输出计算的结果 */
  // log('整个表头的行列数:', JSON.stringify(cellData));
  // 给表头每个单元格设置行列合并数量信息rowspan行 colspan列
  let maxcolspan = function (list) {
    if (list && Array.isArray(list) == true) {
      for (let i = 0; i < list.length; i++) {
        let element = list[i];
        let children = element.children;
        let childrenColCount;
        if (children) {
          childrenColCount = maxColCount(children); // 获取当前单元格的子单元格行列数
        }
        if (children && Array.isArray(children) && children.length > 0) {
          // 存在子节点
          element.rowspan = 0;
          element.colspan = childrenColCount - 1;
          getChildColspan(children);
        } else {
          // 不存在子节点
          element.colspan = 0;
          element.rowspan = cellData.rowCount - 1;
        }
      }
    }
  };
  function getChildColspan(list) {
    let listRowCount = getMaxFloor(list); // 获取当前list的占用单元格的行数和列数
    let rowIndex = cellData.rowCount - listRowCount;
    if (list && Array.isArray(list) == true) {
      for (let i = 0; i < list.length; i++) {
        let element = list[i];
        let children = element.children;
        let childrenColCount;
        if (children) {
          childrenColCount = maxColCount(children); // 获取当前单元格的子单元格行列数
        }
        if (children && Array.isArray(children) && children.length > 0) {
          // 存在子节点
          element.colspan = childrenColCount - 1;
          element.rowspan = 0;
          getChildColspan(children);
        } else {
          // 不存在子节点
          element.rowspan = listRowCount - rowIndex <= 0 ? 0 : listRowCount - rowIndex;
          element.colspan = 0;
        }
      }
    }
  }
  maxcolspan(tableColumns);
  /** 输出计算的结果 */
  // let arr = [];
  // for (let i = 0; i < tableColumns.length; i++) {
  //   arr.push({label: tableColumns[i].label, colspan: tableColumns[i].colspan, rowspan: tableColumns[i].rowspan});
  // }
  // log('每个单元格的colspan&rowspan:', JSON.stringify(arr));
  /** ----------------------------------> 2.获取所有表头字段名label <------------------------------------------ */
  // 存储所有表头字段名
  let headLabel = []; // 所有表头的label，prop，没有prop就取''.
  let havePropArr = []; // 所有表头字段的prop
  let haveOptions = []; // 所有含有options的prop
  function getHeadLabel(list) {
    if (!list || !Array.isArray(list)) {
      return new Error('参数类型必须是数组');
    }
    for (let i = 0; i < list.length; i++) {
      if (list[i].label) {
        headLabel.push({ label: list[i].label, prop: list[i].prop || '' });
        if (list[i].prop) {
          havePropArr.push({ prop: list[i].prop });
          if (list[i].options) {
            haveOptions.push({ prop: list[i].prop, options: list[i].options });
          }
        }
        if (list[i].children && Array.isArray(list[i].children)) {
          getHeadLabel(list[i].children); // 递归子表头数据
        }
      }
    }
  }
  getHeadLabel(tableColumns);
  /** 输出计算的结果 */
  // log('所有label:', JSON.stringify(headLabel));
  // log('所有有prop属性的label:', JSON.stringify(havePropArr));
  /** ----------------------------------> 3.设置表头每个表头单元格的行列起始信息 <------------------------------------------ */
  let mergeCellDataList = []; // 存放表头每个单元格的行列起始信息
  function genCellPlace() {
    return {
      // 定义单元格的起止行列
      s: {
        // s为开始
        c: 0, // 开始列
        r: 0, // 开始行
      },
      e: {
        // e结束
        c: 0, // 结束列
        r: 0, // 结束行
      },
    };
  }
  /**
   * 设置表头每个表头单元格的行列起始信息
   * @param {Array} list 表头列组成的数据
   * @param {Number} subLength 当前表头有几个子表头（不含子表头的子表头的标志）
   */
  function getMerges(list) {
    if (!list || !Array.isArray(list)) {
      return new Error('参数类型必须是数组');
    }
    let lastEc = 0;
    for (let i = 0; i < list.length; i++) {
      let element = list[i];
      let cellPlace = genCellPlace();
      let children = element.children;
      if (children && Array.isArray(children) && children.length > 0) {
        // 存在子节点
        if (i == 0) {
          // 第一列就是多表头的处理
          cellPlace.s.c = lastEc > i ? lastEc : i;
        } else {
          cellPlace.s.c = lastEc + 1;
        }
        cellPlace.s.r = element.rowspan;
        cellPlace.e.c = cellPlace.s.c + element.colspan;
        cellPlace.e.r = element.rowspan;
        lastEc = cellPlace.e.c;
        mergeCellDataList.push(cellPlace);
        getChildMerges(children, cellPlace.s.c);
      } else {
        // 没有子节点的一级表头
        lastEc = lastEc > i ? lastEc : i;
        cellPlace.s.c = getCellPlaceSC(element.prop);
        cellPlace.s.r = element.colspan;
        cellPlace.e.c = cellPlace.s.c;
        cellPlace.e.r = element.rowspan;
        lastEc = cellPlace.e.c;
        mergeCellDataList.push(cellPlace);
      }
    }
  }
  function getChildMerges(list, lastColIndex) {
    let listRowCount = getMaxFloor(list); // 获取当前list的占用单元格的行数和列数
    let rowIndex = cellData.rowCount - listRowCount;
    let lastEc = lastColIndex;
    for (let i = 0; i < list.length; i++) {
      let element = list[i];
      let cellPlace = genCellPlace();
      let children = element.children;
      if (children && Array.isArray(children) && children.length > 0) {
        // 存在子节点
        if (i < 1) {
          cellPlace.s.c = lastEc > lastColIndex ? lastEc + 1 : lastEc;
        } else {
          cellPlace.s.c = lastEc + 1;
        }
        cellPlace.s.r = rowIndex;
        cellPlace.e.c = cellPlace.s.c + element.colspan;
        cellPlace.e.r = rowIndex;
        lastEc = cellPlace.e.c;
        mergeCellDataList.push(cellPlace);
        getChildMerges(children, cellPlace.s.c);
      } else {
        if (element.prop) {
          cellPlace.s.c = getCellPlaceSC(element.prop);
        } else {
          cellPlace.s.c = lastEc > lastColIndex ? lastEc + 1 : lastEc;
        }
        cellPlace.s.r = rowIndex;
        cellPlace.e.c = cellPlace.s.c;
        cellPlace.e.r = rowIndex + element.rowspan;
        lastEc = cellPlace.e.c;
        mergeCellDataList.push(cellPlace);
      }
    }
  }
  function getCellPlaceSC(prop) {
    if (prop) {
      let index = 0;
      for (let i = 0; i < havePropArr.length; i++) {
        let element = havePropArr[i];
        if (element.prop === prop) {
          index = i;
          break;
        }
      }
    } else {
      return 0;
    }
    return index;
  }
  getMerges(tableColumns);
  // log('每个表头单元格的行列起始信息:', JSON.stringify(mergeCellDataList));
  /** ----------------------------------> 4.表头单元格对应到excel中的位置排列(包括列数超出26处理)，比如A1 B1...AA1 AB1 AC1 <------------------------------------- */
  let l = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  let letter = l.split('');
  // 表头数量超过26个
  if (cellData.colCount > l.length) {
    for (let len = cellData.colCount - l.length, ln = parseInt(len / l.length), k = 0; k <= ln; k++) {
      for (let i = 0; i < Math.min(len, l.length); ) {
        letter.push(letter[k] + '' + letter[i++]);
      }
    }
  }
  /** ----------------------------------> 5.设置所有表头单元格对应excel的单元格位置信息 <------------------------------------- */
  // 表头单元格对应excel的位置 ，比如 A1 B1 C1 ...
  let headSheel = [];
  /**
   * 设置所有表头单元格对应excel的单元格位置信息
   * @param {Array} list 表头每个单元格的行列起始信息组成的数据
   */
  function getHeadcellPosition(list) {
    if (!list || !Array.isArray(list)) {
      return new Error('参数类型必须是数组');
    }
    for (let i = 0; i < list.length; i++) {
      let obj = list[i];
      headSheel.push(letter[obj.s.c] + (obj.s.r + 1)); // 根据单元格的起始行和起始列来对应excel的位置
    }
  }
  getHeadcellPosition(mergeCellDataList);
  // log('表头单元格对应excel的位置:', JSON.stringify(headSheel));
  /** ----------------------------------> 6.获取要导出的数据 <------------------------------------- */
  let data = [];
  let tableData = [];
  // 导出方式
  if (options.importType == 'page') {
    // updated by taoting1 on 20200211
    // 解决导出无法取得表格数据的情况
    tableData = tableRef.tabledata;
  } else if (options.importType == 'selected') {
    tableData = tableRef.selections;
  } else if (options.importType == 'service') {
    request({
      url: options.url,
      async: false,
      data: options.param,
      method: options.method ? options.method : 'GET',
    }).then((code, message, response) => {
      // 处理请求成功的情况
      if (options.jsonData) {
        let tmp = options.jsonData.split('.');
        let obj = response;
        for (let z = 0; z < tmp.length; z++) {
          if (!obj) {
            break;
          }
          obj = obj[tmp[z]];
        }
        tableData = obj;
      } else {
        tableData = response.data;
      }
    });
  }
  /** ----------------------------------> 7.列字段中对数据字典的翻译 <------------------------------------- */
  /**
   * 获取实际对应数据的列字段名称
   * @param {String} name 某一列的label属性对应的中文名
   * @return {String} 某一列的label属性对应的prop英文字段
   */
  // 存放表头最底层实际对应数据的列字段prop 比如['id','title','username'...]
  let headList_ = [];
  // 循环获取表头最底层实际对应数据的列字段prop存储于headList数组
  for (let j = 0; j < havePropArr.length; j++) {
    let key = havePropArr[j].prop;
    headList_[headList_.length] = key;
  }

  /**
   * 获取列的数据字典
   * @param {String} column 某一列的label属性对应的中文名
   * @param {Array} tableColumns 表头列数组
   * @return {String} 数据字典dataCode
   */
  let getColumnsDataCode = function (column, tableColumns) {
    let code;
    for (let i = 0; i < tableColumns.length; i++) {
      if (tableColumns[i].children && tableColumns[i].children instanceof Array == true) {
        code = getColumnsDataCode(column, tableColumns[i].children);
        if (code != undefined && code != null) {
          break;
        }
      } else {
        if (column == tableColumns[i].prop) {
          code = tableColumns[i].dataCode || '';
          break;
        }
      }
    }
    return code;
  };
  // 翻译数据字典字段
  for (let i = 0; i < tableData.length; i++) {
    let o = {};
    let rowData = tableData[i];
    for (let j = 0; j < headList_.length; j++) {
      let k = headList_[j];
      let code = getColumnsDataCode(k, tableColumns);
      if (code) {
        let val = lookup.convertKey(code, rowData[k]);
        o['' + k + ''] = val; // 如果配置了字典项则为翻译后的值
      } else {
        o['' + k + ''] = rowData[k]; // 没配置字典项为原始值
      }
    }
    for (let index = 0; index < haveOptions.length; index++) {
      let element = haveOptions[index];
      let value = getValByKey(rowData[element.prop], element.options);
      o[element.prop] = value;
    }
    data.push(o);
  }
  function getValByKey(key, options) {
    if (!key) {
      return;
    }
    if (!options || !Array.isArray(options)) {
      return key;
    }
    let val;
    for (let i = 0; i < options.length; i++) {
      let element = options[i];
      if (element.key === key) {
        val = element.value;
        break;
      }
    }
    return val;
  }
  // TODO 有待了解插入空对象原因，但是如果删掉会导致导出数据的前两条丢失
  for (let i = 1; i < collectionHtml.length; i++) {
    data.unshift({});
  }
  /** ----------------------------------> 8.导出相关数据构造 <------------------------------------- */
  let saveAs = function (obj, fileName) {
    // 当然可以自定义简单的下载文件实现方式
    let tmpa = document.createElement('a');
    tmpa.download = fileName || '下载';
    tmpa.href = URL.createObjectURL(obj); // 绑定a标签
    tmpa.click(); // 模拟点击实现下载
    setTimeout(function () {
      // 延时释放
      URL.revokeObjectURL(obj); // 用URL.revokeObjectURL()来释放这个object URL
    }, 100);
  };
  // 字符串转字符流
  let s2ab = function (s) {
    if (typeof ArrayBuffer !== 'undefined') {
      let buf = new ArrayBuffer(s.length);
      let view = new Uint8Array(buf);
      for (let i = 0; i < s.length; ++i) {
        view[i] = s.charCodeAt(i) & 0xff;
      }
      return buf;
    } else {
      let buf = new Array(s.length);
      for (let i = 0; i < s.length; ++i) {
        buf[i] = s.charCodeAt(i) & 0xff;
      }
      return buf;
    }
  };
  let wb = { SheetNames: ['Sheet1'], Sheets: {}, Props: {} };
  data = XLSX.utils.json_to_sheet(data);
  for (let i = 0; i < headSheel.length; i++) {
    data[headSheel[i]] = { t: 's', v: headLabel[i].label };
  }
  // 如果单元格是数字，将数字转换成字符串，防止导出后成为科学计数显示格式
  if (options.stringifyNum) {
    Object.keys(data).forEach((item) => {
      const cell = data[item];
      if (cell.t === 'n') {
        cell.t = 's';
        cell.v = cell.v.toString();
      }
    });
  }

  data['!merges'] = mergeCellDataList;
  wb.Sheets['Sheet1'] = data;
  let wopts = { bookType: 'xlsx', bookSST: true, type: 'binary' }; // 这里的数据是用来定义导出的格式类型
  let blob = new window.Blob([s2ab(XLSX.write(wb, wopts))], { type: 'application/octet-stream' });
  let filename = options.fileName + '.' + (wopts.bookType == 'biff2' ? 'xls' : wopts.bookType);
  let browser = getBrowserType();
  if (browser == 'IE') {
    window.navigator.msSaveBlob(blob, filename);
  } else {
    saveAs(blob, filename);
  }
  // 导出后置空
  tableRef = colums = tableColumns = collectionHtml = getColumnsDataCode = saveAs = s2ab = options = null;
}

/**
 * @description 获取机构名称
 */
export function getOrgName() {}
/**
 * @description 获取用户名称
 */
export function getUserName() {}

/**
 * @description 根据菜单 funcUrl 获取菜单数据
 * @param funcUrl 菜单funcUrl
 */
export function getMenuNode(funcUrl) {
  const menuList = storage.get(MENU_STOREOG_KEY) || [];
  return menuList.find((item) => {
    return `/${item.funcUrl}` === funcUrl;
  });
}

/**
 * @description 判断当前用户是否管理员，从缓存中获取当前用户所有角色，然后与固定值判断是否项匹配
 */
export function isAdmin() {
  const userInfo = sessionStore.get(USER_STORE_KEY) || {}; // 获取用户缓存信息
  const { additionals = {}, userCode = '' } = userInfo;
  const { authOrgRoles = [] } = additionals;
  if (ADMIN_ROLECODES.includes(userCode)) {
    return true;
  }
  if (authOrgRoles.length > 0) {
    for (let i = 0, l = authOrgRoles.length; i < l; i++) {
      if (ADMIN_ROLECODES.includes(authOrgRoles[i].roleCode)) {
        return true;
      }
    }
  }
  return false;
}

/**
 * 取消刷新动画帧函数
 * @param {*} id
 */
export function cancelAnimationFrame(id) {
  const cancelAnimationFrame = window.cancelAnimationFrame || window.clearTimeout;
  cancelAnimationFrame.call(window, id);
}

let prev = Date.now();

/**
 * 延迟器,优先使用系统自带API,根据不同系统刷新动画帧
 */
export function requestAnimationFrame(fn) {
  const requestAnimationFrame =
    window.requestAnimationFrame ||
    function (fn) {
      const curr = Date.now();
      const ms = Math.max(0, 16 - (curr - prev));
      const id = setTimeout(fn, ms);
      prev = curr + ms;
      return id;
    };
  return requestAnimationFrame.call(window, fn);
}

/**
 * 对手机号码进行脱敏处理
 * @param {*} mobileNo  手机号码
 */
export function mobileNoHide(mobileNo) {
  if (mobileNo != null && typeof mobileNo !== 'string') {
    mobileNo = mobileNo.toString();
  }
  if (!mobileNo) {
    return '';
  } else {
    let temp;
    let hideNumber = mobileNo.substring(3, mobileNo.length - 4);
    let star = '';
    for (let i = 0; i < hideNumber.length; i++) {
      star += '*';
    }
    if (mobileNo.length === 11) {
      temp = mobileNo.replace(hideNumber, star);
    } else {
      temp = mobileNo;
    }
  }
  return temp;
}

/**
 * @description 判断文件是否图片
 * @param {String} param 文件后缀
 * @returns 判断结果
 */
export function isPicture(ext = '') {
  return ['bmp', 'gif', 'svg', 'jpeg', 'png', 'jpg'].indexOf(ext.split('.').reverse()[0]) > -1;
}

/**
 * @description 判断文件是否视频
 * @param {String} str 文件类型
 * @returns 判断结果
 */
export function isVideo(ext = '') {
  return ['mp4', 'avi', 'rmvb', 'mov', '3gp', 'flv'].indexOf(ext.split('.').reverse()[0]) > -1;
}

/**
 * 检查字符串是否包含中文
 * @param {*} value 检查值
 * @returns {Boolean}
 */
export function strIsChn(value) {
  const reg = /[\u4E00-\u9FA5]/;
  return reg.test(value);
}

/**
 * 判断文字是否超过dom宽度 el:DOM元素
 */
export function textRange(el) {
  const textContent = el;
  const targetW = textContent.getBoundingClientRect().width;
  const range = document.createRange();
  range.setStart(textContent, 0);
  range.setEnd(textContent, textContent.childNodes.length);
  const rangeWidth = range.getBoundingClientRect().width;
  return rangeWidth > targetW;
}

/**
 * 根据key值将引入的数组进行去重
 * @param {*} key
 * @param {*} selArr 要引入的数据
 * @param {*} oriArr 原数据
 */
export function arrayUnrepeat(key, selArr, oriArr) {
  let arr = [];
  const keyArr = oriArr.map((item) => item[key]);
  for (let i = 0; i < selArr.length; i++) {
    if (keyArr.indexOf(selArr[i][key]) === -1) {
      arr.push(selArr[i]);
    }
  }
  return arr;
}

/**
 * 根据key值将引入的数组进行去重
 * @param {*} orgLevel 要判断的机构级别
 * 总行及下属部门: 1  分行及下属部门:  2  二级分行及下属部门:3  支行:  4   二级支行:5
 */
export function getLevelByOrgLevel(orgLevel) {
  let level = '';
  if (orgLevel === '1') {
    level = '1'; // 总行
  } else if (orgLevel === '2' || orgLevel === '3') {
    level = '2'; // 分行
  } else if (orgLevel === '4' || orgLevel === '5') {
    level = '3'; // 支行
  }
  return level;
}
/**
 * 数值向下取整
 * @param {*} num
 * @param {*} n
 * @returns
 */
export function numFloor(num, n) {
  if (num.toString().indexOf('.') > 0) {
    if (n) {
      let reg = eval('/^\\d+(?:\\.\\d{0,' + n + '})?/');
      num = Number(num.toString().match(reg)).toFixed(n); // 小数向下取小数n位
    } else {
      num = Number(num.toString().split('.')[0]); // 整数
    }
  }
  return num;
}
/**
 * 开始日期和结束日期比较
 * date 选择日期
 * compaDate 需要比较日期
 * message 错误提示信息
 * compMsg 比较日期提示信息
 * type 比较类型
 */
export function compaStrtToEndDate(date, message, compaDate, compMsg, type) {
  let exdate = '';
  let precompaDate = '';
  if (typeof date == 'object') {
    exdate = date.getTime();
  } else {
    exdate = new Date(date).getTime();
  }
  if (typeof compaDate == 'object') {
    precompaDate = compaDate.getTime();
  } else {
    precompaDate = new Date(compaDate).getTime();
  }
  if (
    (type == 'strt' && exdate <= precompaDate) ||
    (type == 'end' && exdate >= precompaDate) ||
    ((!compaDate || compaDate == '') && type == 'strt')
  ) {
    return true;
  } else {
    let tipsMsg = type == 'strt' ? '应该小于' : '应该大于';
    showMessage(message + tipsMsg + compMsg, 'error');
    return false;
  }
}

/**
 * 日期两者之间计算相差天数
 * strtDate 选择日期
 * endDate 需要比较日期
 */
export function diffDays(strtDate, endDate) {
  if (strtDate && endDate) {
    let diff = new Date(endDate) - new Date(strtDate);
    if (!diff) {
      return '';
    } else {
      let days = Math.round(diff / 1000 / 3600 / 24) + 1;
      return days;
    }
  } else {
    return '';
  }
}
/**
 * 日期两者之间计算相差小时数
 * strtDate 选择日期
 * endDate 需要比较日期
 */
export function diffHours(strtDate, endDate) {
  if (strtDate && endDate) {
    let diff = new Date(endDate) - new Date(strtDate);
    if (!diff && diff != '0') {
      return '0';
    } else {
      let days = Math.round(diff / 1000 / 3600);
      return days;
    }
  } else {
    return '';
  }
}
/**
 * 精准加法计算
 * @param {*} arg1
 * @param {*} arg2
 * @returns
 */
export function accAdd(arg1, arg2) {
  let r1, r2, m;
  try {
    r1 = arg1.toString().split('.')[1].length;
  } catch (e) {
    r1 = 0;
  }
  try {
    r2 = arg2.toString().split('.')[1].length;
  } catch (e) {
    r2 = 0;
  }
  m = Math.pow(10, Math.max(r1, r2));
  return (accMul(arg1, m) + accMul(arg2, m)) / m;
}
/**
 * 精准乘法法计算
 * @param {*} arg1
 * @param {*} arg2
 * @returns
 */
export function accMul(arg1, arg2) {
  let m = 0,
    s1 = arg1.toString(),
    s2 = arg2.toString();
  try {
    m += s1.split('.')[1].length;
  } catch (e) {}
  try {
    m += s2.split('.')[1].length;
  } catch (e) {}
  return (Number(s1.replace('.', '')) * Number(s2.replace('.', ''))) / Math.pow(10, m);
}
/**
 * 精准减法法计算
 * @param {*} arg1
 * @param {*} arg2
 * @returns
 */
export function accSub(arg1, arg2) {
  let r1, r2, m, n;
  try {
    r1 = arg1.toString().split('.')[1].length;
  } catch (e) {
    r1 = 0;
  }
  try {
    r2 = arg2.toString().split('.')[1].length;
  } catch (e) {
    r2 = 0;
  }
  m = Math.pow(10, Math.max(r1, r2));
  // last modify by deeka
  // 动态控制精度长度
  n = r1 >= r2 ? r1 : r2;
  return ((arg1 * m - arg2 * m) / m).toFixed(n);
}
/**
 * 精准除法计算
 * @param {*} arg1
 * @param {*} arg2
 * @returns
 */
export function accDiv(arg1, arg2) {
  let t1 = 0,
    t2 = 0,
    r1,
    r2;
  try {
    t1 = arg1.toString().split('.')[1].length;
  } catch (e) {}
  try {
    t2 = arg2.toString().split('.')[1].length;
  } catch (e) {}
  // with(Math) {
  r1 = Number(arg1.toString().replace('.', ''));
  r2 = Number(arg2.toString().replace('.', ''));
  return (r1 / r2) * Math.pow(10, t2 - t1);
  // }
}
// 跳转客户外部数据
export function toCustOutData(row) {
  if (row.cstTyp === '1' && row.source != 1) {
    // 对公
    // TODO 跳转天探系统
    showMessage('TODO 跳转天探系统', 'info');
  } else if (row.cstTyp === '2' || (row.cstTyp === '1' && row.source == 1)) {
    // 零售
    let pathName = '/custOutData_' + new Date().getTime();
    router.addRoute('dsamp-web/npam/dailyManage/custView/outData/index.vue', '客户外部数据信息', {}, pathName);
    router.push({
      path: pathName,
      query: { cstId: row.cstId, custName: row.custName, cstTyp: row.cstTyp, relaCertCode: row.relaCertCode },
    });
  } else {
    showMessage('该客户非对公、零售客户', 'warning');
  }
}
// 跳转借据详情
export function toIouDetailFn(query) {
  let path = 'dsamp-web/common/npam/iouInfo/index.vue';
  let title = '借据信息';
  let pathName = '/laonIouInfo_' + new Date().getTime();
  router.addRoute(path, title, {}, pathName);
  router.push({
    path: pathName,
    query: query,
    needBackHistory: true,
  });
}
/**
 * 债权引入确定时校验
 * 1. 线下贷款：只能引入同一个产品类别的借据。对公1 零售2
 * 2. 线上贷款：只能引入同一个产品名称的借据  公司线上3  零售线上6
 * 3. 线上贷款与线下贷款不能同时发起。
 * @param {*} arr 待引入选中的数组
 * @param {*} oriTableData 已经引入的列表数据(第一页或全部)
 * @returns
 */
export function validImportSameIou(arr, oriTableData) {
  // 获取已选择的借据
  let newArr = yufp.extend([], arr);
  let selectedIou = oriTableData.length > 0 ? oriTableData[0] : null;
  if (selectedIou) newArr.push(selectedIou);
  let bsinPlatArr = []; // 业务板块
  let prdTypArr = []; // 产品类别
  let bsinTypeArr = []; // 产品名称
  for (let i = 0; i < newArr.length; i++) {
    if (bsinPlatArr.indexOf(newArr[i].bizSct) === -1) bsinPlatArr.push(newArr[i].bizSct);
    if (prdTypArr.indexOf(newArr[i].prdTyp) === -1) prdTypArr.push(newArr[i].prdTyp);
    if (bsinTypeArr.indexOf(newArr[i].bsinType) === -1) bsinTypeArr.push(newArr[i].bsinType);
  }
  let onlyInline = bsinPlatArr.indexOf('3') > -1 || bsinPlatArr.indexOf('6') > -1; // 线上贷款：公司线上3  零售线上6
  let onlyOffline = bsinPlatArr.indexOf('1') > -1 || bsinPlatArr.indexOf('2') > -1; // 线下贷款：对公1 零售2
  // 同时存在线上线下
  if (onlyInline && onlyOffline) {
    showMessage('线上贷款与线下贷款不能同时发起', 'warning');
    return false;
  }
  // 仅线上
  if (onlyInline && !onlyOffline && prdTypArr.length > 1) {
    showMessage('线上贷款：只能引入同一个产品类别的借据', 'warning');
    return false;
  }
  // 仅线下
  if (!onlyInline && onlyOffline && bsinTypeArr.length > 1) {
    showMessage('线下贷款：只能引入同一个产品名称的借据', 'warning');
    return false;
  }
  return true;
}
// 跳转信用卡详情
export function toCardDetailFn(query) {
  let path = 'dsamp-web/common/npam/cardInfo/index.vue';
  let title = '信用卡信息';
  let pathName = '/laonIouInfo_' + new Date().getTime();
  router.addRoute(path, title, {}, pathName);
  router.push({
    path: pathName,
    query: query,
  });
}

/**
 * @description 渲染水印方法
 */
 export function renderWatermark() {
  if (frameConfig.watermark) {
    !window.watermark && import('@/utils/yufp.watermark');
    window.watermark && window.watermark.init();
  }
}

/**
 * @description 清除水印方法
 */
export function clearWatermark() {
  if (frameConfig.watermark) {
    window.watermark && window.watermark.clearWatermark();
  }
}
// 调用水印渲染
renderWatermark();