Merge remote-tracking branch 'origin/dev' into dev

gaoluyang

2025-02-20 61116c35fda12264fda46211dcad45e27df8e2f8

Merge remote-tracking branch 'origin/dev' into dev

 package.json

@@ -85,7 +85,8 @@
    "sass-loader": "10.1.1",
    "script-ext-html-webpack-plugin": "2.1.5",
    "svg-sprite-loader": "5.1.1",
    "vue-template-compiler": "2.6.12"
    "vue-template-compiler": "2.6.12",
    "worker-loader": "^3.0.8"
  },
  "engines": {
    "node": ">=8.9",

 src/DataWorker.worker.js

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,160 @@
// æ­¤çº¿ç¨‹ä¸ºæ•°æ®é‡‡é›†çº¿ç¨‹

// ä¿å­˜æ•°æ®
// æ•°æ®é‡‡é›†ä¿¡æ¯
let dataAcquisitionInfo = null;
// æ•°æ®åˆ—表
let list = null;
// ä¼ é€’到主线程的数据
let result = {
  method:'',
  value:null
}
// ä¼˜åŒ–数采较多数据时--记录数采项目的Id数组，目的是取最后一个数采项目，传到主线程进行批量的数据采集保存
let arrSpecial = []
// æŽ¥æ”¶ä¸»çº¿ç¨‹ä¼ é€’过来的数据
self.onmessage = function(event) {
  const data = JSON.parse(event.data);
  dataAcquisitionInfo = data.dataAcquisitionInfo;
  list = data.list;
  // console.log(111,dataAcquisitionInfo)
  arrSpecial = []
  // å¤„理数据
  handleData()
}

function handleData(){
  // éåŽ†æ•°æ®åˆ—表
  list.forEach((item,index)=>{
    let num = 0;
    let str = ''
    item.forEach(m=>{
      if(m.v.ps&&(m.v.ps.value=='检验子项'||m.v.ps.value=='检验项'||m.v.ps.value=='检验项分类')){
        if(m.v.ps&&m.v.ps.value=='检验项分类'){
          if(num==0){
            num++
            str = m.v.v+','
          }
        }
        if(m.v.ps&&m.v.ps.value=='检验项'){
          if(num==1){
            str = str+m.v.v + ','
            num++
          } else {
            str = m.v.v+','
            num++
          }
        }
        if(m.v.ps&&m.v.ps.value=='检验子项'){
          str = str+m.v.v
        }
        // ä¸Šé¢åœ¨è®°å½•æ£€éªŒé¡¹+检验子项的名称，如果数采包含检验项+检验子项的数据，则执行
        if(dataAcquisitionInfo[str]){
          let num = 0;//该检验项对应检验值的个数，用用判断最多有多少个检验值，如果多次采集超过了该个数，则赋值给最后一个检验值
          list[index].forEach(n=>{
            if(n.v.ps&&n.v.ps.value&&typeof n.v.ps.value == 'string'&&n.v.ps.value.includes('检验值')){
              num++
            }
          })
          list[index].forEach((n,i)=>{
            if(n.v.ps&&n.v.ps.value&&typeof n.v.ps.value == 'string'&&n.v.ps.value.includes('检验值')){
              let arr = n.v.ps.value.split('值')
              if(Array.isArray(dataAcquisitionInfo[str].value)){
                // å¦‚果数据源为数组，则执行
                for (let i = 0; i < dataAcquisitionInfo[str].value.length; i++) {
                  if(i+1==arr[1]){
                    // èµ‹å€¼æ•°é‡‡ä¼˜åŒ–检验项列表
                    arrSpecial.push(n.i)
                    setTimeout(()=>{
                      let num0 = 0
                      if(n.v.ct&&n.v.ct.fa&&typeof n.v.ct.fa == 'string'&&n.v.ct.fa.includes('.')){
                        // ä¿ç•™æ¨¡æ¿é…ç½®çš„小数点位数
                        let str0 = n.v.ct.fa.split('.')[1]
                        num0 = str0.length
                        n.v.v = dataAcquisitionInfo[str].value[i]?Number(dataAcquisitionInfo[str].value[i]).toFixed(num0):dataAcquisitionInfo[str].value[i]
                      }else{
                        // ç›´æŽ¥èµ‹å€¼
                        n.v.v = dataAcquisitionInfo[str].value[i]
                      }
                      // ä¼ é€’给主线程
                      result = {
                        method:'changeInput',
                        value:{
                          list:list,
                          n:n
                        }
                      }
                      self.postMessage(JSON.stringify(result))
                    },2000)
                  }
                }
              }else{
                // å¦‚果数据源为字符或数字，则执行
                if(arr[1] ==dataAcquisitionInfo[str].frequency){
                  // å¦‚果数采次数等于检验值序号，则赋值给当前检验值
                  arrSpecial.push(n.i)
                  setTimeout(()=>{
                    let num0 = 0
                    if(n.v.ct&&n.v.ct.fa&&typeof n.v.ct.fa == 'string'&&n.v.ct.fa.includes('.')){
                      // ä¿ç•™æ¨¡æ¿é…ç½®çš„小数点位数
                      let str0 = n.v.ct.fa.split('.')[1]
                      num0 = str0.length
                      n.v.v = dataAcquisitionInfo[str].value?Number(dataAcquisitionInfo[str].value).toFixed(num0):dataAcquisitionInfo[str].value
                    }else{
                      // ç›´æŽ¥èµ‹å€¼
                      n.v.v = dataAcquisitionInfo[str].value
                    }
                    // ä¼ é€’给主线程
                    result = {
                      method:'changeInput',
                      value:{
                        list:list,
                        n:n
                      }
                    }
                    self.postMessage(JSON.stringify(result))
                  },2000)
                }else if(Number(dataAcquisitionInfo[str].frequency)>num){
                  // å¦‚果数采次数大于检验值序号，则赋值给最后一个检验值
                  if(n.v.ps.value.includes(num)){
                    arrSpecial.push(n.i)
                    setTimeout(()=>{
                      let num0 = 0
                      if(n.v.ct&&n.v.ct.fa&&typeof n.v.ct.fa == 'string'&&n.v.ct.fa.includes('.')){
                        // ä¿ç•™æ¨¡æ¿é…ç½®çš„小数点位数
                        let str0 = n.v.ct.fa.split('.')[1]
                        num0 = str0.length
                        n.v.v = dataAcquisitionInfo[str].value?Number(dataAcquisitionInfo[str].value).toFixed(num0):dataAcquisitionInfo[str].value
                      }else{
                        // ç›´æŽ¥èµ‹å€¼
                        n.v.v = dataAcquisitionInfo[str].value
                      }
                      // ä¼ é€’给主线程
                      result = {
                        method:'changeInput',
                        value:{
                          list:list,
                          n:n
                        }
                      }
                      self.postMessage(JSON.stringify(result))
                    },2000)
                  }
                }
              }
            }
          })
        }
      }
    })
  })
  // if(arrSpecial[arrSpecial.length-1]){
  //   //优化数采较多数据时-记录最后一个检验项的id，用于后续处理
  //   setTimeout(()=>{
  //     result = {
  //       getDataTypeId:arrSpecial[arrSpecial.length-1],
  //     }
  //     self.postMessage(JSON.stringify(result))
  //   },0)
  // }
}

 src/InspectionWorker.worker.js

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,2352 @@
// å¤šçº¿ç¨‹é‡Œé¢éœ€è¦ä¿å­˜çš„数据
let code = "";
// è¡¨æ ¼æ•°æ®ï¼ˆæ¸²æŸ“）
let tableList = null;
// æ–¹æ³•åˆ—表
let excelMethodList = [];
// excel坐标比较列表
let comparisonList = [];
// å½“前样品信息
let currentSample = {};
// å½“前项目：检测中心、装备电缆
let PROJECT = "";
// å¥—管
let bushing = "";
// å¤šçº¿ç¨‹ä¼ é€’到主线程的数据
let result = {
  method: "",
  value: null,
};

let modelType = "";

// ä¿å­˜æ—¶ä¼ åˆ°åŽç«¯å‚æ•°
let param = null;
// å½“前的模板
let currentTable = "";
// ä¼˜åŒ–数采较多数据时-记录最后一个检验项的id
let getDataTypeId = null;
//当前检验项
let currentInsItem = null;
// æŽ¥æ”¶åˆ°ä¸»çº¿ç¨‹å¤„理逻辑的消息
self.onmessage = function (event) {
  console.log(2222, event);
  // ä¿å­˜ä¸»çº¿ç¨‹ä¼ è¿‡æ¥çš„值
  const data = JSON.parse(event.data);
  if (currentTable != data.currentTable) {
    // æ£€éªŒæ¨¡æ¿æ”¹å˜åŽéœ€è¦åˆ·æ–°è¡¨æ ¼
    tableList = data.tableList;
  }
  currentTable = data.currentTable;
  if (data.type && data.type == "saveData") {
    // æ›´æ–°è¡¨æ ¼æ•°æ®å’Œä¼ é€’到后端的参数
    tableList = data.tableList;
    param = data.param;
    return;
  }
  if (data.bushing && data.bushing != bushing && data.type == "saveData") {
    // æ›´æ–°è¡¨æ ¼æ•°æ®ã€ä¼ é€’到后端的参数和套管数据
    tableList = data.tableList;
    param = data.param;
    bushing = data.bushing;
    return;
  }
  modelType = data.modelType;
  code = data.code;
  if (data.getDataTypeId) {
    // è®°å½• ä¼˜åŒ–数采较多数据时-记录最后一个检验项的id
    getDataTypeId = data.getDataTypeId;
  } else {
    getDataTypeId = null;
  }
  if (tableList) {
    // å¦‚果表格数据存在，则更新当前修改检验项的表格数据
    let str = code.split("-");
    let r = str[1];
    let c = str[2];
    tableList[0].arr.forEach((item, index) => {
      item.forEach((m, i) => {
        if (m.c == c && m.r == r) {
          tableList[0].arr[index] = data.tableList[0].arr[index];
        }
      });
    });
  } else {
    // å¦‚果初始化表格数据不存在，直接赋值
    tableList = data.tableList;
  }
  if (param) {
    // å¦‚果传递到后端的参数存在，则更新当前修改检验项的传递到后端的参数
    let str = code.split("-");
    let pId = str[3];
    param[pId] = data.param[pId];
  } else {
    // åˆå§‹åŒ–传递到后端的参数
    param = data.param;
  }
  if (data.currentInsItem) {
    currentInsItem = data.currentInsItem;
  }
  // æ›´æ–°æ–¹æ³•åˆ—表、坐标比较列表、当前样品信息、项目
  excelMethodList = JSON.parse(JSON.stringify(data.excelMethodList));
  comparisonList = JSON.parse(JSON.stringify(data.comparisonList));
  currentSample = JSON.parse(JSON.stringify(data.currentSample));
  PROJECT = data.PROJECT;
  // æ‰§è¡Œè®¡ç®—方法
  changeInput("", code);
};

function changeInput(m, code) {
  let str = code.split("-");
  let r = str[1]; //当前行
  let c = str[2]; //当前列
  let id = str[0];
  let pId = str[3]; //当前检验项id，param[pId]为当前检验项的所有值，包含：过程值insValue、计算值comValue、设备编码equipValue、设备名称equipName、最终值resValue、结论insResult
  var list = []; //一个双层数组，里面保存有当前页面渲染的所有数据
  // èµ‹å€¼å½“前模板的表格数据
  for (let a in tableList) {
    if (tableList[a].templateId == id) {
      list = tableList[a].arr;
      break;
    }
  }
  let isToExponential = ""; //是否为科学计数法
  let list2 = []; //一个数组，里面保存有当前检验项的所有参数值
  let isPoint = ""; //是否为小数点
  let inputType = null;
  let currentInsItemId = "";
  let isSave = "true";
  // å¾ªçŽ¯æ‰€æœ‰excel方法，找到当前行、列的检验项，如果此单元格（r,c）是某个excel方法里面的参数，则执行此方法
  const index = excelMethodList.findIndex((item) => item.r == r);
  excelMethodList.forEach((item) => {
    inputType =
      item.valueList &&
      item.valueList.length > 0 &&
      item.valueList.find((m) => m.r == r && m.c == c);
    // item.valueList  æ˜¯å½“前excel方法的参数列表，找到当前填入的值是否是参数
    if (
      item.valueList &&
      item.valueList.length > 0 &&
      item.valueList.find((m) => m.r == r && m.c == c)
    ) {
      isSave = "false";
      // å¦‚果是，则定义一个参数的对象集合，用于保存当前excel方法参数的值
      var comValue = {};
      item.valueList.forEach((a) => {
        list.forEach((b) => {
          if (b[0].r == a.r) {
            b.forEach((c) => {
              if (c.c == a.c) {
                // èŽ·å–当前参数的Execl行坐标(ABCD)等等
                var tableCode = "";
                for (var d in comparisonList) {
                  if (c.c == comparisonList[d].value) {
                    tableCode = comparisonList[d].label;
                    break;
                  }
                }
                list2.push(c.v.v);
                // ç»„装参数的对象集合并赋值，列如{A3:12,B4:15}
                if (
                  getInspectionValueType(item.i) == 1 &&
                  !isNaN(parseFloat(c.v.v))
                ) {
                  // å¦‚果是数字输入框
                  let n = String(c.v.v);
                  if (n.includes("/")) {
                    // å¦‚果是分数，则赋值
                    comValue[tableCode + (c.r + 1)] = c.v.v;
                  } else {
                    comValue[tableCode + (c.r + 1)] = parseFloat(c.v.v);
                  }
                } else {
                  // å¦‚果是文本、下拉框等等
                  comValue[tableCode + (c.r + 1)] = c.v.v;
                }
              }
            });
          }
        });
      });
      // å¦‚果此excel方法是结论判断方法，则执行此方法
      // console.log('item.v.ps.value---', item.v.ps.value)
      if (item.v.ps != undefined && item.v.ps.value == "结论") {
        try {
          if (currentSample.insProduct.find((m) => m.id == item.i)) {
            // å¦‚果当前检验项是产品检验项，则执行此方法，找到此检验项的要求值
            let ask = currentSample.insProduct.find((m) => m.id == item.i).ask
              ? currentSample.insProduct
                  .find((m) => m.id == item.i)
                  .ask.split("&")
              : null;
            // èŽ·å–当前结论的参数，也就是当前检验项的最终值
            let res = Object.values(comValue)[0];
            if (typeof res == "string" && res.includes(">")) {
              res = res.replace(">", "");
            }
            if (typeof res == "string" && res.includes("≤")) {
              res = res.replace("≤", "");
            }
            if (typeof res == "string" && res.includes("≥")) {
              res = res.replace("≥", "");
            }
            if (typeof res == "string" && res.includes("<")) {
              res = res.replace("<", "");
            }
            if (typeof res == "string" && res.includes("＞")) {
              res = res.replace("＞", "");
            }
            if (typeof res == "string" && res.includes("＜")) {
              res = res.replace("＜", "");
            }
            if (
              typeof res == "string" &&
              (res === "断裂" || res === "脆化" || res === "断裂脆化")
            ) {
              item.v.v = 0;
              list.forEach((a) => {
                if (a[0].r == item.r) {
                  for (let b = 0; b < a.length; b++) {
                    if (a[b].c == item.c) {
                      a[b].v.v = 0;
                      break;
                    }
                  }
                }
              });
            }
            let comp = [];
            // åˆ¤æ–­å½“前结论的参数（当前检验项的最终值）是否为空，如果为空，则直接赋值
            if (
              res === "" ||
              res === null ||
              res === undefined ||
              res === "Infinity"
            ) {
              item.v.v = null;
              list.forEach((a) => {
                if (a[0].r == item.r) {
                  for (let b = 0; b < a.length; b++) {
                    if (a[b].c == item.c) {
                      a[b].v.v = null;
                      break;
                    }
                  }
                }
              });
            } else {
              // å¦‚果不为空，则判断当前结论就需要进行判断
              //要求值为-，/，—，则结论设置为不判定，结论赋值为3
              if (
                ask == null ||
                ask[0] == "-" ||
                ask[0] == "/" ||
                ask[0] == "—"
              ) {
                item.v.v = 3;
                list.forEach((a) => {
                  if (a[0].r == item.r) {
                    for (let b = 0; b < a.length; b++) {
                      if (a[b].c == item.c) {
                        a[b].v.v = 3;
                        break;
                      }
                    }
                  }
                });
              } else {
                // è¦æ±‚值不为-，/，—，则进行判断
                if (ask) {
                  // å¾ªçŽ¯è¦æ±‚值列表，判断当前结论的参数是否符合要求
                  comp = ask.map((m, i) => {
                    // å¦‚果要求值包含=，则判断当前结论的参数是否等于要求值，
                    // ä»¥ä¸‹åˆ¤æ–­åŸºæœ¬ä¸€è‡´ï¼Œåªæ˜¯åˆ¤æ–­ç±»åž‹ä¸ä¸€æ ·ï¼Œå°±ä¸åšæ³¨é‡Šäº†
                    if (m.includes("=")) {
                      // å¤„理要求值
                      let str = handleFraction(m.split("=")[1]);
                      if (typeof res == "string" && typeof str == "string") {
                        // å¦‚果要求值和当前结论的参数都是字符串，则执行
                        if (res.includes("/")) {
                          // å¦‚果结论的参数是分数，则判断
                          if (m.includes("/")) {
                            // å¦‚果要求值是分数，则判断
                            return eval(res) == eval(str);
                          } else {
                            // å¦‚果要求值不是分数，则判断
                            return handleMoreParam(res, m.split("=")[1], "=");
                          }
                        } else {
                          // å¦‚果结论的参数不是分数，则判断
                          return (
                            res.trim().replace(/[.,。、；：'";?？“，]/g, "") ==
                            str.trim().replace(/[.,。、；：'";?？“，]/g, "")
                          );
                        }
                      } else {
                        // å¦‚果要求值和当前结论的参数有一个是数字，则执行
                        return eval(res) == eval(str);
                      }
                    } else if (m.includes("≥")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split("≥")[1]);
                          return eval(res) >= eval(str);
                        } else {
                          return handleMoreParam(res, m.split("≥")[1], "≥");
                        }
                      } else {
                        let str = handleFraction(m.split("≥")[1]);
                        return eval(res) >= eval(str);
                      }
                    } else if (m.includes("≤")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split("≤")[1]);
                          return eval(res) <= eval(str);
                        } else {
                          return handleMoreParam(res, m.split("≤")[1], "≤");
                        }
                      } else {
                        let str = handleFraction(m.split("≤")[1]);
                        if (typeof str == "string" && str.includes("A")) {
                          str = str.replace("A", "");
                        }
                        if (typeof str == "string" && str.includes("D")) {
                          str = str.replace("D", "");
                        }
                        if (typeof res == "string" && res.includes("A")) {
                          res = res.replace("A", "");
                        }
                        if (typeof res == "string" && res.includes("D")) {
                          res = res.replace("D", "");
                        }
                        return eval(res) <= eval(str);
                      }
                    } else if (m.includes("<")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split("<")[1]);
                          return eval(res) < eval(str);
                        } else {
                          return handleMoreParam(res, m.split("<")[1], "<");
                        }
                      } else {
                        let str = handleFraction(m.split("<")[1]);
                        return eval(res) < eval(str);
                      }
                    } else if (m.includes(">")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split(">")[1]);
                          return eval(res) > eval(str);
                        } else {
                          return handleMoreParam(res, m.split(">")[1], ">");
                        }
                      } else {
                        let str = handleFraction(m.split(">")[1]);
                        return eval(res) > eval(str);
                      }
                    } else if (m.includes("~")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let k = m.split("~");
                          return (
                            eval(res) >= eval(handleFraction(k[0])) &&
                            eval(res) <= eval(handleFraction(k[1]))
                          );
                        } else {
                          return handleMoreParam(res, m, "~");
                        }
                      } else {
                        let k = m.split("~");
                        return (
                          eval(res) >= eval(handleFraction(k[0])) &&
                          eval(res) <= eval(handleFraction(k[1]))
                        );
                      }
                    } else if (m.includes("-")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let k = m.split("-");
                          return (
                            eval(res) >= eval(handleFraction(k[0])) &&
                            eval(res) <= eval(handleFraction(k[1]))
                          );
                        } else {
                          return handleMoreParam(res, m, "-");
                        }
                      } else {
                        let k = m.split("-");
                        return (
                          eval(res) >= eval(handleFraction(k[0])) &&
                          eval(res) <= eval(handleFraction(k[1]))
                        );
                      }
                    } else if (m.includes("±")) {
                      if (modelType.includes("φ-")) {
                        if (m.indexOf("±") == 0) {
                          m =
                            modelType.substring(modelType.indexOf("-") + 1) + m;
                        }
                      }
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let k = m.split("±");
                          return (
                            eval(res) >=
                              eval(
                                handleFraction(k[0]) - handleFraction(k[1])
                              ) &&
                            eval(res) <=
                              eval(
                                Number(handleFraction(k[0])) +
                                  Number(handleFraction(k[1]))
                              )
                          );
                        } else {
                          return handleMoreParam(res, m, "±");
                        }
                      } else {
                        let k = m.split("±");
                        return (
                          eval(res) >=
                            eval(handleFraction(k[0]) - handleFraction(k[1])) &&
                          eval(res) <=
                            eval(
                              Number(handleFraction(k[0])) +
                                Number(handleFraction(k[1]))
                            )
                        );
                      }
                    } else if (m.includes("＞")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split("＞")[1]);
                          return eval(res) > eval(str);
                        } else {
                          return handleMoreParam(res, m.split("＞")[1], ">");
                        }
                      } else {
                        let str = handleFraction(m.split("＞")[1]);
                        return eval(res) > eval(str);
                      }
                    } else if (m.includes("＜")) {
                      if (typeof res == "string" && res.includes("/")) {
                        if (m.includes("/")) {
                          let str = handleFraction(m.split("＜")[1]);
                          return eval(res) < eval(str);
                        } else {
                          return handleMoreParam(res, m.split("＜")[1], "<");
                        }
                      } else {
                        let str = handleFraction(m.split("＜")[1]);
                        return eval(res) < eval(str);
                      }
                    }
                  });
                }
                // å¦‚果要求值的每个条件都符合，则给结论赋值为1，合格
                if (comp.every((m) => m)) {
                  item.v.v = 1;
                  list.forEach((a) => {
                    if (a[0].r == item.r) {
                      for (let b = 0; b < a.length; b++) {
                        if (a[b].c == item.c) {
                          a[b].v.v = 1;
                          break;
                        }
                      }
                    }
                  });
                } else {
                  // å¦åˆ™ç»™ç»“论赋值为0，不合格
                  item.v.v = 0;
                  list.forEach((a) => {
                    if (a[0].r == item.r) {
                      for (let b = 0; b < a.length; b++) {
                        if (a[b].c == item.c) {
                          a[b].v.v = 0;
                          break;
                        }
                      }
                    }
                  });
                }
              }
            }
            let getDataType0 = false;
            // ä¼˜åŒ–数采较多数据时-记录最后一个检验项的id，如果当前检验项的id与记录的id相同，则多传一个参数到主线程，进行数据保存，否则数采就不进行保存
            if (item.i == getDataTypeId) {
              getDataType0 = true;
            }
            // èµ‹å€¼ä¼ é€’到主线程的数据，method：saveInsContext表示此消息需要保存数据
            currentInsItemId = item.i;
            // èµ‹å€¼ä¼ é€’到主线程的数据，method：saveInsContext表示此消息需要保存数据
            result = {
              method: "saveInsContext",
              value: {
                tableList, // è¡¨æ ¼æ•°æ®
                param: getParam(), //传给后端的参数
                getDataTypeId: getDataTypeId,
                currentInsItemId: item.i,
              },
            };
            // å‘消息给主线程
            self.postMessage(JSON.stringify(result));
          }
        } catch (error) {
          console.log("error---", error);
        }
      } else {
        // å¦‚果是函数方法，则执行此方法
        let comResult = ""; //初始化计算结果
        try {
          if (getInspectionValueType(item.i) == 1) {
            // å¦‚果检验值类型是数字输入框
            let tell = currentSample.insProduct.find((m) => m.id == item.i).tell
              ? currentSample.insProduct
                  .find((m) => m.id == item.i)
                  .tell.split("&")
              : null;
            isPoint =
              tell &&
              tell.length > 0 &&
              typeof tell[0] == "string" &&
              tell[0].includes("/") &&
              tell[0] !== "/"; // è£…备电缆--判断要求值是否为分数
            const inspectionItemClass = currentSample.insProduct.find(
              (m) => m.id == item.i
            ).inspectionItemClass; // æ£€éªŒé¡¹åˆ†ç±»
            const inspectionItem = currentSample.insProduct.find(
              (m) => m.id == item.i
            ).inspectionItem; // æ£€éªŒé¡¹
            const inspectionItemSubclass = currentSample.insProduct.find(
              (m) => m.id == item.i
            ).inspectionItemSubclass; // æ£€éªŒå­é¡¹
            let isHaveSymbol = false;
            let symbol = "";
            for (var a in comValue) {
              if (
                typeof comValue[a] == "string" &&
                (comValue[a].includes(">") ||
                  comValue[a].includes("≤") ||
                  comValue[a].includes("<") ||
                  comValue[a].includes("≥") ||
                  comValue[a].includes("＜") ||
                  comValue[a].includes("＞"))
              ) {
                if (comValue[a].includes(">")) {
                  symbol = ">";
                } else if (comValue[a].includes("≤")) {
                  symbol = "≤";
                } else if (comValue[a].includes("≥")) {
                  symbol = "≥";
                } else if (comValue[a].includes("＜")) {
                  symbol = "＜";
                } else if (comValue[a].includes("＞")) {
                  symbol = "＞";
                } else {
                  symbol = "<";
                }
                isHaveSymbol = true;
                break;
              }
            }
            // æ ¹æ®è¾“入的数值，进行计算
            comResult = compute(item.v.f.replace(/=/g, " "), comValue, isPoint);
            // æ£€éªŒé¡¹ä¸ºå¯†åº¦æ—¶ï¼Œæ ¹æ®è¦æ±‚值的小数位改变最终值的小数位
            if (inspectionItem == "密度") {
              const str = "" + tell;
              const indexOfDecimal = str.indexOf(".");
              if (indexOfDecimal > -1) {
                const length = str.length - indexOfDecimal - 1;
                comResult = comResult.toFixed(length);
              }
            } else if (
              inspectionItemClass == "外护套机械物理性能" &&
              inspectionItem == "在IRM 902矿物油中浸泡后" &&
              (inspectionItemSubclass == "断裂伸长率变化率" ||
                inspectionItemSubclass == "抗张强度变化率")
            ) {
              comResult = Math.round(comResult).toFixed(0);
            } else if (
              typeof comResult == "string" &&
              (comResult.includes("断裂") || comResult.includes("脆化"))
            ) {
              comResult = comResult + "";
            }
            if (inspectionItem === "邵氏硬度" && tell[0].includes("A")) {
              // è¦æ±‚值如果有包含字母，最终结果要展示出字母
              comResult = comResult + "A";
            }
            if (
              inspectionItemClass === "绝缘机械物理性能" &&
              inspectionItem === "弯曲性能" &&
              inspectionItemSubclass === "最小弯曲半径" &&
              tell[0].includes("D")
            ) {
              // è¦æ±‚值如果有包含字母，最终结果要展示出字母
              comResult = comResult + "D";
            }
            if (isHaveSymbol) {
              comResult = symbol + comResult;
            }
            let list3 = list2.map((item) => item + "");
            // åˆ¤æ–­å¡«çš„检验值是否为科学计数法，如果为科学计数法，则进行转化
            isToExponential = list3.some(
              (val) => val.includes("e+") || val.includes("e-")
            );
            if (isToExponential) {
              let num2 = new Big(comResult);
              comResult = num2.toExponential(1);
            }
          } else {
            // å¦‚果检验值类型是文本输入框、下拉框
            let valueList = [];
            // å¤„理excel函数参数列表
            item.valueList.forEach((a) => {
              valueList.push({
                name: `${comparisonList.find((e) => e.value == a.c).label}${
                  a.r + 1
                }`,
                value: 0,
              });
            });
            // ç»™excel函数参数赋文本值
            for (var a in comValue) {
              valueList.forEach((b) => {
                if (b.name == a) {
                  b.value = comValue[a];
                }
              });
            }
            // è®¡ç®—公式，去掉excel函数的等号，并替换参数，列如：=A1  å˜æˆ A1 å˜æˆ â€˜æ–‡æœ¬è¾“入的值’
            let str = item.v.f.replace(/=/g, " ");
            valueList.forEach((b) => {
              str = str.replace(b.name, b.value);
            });
            // è®¡ç®—结果赋值
            comResult = str;
          }
        } catch (error) {
          console.log("error---", error);
        }
        try {
          // å¾ªçŽ¯è¡¨æ ¼æ•°æ®ï¼Œç»™è¡¨æ ¼æ•°æ®è¿›è¡Œèµ‹å€¼
          list.forEach((a) => {
            if (a[0].r == item.r && comResult !== "") {
              // åˆ¤æ–­å½“前行是否为当前检验项所在行，如果为当前行，则给表格数据赋值
              for (var b in a) {
                if (a[b].c == item.c) {
                  try {
                    if (comResult == 0) {
                      // åˆ¤æ–­è®¡ç®—结果是否为0，如果为0，则给表格数据赋值为0
                      a[b].v.v = 0;
                    } else if (
                      a[b].v.ct &&
                      a[b].v.ct.fa &&
                      typeof a[b].v.ct.fa == "string" &&
                      a[b].v.ct.fa.includes(".")
                    ) {
                      // åˆ¤æ–­å½“前单元格是否保留小数点，如果为保留小数点，则给表格数据赋值为保留小数点，这个是根据模板配置小数点来的
                      let num = 0;
                      let str = a[b].v.ct.fa.split(".")[1];
                      num = str.length;
                      a[b].v.v = comResult
                        ? Number(comResult).toFixed(num)
                        : comResult;
                    } else if (
                      typeof comResult == "string" &&
                      (comResult.includes("e+") || comResult.includes("e-"))
                    ) {
                      // åˆ¤æ–­è®¡ç®—结果是否为科学计数法，如果为科学计数法，则给表格数据赋值为科学计数法
                      a[b].v.v = comResult;
                    } else {
                      const inspectionItem = currentSample.insProduct.find(
                        (m) => m.id == item.i
                      ).inspectionItem;
                      // åˆ¤æ–­è®¡ç®—结果是否为数字，如果为数字，则给表格数据赋值为数字
                      if (inspectionItem == "铜线电阻率ρ20最大值") {
                        let val = parseFloat(Number(comResult).toFixed(5));
                        a[b].v.v = isNaN(val) ? comResult : val;
                      } else {
                        let val = parseFloat(Number(comResult).toFixed(3));
                        a[b].v.v = isNaN(val) ? comResult : val;
                      }
                    }
                  } catch (error) {
                    // å¦‚果以上判断都不支持，则直接赋值
                    a[b].v.v = comResult;
                    console.log("error---", error);
                  }
                  break;
                }
              }
            }
          });
          // å¦‚果此计算结果所属单元格，同时也是另一个excel函数的参数，那么就需要递归进行计算
          changeInput(comResult, `${id}-${item.r}-${item.c}-${pId}`); //改变最终值
          currentInsItemId = item.i;
        } catch (error) {
          console.log("error---", error);
        }
      }
    }
  });
  if (index === -1 || (inputType === undefined && isSave === "true")) {
    // èµ‹å€¼ä¼ é€’到主线程的数据，method：saveInsContext表示此消息需要保存数据
    result = {
      method: "saveInsContext",
      value: {
        tableList, // è¡¨æ ¼æ•°æ®
        param: getParam(), //传给后端的参数
        getDataTypeId: getDataTypeId,
        currentInsItemId: currentInsItemId,
      },
    };
    // å‘消息给主线程
    self.postMessage(JSON.stringify(result));
  }

  // èµ‹å€¼å¤šçº¿ç¨‹ä¼ è¾“数据
  result = {
    method: "tableList",
    value: tableList,
  };
  // å‘送主线程数据
  self.postMessage(JSON.stringify(result));
  try {
    // èµ‹å€¼å¤šçº¿ç¨‹ä¼ è¾“数据
    result = {
      method: "getCurrentInsProduct",
      value: pId,
    };
    // å‘送主线程数据
    self.postMessage(JSON.stringify(result));
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * èŽ·å–检测值类型
 *
 * @param id æ£€æµ‹å€¼ç±»åž‹å¯¹åº”çš„id
 * @returns è¿”回检测值类型
 */
function getInspectionValueType(id) {
  for (var a in currentSample.insProduct) {
    if (currentSample.insProduct[a].id == id) {
      return currentSample.insProduct[a].inspectionValueType;
    }
  }
}
/**
 * å¤„理分数或带有乘法和乘方的字符串
 *
 * @param str å­—符串类型，表示要处理的分数或乘方表达式
 * @returns è¿”回一个数字或原字符串，如果字符串为有效的分数或乘方表达式，则返回计算结果；否则返回原字符串
 */
function handleFraction(str) {
  if (str && typeof str == "string" && str.includes("/")) {
    // å¤„理分数
    return eval(str.split("/")[0] / str.split("/")[1]);
  } else if (
    str &&
    typeof str == "string" &&
    str.includes("*") &&
    str.includes("^")
  ) {
    // è®¡ç®—乘方
    const num1 = str.split("*");
    const num2 = num1[1].split("^");
    let num3 = new Big(num2[0]);
    let num4 = new Big(num2[1]);
    let num5 = Math.pow(num3, num4); // è®¡ç®—次方
    return num1[0] * num5; // æœ€åŽè®¡ç®—乘法
  } else {
    return str;
  }
}

/**
 * å¤„理带有多个参数的函数
 *
 * @param res å­—符串，需要被分割并处理的字符串
 * @param str å­—符串，与res中的每一项进行比较的字符串，可能是分数或者带有比较符号的字符串
 * @param comp å­—符串，表示比较类型的字符（如 '>'、'<'、'='、'≥'、'≤'、'±'、'~'、'-'）
 * @returns è¿”回布尔值，如果res中每一项都满足与str的比较条件，则返回true，否则返回false
 */
function handleMoreParam(res, str, comp) {
  let arr = res.split("/");
  let arr0 = arr.every((item) => {
    switch (comp) {
      case ">":
        return item > handleFraction(str);
      case "<":
        return item < handleFraction(str);
      case "=":
        return item == handleFraction(str);
      case "≥":
        return item >= handleFraction(str);
      case "≤":
        return item <= handleFraction(str);
      case "±":
        let k = str.split("±");
        return (
          item >= eval(handleFraction(k[0]) - handleFraction(k[1])) &&
          item <=
            eval(Number(handleFraction(k[0])) + Number(handleFraction(k[1])))
        );
      case "~":
        let j = str.split("~");
        return (
          item >= eval(handleFraction(j[0])) &&
          item <= eval(handleFraction(j[1]))
        );
      case "-":
        let o = str.split("-");
        return (
          item >= eval(handleFraction(o[0])) &&
          item <= eval(handleFraction(o[1]))
        );
    }
  });
  if (arr0) {
    return true;
  } else {
    return false;
  }
}

/**
 * èŽ·å–参数
 *
 * @returns è¿”回处理后的参数对象
 */
function getParam() {
  tableList[0].arr.forEach((a) => {
    a.forEach((b) => {
      // åˆå§‹åŒ–传递到后端的参数
      if (param[b.i]) {
        param[b.i].insValue = [];
        param[b.i].comValue = [];
        param[b.i].equipValue = [];
        param[b.i].equipName = [];
        param[b.i].resValue = null;
        param[b.i].insResult = null;
      }
    });
  });
  tableList[0].arr.forEach((a) => {
    a.forEach((b) => {
      // æ ¹æ®è¡¨æ ¼æ•°æ®ï¼Œèµ‹å€¼ä¼ é€’到后端的参数
      if (
        b.v.ps != undefined &&
        typeof b.v.ps.value == "string" &&
        b.v.ps.value.includes("检验值")
      ) {
        // èµ‹å€¼æ£€éªŒå€¼
        b.i && b.v.v && param[b.i].insValue.push(b);
      }
      if (b.v.ps != undefined && b.v.ps.value === "计算值") {
        // èµ‹å€¼è®¡ç®—值
        b.i &&
          b.v.v &&
          b.valueList &&
          b.valueList.length > 0 &&
          param[b.i].comValue.push(b);
      }
      if (b.v.ps != undefined && b.v.ps.value === "设备编码") {
        // èµ‹å€¼è®¾å¤‡ç¼–码
        b.i && b.v && param[b.i].equipValue.push(b);
      }
      if (b.v.ps != undefined && b.v.ps.value === "设备名称") {
        // èµ‹å€¼è®¾å¤‡åç§°
        b.i && b.v && param[b.i].equipName.push(b);
      }
      if (b.v.ps != undefined && b.v.ps.value === "最终值") {
        // èµ‹å€¼æœ€ç»ˆå€¼
        b.i &&
          b.v &&
          b.valueList &&
          b.valueList.length > 0 &&
          (param[b.i].resValue = b);
      }
      if (b.v.ps != undefined && b.v.ps.value === "结论") {
        if (b.i && (b.v.v || b.v.v === 0 || b.v.v === "0")) {
          if (b.v.v != "合格" && b.v.v != "不合格") {
            // èµ‹å€¼ç»“论
            param[b.i].insResult = b;
          }
        }
      }
    });
  });
  return param;
}

/**
 * è®¡ç®—多个数值的和
 *
 * @param val æ•°å€¼åž‹å‚数，可变长参数列表
 * @returns è¿”回所有参数的和，如果参数列表为空或参数类型非数值型，则返回null
 */
function SUM(...val) {
  try {
    let num = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val.forEach((item) => {
        num += item;
      });
    }
    return num;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è®¡ç®—传入参数中的最大值
 *
 * @param ...val å¯å˜å‚数列表，用于计算最大值的数值或可转换为数值的类型
 * @returns è¿”回最大值，如果参数列表为空或为null/undefined/''，则返回null
 */
function MAX(...val) {
  try {
    let max = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val = val.filter((item) => item != null && item !== "");
      if (val.length > 0) {
        max = Math.max(...val);
      } else {
        max = null;
      }
    }
    return max;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * IF判断
 *
 *
 *
 */
function IF(...val) {
  try {
    let ifNUm = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      if (val[0] === "" || val[0] == 0 || val[0] === " ") {
        ifNUm = val[1];
      } else {
        ifNUm = val[0];
      }
    }
    return ifNUm;
  } catch (error) {
    console.log("IFerror---", error);
  }
}
/**
 * è®¡ç®—传入参数中的最小值
 *
 * @param val å¯å˜å‚数，用于计算最小值的数值数组
 * @returns è¿”回传入参数中的最小值，如果传入参数为空或所有值均为null或空字符串，则返回null
 */
function MIN(...val) {
  try {
    let min = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val = val.filter((item) => item != null && item !== "");
      if (val.length > 0) {
        min = Math.min(...val);
      }
    }
    return min;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è®¡ç®—给定数值的平均值
 *
 * @param val æ•°å€¼åˆ—表，可包含任意个参数
 * @returns è¿”回平均值，如果数值列表为空或包含非数值项，则返回null
 */
function AVERAGE(...val) {
  try {
    let num = null;
    let arr = [];
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      arr = val.filter(
        (item) => item !== null && item !== "" && item != undefined
      );
      arr.forEach((item) => {
        num += item;
      });
      if (arr.length > 0) {
        return num / arr.length;
      } else {
        return null;
      }
    } else {
      return null;
    }
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * å–æ•´æ•°
 *
 * @param val ä»»æ„æ•°å€¼
 * @returns è¿”回该数值的整数
 */
function INT(val) {
  try {
    return Math.round(val);
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è®¡ç®—一个数的绝对值
 *
 * @param val ä»»æ„æ•°å€¼
 * @returns è¿”回该数值的绝对值
 */
function ABS(val) {
  try {
    return Math.abs(val);
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è®¡ç®—一组数字的中位数
 *
 * @param val ä»»æ„ä¸ªå‚数，需要计算中位数的数字
 * @returns å¦‚果参数中有有效的数字，则返回计算出的中位数；否则返回null
 */
function MEDIAN(...val) {
  try {
    let arr = [];
    if (val && val.length > 0) {
      arr = val.filter((item) => item != null && item !== "");
      const sortedArr = arr.sort((a, b) => a - b);
      // è®¡ç®—中位数
      const half = Math.floor(sortedArr.length / 2);
      if (arr.length > 0) {
        // å¦‚果数组长度是奇数，直接取中间的元素
        if (sortedArr.length % 2 === 1) {
          return sortedArr[half];
        } else {
          // å¦‚果数组长度是偶数，取中间两个元素的平均值
          return (sortedArr[half - 1] + sortedArr[half]) / 2;
        }
      } else {
        return null;
      }
    } else {
      return null;
    }
  } catch (error) {
    console.log("error---", error);
  }
}

/**
 * è®¡ç®—幂
 *
 * @param str å­—符串形式的幂表达式，例如"2^3"
 * @returns è¿”回计算后的幂值，如果表达式无效则返回null
 */
function CalculatePower(str) {
  try {
    if (str && str.includes("^")) {
      let arr = str.split("^");
      if (arr && arr.length > 1) {
        return Math.pow(arr[0], arr[1]);
      } else {
        return null;
      }
    }
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è½¬æ¢Ï€
 *
 *
 *
 */
function PI() {
  try {
    return 3.1415926;
  } catch (error) {
    console.log("error---", error);
  }
}
/**
 * è®¡ç®—LOG
 *
 *
 *
 */
function LOG(...val) {
  try {
    let LOGNUm = null;
    if (
      val != null &&
      val != undefined &&
      val != "undefined" &&
      val != "NaN" &&
      val.length > 0
    ) {
      val = val.filter((item) => item != null && item !== "");
      if (val.length > 0) {
        LOGNUm = Math.log(val[0]);
      }
    }
    // console.log(LOGNUm);
    return LOGNUm;
  } catch (error) {
    console.log("error---", error);
  }
}

/**
 * æ ¹æ®åæ ‡èŽ·å–列名
 * @param {Object} cellId
 */
function getColumnNameFromId(cellId) {
  try {
    if (!Array.isArray(cellId)) {
      cellId = cellId.split("-");
    }
    var i = cellId[0];
    var letter = "";
    if (i > 701) {
      letter += String.fromCharCode(64 + parseInt(i / 676));
      letter += String.fromCharCode(64 + parseInt((i % 676) / 26));
    } else if (i > 25) {
      letter += String.fromCharCode(64 + parseInt(i / 26));
    }
    letter += String.fromCharCode(65 + (i % 26));
    return letter + (parseInt(cellId[1]) + 1);
  } catch (e) {
    console.log("error", e);
  }
}
/**
 * æ ¹æ®åˆ—名获取坐标
 * @param {Object} id
 * @param {Object} arr
 */
function getIdFromColumnName(id, arr) {
  try {
    // Get the letters
    var t = /^[a-zA-Z]+/.exec(id);
    if (t) {
      // Base 26 calculation
      var code = 0;
      for (var i = 0; i < t[0].length; i++) {
        code +=
          parseInt(t[0].charCodeAt(i) - 64) * Math.pow(26, t[0].length - 1 - i);
      }
      code--;
      // Make sure jexcel starts on zero
      if (code < 0) {
        code = 0;
      }

      // Number
      var number = parseInt(/[0-9]+$/.exec(id));
      if (number > 0) {
        number--;
      }

      if (arr == true) {
        id = [code, number];
      } else {
        // id = code + '-' + number;
        id = {
          c: code,
          r: number,
        };
      }
    }
    return id;
  } catch (e) {
    console.log("error", e);
  }
}

/**
 * æ›´æ”¹å‚æ•°
 *
 * @param f å‚数列表
 * @returns è¿”回一个包含坐标信息的数组
 */
function changeParameter(f) {
  try {
    let arr = getABCList(f);
    let arr2 = [];
    arr.forEach((item) => {
      // åˆ¤æ–­æ˜¯å¦ä¸ºèŒƒå›´ï¼Œåˆ—如MAX(A1:B2)
      if (item.includes(":")) {
        let r0 = getIdFromColumnName(item.split(":")[0]).r;
        let c0 = getIdFromColumnName(item.split(":")[0]).c;
        let r1 = getIdFromColumnName(item.split(":")[1]).r;
        let c1 = getIdFromColumnName(item.split(":")[1]).c;
        for (let i = Number(r0); i <= Number(r1); i++) {
          for (let u = Number(c0); u <= Number(c1); u++) {
            arr2.push({
              r: i,
              c: u,
            });
          }
        }
      } else {
        // æ²¡æœ‰åˆ™ç›´æŽ¥èŽ·å–
        arr2.push(getIdFromColumnName(item));
      }
    });
    return arr2;
  } catch (error) {
    console.log("error", error);
  }
}
/**
 * èŽ·å–包含 ABC å­—符的列表
 *
 * @param f å­—符串，包含需要解析的公式或表达式
 * @returns åŒ…含 ABC å­—符的数组列表
 */
function getABCList(f) {
  try {
    let regex = /[=\+\-\*\%\(\)\/\^\s]/g;
    // ä¸Šé¢è®¡ç®—函数新增后，这里也要同步增加
    let fouList = [
      "SUM",
      "MAX",
      "MIN",
      "AVERAGE",
      "ABS",
      "PI",
      "INT",
      "IF",
      "LOG",
    ];
    // æ›¿æ¢ç‰¹æ®Šå­—符
    f = f
      .replace(regex, ",")
      .replace(new RegExp('"&', "g"), "")
      .replace(new RegExp('&"', "g"), "");
    fouList.forEach((item) => {
      f = f.replace(new RegExp(item, "g"), ",");
    });
    let arr = f.split(",").filter((item) => {
      return (
        item && /[a-zA-Z]/.test(item) && item != "undefined" && item != "null"
      );
    });
    return arr;
  } catch (error) {
    console.log("error", error);
  }
}
/**
 * èŽ·å–所有单元格
 *
 * @param f è¡¨æ ¼æ•°æ®æˆ–相关参数
 * @returns è¿”回一个对象，其键为单元格的唯一标识符（由列和行ID拼接而成），值为null
 */
function getAllCell(f) {
  try {
    let arr = changeParameter(f);
    let arr0 = {};
    arr.forEach((item) => {
      arr0[getColumnNameFromId(`${item.c}` + "-" + `${item.r}`)] = null;
    });
    return arr0;
  } catch (error) {
    console.log("error", error);
  }
}

/**
 * è®¡ç®—函数
 *
 * @param f å­—符串类型，表示待计算的公式
 * @param comValue å¯¹è±¡ç±»åž‹ï¼Œè¡¨ç¤ºè¦æ›¿æ¢çš„单元格值，键为单元格名称，值为替换后的值
 * @returns è¿”回计算后的结果，如果计算失败则返回0
 */
function compute(f, comValue, isPoint) {
  try {
    let str = f;
    // èŽ·å–单元格对应值
    let arr = getAllCell(f);
    for (var a in comValue) {
      if (typeof comValue[a] == "string" && comValue[a].includes(">")) {
        comValue[a] = comValue[a].replace(">", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("≤")) {
        comValue[a] = comValue[a].replace("≤", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("≥")) {
        comValue[a] = comValue[a].replace("≥", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("<")) {
        comValue[a] = comValue[a].replace("<", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("＜")) {
        comValue[a] = comValue[a].replace("＜", "");
      }
      if (typeof comValue[a] == "string" && comValue[a].includes("＞")) {
        comValue[a] = comValue[a].replace("＞", "");
      }
      if (
        comValue[a] !== "undefined" &&
        comValue[a] !== "null" &&
        comValue[a] !== undefined
      ) {
        if (typeof comValue[a] == "string" && comValue[a].includes("^")) {
          // è®¡ç®—幂次
          arr[a] = CalculatePower(comValue[a]);
        } else {
          arr[a] = comValue[a];
        }
      }
    }
    // è§£æžå…¬å¼å‚数，特别是带：的
    let arr0 = getABCList(f);
    let obj = {};
    arr0.forEach((item) => {
      if (item.includes(":")) {
        let arr1 = [];
        let r0 = getIdFromColumnName(item.split(":")[0]).r;
        let c0 = getIdFromColumnName(item.split(":")[0]).c;
        let r1 = getIdFromColumnName(item.split(":")[1]).r;
        let c1 = getIdFromColumnName(item.split(":")[1]).c;
        for (let i = Number(r0); i <= Number(r1); i++) {
          for (let u = Number(c0); u <= Number(c1); u++) {
            arr1.push({
              r: i,
              c: u,
            });
          }
        }
        let arr2 = [];
        arr1.forEach((m) => {
          arr2.push(getColumnNameFromId(`${m.c}` + "-" + `${m.r}`));
        });
        obj[item.split(":").join("-")] = arr2.join(",");
      } else {
        obj[item] = item;
      }
    });
    str = str.replace(new RegExp(":", "g"), "-");
    // æ›¿æ¢å‚æ•°
    for (var a in obj) {
      str = str.replace(new RegExp(a, "g"), obj[a]);
    }
    // è®¡ç®—
    for (var a in arr) {
      str = str.replace(new RegExp(a, "g"), arr[a]);
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes(",,")) {
      str = str.replace(new RegExp(",,", "g"), ",");
    }
    if (str.includes('&"/"&')) {
      // è®¡ç®—带斜杠的
      return str
        .replace(new RegExp('&"/"&', "g"), "/")
        .replace(new RegExp("//", "g"), "");
    } else if (isPoint) {
      // è®¡ç®—带小数点的
      return str.replace("ABS", "").replace(/\(|\)/g, "");
    } else {
      if (str.includes("IF")) {
        str = str.replace("IF", "").replace(/\(|\)/g, "");
        const str1 = str.split(",");
        if (str1[0] === " " || str1[0] === "") {
          str1[0] = 0;
        }
        if (str1[2] === " " || str1[2] === "") {
          str1[2] = 0;
        }
        const str2 = str1.join(",");
        str = "IF(" + str2 + ")";
      }
      // console.log('str---', str)
      if (str.includes("断裂") || str.includes("脆化")) {
        const result = str.replace(/[^\u4e00-\u9fa5]/g, "");
        if (result.includes("断裂") && !result.includes("脆化")) {
          return "断裂";
        } else if (!result.includes("断裂") && result.includes("脆化")) {
          return "脆化";
        } else if (result.includes("断裂") && result.includes("脆化")) {
          return "断裂脆化";
        }
      }
      // è®¡ç®—常规的
      return eval(str);
    }
  } catch (error) {
    console.log("error", error);
  }
}

/*
 *  big.js v5.2.2
 *  A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.
 *  Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>
 *  https://github.com/MikeMcl/big.js/LICENCE
 */
(function (GLOBAL) {
  "use strict";
  var Big,
    /************************************** EDITABLE DEFAULTS *****************************************/

    // The default values below must be integers within the stated ranges.

    /*
     * The maximum number of decimal places (DP) of the results of operations involving division:
     * div and sqrt, and pow with negative exponents.
     */
    DP = 20, // 0 to MAX_DP
    /*
     * The rounding mode (RM) used when rounding to the above decimal places.
     *
     *  0  Towards zero (i.e. truncate, no rounding).       (ROUND_DOWN)
     *  1  To nearest neighbour. If equidistant, round up.  (ROUND_HALF_UP)
     *  2  To nearest neighbour. If equidistant, to even.   (ROUND_HALF_EVEN)
     *  3  Away from zero.                                  (ROUND_UP)
     */
    RM = 1, // 0, 1, 2 or 3
    // The maximum value of DP and Big.DP.
    MAX_DP = 1e6, // 0 to 1000000
    // The maximum magnitude of the exponent argument to the pow method.
    MAX_POWER = 1e6, // 1 to 1000000
    /*
     * The negative exponent (NE) at and beneath which toString returns exponential notation.
     * (JavaScript numbers: -7)
     * -1000000 is the minimum recommended exponent value of a Big.
     */
    NE = -7, // 0 to -1000000
    /*
     * The positive exponent (PE) at and above which toString returns exponential notation.
     * (JavaScript numbers: 21)
     * 1000000 is the maximum recommended exponent value of a Big.
     * (This limit is not enforced or checked.)
     */
    PE = 21, // 0 to 1000000
    /**************************************************************************************************/

    // Error messages.
    NAME = "[big.js] ",
    INVALID = NAME + "Invalid ",
    INVALID_DP = INVALID + "decimal places",
    INVALID_RM = INVALID + "rounding mode",
    DIV_BY_ZERO = NAME + "Division by zero",
    // The shared prototype object.
    P = {},
    UNDEFINED = void 0,
    NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;

  /*
   * Create and return a Big constructor.
   *
   */
  function _Big_() {
    /*
     * The Big constructor and exported function.
     * Create and return a new instance of a Big number object.
     *
     * n {number|string|Big} A numeric value.
     */
    function Big(n) {
      var x = this;

      // Enable constructor usage without new.
      if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n);

      // Duplicate.
      if (n instanceof Big) {
        x.s = n.s;
        x.e = n.e;
        x.c = n.c.slice();
      } else {
        parse(x, n);
      }

      /*
       * Retain a reference to this Big constructor, and shadow Big.prototype.constructor which
       * points to Object.
       */
      x.constructor = Big;
    }

    Big.prototype = P;
    Big.DP = DP;
    Big.RM = RM;
    Big.NE = NE;
    Big.PE = PE;
    Big.version = "5.2.2";

    return Big;
  }

  /*
   * Parse the number or string value passed to a Big constructor.
   *
   * x {Big} A Big number instance.
   * n {number|string} A numeric value.
   */
  function parse(x, n) {
    var e, i, nl;

    // Minus zero?
    if (n === 0 && 1 / n < 0) n = "-0";
    else if (!NUMERIC.test((n += ""))) throw Error(INVALID + "number");

    // Determine sign.
    x.s = n.charAt(0) == "-" ? ((n = n.slice(1)), -1) : 1;

    // Decimal point?
    if ((e = n.indexOf(".")) > -1) n = n.replace(".", "");

    // Exponential form?
    if ((i = n.search(/e/i)) > 0) {
      // Determine exponent.
      if (e < 0) e = i;
      e += +n.slice(i + 1);
      n = n.substring(0, i);
    } else if (e < 0) {
      // Integer.
      e = n.length;
    }

    nl = n.length;

    // Determine leading zeros.
    for (i = 0; i < nl && n.charAt(i) == "0"; ) ++i;

    if (i == nl) {
      // Zero.
      x.c = [(x.e = 0)];
    } else {
      // Determine trailing zeros.
      for (; nl > 0 && n.charAt(--nl) == "0"; );
      x.e = e - i - 1;
      x.c = [];

      // Convert string to array of digits without leading/trailing zeros.
      for (e = 0; i <= nl; ) x.c[e++] = +n.charAt(i++);
    }

    return x;
  }

  /*
   * Round Big x to a maximum of dp decimal places using rounding mode rm.
   * Called by stringify, P.div, P.round and P.sqrt.
   *
   * x {Big} The Big to round.
   * dp {number} Integer, 0 to MAX_DP inclusive.
   * rm {number} 0, 1, 2 or 3 (DOWN, HALF_UP, HALF_EVEN, UP)
   * [more] {boolean} Whether the result of division was truncated.
   */
  function round(x, dp, rm, more) {
    var xc = x.c,
      i = x.e + dp + 1;

    if (i < xc.length) {
      if (rm === 1) {
        // xc[i] is the digit after the digit that may be rounded up.
        more = xc[i] >= 5;
      } else if (rm === 2) {
        more =
          xc[i] > 5 ||
          (xc[i] == 5 &&
            (more || i < 0 || xc[i + 1] !== UNDEFINED || xc[i - 1] & 1));
      } else if (rm === 3) {
        more = more || !!xc[0];
      } else {
        more = false;
        if (rm !== 0) throw Error(INVALID_RM);
      }

      if (i < 1) {
        xc.length = 1;

        if (more) {
          // 1, 0.1, 0.01, 0.001, 0.0001 etc.
          x.e = -dp;
          xc[0] = 1;
        } else {
          // Zero.
          xc[0] = x.e = 0;
        }
      } else {
        // Remove any digits after the required decimal places.
        xc.length = i--;

        // Round up?
        if (more) {
          // Rounding up may mean the previous digit has to be rounded up.
          for (; ++xc[i] > 9; ) {
            xc[i] = 0;
            if (!i--) {
              ++x.e;
              xc.unshift(1);
            }
          }
        }

        // Remove trailing zeros.
        for (i = xc.length; !xc[--i]; ) xc.pop();
      }
    } else if (rm < 0 || rm > 3 || rm !== ~~rm) {
      throw Error(INVALID_RM);
    }

    return x;
  }

  /*
   * Return a string representing the value of Big x in normal or exponential notation.
   * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.
   *
   * x {Big}
   * id? {number} Caller id.
   *         1 toExponential
   *         2 toFixed
   *         3 toPrecision
   *         4 valueOf
   * n? {number|undefined} Caller's argument.
   * k? {number|undefined}
   */
  function stringify(x, id, n, k) {
    var e,
      s,
      Big = x.constructor,
      z = !x.c[0];

    if (n !== UNDEFINED) {
      if (n !== ~~n || n < (id == 3) || n > MAX_DP) {
        throw Error(id == 3 ? INVALID + "precision" : INVALID_DP);
      }

      x = new Big(x);

      // The index of the digit that may be rounded up.
      n = k - x.e;

      // Round?
      if (x.c.length > ++k) round(x, n, Big.RM);

      // toFixed: recalculate k as x.e may have changed if value rounded up.
      if (id == 2) k = x.e + n + 1;

      // Append zeros?
      for (; x.c.length < k; ) x.c.push(0);
    }

    e = x.e;
    s = x.c.join("");
    n = s.length;

    // Exponential notation?
    if (
      id != 2 &&
      (id == 1 || (id == 3 && k <= e) || e <= Big.NE || e >= Big.PE)
    ) {
      s =
        s.charAt(0) +
        (n > 1 ? "." + s.slice(1) : "") +
        (e < 0 ? "e" : "e+") +
        e;

      // Normal notation.
    } else if (e < 0) {
      for (; ++e; ) s = "0" + s;
      s = "0." + s;
    } else if (e > 0) {
      if (++e > n) for (e -= n; e--; ) s += "0";
      else if (e < n) s = s.slice(0, e) + "." + s.slice(e);
    } else if (n > 1) {
      s = s.charAt(0) + "." + s.slice(1);
    }

    return x.s < 0 && (!z || id == 4) ? "-" + s : s;
  }

  // Prototype/instance methods

  /*
   * Return a new Big whose value is the absolute value of this Big.
   */
  P.abs = function () {
    var x = new this.constructor(this);
    x.s = 1;
    return x;
  };

  /*
   * Return 1 if the value of this Big is greater than the value of Big y,
   *       -1 if the value of this Big is less than the value of Big y, or
   *        0 if they have the same value.
   */
  P.cmp = function (y) {
    var isneg,
      x = this,
      xc = x.c,
      yc = (y = new x.constructor(y)).c,
      i = x.s,
      j = y.s,
      k = x.e,
      l = y.e;

    // Either zero?
    if (!xc[0] || !yc[0]) return !xc[0] ? (!yc[0] ? 0 : -j) : i;

    // Signs differ?
    if (i != j) return i;

    isneg = i < 0;

    // Compare exponents.
    if (k != l) return (k > l) ^ isneg ? 1 : -1;

    j = (k = xc.length) < (l = yc.length) ? k : l;

    // Compare digit by digit.
    for (i = -1; ++i < j; ) {
      if (xc[i] != yc[i]) return (xc[i] > yc[i]) ^ isneg ? 1 : -1;
    }

    // Compare lengths.
    return k == l ? 0 : (k > l) ^ isneg ? 1 : -1;
  };

  /*
   * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,
   * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
   */
  P.div = function (y) {
    var x = this,
      Big = x.constructor,
      a = x.c, // dividend
      b = (y = new Big(y)).c, // divisor
      k = x.s == y.s ? 1 : -1,
      dp = Big.DP;

    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) throw Error(INVALID_DP);

    // Divisor is zero?
    if (!b[0]) throw Error(DIV_BY_ZERO);

    // Dividend is 0? Return +-0.
    if (!a[0]) return new Big(k * 0);

    var bl,
      bt,
      n,
      cmp,
      ri,
      bz = b.slice(),
      ai = (bl = b.length),
      al = a.length,
      r = a.slice(0, bl), // remainder
      rl = r.length,
      q = y, // quotient
      qc = (q.c = []),
      qi = 0,
      d = dp + (q.e = x.e - y.e) + 1; // number of digits of the result

    q.s = k;
    k = d < 0 ? 0 : d;

    // Create version of divisor with leading zero.
    bz.unshift(0);

    // Add zeros to make remainder as long as divisor.
    for (; rl++ < bl; ) r.push(0);

    do {
      // n is how many times the divisor goes into current remainder.
      for (n = 0; n < 10; n++) {
        // Compare divisor and remainder.
        if (bl != (rl = r.length)) {
          cmp = bl > rl ? 1 : -1;
        } else {
          for (ri = -1, cmp = 0; ++ri < bl; ) {
            if (b[ri] != r[ri]) {
              cmp = b[ri] > r[ri] ? 1 : -1;
              break;
            }
          }
        }

        // If divisor < remainder, subtract divisor from remainder.
        if (cmp < 0) {
          // Remainder can't be more than 1 digit longer than divisor.
          // Equalise lengths using divisor with extra leading zero?
          for (bt = rl == bl ? b : bz; rl; ) {
            if (r[--rl] < bt[rl]) {
              ri = rl;
              for (; ri && !r[--ri]; ) r[ri] = 9;
              --r[ri];
              r[rl] += 10;
            }
            r[rl] -= bt[rl];
          }

          for (; !r[0]; ) r.shift();
        } else {
          break;
        }
      }

      // Add the digit n to the result array.
      qc[qi++] = cmp ? n : ++n;

      // Update the remainder.
      if (r[0] && cmp) r[rl] = a[ai] || 0;
      else r = [a[ai]];
    } while ((ai++ < al || r[0] !== UNDEFINED) && k--);

    // Leading zero? Do not remove if result is simply zero (qi == 1).
    if (!qc[0] && qi != 1) {
      // There can't be more than one zero.
      qc.shift();
      q.e--;
    }

    // Round?
    if (qi > d) round(q, dp, Big.RM, r[0] !== UNDEFINED);

    return q;
  };

  /*
   * Return true if the value of this Big is equal to the value of Big y, otherwise return false.
   */
  P.eq = function (y) {
    return !this.cmp(y);
  };

  /*
   * Return true if the value of this Big is greater than the value of Big y, otherwise return
   * false.
   */
  P.gt = function (y) {
    return this.cmp(y) > 0;
  };

  /*
   * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise
   * return false.
   */
  P.gte = function (y) {
    return this.cmp(y) > -1;
  };

  /*
   * Return true if the value of this Big is less than the value of Big y, otherwise return false.
   */
  P.lt = function (y) {
    return this.cmp(y) < 0;
  };

  /*
   * Return true if the value of this Big is less than or equal to the value of Big y, otherwise
   * return false.
   */
  P.lte = function (y) {
    return this.cmp(y) < 1;
  };

  /*
   * Return a new Big whose value is the value of this Big minus the value of Big y.
   */
  P.minus = P.sub = function (y) {
    var i,
      j,
      t,
      xlty,
      x = this,
      Big = x.constructor,
      a = x.s,
      b = (y = new Big(y)).s;

    // Signs differ?
    if (a != b) {
      y.s = -b;
      return x.plus(y);
    }

    var xc = x.c.slice(),
      xe = x.e,
      yc = y.c,
      ye = y.e;

    // Either zero?
    if (!xc[0] || !yc[0]) {
      // y is non-zero? x is non-zero? Or both are zero.
      return yc[0] ? ((y.s = -b), y) : new Big(xc[0] ? x : 0);
    }

    // Determine which is the bigger number. Prepend zeros to equalise exponents.
    if ((a = xe - ye)) {
      if ((xlty = a < 0)) {
        a = -a;
        t = xc;
      } else {
        ye = xe;
        t = yc;
      }

      t.reverse();
      for (b = a; b--; ) t.push(0);
      t.reverse();
    } else {
      // Exponents equal. Check digit by digit.
      j = ((xlty = xc.length < yc.length) ? xc : yc).length;

      for (a = b = 0; b < j; b++) {
        if (xc[b] != yc[b]) {
          xlty = xc[b] < yc[b];
          break;
        }
      }
    }

    // x < y? Point xc to the array of the bigger number.
    if (xlty) {
      t = xc;
      xc = yc;
      yc = t;
      y.s = -y.s;
    }

    /*
     * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only
     * needs to start at yc.length.
     */
    if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--; ) xc[i++] = 0;

    // Subtract yc from xc.
    for (b = i; j > a; ) {
      if (xc[--j] < yc[j]) {
        for (i = j; i && !xc[--i]; ) xc[i] = 9;
        --xc[i];
        xc[j] += 10;
      }

      xc[j] -= yc[j];
    }

    // Remove trailing zeros.
    for (; xc[--b] === 0; ) xc.pop();

    // Remove leading zeros and adjust exponent accordingly.
    for (; xc[0] === 0; ) {
      xc.shift();
      --ye;
    }

    if (!xc[0]) {
      // n - n = +0
      y.s = 1;

      // Result must be zero.
      xc = [(ye = 0)];
    }

    y.c = xc;
    y.e = ye;

    return y;
  };

  /*
   * Return a new Big whose value is the value of this Big modulo the value of Big y.
   */
  P.mod = function (y) {
    var ygtx,
      x = this,
      Big = x.constructor,
      a = x.s,
      b = (y = new Big(y)).s;

    if (!y.c[0]) throw Error(DIV_BY_ZERO);

    x.s = y.s = 1;
    ygtx = y.cmp(x) == 1;
    x.s = a;
    y.s = b;

    if (ygtx) return new Big(x);

    a = Big.DP;
    b = Big.RM;
    Big.DP = Big.RM = 0;
    x = x.div(y);
    Big.DP = a;
    Big.RM = b;

    return this.minus(x.times(y));
  };

  /*
   * Return a new Big whose value is the value of this Big plus the value of Big y.
   */
  P.plus = P.add = function (y) {
    var t,
      x = this,
      Big = x.constructor,
      a = x.s,
      b = (y = new Big(y)).s;

    // Signs differ?
    if (a != b) {
      y.s = -b;
      return x.minus(y);
    }

    var xe = x.e,
      xc = x.c,
      ye = y.e,
      yc = y.c;

    // Either zero? y is non-zero? x is non-zero? Or both are zero.
    if (!xc[0] || !yc[0]) return yc[0] ? y : new Big(xc[0] ? x : a * 0);

    xc = xc.slice();

    // Prepend zeros to equalise exponents.
    // Note: reverse faster than unshifts.
    if ((a = xe - ye)) {
      if (a > 0) {
        ye = xe;
        t = yc;
      } else {
        a = -a;
        t = xc;
      }

      t.reverse();
      for (; a--; ) t.push(0);
      t.reverse();
    }

    // Point xc to the longer array.
    if (xc.length - yc.length < 0) {
      t = yc;
      yc = xc;
      xc = t;
    }

    a = yc.length;

    // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.
    for (b = 0; a; xc[a] %= 10) b = ((xc[--a] = xc[a] + yc[a] + b) / 10) | 0;

    // No need to check for zero, as +x + +y != 0 && -x + -y != 0

    if (b) {
      xc.unshift(b);
      ++ye;
    }

    // Remove trailing zeros.
    for (a = xc.length; xc[--a] === 0; ) xc.pop();

    y.c = xc;
    y.e = ye;

    return y;
  };

  /*
   * Return a Big whose value is the value of this Big raised to the power n.
   * If n is negative, round to a maximum of Big.DP decimal places using rounding
   * mode Big.RM.
   *
   * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.
   */
  P.pow = function (n) {
    var x = this,
      one = new x.constructor(1),
      y = one,
      isneg = n < 0;

    if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER)
      throw Error(INVALID + "exponent");
    if (isneg) n = -n;

    for (;;) {
      if (n & 1) y = y.times(x);
      n >>= 1;
      if (!n) break;
      x = x.times(x);
    }

    return isneg ? one.div(y) : y;
  };

  /*
   * Return a new Big whose value is the value of this Big rounded using rounding mode rm
   * to a maximum of dp decimal places, or, if dp is negative, to an integer which is a
   * multiple of 10**-dp.
   * If dp is not specified, round to 0 decimal places.
   * If rm is not specified, use Big.RM.
   *
   * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.
   * rm? 0, 1, 2 or 3 (ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_UP)
   */
  P.round = function (dp, rm) {
    var Big = this.constructor;
    if (dp === UNDEFINED) dp = 0;
    else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP)
      throw Error(INVALID_DP);
    return round(new Big(this), dp, rm === UNDEFINED ? Big.RM : rm);
  };

  /*
   * Return a new Big whose value is the square root of the value of this Big, rounded, if
   * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.
   */
  P.sqrt = function () {
    var r,
      c,
      t,
      x = this,
      Big = x.constructor,
      s = x.s,
      e = x.e,
      half = new Big(0.5);

    // Zero?
    if (!x.c[0]) return new Big(x);

    // Negative?
    if (s < 0) throw Error(NAME + "No square root");

    // Estimate.
    s = Math.sqrt(x + "");

    // Math.sqrt underflow/overflow?
    // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.
    if (s === 0 || s === 1 / 0) {
      c = x.c.join("");
      if (!((c.length + e) & 1)) c += "0";
      s = Math.sqrt(c);
      e = (((e + 1) / 2) | 0) - (e < 0 || e & 1);
      r = new Big(
        (s == 1 / 0
          ? "1e"
          : (s = s.toExponential()).slice(0, s.indexOf("e") + 1)) + e
      );
    } else {
      r = new Big(s);
    }

    e = r.e + (Big.DP += 4);

    // Newton-Raphson iteration.
    do {
      t = r;
      r = half.times(t.plus(x.div(t)));
    } while (t.c.slice(0, e).join("") !== r.c.slice(0, e).join(""));

    return round(r, (Big.DP -= 4), Big.RM);
  };

  /*
   * Return a new Big whose value is the value of this Big times the value of Big y.
   */
  P.times = P.mul = function (y) {
    var c,
      x = this,
      Big = x.constructor,
      xc = x.c,
      yc = (y = new Big(y)).c,
      a = xc.length,
      b = yc.length,
      i = x.e,
      j = y.e;

    // Determine sign of result.
    y.s = x.s == y.s ? 1 : -1;

    // Return signed 0 if either 0.
    if (!xc[0] || !yc[0]) return new Big(y.s * 0);

    // Initialise exponent of result as x.e + y.e.
    y.e = i + j;

    // If array xc has fewer digits than yc, swap xc and yc, and lengths.
    if (a < b) {
      c = xc;
      xc = yc;
      yc = c;
      j = a;
      a = b;
      b = j;
    }

    // Initialise coefficient array of result with zeros.
    for (c = new Array((j = a + b)); j--; ) c[j] = 0;

    // Multiply.

    // i is initially xc.length.
    for (i = b; i--; ) {
      b = 0;

      // a is yc.length.
      for (j = a + i; j > i; ) {
        // Current sum of products at this digit position, plus carry.
        b = c[j] + yc[i] * xc[j - i - 1] + b;
        c[j--] = b % 10;

        // carry
        b = (b / 10) | 0;
      }

      c[j] = (c[j] + b) % 10;
    }

    // Increment result exponent if there is a final carry, otherwise remove leading zero.
    if (b) ++y.e;
    else c.shift();

    // Remove trailing zeros.
    for (i = c.length; !c[--i]; ) c.pop();
    y.c = c;

    return y;
  };

  /*
   * Return a string representing the value of this Big in exponential notation to dp fixed decimal
   * places and rounded using Big.RM.
   *
   * dp? {number} Integer, 0 to MAX_DP inclusive.
   */
  P.toExponential = function (dp) {
    return stringify(this, 1, dp, dp);
  };

  /*
   * Return a string representing the value of this Big in normal notation to dp fixed decimal
   * places and rounded using Big.RM.
   *
   * dp? {number} Integer, 0 to MAX_DP inclusive.
   *
   * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.
   * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.
   */
  P.toFixed = function (dp) {
    return stringify(this, 2, dp, this.e + dp);
  };

  /*
   * Return a string representing the value of this Big rounded to sd significant digits using
   * Big.RM. Use exponential notation if sd is less than the number of digits necessary to represent
   * the integer part of the value in normal notation.
   *
   * sd {number} Integer, 1 to MAX_DP inclusive.
   */
  P.toPrecision = function (sd) {
    return stringify(this, 3, sd, sd - 1);
  };

  /*
   * Return a string representing the value of this Big.
   * Return exponential notation if this Big has a positive exponent equal to or greater than
   * Big.PE, or a negative exponent equal to or less than Big.NE.
   * Omit the sign for negative zero.
   */
  P.toString = function () {
    return stringify(this);
  };

  /*
   * Return a string representing the value of this Big.
   * Return exponential notation if this Big has a positive exponent equal to or greater than
   * Big.PE, or a negative exponent equal to or less than Big.NE.
   * Include the sign for negative zero.
   */
  P.valueOf = P.toJSON = function () {
    return stringify(this, 4);
  };

  // Export

  Big = _Big_();

  Big["default"] = Big.Big = Big;

  //AMD.
  if (typeof define === "function" && define.amd) {
    define(function () {
      return Big;
    });

    // Node and other CommonJS-like environments that support module.exports.
  } else if (typeof module !== "undefined" && module.exports) {
    module.exports = Big;

    //Browser.
  } else {
    GLOBAL.Big = Big;
  }
})(this);

 src/api/business/inspectionTask.js

@@ -1,3 +1,4 @@
// æ£€éªŒä»»åŠ¡ç›¸å…³æŽ¥å£
import request from "@/utils/request";

// é€šè¿‡æ£€éªŒå•æŸ¥è¯¢æ£€éªŒæ•°æ®ï¼ˆæ•°æ®æŸ¥çœ‹ï¼‰
@@ -269,3 +270,12 @@
    params: query,
  });
}

// æ£€éªŒå•è¯¦æƒ…-任务切换
export function inspectionOrderDetailsTaskSwitching(query) {
  return request({
    url: "/insOrderPlan/inspectionOrderDetailsTaskSwitching",
    method: "get",
    params: query,
  });
}

 src/api/business/unpass.js

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,75 @@
// ä¸åˆæ ¼ç®¡ç†ç›¸å…³æŽ¥å£

import request from "@/utils/request";

//查询进货验证信息
export function getFactoryVerify(query) {
  return request({
    url: "/insOrderPlan/getFactoryVerify",
    method: "get",
    params: query,
  });
}

// ä¿å­˜è¿›è´§åŽŸå§‹è®°å½•
export function addFactoryVerify(data) {
  return request({
    url: "/insOrderPlan/addFactoryVerify",
    method: "post",
    data: data,
  });
}

//查询不合格的检验项
export function getInsProductUnqualified(query) {
  return request({
    url: "/insOrderPlan/getInsProductUnqualified",
    method: "get",
    params: query,
  });
}

// æäº¤éœ€è¦å¤æµ‹çš„检验项
export function addUnqualifiedRetest(data) {
  return request({
    url: "/insOrderPlan/addUnqualifiedRetest",
    method: "post",
    data: data,
  });
}

// æŸ¥è¯¢æ£€éªŒä¸‹å•å†…容详情
export function getInsOrder(query) {
  return request({
    url: "/insOrder/getInsOrder",
    method: "get",
    params: query,
  });
}

// æŸ¥çœ‹OA详情
export function getUnqualifiedHandler(query) {
  return request({
    url: "/unqualifiedHandler/getUnqualifiedHandler",
    method: "get",
    params: query,
  });
}

// ä¸‹è½½OA附件
export function downFile(query) {
  return request({
    url: "/unqualifiedHandler/downFile",
    method: "get",
    params: query,
  });
}

// æäº¤ä¸åˆæ ¼å¤„理
export function addUnqualifiedHandler(data) {
  return request({
    url: "/unqualifiedHandler/addUnqualifiedHandler",
    method: "post",
    data: data,
  });
}

 src/api/cnas/process/method/standardMethod.js

@@ -1,3 +1,4 @@
// å®žéªŒå®¤çš„检测能力档案相关接口
import request from "@/utils/request";

//获取标准方法列表

 src/api/performance/class.js

@@ -1,3 +1,5 @@
// ç­æ¬¡ç›¸å…³æŽ¥å£

import request from "@/utils/request";

// ç»©æ•ˆç®¡ç†-班次-分页查询

 src/api/performance/manHour.js

@@ -1,3 +1,5 @@
// å·¥æ—¶ç®¡ç†ç›¸å…³æŽ¥å£

import request from "@/utils/request";

// æŸ¥è¯¢å·¥æ—¶æ±‡æ€»

 src/api/standard/model.js

@@ -1,3 +1,5 @@
// åŽŸå§‹è®°å½•æ¨¡æ¿ç›¸å…³æŽ¥å£

import request from "@/utils/request";

// æŸ¥è¯¢å®¢æˆ·åˆ—表

 src/api/standard/standardLibrary.js

@@ -1,3 +1,5 @@
// æ ‡å‡†åº“相关接口

import request from "@/utils/request";

// æ ‡å‡†åº“树排序

 src/components/Table/lims-table.vue

@@ -1,82 +1,29 @@
<template>
  <div>
    <!-- è¡¨æ ¼ -->
    <el-table
      ref="multipleTable"
      v-loading="tableLoading"
      :border="border"
      :data="tableData"
      :header-cell-style="{ background: '#f8f8f9', color: '#515a6e' }"
      :height="height"
      :highlight-current-row="highlightCurrentRow"
      :row-class-name="rowClassName"
      :row-style="rowStyle"
      :row-key="rowKey"
      :span-method="spanMethod"
      stripe
      style="width: 100%"
      tooltip-effect="dark"
      @row-click="rowClick"
      @current-change="currentChange"
      @selection-change="handleSelectionChange"
    >
      <el-table-column
        align="center"
        type="selection"
        width="55"
        v-if="isSelection"
      />
      <el-table-column
        align="center"
        label="序号"
        type="index"
        width="60"
        :index="indexMethod"
      />
    <el-table ref="multipleTable" v-loading="tableLoading" :border="border" :data="tableData"
      :header-cell-style="{ background: '#f8f8f9', color: '#515a6e' }" :height="height"
      :highlight-current-row="highlightCurrentRow" :row-class-name="rowClassName" :row-style="rowStyle"
      :row-key="rowKey" :span-method="spanMethod" stripe style="width: 100%" tooltip-effect="dark" @row-click="rowClick"
      @current-change="currentChange" @selection-change="handleSelectionChange">
      <el-table-column align="center" type="selection" width="55" v-if="isSelection" />
      <el-table-column align="center" label="序号" type="index" width="60" :index="indexMethod" />

      <el-table-column
        v-for="(item, index) in column"
        :key="index"
        :column-key="item.columnKey"
        :filter-method="item.filterHandler"
        :filter-multiple="item.filterMultiple"
        :filtered-value="item.filteredValue"
        :filters="item.filters"
        :fixed="item.fixed"
        :label="item.label"
        :min-width="item.minWidth"
        :prop="item.prop"
        :show-overflow-tooltip="item.dataType === 'action' ? false : true"
        :sortable="item.sortable ? true : false"
        :type="item.type"
        :width="
          item.dataType === 'action' ? getWidth(item.operation) : item.width
        "
        align="center"
      >
      <el-table-column v-for="(item, index) in column" :key="index" :column-key="item.columnKey"
        :filter-method="item.filterHandler" :filter-multiple="item.filterMultiple" :filtered-value="item.filteredValue"
        :filters="item.filters" :fixed="item.fixed" :label="item.label" :min-width="item.minWidth" :prop="item.prop"
        :show-overflow-tooltip="item.dataType === 'action' ? false : true" :sortable="item.sortable ? true : false"
        :type="item.type" :width="item.dataType === 'action' ? getWidth(item.operation) : item.width
          " align="center">
        <!-- <div class="123" v-if="item.type == ''"> -->
        <template
          v-if="item.hasOwnProperty('colunmTemplate')"
          :slot="item.colunmTemplate"
          slot-scope="scope"
        >
          <slot
            v-if="item.theadSlot"
            :index="index"
            :name="item.theadSlot"
            :row="scope.row"
          />
        <template v-if="item.hasOwnProperty('colunmTemplate')" :slot="item.colunmTemplate" slot-scope="scope">
          <slot v-if="item.theadSlot" :index="index" :name="item.theadSlot" :row="scope.row" />
        </template>

        <template slot-scope="scope">
          <!-- æ’槽 -->
          <div v-if="item.dataType == 'slot'">
            <slot
              v-if="item.slot"
              :index="scope.$index"
              :name="item.slot"
              :row="scope.row"
            />
            <slot v-if="item.slot" :index="scope.$index" :name="item.slot" :row="scope.row" />
          </div>
          <!-- è¿›åº¦æ¡ -->
          <div v-else-if="item.dataType == 'progress'">
@@ -84,107 +31,61 @@
          </div>
          <!-- å›¾ç‰‡ -->
          <div v-else-if="item.dataType == 'image'">
            <img
              :src="javaApi + '/img/' + item.prop"
              alt=""
              style="width: 40px; height: 40px; margin-top: 10px"
            />
            <img :src="javaApi + '/img/' + item.prop" alt="" style="width: 40px; height: 40px; margin-top: 10px" />
          </div>

          <!-- tag -->
          <div v-else-if="item.dataType == 'tag'">
            <el-tag
              v-if="
                typeof dataTypeFn(scope.row[item.prop], item.formatData) ==
                'string'
              "
              :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(scope.row[item.prop], item.formatType)"
              >{{ scope.row[item.prop] | formatters(item.formatData) }}</el-tag
            >
            <el-tag
              v-for="(tag, index) in dataTypeFn(
                scope.row[item.prop],
                item.formatData
              )"
              v-else-if="
                typeof dataTypeFn(scope.row[item.prop], item.formatData) ==
                'object'
              "
              :key="index"
              :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(tag, item.formatType)"
              >{{
            <el-tag v-if="
              typeof dataTypeFn(scope.row[item.prop], item.formatData) ==
              'string'
            " :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(scope.row[item.prop], item.formatType)">{{ scope.row[item.prop] |
                formatters(item.formatData) }}</el-tag>
            <el-tag v-for="(tag, index) in dataTypeFn(
              scope.row[item.prop],
              item.formatData
            )" v-else-if="
              typeof dataTypeFn(scope.row[item.prop], item.formatData) ==
              'object'
            " :key="index" :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(tag, item.formatType)">{{
                item.tagGroup
                  ? tag[item.tagGroup.label]
                    ? tag[item.tagGroup.label]
                    : tag
                  : tag
              }}</el-tag
            >
            <el-tag
              v-else
              :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(scope.row[item.prop], item.formatType)"
              >{{ scope.row[item.prop] | formatters(item.formatData) }}</el-tag
            >
              }}</el-tag>
            <el-tag v-else :title="scope.row[item.prop] | formatters(item.formatData)"
              :type="formatType(scope.row[item.prop], item.formatType)">{{ scope.row[item.prop] |
                formatters(item.formatData) }}</el-tag>
          </div>

          <!-- æŒ‰é’® -->
          <div v-else-if="item.dataType == 'action'">
            <template v-for="(o, key) in item.operation">
              <el-button
                v-if="o.type != 'upload'"
                size="mini"
                v-show="o.showHide ? o.showHide(scope.row) : true"
                :disabled="o.disabled ? o.disabled(scope.row) : false"
                :icon="iconFn(o)"
                :plain="o.plain"
                :style="{ color: o.name === '删除' ? '#f56c6c' : o.color }"
                :type="o.type | typeFn(scope.row)"
                @click="o.clickFun(scope.row)"
                :key="key"
              >
              <el-button v-if="o.type != 'upload'" size="mini" v-show="o.showHide ? o.showHide(scope.row) : true"
                :disabled="o.disabled ? o.disabled(scope.row) : false" :icon="iconFn(o)" :plain="o.plain"
                :style="{ color: o.name === '删除' ? '#f56c6c' : o.color }" :type="o.type | typeFn(scope.row)"
                @click="o.clickFun(scope.row)" :key="key">
                {{ o.name }}
              </el-button>
              <el-upload
                action="#"
                size="mini"
                :on-change="
                  (file, fileList) => o.clickFun(scope.row, file, fileList)
                "
                :multiple="o.multiple ? o.multiple : false"
                :limit="o.limit ? o.limit : 1"
                :disabled="o.disabled ? o.disabled(scope.row) : false"
                :accept="
                  o.accept
                    ? o.accept
                    : '.jpg,.jpeg,.png,.gif,.doc,.docx,.xls,.xlsx,.ppt,.pptx,.pdf,.zip,.rar'
                "
                v-if="o.type == 'upload'"
                style="display: inline-block; width: 50px"
                v-show="o.showHide ? o.showHide(scope.row) : true"
                :auto-upload="false"
                :on-exceed="onExceed"
                :show-file-list="false"
                :key="key"
              >
                <el-button
                  :size="o.size ? o.size : 'small'"
                  type="text"
                  :disabled="o.disabled ? o.disabled(scope.row) : false"
                  >{{ o.name }}</el-button
                >
              <el-upload action="#" size="mini" :on-change="(file, fileList) => o.clickFun(scope.row, file, fileList)
                " :multiple="o.multiple ? o.multiple : false" :limit="o.limit ? o.limit : 1"
                :disabled="o.disabled ? o.disabled(scope.row) : false" :accept="o.accept
                  ? o.accept
                  : '.jpg,.jpeg,.png,.gif,.doc,.docx,.xls,.xlsx,.ppt,.pptx,.pdf,.zip,.rar'
                  " v-if="o.type == 'upload'" style="display: inline-block; width: 50px"
                v-show="o.showHide ? o.showHide(scope.row) : true" :auto-upload="false" :on-exceed="onExceed"
                :show-file-list="false" :key="key">
                <el-button :size="o.size ? o.size : 'small'" type="text"
                  :disabled="o.disabled ? o.disabled(scope.row) : false">{{ o.name }}</el-button>
              </el-upload>
            </template>
          </div>
          <!-- å¯ç‚¹å‡»çš„文字 -->
          <div
            v-else-if="item.dataType == 'link'"
            class="cell link"
            style="width: 100%"
            @click="goLink(scope.row, item.linkMethod)"
          >
          <div v-else-if="item.dataType == 'link'" class="cell link" style="width: 100%"
            @click="goLink(scope.row, item.linkMethod)">
            <span v-if="!item.formatData">{{ scope.row[item.prop] }}</span>
          </div>
          <!-- é»˜è®¤çº¯å±•ç¤ºæ•°æ® -->
@@ -197,14 +98,8 @@
        </template>
      </el-table-column>
    </el-table>
    <pagination
      v-show="page.total > 0"
      :total="page.total"
      :layout="page.layout"
      :page.sync="page.current"
      :limit.sync="page.size"
      @pagination="pagination"
    />
    <pagination v-show="page.total > 0" :total="page.total" :layout="page.layout" :page.sync="page.current"
      :limit.sync="page.size" @pagination="pagination" />
  </div>
</template>

@@ -294,19 +189,19 @@
    handleSelectionChange: {
      type: Function,
      default: () => {
        return () => {};
        return () => { };
      },
    },
    rowClick: {
      type: Function,
      default: () => {
        return () => {};
        return () => { };
      },
    },
    currentChange: {
      type: Function,
      default: () => {
        return () => {};
        return () => { };
      },
    },
    border: {
@@ -331,11 +226,11 @@
    },
    rowClassName: {
      type: Function,
      default: () => {},
      default: () => { },
    },
    rowStyle: {
      type: Object || Function,
      default: () => {},
      default: () => { },
    },
    tableData: {
      type: Array,
@@ -506,13 +401,14 @@
</script>

<style scoped>
.el-table >>> .el-table__empty-text {
.el-table>>>.el-table__empty-text {
  text-align: center;
}

>>> .cell {
>>>.cell {
  padding: 0 !important;
}

.cell {
  white-space: nowrap;
  overflow: hidden;
@@ -520,11 +416,14 @@
  padding-right: 4px !important;
  padding-left: 10px !important;
}

.link {
  color: rgb(64, 158, 255);
  cursor: pointer;
}
>>> .el-table__body-wrapper::-webkit-scrollbar {
  height: 14px; /* è®¾ç½®æ»šåŠ¨æ¡å®½åº¦ */

>>>.el-table__body-wrapper::-webkit-scrollbar {
  height: 14px;
  /* è®¾ç½®æ»šåŠ¨æ¡å®½åº¦ */
}
</style>

 src/router/index.js

@@ -101,17 +101,21 @@
    children: [
      {
        // åŽŸææ–™ä¸‹å•
        path: 'customsInspection',
        component: () => import('@/views/business/materialOrder/customsInspection'),
        name: 'customsInspection',
        meta: { title: '原材料下单详情', activeMenu: '/business/materialOrder' }
        path: "customsInspection",
        component: () =>
          import("@/views/business/materialOrder/customsInspection"),
        name: "customsInspection",
        meta: {
          title: "原材料下单详情",
          activeMenu: "/business/materialOrder",
        },
      },
      {
        // é“œææ–™ä¸‹å•
        path: 'copperOrder',
        component: () => import('@/views/business/materialOrder/copperOrder'),
        name: 'copperOrder',
        meta: { title: '铜材料下单', activeMenu: '/business/materialOrder' }
        path: "copperOrder",
        component: () => import("@/views/business/materialOrder/copperOrder"),
        name: "copperOrder",
        meta: { title: "铜材料下单", activeMenu: "/business/materialOrder" },
      },
    ],
  },

 src/utils/request.js

@@ -1,114 +1,148 @@
import axios from 'axios'
import { Notification, MessageBox, Message, Loading } from 'element-ui'
import store from '@/store'
import { getToken } from '@/utils/auth'
import errorCode from '@/utils/errorCode'
import axios from "axios";
import { Notification, MessageBox, Message, Loading } from "element-ui";
import store from "@/store";
import { getToken } from "@/utils/auth";
import errorCode from "@/utils/errorCode";
import { tansParams, blobValidate } from "@/utils/ruoyi";
import cache from '@/plugins/cache'
import { saveAs } from 'file-saver'
import cache from "@/plugins/cache";
import { saveAs } from "file-saver";

let downloadLoadingInstance;
// æ˜¯å¦æ˜¾ç¤ºé‡æ–°ç™»å½•
export let isRelogin = { show: false };

axios.defaults.headers['Content-Type'] = 'application/json;charset=utf-8'
axios.defaults.headers["Content-Type"] = "application/json;charset=utf-8";
// åˆ›å»ºaxios实例
const service = axios.create({
  // axios中请求配置有baseURL选项，表示请求URL公共部分
  baseURL: process.env.VUE_APP_BASE_API,
  // è¶…æ—¶
  timeout: 10000
})
  timeout: 10000 * 60,
});

// request拦截器
service.interceptors.request.use(config => {
  // æ˜¯å¦éœ€è¦è®¾ç½® token
  const isToken = (config.headers || {}).isToken === false
  // æ˜¯å¦éœ€è¦é˜²æ­¢æ•°æ®é‡å¤æäº¤
  const isRepeatSubmit = (config.headers || {}).repeatSubmit === false
  if (getToken() && !isToken) {
    config.headers['Authorization'] = 'Bearer ' + getToken() // è®©æ¯ä¸ªè¯·æ±‚携带自定义token è¯·æ ¹æ®å®žé™…情况自行修改
  }
  // get请求映射params参数
  if (config.method === 'get' && config.params) {
    let url = config.url + '?' + tansParams(config.params);
    url = url.slice(0, -1);
    config.params = {};
    config.url = url;
  }
  if (!isRepeatSubmit && (config.method === 'post' || config.method === 'put')) {
    const requestObj = {
      url: config.url,
      data: typeof config.data === 'object' ? JSON.stringify(config.data) : config.data,
      time: new Date().getTime()
service.interceptors.request.use(
  (config) => {
    // æ˜¯å¦éœ€è¦è®¾ç½® token
    const isToken = (config.headers || {}).isToken === false;
    // æ˜¯å¦éœ€è¦é˜²æ­¢æ•°æ®é‡å¤æäº¤
    const isRepeatSubmit = (config.headers || {}).repeatSubmit === false;
    if (getToken() && !isToken) {
      config.headers["Authorization"] = "Bearer " + getToken(); // è®©æ¯ä¸ªè¯·æ±‚携带自定义token è¯·æ ¹æ®å®žé™…情况自行修改
    }
    const requestSize = Object.keys(JSON.stringify(requestObj)).length; // è¯·æ±‚数据大小
    const limitSize = 5 * 1024 * 1024; // é™åˆ¶å­˜æ”¾æ•°æ®5M
    if (requestSize >= limitSize) {
      console.warn(`[${config.url}]: ` + '请求数据大小超出允许的5M限制，无法进行防重复提交验证。')
      return config;
    // get请求映射params参数
    if (config.method === "get" && config.params) {
      let url = config.url + "?" + tansParams(config.params);
      url = url.slice(0, -1);
      config.params = {};
      config.url = url;
    }
    const sessionObj = cache.session.getJSON('sessionObj')
    if (sessionObj === undefined || sessionObj === null || sessionObj === '') {
      cache.session.setJSON('sessionObj', requestObj)
    } else {
      const s_url = sessionObj.url;                  // è¯·æ±‚地址
      const s_data = sessionObj.data;                // è¯·æ±‚数据
      const s_time = sessionObj.time;                // è¯·æ±‚时间
      const interval = 1000;                         // é—´éš”时间(ms)，小于此时间视为重复提交
      if (s_data === requestObj.data && requestObj.time - s_time < interval && s_url === requestObj.url) {
        const message = '数据正在处理，请勿重复提交';
        console.warn(`[${s_url}]: ` + message)
        return Promise.reject(new Error(message))
    if (
      !isRepeatSubmit &&
      (config.method === "post" || config.method === "put")
    ) {
      const requestObj = {
        url: config.url,
        data:
          typeof config.data === "object"
            ? JSON.stringify(config.data)
            : config.data,
        time: new Date().getTime(),
      };
      const requestSize = Object.keys(JSON.stringify(requestObj)).length; // è¯·æ±‚数据大小
      const limitSize = 5 * 1024 * 1024; // é™åˆ¶å­˜æ”¾æ•°æ®5M
      if (requestSize >= limitSize) {
        console.warn(
          `[${config.url}]: ` +
            "请求数据大小超出允许的5M限制，无法进行防重复提交验证。"
        );
        return config;
      }
      const sessionObj = cache.session.getJSON("sessionObj");
      if (
        sessionObj === undefined ||
        sessionObj === null ||
        sessionObj === ""
      ) {
        cache.session.setJSON("sessionObj", requestObj);
      } else {
        cache.session.setJSON('sessionObj', requestObj)
        const s_url = sessionObj.url; // è¯·æ±‚地址
        const s_data = sessionObj.data; // è¯·æ±‚数据
        const s_time = sessionObj.time; // è¯·æ±‚时间
        const interval = 1000; // é—´éš”时间(ms)，小于此时间视为重复提交
        if (
          s_data === requestObj.data &&
          requestObj.time - s_time < interval &&
          s_url === requestObj.url
        ) {
          const message = "数据正在处理，请勿重复提交";
          console.warn(`[${s_url}]: ` + message);
          return Promise.reject(new Error(message));
        } else {
          cache.session.setJSON("sessionObj", requestObj);
        }
      }
    }
    return config;
  },
  (error) => {
    console.log(error);
    Promise.reject(error);
  }
  return config
}, error => {
    console.log(error)
    Promise.reject(error)
})
);

// å“åº”拦截器
service.interceptors.response.use(res => {
service.interceptors.response.use(
  (res) => {
    // æœªè®¾ç½®çŠ¶æ€ç åˆ™é»˜è®¤æˆåŠŸçŠ¶æ€
    const code = res.data.code || 200;
    // èŽ·å–错误信息
    const msg = errorCode[code] || res.data.msg || errorCode['default']
    const msg = errorCode[code] || res.data.msg || errorCode["default"];
    // äºŒè¿›åˆ¶æ•°æ®åˆ™ç›´æŽ¥è¿”回
    if (res.request.responseType ===  'blob' || res.request.responseType ===  'arraybuffer') {
      return res.data
    if (
      res.request.responseType === "blob" ||
      res.request.responseType === "arraybuffer"
    ) {
      return res.data;
    }
    if (code === 401) {
      if (!isRelogin.show) {
        isRelogin.show = true;
        MessageBox.confirm('登录状态已过期，您可以继续留在该页面，或者重新登录', '系统提示', { confirmButtonText: '重新登录', cancelButtonText: '取消', type: 'warning' }).then(() => {
          isRelogin.show = false;
          store.dispatch('LogOut').then(() => {
            location.href = '/index';
        MessageBox.confirm(
          "登录状态已过期，您可以继续留在该页面，或者重新登录",
          "系统提示",
          {
            confirmButtonText: "重新登录",
            cancelButtonText: "取消",
            type: "warning",
          }
        )
          .then(() => {
            isRelogin.show = false;
            store.dispatch("LogOut").then(() => {
              location.href = "/index";
            });
          })
      }).catch(() => {
        isRelogin.show = false;
      });
    }
      return Promise.reject('无效的会话，或者会话已过期，请重新登录。')
          .catch(() => {
            isRelogin.show = false;
          });
      }
      return Promise.reject("无效的会话，或者会话已过期，请重新登录。");
    } else if (code === 500) {
      Message({ message: msg, type: 'error' })
      return Promise.reject(new Error(msg))
      Message({ message: msg, type: "error" });
      return Promise.reject(new Error(msg));
    } else if (code === 601) {
      Message({ message: msg, type: 'warning' })
      return Promise.reject('error')
      Message({ message: msg, type: "warning" });
      return Promise.reject("error");
    } else if (code !== 200) {
      Notification.error({ title: msg })
      return Promise.reject('error')
      Notification.error({ title: msg });
      return Promise.reject("error");
    } else {
      return res.data
      return res.data;
    }
  },
  error => {
    console.log('err' + error)
  (error) => {
    console.log("err" + error);
    let { message } = error;
    if (message == "Network Error") {
      message = "后端接口连接异常";
@@ -117,36 +151,48 @@
    } else if (message.includes("Request failed with status code")) {
      message = "系统接口" + message.substr(message.length - 3) + "异常";
    }
    Message({ message: message, type: 'error', duration: 5 * 1000 })
    return Promise.reject(error)
    Message({ message: message, type: "error", duration: 5 * 1000 });
    return Promise.reject(error);
  }
)
);

// é€šç”¨ä¸‹è½½æ–¹æ³•
export function download(url, params, filename, config) {
  downloadLoadingInstance = Loading.service({ text: "正在下载数据，请稍候", spinner: "el-icon-loading", background: "rgba(0, 0, 0, 0.7)", })
  return service.post(url, params, {
    transformRequest: [(params) => { return tansParams(params) }],
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    responseType: 'blob',
    ...config
  }).then(async (data) => {
    const isBlob = blobValidate(data);
    if (isBlob) {
      const blob = new Blob([data])
      saveAs(blob, filename)
    } else {
      const resText = await data.text();
      const rspObj = JSON.parse(resText);
      const errMsg = errorCode[rspObj.code] || rspObj.msg || errorCode['default']
      Message.error(errMsg);
    }
    downloadLoadingInstance.close();
  }).catch((r) => {
    console.error(r)
    Message.error('下载文件出现错误，请联系管理员！')
    downloadLoadingInstance.close();
  })
  downloadLoadingInstance = Loading.service({
    text: "正在下载数据，请稍候",
    spinner: "el-icon-loading",
    background: "rgba(0, 0, 0, 0.7)",
  });
  return service
    .post(url, params, {
      transformRequest: [
        (params) => {
          return tansParams(params);
        },
      ],
      headers: { "Content-Type": "application/x-www-form-urlencoded" },
      responseType: "blob",
      ...config,
    })
    .then(async (data) => {
      const isBlob = blobValidate(data);
      if (isBlob) {
        const blob = new Blob([data]);
        saveAs(blob, filename);
      } else {
        const resText = await data.text();
        const rspObj = JSON.parse(resText);
        const errMsg =
          errorCode[rspObj.code] || rspObj.msg || errorCode["default"];
        Message.error(errMsg);
      }
      downloadLoadingInstance.close();
    })
    .catch((r) => {
      console.error(r);
      Message.error("下载文件出现错误，请联系管理员！");
      downloadLoadingInstance.close();
    });
}

export default service
export default service;

 src/views/business/inspectionTask/index.vue

@@ -89,7 +89,7 @@
</style>
<template>
  <div class="ins-order-plan-main">
    <div v-show="activeFace == 0" style="height: 100%">
    <div style="height: 100%">
      <div class="search">
        <div class="search_thing">
          <div class="search_label">委托编号：</div>
@@ -178,31 +178,6 @@
        <el-button :loading="loading" type="primary" @click="confirmConnect">ç¡® å®š</el-button>
      </span>
    </el-dialog>
    <div v-if="activeFace > 0 && isCopper == null" style="width: 100%; height: 100%">
      <!-- <Add :active="activeFace" :currentId="currentId" :examine="examine" /> -->
    </div>
    <div v-if="activeFace > 0 && isCopper == 0" style="width: 100%; height: 100%">
      <!-- <CustomsInspection
        :active="activeFace"
        :currentId="currentId"
        :customsInspection="customsInspection"
        :isReport="isReport"
      /> -->
    </div>
    <div v-if="activeFace > 0 && isCopper == 1" style="width: 100%; height: 100%">
      <!-- <CopperOrder :active="activeFace" :currentId="currentId"></CopperOrder> -->
    </div>
    <!--<Inspection
      v-if="state > 0"
      :key="InspectionKey"
      :inspectorList="inspectorList"
      :orderId="orderId"
      :sonLaboratory="sonLaboratory"
      :state="state"
      :typeSource="typeSource"
      @goback="goback"
      @refreshView="refreshView"
    />-->
    <el-dialog :visible.sync="dataDialogVisible" title="数据查看" width="80%">
      <div v-if="dataDialogVisible" style="height: 70vh; overflow-y: auto">
        <lims-table :tableData="lookTableData" :column="lookColumn" :page="lookPage" :tableLoading="lookTableLoading"
@@ -261,13 +236,7 @@
</template>

<script>
import ValueTable from "@/components/Table/value-table.vue";
// import Inspection from "../do/b1-inspect-order-plan/Inspection.vue";
// import CustomsInspection from "../do/b1-material-ins-order/customs-inspection.vue";
import { getYearAndMonthAndDays } from "@/utils/date";
// import Add from "../do/b1-ins-order/add.vue";
// import ShowInfo from "../do/b1-material-ins-order/showInfo.vue";
// import CopperOrder from "../do/b1-material-ins-order/copper-order.vue";
import EditInspectionItem from "./components/EditInspectionItem.vue";
import limsTable from "@/components/Table/lims-table.vue";
import {
@@ -286,13 +255,7 @@
export default {
  components: {
    EditInspectionItem,
    // CopperOrder,
    // ShowInfo,
    ValueTable,
    limsTable,
    // Inspection,
    // Add,
    // CustomsInspection,
  },
  dicts: ["urgency_level", "inspection_task_state"],
  computed: {
@@ -384,14 +347,15 @@
        {
          label: "委托编号",
          prop: "entrustCode",
          width: "140px",
          width: "160px",
          dataType: "link",
          linkMethod: "selectAllByOne",
        },
        { label: "样品名称", prop: "sample", width: "140px" },
        { label: "样品名称", prop: "sample", width: "160px" },
        {
          label: "下单类别",
          prop: "typeSource",
          width: "100px",
          dataType: "tag",
          formatData: (params) => {
            if (params == 0) {
@@ -413,6 +377,7 @@
        {
          label: "检验类型",
          prop: "orderType",
          width: "100px",
          dataType: "tag",
          formatData: (params) => {
            return this.orderTypeList.find((m) => m.value == params).label;
@@ -794,6 +759,39 @@
      this.examine = 1;
      this.isReport = 0;
      this.currentId = parseInt(row.id);
      switch (row.isCopper) {
        case 0:
          // åŽŸææ–™
          this.$router.push({
            path: "/materialOrder/customsInspection", query: {
              customsInspection: row,
              active: this.activeFace,
              currentId: this.currentId,
              isReport: this.isReport
            }
          });
          break;
        case null:
          // æˆå“
          this.$router.push({
            path: "/productOrder/add", query: {
              examine: this.examine,
              active: this.activeFace,
              currentId: this.currentId
            }
          });
          break;
        case 1:
          // é“œæ
          this.$router.push({
            path: "/materialOrder/copperOrder", query: {
              active: this.activeFace,
              currentId: this.currentId
            }
          });
          break;
      }

    },
    playOrder(num) {
      this.activeFace = num;
@@ -843,6 +841,16 @@
      this.state = 3;
      this.typeSource = row.typeSource;
      this.orderId = row.id;
      this.$router.push({
        path: "/inspectionTask/inspection",
        query: {
          inspectorList: this.inspectorList,
          sonLaboratory: this.sonLaboratory,
          state: this.state,
          typeSource: this.typeSource,
          orderId: this.orderId,
        },
      });
    },
    handleConnect(row) {
      this.orderId = row.id;

 src/views/business/inspectionTask/inspection.vue

@@ -1,9 +1,7 @@
<template>
  <div v-loading="loading" class="inspection">
  <div v-loading="loading" class="inspection" style="background-color: rgb(245, 247, 251);">
    <el-row class="title">
      <el-col :span="4" style="padding-left: 20px; text-align: left">检验单详情
      </el-col>
      <el-col :span="20" style="text-align: right">
      <el-col :span="8" style="text-align: left">
        <el-form :inline="true" :model="otherForm" class="form-inline" label-width="50px"
          style="text-align: right; padding-top: 0; display: inline">
          <el-form-item label="温度:" style="margin-bottom: 0">
@@ -17,6 +15,8 @@
            <span style="margin-left: 4px">%</span>
          </el-form-item>
        </el-form>
      </el-col>
      <el-col :span="16" style="text-align: right">
        <el-button size="small" type="primary" @click="refreshView">刷新</el-button>
        <el-button v-if="typeSource === 1" size="small" type="primary" @click="openPurchase">进货验证</el-button>
        <el-button v-if="state === 1 && typeSource === 1" size="small" type="primary"
@@ -31,7 +31,7 @@
        <el-button v-if="state == 2" size="medium" type="primary" @click="openAddCheck">通过</el-button>
        <el-button v-if="state == 2" size="medium" @click="upInsReview(0)">不通过</el-button>
        <el-button type="primary" size="small" @click="exportTable('myTable')">下载原始记录</el-button>
        <el-button size="small" @click="$emit('goback')">返回</el-button>
        <el-button size="small" @click="goback">返回</el-button>
      </el-col>
    </el-row>
    <div class="search">
@@ -68,7 +68,7 @@
        <el-form-item v-if="typeSource === 1" label="厂家密度:">
          <el-input v-model="supplierDensity" clearable disabled placeholder="请输入" size="small"></el-input>
        </el-form-item>
        <el-form-item label="当前样品位数:">
        <el-form-item label="当前样品位数:" label-width="120px">
          <el-tag v-if="currentKey">{{ `NO.${currentKey}` }}</el-tag>
        </el-form-item>
        <el-form-item label="备注:">
@@ -149,74 +149,64 @@
        </div>
      </div>
      <!-- å¸¸è§„检验原始记录 -->
      <div v-if="
        !tableLists.find((m) => m.templateId == currentTable) ||
        (tableLists.find((m) => m.templateId == currentTable).templateName !=
          '温度循环检验原始记录' &&
          !tableLists
            .find((m) => m.templateId == currentTable)
            .templateName.includes('热循环') &&
          !tableLists
            .find((m) => m.templateId == currentTable)
            .templateName.includes('温升试验') &&
          tableLists.find((m) => m.templateId == currentTable).templateName !=
          '弧垂特性检验原始记录')
      " id="nav" v-loading="tableLoading" class="center-box">
        <table v-for="(item, index) in tableList" :key="index + currentTable + currentSample.id" border="1"
          cellpadding="10" class="tables" id="myTable">
          <tbody>
            <tr style="white-space: nowrap">
              å§”托编号：{{
                insOrder.entrustCode
              }}
            </tr>
            <tr v-for="(m, i) in item.arr" :key="i">
              <td v-for="(n, j) in m" v-if="n.v.mc == undefined || Object.keys(n.v.mc).length === 4"
                :id="item.templateId + '-' + n.i + '-' + n.r + '-' + n.c" :key="j"
                :colspan="n.v.mc && n.v.mc.cs ? n.v.mc.cs : 1" :rowspan="n.v.mc && n.v.mc.rs ? n.v.mc.rs : 1" :style="`background:${n.v.bg ? n.v.bg : ''};color:${n.v.fc
                  };font-size:${n.v.fs}px;width:${handleWidth(
                    n
                  )}px !important;height:${item.style.rowlen[n.r]}px;font-wight:${n.v.bl ? 'bold' : ''
                  };`">
                <div :class="`content-h-${n.v.ht} content-v-${n.v.vt}`" :style="`width:${handleWidth(n)}px !important;min-height:${item.style.rowlen[n.r]
                  }px;`" class="content">
                  <template v-if="
                    n.v.ps != undefined &&
                    typeof n.v.ps.value === 'string' &&
                    n.v.ps.value.includes('检验值') &&
                    state == 1
                  ">
                    <el-input v-if="getInspectionValueType(n.i) == 1"
                      :key="'abc-' + '000' + index + '000' + i + '000' + j" v-model="n.v.v" :disabled="(getInspectionItemType(n.i) == 1 &&
                        !dataAcquisitionEidtAble) ||
      <div id="nav" v-loading="tableLoading" class="center-box">
        <template v-if="
          tableLists.find((m) => m.templateId == currentTable)">
          <table v-for="(item, index) in tableList" :key="index + currentTable + currentSample.id" border="1"
            cellpadding="10" class="tables" id="myTable">
            <tbody>
              <tr style="white-space: nowrap">
                å§”托编号：{{
                  insOrder.entrustCode
                }}
              </tr>
              <tr v-for="(m, i) in item.arr" :key="i">
                <td v-for="(n, j) in m" v-if="n.v.mc == undefined || Object.keys(n.v.mc).length === 4"
                  :id="item.templateId + '-' + n.i + '-' + n.r + '-' + n.c" :key="j"
                  :colspan="n.v.mc && n.v.mc.cs ? n.v.mc.cs : 1" :rowspan="n.v.mc && n.v.mc.rs ? n.v.mc.rs : 1" :style="`background:${n.v.bg ? n.v.bg : ''};color:${n.v.fc
                    };font-size:${n.v.fs}px;width:${handleWidth(
                      n
                    )}px !important;height:${item.style.rowlen[n.r]}px;font-wight:${n.v.bl ? 'bold' : ''
                    };`">
                  <div :class="`content-h-${n.v.ht} content-v-${n.v.vt}`" :style="`width:${handleWidth(n)}px !important;min-height:${item.style.rowlen[n.r]
                    }px;`" class="content">
                    <template v-if="
                      n.v.ps != undefined &&
                      typeof n.v.ps.value === 'string' &&
                      n.v.ps.value.includes('检验值') &&
                      state == 1
                    ">
                      <el-input v-if="getInspectionValueType(n.i) == 1"
                        :key="'abc-' + '000' + index + '000' + i + '000' + j" v-model="n.v.v" :disabled="(getInspectionItemType(n.i) == 1 &&
                          !dataAcquisitionEidtAble) ||
                          (n.u != userId && n.u != undefined && n.u != '')
                          " class="table_input" @change="(m) =>
                            changeInput(
                              m,
                              `${item.templateId}-${n.r}-${n.c}-${n.i}`,
                              n,
                              'getDataType'
                            )
                            " @input="handleInput(n)" @mousewheel.native.prevent @keydown.enter="
                              changeInput(
                                '',
                                `${item.templateId}-${n.r}-${n.c}-${n.i}`,
                                n,
                                'getDataType'
                              )
                              ">
                      </el-input>
                      <el-input v-else-if="getInspectionValueType(n.i) == 2" v-model="n.v.v" :disabled="getInspectionItemType(n.i) == 1 ||
                        (n.u != userId && n.u != undefined && n.u != '')
                        " class="table_input" @change="(m) =>
                        " class="table_input" type="textarea" @change="(m) =>
                          changeInput(
                            m,
                            `${item.templateId}-${n.r}-${n.c}-${n.i}`,
                            n,
                            'getDataType'
                          )
                          " @input="handleInput(n)" @mousewheel.native.prevent @keydown.enter="
                            changeInput(
                              '',
                              `${item.templateId}-${n.r}-${n.c}-${n.i}`,
                              n,
                              'getDataType'
                            )
                            ">
                    </el-input>
                    <el-input v-else-if="getInspectionValueType(n.i) == 2" v-model="n.v.v" :disabled="getInspectionItemType(n.i) == 1 ||
                      (n.u != userId && n.u != undefined && n.u != '')
                      " class="table_input" type="textarea" @change="(m) =>
                        changeInput(
                          m,
                          `${item.templateId}-${n.r}-${n.c}-${n.i}`,
                          n,
                          'getDataType'
                        )
                        " />
                    <!-- <el-select v-else-if="getInspectionValueType(n.i) == 5" v-model="n.v.v" :disabled="state > 1 ||
                          " />
                      <!-- <el-select v-else-if="getInspectionValueType(n.i) == 5" v-model="n.v.v" :disabled="state > 1 ||
                      getInspectionItemType(n.i) == 1 ||
                      (n.u != userId && n.u != undefined && n.u != '')
                      " class="table_input" @change="(m) =>
@@ -229,136 +219,131 @@
                        " @visible-change="(e) => getDic(e, n.i)">
                      <el-option v-for="(e, i) in enumList" :key="i" :label="e.label" :value="e.value"></el-option>
                    </el-select> -->
                    <span v-else-if="getInspectionValueType(n.i) == 4"
                      :style="`font-family:${n.v.ff} !important;`">/</span>
                  </template>
                  <template v-else-if="n.v.ps != undefined && n.v.ps.value === '结论'">
                    <el-select v-if="
                      (getInspectionValueType(n.i) == 2 ||
                        getInspectionValueType(n.i) == 5) &&
                      <span v-else-if="getInspectionValueType(n.i) == 4"
                        :style="`font-family:${n.v.ff} !important;`">/</span>
                    </template>
                    <template v-else-if="n.v.ps != undefined && n.v.ps.value === '结论'">
                      <el-select v-if="
                        (getInspectionValueType(n.i) == 2 ||
                          getInspectionValueType(n.i) == 5) &&
                        state == 1
                      " v-model="n.v.v" class="table_input" @change="(m) =>
                        changeInput(
                          m,
                          `${item.templateId}-${n.r}-${n.c}-${n.i}`,
                          n,
                          'getDataType',
                          'changeSelect'
                        )
                        ">
                        <el-option :value="1" label="合格"></el-option>
                        <el-option :value="0" label="不合格"></el-option>
                        <el-option :value="3" label="不判定"></el-option>
                        <el-option :value="2" label="待定"></el-option>
                      </el-select>
                      <template v-if="state > 1">
                        <span v-if="n.v.v === 1" :style="`font-family:${n.v.ff} !important;color: green;`">合格</span>
                        <span v-else-if="n.v.v === 0" :style="`font-family:${n.v.ff} !important;color: red;`">不合格</span>
                        <span v-else-if="n.v.v === 3"
                          :style="`font-family:${n.v.ff} !important;color: #3A7BFA;`">不判定</span>
                        <span v-else :style="`font-family:${n.v.ff} !important;`">待定</span>
                      </template>
                      <template v-if="getInspectionValueType(n.i) != 2 &&
                        state == 1">
                        <span v-if="n.v.v === 1" :style="`font-family:${n.v.ff} !important;color: green;`">合格</span>
                        <span v-else-if="n.v.v === 0" :style="`font-family:${n.v.ff} !important;color: red;`">不合格</span>
                        <span v-else-if="n.v.v === 3"
                          :style="`font-family:${n.v.ff} !important;color: #3A7BFA;`">不判定</span>
                        <span v-else :style="`font-family:${n.v.ff} !important;`">待定</span>
                      </template>
                    </template>
                    <template v-else-if="
                      n.v.ps != undefined &&
                      n.v.ps.value === '设备编码' &&
                      state == 1
                    " v-model="n.v.v" class="table_input" @change="(m) =>
                      changeInput(
                        m,
                        `${item.templateId}-${n.r}-${n.c}-${n.i}`,
                        n,
                        'getDataType',
                        'changeSelect'
                      )
                      ">
                      <el-option :value="1" label="合格"></el-option>
                      <el-option :value="0" label="不合格"></el-option>
                      <el-option :value="3" label="不判定"></el-option>
                      <el-option :value="2" label="待定"></el-option>
                    </el-select>
                    <template v-if="state > 1">
                      <span v-if="n.v.v === 1" :style="`font-family:${n.v.ff} !important;color: green;`">合格</span>
                      <span v-else-if="n.v.v === 0" :style="`font-family:${n.v.ff} !important;color: red;`">不合格</span>
                      <span v-else-if="n.v.v === 3"
                        :style="`font-family:${n.v.ff} !important;color: #3A7BFA;`">不判定</span>
                      <span v-else :style="`font-family:${n.v.ff} !important;`">待定</span>
                    </template>
                    <template v-if="
                      PROJECT == '检测中心' ||
                      (PROJECT == '装备电缆' &&
                        getInspectionValueType(n.i) != 2 &&
                        state == 1)
                    ">
                      <span v-if="n.v.v === 1" :style="`font-family:${n.v.ff} !important;color: green;`">合格</span>
                      <span v-else-if="n.v.v === 0" :style="`font-family:${n.v.ff} !important;color: red;`">不合格</span>
                      <span v-else-if="n.v.v === 3"
                        :style="`font-family:${n.v.ff} !important;color: #3A7BFA;`">不判定</span>
                      <span v-else :style="`font-family:${n.v.ff} !important;`">待定</span>
                      <span>{{ n.v.v }}</span>
                    </template>
                  </template>
                  <template v-else-if="
                    n.v.ps != undefined &&
                    n.v.ps.value === '设备编码' &&
                    state == 1
                  ">
                    <span>{{ n.v.v }}</span>
                  </template>
                  <template v-else-if="
                    n.v.ps != undefined && n.v.ps.value === '设备名称'
                  ">
                    <el-select v-model="n.v.v" :disabled="state > 1" class="table_input" filterable multiple
                      placeholder="设备" remote @change="(val) => changeEquip(val, n)"
                      @visible-change="(e) => getEquipOptions(e, n.i)">
                      <el-option v-for="item in equipOptions" :key="item.value" :label="item.label" :value="item.value">
                        {{ item.label + "--" + item.value }}
                      </el-option>
                    </el-select>
                  </template>
                  <template v-else-if="
                    n.v.ps != undefined &&
                    n.v.ps.value === '要求值' &&
                    state == 1
                  ">
                    <span :style="`font-family:${n.v.ff} !important;`">{{
                      getTell(n.i)
                    }}</span>
                  </template>
                  <template v-else-if="
                    n.v.ps != undefined &&
                    n.v.ps.value === '计算值' &&
                    state == 1
                  "><span :style="`font-family:${n.v.ff} !important;`">{{
                    toFixed(n.v.v, n.v.ct)
                      }}</span></template>
                  <template v-else-if="
                    n.v.ps != undefined &&
                    n.v.ps.value === '最终值' &&
                    state == 1
                  ">
                    <span :style="`font-family:${n.v.ff} !important;`">{{
                    <template v-else-if="
                      n.v.ps != undefined && n.v.ps.value === '设备名称'
                    ">
                      <el-select v-model="n.v.v" :disabled="state > 1" class="table_input" filterable multiple
                        placeholder="设备" remote @change="(val) => changeEquip(val, n)"
                        @visible-change="(e) => getEquipOptions(e, n.i)">
                        <el-option v-for="item in equipOptions" :key="item.value" :label="item.label"
                          :value="item.value">
                          {{ item.label + "--" + item.value }}
                        </el-option>
                      </el-select>
                    </template>
                    <template v-else-if="
                      n.v.ps != undefined &&
                      n.v.ps.value === '要求值' &&
                      state == 1
                    ">
                      <span :style="`font-family:${n.v.ff} !important;`">{{
                        getTell(n.i)
                      }}</span>
                    </template>
                    <template v-else-if="
                      n.v.ps != undefined &&
                      n.v.ps.value === '计算值' &&
                      state == 1
                    "><span :style="`font-family:${n.v.ff} !important;`">{{
                      toFixed(n.v.v, n.v.ct)
                    }}</span>
                  </template>
                  <template v-else-if="
                    n.v.ps != undefined && n.v.ps.value === '样品编号'
                  ">
                    <div :title="currentSample.sampleCode" style="
                    }}</span></template>
                    <template v-else-if="
                      n.v.ps != undefined &&
                      n.v.ps.value === '最终值' &&
                      state == 1
                    ">
                      <span :style="`font-family:${n.v.ff} !important;`">{{
                        toFixed(n.v.v, n.v.ct)
                      }}</span>
                    </template>
                    <template v-else-if="
                      n.v.ps != undefined && n.v.ps.value === '样品编号'
                    ">
                      <div :title="currentSample.sampleCode" style="
                        display: flex;
                        flex-wrap: nowrap;
                        align-items: center;
                        width: 100%;
                      ">
                      <i v-if="!currentFiberOpticTape && !currentFiberOptic" class="el-icon-caret-left table_caret"
                        style="width: 16px" @click="caretSample(-1)"></i>
                      <div
                        :style="`font-family:${n.v.ff} !important;overflow: hidden;white-space: nowrap;width: calc(100% - 32px);`">
                        {{ currentSample.sampleCode }}
                        <i class="el-icon-caret-left table_caret" style="width: 16px" @click="caretSample(-1)"></i>
                        <div
                          :style="`font-family:${n.v.ff} !important;overflow: hidden;white-space: nowrap;width: calc(100% - 32px);`">
                          {{ currentSample.sampleCode }}
                        </div>
                        <i class="el-icon-caret-right table_caret" style="width: 16px" @click="caretSample(1)"></i>
                      </div>
                      <i v-if="!currentFiberOpticTape && !currentFiberOptic" class="el-icon-caret-right table_caret"
                        style="width: 16px" @click="caretSample(1)"></i>
                    </div>
                  </template>
                  <template v-else-if="
                    n.v.ps != undefined && n.v.ps.value === '样品型号'
                  ">
                    <div v-if="
                      currentSample.model !== undefined &&
                      currentSample.model !== null
                    " :style="`font-family:${n.v.ff} !important;`">
                      {{ currentSample.model }}
                    </div>
                  </template>
                  <span v-else :style="`font-family:${n.v.ff} !important;`" v-html="getValue(n.v)"></span>
                </div>
              </td>
            </tr>
          </tbody>
        </table>
                    </template>
                    <template v-else-if="
                      n.v.ps != undefined && n.v.ps.value === '样品型号'
                    ">
                      <div v-if="
                        currentSample.model !== undefined &&
                        currentSample.model !== null
                      " :style="`font-family:${n.v.ff} !important;`">
                        {{ currentSample.model }}
                      </div>
                    </template>
                    <span v-else :style="`font-family:${n.v.ff} !important;`" v-html="getValue(n.v)"></span>
                  </div>
                </td>
              </tr>
            </tbody>
          </table>
        </template>
      </div>
      <el-upload v-if="state == 1" ref="upload" :action="action" :before-upload="beforeUpload" :data="{
        orderId: id,
      }" :headers="headers" :on-error="onError" :on-success="handleSuccessUp" :show-file-list="false"
        accept=".jpg,.jpeg,.png,.gif,.doc,.docx,.xls,.xlsx,.ppt,.pptx,.pdf,.zip,.rar" style="width: 80px !important">
        accept=".jpg,.jpeg,.png,.gif,.doc,.docx,.xls,.xlsx,.ppt,.pptx,.pdf,.zip,.rar"
        style="width: 80px !important;margin-top: 10px;">
        <el-button v-if="state == 1" size="small" type="primary">附件上传</el-button></el-upload>
      <lims-table :tableData="tableData" :column="column" :page="page" :tableLoading="tableLoading"
        :height="'calc(100vh - 290px)'" @pagination="pagination"></lims-table>
      <!-- <ValueTable :key="upIndex" ref="fileList" :componentData="componentData0" :delUrl="$api.insOrderPlan.delfile"
        :url="$api.insOrderPlan.getFileList" class="value-table" style="height: 100%; margin-top: 16px" /> -->
        :height="'calc(100vh - 290px)'" @pagination="pagination" style="height: 100%; margin-top: 16px"></lims-table>
    </div>
    <el-drawer :size="550" :visible.sync="sampleVisible" title="样品切换">
      <el-table v-if="sampleVisible" ref="productTable" :current-row-key="currentKey" :data="sampleProduct"
@@ -390,8 +375,8 @@
      </el-table>
    </el-drawer>
    <el-drawer :size="500" :visible.sync="taskVisible" title="任务切换">
      <!-- <ValueTable :key="upIndex" ref="insOrderPlan" :componentData="componentData"
        :url="$api.insOrderPlan.inspectionOrderDetailsTaskSwitching" class="value-table" style="height: 100%" /> -->
      <lims-table :tableData="tableData0" :column="column0" :page="page0" :tableLoading="tableLoading0"
        :height="'calc(100vh - 90px)'" :currentChange="handleChangeTask"></lims-table>
    </el-drawer>
    <el-dialog :visible.sync="reviewDia" title="检验复核" width="500px">
      <div v-if="reviewDia" class="body" style="display: flex; padding: 10px">
@@ -521,42 +506,23 @@
    </el-dialog>
    <add-un-pass v-if="addUnPassDialog" ref="addUnPassDialog" :addUnPassDialog="addUnPassDialog"
      @resetAddUnPass="resetAddUnPass"></add-un-pass>
    <!-- <UnPassDialog
      v-if="unPassDialog"
      ref="unPassDialog"
      :orderId="orderId"
      :unPassDialog="unPassDialog"
      @resetForm="resetForm"
    ></UnPassDialog> -->
    <!-- <InspectionWord
      v-if="unPassCheck"
      :inspectorList="inspectorList"
      :orderId="orderId"
      :rawMaterialTag="rawMaterialTag"
      :sonLaboratory="sonLaboratory"
      :state="state"
      :typeSource="typeSource"
      :unPassCheck="unPassCheck"
      @closeUnPassCheckDialog="closeUnPassCheckDialog"
      @refreshView="refreshView"
    /> -->
    <!-- <purchase-verification
      v-if="purchaseDialog"
      ref="purchaseDialog"
      :orderId="orderId"
      :purchaseDialog="purchaseDialog"
      @resetPurchaseDialog="resetPurchaseDialog"
    ></purchase-verification> -->
    <UnPassDialog v-if="unPassDialog" ref="unPassDialog" :orderId="orderId" :unPassDialog="unPassDialog"
      @resetForm="resetForm"></UnPassDialog>
    <!-- <InspectionWord v-if="unPassCheck" :inspectorList="inspectorList" :orderId="orderId"
      :rawMaterialTag="rawMaterialTag" :sonLaboratory="sonLaboratory" :state="state" :typeSource="typeSource"
      :unPassCheck="unPassCheck" @closeUnPassCheckDialog="closeUnPassCheckDialog" @refreshView="refreshView" /> -->
    <purchase-verification v-if="purchaseDialog" ref="purchaseDialog" :orderId="orderId"
      :purchaseDialog="purchaseDialog" @resetPurchaseDialog="resetPurchaseDialog"></purchase-verification>
  </div>
</template>

<script>
import excelFunction from "@/utils/excelFountion";
import limsTable from "@/components/Table/lims-table.vue";
// import UnPassDialog from "../b1-unpass-manage/unPassDialog.vue";
// import AddUnPass from "../b1-unpass-manage/addUnPass.vue";
// import InspectionWord from "./InspectionWord.vue";
// import PurchaseVerification from "../b1-unpass-manage/PurchaseVerification.vue";
import UnPassDialog from "../unpass/components/addUnPass.vue";
import AddUnPass from "../unpass/components/addUnPass.vue";
// import InspectionWord from "./components/InspectionWord.vue";
import PurchaseVerification from "../unpass/components/PurchaseVerification.vue";
import {
  doInsOrder,
  getCableTag,
@@ -565,8 +531,6 @@
  dataCollection,
  write,
  getInsProduct,
  getReportModel,
  determineWhetherToCollectData,
  search,
  verifyPlan,
  checkSubmitPlan,
@@ -575,17 +539,19 @@
  selectUserCondition,
  downFile,
  getFileList,
  delfile
  delfile,
  inspectionOrderDetailsTaskSwitching
} from "@/api/business/inspectionTask.js";
import InspectionWorker from '../../../InspectionWorker.worker';
import DataWorker from '../../../DataWorker.worker';
import html2canvas from "html2canvas";
import { mapGetters } from "vuex";
export default {
  // props: ["sonLaboratory", "orderId", "state", "inspectorList", "typeSource"],
  components: {
    // PurchaseVerification,
    // AddUnPass,
    PurchaseVerification,
    AddUnPass,
    limsTable,
    // UnPassDialog,
    UnPassDialog,
    // InspectionWord,
  },
  data() {
@@ -606,7 +572,6 @@
        load: null,
      },
      dataGetDia: false,
      wareTableDataLoading: false,
      fileAdd: false,
      sampleVisible: false,
      taskVisible: false,
@@ -616,34 +581,7 @@
        state: null,
      },
      id: null,
      componentData: {
        entity: {
          sonLaboratory: null,
          userId: 0,
        },
        isIndex: false,
        showSelect: false,
        select: false,
        selectMethod: "handleChangeTask",
        sort: false,
        do: [],
        isPage: false,
        linkEvent: {},
        tagField: {
          type: {
            select: [],
          },
          insState: {
            select: [],
          },
        },
        currentId: "",
        selectField: {},
        requiredAdd: [],
        requiredUp: [],
      },
      changeType: null,
      getReportModelLoading: false,
      insOrder: {},
      sampleProduct: [],
      supplierDensity: "", // åŽ‚家密度
@@ -672,30 +610,14 @@
      verifyUser: null,
      personList: [],
      enumList: [],
      fiberOpticVisible: false,
      fiberOpticTapeVisible: false,
      bushingVisible: false,
      fiberOpticTape: [], //光纤带列表
      fiberOptic: [], //光纤列表
      bushing: [], //套管列表
      currentFiberOpticTape: null, //当前光纤带
      currentFiberOptic: null, //当前光纤
      currentBushing: null, //当前套管
      tableLoading: false,
      upLoading: false,
      temptList: null,
      fiber: [],
      fibers: [],
      casing: [],
      currentTab: null,
      wareForm: {
        inspectionItem: 1,
        inspectionItemSubclass: "20(常温)",
      },
      wareForm0: {},
      numOptions: [],
      temperatureOptions: [],
      wareTableData: [],
      otherForm: {
        humidity: null,
        temperature: null,
@@ -713,18 +635,8 @@
      dataAcquisitionInfo: {},
      dataAcquisitionInfoNew: {},
      dataAcquisitionEidtAble: false,
      isGet: false,
      dataAcquisitionLoading: false,
      collected: false,
      // çƒ­å¾ªçŽ¯---开始
      thermalCyclingInfo: {
        max: 0,
        inspectionItem: 1,
        arr: [],
        length: 1,
        inspectionItemClass: null,
      },
      thermalCyclingLoading: false,
      temDataAcquisition: false,
      getData: [
        {
@@ -781,7 +693,7 @@
            } else {
              return '文件'
            }
          },
          }
        },
        { label: "附件名称", prop: "fileName" },
        { label: "上传人", prop: "name" },
@@ -818,6 +730,39 @@
      },
      tableLoading: false,
      // æ–‡ä»¶åˆ—表相关--结束
      // ä»»åŠ¡åˆ‡æ¢åˆ—表--开始
      tableData0: [],
      column0: [
        { label: "委托编号", prop: "entrustCode", width: '160px' },
        { label: "检验对象", prop: "sampleType", width: '140px' },
        {
          label: "紧急程度", prop: "type", dataType: "tag",
          formatData: (params) => {
            return this.urgentList.find(m => m.value == params).label
          },
          formatType: (params) => {
            return this.urgentList.find(m => m.value == params).type
          }
        },
        {
          label: "状态", prop: "insState", dataType: "tag",
          formatData: (params) => {
            return this.typeList.find(m => m.value == params).label
          },
          formatType: (params) => {
            return this.typeList.find(m => m.value == params).type
          }
        },
        { label: "约定时间", prop: "appointed", width: '140px' },
        { label: "下发时间", prop: "sendTime", width: '140px' },
      ],
      page0: {
        total: 0,
        size: -1,
        current: -1,
      },
      tableLoading0: false,
      // ä»»åŠ¡åˆ‡æ¢åˆ—表--结束
    };
  },
  // ç”¨äºŽä¸Šä¼ æ–‡ä»¶çš„信息
@@ -833,8 +778,6 @@
    },
  },
  created() {
    this.componentData.entity.sonLaboratory = this.sonLaboratory;
    this.getUserInfo();
    let { sonLaboratory, orderId, state, inspectorList, typeSource } =
      this.$route.query;
    this.sonLaboratory = sonLaboratory;
@@ -849,89 +792,15 @@
    this.getInsStateDicts();
    this.getComparisonList();
    this.getAuthorizedPerson();
    this.scrollInit();
    // this.getPower();
    this.startWorker();
    this.getList0()
    this.scrollInit();
  },
  watch: {
    // ç›‘听任务id，获取任务信息
    id(val) {
      this.loading = true;
      doInsOrder({
        id: val,
        laboratory: this.sonLaboratory,
      }).then(async (res) => {
        this.insOrder = res.data.insOrder;
        this.supplierDensity = res.data.supplierDensity;
        this.getList()
        this.urgentList.forEach((m) => {
          if (m.value == this.insOrder.type) {
            this.insOrder.typeName = m.label;
          }
        });
        this.loading = false;
        if (!res.data.sampleProduct || res.data.sampleProduct.length == 0) {
          this.$emit("goback");
          return this.$message.error("该任务没有样品信息");
        }
        // èµ‹å€¼å½“前样品列表
        this.sampleProduct = res.data.sampleProduct;
        this.currentSample = this.HaveJson(this.sampleProduct[0]);
        let insProduct = this.HaveJson(this.currentSample.insProduct);
        // æ¸©åº¦ã€æ¹¿åº¦èµ‹å€¼
        this.otherForm = {
          temperature: this.insOrder.temperature
            ? this.insOrder.temperature
            : null,
          humidity: this.insOrder.humidity ? this.insOrder.humidity : null,
        };
        if (this.typeSource == "1") {
          this.getRawMaterialTag(this.currentSample.id); // åŽŸææ–™çš„检验任务查询批数
          this.rawMaterialTag = "1";
        }
        this.getEquipOptions(1);
        // èŽ·å–当前样品的检验项
        let list = await this.getCurrentProduct(this.currentSample.id, 0);
        this.currentSample.insProduct = this.HaveJson(list);
        // åˆå§‹åŒ–传递到后端的参数
        this.param = {};
        this.changeType = 0;
        this.currentSample.insProduct.forEach((a) => {
          // æ˜¯å¦ä¸ºæˆå“ç”µç¼†ä¸‹çš„松套管项目，不是则执行初始化
          if (this.handleCasing(a.inspectionItem)) {
            this.param[a.id] = {
              insValue: [],
              comValue: [],
              resValue: null,
              equipValue: [],
              equipName: [],
              insResult: null,
            };
          }
        });
        this.determineWhetherToCollectData(); //是否需要数采
        this.getReportModel(this.currentSample.id); //获取套管、光纤带、光纤信息
        if (this.currentSample.index == undefined)
          this.currentSample["index"] = 1;
        let bushing = this.currentSample.bushing;
        this.getTableLists(); //处理模板列表信息

        this.componentData.currentId = val;
        this.currentKey = 1;
        this.getCableTag(this.currentSample.id); // æŸ¥è¯¢æ˜¯å¦æœ‰è¦å¤šæ¬¡æ£€éªŒçš„电缆配置
        this.getRepetitionTag(this.currentSample.id); // æŸ¥è¯¢æ˜¯å¦æœ‰è¦é‡å¤æ£€éªŒé¡¹
        // æ¸…空光纤配置相关数据---下面信息暂时可忽略
        this.fiberOpticTape = [];
        this.currentFiberOpticTape = null;
        this.fiberOptic = [];
        this.currentFiberOptic = null;
        this.bushing = [];
        this.currentBushing = null;
        this.currentTab = null;
        if (bushing && bushing.length > 0) {
          this.bushing = bushing;
        }
      });
      this.refreshView()
    },
    // ç›‘听当前模板变化
    currentTable(val1, val0) {
@@ -946,18 +815,15 @@
            this.currentSample.insProduct = this.HaveJson(list); //赋值当前样品的检验项
            this.param = {}; //初始化传到后端的参数
            this.currentSample.insProduct.forEach((a, j) => {
              if (this.handleCasing(a.inspectionItem)) {
                this.param[a.id] = {
                  insValue: [],
                  comValue: [],
                  resValue: null,
                  equipValue: [],
                  equipName: [],
                  insResult: null,
                };
              }
              this.param[a.id] = {
                insValue: [],
                comValue: [],
                resValue: null,
                equipValue: [],
                equipName: [],
                insResult: null,
              };
            });
            this.getReportModel(this.currentSample.id); //获取套管、光纤带、光纤信息
            // åŽ»é‡æ¨¡æ¿ï¼Œè¿”回有几个模板
            const mySet1 = new Set();
            this.tableLists = this.currentSample.insProduct.filter((m) => {
@@ -1041,13 +907,89 @@
    },
    // æ–‡ä»¶ç®¡ç†--结束

    // ä»»åŠ¡åˆ‡æ¢--开始
    getList0() {
      this.tableLoading0 = true;
      let param = { userId: this.userId, sonLaboratory: this.sonLaboratory, ...this.page0 };
      delete param.total;
      inspectionOrderDetailsTaskSwitching({ ...param })
        .then((res) => {
          this.tableLoading0 = false;
          if (res.code === 200) {
            this.tableData0 = res.data.records;
          }
        })
        .catch((err) => {
          this.tableLoading0 = false;
        });
    },
    // ä»»åŠ¡åˆ‡æ¢--结束

    closeAddVerifyDia() {
      this.addCheck = false;
      this.checkUser = "";
    },
    // åˆ·æ–°é¡µé¢
    refreshView() {
      this.$emit("refreshView");
      this.loading = true;
      doInsOrder({
        id: this.id,
        laboratory: this.sonLaboratory,
      }).then(async (res) => {
        this.insOrder = res.data.insOrder;
        this.supplierDensity = res.data.supplierDensity;
        this.getList()
        this.urgentList.forEach((m) => {
          if (m.value == this.insOrder.type) {
            this.insOrder.typeName = m.label;
          }
        });
        this.loading = false;
        if (!res.data.sampleProduct || res.data.sampleProduct.length == 0) {
          this.goback();
          return this.$message.error("该任务没有样品信息");
        }
        // èµ‹å€¼å½“前样品列表
        this.sampleProduct = res.data.sampleProduct;
        this.currentSample = this.HaveJson(this.sampleProduct[0]);
        let insProduct = this.HaveJson(this.currentSample.insProduct);
        // æ¸©åº¦ã€æ¹¿åº¦èµ‹å€¼
        this.otherForm = {
          temperature: this.insOrder.temperature
            ? this.insOrder.temperature
            : null,
          humidity: this.insOrder.humidity ? this.insOrder.humidity : null,
        };
        if (this.typeSource == "1") {
          this.getRawMaterialTag(this.currentSample.id); // åŽŸææ–™çš„检验任务查询批数
          this.rawMaterialTag = "1";
        }
        this.getEquipOptions(1);
        // èŽ·å–当前样品的检验项
        let list = await this.getCurrentProduct(this.currentSample.id, 0);
        this.currentSample.insProduct = this.HaveJson(list);
        // åˆå§‹åŒ–传递到后端的参数
        this.param = {};
        this.changeType = 0;
        this.currentSample.insProduct.forEach((a) => {
          this.param[a.id] = {
            insValue: [],
            comValue: [],
            resValue: null,
            equipValue: [],
            equipName: [],
            insResult: null,
          };
        });
        if (this.currentSample.index == undefined)
          this.currentSample["index"] = 1;
        let bushing = this.currentSample.bushing;
        this.getTableLists(); //处理模板列表信息

        this.currentKey = 1;
        this.getCableTag(this.currentSample.id); // æŸ¥è¯¢æ˜¯å¦æœ‰è¦å¤šæ¬¡æ£€éªŒçš„电缆配置
        this.getRepetitionTag(this.currentSample.id); // æŸ¥è¯¢æ˜¯å¦æœ‰è¦é‡å¤æ£€éªŒé¡¹
      });
    },
    closeUnPassCheckDialog() {
      this.unPassCheck = false;
@@ -1336,11 +1278,11 @@
                      n.v.ps.value.includes("检验值")
                    ) {
                      num++;
                      if (str0 == str) {
                        maxNum = num;
                      }
                    }
                  });
                  if (str0 == str) {
                    maxNum = num;
                  }
                }
                // ç»‘定设备
                if (
@@ -1510,12 +1452,12 @@
        this.stopWorker(); // ç¡®ä¿ä¹‹å‰çš„ Worker å·²åœæ­¢
      }
      // åˆ›å»º Worker å®žä¾‹
      this.worker = new Worker("/static/js/worker.js");
      this.worker = new InspectionWorker();
      if (this.worker0) {
        this.stopWorker(); // ç¡®ä¿ä¹‹å‰çš„ Worker å·²åœæ­¢
      }
      // åˆ›å»º Worker å®žä¾‹
      this.worker0 = new Worker("/static/js/worker0.js");
      this.worker0 = new DataWorker();
    },
    // åœæ­¢å¤šçº¿ç¨‹
    stopWorker() {
@@ -1528,7 +1470,6 @@
        this.worker0 = null;
      }
    },
    // çƒ­å¾ªçŽ¯---结束
    // ä¿å­˜æ¹¿åº¦ã€æ¸©åº¦æ•°æ®
    subOtherForm(m, type) {
      console.log("m---", m);
@@ -1617,13 +1558,6 @@
    async handleChangeSample(row, column, event) {
      // åˆå§‹åŒ–数据
      this.param = {};
      // æ¸…空光纤配置相关数据
      this.fiberOpticTape = [];
      this.currentFiberOpticTape = null;
      this.fiberOptic = [];
      this.currentFiberOptic = null;
      this.bushing = [];
      this.currentBushing = null;
      this.sampleVisible = false;
      // èµ‹å€¼æ ·å“
      this.currentSample = this.HaveJson(row);
@@ -1634,23 +1568,15 @@
      this.param = {};
      this.changeType = 0;
      this.currentSample.insProduct.forEach((a, j) => {
        if (this.handleCasing(a.inspectionItem)) {
          this.param[a.id] = {
            insValue: [],
            comValue: [],
            resValue: null,
            equipValue: [],
            equipName: [],
            insResult: null,
          };
        }
        this.param[a.id] = {
          insValue: [],
          comValue: [],
          resValue: null,
          equipValue: [],
          equipName: [],
          insResult: null,
        };
      });
      // èŽ·å–套管,光纤带,光纤数据
      this.getReportModel(row.id);
      let bushing = this.currentSample.bushing;
      if (bushing && bushing.length > 0) {
        this.bushing = bushing;
      }
      // å¤„理页面列表数据
      this.getTableLists();
      this.currentKey = row.index;
@@ -1665,33 +1591,6 @@
          currentTable: this.currentTable,
        })
      );
    },
    // æ¾å¥—管的判断\如果changeType不等于3那么页面不展示松套管检验项
    handleCasing(inspectionItem) {
      if (this.changeType != 3) {
        if (inspectionItem.includes("松套管")) {
          return false;
        } else {
          return true;
        }
      } else {
        return true;
      }
    },
    // èŽ·å–套管,光纤带,光纤数据
    getReportModel(id) {
      if (this.PROJECT != "检测中心") {
        return;
      }
      this.getReportModelLoading = true;
      getReportModel({
        sampleId: id
      }).then((res) => {
        this.getReportModelLoading = false;
        this.fibers = res.data["光纤带"];
        this.fiber = res.data["光纤"];
        this.casing = res.data["套管"];
      });
    },
    async handleChangeCableTag(m, type, num, m2) {
      let cableTag = "";
@@ -1724,7 +1623,6 @@
            };
          });
          this.getTableLists0(list);
          this.getReportModel(this.currentSample.id);
          this.worker.postMessage(
            JSON.stringify({
              type: "saveData",
@@ -1743,21 +1641,19 @@
    },
    // æ”¹å˜ä»»åŠ¡
    handleChangeTask(row) {
      if (row.length > 0) this.id = row[0].id;
      if (row) this.id = row.id;
      this.taskVisible = false;
    },
    // å­—典获取信息
    getTypeDicts() {
      this.getDicts("urgency_level").then((response) => {
        this.urgentList = this.dictToValue(response.data);
        this.componentData.tagField.type.select = this.urgentList;
      });
    },
    // å­—典获取信息
    getInsStateDicts() {
      this.getDicts("inspection_task_state").then((response) => {
        this.typeList = this.dictToValue(response.data);
        this.componentData.tagField.insState.select = this.typeList;
      });
    },
    // å­—典获取信息
@@ -2196,7 +2092,8 @@
          }
        });
        // ä»¥ä¸‹æ˜¯æ ·å¼å¤„理逻辑
        set = Array.sort(set);
        set = [...set]
        // set = set.sort();
        set.forEach((b) => {
          let arr = [];
          a.template.forEach((c) => {
@@ -2406,11 +2303,6 @@
          this.saveInsContext(currentInsItemId);
        }
      }, 200);
    },
    // æ˜¯å¦éœ€è¦æ•°é‡‡
    async determineWhetherToCollectData() {
      let res = await determineWhetherToCollectData({ managementNumber: '' })
      this.isGet = res.data;
    },
    // æ ¹æ®åŽç«¯ä¼ å‚更新页面数据   param => this.tableList[0].insProductResult
    getCurrentInsProduct(pId) {
@@ -2635,9 +2527,6 @@
    //     }
    //   }
    // },
    getUserInfo() {
      this.componentData.entity.userId = this.userId;
    },
    openAddCheck() {
      this.addCheck = true;
    },
@@ -2655,7 +2544,7 @@
        }).then((res) => {
          if (res.code === 200) {
            this.$message.success("操作成功");
            this.$emit("goback");
            this.goback();
            this.addCheck = false;
          }
          this.reviewLoading = false;
@@ -2680,7 +2569,7 @@
        }).then((res) => {
          if (res.code === 200) {
            this.$message.success("操作成功");
            this.$emit("goback");
            this.goback();
          }
          this.reviewLoading = false;
        })
@@ -2721,7 +2610,7 @@
            }).then((res) => {
              if (res.code === 200) {
                this.$message.success("操作成功");
                this.$emit("goback");
                this.goback();
                this.submitLoading = false;
                this.addVerifyDia = false;
              }
@@ -2773,7 +2662,7 @@
                  if (res.code === 200) {
                    this.$message.success("操作成功");
                    this.addVerifyDia = false;
                    this.$emit("goback");
                    this.goback();
                  }
                  this.submitLoading = false;
                })
