kd-aiot-frontend-wt/src/views/bpm/handleTask/components/qualityReportApproval/unqualifiedProduct.vue

<template>
  <div class="ele-body">
    <el-card shadow="never" v-loading="loading">
      <ele-pro-table
        ref="table"
        :columns="columns"
        :datasource="displayPoList"
        :selection.sync="selection"
        :needPage="false"
        row-key="uniqueKey"
        max-height="500px"
      >
        <!-- 操作列 -->
        <template v-slot:toolbar v-if="showBtn">
          <el-button type="primary" slot="reference" @click="add"
            >新增</el-button
          >
          <el-button
            type="primary"
            slot="reference"
            :disabled="selection.length == 0"
            @click="disposeFn(1)"
            >批量处置</el-button
          >

          <el-popconfirm
            class="ele-action"
            title="确定要删除吗？"
            @confirm="remove"
            style="margin-left: 10px"
          >
            <template v-slot:reference>
              <el-button :disabled="selection.length == 0" type="danger"
                >批量删除</el-button
              >
            </template>
          </el-popconfirm>
        </template>
        <template v-slot:action="{ row }">
          <el-link
            slot="reference"
            type="primary"
            :underline="false"
            icon="el-icon-edit"
            v-if="row.disposalStatus != 2"
            @click="disposeFn(2, row)"
          >
            处置
          </el-link>
        </template>
        <template v-slot:badTypeName="{ row, $index }">
          <el-select
            v-model="row.badTypeId"
            placeholder="请选择不良类型"
            size="small"
            style="width: 100%"
            remote
            filterable
            clearable
          >
            <el-option
              v-for="item in badTypeList"
              :key="item.id"
              :label="item.name"
              :value="item.id"
              @click="row.badTypeName = item.name"
            >
            </el-option>
          </el-select>
        </template>

        <template v-slot:badNameName="{ row, $index }">
          <el-select
            v-model="row.badNameId"
            placeholder="请选择不良名称"
            size="small"
            style="width: 100%"
            remote
            filterable
            clearable
          >
            <el-option
              v-for="item in badNameList"
              :key="item.id"
              :label="item.name"
              :value="item.id"
              @click="row.badNameName = item.name"
            >
            </el-option>
          </el-select>
        </template>
        <template v-slot:reasonTypeName="{ row, $index }">
          <el-select
            v-model="row.reasonTypeId"
            placeholder="请选择原因类型"
            size="small"
            style="width: 100%"
            remote
            filterable
            clearable
          >
            <el-option
              v-for="item in reasonTypeList"
              :key="item.id"
              :label="item.name"
              :value="item.id"
              @click="row.reasonTypeName = item.name"
            >
            </el-option>
          </el-select>
        </template>
        <template v-slot:unqualifiedReason="{ row, $index }">
          <el-input v-model="row.unqualifiedReason"></el-input>
        </template>
      </ele-pro-table>
    </el-card>

    <ele-modal
      :visible.sync="dialogVisible"
      width="35%"
      @close="close"
      append-to-body
      title="处置"
    >
      <el-form
        ref="disposeForm"
        :model="disposeForm"
        label-width="150px"
        :rules="rules"
      >
        <el-form-item label="处置方式：" prop="disposeType">
          <el-select
            v-model="disposeForm.disposeType"
            placeholder="请选择"
            style="width: 100%"
            @change="disposeTypeChange"
          >
            <el-option
              v-for="item in disposeList"
              :key="item.value"
              :label="item.label"
              :value="item.value"
            >
            </el-option>
          </el-select>
        </el-form-item>

        <template
          v-if="disposeForm.disposeType == 1 || disposeForm.disposeType == 2"
        >
          <el-form-item label="回流工序" prop="taskId" align="center">
            <el-select
              style="width: 100%"
              v-model="disposeForm.taskId"
              clearable
            >
              <el-option
                v-for="item in refluxTaskList"
                :key="item.taskId"
                :value="item.taskId"
                :label="item.taskTypeName"
              ></el-option>
            </el-select>
          </el-form-item>
        </template>

        <template v-if="disposeForm.disposeType == 6">
          <el-row>
            <el-col :span="24">
              <el-form-item
                label="留样数量："
                prop="keepSampleQuantity"
                align="center"
              >
                <el-input
                  v-model="disposeForm.keepSampleQuantity"
                  placeholder="请输入"
                  style="width: 100%"
                >
                  <template slot="append">{{
                    current?.measureUnit
                  }}</template></el-input
                >
              </el-form-item>
            </el-col>
            <el-col :span="6"> </el-col>
          </el-row>
          <el-row style="margin-top: 12px">
            <el-col :span="24">
              <el-form-item label="留样日期：" prop="sampleDate" align="center">
                <el-date-picker
                  class="w100"
                  v-model="disposeForm.sampleDate"
                  type="date"
                  value-format="yyyy-MM-dd"
                  placeholder="请输入"
                ></el-date-picker>
              </el-form-item>
            </el-col>
            <el-col :span="6"> </el-col>
          </el-row>
          <el-row style="margin-top: 12px">
            <el-col :span="24">
              <el-form-item
                label="留样条件："
                prop="sampleCondition"
                align="center"
              >
                <el-input
                  v-model="disposeForm.sampleCondition"
                  placeholder="请输入"
                  style="width: 100%"
                ></el-input>
              </el-form-item>
            </el-col>
          </el-row>
          <el-row style="margin-top: 12px">
            <el-col :span="24">
              <el-form-item
                label="生产商/受托生产："
                prop="producerManufacturer"
                align="center"
              >
                <el-input
                  v-model="disposeForm.producerManufacturer"
                  placeholder="请输入"
                  style="width: 100%"
                ></el-input>
              </el-form-item>
            </el-col>
          </el-row>
          <el-row style="margin-top: 12px">
            <el-col :span="24">
              <el-form-item
                label="留样地点："
                prop="samplePlace"
                align="center"
              >
                <el-input
                  type="textarea"
                  v-model="disposeForm.samplePlace"
                  placeholder="请输入"
                  style="width: 100%"
                ></el-input>
              </el-form-item>
            </el-col>
          </el-row>
          <el-row style="margin-top: 12px">
            <el-col :span="24">
              <el-form-item
                label="留样备注："
                prop="sampleRemark"
                align="center"
              >
                <el-input
                  type="textarea"
                  v-model="disposeForm.sampleRemark"
                  placeholder="请输入"
                  style="width: 100%"
                ></el-input>
              </el-form-item>
            </el-col>
          </el-row>

          <el-row style="margin-top: 12px">
            <el-col :span="24"> </el-col>
          </el-row>
        </template>

        <template
          v-if="
            disposeForm.disposeType == 3 ||
            disposeForm.disposeType == 6 ||
            disposeForm.disposeType == 9
          "
        >
          <el-form-item label="入库仓库：" prop="depotId" align="center">
            <el-select style="width: 100%" v-model="disposeForm.depotId">
              <el-option
                v-for="item in warehouseList"
                :key="item.id"
                :value="item.id"
                :label="item.name"
                @click.native="chooseWarehouse(item)"
              ></el-option>
            </el-select>
          </el-form-item>
        </template>
      </el-form>

      <!-- <DictSelection
        dictName="不良品处理类型"
        :filterArr="all ? ['返工返修'] : []"
        v-model="current.disposalStatus"
      /> -->

      <div slot="footer" class="dialog-footer">
        <el-button @click="dialogVisible = false">取 消 </el-button>
        <el-button type="primary" @click="handleDispose">确 定</el-button>
      </div>
    </ele-modal>
    <!-- <Edit ref="edit" @success="save" /> -->
    <ele-modal
      :visible.sync="addDialogVisible"
      width="60%"
      append-to-body
      title="选择"
      @close="closeAdd"
    >
      <el-table
        ref="addTable"
        :data="inventoryList"
        @selection-change="handleAddSelectionChange"
        row-key="id"
      >
        <el-table-column
          type="selection"
          width="55"
          align="center"
          :selectable="
            (row, index) => {
              return (
                !poList.map((item) => item.sourceId).includes(row.sourceId) ||
                inventoryList.length == 1
              );
            }
          "
        ></el-table-column>
        <el-table-column
          type="index"
          label="序号"
          width="55"
          align="center"
        ></el-table-column>
        <el-table-column
          prop="sampleCode"
          label="样品编码"
          width="150"
          align="center"
        ></el-table-column>
        <el-table-column
          prop="categoryCode"
          label="物品编码"
          width="150"
          align="center"
        ></el-table-column>
        <el-table-column
          prop="categoryName"
          label="物品名称"
          width="150"
          align="center"
          show-overflow-tooltip
        ></el-table-column>
        <el-table-column
          prop="specification"
          label="规格"
          width="120"
          align="center"
        ></el-table-column>
        <el-table-column prop="measureQuantity" label="计量数量" align="center">
          <template slot-scope="scope">
            <template v-if="inventoryList.length === 1">
              <el-input-number
                v-model="singleQuantity"
                :min="0"
                :max="availableTotal"
                style="width: 120px"
              ></el-input-number>
            </template>
            <template v-else>
              {{ scope.row.measureQuantity }}
            </template>
          </template>
        </el-table-column>
        <el-table-column
          prop="measureUnit"
          label="计量单位"
          align="center"
        ></el-table-column>
      </el-table>
      <div slot="footer" class="dialog-footer">
        <el-button @click="addDialogVisible = false">取 消</el-button>
        <el-button type="primary" @click="handleAddSave">确 定</el-button>
      </div>
    </ele-modal>
  </div>
