代码提交

liusheng

5 天以前 c7ef5f837fe90766574cee9d0eae9e89e34af263

 ruoyi-quartz/src/main/java/com/ruoyi/quartz/task/RyTask.java

@@ -3,25 +3,23 @@
import com.alibaba.fastjson2.JSONObject;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.reflect.TypeToken;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
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;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.HttpUtil;
import com.ruoyi.common.utils.OkHttpExample;
import com.ruoyi.common.utils.RSAPublicKeyExample;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.http.HttpUtils;
import com.ruoyi.common.utils.sms.smsUtils;
import com.ruoyi.quartz.service.ICollectHISService;
import com.ruoyi.system.service.ISysConfigService;
import com.smartor.common.LSHospTokenUtil;
import com.smartor.domain.*;
import com.smartor.mapper.ServiceSubtaskMapper;
import com.smartor.mapper.ServiceTaskMapper;
import com.smartor.mapper.SysUserImportMapper;
import com.smartor.mapper.*;
import com.smartor.service.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
@@ -29,20 +27,13 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.Transactional;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.Type;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.MessageDigest;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
@@ -86,16 +77,34 @@
    private IServicePatientTempService iServicePatientTempService;

    @Autowired
    private PlatformTransactionManager transactionManager;
    private IHNGatherPatArchiveService ihnGatherPatArchiveService;

    @Autowired
    private IServiceSLTDHealthcareRecordService serviceSLTDHealthcareRecordService;

    @Autowired
    private SysUserImportMapper sysUserImportMapper;

    @Autowired
    private HeLibraryMapper heLibraryMapper;

    @Autowired
    private ICollectHISService ichService;

    @Autowired
    private ISysConfigService configService;

    @Value("${localIP}")
    private String localIP;

    @Value("${xhsmsPath}")
    private String xhsmsPath;

    @Value("${xhsmsAccount}")
    private String xhsmsAccount;

    @Value("${xhsmsPwd}")
    private String xhsmsPwd;

    @Value("${pub_key}")
    private String pub_key;
@@ -124,8 +133,6 @@
    @Autowired
    IPatArchiveService patArchiveService;

    @Autowired
    IPatMedInhospService patMedInhospService;

    @Autowired
    IPatMedOuthospService patMedOuthospService;
