新增Orgid

liusheng

2025-09-29 55f5271f893a25a7be671b24938e49976936a67b

 ruoyi-admin/src/main/java/com/ruoyi/web/component/RedisMqReceiver.java

@@ -5,6 +5,7 @@
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.dx.MessageSend;
import com.ruoyi.common.enums.MsgLSEnum;
import com.ruoyi.common.enums.ServiceFromEnum;
import com.ruoyi.common.enums.WxGZHEnum;
@@ -14,11 +15,10 @@
import com.ruoyi.common.utils.RSAPublicKeyExample;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.http.HttpUtils;
import com.ruoyi.system.service.ISysConfigService;
import com.smartor.common.LSHospTokenUtil;
import com.smartor.domain.*;
import com.smartor.mapper.PatArchiveMapper;
import com.smartor.mapper.ServiceSubtaskMapper;
import com.smartor.mapper.ServiceTaskMapper;
import com.smartor.mapper.*;
import com.smartor.service.IBaseSmsaccountService;
import com.smartor.service.IServiceOutPathService;
import com.smartor.service.IServiceSubtaskRecordService;
@@ -34,6 +34,8 @@

import java.io.IOException;
import java.security.MessageDigest;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
@@ -63,6 +65,10 @@
    @Autowired
    private ServiceSubtaskMapper ivrTaskcallMapper;


    @Autowired
    private HeLibraryMapper heLibraryMapper;

    @Autowired
    private ServiceTaskMapper ivrTaskMapper;

@@ -79,6 +85,9 @@
    private ServiceSubtaskMapper serviceSubtaskMapper;

    @Autowired
    private ServiceSubtaskPreachformMapper serviceSubtaskPreachformMapper;

    @Autowired
    private IServiceSubtaskRecordService serviceSubtaskRecordService;

    @Autowired
@@ -93,6 +102,9 @@
    @Value("${server.port}")
    private String port;

    @Autowired
    private ISysConfigService configService;

    // 创建固定大小的线程池
    private static final ExecutorService executorService = Executors.newFixedThreadPool(10);

