申请记录接口 修改流程相关的接口

wangwh

2024-09-13 99bb79a7ceac1107d2bf65df29e149810bf2bbb7

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

@@ -11,7 +11,6 @@
import cn.huge.module.cases.domain.dto.TabButtonInfoDTO;
import cn.huge.module.cases.domain.po.CaseAssistApply;
import cn.huge.module.cases.domain.po.CaseInfoUnfold;
import cn.huge.module.cases.domain.dto.*;
import cn.huge.module.cases.domain.po.*;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.client.api.impl.DispClientImpl;
@@ -25,7 +24,6 @@
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.mediate.constant.AuditBaseConsts;
import cn.huge.module.mediate.constant.AuditBaseConstsEnum;
import cn.huge.module.mediate.constant.CaseBaseConsts;
import cn.huge.module.disp.constant.DispBaseConstsEnum;
import cn.huge.module.disp.dto.CaseDispBaseDTO;
import cn.huge.module.disp.dto.DispCaseBaseDTO;
@@ -43,7 +41,6 @@
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
@@ -51,8 +48,6 @@
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

@@ -90,21 +85,21 @@
    private CaseInfoUnfoldService caseInfoUnfoldService;
    @Autowired
    private CaseWindupApplyService caseWindupApplyService;
    @Autowired
    private CaseAssistApplyService caseAssistApplyService;
    @Autowired
    private CaseAppearService caseAppearService;
    @Autowired
    private CaseReturnService caseReturnService;

    @Autowired
    private CaseWindupApplyMapper caseWindupApplyMapper;

    @Autowired
    private CaseReturnMapper caseReturnMapper;

    @Autowired
    private CaseAppearMapper caseAppearMapper;

    @Autowired
    private CaseAssistApplyMapper caseAssistApplyMapper;

    @Autowired
    private CaseAssistApplyService assistApplyService;

    /**
    * 更新对象
@@ -444,11 +439,12 @@
                    caseFlowDTO.setStatus(caseTask.getStatus());
                }
                handleCaseFlowList.add(caseFlowDTO);
                // 待受理节点，已签收的，需要加多一个受理节点
                // 待受理节点，已签收的并处理完，需要加多一个受理节点
                if(caseTask.getNodeId().equals(FlowNodeEnum.FLOW_NODE_ZJ_DSL.getIndex())
                        || caseTask.getNodeId().equals(FlowNodeEnum.FLOW_NODE_QJ_DSL.getIndex())
                        || caseTask.getNodeId().equals(FlowNodeEnum.FLOW_NODE_SJ_DSL.getIndex())){
                    if(CaseTaskConsts.SIGN_STATUS_2 == caseTask.getSignStatus()){
                    if(CaseTaskConsts.SIGN_STATUS_2 == caseTask.getSignStatus()
                            && CaseTaskConsts.TASK_STATUS_2 == caseTask.getStatus()){
                        CaseFlowDTO slCaseFlowDTO = new CaseFlowDTO();
                        if (CaseTaskConsts.TASK_STATUS_1 == caseTask.getStatus()){
                            if (caseTask.getNodeId().equals(FlowNodeEnum.FLOW_NODE_DSRPJ.getIndex())){
@@ -554,10 +550,10 @@
            FrontPageCountDTO frontPageCountDTO = mapper.countTaskList(terms);
            long supervise = superviseService.countCaseSuperviseList(0,loginUser.getUnitId());
            frontPageCountDTO.setSupervise(supervise);
            long countApplyReview = caseWindupApplyMapper.countApplyReview(loginUser.getUnitId());
            long countReturnReview = caseReturnMapper.countReturnReview(loginUser.getUnitId());
            long countAppearReview = caseAppearMapper.countAppearReview(loginUser.getUnitId());
            long countAssistReview = caseAssistApplyMapper.countAssistReview(loginUser.getUnitId());
            long countApplyReview = caseWindupApplyService.countApplyReview(loginUser.getUnitId());
            long countReturnReview = caseReturnService.countReturnReview(loginUser.getUnitId());
            long countAppearReview = caseAppearService.countAppearReview(loginUser.getUnitId());
            long countAssistReview = caseAssistApplyService.countAssistReview(loginUser.getUnitId());
            frontPageCountDTO.setWaitReview(countApplyReview+countReturnReview+countAppearReview+countAssistReview);
            return frontPageCountDTO;
        }catch (Exception e) {
@@ -645,7 +641,7 @@
                for(CaseInfoUnfold unfold: unfoldList){
                    for(FrontPageListDTO frontPageListDTO: frontPageListDTOList){
                        if(frontPageListDTO.getCaseId().equals(unfold.getId())){
                            frontPageListDTO.setOrganizingUnit(unfold.getMediateUnitId());
                            frontPageListDTO.setOrganizingUnit(unfold.getMediateUnitName());
                            frontPageListDTO.setCooperatingUnit(unfold.getAssistUnitName());
                        }
                    }
@@ -667,8 +663,8 @@
     */
    public Page<FrontPageListDTO> pageMyTaskBl(PageRequest page, Map<String, Object> terms){
        try {
            long total = caseWindupApplyMapper.countMySubmitApplyReview(terms);
            List<FrontPageListDTO> frontPageListDTOList = caseWindupApplyMapper.pageMySubmitApplyReview(page, terms);
            long total = caseWindupApplyService.countMySubmitApplyReview(terms);
            List<FrontPageListDTO> frontPageListDTOList = caseWindupApplyService.listMySubmitApplyReview(page, terms);

            List<String> caseIdList = new ArrayList<>();
            caseIdList = frontPageListDTOList.stream().map(FrontPageListDTO ::getCaseId).collect(Collectors.toList());
@@ -679,7 +675,7 @@
                for(CaseInfoUnfold unfold: unfoldList){
                    for(FrontPageListDTO frontPageListDTO: frontPageListDTOList){
                        if(frontPageListDTO.getCaseId().equals(unfold.getId())){
                            frontPageListDTO.setOrganizingUnit(unfold.getMediateUnitId());
                            frontPageListDTO.setOrganizingUnit(unfold.getMediateUnitName());
                            frontPageListDTO.setCooperatingUnit(unfold.getAssistUnitName());
                        }
                    }
@@ -703,17 +699,17 @@
            long total = 0;
            List<FrontPageListDTO> frontPageListDTOList = new ArrayList<>();
            if(1 == type){
                total = caseReturnMapper.countMyTaskReturnReview(terms);
                frontPageListDTOList = caseReturnMapper.pageMyTaskReturnReview(page,terms);
                total = caseReturnService.countMyTaskReturnReview(terms);
                frontPageListDTOList = caseReturnService.pageMyTaskReturnReview(page,terms);
            }else if(2 == type){
                total = caseAppearMapper.countMyTaskAppearReview(terms);
                frontPageListDTOList = caseAppearMapper.pageMyTaskAppearReview(page, terms);
                total = caseAppearService.countMyTaskAppearReview(terms);
                frontPageListDTOList = caseAppearService.pageMyTaskAppearReview(page, terms);
            }else if(3 == type){
                total = caseWindupApplyMapper.countMyTaskApplyReview(terms);
                frontPageListDTOList = caseWindupApplyMapper.pageMyTaskApplyReview(page, terms);
                total = caseWindupApplyService.countMyTaskApplyReview(terms);
                frontPageListDTOList = caseWindupApplyService.listMyTaskApplyReview(page, terms);
            }else if(4 == type){
                total = caseAssistApplyMapper.countMyTaskAssistReview(terms);
                frontPageListDTOList = caseAssistApplyMapper.pageMyTaskAssistReview(page, terms);
                total = caseAssistApplyService.countMyTaskAssistReview(terms);
                frontPageListDTOList = caseAssistApplyService.pageMyTaskAssistReview(page, terms);
            }
            return new PageImpl<FrontPageListDTO>(frontPageListDTOList, page, total);
        }catch (Exception e) {
@@ -721,6 +717,70 @@
            throw new ServiceException("CaseTaskService.pageMyTaskQs", e);
        }
    }

    /**
     * 首页-待审核分页查询
     * @param caseId 事项编号
     * @return Page
     */
    public List<Object> listMyApplyRecord(String caseId){
        try {
            QueryWrapper<CaseReturn> caseReturnQueryWrapper = new QueryWrapper<>();
            caseReturnQueryWrapper.eq("case_id", caseId);
            List<CaseReturn>caseReturnList = caseReturnService.list(caseReturnQueryWrapper);

            QueryWrapper<CaseAppear> caseAppearQueryWrapper = new QueryWrapper<>();
            caseAppearQueryWrapper.eq("case_id", caseId);
            List<CaseAppear>caseAppearList = caseAppearService.list(caseAppearQueryWrapper);

            QueryWrapper<CaseWindupApply> caseWindupApplyQueryWrapper = new QueryWrapper<>();
            caseWindupApplyQueryWrapper.eq("case_id", caseId);
            List<CaseWindupApply>caseWindupApplyList = caseWindupApplyService.list(caseWindupApplyQueryWrapper);

            QueryWrapper<CaseAssistApply> caseAssistApplyQueryWrapper = new QueryWrapper<>();
            caseAssistApplyQueryWrapper.eq("case_id", caseId);
            List<CaseAssistApply>caseAssistApplyList = caseAssistApplyService.list(caseAssistApplyQueryWrapper);
            List<SortUtilDTO> sortUtilDTOList = new ArrayList<>();
            for(CaseReturn caseReturn: caseReturnList){
                SortUtilDTO sortUtilDTO = new SortUtilDTO();
                sortUtilDTO.setObject(caseReturn);
                sortUtilDTO.setDate(caseReturn.getCreateTime());
                sortUtilDTO.setType("回退申请");
                sortUtilDTOList.add(sortUtilDTO);
            }
            for(CaseAppear caseAppear: caseAppearList){
                SortUtilDTO sortUtilDTO = new SortUtilDTO();
                sortUtilDTO.setObject(caseAppear);
                sortUtilDTO.setDate(caseAppear.getCreateTime());
                sortUtilDTO.setType("上报申请");
                sortUtilDTOList.add(sortUtilDTO);
            }
            for(CaseWindupApply caseWindupApply: caseWindupApplyList){
                SortUtilDTO sortUtilDTO = new SortUtilDTO();
                sortUtilDTO.setObject(caseWindupApply);
                sortUtilDTO.setDate(caseWindupApply.getCreateTime());
                sortUtilDTO.setType("结案申请");
                sortUtilDTOList.add(sortUtilDTO);
            }
            for(CaseAssistApply caseAssistApply: caseAssistApplyList){
                SortUtilDTO sortUtilDTO = new SortUtilDTO();
                sortUtilDTO.setObject(caseAssistApply);
                sortUtilDTO.setDate(caseAssistApply.getCreateTime());
                sortUtilDTO.setType("联合处置申请");
                sortUtilDTOList.add(sortUtilDTO);
            }
            sortUtilDTOList.sort(Comparator.comparing(SortUtilDTO::getDate));
            List<Object> resultList = new ArrayList<>();
            for(SortUtilDTO sortUtilDTO: sortUtilDTOList){
                resultList.add(sortUtilDTO);
            }
            return resultList;
        }catch (Exception e) {
            log.error("[CaseTaskService.pageMyTaskQs]调用失败，异常信息：" + e, e);
            throw new ServiceException("CaseTaskService.pageMyTaskQs", e);
        }
    }

    /**
     * wechat端-查询流程进度
     * @param caseId 纠纷编号
@@ -895,7 +955,48 @@
     */
    public void webStartFlowZXSL(CaseInfo caseInfo, CtUserDTO loginUser){
        try{

            // 启动自行受理工作流
            FlowNode firstFlowNode = flowInfoService.startFlow(FlowableConsts.FLOWABLE_ID_ZXSL, caseInfo.getId());
            // 进入第1个节点-办理反馈
            CaseTask blfkCaseTask = new CaseTask();
            blfkCaseTask.setId(utilsClient.getNewTimeId());
            blfkCaseTask.setCaseId(caseInfo.getId());
            blfkCaseTask.setFlowableId(firstFlowNode.getFlowableId());
            blfkCaseTask.setProcessInstanceId(firstFlowNode.getProcessInstanceId());
            blfkCaseTask.setProcessTaskId(firstFlowNode.getProcessTaskId());
            blfkCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_1);
            blfkCaseTask.setNodeType(firstFlowNode.getNodeType());
            blfkCaseTask.setNodeId(firstFlowNode.getNodeId());
            blfkCaseTask.setNodeName(firstFlowNode.getNodeName());
            blfkCaseTask.setFlowId(firstFlowNode.getFlowId());
            blfkCaseTask.setNodeShowName(firstFlowNode.getNodeShowName());
            blfkCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
            // 通过调度的，任务候选执行者类型是上一步骤选择
            blfkCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
            blfkCaseTask.setCandeUnitId(loginUser.getUnitId());
            blfkCaseTask.setCandeUnitName(loginUser.getUnitName());
            // 系统给综治中心分派，不需要签收
            blfkCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
            blfkCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
            // 任务处理时限
            if (firstFlowNode.getExpire() != 0) {
                blfkCaseTask.setExpireTime(DateUtils.addDay(caseInfo.getCreateTime(), firstFlowNode.getExpire()));
            }
            blfkCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
            blfkCaseTask.setCustId(caseInfo.getCustId());
            blfkCaseTask.setCreateTime(caseInfo.getCreateTime());
            blfkCaseTask.setUpdateTime(caseInfo.getUpdateTime());
            mapper.insert(blfkCaseTask);
            // 更新纠纷信息
            CaseInfo caseInfoPO = new CaseInfo();
            caseInfoPO.setId(caseInfo.getId());
            caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_4.getIndex());
            caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_4.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());
            caseInfoService.updateCaseInfo(caseInfoPO);
        }catch (Exception e){
            log.error("[CaseTaskService.webStartFlowZXSL]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webStartFlowZXSL", e);
@@ -1072,35 +1173,41 @@

    /**
     * web端任务处理-签收
     * @param signTaskDTO 签收任务表单
     * @param signTaskDTOList 签收任务表单
     * @param userId 当前登录用户
     */
    public void webSign(SignTaskDTO signTaskDTO, String userId){
    public void webSign(List<SignTaskDTO> signTaskDTOList, String userId){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            // 更新纠纷任务信息
            CaseTask caseTaskPO = new CaseTask();
            caseTaskPO.setId(signTaskDTO.getCaseTaskId());
            caseTaskPO.setSignStatus(CaseTaskConsts.SIGN_STATUS_2);
            caseTaskPO.setSignTime(nowDate);
            caseTaskPO.setSignUserId(loginUser.getId());
            caseTaskPO.setSignUserName(loginUser.getTrueName());
            caseTaskPO.setHandleIllust("已签收");
            caseTaskPO.setUpdateTime(nowDate);
            mapper.updateCaseTask(caseTaskPO);
            // 更新纠纷信息
            CaseInfo caseInfoPO = new CaseInfo();
            caseInfoPO.setId(signTaskDTO.getCaseId());
            caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_3.getIndex());
            caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_3.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);
            List<String> taskIdList = new ArrayList<>();
            List<String> caseIdList = new ArrayList<>();
            for (SignTaskDTO signTaskDTO: signTaskDTOList){
                CaseTask qsCaseTask = mapper.selectById(signTaskDTO.getCaseId());
                // 更新纠纷任务信息
                CaseTask caseTaskPO = new CaseTask();
                caseTaskPO.setSignStatus(CaseTaskConsts.SIGN_STATUS_2);
                caseTaskPO.setSignTime(nowDate);
                caseTaskPO.setSignUserId(loginUser.getId());
                caseTaskPO.setSignUserName(loginUser.getTrueName());
                caseTaskPO.setHandleIllust("已签收");
                caseTaskPO.setUpdateTime(nowDate);
                mapper.updateCaseTask(caseTaskPO);
                // 承办部门签收才更新纠纷信息
                if (CaseTaskConsts.CASE_TASK_TYPE_1 ==  qsCaseTask.getCaseTaskType()) {
                    // 更新纠纷信息
                    CaseInfo caseInfoPO = new CaseInfo();
                    caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_3.getIndex());
                    caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_3.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);
                }
            }
        }catch (Exception e){
            log.error("[CaseTaskService.webSign]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webSign", e);
@@ -1148,7 +1255,7 @@
            blfkCaseTask.setNodeName(newFlowNode.getNodeName());
            blfkCaseTask.setFlowId(newFlowNode.getFlowId());
            blfkCaseTask.setNodeShowName(newFlowNode.getNodeShowName());
            blfkCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
            blfkCaseTask.setCaseTaskType(dslCaseTask.getCaseTaskType());
            // 受理任务，任务候选执行者类型是上一步骤选择
            blfkCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
            blfkCaseTask.setCandeUnitId(loginUser.getUnitId());
@@ -1165,23 +1272,26 @@
            blfkCaseTask.setCreateTime(nowDate);
            blfkCaseTask.setUpdateTime(nowDate);
            mapper.insert(blfkCaseTask);
            // 更新纠纷信息
            CaseInfo caseInfoPO = new CaseInfo();
            caseInfoPO.setId(blfkCaseTask.getCaseId());
            caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_4.getIndex());
            caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_4.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());
            caseInfoService.updateCaseInfo(caseInfoPO);
            // 更新纠纷扩展信息
            CaseInfoUnfold caseInfoUnfoldPO = new CaseInfoUnfold();
            caseInfoUnfoldPO.setId(blfkCaseTask.getCaseId());
            caseInfoUnfoldPO.setAcceptTime(nowDate);
            caseInfoUnfoldPO.setMediateUnitId(blfkCaseTask.getCandeUnitId());
            caseInfoUnfoldPO.setMediateUnitName(blfkCaseTask.getCandeUnitName());
            caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfoldPO);
            // 承办部门签收才更新纠纷信息
            if (CaseTaskConsts.CASE_TASK_TYPE_1 ==  dslCaseTask.getCaseTaskType()) {
                // 更新纠纷信息
                CaseInfo caseInfoPO = new CaseInfo();
                caseInfoPO.setId(blfkCaseTask.getCaseId());
                caseInfoPO.setStatus(CaseStatusBaseConstsEnum.CASE_STATUS_4.getIndex());
                caseInfoPO.setStatusName(CaseStatusBaseConstsEnum.CASE_STATUS_4.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());
                caseInfoService.updateCaseInfo(caseInfoPO);
                // 更新纠纷扩展信息
                CaseInfoUnfold caseInfoUnfoldPO = new CaseInfoUnfold();
                caseInfoUnfoldPO.setId(blfkCaseTask.getCaseId());
                caseInfoUnfoldPO.setAcceptTime(nowDate);
                caseInfoUnfoldPO.setMediateUnitId(blfkCaseTask.getCandeUnitId());
                caseInfoUnfoldPO.setMediateUnitName(blfkCaseTask.getCandeUnitName());
                caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfoldPO);
            }
        }catch (Exception e){
            log.error("[CaseTaskService.webAccept]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webAccept", e);
@@ -1248,6 +1358,7 @@
            jasqCaseTask.setHandleUnitName(loginUser.getUnitName());
            jasqCaseTask.setHandleUserId(loginUser.getId());
            jasqCaseTask.setHandleUserName(loginUser.getTrueName());
            jasqCaseTask.setHandleContent(caseWindupApply.getWindupContent());
            jasqCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
            jasqCaseTask.setHandleTime(nowDate);
            jasqCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
@@ -1425,6 +1536,27 @@
                caseInfoUnfoldPO.setUpdateTime(nowDate);
                caseInfoUnfoldService.updateCaseInfoUnfold(caseInfoUnfoldPO);
            }
            // 查询配合部门的任务，全部结束流程
            QueryWrapper<CaseTask> caseTaskQueryWrapper = new QueryWrapper<>();
            caseTaskQueryWrapper.eq("case_task_type", CaseTaskConsts.CASE_TASK_TYPE_2).eq("case_id", jasqCaseTask.getCaseId());
            List<CaseTask> assistCaseTaskList = mapper.selectList(caseTaskQueryWrapper);
            for (CaseTask assistCaseTask: assistCaseTaskList){
                // 完成配合部门当前办理反馈任务
                assistCaseTask.setId(caseWindupApply.getCaseTaskId());
                assistCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_2);
                assistCaseTask.setHandleUnitId(loginUser.getUnitId());
                assistCaseTask.setHandleUnitName(loginUser.getUnitName());
                assistCaseTask.setHandleUserId(loginUser.getId());
                assistCaseTask.setHandleUserName(loginUser.getTrueName());
                assistCaseTask.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
                assistCaseTask.setHandleTime(nowDate);
                assistCaseTask.setUpdateTime(nowDate);
                mapper.updateCaseTask(assistCaseTask);
                // 完成当前配合部门办理反馈工作流任务
                flowInfoService.completeTask(assistCaseTask.getFlowableId(), assistCaseTask.getProcessTaskId(),
                        FlowableConsts.OPERATION_forward, userId);

            }
        }catch (Exception e){
            log.error("[CaseTaskService.webWindupApply]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webWindupApply", e);
@@ -1445,6 +1577,8 @@
            caseWindupApply.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_1);
            caseWindupApply.setAuditUserId(loginUser.getId());
            caseWindupApply.setAuditUserName(loginUser.getTrueName());
            caseWindupApply.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
            caseWindupApply.setCustId(loginUser.getCustId());
            caseWindupApply.setAuditTime(nowDate);
            caseWindupApply.setUpdateTime(nowDate);
            caseWindupApplyService.updateCaseWindupApply(caseWindupApply);