@@ -136,14 +143,25 @@
    @Autowired
    IIvrTaskTemplateService iIvrTaskTemplateService;

    @Value("${hosp_info_url}")
    private String hospInfoUrl;
    @Autowired
    IXHGatherPatArchiveService ixhGatherPatArchiveService;

    @Autowired
    ServiceSubtaskPreachformMapper serviceSubtaskPreachformMapper;

    @Autowired
    ICollectHISService icollectHis;


    @Value("${appid}")
    private String appid;

    @Value("${server.port}")
    private String port;


    @Value("${spring.profiles.active}")
    private String active;

    public void ryMultipleParams(String s, Boolean b, Long l, Double d, Integer i) {
        System.out.println(StringUtils.format("执行多参方法： 字符串类型{}，布尔类型{}，长整型{}，浮点型{}，整形{}", s, b, l, d, i));
@@ -205,31 +223,98 @@


    /**
     * 处理his数据
     * 处理HIS数据采集
     * 定时任务：采集患者信息、出院、门诊数据
     */
    public void dealHisData() {
        //将患者信息、出院、门诊数据全部采集
        // 获取当前日期和时间
        LocalDateTime endTime = LocalDateTime.now();
        endTime = endTime.with(LocalTime.MIN);
//        String dateStr = "2024/11/30 00:00:00";
//        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
//        LocalDateTime endTime = LocalDateTime.parse(dateStr, formatter);
        // 获取前一天的日期和时间
        LocalDateTime startTime = endTime.minusDays(1);
        startTime = startTime.with(LocalTime.MIN);
        getInHospInfo("0", startTime, endTime);
        getInHospInfo("1", startTime, endTime);
        log.info("【dealHisData】开始执行HIS数据采集任务");
        // 获取昨天0点到今天0点的时间范围
        LocalDateTime todayZero = LocalDateTime.now().with(LocalTime.MIN);
        LocalDateTime yesterdayZero = todayZero.minusDays(1);
        log.info("【dealHisData】采集时间范围：{} ~ {}", yesterdayZero, todayZero);

        //调用dealOupHospInfo数据处理方法，处理完后，将“出院表的check_flag=1”
        //获取当前日期 （精确到天）往前推相应天数（在指定的基础模板中找对应的天数），
        //循环患者信息，根据患者"出院诊断ICD值”获取到相当的模板（获取取相应的天数）;
        //根据查询出来的模板，去固定任务（固定任务，已经将模板也固定了）去匹配模板
        //根据匹配出来的模板和任务与患者信息，将数据插入到子任务表中
        if (active.trim().equals("xh")) {
            try {
                // 采集入院数据
                log.info("【dealHisData】新华开始采集入院数据");
                ixhGatherPatArchiveService.getInHospDataGather("0", yesterdayZero, todayZero);
                log.info("【dealHisData】新华入院数据采集完成");

                // 采集出院数据
                log.info("【dealHisData】新华开始采集出院数据");
                ixhGatherPatArchiveService.getInHospDataGather("1", yesterdayZero, todayZero);
                log.info("【dealHisData】新华出院数据采集完成");

            } catch (Exception e) {
                log.error("【dealHisData】新华数据采集异常", e);
            }
        } else if (active.trim().equals("hn")) {
            try {
                // 河南数据采集
                HnDataGatherVO hnDataGatherVO = new HnDataGatherVO();
                log.info("【dealHisData】河南开始采集数据");
                Date startTime = Date.from(yesterdayZero.atZone(ZoneId.systemDefault()).toInstant());
                Date endTime = Date.from(todayZero.atZone(ZoneId.systemDefault()).toInstant());

                hnDataGatherVO.setStartTime(startTime);
                hnDataGatherVO.setEndTime(endTime);
                ihnGatherPatArchiveService.hnDataGather(hnDataGatherVO);
                log.info("【dealHisData】河南结束采集数据");
            } catch (Exception e) {
                log.error("【dealHisData】河南数据采集异常", e);
            }
        } else if (active.trim().equals("sltd")) {
            try {
                // 省立同德数据采集
                log.info("【dealHisData】省立同德“入院”开始采集数据");
                String yesterday = LocalDate.now().minusDays(1).format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
                ServiceSLTDInhospReqVO serviceSLTDInhospReqVO = new ServiceSLTDInhospReqVO();
                serviceSLTDInhospReqVO.setOrgId("20001001");
                serviceSLTDInhospReqVO.setCampusId(30001002L);
                serviceSLTDInhospReqVO.setStartHeadTime(yesterday);
                serviceSLTDInhospReqVO.setStartTailTime(yesterday);
                List<String> list = new ArrayList<>();
                list.add("FH0108.02");
                serviceSLTDInhospReqVO.setHealthcareRecordTypeList(list);
                serviceSLTDHealthcareRecordService.queryHealthcareRecordList(serviceSLTDInhospReqVO);
                log.info("【dealHisData】省立同德“入院”結束采集数据");

                log.info("【dealHisData】省立同德“门急诊”开始采集数据");
                serviceSLTDInhospReqVO.setStartHeadTime(null);
                serviceSLTDInhospReqVO.setStartTailTime(null);
                serviceSLTDInhospReqVO.setEncounterTimeStart(yesterday);
                serviceSLTDInhospReqVO.setEncounterTimeEnd(yesterday);
                List<String> list1 = new ArrayList<>();
                list1.add("FH0108.01");
                list1.add("FH0108.03");
                serviceSLTDInhospReqVO.setHealthcareRecordTypeList(list1);
                serviceSLTDHealthcareRecordService.queryHealthcareRecordList(serviceSLTDInhospReqVO);
                log.info("【dealHisData】河南结“门急诊”束采集数据");

                log.info("【dealHisData】省立同德“出院”开始采集数据");
                serviceSLTDInhospReqVO.setStartHeadTime(null);
                serviceSLTDInhospReqVO.setStartTailTime(null);
                serviceSLTDInhospReqVO.setEncounterTimeStart(null);
                serviceSLTDInhospReqVO.setEncounterTimeEnd(null);
                serviceSLTDInhospReqVO.setPreOutHospitalHeadDate(yesterday);
                serviceSLTDInhospReqVO.setPreOutHospitalTailDate(yesterday);
                List<String> list2 = new ArrayList<>();
                list2.add("FH0108.02");
                serviceSLTDInhospReqVO.setHealthcareRecordTypeList(list2);
                serviceSLTDHealthcareRecordService.queryHealthcareRecordList(serviceSLTDInhospReqVO);
                log.info("【dealHisData】河南结“出院”束采集数据");

            } catch (Exception e) {
                log.error("【dealHisData】省立同德数据采集异常", e);
            }
        }
    }

    /**
     * 这个只是新华临时使用，平时用不到
     */
    public void dealHisData2() {
        //将患者信息、出院、门诊数据全部采集
        //将患者信息、出入院数据全部采集
        // 指定的开始日期
        LocalDate endDate = LocalDate.of(2025, 3, 3);
        // 当前日期
@@ -240,8 +325,8 @@
        // 从开始日期到当前日期逐天打印
        for (LocalDate date = endDate; !date.isAfter(currentDate); date = date.plusDays(1)) {
            System.out.println(date.format(formatter));
            getInHospInfo("0", date.minusDays(1).atStartOfDay(), date.atStartOfDay());
            getInHospInfo("1", date.minusDays(1).atStartOfDay(), date.atStartOfDay());
            ixhGatherPatArchiveService.getInHospDataGather("0", date.minusDays(1).atStartOfDay(), date.atStartOfDay());
            ixhGatherPatArchiveService.getInHospDataGather("1", date.minusDays(1).atStartOfDay(), date.atStartOfDay());
        }

    }
@@ -282,7 +367,7 @@


    /**
     * 长期任务执行（电话）
     * 长期任务执行
     */
    public void longTaskSend() {
        //获取任务信息
@@ -290,15 +375,75 @@
        st.setDelFlag("0");
        st.setLongTask(1);
        List<ServiceTask> serviceTasks = serviceTaskMapper.selectServiceTaskList(st);
        log.error("serviceTasks进来了吗？{}", serviceTasks);
        log.info("【longTaskSend】获取到{}个长期任务", serviceTasks.size());
        for (ServiceTask serviceTask : serviceTasks) {
            CommonTaskcallMQ commonTaskcallMQ = new CommonTaskcallMQ();
            commonTaskcallMQ.setTaskid(serviceTask.getTaskid());
            commonTaskcallMQ.setPreachform(serviceTask.getPreachform());
            commonTaskcallMQ.setSendType("2");
            sfHandlle(commonTaskcallMQ, localIP);

            //通过任务ID拿到患者信息,并且随访时间得是今天之前的
            ServiceSubtaskVO serviceSubtaskVO = new ServiceSubtaskVO();
            serviceSubtaskVO.setTaskid(commonTaskcallMQ.getTaskid());
            serviceSubtaskVO.setSendstate(2L);
            serviceSubtaskVO.setVisitTime(new Date());
            List<ServiceSubtask> selectServiceSubtaskList = serviceSubtaskMapper.queryServiceSubtaskList(serviceSubtaskVO);
            for (ServiceSubtask serviceSubtask : selectServiceSubtaskList) {
                sfHandlle(serviceSubtask);
            }

        }
    }

    /**
     * 处理补偿任务
     */
    public void compensateTask() {
        //获取到sendstate=3 并且 visit_time为今天的subtask
        ServiceSubtaskVO serviceSubtaskVO = new ServiceSubtaskVO();
        serviceSubtaskVO.setSendstate(3L);
        serviceSubtaskVO.setVisitTime(new Date());
        List<ServiceSubtask> serviceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(serviceSubtaskVO);
        for (ServiceSubtask serviceSubtask : serviceSubtaskList) {
            //根据当前的执行方式，获取下一种执行方式
            ServiceSubtaskPreachform serviceSubtaskPreachform = new ServiceSubtaskPreachform();
            serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
            serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
            serviceSubtaskPreachform.setOrgid(serviceSubtask.getOrgid());
            List<ServiceSubtaskPreachform> serviceSubtaskPreachforms = serviceSubtaskPreachformMapper.selectServiceSubtaskPreachformList(serviceSubtaskPreachform);
            //获取当前执行方式的序号
            Optional<Long> currentSort = serviceSubtaskPreachforms.stream().filter(item -> serviceSubtask.getCurrentPreachform().equals(item.getPreachform())).map(ServiceSubtaskPreachform::getSort).findFirst();
            Optional<Long> id = serviceSubtaskPreachforms.stream().filter(item -> serviceSubtask.getCurrentPreachform().equals(item.getPreachform())).map(ServiceSubtaskPreachform::getId).findFirst();
            if (currentSort.isPresent()) {
                //1先检查一下，是不是有执行状态是完成的（怕之前已经有完的了，没有将servuce_subtask的状态改成功，这里再检查一下）
                boolean finishState = serviceSubtaskPreachforms.stream().allMatch(item -> item.getSendstate().equals("9"));
                if (finishState) {
                    serviceSubtask.setSendstate(6L);
                    serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                    continue;
                }

                //2判断一下，当前的sort是不是等于需要执行的总个数，如果等于的话，说明是最后一个，直接将servuce_subtask的状态改成5，执行失败就行了
                Long cs = currentSort.get();
                if (cs.equals(serviceSubtaskPreachforms.size())) {
                    serviceSubtask.setSendstate(5L);
                    serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                    //修改发送方式的状态为失败
                    serviceSubtaskPreachform.setSendstate("5");
                    serviceSubtaskPreachform.setId(id.get());
                    serviceSubtaskPreachformMapper.updateServiceSubtaskPreachform(serviceSubtaskPreachform);
                    continue;
                }

                //3.不是最后一个，获取到下一个执行方式(因为都是在今天执行，那就直接发出去就完了)
                sfHandlle(serviceSubtask);

            }

        }

    }


    /**
     * 判断日期是否是今天
@@ -318,526 +463,342 @@
        return !localDate.isAfter(today);
    }

    public void sfHandlle(CommonTaskcallMQ commonTaskcallMQ, String ip) {
        log.error("sfHandlle进来了吗？{}", commonTaskcallMQ);
        //判断一下commonTaskcallMQ中的stopstate是否与ivr_task中的一致，不一致，则说明是暂停了
        ServiceTask ivrTask1 = serviceTaskMapper.selectServiceTaskByTaskid(commonTaskcallMQ.getTaskid());
    public void sfHandlle(ServiceSubtask serviceSubtask) {
        //这里需要根据身份证去重(给微信小程序的固定任务用的)
        List<ServiceSubtask> serviceSubtaskListFilter = new ArrayList<>();
        ServiceTask ivrTask1 = serviceTaskMapper.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
        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) {
            //说明已经全部遍历完了，当前的执行方式序号是最后一个了   或者  该患者已经随访结束（成功或失败了或不执行）
            return;
        }
        //先判断患者是不是还要发送
        PatArchive patArchive = patArchiveService.selectPatArchiveByPatid(serviceSubtask.getPatid());
        if (!Objects.isNull(patArchive) && patArchive.getNotrequiredFlag() == "1") {
            //不需要发送
            serviceSubtask.setResult("患者不需要随访");
            serviceSubtask.setRemark(patArchive.getNotrequiredreason());
            serviceSubtask.setSendstate(4L);
            iServiceSubtaskService.insertServiceSubtask(serviceSubtask);
            setSuccessPreachForm(serviceSubtask, "-1", "不需要执行", "6");
            return;
        }

        if (StringUtils.isNotEmpty(commonTaskcallMQ.getPreachform())) {
            //如何任务发送方式不为空
            String[] split = commonTaskcallMQ.getPreachform().split(",");
            log.error("split进来了吗？{}", split);
            for (String serviceFrom : split) {
                String descByCode = ServiceFromEnum.getDescByCode(Integer.valueOf(serviceFrom));
                //通过任务ID拿到患者信息
                ServiceSubtaskVO ivrTaskcall = new ServiceSubtaskVO();
                ivrTaskcall.setTaskid(commonTaskcallMQ.getTaskid());
                ivrTaskcall.setSendstate(2L);
                List<ServiceSubtask> subtaskList = iServiceSubtaskService.selectServiceSubtaskList(ivrTaskcall);

                // 按照 endtime 离当前时间最近的排序
                List<ServiceSubtask> selectServiceSubtaskList = subtaskList.stream().sorted(Comparator.comparing(subtask -> Math.abs(subtask.getEndtime().getTime() - new Date().getTime()))).collect(Collectors.toList());

                if (descByCode.equals("电话")) {
                    String value = "";
                    List<String> list = new ArrayList<>();
                    for (ServiceSubtask serviceSubtask : selectServiceSubtaskList) {
                        ServiceTask ivrTask = serviceTaskMapper.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.setRemark("手机号为空");
                            serviceSubtask.setSendstate(4L);
                            serviceSubtask.setResult("error");
                            serviceSubtask.setFinishtime(new Date());
                            serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                            continue;
                        }
                        boolean dateToday = isDateToday(serviceSubtask.getLongSendTime());
                        //说明是立即发送(先把消息放到cache-0中，   displayNo不知道怎么配置)
                        if (dateToday) {
                            list.add(serviceSubtask.getId().toString());
                            //在子任务表里记录一下
                            String uuid = UUID.randomUUID().toString();
                            serviceSubtask.setResult("success");
                            serviceSubtask.setRemark("长期任务，电话进入队列成功");
                            serviceSubtask.setGuid(uuid);
                            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("3");
                            serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                            serviceSubtaskRecord.setRemark("长期任务，电话进入队列成功");
                            serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);

                        }
                    }
                    //将要执行的放到缓存中
                    if (list.size() > 0) {
//                        redisCache.setCacheListLeft("cache-0", list);
                        redisCache.setCacheListLeftAndDistinct("cache-0", list);
                    }
                } else if (descByCode.equals("多媒体")) {
                    //多媒体
                } else if (descByCode.equals("纸质")) {
                    //纸质
                } else if (descByCode.equals("微信小程序")) {
                    //微信小程序
                    log.error("ivrTask1的值为：{}", ivrTask1);
                    if (ObjectUtils.isNotEmpty(ivrTask1) && ivrTask1.getPatCycle() == 1) {
                        //说明该任务的患者是循环执行的
                        ServiceSubtaskVO serviceSubtaskVO = new ServiceSubtaskVO();
                        serviceSubtaskVO.setTaskid(ivrTask1.getTaskid());
                        List<ServiceSubtask> serviceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(serviceSubtaskVO);
                        //这里需要根据身份证去重
                        List<ServiceSubtask> serviceSubtaskListFilter = new ArrayList<>();
                        aa:
                        for (ServiceSubtask serviceSubtask : serviceSubtaskList) {
                            for (ServiceSubtask ss : serviceSubtaskListFilter) {
                                if (ss.getSfzh().equals(serviceSubtask.getSfzh())) {
                                    continue aa;
                                }
                            }
                            serviceSubtaskListFilter.add(serviceSubtask);
                        }
                        for (ServiceSubtask serviceSubtask : serviceSubtaskListFilter) {
                            //将子任务ID删除 、sendstate改成3
                            serviceSubtask.setSendstate(3L);
                            serviceSubtask.setId(null);
                            serviceSubtask.setFinishtime(null);
                            serviceSubtask.setCreateTime(new Date());
                            serviceSubtask.setUpdateTime(new Date());
                            //处理重复新增问题，先查一下今天是不是有新增过，新增过就不新增了
                            ServiceSubtaskVO ssvo = new ServiceSubtaskVO();
                            LocalDate today = LocalDate.now();
                            LocalTime startOfDay = LocalTime.of(0, 0, 0);
                            LocalTime endOfDay = LocalTime.of(23, 59, 59);
                            Date startOfDayDate = Date.from(today.atTime(startOfDay).atZone(ZoneId.systemDefault()).toInstant());
                            Date endOfDayDate = Date.from(today.atTime(endOfDay).atZone(ZoneId.systemDefault()).toInstant());
                            ssvo.setCreateStartTime(startOfDayDate);
                            ssvo.setCreateEndTime(endOfDayDate);
                            ssvo.setCreateBy(serviceSubtask.getCreateBy());
                            ssvo.setSendname(serviceSubtask.getSendname());
                            ssvo.setSfzh(serviceSubtask.getSfzh());
                            List<ServiceSubtask> serviceSubtaskListByCreateTime = serviceSubtaskMapper.selectServiceSubtaskListByCreateTime(ssvo);
                            if (CollectionUtils.isEmpty(serviceSubtaskListByCreateTime))
                                serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
                        }
                    }
                } else if (descByCode.equals("短信")) {
                    RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
                    String taskId = rsaPublicKeyExample.encryptedData(ivrTask1.getTaskid().toString(), pub_key);
                    for (ServiceSubtask serviceSubtask : selectServiceSubtaskList) {
                        log.error("短信长期任务发送---------进来了吗？{}", serviceSubtask);
                        boolean dateToday = isDateToday(serviceSubtask.getLongSendTime());
                        if (dateToday) {
                            try {
                                //先判断患者是不是还要发送
                                PatArchive patArchive = patArchiveService.selectPatArchiveByPatid(serviceSubtask.getPatid());
                                if (!Objects.isNull(patArchive) && patArchive.getNotrequiredFlag() == "1") {
                                    //不需要发送
                                    serviceSubtask.setResult("error");
                                    serviceSubtask.setRemark(patArchive.getNotrequiredreason());
                                    serviceSubtask.setSendstate(4L);
                                    serviceSubtask.setFinishtime(new Date());
                                    iServiceSubtaskService.insertServiceSubtask(serviceSubtask);
                                    continue;
                                }
                                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");
                                ServiceOutPath serviceOutPath = new ServiceOutPath();
                                serviceOutPath.setParam1(taskId);
                                serviceOutPath.setParam2(patid);
                                serviceOutPath.setParam3(ivrTask1.getTaskName());
                                serviceOutPath.setParam6(subId);
                                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.setPhone(serviceSubtask.getPhone());
                                sendMagParam.setUrl(ip + ":" + req_path + "/wt?p=" + format);
                                sendMagParam.setContent("【新华医院】您好，邀请您填写出院调查表，请点击" + sendMagParam.getUrl() + "填写。感谢您配合！");
                                String isSuccess = null;
                                if (visitHosp == 1) {
                                    Map<String, String> req = new HashMap<>();
                                    req.put("phone", sendMagParam.getPhone());
                                    req.put("content", sendMagParam.getContent());
                                    isSuccess = 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());
                                    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("---------丽水短信发送入参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")) {
                                        isSuccess = "true";
                                    }
                                }
                                //任务发送记录
                                ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                                serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                                serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                                serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                                serviceSubtaskRecord.setPreachform("4");
                                serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                                serviceSubtaskRecord.setResult("success");
                                if (StringUtils.isNotEmpty(isSuccess) && !isSuccess.equals("true"))
                                    serviceSubtaskRecord.setResult("error");
                                serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);

                                //发送完成后，修改状态
                                serviceSubtask.setSendstate(3L);
                                if (StringUtils.isNotEmpty(isSuccess) && !isSuccess.equals("true")) {
                                    serviceSubtask.setResult("success");
                                    serviceSubtask.setRemark("短信发送成功");
                                } else {
                                    serviceSubtask.setResult("error");
                                    serviceSubtask.setSendstate(5L);
                                    serviceSubtask.setRemark("短信发送失败");
                                }
                                iServiceSubtaskService.updateServiceSubtask(serviceSubtask);
                            } catch (Exception e) {
                                String guid = UUID.randomUUID().toString();
                                log.error("长期任务，短信发送失败原因：{},{}", e.getMessage(), guid);
                                serviceSubtask.setResult("error");
                                serviceSubtask.setRemark("系统错误");
                                serviceSubtask.setSendstate(5L);
                                serviceSubtask.setFinishtime(new Date());
                                serviceSubtask.setGuid(guid);
                                iServiceSubtaskService.updateServiceSubtask(serviceSubtask);
                            }
                        }
                    }
                } else if (descByCode.equals("公众号")) {
                    log.error("公众号进来了吗？{}", descByCode);
                    //公众号
                    RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
                    String taskId = rsaPublicKeyExample.encryptedData(ivrTask1.getTaskid().toString(), pub_key);
                    for (ServiceSubtask serviceSubtask : selectServiceSubtaskList) {
                        log.error("serviceSubtask---------进来了吗？{}", serviceSubtask);
                        boolean dateToday = isDateToday(serviceSubtask.getLongSendTime());
                        if (dateToday) {
                            try {
                                //先判断患者是不是还要发送
                                PatArchive patArchive = patArchiveService.selectPatArchiveByPatid(serviceSubtask.getPatid());
                                if (!Objects.isNull(patArchive) && patArchive.getNotrequiredFlag() == "1") {
                                    //不需要发送
                                    serviceSubtask.setResult("error");
                                    serviceSubtask.setRemark(patArchive.getNotrequiredreason());
                                    serviceSubtask.setSendstate(4L);
                                    serviceSubtask.setFinishtime(new Date());
                                    iServiceSubtaskService.insertServiceSubtask(serviceSubtask);
                                    continue;
                                }
                                String patid = rsaPublicKeyExample.encryptedData(serviceSubtask.getPatid().toString(), pub_key);
                                String url = null;
                                url = ip + ":" + req_path + "/outsideChainwt?param1=" + taskId + "&param2=" + patid + "&param3=" + URLEncoder.encode(ivrTask1.getTaskName(), StandardCharsets.UTF_8.toString()) + "&param5=false";
//                                String wxCode = getWXCode(serviceSubtask.getSfzh(), url, serviceSubtask.getTaskName(), serviceSubtask.getTaskDesc(), "无");

                                //获取微信公众号请求信息根据机构ID
                                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;
                                }

                                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;
                                }
                                String wxCode = getWXCode(serviceSubtask.getSfzh(), url, serviceSubtask.getTaskName(), serviceSubtask.getTaskDesc(), patArchive.getTelcode(), serviceSubtask.getSendname(), patArchive.getPatidHis(), wxqqxx);

                                Map<String, Object> map = JSONObject.parseObject(wxCode, Map.class);
                                //任务发送记录
                                ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                                serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                                serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                                serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                                serviceSubtaskRecord.setPreachform("4");
                                serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                                serviceSubtaskRecord.setResult("success");
                                if (!map.isEmpty() && (Boolean) map.get("succ") == false)
                                    serviceSubtaskRecord.setResult("error");
                                serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);

                                //发送完成后，修改状态
                                serviceSubtask.setSendstate(3L);
                                if ((Boolean) map.get("succ") == true) {
                                    serviceSubtask.setResult("success");
                                } else {
                                    log.error("serviceSubtask1231313的值为：{}", serviceSubtask);
                                    serviceSubtask.setResult("error");
                                    serviceSubtask.setSendstate(5L);
                                    serviceSubtask.setRemark(map.get("msg").toString());
                                }
                                iServiceSubtaskService.updateServiceSubtask(serviceSubtask);
                            } catch (Exception e) {
                                String guid = UUID.randomUUID().toString();
                                log.error("长期任务，公众号发送失败原因：{},{}", e.getMessage(), guid);
                                serviceSubtask.setResult("error");
                                serviceSubtask.setRemark("系统错误");
                                serviceSubtask.setSendstate(5L);
                                serviceSubtask.setFinishtime(new Date());
                                serviceSubtask.setGuid(guid);
                                iServiceSubtaskService.updateServiceSubtask(serviceSubtask);
                            }
                        }
                    }
                }
                //通知 MQ 消息已被接收,可以ACK(从队列中删除)了   （这个需要根据业务再去处理ACK）
        String descByCode = ServiceFromEnum.getDescByCode(Integer.valueOf(sendPreachform));
        if (descByCode.equals("电话")) {
            List<String> list = new ArrayList<>();
            ServiceTask ivrTask = serviceTaskMapper.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
            if (ivrTask.getSendState() != null && ivrTask.getSendState() == 3 || ivrTask.getSendState() != null && ivrTask.getSendState() == 4) {
                //如何任务被"暂停"或"终止"
                return;
            }
        }
    }


    /**
     * 获出院患者信息
     * cry    出入院： 0 入院   1 出院
     */
    @Transactional
    public void getInHospInfo(String cry, LocalDateTime startTime, LocalDateTime endTime) {
        // 定义日期时间格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.S");
        Map<String, String> req = new HashMap<>();
        if (cry.equals("1")) {
            req.put("cashStartDate", startTime.format(formatter));
            req.put("cashEndDate", endTime.format(formatter));
            req.put("currStatus", "4");
        } else if (cry.equals("0")) {
            req.put("admissStartDate", startTime.format(formatter));
            req.put("admissEndDate", endTime.format(formatter));
            req.put("currStatus", "2");
        }
        Map<String, String> header = new HashMap<>();
        header.put("x-hcsb-serviceno", "IS002347");
        header.put("x-hcsb-version", "2.0");
        header.put("x-hcsb-sourcesyscode", "14");
        header.put("x-hcsb-token", "ArGE2JnHtxG/Zx5nrnGY4eOfMUJGGJokAJHigG1BrCY=");
        header.put("x-hcsb-msgdate", startTime.format(formatter));
        String result = HttpUtils.sendPostByHeader(hospInfoUrl, new Gson().toJson(req), header);
        //数据解析
        Gson gson = new Gson();
        JsonObject jsonObject = gson.fromJson(result, JsonObject.class);
        JsonArray resultArray = jsonObject.getAsJsonObject("data").getAsJsonArray("result");
        Type resultType = new TypeToken<List<ThiedInhospInfo>>() {
        }.getType();
        List<ThiedInhospInfo> thiedInhospInfoList = gson.fromJson(resultArray, resultType);

        // 创建一个新文件
        String filename = null;
        if (cry.equals("0")) filename = "入院信息" + System.currentTimeMillis();
        if (cry.equals("1")) filename = "出院信息" + System.currentTimeMillis();
        File file = new File("D:\\public\\HIS数据采集\\" + filename);
        if (!file.exists()) {
            // 如果文件不存在，则创建新文件
            try {
                if (file.createNewFile()) {
                    System.out.println("成功创建了新文件!");
                } else {
                    System.out.println("失败！文件无法创建！");
                }
            } catch (IOException e) {
                e.printStackTrace();
            if (org.apache.commons.lang3.StringUtils.isEmpty(serviceSubtask.getPhone())) {
                setSuccessPreachForm(serviceSubtask, sendPreachform, "手机号为空", "4");
                return;
            }
        }
        // 将数据写入到文件中
        try {
            FileWriter writer = new FileWriter(file);
            writer.write(result);
        } catch (IOException e) {
            e.printStackTrace();
        }

        if (CollectionUtils.isNotEmpty(thiedInhospInfoList)) {
            for (ThiedInhospInfo thiedInhospInfo : thiedInhospInfoList) {
                //通过身份证号查询该患者在患者表是否存在
                PatArchive patArchive = new PatArchive();
                List<PatArchive> patArchives = null;
                patArchive.setIdcardno(thiedInhospInfo.getPatiIdCardNo().trim());
                if (StringUtils.isNotEmpty(thiedInhospInfo.getPatiIdCardNo().trim())) {
                    patArchives = patArchiveService.selectPatArchiveList(patArchive);
                } else {
                    //患者信息为空，直接 下一个
                    continue;
            boolean dateToday = isDateToday(serviceSubtask.getVisitTime());
            //说明是立即发送(先把消息放到cache-0中，   displayNo不知道怎么配置)
            if (dateToday) {
                list.add(serviceSubtask.getId().toString());
                //在子任务表里记录一下
                setSuccessPreachForm(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);
            }
            //将要执行的放到缓存中
            if (list.size() > 0) {
                redisCache.setCacheListLeftAndDistinct("cache-0", list);
                log.info("【sfHandlle】电话任务已加入队列，数量：{}", list.size());
            }
        } else if (descByCode.equals("微信小程序")) {
            //微信小程序
            if (ObjectUtils.isNotEmpty(ivrTask1) && ivrTask1.getPatCycle() == 1) {
                //说明该任务的患者是循环执行的
                //判断患者过滤集合中，是否存在当前执行患者的身份证
                boolean continutFlag = false;
                for (ServiceSubtask ss : serviceSubtaskListFilter) {
                    if (ss.getSfzh().equals(serviceSubtask.getSfzh())) {
                        continutFlag = true;
                    }
                }
                if (CollectionUtils.isEmpty(patArchives) || patArchives.size() == 0) {
                    patArchive.setPatientno(thiedInhospInfo.getPatiMediaNo());
                    patArchive.setSourcefrom(2);
                    patArchive.setPattype("2");
                    if (StringUtils.isNotEmpty(thiedInhospInfo.getOutWayId()) && thiedInhospInfo.getOutWayId().equals("4")) {
                        //如果为4就是死亡
                        patArchive.setNotrequiredFlag("1");
                        patArchive.setNotrequiredreason(thiedInhospInfo.getOutWayName());
                    }
                    if (cry.equals("1") && StringUtils.isEmpty(thiedInhospInfo.getOutWayId())) {
                        //如果为4就是死亡
                        patArchive.setNotrequiredFlag("1");
                        patArchive.setNotrequiredreason("出院方式为空");
                    }
                    patArchive.setSex(thiedInhospInfo.getPatiRecordGender().equals("男") ? 1L : 2L);
                    patArchive.setNation(thiedInhospInfo.getPatiNation());
                    patArchive.setNativePlace(thiedInhospInfo.getPatiNationality());
                    patArchive.setPlaceOfResidence(StringUtils.isNotEmpty(thiedInhospInfo.getPatiHomeAddr()) ? thiedInhospInfo.getPatiHomeAddr().replace("null", "") : "");
                    try {
                        if (StringUtils.isNotEmpty(thiedInhospInfo.getPatiBirthday()))
                            patArchive.setBirthdate(new SimpleDateFormat("yyyy-MM-dd").parse(thiedInhospInfo.getPatiBirthday()));
                    } catch (ParseException e) {
                        e.printStackTrace();
                    }
                    if (thiedInhospInfo.getTreateAge() != null) {
                        patArchive.setAge(Long.valueOf(thiedInhospInfo.getTreateAge()));
                //如果存在当前执行患者的身份证，则不执行该患者了
                if (continutFlag) {
                    return;
                }

                //将子任务ID删除 、sendstate改成3（循环任务就是这样）
                serviceSubtask.setSendstate(3L);
                serviceSubtask.setId(null);
                serviceSubtask.setFinishtime(null);
                serviceSubtask.setCreateTime(new Date());
                serviceSubtask.setUpdateTime(new Date());
                serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);

                //将当前要执行的患者放到过滤患者集合中
                serviceSubtaskListFilter.add(serviceSubtask);
            }
        } else if (descByCode.equals("短信")) {
            RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
            String taskId = rsaPublicKeyExample.encryptedData(ivrTask1.getTaskid().toString(), pub_key);
            log.info("【sfHandlle】处理短信长期任务，患者ID：{}", serviceSubtask.getPatid());
            boolean dateToday = isDateToday(serviceSubtask.getVisitTime());
            if (dateToday) {
                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");
                    ServiceOutPath serviceOutPath = new ServiceOutPath();
                    serviceOutPath.setParam1(taskId);
                    serviceOutPath.setParam2(patid);
                    serviceOutPath.setParam3(ivrTask1.getTaskName());
                    serviceOutPath.setParam6(subId);
                    serviceOutPath.setCreateTime(new Date());
                    iServiceOutPathService.insertServiceOutPath(serviceOutPath);
                    String format = String.format("%03X", serviceOutPath.getId());
                    serviceOutPath.setRadix(format);
                    serviceOutPath.setUpdateTime(new Date());
                    iServiceOutPathService.updateServiceOutPath(serviceOutPath);
                    //先判断一下发的是不是宣教
                    if (!"3".equals(serviceSubtask.getType())) {
                        sendMagParam.setPhone(serviceSubtask.getPhone());
                        sendMagParam.setUrl(localIP + ":" + req_path + "/wt?p=" + format);
                        //如果type是语音随访的话（说明补偿发送方式中有电话随访的方式，这里的外链就地址只能用/sf）
                        if (serviceSubtask.getType().equals("1"))
                            sendMagParam.setUrl(localIP + ":" + req_path + "/sf?p=" + format);
                        sendMagParam.setContent("您好，邀请您填写出院调查表，请点击" + sendMagParam.getUrl() + "填写。感谢您配合！");
                    } else {
                        patArchive.setAge(null);
                        HeLibrary heLibrary = heLibraryMapper.selectHeLibraryById(serviceSubtask.getLibtemplateid());
                        if ("2".equals(heLibrary.getHetype())) {
                            sendMagParam.setPhone(serviceSubtask.getPhone());
                            sendMagParam.setContent(heLibrary.getPreachcontent());
                        }
                    }
                    patArchive.setAgeUnit(thiedInhospInfo.getTreatAgeunit());
                    patArchive.setTelcode(thiedInhospInfo.getCompanyTelNum());
                    patArchive.setRelativetelcode(thiedInhospInfo.getContactPersonPhone());
                    patArchive.setDelFlag("0");
                    patArchive.setCreateTime(new Date());
                    patArchive.setUpdateTime(new Date());
                    patArchive.setName(thiedInhospInfo.getPatiRecordName());
                    patArchiveService.insertPatArchive(patArchive);
                } else {
                    patArchive = patArchives.get(0);
                }
                    String isSuccess = null;
                    if (visitHosp == 1) {
                        Map<String, String> req = new HashMap<>();
                        req.put("phone", sendMagParam.getPhone());
                        req.put("content", sendMagParam.getContent());
                        isSuccess = 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);
                        if (ObjectUtils.isNotEmpty(map) && StringUtils.isEmpty(map.get("address"))) {
                            setSuccessPreachForm(serviceSubtask, sendPreachform, "短信发送失败,该机构没有配置短信地址", "5");
                            return;
                        }
                        log.info("【sfHandlle】丽水短信发送，地址：{}，参数：{}，机构ID：{}", 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("【sfHandlle】丽水短信发送结果：{}", dxCode);
                        ObjectMapper objectMapper = new ObjectMapper();
                        Map<String, Object> textParam = objectMapper.readValue(dxCode, Map.class);
                        String code = textParam.get("Code").toString();
                        if (code.equals("0")) {
                            isSuccess = "true";
                        }
                    } else if (visitHosp == 4) {
                        //省立同德的短信发送方式
                        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")) {
                            isSuccess = "true";
                        }
                    } else if (visitHosp == 3) {//市一医院
                        String content = sendMagParam.getContent().replace("【新华医院】", "");
                        String result = smsUtils.sendSms(xhsmsPath, xhsmsAccount, xhsmsPwd, sendMagParam.getPhone(), content);
                        //这里需要根据result返回的值去判断，是否成功，然后将值赋值给isSuccess

                log.error("入参的patArchive：{}", patArchive);
                PatMedInhosp patMedInhosp = new PatMedInhosp();
                patMedInhosp.setPatid(patArchive.getId());
                patMedInhosp.setPatno(patArchive.getPatientno());
                patMedInhosp.setPatname(patArchive.getName());
                patMedInhosp.setNurseId(thiedInhospInfo.getNurseId());
                patMedInhosp.setNurseName(thiedInhospInfo.getNurseName());
                patMedInhosp.setSerialnum(thiedInhospInfo.getInpatientId());
                patMedInhosp.setFuflag("1");
                if (cry.equals("0")) {
                    patMedInhosp.setInhospstate("0");
                } else if (cry.equals("1")) {
                    patMedInhosp.setInhospstate("1");
                }
                patMedInhosp.setHospitalcode(thiedInhospInfo.getAreaId());
                patMedInhosp.setIcd10code(thiedInhospInfo.getDiagIcd10());
                patMedInhosp.setDiagname(thiedInhospInfo.getDiagName());
                try {
                    if (StringUtils.isNotEmpty(thiedInhospInfo.getAdmissDate()))
                        patMedInhosp.setStarttime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(thiedInhospInfo.getAdmissDate()));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                try {
                    if (StringUtils.isNotEmpty(thiedInhospInfo.getOutDate()))
                        patMedInhosp.setEndtime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(thiedInhospInfo.getOutDate()));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                patMedInhosp.setDeptcode(thiedInhospInfo.getAdmissDeptId());
                patMedInhosp.setDeptid(thiedInhospInfo.getAdmissDeptId());
                patMedInhosp.setDeptname(thiedInhospInfo.getAdmissDeptName());
                patMedInhosp.setBedNo(thiedInhospInfo.getAdmissBedNo());
                patMedInhosp.setDelFlag("0");
//                patMedInhosp.setLeaveldeptcode(thiedInhospInfo.getCurrDeptCode());
                patMedInhosp.setLeaveldeptcode(thiedInhospInfo.getCurrDeptId());
                patMedInhosp.setLeaveldeptname(thiedInhospInfo.getCurrDeptName());
                patMedInhosp.setLeavediagname(thiedInhospInfo.getDiagName());
                patMedInhosp.setLeaveicd10code(thiedInhospInfo.getDiagIcd10());
                patMedInhosp.setDrname(thiedInhospInfo.getDoctName());
                patMedInhosp.setDrcode(thiedInhospInfo.getDoctId());
                patMedInhosp.setOutWayId(thiedInhospInfo.getOutWayId());
                patMedInhosp.setOutWayName(thiedInhospInfo.getOutWayName());
                if (cry.equals("0")) {
                    patMedInhosp.setSchemestatus(1L);
                } else if (cry.equals("1")) {
                    patMedInhosp.setSchemestatus(2L);
                }
                patMedInhosp.setLeavehospitaldistrictid(thiedInhospInfo.getCurrWardCode());
                patMedInhosp.setLeavehospitaldistrictcode(thiedInhospInfo.getCurrWardId());
                patMedInhosp.setLeavehospitaldistrictname(thiedInhospInfo.getCurrWardName());
                patMedInhosp.setLeaveldeptid(thiedInhospInfo.getCurrDeptCode());
                patMedInhosp.setOrgid("1");
                //如果是出院，先通过患者编号和流水号去查一下，患者是否存在，如果存在，则进行修改
                PatMedInhosp inhosp = new PatMedInhosp();
                inhosp.setPatno(patArchive.getPatientno());
                inhosp.setSerialnum(patMedInhosp.getSerialnum());
                List<PatMedInhosp> patMedInhosps = patMedInhospService.selectPatMedInhospList(inhosp);
                log.error("是否需要更新：{}", patMedInhosps.size());
                if (CollectionUtils.isNotEmpty(patMedInhosps)) {
                    patMedInhosp.setInhospid(patMedInhosps.get(0).getInhospid());
                    log.error("------患者出入院修改信息：{}", patMedInhosp);
                    patMedInhospService.updatePatMedInhosp(patMedInhosp);
                } else {
                    log.error("----患者出入院新增信息：{}", patMedInhosp);
                    patMedInhospService.insertPatMedInhosp(patMedInhosp);
                }

                    }
                    //任务发送记录
                    ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                    serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                    serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                    serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                    serviceSubtaskRecord.setPreachform("4");
                    serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                    serviceSubtaskRecord.setResult("success");
                    if (StringUtils.isNotEmpty(isSuccess) && !isSuccess.equals("true"))
                        serviceSubtaskRecord.setResult("error");
                    serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);

                    //发送完成后，修改状态
                    serviceSubtask.setSendstate(3L);
                    if (StringUtils.isNotEmpty(isSuccess) && isSuccess.equals("true")) {
                        serviceSubtask.setResult("success");
                        serviceSubtask.setRemark("短信发送成功");
                        setSuccessPreachForm(serviceSubtask, sendPreachform, "短信发送成功", "2");
                    } else {
                        serviceSubtask.setResult("error");
                        serviceSubtask.setRemark("短信发送失败");
                        setSuccessPreachForm(serviceSubtask, sendPreachform, "短信发送失败", "5");
                    }
                } catch (Exception e) {
                    String guid = UUID.randomUUID().toString();
                    log.error("【sfHandlle】长期任务短信发送失败，原因：{}，GUID：{}", e.getMessage(), guid);
                    setSuccessPreachForm(serviceSubtask, sendPreachform, "长期任务短信发送失败:系统错误", "5");
                }
            }

        } else if (descByCode.equals("公众号")) {
            log.info("【sfHandlle】处理公众号任务，任务信息：{}", ivrTask1);
            //公众号
            RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
            String taskId = rsaPublicKeyExample.encryptedData(ivrTask1.getTaskid().toString(), pub_key);
            boolean dateToday = isDateToday(serviceSubtask.getVisitTime());
            if (dateToday) {
                try {
                    String patid = rsaPublicKeyExample.encryptedData(serviceSubtask.getPatid().toString(), pub_key);
                    String url = null;
                    url = localIP + ":" + req_path + "/outsideChainwt?param1=" + taskId + "&param2=" + patid + "&param3=" + URLEncoder.encode(ivrTask1.getTaskName(), StandardCharsets.UTF_8.toString()) + "&param5=false";

                    //获取微信公众号请求信息根据机构ID
                    List<String> wxqqxx = WxGZHEnum.getDescByCode(patArchive.getOrgid());
                    if (CollectionUtils.isEmpty(wxqqxx) || wxqqxx.size() < 4) {
                        setSuccessPreachForm(serviceSubtask, sendPreachform, "【公众号】该机构的公众号配置信息不全，无法通过公众号发送", "4");
                        return;
                    }

                    if (StringUtils.isEmpty(patArchive.getPatidHis())) {
                        setSuccessPreachForm(serviceSubtask, sendPreachform, "【公众号】公众号发送失败,his系统的患者id为空", "5");
                        return;
                    }
                    String wxCode = "";
                    if (visitHosp == 3) {//市一医院
                        String urlTemp = "http://192.200.54.14:5003/sfjk/SendMessage?sfzh=" + serviceSubtask.getSfzh()
                                + "&title=您好，邀请您填写出院调查表，请点击填写。&content=您好，邀请您填写出院调查表，请点击填写。&phone=" + patArchive.getTelcode()
                                + "&url=" + url + "&key=ff76f8904f5f32b5ee1739e8ea46e60g";
                        HttpUtils.sendGet(urlTemp);
                    } else {
                        wxCode = getWXCode(serviceSubtask.getSfzh(), url, serviceSubtask.getTaskName(), serviceSubtask.getTaskDesc(), patArchive.getTelcode(), serviceSubtask.getSendname(), patArchive.getPatidHis(), wxqqxx);
                    }

                    Map<String, Object> map = JSONObject.parseObject(wxCode, Map.class);
                    //任务发送记录
                    ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                    serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
                    serviceSubtaskRecord.setUuid(UUID.randomUUID().toString());
                    serviceSubtaskRecord.setTasktype(serviceSubtask.getType());
                    serviceSubtaskRecord.setPreachform("4");
                    serviceSubtaskRecord.setStartTime(System.currentTimeMillis());
                    serviceSubtaskRecord.setResult("success");
                    if (!map.isEmpty() && (Boolean) map.get("succ") == false) serviceSubtaskRecord.setResult("error");
                    serviceSubtaskRecordService.insertServiceSubtaskRecord(serviceSubtaskRecord);

                    //发送完成后，修改状态
                    serviceSubtask.setSendstate(3L);
                    if ((Boolean) map.get("succ") == true) {
                        serviceSubtask.setResult("success");
                        setSuccessPreachForm(serviceSubtask, sendPreachform, "【公众号】公众号发送成功", "2");
                    } else {
                        log.error("【sfHandlle】公众号发送失败，患者信息：{}，错误信息：{}", serviceSubtask, map.get("msg"));
                        setSuccessPreachForm(serviceSubtask, sendPreachform, "【公众号】公众号发送失败", "5");
                    }
                } catch (Exception e) {
                    String guid = UUID.randomUUID().toString();
                    log.error("【sfHandlle】长期任务公众号发送失败，原因：{}，GUID：{}", e.getMessage(), guid);
                    setSuccessPreachForm(serviceSubtask, sendPreachform, "【公众号】长期任务公众号发送失败，原因：" + e.getMessage(), "5");
                }
            }
        } else if (descByCode.equals("人工")) {
            setSuccessPreachForm(serviceSubtask, sendPreachform, "人工待执行", "2");
        }

    }


    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));
            }
    private Date getNextVisitTime(Long subid, Long taskid, Date visitTime) {
        ServiceSubtaskPreachform serviceSubtaskPreachform = new ServiceSubtaskPreachform();
        serviceSubtaskPreachform.setSubid(subid);
        serviceSubtaskPreachform.setTaskid(taskid);
        List<ServiceSubtaskPreachform> serviceSubtaskPreachforms = serviceSubtaskPreachformMapper.selectServiceSubtaskPreachformList(serviceSubtaskPreachform);
        if (CollectionUtils.isNotEmpty(serviceSubtaskPreachforms)) {
            String compensateTime = serviceSubtaskPreachforms.get(0).getCompensateTime();
            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);
        }

        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();
                }
        // 情况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"));
            if (!allSendStateNot1AndNot9) {
                //说明，在某种方式发送失败后，又成功了（例如短信或公众号，在规定时间外患者做完了，这个时候，状态改成了9）
                serviceSubtask.setSendstate(6L);
                serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                return "-1";
            }

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

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

            //如果当前的发送方式不为空，并且开始准备要用下一种方式发送了，那当前的肯定没有发送成功，需要设置失败
            // (这里主要是，人工如果没有随访，然后到公众号的时候，就不会再去管人工是否成功，人工的状态会一直卡在2的状态上)
            if (StringUtils.isNotEmpty(serviceSubtask.getCurrentPreachform())) {
                setFail(serviceSubtaskPreachforms, serviceSubtask);
            }

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

        return null;
    }

    private Integer setFail(List<ServiceSubtaskPreachform> serviceSubtaskPreachforms, ServiceSubtask serviceSubtask) {
        Optional<Long> id = serviceSubtaskPreachforms.stream().filter(item -> serviceSubtask.getCurrentPreachform().equals(item.getPreachform())).map(ServiceSubtaskPreachform::getId).findFirst();
        if (id.isPresent()) {
            ServiceSubtaskPreachform subtaskPreachform = new ServiceSubtaskPreachform();
            subtaskPreachform.setSendstate("5");
            subtaskPreachform.setId(id.get());
            return serviceSubtaskPreachformMapper.updateServiceSubtaskPreachform(subtaskPreachform);
        }
        return 0;
    }


    private String getDXCode(String address, String ShouJiHM, String FaSongNR, String FaSongRID, String FaSongRXM, Map<String, Object> headerMap, String token) {
        Map<String, Object> map = new LinkedHashMap<>();
@@ -862,7 +823,7 @@
        } catch (IOException e) {
            e.printStackTrace();
        }
        log.error("--------result的值为：{}-----", result);
        log.info("【getDXCode】短信发送结果：{}", result);

        JSONObject jsonObject = JSONObject.parseObject(result);
        String code = (String) jsonObject.toString();
