现场编制功能适配

yangys

2025-09-17 ae2c3f847da927b6124e872d8d74c0457a1eea14

 src/views/flow/todolist.vue

@@ -1,60 +1,98 @@
<template>
    <basic-container>
        <avue-crud :option="option" :table-loading="loading" :data="data" v-model:page="page" v-model="form" ref="crud"
            :search="query"
            @search-change="searchChange" @search-reset="searchReset" @current-change="currentChange"
            @size-change="sizeChange" @refresh-change="refreshChange" @on-load="onLoad"
            @selection-change="selectionTransferTask">
            <template #menu-left>
                <el-button type="primary" plain @click="reassign">重新指派
                
                <el-button type="primary" :disabled="this.transferTaskSelection.length==0" v-if="permission.auto_dispatch" plain @click="reassign(2)">自动派工
                </el-button>
                <el-button type="primary" :disabled="this.transferTaskSelection.length==0" v-if="permission.manual_dispatch" plain @click="reassign(1)">手动派工
                </el-button>
                <el-button type="primary" :disabled="this.transferTaskSelection.length==0" plain @click="reassign(0)">转派</el-button>
                <el-button type="primary" :disabled="this.transferTaskSelection.length==0" v-if="permission.batch_approve" plain @click="reassign(3)">批量审批
                </el-button>

                <el-button type="primary" :disabled="this.transferTaskSelection.length==0" v-if="permission.batch_on_machine" plain @click="showBatchOnMachine()">现场编制
                </el-button>
            </template>
            <template #menu="scope">
                <el-button type="primary" text size="default" @click.stop="handleAction(scope.row, scope.index)">审批
                <el-button type="primary" text size="default" @click.stop="handleAction(scope.row, scope.index)">
                    {{approveButtonText(scope.row.taskDefinitionKey)}}
                </el-button>
            </template>
              
        </avue-crud>
        <el-dialog title="指派" append-to-body v-model="reassignBox" width="30%">
        <el-dialog title=" " append-to-body v-model="reassignBox" width="30%">
            <avue-form ref="reassginform" :option="reassignOption" v-model="reassignForm" @submit="toPerson"></avue-form>
        </el-dialog>
        <el-drawer title="审批" append-to-body v-model="approveBox" size="100%" v-if="approveBox">
        <el-dialog title="现场编制" append-to-body v-model="onMachineBox" width="30%">
            <avue-form :option="onMachineOption" v-model="onMachineForm" @submit="batchOnMachine"></avue-form>
        </el-dialog>
        <div  class="box-drawer">
        <el-drawer title="审批" append-to-body v-model="approveBox" size="100%" v-if="approveBox" class="remark-drawer">
            <div class="approve-box">
                <div class="left">
                    <TodolistLeft :row="row" @selection-change="selectionChange" />
                    <TodolistLeft ref="todolistLeft" :row="row" @selection-change="selectionChange" />
                </div>
                <div class="right">
                    <TodolistRightTop :row="row" />
                    <avue-form ref="form" :option="optionApprove" v-model="formApprove" @submit="handleSubmit" />
                    <el-tabs
                        type="card"
                        class="demo-tabs"
                        v-model="activeName"
                    >
                        <el-tab-pane label="审批" name="approve">
                            <avue-form ref="form" :option="optionApprove" v-model="formApprove" @submit="handleSubmit" >
                                
                            </avue-form>
                        </el-tab-pane>
                        <el-tab-pane label="流程轨迹" name="log">
                            <processTrace :item="row" v-if="activeName==='log'"></processTrace>
                        </el-tab-pane>
                    </el-tabs>
                    
                </div>
            </div>
        </el-drawer>
        </div>
    </basic-container>
</template>

<script>
import { getList, approve, getAssignee,reassgin } from '@/api/flow/todolist';
import { getList, approve, getAssignee,getAssigneeTree,reassgin,manualDispatch,autoDispatch,todoChangeNotify,batchApprove, batchApproveOnMachine } from '@/api/flow/todolist';
import { mapGetters } from 'vuex';
import dayjs from 'dayjs';
import TodolistLeft from './components/TodolistLeft.vue';
import TodolistRightTop from './components/TodolistRightTop.vue';
import processTrace from './components/process-trace.vue';

