1、自行受理、受理跳转bug修复 2、联合处置流程优化

liyj

2024-09-15 63e6c990e5bfd5c48b1abfeb273a500b783e7fa7

 dyh-service/dyh-mediate/src/main/java/cn/huge/module/cases/service/CaseTaskService.java

@@ -34,6 +34,7 @@
import cn.huge.module.flow.service.FlowInfoService;
import cn.huge.module.mediate.constant.*;
import cn.huge.module.sys.constant.SyTimeEnum;
import cn.huge.module.sys.dto.FileIdTypeInfoBaseDTO;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -442,7 +443,7 @@
                    // 回退申请节点
                    if(CaseTaskConsts.TASK_TYPE_2 == caseTask.getTaskType()){
                        webCaseFlowDTO.setNodeShowName("事件回退");
                        CaseReturn caseReturn = caseReturnService.getNewByCaseId(caseId);
                        CaseReturn caseReturn = caseReturnService.getNewByCaseId(caseId, caseTask.getCaseTaskType());
                        if (StringUtils.isNotEmpty(caseReturn.getReturnContent())) {
                            webCaseFlowDTO.setHandleNotes("回退理由：" + caseReturn.getReturnContent());
                        }else {
@@ -644,6 +645,7 @@
                        if(frontPageListDTO.getCaseId().equals(unfold.getId())){
                            frontPageListDTO.setOrganizingUnit(unfold.getMediateUnitName());
                            frontPageListDTO.setCooperatingUnit(unfold.getAssistUnitName());
                            frontPageListDTO.setManager(unfold.getMediator());
                        }
                    }
                }
@@ -742,12 +744,31 @@
            caseAssistApplyQueryWrapper.eq("case_id", caseId);
            List<CaseAssistApply>caseAssistApplyList = caseAssistApplyService.list(caseAssistApplyQueryWrapper);
            List<SortUtilDTO> sortUtilDTOList = new ArrayList<>();

            String ids = new String();
            ids += caseReturnList.stream().map(CaseReturn:: getId).collect(Collectors.joining(","));
            ids += caseAppearList.stream().map(CaseAppear:: getId).collect(Collectors.joining(","));
            ids += caseWindupApplyList.stream().map(CaseWindupApply:: getId).collect(Collectors.joining(","));
            ids += caseAssistApplyList.stream().map(CaseAssistApply:: getId).collect(Collectors.joining(","));
            List<FileIdTypeInfoBaseDTO> fileIdTypeInfoBaseDTOList = new ArrayList<>();
            if(StringUtils.isNotBlank(ids)){
                Map terms = new HashMap();
                terms.put("mainId", caseId);
                terms.put("ownerIds", "," + ids + ",");
                fileIdTypeInfoBaseDTOList = sysClient.listIdTypeInfoByOwnerIdList(terms);
            }

            for(CaseReturn caseReturn: caseReturnList){
                SortUtilDTO sortUtilDTO = new SortUtilDTO();
                sortUtilDTO.setObject(caseReturn);
                sortUtilDTO.setDate(caseReturn.getCreateTime());
                sortUtilDTO.setType("回退申请");
                sortUtilDTOList.add(sortUtilDTO);
                for(FileIdTypeInfoBaseDTO fileIdTypeInfoBaseDTO: fileIdTypeInfoBaseDTOList){
                    if(caseReturn.getId().equals(fileIdTypeInfoBaseDTO.getOwnerId())){
                        sortUtilDTO.setFileList(fileIdTypeInfoBaseDTO.getFileList());
                    }
                }
            }
            for(CaseAppear caseAppear: caseAppearList){
                SortUtilDTO sortUtilDTO = new SortUtilDTO();
@@ -755,6 +776,11 @@
                sortUtilDTO.setDate(caseAppear.getCreateTime());
                sortUtilDTO.setType("上报申请");
                sortUtilDTOList.add(sortUtilDTO);
                for(FileIdTypeInfoBaseDTO fileIdTypeInfoBaseDTO: fileIdTypeInfoBaseDTOList){
                    if(caseAppear.getId().equals(fileIdTypeInfoBaseDTO.getOwnerId())){
                        sortUtilDTO.setFileList(fileIdTypeInfoBaseDTO.getFileList());
                    }
                }
            }
            for(CaseWindupApply caseWindupApply: caseWindupApplyList){
                SortUtilDTO sortUtilDTO = new SortUtilDTO();
@@ -762,6 +788,11 @@
                sortUtilDTO.setDate(caseWindupApply.getCreateTime());
                sortUtilDTO.setType("结案申请");
                sortUtilDTOList.add(sortUtilDTO);
                for(FileIdTypeInfoBaseDTO fileIdTypeInfoBaseDTO: fileIdTypeInfoBaseDTOList){
                    if(caseWindupApply.getId().equals(fileIdTypeInfoBaseDTO.getOwnerId())){
                        sortUtilDTO.setFileList(fileIdTypeInfoBaseDTO.getFileList());
                    }
                }
            }
            for(CaseAssistApply caseAssistApply: caseAssistApplyList){
                SortUtilDTO sortUtilDTO = new SortUtilDTO();
@@ -769,6 +800,11 @@
                sortUtilDTO.setDate(caseAssistApply.getCreateTime());
                sortUtilDTO.setType("联合处置申请");
                sortUtilDTOList.add(sortUtilDTO);
                for(FileIdTypeInfoBaseDTO fileIdTypeInfoBaseDTO: fileIdTypeInfoBaseDTOList){
                    if(caseAssistApply.getId().equals(fileIdTypeInfoBaseDTO.getOwnerId())){
                        sortUtilDTO.setFileList(fileIdTypeInfoBaseDTO.getFileList());
                    }
                }
            }
            sortUtilDTOList.sort(Comparator.comparing(SortUtilDTO::getDate));
            List<Object> resultList = new ArrayList<>();