@@ -104,7 +116,7 @@
    public void onMessage(Message message, byte[] pattern) {
        log.info("监听Redis key过期，key：{}，channel：{}", message.toString(), new String(pattern));
        String ip = localIP;
        log.error("本机的网络IP为:{}", ip);
        log.info("本机的网络IP为:{}", ip);
        String content = message.toString();
        //判断是不是任务信息，如果不是，直接返回，不需要执行
        if (!content.contains("taskid") || !port.equals("8095")) {
@@ -154,538 +166,576 @@
     * @param commonTaskcallMQ
     */
    public void tsakHandle(CommonTaskcallMQ commonTaskcallMQ, String ip, Integer type) {
        log.error("进任务了吗？{}", commonTaskcallMQ);
        log.info("进任务了吗？{}", commonTaskcallMQ);
        //判断一下commonTaskcallMQ中的stopstate是否与ivr_task中的一致，不一致，则说明是暂停了
        ServiceTask ivrTask1 = ivrTaskMapper.selectServiceTaskByTaskid(commonTaskcallMQ.getTaskid());

//        if (ivrTask1.getStopState() != commonTaskcallMQ.getStopState()) {
//            //将消息从队列中剔除
//            return;
//        }
        //通过任务ID拿到患者信息
        ServiceSubtaskVO serviceSubtaskVO = new ServiceSubtaskVO();
        serviceSubtaskVO.setTaskid(commonTaskcallMQ.getTaskid());
        serviceSubtaskVO.setSendstate(2L);
        List<ServiceSubtask> selectServiceSubtaskList = ivrTaskcallMapper.selectServiceSubtaskList(serviceSubtaskVO);

        if (StringUtils.isNotEmpty(commonTaskcallMQ.getPreachform())) {
            //如何任务发送方式不为空
            String[] split = commonTaskcallMQ.getPreachform().split(",");
            log.error("split的值为：{}", split);
        for (ServiceSubtask serviceSubtask : selectServiceSubtaskList) {
            //先判断患者是不是还要发送
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(serviceSubtask.getPatid());
            if (!Objects.isNull(patArchive) && patArchive.getNotrequiredFlag() == "1") {
                //不需要发送
                serviceSubtask.setResult("患者不需要随访");
                serviceSubtask.setRemark(patArchive.getNotrequiredreason());
                serviceSubtask.setSendstate(4L);
                serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                setFailPreachForm(serviceSubtask, "-1", "不需要执行", "6");
                continue;
            }

            //定义一个集合，用与存没有执行的子任务ID
            List<Long> subIds = new ArrayList<>();
            //临时存没有执行的子任务ID
            List<Long> lssubIds = new ArrayList<>();
            //是否将全部患者者发送完
            Boolean isSend = false;
            ServiceSubtaskPreachform serviceSubtaskPreachform = new ServiceSubtaskPreachform();
            serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
            serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
            //获取发送方式
            String sendPreachform = getSendPreachform(serviceSubtaskPreachform, serviceSubtask);
            if (sendPreachform.equals("-1") || serviceSubtask.getSendstate() == 6 || serviceSubtask.getSendstate() == 5 || serviceSubtask.getSendstate() == 4) {
                //说明已经全部遍历完了，当前的执行方式序号是最后一个了   或者  该患者已经随访结束（成功或失败了或不执行）
                continue;
            }

            aa:
            for (String serviceFrom : split) {
                String descByCode = ServiceFromEnum.getDescByCode(Integer.valueOf(serviceFrom));
                if (isSend == true) {
                    break aa;
                }
            String descByCode = ServiceFromEnum.getDescByCode(Integer.valueOf(sendPreachform));
            if (descByCode.equals("电话")) {
                try {
                    ServiceTask ivrTask = ivrTaskMapper.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
                    if (ivrTask.getSendState() != null && ivrTask.getSendState() == 3 || ivrTask.getSendState() != null && ivrTask.getSendState() == 4) {
                        //如何任务被“暂停”或“终止”
                        break;
                    }
                    if (org.apache.commons.lang3.StringUtils.isEmpty(serviceSubtask.getPhone())) {
                        serviceSubtask.setCurrentPreachform(sendPreachform);
                        serviceSubtask.setVisitTime(getNextVisitTime(serviceSubtask.getId(), serviceSubtask.getTaskid(), serviceSubtask.getVisitTime(), serviceSubtask.getCurrentPreachform()));
                        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                        setFailPreachForm(serviceSubtask, sendPreachform, "手机号为空", "4");
                        continue;
                    }

                //通过任务ID拿到患者信息
                ServiceSubtaskVO ivrTaskcall = new ServiceSubtaskVO();
                ivrTaskcall.setTaskid(commonTaskcallMQ.getTaskid());
                ivrTaskcall.setSendstate(1L);
                List<ServiceSubtask> selectServiceSubtaskList = ivrTaskcallMapper.selectServiceSubtaskList(ivrTaskcall);
                if (CollectionUtils.isEmpty(selectServiceSubtaskList)) {
                    //获取到value值最少的key
                    String key = getKey();
                    if (commonTaskcallMQ.getSendType().equals("2")) {
                        //说明是立即发送
                        List<String> list = new ArrayList<>();
                        list.add(serviceSubtask.getId().toString());
                        log.info("缓存中cache-0的值为：{}", list);
                        redisCache.setCacheListLeftAndDistinct("cache-0", list);
                    } else {
                        //非立即发送
                        List<String> list = new ArrayList<>();
                        list.add(serviceSubtask.getId().toString());
                        redisCache.setCacheListLeftAndDistinct(key, list);
                    }
                } catch (Exception exception) {
                    ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                    serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                    serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
                    serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                    serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                    serviceSubtaskRecord.setPreachform("3");
                    serviceSubtaskRecord.setResult("fail");
                    serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                    serviceSubtaskRecord.setRemark("队列任务电话发送失败");
                    log.error("队列任务电话发送失败：{}", exception.getMessage());
                    serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);
                    //将电话状态设置为失败
                    setFailPreachForm(serviceSubtask, sendPreachform, "队列任务电话发送失败", "5");

                    continue;
                }
                if (descByCode.equals("电话")) {
                    for (ServiceSubtask serviceSubtask : selectServiceSubtaskList) {
                        //先判断一下，subIds是否为空，如果不为空，只执行subIds里的患者
                        if (CollectionUtils.isNotEmpty(subIds)) {
                            boolean contains = subIds.contains(serviceSubtask.getId());
                            //如果contains不为true,说明当前的患者已经发送成功，直接循环下一个人就行
                            if (!contains) continue;
                //在子任务表里记录一下
                setFailPreachForm(serviceSubtask, sendPreachform, "队列任务电话发送成功", "2");

                //任务发送记录
                ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
                serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                serviceSubtaskRecord.setPreachform("3");
                serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                serviceSubtaskRecord.setRemark("队列任务电话发送成功");
                serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);

            } else if (descByCode.equals("短信")) {
                //短信
                //对url中两个参数加密
                RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
                String taskId = rsaPublicKeyExample.encryptedData(ivrTask1.getTaskid().toString(), pub_key);

                if (org.apache.commons.lang3.StringUtils.isEmpty(serviceSubtask.getPhone())) {
                    setFailPreachForm(serviceSubtask, sendPreachform, "手机号为空", "4");
                    continue;
                }

                try {
                    String patid = rsaPublicKeyExample.encryptedData(serviceSubtask.getPatid().toString(), pub_key);
                    String subId = rsaPublicKeyExample.encryptedData(serviceSubtask.getId().toString(), pub_key);
                    SendMagParam sendMagParam = new SendMagParam();
                    sendMagParam.setType("4");
                    if (type == 1) {
                        //随访
                        ServiceOutPath serviceOutPath = new ServiceOutPath();
                        serviceOutPath.setParam1(taskId);
                        serviceOutPath.setParam2(patid);
                        serviceOutPath.setParam6(subId);
                        serviceOutPath.setCreateTime(new Date());
                        iServiceOutPathService.insertServiceOutPath(serviceOutPath);
//                                sendMagParam.setUrl(ip + ":" + req_path + "/followvisit/particty?param1=" + taskId + "&param2=" + patid + "&param5=false");
                        //转成16进制
                        String format = String.format("%03X", serviceOutPath.getId());
                        serviceOutPath.setRadix(format);
                        serviceOutPath.setUpdateTime(new Date());
                        iServiceOutPathService.updateServiceOutPath(serviceOutPath);
                        sendMagParam.setPhone(serviceSubtask.getPhone());
                        sendMagParam.setUrl(ip + ":" + req_path + "/sf?p=" + format);
                        if (visitHosp == 2) {
                            sendMagParam.setContent("您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                        } else if (visitHosp == 1) {
                            sendMagParam.setContent("【新华医院】您好，邀请您填写出院随访调查表，请点击" + sendMagParam.getUrl() + "填写。感谢您配合！");
                        }

                        try {
                            ServiceTask ivrTask = ivrTaskMapper.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
                            if (ivrTask.getSendState() != null && ivrTask.getSendState() == 3 || ivrTask.getSendState() != null && ivrTask.getSendState() == 4) {
                                //如何任务被“暂停”或“终止”
                                break;
                            }
                            //获取到value值最少的key
                            String key = getKey();
                            if (commonTaskcallMQ.getSendType().equals("2")) {
                                //说明是立即发送
                                ServiceSubtaskVO serviceSubtask1 = new ServiceSubtaskVO();
                                serviceSubtask1.setTaskid(commonTaskcallMQ.getTaskid());
                                log.error("缓存中serviceSubtask1的值为：{}", serviceSubtask1);
                                List<String> list = new ArrayList<>();
                                List<ServiceSubtask> selectServiceSubtaskList1 = ivrTaskcallMapper.selectServiceSubtaskList(serviceSubtask1);
                                for (ServiceSubtask serviceSubtask2 : selectServiceSubtaskList1) {
                                    list.add(serviceSubtask2.getId().toString());
                                }
                                log.error("缓存中cache-0的值为：{}", list);
//                                redisCache.setCacheListLeft("cache-0", list);
                                redisCache.setCacheListLeftAndDistinct("cache-0", list);
                            } else {
                                //非立即发送
                                ServiceSubtaskVO serviceSubtask1 = new ServiceSubtaskVO();
                                serviceSubtask1.setTaskid(commonTaskcallMQ.getTaskid());
                                List<ServiceSubtask> selectServiceSubtaskList1 = ivrTaskcallMapper.selectServiceSubtaskList(serviceSubtask1);
                                List<String> list = new ArrayList<>();
                                for (ServiceSubtask serviceSubtask2 : selectServiceSubtaskList1) {
                                    list.add(serviceSubtask2.getId().toString());
                                }
//                                redisCache.setCacheListLeft(key, list);
                                redisCache.setCacheListLeftAndDistinct(key, list);
                            }
                        } catch (Exception exception) {
                            ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                            serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                            serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
                            serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                            serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                            serviceSubtaskRecord.setPreachform("3");
                            serviceSubtaskRecord.setResult("fail");
                            serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                            serviceSubtaskRecord.setRemark("队列任务电话发送失败");
                            log.error("队列任务电话发送失败：{}", exception.getMessage());
                            lssubIds.add(serviceSubtask.getId());
                            serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);
                    } else if (type == 2) {
                        //问券（问题）
                        ServiceOutPath serviceOutPath = new ServiceOutPath();
                        serviceOutPath.setParam1(taskId);
                        serviceOutPath.setParam2(patid);
                        serviceOutPath.setParam6(subId);
//                                serviceOutPath.setParam3(URLEncoder.encode(ivrTask1.getTaskName(), StandardCharsets.UTF_8.toString()));
                        serviceOutPath.setParam3(ivrTask1.getTaskName());
                        serviceOutPath.setCreateTime(new Date());
                        iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                        String format = String.format("%03X", serviceOutPath.getId());
                        serviceOutPath.setRadix(format);
                        serviceOutPath.setUpdateTime(new Date());
                        iServiceOutPathService.updateServiceOutPath(serviceOutPath);
//                                sendMagParam.setUrl(ip + ":" + req_path + "/outsideChainwt?param1=" + taskId + "&param2=" + patid + "&param3=" + URLEncoder.encode(ivrTask1.getTaskName(), StandardCharsets.UTF_8.toString()) + "&param5=false");
                        sendMagParam.setPhone(serviceSubtask.getPhone());
                        sendMagParam.setUrl(ip + ":" + req_path + "/wt?p=" + format);
                        //如果type是语音随访的话（说明补偿发送方式中有电话随访的方式，这里的外链就地址只能用/sf）
                        if (serviceSubtask.getType().equals("1"))
                            sendMagParam.setUrl(ip + ":" + req_path + "/sf?p=" + format);
                        if (serviceSubtask.getOrgid().equals("47255004333112711A1001")) {
                            sendMagParam.setContent("【景宁畲族自治县人民医院】您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                        } else if (serviceSubtask.getOrgid().equals("47255004333112711A1001")) {
                            sendMagParam.setContent("【丽水中医院】您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                        } else sendMagParam.setContent("【新华医院】您好，邀请您填写出院调查表，请点击" + sendMagParam.getUrl() + "填写。感谢您配合！");
                    } else if (type == 3) {
                        //宣教
                        ServiceOutPath serviceOutPath = new ServiceOutPath();
                        serviceOutPath.setParam1(taskId);
                        serviceOutPath.setParam2(patid);
                        serviceOutPath.setParam6(subId);
                        serviceOutPath.setParam3(ivrTask1.getTaskName());
                        serviceOutPath.setCreateTime(new Date());
                        iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                        String format = String.format("%03X", serviceOutPath.getId());
                        serviceOutPath.setRadix(format);
                        serviceOutPath.setUpdateTime(new Date());
                        iServiceOutPathService.updateServiceOutPath(serviceOutPath);
                        //需要通过模板ID去判断要发的内容是宣教还是通知
                        HeLibrary heLibrary = heLibraryMapper.selectHeLibraryById(serviceSubtask.getLibtemplateid());
                        if (heLibrary.getHetype().equals("1")) {
                            sendMagParam.setPhone(serviceSubtask.getPhone());
                            sendMagParam.setUrl(ip + ":" + req_path + "/xj?p=" + format);
                            if (serviceSubtask.getOrgid().equals("47255004333112711A1001")) {
                                sendMagParam.setContent("【景宁畲族自治县人民医院】您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                            } else if (serviceSubtask.getOrgid().equals("47255004333112711A1001")) {
                                sendMagParam.setContent("【丽水中医院】您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                            } else
                                sendMagParam.setContent("【新华医院】您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                        } else {
                            //通知
                            sendMagParam.setPhone(serviceSubtask.getPhone());
                            sendMagParam.setContent(heLibrary.getPreachcontent());
                        }
                    }

                    //短信还需要模板
                    String s = null;
                    if (visitHosp == 1) {
                        //新华的短信发送方式
                        Map<String, String> req = new HashMap<>();
                        req.put("phone", sendMagParam.getPhone());
                        req.put("content", sendMagParam.getContent());
                        s = HttpUtil.postJsonRequest(xhsmsPath, new Gson().toJson(req));
                    } else if (visitHosp == 2) {
                        String url = configService.selectConfigByKey("token.360", serviceSubtask.getOrgid());
                        //丽水的短信发送方式
                        Map<String, String> map = MsgLSEnum.getAddressByCode(serviceSubtask.getOrgid());
                        String token = LSHospTokenUtil.getToken(serviceSubtask.getOrgid(), url);
                        log.info("-----------token的值为：{}", token);
                        if (ObjectUtils.isNotEmpty(map) && StringUtils.isEmpty(map.get("address"))) {
                            serviceSubtask.setCurrentPreachform(sendPreachform);
                            serviceSubtask.setVisitTime(getNextVisitTime(serviceSubtask.getId(), serviceSubtask.getTaskid(), serviceSubtask.getVisitTime(), serviceSubtask.getCurrentPreachform()));
                            setFailPreachForm(serviceSubtask, descByCode, "短信发送失败,该机构没有配置短信地址", "5");
                            serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                            continue;
                        }
                        log.info("---------mq丽水短信发送入参address：{},  sendMagParam:{},  orgid:{}-------", map.get("address"), sendMagParam, serviceSubtask.getOrgid());
                        String dxCode = getDXCode(map.get("address"), sendMagParam.getPhone(), sendMagParam.getContent(), map.get("sendPersonId"), map.get("sendPersonName"), MsgLSEnum.getHeaderByCode(serviceSubtask.getOrgid()), token);
                        log.info("---------丽水短信发送结果：{}-------", dxCode);
                        ObjectMapper objectMapper = new ObjectMapper();
                        Map<String, Object> textParam = objectMapper.readValue(dxCode, Map.class);
                        String code = textParam.get("Code").toString();
                        if (code.equals("0")) {
                            s = "true";
                        } else {
                            setFailPreachForm(serviceSubtask, sendPreachform, "短信发送失败", "5");
                            throw new BaseException("短信发送失败");
                        }
                    } else if (visitHosp == 3) {
                        //省立同德的短信发送方式
                        JSONObject data = MessageSend.sendMsg(sendMagParam.getContent(), "2", sendMagParam.getPhone(), LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss")));
                        String code = data.get("code").toString();
                        if (StringUtils.isNotEmpty(code) && code.equals("00000")) {
                            s = "true";
                        } else {
                            setFailPreachForm(serviceSubtask, sendPreachform, "短信发送失败", "5");
                            throw new BaseException("短信发送失败");
                        }
                    }
                    if (s.equals("true")) {
                        //在子任务表里记录一下
                        String uuid = UUID.randomUUID().toString();
                        serviceSubtask.setResult("success");
                        serviceSubtask.setRemark("队列任务电话发送成功");
                        serviceSubtask.setGuid(uuid);
                        serviceSubtask.setSendstate(3L);
                        serviceSubtask.setFinishtime(new Date());
                        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);

                        setFailPreachForm(serviceSubtask, sendPreachform, "短信发送成功", "2");
                        //任务发送记录
                        ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                        serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                        serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
                        serviceSubtaskRecord.setUuid(uuid);
                        serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                        serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                        serviceSubtaskRecord.setPreachform("3");
                        serviceSubtaskRecord.setPreachform("5");
                        serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                        serviceSubtaskRecord.setRemark("队列任务电话发送成功");
                        serviceSubtaskRecord.setResult("success");
                        serviceSubtaskRecord.setRemark("短信发送成功");
                        serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);
                        log.error("serviceSubtaskRecord保存成功了吗？：{}", serviceSubtaskRecord);
                    } else {
                        //在子任务表里记录一下
                        setFailPreachForm(serviceSubtask, sendPreachform, "短信发送失败", "5");
                    }
                    if (CollectionUtils.isEmpty(lssubIds)) {
                        //如果“临时子任务”为空，说明全发送完了
                        isSend = true;
                    }
                    //将子任务ID清空，将“临时子任务”数据 放到 “子任务” 中
                    subIds.clear();
                    subIds.addAll(lssubIds);
                    lssubIds.clear();
                }
                else if (descByCode.equals("多媒体")) {
                    //多媒体
                } catch (Exception e) {
                    ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                    serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                    serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
                    serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                    serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                    serviceSubtaskRecord.setPreachform("4");
                    serviceSubtaskRecord.setResult("fail");
                    serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                    serviceSubtaskRecord.setRemark("短信发送失败");
                    log.error("短信发送失败：{}", e.getMessage());
                    serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);
                    setFailPreachForm(serviceSubtask, sendPreachform, "短信发送失败", "5");
                    continue;
                }
                else if (descByCode.equals("纸质")) {
                    //纸质
                    continue;
                }
                else if (descByCode.equals("短信")) {
                    //短信
                    //对url中两个参数加密
                    RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
                    String taskId = rsaPublicKeyExample.encryptedData(ivrTask1.getTaskid().toString(), pub_key);

                    for (ServiceSubtask serviceSubtask : selectServiceSubtaskList) {
                        //先判断一下，subIds是否为空，如果不为空，只执行subIds里的患者
                        if (CollectionUtils.isNotEmpty(subIds)) {
                            boolean contains = subIds.contains(serviceSubtask.getId());
                            //如果contains不为true,说明当前的患者已经发送成功，直接循环下一个人就行
                            if (!contains) continue;
                        }
            } else if (descByCode.equals("公众号")) {
                //公众号
                RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
                String taskId = rsaPublicKeyExample.encryptedData(ivrTask1.getTaskid().toString(), pub_key);
                String patid = rsaPublicKeyExample.encryptedData(serviceSubtask.getPatid().toString(), pub_key);

                        try {
                            String patid = rsaPublicKeyExample.encryptedData(serviceSubtask.getPatid().toString(), pub_key);
                            String subId = rsaPublicKeyExample.encryptedData(serviceSubtask.getId().toString(), pub_key);
                            SendMagParam sendMagParam = new SendMagParam();
                            sendMagParam.setType("4");
                            if (type == 1) {
                                //随访
                                ServiceOutPath serviceOutPath = new ServiceOutPath();
                                serviceOutPath.setParam1(taskId);
                                serviceOutPath.setParam2(patid);
                                serviceOutPath.setParam6(subId);
                                serviceOutPath.setCreateTime(new Date());
                                iServiceOutPathService.insertServiceOutPath(serviceOutPath);
//                                sendMagParam.setUrl(ip + ":" + req_path + "/followvisit/particty?param1=" + taskId + "&param2=" + patid + "&param5=false");
                                //转成16进制
                                String format = String.format("%03X", serviceOutPath.getId());
                                serviceOutPath.setRadix(format);
                                serviceOutPath.setUpdateTime(new Date());
                                iServiceOutPathService.updateServiceOutPath(serviceOutPath);
                                sendMagParam.setPhone(serviceSubtask.getPhone());
                                sendMagParam.setUrl(ip + ":" + req_path + "/sf?p=" + format);
                                if (visitHosp == 2) {
                                    sendMagParam.setContent("您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                                } else if (visitHosp == 1) {
                                    sendMagParam.setContent("【新华医院】您好，邀请您填写出院随访调查表，请点击" + sendMagParam.getUrl() + "填写。感谢您配合！");
                                }

                            } else if (type == 2) {
                                //问券（问题）
                                ServiceOutPath serviceOutPath = new ServiceOutPath();
                                serviceOutPath.setParam1(taskId);
                                serviceOutPath.setParam2(patid);
                                serviceOutPath.setParam6(subId);
//                                serviceOutPath.setParam3(URLEncoder.encode(ivrTask1.getTaskName(), StandardCharsets.UTF_8.toString()));
                                serviceOutPath.setParam3(ivrTask1.getTaskName());
                                serviceOutPath.setCreateTime(new Date());
                                iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                                String format = String.format("%03X", serviceOutPath.getId());
                                serviceOutPath.setRadix(format);
                                serviceOutPath.setUpdateTime(new Date());
                                iServiceOutPathService.updateServiceOutPath(serviceOutPath);
//                                sendMagParam.setUrl(ip + ":" + req_path + "/outsideChainwt?param1=" + taskId + "&param2=" + patid + "&param3=" + URLEncoder.encode(ivrTask1.getTaskName(), StandardCharsets.UTF_8.toString()) + "&param5=false");
                                sendMagParam.setPhone(serviceSubtask.getPhone());
                                sendMagParam.setUrl(ip + ":" + req_path + "/wt?p=" + format);
                                if (serviceSubtask.getOrgid().equals("47255004333112711A1001")) {
                                    sendMagParam.setContent("【景宁畲族自治县人民医院】您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                                } else if (serviceSubtask.getOrgid().equals("47255004333112711A1001")) {
                                    sendMagParam.setContent("【丽水中医院】您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                                } else
                                    sendMagParam.setContent("【新华医院】您好，邀请您填写出院调查表，请点击" + sendMagParam.getUrl() + "填写。感谢您配合！");
                            } else if (type == 3) {
                                //宣教
                                ServiceOutPath serviceOutPath = new ServiceOutPath();
                                serviceOutPath.setParam1(taskId);
                                serviceOutPath.setParam2(patid);
                                serviceOutPath.setParam6(subId);
//                                serviceOutPath.setParam3(URLEncoder.encode(ivrTask1.getTaskName(), StandardCharsets.UTF_8.toString()));
                                serviceOutPath.setParam3(ivrTask1.getTaskName());
                                serviceOutPath.setCreateTime(new Date());
                                iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                                String format = String.format("%03X", serviceOutPath.getId());
                                serviceOutPath.setRadix(format);
                                serviceOutPath.setUpdateTime(new Date());
                                iServiceOutPathService.updateServiceOutPath(serviceOutPath);
//                                sendMagParam.setUrl(ip + ":" + req_path + "/outsideChainxj?param1=" + taskId + "&param2=" + patid + "&param3=" + URLEncoder.encode(ivrTask1.getTaskName(), StandardCharsets.UTF_8.toString()) + "&param5=false");
                                sendMagParam.setPhone(serviceSubtask.getPhone());
                                sendMagParam.setUrl(ip + ":" + req_path + "/xj?p=" + format);
                                if (serviceSubtask.getOrgid().equals("47255004333112711A1001")) {
                                    sendMagParam.setContent("【景宁畲族自治县人民医院】您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                                } else if (serviceSubtask.getOrgid().equals("47255004333112711A1001")) {
                                    sendMagParam.setContent("【丽水中医院】您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                                } else
                                    sendMagParam.setContent("【新华医院】您好，邀请您填写出院宣教调查表，请点击" + sendMagParam.getUrl() + "查看。感谢您配合！");
                            }
                            //短信还需要模板
                            String s = null;
                            if (visitHosp == 1) {
                                //新华的短信发送方式
                                Map<String, String> req = new HashMap<>();
                                req.put("phone", sendMagParam.getPhone());
                                req.put("content", sendMagParam.getContent());
                                s = HttpUtil.postJsonRequest(xhsmsPath, new Gson().toJson(req));
                            } else if (visitHosp == 2) {
                                //丽水的短信发送方式
                                Map<String, String> map = MsgLSEnum.getAddressByCode(serviceSubtask.getOrgid());
                                String token = LSHospTokenUtil.getToken(serviceSubtask.getOrgid());
                                log.error("-----------token的值为：{}", token);
                                if (ObjectUtils.isNotEmpty(map) && StringUtils.isEmpty(map.get("address"))) {
                                    ServiceSubtask ss = new ServiceSubtask();
                                    ss.setResult("error");
                                    ss.setRemark("短信发送失败,该机构没有配置短信地址");
                                    ss.setSendstate(5L);
                                    ss.setId(serviceSubtask.getId());
//                                    ss.setFinishtime(new Date());
                                    serviceSubtaskMapper.updateServiceSubtask(ss);
                                    continue;
                                }
                                log.error("---------mq丽水短信发送入参address：{},  sendMagParam:{},  orgid:{}-------", map.get("address"), sendMagParam, serviceSubtask.getOrgid());
                                String dxCode = getDXCode(map.get("address"), sendMagParam.getPhone(), sendMagParam.getContent(), map.get("sendPersonId"), map.get("sendPersonName"), MsgLSEnum.getHeaderByCode(serviceSubtask.getOrgid()), token);
                                log.error("---------丽水短信发送结果：{}-------", dxCode);
                                ObjectMapper objectMapper = new ObjectMapper();
                                Map<String, Object> textParam = objectMapper.readValue(dxCode, Map.class);
                                String code = textParam.get("Code").toString();
                                if (code.equals("0")) {
                                    s = "true";
                                } else {
                                    throw new BaseException(null);
                                }
                            }
                            if (s.equals("true")) {
                                //在子任务表里记录一下
                                log.error("serviceSubtask保存成功了吗？：{}", s);
                                String uuid = UUID.randomUUID().toString();
                                serviceSubtask.setResult("success");
                                serviceSubtask.setRemark("短信发送成功");
                                serviceSubtask.setGuid(uuid);
                                serviceSubtask.setSendstate(3L);
                                serviceSubtask.setFinishtime(new Date());
                                serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);

                                //任务发送记录
                                ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                                serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                                serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
                                serviceSubtaskRecord.setUuid(uuid);
                                serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                                serviceSubtaskRecord.setPreachform("5");
                                serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                                serviceSubtaskRecord.setResult("success");
                                serviceSubtaskRecord.setRemark("短信发送成功");
                                serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);
                                log.error("serviceSubtaskRecord保存成功了吗？：{}", serviceSubtaskRecord);
                            }
                        } catch (Exception e) {
                            ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                            serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                            serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
                            serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                            serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                            serviceSubtaskRecord.setPreachform("4");
                            serviceSubtaskRecord.setResult("fail");
                            serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                            serviceSubtaskRecord.setRemark("短信发送失败");
                            log.error("短信发送失败：{}", e.getMessage());
                            lssubIds.add(serviceSubtask.getId());
                            serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);
                            continue;
                        }


                try {
                    SendMagParam sendMagParam = new SendMagParam();
                    sendMagParam.setType("5");
                    String url = null;
                    Boolean aBoolean = false;
                    if (type == 1) {
                        //随访
                        ServiceOutPath serviceOutPath = new ServiceOutPath();
                        serviceOutPath.setParam1(taskId);
                        serviceOutPath.setParam2(patid);
                        serviceOutPath.setCreateTime(new Date());
                        iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                        String format = String.format("%03X", serviceOutPath.getId());
                        serviceOutPath.setRadix(format);
                        serviceOutPath.setUpdateTime(new Date());
                        iServiceOutPathService.updateServiceOutPath(serviceOutPath);
                        url = ip + ":" + req_path + "/sf?p=" + format;
                    } else if (type == 2) {
                        //问券
                        ServiceOutPath serviceOutPath = new ServiceOutPath();
                        serviceOutPath.setParam1(taskId);
                        serviceOutPath.setParam2(patid);
                        serviceOutPath.setParam3(ivrTask1.getTaskName());
                        serviceOutPath.setCreateTime(new Date());
                        iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                        String format = String.format("%03X", serviceOutPath.getId());
                        serviceOutPath.setRadix(format);
                        serviceOutPath.setUpdateTime(new Date());
                        iServiceOutPathService.updateServiceOutPath(serviceOutPath);
                        url = ip + ":" + req_path + "/wt?p=" + format;
                        //如果type是语音随访的话（说明补偿发送方式中有电话随访的方式，这里的外链就地址只能用/sf）
                        if (serviceSubtask.getType().equals("1"))
                            sendMagParam.setUrl(ip + ":" + req_path + "/sf?p=" + format);
                    } else if (type == 3) {
                        //宣教
                        ServiceOutPath serviceOutPath = new ServiceOutPath();
                        serviceOutPath.setParam1(taskId);
                        serviceOutPath.setParam2(patid);
                        serviceOutPath.setParam3(ivrTask1.getTaskName());
                        serviceOutPath.setCreateTime(new Date());
                        iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                        String format = String.format("%03X", serviceOutPath.getId());
                        serviceOutPath.setRadix(format);
                        serviceOutPath.setUpdateTime(new Date());
                        iServiceOutPathService.updateServiceOutPath(serviceOutPath);
                        url = ip + ":" + req_path + "/xj?p=" + format;
                    }
                    if (CollectionUtils.isEmpty(lssubIds)) {
                        //如果“临时子任务”为空，说明全发送完了
                        isSend = true;
                    if (StringUtils.isEmpty(patArchive.getPatidHis())) {
                        serviceSubtask.setCurrentPreachform(sendPreachform);
                        serviceSubtask.setVisitTime(getNextVisitTime(serviceSubtask.getId(), serviceSubtask.getTaskid(), serviceSubtask.getVisitTime(), serviceSubtask.getCurrentPreachform()));
                        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                        //失败记录
                        setFailPreachForm(serviceSubtask, sendPreachform, "公众号发送失败,his系统的患者id为空", "5");
                        continue;
                    }
                    //将子任务ID清空，将“临时子任务”数据 放到 “子任务” 中
                    subIds.clear();
                    subIds.addAll(lssubIds);
                    lssubIds.clear();
                }
                else if (descByCode.equals("公众号")) {
                    //公众号
                    RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
                    String taskId = rsaPublicKeyExample.encryptedData(ivrTask1.getTaskid().toString(), pub_key);
                    for (ServiceSubtask serviceSubtask : selectServiceSubtaskList) {
                        String patid = rsaPublicKeyExample.encryptedData(serviceSubtask.getPatid().toString(), pub_key);
                        try {
                            SendMagParam sendMagParam = new SendMagParam();
                            sendMagParam.setType("5");
                            String url = null;
                            Boolean aBoolean = false;
                            if (type == 1) {
                                //随访
                                ServiceOutPath serviceOutPath = new ServiceOutPath();
                                serviceOutPath.setParam1(taskId);
                                serviceOutPath.setParam2(patid);
                                serviceOutPath.setCreateTime(new Date());
                                iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                                String format = String.format("%03X", serviceOutPath.getId());
                                serviceOutPath.setRadix(format);
                                serviceOutPath.setUpdateTime(new Date());
                                iServiceOutPathService.updateServiceOutPath(serviceOutPath);
                                url = ip + ":" + req_path + "/sf?p=" + format;
                            } else if (type == 2) {
                                //问券
                                ServiceOutPath serviceOutPath = new ServiceOutPath();
                                serviceOutPath.setParam1(taskId);
                                serviceOutPath.setParam2(patid);
//                                serviceOutPath.setParam3(URLEncoder.encode(ivrTask1.getTaskName(), StandardCharsets.UTF_8.toString()));
                                serviceOutPath.setParam3(ivrTask1.getTaskName());
                                serviceOutPath.setCreateTime(new Date());
                                iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                                String format = String.format("%03X", serviceOutPath.getId());
                                serviceOutPath.setRadix(format);
                                serviceOutPath.setUpdateTime(new Date());
                                iServiceOutPathService.updateServiceOutPath(serviceOutPath);
                                url = ip + ":" + req_path + "/wt?p=" + format;
                            } else if (type == 3) {
                                //宣教
                                ServiceOutPath serviceOutPath = new ServiceOutPath();
                                serviceOutPath.setParam1(taskId);
                                serviceOutPath.setParam2(patid);
                                serviceOutPath.setParam3(ivrTask1.getTaskName());
                                serviceOutPath.setCreateTime(new Date());
                                iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                                String format = String.format("%03X", serviceOutPath.getId());
                                serviceOutPath.setRadix(format);
                                serviceOutPath.setUpdateTime(new Date());
                                iServiceOutPathService.updateServiceOutPath(serviceOutPath);
                                url = ip + ":" + req_path + "/xj?p=" + format;
                            }
                            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(serviceSubtask.getPatid());
                            if (StringUtils.isEmpty(patArchive.getPatidHis())) {
                                ServiceSubtask ss = new ServiceSubtask();
                                ss.setResult("error");
                                ss.setRemark("公众号发送失败,his系统的患者id为空");
                                ss.setSendstate(5L);
                                ss.setId(serviceSubtask.getId());
//                                ss.setFinishtime(new Date());
                                serviceSubtaskMapper.updateServiceSubtask(ss);
                                continue;
                            }

                            //获取微信公众号请求信息根据机构ID
                            log.error("获取微信公众号请求信息根据机构ID：{}", patArchive.getOrgid());
                            List<String> wxqqxx = WxGZHEnum.getDescByCode(patArchive.getOrgid());
                            if (CollectionUtils.isEmpty(wxqqxx) || wxqqxx.size() < 4) {
                                ServiceSubtask ss = new ServiceSubtask();
                                ss.setResult("error");
                                ss.setRemark("该机构的公众号配置信息不全，无法通过公众号发送");
                                ss.setSendstate(5L);
                                ss.setId(serviceSubtask.getId());
//                                ss.setFinishtime(new Date());
                                serviceSubtaskMapper.updateServiceSubtask(ss);
                                continue;
                            }
                    //获取微信公众号请求信息根据机构ID
                    log.error("获取微信公众号请求信息根据机构ID：{}", patArchive.getOrgid());
                    List<String> wxqqxx = WxGZHEnum.getDescByCode(patArchive.getOrgid());
                    if (CollectionUtils.isEmpty(wxqqxx) || wxqqxx.size() < 4) {
                        serviceSubtask.setCurrentPreachform(sendPreachform);
                        serviceSubtask.setVisitTime(getNextVisitTime(serviceSubtask.getId(), serviceSubtask.getTaskid(), serviceSubtask.getVisitTime(), serviceSubtask.getCurrentPreachform()));
                        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);

                        //失败记录
                        setFailPreachForm(serviceSubtask, sendPreachform, "该机构的公众号配置信息不全，无法通过公众号发送", "5");
                        continue;
                    }


                            String wxCode = getWXCode(serviceSubtask.getSfzh(), url, serviceSubtask.getTaskName(), serviceSubtask.getTaskName(), patArchive.getTelcode(), patArchive.getName(), patArchive.getPatidHis(), wxqqxx);
                            log.error("wxCode的值为:{}", wxCode);
                            Map<String, Object> map = JSONObject.parseObject(wxCode, Map.class);
                            log.error("map的值为:{}", map);
                            if (!map.isEmpty()) {
                                serviceSubtask.setResult("success");
                                serviceSubtask.setSendstate(3L);
                                log.error("aBoolean的值为:{}", aBoolean);
                                if (map.get("succ").toString().equals("true")) {
                                    aBoolean = true;
                                }
                                if (aBoolean == false) {
                                    ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                                    serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                                    serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
                                    serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                                    serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                                    serviceSubtaskRecord.setPreachform("5");
                                    serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                                    serviceSubtaskRecord.setRemark(ObjectUtils.isNotEmpty(map.get("msg")) ? map.get("msg").toString() : null);
                                    lssubIds.add(serviceSubtask.getId());
                                    serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);
                                    continue;
                                }
                            }
                        } catch (Exception e) {
                    String wxCode = getWXCode(serviceSubtask.getSfzh(), url, serviceSubtask.getTaskName(), serviceSubtask.getTaskName(), patArchive.getTelcode(), patArchive.getName(), patArchive.getPatidHis(), wxqqxx);
                    log.error("wxCode的值为:{}", wxCode);
                    Map<String, Object> map = JSONObject.parseObject(wxCode, Map.class);
                    log.error("map的值为:{}", map);
                    if (!map.isEmpty()) {
                        serviceSubtask.setResult("success");
                        serviceSubtask.setSendstate(3L);
                        log.error("aBoolean的值为:{}", aBoolean);
                        if (map.get("succ").toString().equals("true")) {
                            aBoolean = true;
                        }
                        if (aBoolean == false) {
                            ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                            serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                            serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
                            serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                            serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                            serviceSubtaskRecord.setPreachform("5");
                            serviceSubtaskRecord.setResult("fail");
                            serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                            serviceSubtaskRecord.setRemark("公众号发送失败");
                            log.error("公众号发送失败：{}", e.getMessage());
                            lssubIds.add(serviceSubtask.getId());
                            serviceSubtaskRecord.setRemark(ObjectUtils.isNotEmpty(map.get("msg")) ? map.get("msg").toString() : null);
                            serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);
                            //在子任务表里记录一下
                            setFailPreachForm(serviceSubtask, sendPreachform, "公众号发送失败", "5");
                            continue;
                        }
                        //在子任务表里记录一下
                        String uuid = UUID.randomUUID().toString();
                        serviceSubtask.setResult("success");
                        serviceSubtask.setRemark("公众号发送成功");
                        serviceSubtask.setGuid(uuid);
                        serviceSubtask.setSendstate(3L);
                        serviceSubtask.setFinishtime(new Date());
                        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);

                        //任务发送记录
                        ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                        serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                        serviceSubtaskRecord.setUuid(uuid);
                        serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                        serviceSubtaskRecord.setPreachform("5");
                        serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                        serviceSubtaskRecord.setResult("success");
                        serviceSubtaskRecord.setRemark("公众号发送成功");
                        serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);
                    }
                    if (CollectionUtils.isEmpty(lssubIds)) {
                        //如果“临时子任务”为空，说明全发送完了
                        isSend = true;
                    }
                    //将子任务ID清空，将“临时子任务”数据 放到 “子任务” 中
                    subIds.clear();
                    subIds.addAll(lssubIds);
                    lssubIds.clear();
                } catch (Exception e) {
                    ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                    serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                    serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
                    serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                    serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                    serviceSubtaskRecord.setPreachform("5");
                    serviceSubtaskRecord.setResult("fail");
                    serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                    serviceSubtaskRecord.setRemark("公众号发送失败");
                    log.error("公众号发送失败：{}", e.getMessage());
                    serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);
                    //失败记录
                    setFailPreachForm(serviceSubtask, sendPreachform, "公众号发送失败", "5");
                    continue;
                }
                //通知 MQ 消息已被接收,可以ACK(从队列中删除)了   （这个需要根据业务再去处理ACK）
                //在子任务表里记录一下
                setFailPreachForm(serviceSubtask, sendPreachform, "公众号发送成功", "2");
                //任务发送记录
                ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                serviceSubtaskRecord.setPreachform("5");
                serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                serviceSubtaskRecord.setResult("success");
                serviceSubtaskRecord.setRemark("公众号发送成功");
                serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);

            } else if (descByCode.equals("人工")) {
                setFailPreachForm(serviceSubtask, sendPreachform, "人工待执行", "2");
            }
            if (CollectionUtils.isNotEmpty(subIds)) {
                //如果全部的发送方式都发完了，还有是未发送的,需要去subTask表中，记录一下，发送失败
                for (Long id : subIds) {
                    ServiceSubtask serviceSubtask = new ServiceSubtask();
                    serviceSubtask.setResult("error");
                    serviceSubtask.setRemark("发送失败");
        }

    }

    private Date getNextVisitTime(Long subid, Long taskid, Date visitTime, String currentPreachform) {
        ServiceSubtaskPreachform serviceSubtaskPreachform = new ServiceSubtaskPreachform();
        serviceSubtaskPreachform.setSubid(subid);
        serviceSubtaskPreachform.setTaskid(taskid);
        List<ServiceSubtaskPreachform> serviceSubtaskPreachforms = serviceSubtaskPreachformMapper.selectServiceSubtaskPreachformList(serviceSubtaskPreachform);

        if (CollectionUtils.isNotEmpty(serviceSubtaskPreachforms)) {
            Optional<String> ct = serviceSubtaskPreachforms.stream().filter(item -> currentPreachform.equals(item.getPreachform())).map(ServiceSubtaskPreachform::getCompensateTime).findFirst();
            String compensateTime = "0";
            if (ct.isPresent()) compensateTime = ct.get();
            int hoursToAdd = Integer.valueOf(compensateTime) * 24;
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(visitTime);
            calendar.add(Calendar.HOUR_OF_DAY, hoursToAdd);
            Date newDate = calendar.getTime();
            return newDate;
        }
        return visitTime;
    }

    private String getSendPreachform(ServiceSubtaskPreachform serviceSubtaskPreachform, ServiceSubtask serviceSubtask) {
        List<ServiceSubtaskPreachform> serviceSubtaskPreachforms = serviceSubtaskPreachformMapper.selectServiceSubtaskPreachformList(serviceSubtaskPreachform);

        // 情况1：currentPreachform为空，取sort为1的preachform
        if (StringUtils.isEmpty(serviceSubtask.getCurrentPreachform())) {
            return serviceSubtaskPreachforms.stream().filter(item -> item.getSort() == 1L).map(ServiceSubtaskPreachform::getPreachform).findFirst().orElse(null);
        }

        // 情况2：currentPreachform不为空，找下一个sort
        Optional<Long> currentSort = serviceSubtaskPreachforms.stream().filter(item -> serviceSubtask.getCurrentPreachform().equals(item.getPreachform())).map(ServiceSubtaskPreachform::getSort).findFirst();

        if (currentSort.isPresent()) {
            // 检查是否所有sendstate不等于9
            boolean allSendStateNot1AndNot9 = serviceSubtaskPreachforms.stream().allMatch(item -> !item.getSendstate().equals("9"));

            // 当sort等于列表size时，并且所有sendstate都不等于9，则返回-1
            if (currentSort.get().equals((long) serviceSubtaskPreachforms.size())) {
                if (allSendStateNot1AndNot9) {
                    //说明全发送失败了
                    serviceSubtask.setSendstate(5L);
                    serviceSubtask.setId(id);
//                    serviceSubtask.setFinishtime(new Date());
                    serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                }
                return "-1";
            }

            // 当sort等于列表size时，下一个sort为-1
            Long nextSort = currentSort.get() + 1;

            // 找到下一个sort对应的preachform
            return serviceSubtaskPreachforms.stream().filter(item -> nextSort.equals(item.getSort())).map(ServiceSubtaskPreachform::getPreachform).findFirst().orElse(null);
        }

        return null;
    }

    //    /**
//     * 机器人第一句话语音
//     * concurrency = "50"  并发数为50
//     */
//    @RabbitListener(queues = "ob_queue", concurrency = "50")
//    public void obVisit(String content, Message message, Channel channel) throws IOException {
//        try {
//            IvrTaskcallPhoneMQ commonTaskcallMQ = null;
//            ObjectMapper mapper = new ObjectMapper();
//            commonTaskcallMQ = mapper.readValue(content, IvrTaskcallPhoneMQ.class);
//            //判断患者是否已经接电话
//            String str = redisCache.getCacheObject(commonTaskcallMQ.getUuid() + "state_id");
//            System.out.println("-----------------" + str);
//            if (StringUtils.isNotEmpty(str) && str.equals("0")) {
//                //患者已经接听了电话
//                new PhoneUtils().ttsPlayback(commonTaskcallMQ.getScript(), commonTaskcallMQ.getUuid());
//            } else if (StringUtils.isNotEmpty(str) && str.equals("-10")) {
//                //这个说明,已经打了指定遍数还是没有人接，可以将消息从队列中移除了
//                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
//                return;
//            } else {
//                //进行队列尾部，进行下一次校验
////                channel.basicRecover(false);
//                channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
//                System.out.println("++++++++++++++++++++++" + str);
//                return;
//            }
//            //通知 MQ 消息已被接收,可以ACK(从队列中删除)了   （这个需要根据业务再去处理ACK）
//            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
//        } catch (Exception e) {
//            log.error("============消费失败,尝试消息补发再次消费!==============");
//            log.error(e.getMessage());
//            channel.basicReject(message.getMessageProperties().getDeliveryTag(), true);
//        }
//    }
    private String getKey() {
        Map<String, String> map = new HashMap<>();
        for (int i = 0; i < 6; i++) {
            Boolean aBoolean = redisCache.hasKey("cache-" + i);
            if (!aBoolean) {
                redisCache.setCacheObject("cache-" + i, "");
                map.put("cache-" + i, "");
            } else {
                map.put("cache-" + i, redisCache.getCacheObject("cache-" + i));
            }

    /**
     * @param serviceSubtask
     * @param preachform
     * @param remark
     * @param failSendstate
     * @return
     */
    public Boolean setFailPreachForm(ServiceSubtask serviceSubtask, String preachform, String remark, String failSendstate) {
        if (preachform.equals("-1")) {
            //说明都不需要执行了
            ServiceSubtaskPreachform serviceSubtaskPreachform = new ServiceSubtaskPreachform();
            serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
            serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
            serviceSubtaskPreachform.setOrgid(serviceSubtask.getOrgid());
            serviceSubtaskPreachform.setSendstate(failSendstate);
            serviceSubtaskPreachformMapper.updateSSPByCondition(serviceSubtaskPreachform);
            return true;
        }

        String key = null;
        String value = "";
        for (Map.Entry<String, String> entry : map.entrySet()) {
            if (StringUtils.isEmpty(value)) {
                value = entry.getValue();
                key = entry.getKey();
            } else {
                if (entry.getValue().split(",").length < value.split(",").length) {
                    value = entry.getValue();
                    key = entry.getKey();
        //将状态设置为失败
        ServiceSubtaskPreachform serviceSubtaskPreachform = new ServiceSubtaskPreachform();
        serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
        serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
        serviceSubtaskPreachform.setOrgid(serviceSubtask.getOrgid());
        //获取该患者的发送方式总数
        List<ServiceSubtaskPreachform> spSize = serviceSubtaskPreachformMapper.selectServiceSubtaskPreachformList(serviceSubtaskPreachform);

        serviceSubtaskPreachform.setPreachform(preachform);
        //1:未发送状态
        serviceSubtaskPreachform.setSendstate("1");
        //电话的未发送状态，需要查2，因为，数据可能卡在队列里了
        if (preachform.equals("3")) serviceSubtaskPreachform.setSendstate("2");
        List<ServiceSubtaskPreachform> serviceSubtaskPreachforms = serviceSubtaskPreachformMapper.selectServiceSubtaskPreachformList(serviceSubtaskPreachform);
        if (CollectionUtils.isNotEmpty(serviceSubtaskPreachforms)) {
            ServiceSubtaskPreachform serviceSubtaskPreachform1 = serviceSubtaskPreachforms.get(0);
            serviceSubtaskPreachform1.setSendstate(failSendstate);
            serviceSubtaskPreachform1.setRemark(remark);
            serviceSubtaskPreachformMapper.updateServiceSubtaskPreachform(serviceSubtaskPreachform1);
            //如果当前的preachform已经是最后一个了,并且本次还是发送失败，那直接将serviceSubtask的sendstate状态改成5就行了(全失败了)
            if (serviceSubtaskPreachform1.getSort() == spSize.size()) {
                if (serviceSubtaskPreachform1.getSort() == spSize.size()) {
                    if (failSendstate.equals("4") || failSendstate.equals("5")) {
                        serviceSubtask.setCurrentPreachform(preachform);
                        serviceSubtask.setSendstate(5L);
                        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                        return true;
                    }
                }
            }
        } else {
            log.error("【MQ中该患者没有查询到属于他的发送方式，subid：{},prechform:{},orgid:{}】", serviceSubtask.getId(), preachform, serviceSubtask.getOrgid());
            return false;
        }
        return key;

        serviceSubtask.setCurrentPreachform(preachform);
        serviceSubtask.setVisitTime(getNextVisitTime(serviceSubtask.getId(), serviceSubtask.getTaskid(), serviceSubtask.getVisitTime(), serviceSubtask.getCurrentPreachform()));
        serviceSubtask.setSendstate(3L);
        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
        return true;
    }

    private String getKey() {
        String targetKey = null;
        long minSize = Long.MAX_VALUE;

        for (int i = 1; i < 6; i++) {
            String key = "cache-" + i;

            // 获取 list 的长度（即 value 的元素个数）
            Long size = redisCache.getListSize(key);
            if (size == null) {
                size = 0L; // 如果 key 不存在，认为是 0
            }

            // 取最小值
            if (size < minSize) {
                minSize = size;
                targetKey = key;
            }
        }
        return targetKey;
    }

//    private String getKey() {
//        Map<String, List> map = new HashMap<>();
//        for (int i = 0; i < 6; i++) {
//            Boolean aBoolean = redisCache.hasKey("cache-" + i);
//            if (!aBoolean) {
//                redisCache.setCacheList("cache-" + i, new ArrayList<String>());
//                map.put("cache-" + i, new ArrayList<String>());
//            } else {
//                map.put("cache-" + i, redisCache.getCacheObject("cache-" + i));
//            }
//        }
//
//        String key = null;
//        List<String> value = new ArrayList<String>();
//        for (Map.Entry<String, List> entry : map.entrySet()) {
//            if (CollectionUtils.isEmpty(value)) {
//                value = entry.getValue();
//                key = entry.getKey();
//            } else {
//                value = entry.getValue();
//                key = entry.getKey();
//            }
//        }
//        return key;
//    }

    private String getWXCode(String idcard, String url, String taskName, String taskDesc, String phone, String patientname, String setPatientid, List<String> wxqqxx) {
        XinHuaWXReq xinHuaWXReq = new XinHuaWXReq();
        xinHuaWXReq.setIdcard(idcard);