kd-aiot-frontend-eom/src/BIZComponents/selectStockLedger/selectStockLedgerDialog.vue

<template>
  <ele-modal
    title="库存台账"
    :visible.sync="visible"
    v-if="visible"
    :close-on-click-modal="false"
    :before-close="handleClose"
    :close-on-press-escape="false"
    destroy-on-close
    top="5vh"
    append-to-body
    width="70%"
    :maxable="true"
  >
    <el-card shadow="never">
      <item-search @search="reload" ref="refSeavch"></item-search>
      <ele-split-layout
        width="244px"
        allow-collapse
        :right-style="{ overflow: 'hidden' }"
      >
        <div class="ele-border-lighter split-layout-right-content">
          <el-tree
            :data="treeList"
            :props="defaultProps"
            ref="treeRef"
            :default-expanded-keys="
              curNodeData && curNodeData.id ? [curNodeData.id] : []
            "
            :highlight-current="true"
            node-key="id"
            :expand-on-click-node="false"
            @node-click="handleNodeClick"
            ><span class="custom-tree-node" slot-scope="{ node, data }">
              <span
                >{{ data.factoryName ? data.factoryName + '-' : ''
                }}{{ data.name }}</span
              >
            </span></el-tree
          >
        </div>
        <!-- 表格 -->
        <template v-slot:content>
          <ele-pro-table
            ref="table"
            :columns="columns"
            :datasource="datasource"
            row-key="id"
            height="calc(100vh - 480px)"
            class="dict-table"
            @cell-click="cellClick"
            :selection.sync="selection"
            :cache-key="cacheKeyUrl"
            :page-size="20"
            @columns-change="handleColumnChange"
            @header-dragend="handleHeaderDragend"
          >
            <template v-slot:saleCount="{ row }">
              <el-input
                v-model="row.saleCount"
                style="width: 100%"
                placeholder="请输入"
                type="number"
                :min="0"
                @input="handleSaleCountInput(row)"
              ></el-input>
            </template>
            <template v-slot:action="{ row }">
              <el-radio class="radio" v-model="radio" :label="row.id"
                ><i></i
              ></el-radio>
            </template>
          </ele-pro-table>
        </template>
      </ele-split-layout>
    </el-card>

    <div slot="footer">
      <el-button v-if="!isView" type="primary" size="small" @click="selected"
        >选择</el-button
      >
      <el-button size="small" @click="handleClose">关闭</el-button>
    </div>
  </ele-modal>
</template>