@@ -2806,6 +2695,8 @@
            param: JSON.stringify(param),
            currentTable: this.currentTable,
            sampleId: this.currentSample.id,
            orderId: this.orderId,
            sonLaboratory: this.sonLaboratory
          }).then((res) => {
            if (res.code == 201) {
              this.$message.error("保存失败");
@@ -2936,16 +2827,14 @@
      this.param = {};
      this.changeType = 0;
      this.currentSample.insProduct.forEach((a, j) => {
        if (this.handleCasing(a.inspectionItem)) {
          this.param[a.id] = {
            insValue: [],
            comValue: [],
            resValue: null,
            equipValue: [],
            equipName: [],
            insResult: null,
          };
        }
        this.param[a.id] = {
          insValue: [],
          comValue: [],
          resValue: null,
          equipValue: [],
          equipName: [],
          insResult: null,
        };
      });
      // é¡µé¢æ•°æ®å¤„理
      this.getTableLists();
@@ -3016,6 +2905,9 @@
        return v;
      }
    },
    goback() {
      this.$tab.closeOpenPage({ path: "/business/inspectionTask" });
    }
  },
};
</script>
@@ -3048,13 +2940,14 @@
.title {
  height: 60px;
  line-height: 60px;
  padding: 0 16px;
}

.search {
  width: 100%;
  margin-bottom: 10px;
  background-color: #fff;
  border-radius: 3px;
  margin-bottom: 10px;
}

