art: 技术状态鉴定工单-审批接口

zhangherong

2025-07-11 44a7e1614ac9894d65ff1159fd7d7747b0f19922

art: 技术状态鉴定工单-审批接口

 db/430É豸¹ÜÀíÊý¾Ý¿âÉè¼Æ.pdma.json

@@ -4,7 +4,7 @@
  "avatar": "",
  "version": "4.9.2",
  "createdTime": "2025-3-10 16:38:19",
  "updatedTime": "2025-7-10 20:07:59",
  "updatedTime": "2025-7-11 19:36:02",
  "dbConns": [],
  "profile": {
    "default": {
@@ -24869,7 +24869,7 @@
          "id": "7C33F96F-F828-4A60-AA98-8847020EF388"
        },
        {
          "defKey": "safety_check_result",
          "defKey": "safety_check_confirm_result",
          "defName": "安全装置检查确认结果",
          "comment": "",
          "type": "",
@@ -24887,7 +24887,7 @@
          "id": "699E6979-B91F-4471-8DE7-A527AD2C82B7"
        },
        {
          "defKey": "safety_check_comment",
          "defKey": "safety_check_confirm_comment",
          "defName": "安全装置检查确认意见",
          "comment": "",
          "type": "",

 lxzn-module-eam-common/src/main/java/org/jeecg/modules/eam/constant/BusinessCodeConst.java

@@ -62,18 +62,24 @@
    String PCR0001 = "PCR0001";
    //维修工
    String PCR0002 = "PCR0002";
    //班组长
    //设备检验员
    String PCR0003 = "PCR0003";
    //设备管理员
    //车间设备管理员
    String PCR0004 = "PCR0004";
    //设备能源部
    String PCR0005 = "PCR0005";
    //机动办管理员
    //生产保障部
    String PCR0006 = "PCR0006";
    //备件管理员
    //工艺员
    String PCR0007 = "PCR0007";
    //维修室主任
    String PCR0008 = "PCR0008";
    //技术主管
    //生产设备技术主管
    String PCR0009 = "PCR0009";
    //使用车间技术主管
    String PCR0010 = "PCR0010";

    //通过、驳回
    String APPROVED = "1";
    String REJECTED = "2";
}

 lxzn-module-eam-common/src/main/java/org/jeecg/modules/eam/constant/TechnicalStatusEvaluationOrderStatusEnum.java

@@ -13,4 +13,14 @@
    CHANGING, //变更中
    EXPIRED, //已过期
    ;

    public static TechnicalStatusEvaluationOrderStatusEnum getInstance(String code) {
        TechnicalStatusEvaluationOrderStatusEnum[] values = TechnicalStatusEvaluationOrderStatusEnum.values();
        for (TechnicalStatusEvaluationOrderStatusEnum value : values) {
            if (value.name().equals(code)) {
                return value;
            }
        }
        return null;
    }
}

 lxzn-module-eam/src/main/java/org/jeecg/modules/eam/controller/EamTechnicalStatusEvaluationOrderController.java

@@ -1,6 +1,7 @@
package org.jeecg.modules.eam.controller;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import io.swagger.annotations.Api;
@@ -88,6 +89,29 @@
        return Result.OK("领取成功!");
    }

    /**
     * æˆ‘的待办，审批动作
     *
     * @param request
     * @return
     */
    @ApiOperation(value = "技术状态鉴定工单-执行操作", notes = "技术状态鉴定工单-执行操作")
    @PutMapping(value = "/approval")
    public Result<?> approval(@RequestBody EamTechnicalStatusEvaluationOrderRequest request) {
        if (request == null) {
            return Result.error("审批的对象不能为空！");
        }
        // æ£€æŸ¥è¯·æ±‚参数
        if (StrUtil.isBlank(request.getTaskId()) || StrUtil.isBlank(request.getDataId()) || StrUtil.isBlank(request.getInstanceId())) {
            return Result.error("审批任务错误或不存在！");
        }
        EamTechnicalStatusEvaluationOrder entity = eamTechnicalStatusEvaluationOrderService.approval(request);
        if (entity == null) {
            return Result.error("操作失败！");
        }
        return Result.ok("操作成功！");
    }


    /**
     * é€šè¿‡id查询

 lxzn-module-eam/src/main/java/org/jeecg/modules/eam/entity/EamTechnicalStatusEvaluationOrder.java

@@ -113,10 +113,10 @@
    /**安全装置检查确认结果*/
    @ApiModelProperty(value = "安全装置检查确认结果")
    @Dict(dicCode = "approved_rejected")
    private String safetyCheckResult;
    private String safetyCheckConfirmResult;
    /**安全装置检查确认意见*/
    @ApiModelProperty(value = "安全装置检查确认意见")
    private String safetyCheckComment;
    private String safetyCheckConfirmComment;
    /**设备精度检查确认人*/
    @ApiModelProperty(value = "设备精度检查确认人")
    @Dict(dicCode = "sys_user, realname, username")

 lxzn-module-eam/src/main/java/org/jeecg/modules/eam/request/EamTechnicalStatusEvaluationOrderRequest.java

