代码提交

liusheng

2024-08-28 bedd0a1cef215538df64470df6b8d4a022189136

 ruoyi-admin/src/main/java/com/ruoyi/web/controller/hanler/ChatWebSocketHandler.java

@@ -8,6 +8,7 @@
import com.smartor.domain.*;
import com.smartor.mapper.IvrLibaExtemplatescriptMapper;
import com.smartor.service.IIvrLibaTemplateService;
import com.smartor.service.IIvrTaskTemplateService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@@ -31,7 +32,7 @@

    private static RedisCache redisCache;

    private static IIvrLibaTemplateService ivrLibaTemplateService;
    private static IIvrTaskTemplateService ivrTaskTemplateService;

    private static IvrLibaExtemplatescriptMapper ivrLibaExtemplatescriptMapper;

@@ -44,8 +45,8 @@
    }

    @Autowired
    public void setTodayReaderService(IIvrLibaTemplateService ivrLibaTemplateService) {
        ChatWebSocketHandler.ivrLibaTemplateService = ivrLibaTemplateService;
    public void setTodayReaderService(IIvrTaskTemplateService ivrTaskTemplateService) {
        ChatWebSocketHandler.ivrTaskTemplateService = ivrTaskTemplateService;
    }

    @Autowired
@@ -115,17 +116,17 @@
        if (session != null && session.isOpen()) {
            if (socketMessage.getTemplateId() != null) {
                //通过模板ID获取模板问题
                IvrLibaTemplateVO ivrLibaTemplateVO = new IvrLibaTemplateVO();
                ivrLibaTemplateVO.setID(socketMessage.getTemplateId());
                IvrLibaTemplateVO ivrLibaTemplateVO1 = ivrLibaTemplateService.selectInfoByCondition(ivrLibaTemplateVO);
                redisCache.setCacheObject(userId + "ivrLibaTemplateVO1", ivrLibaTemplateVO1, 120, TimeUnit.MINUTES);
                IvrTaskTemplateVO ivrTaskTemplateVO = new IvrTaskTemplateVO();
                ivrTaskTemplateVO.setId(socketMessage.getTemplateId());
                IvrTaskTemplateVO ivrTaskTemplateVO1 = ivrTaskTemplateService.selectInfoByCondition(ivrTaskTemplateVO);
                redisCache.setCacheObject(userId + "ivrTaskTemplateVO1", ivrTaskTemplateVO1, 120, TimeUnit.MINUTES);
                //将查出来的问题,放到全局变量中去
                List<IvrLibaTemplateScriptVO> ivrLibaTemplateScriptVOList = ivrLibaTemplateVO1.getIvrLibaTemplateScriptVOList();
                List<IvrTaskTemplateScriptVO> ivrTaskTemplateScriptVOList = ivrTaskTemplateVO1.getIvrTaskTemplateScriptVOList();
                //根据序号进行排序
                Collections.sort(ivrLibaTemplateScriptVOList, Comparator.comparing(IvrLibaTemplateScriptVO::getTargetid));
                Collections.sort(ivrTaskTemplateScriptVOList, Comparator.comparing(IvrTaskTemplateScriptVO::getTargetid));

                //将查出来的数据放到redis中
                redisCache.setCacheObject(userId + "ivrLibaTemplateScriptVOList", ivrLibaTemplateScriptVOList, 120, TimeUnit.MINUTES);
                redisCache.setCacheObject(userId + "ivrTaskTemplateScriptVOList", ivrTaskTemplateScriptVOList, 120, TimeUnit.MINUTES);
                //用来返回调查的总结果
                redisCache.setCacheObject(userId + "backQuset", new ArrayList<>(), 120, TimeUnit.MINUTES);
                //用来记录无声响应次数
@@ -138,14 +139,14 @@
                //用来返回当前需要问的问题信息
                QuestionMessage returnQues = new QuestionMessage();

                for (IvrLibaTemplateScriptVO ivrLibaTemplateScriptVO : ivrLibaTemplateScriptVOList) {
                    if (ivrLibaTemplateScriptVO.getTargetid() == ivrLibaTemplateVO1.getFirstQuestionNum().intValue())
                for (IvrTaskTemplateScriptVO ivrTaskTemplateScriptVO : ivrTaskTemplateScriptVOList) {
                    if (ivrTaskTemplateScriptVO.getTargetid() == ivrTaskTemplateVO1.getFirstQuestionNum().intValue())
                        //获取第一题的问题
                        returnQues.setNowQuestion(ivrLibaTemplateScriptVO);
//                        returnQues.setCode(ivrLibaTemplateScriptVO.getTargetid() + 1);
                        returnQues.setNowQuestion(ivrTaskTemplateScriptVO);
//                        returnQues.setCode(ivrTaskTemplateScriptVO.getTargetid() + 1);
                }
//                returnQues.setKcb("你好,大傻狗,我们是某某某医院,现在需要做一次随访;");
                returnQues.setKcb(ivrLibaTemplateVO1.getRevisitBefore());
//              设置开场白
                returnQues.setKcb(ivrTaskTemplateVO1.getRevisitBefore());

                //记录响应
                redisCache.setCacheObject(userId + "returnQues", returnQues, 120, TimeUnit.MINUTES);
@@ -157,40 +158,40 @@
                }

                QuestionMessage questionMessage = socketMessage.getQuestionMessage();
                List<IvrLibaTemplateScriptVO> ivrLibaTemplateScriptVOList = redisCache.getCacheObject(userId + "ivrLibaTemplateScriptVOList");
                List<IvrTaskTemplateScriptVO> ivrTaskTemplateScriptVOList = redisCache.getCacheObject(userId + "ivrTaskTemplateScriptVOList");
                //根据前端传回的条件，获取当前题目
                IvrLibaTemplateScriptVO ivrLibaTemplateScriptVO = questionMessage.getNowQuestion();
                if (ivrLibaTemplateScriptVO.getID() == null) {
                IvrTaskTemplateScriptVO ivrTaskTemplateScriptVO = questionMessage.getNowQuestion();
                if (ivrTaskTemplateScriptVO.getId() == null) {
                    QuestionMessage returnQues = redisCache.getCacheObject(userId + "returnQues");
                    ivrLibaTemplateScriptVO = returnQues.getNowQuestion();
                    ivrTaskTemplateScriptVO = returnQues.getNowQuestion();
                }
                //获取模板信息
                IvrLibaTemplateVO ivrLibaTemplateVO1 = redisCache.getCacheObject(userId + "ivrLibaTemplateVO1");
                IvrTaskTemplateVO ivrTaskTemplateVO1 = redisCache.getCacheObject(userId + "ivrTaskTemplateVO1");

                if (StringUtils.isEmpty(questionMessage.getContent())) {
                    //调用ivrLibaTemplateScriptVO中的slienceText(静默话术)
                    //调用ivrTaskTemplateScriptVO中的slienceText(静默话术)
                    Integer noVoice = redisCache.getCacheObject(userId + "noVoice");
                    //实际静默次数是否 等于 模板中配置的次数
                    if (noVoice == ivrLibaTemplateVO1.getNoVoiceNum().intValue()) {
                    if (noVoice == ivrTaskTemplateVO1.getNoVoiceNum().intValue()) {
                        //用来返回调查的总结果
                        List<IvrLibaTemplateScriptVO> backQuset = new ArrayList<>();
                        backQuset.add(ivrLibaTemplateScriptVO);
                        List<IvrTaskTemplateScriptVO> backQuset = new ArrayList<>();
                        backQuset.add(ivrTaskTemplateScriptVO);
                        redisCache.setCacheObject(userId + "backQuset", backQuset, 120, TimeUnit.MINUTES);

                        //如果几次都没响应，就下一题（需要先判断是否有下一题）
                        if (ivrLibaTemplateScriptVO.getTargetid() == ivrLibaTemplateScriptVOList.size()) {
                        if (ivrTaskTemplateScriptVO.getTargetid() == ivrTaskTemplateScriptVOList.size()) {
                            //如果下一题没有了，就结束了
                            QuestionMessage returnQues = new QuestionMessage();
//                            returnQues.setCode(null);
                            List<IvrLibaTemplateScriptVO> backQusetRedis = redisCache.getCacheObject(userId + "backQuset");
                            List<IvrTaskTemplateScriptVO> backQusetRedis = redisCache.getCacheObject(userId + "backQuset");
                            returnQues.setContent(JSON.toJSONString(backQusetRedis));
                            returnQues.setJsy("感谢您的耐心回答，再见");
                            returnQues.setJsy(ivrTaskTemplateVO1.getRevisitAfter());
                            redisCache.setCacheObject(userId + "returnQues", returnQues, 120, TimeUnit.MINUTES);
                            redisCache.setCacheObject(userId + "isOver", 1, 120, TimeUnit.MINUTES);

                        } else {
                            //如果有下一题，就根据当前teagetID+1 获取下一题
                            QuestionMessage returnQues = getNextQuestion(ivrLibaTemplateScriptVOList, ivrLibaTemplateScriptVO);
                            QuestionMessage returnQues = getNextQuestion(ivrTaskTemplateScriptVOList, ivrTaskTemplateScriptVO);
                            redisCache.setCacheObject(userId + "returnQues", returnQues, 120, TimeUnit.MINUTES);
                            redisCache.setCacheObject(userId + "noVoice", 0, 120, TimeUnit.MINUTES);
                        }
@@ -205,77 +206,121 @@
                        redisCache.setCacheObject(userId + "noVoice", noVoice2, 120, TimeUnit.MINUTES);
                    }
                } else {
                    //对回答的问题,进行正则匹配（这里只针对选择题，其它题型不行）
                    for (int j = 0; j < ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().size(); j++) {
                        //包含
                        Matcher matcher = null;
                        if (StringUtils.isNotEmpty(ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex())) {
                            Pattern pattern = Pattern.compile(ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex());
                            matcher = pattern.matcher(questionMessage.getContent());
                        }
                        //不包含
                        Matcher matcher2 = null;
                        if (StringUtils.isNotEmpty(ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex2())) {
                            Pattern pattern2 = Pattern.compile(ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex2());
                            matcher2 = pattern2.matcher(questionMessage.getContent());
                        }
                        log.info("==============================Targetregex的值为：{},   Targetregex2的值为：{}", ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex(), ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex2());
                    //通过valueType判断是什么题型（值类型（1 选项  2 文本  3 数值））
                    if (ivrTaskTemplateScriptVO.getValueType() == 2 || ivrTaskTemplateScriptVO.getValueType() == 3) {
                        ivrTaskTemplateScriptVO.setQuestionResult(questionMessage.getContent());

                        if (StringUtils.isNotEmpty(ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex()) && matcher.matches() && StringUtils.isNotEmpty(ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex2()) && matcher2.matches() || StringUtils.isEmpty(ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex()) && StringUtils.isNotEmpty(ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex2()) && matcher2.matches() || StringUtils.isEmpty(ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex2()) && StringUtils.isNotEmpty(ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getTargetregex()) && matcher.matches()) {
                            //说明匹配正确了
                            ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).setIsUserOperation(true);
                            List<IvrLibaTemplateScriptVO> backQuset = redisCache.getCacheObject(userId + "backQuset");
                            //匹配完成后,将结果保存到新的数组
                            backQuset.add(ivrLibaTemplateScriptVO);
                            redisCache.setCacheObject(userId + "backQuset", backQuset, 120, TimeUnit.MINUTES);
                            //将静默置为0
                            redisCache.setCacheObject(userId + "noVoice", 0, 120, TimeUnit.MINUTES);
                            //获取下一题
                            Integer nextQuestion = ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().get(j).getNextQuestion();
                            for (IvrLibaTemplateScriptVO script : ivrLibaTemplateScriptVOList) {
                        List<IvrTaskTemplateScriptVO> backQusetList = redisCache.getCacheObject(userId + "backQuset");
                        //匹配完成后,将结果保存到新的数组
                        backQusetList.add(ivrTaskTemplateScriptVO);
                        redisCache.setCacheObject(userId + "backQuset", backQusetList, 120, TimeUnit.MINUTES);
                        //将静默置为0
                        redisCache.setCacheObject(userId + "noVoice", 0, 120, TimeUnit.MINUTES);
                        //获取下一题
                        Long nextQuestion = ivrTaskTemplateScriptVO.getTargetid() + 1;
                        if (nextQuestion > ivrTaskTemplateScriptVOList.size()) {
                            //如果下一题没有了，就结束了
                            QuestionMessage returnQues = new QuestionMessage();
                            List<IvrTaskTemplateScriptVO> backQusetRedis = redisCache.getCacheObject(userId + "backQuset");
                            returnQues.setContent(JSON.toJSONString(backQusetRedis));
                            returnQues.setJsy(ivrTaskTemplateVO1.getRevisitAfter());
                            redisCache.setCacheObject(userId + "returnQues", returnQues, 120, TimeUnit.MINUTES);
                            redisCache.setCacheObject(userId + "isOver", 1, 120, TimeUnit.MINUTES);
                        } else {
                            for (IvrTaskTemplateScriptVO script : ivrTaskTemplateScriptVOList) {
                                if (script.getTargetid() == nextQuestion) {
                                    QuestionMessage returnQues = new QuestionMessage();
                                    returnQues.setNowQuestion(script);
                                    redisCache.setCacheObject(userId + "returnQues", returnQues, 120, TimeUnit.MINUTES);
                                    break;
                                }
                            }
                            break;
                        } else {
                            //没有匹配到
                            Integer mateNum = redisCache.getCacheObject(userId + "mateNum");
                        }

                            //无匹配次数去判断是否到最大询问次数，并且所有的选项都匹配完了
                            if (mateNum == ivrLibaTemplateVO1.getMateNum().intValue() && j == ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().size() - 1) {
                                //问了最大询问次数后，还是没有匹配上,将结果保存到新的数组
                                List<IvrLibaTemplateScriptVO> backQuset = redisCache.getCacheObject(userId + "backQuset");
                                backQuset.add(ivrLibaTemplateScriptVO);
                    } else if (ivrTaskTemplateScriptVO.getValueType() == 1) {

                        //对回答的问题,进行正则匹配（这里只针对选择题，其它题型不行）x
                        for (int j = 0; j < ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().size(); j++) {
                            //包含
                            Matcher matcher = null;
                            if (StringUtils.isNotEmpty(ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).getTargetregex())) {
                                Pattern pattern = Pattern.compile(ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).getTargetregex());
                                matcher = pattern.matcher(questionMessage.getContent());
                            }
                            //不包含
                            Matcher matcher2 = null;
                            if (StringUtils.isNotEmpty(ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).getTargetregex2())) {
                                Pattern pattern2 = Pattern.compile(ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).getTargetregex2());
                                matcher2 = pattern2.matcher(questionMessage.getContent());
                            }
                            log.info("==============================Targetregex的值为：{},   Targetregex2的值为：{}", ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).getTargetregex(), ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).getTargetregex2());

                            if (StringUtils.isNotEmpty(ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).getTargetregex2()) && matcher2.matches() && StringUtils.isNotEmpty(ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).getTargetregex()) && matcher.matches() || StringUtils.isEmpty(ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).getTargetregex2()) && StringUtils.isNotEmpty(ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).getTargetregex()) && matcher.matches()) {

                                //说明匹配正确了
                                ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).setIsUserOperation(1);
                                List<IvrTaskTemplateScriptVO> backQuset = redisCache.getCacheObject(userId + "backQuset");
                                //匹配完成后,将结果保存到新的数组
                                backQuset.add(ivrTaskTemplateScriptVO);
                                redisCache.setCacheObject(userId + "backQuset", backQuset, 120, TimeUnit.MINUTES);

                                //如果下一题为空.则新的数据返回,并加上感谢语
                                if (ivrLibaTemplateScriptVO.getTargetid() < ivrLibaTemplateScriptVOList.size()) {
                                    QuestionMessage returnQues = getNextQuestion(ivrLibaTemplateScriptVOList, ivrLibaTemplateScriptVO);
                                //将静默置为0
                                redisCache.setCacheObject(userId + "noVoice", 0, 120, TimeUnit.MINUTES);
                                //获取下一题
                                Long nextQuestion = ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().get(j).getNextQuestion();
                                if (nextQuestion > ivrTaskTemplateScriptVOList.size()) {
                                    //如果下一题没有了，就结束了
                                    QuestionMessage returnQues = new QuestionMessage();
                                    List<IvrTaskTemplateScriptVO> backQusetRedis = redisCache.getCacheObject(userId + "backQuset");
                                    returnQues.setContent(JSON.toJSONString(backQusetRedis));
                                    returnQues.setJsy(ivrTaskTemplateVO1.getRevisitAfter());
                                    redisCache.setCacheObject(userId + "returnQues", returnQues, 120, TimeUnit.MINUTES);
                                    redisCache.setCacheObject(userId + "mateNum", 0, 120, TimeUnit.MINUTES);
                                } else {
                                    QuestionMessage returnQues2 = new QuestionMessage();
//                                    returnQues2.setCode(null);
                                    List<IvrLibaTemplateScriptVO> backQusetRedis = redisCache.getCacheObject(userId + "backQuset");
                                    returnQues2.setQuestionList(backQusetRedis);
                                    returnQues2.setJsy("感谢您的耐心回答，再见");
                                    redisCache.setCacheObject(userId + "returnQues", returnQues2, 120, TimeUnit.MINUTES);
                                    redisCache.setCacheObject(userId + "isOver", 1, 120, TimeUnit.MINUTES);
                                    break;
                                } else {
                                    for (IvrTaskTemplateScriptVO script : ivrTaskTemplateScriptVOList) {
                                        if (script.getTargetid() == nextQuestion) {
                                            QuestionMessage returnQues = new QuestionMessage();
                                            returnQues.setNowQuestion(script);
                                            redisCache.setCacheObject(userId + "returnQues", returnQues, 120, TimeUnit.MINUTES);
                                            break;
                                        }
                                    }
                                }
                            } else if (mateNum < ivrLibaTemplateVO1.getMateNum().intValue() && j == ivrLibaTemplateScriptVO.getIvrLibaScriptTargetoptionList().size() - 1) {
                                //没有问到规定次数
                                mateNum = mateNum + 1;
                                redisCache.setCacheObject(userId + "mateNum", mateNum, 120, TimeUnit.MINUTES);
                                break;
                            } else {
                                //没有匹配到
                                Integer mateNum = redisCache.getCacheObject(userId + "mateNum");

                                //无匹配次数去判断是否到最大询问次数，并且所有的选项都匹配完了
                                if (mateNum == ivrTaskTemplateVO1.getMateNum().intValue() && j == ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().size() - 1) {
                                    //问了最大询问次数后，还是没有匹配上,将结果保存到新的数组
                                    List<IvrTaskTemplateScriptVO> backQuset = redisCache.getCacheObject(userId + "backQuset");
                                    backQuset.add(ivrTaskTemplateScriptVO);
                                    redisCache.setCacheObject(userId + "backQuset", backQuset, 120, TimeUnit.MINUTES);

                                    //如果下一题为空.则新的数据返回,并加上感谢语
                                    if (ivrTaskTemplateScriptVO.getTargetid() < ivrTaskTemplateScriptVOList.size()) {
                                        QuestionMessage returnQues = getNextQuestion(ivrTaskTemplateScriptVOList, ivrTaskTemplateScriptVO);
                                        redisCache.setCacheObject(userId + "returnQues", returnQues, 120, TimeUnit.MINUTES);
                                        redisCache.setCacheObject(userId + "mateNum", 0, 120, TimeUnit.MINUTES);
                                    } else {
                                        QuestionMessage returnQues2 = new QuestionMessage();
//                                    returnQues2.setCode(null);
                                        List<IvrTaskTemplateScriptVO> backQusetRedis = redisCache.getCacheObject(userId + "backQuset");
                                        returnQues2.setQuestionList(backQusetRedis);
                                        returnQues2.setJsy("感谢您的耐心回答，再见");
                                        redisCache.setCacheObject(userId + "returnQues", returnQues2, 120, TimeUnit.MINUTES);
                                        redisCache.setCacheObject(userId + "isOver", 1, 120, TimeUnit.MINUTES);
                                        break;
                                    }
                                } else if (mateNum < ivrTaskTemplateVO1.getMateNum().intValue() && j == ivrTaskTemplateScriptVO.getIvrTaskScriptTargetoptionList().size() - 1) {
                                    //没有问到规定次数
                                    mateNum = mateNum + 1;
                                    redisCache.setCacheObject(userId + "mateNum", mateNum, 120, TimeUnit.MINUTES);
                                }
                            }
                        }
                    }
                    //选项匹配完成后，需要再去通过库再进行匹配一次
                    String extemplateID = ivrLibaTemplateVO1.getSubmoduleID();
                    String extemplateID = ivrTaskTemplateVO1.getSubmoduleID();
                    String[] split = extemplateID.split(",");
                    List<String> list = Arrays.asList(split);
                    List<Long> list1 = new ArrayList<>();