.search .form-inline {
@@ -3064,7 +2957,7 @@
}

.center {
  width: calc(100% - 40px);
  width: 100%;
  /* max-height: 580px; */
  background-color: #fff;
  border-radius: 3px;
@@ -3091,6 +2984,7 @@
.tables {
  table-layout: fixed;
  margin: 5px 5px 16px;
  border-collapse: collapse;
}

.tables td {
@@ -3221,9 +3115,9 @@
}
</style>
<style>
.inspection .el-form-item__label {
/* .inspection .el-form-item__label {
  color: #000;
}
} */

.inspection .el-drawer__header::before {
  content: "";

 src/views/business/materialOrder/index.vue

@@ -3,60 +3,50 @@
    <div>
      <div class="search">
        <el-form :model="entity" ref="entity" size="small" :inline="true"><el-form-item label="批号" prop="updateBatchNo">
          <el-input v-model="entity.updateBatchNo" clearable placeholder="请输入"
                    size="small"
                    @keyup.enter.native="refreshTable">
          </el-input>
        </el-form-item><el-form-item label="委托编号" prop="entrustCode">
          <el-input v-model="entity.entrustCode" clearable placeholder="请输入"
                    size="small"
                    @keyup.enter.native="refreshTable">
          </el-input>
        </el-form-item><el-form-item label="零件号" prop="partNo">
          <el-input v-model="entity.partNo" clearable placeholder="请输入"
                    size="small"
                    @keyup.enter.native="refreshTable">
          </el-input>
        </el-form-item><el-form-item label="零件描述" prop="partDesc">
          <el-input v-model="entity.partDesc" clearable placeholder="请输入"
                    size="small"
                    @keyup.enter.native="refreshTable">
          </el-input>
        </el-form-item>
            <el-input v-model="entity.updateBatchNo" clearable placeholder="请输入" size="small"
              @keyup.enter.native="refreshTable">
            </el-input>
          </el-form-item><el-form-item label="委托编号" prop="entrustCode">
            <el-input v-model="entity.entrustCode" clearable placeholder="请输入" size="small"
              @keyup.enter.native="refreshTable">
            </el-input>
          </el-form-item><el-form-item label="零件号" prop="partNo">
            <el-input v-model="entity.partNo" clearable placeholder="请输入" size="small"
              @keyup.enter.native="refreshTable">
            </el-input>
          </el-form-item><el-form-item label="零件描述" prop="partDesc">
            <el-input v-model="entity.partDesc" clearable placeholder="请输入" size="small"
              @keyup.enter.native="refreshTable">
            </el-input>
          </el-form-item>
          <el-form-item>
            <el-button v-if="tabIndex === 2 || tabIndex === 3 || tabIndex === 4" :icon="!more?'el-icon-arrow-down':'el-icon-arrow-up'" style="color: #3A7BFA;" type="text" @click="more=!more">{{!more?'更多':'收起'}}</el-button>
            <el-button v-if="tabIndex === 2 || tabIndex === 3 || tabIndex === 4"
              :icon="!more ? 'el-icon-arrow-down' : 'el-icon-arrow-up'" style="color: #3A7BFA;" type="text"
              @click="more = !more">{{ !more ? '更多' : '收起' }}</el-button>
            <el-button size="mini" type="primary" @click="refreshTable()">查询</el-button>
            <el-button size="mini" @click="refresh()">重置</el-button>
          </el-form-item>
          <el-form-item label="供应商名称" prop="supplierName" v-if="(tabIndex === 2 || tabIndex === 3 || tabIndex === 4) && more">
            <el-input v-model="entity.supplierName" clearable placeholder="请输入"
                      size="small"
                      @keyup.enter.native="refreshTable">
          <el-form-item label="供应商名称" prop="supplierName"
            v-if="(tabIndex === 2 || tabIndex === 3 || tabIndex === 4) && more">
            <el-input v-model="entity.supplierName" clearable placeholder="请输入" size="small"
              @keyup.enter.native="refreshTable">
            </el-input>
          </el-form-item>
          <el-form-item label="样品型号" prop="sampleModel" v-if="(tabIndex === 2 || tabIndex === 3 || tabIndex === 4) && more">
            <el-input v-model="entity.sampleModel" clearable placeholder="请输入"
                      size="small"
                      @keyup.enter.native="refreshTable">
          <el-form-item label="样品型号" prop="sampleModel"
            v-if="(tabIndex === 2 || tabIndex === 3 || tabIndex === 4) && more">
            <el-input v-model="entity.sampleModel" clearable placeholder="请输入" size="small"
              @keyup.enter.native="refreshTable">
            </el-input>
          </el-form-item>
          <el-form-item label="检验状态" prop="inspectStatus" v-if="(tabIndex === 2 || tabIndex === 3 || tabIndex === 4) && more">
            <el-select v-model="entity.inspectStatus" clearable
                       size="small" @change="refreshTable()">
          <el-form-item label="检验状态" prop="inspectStatus"
            v-if="(tabIndex === 2 || tabIndex === 3 || tabIndex === 4) && more">
            <el-select v-model="entity.inspectStatus" clearable size="small" @change="refreshTable()">
              <el-option v-for="(a, i) in inspectStatusList" :key="i" :label="a.label" :value="a.value"></el-option>
            </el-select>
          </el-form-item>
          <el-form-item label="下发时间" prop="date" v-if="(tabIndex === 2 || tabIndex === 3 || tabIndex === 4) && more">
            <el-date-picker
              v-model="entity.date"
              end-placeholder="结束日期"
              format="yyyy-MM-dd"
              placeholder="选择日期"
              range-separator="至"
              size="small"
              start-placeholder="开始日期"
              type="daterange"
              value-format="yyyy-MM-dd">
            <el-date-picker v-model="entity.date" end-placeholder="结束日期" format="yyyy-MM-dd" placeholder="选择日期"
              range-separator="至" size="small" start-placeholder="开始日期" type="daterange" value-format="yyyy-MM-dd">
            </el-date-picker>
          </el-form-item>
        </el-form>
@@ -65,48 +55,45 @@
        <div class="table-tab">
          <div>
            <ul class="tab">
              <li v-for="(m,i) in tabList" :key="m.value" :class="{active:m.value===tabIndex}" @click="handleTab(m)">{{m.label}}</li>
              <li v-for="(m, i) in tabList" :key="m.value" :class="{ active: m.value === tabIndex }" @click="handleTab(m)">
                {{ m.label }}</li>
            </ul>
          </div>
          <div>
            <el-button v-show="tabIndex === 3 || tabIndex === 2" :loading="outLoading" size="small" type="primary" @click="handleOut">导出</el-button>
            <el-button v-show="tabIndex === 3 || tabIndex === 2" :loading="outLoading" size="small" type="primary"
              @click="handleOut">导出</el-button>
            <el-button v-if="tabIndex === 0" size="small" type="primary" @click="copper">铜材料下单</el-button>
            <el-button v-if="tabIndex !== 0" size="small" type="primary" @click="openPrint">标签打印</el-button>
          </div>
        </div>
        <!--待下单-->
        <div class="table">
          <lims-table :tableData="tableData" :column="column" v-if="tabIndex === 0"
            @pagination="pagination" :height="'calc(100vh - 290px)'" key="tableData"
            :page="page" :tableLoading="tableLoading"></lims-table>
          <lims-table :tableData="tableData" :column="column" v-if="tabIndex === 0" @pagination="pagination"
            :height="'calc(100vh - 290px)'" key="tableData" :page="page" :tableLoading="tableLoading"></lims-table>
        </div>
        <!--检验中-->
        <div class="table">
          <lims-table :tableData="tableData1" :column="column1" v-if="tabIndex === 1"
                      :isSelection="true" :handleSelectionChange="selectMethod"
                      @pagination="pagination1" :height="'calc(100vh - 290px)'" key="tableData1"
                      :page="page1" :tableLoading="tableLoading1"></lims-table>
          <lims-table :tableData="tableData1" :column="column1" v-if="tabIndex === 1" :isSelection="true"
            :handleSelectionChange="selectMethod" @pagination="pagination1" :height="'calc(100vh - 290px)'"
            key="tableData1" :page="page1" :tableLoading="tableLoading1"></lims-table>
        </div>
        <!--已检验-->
        <div class="table">
          <lims-table :tableData="tableData2" :column="column2" v-if="tabIndex === 2"
                      :isSelection="true" :handleSelectionChange="selectMethod"
                      @pagination="pagination2" :height="'calc(100vh - 290px)'" key="tableData2"
                      :page="page2" :tableLoading="tableLoading2"></lims-table>
          <lims-table :tableData="tableData2" :column="column2" v-if="tabIndex === 2" :isSelection="true"
            :handleSelectionChange="selectMethod" @pagination="pagination2" :height="'calc(100vh - 290px)'"
            key="tableData2" :page="page2" :tableLoading="tableLoading2"></lims-table>
        </div>
        <!--全部-->
        <div class="table">
          <lims-table :tableData="tableData3" :column="column3" v-if="tabIndex === 3"
                      :isSelection="true" :handleSelectionChange="selectMethod"
                      @pagination="pagination3" :height="'calc(100vh - 290px)'" key="tableData3"
                      :page="page3" :tableLoading="tableLoading3"></lims-table>
          <lims-table :tableData="tableData3" :column="column3" v-if="tabIndex === 3" :isSelection="true"
            :handleSelectionChange="selectMethod" @pagination="pagination3" :height="'calc(100vh - 290px)'"
            key="tableData3" :page="page3" :tableLoading="tableLoading3"></lims-table>
        </div>
        <!--季度检验-->
        <div class="table">
          <lims-table :tableData="tableData4" :column="column4" v-if="tabIndex === 4"
                      :isSelection="true" :handleSelectionChange="selectMethod"
                      @pagination="pagination4" :height="'calc(100vh - 290px)'" key="tableData4"
                      :page="page4" :tableLoading="tableLoading4"></lims-table>
          <lims-table :tableData="tableData4" :column="column4" v-if="tabIndex === 4" :isSelection="true"
            :handleSelectionChange="selectMethod" @pagination="pagination4" :height="'calc(100vh - 290px)'"
            key="tableData4" :page="page4" :tableLoading="tableLoading4"></lims-table>
        </div>
      </div>
    </div>
@@ -114,9 +101,8 @@
    <el-dialog :visible.sync="exemptionVisible" title="确认免检" width="42%">
      <div style="display: flex">
        <span style="width: 90px; line-height: 32px">规格型号：</span>
        <el-input v-model="exemptionInfo.partDetail" clearable placeholder="请输入"
                  size="small"
                  @keyup.enter.native="refreshTable"></el-input>
        <el-input v-model="exemptionInfo.partDetail" clearable placeholder="请输入" size="small"
          @keyup.enter.native="refreshTable"></el-input>
      </div>
      <span slot="footer" class="dialog-footer">
        <el-row>
@@ -128,13 +114,14 @@
    <!-- æ’¤é”€æŠ¥æ£€ -->
    <el-dialog :visible.sync="declareDialogVisible" title="报检撤销" width="30%">
      <p style="font-size:16px;color:#333333">批号<span
        style="color:#34BD66">{{this.insOrderRow.updateBatchNo}}</span>的信息是否<span style="color: #FF4902">撤销报检</span></p>
          style="color:#34BD66">{{ this.insOrderRow.updateBatchNo }}</span>的信息是否<span style="color: #FF4902">撤销报检</span>
      </p>
      <span slot="footer" class="dialog-footer">
                    <el-row>
                        <el-button @click="declareDialogVisible = false">取 æ¶ˆ</el-button>
                        <el-button :loading="upLoad" type="primary" @click="submitDeclare">ç¡® å®š</el-button>
                    </el-row>
                </span>
        <el-row>
          <el-button @click="declareDialogVisible = false">取 æ¶ˆ</el-button>
          <el-button :loading="upLoad" type="primary" @click="submitDeclare">ç¡® å®š</el-button>
        </el-row>
      </span>
    </el-dialog>
    <!-- æ’¤é”€ä¸‹å• -->
    <el-dialog :visible.sync="quashDialogVisible" title="下单撤销" width="30%">
@@ -155,42 +142,37 @@
      </span>
    </el-dialog>
    <!--标签打印弹框-->
    <print-dialog v-if="printDialog" ref="printDialog"
                  :printDialog="printDialog"
                  @closePrintDialog="closePrintDialog"></print-dialog>
    <print-dialog v-if="printDialog" ref="printDialog" :printDialog="printDialog"
      @closePrintDialog="closePrintDialog"></print-dialog>
    <!--数据查看弹框-->
    <data-look-visible v-if="dataDialogVisible" ref="dataDialogVisible"
                       :dataDialogVisible="dataDialogVisible"
                       :dataLookInfo="dataLookInfo" @closeDataLook="closeDataLook"></data-look-visible>
    <data-look-visible v-if="dataDialogVisible" ref="dataDialogVisible" :dataDialogVisible="dataDialogVisible"
      :dataLookInfo="dataLookInfo" @closeDataLook="closeDataLook"></data-look-visible>
    <!--附件查看弹框-->
    <files-look-visible v-if="filesDialogVisible" ref="filesDialogVisible"
                        :filesDialogVisible="filesDialogVisible"
                        :filesLookInfo="filesLookInfo" @closeFilesLook="closeFilesLook"></files-look-visible>
    <files-look-visible v-if="filesDialogVisible" ref="filesDialogVisible" :filesDialogVisible="filesDialogVisible"
      :filesLookInfo="filesLookInfo" @closeFilesLook="closeFilesLook"></files-look-visible>
    <!--报告下载弹框-->
    <down-file-dialog v-if="downFileDialogVisible" ref="downFileDialogVisible"
                      :downFileDialogVisible="downFileDialogVisible"
                      :downLoadInfo="downLoadInfo" @closeDownFileDialog="closeDownFileDialog"></down-file-dialog>
      :downFileDialogVisible="downFileDialogVisible" :downLoadInfo="downLoadInfo"
      @closeDownFileDialog="closeDownFileDialog"></down-file-dialog>
    <!--产业链信息查看-->
    <ShowInfo v-if="showInfoDialog" ref="showInfoDialog" :showInfoDialog="showInfoDialog"></ShowInfo>
    <!--检验任务信息查看-->
    <el-dialog :visible.sync="InspectInfoDialog" title="数据查看" width="400px" @closed="closeInsInfoDialog">
      <div style="margin-bottom: 8px">
        <span style="font-size: 16px;">进厂检验原始数据</span>
        <el-link :disabled="!insInfo.enterOrderId" :underline="false"
                 style="vertical-align: bottom;margin-left: 6px"
                 type="primary" @click="viewInsInfo0">查看</el-link>
        <el-link :disabled="!insInfo.enterOrderId" :underline="false" style="vertical-align: bottom;margin-left: 6px"
          type="primary" @click="viewInsInfo0">查看</el-link>
      </div>
      <div>
        <span  style="font-size: 16px;">季度检验原始数据</span>
        <el-link :disabled="!insInfo.quarterOrderId" :underline="false"
                 style="vertical-align: bottom;margin-left: 6px"
                 type="primary" @click="viewInsInfo1">查看</el-link>
        <span style="font-size: 16px;">季度检验原始数据</span>
        <el-link :disabled="!insInfo.quarterOrderId" :underline="false" style="vertical-align: bottom;margin-left: 6px"
          type="primary" @click="viewInsInfo1">查看</el-link>
      </div>
    </el-dialog>
<!--    <Inspection v-if="state>0" :key="InspectionKey" :inspectorList="inspectorList" :orderId="orderId"-->
<!--                :sonLaboratory="'原材料'" :state="state"-->
<!--                :typeSource="typeSource"-->
<!--                @goback="goback" @refreshView="refreshView"/>-->
    <!--    <Inspection v-if="state>0" :key="InspectionKey" :inspectorList="inspectorList" :orderId="orderId"-->
    <!--                :sonLaboratory="'原材料'" :state="state"-->
    <!--                :typeSource="typeSource"-->
    <!--                @goback="goback" @refreshView="refreshView"/>-->
  </div>
</template>

@@ -213,22 +195,22 @@
  revokeInspectionReport,
  updateEntrustCode
} from "@/api/business/rawMaterialOrder";
import {getWarehouseSubmit} from "@/api/business/materialInspection";
import { getWarehouseSubmit } from "@/api/business/materialInspection";
// import Inspection from "../do/b1-inspect-order-plan/Inspection.vue";

export default {
  name: "b1-material-inspection-order",
  // import å¼•å…¥çš„组件需要注入到对象中才能使用
  components: {limsTable,DownFileDialog, FilesLookVisible, DataLookVisible, ShowInfo, PrintDialog},
  components: { limsTable, DownFileDialog, FilesLookVisible, DataLookVisible, ShowInfo, PrintDialog },
  data() {
    // è¿™é‡Œå­˜æ”¾æ•°æ®
    return {
      tableData: [],
      tableLoading: false,
      column: [
        {label: '批号', prop: 'updateBatchNo'},
        {label: '零件号', prop: 'partNo'},
        {label: '零件描述', prop: 'partDesc'},
        { label: '批号', prop: 'updateBatchNo' },
        { label: '零件号', prop: 'partNo' },
        { label: '零件描述', prop: 'partDesc' },
        {
          dataType: 'tag',
          label: '物料类型',
@@ -248,11 +230,11 @@
            }
          }
        },
        {label: '抵达的采购数量', prop: 'qtyArrived'},
        {label: '单位', prop: 'buyUnitMeas'},
        {label: '订单号', prop: 'orderNo'},
        {label: '接收时间', prop: 'receiverDate'},
        {label: '报检时间', prop: 'declareDate'},
        { label: '抵达的采购数量', prop: 'qtyArrived' },
        { label: '单位', prop: 'buyUnitMeas' },
        { label: '订单号', prop: 'orderNo' },
        { label: '接收时间', prop: 'receiverDate' },
        { label: '报检时间', prop: 'declareDate' },
        {
          dataType: 'action',
          fixed: 'right',
@@ -283,21 +265,21 @@
        }
      ],
      page: {
        total:0,
        size:10,
        current:1
        total: 0,
        size: 10,
        current: 1
      },
      tableData1: [],
      tableLoading1: false,
      column1: [
        {label: '批号', prop: 'updateBatchNo'},
        {label: '委托编号', prop: 'entrustCode'},
        {label: '零件号', prop: 'partNo'},
        {label: '零件描述', prop: 'partDesc'},
        {label: '样品名称', prop: 'sampleName'},
        {label: '样品型号', prop: 'sampleModel'},
        {label: '检验人', prop: 'userName'},
        {label: '下发时间', prop: 'sendTime'},
        { label: '批号', prop: 'updateBatchNo' },
        { label: '委托编号', prop: 'entrustCode' },
        { label: '零件号', prop: 'partNo' },
        { label: '零件描述', prop: 'partDesc' },
        { label: '样品名称', prop: 'sampleName' },
        { label: '样品型号', prop: 'sampleModel' },
        { label: '检验人', prop: 'userName' },
        { label: '下发时间', prop: 'sendTime' },
        {
          dataType: 'tag',
          label: '物料类型',
@@ -317,11 +299,11 @@
            }
          }
        },
        {label: '抵达的采购数量', prop: 'qtyArrived'},
        {label: '单位', prop: 'buyUnitMeas'},
        {label: '订单号', prop: 'orderNo'},
        {label: '接收时间', prop: 'receiverDate'},
        {label: '报检时间', prop: 'declareDate'},
        { label: '抵达的采购数量', prop: 'qtyArrived' },
        { label: '单位', prop: 'buyUnitMeas' },
        { label: '订单号', prop: 'orderNo' },
        { label: '接收时间', prop: 'receiverDate' },
        { label: '报检时间', prop: 'declareDate' },
        {
          dataType: 'action',
          fixed: 'right',
@@ -352,27 +334,27 @@
        }
      ],
      page1: {
        total:0,
        size:10,
        current:1
        total: 0,
        size: 10,
        current: 1
      },
      tableData2: [],
      tableLoading2: false,
      column2: [
        {label: '委托编号', prop: 'entrustCode'},
        {label: '检验状态', prop: 'inspectStatus'},
        {label: '订单号', prop: 'orderNo'},
        {label: '抵达的采购数量', prop: 'qtyArrived'},
        {label: '下发时间', prop: 'sendTime'},
        {label: '批号', prop: 'updateBatchNo'},
        {label: '零件号', prop: 'partNo'},
        {label: '零件描述', prop: 'partDesc'},
        {label: '供应商名称', prop: 'supplierName'},
        {label: '不合格描述', prop: 'unqualifiedDesc'},
        {label: '免检', prop: 'isExemption'},
        {label: '样品名称', prop: 'sampleName'},
        {label: '样品型号', prop: 'sampleModel'},
        {label: '检验人', prop: 'userName'},
        { label: '委托编号', prop: 'entrustCode' },
        { label: '检验状态', prop: 'inspectStatus' },
        { label: '订单号', prop: 'orderNo' },
        { label: '抵达的采购数量', prop: 'qtyArrived' },
        { label: '下发时间', prop: 'sendTime' },
        { label: '批号', prop: 'updateBatchNo' },
        { label: '零件号', prop: 'partNo' },
        { label: '零件描述', prop: 'partDesc' },
        { label: '供应商名称', prop: 'supplierName' },
        { label: '不合格描述', prop: 'unqualifiedDesc' },
        { label: '免检', prop: 'isExemption' },
        { label: '样品名称', prop: 'sampleName' },
        { label: '样品型号', prop: 'sampleModel' },
        { label: '检验人', prop: 'userName' },
        {
          dataType: 'tag',
          label: '物料类型',
@@ -392,9 +374,9 @@
            }
          }
        },
        {label: '单位', prop: 'buyUnitMeas'},
        {label: '接收时间', prop: 'receiverDate'},
        {label: '报检时间', prop: 'declareDate'},
        { label: '单位', prop: 'buyUnitMeas' },
        { label: '接收时间', prop: 'receiverDate' },
        { label: '报检时间', prop: 'declareDate' },
        {
          dataType: 'action',
          fixed: 'right',
@@ -465,27 +447,27 @@
        }
      ],
      page2: {
        total:0,
        size:10,
        current:1
        total: 0,
        size: 10,
        current: 1
      },
      tableData3: [],
      tableLoading3: false,
      column3: [
        {label: '委托编号', prop: 'entrustCode'},
        {label: '检验状态', prop: 'inspectStatus'},
        {label: '订单号', prop: 'orderNo'},
        {label: '抵达的采购数量', prop: 'qtyArrived'},
        {label: '下发时间', prop: 'sendTime'},
        {label: '批号', prop: 'updateBatchNo'},
        {label: '零件号', prop: 'partNo'},
        {label: '零件描述', prop: 'partDesc'},
        {label: '供应商名称', prop: 'supplierName'},
        {label: '不合格描述', prop: 'unqualifiedDesc'},
        {label: '免检', prop: 'isExemption'},
        {label: '样品名称', prop: 'sampleName'},
        {label: '样品型号', prop: 'sampleModel'},
        {label: '检验人', prop: 'userName'},
        { label: '委托编号', prop: 'entrustCode' },
        { label: '检验状态', prop: 'inspectStatus' },
        { label: '订单号', prop: 'orderNo' },
        { label: '抵达的采购数量', prop: 'qtyArrived' },
        { label: '下发时间', prop: 'sendTime' },
        { label: '批号', prop: 'updateBatchNo' },
        { label: '零件号', prop: 'partNo' },
        { label: '零件描述', prop: 'partDesc' },
        { label: '供应商名称', prop: 'supplierName' },
        { label: '不合格描述', prop: 'unqualifiedDesc' },
        { label: '免检', prop: 'isExemption' },
        { label: '样品名称', prop: 'sampleName' },
        { label: '样品型号', prop: 'sampleModel' },
        { label: '检验人', prop: 'userName' },
        {
          dataType: 'tag',
          label: '物料类型',
@@ -505,9 +487,9 @@
            }
          }
        },
        {label: '单位', prop: 'buyUnitMeas'},
        {label: '接收时间', prop: 'receiverDate'},
        {label: '报检时间', prop: 'declareDate'},
        { label: '单位', prop: 'buyUnitMeas' },
        { label: '接收时间', prop: 'receiverDate' },
        { label: '报检时间', prop: 'declareDate' },
        {
          dataType: 'action',
          fixed: 'right',
@@ -531,27 +513,27 @@
        }
      ],
      page3: {
        total:0,
        size:10,
        current:1
        total: 0,
        size: 10,
        current: 1
      },
      tableData4: [],
      tableLoading4: false,
      column4: [
        {label: '委托编号', prop: 'entrustCode'},
        {label: '检验状态', prop: 'inspectStatus'},
        {label: '订单号', prop: 'orderNo'},
        {label: '抵达的采购数量', prop: 'qtyArrived'},
        {label: '下发时间', prop: 'sendTime'},
        {label: '批号', prop: 'updateBatchNo'},
        {label: '零件号', prop: 'partNo'},
        {label: '零件描述', prop: 'partDesc'},
        {label: '供应商名称', prop: 'supplierName'},
        {label: '不合格描述', prop: 'unqualifiedDesc'},
        {label: '免检', prop: 'isExemption'},
        {label: '样品名称', prop: 'sampleName'},
        {label: '样品型号', prop: 'sampleModel'},
        {label: '检验人', prop: 'userName'},
        { label: '委托编号', prop: 'entrustCode' },
        { label: '检验状态', prop: 'inspectStatus' },
        { label: '订单号', prop: 'orderNo' },
        { label: '抵达的采购数量', prop: 'qtyArrived' },
        { label: '下发时间', prop: 'sendTime' },
        { label: '批号', prop: 'updateBatchNo' },
        { label: '零件号', prop: 'partNo' },
        { label: '零件描述', prop: 'partDesc' },
        { label: '供应商名称', prop: 'supplierName' },
        { label: '不合格描述', prop: 'unqualifiedDesc' },
        { label: '免检', prop: 'isExemption' },
        { label: '样品名称', prop: 'sampleName' },
        { label: '样品型号', prop: 'sampleModel' },
        { label: '检验人', prop: 'userName' },
        {
          dataType: 'tag',
          label: '物料类型',
@@ -571,9 +553,9 @@
            }
          }
        },
        {label: '单位', prop: 'buyUnitMeas'},
        {label: '接收时间', prop: 'receiverDate'},
        {label: '报检时间', prop: 'declareDate'},
        { label: '单位', prop: 'buyUnitMeas' },
        { label: '接收时间', prop: 'receiverDate' },
        { label: '报检时间', prop: 'declareDate' },
        {
          dataType: 'action',
          fixed: 'right',
@@ -614,9 +596,9 @@
        }
      ],
      page4: {
        total:0,
        size:10,
        current:1
        total: 0,
        size: 10,
        current: 1
      },
      entity: {
        updateBatchNo: null,
@@ -652,16 +634,16 @@
          value: 3
        }
      ],
      more:false,
      more: false,
      tabIndex: 0,
      multipleSelection:[],
      multipleSelection: [],
      active: 0, //1：下单，2：查看
      orderType: 0, //0：原材料下单，1：季度检验下单
      currentId: null,
      btnLoading: false,
      quashDialogVisible: false, // æ’¤é”€ä¸‹å•æé†’弹框
      declareDialogVisible: false, // æ’¤é”€æŠ¥æ£€æé†’弹框
      insOrderRow:{},
      insOrderRow: {},
      upLoad: false,
      filesDialogVisible: false, // é™„件查看弹框
      printDialog: false, // æ ‡ç­¾æ‰“印弹框
