import ElementUI from 'element-ui';
/* 工具类 */
/**
 * @summary 获取数组对象成员某个字段的集合
 * @param {JSONArray} arrayObj 数组对象
 * @param {string} 对象的
 * @param {string} 分割符，默认中文'、'
 * @return {string} 字符串
 */
export const getFieldsFromArray = (aData, sField, sSplit = '、') => {
  let str = '';
  if (aData && aData.length > 0) {
    for (let item of aData) {
      if (item[sField]) {
        str += sSplit + item[sField];
      }
    }
  }
  if (str.length > 0) { str = str.substring(1) }
  return str;
};
/**
 * @summary delItemFormArrayObject 删除部分数组对象
 * @param {array} arrayObj 数组对象
 * @param {array} arrayObj 需要删除的对象
 * @param {string} attrName 比对的参数名（如ID）
 * @return {array} 新的数组对象
 */
export const delItemFormArrayObject = (arrayObj, arrayObj2, attrName) => {
  let aReturn = [];
  for (let item of arrayObj) {
    let f = true;
    for (let item2 of arrayObj2) {
      if (item[attrName] === item2[attrName]) {
        f = false;
      }
    }
    if (f) {
      aReturn.push(item);
    }
  }
  return aReturn;
};
/**
 * @summary 删除数组对象的某个成员（或添加成员）
 * @param {JSONArray} arrayObj 数组对象
 * @param {object} obj 需要删除的对象
 * @param {string} attrName 比对的参数名（如ID）
 * @return {JSONArray} 新的数组对象
 */
export const toggleJSONArray = (arrayObj = [], obj, attrName) => {
  let iIndex = -1;
  for (let i = 0; i < arrayObj.length; i++) {
    if (arrayObj[i][attrName] && arrayObj[i][attrName] === obj[attrName]) {
      iIndex = i;
      break;
    }
  }
  if (iIndex >= 0) {
    arrayObj.splice(iIndex, 1);
  } else {
    // arrayObj.splice(0, 0, obj);
    arrayObj.push(obj);
  }
  return arrayObj;
};
/**
 * @summary 根据时间及格式获取时间的字符串
 * @param {int} iDate 时间
 * @param {string} sFormat 格式，默认：yyyy-MM-dd HH:mm:ss
 * @return {string} 格式化后的日期字符串
 * @example
 *    formatDate(new Date(),'yyyy-MM-dd HH:mm:ss SSS');// 2017-6-6 11:11:11
 */
export const formatDate = (iDate, sFormat = 'yyyy-MM-dd HH:mm:ss') => {
  if (!iDate) { return ''; }
  let dDate = new Date(iDate);
  let year = dDate.getFullYear();// 年
  let month = dDate.getMonth() + 1;// 月
  if (month < 10) { month = '0' + month; }
  let date = dDate.getDate();// 日
  if (date < 10) { date = '0' + date; }
  let hour = dDate.getHours();// 时
  if (hour < 10) { hour = '0' + hour; }
  let minute = dDate.getMinutes();// 分
  if (minute < 10) { minute = '0' + minute; }
  let second = dDate.getSeconds();// 秒
  if (second < 10) { second = '0' + second; }
  let millisecond = dDate.getMilliseconds();// 毫秒
  if (sFormat.indexOf('yyyy') >= 0) { sFormat = sFormat.replace('yyyy', year + ''); }
  if (sFormat.indexOf('MM') >= 0) { sFormat = sFormat.replace('MM', month + ''); }
  if (sFormat.indexOf('dd') >= 0) { sFormat = sFormat.replace('dd', date + ''); }
  if (sFormat.indexOf('HH') >= 0) { sFormat = sFormat.replace('HH', hour + ''); }
  if (sFormat.indexOf('mm') >= 0) { sFormat = sFormat.replace('mm', minute + ''); }
  if (sFormat.indexOf('ss') >= 0) { sFormat = sFormat.replace('ss', second + ''); }
  if (sFormat.indexOf('SSS') >= 0) { sFormat = sFormat.replace('SSS', millisecond + ''); }
  return sFormat;
};
/**
 * @summary 根据时间字符串转化为时间对象
 * @param {string} dateStr 时间字符串，年月日分隔支持（- /）
 * @example
 *    convertDate('2017-11-11 11:11:111');
 */
