工作流代码

lyh

2 天以前 40bf019f0b348378385ed0a819b5b06e1708d558

 lxzn-module-eam/src/main/java/org/jeecg/modules/eam/service/impl/EamMaintenanceStandardServiceImpl.java

@@ -5,6 +5,7 @@
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@@ -23,6 +24,7 @@
import org.jeecg.modules.eam.constant.BusinessCodeConst;
import org.jeecg.modules.eam.constant.EamMaintenanceStandardDetailCategory;
import org.jeecg.modules.eam.constant.MaintenanceStandardStatusEnum;
import org.jeecg.modules.eam.constant.SecondMaintenanceStatusEnum;
import org.jeecg.modules.eam.entity.EamEquipment;
import org.jeecg.modules.eam.entity.EamEquipmentExtend;
import org.jeecg.modules.eam.entity.EamMaintenanceStandard;
@@ -39,6 +41,7 @@
import org.jeecg.modules.flowable.apithird.business.service.IFlowMyBusinessService;
import org.jeecg.modules.flowable.apithird.service.FlowCallBackServiceI;
import org.jeecg.modules.flowable.apithird.service.FlowCommonService;
import org.jeecg.modules.flowable.domain.vo.FlowTaskVo;
import org.jeecg.modules.flowable.service.IFlowDefinitionService;
import org.jeecg.modules.flowable.service.IFlowTaskService;
import org.jeecg.modules.system.entity.BaseFactory;
@@ -286,6 +289,7 @@
        queryWrapper.eq(EamMaintenanceStandard::getMaintenanceCategory, maintenanceCategory);
        queryWrapper.eq(EamMaintenanceStandard::getDelFlag, CommonConstant.DEL_FLAG_0);
        queryWrapper.ne(EamMaintenanceStandard::getStandardStatus, standardStatus);
        queryWrapper.ne(EamMaintenanceStandard::getStandardStatus,MaintenanceStandardStatusEnum.START.name());
        queryWrapper.orderByDesc(EamMaintenanceStandard::getStandardVersion);

        List<EamMaintenanceStandard> list = eamMaintenanceStandardMapper.selectList(queryWrapper);