@@ -678,11 +660,11 @@
      exemptionLoading: false,
      exemptionInfo: {},
      inspectStatusList: [
        {label: '检验中', value: 0},
        {label: '合格', value: 1},
        {label: '不合格', value: 2},
        {label: '未下单', value: 3},
        {label: '让步放行', value: 4},
        { label: '检验中', value: 0 },
        { label: '合格', value: 1 },
        { label: '不合格', value: 2 },
        { label: '未下单', value: 3 },
        { label: '让步放行', value: 4 },
      ],
      state: 0,
      orderId: 0,
@@ -691,10 +673,10 @@
      typeSource: null,// 0:成品下单，1：原材料下单, 2: é“œå•ä¸ä¸‹å•
      InspectInfoDialog: false, // æ•°æ®æŸ¥çœ‹å¼¹æ¡†
      insInfo: {},
      outLoading:false
      outLoading: false
    }
  },
  mounted () {
  mounted() {
    this.refreshTable()
  },
  // æ–¹æ³•é›†åˆ
@@ -719,9 +701,9 @@
      }
    },
    // å¾…下单查询
    getPurchaseOrderList () {
    getPurchaseOrderList() {
      this.tableLoading = true
      const params = {...this.entity, isInspect: 1, state: 0}
      const params = { ...this.entity, isInspect: 1, state: 0 }
      getWarehouseSubmit(params).then(res => {
        this.tableLoading = false
        if (res.code === 200) {
@@ -733,9 +715,9 @@
      })
    },
    // æ£€éªŒä¸­æŸ¥è¯¢
    getIfsByStateOneList () {
    getIfsByStateOneList() {
      this.tableLoading1 = true
      const params = {...this.entity, orderState: 1, state: 1}
      const params = { ...this.entity, orderState: 1, state: 1 }
      getIfsByStateOne(params).then(res => {
        this.tableLoading1 = false
        if (res.code === 200) {
@@ -747,9 +729,9 @@
      })
    },
    // å·²æ£€éªŒæŸ¥è¯¢
    getIfsByOverList () {
    getIfsByOverList() {
      this.tableLoading2 = true
      const params = {...this.entity, orderState: 4, state: 2}
      const params = { ...this.entity, orderState: 4, state: 2 }
      getIfsByOver(params).then(res => {
        this.tableLoading2 = false
        if (res.code === 200) {
@@ -761,9 +743,9 @@
      })
    },
    // æŸ¥è¯¢å­£åº¦æ£€éªŒ
    getIfsByQuarterList () {
    getIfsByQuarterList() {
      this.tableLoading4 = true
      const params = {...this.entity}
      const params = { ...this.entity }
      getIfsByOver(params).then(res => {
        this.tableLoading4 = false
        if (res.code === 200) {
@@ -775,9 +757,9 @@
      })
    },
    // å…¨éƒ¨
    getIfsByAllList () {
    getIfsByAllList() {
      this.tableLoading3 = true
      const params = {...this.entity, isInspect: 1}
      const params = { ...this.entity, isInspect: 1 }
      getIfsByAll(params).then(res => {
        this.tableLoading3 = false
        if (res.code === 200) {
@@ -793,52 +775,52 @@
      this.resetForm('entity')
      this.refreshTable()
    },
    pagination (page) {
    pagination(page) {
      this.page.size = page.limit
      this.refreshTable()
    },
    pagination1 (page) {
    pagination1(page) {
      this.page1.size = page.limit
      this.refreshTable()
    },
    pagination2 (page) {
    pagination2(page) {
      this.page2.size = page.limit
      this.refreshTable()
    },
    pagination3 (page) {
    pagination3(page) {
      this.page3.size = page.limit
      this.refreshTable()
    },
    pagination4 (page) {
    pagination4(page) {
      this.page4.size = page.limit
      this.refreshTable()
    },
    // æŸ¥çœ‹æ£€éªŒæ•°æ®
    viewInspectInfo (row) {
    viewInspectInfo(row) {
      //当前检验任务的检验人列表
      let inspectorList = []
      if(row.userName){
      if (row.userName) {
        inspectorList = row.userName.split(',')
      }
      let user = JSON.parse(localStorage.getItem('user'))
      if(user){
      if (user) {
        inspectorList.push(user.name)
      }
      this.inspectorList = inspectorList
      this.insInfo = row
      this.InspectInfoDialog = true
    },
    closeInsInfoDialog () {
    closeInsInfoDialog() {
      this.InspectInfoDialog = false
    },
    // ç›´æŽ¥æ”¾è¡Œ
    goPass (row) {
    goPass(row) {
      this.$confirm('是否放行当前数据?', '提示', {
        confirmButtonText: '确定',
        cancelButtonText: '取消',
        type: 'warning'
      }).then(() => {
        concessionRelease({ifsInventoryId: row.id}).then(res => {
        concessionRelease({ ifsInventoryId: row.id }).then(res => {
          if (res.code === 200) {
            this.$message({
              type: 'success',
@@ -861,21 +843,21 @@
        cancelButtonText: "取消",
        type: "warning"
      }).then(() => {
        repealQuarterRawOrder({quarterOrderId: row.quarterOrderId}).then(res => {
        repealQuarterRawOrder({ quarterOrderId: row.quarterOrderId }).then(res => {
          if (res.code === 200) {
            this.$message.success('撤销成功')
            this.refreshTable('page')
          }
        })
      }).catch(() => {})
      }).catch(() => { })
    },
    viewInsInfo0 () {
    viewInsInfo0() {
      this.state = 3;
      this.typeSource = this.insInfo.typeSource
      this.orderId = this.insInfo.enterOrderId
      this.InspectInfoDialog = false
    },
    viewInsInfo1 () {
    viewInsInfo1() {
      this.state = 3;
      this.typeSource = this.insInfo.typeSource
      this.orderId = this.insInfo.quarterOrderId
@@ -886,16 +868,16 @@
      this.refreshTable('page')
    },
    // åˆ·æ–°é¡µé¢
    refreshView () {
    refreshView() {
      this.InspectionKey++
    },
    // é“œææ–™ä¸‹å•
    copper () {
    copper() {
      this.$router.push("/materialOrder/copperOrder");
      this.$router.push({ path: "/materialOrder/copperOrder", query: {active: 1} });
      this.$router.push({ path: "/materialOrder/copperOrder", query: { active: 1 } });
    },
    // æ‰“开标签打印弹框
    openPrint () {
    openPrint() {
      if (this.multipleSelection.length > 0) {
        this.printDialog = true
        this.$nextTick(() => {
@@ -907,29 +889,29 @@
      }
    },
    // å…³é—­æ ‡ç­¾æ‰“印弹框
    closePrintDialog () {
    closePrintDialog() {
      this.printDialog = false
    },
    // ä¸‹å•
    playOrder(row) {
      this.$router.push({ path: "/materialOrder/customsInspection", query: {orderType: 0, customsInspection: row, active: 1} });
      this.$router.push({ path: "/materialOrder/customsInspection", query: { orderType: 0, customsInspection: row, active: 1 } });
    },
    // å­£åº¦æ£€éªŒä¸‹å•
    playOrderSec (row) {
    playOrderSec(row) {
      if (typeof row !== "object") {
        this.$router.push({ path: "/materialOrder/customsInspection", query: {active: row} });
        this.$router.push({ path: "/materialOrder/customsInspection", query: { active: row } });
      } else {
        this.$router.push({ path: "/materialOrder/customsInspection", query: {orderType: 1, customsInspection: row, active: 1} });
        this.$router.push({ path: "/materialOrder/customsInspection", query: { orderType: 1, customsInspection: row, active: 1 } });
      }
    },
    // æ‰“开免检弹框
    exemption (row) {
    exemption(row) {
      this.exemptionVisible = true
      this.exemptionInfo = row
      this.$set(this.exemptionInfo, 'partDetail', row.partDesc)
    },
    // æäº¤å…æ£€ä¿¡æ¯
    submitExemption () {
    submitExemption() {
      this.exemptionLoading = true
      rawOrderRelease({
        ifsInventoryId: this.exemptionInfo.id,
@@ -947,13 +929,13 @@
      })
    },
    // æ‰“开撤销报检弹框
    cancelDeclare (row) {
    cancelDeclare(row) {
      this.declareDialogVisible = true
      this.insOrderRow = row
    },
    // æäº¤æ’¤é”€æŠ¥æ£€ç”³è¯·
    submitDeclare () {
      revokeInspectionReport({id: this.insOrderRow.id}).then(res => {
    submitDeclare() {
      revokeInspectionReport({ id: this.insOrderRow.id }).then(res => {
        if (res.code === 200) {
          this.declareDialogVisible = false
          this.refreshTable()
@@ -964,7 +946,7 @@
      })
    },
    // æ‰“开撤销下单的弹框
    cancelOrder (row) {
    cancelOrder(row) {
      if (row.enterOrderId && row.quarterOrderId) {
        this.quashDialogVisible = true
      } else if (row.enterOrderId && !row.quarterOrderId) {
@@ -973,56 +955,56 @@
          cancelButtonText: "取消",
          type: "warning"
        }).then(() => {
          repealEnterRawOrder({enterOrderId: row.enterOrderId}).then(res => {
          repealEnterRawOrder({ enterOrderId: row.enterOrderId }).then(res => {
            if (res.code === 200) {
              this.$message.success('撤销成功')
              this.refreshTable('page')
            }
          })
        }).catch(() => {})
        }).catch(() => { })
      } else if (!row.enterOrderId && row.quarterOrderId) {
        this.$confirm('是否撤销季度下单?', "警告", {
          confirmButtonText: "确定",
          cancelButtonText: "取消",
          type: "warning"
        }).then(() => {
          repealQuarterRawOrder({quarterOrderId: row.quarterOrderId}).then(res => {
          repealQuarterRawOrder({ quarterOrderId: row.quarterOrderId }).then(res => {
            if (res.code === 200) {
              this.$message.success('撤销成功')
              this.refreshTable('page')
            }
          })
        }).catch(() => {})
        }).catch(() => { })
      }
      this.insOrderRow = row
    },
    cancelQuashOrder (type) {
    cancelQuashOrder(type) {
      if (type === 'enterOrderId') {
        this.$confirm('是否撤销当前数据?', "警告", {
          confirmButtonText: "确定",
          cancelButtonText: "取消",
          type: "warning"
        }).then(() => {
          repealEnterRawOrder({enterOrderId: this.insOrderRow.enterOrderId}).then(res => {
          repealEnterRawOrder({ enterOrderId: this.insOrderRow.enterOrderId }).then(res => {
            if (res.code === 200) {
              this.$message.success('撤销成功')
              this.refreshTable('page')
            }
          })
        }).catch(() => {})
        }).catch(() => { })
      } else {
        this.$confirm('是否撤销当前数据?', "警告", {
          confirmButtonText: "确定",
          cancelButtonText: "取消",
          type: "warning"
        }).then(() => {
          repealQuarterRawOrder({quarterOrderId: this.insOrderRow.quarterOrderId}).then(res => {
          repealQuarterRawOrder({ quarterOrderId: this.insOrderRow.quarterOrderId }).then(res => {
            if (res.code === 200) {
              this.$message.success('撤销成功')
              this.refreshTable('page')
            }
          })
        }).catch(() => {})
        }).catch(() => { })
      }
    },
    // ç‚¹å‡»æ ·å“åç§°æŸ¥çœ‹è¯¦æƒ…
@@ -1040,16 +1022,16 @@
      this.dataDialogVisible = true;
    },
    // å…³é—­æ•°æ®æŸ¥çœ‹å¼¹æ¡†
    closeDataLook () {
    closeDataLook() {
      this.dataDialogVisible = false
    },
    // é™„件查看
    handleFileLook (row) {
    handleFileLook(row) {
      this.filesDialogVisible = true
      this.filesLookInfo = row
    },
    // å…³é—­é™„件查看弹框
    closeFilesLook () {
    closeFilesLook() {
      this.filesDialogVisible = false
    },
    // æŠ¥å‘Šä¸‹è½½
@@ -1058,32 +1040,32 @@
      this.downLoadInfo = row
    },
    // å…³é—­æŠ¥å‘Šä¸‹è½½å¼¹æ¡†
    closeDownFileDialog () {
    closeDownFileDialog() {
      this.downFileDialogVisible = false
    },
    // æŸ¥çœ‹äº§ä¸šé“¾ä¿¡æ¯
    openInfoDialog (row) {
    openInfoDialog(row) {
      this.showInfoDialog = true
      this.$nextTick(() => {
        this.$refs.showInfoDialog.getInfo(row.id)
      })
    },
    // ä¿®æ”¹å§”托编号
    changeEntrustCode (row) {
    changeEntrustCode(row) {
      this.entrustCodeVisible = true
      this.entrustCodeInfo = {...row}
      this.entrustCodeInfo = { ...row }
    },
    // å¯¼å‡º
    handleOut(){
      let entity = this.tabIndex === 3 ? {...this.entity, isInspect: 2} : {...this.entity,state: 2, orderState: 4,}
    handleOut() {
      let entity = this.tabIndex === 3 ? { ...this.entity, isInspect: 2 } : { ...this.entity, state: 2, orderState: 4, }
      delete entity.orderBy
      this.outLoading = true
      rawAllExport({
        entity:entity
      },{responseType: "blob"}).then(res => {
        entity: entity
      }, { responseType: "blob" }).then(res => {
        this.outLoading = false
        this.$message.success('导出成功')
        const blob = new Blob([res],{ type: 'application/octet-stream' });
        const blob = new Blob([res], { type: 'application/octet-stream' });
        const url = URL.createObjectURL(blob);
        const link = document.createElement('a');
        link.href = url;
@@ -1092,7 +1074,7 @@
      })
    },
    // æäº¤ä¿®æ”¹å§”托编号信息
    submitCode () {
    submitCode() {
      this.submitCodeLoading = true
      try {
        updateEntrustCode({
@@ -1115,7 +1097,7 @@
      this.refreshTable()
    },
    // è¡¨æ ¼é€‰æ‹©æ–¹æ³•
    selectMethod(val){
    selectMethod(val) {
      this.multipleSelection = val
    },
  },
@@ -1127,6 +1109,7 @@
  display: flex;
  justify-content: space-between;
}

.tab {
  list-style-type: none;
  display: flex;

 src/views/business/unpass/components/PurchaseVerification.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,376 @@
<template>
  <div>
    <el-dialog title="进货验证原始记录" :visible.sync="isShow" width="1000px" :show-close="false" :close-on-click-modal="false"
      style="max-height: 96vh; margin-top: 2vh" :modal-append-to-body="false" :close-on-press-escape="false">
      <div class="search">
        <el-form :inline="true" :model="purchaseForm" label-position="right" :rules="purchaseFormRules"
          ref="purchaseForm" class="form-inline" label-width="130px">
          <el-row>
            <el-col :span="8">
              <el-form-item label="检验编号:">
                <el-input clearable v-model="purchaseForm.entrustCode" disabled size="small"
                  placeholder="请输入"></el-input>
              </el-form-item>
            </el-col>
            <el-col :span="8">
              <el-form-item label="材料厂家:">
                <el-input clearable v-model="purchaseForm.supplierName" disabled size="small"
                  placeholder="请输入"></el-input>
              </el-form-item>
            </el-col>
            <el-col :span="8">
              <el-form-item label="到货日期:">
                <el-input clearable v-model="purchaseForm.declareDate" disabled size="small"
                  placeholder="请输入"></el-input>
              </el-form-item>
            </el-col>
            <el-col :span="8">
              <el-form-item label="材料名称:">
                <el-input clearable v-model="purchaseForm.sample" disabled size="small" placeholder="请输入"></el-input>
              </el-form-item>
            </el-col>
            <el-col :span="8">
              <el-form-item label="规格型号:">
                <el-input clearable v-model="purchaseForm.model" disabled size="small" placeholder="请输入"></el-input>
              </el-form-item>
            </el-col>
            <el-col :span="8">
              <el-form-item label="材料批号:">
                <el-input clearable v-model="purchaseForm.updateBatchNo" disabled size="small"
                  placeholder="请输入"></el-input>
              </el-form-item>
            </el-col>
          </el-row>
          <div>
            <el-form-item class="headLine" label="验证依据文件编号:" label-width="160px" style="width: 100%"
              prop="verifyFileCode">
              <el-input clearable v-model="purchaseForm.verifyFileCode" size="small"
                :disabled="operationType === 'view'" placeholder="请输入"></el-input>
            </el-form-item>
          </div>
          <h4>
            <span style="display: flex;align-items: center;">
              <span class="line"></span><span>验证内容</span>
            </span>
          </h4>
          <div class="title">一、供方产品检测报告的基本信息确认</div>
          <el-form-item label="材料名称:" prop="basicName">
            <el-radio-group v-model="purchaseForm.basicName" :disabled="operationType === 'view'" v-removeAriaHidden>
              <el-radio label="1">符合</el-radio>
              <el-radio label="2">不符合</el-radio>
              <el-radio label="3">不适用</el-radio>
            </el-radio-group>
          </el-form-item>
          <el-form-item label="规格型号:" prop="basicModel">
            <el-radio-group v-model="purchaseForm.basicModel" :disabled="operationType === 'view'" v-removeAriaHidden>
              <el-radio label="1">符合</el-radio>
              <el-radio label="2">不符合</el-radio>
              <el-radio label="3">不适用</el-radio>
            </el-radio-group>
          </el-form-item>
          <el-form-item label="材料批号:" prop="basicBatchNo">
            <el-radio-group v-model="purchaseForm.basicBatchNo" :disabled="operationType === 'view'" v-removeAriaHidden>
              <el-radio label="1">符合</el-radio>
              <el-radio label="2">不符合</el-radio>
              <el-radio label="3">不适用</el-radio>
            </el-radio-group>
          </el-form-item>
          <el-form-item label="执行标准:" prop="basicStandard">
            <el-radio-group v-model="purchaseForm.basicStandard" :disabled="operationType === 'view'"
              v-removeAriaHidden>
              <el-radio label="1">符合</el-radio>
              <el-radio label="2">不符合</el-radio>
              <el-radio label="3">不适用</el-radio>
            </el-radio-group>
          </el-form-item>
          <el-form-item label="生产日期:" prop="basicDate">
            <el-radio-group v-model="purchaseForm.basicDate" :disabled="operationType === 'view'" v-removeAriaHidden>
              <el-radio label="1">符合</el-radio>
              <el-radio label="2">不符合</el-radio>
              <el-radio label="3">不适用</el-radio>
            </el-radio-group>
          </el-form-item>
          <el-form-item label="供货数量:" prop="basicNumber">
            <el-radio-group v-model="purchaseForm.basicNumber" :disabled="operationType === 'view'" v-removeAriaHidden>
              <el-radio label="1">符合</el-radio>
              <el-radio label="2">不符合</el-radio>
              <el-radio label="3">不适用</el-radio>
            </el-radio-group>
          </el-form-item>
          <el-form-item label="材料颜色:" prop="basicColor">
            <el-radio-group v-model="purchaseForm.basicColor" :disabled="operationType === 'view'" v-removeAriaHidden>
              <el-radio label="1">符合</el-radio>
              <el-radio label="2">不符合</el-radio>
              <el-radio label="3">不适用</el-radio>
            </el-radio-group>
          </el-form-item>
          <div>
            <el-form-item label="其他:">
              <el-input clearable v-model="purchaseForm.basicOtherValue" size="small"
                :disabled="operationType === 'view'" placeholder="请输入"></el-input>
            </el-form-item>
            <el-form-item>
              <el-radio-group v-model="purchaseForm.basicOther" :disabled="operationType === 'view'">
                <el-radio label="1">符合</el-radio>
                <el-radio label="2">不符合</el-radio>
              </el-radio-group>
            </el-form-item>
            <div class="titleSec">
              <span>二、供方产品检测报告中各项性能指标的验证</span>
              <span>
                <el-button type="primary" size="small" @click="addItem"
                  v-if="operationType === 'add'">手动添加检验项目</el-button>
                <el-button type="primary" @click="addFactoryVerifyItem" v-if="operationType === 'add'"
                  size="small">添加验证项目</el-button>
              </span>
            </div>
            <div>
              <el-table :data="factoryVerifyItemList" style="width: 98%" v-loading="tableLoading">
                <el-table-column type="index" label="序号" width="180" align="center"></el-table-column>
                <el-table-column prop="inspectionItem" label="验证项目" width="300"></el-table-column>
                <el-table-column prop="result" label="验证结果">
                  <template slot-scope="scope">
                    <el-radio-group v-model="scope.row.result" v-removeAriaHidden :disabled="operationType === 'view'">
                      <el-radio label="1">符合</el-radio>
                      <el-radio label="2">不符合</el-radio>
                      <el-radio label="3">不适用</el-radio>
                    </el-radio-group>
                  </template>
                </el-table-column>
                <el-table-column label="操作" width="120" v-if="operationType === 'add'">
                  <template slot-scope="scope">
                    <el-button @click.native.prevent="deleteRow(scope.$index)" type="text" size="small">删除</el-button>
                  </template>
                </el-table-column>
              </el-table>
            </div>
          </div>
        </el-form>
      </div>
      <span slot="footer" class="dialog-footer">
        <el-button @click="$emit('resetPurchaseDialog')">取 æ¶ˆ</el-button>
        <el-button type="primary" @click="handlePurchase" :loading="handlePurchaseLoading"
          v-if="operationType === 'add'">ç¡®
          å®š</el-button>
      </span>
    </el-dialog>
    <el-dialog title="待验证项目" :visible.sync="factoryVerifyItemDia" width="1000px"
      style="max-height: 96vh; margin-top: 2vh" :show-close="false" :close-on-click-modal="false"
      :close-on-press-escape="false">
      <el-table :data="tableList" style="width: 100%" v-loading="tableLoading"
        @selection-change="handleSelectionChange">
        <el-table-column type="selection" width="55"></el-table-column>
        <el-table-column type="index" label="序号" width="60" align="center"></el-table-column>
        <el-table-column prop="inspectionItem" label="验证项目"></el-table-column>
      </el-table>
      <span slot="footer" class="dialog-footer">
        <el-button @click="factoryVerifyItemDia = false">取 æ¶ˆ</el-button>
        <el-button type="primary" @click="handleFactoryVerifyItem" :loading="handleFactoryVerifyLoading">æ·» åŠ </el-button>
      </span>
    </el-dialog>
    <el-dialog title="手动添加验证项目" :visible.sync="inspectionItemDia" width="500px" @close="resetInput" :show-close="false"
      :close-on-click-modal="false" :close-on-press-escape="false">
      <el-input v-model="inspectionItem"></el-input>
      <span slot="footer" class="dialog-footer">
        <el-button @click="inspectionItemDia = false">取 æ¶ˆ</el-button>
        <el-button type="primary" @click="handleAdd">æ·» åŠ </el-button>
      </span>
    </el-dialog>
  </div>
</template>

<script>
import { getFactoryVerify, addFactoryVerify } from '@/api/business/unpass.js'
import {
  getInsProduct,
} from "@/api/business/inspectionTask.js";
export default {
  name: "PurchaseVerification",
  // import å¼•å…¥çš„组件需要注入到对象中才能使用
  components: {},
  props: {
    purchaseDialog: {
      type: Boolean,
      default: () => false
    },
    orderId: {
      type: String,
      default: () => null
    },
  },
  data() {
    // è¿™é‡Œå­˜æ”¾æ•°æ®
    return {
      type: '',
      info: {},
      isShow: this.purchaseDialog,
      purchaseForm: {
        entrustCode: '', // æ£€éªŒç¼–号
        supplierName: '', // ææ–™åŽ‚家
        declareDate: '', // åˆ°è´§æ—¥æœŸ
        sample: '', // ææ–™åç§°
        model: '', // è§„格型号
        updateBatchNo: '', // ææ–™æ‰¹å·
        verifyFileCode: '', // éªŒè¯ä¾æ®æ–‡ä»¶ç¼–号
        // ç¡®è®¤ä¿¡æ¯
        basicName: '', // ææ–™åç§°
        basicModel: '', // è§„格型号
        basicBatchNo: '', // ææ–™æ‰¹å·
        basicStandard: '', // æ‰§è¡Œæ ‡å‡†
        basicDate: '', // ç”Ÿäº§æ—¥æœŸ
        basicNumber: '', // ä¾›è´§æ•°é‡
        basicColor: '', // ææ–™é¢œè‰²
        basicOtherValue: '', // å…¶ä»–名称
        basicOther: '', // å…¶ä»–
      },
      purchaseFormRules: {
        verifyFileCode: [{ required: true, message: '请填写验证依据文件编号', trigger: 'blur' }],
        basicName: [{ required: false, message: '请选择材料名称验证信息', trigger: 'change' }],
        basicModel: [{ required: false, message: '请选择规格型号验证信息', trigger: 'change' }],
        basicStandard: [{ required: false, message: '请选择执行标准验证信息', trigger: 'change' }],
        basicDate: [{ required: false, message: '请选择生产日期验证信息', trigger: 'change' }],
        basicNumber: [{ required: false, message: '请选择供货数量验证信息', trigger: 'change' }],
        basicColor: [{ required: false, message: '请选择材料颜色验证信息', trigger: 'change' }],
      },
      factoryVerifyItemList: [], // ä¾›æ–¹äº§å“æ£€æµ‹æŠ¥å‘Šä¸­å„项性能指标的验证
      tableList: [], //
      multipleSelection: [], //
      operationType: '',
      handlePurchaseLoading: false,
      tableLoading: false,
      factoryVerifyItemDia: false, // æ·»åŠ éªŒè¯é¡¹ç›®å¼¹æ¡†
      handleFactoryVerifyLoading: false,
      inspectionItemDia: false,
      inspectionItem: ''
    }
  },
  // æ–¹æ³•é›†åˆ
  methods: {
    async getInsOrder(operationType, item) {
      this.operationType = operationType
      this.info = item
      // æŸ¥è¯¢å·²æäº¤çš„数据
      let factoryVerify = await getFactoryVerify({ insOrderId: this.orderId })
      this.purchaseForm = factoryVerify.data
      this.factoryVerifyItemList = factoryVerify.data.factoryVerifyItemList || []
    },
    // æ‰“开添加验证项目弹框
    async addFactoryVerifyItem() {
      this.factoryVerifyItemDia = true
      this.tableList = []
      if (this.info.cableTag === undefined) {
        this.info.cableTag = ''
      }
      this.tableLoading = true;
      const type1 = 5
      // æŸ¥è¯¢æ£€éªŒé¡¹ç›®
      let res = await getInsProduct({ id: this.info.id, type: type1, laboratory: this.info.sonLaboratory, cableTag: this.info.cableTag, rawMaterialTag: this.info.rawMaterialTag })
      if (res.data.length > 0) {
        res.data.map((item) => {
          if (item.inspectionItemSubclass) {
            item.inspectionItem = item.inspectionItem + '-' + item.inspectionItemSubclass
          }
          const obj = Object.assign({
            inspectionItem: item.inspectionItem,
            result: item.result,
          })
          this.tableList.push(obj)
        })
        this.tableLoading = false;
      }
    },
    handleSelectionChange(val) {
      console.log('val---', val)
      this.multipleSelection = val;
    },
    addItem() {
      this.inspectionItemDia = true
    },
    deleteRow(index) {
      this.factoryVerifyItemList.splice(index, 1);
    },
    handleAdd() {
      if (!this.inspectionItem) {
        this.$message.warning('请填写内容')
        return
      }
      this.factoryVerifyItemList.push({
        inspectionItem: this.inspectionItem,
        result: null,
      })
      this.inspectionItemDia = false
    },
    resetInput() {
      this.inspectionItem = ''
      this.inspectionItemDia = false
    },
    // æäº¤æ·»åŠ è¦éªŒè¯çš„检验项
    handleFactoryVerifyItem() {
      if (this.multipleSelection.length === 0) {
        this.$message.warning('请选择数据')
      } else {
        this.factoryVerifyItemList = JSON.parse(JSON.stringify(this.multipleSelection))
        this.factoryVerifyItemDia = false
      }
    },
    handlePurchase() {
      this.$refs['purchaseForm'].validate((valid) => {
        if (valid) {
          if (this.factoryVerifyItemList.some(item => item.result === undefined || item.result === null || item.result === '')) {
            this.$message.warning('请选择供方产品验证结果')
            return
          }
          this.factoryVerifyItemList.forEach((item, index) => {
            item.sort = index
          })
          this.purchaseForm.factoryVerifyItemList = JSON.parse(JSON.stringify(this.factoryVerifyItemList))
          this.handlePurchaseLoading = true
          addFactoryVerify(this.purchaseForm).then(res => {
            if (res.code === 200) {
              this.$message.success('提交成功')
              this.$emit('resetPurchaseDialog')
            }
            this.handlePurchaseLoading = false
          })
        } else {
          console.log('error submit!!');
          return false;
        }
      });
    },
  },
}
</script>

<style scoped>
.headLine>>>.el-form-item__content {
  width: 68%;
}

>>>.el-form-item__content {
  display: inline-block;
}

h4 .line {
  display: inline-block;
  width: 3px;
  height: 16px;
  background: #3A7BFA;
  margin-right: 4px;
}

.title {
  margin: 10px 0;
}

.titleSec {
  margin: 10px 0;
  display: flex;
  justify-content: space-between;
}

>>>.el-dialog__body {
  max-height: 700px;
  overflow-y: auto;
}
</style>

 src/views/business/unpass/components/addUnPass.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,124 @@
<template>
  <div>
    <el-dialog title="新增不合格复测" :visible.sync="isShow" width="70%" :show-close="false" :close-on-click-modal="false"
      :close-on-press-escape="false">
      <div class="table">
        <el-table class="el-table" ref="productTable" :data="productList" max-height="800px" tooltip-effect="dark"
          border v-loading="tableLoading" @selection-change="selectProduct" style="margin-bottom: 10px;"
          @select-all="handleAll">
          <el-table-column type="selection" width="65"></el-table-column>
          <el-table-column prop="inspectionItemClass" label="检验项分类" min-width="140"
            show-overflow-tooltip></el-table-column>
          <el-table-column prop="inspectionItem" label="检验项" min-width="140" show-overflow-tooltip></el-table-column>
          <el-table-column prop="inspectionItemSubclass" label="检验项子项" min-width="140"
            show-overflow-tooltip></el-table-column>
          <el-table-column prop="tell" label="要求描述" min-width="220px"></el-table-column>
          <el-table-column prop="ask" label="要求值" min-width="220px"></el-table-column>
          <el-table-column prop="lastValue" label="检验结果" min-width="140" show-overflow-tooltip></el-table-column>
          <el-table-column prop="insResult" label="结果判定" min-width="140" show-overflow-tooltip>
            <template>
              <el-tag type="danger">不合格</el-tag>
            </template>
          </el-table-column>
        </el-table>
      </div>
      <span slot="footer" class="dialog-footer">
        <el-button @click="$emit('resetAddUnPass')">取 æ¶ˆ</el-button>
        <el-button type="primary" @click="submitHandle" :loading="handlePassLoading">ç¡® å®š</el-button>
      </span>
    </el-dialog>
  </div>
</template>

<script>
import { getInsProductUnqualified } from '@/api/business/unpass.js'
export default {
  name: "addUnPass",
  // import å¼•å…¥çš„组件需要注入到对象中才能使用
  components: {},
  props: {
    addUnPassDialog: {
      type: Boolean,
      default: () => false
    },
  },
  data() {
    // è¿™é‡Œå­˜æ”¾æ•°æ®
    return {
      type: '',
      isShow: this.addUnPassDialog,
      handlePassLoading: false,
      productList: [],
      productListSelected: [],
      productIds: [],
      tableLoading: false
    }
  },
  mounted() {
  },
  // æ–¹æ³•é›†åˆ
  methods: {
    getInsOrder(info) {
      this.tableLoading = true
      try {
        getInsProductUnqualified({ id: info.id, type: info.type, laboratory: info.laboratory, rawMaterialTag: info.rawMaterialTag }).then(res => {
          if (res.code === 200) {
            this.productList = res.data
          }
          this.tableLoading = false
        })
      } catch (err) {
        this.tableLoading = false
      }
    },
    // æäº¤ä¸åˆæ ¼å¤„理
    submitHandle() {
      if (this.productListSelected.length === 0) {
        this.$message.warning('请选择需要复测的检验项')
        return
      }
      this.$confirm('确认提交不合格复测?', '提示', {
        confirmButtonText: '确定',
        cancelButtonText: '取消',
        type: 'warning'
      }).then(() => {
        this.handlePass()
      }).catch(() => {

      });
    },
    handlePass() {
      this.handlePassLoading = true
      try {
        addUnqualifiedRetest({
          ids: this.productIds
        }).then(res => {
          if (res.code === 200) {
            this.$message.success('提交成功')
            this.$emit('resetAddUnPass')
          }
          this.handlePassLoading = false
        })
      } catch (e) {
        this.handlePassLoading = false
      }
    },
    selectProduct(val) {
      this.productListSelected = val
      this.productIds = []
      val.forEach(a => {
        this.productIds.push(a.id)
      })
    },
    handleAll(val) {
      this.productListSelected = val
      this.productIds = []
      val.forEach(a => {
        this.productIds.push(a.id)
      })
    },
  },
}
</script>

<style scoped></style>

 src/views/business/unpass/components/unPassDialog.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,275 @@
<template>
  <div>
    <el-dialog title="新增不合格处理" :visible.sync="isShow" width="740px" :show-close="false" :close-on-click-modal="false"
      :close-on-press-escape="false">
      <div class="search">
        <el-form :inline="true" :model="unPassForm" :rules="unPassFormRules" ref="unPassForm" class="form-inline"
          label-width="120px">
          <div>
            <el-form-item class="headLine" label="标题:" style="width: 100%" prop="headline">
              <el-input clearable v-model="unPassForm.headline" size="small" :disabled="type === 'view'" type="textarea"
                placeholder="请输入"></el-input>
            </el-form-item>
          </div>
          <el-form-item label="供应商名称:">
            <el-input clearable v-model="unPassForm.supplierName" disabled size="small" placeholder="请输入"></el-input>
          </el-form-item>
          <el-form-item label="物料名称:">
            <el-tooltip class="item" effect="dark" placement="top" :content="unPassForm.materialName">
              <el-input clearable v-model="unPassForm.materialName" disabled size="small" placeholder="请输入"></el-input>
            </el-tooltip>
          </el-form-item>
          <el-form-item label="生产批次:">
            <el-input clearable v-model="unPassForm.productionBatch" disabled size="small" placeholder="请输入"></el-input>
          </el-form-item>
          <el-form-item label="到货数量:">
            <el-input clearable v-model="unPassForm.cargoQuantity" disabled size="small" placeholder="请输入"></el-input>
          </el-form-item>
          <el-form-item label="规格型号:">
            <el-input clearable v-model="unPassForm.specsModels" disabled size="small" placeholder="请输入"></el-input>
          </el-form-item>
          <el-form-item label="报检时间:">
            <el-date-picker v-model="unPassForm.inspectTime" format="yyyy-MM-dd" value-format="yyyy-MM-dd" size="small"
              disabled style="width: 175px" type="date" placeholder="选择日期">
            </el-date-picker>
          </el-form-item>
          <el-form-item label="反馈人:">
            <el-input clearable v-model="unPassForm.feedbackUser" disabled size="small" placeholder="请输入"></el-input>
          </el-form-item>
          <el-form-item label="反馈时间:" prop="feedbackTime">
            <el-date-picker v-model="unPassForm.feedbackTime" :disabled="type === 'view'" format="yyyy-MM-dd"
              value-format="yyyy-MM-dd HH:mm:ss" size="small" style="width: 175px" type="date" placeholder="选择日期">
            </el-date-picker>
          </el-form-item>
          <el-form-item label="分类:" prop="classification">
            <el-select v-model="unPassForm.classification" :disabled="type === 'view'" size="small" placeholder="请选择">
              <el-option v-for="item in classificationOptions" :key="item.value" :label="item.label"
                :value="item.value">
              </el-option>
            </el-select>
          </el-form-item>
          <el-form-item label="不合格归属:" prop="offGradeAscription">
            <el-select v-model="unPassForm.offGradeAscription" :disabled="type === 'view'" size="small"
              placeholder="请选择">
              <el-option v-for="item in offGradeAscriptionOptions" :key="item.value" :label="item.label"
                :value="item.value">
              </el-option>
            </el-select>
          </el-form-item>
          <el-form-item label="不合格情况描述:" prop="unqualifiedDesc">
            <el-input clearable type="textarea" v-model="unPassForm.unqualifiedDesc" :disabled="type === 'view'"
              style="width: 484px" size="small" placeholder="请输入"></el-input>
          </el-form-item>
        </el-form>
        <el-upload v-if="type === 'add'" ref="upload" :action="action2" :on-change="beforeUpload" :on-error="onError"
          :on-remove="handleRemoveFile" :on-success="getUnpassUrl" :headers="headers" :file-list="unPassFilesList">
          <el-button size="small" type="primary" style="text-align: left">附件上传</el-button>
        </el-upload>
        <div v-if="type !== 'add'">
          <div style="padding-left: 40px;margin-bottom: 4px">附件：</div>
          <div style="padding-left: 40px;margin-bottom: 4px" v-for="item in unqualifiedHandlerFiles">
            <span>{{ item.fileName }}</span><el-link type="primary" style="margin-left: 20px;vertical-align: top"
              :underline="false" @click="handleDown(item)">下载</el-link>
          </div>
        </div>
      </div>
      <span slot="footer" class="dialog-footer">
        <el-button @click="$emit('resetForm')">取 æ¶ˆ</el-button>
        <el-button type="primary" @click="handlunPass" :loading="handlunPassLoading" v-if="type === 'add'">ç¡®
          å®š</el-button>
      </span>
    </el-dialog>
  </div>
</template>

<script>
import { getInsOrder, getUnqualifiedHandler, downFile, addUnqualifiedHandler } from '@/api/business/unpass.js'
export default {
  name: "unPassDialog",
  // import å¼•å…¥çš„组件需要注入到对象中才能使用
  components: {},
  props: {
    unPassDialog: {
      type: Boolean,
      default: () => false
    },
    orderId: {
      type: String,
      default: () => null
    },
  },
  data() {
    // è¿™é‡Œå­˜æ”¾æ•°æ®
    return {
      type: '',
      isShow: this.unPassDialog,
      unPassForm: { // ä¸åˆæ ¼å¤„理数据
        headline: '', // æ ‡é¢˜
        inventoryQuantityId: '', // åŽŸææ–™id,不做展示，只传值
        supplierName: '', // ä¾›åº”商名称
        materialName: '', // ç‰©æ–™åç§°
        productionBatch: '', // ç”Ÿäº§æ‰¹æ¬¡
        cargoQuantity: '', // åˆ°è´§æ•°é‡
        specsModels: '', // è§„格型号
        inspectTime: '', // æŠ¥æ£€æ—¶é—´
        feedbackUser: '', // åé¦ˆäºº
        feedbackTime: '', // åé¦ˆæ—¶é—´
        classification: '', // åˆ†ç±»
        offGradeAscription: '', // ä¸åˆæ ¼å½’属
        unqualifiedDesc: '', // ä¸åˆæ ¼æƒ…况描述
        unqualifiedHandlerFiles: [], // ä¸åˆæ ¼é™„件URL
      },
      unPassFormRules: {
        offGradeAscription: [
          { required: true, message: '请选择不合格归属', trigger: 'change' }
        ],
        headline: [
          { required: true, message: '请填写标题', trigger: 'blur' }
        ]
      },
      unPassFilesList: [], // ä¸åˆæ ¼å¤„理附件数据
      classificationOptions: [], // ä¸åˆæ ¼åˆ†ç±»ä¸‹æ‹‰æ¡†
      offGradeAscriptionOptions: [], // ä¸åˆæ ¼å½’属下拉框
      handlunPassLoading: false,
      unqualifiedHandlerFiles: []
    }
  },
  mounted() {
    this.getClassificationOptions() // èŽ·å–不合格分类下拉框选项
    this.getOffGradeAscriptionOptions() // èŽ·å–不合格归属下拉框选项
  },
  // æ–¹æ³•é›†åˆ
  methods: {
    getInsOrder(type, row) {
      this.type = type
      if (type === 'add') {
        // èµ‹å€¼é»˜è®¤æ•°æ®
        getInsOrder({
          orderId: this.orderId
        }).then(res => {
          if (res.code === 200) {
            this.unPassForm.headline = `No.0005-中天装备电线-外购品不合格反馈评审及纠正预防流程(正式版)-${JSON.parse(localStorage.getItem("user")).name}-${new Date().toISOString().substring(0, 10)}` // æ ‡é¢˜
            this.unPassForm.inventoryQuantityId = res.data.insOrderTemplate.inventoryQuantityId // åŽŸææ–™id
            this.unPassForm.insOrderId = res.data.insOrder.id // è®¢å•id
            this.unPassForm.supplierName = res.data.insOrderTemplate.supplierName // ä¾›åº”商名称
            this.unPassForm.materialName = res.data.insOrder.sampleType // ç‰©æ–™åç§°
            this.unPassForm.productionBatch = res.data.insOrderTemplate.updateBatchNo // ç”Ÿäº§æ‰¹æ¬¡
            this.unPassForm.cargoQuantity = res.data.insOrderTemplate.qtyArrived + res.data.insOrderTemplate.buyUnitMeas // åˆ°è´§æ•°é‡
            this.unPassForm.specsModels = res.data.insOrder.partDetail // è§„格型号
            this.unPassForm.inspectTime = res.data.insOrderTemplate.sendTime.substring(0, 10)  // æŠ¥æ£€æ—¶é—´
            this.unPassForm.feedbackTime = new Date().toISOString().substring(0, 10) // æŠ¥æ£€æ—¶é—´
            this.unPassForm.feedbackUser = JSON.parse(localStorage.getItem("user")).name // åé¦ˆäºº
          }
        })
      } else {
        this.getInfo(row.handlerId)
        this.unPassForm = { ...row }
      }
    },
    getInfo(handlerId) {
      getUnqualifiedHandler({
        id: handlerId
      }).then(res => {
        if (res.code === 200) {
          this.unqualifiedHandlerFiles = this.HaveJson(res.data.unqualifiedHandlerFiles)
        }
      })
    },
    handleDown(row) {
      downFile({
        id: row.id,
      }).then(res => {
        if (res.code === 200) {
          let url = '';
          if (res.data.type == 1) {
            url = this.javaApi + '/img/' + res.data.fileUrl
            this.$download.saveAs(url, row.fileName);
          } else {
            url = this.javaApi + '/word/' + res.data.fileUrl
            this.$download.saveAs(url, row.fileName);
          }
        }
      }).catch(error => {

      })
    },
    // æäº¤ä¸åˆæ ¼å¤„理
    handlunPass() {
      this.$refs['unPassForm'].validate((valid) => {
        if (valid) {
          this.unPassForm.unqualifiedHandlerFiles.forEach(item => {
            delete item.orderBy
          })
          this.handlunPassLoading = true
          addUnqualifiedHandler(this.unPassForm).then(res => {
            if (res.code === 200) {
              this.$message.success('提交成功')
              this.$emit('resetForm')
            }
            this.handlunPassLoading = false
          })
        } else {
          console.log('error submit!!');
          return false;
        }
      });
    },
    getUnpassUrl(response, file, fileList) {
      // é™„件上传成功后，将url在提交不合格处理时传给后台
      if (response.code == 200) {
        this.$message.success('上传成功')
        this.unPassForm.unqualifiedHandlerFiles.push(response.data)
      }
    },
    // ç§»é™¤é™„件
    handleRemoveFile(file) {
      const index = this.unPassForm.unqualifiedHandlerFiles.findIndex(val => val === file.response.data)
      if (index > -1) {
        this.unPassForm.unqualifiedHandlerFiles.splice(index, 1)
      }
    },
    beforeUpload(file) {
      if (file.size > 1024 * 1024 * 10) {
        this.$message.error('上传文件不超过10M');
        this.$refs.upload.clearFiles()
        return false;
      } else {
        this.upLoading = true;
        return true;
      }
    },
    onError(err, file, fileList) {
      this.$message.error('上传失败')
      this.$refs.upload.clearFiles()
    },
    getClassificationOptions() {
      // ä¸åˆæ ¼åˆ†ç±»
      this.getDicts("categories_no_conformities").then((response) => {
        this.classificationOptions = this.dictToValue(response.data);
      });
    },
    getOffGradeAscriptionOptions() {
      // ä¸åˆæ ¼å½’属
      this.getDicts("attribution_no_conformities").then((response) => {
        this.offGradeAscriptionOptions = this.dictToValue(response.data);
      });
    },
  },
  computed: {
    headers() {
      return {
        'token': sessionStorage.getItem('token')
      }
    },
    action2() {
      return this.javaApi + '/unqualifiedHandler/uploadFileByUnqualified'
    }
  },
}
</script>

<style scoped>
.headLine>>>.el-form-item__content {
  width: 68%;
}
</style>

 vue.config.js

@@ -59,6 +59,19 @@
        "@": resolve("src"),
      },
    },
    module: {
      rules: [
        {
          test: /\.worker\.js$/,
          use: {
            loader: "worker-loader",
            options: {
              inline: "fallback",
            },
          },
        },
      ],
    },
    plugins: [
      // http://doc.ruoyi.vip/ruoyi-vue/other/faq.html#使用gzip解压缩静态文件
      new CompressionPlugin({