export const convertDate = (dateStr) => {
  if (dateStr) {
    return new Date(dateStr.replace(/-/, '/'));
  } else {
    return '';
  }
};
/**
 * 转化时间
 * @param {String} str
 * @returns {String} 转化后的时间
 */
export const transDate = (str) => {
  if (!str) return '';
  let date = new Date(str)
  // 现在的时间-传入的时间 = 相差的时间（单位 = 毫秒）
  let time = new Date().getTime() - date.getTime();
  if (time < 0) {
    return '';
  } else if ((time / 1000 < 30)) {
    return '刚刚';
  } else if (time / 1000 < 60) {
    return parseInt((time / 1000)) + '秒前';
  } else if ((time / 60000) < 60) {
    return parseInt((time / 60000)) + '分钟前';
  } else if ((time / 3600000) < 24) {
    return parseInt(time / 3600000) + '小时前';
  } else if ((time / 86400000) < 31) {
    return parseInt(time / 86400000) + '天前';
  } else if ((time / 2592000000) < 12) {
    return parseInt(time / 2592000000) + '月前';
  } else {
    return parseInt(time / 31536000000) + '年前';
  }
};
/**
 * @summary 设置cookie
 * @param {string} name cookie名称
 * @param {string} value cookie值
 * @param {int} expires 保存时间(单位:小时)
 * @param {string} path
 * @param {string} domain
 * @param {string} secure
 */
export const setCookie = (name, value, expires, path, domain, secure) => {
  let str = name + '=' + encodeURIComponent(value);
  // if (expires > 0) {
  //   let date = new Date();
  //   date.setTime(date.getTime() + expires * 3600 * 1000);
  //   str += ';expires=' + date.toGMTString();
  // }
  if (path) { str += ';path=' + path; }
  if (domain) { str += ';domain=' + domain; }
  if (secure) { str += ';secure=' + secure; }
  document.cookie = str;
};
/**
 * @summary 读取cookie
 * @param {string} name cookie名称
 * @retrun {string} value cookie值
 * @example
 */
export const getCookie = (name) => {
  let start = document.cookie.indexOf(name + '=');
  if ((!start) && (name !== document.cookie.substring(0, name.length))) { return ''; }
  if (start === -1) { return ''; }
  let len = start + name.length + 1;
  let end = document.cookie.indexOf(';', len);
  if (end === -1) { end = document.cookie.length; }
  return decodeURIComponent(document.cookie.substring(len, end));
};
/**
 * 存储localStorage
 * @param {string} sName
 * @param {string} sCntent
 * @example setLocalStore('name', '测试');
 */
export const setLocalStore = (sName, sCntent) => {
  if (!sName) return;
  window.localStorage.setItem(sName, sCntent);
};

/**
 * 获取localStorage
 */
export const getLocalStore = name => {
  if (!name) return null;
  return window.localStorage.getItem(name);
};

// 过滤url中的参数
export const filterURL = (val, newVal) => {
  if (val !== null && typeof val !== 'undefined') {
    return val;
  } else {
    return newVal;
  }
};

/**
 *  @summary 获取B数组中存在A数组值的自身索引
 * @param {array} A 已存在数组对象
 * @param {array} B 待比较数组对象
 * @param {array} str 待比较数组的id
 * **/
export const compareArray = (A, B, str) => {
  let indexs = []; // 获取比较后的索引数组
  for (let i = 0; i < A.length; i++) {
    for (let j = 0; j < B.length; j++) {
      // console.log(A[i][str], B[j][str], A[i][str] === B[j][str]);
      if (A[i][str] === B[j][str]) {
        indexs.push(j);
        break;
      }
    }
  }
  return indexs
};