@@ -777,8 +813,8 @@
            }
            return resultList;
        }catch (Exception e) {
            log.error("[CaseTaskService.pageMyTaskQs]调用失败，异常信息：" + e, e);
            throw new ServiceException("CaseTaskService.pageMyTaskQs", e);
            log.error("[CaseTaskService.listMyApplyRecord]调用失败，异常信息：" + e, e);
            throw new ServiceException("CaseTaskService.listMyApplyRecord", e);
        }
    }

@@ -932,36 +968,36 @@
                        FlowNode secondFlowNode = flowInfoService.completeTask(dfpCaseTask.getFlowableId(), dfpCaseTask.getProcessTaskId(),
                                FlowableConsts.OPERATION_jb_zszz, "系统派单");
                        // 进入第2个节点-镇街级组织待受理
                        CaseTask sdlCaseTask = new CaseTask();
                        sdlCaseTask.setId(utilsClient.getNewTimeId());
                        sdlCaseTask.setCaseId(caseInfo.getId());
                        sdlCaseTask.setFlowableId(secondFlowNode.getFlowableId());
                        sdlCaseTask.setProcessInstanceId(secondFlowNode.getProcessInstanceId());
                        sdlCaseTask.setProcessTaskId(secondFlowNode.getProcessTaskId());
                        sdlCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_1);
                        sdlCaseTask.setNodeType(secondFlowNode.getNodeType());
                        sdlCaseTask.setNodeId(secondFlowNode.getNodeId());
                        sdlCaseTask.setNodeName(secondFlowNode.getNodeName());
                        sdlCaseTask.setFlowId(secondFlowNode.getFlowId());
                        sdlCaseTask.setNodeShowName(secondFlowNode.getNodeShowName());
                        sdlCaseTask.setCaseTaskType(dfpCaseTask.getCaseTaskType());
                        CaseTask dslCaseTask = new CaseTask();
                        dslCaseTask.setId(utilsClient.getNewTimeId());
                        dslCaseTask.setCaseId(caseInfo.getId());
                        dslCaseTask.setFlowableId(secondFlowNode.getFlowableId());
                        dslCaseTask.setProcessInstanceId(secondFlowNode.getProcessInstanceId());
                        dslCaseTask.setProcessTaskId(secondFlowNode.getProcessTaskId());
                        dslCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_1);
                        dslCaseTask.setNodeType(secondFlowNode.getNodeType());
                        dslCaseTask.setNodeId(secondFlowNode.getNodeId());
                        dslCaseTask.setNodeName(secondFlowNode.getNodeName());
                        dslCaseTask.setFlowId(secondFlowNode.getFlowId());
                        dslCaseTask.setNodeShowName(secondFlowNode.getNodeShowName());
                        dslCaseTask.setCaseTaskType(dfpCaseTask.getCaseTaskType());
                        // 通过调度的，任务候选执行者类型是上一步骤选择
                        sdlCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
                        sdlCaseTask.setCandeUnitId(caseDispBaseDTO.getTargetId());
                        sdlCaseTask.setCandeUnitName(caseDispBaseDTO.getTargetName());
                        dslCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
                        dslCaseTask.setCandeUnitId(caseDispBaseDTO.getTargetId());
                        dslCaseTask.setCandeUnitName(caseDispBaseDTO.getTargetName());
                        // 系统调度给调解组织，需要签收
                        sdlCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_1);
                        sdlCaseTask.setSignExpireTime(sysClient.getExpireTime(caseInfo.getCreateTime(), SyTimeEnum.SY_TIME_2.getIndex()));
                        dslCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_1);
                        dslCaseTask.setSignExpireTime(sysClient.getExpireTime(caseInfo.getCreateTime(), SyTimeEnum.SY_TIME_2.getIndex()));
                        // 任务处理时限
                        if (firstFlowNode.getExpire() != 0) {
                            sdlCaseTask.setExpireTime(DateUtils.addDay(caseInfo.getCreateTime(), firstFlowNode.getExpire()));
                            dslCaseTask.setExpireTime(DateUtils.addDay(caseInfo.getCreateTime(), firstFlowNode.getExpire()));
                        }
                        sdlCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
                        sdlCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
                        sdlCaseTask.setCustId(caseInfo.getCustId());
                        sdlCaseTask.setCreateTime(caseInfo.getCreateTime());
                        sdlCaseTask.setUpdateTime(caseInfo.getUpdateTime());
                        mapper.insert(sdlCaseTask);
                        dslCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
                        dslCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
                        dslCaseTask.setCustId(caseInfo.getCustId());
                        dslCaseTask.setCreateTime(caseInfo.getCreateTime());
                        dslCaseTask.setUpdateTime(caseInfo.getUpdateTime());
                        mapper.insert(dslCaseTask);
                        // 更新纠纷信息
                        CaseInfo caseInfoPO = new CaseInfo();
                        caseInfoPO.setId(caseInfo.getId());