<script>
  import {
    getOutindetailtwoList,
    getTreeByGroup,
    getBatchList,
    getCategoryPackageDisposition
  } from '@/api/wms';
  import ItemSearch from './item-search.vue';
  import { contactQueryByCategoryIdsAPI } from '@/api/saleManage/contact';
  import tabMixins from '@/mixins/tableColumnsMixin';

  export default {
    mixins: [tabMixins],
    components: { ItemSearch },
    props: {
      /*已选择的产品*/
      data: {
        type: Array,
        default: () => []
      },
      /*是否需要供应商*/
      isSupplier: {
        type: Boolean,
        default: false
      },
      /*是否显示销售数量*/
      showSaleCount: {
        type: Boolean,
        default: false
      },
      // 是否按库存余额和锁库数量展示可用数量
      showStockCount: {
        type: Boolean,
        default: false
      },
      cacheKeyUrl: {
        type: String,
        default: 'eom-sales-selectStockLedgerDialog-202605131603'
      },
      isView: {
        type: Boolean,
        default: false
      }
    },

    data() {
      return {
        visible: false,
        currentIndex: null,
        radio: null,
        dictList: {},
        curNodeData: {},
        selection: [],
        treeData: [],
        dimension: '2',
        defaultProps: {
          children: 'children',
          label: 'name'
        },
        treeList: [],
        treeLoading: false,
        // cacheKeyUrl: '',
        columnsVersion: 1,
        tabMixinsInit: false
      };
    },
    watch: {},
    computed: {
      columns() {
        const version = this.columnsVersion;
        let data = null;
        if (this.currentIndex != -1) {
          data = {
            action: 'action',
            slot: 'action',
            align: 'center',
            label: '选择',
            reserveSelection: true
          };
        }
        if (this.currentIndex == -1) {
          data = {
            label: '选择',
            width: 45,
            type: 'selection',
            columnKey: 'selection',
            align: 'center',
            reserveSelection: true,
            selectable: (row) => {
              if (this.showStockCount) {
                return this.getAvailableStockCount(row) != 0;
              }
              const measureQuantity = parseFloat(row.measureQuantity) || 0;
              const lockQuantity = parseFloat(row.lockQuantity) || 0;
              const available = measureQuantity - lockQuantity;
              return available != 0;
            }
          };
        }

        const tempData = [
          data,

          {
            columnKey: 'index',
            type: 'index',
            width: 50,
            align: 'center',
            showOverflowTooltip: true,
            label: '序号'
          },
          {
            prop: 'categoryCode',
            label: '编码',
            align: 'center',
            showOverflowTooltip: true,
            minWidth: 110
          },
          {
            prop: 'categoryName',
            label: '名称',
            align: 'center',
            showOverflowTooltip: true,
            minWidth: 110
          },
          {
            prop: 'saleCount',
            slot: 'saleCount',
            label: '订单数量',
            showOverflowTooltip: true,
            align: 'center',
            minWidth: 120,
            hide: !this.showSaleCount
          },
          {
            prop: 'brandNum',
            align: 'center',
            label: '牌号',
            showOverflowTooltip: true
          },
          this.dimension == '2'
            ? {
                prop: 'batchNo',
                label: '批次号',
                align: 'center',
                showOverflowTooltip: true
              }
            : {
                width: 1
              },
          this.dimension == '2'
            ? {
                prop: 'systemBatchNo',
                label: '系统内部批次号',
                align: 'center',
                minWidth: 180,
                showOverflowTooltip: true,
                formatter: (row) => row.systemBatchNo || '-'
              }
            : {
                width: 1
              },
          {
            prop: 'categoryModel',
            label: '型号',
            align: 'center',
            showOverflowTooltip: true
          },
          {
            prop: 'specification',
            label: '规格',
            align: 'center',
            showOverflowTooltip: true
          },
          {
            prop: 'colorKey',
            label: '颜色',
            align: 'center',
            showOverflowTooltip: true
          },
          {
            prop: 'modelKey',
            label: '机型',
            align: 'center',
            showOverflowTooltip: true
          },
          {
            prop: 'warehouseName',
            label: '仓库',
            showOverflowTooltip: true,
            align: 'center',
            minWidth: 90
          },
          {
            prop: 'inventoryCycle',
            label: '存货周期(天)',
            align: 'center',
            width: 150,
            sortable: true,
            showOverflowTooltip: true,
            hide: this.dimension == 1
          },
          {
            prop: 'measureQuantity',
            label: '库存',
            showOverflowTooltip: true,
            align: 'center',
            minWidth: 90,
            formatter: (row) =>
              this.showStockCount
                ? this.getStockCount(row)
                : row.measureQuantity
          },
          {
            prop: 'lockQuantity',
            label: '锁库数量',
            showOverflowTooltip: true,
            align: 'center',
            minWidth: 90
          },
          {
            prop: 'useQuantity',
            label: '可用数量',
            showOverflowTooltip: true,
            align: 'center',
            minWidth: 90,
            formatter: (row) => {
              if (this.showStockCount) {
                return this.getAvailableStockCount(row);
              }
              // 使用toFixed处理浮点数精度问题，保留4位小数
              const measureQuantity = parseFloat(row.measureQuantity) || 0;
              const lockQuantity = parseFloat(row.lockQuantity) || 0;
              const available = measureQuantity - lockQuantity;
              // 使用toFixed避免精度丢失，然后去除末尾多余的0
              return available.toFixed(4).replace(/\.?0+$/, '');
            }
          },
          {
            prop: 'measureUnit',
            label: '单位',
            showOverflowTooltip: true,
            align: 'center',
            minWidth: 90
          },
          {
            prop: 'weight',
            label: '重量',
            showOverflowTooltip: true,
            align: 'center',
            minWidth: 90
          },
          {
            prop: 'weightUnit',
            label: '重量单位',
            showOverflowTooltip: true,
            align: 'center',
            minWidth: 90
          },
          {
            prop: 'packingUnit',
            align: 'center',
            label: '包装单位',
            showOverflowTooltip: true
          },
          {
            prop: 'reelSpecification',
            label: '盘具',
            showOverflowTooltip: true,
            align: 'center'
          }
        ];
        return this.applyColumnWidth(tempData.filter((item) => !item.hide));
      }
    },
    methods: {
      getDictV(code, val) {
        if (!this.dictList[code]) return '';
        return this.dictList[code].find((item) => item.value == val)?.label;
      },
      open(item, currentIndex) {
        console.log(item, currentIndex);
        this.currentIndex = currentIndex;
        this.visible = true;
        this.getTreeData();
      },
      async getTreeData() {
        try {
          this.treeLoading = true;
          let res = null;
          res = await getTreeByGroup({ type: 2 });
          this.treeLoading = false;
          if (res?.code === '0') {
            this.treeList = res.data;
            return this.treeList;
          }
        } catch (error) {
          console.log(error);
        }
        this.treeLoading = false;
      },

      /* 表格数据源 */
      async datasource({ page, limit, where, order }) {
        this.dimension = where.dimension || '2';
        let api = where.dimension == '1' ? getOutindetailtwoList : getBatchList;

        const data = await api({
          ...where,
          ...order,
          pageNum: page,
          size: limit
        });
        this.getTabColumns();
        return data;
      },

      /* 刷新表格 */
      reload(where) {
        this.$refs.table.reload({ pageNum: 1, where: where });
      },

      handleNodeClick(data, node) {
        this.curNodeData = data;
        if (data.id == this.currentId) {
          this.$refs.treeRef.setCurrentKey(null);
          this.reload();
        } else {
          this.reload({ categoryLevelId: data.id });
        }
      },
      async getSupplierObj(productList, queryName) {
        try {
          let categoryIds = productList
            .filter((item) => item.id)
            .map((item) => item.id);
          if (categoryIds.length > 0) {
            return await contactQueryByCategoryIdsAPI({
              categoryIds,
              isQueryEE: 1
            });
          } else {
            return Promise.resolve({});
          }
        } catch (e) {
          return Promise.resolve({});
        }
      },
      // 单击获取id
      cellClick(row) {
        if (this.currentIndex == -1) return;
        this.current = row;
        this.radio = row.id;
      },
      // 新接口返回 stockCountBase，旧接口使用 measureQuantity 表示当前库存
      getStockCount(row) {
        if (row.stockCountBase !== undefined && row.stockCountBase !== null) {
          return Number(row.stockCountBase);
        }
        return Number(row.measureQuantity || 0);
      },
      getAvailableStockCount(row) {
        const available =
          this.getStockCount(row) - Number(row.lockQuantity || 0);
        return Number(available.toFixed(4));
      },
      // 限制订单数量不超过当前可用数量
      handleSaleCountInput(row) {
        const available = this.showStockCount
          ? this.getAvailableStockCount(row)
          : (parseFloat(row.measureQuantity) || 0) -
            (parseFloat(row.lockQuantity) || 0);
        const val = parseFloat(row.saleCount);
        if (!isNaN(val) && val > available) {
          this.$message.warning(`订单数量不能超过可用数量（${available}）`);
          this.$set(row, 'saleCount', available);
        }
      },
      handleClose() {
        this.visible = false;
        this.current = null;
        this.selection = [];
        this.$refs.table.clearSelection();
        this.radio = '';
      },

      isSameStockRecord(source, target) {
        if (source.batchStockId && target.id) {
          return source.batchStockId == target.id;
        }
        const sourceProductId = source.productId || source.categoryId;
        const targetProductId = target.categoryId || target.productId;
        const sourceProductCode =
          source.productCode || source.categoryCode || source.code;
        const targetProductCode =
          target.categoryCode || target.productCode || target.code;
        const sameProduct =
          sourceProductId && targetProductId
            ? sourceProductId == targetProductId
            : sourceProductCode == targetProductCode;
        const sameWarehouse =
          !source.warehouseId ||
          !target.warehouseId ||
          source.warehouseId == target.warehouseId;
        return (
          sameProduct &&
          sameWarehouse &&
          source.batchNo == target.batchNo &&
          (source.systemBatchNo || '') == (target.systemBatchNo || '')
        );
      },

      async selected() {
        if (!this.current && !this.selection.length) {
          return this.$message.warning('请至少选择一条数据');
        }
        if (this.currentIndex != -1) {
          if (
            this.data.some((item) => this.isSameStockRecord(item, this.current))
          ) {
            return this.$message.error('选择的库存记录已经存在列表了');
          }
        } else {
          if (
            this.selection.some((item) =>
              this.data.some((source) => this.isSameStockRecord(source, item))
            )
          ) {
            return this.$message.error('选择的库存记录已经存在列表了');
          }
        }
        let list = this.currentIndex == -1 ? this.selection : [this.current];
        //获取供应商
        if (this.isSupplier) {
          let supplierList = await this.getSupplierObj(list);
          list.forEach((item) => {
            item['entrustedEnterpriseIdList'] = supplierList[item.id];
            if (supplierList[item.id]?.length === 1) {
              item['entrustedEnterpriseId'] = supplierList[item.id][0].id;
            }
          });
        }
        let idList = list.map((item) => item.categoryId);

        // 获取包装规格
        let packingSpecification = await getCategoryPackageDisposition({
          categoryIds: idList
        });

        list.forEach((item, index) => {
          item.productName = item.categoryName;
          item.productCode = item.categoryCode;
          item.productCategoryName = '';
          item.productBrand = item.brandNum;
          item.provenance = item.provenance || [];
          if (this.showSaleCount) {
            item.saleCount = item.saleCount;
          }
          item['packageDispositionList'] = packingSpecification
            .filter(
              (ite) => item.categoryId == ite.categoryId && ite.conversionUnit
            )
            .sort((a, b) => a.sort - b.sort);
          this.$set(list[index], 'totalCount', 1);
          // item.totalCount = 1;
          item.measuringUnit = item.measureUnit;
          //item.weightUnit = item.weightUnit;
          // item.warehouseNum = item.measureQuantity;
          item.productId = item.categoryId;
          item.batchStockId = item.id;
          item.id = '';
          item.batchNo = this.dimension != 1 ? item.batchNo : '';
          item.systemBatchNo =
            this.dimension != 1 ? item.systemBatchNo || '' : '';

          // item.specification = item.specification;
        });
        this.$emit('changeParent', list, this.currentIndex);
        this.handleClose();
      }
    }
  };
</script>

<style lang="scss" scoped>
  .tree_col {
    border: 1px solid #eee;
    padding: 10px 0;
    box-sizing: border-box;
    height: 500px;
    overflow: auto;
  }

  .table_col {
    padding-left: 10px;

    ::v-deep .el-table th.el-table__cell {
      background: #f2f2f2;
    }
  }

  .pagination {
    text-align: right;
    padding: 10px 0;
  }

  .btns {
    text-align: center;
    padding: 10px 0;
  }

  .topsearch {
    margin-bottom: 15px;
  }
</style>