/**
 * @summary 删除数组对象的某个成员（或添加成员）
 * @param {array} arrayObj 数组对象
 * @param {object} obj 需要删除的对象
 * @param {string} attrName 比对的参数名（如ID）
 * @return {array} 新的数组对象
 */
export const removeOrAddEleFormArrayObj = (arrayObj = [], obj, attrName) => {
  let iIndex = -1;
  for (let i = 0; i < arrayObj.length; i++) {
    if (arrayObj[i][attrName] && arrayObj[i][attrName] === obj[attrName]) {
      iIndex = i;
      break;
    }
  }
  if (iIndex >= 0) {
    arrayObj.splice(iIndex, 1);
  } else {
    // arrayObj.splice(0, 0, obj);
    arrayObj.push(obj);
  }
  return arrayObj;
};

/**
 * @summary 字符串去空格
 * @param {string} str 字符串
 * @return {string} 去掉空格后的字符串
 */
export const trimStr = (str = '') => {
  return str.replace(/(^\s*)|(\s*$)/g, '');
};

/**
 * 千分表达式转换
 * @param num 要格式化的数字
 * @param n 保留小数位
 */
export const changeNum = (num, n) => {
  if (num === null || num === 'null' || num === undefined || num === 'undefined') { return ''; }
  if (isNaN(num)) { return num; }
  if (n) {
    num = Number(num);
    num.toFixed(n);
  }
  num = String(num);
  var re = /(-?\d+)(\d{3})/;
  while (re.test(num)) {
    num = num.replace(re, '$1,$2');
  }
  return num;
};

/**
 *  拼音首字母转换
 */
const strChineseFirstPY = ' ';

export const makePy = (str) => {
  if (typeof (str) !== 'string') {
    throw new Error(-1, '函数makePy需要字符串类型参数!');
  }
  var result = ''; // 保存中间结果的数组
  str = str.toString().trim()
  for (var i = 0, len = str.length; i < len; i++) {
    // 获得unicode码
    var ch = str.charAt(i);
    // 检查该unicode码是否在处理范围之内,在则返回该码对映汉字的拼音首字母,不在则调用其它函数处理
    result += checkCh(ch);
  }
  // result,返回所有可能的拼音首字母串数组
  return result
};
function checkCh (ch) {
  var uni = ch.codePointAt(0);
  // 如果不在汉字处理范围之内,返回原字符,也可以调用自己的处理函数
  if (uni > 40869 || uni < 19968) {
    return ch; // dealWithOthers(ch);
  }
  // (暂不做多音字处理) 检查是否是多音字,是按多音字处理,不是就直接在strChineseFirstPY字符串中找对应的首字母
  // return (oMultiDiff[uni]?oMultiDiff[uni]:(strChineseFirstPY.charAt(uni-19968)));
  return strChineseFirstPY.charAt(uni - 19968)
};
/**
 * @summary 上传文件转化为annex数组
 * @param {object} oUpload 上传文件对象
 * @param {string} idSqe 业务ID
 */