@@ -1460,6 +1594,7 @@
                jashCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
                jashCaseTaskPO.setHandleUserId(loginUser.getId());
                jashCaseTaskPO.setHandleUserName(loginUser.getTrueName());
                jashCaseTaskPO.setHandleContent(caseWindupApply.getAuditContent());
                jashCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
                jashCaseTaskPO.setHandleTime(nowDate);
                jashCaseTaskPO.setUpdateTime(nowDate);
@@ -1530,6 +1665,7 @@
                jashCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
                jashCaseTaskPO.setHandleUserId(loginUser.getId());
                jashCaseTaskPO.setHandleUserName(loginUser.getTrueName());
                jashCaseTaskPO.setHandleContent(caseWindupApply.getAuditContent());
                jashCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_2);
                jashCaseTaskPO.setHandleTime(nowDate);
                jashCaseTaskPO.setUpdateTime(nowDate);
@@ -1598,16 +1734,436 @@
    }

    /**
     * web端任务处理-回退申请
     * @param caseReturn 回退申请表单
     * @param userId 当前登录用户
     */
    public void webReturnApply(CaseReturn caseReturn, String userId){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            // 创建回退申请信息
            caseReturn.setReturnUnitId(loginUser.getUnitId());
            caseReturn.setReturnUnitName(loginUser.getUnitName());
            caseReturn.setReturnUserId(loginUser.getId());
            caseReturn.setReturnUserName(loginUser.getTrueName());
            caseReturn.setReturnTime(nowDate);
            CtUnitDTO zzzxUnit = custClient.getParentZzzxUnit(loginUser.getUnitId());
            caseReturn.setAuditUnitId(zzzxUnit.getId());
            caseReturn.setAuditUnitName(zzzxUnit.getUnitName());
            caseReturn.setReturnStatus(AuditBaseConsts.AUDIT_STATUS_0);
            caseReturn.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
            caseReturn.setCustId(loginUser.getCustId());
            caseReturn.setCreateTime(nowDate);
            caseReturn.setUpdateTime(nowDate);
            // 查询待受理任务
            CaseTask dslCaseTask = mapper.selectById(caseReturn.getCaseTaskId());
            // 完成当前待受理任务
            CaseTask dslCaseTaskPO = new CaseTask();
            dslCaseTaskPO.setId(caseReturn.getCaseTaskId());
            dslCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
            dslCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
            dslCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
            dslCaseTaskPO.setHandleUserId(loginUser.getId());
            dslCaseTaskPO.setHandleUserName(loginUser.getTrueName());
            dslCaseTaskPO.setHandleContent(caseReturn.getReturnContent());
            dslCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
            dslCaseTaskPO.setHandleTime(nowDate);
            dslCaseTaskPO.setUpdateTime(nowDate);
            mapper.updateCaseTask(dslCaseTaskPO);
            // 完成当前待受理工作流任务，走回退审核任务
            FlowNode htshFlowNode = flowInfoService.completeTask(dslCaseTask.getFlowableId(), dslCaseTask.getProcessTaskId(),
                    FlowableConsts.OPERATION_htsq, userId);
            // 新建回退审核任务
            CaseTask htshCaseTask = new CaseTask();
            htshCaseTask.setId(utilsClient.getNewTimeId());
            htshCaseTask.setCaseId(dslCaseTaskPO.getCaseId());
            htshCaseTask.setFlowableId(htshFlowNode.getFlowableId());
            htshCaseTask.setProcessInstanceId(htshFlowNode.getProcessInstanceId());
            htshCaseTask.setProcessTaskId(htshFlowNode.getProcessTaskId());
            htshCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_2);
            htshCaseTask.setNodeType(htshFlowNode.getNodeType());
            htshCaseTask.setNodeId(htshFlowNode.getNodeId());
            htshCaseTask.setNodeName(htshFlowNode.getNodeName());
            htshCaseTask.setFlowId(htshFlowNode.getFlowId());
            htshCaseTask.setNodeShowName(htshFlowNode.getNodeShowName());
            htshCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
            // 受理任务，任务候选执行者类型是上一步骤选择
            htshCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
            CtUnitDTO ctUnitDTO = custClient.getParentZzzxUnit(loginUser.getUnitId());
            htshCaseTask.setCandeUnitId(ctUnitDTO.getId());
            htshCaseTask.setCandeUnitName(ctUnitDTO.getUnitName());
            // 受理后的任务，不需要签收
            htshCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
            // 任务处理时限
            if (htshFlowNode.getExpire() != 0) {
                htshCaseTask.setExpireTime(DateUtils.addDay(nowDate, htshFlowNode.getExpire()));
            }
            htshCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
            htshCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
            htshCaseTask.setCustId(htshCaseTask.getCustId());
            htshCaseTask.setCreateTime(nowDate);
            htshCaseTask.setUpdateTime(nowDate);
            mapper.insert(htshCaseTask);
            // 新增回退申请信息
            caseReturn.setCaseTaskId(htshCaseTask.getId());
            caseReturnService.save(caseReturn);
        }catch (Exception e){
            log.error("[CaseTaskService.webAppearApply]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webAppearApply", e);
        }
    }

    /**
     * web端任务处理-回退审核
     * @param caseReturn 回退审核表单
     * @param userId 当前登录用户
     */
    public void webReturnAudit(CaseReturn caseReturn, String userId){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            // 更新回退申请信息
            caseReturn.setReturnStatus(AuditBaseConsts.AUDIT_STATUS_1);
            caseReturn.setAuditUserId(loginUser.getId());
            caseReturn.setAuditUserName(loginUser.getTrueName());
            caseReturn.setAuditTime(nowDate);
            caseReturn.setUpdateTime(nowDate);
            caseReturnService.updateCaseReturn(caseReturn);
            // 查询回退审核任务
            CaseTask htshCaseTask = mapper.selectById(caseReturn.getCaseTaskId());
            // 审核通过
            if (AuditBaseConstsEnum.AUDIT_RESULT_1.getIndex().equals(caseReturn.getAuditResult())){
                // 完成当前回退审核任务
                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.setHandleContent(caseReturn.getAuditContent());
                htshCaseTaskPO.setHandleUserName(loginUser.getTrueName());
                htshCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
                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()));
                }
                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);
                CtUnitDTO returnUnit = custClient.getUnitById(caseReturn.getReturnUnitId());
                String operation = FlowableConsts.OPERATION_htsh_bty;
                if (UserBaseConsts.UNIT_GRADE_2 == returnUnit.getUnitGrade()){
                    operation = FlowableConsts.OPERATION_htsh_bty_qj;
                }
                if(UserBaseConsts.UNIT_GRADE_1 == returnUnit.getUnitGrade()){
                    operation = FlowableConsts.OPERATION_htsh_bty_sj;
                }
                // 完成当前上报审核任务，走待受理任务
                FlowNode dslFlowNode = flowInfoService.completeTask(htshCaseTask.getFlowableId(), htshCaseTask.getProcessTaskId(),
                        operation, userId);
                // 新建待分派任务
                CaseTask dslCaseTask = new CaseTask();
                dslCaseTask.setId(utilsClient.getNewTimeId());
                dslCaseTask.setCaseId(dslCaseTask.getCaseId());
                dslCaseTask.setFlowableId(dslFlowNode.getFlowableId());
                dslCaseTask.setProcessInstanceId(dslFlowNode.getProcessInstanceId());
                dslCaseTask.setProcessTaskId(dslFlowNode.getProcessTaskId());
                dslCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_1);
                dslCaseTask.setNodeType(dslFlowNode.getNodeType());
                dslCaseTask.setNodeId(dslFlowNode.getNodeId());
                dslCaseTask.setNodeName(dslFlowNode.getNodeName());
                dslCaseTask.setFlowId(dslFlowNode.getFlowId());
                dslCaseTask.setNodeShowName(dslFlowNode.getNodeShowName());
                dslCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
                // 受理任务，任务候选执行者类型是上一步骤选择
                dslCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
                dslCaseTask.setCandeUnitId(caseReturn.getReturnUnitId());
                dslCaseTask.setCandeUnitName(caseReturn.getReturnUnitName());
                // 受理后的任务，不需要签收
                dslCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
                // 任务处理时限
                if (dslFlowNode.getExpire() != 0) {
                    dslCaseTask.setExpireTime(DateUtils.addDay(nowDate, dslFlowNode.getExpire()));
                }
                dslCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
                dslCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
                dslCaseTask.setCustId(dslCaseTask.getCustId());
                dslCaseTask.setCreateTime(nowDate);
                dslCaseTask.setUpdateTime(nowDate);
                mapper.insert(dslCaseTask);
            }
        }catch (Exception e){
            log.error("[CaseTaskService.webAppearAudit]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webAppearAudit", e);
        }
    }

    /**
     * web端任务处理-上报
     * @param caseAppear 上报表单
     * @param userId 当前登录用户
     */
    public void webAppearApply(CaseAppear caseAppear, String userId){
        try{

            Date nowDate = DateUtils.getNowDate();
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            // 创建上报信息
            caseAppear.setAppearUnitId(loginUser.getUnitId());
            caseAppear.setAppearUnitName(loginUser.getUnitName());
            caseAppear.setAppearUserId(loginUser.getId());
            caseAppear.setAppearUserName(loginUser.getTrueName());
            caseAppear.setAppearTime(nowDate);
            caseAppear.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_0);
            caseAppear.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
            caseAppear.setCustId(loginUser.getCustId());
            caseAppear.setCreateTime(nowDate);
            caseAppear.setUpdateTime(nowDate);
            // 查询待受理任务
            CaseTask dslCaseTask = mapper.selectById(caseAppear.getCaseTaskId());
            // 完成当前待受理任务
            CaseTask dslCaseTaskPO = new CaseTask();
            dslCaseTaskPO.setId(caseAppear.getCaseTaskId());
            dslCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
            dslCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
            dslCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
            dslCaseTaskPO.setHandleUserId(loginUser.getId());
            dslCaseTaskPO.setHandleUserName(loginUser.getTrueName());
            dslCaseTaskPO.setHandleContent(caseAppear.getAppearContent());
            dslCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
            dslCaseTaskPO.setHandleTime(nowDate);
            dslCaseTaskPO.setUpdateTime(nowDate);
            mapper.updateCaseTask(dslCaseTaskPO);
            // 完成当前待受理工作流任务，走上报审核任务
            FlowNode sbshFlowNode = flowInfoService.completeTask(dslCaseTask.getFlowableId(), dslCaseTask.getProcessTaskId(),
                    FlowableConsts.OPERATION_sb, userId);
            // 新建上报审核任务
            CaseTask sbshCaseTask = new CaseTask();
            sbshCaseTask.setId(utilsClient.getNewTimeId());
            sbshCaseTask.setCaseId(dslCaseTaskPO.getCaseId());
            sbshCaseTask.setFlowableId(sbshFlowNode.getFlowableId());
            sbshCaseTask.setProcessInstanceId(sbshFlowNode.getProcessInstanceId());
            sbshCaseTask.setProcessTaskId(sbshFlowNode.getProcessTaskId());
            sbshCaseTask.setTaskType(CaseTaskConsts.TASK_TYPE_3);
            sbshCaseTask.setNodeType(sbshFlowNode.getNodeType());
            sbshCaseTask.setNodeId(sbshFlowNode.getNodeId());
            sbshCaseTask.setNodeName(sbshFlowNode.getNodeName());
            sbshCaseTask.setFlowId(sbshFlowNode.getFlowId());
            sbshCaseTask.setNodeShowName(sbshFlowNode.getNodeShowName());
            sbshCaseTask.setCaseTaskType(CaseTaskConsts.CASE_TASK_TYPE_1);
            // 受理任务，任务候选执行者类型是上一步骤选择
            sbshCaseTask.setCandeType(CaseTaskConsts.CANDE_TYPE_1);
            sbshCaseTask.setCandeUnitId(caseAppear.getAuditUnitId());
            sbshCaseTask.setCandeUnitName(caseAppear.getAuditUnitName());
            // 受理后的任务，不需要签收
            sbshCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
            // 任务处理时限
            if (sbshFlowNode.getExpire() != 0) {
                sbshCaseTask.setExpireTime(DateUtils.addDay(nowDate, sbshFlowNode.getExpire()));
            }
            sbshCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
            sbshCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
            sbshCaseTask.setCustId(sbshCaseTask.getCustId());
            sbshCaseTask.setCreateTime(nowDate);
            sbshCaseTask.setUpdateTime(nowDate);
            mapper.insert(sbshCaseTask);
            // 新增上报申请信息
            caseAppear.setCaseTaskId(sbshCaseTask.getId());
            caseAppearService.save(caseAppear);
        }catch (Exception e){
            log.error("[CaseTaskService.webWindupApply]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webWindupApply", e);
            log.error("[CaseTaskService.webAppearApply]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webAppearApply", e);
        }
    }

    /**
     * web端任务处理-上报审核
     * @param caseAppear 上报审核表单
     * @param userId 当前登录用户
     */
    public void webAppearAudit(CaseAppear caseAppear, String userId){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            // 更新上报信息
            caseAppear.setApplyStatus(AuditBaseConsts.AUDIT_STATUS_1);
            caseAppear.setAuditUserId(loginUser.getId());
            caseAppear.setAuditUserName(loginUser.getTrueName());
            caseAppear.setAuditTime(nowDate);
            caseAppear.setUpdateTime(nowDate);
            caseAppearService.updateCaseAppear(caseAppear);
            // 查询上报审核任务
            CaseTask sbshCaseTask = mapper.selectById(caseAppear.getCaseTaskId());
            // 审核通过
            if (AuditBaseConstsEnum.AUDIT_RESULT_1.getIndex().equals(caseAppear.getAuditResult())){
                // 完成当前上报审核任务
                CaseTask sbshCaseTaskPO = new CaseTask();
                sbshCaseTaskPO.setId(caseAppear.getCaseTaskId());
                sbshCaseTaskPO.setStatus(CaseTaskConsts.TASK_STATUS_2);
                sbshCaseTaskPO.setHandleUnitId(loginUser.getUnitId());
                sbshCaseTaskPO.setHandleUnitName(loginUser.getUnitName());
                sbshCaseTaskPO.setHandleUserId(loginUser.getId());
                sbshCaseTaskPO.setHandleContent(caseAppear.getAuditContent());
                sbshCaseTaskPO.setHandleUserName(loginUser.getTrueName());
                sbshCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_1);
                sbshCaseTaskPO.setHandleTime(nowDate);
                sbshCaseTaskPO.setUpdateTime(nowDate);
                mapper.updateCaseTask(sbshCaseTaskPO);
                // 完成当前上报审核任务，走待分派任务
                FlowNode dfpFlowNode = flowInfoService.completeTask(sbshCaseTask.getFlowableId(), sbshCaseTask.getProcessTaskId(),
                        FlowableConsts.OPERATION_sbsh_ty, userId);
                // 新建待分派任务
                CaseTask dfphCaseTask = new CaseTask();
                dfphCaseTask.setId(utilsClient.getNewTimeId());
                dfphCaseTask.setCaseId(sbshCaseTask.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);
                dfphCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
                // 任务处理时限
                if (dfpFlowNode.getExpire() != 0) {
                    dfphCaseTask.setExpireTime(DateUtils.addDay(nowDate, dfpFlowNode.getExpire()));
                }
                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(sbshCaseTask.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(caseAppear.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(caseAppear.getAuditContent());
                sbshCaseTaskPO.setHandleResult(CaseTaskConsts.HANDLE_RESULT_2);
                sbshCaseTaskPO.setHandleTime(nowDate);
                sbshCaseTaskPO.setUpdateTime(nowDate);
                mapper.updateCaseTask(sbshCaseTaskPO);
                // 完成当前上报审核任务，走待分派任务
                FlowNode dfpFlowNode = flowInfoService.completeTask(sbshCaseTask.getFlowableId(), sbshCaseTask.getProcessTaskId(),
                        FlowableConsts.OPERATION_sbsh_bty, userId);
                // 新建待分派任务
                CaseTask dfphCaseTask = new CaseTask();
                dfphCaseTask.setId(utilsClient.getNewTimeId());
                dfphCaseTask.setCaseId(sbshCaseTask.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(caseAppear.getAppearUnitId());
                dfphCaseTask.setCandeUnitName(caseAppear.getAppearUnitName());
                // 受理后的任务，不需要签收
                dfphCaseTask.setSignStatus(CaseTaskConsts.SIGN_STATUS_0);
                dfphCaseTask.setStatus(CaseTaskConsts.TASK_STATUS_1);
                // 任务处理时限
                if (dfpFlowNode.getExpire() != 0) {
                    dfphCaseTask.setExpireTime(DateUtils.addDay(nowDate, dfpFlowNode.getExpire()));
                }
                dfphCaseTask.setDeleteStatus(BaseConsts.DELETE_STATUS_0);
                dfphCaseTask.setCustId(dfphCaseTask.getCustId());
                dfphCaseTask.setCreateTime(nowDate);
                dfphCaseTask.setUpdateTime(nowDate);
                mapper.insert(dfphCaseTask);
            }
        }catch (Exception e){
            log.error("[CaseTaskService.webAppearAudit]调用失败，异常信息："+e, e);
            throw new ServiceException("CaseTaskService.webAppearAudit", e);
        }
    }