@@ -6,6 +6,7 @@
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import org.jeecg.common.aspect.annotation.Dict;
import org.jeecg.modules.eam.entity.EamTechnicalStatusEvaluationOrderDetail;
import org.jeecg.modules.flowable.domain.vo.FlowTaskVo;
import org.springframework.format.annotation.DateTimeFormat;
@@ -50,6 +51,26 @@
    private List<EamTechnicalStatusEvaluationOrderDetail> tableDetailList;

    //审批操作
    //维修室主任确认
    /**安全装置检查确认结果*/
    @ApiModelProperty(value = "安全装置检查确认结果")
    private String safetyCheckConfirmResult;
    /**安全装置检查确认意见*/
    @ApiModelProperty(value = "安全装置检查确认意见")
    private String safetyCheckConfirmComment;
    /**设备精度检查确认结果*/
    @ApiModelProperty(value = "设备精度检查确认结果")
    private String precisionCheckConfirmResult;
    /**设备精度检查确认意见*/
    @ApiModelProperty(value = "设备精度检查确认意见")
    private String precisionCheckConfirmComment;
    /**其他检查确认结果*/
    @ApiModelProperty(value = "其他检查确认结果")
    private String otherCheckConfirmResult;
    /**其他检查确认意见*/
    @ApiModelProperty(value = "其他检查确认意见")
    private String otherCheckConfirmComment;
    //维修工签字
    /**安全装置检查结果;是、否*/
    @ApiModelProperty(value = "安全装置检查结果;是、否")
    private String safetyEquipmentCheckResult;
@@ -62,13 +83,35 @@
    /**其他检查结果;是、否、无*/
    @ApiModelProperty(value = "其他检查结果;是、否、无")
    private String otherCheckResult;
    //维修室主任签字
    /**维修室主任签字结果*/
    @ApiModelProperty(value = "维修室主任签字结果")
    private String repairManagerSignatureResult;
    /**维修室主任意见*/
    @ApiModelProperty(value = "维修室主任意见")
    private String repairManagerComment;
    //工艺员签字
    /**试件检查结果;合格、不合格*/
    @ApiModelProperty(value = "试件检查结果;合格、不合格")
    private String sampleCheckResult;
    /**工艺员意见*/
    @ApiModelProperty(value = "工艺员意见")
    private String processTechnicianComment;
    //使用单位技术主管签字
    /**使用单位技术主管签字结果*/
    @ApiModelProperty(value = "使用单位技术主管签字结果")
    private String departTechnicalLeaderSignatureResult;
    /**使用单位技术主管意见*/
    @ApiModelProperty(value = "使用单位技术主管意见")
    private String departTechnicalLeaderComment;
    //设备检验员签字
    /**鉴定结果;合格、限用、禁用*/
    @ApiModelProperty(value = "鉴定结果;合格、限用、禁用")
    private String evaluationResult;
    /**限\禁用原因(多选);安全装置、设备功能、精度、试件、其他*/
    @ApiModelProperty(value = "限/禁用原因(多选);安全装置、设备功能、精度、试件、其他")
    private String evaluationReason;
    /**设备检查人意见*/
    @ApiModelProperty(value = "设备检查人意见")
    private String inspectorComment;
}

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

@@ -36,4 +36,11 @@
     * @return
     */
    boolean collect(String id);

    /**
     * å®¡æ‰¹æµç¨‹
     * @param request
     * @return
     */
    EamTechnicalStatusEvaluationOrder approval(EamTechnicalStatusEvaluationOrderRequest request);
}

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