@@ -986,7 +1022,7 @@
     * @param caseInfo
     * @param loginUser
     */
    public void webStartFlowZXSL(CaseInfo caseInfo, CtUserDTO loginUser){
    public String webStartFlowZXSL(CaseInfo caseInfo, CtUserDTO loginUser){
        try{
            // 启动自行受理工作流，进入待受理节点
            FlowNode dslFlowNode = flowInfoService.startFlow(FlowableConsts.FLOWABLE_ID_ZXSL, caseInfo.getId());
@@ -1077,6 +1113,7 @@
            caseInfoUnfoldPO.setMediateUnitId(blfkCaseTask.getCandeUnitId());
            caseInfoUnfoldPO.setMediateUnitName(blfkCaseTask.getCandeUnitName());
            caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfoldPO);
            return blfkCaseTask.getId();
        }catch (Exception e){
            log.error("[CaseTaskService.webStartFlowZXSL]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webStartFlowZXSL", e);
@@ -1186,57 +1223,77 @@
                String assistUnitName = assignTaskDTO.getAssistUnitList().stream().map(AssignAssistUnitDTO::getUitId).
                        collect(Collectors.joining(BaseConsts.COMMA));
                for (AssignAssistUnitDTO assignAssistUnitDTO: assignTaskDTO.getAssistUnitList()){
                    // 创建交办配合组织任务
                    CaseTask jbAssistCaseTask = new CaseTask();
                    jbAssistCaseTask.setId(utilsClient.getNewTimeId());
                    jbAssistCaseTask.setCaseId(dfpCaseTask.getCaseId());
                    jbAssistCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_1);
                    jbAssistCaseTask.setNodeName("交办配合部门");
                    jbAssistCaseTask.setNodeShowName("交办配合部门");
                    jbAssistCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_2);
                    // 配合任务，任务候选执行者类型是上一步骤选择
                    jbAssistCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
                    jbAssistCaseTask.setCandeUnitId(loginUser.getUnitId());
                    jbAssistCaseTask.setCandeUnitName(loginUser.getUnitName());
                    jbAssistCaseTask.setHandleUnitId(loginUser.getUnitId());
                    jbAssistCaseTask.setHandleUnitName(loginUser.getUnitId());
                    jbAssistCaseTask.setHandleUserId(loginUser.getId());
                    jbAssistCaseTask.setHandleUserName(loginUser.getTrueName());
                    jbAssistCaseTask.setHandleContent(assignTaskDTO.getAssignContent());
                    jbAssistCaseTask.setHandleIllust("派单至："+assignTaskDTO.getHandleUnitName());
                    jbAssistCaseTask.setHandleTime(nowDate);
                    // 启动联合处置工作流
                    FlowNode lhczdfpFlowNode = flowInfoService.startFlow(FlowableConsts.FLOWABLE_ID_LHCZ, dfpCaseTask.getCaseId());
                    // 新建并完成配合部门待分派任务
                    CaseTask lhczdfpCaseTask = new CaseTask();
                    lhczdfpCaseTask.setId(utilsClient.getNewTimeId());
                    lhczdfpCaseTask.setCaseId(dfpCaseTask.getCaseId());
                    lhczdfpCaseTask.setFlowableId(lhczdfpFlowNode.getFlowableId());
                    lhczdfpCaseTask.setProcessInstanceId(lhczdfpFlowNode.getProcessInstanceId());
                    lhczdfpCaseTask.setProcessTaskId(lhczdfpFlowNode.getProcessTaskId());
                    lhczdfpCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_1);
                    lhczdfpCaseTask.setNodeType(lhczdfpFlowNode.getNodeType());
                    lhczdfpCaseTask.setNodeId(lhczdfpFlowNode.getNodeId());
                    lhczdfpCaseTask.setNodeName(lhczdfpFlowNode.getNodeName());
                    lhczdfpCaseTask.setFlowId(lhczdfpFlowNode.getFlowId());
                    lhczdfpCaseTask.setNodeShowName(lhczdfpFlowNode.getNodeShowName());
                    lhczdfpCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_2);
                    // 通过调度的，任务候选执行者类型是上一步骤选择
                    lhczdfpCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
                    lhczdfpCaseTask.setCandeUnitId(loginUser.getUnitId());
                    lhczdfpCaseTask.setCandeUnitName(loginUser.getUnitName());
                    // 不需要签收
                    jbAssistCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
                    jbAssistCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
                    jbAssistCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
                    jbAssistCaseTask.setCustId(dfpCaseTask.getCustId());
                    jbAssistCaseTask.setCreateTime(nowDate);
                    jbAssistCaseTask.setUpdateTime(nowDate);
                    mapper.insert(jbAssistCaseTask);
                    // 创建配合组织任务
                    CaseTask assistCaseTask = new CaseTask();
                    assistCaseTask.setId(utilsClient.getNewTimeId());
                    assistCaseTask.setCaseId(dfpCaseTask.getCaseId());
                    assistCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_1);
                    assistCaseTask.setNodeId(FlowNodeEnum.FLOW_NODE_BLFK.getIndex());
                    assistCaseTask.setNodeName(FlowNodeEnum.FLOW_NODE_BLFK.getDes());
                    assistCaseTask.setNodeShowName(FlowNodeEnum.FLOW_NODE_BLFK.getIndex());
                    assistCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_2);
                    // 配合任务，任务候选执行者类型是上一步骤选择
                    assistCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
                    assistCaseTask.setCandeUnitId(assignAssistUnitDTO.getUitId());
                    assistCaseTask.setCandeUnitName(assignAssistUnitDTO.getUitName());
                    assistCaseTask.setHandleUnitId(assignAssistUnitDTO.getUitId());
                    assistCaseTask.setHandleUnitName(assignAssistUnitDTO.getUitName());
                    // 分派的任务，需要签收
                    assistCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_1);
                    assistCaseTask.setSignExpireTime(sysClient.getExpireTime(nowDate, SyTimeEnum.SY_TIME_2.getIndex()));
                    assistCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
                    assistCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
                    assistCaseTask.setCustId(dfpCaseTask.getCustId());
                    assistCaseTask.setCreateTime(nowDate);
                    assistCaseTask.setUpdateTime(nowDate);
                    mapper.insert(assistCaseTask);
                    lhczdfpCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
                    lhczdfpCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
                    lhczdfpCaseTask.setHandleUnitId(loginUser.getUnitId());
                    lhczdfpCaseTask.setHandleUnitName(loginUser.getUnitName());
                    lhczdfpCaseTask.setHandleUserId(loginUser.getId());
                    lhczdfpCaseTask.setHandleUserName(loginUser.getTrueName());
                    lhczdfpCaseTask.setHandleContent(assignTaskDTO.getAssignContent());
                    lhczdfpCaseTask.setHandleIllust("交办至："+assistUnitName);
                    // 任务处理时限
                    if (lhczdfpFlowNode.getExpire() != 0) {
                        lhczdfpCaseTask.setExpireTime(DateUtils.addDay(nowDate, lhczdfpFlowNode.getExpire()));
                    }
                    lhczdfpCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
                    lhczdfpCaseTask.setCustId(dfpCaseTask.getCustId());
                    lhczdfpCaseTask.setCreateTime(nowDate);
                    lhczdfpCaseTask.setUpdateTime(nowDate);
                    mapper.insert(lhczdfpCaseTask);
                    // 完成待分派任务
                    FlowNode lhczdslFlowNode = flowInfoService.completeTask(lhczdfpCaseTask.getFlowableId(), lhczdfpCaseTask.getProcessTaskId(),
                            FlowableConsts.OPERATION_forward, loginUser.getId());
                    // 创建配合部门待受理任务
                    CaseTask lhczdslCaseTask = new CaseTask();
                    lhczdslCaseTask.setId(utilsClient.getNewTimeId());
                    lhczdslCaseTask.setCaseId(lhczdfpCaseTask.getCaseId());
                    lhczdslCaseTask.setFlowableId(lhczdslFlowNode.getFlowableId());
                    lhczdslCaseTask.setProcessInstanceId(lhczdslFlowNode.getProcessInstanceId());
                    lhczdslCaseTask.setProcessTaskId(lhczdslFlowNode.getProcessTaskId());
                    lhczdslCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_1);
                    lhczdslCaseTask.setNodeType(lhczdslFlowNode.getNodeType());
                    lhczdslCaseTask.setNodeId(lhczdslFlowNode.getNodeId());
                    lhczdslCaseTask.setNodeName(lhczdslFlowNode.getNodeName());
                    lhczdslCaseTask.setFlowId(lhczdslFlowNode.getFlowId());
                    lhczdslCaseTask.setNodeShowName(lhczdslFlowNode.getNodeShowName());
                    lhczdslCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_2);
                    // 通过调度的，任务候选执行者类型是上一步骤选择
                    lhczdslCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
                    lhczdslCaseTask.setCandeUnitId(assignAssistUnitDTO.getUitId());
                    lhczdslCaseTask.setCandeUnitName(assignAssistUnitDTO.getUitName());
                    // 需要签收
                    lhczdslCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_1);
                    lhczdslCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
                    // 任务处理时限
                    if (lhczdslFlowNode.getExpire() != 0) {
                        lhczdslCaseTask.setExpireTime(DateUtils.addDay(nowDate, lhczdslFlowNode.getExpire()));
                    }
                    lhczdslCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
                    lhczdslCaseTask.setCustId(lhczdfpCaseTask.getCustId());
                    lhczdslCaseTask.setCreateTime(nowDate);
                    lhczdslCaseTask.setUpdateTime(nowDate);
                    mapper.insert(lhczdslCaseTask);
                }
                // 更新纠纷扩展信息
                CaseInfoUnfold caseInfoUnfoldPO = new CaseInfoUnfold();