@@ -323,201 +327,374 @@
        return eamMaintenanceStandardMapper.selectList(queryWrapper);
    }

    @Override
    public EamMaintenanceStandard queryByEquipmentIdAndCategory(String equipmentId, String maintenanceCategory) {
        LambdaQueryWrapper<EamMaintenanceStandard> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(EamMaintenanceStandard::getDelFlag, CommonConstant.DEL_FLAG_0);
        queryWrapper.eq(EamMaintenanceStandard::getMaintenanceCategory, maintenanceCategory);
        queryWrapper.eq(EamMaintenanceStandard::getStandardStatus, MaintenanceStandardStatusEnum.START.name());
        queryWrapper.eq(EamMaintenanceStandard::getEquipmentId, equipmentId);
        return eamMaintenanceStandardMapper.selectOne(queryWrapper);
    }


    /*流程业务代码--------------------------开始*/

    /**
     * 流程启动,保存对应的数据
     *
     * @param id
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> saveEamMaintenanceStandardProcess(String id) {
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        EamMaintenanceStandard maintenanceStandard = this.getById(id);
        if (maintenanceStandard == null) {
            return Result.error("未找到对应保养标准");
        // 获取当前登录用户
        LoginUser currentUser = getCurrentUser();

        // 校验保养标准是否存在
        EamMaintenanceStandard maintenanceStandard = validateStandardExistence(id);

        // 校验关联设备是否存在
        EamEquipment equipment = validateEquipmentExistence(maintenanceStandard.getEquipmentId());

        // 检查是否是驳回后重新提交的流程
        FlowMyBusiness flowBusiness = flowMyBusinessService.selectByDataId(maintenanceStandard.getId());

        if (isReSubmitScenario(flowBusiness)) {
            return handleReSubmitScenario(maintenanceStandard, equipment, currentUser, flowBusiness);
        }
        System.out.println("保养规范流程：" + maintenanceStandard.getId());
        flowCommonService.initActBusiness(maintenanceStandard.getStandardName() + "规范进行流程审核",
                maintenanceStandard.getId(), "IEamMaintenanceStandardService", "eam_maintenance_standard", null);
        Map<String, Object> variables = new HashMap<>();
        variables.put("dataId", maintenanceStandard.getId());
        variables.put("organization", "保养规范启动流程");
        variables.put("comment", "保养规范启动流程");
        variables.put("proofreading", true);
        Result result = flowDefinitionService.startProcessInstanceByKey("eam_maintenance_standard", variables);
        if (!result.isSuccess()) {
            super.removeById(maintenanceStandard.getId());
        } else {
            maintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_REPAIR_DIRECTOR.name());
            maintenanceStandard.setDesigner(user.getUsername());
            maintenanceStandard.setDesignTime(new Date());
            eamMaintenanceStandardMapper.updateById(maintenanceStandard);
            //获取flow的流程实例id,设置下一步的处理人员
            List<FlowMyBusiness> businessList = flowMyBusinessService.list(
                    new QueryWrapper<FlowMyBusiness>()
                            .eq("data_id", maintenanceStandard.getId())
            );
            if (businessList.isEmpty()) {
                return Result.error("流程记录不存在");
            }
            FlowMyBusiness flowMyBusiness = businessList.get(0);
            EamEquipment eamEquipment = eamEquipmentService.getById(maintenanceStandard.getEquipmentId());
            List<UserSelector> userSelectorList = sysUserService.selectOperatorList(eamEquipment.getEquipmentCode(), eamEquipment.getFactoryOrgCode(), BusinessCodeConst.PCR0008);
            if (!CollectionUtils.isEmpty(userSelectorList)) {
                List<String> usernameList = userSelectorList.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                flowMyBusiness.setTodoUsers(JSON.toJSONString(usernameList));
                flowMyBusinessService.updateById(flowMyBusiness);
            }

        // 处理首次启动流程
        return handleFirstSubmitScenario(maintenanceStandard, equipment, currentUser);
    }

    /**
     * 判断是否是驳回后重新提交的场景
     */
    private boolean isReSubmitScenario(FlowMyBusiness flowBusiness) {
        return flowBusiness != null &&
                MaintenanceStandardStatusEnum.WAIT_SUBMIT.name().equals(flowBusiness.getTaskNameId());
    }

    /**
     * 处理驳回后重新提交的流程
     */
    private Result<?> handleReSubmitScenario(EamMaintenanceStandard maintenanceStandard,
                                             EamEquipment equipment,
                                             LoginUser currentUser,
                                             FlowMyBusiness flowBusiness) {
        // 更新待办维修工
        updateTodoMaintenanceWorkers(flowBusiness, equipment);

        // 认领任务
        claimTaskOrFail(flowBusiness.getTaskId(), currentUser);

        // 构建流程变量
        Map<String, Object> variables = buildProcessVariables(maintenanceStandard.getId(), "保养规范再次启动流程");

        // 设置下一级审批人(维修室主任)
        setNextApprover(variables, equipment, BusinessCodeConst.PCR0008, "维修室主任");

        // 完成当前任务，推进流程
        FlowTaskVo taskVo = buildFlowTaskVo(flowBusiness, maintenanceStandard, variables, "保养规范再次启动流程");
        Result result = flowTaskService.complete(taskVo);

        // 更新保养标准状态
        if (result.isSuccess()) {
            updateMaintenanceStandardStatus(maintenanceStandard, currentUser, MaintenanceStandardStatusEnum.WAIT_REPAIR_DIRECTOR);
            return Result.ok("保养规范流程重启成功");
        }

        return result;
    }

    /**
     * 审批操作
     *
     * @param eamMaintenanceStandardVo
     * @return
     * 处理首次提交的流程
     */
    private Result<?> handleFirstSubmitScenario(EamMaintenanceStandard maintenanceStandard,
                                                EamEquipment equipment,
                                                LoginUser currentUser) {
        // 初始化流程业务信息
        flowCommonService.initActBusiness(
                maintenanceStandard.getStandardName() + "规范进行流程审核",
                maintenanceStandard.getId(),
                "IEamMaintenanceStandardService",
                "eam_maintenance_standard",
                null
        );

        // 构建流程变量
        Map<String, Object> variables = buildProcessVariables(maintenanceStandard.getId(), "保养规范启动流程");

        // 设置下一级审批人(维修室主任)
        setNextApprover(variables, equipment, BusinessCodeConst.PCR0008, "维修室主任");

        // 启动流程实例
        Result result = flowDefinitionService.startProcessInstanceByKey("eam_maintenance_standard", variables);

        // 处理流程启动结果
        if (result.isSuccess()) {
            updateMaintenanceStandardStatus(maintenanceStandard, currentUser, MaintenanceStandardStatusEnum.WAIT_REPAIR_DIRECTOR);
            validateFlowBusinessRecord(maintenanceStandard.getId());
        } else {
            this.removeById(maintenanceStandard.getId());
        }

        return result;
    }

    /**
            * 审批操作
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> auditEamMaintenanceStandard(EamMaintenanceStandardVo eamMaintenanceStandardVo) {
        try {
            // 参数校验
            if (StrUtil.isEmpty(eamMaintenanceStandardVo.getTaskId()) || StrUtil.isEmpty(eamMaintenanceStandardVo.getDataId())) {
                return Result.error("参数错误");
            }
            LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
            String userId = user.getId();
            eamMaintenanceStandardVo.setAssignee(user.getUsername());
            if (StrUtil.isEmpty(userId)) {
                return Result.error("未找到对应用户");
            }
    public Result<?> auditEamMaintenanceStandard(EamMaintenanceStandardVo vo) {
        // 基础校验
        EamMaintenanceStandard standard = validateStandardExistence(vo.getDataId());
        LoginUser user = getCurrentUser();
        FlowMyBusiness business = validateFlowBusiness(vo);
        validateUserAuthorization(business, user);
        claimTaskOrFail(business.getTaskId(), user);

            // 数据查询
            EamMaintenanceStandard eamMaintenanceStandard = this.getById(eamMaintenanceStandardVo.getDataId());
            if (eamMaintenanceStandard == null) {
                return Result.error("未找到对应保养标准");
            }
        // 准备审批所需数据
        EamEquipment equipment = validateEquipmentExistence(standard.getEquipmentId());
        Map<String, Object> variables = new HashMap<>();

            // 2. 查询流程业务记录（处理空结果）
            List<FlowMyBusiness> businessList = flowMyBusinessService.list(
                    new QueryWrapper<FlowMyBusiness>()
                            .eq("process_instance_id", eamMaintenanceStandardVo.getInstanceId())
            );
            if (businessList.isEmpty()) {
                return Result.error("流程记录不存在");
            }
            FlowMyBusiness flowMyBusiness = businessList.get(0);
        // 根据当前状态处理审批
        MaintenanceStandardStatusEnum status = MaintenanceStandardStatusEnum.getInstance(standard.getStandardStatus());
        if (status == null) {
            throw new JeecgBootException("无效的保养标准状态");
        }

            // 3. 校验用户是否为候选处理人
            List<String> todoUsers = JSON.parseArray(flowMyBusiness.getTodoUsers(), String.class);
            if (todoUsers == null || !todoUsers.contains(user.getUsername())) {
                return Result.error("用户无权操作此任务");
            }
        switch (status) {
            case WAIT_REPAIR_DIRECTOR:
                handleRepairDirectorApproval(vo, standard, equipment, variables);
                break;
            case WAIT_TECHNICAL_DIRECTOR:
                handleTechnicalDirectorApproval(vo, standard, equipment, variables);
                break;
            default:
                throw new JeecgBootException("当前状态不支持审批操作");
        }

            // 4. 认领任务（处理已被认领的情况）
            String taskId = flowMyBusiness.getTaskId();
            Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
            if (task == null) {
                return Result.error("任务不存在或已完成");
            }
            if (task.getAssignee() != null && !task.getAssignee().equals(user.getUsername())) {
                return Result.error("任务已被他人认领");
            }
            taskService.claim(taskId, user.getUsername());
        // 提交审批结果
        submitApprovalResult(vo, standard, variables);
        return Result.OK("操作成功");
    }

            // 设置流程变量
            Map<String, Object> values = setProcessVariables(eamMaintenanceStandard, userId, eamMaintenanceStandardVo);
            eamMaintenanceStandardVo.setValues(values);
            eamMaintenanceStandardVo.setComment(values.get("comment").toString());
            // 完成流程任务
            Result result = flowTaskService.complete(eamMaintenanceStandardVo);
            if (result.isSuccess()) {
                if (eamMaintenanceStandardVo.getRepairManagerApproveResult() != null) {
                    if ("2".equals(eamMaintenanceStandard.getRepairManagerApproveResult())) {
                        eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.REJECTED.name());
                    }
                    if (eamMaintenanceStandardVo.getRepairManagerApproveResult().equals("1")) {
                        List<FlowMyBusiness> newbusinessList = flowMyBusinessService.list(
                                new QueryWrapper<FlowMyBusiness>()
                                        .eq("process_instance_id", eamMaintenanceStandardVo.getInstanceId()));
                        FlowMyBusiness newflowMyBusiness = newbusinessList.get(0);
                        eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_TECHNICAL_DIRECTOR.name());
                        //获取flow的流程实例id,设置下一步的处理人员
                        EamMaintenanceStandard maintenanceStandard = this.getById(eamMaintenanceStandardVo.getDataId());
                        EamEquipment eamEquipment = eamEquipmentService.getById(maintenanceStandard.getEquipmentId());
                        List<UserSelector> userSelectorList = sysUserService.selectOperatorList(eamEquipment.getEquipmentCode(), eamEquipment.getFactoryOrgCode(), BusinessCodeConst.PCR0009);
                        if (!CollectionUtils.isEmpty(userSelectorList)) {
                            List<String> usernameList = userSelectorList.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                            newflowMyBusiness.setTodoUsers(JSON.toJSONString(usernameList));
                            flowMyBusinessService.updateById(newflowMyBusiness);
                        }else {
                            throw new JeecgBootException("设备未存在管理员，无法进入下级审批！");
                        }
                    } else {
                        eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
                    }
                    eamMaintenanceStandard.setRepairManager(user.getUsername());
                    eamMaintenanceStandard.setRepairManagerApproveResult(eamMaintenanceStandardVo.getRepairManagerApproveResult());
                    eamMaintenanceStandard.setRepairManagerApproveTime(new Date());
                    eamMaintenanceStandard.setRepairManagerApproveComment(eamMaintenanceStandardVo.getComment());
                }
                if (eamMaintenanceStandardVo.getTechnicalManagerApproveResult() != null) {
                    if ("2".equals(eamMaintenanceStandard.getTechnicalManagerApproveResult())) {
                        eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.REJECTED.name());
                    }
                    if (eamMaintenanceStandardVo.getTechnicalManagerApproveResult().equals("1")) {
                        eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.START.name());
                        //判断是否进行升版，通过设备编号、保养分类、状态进行筛选
                        EamMaintenanceStandard maintenanceStandard = this.getById(eamMaintenanceStandardVo.getDataId());
                        QueryWrapper<EamMaintenanceStandard> queryWrapper = new QueryWrapper<>();
                        queryWrapper.eq("equipment_id", maintenanceStandard.getEquipmentId());
                        queryWrapper.eq("maintenance_category", maintenanceStandard.getMaintenanceCategory());
                        queryWrapper.eq("standard_status", MaintenanceStandardStatusEnum.START.name());
                        List<EamMaintenanceStandard> list = eamMaintenanceStandardMapper.selectList(queryWrapper);
                        if (!CollectionUtils.isEmpty(list)) {
                            //作废原有
                            for (EamMaintenanceStandard eamMaintenanceStandard1 : list) {
                                eamMaintenanceStandard1.setStandardStatus(MaintenanceStandardStatusEnum.ABOLISH.name());
                                this.updateById(eamMaintenanceStandard1);
                            }
                        }
                    } else {
                        eamMaintenanceStandard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
                    }
                    eamMaintenanceStandard.setTechnicalManager(user.getUsername());
                    eamMaintenanceStandard.setTechnicalManagerApproveResult(eamMaintenanceStandardVo.getTechnicalManagerApproveResult());
                    eamMaintenanceStandard.setTechnicalManagerApproveTime(new Date());
                    eamMaintenanceStandard.setTechnicalManagerApproveComment(eamMaintenanceStandardVo.getComment());
                }
                this.updateById(eamMaintenanceStandard);
            } else {
                return result;
            }
            return Result.OK("操作成功");
        } catch (Exception e) {
            return Result.error("操作失败：" + e.getMessage());

    private LoginUser getCurrentUser() {
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        if (user == null) {
            throw new JeecgBootException("未获取到登录用户，请重新登录后再试！");
        }
        return user;
    }

    private EamMaintenanceStandard validateStandardExistence(String id) {
        EamMaintenanceStandard standard = this.getById(id);
        if (standard == null) {
            throw new JeecgBootException("未找到对应保养标准");
        }
        return standard;
    }

    private EamEquipment validateEquipmentExistence(String equipmentId) {
        EamEquipment equipment = eamEquipmentService.getById(equipmentId);
        if (equipment == null) {
            throw new JeecgBootException("关联设备不存在");
        }
        return equipment;
    }

    private FlowMyBusiness validateFlowBusiness(EamMaintenanceStandardVo vo) {
        FlowMyBusiness business = flowMyBusinessService.getFlowMyBusiness(vo.getInstanceId(), vo.getTaskId());
        if (business == null) {
            throw new JeecgBootException("流程实例不存在，请刷新重试");
        }
        return business;
    }

    private void validateUserAuthorization(FlowMyBusiness business, LoginUser user) {
        List<String> todoUsers = JSON.parseArray(business.getTodoUsers(), String.class);
        if (todoUsers == null || !todoUsers.contains(user.getUsername())) {
            throw new JeecgBootException("用户无权操作此任务");
        }
    }

    private Map<String, Object> setProcessVariables(EamMaintenanceStandard eamMaintenanceStandard, String userId, EamMaintenanceStandardVo eamMaintenanceStandardVo) {
        Map<String, Object> values = new HashMap<>();
        values.put("dataId", eamMaintenanceStandard.getId());
        values.put("assignee", userId);
        if (eamMaintenanceStandardVo.getRepairManagerApproveResult() != null) {
            values.put("repairManagerApproveResult", eamMaintenanceStandardVo.getRepairManagerApproveResult());
            values.put("organization", eamMaintenanceStandardVo.getRepairManagerApproveComment());
            values.put("comment", eamMaintenanceStandardVo.getRepairManagerApproveComment());
    private void claimTaskOrFail(String taskId, LoginUser user) {
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if (task == null) {
            throw new JeecgBootException("任务不存在或已完成");
        }
        if (eamMaintenanceStandardVo.getTechnicalManagerApproveResult() != null) {
            values.put("technicalManagerApproveResult", eamMaintenanceStandardVo.getTechnicalManagerApproveResult());
            values.put("organization", eamMaintenanceStandardVo.getTechnicalManagerApproveComment());
            values.put("comment", eamMaintenanceStandardVo.getTechnicalManagerApproveComment());
        if (task.getAssignee() != null && !task.getAssignee().equals(user.getUsername())) {
            throw new JeecgBootException("任务已被他人认领");
        }
        return values;
        taskService.claim(taskId, user.getUsername());
    }

    private Map<String, Object> buildProcessVariables(String dataId, String comment) {
        Map<String, Object> vars = new HashMap<>();
        vars.put("dataId", dataId);
        vars.put("organization", comment);
        vars.put("comment", comment);
        vars.put("proofreading", true);
        return vars;
    }

    private void setNextApprover(Map<String, Object> variables, EamEquipment equipment,
                                 String businessCode, String roleName) {
        List<UserSelector> approvers = sysUserService.selectOperatorList(
                equipment.getEquipmentCode(),
                equipment.getFactoryOrgCode(),
                businessCode
        );
        if (CollectionUtils.isEmpty(approvers)) {
            throw new JeecgBootException("设备未配置" + roleName);
        }
        variables.put("NextAssignee", approvers.stream()
                .map(UserSelector::getUsername)
                .collect(Collectors.toList()));
    }

    private void updateTodoMaintenanceWorkers(FlowMyBusiness business, EamEquipment equipment) {
        List<UserSelector> maintenanceWorkers = sysUserService.selectOperatorList(
                equipment.getEquipmentCode(),
                equipment.getFactoryOrgCode(),
                BusinessCodeConst.PCR0002
        );
        if (CollectionUtils.isEmpty(maintenanceWorkers)) {
            throw new JeecgBootException("设备未配置维修工");
        }
        business.setTodoUsers(JSON.toJSONString(
                maintenanceWorkers.stream()
                        .map(UserSelector::getUsername)
                        .collect(Collectors.toList())
        ));
        flowMyBusinessService.updateById(business);
    }

    private FlowTaskVo buildFlowTaskVo(FlowMyBusiness business, EamMaintenanceStandard standard,
                                       Map<String, Object> variables, String comment) {
        FlowTaskVo taskVo = new FlowTaskVo();
        taskVo.setTaskId(business.getTaskId());
        taskVo.setComment(comment);
        taskVo.setInstanceId(business.getProcessInstanceId());
        taskVo.setDataId(standard.getId());
        taskVo.setValues(variables);
        return taskVo;
    }

    private void updateMaintenanceStandardStatus(EamMaintenanceStandard standard,
                                                 LoginUser user,
                                                 MaintenanceStandardStatusEnum status) {
        standard.setStandardStatus(status.name());
        if (MaintenanceStandardStatusEnum.WAIT_REPAIR_DIRECTOR.equals(status)) {
            standard.setDesigner(user.getUsername());
            standard.setDesignTime(new Date());
        }
        this.updateById(standard);
    }

    private void validateFlowBusinessRecord(String standardId) {
        List<FlowMyBusiness> businessList = flowMyBusinessService.list(
                new QueryWrapper<FlowMyBusiness>().eq("data_id", standardId)
        );
        if (CollectionUtils.isEmpty(businessList)) {
            throw new JeecgBootException("流程记录不存在");
        }
    }

    private void handleRepairDirectorApproval(EamMaintenanceStandardVo vo,
                                              EamMaintenanceStandard standard,
                                              EamEquipment equipment,
                                              Map<String, Object> variables) {
        // 设置基础流程变量
        variables.putAll(buildProcessVariables(standard.getId(),
                StrUtil.blankToDefault(vo.getRepairManagerApproveComment(), "")));
        variables.put("repairManagerApproveResult", vo.getRepairManagerApproveResult());

        LoginUser user = getCurrentUser();
        vo.setAssignee(user.getUsername());
        vo.setComment(vo.getRepairManagerApproveComment());
        if ("2".equals(vo.getRepairManagerApproveResult())) {
            // 驳回
            UpdateWrapper<EamMaintenanceStandard> updateWrapper = new UpdateWrapper<>();
            updateWrapper.eq("id", standard.getId());
            updateWrapper.set("standard_status", MaintenanceStandardStatusEnum.WAIT_SUBMIT.name());
            updateWrapper.set("designer", null);
            updateWrapper.set("design_time", null);
            this.update(updateWrapper);
        } else {
            // 通过
            setNextApprover(variables, equipment, BusinessCodeConst.PCR0009, "生产设备技术主管");
            standard.setRepairManager(user.getUsername());
            standard.setRepairManagerApproveResult(vo.getRepairManagerApproveResult());
            standard.setRepairManagerApproveTime(new Date());
            standard.setRepairManagerApproveComment(vo.getRepairManagerApproveComment());
            standard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_TECHNICAL_DIRECTOR.name());
        }
    }

    private void handleTechnicalDirectorApproval(EamMaintenanceStandardVo vo,
                                                 EamMaintenanceStandard standard,
                                                 EamEquipment equipment,
                                                 Map<String, Object> variables) {
        // 设置基础流程变量
        variables.putAll(buildProcessVariables(standard.getId(),
                StrUtil.blankToDefault(vo.getTechnicalManagerApproveComment(), "")));
        variables.put("technicalManagerApproveResult", vo.getTechnicalManagerApproveResult());

        LoginUser user = getCurrentUser();
        vo.setAssignee(user.getUsername());
        vo.setComment(vo.getTechnicalManagerApproveComment());
        if ("2".equals(vo.getTechnicalManagerApproveResult())) {
            // 驳回
            standard.setStandardStatus(MaintenanceStandardStatusEnum.WAIT_REPAIR_DIRECTOR.name());
            standard.setRepairManager(null);
            standard.setRepairManagerApproveResult(null);
            standard.setRepairManagerApproveTime(null);
            standard.setRepairManagerApproveComment(null);
            setNextApprover(variables, equipment, BusinessCodeConst.PCR0008, "维修室主任");
        } else {
            // 通过
            standard.setTechnicalManager(user.getUsername());
            standard.setTechnicalManagerApproveResult(vo.getTechnicalManagerApproveResult());
            standard.setTechnicalManagerApproveTime(new Date());
            standard.setTechnicalManagerApproveComment(vo.getTechnicalManagerApproveComment());
            standard.setStandardStatus(MaintenanceStandardStatusEnum.START.name());
        }
    }

    private void submitApprovalResult(EamMaintenanceStandardVo vo,
                                      EamMaintenanceStandard standard,
                                      Map<String, Object> variables) {
        vo.setValues(variables);
        Result result = flowTaskService.complete(vo);
        if (!result.isSuccess()) {
            throw new JeecgBootException("审批流程提交失败: " + result.getMessage());
        }

        // 更新保养标准
        this.updateById(standard);

        // 技术主管审批通过后，作废旧版本
        if (MaintenanceStandardStatusEnum.WAIT_TECHNICAL_DIRECTOR.name().equals(standard.getStandardStatus())
                && "1".equals(vo.getTechnicalManagerApproveResult())) {
            abolishPreviousStandards(standard);
        }
    }

    private void abolishPreviousStandards(EamMaintenanceStandard current) {
        List<EamMaintenanceStandard> previous = eamMaintenanceStandardMapper.selectList(
                new QueryWrapper<EamMaintenanceStandard>()
                        .ne("id", current.getId())
                        .eq("equipment_id", current.getEquipmentId())
                        .eq("maintenance_category", current.getMaintenanceCategory())
                        .eq("standard_status", MaintenanceStandardStatusEnum.START.name())
        );

        if (!CollectionUtils.isEmpty(previous)) {
            previous.forEach(standard -> {
                standard.setStandardStatus(MaintenanceStandardStatusEnum.ABOLISH.name());
            });
            this.updateBatchById(previous);
        }
    }


@@ -540,8 +717,9 @@

    @Override
    public List<String> flowCandidateUsernamesOfTask(String taskNameId, Map<String, Object> values) {
        //业务是否干预流程，业务干预，流程干预，指定人员进行处理
        return null;
        //获取下一步处理人
        Object object = values.get("NextAssignee");
        return (List<String>) object;
    }

    /*流程业务代码--------------------------结束*/