export const annexTranslateForUpload = (oUpload, idSqe) => {
  let aoImg = oUpload.images;
  let aoFile = oUpload.files;
  let returnArray = [];
  /*
   {
   'id_sqe': '20170620105934130084',
   'annex_no': '20170620105934130001',
   'annex_name': 'magazine-unlock-01-2.3.651-_32ba439c4cd94f89a4a89cba3e0a2eee.jpg',
   'annex_path': 'group1/M00/00/07/wKgBSVlIj2GAQi6WAATzNeU1dqU155.jpg',
   'is_image': '1',
   'annex_type': '.jpg',
   'annex_other_name': 'magazine-unlock-01-2.3.651-_32ba439c4cd94f89a4a89cba3e0a2eee'
   }
   */
  /*
   file对象格式：
   {
   'name':'/image-temp/20170804/346835header背景.png',
   'path':'MjAxNzA4MDQvMzQ2ODM1aGVhZGVy6IOM5pmvLnBuZw ==',
   'filename':'header背景.png',
   'filetime':'2017-08-07 11:16:09',
   'filetype':'.png'
   }
   */

  for (let i = 0; i < aoImg.length; i++) {
    let oimg = aoImg[i];
    if (typeof (oimg.path) === 'undefined') {
      oimg.path = oimg.annex_path
    }
    if (typeof (oimg.filetype) === 'undefined') {
      oimg.filetype = oimg.annex_type
    }
    /* let spath = oimg.path;
     if(spath && spath.indexOf('/')===0){ spath = spath.substring(1);} */
    returnArray.push({
      id_sqe: idSqe,
      name: oimg.name,
      annex_name: oimg.filename,
      annex_path: oimg.path,
      save_path: oimg.path,
      is_image: '1',
      is_img: '1',
      annex_type: oimg.filetype,
      annex_other_name: 'image'
    });
  }
  for (let j = 0; j < aoFile.length; j++) {
    let ofile = aoFile[j];
    if (typeof (ofile.path) === 'undefined') {
      ofile.path = ofile.annex_path
    }
    if (typeof (ofile.filetype) === 'undefined') {
      ofile.filetype = ofile.annex_type
    }
    returnArray.push({
      id_sqe: idSqe,
      name: ofile.name,
      annex_name: ofile.filename,
      annex_path: ofile.path,
      save_path: ofile.path,
      is_image: '0',
      is_img: '0',
      annex_type: ofile.filetype,
      annex_other_name: 'file'
    });
  }
  return returnArray;
};

// 导入excel
var wb; // 读取完成的数据
var rABS = false; // 是否将文件读取为二进制字符串
export const importExcel = (obj, callback) => {
  if (!obj.files) {
    return;
  }
  var f = obj.files[0];
  var reader = new FileReader();
  reader.onload = function (e) {
    var data = e.target.result;
    if (rABS) {
      wb = XLSX.read(btoa(fixdata(data)), { // 手动转化
        type: 'base64'
      });
    } else {
      wb = XLSX.read(data, {
        type: 'binary'
      });
    }
    // wb.SheetNames[0]是获取Sheets中第一个Sheet的名字
    //  wb.Sheets[Sheet名]获取第一个Sheet的数据
    callback(XLSX.utils.sheet_to_json(wb.Sheets[wb.SheetNames[0]]));
  };
  if (rABS) {
    reader.readAsArrayBuffer(f);
  } else {
    reader.readAsBinaryString(f);
  }
};

function fixdata (data) { // 文件流转BinaryString
  var o = '',
    l = 0,
    w = 10240;
  for (; l < data.byteLength / w; ++l) o += String.fromCharCode.apply(null, new Uint8Array(data.slice(l * w, l * w + w)));
  o += String.fromCharCode.apply(null, new Uint8Array(data.slice(l * w)));
  return o;
};

/**
 * @summary 内控模块使用，校验上、下限值的正确性
 * @param: min: 下限值
 * @param: max: 上限值
 * @param: len: 字符限制长度
 * @param: decimal: 小数位数
 * @return: Object 0：不弹出错误信息，1：只能填写正实数，最多保留四位小数！，2：数字的长度不能大于' + len + '位，3：下限值不能大于上限值
 * 如果只传了min没有传max，则为单个数字的校验
 * */
