kd-aiot-frontend-mes/src/views/produceOrder/components/releaseDialog/index.vue

<template>
  <ele-modal
    :before-close="cancel"
    :close-on-click-modal="false"
    :maxable="true"
    title="任务派单"
    :visible.sync="dispatchVisible"
    :width="modelWidth"
    append-to-body
    custom-class="ele-dialog-form"
  >
    <div class="form-wrapper">
      <el-form
        ref="form"
        :inline="true"
        :model="form"
        label-position="right"
        label-width="100px"
      >
        <el-row :gutter="10" class="basic" style="flex-wrap: wrap" type="flex">
          <el-col
            v-for="item in fieldList"
            :key="item.prop"
            :lg="8"
            :md="12"
            :sm="12"
            :xl="6"
            :xs="12"
          >
            <el-form-item :label="item.label">
              <!-- <div class="item_label">{{ current[item.prop] }}</div> -->
              <el-input v-model="current[item.prop]" disabled />
            </el-form-item>
          </el-col>
        </el-row>
        <el-row :gutter="10">
          <el-col :lg="8" :md="12" :sm="12" :xl="6" :xs="12">
            <el-form-item label="所属工厂:">
              <el-input v-model="form.factoryName" :disabled="true"></el-input>
            </el-form-item>
          </el-col>
          <el-col :lg="8" :md="12" :sm="12" :xl="6" :xs="12">
            <el-form-item label="所属工作中心:">
              <el-select
                v-model="form.workCenterId"
                placeholder="请选择"
                style="width: 100%"
                @change="changeWork"
              >
                <el-option
                  v-for="item in workCenterList"
                  :key="item.id"
                  :label="item.name"
                  :value="item.id"
                >
                </el-option>
              </el-select>
            </el-form-item>
          </el-col>
          <el-col :lg="8" :md="12" :sm="12" :xl="6" :xs="12">
            <el-form-item label="所属班组:" required>
              <el-select
                v-model="form.teamId"
                placeholder="请选择"
                style="width: 100%"
                @change="changeGroups"
              >
                <el-option
                  v-for="item in teamList"
                  :key="item.id"
                  :label="item.name"
                  :value="item.id"
                >
                </el-option>
              </el-select>
            </el-form-item>
          </el-col>
        </el-row>
        <!--        <el-row>-->
        <!--          <el-form-item label="报工类型:" required>-->
        <!--            <el-radio-group v-model="form.singleReport">-->
        <!--              &lt;!&ndash; v-if="clientEnvironmentId != 2" &ndash;&gt;-->
        <!--              <el-radio :label="1">单件报工</el-radio>-->
        <!--              <el-radio :label="0">批量报工</el-radio>-->
        <!--            </el-radio-group>-->
        <!--          </el-form-item>-->
        <!--        </el-row>-->
        <!--        <el-row>-->
        <!--          <el-form-item label="派单方式:" prop="taskAss">-->
        <!--            <el-radio-group v-model="form.taskAss">-->
        <!--              <el-radio :label="1">生产订单派单</el-radio>-->
        <!--              <el-radio :disabled="procTaskDis" :label="0"-->
        <!--              >工序任务派单-->
        <!--              </el-radio-->
        <!--              >-->
        <!--            </el-radio-group>-->
        <!--          </el-form-item>-->
        <!--        </el-row>-->
        <!--        <el-row v-if="form.taskAss == 1">-->
        <!--          <el-col :span="24">-->
        <!--            <el-form-item label="指派:" prop="assignType">-->
        <!--              <el-radio-group-->
        <!--                v-model="form.assignType"-->
        <!--                size="mini"-->
        <!--                @change="assignRadio"-->
        <!--              >-->
        <!--                <el-radio-button :label="1">工位</el-radio-button>-->
        <!--                <el-radio-button :label="2">人员</el-radio-button>-->
        <!--                &lt;!&ndash; <el-radio-button :label="3">产线</el-radio-button> &ndash;&gt;-->
        <!--              </el-radio-group>-->
        <!--            </el-form-item>-->
        <!--          </el-col>-->
        <!--          <el-form-item v-if="form.assignType == 1" label="工位:" required>-->
        <!--            <el-select-->
        <!--              v-model="form.workstationIds"-->
        <!--              class="ele-block"-->
        <!--              filterable-->
        <!--              multiple-->
        <!--              placeholder="请选择工位"-->
        <!--              size="mini"-->
        <!--            >-->
        <!--              <el-option-->
        <!--                v-for="item in stationList"-->
        <!--                :key="item.id"-->
        <!--                :label="item.name + '（' + item.code + '）'"-->
        <!--                :value="item.id"-->
        <!--              >-->
        <!--              </el-option>-->
        <!--            </el-select>-->
        <!--          </el-form-item>-->

        <!--          <el-form-item-->
        <!--            v-if="form.assignType == 2"-->
        <!--            label="人员:"-->
        <!--            prop="crewIds"-->
        <!--          >-->
        <!--            <el-select-->
        <!--              v-model="form.crewIds"-->
        <!--              class="ele-block"-->
        <!--              filterable-->
        <!--              multiple-->
        <!--              placeholder="请选择人员"-->
        <!--              size="mini"-->
        <!--            >-->
        <!--              <el-option-->
        <!--                v-for="item in crewList"-->
        <!--                :key="item.id"-->
        <!--                :label="item.name"-->
        <!--                :value="item.id"-->
        <!--              >-->
        <!--              </el-option>-->
        <!--            </el-select>-->
        <!--          </el-form-item>-->
        <!--        </el-row>-->
        <!-- v-show="form.taskAss == 0" -->
        <el-tabs
          v-model="processId"
          v-loading="tabsLoading"
          class="process_list"
          style="margin-bottom: 20px"
          type="border-card"
          @tab-click="handleClick"
        >
          <el-tab-pane
            v-for="(item, index) in processList"
            :key="item.id"
            :label="item.name"
            :name="item.id"
          >
            <ele-pro-table
              ref="tableRef"
              v-loading="tabLoading"
              :columns="columns"
              :datasource="item.list"
              :pageSize="20"
              :selection.sync="item.selection"
              cache-key="systemRoleTable"
              class="table"
            >
              <template v-slot:toolbar>
                <div style="display: inline-block" v-if="!item.isSpecialField">
                  <el-button
                    :loading="toolbarLoading"
                    type="primary"
                    @click="dispatch(item, 1)"
                  >
                    派单
                  </el-button>
                  <el-button
                    :loading="toolbarLoading"
                    type="primary"
                    @click="dispatch(item, 2)"
                  >
                    撤回
                  </el-button>
                  <el-button
                    :loading="toolbarLoading"
                    type="primary"
                    @click="dispatch(item, 3)"
                  >
                    保存
                  </el-button>
                </div>
                <div
                  style="margin-left: 50px; display: inline-block"
                  v-if="!item.isSpecialField"
                >
                  <span
                    class="text"
                    style="
                      font-weight: bold;
                      font-size: 14px;
                      margin-right: 8px;
                    "
                    >指派:</span
                  >
                  <el-radio-group
                    v-model="item.assignType"
                    size="mini"
                    @change="(e) => changeRadio(e, index)"
                  >
                    <el-radio-button
                      :disabled="radioBun(item, 'stationDis')"
                      :label="1"
                      >工位
                    </el-radio-button>
                    <el-radio-button
                      :disabled="radioBun(item, 'staffDis')"
                      :label="2"
                      >人员
                    </el-radio-button>
                    <el-radio-button
                      :disabled="radioBun(item, 'lineDis')"
                      :label="3"
                      >产线
                    </el-radio-button>
                  </el-radio-group>
                </div>
                <div
                  v-if="item.isSpecialField"
                  class="describe"
                  style="color: #67c23a"
                >
                  该工序已完成派单!
                </div>

                <div
                  style="margin-left: 50px; display: inline-block"
                  v-if="timeSlot(item)"
                >
                  时间段: {{ item.startDate }} ----- {{ item.endDate }}
                </div>
              </template>
              <template v-slot:quantity="{ row }">
                <el-input
                  v-model="row.quantity"
                  :disabled="permissions(row, item)"
                  placeholder="请输入数量"
                  type="number"
                  @input="(e) => handleQuantityInput(e, row, item)"
                ></el-input>
              </template>
              <template v-slot:weight="{ row }">
                <el-input
                  v-model="row.weight"
                  :disabled="permissions(row, item)"
                  placeholder="请输入重量"
                  type="number"
                  @input="(e) => handleWeightInput(e, row, item)"
                ></el-input>
              </template>
              <template v-slot:teamTimeDetailId="{ row }">
                <el-select
                  v-model="row.teamTimeDetailId"
                  placeholder="班次"
                  :disabled="permissions(row, item)"
                  @change="(e) => shiftSelection(e, row, item)"
                >
                  <el-option
                    v-for="item in shiftList"
                    :key="item.id"
                    :label="item.name"
                    :value="item.id"
                  >
                  </el-option>
                </el-select>
              </template>
              <template v-slot:startTime="{ row }">
                <el-date-picker
                  v-model="row.startTime"
                  :disabled="permissions(row, item)"
                  @change="handleStartTimeChange(row, item)"
                  class="w100"
                  placeholder="开始时间"
                  type="datetime"
                  value-format="yyyy-MM-dd HH:mm:ss"
                ></el-date-picker>
              </template>
              <template v-slot:endTime="{ row }">
                <el-date-picker
                  v-model="row.endTime"
                  :disabled="permissions(row, item)"
                  class="w100"
                  placeholder="完成时间"
                  type="datetime"
                  value-format="yyyy-MM-dd HH:mm:ss"
                ></el-date-picker>
              </template>

              <template v-slot:action="{ row }">
                <!--  :disabled="resetBtnDis(row)" -->
                <el-popconfirm
                  v-if="resetBtnDis(row)"
                  title="确定要重置该条数据吗？"
                  @confirm="resetData(row, item)"
                >
                  <template v-slot:reference>
                    <el-link :underline="false" type="primary"> 重置</el-link>
                  </template>
                </el-popconfirm>
              </template>
            </ele-pro-table>
          </el-tab-pane>
        </el-tabs>
      </el-form>
    </div>

    <!--    <div slot="footer">-->
    <!--      <el-button plain @click="cancel">取消</el-button>-->
    <!--      <el-button :loading="toolbarLoading" type="primary" @click="confirm"-->
    <!--      >确定-->
    <!--      </el-button-->
    <!--      >-->
    <!--    </div>-->
  </ele-modal>
