WMS_IAC_FE/PC/UI.WinIn.FasterZ.Inventory/src/utils/index.js

/**
 * Created by PanJiaChen on 16/11/18.
 */
 import {fileStorage, getPageList } from '@/api/wms-api'
 import store from '@/store'
 
 /**
  * @param {string} url
  * @returns {Object}
  */
 export function getQueryObject(url) {
   url = url == null ? window.location.href : url
   const search = url.substring(url.lastIndexOf('?') + 1)
   const obj = {}
   const reg = /([^?&=]+)=([^?&=]*)/g
   search.replace(reg, (rs, $1, $2) => {
     const name = decodeURIComponent($1)
     let val = decodeURIComponent($2)
     val = String(val)
     obj[name] = val
     return rs
   })
   return obj
 }
 
 // 返回utf8字符串的字节长度
 /**
  * @param {string} input value
  * @returns {number} output value
  */
 export function byteLength(str) {
   // returns the byte length of an utf8 string
   let s = str.length
   for (var i = str.length - 1; i >= 0; i--) {
     const code = str.charCodeAt(i)
     if (code > 0x7f && code <= 0x7ff) s++
     else if (code > 0x7ff && code <= 0xffff) s += 2
     if (code >= 0xDC00 && code <= 0xDFFF) i--
   }
   return s
 }
 
 /**
  * @param {Array} actual
  * @returns {Array}
  */
 export function cleanArray(actual) {
   const newArray = []
   for (let i = 0; i < actual.length; i++) {
     if (actual[i]) {
       newArray.push(actual[i])
     }
   }
   return newArray
 }
 
 /**
  * @param {Object} json
  * @returns {Array}
  */
 export function param(json) {
   if (!json) return ''
   return cleanArray(
     Object.keys(json).map(key => {
       if (json[key] === undefined) return ''
       return encodeURIComponent(key) + '=' + encodeURIComponent(json[key])
     })
   ).join('&')
 }
 
 /**
  * @param {string} url
  * @returns {Object}
  */
 export function param2Obj(url) {
   const search = decodeURIComponent(url.split('?')[1]).replace(/\+/g, ' ')
   if (!search) {
     return {}
   }
   const obj = {}
   const searchArr = search.split('&')
   searchArr.forEach(v => {
     const index = v.indexOf('=')
     if (index !== -1) {
       const name = v.substring(0, index)
       const val = v.substring(index + 1, v.length)
       obj[name] = val
     }
   })
   return obj
 }
 
 /**
  * @param {string} val
  * @returns {string}
  */
 export function html2Text(val) {
   const div = document.createElement('div')
   div.innerHTML = val
   return div.textContent || div.innerText
 }
 
 /**
  * Merges two objects, giving the last one precedence
  * @param {Object} target
  * @param {(Object|Array)} source
  * @returns {Object}
  */
 export function objectMerge(target, source) {
   if (typeof target !== 'object') {
     target = {}
   }
   if (Array.isArray(source)) {
     return source.slice()
   }
   Object.keys(source).forEach(property => {
     const sourceProperty = source[property]
     if (typeof sourceProperty === 'object') {
       target[property] = objectMerge(target[property], sourceProperty)
     } else {
       target[property] = sourceProperty
     }
   })
   return target
 }
 
 /**
  * @param {HTMLElement} element
  * @param {string} className
  */
 // export function toggleClass(element, className) {
 //   if (!element || !className) {
 //     return
 //   }
 //   let classString = element.className
 //   const nameIndex = classString.indexOf(className)
 //   if (nameIndex === -1) {
 //     classString += '' + className
 //   } else {
 //     classString =
 //       classString.substr(0, nameIndex) +
 //       classString.substr(nameIndex + className.length)
 //   }
 //   element.className = classString
 // }
 
 /**
  * @param {Function} func
  * @param {number} wait
  * @param {boolean} immediate
  * @return {*}
  */
 export function debounce(func, wait, immediate) {
   let timeout, args, context, timestamp, result
   // console.log('我在防抖函数里面')
   const later = function () {
     // 据上一次触发时间间隔
     const last = +new Date() - timestamp
 
     // 上次被包装函数被调用时间间隔 last 小于设定时间间隔 wait
     if (last < wait && last > 0) {
       timeout = setTimeout(later, wait - last)
     } else {
       timeout = null
       // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用
       if (!immediate) {
         result = func.apply(context, args)
         if (!timeout) context = args = null
       }
     }
   }
 
   return function (...args) {
     context = this
     timestamp = +new Date()
     const callNow = immediate && !timeout
     // 如果延时不存在，重新设定延时
     if (!timeout) timeout = setTimeout(later, wait)
     if (callNow) {
       result = func.apply(context, args)
       context = args = null
     }
 
     return result
   }
 }
 
 /**
  * This is just a simple version of deep copy
  * Has a lot of edge cases bug
  * If you want to use a perfect deep copy, use lodash's _.cloneDeep
  * @param {Object} source
  * @returns {Object}
  */
 export function deepClone(source) {
   if (!source && typeof source !== 'object') {
     throw new Error('error arguments', 'deepClone')
   }
   const targetObj = source.constructor === Array ? [] : {}
   Object.keys(source).forEach(keys => {
     if (source[keys] && typeof source[keys] === 'object') {
       targetObj[keys] = deepClone(source[keys])
     } else {
       targetObj[keys] = source[keys]
     }
   })
   return targetObj
 }
 
 /**
  * @param {Array} arr
  * @returns {Array}
  */
 export function uniqueArr(arr) {
   return Array.from(new Set(arr))
 }
 
 /**
  * @returns {string}
  */
 export function createUniqueString() {
   const timestamp = +new Date() + ''
   const randomNum = parseInt((1 + Math.random()) * 65536) + ''
   return (+(randomNum + timestamp)).toString(32)
 }
 
 /**
  * Check if an element has a class
  * @param {HTMLElement} elm
  * @param {string} cls
  * @returns {boolean}
  */
 export function hasClass(ele, cls) {
   return !!ele.className.match(new RegExp('(\\s|^)' + cls + '(\\s|$)'))
 }
 
 /**
  * Add class to element
  * @param {HTMLElement} elm
  * @param {string} cls
  */
 export function addClass(ele, cls) {
   if (!hasClass(ele, cls)) ele.className += ' ' + cls
 }
 
 /**
  * Remove class from element
  * @param {HTMLElement} elm
  * @param {string} cls
  */
 export function removeClass(ele, cls) {
   if (hasClass(ele, cls)) {
     const reg = new RegExp('(\\s|^)' + cls + '(\\s|$)')
     ele.className = ele.className.replace(reg, ' ')
   }
 }
 
 //返回
 export function Enum(status, index, prop) {
   let _no_text = '无'
   if(!status)return _no_text
   if (index != undefined) { //如果传入的是index
     if (prop === 'color') {
       const domColor = status[index] ? status[index][prop] : ""
       return 'color:' + domColor
     } else {
       const dom = status[index] ? status[index][prop] : _no_text
       return dom
     }
   } else {
     return prop ? "" : Object.values(status)
   }
 }
 
 // 判断是否存在某个父级元素，层级不定
 /**
  * @param {*} obj 当前节点，如点击事件返回的e.target
  * @param {*} searchName 要查找是否存在的父级节点class
  * @returns 
  */
 export function getParentNode(obj,searchName) {
   let node = obj;
   let ofDiv = true;
   while (ofDiv) {
     if(!node){
       ofDiv = false;
     }
     if (node && node.parentNode && String(node.parentNode.className).includes(searchName)) { 
       node = node.parentNode;
       ofDiv = false;
     }else if (node && String(node.className).includes(searchName)) {
       node = null;
       ofDiv = false;
     } else {
       node = node && node.parentNode ? node.parentNode : null;
     }
   }
   return node
 }
 
 // 获取图片详情弹窗模式的图片数据格式
 export function getImgsDetailPopData(row,sucess,faild) {
   let imgsrcList = []
   JSON.parse(row.inspectPhotoJson).forEach(item => {
     fileStorage({blobName: item.FileKey}).then(res => {
       var byteString = atob(res.bytes)
       var arrayBuffer = new ArrayBuffer(byteString.length) // 创建缓冲数组
       var intArray = new Uint8Array(arrayBuffer) // 创建视图
       for (var i = 0; i < byteString.length; i++) {
         intArray[i] = byteString.charCodeAt(i)
       }
       const blob = new Blob([intArray], { type: '' })
       imgsrcList.push(window.URL.createObjectURL(blob))
       if(sucess)sucess()
     }).catch(err => {
       console.log(err)
       if(faild)faild()
     })
   })
   return imgsrcList
 }
 
 // 匹配正则返回值
 /** 具体参数详细，可参照README.md的[表单组件补充:currenForm]说明
  * @param {*} type      需要匹配的正则类型
  * @param {*} defaultValue     当前传入值（即需要校验值）
  * @param {*} fixedNum  如果type为pointNumber，需要保留小数点后的位数
  * @returns 
  */
 export function getMatchRegConformValue(type,defaultValue,fixedNum){
   let value = defaultValue ? String(defaultValue) : ''
   let _conformValue = ""
   switch(type){
     // 正整数
     case "number":
       _conformValue=value.replace(/[^\d]/g,'');
       break;
 
     // 数字+带小数点，只能输入一个小数点
     case "pointNumber":
       //小数点后保留位数
       let _fixed = fixedNum ? Number(fixedNum) : 100
       let reg = new RegExp(`\\d+\\.?\\d{0,${_fixed}}`);
       let _match = String(value).match(reg)
       _conformValue = _match ? _match[0] : _match
       break;
 
     // 数字+字母
     case "numberLetter":
       _conformValue=value.replace(/[^\a-\z\A-\Z0-9]/g,'');
       break;
       
     // 字母
     case "letter":
       _conformValue=value.replace(/[^a-zA-Z]/g,'');
       break;
 
     // 字母+中文
     case "letterCn":
       _conformValue=value.replace(/[\d]/g,'');
       break;
 
     // 数字+字母+横杠(-)
     case "numberLetterBar":
       _conformValue=value.replace(/[^\a-\z\A-\Z0-9\-]/g,'');
       break;
   }
   return _conformValue
 }
 
 // 字典格式化数据结构
 export function dictFormatData() {
   return new Promise((resolve,reject) => {
     let rs = []
     let childRs = {}
     let param = {
       maxResultCount: 1000,
       condition: {
           filters: []
       },
       sorting: "",
       skipCount: 0
     }
     getPageList(param, 'basedata/dict', true).then(res => {
       res.items.forEach(item => {
         childRs[item.code] = {}
         item.items.forEach( itemValue => {
           childRs[item.code][itemValue.code] = {
             label: itemValue.name,
             value: itemValue.code
           }
         })
         rs.push(childRs)
         childRs = {}
       })
       resolve(rs)
     }).catch(err => {
       console.log(err)
       reject(err)
     })
   })
 }
 
 // 像接口传参时候需要补充.0000000 否则会报错情况下转义
 export function initDataToHttpFormat (date) {
   return date ? date + '.0000000' : undefined
 }
 
 // 新建浏览器标签页面
 export function createNewTabs (url) {
   window.open(url, "_blank")
 }
 
 // faster-new
 // 转义及读取api接口返回的表头信息 
 export function zhApiColumnsLable (data,list) {
    let _list = list ? list : store.getters.columZHList
    return _list ? _list[data] : data
 }
 
 // 首字母转换 type='Lower'(小写，默认) Upper（大写）
 export function firstWordSizeChange (str,type='Lower') {
   switch(type){
     case 'Lower':
       return str.substring(0,1).toLowerCase() + str.substring(1,str.length);
       
     case 'Upper':
       return str.substring(0,1).toUpperCase() + str.substring(1,str.length);
     
   }
 }