export const validOrder = (len, min, max, decimal) => {
  let obj = {
    state: '',
    msg: ''
  };
  let reg = /^(0|[1-9][0-9]*)(\.[0-9]{1,4})?$/;
  if (decimal) {
    let str = '^(0|[1-9][0-9]*)(\\.[0-9]{1,' + decimal + '})?$';
    reg = new RegExp(str);
  }
  if (len && min) {
    if (reg.test(min)) {
      // 判断数字的长度
      if (min.length > len) {
        obj.state = '2';
        obj.msg = '数字的长度不能大于' + len + '位';
        return obj;
      } else {
        if (max) {
          if (reg.test(max)) {
            // 上下限都有值，则比较大小
            if (max.length <= len) {
              // 长度符合要求，比较大小
              if (parseFloat(min) > parseFloat(max)) {
                // 下限值大于上限值，报错
                obj.state = '3';
                obj.msg = '下限值不能大于上限值';
                return obj;
              } else {
                // 两个数字都校验通过
                obj.state = '0';
                obj.msg = '';
                return obj;
              }
            } else {
              obj.state = '2';
              obj.msg = '数字的长度不能大于' + len + '位';
              return obj;
            }
          } else {
            obj.state = '1';
            obj.msg = '只能填写正实数，最多保留四位小数！';
            return obj;
          }
        } else {
          // 没有传第二个数字，则为单个数字的校验，这个时候已经证明参数min是一个正实数且长度不大于len，校验通过
          obj.state = '0';
          obj.msg = '';
          return obj;
        }
      }
    } else {
      obj.state = '1';
      obj.msg = '只能填写正实数，最多保留四位小数！';
      return obj;
    }
  }
};

/**
 * @summary 内控模块使用，校验上、下限值的正确性
 * @param: min: 下限值
 * @param: max: 上限值
 * @param: len: 字符限制长度
 * @param: decimal: 小数位数
 * @return: Object 0：不弹出错误信息，1：只能填写正实数，最多保留四位小数！，2：数字的长度不能大于' + len + '位，3：下限值不能大于上限值
 * 如果只传了min没有传max，则为单个数字的校验
 * */
export const validOrder2 = (len, min, max, decimal) => {
  let obj = {
    state: '',
    msg: ''
  };
  let reg = /^(0|[1-9][0-9]*)(\.[0-9]{1,7})?$/;
  if (decimal) {
    let str = '^(0|[1-9][0-9]*)(\\.[0-9]{1,' + decimal + '})?$';
    reg = new RegExp(str);
  }
  console.log('%c几个值', 'color:red', len, min, max, decimal);
  if (len && min) {
    if (reg.test(min)) {
      // 判断数字的长度
      if (min.length > len) {
        obj.state = '2';
        obj.msg = '数字的长度不能大于' + len + '位';
        return obj;
      } else {
        if (max) {
          if (reg.test(max)) {
            // 上下限都有值，则比较大小
            if (max.length <= len) {
              // 长度符合要求，比较大小
              if (parseFloat(min) > parseFloat(max)) {
                // 下限值大于上限值，报错
                obj.state = '3';
                obj.msg = '下限值不能大于上限值';
                return obj;
              } else {
                // 两个数字都校验通过
                obj.state = '0';
                obj.msg = '';
                return obj;
              }
            } else {
              obj.state = '2';
              obj.msg = '数字的长度不能大于' + len + '位';
              return obj;
            }
          } else {
            obj.state = '1';
            obj.msg = '只能填写正实数，最多保留七位小数！';
            return obj;
          }
        } else {
          // 没有传第二个数字，则为单个数字的校验，这个时候已经证明参数min是一个正实数且长度不大于len，校验通过
          obj.state = '0';
          obj.msg = '';
          return obj;
        }
      }
    } else {
      obj.state = '1';
      obj.msg = '只能填写正实数，最多保留七位小数！';
      return obj;
    }
  }
};

export const isStartEndDate = (startDate, endDate) => {
  let start = new Date(startDate);
  let end = new Date(endDate);
  if (start > end) {
    return true;
  }
  return false;
};

export const startEndate = (startDate, endDate) => {
  let startYear = new Date(startDate).getFullYear();
  let startMonth = new Date(startDate).getMonth();
  let startDay = new Date(startDate).getDate();
  let endYear = new Date(endDate).getFullYear();
  let endMonth = new Date(endDate).getMonth();
  let endDay = new Date(endDate).getDate();
  console.log(startYear, startMonth, startDay)
  console.log(endYear, endMonth, endDay)
  if (startYear > endYear) {
    return true
  } else if (startYear === endYear) {
    if (startMonth > endMonth) {
      return true;
    } else if (startMonth === endMonth) {
      if (startDay > endDay) {
        return true;
      } else {
        return false
      }
    } else {
      return false
    }
  } else {
    return false
  }
}