@@ -21,10 +21,7 @@
import org.jeecg.modules.eam.constant.HfTemplateCategoryEnum;
import org.jeecg.modules.eam.constant.OrderCreationMethodEnum;
import org.jeecg.modules.eam.constant.TechnicalStatusEvaluationOrderStatusEnum;
import org.jeecg.modules.eam.entity.EamBaseHFCode;
import org.jeecg.modules.eam.entity.EamEquipment;
import org.jeecg.modules.eam.entity.EamTechnicalStatusEvaluationOrder;
import org.jeecg.modules.eam.entity.EamTechnicalStatusEvaluationStandard;
import org.jeecg.modules.eam.entity.*;
import org.jeecg.modules.eam.mapper.EamTechnicalStatusEvaluationOrderMapper;
import org.jeecg.modules.eam.request.EamTechnicalStatusEvaluationOrderQuery;
import org.jeecg.modules.eam.request.EamTechnicalStatusEvaluationOrderRequest;
@@ -147,7 +144,6 @@
        } else {
            queryWrapper.orderByDesc("ems.create_time");
        }
        queryWrapper.orderByDesc("ems.create_time");
        return this.getBaseMapper().queryPageList(page, queryWrapper);
    }

@@ -169,11 +165,10 @@
        order.setEvaluationDate(request.getEvaluationDate());
        order.setRemark(request.getRemark());
        String codeSeq = businessCodeRuleService.generateBusinessCodeSeq(BusinessCodeConst.TECHNICAL_STATUS_EVALUATION_ORDER_CODE_RULE);
        request.setOrderNum(codeSeq);
        request.setCreationMethod(OrderCreationMethodEnum.MANUAL.name());
        order.setOrderNum(codeSeq);
        order.setCreationMethod(OrderCreationMethodEnum.MANUAL.name());
        //状态初始化
        order.setEvaluationStatus(TechnicalStatusEvaluationOrderStatusEnum.WAIT_EVALUATION.name());
        order.setCreationMethod(request.getCreationMethod());
        //删除标记
        order.setDelFlag(CommonConstant.DEL_FLAG_0);
        //技术状态鉴定表
@@ -205,6 +200,10 @@
        if (CollectionUtil.isNotEmpty(request.getTableDetailList())) {
            request.getTableDetailList().forEach(tableDetail -> {
                tableDetail.setId(null);
                tableDetail.setCreateBy(null);
                tableDetail.setCreateTime(null);
                tableDetail.setUpdateBy(null);
                tableDetail.setUpdateTime(null);
                tableDetail.setOrderId(order.getId());
            });
            orderDetailService.saveBatch(request.getTableDetailList());
@@ -239,6 +238,9 @@
            throw new JeecgBootException("设备未分配给维修工，无法领取！");
        }
        List<String> userApprovalList = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList());
        if (!userApprovalList.contains(sysUser.getUsername())) {
            throw new JeecgBootException("您没有领取此工单的权限！");
        }
        entity.setEvaluator(sysUser.getUsername());
        entity.setEvaluationStatus(TechnicalStatusEvaluationOrderStatusEnum.UNDER_EVALUATION.name());
        entity.setActualStartTime(new Date());