export default {
    components: {
        TodolistLeft,
        TodolistRightTop
        TodolistRightTop,
        processTrace
    },
    data() {
       let rejectText = '驳回';//+this.row.categoryName;
        console.log(this,'ttt');
        return {
            
            activeName: 'approve',
            applist: [],
            assigneeData: [],
            allAssigneeData: [],
            managerAssigneeData: [],//数控管理员角色的审批用户

            assignee2Data:[],

            row: {},
            approveBox: false,
            formApprove: {
                comment: '',
                approve: '', // 默认同意
                assignee: ''
                approve: '',
                assignee: '',
            },
    

            optionApprove: {
                labelWidth: 100,
                column: [
@@ -66,43 +104,32 @@
                        span: 24,
                        dicData: [
                            { label: '通过', value: 'Y' },
                            { label: rejectText, value: 'N' },
                            { label: '驳回', value: 'N' },
                        ],
                        rules: [{ required: true, message: '请选择审批结果', trigger: 'blur' }],
                    },
                    {
                        label: '发送给',
                        prop: 'assignee',
                        type: 'select',
                        // dicUrl: `/blade-mdm/flow/flow-user-list?deptId=0`,
                        // dicFlag: true,
                        props: {
                            label: 'name',
                            value: 'id',
                        component: 'elTreeSelect',
                        params: {
                            props:{
                                label: 'name',
                                value:'id',
                                disabled: (data) => data.nodeType==='dept',
                                isLeaf: (data) => data.children==null || data.children.length==0,
                            },
                        },
                        display: true,
                        filterable: true,
                        span: 24,
                        disabled: false,
                        dicData: [

                        ],
                        // rules: [{ required: true, message: '请选择下一审批用户', trigger: 'blur' }],
                    },
                    {
                        label: '工序版次',
                        prop: 'processEdition',
                        type: 'input',
                        span: 24,
                        // disabled: true,
                        display: false,// 隐藏显示
                        // rules: [{ required: true, message: '请选择下一审批用户', trigger: 'blur' }],
                    },
                    {
                        label: '备注',
                        span: 24,
                        prop: 'comment',
                        type: 'textarea',
                        // rules: [{ required: true, message: '请输入审批意见', trigger: 'blur' }],
                        rules: [
                            {
                            validator: (rule, value, callback) => {
@@ -117,6 +144,7 @@
                            }
                        ]
                    },
                    
                ],
            },
            page: {
@@ -125,7 +153,12 @@
                total: 0,
            },
            form: {},
            query: {},
            query: {
                machineSpec: ['1','2']
            },
            defaultQuery: {
                machineSpec: ['1','2']
            },
            loading: true,
            option: {
                rowKey: "taskId",
@@ -134,11 +167,10 @@
                delBtn: false,
                columnBtn: false,
                tip: false,
                // simplePage: true,
                searchEnter:true,
                searchShow: true,
                searchMenuSpan: 6,
                searchMenuSpan: 4,
                dialogWidth: '60%',
                // tree: true,
                border: true,
                index: true,
                selection: true,
@@ -149,7 +181,7 @@
                    {
                        label: '关键字',
                        prop: 'keyword',
                        width: 300,
                        width: 200,
                        search: true,
                        searchType: 'input',
                        hide: true,
@@ -164,10 +196,31 @@
                            },
                        ],
                    },
                    {
                        label: '机床类型',
                        prop: 'machineSpec',
                        width: 200,
                        search: true,
                        searchType: 'select',
                        multiple:true,
                        clearable:false,
                        hide: true,
                        emptyValues :["1",'2'],
                        dicData: [
                            {
                                label: '车床',
                                value: '1',
                            },
                            {
                                label: '加工中心',
                                value: '2',
                            },
                        ],
                    },
               {
                        label: '标题',
                        prop: '',
                        width: 100,
                        width: 200,
                  render: ({ row }) => {
                            return h('p',
                                {
@@ -179,31 +232,47 @@
                    },
                    {
                        label: '流程名称',
                        prop: 'processDefinitionName',
                        width: 100,
                    },/*
                        prop: '',
                        width: 110,
                  render: ({ row }) => {
                            return h('p',
                                {
                                    attrs: {},
                                    class: {},
                                    style: {},
                                }, row?.variables?.myProcessName)
                        }
                    },
                    {
                        label: '流程类型',
                        label: '编制',
                        width: 100,
                        prop: 'categoryName',
                    },*/

                        render: ({ row }) => {
                            return h('p',
                                {
                                    attrs: {},
                                    class: {},
                                    style: {},
                                }, row?.variables?.programmerName)
                        }
                    },
                    {
                        label: '机床',
                        width: 100,
                        prop: '',
                        showOverflowTooltip:true,
                        formatter: (val, value, label) => {
                            return `${val?.variables?.machineCode}`;
                        },
                    },
                    {
                        label: '创建人',
                        width: 100,
                        width: 70,
                        overHidden:true,
                        prop: 'startUserName',
                    },
                    {
                        label: '创建时间',
                        width: 200,
                        width: 100,
                        prop: 'processCreateTime',
                        type: 'datetime',
                        format: 'YYYY-MM-DD HH:mm:ss',
@@ -211,11 +280,12 @@
                        search: true,
                        searchRange: true,
                        searchSpan: 8,
                        showOverflowTooltip:true,
                        // hide: true,
                    },
                    {
                        label: '上一步用户',
                        width: 200,
                        width: 100,
                        prop: '',
                        formatter: (val, value, label) => {
                            return `${val?.variables?.approveUserNickName || ''}`;
@@ -223,18 +293,23 @@
                    },
                    {
                        label: '当前节点',
                        width: 200,
                        width: 120,
                        showOverflowTooltip:true,
                        prop: 'taskName',
                    },
                    {
                        label: '文件',
                        width: 200,
                        prop: 'file',
                        showOverflowTooltip:true,
                    },
                    {
                        label: '到达时间',
                        width: 200,
                        width: 120,
                        prop: 'createTime',
                        showOverflowTooltip:true,
                       
                        
                    },
                    {
                        label: '到达描述',
@@ -247,25 +322,103 @@
            data: [],
            transferTaskSelection: [],
            reassignBox: false,
            reassignType: 0, // 0:重新指派，1:自动派工 2: 自动派工
            reassignOption: {
                submitBtn: true,
                emptyBtn: false,
                column: [
                    {
                        label: '审批结果',
                        prop: 'approve',
                        type: 'radio',
                        span: 24,
                        display: false,
                        dicData: [
                            { label: '通过', value: 'Y' },
                            { label: '驳回', value: 'N' },
                        ],
                        rules: [{ required: true, message: '请选择审批结果', trigger: 'blur' }],
                    },
                    {
                        label: '发送给',
                        prop: 'newAssigneeId',
                        component: 'elTreeSelect',
                        params: {
                            props:{
                                label: 'name',
                                value:'id',
                                disabled: (data) => data.nodeType==='dept',
                                isLeaf: (data) => data.children==null || data.children.length==0,
                            },
                        },
                        display: true,
                        filterable: true,
                        span: 24,
                        disabled: false,
                        rules: [{ required: true, message: '请输入选择', trigger: 'blur' }],
                    },
                    /*
                    {
                        label: '发送给',
                        prop: 'newAssigneeId',
                        filterable:true,
                        type: 'select',
                        // dicUrl: `/blade-mdm/flow/flow-user-list?deptId=0`,
                        // dicFlag: true,
                        props: {
                            label: 'name',
                            value: 'id',
                        },
                        span: 24,
                        disabled: false,
                        display: true,
                        dicData: [

                        ],
                        rules: [{ required: true, message: '请输入选择', trigger: 'blur' }],
                    },*/
                    {
                        label: '备注',
                        span: 24,
                        prop: 'comment',
                        type: 'textarea',
                    },
                ],
            },
            reassignForm: {},

            onMachineBox: false,//现场编制框
            onMachineForm: {},
            onMachineOption: {
                submitBtn: true,
                emptyBtn: false,
                column: [
                    {
                        label: '审批结果',
                        prop: 'approve',
                        type: 'radio',
                        span: 24,
                        display: false,
                        dicData: [
                            { label: '通过', value: 'Y' },
                            { label: '驳回', value: 'N' },
                        ],
                        rules: [{ required: true, message: '请选择审批结果', trigger: 'blur' }],
                    },
                    {
                        label: '发送给',
                        prop: 'assignee',
                        component: 'elTreeSelect',
                        params: {
                            props:{
                                label: 'name',
                                value:'id',
                                disabled: (data) => data.nodeType==='dept',
                                isLeaf: (data) => data.children==null || data.children.length==0,
                            },
                        },
                        display: true,
                        filterable: true,
                        span: 24,
                        disabled: false,
                        rules: [{ required: true, message: '请输入选择', trigger: 'blur' }],
                    },
                    {
@@ -273,79 +426,140 @@
                        span: 24,
                        prop: 'comment',
                        type: 'textarea',
                        rules: [{ required: true, message: '请输入审批意见', trigger: 'blur' }],
                    },
                ],
            },
            reassignForm: {}
        };
    },
    watch: {
        // 'form.category'() {
        //     const category = func.toInt(this.form.category);
        //     this.$refs.crud.option.column.filter(item => {
        //         if (item.prop === 'path') {
        //             item.rules[0].required = category === 1;
        //         }
        //         if (item.prop === 'isOpen') {
        //             item.disabled = category === 2;
        //         }
        //     });
        // },
        
        'formApprove.approve'(val) {
            this.setAssignee(this.row, val);
            // if(val === 'Y' && ['confirmIsUseableTask'].includes(this.row.taskDefinitionKey) && this.row.variables.isProcessEditionSame=='N') {
            //     // this.optionApprove.column[2].display = true; // 显示工序版次
            // } else {
            //     this.optionApprove.column[2].display = false; // 隐藏工序版次
            // }
            
        },
        'reassignForm.approve'(val) {
            if(this.reassignType ===3) {
                if(val === 'Y') {
                    this.reassignOption.column[1].disabled = true;
                    this.reassignOption.column[1].display = false;
                    this.reassignForm.newAssigneeId = '';
                } else {
                    this.reassignOption.column[1].display = false;
                    this.reassignOption.column[1].disabled = false;
                    this.reassignForm.newAssigneeId = '';
                }
            }
            
        }
    },
    computed: {
        ...mapGetters(['userInfo', 'permission']),
        // permissionList() {
        //     return {
        //         addBtn: this.validData(this.permission.menu_add, false),
        //         viewBtn: this.validData(this.permission.menu_view, false),
        //         delBtn: this.validData(this.permission.menu_delete, false),
        //         editBtn: this.validData(this.permission.menu_edit, false),
        //     };
        // },
        permissionList() {
            return {
                manual_dispatch: this.validData(this.permission.manual_dispatch, false),
                auto_dispatch: this.validData(this.permission.auto_dispatch, false),
                batch_approve: this.validData(this.permission.batch_approve, true),
            };
        },
    },
    mounted() {
        getAssignee().then(res => {
            this.assigneeData = res.data.data;
            this.optionApprove.column[1].dicData = this.assigneeData;
            this.reassignOption.column[0].dicData = this.assigneeData;
        })
        //this.setApproveBtn(row)
        /*
        getAssignee({
                taskId: 0,
             }).then(res => {
                //if(row.taskDefinitionKey === '')
                this.assigneeData = res.data.data;
                this.reassignOption.column[1].dicData = this.assigneeData;
             });
        */
         getAssigneeTree({
                taskId: 0,
             }).then(res => {
                this.assigneeData = res.data.data;
                //初始化数控管理员的数组
                for(var i=0;i<this.assigneeData.length;i++){
                    for(var j=0;j<this.assigneeData[i].children.length;j++){
                        if(this.assigneeData[i].children[j].nodeType=='manager'){
                            this.managerAssigneeData[this.managerAssigneeData.length] = this.assigneeData[i].children[j];
                        }
                    }
                }
                
                this.optionApprove.column[1].data = this.assigneeData;
                this.reassignOption.column[1].data = this.assigneeData;
                this.onMachineOption.column[1].data = this.assigneeData;
             });
    },
    methods: {
        // 设置审批结果的状态
        setApproveBtn () {
        approveButtonText(taskDefinitionKey){
            let lower = taskDefinitionKey.toLowerCase();
            if(taskDefinitionKey === 'teamLeaderTask') {
                return '派工'
            }else if(taskDefinitionKey == 'unlockProgramConfirm') {
                //解锁，编制复核
                return '复核'
            }else if(taskDefinitionKey == 'programMgrConfirm') {
                //固化，程序管理员确认
                return '确认'
            }else if(lower.indexOf('program')>-1) {
                return '编制'
            }else if(lower.indexOf('check')>-1) {
                return '校对'
            }else if(lower.indexOf('useable')>-1) {
                return '检查'
            }else{
                return '审批'
            } 
        },
        setApproveBtn (row) { // 设置审批结果的状态
            // 1.审批界面radio文本修改，普通节点的2个radio文本 通过（approve=Y),不通过(现在的驳回)(approve=N)
            
            this.optionApprove.column[0].dicData = [
                { label: '通过', value: 'Y' },
                { label: '不通过', value: 'N' },
            ];
            switch (this.row.taskDefinitionKey) {
                case 'teamLeaderTask': // 任务派工
                case 'cureProgramTask': // 固化编制
                    this.optionApprove.column[0].dicData = [
                        { label: '通过', value: 'Y' },
                        { label: '结束', value: 'N' },
                    ];
                    break;
                case 'confirmIsUseableTask': // 检查程序是否可用
                case 'appendProgrammingTask': // 补充流程的 编程节点
                    this.optionApprove.column[0].dicData = [
                        { label: '通过', value: 'Y' },
                        { label: '不通过', value: 'N' },
                        { label: '驳回', value: 'R' },
                        { label: '结束', value: 'E' },
                    ];
                    break;
                case 'cureProgramTask': // 固化编制,可以通过（给校对）；不通过N（给程序管理员）
                    this.optionApprove.column[0].dicData = [
                        { label: '通过', value: 'Y' },
                        { label: '不通过', value: 'N' },//给程序管理员
                       
                    ];
                    break;
                case 'confirmIsUseableTask': // 检查程序是否可用，驳回是给
                    this.optionApprove.column[0].dicData = [
                        { label: '可用', value: 'Y' }, //给校对
                        { label: '不可用', value: 'N' },//给编制
                        { label: '驳回', value: 'R' },//给驳回组长
                    ];
                    break;
                case 'programmingTask': //试切 编制节点
                    this.optionApprove.column[0].dicData = [
                        { label: '通过', value: 'Y' },
                        { label: '不通过', value: 'N' },//给组长
                        { label: '结束', value: 'E' },//结束流程
                    ];
                    break;
                case 'programMgrConfirm'://固化流程 程序管理员，只能结束
                    this.optionApprove.column[0].dicData = [
                        { label: '结束', value: 'E' },
                    ];
                    break;
                case 'seniorApproveTask': // 高师审核
                case 'approveTask': // 高师审核

                default:
                    this.optionApprove.column[0].dicData = [
                        { label: '通过', value: 'Y' },
@@ -355,89 +569,354 @@
            }
        },
        setAssignee (row, approve) {
            if (approve === 'Y') {
                if (["check", 'cureCheckTask '].includes(row.taskDefinitionKey)) {// 校对
            
            if (["cureProgramTask"].includes(row.taskDefinitionKey)) {
                if(approve === 'N'){
                    this.optionApprove.column[1].data = this.managerAssigneeData;
                }else{
                    //this.optionApprove.column[1].dicData = this.allAssigneeData;
                    this.optionApprove.column[1].data = this.assigneeData;
                }
            }
            if (approve === 'Y') {//审批通过的情况

                this.optionApprove.column[1].disabled = false;
                if (["check", 'cureCheckTask','repalceCheckTask','appendCheckTask'].includes(row.taskDefinitionKey)) {// 校对节点
                    this.formApprove.assignee = row.variables.senior;
                } else if (["programmingTask",'cureProgramTask'].includes(row.taskDefinitionKey)) {// 编制，校对
                } else if (["programmingTask",'cureProgramTask','replaceProgrammingTask','appendProgrammingTask'].includes(row.taskDefinitionKey)) {// 编制节点
                    this.formApprove.assignee = row.variables.checker;
                } else if (row.taskDefinitionKey == "teamLeaderTask") {// 任务派工
                } else if (row.taskDefinitionKey == "teamLeaderTask") {// 任务派工(组长)
                    this.optionApprove.column[1].disabled = false;
                    this.formApprove.assignee = row.variables.programmer
                } else if (row.taskDefinitionKey == "confirmIsUseableTask") {
                } else if (row.taskDefinitionKey == "confirmIsUseableTask") {//判断程序是否可用节点，都是发送给校对
                    this.formApprove.assignee = row.variables.checker
                } else if (["approveTask", 'seniorApproveTask'].includes(row.taskDefinitionKey)) {// 高师审核
                    this.optionApprove.column[1].disabled = true;
                    this.formApprove.assignee = ''; // 如果是通过，则默认指派给自己
                } else if (["approveTask", 'seniorApproveTask','replaceApprove','unlockApproveTask','appendApproveTask'].includes(row.taskDefinitionKey)) {// 高师审核
                    this.optionApprove.column[1].disabled = true;//最后一个节点"发送给" 禁用
                    this.formApprove.assignee = ''; // 如果是通过流程直接结束
                }else if('unlockProgramConfirm'==row.taskDefinitionKey){
                    //解锁流程，编程复核,默认给高师
                    this.formApprove.assignee = row.variables.senior;
                }
            } else if(approve === 'N'){
                this.formApprove.assignee = ''
                if (["approveTask", 'seniorApproveTask'].includes(row.taskDefinitionKey)) {// 高师审核
                    this.optionApprove.column[1].disabled = true;
                    this.formApprove.assignee = row.varables.assignee; // 如果是通过，则默认指派给自己
                //不通过的情况
                //根据在线文档34行，'发送给'是禁用，但有默认选项
                this.optionApprove.column[1].disabled = true;

                if (["approveTask", 'seniorApproveTask','replaceApprove','appendApproveTask'].includes(row.taskDefinitionKey)) {
                    //审批节点，不通过给编制：编制是责任人，给实际编程员
                    if(row.variables.actProgrammer){
                        this.formApprove.assignee = row.variables.actProgrammer;//给实际编程员
                    }else{
                        this.formApprove.assignee = row.variables.programmer;//无编程员给主管工艺
                    }
                }else if(['unlockApproveTask'].includes(row.taskDefinitionKey)){
                    //解锁高师审批节点,上一步是编程
                    this.formApprove.assignee = row.variables.programmer;//给主管工艺
                } else if(["check", 'cureCheckTask','repalceCheckTask','appendCheckTask'].includes(row.taskDefinitionKey)){
                    //校对节点,上一步是编程
                    //this.formApprove.assignee = row.variables.programmer;
                    this.formApprove.assignee = row.variables.actProgrammer;//给实际编程员
                }else if (["programmingTask"].includes(row.taskDefinitionKey)) {
                    // 试切编制节点,上一步是组长
                    this.formApprove.assignee = row.variables.teamLeader;
                }else if(["cureProgramTask"].includes(row.taskDefinitionKey)) {
                    //固化编制节点，不通过给数控管理员
                    //TODO 按找角色定位给其中一个数控管理员
                    this.optionApprove.column[1].disabled = false;
                    
                    if(this.managerAssigneeData.length>0){
                        this.formApprove.assignee = this.managerAssigneeData[0].id;
                    }
                }else if(["confirmIsUseableTask"].includes(row.taskDefinitionKey)) {
                    //判断是否可用节点，不可用，给编制
                    this.formApprove.assignee = row.variables.programmer;
                }if(['teamLeaderTask','replaceProgrammingTask','unlockProgramConfirm'].includes(row.taskDefinitionKey)){
                    //初始节点不通过就是结束流程，处理人为空
                    this.formApprove.assignee = '';
                }
                
            }else if(approve === 'R'){
                //驳回，目前只有检查程序是否可用节点
                if(["confirmIsUseableTask"].includes(row.taskDefinitionKey)) {
                    //判断程序是否可用节点，驳回，给组长
                    this.formApprove.assignee = row.variables.teamLeader;
                }
            }else if(approve === 'E'){//END 结束流程，不可选处理人
                //驳回，目前只有检查程序是否可用节点
                this.optionApprove.column[1].disabled = true;//处理人选项禁用
                this.formApprove.assignee = ''
            }
            
        },
        selectionTransferTask(list) {
            this.transferTaskSelection = list;
        },
        reassign() {// 重新指派
        reassign(val) {// 重新指派
            //var 0:批量转派；1：手动派工；2：自动派工；3：批量审批
            this.reassignType = val;
            if (this.transferTaskSelection.length === 0) {
                this.$message.warning('请选择需要重新指派的任务');
                this.$message.warning('请选择需要操作的任务');
                return;
            }
            if (this.transferTaskSelection.length > 1) {
            if (this.transferTaskSelection.length > 1 && this.reassignType === 0) {
                this.$message.warning('请选择一条');
                return;
            }
            this.reassignBox = true;
            if(val === 2) {
                this.$confirm('请确认是否进行批量自动派工？', '', {
                    confirmButtonText: this.$t('submitText'),
                    cancelButtonText: this.$t('cancelText'),
                    type: 'warning',
                }).then(() => {
                    autoDispatch({
                        taskIds: this.transferTaskSelection.map(v => v.taskId),
                        processInstanceIds: this.transferTaskSelection.map(v => v.processInstanceId),
                    }).then(res => {
                        if(res.data.code !== 200) {
                            this.$message.error(res.data.msg);
                            return;
                        }
                        this.$message.success('操作成功');
                        this.onLoad(this.page, this.query);
                        todoChangeNotify();
                    }).catch(err => {
                        this.$message.success('操作失败');
                    })
                }).catch(() => {
                    // this.$message.info('已取消操作');
                });
            } else {
                //0重新指派 3批量审批 ，1手动派工
                this.reassignBox = true;

                if(val === 3) {//批量审批时 显示通过驳回
                    this.reassignOption.column[0].display = true;
                    this.reassignOption.column[0].dicData[1].label = '不通过';
                    this.reassignForm.approve = 'Y';
                    this.reassignForm.newAssigneeId = '';
                    this.reassignOption.column[1].disabled = true;
                    this.reassignOption.column[1].display = true;
                } else {
                    //0
                    this.reassignOption.column[0].display = false;
                    this.reassignForm.approve = '';

                    if(val === 0 || val === 1) {//0重新指派 1手动派工 ,需要显示处理人
                        this.reassignOption.column[1].disabled = false;
                        this.reassignOption.column[1].display = true;
                    }
                }
                if(val ===1) {
                    this.reassignForm.newAssigneeId = this.transferTaskSelection[0].variables.programmer;
                }
            }
            
        },
        toPerson(form, done) {
            this.$confirm('请确认是否指派', '', {
        showBatchOnMachine(){//显示现场编制对话框
            this.onMachineBox = true;
            this.onMachineForm.assignee = this.transferTaskSelection[0].variables.checker;

        },
        batchOnMachine() {//编制批量处理（现场编制）
           
            this.$confirm('请确认是否将选定任务设置为现场编制？', '', {
                confirmButtonText: this.$t('submitText'),
                cancelButtonText: this.$t('cancelText'),
                type: 'warning',
            }).then(() => {
                console.log('toPerson', form);
                reassgin({
                    ...form,
                    taskId: this.transferTaskSelection[0].taskId,
                    processInstanceId: this.transferTaskSelection[0].processInstanceId,
                batchApproveOnMachine({
                    taskIds: this.transferTaskSelection.map(v => v.taskId),
                    processInstanceIds: this.transferTaskSelection.map(v => v.processInstanceId),
                    assignee: this.onMachineForm.assignee,
                }).then(res => {
                    this.$message.success('指派成功');
                    this.reassignBox = false;
                    this.$refs?.reassginform?.resetForm();
                    if(res.data.code !== 200) {
                        this.$message.error(res.data.msg);
                        return;
                    }
                    this.$message.success('操作成功');
                    this.onMachineBox = false;
                    this.onLoad(this.page, this.query);
                    done()

                    todoChangeNotify();
                }).catch(err => {
                    console.error(err);
                    done()
                    this.$message.success('操作失败');
                })
            }).catch(() => {
                // this.$message.info('已取消操作');
            });
            done();
           
        },

        toPerson(form, done) {
            let tip = ''
            this.reassignType === 1 ? tip = '请确认是否手动派工' : this.reassignType === 2 ? tip = '请确认是否自动派工' : tip = '请确认是否重新指派';
            if (this.reassignType === 0) {
                this.$confirm(tip, '', {
                    confirmButtonText: this.$t('submitText'),
                    cancelButtonText: this.$t('cancelText'),
                    type: 'warning',
                }).then((res) => {
                    console.log(res,'>>>>>>')
                    reassgin({
                        ...form,
                        taskId: this.transferTaskSelection[0].taskId,
                        processInstanceId: this.transferTaskSelection[0].processInstanceId,
                    }).then(res => {
                        if(res.data.code !== 200) {
                            this.$message.error(res.data.msg);
                            return;
                        }
                        this.$message.success('操作成功');
                        this.reassignBox = false;
                        this.$refs?.reassginform?.resetForm();
                        this.onLoad(this.page, this.query);

                        todoChangeNotify();
                        done()

                    }).catch(err => {
                        this.$message.error('操作失败');
                        done()
                    })
                }).catch(() => {
                    console.log('>>>>>>')
                    // this.$message.info('已取消操作');
                    done();
                });
                
            } else if (this.reassignType === 1) {
                this.$confirm(tip, '', {
                    confirmButtonText: this.$t('submitText'),
                    cancelButtonText: this.$t('cancelText'),
                    type: 'warning',
                }).then(() => {
                    manualDispatch({
                        assignee: form.newAssigneeId,
                        comment: form.comment,
                        taskIds: this.transferTaskSelection.map(v => v.taskId),
                        processInstanceIds: this.transferTaskSelection.map(v => v.processInstanceId),
                    }).then(res => {
                        if(res.data.code !== 200) {
                            this.$message.error(res.data.msg);
                            return;
                        }
                        this.$message.success('操作成功');
                        this.reassignBox = false;
                        this.$refs?.reassginform?.resetForm();
                        this.onLoad(this.page, this.query);

                        todoChangeNotify();
                        done()

                    }).catch(err => {
                        console.error(err);
                        done()
                    })
                }).catch(() => {
                    console.log('>>>>>>')
                    // this.$message.info('已取消操作');
                    done();
                });
            } else if (this.reassignType === 3) {
                this.$confirm('确认要进行批量审批吗？', '', {
                    confirmButtonText: this.$t('submitText'),
                    cancelButtonText: this.$t('cancelText'),
                    type: 'warning',
                }).then(() => {
                    batchApprove({
                        assignee: form.newAssigneeId,
                        comment: form.comment,
                        approve: form.approve,
                        taskIds: this.transferTaskSelection.map(v => v.taskId),
                        processInstanceIds: this.transferTaskSelection.map(v => v.processInstanceId),
                    }).then(res => {
                        if(res.data.code !== 200) {
                            this.$message.error(res.data.msg);
                            return;
                        }
                        this.$message.success('操作成功');
                        this.reassignBox = false;
                        this.$refs?.reassginform?.resetForm();
                        this.onLoad(this.page, this.query);

                        todoChangeNotify();
                        done()

                    }).catch(err => {
                        console.error(err);
                        done()
                    })
                }).catch(() => {
                    console.log('>>>>>>')
                    // this.$message.info('已取消操作');
                    done();
                });
            }
        },
        handleAction(row, index) {
             getAssigneeTree({
                taskId: row.taskId,
             }).then(res => {
      
                this.assigneeData = res.data.data;
                this.allAssigneeData = res.data.data;

                this.managerAssigneeData=[];
                //初始化数控管理员的数组
                for(var i=0;i<this.assigneeData.length;i++){
                    for(var j=0;j<this.assigneeData[i].children.length;j++){
                        if(this.assigneeData[i].children[j].nodeType=='manager'){
                            this.managerAssigneeData[this.managerAssigneeData.length] = this.assigneeData[i].children[j];
                        }
                    }
                }
                this.optionApprove.column[1].data = this.assigneeData;
                this.reassignOption.column[1].data = this.assigneeData;
            })
            this.formApprove = {
                comment: '',
                approve: 'Y', // 默认同
            }
            this.approveBox = true;
            this.row = row

            this.setAssignee(row, this.formApprove.approve);
            console.log('handleAction', row, index);
            this.setApproveBtn(row);
            //console.log('handleAction', row, index);
        },
        handleSubmit(form, done) {
            if(this.row.taskDefinitionKey === 'programmingTask') {
                // if(this.applist.length !== 1) {
                //     done();
                //     return this.$message.success('请选择1个程序');
                // }
        async handleSubmit(form, done) {

            let programOnMachine = 'N'
            let goApprove = true;
            if(this.row.taskDefinitionKey==='programmingTask' || this.row.taskDefinitionKey==='cureProgramTask'){
                programOnMachine = this.$refs.todolistLeft.programOnMachine?'Y':'N';

                let atts = this.$refs.todolistLeft.tableData;
                let otherFileCOunt = atts.filter(att => att.program === false).length;
                if(otherFileCOunt == 0){
                    let confirResult = await this.$confirm('文件列表中无其他文件，确认要提交吗？', '', {
                        confirmButtonText: this.$t('submitText'),
                        cancelButtonText: this.$t('cancelText'),
                        type: 'warning',
                    }).then(()=>{
                        goApprove = true;
                    }).catch(action => {
                        //取消操作
                        goApprove = false;
                    });

                }
                
            }
            if(goApprove == false){
                done();
                return;
            }

            approve({
                ...this.formApprove,
                taskId: this.row.taskId,
                processInstanceId: this.row.processInstanceId,
                // programIds: this.row.taskDefinitionKey === 'programmingTask' ? this.applist.map(v => v.id).join(',') : '',
                programOnMachine: programOnMachine
            }).then(res => {
                if(res.data.code !== 200) {
                    this.$message.error(res.data.msg);
@@ -447,6 +926,8 @@
                this.$message.success('审批成功');
                this.approveBox = false;
                this.onLoad(this.page, this.query);

                todoChangeNotify();//顶部待办数量刷新
                done();
            }).catch(err => {
                done();
@@ -457,26 +938,22 @@
            let data = {}
            this.query = params;
            this.page.currentPage = 1;
            /*
            console.log('searchChange', params);
            params.createTimeBegin = params?.processCreateTime?.[0] || '';
            params.createTimeEnd = params?.processCreateTime?.[1] || '';
            console.log(params);
            // data = {
            //     createTimeBegin: dayjs(params.createTimeBegin).isValid() ? dayjs(params.createTimeBegin).format('YYYY-MM-DD') : '',
            //     createTimeEnd: dayjs(params.createTimeEnd).isValid() ? dayjs(params.createTimeEnd).format('YYYY-MM-DD') : '',
            //     keyword: params.keyword || ''
            // }
            data = {
                createTimeBegin: params.createTimeBegin,
                createTimeEnd: params.createTimeEnd,
                keyword: params.keyword || ''
            }
            this.query = data
            this.onLoad(this.page, data);
            */
            this.onLoad(this.page, {});
            done();
        },
        searchReset() {
            this.query = {};
            this.query = this.defaultQuery;
            this.onLoad(this.page);
        },
        currentChange(currentPage) {
@@ -492,7 +969,6 @@
        onLoad(page, params = {}) {
            const query = {
                ...this.query,
                // category: params.category ? flowCategory(params.category) : null,
                mode: this.mode,
            };
            try {
@@ -500,7 +976,9 @@
            } catch (error) {
                console.error('日期格式化错误', error);
            }

             console.log('params',params);
            console.log('q',query);
            console.log('thisq',this.query);
            this.loading = true;
            getList(page.currentPage, page.pageSize, Object.assign(query, params)).then(res => {
                const data = res.data.data;
@@ -516,7 +994,19 @@
};
</script>

<style lang="scss">
.remark-drawer  {
    .el-drawer__header {
        padding-top:5px;
      margin-bottom: 0px !important;
    }
    .el-drawer__body{
        padding-top:5px;
    }
}
</style>
<style scoped="scoped" lang="scss">

.approve-box {
    display: flex;

@@ -525,11 +1015,12 @@
    }

    .left {
        width: 400px;
        width: 40%;
    }

    .right {
        flex: 1;
        padding: 0 10px;
    }
}
</style>