/**
 * @summary 比较一个对象前后的属性值是否相同
 * @param: before: 未改变的对象（备份）
 * @param: after: 可能改变了的对象
 * @return: Boolean true: 相同（未改变），false: 对象的属性值已经改变了
 * */
export const compareObj = (before, after) => {
  let flag = true;
  // 首先获取对象的所有属性
  let propList = Object.keys(before);
  for (let item of propList) {
    if (before[item] !== after[item]) {
      flag = false;
      break;
    }
  }
  return flag;
};
// 浮点加法
export const accAdd = function (arg1, arg2) {
  let r1, r2, m, c;
  try {
    r1 = arg1.toString().split('.')[1].length;
  } catch (e) {
    r1 = 0;
  }
  try {
    r2 = arg2.toString().split('.')[1].length;
  } catch (e) {
    r2 = 0;
  }
  c = Math.abs(r1 - r2);
  m = Math.pow(10, Math.max(r1, r2));
  if (c > 0) {
    let cm = Math.pow(10, c);
    if (r1 > r2) {
      arg1 = Number(arg1.toString().replace('.', ''));
      arg2 = Number(arg2.toString().replace('.', '')) * cm;
    } else {
      arg1 = Number(arg1.toString().replace('.', '')) * cm;
      arg2 = Number(arg2.toString().replace('.', ''));
    }
  } else {
    arg1 = Number(arg1.toString().replace('.', ''));
    arg2 = Number(arg2.toString().replace('.', ''));
  }
  return (arg1 + arg2) / m;
};

/*
 * 千分表达式转换
 * num 要格式化的数字 n 保留小数位
 */
export const formatNum = function (num, n) {
  if (!n) {
    n = 2;
  }
  if (num === null || num === 'null' || num === undefined || num === 'undefined') { return ''; }
  if (isNaN(num)) { return num; }
  let data = (num + '').split('.');
  num = data[0];
  if (n) {
    num = Number(num);
    num.toFixed(n);
  }
  num = String(num);
  var re = /(-?\d+)(\d{3})/;
  while (re.test(num)) {
    num = num.replace(re, '$1,$2');
    // console.log('num: ', num);
  }
  if (data[1] !== '' && data[1] !== null && data[1] !== undefined) {
    num = num + '.' + data[1];
  }
  return num;
};
/*
 * 数字修改，千分表达式转换
 * num 要格式化的数字 n 保留小数位，不够补0, 如果数据小数位大于n,则显示原数据小数。
*/
export const formatNum2 = function (num, n) {
  if (num === null || num === '' || num === undefined) {
    return ''
  }
  if (isNaN(num)) { return num; }
  let data = (num + '').split('.');
  let integer = data[0]
  let decimal = data[1]
  let decimal2 = ''
  let m = 0;
  if (typeof decimal !== 'undefined') {
    m = decimal.length;
    decimal2 = '.' + decimal;
  }
  let str = /^([1-9][0-9]*)$/
  if (n && str.test(n)) {
    num = Number(num);
    // num = num.toFixed(m > n ? m : n);
    num = num.toFixed(n);
    decimal2 = '.' + String(num).split('.')[1];
  }
  var re = /(-?\d+)(\d{3})/;
  while (re.test(integer)) {
    integer = integer.replace(re, '$1,$2');
  }
  return integer + decimal2;
};
/*
 *解析cookie值
 */
export const getUserName = function (str) {
  let arr = str.split(';');
  let arr1 = [];
  let obj = {};
  for (let item of arr) {
    arr1 = item.split('=');
    obj[arr1[0].trim()] = arr1[1].trim();
  }
  return obj;
};

/**
 * @summary: 设置表格选中行
 * @param: row: 需要设置为选中状态的行数据，为{}、null时默认选中第一行
 * @param: id: 表格的主键
 * @param: ref: 表格的ref
 * @param: data: 表格绑定的数据源
 * @return: 被设置为选中的表格行
 * */