@@ -554,7 +732,11 @@
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> importPointInspectionExcel(MultipartFile file) {
    public Result<?> importPointInspectionExcel(MultipartFile file,String id) {
        EamMaintenanceStandard eamMaintenanceStandardOld=new EamMaintenanceStandard();
        if (StrUtil.isNotEmpty(id)){
            eamMaintenanceStandardOld=eamMaintenanceStandardMapper.selectById(id);
        }
        try (Workbook workbook = WorkbookFactory.create(file.getInputStream())) {
            Sheet sheet = workbook.getSheetAt(0);

@@ -569,11 +751,56 @@

            eamMaintenanceStandard.setStandardName(name);

            // 检查重复
            EamMaintenanceStandard exist = checkDuplicate(eamMaintenanceStandard.getEquipmentId(),
                    eamMaintenanceStandard.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name());
            if (exist != null) {
                return Result.error(name + ": 设备标准已存在，不能重复添加");
            // 检查重复,只导入校验，升版不校验
            if (StrUtil.isEmpty(id)){
                EamMaintenanceStandard exist = checkDuplicate(eamMaintenanceStandard.getEquipmentId(),
                        eamMaintenanceStandard.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name());
                if (exist != null) {
                    return Result.error(name + ": 设备标准已存在，不能重复添加");
                }
            }
            if (StrUtil.isNotEmpty(id)){
                if (eamMaintenanceStandardOld.getEquipmentId().equals(eamMaintenanceStandard.getEquipmentId())
                        &&eamMaintenanceStandardOld.getMaintenanceCategory().equals(eamMaintenanceStandard.getMaintenanceCategory())) {
                    //判断是否现有待提交数据
                    EamMaintenanceStandard maintenanceStandard=eamMaintenanceStandardMapper.selectOne(
                            new QueryWrapper<EamMaintenanceStandard>().eq("equipment_id",eamMaintenanceStandard.getEquipmentId())
                                    .eq("maintenance_category",eamMaintenanceStandard.getMaintenanceCategory())
                                    .eq("standard_status",MaintenanceStandardStatusEnum.WAIT_SUBMIT.name())
                                    .eq("del_flag", CommonConstant.DEL_FLAG_0));
                    if (maintenanceStandard != null) {
                        //删除原有待提交
                        eamMaintenanceStandardMapper.deleteById(maintenanceStandard.getId());
                    }
                    //查询在流程中的数据
                    List<EamMaintenanceStandard> eamMaintenanceStandardList=eamMaintenanceStandardMapper.selectList(
                            new QueryWrapper<EamMaintenanceStandard>().eq("equipment_id",eamMaintenanceStandard.getEquipmentId())
                                    .eq("maintenance_category",eamMaintenanceStandard.getMaintenanceCategory())
                                    .eq("del_flag", CommonConstant.DEL_FLAG_0)
                                    .and(i->i.
                                            eq("standard_status",MaintenanceStandardStatusEnum.WAIT_REPAIR_DIRECTOR.name())
                                            .or()
                                            .eq("standard_status",MaintenanceStandardStatusEnum.WAIT_TECHNICAL_DIRECTOR.name())
                    ));
                    if (!eamMaintenanceStandardList.isEmpty()) {
                        return Result.error("已存在处于审批流程的数据，请删除或结束后进行升版导入操作");
                    }
                    //升版操作，作废原有
                    eamMaintenanceStandardOld.setStandardStatus(MaintenanceStandardStatusEnum.ABOLISH.name());
                    eamMaintenanceStandardMapper.updateById(eamMaintenanceStandardOld);
                    //版本递增获取数字
                    Pattern pattern = Pattern.compile("(\\d+)(?:\\.\\d+)*$");
                    Matcher matcher = pattern.matcher(eamMaintenanceStandardOld.getStandardVersion());
                    if (matcher.find()) {
                        try {
                            int mainVersion = Integer.parseInt(matcher.group(1));
                            eamMaintenanceStandard.setStandardVersion("v" + (mainVersion + 1));
                        } catch (NumberFormatException ignored) {
                        }
                    }
                }else {
                    return Result.error("升版导入的文件与原有数据的设备编号不一致,请重新编辑导入文件");
                }
            }
            eamMaintenanceStandard.setInitialDate(new Date());
            eamMaintenanceStandardMapper.insert(eamMaintenanceStandard);
@@ -1086,7 +1313,7 @@
     */
    @Override
    @Transactional
    public Result<?> importMaintenanceStandard(MultipartFile file, String type) {
    public Result<?> importMaintenanceStandard(MultipartFile file, String type,String id) {
        String fileName = file.getOriginalFilename();

        try (XWPFDocument doc = new XWPFDocument(file.getInputStream())) {
@@ -1132,11 +1359,62 @@
                        return Result.error(fileName + ": 设备信息提取失败");
                    }

                    EamMaintenanceStandard eamMaintenanceStandardOld=new EamMaintenanceStandard();
                    if (StrUtil.isNotEmpty(id)){
                        eamMaintenanceStandardOld=eamMaintenanceStandardMapper.selectById(id);
                    }

                    // 配置类型相关参数
                    configureStandard(standard, type, file);
                    EamMaintenanceStandard exist = checkDuplicate(standard.getEquipmentId(), standard.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name());
                    if (exist != null) {
                        return Result.error(fileName + ": 设备标准已存在，不能重复添加");
                    if (StrUtil.isEmpty(id)){
                        EamMaintenanceStandard exist = checkDuplicate(standard.getEquipmentId(), standard.getMaintenanceCategory(), MaintenanceStandardStatusEnum.ABOLISH.name());
                        if (exist != null) {
                            return Result.error(fileName + ": 设备标准已存在，不能重复添加");
                        }
                    }

                    if (StrUtil.isNotEmpty(id)){
                        if (eamMaintenanceStandardOld.getEquipmentId().equals(standard.getEquipmentId())
                                &&eamMaintenanceStandardOld.getMaintenanceCategory().equals(standard.getMaintenanceCategory())) {
                            //判断是否现有待提交数据
                            EamMaintenanceStandard maintenanceStandard=eamMaintenanceStandardMapper.selectOne(
                                    new QueryWrapper<EamMaintenanceStandard>().eq("equipment_id",standard.getEquipmentId())
                                            .eq("maintenance_category",standard.getMaintenanceCategory())
                                            .eq("standard_status",MaintenanceStandardStatusEnum.WAIT_SUBMIT.name())
                                            .eq("del_flag", CommonConstant.DEL_FLAG_0));
                            if (maintenanceStandard != null) {
                                //删除原有待提交
                                eamMaintenanceStandardMapper.deleteById(maintenanceStandard.getId());
                            }
                            //查询在流程中的数据
                            List<EamMaintenanceStandard> eamMaintenanceStandardList=eamMaintenanceStandardMapper.selectList(
                                    new QueryWrapper<EamMaintenanceStandard>().eq("equipment_id",standard.getEquipmentId())
                                            .eq("maintenance_category",standard.getMaintenanceCategory())
                                            .eq("del_flag", CommonConstant.DEL_FLAG_0)
                                            .and(it->it.
                                                    eq("standard_status",MaintenanceStandardStatusEnum.WAIT_REPAIR_DIRECTOR.name())
                                                    .or()
                                                    .eq("standard_status",MaintenanceStandardStatusEnum.WAIT_TECHNICAL_DIRECTOR.name())
                                            ));
                            if (!eamMaintenanceStandardList.isEmpty()) {
                                return Result.error("已存在处于审批流程的数据，请删除或结束后进行升版导入操作");
                            }
                            //升版操作，作废原有
                            eamMaintenanceStandardOld.setStandardStatus(MaintenanceStandardStatusEnum.ABOLISH.name());
                            eamMaintenanceStandardMapper.updateById(eamMaintenanceStandardOld);
                            //版本递增获取数字
                            Pattern pattern = Pattern.compile("(\\d+)(?:\\.\\d+)*$");
                            Matcher matcher = pattern.matcher(eamMaintenanceStandardOld.getStandardVersion());
                            if (matcher.find()) {
                                try {
                                    int mainVersion = Integer.parseInt(matcher.group(1));
                                    standard.setStandardVersion("v" + (mainVersion + 1));
                                } catch (NumberFormatException ignored) {
                                }
                            }
                        }else {
                            return Result.error("升版导入的文件与原有数据的设备编号不一致,请重新编辑导入文件");
                        }
                    }
                    standard.setStandardName(documentTitle);
                    eamMaintenanceStandardMapper.insert(standard);