@@ -289,6 +291,206 @@
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public EamTechnicalStatusEvaluationOrder approval(EamTechnicalStatusEvaluationOrderRequest request) {
        EamTechnicalStatusEvaluationOrder entity = this.getBaseMapper().selectById(request.getId());
        if (entity == null) {
            throw new JeecgBootException("审批的数据已删除，请刷新重试！");
        }
        // èŽ·å–当前登录用户
        LoginUser user = (LoginUser) SecurityUtils.getSubject().getPrincipal();
        if (user == null || StrUtil.isBlank(user.getId())) {
            throw new JeecgBootException("未获取到登录用户，请重新登录后再试！");
        }
        request.setAssignee(user.getUsername());
        // èŽ·å–流程业务记录
        FlowMyBusiness flowMyBusiness = flowMyBusinessService.getFlowMyBusiness(request.getInstanceId(), request.getTaskId());
        if (flowMyBusiness == null) {
            throw new JeecgBootException("流程实例不存在，请刷新后重试！");
        }

        boolean userAuthorized = flowMyBusinessService.isUserAuthorized(flowMyBusiness, user);
        if (!userAuthorized) {
            throw new JeecgBootException("用户无权操作此任务，请刷新后重试！");
        }
        // è®¤é¢†ä»»åŠ¡
        if (!flowMyBusinessService.claimTask(flowMyBusiness.getTaskId(), user)) {
            throw new JeecgBootException("任务不存在、已完成或已被他人认领！");
        }

        EamEquipment equipment = equipmentService.getById(entity.getEquipmentId());
        if (equipment == null) {
            throw new JeecgBootException("设备不存在，请检查！");
        }

        TechnicalStatusEvaluationOrderStatusEnum status = TechnicalStatusEvaluationOrderStatusEnum.getInstance(entity.getEvaluationStatus());
        if (status == null) {
            return null;
        }
        //流程变量
        Map<String, Object> values = new HashMap<>();
        List<String> userApprovalList;
        List<UserSelector> userSelectors;
        switch (status) {
            case UNDER_EVALUATION:
                boolean parallelCompletion = flowTaskService.checkParallelCompletion(flowMyBusiness.getTaskId());
                //执行完成
                userSelectors = sysUserService.selectOperatorList(equipment.getEquipmentCode(), equipment.getFactoryOrgCode(), BusinessCodeConst.PCR0008);
                if (CollectionUtil.isEmpty(userSelectors)) {
                    throw new JeecgBootException("设备未分配给维修室主任，无法进入下级审批！");
                }
                userApprovalList = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                values.put("dataId", entity.getId());
                values.put("organization", "技术状态鉴定执行结束");
                values.put("comment", "技术状态鉴定执行结束");
                request.setComment("技术状态鉴定执行结束");
                //设置entity
                if (parallelCompletion) {
                    //多个任务都已完成且维修室主任都已审批通过,会签完成，进行维修工签字
                    userSelectors = sysUserService.selectOperatorList(equipment.getEquipmentCode(), equipment.getFactoryOrgCode(), BusinessCodeConst.PCR0002);
                    userApprovalList = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                    values.put("NextAssignee", userApprovalList);
                    entity.setEvaluationStatus(TechnicalStatusEvaluationOrderStatusEnum.REPAIRER_SIGNING.name());
                    entity.setActualEndTime(new Date());
                }
                if ("safety_equipment_check".equals(flowMyBusiness.getTaskNameId())) {
                    //执行安全检查
                    if(CommonConstant.STATUS_1.equals(entity.getSafetyCheckCompleted())) {
                        values.put("safetyEquipmentCheckFlag", request.getSafetyCheckConfirmResult());
                        entity.setSafetyCheckConfirmResult(request.getSafetyCheckConfirmResult());
                        entity.setSafetyCheckConfirm(user.getUsername());
                        entity.setSafetyCheckConfirmTime(new Date());
                        entity.setSafetyCheckConfirmComment(request.getSafetyCheckConfirmComment());
                        //维修室主任审批
                        if(!CommonConstant.STATUS_1.equals(request.getSafetyCheckConfirmResult())) {
                            //驳回 ç»™ç›‘察人
                            userApprovalList = Collections.singletonList(request.getTableDetailList().get(0).getRepairmanSignature());
                            values.put("NextAssignee", userApprovalList);
                            entity.setSafetyCheckCompleted(CommonConstant.STATUS_0);
                        }
                    }else {
                        //安全装置检查结果填报
                        if(CollectionUtil.isNotEmpty(request.getTableDetailList())) {
                            for (EamTechnicalStatusEvaluationOrderDetail detail : request.getTableDetailList()) {
                                detail.setRepairmanSignature(user.getUsername());
                                detail.setRepairmanSignatureTime(new Date());
                            }
                            orderDetailService.updateBatchById(request.getTableDetailList());
                        }
                        values.put("NextAssignee", userApprovalList);
                        entity.setSafetyCheckCompleted(CommonConstant.STATUS_1);
                    }
                } else if ("equipment_precision_check".equals(flowMyBusiness.getTaskNameId())) {
                    //处理精度检验
                    if(CommonConstant.STATUS_1.equals(entity.getPrecisionCheckCompleted())) {
                        values.put("precisionCheckFlag", request.getPrecisionCheckConfirmResult());
                        entity.setPrecisionCheckConfirmResult(request.getPrecisionCheckConfirmResult());
                        entity.setPrecisionCheckConfirm(user.getUsername());
                        entity.setPrecisionCheckConfirmTime(new Date());
                        entity.setPrecisionCheckConfirmComment(request.getPrecisionCheckConfirmComment());
                        //维修室主任审批
                        if(!CommonConstant.STATUS_1.equals(request.getPrecisionCheckConfirmResult())) {
                            //驳回 ç»™ç›‘察人
                            userApprovalList = Collections.singletonList(request.getTableDetailList().get(0).getRepairmanSignature());
                            values.put("NextAssignee", userApprovalList);
                            entity.setPrecisionCheckCompleted(CommonConstant.STATUS_0);
                        }
                    }else {
                        //设备精度检查结果填报
                        if(CollectionUtil.isNotEmpty(request.getTableDetailList())) {
                            for (EamTechnicalStatusEvaluationOrderDetail detail : request.getTableDetailList()) {
                                detail.setRepairmanSignature(user.getUsername());
                                detail.setRepairmanSignatureTime(new Date());
                            }
                            orderDetailService.updateBatchById(request.getTableDetailList());
                        }
                        values.put("NextAssignee", userApprovalList);
                        entity.setPrecisionCheckCompleted(CommonConstant.STATUS_1);
                    }

                } else if("other_check".equals(flowMyBusiness.getTaskNameId())) {
                    //处理其他检查
                    if(CommonConstant.STATUS_1.equals(entity.getOtherCheckCompleted())) {
                        values.put("otherCheckFlag", request.getOtherCheckResult());
                        entity.setOtherCheckResult(request.getOtherCheckConfirmResult());
                        entity.setOtherCheckConfirm(user.getUsername());
                        entity.setOtherCheckConfirmTime(new Date());
                        entity.setOtherCheckConfirmComment(request.getOtherCheckConfirmComment());
                        //维修室主任审批
                        if(!CommonConstant.STATUS_1.equals(request.getOtherCheckConfirmResult())) {
                            //驳回 ç»™ç›‘察人
                            userApprovalList = Collections.singletonList(request.getTableDetailList().get(0).getRepairmanSignature());
                            values.put("NextAssignee", userApprovalList);
                            entity.setOtherCheckCompleted(CommonConstant.STATUS_0);
                        }
                    }else {
                        //其他检查结果填报
                        if(CollectionUtil.isNotEmpty(request.getTableDetailList())) {
                            for (EamTechnicalStatusEvaluationOrderDetail detail : request.getTableDetailList()) {
                                detail.setRepairmanSignature(user.getUsername());
                                detail.setRepairmanSignatureTime(new Date());
                            }
                            orderDetailService.updateBatchById(request.getTableDetailList());
                        }
                        values.put("NextAssignee", userApprovalList);
                        entity.setOtherCheckCompleted(CommonConstant.STATUS_1);
                    }
                }
                break;
            case REPAIRER_SIGNING:
                userSelectors = sysUserService.selectOperatorList(equipment.getEquipmentCode(),equipment.getFactoryOrgCode(), BusinessCodeConst.PCR0008);
                if (CollectionUtil.isEmpty(userSelectors)) {
                    throw new JeecgBootException("设备未分配给维修室主任，无法进入下级审批！");
                }
                //维修工签字
                userApprovalList = userSelectors.stream().map(UserSelector::getUsername).collect(Collectors.toList());
                values.put("dataId", entity.getId());
                values.put("organization", "维修工签字完成");
                values.put("comment", "维修工签字完成");
                values.put("NextAssignee", userApprovalList);
                request.setComment("维修工签字完成");
                //设置entity
                entity.setEvaluationStatus(TechnicalStatusEvaluationOrderStatusEnum.REPAIR_MANAGER_SIGNING.name());
                entity.setRepairerSignature(user.getUsername());
                entity.setRepairerSignatureTime(new Date());
                entity.setSafetyEquipmentCheckResult(request.getSafetyEquipmentCheckResult());
                entity.setPrecisionCheckResult(request.getPrecisionCheckResult());
                entity.setFunctionalCheckResult(request.getFunctionalCheckResult());
                entity.setOtherCheckResult(request.getOtherCheckResult());
                break;
            case REPAIR_MANAGER_SIGNING:
//                values.put("dataId", entity.getId());
//                values.put("organization", request.getLeaderConfirmComment());
//                values.put("comment", request.getLeaderConfirmComment());
//                request.setComment(request.getLeaderConfirmComment());
//                //设置entity
//                entity.setMaintenanceStatus(ThirdMaintenanceStatusEnum.COMPLETE.name());
//                entity.setConfirmLeader(user.getUsername());
//                entity.setLeaderConfirmComment(request.getLeaderConfirmComment());
//                entity.setLeaderConfirmTime(new Date());
//                //更新设备保养状态
//                eamEquipmentExtendService.updateEquipmentMaintenanceStatus(entity.getEquipmentId(), EquipmentMaintenanceStatus.NORMAL.name());
                break;
            case PROCESS_TECHNICIAN_SIGNING:
                break;
            case DEPART_TECHNICAL_LEADER_SIGNING:
                break;
            case INSPECTOR_SIGNING:
                break;
        }
        request.setValues(values);

        // å®Œæˆæµç¨‹ä»»åŠ¡
        Result<?> result = flowTaskService.complete(request);
        if (!result.isSuccess()) {
            throw new JeecgBootException("审批失败，请刷新查看！");
        }
        //保存工单
        this.getBaseMapper().updateById(entity);
        return entity;
    }

    @Override
    public void afterFlowHandle(FlowMyBusiness business) {
        business.getTaskNameId();//接下来审批的节点
        business.getValues();//前端传进来的参数

 lxzn-module-flowable/src/main/java/org/jeecg/modules/flowable/apithird/business/service/IFlowMyBusinessService.java

@@ -1,6 +1,8 @@
package org.jeecg.modules.flowable.apithird.business.service;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.flowable.apithird.business.entity.FlowMyBusiness;
import org.jeecg.modules.flowable.apithird.entity.SysUser;

import java.util.List;

@@ -38,4 +40,20 @@
     * @return
     */
    List<FlowMyBusiness> selectListByDataId(String dataId);

    /**
     * æ ¡éªŒç”¨æˆ·æ˜¯å¦å¯å®Œæˆæ­¤ä»»åŠ¡
     * @param flowMyBusiness
     * @param user
     * @return
     */
    boolean isUserAuthorized(FlowMyBusiness flowMyBusiness, LoginUser user);

    /**
     * é¢†å–任务
     * @param taskId
     * @param user
     * @return
     */
    boolean claimTask(String taskId, LoginUser user);
}

 lxzn-module-flowable/src/main/java/org/jeecg/modules/flowable/apithird/business/service/impl/FlowMyBusinessServiceImpl.java