export const commonCurrentRow = (row, id, ref, data) => {
  let _this = this;
  let index = 0;
  if (row && row[id]) {
    for (let i = 0; i < data.length; i++) {
      if (data[i][id] === row[id]) {
        index = i;
      }
    }
  }
  _this.$refs[ref].setCurrentRow(data[index]);
  return data[index];
}

// =============== wu 2018-07-28 ==================

/**
 * 生成树
 * @param {Array} arr 带上级ID的数组
 * @param {String} id ID字符串
 * @param {String} pid 上级ID字符串
 * @param {String} children 子标志名
 * @param {String} root 取哪一个节点ID的树
 * @returns {Array} 为rootId的树
 */
export const createTree = function (arr, id, pid, children, rootId) {
  let tree = [];
  //
  if (!(Object.prototype.toString.call(arr) === '[object Array]' && arr.length > 0)) {
    return tree;
  }
  //
  if (!id) id = 'id';
  if (!pid) pid = 'pid';
  if (!rootId && rootId !== null) rootId = '';
  if (!children) children = 'children';
  //
  let obj = {};
  //  清空原结构
  for (let item of arr) {
    delete item[children];
  }
  for (let item of arr) {
    if (!(children in item)) {
      item[children] = [];
    }
    obj[item[id]] = item;
    //
    if (Object.keys(obj).indexOf(item[pid] === null ? item[pid] : item[pid].toString()) > -1) {
      //  找到了
      obj[item[pid]][children].push(item);
    } else {
      //  没找到
      for (let obj of arr) {
        if (obj[id] === item[pid]) {
          if (!(children in obj)) {
            obj[children] = [];
          }
          obj[children].push(item);
        }
      }
    }
  }
  for (let id in obj) {
    if (obj[id][pid] === rootId) {
      tree.push(obj[id]);
    }
  }
  return tree;
}

/**
 * 递归树
 * @param {Array} tree 树数组
 * @param {String} children 子级属性名
 * @param {Function} fn 回调
 * @return void
 */
const fnDgTree = function (tree, children, fn) {
  if (!children) {
    children = 'children';
  }
  for (let i = 0; i < tree.length; i++) {
    fn(tree[i]);
    if (tree[i] && tree[i][children] && tree[i][children].length > 0) {
      fnDgTree(tree[i][children], children, fn);
    }
  }
}

export const dgTree = fnDgTree;

/**
 * 递归树 添加层级
 * @param {Array} tree 树数组
 * @param {String} children 子级属性名
 * @param {Function} fn 回调
 * @return void
 */
const fnDgTreeLevel = function (tree, children, fn, level) {
  if (!children) {
    children = 'children';
  }
  for (let i = 0; i < tree.length; i++) {
    tree[i].tempLevel = level;
    fn(tree[i]);
    if (tree[i] && tree[i][children] && tree[i][children].length > 0) {
      fnDgTreeLevel(tree[i][children], children, fn, (+level + 1));
    }
  }
}

export const dgTreeLevel = fnDgTreeLevel;

/**
 * 对象覆盖 忽略多余属性
 * @param {Object} obj1 基
 * @param {Object} obj2 覆盖
 */
export const objAssign = function (obj1, obj2) {
  if (!(typeof obj1 === 'object' && typeof obj2 === 'object')) {
    return {};
  }
  for (let i in obj1) {
    if (i in obj2) {
      obj1[i] = obj2[i];
    }
  }
  return obj1;
}

/**
 * 对数据进行分页，返回分页后的页数据
 * @param {Array} allItems 需要分页数据
 * @param {Number} index 页码 1页开始
 * @param {Number} size 每页条数
 * @returns {Array} 返回页数据数组
 */
