kd-aiot-frontend-mes/src/views/produce/components/workPlan/edit.vue

<template>
  <ele-modal
    :visible.sync="visible"
    v-if="visible"
    :before-close="handleClose"
    :close-on-click-modal="true"
    :close-on-press-escape="false"
    :maxable="true"
    append-to-body
    width="90%"
  >
    <div class="ele-body">
      <el-card shadow="never">
        <header-title title="基本信息">
          <el-button @click="cancel">返回</el-button>
          <el-button
            type="primary"
            @click="save"
            :loading="loading"
            v-if="type != 'detail'"
            >保存</el-button
          >
          <el-button
            type="primary"
            @click="handleReporting"
            :loading="loading"
            v-if="type != 'detail'"
            >报工完成</el-button
          >
        </header-title>
        <base-info
          ref="baseInfoRefs"
          v-if="form"
          :form="form"
          :btnType="type"
          :qualityType1="qualityType"
          @changeModel="changeModel"
          @changeNumber="changeNumber"
          @changeInspectionStandardsModel="changeInspectionStandardsModel"
        ></base-info>
        <header-title title="样品信息"></header-title>
        <el-form label-width="110px">
          <el-row>
            <el-col :span="6">
              <el-form-item label="样品合格数:" prop="sampleQualifiedNumber">
                <el-input
                  type="number"
                  :min="0"
                  disabled
                  v-model="form.sampleQualifiedNumber"
                  placeholder=""
                ></el-input>
              </el-form-item>
            </el-col>
            <el-col :span="6">
              <el-form-item
                label="样品不合格数:"
                prop="sampleNoQualifiedNumber"
              >
                <el-input
                  type="number"
                  :min="0"
                  disabled
                  v-model="form.sampleNoQualifiedNumber"
                  placeholder=""
                ></el-input>
              </el-form-item>
            </el-col>
            <el-col :span="6">
              <el-form-item label="样品合格率:" prop="sampleQualificationRate">
                <el-input v-model="form.sampleQualificationRate" disabled />
              </el-form-item>
            </el-col>
            <el-col :span="6">
              <el-form-item
                label="样品不合格率:"
                prop="sampleNoQualificationRate"
              >
                <el-input v-model="form.sampleNoQualificationRate" disabled />
              </el-form-item>
            </el-col>
          </el-row>
          <el-row>
            <el-col :span="6">
              <el-form-item label="样品类型:" prop="samplesType">
                <el-input disabled :value="sampletypeVal(form.conditionType)" />
              </el-form-item>
            </el-col>
            <el-col :span="6">
              <el-form-item label="样品数量:" prop="sampleQuantity">
                <el-input
                  type="number"
                  disabled
                  v-model="form.sampleQuantity"
                />
              </el-form-item>
            </el-col>
            <el-col :span="6">
              <el-form-item label="样品重量:" prop="sampleWeight">
                <el-input type="number" disabled v-model="form.sampleWeight" />
              </el-form-item>
            </el-col>
          </el-row>
        </el-form>
        <quality-content-tabs
          v-if="form.id"
          ref="tabsRef"
          :type="type"
          :ids="dataWork.id"
          :sample-list="sampleList"
          :activeName="activeName"
          :scheme-list="schemeList"
          :loading="loading"
          :form="form"
          :productId="productId"
          :status="statusType"
          @handleSelectionChange="handleSelectionChange1"
          @batch-quality="batchQuality"
          @batch-dispose="batchDispose"
          @handleDetail="handleDetail"
          @inputWeight="inputWeight"
          @handleDispose="handleDispose"
          @changeSamUnit="changeSamUnit"
          @handleSample1="handleSample1"
          @handleSampleSubmit="handleSampleSubmit"
          @getConditionType="getConditionType"
          @countQualityResults="countQualityResults"
          @setSchemeList="setSchemeList"
        />
      </el-card>

      <sampleListDialog
        ref="detailRef"
        @handleConfirm="handleConfirm"
        @handleDispose="handleDispose"
      ></sampleListDialog>
      <sampleDisposeDialog
        v-if="sampleDisposeVisble"
        :sampleDisposeVisble.sync="sampleDisposeVisble"
        ref="disposeRef"
        @handleDisposeConfirm="handleDisposeConfirm"
        :rowData="rowData"
        @close="closeDispose"
        @handleDispose="handleDispose"
      ></sampleDisposeDialog>
    </div>
  </ele-modal>
</template>