</template>

<script>
  import validDate from '@/utils/date';
  import {
    lineByCurrentUser,
    listAssign,
    listByFirstTaskId,
    listByMesWorkOrder,
    listByRoutingIds,
    listUserByIds,
    listWorkCenter,
    resetAssignee,
    taskAssignment,
    taskRevoked,
    taskSave,
    listByFactoryId
  } from '@/api/mainData/index.js';

  export default {
    components: {},
    props: {
      current: {
        type: Object,
        default: () => {}
      },
      dispatchVisible: {
        type: Boolean,
        default: false
      }
    },
    data() {
      return {
        processId: '',
        tabLoading: false,
        dynamicName: '工位名称',
        form: {
          assignType: 1,
          crewIds: '',
          workstationIds: '',
          teamId: '',
          singleReport: '',
          workCenterId: '',
          taskAss: 1,
          factoryName: ''
        },
        toolbarLoading: false,
        processList: [],
        workCenterList: [],
        teamList: [],
        tabsLoading: false,
        stationList: [], // 工位的数据
        productionList: [], // 产线的数据
        crewList: [], // 人员的数据
        // procTaskDis: false, // 工序任务派单选择
        // firstTaskindex: '', // 首工序id 对应的工序列表数据下标
        fieldList: [
          { label: '生产订单号:', prop: 'code' },
          { label: '计划编号:', prop: 'productionPlanCode' },
          { label: '工艺路线:', prop: 'produceRoutingName' },
          // { label: '编码', prop: 'productCode' },
          { label: '名称:', prop: 'productName' },
          { label: '生产编号:', prop: 'productionCodes' },
          { label: '牌号:', prop: 'brandNo' },
          { label: '批次号:', prop: 'batchNo' },
          { label: '型号:', prop: 'model' },
          { label: '要求生产数量:', prop: 'formingNum' },
          { label: '要求生产重量:', prop: 'initialWeight' },
          { label: '计划开始时间:', prop: 'planStartTime' },
          { label: '计划结束时间:', prop: 'planCompleteTime' }
        ],
        shiftList: [],
        dateValue: '',
        factoriesId: '', // 工厂id
        dispatchType: 1,
        time_calc_code: '0', // 是否进行时间赋值 0 否 1 是
        validDate
      };
    },
    computed: {
      clientEnvironmentId() {
        return this.$store.state.user.info.clientEnvironmentId;
      },
      userInfo() {
        return this.$store.state.user.info;
      },
      modelWidth() {
        // if(this.form.taskAss == 1){
        //   return '1000px'
        // }
        return '75vw';
      },
      // 重置按钮 的置灰权限 没有进行操作跟派单的数据 置灰
      resetBtnDis() {
        return (row) => {
          if (!row.status) return false;
          let flag = row.status.code != 1;
          return flag;
        };
      },
      // 指派单选框操作 已派单的 其它两个按钮不能操作
      radioBun() {
        return (row, type) => {
          if (!row.radioBun) return false;
          let flag = row.radioBun[type];
          return flag;
        };
      },
      // 列表输入框操作 已派单的不能操作
      permissions() {
        return (row, item) => {
          if (item.isSpecialField) return true;
          if (!row.status) return false;
          if (row.status.code == 1) return true;
        };
      },
      // 时间段显示
      timeSlot() {
        return (item) => {
          if (!item.startDate || !item.endDate) {
            return false;
          }
          return true;
        };
      },
      columns() {
        return [
          {
            columnKey: 'index',
            label: '序号',
            type: 'index',
            width: 55,
            align: 'center',
            showOverflowTooltip: true,
            fixed: 'left'
          },
          {
            width: 45,
            type: 'selection',
            columnKey: 'selection',
            align: 'center',
            fixed: 'left'
          },
          {
            prop: 'name',
            label: this.dynamicName,
            align: 'center',
            showOverflowTooltip: true,
            width: 200
          },
          {
            prop: 'code',
            label: '编码',
            align: 'center',
            showOverflowTooltip: true,
            width: 200
          },
          {
            prop: 'status',
            label: '状态',
            align: 'center',
            showOverflowTooltip: true,
            width: 150,
            formatter: (row) => {
              if (!row.status) return '';
              return row.status.desc || '';
            }
          },
          {
            slot: 'quantity',
            prop: 'quantity',
            label: '数量',
            align: 'center',
            width: 140
          },
          {
            slot: 'weight',
            prop: 'weight',
            label: `重量(${this.current.weightUnit})`,
            align: 'center',
            width: 140
          },
          {
            slot: 'teamTimeDetailId',
            prop: 'teamTimeDetailId',
            label: '班次',
            align: 'center',
            minWidth: 140
          },
          {
            slot: 'startTime',
            prop: 'startTime',
            label: '计划开始时间',
            align: 'center',
            minWidth: 240
          },
          {
            slot: 'endTime',
            prop: 'endTime',
            label: '计划完成时间',
            align: 'center',
            minWidth: 240
          },
          {
            columnKey: 'action',
            label: '操作',
            width: 120,
            align: 'center',
            resizable: false,
            fixed: 'right',
            slot: 'action'
          }
        ];
      }
    },
    watch: {},
    created() {
      this.dispatchType = this.current.singleReport || 0;
      this.workCenterData();
      this.form.singleReport = this.clientEnvironmentId == 2 ? 0 : 1;
      this.dateValue = this.getFormattedDate();
    },
    methods: {
      getCode() {
        parameterGetByCode({
          code: 'time_calculation_rules'
        }).then((res) => {
          if (res) {
            this.time_calc_code = res.value || '0';
          }
        });
      },
      // 查询班次
      getClassesData() {
        if (!this.factoriesId) return;
        listByFactoryId(this.factoriesId).then((res) => {
          console.log(res, 'res ++++');
          if (!res) return;
          this.shiftList = res;
        });
      },
      // 获取当前年月日
      getFormattedDate() {
        const now = new Date();
        const year = now.getFullYear();
        const month = String(now.getMonth() + 1).padStart(2, '0');
        const date = String(now.getDate()).padStart(2, '0');
        return `${year}-${month}-${date}`;
      },
      // 查询工作中心
      async workCenterData() {
        const res = await listWorkCenter(this.current.taskInstanceId);
        this.workCenterList = res;
        if (res.length > 0) {
          console.log(res, '工作中心');
          this.form.factoryName = res[0].factoryName;
          this.form.workCenterId = res[0].id;
          this.factoriesId = res[0].factoryId;
          console.log(res, 'res 工作中心数据');
          // 查首工序
          this.changeWork(res[0].id); // 选择工作中心
          this.getProductionData(res[0].id); // 查询产线
          this.FirstTaskIdFn(); // 查询工位数据
          this.getClassesData();
        }
      },
      // 查询工序列表数据
      async changeDispatch(e) {
        this.tabsLoading = true;
        try {
          // /aps/assign/listByMesWorkOrder
          let allRes = await listByRoutingIds([this.current.produceRoutingId]); // 查询全部工序数据
          let params = {
            apsWorkOrderId: this.current.apsWorkOrderId,
            categoryId: this.current.categoryId,
            mesWorkOrderId: this.current.id,
            produceRoutingId: this.current.produceRoutingId
          };
          let existRes = await listByMesWorkOrder(params); // 存在的工序数据
          console.log(existRes, 'existRes ++++++');
          let res = [];
          if (!existRes || existRes.length === 0) {
            res = allRes;
          } else {
            // 先将 存在的工序数据 数组的 id 存入 Set
            const existIds = new Map(
              existRes.map((item) => [
                item.assignees.length ? item.taskId : null,
                true
              ])
            );
            // 过滤 全部工序数据 数组
            // res = allRes.map((aItem) => !existIds.has(aItem.sourceTaskId));
            res = allRes.map((aItem) => {
              return {
                ...aItem,
                isSpecialField: existIds.has(aItem.sourceTaskId)
              };
            });
          }
          // 如果没有首工序的数据 就不能选择工序任务派单
          if (!res || res.length === 0) {
            this.processList = [];
            // this.form.taskAss = 1;
            // this.procTaskDis = true;
            this.$message.warning('当前工单没有工序数据');
            return;
          }
          // this.procTaskDis = false;
          let list = [];
          res.forEach((item, index) => {
            let obj = {
              id: item.sourceTaskId, //工序 id
              name: item.name, //工序 名称
              assignType: 1, // 默认的指派数据
              assignName: '工位', // 默认指派数据名称
              list: [], // 当前工序下面的指派 绑定的表格
              selection: [], // 当前工序下面的指派 选中的数据
              code: item.code, // 工序 编码
              index: index, // 当前工序数据的下标
              isSpecialField: item.isSpecialField,
              radioBun: {
                // 指派按钮的操作状态 绑定 默认false(可操作)
                stationDis: false, // 工位按钮
                staffDis: false, // 人员按钮
                lineDis: false // 产线按钮
              },
              startDate: '', // 开始日期 (当前工序中最早的计划开始时间)
              endDate: '' // 结束日期 (当前工序中最晚的计划结束时间)
            };
            list.push(obj);
          });
          this.processList = list;
          this.processId = res[0].sourceTaskId;
          // this.handleClick({ name: res[0].sourceTaskId });
          this.initializeQuery();
        } catch (err) {
          this.processList = [];
          this.$message.error(err.message);
        } finally {
          this.tabsLoading = false;
        }
      },

      // 初始化查询 查询全部工序操作过的数据
      async initializeQuery() {
        try {
          // 不存在 班组数据的话 就不调用这个方法
          if (!this.form.teamId) {
            return;
          }
          let params = {
            workOrderId: this.current.id,
            workCenterId: this.form.workCenterId,
            teamId: this.form.teamId
          };
          let processMap = {};
          this.processList.map((el, index) => (processMap[el.id] = index));
          const res = await listAssign(params);
          let isFirstData = false; // 判断默认第一道工序是否操作过
          if (res && res.length > 0) {
            res.map((el) => {
              let index = processMap[el.taskId];
              if (index === 0 && el.assignees && el.assignees.length > 0) {
                isFirstData = true; // 操作过
              }
              // 这里第三个参数传空数组就好了 会自动计算的
              setTimeout(() => {
                this.operationalData(index, [el], []);
              });
            });
            // 没有操作过 默认获取一下表格数据
            if (!isFirstData) {
              this.handleClick({ name: this.processId });
            }
          } else {
            this.handleClick({ name: this.processId });
          }
        } catch (err) {}
      },

      // 选择工作中心
      async changeWork(e) {
        this.form.workCenterId = e;
        // this.changeDispatch(); // 查询工序列表
        let data = this.workCenterList.find((item) => item.id == e);
        this.form.workCenterName = data.name;
        this.teamList = data.teamList || [];
        if (this.teamList.length > 0) {
          this.form.teamId = this.teamList[0].id;
          await this.changeGroups(this.teamList[0].id);
        } else {
          // 如果没有 班组数据 将人员数据清空 并且判断
          this.crewList = [];
          this.form.teamId = '';
          let data = this.processList.find((item) => item.id == this.processId);
          if (data.assignType == 2) {
            this.$set(data, 'list', []);
          }
        }
      },
      // 选择班组 查询人员的数据
      async changeGroups(e) {
        let data = this.teamList.find((item) => item.id == e);
        this.form.teamName = data.name;
        try {
          const res = await listUserByIds([e]);
          this.crewList = res || [];
          if (!this.processId || this.processId == 0) {
            return;
          }
          this.handleClick({ name: this.processId });
          this.btnInit();
        } catch {
          this.crewList = [];
        }
      },
      // 工序按钮初始化
      btnInit() {
        let data = this.processList.find((item) => item.id == this.processId);
        this.$set(data.radioBun, 'lineDis', false);
        this.$set(data.radioBun, 'staffDis', false);
        this.$set(data.radioBun, 'stationDis', false);
        this.$set(data, 'assignName', '工位');
        this.$set(data, 'assignType', 1);
      },
      // 获取产线数据
      async getProductionData() {
        const res = await lineByCurrentUser(this.form.workCenterId);
        this.productionList = res || [];
      },
      // 查询工位数据
      FirstTaskIdFn() {
        listByFirstTaskId(this.current.taskInstanceId)
          .then((res) => {
            this.stationList = res;
            this.changeDispatch();
          })
          .catch((err) => {
            this.stationList = [];
            this.$message.error(err.message);
          });
      },
      // 重置(单个)
      resetData(row, item) {
        if (!row.changeId) {
          return this.$message.warning('只能对已撤回跟已保存的数据进行重置');
        }
        this.toolbarLoading = true;
        resetAssignee(row.changeId)
          .then((res) => {
            this.toolbarLoading = false;
            if (res) {
              this.$message.success('操作成功');
              // 更改当前表格数据
              this.setCurrentTab(item);
            }
          })
          .catch((err) => {
            this.toolbarLoading = false;
            this.$message.warning(err.message);
          });
      },
      // 撤回的逻辑
      getWithdrawT(row, type) {
        if (type != 2) {
          return true;
        }
        let isFlag = true;
        row.selection.forEach((item) => {
          if (!item.status) {
            isFlag = false;
            return;
          }
          if (!item.status.code) {
            isFlag = false;
          }
        });
        return isFlag;
      },
      // 派单
      dispatch(row, type) {
        if (row.selection.length == 0) {
          return this.$message.warning('请最少选择一条数据');
        }
        let isWithdraw = this.getWithdrawT(row, type);
        if (!isWithdraw) {
          this.$message.warning('只有状态为派单的数据才能进行撤回');
          return;
        }
        let assignees = [];
        let changeIds = [];
        let flag = true; // 是否填写 校验
        // let digit = true; // 数字校验
        row.selection.forEach((item) => {
          if (!item.quantity || !item.startTime || !item.endTime) {
            flag = false;
            return;
          }
          let Aobj = {
            assigneeId: item.id,
            quantity: item.quantity,
            weight: item.weight,
            startTime: item.startTime,
            endTime: item.endTime,
            assigneeType: row.assignType,
            assigneeName: item.name
          };
          if (item.teamTimeDetailId) {
            Aobj.teamTimeDetailId = item.teamTimeDetailId;
          }
          assignees.push(Aobj);
          changeIds.push(item.changeId);
        });
        if (!flag) {
          this.$message.warning(
            '请将所选数据的 数量 ,开始时间,完成时间 填写完毕'
          );
          return;
        }
        let data = null;
        this.toolbarLoading = true;
        if (type == 2) {
          data = changeIds;
        } else {
          data = {
            dispatchMethod: 0,
            dispatchType: this.dispatchType,
            taskId: this.processId,
            taskName: row.name,
            taskCode: row.code,
            teamName: this.form.teamName,
            teamId: this.form.teamId,
            workCenterId: this.form.workCenterId,
            workCenterName: this.form.workCenterName,
            workOrderId: this.current.apsWorkOrderId,
            sourceType: 2,
            assignees
          };
        }
        const api =
          type == 1 ? taskAssignment : type == 2 ? taskRevoked : taskSave;
        api(data)
          .then((res) => {
            this.toolbarLoading = false;
            if (res) {
              this.$message.success('操作成功');
              // 更改当前表格数据
              this.setCurrentTab(row);
            }
          })
          .catch((err) => {
            this.toolbarLoading = false;
            this.$message.warning(err.message);
          });
      },
      cancel() {
        this.$emit('update:dispatchVisible', false);
      },
      // 按钮操作成功后 更改当前的表格数据
      setCurrentTab(row) {
        let arr = [];
        if (row.assignType == 1) {
          arr = this.stationList;
        } else if (row.assignType == 2) {
          arr = this.crewList;
        } else {
          arr = this.productionList;
        }
        this.getAssignData(row.index, arr);
      },
      // 工序选择
      async handleClick(tab) {
        let id = tab.name;
        this.processId = id;
        let data = this.processList.find((item) => item.id == this.processId);
        await this.changeRadio(data.assignType, data.index);
      },
      // 指派选择
      changeRadio(e, index) {
        let data = this.processList[index];
        if (e == 1) {
          this.dynamicName = '工位名称';
          data.assignName = '工位';
          this.getAssignData(index, this.stationList);
        } else if (e == 2) {
          this.dynamicName = '人员名称';
          data.assignName = '人员';
          this.getAssignData(index, this.crewList);
        } else {
          this.dynamicName = '产线名称';
          data.assignName = '产线';
          this.getAssignData(index, this.productionList);
        }
      },
      // 指派数据处理
      async getAssignData(index, arr) {
        let list = JSON.parse(JSON.stringify(arr));
        let dataRow = this.processList[index];
        // 不存在 班组数据的话 就不调用这个方法
        if (!this.form.teamId) {
          return;
        }
        let params = {
          workOrderId: this.current.apsWorkOrderId,
          workCenterId: this.form.workCenterId,
          teamId: this.form.teamId,
          taskId: this.processId
        };
        this.tabLoading = true;
        try {
          const res = await listAssign(params);
          this.tabLoading = false;
          // 如果 res 没有数据 说明未对数据进行操作 直接赋值
          if (res.length == 0) {
            this.$set(dataRow, 'list', list);
            return;
          }
          // 对有操作过的数据进行赋值
          this.operationalData(index, res, list);
        } catch (err) {
          this.tabLoading = false;
          this.$message.warning(err.message);
        }
      },
      // 操作过的数据 赋值
      operationalData(index, res, list) {
        const dataRow = this.processList[index];
        // 键值对存储 当前工序 操作的数据  指派的code(键) 数据(list:值)
        let arrMap = {};
        // 要先判断有没有操作的数据 如果有的话 其它的指派操作置灰
        let codeT = null; // 表示有已操作的数据(对应的 code)
        res[0].assignees.map((el) => {
          let code = el.assigneeType.code;
          if (arrMap[code]) {
            arrMap[code].arr.push(el);
            arrMap[code].bunDis = arrMap[code].bunDis
              ? arrMap[code].bunDis
              : el.status.desc
              ? true
              : false;
          } else {
            arrMap[code] = {
              arr: [el],
              bunDis: el.status.desc ? true : false
            };
          }
          codeT = codeT ? codeT : el.status.desc ? code : '';
        });
        let radioBun = {
          lineDis: false, // 产线 3
          staffDis: false, // 人员 2
          stationDis: false // 工位 1
        };
        // 默认是传递下来的 list 数据 但是如果 codeT有值 说明 工位 人员 产线 有派单数据
        // 需要自动切换过去
        let listArr = list;
        if (codeT) {
          if (codeT == 1) {
            radioBun.staffDis = true;
            radioBun.lineDis = true;
            radioBun.stationDis = false;
            listArr = JSON.parse(JSON.stringify(this.stationList));
            dataRow.assignType = 1;
            dataRow.assignName = '工位';
          } else if (codeT == 2) {
            radioBun.stationDis = true;
            radioBun.lineDis = true;
            radioBun.staffDis = false;
            listArr = JSON.parse(JSON.stringify(this.crewList));
            dataRow.assignType = 2;
            dataRow.assignName = '人员';
          } else {
            radioBun.stationDis = true;
            radioBun.staffDis = true;
            radioBun.lineDis = false;
            listArr = JSON.parse(JSON.stringify(this.productionList));
            dataRow.assignType = 3;
            dataRow.assignName = '产线';
          }
        }
        // 切换完后 对 指派的数组数据进行赋值
        let listMap = {};
        listArr.map((el, index) => (listMap[el.id] = index));
        let arrList = codeT ? arrMap[codeT].arr : res[0].assignees;
        arrList.map((item) => {
          if (item.assigneeType.code == dataRow.assignType) {
            let idx = listMap[item.assigneeId];
            listArr[idx].status = item.status;
            listArr[idx].startTime = item.startTime;
            listArr[idx].endTime = item.endTime;
            listArr[idx].quantity = item.quantity;
            listArr[idx].weight = item.weight;
            listArr[idx].changeId = item.id;
            listArr[idx].teamTimeDetailId = item.teamTimeDetailId;
            this.compareAndSetTime(listArr[idx], dataRow);
            this.compareEndSetTime(listArr[idx], dataRow);
          }
        });
        this.$set(dataRow, 'list', listArr);
        this.$set(dataRow, 'radioBun', radioBun);
      },
      // 时间比较与赋值方法 开始时间
      compareAndSetTime(data, dataRow) {
        // 如果startDate为空，直接赋值为startTime
        if (!dataRow.startDate) {
          dataRow.startDate = data['startTime'];
          return;
        }

        // 转换为Date对象进行比较
        const startTimeDate = new Date(data['startTime']);
        const startDateDate = new Date(dataRow.startDate);

        // 比较时间（getTime()获取时间戳）
        if (startTimeDate.getTime() < startDateDate.getTime()) {
          dataRow.startDate = data['startTime'];
        }
      },
      // 时间比较与赋值方法 结束时间时间
      compareEndSetTime(data, dataRow) {
        // 如果startDate为空，直接赋值为endTime
        if (!dataRow.endDate) {
          dataRow.endDate = data['endTime'];
          return;
        }
        // 转换为Date对象进行比较
        const endTimeDate = new Date(data['endTime']);
        const endDateDate = new Date(dataRow.endDate);
        // 比较时间（getTime()获取时间戳）
        if (endTimeDate.getTime() > endDateDate.getTime()) {
          dataRow.endDate = data['endTime'];
        }
      },
      assignRadio(e) {},
      // 数量正则 quantity
      handleQuantityInput(e, row, item) {
        // 过滤非数字字符（包括负号）
        let value = e.replace(/[^\d]/g, '');
        // 限制不能以 0 开头（除非是 0 本身）
        if (value.startsWith('0') && value.length > 1) {
          value = value.slice(1);
        }
        // 更新绑定值
        row.quantity = value;
        this.calculateQuantity(row, item);
        this.bringWeight(row.quantity, row);
      },
      // 自动算重量
      bringWeight(value, row) {
        if (!this.current.formingWeight) {
          this.$set(row, 'weight', 0);
          return;
        }
        let weight =
          (this.current.formingWeight / this.current.formingNum) * value;
        if (weight > 0) {
          weight = weight.toFixed(4) - 0;
        }
        this.$set(row, 'weight', weight);
      },
      calculateQuantity(row, item) {
        // 如果没有该字段 就不做判断
        if (!this.current.formingNum) {
          return;
        }
        let total = 0;
        item.list.forEach((el) => {
          if (el.quantity) {
            total = total + (el.quantity - 0);
          }
        });
        if (total > this.current.formingNum - 0) {
          this.$message.warning('列表数量相加不能大于目标要求生产数量');
          row.quantity = 0;
        }
      },
      // 计算重量
      calculateWeight(row, item) {
        // 如果没有该字段 就不做判断
        if (!this.current.formingWeight) {
          return;
        }
        let total = 0;
        item.list.forEach((el) => {
          if (el.weight) {
            total = total + (el.weight - 0);
          }
        });
        if (total > this.current.formingWeight - 0) {
          this.$message.warning('列表数量相加不能大于目标要求生产数量');
          row.weight = 0;
        }
      },
      // 重量正则 weight
      handleWeightInput(e, row, item) {
        // 过滤非数字和非小数点字符（包括负号）
        let value = e.replace(/[^\d.]/g, '');
        // 限制只能有一个小数点
        const dotCount = (value.match(/\./g) || []).length;
        if (dotCount > 1) {
          value = value.slice(0, value.lastIndexOf('.'));
        }

        // 限制不能以小数点开头
        if (value.startsWith('.')) {
          value = '0' + value;
        }
        // 更新绑定值
        row.weight = value;
        this.calculateWeight(row, item);
      },
      // 选中班次
      shiftSelection(e, row, item) {
        let data = this.shiftList.find((item) => item.id == e);
        let startTime = `${this.dateValue} ${data.startTime}`;
        let endTime = `${this.dateValue} ${data.endTime}`;
        this.$set(row, 'startTime', startTime);
        this.$set(row, 'endTime', endTime);
        this.handleStartTimeChange(row, item);
        this.handleEndTimeChange(row, item);
      },
      // 【开始时间变化时】触发
      handleStartTimeChange(row, item) {
        if (!row.startTime) {
          return;
        }
        // 这一道工序的开始时间 不能小于前一道工序的结束时间
        const startTime = new Date(row.startTime); // 开始时间
        if (item.index !== 0) {
          // let frontIdx = item.index - 1;
          let frontIdx = this.calculateIndex(item.index).startIdx;
          if (frontIdx !== 'none') {
            let frontName = this.processList[frontIdx].name;
            let time = this.processList[frontIdx].endDate;
            const frontTime = new Date(time); // 前面工序的结束时间
            if (time && startTime < frontTime) {
              this.$message.closeAll();
              this.$message.info(
                `开始时间不能小于前面工序${frontName}的结束时间${time}`
              );
              // 判断是否 配置时间更改规则
              if (this.time_calc_code == '1') {
                row.startTime = time;
              }
              return;
            }
          }
        }
        // 这一道工序的开始时间更不能大于后一道工序的开始时间
        if (item.index !== this.processList.length - 1) {
          // let latterIdx = item.index + 1;
          let latterIdx = this.calculateIndex(item.index).endIdx;
          if (latterIdx !== 'none') {
            let time = this.processList[latterIdx].startDate;
            let latterName = this.processList[latterIdx].name;
            const latterTime = new Date(time); // 下一道工序的结束时间
            if (time && startTime > latterTime) {
              this.$message.closeAll();
              this.$message.info(
                `开始时间不能大于后面工序${latterName}的开始时间${time}`
              );
              // 判断是否 配置时间更改规则
              if (this.time_calc_code == '1') {
                row.startTime = '';
              }
              return;
            }
          }
        }
        // 校验 是否 大于结束时间  wda
        this.checkEndTimeValid(row);
      },
      // 当更改一个工序开始时间 结束时间的时候
      // 开始时间 不能小于之前工序的结束时间 ( 要先去上一道工序找 是否存在结束时间 不存在就再往前找 直到 第一道工序 )
      // 结束时间 不能大于后面工序的开始时间 ( 要先去后一道工序找 是否存在开始时间 不存在就再往后找 直到 最后一道工序 )
      // 计算出当前下标数据 的前后 有 开始时间 结束时间的数据下标
      calculateIndex(index) {
        let startIdx = 'none';
        let endIdx = 'none';
        // 前面工序下标
        for (let i = index - 1; i >= 0; i--) {
          let row = this.processList[i];
          if (row && row.endDate) {
            startIdx = i;
            break;
          }
        }
        // 后面工序的下标
        for (let i = index + 1; i <= this.processList.length; i++) {
          let row = this.processList[i];
          if (row && row.startDate) {
            endIdx = i;
            break;
          }
        }
        return {
          startIdx,
          endIdx
        };
      },
      // 【结束时间变化时】触发
      handleEndTimeChange(row, item) {
        if (!row.endTime) {
          return;
        }
        const endTime = new Date(row.endTime); // 结束时间
        // 当前工序的结束时间 不能大于后一道工序的开始时间
        if (item.index !== this.processList.length - 1) {
          let latterIdx = this.calculateIndex(item.index).endIdx;
          if (latterIdx !== 'none') {
            let latterName = this.processList[latterIdx].name;
            let time = this.processList[latterIdx].startDate;
            const latterTime = new Date(time); // 后面工序的开始时间
            if (time && endTime > latterTime) {
              this.$message.closeAll();
              this.$message.info(
                `结束时间不能大于后面工序${latterName}的开始时间${time}`
              );
              // 判断是否 配置时间更改规则
              if (this.time_calc_code == '1') {
                row.endTime = time;
              }
              return;
            }
          }
        }
        // 这一道工序的开始时间更不能小于于前一道工序的结束时间
        if (item.index !== 0) {
          // let frontIdx = item.index - 1;
          let frontIdx = this.calculateIndex(item.index).startIdx;
          if (frontIdx !== 'none') {
            let frontName = this.processList[frontIdx].name;
            let time = this.processList[frontIdx].endDate;
            const frontTime = new Date(time); // 上一道工序的结束时间
            if (time && endTime < frontTime) {
              this.$message.closeAll();
              this.$message.info(
                `结束时间不能小于前面工序${frontName}的结束时间${time}`
              );
              // 判断是否 配置时间更改规则
              if (this.time_calc_code == '1') {
                row.endTime = '';
              }
              return;
            }
          }
        }
        this.checkEndTimeValid(row, item);
      },
      // 时间校验
      checkEndTimeValid(row) {
        const { startTime: start, endTime: end } = row;
        // if (!start || !end) return; // 开始/结束时间未填，跳过
        const startTime = new Date(start); // 开始时间
        const endTime = new Date(end); // 结束时间
        if (endTime < startTime) {
          row.endTime = new Date(startTime); // 修正为开始时间
          this.$message.info('结束时间不能早于开始时间，已自动设为开始时间');
        }
      }
    }
  };
</script>

<style lang="scss" scoped>
  .top-box {
    display: flex;
    margin-bottom: 10px;

    .item-box {
      flex: 1;
    }
  }

  .radio-box {
    margin: 10px 0;
  }

  .table {
    margin-top: 20px;
  }

  ::v-deep .el-radio-button__orig-radio:checked + .el-radio-button__inner {
    background-color: #10d070;
    border-color: #10d070;
  }

  ::v-deep .el-radio-button__orig-radio:checked + .el-radio-button__inner {
    box-shadow: none;
  }

  // ::v-deep .ele-block{
  //   width: 240px;
  // }

  // ::v-deep .basic {
  //   .el-form-item {
  //     width: 100%;
  //   }

  //   .form80 {
  //     .el-form-item__content {
  //       width: calc(100% - 80px);
  //     }
  //   }

  //   .form65 {
  //     .el-form-item__content {
  //       width: calc(100% - 65px);
  //     }
  //   }

  //   .el-form-item__label {
  //     padding: 0 4px 0 0;
  //   }

  //   .item_label {
  //     white-space: nowrap;
  //     overflow: hidden;
  //     text-overflow: ellipsis;
  //     width: 100%;
  //   }
  // }

  .describe {
    display: inline-block;
  }
</style>