export const allPagination = function (allItems, index, size) {
  if (!(Object.prototype.toString.call(allItems) === '[object Array]')) {
    return [];
  }
  index < 1 && (index = 1);
  let start = (index - 1) * size;
  let end = 1;
  if (size <= 1) {
    end = index * size;
  } else {
    end = index * size - 1;
  }
  return allItems.slice(start, end);
}
// =============== / wu 2018-07-28 ==================
/**
 * 判断是否位为数字
 * @param: arr: 要检测的数据集合,元素为{id: '数字'，text: '值对应的名称'}
 * @param：data：表格数据
 */
export const doCheckNumber = (arr) => {
  let isNotNum = false;
  let reg = /^(?:0|[1-9]\d*)(?:\.\d*[1-9])?$/;
  let noDecReg = /^[0-9]+[0-9]*$/
  for (let item of arr) {
    if (item.id) {
      if (item.noDec) {
        // console.log('是否是正数', (item.id).toString(), (item.id).toString().indexOf('.'))
        if ((item.id).toString().indexOf('.') > -1 || !noDecReg.test(Number(item.id))) {
          ElementUI.Message({ message: item.text + '只能是整数', type: 'warning', dangerouslyUseHTMLString: true })
          isNotNum = true
        }
      } else {
        if (!reg.test(Number(item.id))) {
          // this.$message.warning(item.text + '只能位数字')
          ElementUI.Message({ message: item.text + '只能是数字', type: 'warning', dangerouslyUseHTMLString: true })
          isNotNum = true
        }
      }
    }
  }
  return isNotNum
}
/**
 * 表格合计函数
 * @param: param elememt-ui表格合计函数默认参数
 * @param: prop: 表示要合计 数 的字段
 */
export const commonSummaries = function (param, prop = []) {
  // let _this = this
  const { columns, data } = param;
  const sums = [];
  columns.forEach((column, index) => {
      if (index === 0) {
          sums[index] = '' + data.length + '条';
      } else if (prop.includes(column.property)) {
          const values = data.map(item => Number(item[column.property]))
          if (!values.every(value => isNaN(value))) {
              sums[index] = values.reduce((prev, curr) => {
                  const value = Number(curr)
                  if (!isNaN(value)) {
                      // return prev + curr;
                      return floatComputed(prev, curr, '+');
                  } else {
                      return prev;
                  }
              }, 0)
          } else {
              sums[index] = 'N/A';
          }
      } else {
          sums[index] = '--';
      }
  })
  return sums;
}

function floatComputed (arg1, arg2, sign) {
  if (!arg1) {
    arg1 = 0;
  }
  if (!arg2) {
    arg2 = 0;
  }
  let val1 = arg1 + '';
  let val2 = arg2 + '';
  let rate = 1;
  let rate1 = 1;
  let rate2 = 1;
  if (val1.indexOf('.') < 0) {
    rate1 = 0;
  } else {
    rate1 = val1.length - val1.indexOf('.') - 1;
  }
  if (val2.indexOf('.') < 0) {
    rate2 = 0;
  } else {
    rate2 = val2.length - val2.indexOf('.') - 1;
  }
  rate = rate2;
  val2 = val2.replace('.', '');
  val1 = val1.replace('.', '');
  if (rate1 > rate2) {
    rate = rate1;
    for (let i = 0; i < rate1 - rate2; i++) {
      val2 = val2 + '0'
    }
  } else {
    for (let i = 0; i < rate2 - rate1; i++) {
      val1 = val1 + '0';
    }
  }
  let rateNum = Math.pow(10, rate);
  if (sign === '-') {
    return (Number(val1) - Number(val2)) / rateNum
  }
  if (sign === '+') {
    return (Number(val1) + Number(val2)) / rateNum
  }
  if (sign === '*') {
    return (Number(val1) * Number(val2)) / (rateNum * rateNum)
  }
  if (sign === '/') { // 默认保留4位
    let num = (Number(val1) / Number(val2)) + '';
    let numArr = num.split('.');
    if (numArr.length > 1) {
      if (numArr[1].length > 4) {
        num = (+num).toFixed(4);
      }
    }
    return num;
  }
  return null;
}