<script>
  import baseInfo from './components/baseInfo.vue';
  // import QualityContentTabs from './components/QualityContentTabs.vue';
  import QualityContentTabs from './components/newQualityContentTabs.vue';

  import { getCode } from '@/api/login';
  import {
    save,
    update,
    getById,
    exeReportWork,
    queryQualitySamplContent,
    queryQualityTempleContent,
    queryQualityInventory
  } from '@/api/inspectionWork';

  import dictMixins from '@/mixins/dictMixins';

  // import term from './term';
  import sampleListDialog from './components/sampleListDialog.vue';
  import sampleDisposeDialog from './components/sampleDisposeDialog.vue';

  import { finishPageTab } from '@/utils/page-tab-util';
  export default {
    components: {
      baseInfo,
      QualityContentTabs,
      sampleListDialog,
      sampleDisposeDialog
    },
    mixins: [dictMixins],
    computed: {
      sampletypeVal() {
        return (row) => {
          if (row == 1) {
            return '整样';
          }
          return '小样';
        };
      }
    },
    // p:{
    //   sampletypeVal()=>{
    //     return
    //   }
    // },
    data() {
      const defaultForm = function () {
        return {
          code: '',
          qualityType: null,
          qualityModeproduceRoutingId: '',
          produceRoutingName: '',
          produceTaskId: '',
          produceTaskName: '',
          productName: '',
          productCode: '',
          batchNo: '',
          specification: '',
          modelType: '',
          brandNo: '',
          total: '',
          qualifiedNumber: '',
          noQualifiedNumber: '',
          groupId: '',
          groupName: '',
          qualityId: '',
          qualityName: '',
          qualityTime: '',
          hours: '',
          qualificationRate: '',
          noQualificationRate: '',
          totalWeight: '',
          sampleNumber: '',
          imgUrl: [],
          qualityTimeStart: '',
          qualityTimeEnd: '',
          templateList: [],
          sampleMeasureUnit: '',
          conditionType: null
        };
      };
      return {
        rowData: null,
        defaultForm,
        sampleDisposeVisble: false,
        // 表单数据
        form: { ...defaultForm() },
        voList: [],

        // 表单验证规则
        categoryParamList: [],
        type: '',
        title: '',
        loading: false,

        tabTaskId: null,
        // activeName: '2',

        packingList: [],
        // 样品清单，处置，批量处置，批量质检，质检的操作
        sampleList: [],
        schemeList: [],
        inventoryList: [],
        activeName: '1',

        isValid: true,
        isStatus: true,
        SampleListbyReportList: [],
        qualityTimeStart: '',
        isReportProcessProduce: false,
        addStatus: [],
        statusType: false,
        visible: false,
        dataWork: {}
      };
    },
    watch: {
      '$route.query.id': {
        handler(id) {
          if (id) {
            this.getDetail();
          } else {
            this.form = { ...defaultForm() };
          }
        }
      },
      // 样品清单
      sampleList: {
        handler(newVal) {
          // 计算重量跟数量
          this.calculate(newVal);
        },
        deep: true,
        immediate: true
      }
    },

    created() {
      // this.open();
      // if (this.$route.query.id) {
      //   this.getDetail();
      // }
    },
    methods: {
      //
      calculate(list) {
        if (list.length == 0) {
          this.form.sampleQuantity = 0;
          this.form.sampleWeight = 0;
        }
        let sampleQuantity = 0; // 样品数量
        let sampleWeight = 0; // 样品重量
        let sampleQualifiedNumber = 0; //  样品合格数
        let sampleNoQualifiedNumber = 0; //  样品不合格数
        list.forEach((el) => {
          sampleQuantity += el.measureQuantity - 0;
          sampleWeight += el.weight - 0;
          if (el.qualityResults != 2) {
            sampleQualifiedNumber += el.measureQuantity - 0;
          } else {
            sampleNoQualifiedNumber += el.measureQuantity - 0;
          }
        });
        // 计算合格率和不合格率（百分比形式）
        let sampleQualificationRate = '';
        let sampleNoQualificationRate = '';

        if (sampleQualifiedNumber || sampleQualifiedNumber == 0) {
          sampleQualificationRate =
            ((sampleQualifiedNumber / sampleQuantity) * 100).toFixed(2) || '';
          sampleNoQualificationRate =
            ((sampleNoQualifiedNumber / sampleQuantity) * 100).toFixed(2) || '';
        }

        if (sampleQualificationRate || sampleQualificationRate == '0.00') {
          if (isNaN(sampleQualificationRate)) {
            sampleQualificationRate = '0%';
          } else {
            sampleQualificationRate = sampleQualificationRate + '%';
          }
        }
        if (sampleNoQualificationRate || sampleNoQualificationRate == '0.00') {
          if (isNaN(sampleNoQualificationRate)) {
            sampleNoQualificationRate = '0%';
          } else {
            sampleNoQualificationRate = sampleNoQualificationRate + '%';
          }
        }

        let resultsTotal = this.form.total - sampleQuantity;
        if (sampleQuantity == sampleQualifiedNumber) {
          this.$set(this.form, 'qualifiedNumber', resultsTotal);
          this.$set(this.form, 'noQualifiedNumber', 0);
          this.$set(this.form, 'qualificationRate', '100%');
          this.$set(this.form, 'noQualificationRate', '0');
          this.$set(this.form, 'qualityResults', 1);
        } else {
          this.$set(this.form, 'noQualifiedNumber', resultsTotal);
          this.$set(this.form, 'qualifiedNumber', 0);
          this.$set(this.form, 'qualificationRate', '0');
          this.$set(this.form, 'noQualificationRate', '100%');
          this.$set(this.form, 'qualityResults', 2);
        }
        // this.$set(this.form, 'resultsTotal', resultsTotal);

        console.log(sampleQualificationRate, 'sampleQualificationRate');
        console.log(sampleNoQualificationRate, 'sampleNoQualificationRate');
        this.$set(
          this.form,
          'sampleQualificationRate',
          sampleQualificationRate
        );
        this.$set(
          this.form,
          'sampleNoQualificationRate',
          sampleNoQualificationRate
        );
        this.$set(this.form, 'sampleQuantity', sampleQuantity);
        this.$set(this.form, 'sampleWeight', sampleWeight);
        this.$set(this.form, 'sampleQualifiedNumber', sampleQualifiedNumber);
        this.$set(
          this.form,
          'sampleNoQualifiedNumber',
          sampleNoQualifiedNumber
        );
      },
      //切换检验方式
      changeModel(val, flag) {
        this.$refs.tabsRef.tableSelClear();
        this.sampleList = [];
        this.$refs.tabsRef.tabsChange('1');
        this.$refs.tabsRef.tabsConditionType(null);
        this.form.qualityMode = val;
        //检验方式 全检
        if (this.form.qualityMode == 1) {
          this.activeName = '2';
          this.form.sampleNumber = '';
          this.changeGetSampleList(this.inventoryList);
        } else {
          this.activeName = '1';
          if (!flag) {
            this.sampleList = [];
          }
        }
      },
      //根据类型判断样品清单现实列表数据
      async getProSamList(list) {
        //生产检验
        if (this.qualityType == 2) {
          if (this.form.qualityMode != null) {
            const ProductSampleList = [];
            for (const oldItem of list) {
              const count = oldItem.measureQuantity;
              const newMeasureQuantity = oldItem.measureQuantity / count;
              const newWeight = parseFloat((oldItem.weight / count).toFixed(2));

              // 遍历新数组设置 qualityResults 默认值
              this.schemeList.forEach((item) => {
                if (typeof item === 'object' && item !== null) {
                  item.qualityResults = 1; // 设置默认值
                }
                delete item.id;
              });

              delete oldItem.id;

              if (
                oldItem.qualitySampleTemplateList == undefined ||
                oldItem.qualitySampleTemplateList == null ||
                oldItem.qualitySampleTemplateList.length == 0
              ) {
                oldItem.qualitySampleTemplateList = JSON.parse(
                  JSON.stringify(this.schemeList)
                );
                for (let i = 0; i < count; i++) {
                  ProductSampleList.push({
                    ...oldItem,
                    measureQuantity: newMeasureQuantity,
                    weight: newWeight,
                    sampleCode: await this.getSampleCode(),
                    qualitySampleTemplateList: JSON.parse(
                      JSON.stringify(this.schemeList)
                    )
                  });
                }
                this.sampleList = ProductSampleList;
                const pNum = ProductSampleList.reduce((sum, item) => {
                  return sum + Number(item.weight || 0);
                }, 0);
                this.form.totalWeight = parseFloat(pNum.toFixed(2));
              } else {
                for (let i = 0; i < count; i++) {
                  ProductSampleList.push({
                    ...oldItem,
                    measureQuantity: newMeasureQuantity,
                    weight: newWeight,
                    sampleCode: await this.getSampleCode(),
                    qualitySampleTemplateList: JSON.parse(
                      JSON.stringify(oldItem.qualitySampleTemplateList)
                    )
                  });
                }
                this.sampleList = ProductSampleList;
                const pNum = ProductSampleList.reduce((sum, item) => {
                  return sum + Number(item.weight || 0);
                }, 0);
                this.form.totalWeight = parseFloat(pNum.toFixed(2));
              }
            }
          }
        } else {
          // this.sampleList = list;
          this.sampleList = this.addStatus;
        }
      },
      // 创建计量数量为1的样品清单函数，用于计数类型的
      async createSampleList(list) {
        if (this.form.qualityMode != null) {
          this.$message('正在生成样品清单');
          const ProductSampleList = [];
          for (const oldItem of list) {
            const count = oldItem.measureQuantity;
            const newMeasureQuantity = oldItem.measureQuantity / count;
            const newWeight = parseFloat((oldItem.weight / count).toFixed(2));

            // 遍历新数组设置 qualityResults 默认值
            this.schemeList.forEach((item) => {
              if (typeof item === 'object' && item !== null) {
                item.qualityResults = 1; // 设置默认值
              }
              delete item.id;
            });
            delete oldItem.id;
            if (
              oldItem.qualitySampleTemplateList == undefined ||
              oldItem.qualitySampleTemplateList == null ||
              oldItem.qualitySampleTemplateList.length == 0
            ) {
              oldItem.qualitySampleTemplateList = JSON.parse(
                JSON.stringify(this.schemeList)
              );
              for (let i = 0; i < count; i++) {
                ProductSampleList.push({
                  ...oldItem,
                  measureQuantity: newMeasureQuantity,
                  weight: newWeight,
                  sampleCode: await this.getSampleCode(),
                  qualitySampleTemplateList: JSON.parse(
                    JSON.stringify(this.schemeList)
                  )
                });
              }
              this.sampleList = ProductSampleList;
              const pNum = ProductSampleList.reduce((sum, item) => {
                return sum + Number(item.weight || 0);
              }, 0);
              this.form.totalWeight = parseFloat(pNum.toFixed(2));
            } else {
              for (let i = 0; i < count; i++) {
                ProductSampleList.push({
                  ...oldItem,
                  measureQuantity: newMeasureQuantity,
                  weight: newWeight,
                  sampleCode: await this.getSampleCode(),
                  qualitySampleTemplateList: JSON.parse(
                    JSON.stringify(oldItem.qualitySampleTemplateList)
                  )
                });
              }
              this.sampleList = ProductSampleList;
              const pNum = ProductSampleList.reduce((sum, item) => {
                return sum + Number(item.weight || 0);
              }, 0);
              this.form.totalWeight = parseFloat(pNum.toFixed(2));
            }
          }
        }
      },
      // 全检计量计重的样品清单函数
      async updatePackingList(list, sampleCount) {
        // for (let i = 0; i < list.length; i++) {
        //   list[i].sampleCode = await this.getSampleCode();
        // }

        const dataList = [];
        let currentNum = sampleCount - list.length;
        let currentNum1 = sampleCount;
        // console.log(this.selectedList);

        for (const item of list) {
          const qualitySampleTemplateList = item.qualitySampleTemplateList
            ?.length
            ? JSON.parse(JSON.stringify(item.qualitySampleTemplateList))
            : JSON.parse(
                JSON.stringify(
                  this.schemeList.map((item) => {
                    item['qualityResults'] = 1;
                    return item;
                  })
                )
              );

          if (sampleCount >= list.length) {
            dataList.push({
              ...item,
              measureQuantity: item.measureQuantity, //作为计量数量
              sampleCode: await this.getSampleCode(),
              qualitySampleTemplateList
            });
          }
        }

        this.sampleList = dataList;
        this.sampleNumber = this.sampleList.length;
      },
      // 切换检验方式为全检后生成样品
      changeGetSampleList(list) {
        this.$message('正在生成样品清单');

        // 计量类型1是数量，2是重量
        if (this.form.inspectionStandards == 1) {
          this.createSampleList(list);
        }
        if (this.form.inspectionStandards == 2) {
          this.updatePackingList(list, this.form.total);
          // this.handleWeightFullSample(this.form.total);
        }
      },

      //输入取样数量
      changeNumber(val) {
        if (this.form.qualityMode !== 2) {
          return;
        }
        if (val <= 0) {
          this.$refs.showPackingListTable.clearSelection();
          return;
        }

        if (this.qualityType == 2) {
          //生产检验的抽检逻辑
          if (val > this.packingList[0].measureQuantity) {
            this.$message.warning('取样数量不能大于来源清单的计量数量！');
            return;
          }

          const ProductSampleList = [];

          this.packingList.forEach((oldItem) => {
            const count = oldItem.measureQuantity;
            const newMeasureQuantity = oldItem.measureQuantity / count;
            const newWeight = parseFloat((oldItem.weight / count).toFixed(2));
            delete oldItem.id;
            // 遍历新数组设置 qualityResults 默认值
            this.schemeList.forEach((item) => {
              if (typeof item === 'object' && item !== null) {
                item.qualityResults = 1; // 设置默认值
              }
              delete item.id;
            });
            for (let i = 0; i < val; i++) {
              ProductSampleList.push({
                ...oldItem,
                measureQuantity: newMeasureQuantity,
                weight: newWeight,
                qualitySampleTemplateList: JSON.parse(
                  JSON.stringify(this.schemeList)
                )
              });
            }
          });
          this.sampleList = ProductSampleList;
          const pNum = ProductSampleList.reduce((sum, item) => {
            return sum + Number(item.weight || 0);
          }, 0);
          this.form.totalWeight = parseFloat(pNum.toFixed(2));
        } else {
          if (val > this.packingList.length) {
            this.$message.warning('取样数量不能大于物料明细总数！');
            return;
          }
          const rows = this.packingList.slice(0, val);
          rows.forEach((row) => {
            this.$refs.showPackingListTable.toggleRowSelection(row);
          });
        }
      },
      getNowDate() {
        let date = new Date(),
          obj = {
            year: date.getFullYear(), //获取当前月份(0-11,0代表1月)
            month: date.getMonth() + 1, //获取当前月份(0-11,0代表1月)
            strDate: date.getDate(), // 获取当前日(1-31)
            hour: date.getHours(), //获取当前小时(0 ~ 23)
            minute: date.getMinutes(), //获取当前分钟(0 ~ 59)
            second: date.getSeconds() //获取当前秒数(0 ~ 59)
          };
        Object.keys(obj).forEach((key) => {
          if (obj[key] < 10) obj[key] = `0${obj[key]}`;
        });
        return obj;
      },
      //来源清单勾选事件
      handleSelectionChange1(selection) {
        if (this.form.qualityMode === 2) {
          this.selectedList = selection;
          this.activeName = '1';
          if (this.schemeList.length == 0) {
            for (let i = 0; i < selection.length; i++) {
              this.$set(selection[i], 'qualityStatus', 2);
              // 遍历新数组设置 qualityResults 默认值
              this.schemeList.forEach((item) => {
                if (typeof item === 'object' && item !== null) {
                  item.qualityResults = 1; // 设置默认值
                }
                delete item.id;
              });
              this.$set(
                selection[i],
                'qualitySampleTemplateList',
                JSON.parse(JSON.stringify(this.schemeList))
              );
            }
          }

          // this.sampleList = selection;
          //赋值取样数量
          this.form.sampleNumber = selection.length;
        }
      },

      async open(req) {
        this.visible = true;
        this.dataWork = req.data;
        this.getDetail(req.workOrderId);
        this.type = req.data.type ? req.data.type : req.type;
        this.qualityType = req.data.qualityType ? req.data.qualityType : '';

        this.title =
          this.type == 'add' ? '新增' : this.type == 'edit' ? '报工' : '详情';

        if (this.type == 'add') {
          const code = await getCode('quality_work_order_code');
          this.form.code = code;
        } else {
          if (
            req.data.qualityTimeStart != '' ||
            req.data.qualityTimeStart != null ||
            req.data.qualityTimeStart != undefined
          ) {
            this.qualityTimeStart = this.getNowTime();
          }
        }
      },
      getNowTime() {
        const nowDate = this.getNowDate();
        return (
          nowDate.year +
          '-' +
          nowDate.month +
          '-' +
          nowDate.strDate +
          ' ' +
          nowDate.hour +
          ':' +
          nowDate.minute +
          ':' +
          nowDate.second
        );
      },
      getNowTimes() {
        const nowDate = this.getNowDate();
        return nowDate.year + '-' + nowDate.month + '-' + nowDate.strDate;
      },
      async getDetail(id) {
        getById(id).then((res) => {
          this.form = res.data;
          this.productId = res.data.productId || '';
          this.statusType = this.form.status == 1 ? true : false;

          this.isReportProcessProduce =
            this.form.isReportProcessProduce == 1 ? true : false;

          this.tabTaskId =
            this.categoryParamList[0] && this.categoryParamList[0].id;

          if (this.form.groupId) {
            this.$nextTick(() => {
              this.$refs.baseInfoRefs?.getUserList({
                groupId: this.form.groupId
              });
            });
          }
          if (this.form.produceRoutingId) {
            this.$nextTick(() => {
              this.$refs.baseInfoRefs?.getTaskList();
            });
          }
        });

        // 来源清单
        await this.getQueryQualityInventory();
        // await this.queryQualityInventory()
        // 质检方案
        await this.queryQualityTempleContent();
        // 样品清单
        await this.queryQualitySamplContent();
      },
      // getNewData(val) {
      //   console.log(val, '清单列表')
      //   this.packingList = val
      // },

      // async queryQualityInventory() {
      //   let res = await queryQualityInventory({ qualityWorkerId: this.$route.query.id });
      //   console.log(res, '清单列表');
      //   this.packingList = res;
      // },

      changeSamUnit(val) {
        this.$set(this.form, 'sampleMeasureUnit', val);
      },
      async handleSample1(val, data) {
        this.sampleList = [];
        if (this.selectedList == undefined || this.selectedList.length == 0) {
          this.activeName = '1';
          this.$message.warning('请先选择样品！');
          return;
        }
        if (val == 1) {
          this.activeName = '2';
          if (this.form.isUnpack == 1) {
            for (let i = 0; i < this.selectedList.length; i++) {
              for (let j = 0; j < this.selectedList[i].measureQuantity; j++) {
                // 不拆计算每个重量
                let newWeight = parseFloat(
                  (
                    this.selectedList[i].weight /
                    this.selectedList[i].measureQuantity
                  ).toFixed(4)
                );
                if (
                  this.selectedList[i].qualitySampleTemplateList == undefined ||
                  this.selectedList[i].qualitySampleTemplateList == null ||
                  this.selectedList[i].qualitySampleTemplateList.length == 0
                ) {
                  this.sampleList.push({
                    ...this.selectedList[i],
                    sampleCode: await this.getSampleCode(),
                    measureQuantity: 1,
                    qualitySampleTemplateList: JSON.parse(
                      JSON.stringify(this.schemeList)
                    ),
                    weight: newWeight || 0
                  });
                } else {
                  this.sampleList.push({
                    ...this.selectedList[i],
                    sampleCode: await this.getSampleCode(),
                    measureQuantity: 1,
                    qualitySampleTemplateList: JSON.parse(
                      JSON.stringify(
                        this.selectedList[i].qualitySampleTemplateList
                      )
                    ),
                    weight: newWeight || 0
                  });
                }
              }
            }
          } else if (this.form.isUnpack == 2) {
            // 不拆计算每个重量
            let newWeight = parseFloat(
              (
                this.selectedList[0].weight /
                this.selectedList[0].measureQuantity
              ).toFixed(4)
            );

            for (let i = 0; i < this.selectedList[0].measureQuantity; i++) {
              if (
                this.selectedList[0].qualitySampleTemplateList == undefined ||
                this.selectedList[0].qualitySampleTemplateList == null ||
                this.selectedList[0].qualitySampleTemplateList.length == 0
              ) {
                this.sampleList.push({
                  ...this.selectedList[0],
                  sampleCode: await this.getSampleCode(),
                  measureQuantity: 1,
                  qualitySampleTemplateList: JSON.parse(
                    JSON.stringify(this.schemeList)
                  ),
                  weight: newWeight || 0
                });
              } else {
                this.sampleList.push({
                  ...this.selectedList[0],
                  sampleCode: await this.getSampleCode(),
                  measureQuantity: 1,
                  qualitySampleTemplateList: JSON.parse(
                    JSON.stringify(
                      this.selectedList[0].qualitySampleTemplateList
                    )
                  ),
                  weight: newWeight || 0
                });
              }
            }
          }
          //取整样=勾选数据
          // this.sampleList = this.selectedList;
          this.$message.success('取样成功！');
        } else if (val == 2) {
          console.log(data, 'datadatadatadataxiaoyang');
        }
      },
      async handleSampleSubmit(data, specifications) {
        this.sampleList = [];
        if (!this.selectedList || this.selectedList.length == 0) {
          this.$message.warning('请先选择样品！');
          return;
        }
        const measureQ = data.measureQ || 1;
        const unit = data.sampleUnit;
        const sampleCount = Number(data.portion);
        try {
          if (this.isStandard1OrWeightSample()) {
            // 新增校验 数量  取整样 ***
            if (this.form.conditionType == 1) {
              let isFlag = this.validateSampleQuantity(
                sampleCount,
                specifications
              );
              if (!isFlag) return;
            }
            // ***
            //抽检计量整样小样或者抽检计重小样
            if (!this.validateMeasureQuantity(measureQ, unit, sampleCount))
              return; //取样数量验证
            if (unit === 'KG' && !this.validateWeight(measureQ, sampleCount))
              return; // 若计量单位为重量，还需验证总重量是否足够
            await this.getNewFullSampleList(
              Math.ceil(sampleCount),
              measureQ,
              unit,
              specifications
            );
            // 这里是取整样 非数量
          } else if (this.isWeightStandardFullSample()) {
            console.log('这里是取整样 吗');
            //抽检取计重取整样
            if (!this.validateSampleCount(sampleCount, specifications)) return;
            await this.handleWeightFullSample(sampleCount, specifications);
          }
          this.activeName = '2';

          this.$refs.tabsRef.tabsChange('2');
        } catch (error) {
          console.error('取样处理失败:', error);
          this.$message.error('取样处理失败');
        }
      },
      // 当计量类型 是数量的时候 取整样 校验
      validateSampleQuantity(sampleCount, specifications) {
        let packingUnit = this.selectedList[0].packingUnit?.trim() || '';
        let totalS = 0;
        let labelKey =
          packingUnit == specifications.conversionUnit.trim()
            ? 'packingQuantity'
            : 'measureQuantity';
        let labelName = labelKey == 'packingQuantity' ? '包装数量' : '计量数量';
        totalS = this.selectedList.reduce(
          (total, el) => total + el[labelKey],
          0
        );

        if (sampleCount > totalS) {
          this.$message.info(
            `所填的条目数量不能超过所选${labelName}总和${totalS}`
          );
          return false;
        }
        return true;
      },
      //获取样品编码
      async getSampleCode() {
        return await getCode('sample_code');
      },
      async getNewSampleList(measureQ, unit, nums) {
        this.sampleList = [];

        if (!this.selectedList || this.selectedList.length == 0) {
          this.$message.warning('请先选择来源清单！');
          return;
        }
        this.activeName = '2';
        this.$refs.tabsRef.tabsChange('2');

        if (this.form.isUnpack == 1) {
          // 1 拆包 2 不拆
          let measureQuantity = 1;
          if (this.form.conditionType == 2) {
            measureQuantity = measureQ;
          }
          for (let i = 0; i < this.selectedList.length; i++) {
            if (
              this.selectedList[i].qualitySampleTemplateList == undefined ||
              this.selectedList[i].qualitySampleTemplateList == null ||
              this.selectedList[i].qualitySampleTemplateList.length == 0
            ) {
              this.sampleList.push({
                ...this.selectedList[i],
                sampleCode: await this.getSampleCode(),
                measureQuantity: measureQuantity,
                qualitySampleTemplateList: JSON.parse(
                  JSON.stringify(this.schemeList)
                ),
                measureUnit: unit
              });
            } else {
              this.sampleList.push({
                ...this.selectedList[i],
                sampleCode: await this.getSampleCode(),
                measureQuantity: measureQuantity,
                qualitySampleTemplateList: JSON.parse(
                  JSON.stringify(this.selectedList[i].qualitySampleTemplateList)
                ),
                measureUnit: unit
              });
            }
          }
        } else if (this.form.isUnpack == 2) {
          if (this.form.conditionType == 1) {
            measureQ = 1;
          }
          // 不拆计算每个重量
          let newWeight = parseFloat(
            (
              this.selectedList[0].weight / this.selectedList[0].measureQuantity
            ).toFixed(4)
          );

          for (let i = 0; i < nums; i++) {
            if (
              this.selectedList[0].qualitySampleTemplateList == undefined ||
              this.selectedList[0].qualitySampleTemplateList == null ||
              this.selectedList[0].qualitySampleTemplateList.length == 0
            ) {
              this.sampleList.push({
                ...this.selectedList[0],
                sampleCode: await this.getSampleCode(),
                measureQuantity: measureQ,
                qualitySampleTemplateList: JSON.parse(
                  JSON.stringify(this.schemeList)
                ),
                measureUnit: unit,
                weight: newWeight || 0
              });
            } else {
              this.sampleList.push({
                ...this.selectedList[0],
                sampleCode: await this.getSampleCode(),
                measureQuantity: measureQ,
                qualitySampleTemplateList: JSON.parse(
                  JSON.stringify(this.selectedList[0].qualitySampleTemplateList)
                ),
                measureUnit: unit,
                weight: newWeight || 0
              });
              // this.sampleList.push({
              //   ...this.selectedList[0],
              //   sampleCode: await this.getSampleCode(),
              //   measureQuantity: measureQ,
              //   measureUnit: unit,
              //   weight: newWeight || 0,
              // });
            }
          }
        }
        // this.sampleList = this.selectedList.map(oldItem => {
        //   const newItem = JSON.parse(JSON.stringify(oldItem));
        //   newItem.measureQuantity = measureQ;
        //   newItem.measureUnit = unit;
        //   return newItem;
        // });

        this.$refs.tabsRef.tabsChange('2');
      },

      async getQueryQualityInventory() {
        const res = await queryQualityInventory({
          qualityWorkerId: this.dataWork.id,
          size: -1
        });

        if (res.list.length > 0) {
          this.inventoryList = res.list;
        }
      },

      async queryQualitySamplContent() {
        const res = await queryQualitySamplContent({
          qualityWorkerId: this.dataWork.id,
          size: 1000
        });
        let addStatus = res.list.map((item) => {
          item.isValid = true;
          // item.disposeTime = item.disposeTime
          //   ? item.disposeTime.split(' ')[0]
          //   : null;
          item.sampleDate = item.sampleDate
            ? item.sampleDate.split(' ')[0]
            : null;
          return {
            ...item
          };
        });
        if (addStatus.length > 0) {
          this.sampleList = addStatus;
          this.addStatus = addStatus;
        } else {
          this.getProSamList(this.packingList);
          // if (this.form.qualityMode == 1) {
          //   this.changeModel(this.form.qualityMode);
          // }
        }
      },
      async queryQualityTempleContent() {
        const res = await queryQualityTempleContent({
          qualityWorkerId: this.dataWork.id
        });
        console.log(res, 'resresresres');
        this.schemeList = res.list;
      },
      // 取样
      getConditionType(val) {
        this.form.conditionType = val;
      },

      /* 保存编辑 */
      save() {
        // *** 新增判断
        // let flag = this.$refs.baseInfoRefs.quantityCalculation();
        // if (!flag) return;
        // ***
        this.$refs.baseInfoRefs.$refs.form1.validate((valid) => {
          if (!valid) {
            return false;
          }
          // this.loading = true;
          let URL =
            this.type == 'add' ? save : this.type == 'edit' ? update : '';

          this.form.qualityTimeStart = this.qualityTimeStart;

          delete this.form['qualityTimeEnd'];

          let params = {
            ...this.form,
            sampleList: this.sampleList,
            planTemplateList: this.schemeList,
            templateList: this.schemeList,
            // qualityInventoryList: this.$refs.tabsRef.$refs.sourceTable.getData()
            qualityInventoryList: this.inventoryList
          };

          URL(params)
            .then((msg) => {
              this.loading = false;
              this.$message.success(msg);
              this.cancel();
              this.$emit('done');
            })
            .catch((e) => {
              this.loading = false;
            });
        });
      },
      update() {
        this.loading = true;
        this.form['status'] = 1;
        update({ ...this.form })
          .then((msg) => {
            this.loading = false;
            this.$message.success(msg);
            this.$emit('done');
          })
          .catch((e) => {
            this.loading = false;
          });
      },
      restForm() {
        this.form = { ...this.defaultForm() };
        this.$nextTick(() => {
          this.$refs.baseInfoRefs.$refs.form1.clearValidate();
        });
      },
      cancel() {
        finishPageTab();
        this.$router.go(-1);
      },
      setSchemeList(list) {
        this.schemeList = list;
      },

      handleDetail(index, row, type) {
        if (!this.sampleList[index] || !this.schemeList) {
          return;
        }
        const selectedData = [];
        selectedData.push(this.sampleList[index]);

        console.log(selectedData, 'selectedData');

        if (this.schemeList.length != 0) {
          this.sampleList.forEach((item) => {
            if (item.qualitySampleTemplateList.length == 0) {
              item.qualitySampleTemplateList.push(...this.schemeList);
            }
          });
        }

        this.$refs.detailRef.openDia(
          index,
          row,
          type,
          selectedData,
          null,
          this.schemeList.toolList
        );
      },
      inputWeight(row, index) {
        // 计算所有样本的总重量
        const pNum = this.sampleList.reduce((sum, item) => {
          return sum + Number(item.weight || 0);
        }, 0);
        this.form.totalWeight = parseFloat(pNum.toFixed(2));
      },
      handleDispose(data) {
        // return
        this.rowData = data;
        this.sampleDisposeVisble = true;
        // if (!this.sampleList[index]) {
        //   return;
        // }

        // this.sampleList[index].sampleDate = this.getNowTimes();

        // this.sampleList[index].disposeTime = this.getNowTimes();

        // console.log(index, row, type, this.qualityType);

        // this.$refs.disposeRef.openDispose(index, row, type, this.qualityType);
      },
      // 报工
      handleReporting(index, row) {
        if (this.form.qualityMode == 2 && !this.form.qualityResults) {
          this.$refs.baseInfoRefs.toggleExpand2();
          this.$message.error('请选择质检结果');
          return;
        }

        this.$refs.baseInfoRefs.$refs.form1.validate((valid) => {
          if (!valid) return false;
          this.loading = true;

          if (this.qualityType == 2 && this.isReportProcessProduce) {
            for (let i = 0; i < this.sampleList.length; i++) {
              const disposalStatus = this.sampleList[i].disposalStatus;

              if (disposalStatus == null) {
                this.loading = false;
                this.$refs.tabsRef.tabsChange('2');
                this.$message.error('请完成以下样品处置！');
                return;
              }
            }
          }

          for (let i = 0; i < this.sampleList.length; i++) {
            const qualityStatus = this.sampleList[i].qualityStatus;

            if (qualityStatus == '2') {
              this.loading = false;
              this.$refs.tabsRef.tabsChange('2');
              this.$message.error('请完成以下样品质检！');
              return;
            }
          }

          // this.form.qualityTimeEnd = new Date(this.getNowTime());
          // this.form.qualityTimeStart = new Date(this.qualityTimeStart);

          this.form.qualityTimeEnd = this.getNowTime();
          this.form.qualityTimeStart = this.qualityTimeStart;

          // if (this.form.qualityMode == 1) {
          //   this.form.qualityResults = '';
          // }

          let params = {
            ...this.form,
            sampleList: this.sampleList,
            planTemplateList: this.schemeList,
            // qualityInventoryList: this.$refs.tabsRef.$refs.sourceTable.getData()
            qualityInventoryList: this.inventoryList
          };

          exeReportWork(params)
            .then((msg) => {
              this.loading = false;
              this.$message.success(msg);
              // this.cancel();
              this.visible = false;
              this.$emit('done');
            })
            .catch((e) => {
              this.loading = false;
            });
        });
      },
      // 处理确认事件
      handleDisposeConfirm(data, index) {
        if (index == undefined) {
          this.sampleList.forEach((obj) => {
            obj.disposeType = data.disposeType;
            obj.sampleDate = data.sampleDate;
            obj.sampleCondition = data.sampleCondition;
            obj.producerManufacturer = data.producerManufacturer;
            obj.samplePlace = data.samplePlace;
            obj.sampleRemark = data.sampleRemark;
            obj.depotId = data.depotId;
            obj.depotName = data.depotName;
          });
        } else {
          this.$set(this.sampleList, index, data);
        }
      },
      //确认质检
      handleConfirm(list, index) {
        // 检查有效性
        // for (const item of list) {
        //   for (const child of item.qualitySampleTemplateList) {
        //
        //     console.log(child, 'child')
        //     if (!child.qualityResultContent || !child.qualityResults) {
        //       this.$message.error('请完善报工内容！');
        //       return;
        //     }
        //   }
        // }
        list.forEach((item) => {
          if (item.qualitySampleTemplateList.length == 1) {
            if (
              item.qualitySampleTemplateList.some(
                (child) => child.qualityResults === 3
              )
            ) {
              // 如果质检项只有一条而且结果为让步接收那么整个就是让步接收
              item.isValid = false;
              item.qualityResults = 3;
            } else if (
              item.qualitySampleTemplateList.some(
                (child) => child.qualityResults === 2
              )
            ) {
              item.isValid = false;
              item.qualityResults = 2;
            } else {
              item.isValid = true;
              item.qualityResults = 1;
            }
          } else {
            if (
              item.qualitySampleTemplateList.some(
                (child) => child.qualityResults === 2
              )
            ) {
              item.isValid = false;
              item.qualityResults = 2;
            } else {
              item.isValid = true;
              item.qualityResults = 1;
            }
          }
          item.qualityStatus = 1;
        });
        if (index != null) {
          this.$set(this.sampleList, index, list[0]);
        } else {
          // this.$set(this.sampleList, null, list);
          this.sampleList = list;
        }
        this.activeName = '2';
        // *** 选完批量质检调用
        // this.countQualityResults();
      },
      // 批量质检
      batchQuality(index, row, type) {
        // if (this.form.sampleList.qualitySampleTemplateList.length == 0) {
        //   this.form.sampleList.forEach((item, index) => {
        //     this.$set(
        //       this.form.sampleList[index],
        //       'qualitySampleTemplateList',
        //       this.form.templateList
        //     );
        //   });
        // }

        if (this.sampleList.length == 0) {
          this.$message.error('样品清单不能为空');
          return;
        }

        if (this.schemeList.length != 0) {
          this.sampleList.forEach((item) => {
            if (item.qualitySampleTemplateList.length == 0) {
              item.qualitySampleTemplateList.push(...this.schemeList);
            }
          });
        }

        this.$refs.detailRef.openDia(
          null,
          null,
          'report',
          this.sampleList,
          null,
          this.schemeList.toolList
        );
      },
      // 批量处置
      batchDispose() {
        if (this.sampleList && this.sampleList.length) {
          this.sampleDisposeVisble = true;
          return;
        }
        this.$message('当前没有样品清单可以处置');

        // this.$refs.disposeRef.openDispose(
        //   null,
        //   null,
        //   'dispose',
        //   this.qualityType
        // );
      },

      //全检，检验标准改变时，重新获取样品列表
      async changeInspectionStandardsModel(val) {
        const sData = this.$refs.tabsRef.$refs.sourceTable.getData();
        if (sData.length > 0) {
          for (let i = 0; i < sData.length; i++) {
            this.$set(sData[i], 'qualityStatus', 2);
          }
        }
        this.form.inspectionStandards = val;
        this.form.sampleNumber = '';
        this.$refs.tabsRef.tableSelClear();
        this.sampleList = [];
        this.$refs.tabsRef.tabsChange('1');
        //检验标准 2计重 1计量
        if (this.form.inspectionStandards == 2 && this.form.qualityMode == 1) {
          for (let i = 0; i < sData.length; i++) {
            let qualitySampleTemplateList = [];
            if (
              sData[i].qualitySampleTemplateList == undefined ||
              sData[i].qualitySampleTemplateList == null ||
              sData[i].qualitySampleTemplateList.length == 0
            ) {
              qualitySampleTemplateList = JSON.parse(
                JSON.stringify(this.schemeList)
              );
            } else {
              qualitySampleTemplateList = sData[i].qualitySampleTemplateList;
            }
            this.sampleList.push({
              ...sData[i],
              sampleCode: await this.getSampleCode(),
              qualitySampleTemplateList
            });
          }
        } else if (
          this.form.inspectionStandards == 1 &&
          this.form.qualityMode == 1
        ) {
          this.getProSamList(sData);
        }
      },

      //从来源数组取样到目标数组
      async getNewFullSampleList(
        sampleCount,
        sampleQuantity,
        sampleUnit,
        specifications
      ) {
        const sourceArray = this.selectedList;
        // 检查单位是否匹配
        const isUnitMismatch =
          sourceArray.length > 0 && sourceArray[0].measureUnit !== sampleUnit;

        // 创建副本并计算初始可取样数量
        const items = sourceArray.map((item) => ({
          ...item,
          remainingQuantity: isUnitMismatch
            ? Infinity
            : item['measureQuantity'], // 剩余可取样数量
          maxPossible: item['measureQuantity'] / sampleQuantity // 最大取样次数
        }));

        const result = [];
        let remainingCount = sampleCount;

        // 尽可能均匀地从各条目取样
        while (remainingCount > 0) {
          // 按剩余可取样比例排序
          items.sort(
            (a, b) =>
              b.remainingQuantity / b['measureQuantity'] -
              a.remainingQuantity / a['measureQuantity']
          );

          let distributed = false;

          for (const item of items) {
            if (
              !isUnitMismatch ||
              (item.remainingQuantity >= sampleQuantity && remainingCount > 0)
            ) {
              let qualitySampleTemplateList = [];
              if (
                item.qualitySampleTemplateList == undefined ||
                item.qualitySampleTemplateList == null ||
                item.qualitySampleTemplateList.length == 0
              ) {
                qualitySampleTemplateList = JSON.parse(
                  JSON.stringify(this.schemeList)
                );
              } else {
                qualitySampleTemplateList = item.qualitySampleTemplateList;
              }
              // 添加到结果数组
              let sampleCode = await this.getSampleCode();
              if (
                this.form.conditionType == 1 &&
                this.form.inspectionStandards == 1
              ) {
                result.push({
                  ...item,
                  measureQuantity: 1,
                  sampleCode,
                  qualitySampleTemplateList
                });
              } else if (
                this.form.conditionType == 2 &&
                (this.form.inspectionStandards == 1 ||
                  this.form.inspectionStandards == 2)
              ) {
                let weight = (item.weight / item.maxPossible).toFixed(2);
                result.push({
                  ...item,
                  measureQuantity: sampleQuantity,
                  measureUnit: sampleUnit,
                  sampleCode,
                  weight,
                  qualitySampleTemplateList
                });
              }
              // 更新剩余数量
              if (!isUnitMismatch) {
                item.remainingQuantity -= sampleQuantity;
              }
              remainingCount--;
              distributed = true;
            }
          }

          // 如果没有分配任何取样
          if (!distributed) {
            break;
          }
        }

        // 判断是不是取整样
        if (
          this.form.conditionType == 1 &&
          specifications &&
          specifications.id
        ) {
          result.map((el) => {
            el.measureQuantity =
              el.measureQuantity * specifications.packageCellTotal;
            el.weight = this.formatNumber(
              el.measureQuantity,
              el.weightProportion
            );
          });
        }
        this.sampleList = result;
        if (this.sampleList.length > sampleCount) {
          this.sampleList = this.sampleList.splice(0, sampleCount);
        }
        this.form.sampleNumber = this.sampleList.length;
      },
      // 小数点数据判断
      formatNumber(a, b, maxDecimals = 4) {
        if (a == 0 || b == 0 || !a || !b) {
          return 0;
        }
        // 计算乘积
        const product = a * b;
        // 转换为固定小数位数，然后转换为数字以去除末尾零
        const rounded = Number(product.toFixed(maxDecimals));
        // 转换为字符串检查是否需要显示小数部分
        const str = rounded.toString();
        // 如果包含小数点
        if (str.indexOf('.') !== -1) {
          // 移除末尾的零和小数点（如果后面没有数字了）
          return str.replace(/\.?0+$/, '');
        }
        return str;
      },
      validateWeight(measureQ, sampleCount) {
        let totalMaxPossible = 0;
        this.selectedList.forEach((item) => {
          totalMaxPossible += item.measureQuantity / measureQ;
        });

        if (totalMaxPossible < sampleCount) {
          // this.formData.portion = totalMaxPossible;
          this.$message.info(`最大取样条数为${totalMaxPossible}`);
          return false;
        }

        let totalWeight = this.selectedList.reduce(
          (sum, item) => sum + item.weight,
          0
        );
        const weightUnit = this.selectedList[0].weightUnit;
        if (weightUnit === 'G') totalWeight /= 1000;

        if (measureQ * sampleCount > totalWeight) {
          this.$message.info('取样计量重量不能大于总计量重量');
          return false;
        }

        const invalidItem = this.selectedList.find((item) => {
          const weight =
            item.weightUnit === 'G' ? item.weight / 1000 : item.weight;
          return weight < measureQ;
        });

        if (invalidItem) {
          this.$message.info('勾选条目重量小于取样重量');
          return false;
        }

        return true;
      },

      isStandard1OrWeightSample() {
        return (
          this.form.inspectionStandards === 1 ||
          (this.form.inspectionStandards === 2 && this.form.conditionType == 2)
        );
      },
      validateMeasureQuantity(measureQ, unit, sampleCount) {
        if (this.form.conditionType == 2 && measureQ <= 0) {
          this.$message.info('取样计量数量必须大于0');
          return false;
        }

        const totalQuantity = this.selectedList.reduce(
          (sum, item) => sum + item.measureQuantity,
          0
        );
        if (
          (this.selectedList[0].measureUnit === unit ||
            this.form.conditionType == 1) &&
          measureQ * sampleCount > totalQuantity
        ) {
          this.$message.info('取样计量数量不能大于总计量数量');
          return false;
        }

        const invalidItem = this.selectedList.find(
          (item) => item.measureQuantity < measureQ
        );
        if (invalidItem) {
          this.$message.info('条目计量数量小于取样计量数量');
          return false;
        }

        return true;
      },

      isWeightStandardFullSample() {
        return (
          this.form.inspectionStandards === 2 && this.form.conditionType == 1
        );
      },

      handleClose() {
        this.visible = false;
        this.$emit('done');
      },

      // 抽检取整样 校验
      validateSampleCount(sampleCount, specifications) {
        // 新增校验 ***
        let isFlag = this.validateSampleQuantity(sampleCount, specifications);
        if (!isFlag) {
          return false;
        }
        // ***
        const chooseNumber = this.selectedList.reduce((acc, pro) => {
          return pro.measureQuantity ? acc + Number(pro.measureQuantity) : acc;
        }, 0);
        const invalidItem = chooseNumber < sampleCount;
        // console.log(this.selectedList, 'this.selectedList');
        // const invalidItem = this.selectedList.find(
        //   (item) => item.measureQuantity < sampleCount
        // );
        if (invalidItem) {
          this.$message.info('所选的条目计量数量小于取样计量数量');
          return false;
        }
        // ***
        return true;
      },

      async handleWeightFullSample(sampleCount, specifications) {
        const dataList = [];
        let currentNum = sampleCount - this.selectedList.length;
        let currentNum1 = sampleCount;
        for (const item of this.selectedList) {
          const qualitySampleTemplateList = item.qualitySampleTemplateList
            ?.length
            ? JSON.parse(JSON.stringify(item.qualitySampleTemplateList))
            : JSON.parse(
                JSON.stringify(
                  this.schemeList.map((item) => {
                    item['qualityResults'] = 1;
                    return item;
                  })
                )
              );

          if (sampleCount >= this.selectedList.length) {
            dataList.push({
              ...item,
              measureQuantity: 1, //作为计量数量
              sampleCode: await this.getSampleCode(),
              qualitySampleTemplateList
            });
          } else {
            if (dataList.length < sampleCount) {
              dataList.push({
                ...item,
                measureQuantity: currentNum1 > 1 ? 1 : currentNum1, //作为计量数量
                sampleCode: await this.getSampleCode(),
                qualitySampleTemplateList
              });
              currentNum1 -= 1;
            }
          }
        }
        if (sampleCount > this.selectedList.length) {
          dataList.forEach((item) => {
            if (currentNum > 0) {
              let data = this.selectedList.find((val) => val.id == item.id);
              item['measureQuantity'] =
                data.measureQuantity - 1 - currentNum > 0
                  ? currentNum + 1
                  : data.measureQuantity;
              currentNum = currentNum - (data.measureQuantity - 1);
            }
          });
        }
        // 更改 从新计算 样品清单 取整样 数据
        if (specifications && specifications.id) {
          // let proportion = (obj.weight / obj.measureQuantity).toFixed(2);
          console.log(dataList, 'dataList 这里是重量');
          console.log(specifications, 'specifications ===');
          dataList.map((el) => {
            el.measureQuantity =
              el.measureQuantity * specifications.packageCellTotal;
            el.weight = this.formatNumber(
              el.measureQuantity,
              el.weightProportion
            );
          });
        }
        // 更改
        this.sampleList = dataList;
        this.sampleNumber = this.sampleList.length;
      },

      //计算合格率
      countQualityResults() {
        let sampleList = this.sampleList; //样品清单
        let sampleNumber = this.form.total; //样品总数
        // let qualifiedNumber = sampleList.filter(item => item.qualityResults == 1 || item.qualityResults == 3).length;
        // let noQualifiedNumber = sampleList.filter(
        //   (item) => item.qualityResults == 2
        // ).length;
        let noQualifiedNumber = sampleList.reduce((acc, pro) => {
          // console.log(acc, pro);
          // if (pro.qualityResults == 2) {
          //   return acc + Number(pro.measureQuantity);
          // }
          return pro.qualityResults == 2
            ? acc + Number(pro.measureQuantity)
            : acc;
        }, 0);
        let qualifiedNumber = sampleNumber - noQualifiedNumber; //不合格数
        let qualificationRate = (
          (qualifiedNumber / sampleNumber) *
          100
        ).toFixed(2); //合格率
        let noQualificationRate = (
          (noQualifiedNumber / sampleNumber) *
          100
        ).toFixed(2); //不合格率
        this.$refs.baseInfoRefs.updateQualificationRate(
          qualifiedNumber,
          noQualifiedNumber,
          qualificationRate,
          noQualificationRate
        );
      },
      closeDispose() {
        this.rowData = null;
        this.sampleDisposeVisble = false;
        // this.rowData = null;
      }
    }
  };
</script>

<style lang="scss" scoped></style>