@@ -1,5 +1,6 @@
package org.jeecg.modules.flowable.apithird.business.service.impl;

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.metadata.IPage;
@@ -7,11 +8,15 @@
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.collections4.CollectionUtils;
import org.flowable.engine.HistoryService;
import org.flowable.engine.TaskService;
import org.flowable.engine.history.HistoricActivityInstance;
import org.flowable.task.api.Task;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.modules.flowable.apithird.business.dto.FlowMyBusinessDto;
import org.jeecg.modules.flowable.apithird.business.entity.FlowMyBusiness;
import org.jeecg.modules.flowable.apithird.business.mapper.FlowMyBusinessMapper;
import org.jeecg.modules.flowable.apithird.business.service.IFlowMyBusinessService;
import org.jeecg.modules.flowable.apithird.entity.SysUser;
import org.jeecg.modules.flowable.domain.dto.FlowTaskDto;
import org.jeecg.modules.flowable.util.TimeUtil;
import org.springframework.beans.factory.annotation.Autowired;
@@ -36,6 +41,8 @@

    @Autowired
    private HistoryService historyService;
    @Autowired
    private TaskService taskService;

    public HistoricActivityInstance getPreviousNode(String taskId) {
        // èŽ·å–当前任务的执行实例 ID
@@ -161,4 +168,25 @@
        }
        return list;
    }

    @Override
    public boolean isUserAuthorized(FlowMyBusiness flowMyBusiness, LoginUser user) {
        List<String> todoUsers = JSON.parseArray(flowMyBusiness.getTodoUsers(), String.class);
        return todoUsers != null && todoUsers.contains(user.getUsername());
    }

    @Override
    public boolean claimTask(String taskId, LoginUser user) {
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        if (task == null) {
            return false;
        }
        if (task.getAssignee() != null && !task.getAssignee().equals(user.getUsername())) {
            return false;
        }
        taskService.claim(taskId, user.getUsername());
        return true;
    }


}