</template>

<script>
  import Edit from './edit.vue';
  import { getWarehouseList } from '@/api/bpm/components/saleManage/saleorder.js';
  import dictMixins from '@/mixins/dictMixins';

  import {
    queryQualitySamplContent,
    queryQualityInventory,
    getById,
    refluxTask,
    getBadnameList,
    getBadtypeList,
    getReasontypeList
  } from '@/api/bpm/components/qualityReportApproval/qualityReportApproval';
  export default {
    components: {
      Edit
    },
    props: {
      total: {
        type: Number,
        default: 0
      },
      businessType: {
        type: String,
        default: ''
      }
    },
    mixins: [dictMixins],
    data() {
      return {
        cacheKeyUrl: 'qsm-c2e9664a-unqualifiedList-detailList',
        key: '',
        warehouseList: [],
        activeComp: 'main',
        addDialogVisible: false,
        rules: {
          disposeType: [
            { required: true, message: '请选择处置方式', trigger: 'change' }
          ],
          depotId: [
            { required: true, message: '请选择仓库', trigger: 'change' }
          ],
          keepSampleQuantity: [
            {
              validator: (rule, value, callback) => {
                if (
                  this.disposeForm.disposeType === 6 &&
                  this.current &&
                  this.current.measureQuantity !== undefined
                ) {
                  const inputVal = Number(value);
                  const maxVal = Number(this.current.measureQuantity);
                  if (inputVal > maxVal) {
                    return callback(new Error(`不能超过原计量数量${maxVal}`));
                  }
                }
                callback();
              },
              trigger: 'blur'
            }
          ]
        },
        disposeType: '',
        // 批量处置标识：一次处置弹窗「确定」对应一个标识，同批明细共享，
        // 审批通过时按「处置类型 + 该标识」合并生成一张处置入库单
        disposeBatchNo: '',
        disposeForm: {
          disposeType: '',
          sampleCondition: '',
          sampleDate: '',
          samplePlace: '',
          sampleRemark: '',
          producerManufacturer: '',
          depotId: '',
          depotName: '',
          taskId: '',
          keepSampleQuantity: '',
          disposeBatchNo: ''
        },
        loading: false,
        selection: [],
        poList: [],
        id: '',
        dialogVisible: false,
        current: {},
        formData: {},
        all: false,
        qualityType: null,
        allList: [
          { value: 1, label: '返工' },
          { value: 2, label: '返修' },
          { value: 3, label: '报废' },
          { value: 4, label: '降级使用' },
          { value: 5, label: '让步接收' },
          // { value: 6, label: '留样' },
          // { value: 7, label: '消耗' },
          // { value: 8, label: '回用/归批' },
          { value: 9, label: '转试销' },
          { value: 10, label: '退货' }
        ],
        //来料
        disposalStatusListType: [
          {
            value: 5,
            label: '让步接收'
          },
          {
            value: 9,
            label: '退货'
          }
        ],
        //生产
        disposalStatusList: [
          {
            value: 1,
            label: '返工'
          },
          {
            value: 2,
            label: '返修'
          },
          {
            value: 3,
            label: '报废'
          },
          {
            value: 4,
            label: '降级使用'
          },
          {
            value: 5,
            label: '让步接收'
          },
          {
            value: 6,
            label: '留样'
          },
          {
            value: 7,
            label: '消耗'
          },
          {
            value: 8,
            label: '回用'
          }
        ],
        workOrderCode: '',
        qualityWorkerId: '',
        qualityResults: '',
        refluxTaskList: [],
        sampleList: [],
        inventoryList: [],
        oldList: [],
        addSelection: [],
        retainedSampleQuantity: 0,
        retainedSampleUnqualified: 0,
        lossNumber: 0,
        lossNumberUnqualified: 0,
        badTypeList: [],
        badNameList: [],
        reasonTypeList: []
      };
    },
    computed: {
      showBtn() {
        return true;
      },
      disposeList() {
        if (this.qualityType == 1) {
          return this.allList.filter((item) => [5, 10].includes(item.value));
        }
        if (this.qualityType == 2) {
          return this.allList.filter((item) => item.value !== 8);
        }
        if (this.qualityType == 2 || this.qualityType == 3) {
          return this.allList.filter(
            (item) => item.value !== 8 && item.value !== 10
          );
        } else {
          return this.allList;
        }
      },
      // 可用总数 = 总数 - 留样数 - 消耗数
      availableTotal() {
        if (!this.sampleList.length) return this.total;
        const usedQuantity = this.sampleList
          .filter((item) => item.disposeType == 6 || item.disposeType == 7)
          .reduce((sum, item) => sum + (item.measureQuantity || 0), 0);
        return this.total - usedQuantity;
      },
      // 表格列配置
      columns() {
        const arr = [
          {
            width: 45,
            type: 'selection',
            columnKey: 'selection',
            reserveSelection: true,
            align: 'center',
            // 已处置的行只做展示，不允许再被勾选去「批量处置 / 批量删除」
            selectable: (row) => row.disposalStatus != 2
          },
          {
            columnKey: 'index',
            label: '序号',
            type: 'index',
            width: 55,
            align: 'center',
            showOverflowTooltip: true,
            fixed: 'left'
          },
          {
            label: '样品编码',
            prop: 'sampleCode',
            width: '150',
            align: 'center',
            showOverflowTooltip: true
          },
          {
            prop: 'categoryCode',
            label: '物品编码',
            width: '150',
            align: 'center',
            showOverflowTooltip: true
          },
          {
            prop: 'categoryName',
            label: '物品名称',
            width: '150',
            align: 'center',
            showOverflowTooltip: true
          },
          {
            label: '规格',
            prop: 'specification',
            width: '120',
            align: 'center',
            showOverflowTooltip: true
          },
          {
            prop: 'brandNum',
            label: '牌号',
            align: 'center'
          },
          {
            prop: 'modelType',
            label: '型号',
            align: 'center',
            width: '120',
            showOverflowTooltip: true
          },
          {
            label: '机型',
            prop: 'modelKey',
            align: 'center',
            showOverflowTooltip: true
          },
          {
            label: '颜色',
            prop: 'colorKey',
            align: 'center',
            showOverflowTooltip: true
          },
          {
            prop: 'batchNo',
            label: '批次号',
            align: 'center',
            width: '120',
            showOverflowTooltip: true
          },
          {
            prop: 'weight',
            label: '重量',
            align: 'center',
            width: '120',
            showOverflowTooltip: true
          },
          {
            prop: 'weightUnit',
            label: '重量单位',
            align: 'center',
            width: '120',
            showOverflowTooltip: true
          },
          {
            prop: 'engrave',
            label: '刻码',
            align: 'center'
          },

          { label: '计量数量', prop: 'measureQuantity', align: 'center' },
          { label: '计量单位', prop: 'measureUnit', align: 'center' },

          {
            prop: 'produceRoutingName',
            label: '工艺路线',
            align: 'center'
          },
          {
            prop: 'produceTaskName',
            label: '工序',
            align: 'center'
          },
          {
            prop: 'badTypeName',
            label: '不良类型',
            slot: 'badTypeName',
            width: '180',
            align: 'center'
          },
          {
            prop: 'badNameName',
            slot: 'badNameName',
            label: '不良名称',
            width: '180',
            align: 'center'
          },
          {
            slot: 'reasonTypeName',
            prop: 'reasonTypeName',
            label: '原因类型',
            width: '180',
            align: 'center'
          },
          {
            slot: 'unqualifiedReason',
            prop: 'unqualifiedReason',
            label: '原因',
            width: '180',
            align: 'center'
          },
          {
            prop: 'disposeTime',
            label: '处置时间',
            align: 'center',
            width: '180',
            showOverflowTooltip: true
          },
          {
            prop: 'disposalStatus',
            label: '处置状态',
            align: 'center',
            fixed: 'right',
            width: '120',
            showOverflowTooltip: true,
            filters: [
              { value: 0, text: '待处置' },
              { value: 1, text: '处置中' },
              { value: 2, text: '处置完成' }
            ],
            filterMethod: this.disposalStatusFilter,
            formatter: (row, column, cellValue) => {
              return this.disposalStatustList[cellValue ? cellValue : 0];
            }
          },
          {
            prop: 'disposeType',
            label: '处置类型',
            align: 'center',
            fixed: 'right',
            width: '120',
            showOverflowTooltip: true,
            formatter: (row, column, cellValue) => {
              console.log(this.allList.find((item) => item.value == cellValue));

              return this.allList.find((item) => item.value == cellValue)
                ?.label;
            }
          },
          {
            columnKey: 'action',
            label: '操作',
            width: 100,
            align: 'center',
            resizable: false,
            fixed: 'right',
            slot: 'action',
            showOverflowTooltip: true
          }
        ];
        return arr;
      },
      disposalStatustList() {
        return { 0: '待处置', 1: '处置中', 2: '处置完成' };
      },
      // 兜底去重，防止 uniqueKey 极端情况下仍重复
      // 注意：不再过滤掉「已处置」的行（disposalStatus == 2），
      // 台账明细要展示全部样品（含已处置），否则审批人看到的条数和实际不合格数对不上
      displayPoList() {
        const seen = new Set();
        return this.poList.filter((item) => {
          const key = item.uniqueKey || item.id;
          if (!key || seen.has(key)) return false;
          seen.add(key);
          return true;
        });
      }
    },
    created() {
      this.getBadTypeList();
      this.getBadNameList();
      this.getReasonTypeList();
    },
    methods: {
      // 为每行生成前端唯一 key：已保存的使用 's_'+id，新增/拆分的生成 'n_'+时间戳+随机数
      ensureUniqueKey(item) {
        if (item.uniqueKey) return item.uniqueKey;
        if (item.id) {
          item.uniqueKey = `s_${item.id}`;
        } else {
          item.uniqueKey = `n_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
        }
        return item.uniqueKey;
      },
      disposalStatusFilter(value, row, column) {
        if (value == row.disposalStatus) {
          return row;
        }
      },
      // 查询不良类型
      async getBadTypeList() {
        const res = await getBadtypeList({
          pageNum: 1,
          size: 999
        });
        this.badTypeList = res.list;
      },
      // 查询不良名称
      async getBadNameList() {
        const res = await getBadnameList({
          pageNum: 1,
          size: 999
        });
        this.badNameList = res.list;
      },
      // 查询原因类型
      async getReasonTypeList() {
        const res = await getReasontypeList({
          pageNum: 1,
          size: 999
        });
        this.reasonTypeList = res.list;
      },
      async init(row) {
        this.qualityType = row.qualityType;
        this.id = row.id;
        console.log(row, 'row');
        this.workOrderCode = row.workOrderCode;
        this.qualityWorkerId = row.qualityWorkerId;
        this.qualityResults = row.qualityResults;
        this.warehouseList = await getWarehouseList();
        await this.getQueryQualityInventory();
        await this.queryQualitySamplContent();
        if (this.id) {
          await this.datasource();
        }
      },
      // fromSelect：结论是用户手动选的，父组件只回填数量、不得按数量反推结论，
      // 否则「整单合格 / 整单让步接收 / 部分合格」会被下面的推导逻辑立刻改回「整单不合格」
      setQualifiedNumber(fromSelect = false) {
        let isQualifiedNumber = true;
        let noQualifiedNumber = this.poList
          .filter((item) => ![5, 6, 7].includes(item.disposeType))
          .reduce((acc, cur) => acc + cur.measureQuantity, 0);

        if (
          this.poList
            .filter((item) => item.disposeType == 5)
            .reduce((acc, cur) => acc + cur.measureQuantity, 0) ==
          this.availableTotal
        ) {
          isQualifiedNumber = false;
        }
        this.$emit('setQualifiedNumber', {
          noQualifiedNumber,
          qualifiedNumber: this.availableTotal - noQualifiedNumber,
          isQualifiedNumber,
          fromSelect
        });
      },
      // 切换结论时重建明细的来源：质检工单场景用「待处置库存」；
      // 手工新增台账没有工单库存（qualityWorkerId 为空），用台账自身未处置的行，
      // 否则选「整单不合格 / 整单让步接收」会把明细清空
      baseDisposeList() {
        if (this.qualityWorkerId) {
          return this.inventoryList;
        }
        return this.oldList.filter((item) => item.disposalStatus != 2);
      },
      selectResult(qualityResults) {
        if (qualityResults == 1) {
          this.poList = JSON.parse(JSON.stringify(this.oldList));
          this.poList = this.poList.map((item) => {
            this.ensureUniqueKey(item);
            if (item.disposalStatus != 2) {
              item.disposalStatus = 1;
              item.disposeType = 5;
            }
            return item;
          });
        }
        if (qualityResults == 4) {
          this.poList = [
            ...JSON.parse(JSON.stringify(this.baseDisposeList())),
            ...JSON.parse(
              JSON.stringify(
                this.oldList.filter((item) => item.disposalStatus == 2)
              )
            )
          ];
          this.poList = this.poList.map((item) => {
            this.ensureUniqueKey(item);
            if (item.disposalStatus != 2) {
              item.disposalStatus = 1;
              item.disposeType = 5;
            }
            return item;
          });
        }
        if (qualityResults == 2) {
          this.poList = [
            ...JSON.parse(JSON.stringify(this.baseDisposeList())),
            ...JSON.parse(
              JSON.stringify(
                this.oldList.filter((item) => item.disposalStatus == 2)
              )
            )
          ];
          this.poList = this.poList.map((item) => {
            this.ensureUniqueKey(item);
            return item;
          });
        }
        if (qualityResults == 3) {
          this.poList = JSON.parse(JSON.stringify(this.oldList));
          this.poList.forEach((item) => {
            this.ensureUniqueKey(item);
          });
        }
        this.qualityResults = qualityResults;
        // 用户手动选结论：只让父组件刷新数量，结论保持用户选的值
        this.setQualifiedNumber(true);
      },
      disposeTypeChange() {
        if (this.disposeForm.disposeType == 6) {
          this.disposeForm.keepSampleQuantity =
            this.current?.measureQuantity || '';
        }
      },
      handleAddSelectionChange(selection) {
        this.addSelection = selection;
      },
      handleAddSave() {
        if (this.addSelection.length === 0) {
          this.$message.warning('请选择数据');
          return;
        }
        const poListTotal = this.poList
        .filter((item) => ![5, 6, 7].includes(item.disposeType))
        .reduce(
          (sum, item) => sum + Number(item.measureQuantity || 0),
          0
        );
        let selectedTotal = 0;
        if (this.inventoryList.length === 1) {
          selectedTotal =
            this.addSelection.length * Number(this.singleQuantity || 0);
        } else {
          selectedTotal = this.addSelection.reduce(
            (sum, item) => sum + Number(item.measureQuantity || 0),
            0
          );
        }
        if (poListTotal + selectedTotal > this.availableTotal) {
          this.$message.error('选中的计量数量之和加上已有数量不能超过总数');
          return;
        }
        this.addSelection.forEach((item) => {
          const newItem = JSON.parse(JSON.stringify(item));
          // 拆分行：始终生成新的 uniqueKey（基于时间戳+随机数）
          newItem.uniqueKey = `n_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
          // 拆分行不带后端 id，清掉避免误传
          delete newItem.id;
          if (this.inventoryList.length === 1) {
            newItem.measureQuantity = Number(this.singleQuantity);
          }
          this.poList.push(newItem);
        });
        this.addDialogVisible = false;
        this.setQualifiedNumber();
      },
      add() {
        this.addDialogVisible = true;
        this.$nextTick(() => {
          this.$refs.addTable?.clearSelection();
        });
        if (this.inventoryList.length === 1) {
          this.singleQuantity = this.inventoryList[0].measureQuantity || 0;
        }
      },
      closeAdd() {
        this.addSelection = [];
        this.$nextTick(() => {
          this.$refs.addTable?.clearSelection();
        });
      },

      // /* 表格数据源 */
      async datasource() {
        const arr = await getById(this.id);
        this.oldList = JSON.parse(JSON.stringify(arr.poList || []));
        this.poList = (arr.poList || []).map((item) => {
          this.ensureUniqueKey(item);
          return item;
        });

        // 回流工序：处置方式选「返工 / 返修」时要选工序，和台账列表页取的是同一份数据。
        // 台账记录里的工单编码就是 sourceCode，拿它调 /mes/workorder/refluxTask。
        if (arr.sourceCode) {
          this.workOrderCode = arr.sourceCode;
          await this.getRefluxTask();
        } else {
          console.warn(
            '[不良品台账] 台账记录未返回工单编码（sourceCode），处置方式选「返工 / 返修」时无法选择回流工序',
            arr
          );
        }
        // 合格数 / 不合格数的数据源是「质检工单详情」接口（父组件 detailDialog 用 getDetailById 回填）；
        // 台账 getById 从不返回这两个字段（内外网实测一致），
        // 用 poList 反推会把「让步接收(5)/留样(6)/消耗(7)」这些处置行排除掉，数也对不上。
        // 其他业务类型（检测报告单等）保持原有计算逻辑不变。
        const hasApiNumber =
          arr.qualifiedNumber !== undefined &&
          arr.qualifiedNumber !== null &&
          arr.noQualifiedNumber !== undefined &&
          arr.noQualifiedNumber !== null;
        if (this.businessType?.includes('不良品处置')) {
          if (hasApiNumber) {
            this.$emit('setQualifiedNumber', {
              qualifiedNumber: arr.qualifiedNumber,
              noQualifiedNumber: arr.noQualifiedNumber,
              // 标记来自接口：父组件只更新数量，不改写台账已保存的「结论」
              fromApi: true
            });
          } else {
            // 不做兜底：台账接口没给就保持父组件用工单数据回填的值，别拿 poList 反推
            console.warn(
              '[不良品台账] 台账 getById 未返回 qualifiedNumber / noQualifiedNumber，合格数/不合格数以质检工单详情回填为准',
              arr.unqualifiedProductsCode
            );
          }
        } else {
          this.setQualifiedNumber();
        }
      },

      /**
       * 回流工序：处置方式选「返工 / 返修」时，工序下拉的数据源
       * 与不合格品台账列表页一致，用工单编码查询
       */
      async getRefluxTask() {
        if (!this.workOrderCode) return;
        try {
          const res = await refluxTask({
            workOrderCode: this.workOrderCode
          });
          this.refluxTaskList = res || [];
        } catch (error) {
          this.refluxTaskList = [];
          this.$message.error(error.message || '回流工序加载失败');
        }
      },

      remove() {
        let ids = this.selection.map((item) => item.id);
        console.log(ids, 'ids');
        this.poList = this.poList.filter((item) => !ids.includes(item.id));
        this.setQualifiedNumber();
      },
      close() {
        this.dialogVisible = false;
        this.disposeType = '';
        this.all = false;
        this.formData.disposalStatus = '';
        this.disposeBatchNo = '';
        this.disposeForm.disposeBatchNo = '';
      },
      /**
       * 生成处置批次标识
       * 规则：DB + yyyyMMddHHmmss + 4 位随机数，例如 DB202611101530251234
       * 一次处置弹窗「确定」生成一个，批量处置写入全部选中行，单条处置只写当前行；
       * 同一条明细被重新处置时标识覆盖为最新一次，保证以最终处置结果为准。
       */
      buildDisposeBatchNo() {
        const d = new Date();
        const pad = (n) => String(n).padStart(2, '0');
        const ts =
          d.getFullYear() +
          pad(d.getMonth() + 1) +
          pad(d.getDate()) +
          pad(d.getHours()) +
          pad(d.getMinutes()) +
          pad(d.getSeconds());
        const rand = String(Math.floor(Math.random() * 10000)).padStart(4, '0');
        return `DB${ts}${rand}`;
      },
      // // 处置
      disposeFn(type, row) {
        this.current = {};
        if (type == 1) {
          this.all = true;
        } else {
          this.current = row;
        }
        this.formData = { ...row };
        // 每次打开处置弹窗都生成新的批次标识：批量处置时全部选中行共享同一个标识，
        // 单条处置时该行使用自己的标识，审批通过后按标识把同批明细合并成一张处置入库单
        this.disposeBatchNo = this.buildDisposeBatchNo();
        this.disposeForm.disposeBatchNo = this.disposeBatchNo;
        this.dialogVisible = true;
      },

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

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

      async queryQualitySamplContent() {
        const res = await queryQualitySamplContent({
          qualityWorkerId: this.qualityWorkerId,
          size: 1000
        });
        this.sampleList = res.list;
        [
          'retainedSampleQuantity',
          'retainedSampleUnqualified',
          'lossNumber',
          'lossNumberUnqualified'
        ].forEach((key) => {
          this[key] = 0;
        });
        if (this.sampleList.length > 0 && this.inventoryList.length > 0) {
          const processedList = this.sampleList.filter(
            (item) => item.disposeType == 6 || item.disposeType == 7
          );
          console.log(
            processedList.filter((item) => item.disposeType == 6),
            'qwewqe'
          );
          console.log(
            processedList.filter((item) => item.disposeType == 7),
            '123123'
          );
          processedList.forEach((sampleItem) => {
            if (sampleItem.disposeType == 6) {
              sampleItem.qualityResults == 2
                ? (this.retainedSampleUnqualified += sampleItem.measureQuantity)
                : (this.retainedSampleQuantity += sampleItem.measureQuantity);
            } else {
              sampleItem.qualityResults == 2
                ? (this.lossNumberUnqualified += sampleItem.measureQuantity)
                : (this.lossNumber += sampleItem.measureQuantity);
            }
            const inventoryItem = this.inventoryList.find(
              (item) => item.sourceId === sampleItem.sourceId
            );
            if (inventoryItem) {
              inventoryItem.measureQuantity = Math.max(
                0,
                (inventoryItem.measureQuantity || 0) -
                  (sampleItem.measureQuantity || 0)
              );
            }
          });
        }
        this.$emit('setLossNumber', {
          lossNumber: this.lossNumber,
          lossNumberUnqualified: this.lossNumberUnqualified,
          retainedSampleQuantity: this.retainedSampleQuantity,
          retainedSampleUnqualified: this.retainedSampleUnqualified
        });
        if (this.inventoryList.length == 1 && !this.inventoryList[0].sourceId) {
          this.inventoryList[0].measureQuantity =
            this.inventoryList[0].measureQuantity -
            this.lossNumber -
            this.lossNumberUnqualified -
            this.retainedSampleQuantity -
            this.retainedSampleUnqualified;
        }
      },

      async handleDispose() {
        this.$refs['disposeForm'].validate(async (valid) => {
          // let ids = this.selection.map((item) => item.id);
          let ids = this.current?.id
            ? [this.current.id]
            : this.selection.map((item) => item.id);
          this.poList.forEach((item, index) => {
            if (ids.includes(item.id)) {
              this.$set(this.poList[index], 'disposalStatus', 1);

              for (const key in this.disposeForm) {
                this.$set(this.poList[index], key, this.disposeForm[key]);
              }
            }
          });
          this.dialogVisible = false;
          this.$refs.table.clearSelection();
          this.setQualifiedNumber();
        });
      },
      validate() {},
      getValue() {
        let unqualifiedProducts = { id: this.id };
        let isNodisposeType = false;
        if (this.poList.length > 0) {
          unqualifiedProducts.poList = this.poList.map((item) => {
            if (!item.disposeType && this.businessType.includes('不良品处置')) {
              isNodisposeType = true;
            }
            item.qualityResults = 1;
            item.qualityStatus = 1;
            item.qualityWorkOrderId = this.qualityWorkerId;
            return item;
          });
          [
            'batchNo',
            'brandNum',
            'categoryCode',
            'categoryId',
            'categoryName',
            'factoriesId',
            'measureUnit',
            'modelType',
            'produceRoutingId',
            'produceRoutingName',
            'productCategory'
          ].forEach((item) => {
            unqualifiedProducts[item] = this.poList[0][item];
          });

          unqualifiedProducts.qualityType = this.qualityType;
          unqualifiedProducts.qualityWorkOrderId = this.qualityWorkerId;
          unqualifiedProducts.sourceCode = this.workOrderCode;
          unqualifiedProducts.quantity = this.poList.reduce(
            (total, item) => total + item.measureQuantity,
            0
          );
          unqualifiedProducts.sourceType = this.workOrderId ? 1 : 0;

          return isNodisposeType ? 'isNodisposeType' : unqualifiedProducts;
        }
        return null;
      },
      chooseWarehouse(item) {
        // console.log(item);
        this.disposeForm.depotId = item.id;
        this.disposeForm.depotName = item.name;
      }
    },
    watch: {
      'disposeForm.disposeType': {
        handler(newVal, oldVal) {
          if (newVal == 6) {
            this.rules.depotId = [];
          } else {
            this.rules.depotId = [
              { required: true, message: '请选择仓库', trigger: 'change' }
            ];
          }
          this.disposeForm.sampleCondition = '';
          this.disposeForm.sampleDate = '';
          this.disposeForm.samplePlace = '';
          this.disposeForm.sampleRemark = '';
          this.disposeForm.producerManufacturer = '';
          this.disposeForm.depotId = '';
          this.disposeForm.depotName = '';
          this.disposeForm.taskId = '';
        }
      }
    }
  };
</script>

<style lang="scss" scoped>
  .unacceptedProductSelect {
    display: flex;
    flex-direction: column;
    align-items: center;
  }
</style>