@@ -1871,7 +1928,7 @@
            htshCaseTask.setNodeName(htshFlowNode.getNodeName());
            htshCaseTask.setFlowId(htshFlowNode.getFlowId());
            htshCaseTask.setNodeShowName(htshFlowNode.getNodeShowName());
            htshCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
            htshCaseTask.setCaseTaskType(dslCaseTask.getCaseTaskType());
            // 受理任务，任务候选执行者类型是上一步骤选择
            htshCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
            CtUnitDTO ctUnitDTO = custClient.getParentZzzxUnit(loginUser.getUnitId());
@@ -1891,6 +1948,7 @@
            mapper.insert(htshCaseTask);
            // 新增回退申请信息
            caseReturn.setCaseTaskId(htshCaseTask.getId());
            caseReturn.setCaseTaskType(htshCaseTask.getCaseTaskType());
            caseReturnService.save(caseReturn);
        }catch (Exception e){
            log.error("[CaseTaskService.webAppearApply]调用失败，异常信息："+e, e);
@@ -1932,65 +1990,67 @@
                htshCaseTaskPO.setHandleTime(nowDate);
                htshCaseTaskPO.setUpdateTime(nowDate);
                mapper.updateCaseTask(htshCaseTaskPO);
                // 完成当前回退审核任务，走待分派任务
                // 完成当前回退审核任务，承办部门走待分派任务，配合部门结束流程
                FlowNode dfpFlowNode = flowInfoService.completeTask(htshCaseTask.getFlowableId(), htshCaseTask.getProcessTaskId(),
                        FlowableConsts.OPERATION_htsh_ty, userId);
                // 新建待分派任务
                CaseTask dfphCaseTask = new CaseTask();
                dfphCaseTask.setId(utilsClient.getNewTimeId());
                dfphCaseTask.setCaseId(htshCaseTask.getCaseId());
                dfphCaseTask.setFlowableId(dfpFlowNode.getFlowableId());
                dfphCaseTask.setProcessInstanceId(dfpFlowNode.getProcessInstanceId());
                dfphCaseTask.setProcessTaskId(dfpFlowNode.getProcessTaskId());
                dfphCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_1);
                dfphCaseTask.setNodeType(dfpFlowNode.getNodeType());
                dfphCaseTask.setNodeId(dfpFlowNode.getNodeId());
                dfphCaseTask.setNodeName(dfpFlowNode.getNodeName());
                dfphCaseTask.setFlowId(dfpFlowNode.getFlowId());
                dfphCaseTask.setNodeShowName(dfpFlowNode.getNodeShowName());
                dfphCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
                // 受理任务，任务候选执行者类型是上一步骤选择
                dfphCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
                dfphCaseTask.setCandeUnitId(loginUser.getUnitId());
                dfphCaseTask.setCandeUnitName(loginUser.getUnitName());
                // 受理后的任务，不需要签收
                dfphCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
                // 任务处理时限
                if (dfpFlowNode.getExpire() != 0) {
                    dfphCaseTask.setExpireTime(DateUtils.addDay(nowDate, dfpFlowNode.getExpire()));
                if (CaseTaskConsts.CASE_TASK_TYPE_1 == htshCaseTask.getCaseTaskType()) {
                    // 新建待分派任务
                    CaseTask dfphCaseTask = new CaseTask();
                    dfphCaseTask.setId(utilsClient.getNewTimeId());
                    dfphCaseTask.setCaseId(htshCaseTask.getCaseId());
                    dfphCaseTask.setFlowableId(dfpFlowNode.getFlowableId());
                    dfphCaseTask.setProcessInstanceId(dfpFlowNode.getProcessInstanceId());
                    dfphCaseTask.setProcessTaskId(dfpFlowNode.getProcessTaskId());
                    dfphCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_1);
                    dfphCaseTask.setNodeType(dfpFlowNode.getNodeType());
                    dfphCaseTask.setNodeId(dfpFlowNode.getNodeId());
                    dfphCaseTask.setNodeName(dfpFlowNode.getNodeName());
                    dfphCaseTask.setFlowId(dfpFlowNode.getFlowId());
                    dfphCaseTask.setNodeShowName(dfpFlowNode.getNodeShowName());
                    dfphCaseTask.setCaseTaskType(htshCaseTask.getCaseTaskType());
                    // 受理任务，任务候选执行者类型是上一步骤选择
                    dfphCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
                    dfphCaseTask.setCandeUnitId(loginUser.getUnitId());
                    dfphCaseTask.setCandeUnitName(loginUser.getUnitName());
                    // 受理后的任务，不需要签收
                    dfphCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
                    // 任务处理时限
                    if (dfpFlowNode.getExpire() != 0) {
                        dfphCaseTask.setExpireTime(DateUtils.addDay(nowDate, dfpFlowNode.getExpire()));
                    }
                    dfphCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
                    dfphCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
                    dfphCaseTask.setCustId(dfphCaseTask.getCustId());
                    dfphCaseTask.setCreateTime(nowDate);
                    dfphCaseTask.setUpdateTime(nowDate);
                    mapper.insert(dfphCaseTask);
                    // 更新纠纷信息
                    CaseInfo caseInfoPO = new CaseInfo();
                    caseInfoPO.setId(htshCaseTask.getCaseId());
                    caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_1.getIndex());
                    caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_1.getDes());
                    caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
                    caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
                    caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
                    caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
                    caseInfoPO.setUpdateTime(nowDate);
                    caseInfoService.updateCaseInfo(caseInfoPO);
                }
                dfphCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
                dfphCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
                dfphCaseTask.setCustId(dfphCaseTask.getCustId());
                dfphCaseTask.setCreateTime(nowDate);
                dfphCaseTask.setUpdateTime(nowDate);
                mapper.insert(dfphCaseTask);
                // 更新纠纷信息
                CaseInfo caseInfoPO = new CaseInfo();
                caseInfoPO.setId(htshCaseTask.getCaseId());
                caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_1.getIndex());
                caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_1.getDes());
                caseInfoPO.setProcess(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getIndex());
                caseInfoPO.setProcessName(CaseProcessBaseConstsEnum.getByStatus(caseInfoPO.getStatus()).getDes());
                caseInfoPO.setInfoProcess(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getIndex());
                caseInfoPO.setInfoProcessName(CaseInfoProcessBaseConstsEnum.getByProcess(caseInfoPO.getProcess()).getDes());
                caseInfoPO.setUpdateTime(nowDate);
                caseInfoService.updateCaseInfo(caseInfoPO);
            }else {
                // 审核不通过
                // 完成当前回退审核任务
                CaseTask sbshCaseTaskPO = new CaseTask();
                sbshCaseTaskPO.setId(caseReturn.getCaseTaskId());
                sbshCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
                sbshCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
                sbshCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
                sbshCaseTaskPO.setHandleUserId(loginUser.getId());
                sbshCaseTaskPO.setHandleUserName(loginUser.getTrueName());
                sbshCaseTaskPO.setHandleContent(caseReturn.getAuditContent());
                sbshCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_2);
                sbshCaseTaskPO.setHandleTime(nowDate);
                sbshCaseTaskPO.setUpdateTime(nowDate);
                mapper.updateCaseTask(sbshCaseTaskPO);
                CaseTask htshCaseTaskPO = new CaseTask();
                htshCaseTaskPO.setId(caseReturn.getCaseTaskId());
                htshCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
                htshCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
                htshCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
                htshCaseTaskPO.setHandleUserId(loginUser.getId());
                htshCaseTaskPO.setHandleUserName(loginUser.getTrueName());
                htshCaseTaskPO.setHandleContent(caseReturn.getAuditContent());
                htshCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_2);
                htshCaseTaskPO.setHandleTime(nowDate);
                htshCaseTaskPO.setUpdateTime(nowDate);
                mapper.updateCaseTask(htshCaseTaskPO);
                CaseReturn btyCaseReturn = caseReturnService.getById(caseReturn.getId());
                CtUnitDTO returnUnit = custClient.getUnitById(btyCaseReturn.getReturnUnitId());
                String operation = FlowableConsts.OPERATION_htsh_bty;
@@ -2016,7 +2076,7 @@
                dslCaseTask.setNodeName(dslFlowNode.getNodeName());
                dslCaseTask.setFlowId(dslFlowNode.getFlowId());
                dslCaseTask.setNodeShowName(dslFlowNode.getNodeShowName());
                dslCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
                dslCaseTask.setCaseTaskType(htshCaseTask.getCaseTaskType());
                // 受理任务，任务候选执行者类型是上一步骤选择
                dslCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
                dslCaseTask.setCandeUnitId(btyCaseReturn.getReturnUnitId());
@@ -2035,8 +2095,8 @@
                mapper.insert(dslCaseTask);
            }
        }catch (Exception e){
            log.error("[CaseTaskService.webAppearAudit]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webAppearAudit", e);
            log.error("[CaseTaskService.webReturnAudit]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webReturnAudit", e);
        }
    }