@@ -300,15 +345,15 @@

                            if (StringUtils.isNotEmpty(ivrLibaExtemplatescript.getSelfRegex()) && matcher.matches() && StringUtils.isNotEmpty(ivrLibaExtemplatescript.getSelfRegex2()) && matcher2.matches() || StringUtils.isEmpty(ivrLibaExtemplatescript.getSelfRegex()) && StringUtils.isNotEmpty(ivrLibaExtemplatescript.getSelfRegex2()) && matcher2.matches() || StringUtils.isEmpty(ivrLibaExtemplatescript.getSelfRegex2()) && StringUtils.isNotEmpty(ivrLibaExtemplatescript.getSelfRegex()) && matcher.matches()) {
                                QuestionMessage returnQues = redisCache.getCacheObject(userId + "returnQues");
                                IvrLibaTemplateScriptVO nowQuestion = returnQues.getNowQuestion();
                                IvrTaskTemplateScriptVO nowQuestion = returnQues.getNowQuestion();
                                nowQuestion.setSubmoduleText(ivrLibaExtemplatescript.getSwitchText());
                                nowQuestion.setSubmoduleVoice(ivrLibaExtemplatescript.getSwitchWav());
                                redisCache.setCacheObject(userId + "returnQues", returnQues, 120, TimeUnit.MINUTES);
                                if (ivrLibaExtemplatescript.getIsEnd() == 1) {
                                    //将问题置空
                                    IvrLibaTemplateScriptVO nowQuestion1 = returnQues.getNowQuestion();
                                    nowQuestion1.setQuestionText(null);
                                    nowQuestion1.setQuestionVoice(null);
                                    IvrTaskTemplateScriptVO nowQuestion1 = returnQues.getNowQuestion();
                                    nowQuestion1.setScriptContent(null);
                                    nowQuestion1.setScriptVoice(null);
                                    returnQues.setNowQuestion(nowQuestion1);
                                    redisCache.setCacheObject(userId + "returnQues", returnQues, 120, TimeUnit.MINUTES);

@@ -319,21 +364,22 @@
                        }
                    }
                }

            }
            QuestionMessage returnQues = redisCache.getCacheObject(userId + "returnQues");
            List<IvrLibaTemplateScriptVO> backQusetRedis = redisCache.getCacheObject(userId + "backQuset");
            List<IvrTaskTemplateScriptVO> backQusetRedis = redisCache.getCacheObject(userId + "backQuset");
            returnQues.setQuestionList(backQusetRedis);
            session.sendMessage(new TextMessage(JSON.toJSONString(returnQues).getBytes(StandardCharsets.UTF_8)));

            //整个流程是否结束，将redis中的该userId下的数据删除;
            Integer isOver = redisCache.getCacheObject(userId + "isOver");
            if (isOver == 1) {
                redisCache.deleteObject(userId + "ivrLibaTemplateScriptVOList");
                redisCache.deleteObject(userId + "ivrTaskTemplateScriptVOList");
                redisCache.deleteObject(userId + "backQuset");
                redisCache.deleteObject(userId + "noVoice");
                redisCache.deleteObject(userId + "returnQues");
                redisCache.deleteObject(userId + "isOver");
                redisCache.deleteObject(userId + "ivrLibaTemplateVO1");
                redisCache.deleteObject(userId + "ivrTaskTemplateVO1");
                try {
                    //断开链接
                    afterConnectionClosed(session, null);
@@ -345,12 +391,12 @@
    }

    //获取下一题（这个方法不适合选项中的nextQuestion）
    private QuestionMessage getNextQuestion(List<IvrLibaTemplateScriptVO> ivrLibaTemplateScriptVOList, IvrLibaTemplateScriptVO ivrLibaTemplateScriptVO) {
    private QuestionMessage getNextQuestion(List<IvrTaskTemplateScriptVO> ivrTaskTemplateScriptVOList, IvrTaskTemplateScriptVO ivrTaskTemplateScriptVO) {
        QuestionMessage returnQues = new QuestionMessage();
        for (int j = 0; j < ivrLibaTemplateScriptVOList.size(); j++) {
            if (ivrLibaTemplateScriptVOList.get(j).getTargetid() == ivrLibaTemplateScriptVO.getTargetid() + 1) {
        for (int j = 0; j < ivrTaskTemplateScriptVOList.size(); j++) {
            if (ivrTaskTemplateScriptVOList.get(j).getTargetid() == ivrTaskTemplateScriptVO.getTargetid() + 1) {
                // 对该条templateScriptVO进行处理
                returnQues.setNowQuestion(ivrLibaTemplateScriptVOList.get(j));
                returnQues.setNowQuestion(ivrTaskTemplateScriptVOList.get(j));
            }
        }
        return returnQues;