@@ -881,7 +842,7 @@
        xinHuaWXReq.setTitlename(taskName);
        xinHuaWXReq.setContent(taskDesc);
        xinHuaWXReq.setAppid(wxqqxx.get(1));
        log.error("----getWXCode---xinHuaWXReq的出参为：{}", xinHuaWXReq);
        log.info("【getWXCode】微信公众号请求参数：{}", xinHuaWXReq);
        String body = new Gson().toJson(xinHuaWXReq);
        String encode = encode(wxqqxx.get(2).concat(body));
        Map<String, String> headerMap = new HashMap<>();
@@ -907,4 +868,72 @@
        }
        return toHex(md5.digest());
    }

    public void collectHIS() {
        try {
            // HIS数据采集
            log.info("【dealHisData】HIS开始采集数据");
            ichService.sync();
            log.info("【dealHisData】HIS结束采集数据");
        } catch (Exception e) {
            log.error("【dealHisData】HIS数据采集异常", e);
        }
    }

    public Boolean setSuccessPreachForm(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;
        }


        ServiceSubtaskPreachform serviceSubtaskPreachform = new ServiceSubtaskPreachform();
        serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
        serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
        serviceSubtaskPreachform.setOrgid(serviceSubtask.getOrgid());
        List<ServiceSubtaskPreachform> sspCount = serviceSubtaskPreachformMapper.selectServiceSubtaskPreachformList(serviceSubtaskPreachform);

        serviceSubtaskPreachform.setPreachform(preachform);
        //1:未发送状态
        serviceSubtaskPreachform.setSendstate("1");
        //电话的未发送状态，需要查2，因为，数据可能卡在队列里了; （没进队列，电话状态还是1）
        if (preachform.equals("3") && StringUtils.isNotEmpty(failSendstate) && Long.valueOf(failSendstate) > 2)
            serviceSubtaskPreachform.setSendstate("2");
        //人工的未发送状态，需要查2
        if (preachform.equals("1") && StringUtils.isNotEmpty(failSendstate) && Long.valueOf(failSendstate) > 2)
            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() == sspCount.size()) {
                if (failSendstate.equals("4") || failSendstate.equals("5")) {
                    serviceSubtask.setCurrentPreachform(preachform);
                    serviceSubtask.setSendstate(5L);
                    serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                    return true;
                }
            }
        } else {
            log.error("【定时任务中该患者没有查询到属于他的发送方式，subid：{},prechform:{},orgid:{}】", serviceSubtask.getId(), preachform, serviceSubtask.getOrgid());
            return false;
        }
        //将下一次的随访时间与当前执行方式记录一下
        serviceSubtask.setVisitTime(getNextVisitTime(serviceSubtask.getId(), serviceSubtask.getTaskid(), serviceSubtask.getVisitTime()));
        serviceSubtask.setCurrentPreachform(preachform);
        serviceSubtask.setSendstate(3L);
        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
        return true;
    }
}