sstt-archives-web/src/utils/common.js

let base = {
  isNull(p){
    return p == '' || p == undefined || p == null || p == 'undefined' || p == 'null';
  },
  isPhone(val) {
    return /^[1][3,4,5,6,7,8,9][0-9]{9}$/.test(val)
  },
  isDecimal(val) {
    return /(^[\-0-9][0-9]*(.[0-9]+)?)$/.test(val)
  },
  isNumber(val) {
    return /(^[\-0-9][0-9]*([0-9]+)?)$/.test(val)
  },
  isMail(val) {
    return /^(\w-*\.*)+@(\w-?)+(\.\w{2,})+$/.test(val)
  },
  isUrl(url) {
    return this.checkUrl(url)
  },
  containsVideoFormat(str) {
    // 定义包含常见视频格式的正则表达式
    const videoFormats = /\.(mp4|avi|mov|wmv|flv|mkv|webm|mpg|mpeg)$/i;

    // 使用正则表达式的test方法来检查字符串
    return videoFormats.test(str);
  },
  checkUrl(url) {
    // url= 协议://(ftp的登录信息)[IP|域名](:端口号)(/或?请求参数)
    var strRegex =
      '^((https|http|ftp)://)?' + // (https或http或ftp):// 可有可无
      "(([\\w_!~*'()\\.&=+$%-]+: )?[\\w_!~*'()\\.&=+$%-]+@)?" + // ftp的user@  可有可无
      '(([0-9]{1,3}\\.){3}[0-9]{1,3}' + // IP形式的URL- 3位数字.3位数字.3位数字.3位数字
      '|' + // 允许IP和DOMAIN（域名）
      '(localhost)|' + // 匹配localhost
      "([\\w_!~*'()-]+\\.)*" + // 域名- 至少一个[英文或数字_!~*\'()-]加上.
      '\\w+\\.' + // 一级域名 -英文或数字  加上.
      '[a-zA-Z]{1,6})' + // 顶级域名- 1-6位英文
      '(:[0-9]{1,5})?' + // 端口- :80 ,1-5位数字
      '((/?)|' + // url无参数结尾 - 斜杆或这没有
      "(/[\\w_!~*'()\\.;?:@&=+$,%#-]+)+/?)$" // 请求参数结尾- 英文或数字和[]内的各种字符
    var re = new RegExp(strRegex, 'i') // i不区分大小写
    // 将url做uri转码后再匹配，解除请求参数中的中文和空字符影响
    if (re.test(encodeURI(url))) {
      return true
    }
    return false
  },
  matchUrlIp(url, ip) { // url使用是否使用的当前ip
    if (!url || !ip) {
      return false
    }
    return url.indexOf(ip.replace('https://', '').replace('http://', '')) >= 0
  },
  getImgSrc(src, httpUrl) {
    if (this.isUrl(src)) {
      return src
    }
    if (httpUrl) {
      return httpUrl + src
    }
    return src
  },
  previewImg(src, httpUrl) { // 图片预览，目前只支持单图片预览
    if (src && !this.isUrl(src) && httpUrl) {
      if (src.substr(0, 1) == '/' && httpUrl.substr(httpUrl.length - 1, 1) == '/') {
        src = src.substr(1)
      }
      src = (httpUrl + src)
    }
    let id = 'vol-preview'
    let $div = document.getElementById(id)
    if (!$div) {
      $div = document.createElement('div')
      $div.setAttribute('id', 'vol-preview')
      let $mask = document.createElement('div')
      $mask.style.position = 'absolute'
      $mask.style.width = '100%'
      $mask.style.height = '100%'
      $mask.style.background = 'black'
      $mask.style.opacity = '0.6'
      $div.appendChild($mask)
      $div.style.position = 'fixed'
      $div.style.width = '100%'
      $div.style.height = '100%'
      // $div.style.overflow = "scroll";
      $div.style.top = 0
      $div.style['z-index'] = 9999999
      let $img = document.createElement('img')
      $img.setAttribute('class', 'vol-preview-img')
      $img.style.position = 'absolute'
      $img.style.top = '50%'
      $img.style.left = '50%'
      $img.style['max-width'] = '90%'
      $img.style['max-height'] = '90%'
      $img.style.transform = 'translate(-50%,-50%)'
      // $img.src = src;
      $img.setAttribute('src', src)
      $div.appendChild($img)
      $div.addEventListener('click', function() {
        this.style.display = 'none'
      })
      document.body.appendChild($div)
      return
    }
    let $img1 = document.body.appendChild($div).querySelector('.vol-preview-img')
    // img.src = src;
    $img1.setAttribute('src', src)
    $div.style.display = 'block'
  },
  // 下载文件 $element 标签, url完整url, fileName 文件名, header 以key/value传值
  // backGroundUrl 后台url，如果后台url直接从后台下载，其他全部通过点击a标签下载
  dowloadFile(url, fileName, header, backGroundUrl) {
    if (!url) return alert('此文件没有url不能下载')
    if (!this.isUrl(url)) {
      url = backGroundUrl + url
    }
    window.open(url)

    // let $element = document.getElementById('dowonloadfile-a');
    // if (!$element) {
    //   $element = document.createElement('a');
    //   $element.setAttribute("id", "dowonloadfile-a");
    //   document.body.append($element);
    // }
    // //url为一个完整的地址，并且不是后台api的地址，直接点击a标签下载
    // // if (this.isUrl(url) && !this.matchUrlIp(url, backGroundUrl)) {
    // // $element.href = url;
    // // $element.click();
    // // return;
    // //  }

    // if (!this.isUrl(url)) {
    //   if (!this.isUrl(backGroundUrl + url)) {
    //     console.log("文件路径不正确");
    //     alert('文件路径不正确')
    //     return;
    //   }
    //   url = backGroundUrl + url;
    // }
    // $element.href = url;
    // $element.click();

    // //通过后台api服务器下载
    // if (!this.isUrl(url)) {
    //   if (!this.isUrl(backGroundUrl + url)) {
    //     alert('当前下载的文件url【' + url + '】不正确')
    //     return;
    //   }
    //   url = backGroundUrl + url;
    // }
    // let xmlResquest = new XMLHttpRequest();
    // xmlResquest.open("GET", url, true);
    // xmlResquest.setRequestHeader("Content-type", "application/json");
    // if (header && typeof header == 'object') {
    //   for (const key in header) {
    //     xmlResquest.setRequestHeader(
    //       key,
    //       header[key]
    //     );
    //   }
    // }

    // xmlResquest.responseType = "blob";
    // xmlResquest.onload = function (oEvent) {
    //   if (xmlResquest.status != 200) {
    //     return alert('没有下载到此文件的信息')
    //   }
    //   let content = xmlResquest.response;
    //   $element.download = fileName;
    //   let blob = new Blob([content]);
    //   $element.href = URL.createObjectURL(blob);
    //   $element.click();
    // };
    // xmlResquest.send();
  },
  downloadImg(data) {
    if (!data.url || !data.callback || typeof data.callback !== 'function') {
      return
    }
    // url, backGroundUrl, header, callback
    if (this.isUrl(data.url) && !this.matchUrlIp(data.url, data.backGroundUrl)) {
      return data.url
    }
    // 通过后台api服务器下载
    if (!this.isUrl(data.url)) {
      if (!this.isUrl(data.backGroundUrl + data.url)) {
        return
      }
      data.url = data.backGroundUrl + data.url
    }
    var xmlResquest = new XMLHttpRequest()
    xmlResquest.open('get', data.url, true)
    xmlResquest.responseType = 'blob'
    xmlResquest.setRequestHeader('Content-Type', 'application/json')
    if (data.header && typeof data.header === 'object') {
      for (const key in data.header) {
        xmlResquest.setRequestHeader(
          key,
          data.header[key]
        )
      }
    }
    xmlResquest.onload = function() {
      if (this.status == 200) {
        var blob = this.response
        callback(window.URL.createObjectURL(blob))
      }
    }
    xmlResquest.send()
  },
  // 2020.06.01增加通用方法，将普通对象转换为tree结构
  // data数据格式[
  //     { name: 'tree1', id: 1, parentId: 0 },
  //     { name: 'tree2', id: 2, parentId: 0 }]

  // 1、id与parentId这两个字段必须有
  // 2、树形tree需要注意Id与parentId循环依赖的问题
  // 3、callback每次生成一新的节点的时回调的方法

  convertTree(data, callback) {
    var treeIds = []
    var root_data = []
    data.forEach(x => {
      if (!x.children) {
        x.children = []
      }
      if (!x.hidden && x.id !== undefined && x.id !== x.parentId && !data.some(s => {
          return x.parentId == s.id
        })) {
        x.isRoot = true
        callback && callback(x, data, true, treeIds)
        root_data.push(x)
        getTree(x.id, x, data, callback, treeIds)
      }
    })
    var exceptionNodes = data.filter(f => {
      return treeIds.indexOf(f.id) == -1 && !f.hidden
    })

    root_data.push(...exceptionNodes)
    return root_data
  },
  getTreeAllParent(id, data) { // 获取某个节点的所有父节点信息2020.11.01
    var nodes = []
    if (!(data instanceof Array)) {
      return nodes
    }

    var _child = data.find(x => {
      return x.id === id
    })
    if (!_child) {
      return []
    }
    nodes.push(_child)
    var _parentIds = [_child.parentId]
    for (let index = 0; index < _parentIds.length; index++) {
      var _node = data.find(x => {
        return x.id === _parentIds[index] && x.id !== x.parentId
      })
      if (!_node) {
        return nodes
      }
      _parentIds.push(_node.parentId)
      nodes.unshift(_node)
    }
    return nodes
  },
  //深拷贝数据
  deepCopy(data) {
    //string,number,bool,null,undefined,symbol
    //object,array,date
    if (data && typeof data === "object") {
      //针对函数的拷贝
      if (typeof data === "function") {
        let tempFunc = data.bind(null);
        tempFunc.prototype = this.deepCopy(data.prototype);
        return tempFunc;
      }

      switch (Object.prototype.toString.call(data)) {
        case "[object String]":
          return data.toString();
        case "[object Number]":
          return Number(data.toString());
        case "[object Boolean]":
          return Boolean(data.toString());
        case "[object Date]":
          return new Date(data.getTime());
        case "[object Array]":
          let arr = [];
          for (let i = 0; i < data.length; i++) {
            arr[i] = this.deepCopy(data[i]);
          }
          return arr;

          //js自带对象或用户自定义类实例
        case "[object Object]":
          let obj = {};
          for (let key in data) {
            //会遍历原型链上的属性方法，可以用hasOwnProperty来控制 （obj.hasOwnProperty(prop)
            obj[key] = this.deepCopy(data[key]);
          }
          return obj;
      }
    } else {
      //string,number,bool,null,undefined,symbol
      return data;
    }
  },
  //  按顺序把接口返回值 赋给 form
  requestToForm(requestObj, form) {
    // 获取a对象中属性的顺序和值
    let aKeys = Object.keys(form);
    let aValues = aKeys.map(key => form[key]);

    // 遍历b对象，将属性等于a中属性值的对象深拷贝给a中的相应属性
    for (let i = 0; i < aKeys.length; i++) {
      let key = aKeys[i];
      let value = aValues[i];
      if (requestObj[key] === value) {
        // 深拷贝对象
        Object.assign(form, {
          [key]: this.deepCopy(requestObj[key])
        });
      }
    }
    // 遍历b对象，将b中独有的属性按照a的顺序插入到a中
    for (let key in requestObj) {
      if (!form[key]) {
        // 深拷贝属性值
        Object.assign(form, {
          [key]: this.deepCopy(requestObj[key])
        });
      }
    }
    return form
  },
  // 根据pid 重组树形结构
  buildTree(flatData) {
    // 创建一个映射表，用于存储每个 id 对应的数据项
    const idMap = {};
    flatData.forEach(item => {
      idMap[item.id] = item;
    });
    // 创建根节点集合
    const rootNodes = [];

    flatData.forEach(item => {
      // 如果没有父节点，则将该项添加到根节点集合中
      if (parseInt(item.pid) === 0) {
        rootNodes.push(item);
      } else {
        // 否则，将该项添加到父节点的 children 数组中
        if(idMap[item.pid]){
          const parent = idMap[item.pid];
          // console.log("par",parent)
          if (!parent.hasOwnProperty('children')) {
            parent.children = [];
          }
          parent.children.push(item);
        }else{
          rootNodes.push(item);
        }

      }
    });
    return rootNodes;
  },
 findNodesById(nodes, targetId) {
   let result = [];

   // 遍历每个节点
   nodes.forEach(node => {
     // 如果当前节点的ID匹配，添加到结果数组
     if (node.id == targetId) {
       result.push(node);
     }
     // 如果节点有子节点，递归查找
     if (node.children && node.children.length > 0) {
       const childNodes = this.findNodesById(node.children, targetId);
       result = result.concat(childNodes);
     }
   });

   return result;
 }


}
export default base

// 2020.06.01增加通用方法，将普通对象转换为tree结构
function getTree(id, node, data, callback, treeIds) {
  if (treeIds.indexOf(id) == -1) {
    treeIds.push(id)
  }
  data.forEach(x => {
    if (!x.hidden && x.parentId == id) {
      if (!node.children) node.children = []
      callback && callback(x, node, false)
      node.children.push(x)
      getTree(x.id, x, data, callback, treeIds)
    }
  })
}