代码提交

liusheng

昨天 74ec634d3ecd024e71188cbdfd9a7118c2c645fe

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

@@ -1,8 +1,6 @@
package com.ruoyi.quartz.task;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.reflect.TypeToken;
@@ -10,19 +8,22 @@
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.enums.MsgLSEnum;
import com.ruoyi.common.enums.ServiceFromEnum;
import com.ruoyi.common.utils.DtoConversionUtils;
import com.ruoyi.common.enums.VisitSendStateEnum;
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.smartor.common.SendService;
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.service.*;
import com.sun.org.apache.bcel.internal.generic.NEW;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.ObjectUtils;
@@ -35,12 +36,12 @@
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
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;
@@ -50,6 +51,8 @@
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

import static cn.hutool.core.convert.Convert.toHex;

/**
 * 定时任务调度测试
@@ -98,9 +101,6 @@
    @Value("${pub_key}")
    private String pub_key;

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

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

@@ -142,6 +142,9 @@

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

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

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


    /**
     * 处理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);

        //调用dealOupHospInfo数据处理方法，处理完后，将“出院表的check_flag=1”
        //获取当前日期 （精确到天）往前推相应天数（在指定的基础模板中找对应的天数），
        //循环患者信息，根据患者"出院诊断ICD值”获取到相当的模板（获取取相应的天数）;
        //根据查询出来的模板，去固定任务（固定任务，已经将模板也固定了）去匹配模板
        //根据匹配出来的模板和任务与患者信息，将数据插入到子任务表中
        log.info("【dealHisData】开始执行HIS数据采集任务");
        long startTime = System.currentTimeMillis();
        
        try {
            // 获取昨天0点到今天0点的时间范围
            LocalDateTime todayZero = LocalDateTime.now().with(LocalTime.MIN);
            LocalDateTime yesterdayZero = todayZero.minusDays(1);
            
            log.info("【dealHisData】采集时间范围：{} ~ {}", yesterdayZero, todayZero);
            
            // 采集入院数据
            log.info("【dealHisData】开始采集入院数据");
            getInHospInfo("0", yesterdayZero, todayZero);
            log.info("【dealHisData】入院数据采集完成");
            
            // 采集出院数据
            log.info("【dealHisData】开始采集出院数据");
            getInHospInfo("1", yesterdayZero, todayZero);
            log.info("【dealHisData】出院数据采集完成");
            
            long endTime = System.currentTimeMillis();
            log.info("【dealHisData】HIS数据采集任务完成，总耗时：{}ms", endTime - startTime);
            
        } catch (Exception e) {
            log.error("【dealHisData】HIS数据采集异常", e);
            // 这里可以添加告警通知逻辑，比如发送邮件或短信
        }
    }

    public void dealHisData2() {
        //将患者信息、出院、门诊数据全部采集
        //将患者信息、出入院数据全部采集
        // 指定的开始日期
        LocalDate endDate = LocalDate.of(2025, 3, 3);
        // 当前日期
@@ -248,11 +261,13 @@
     * 处理患者信息，进入子任务表
     */
    public void dealOutHospInfo() {
        //出院表
        iPatMedInhospService.dealOutHospInfo();
        //门诊表
        if (visitHosp != 1) {
            iPatMedOuthospService.dealOutpatientInfo();
        if (port.equals("8095")) {
            //出院表
            iPatMedInhospService.dealOutHospInfo();
            //门诊表
            if (visitHosp != 1) {
                iPatMedOuthospService.dealOutpatientInfo();
            }
        }
    }

@@ -261,22 +276,24 @@
     * 处理手术信息，进入子任务表
     */
    public void dealOperationInfo() {
        iPatMedOperationService.dealOperationInfo();
        if (port.equals("8095")) iPatMedOperationService.dealOperationInfo();

    }

    /**
     * 处理患者信息，进入子任务表(微信小程序)
     */
    public void dealOutHospInfoXHC() {
        PatMedInhosp patMedInhosp = new PatMedInhosp();
        //获取未处理的数据
        List<ServicePatientTemp> servicePatientTemps = iServicePatientTempService.selectServicePatientTempList(new ServicePatientTemp());

        if (port.equals("8095")) {
            PatMedInhosp patMedInhosp = new PatMedInhosp();
            //获取未处理的数据
            List<ServicePatientTemp> servicePatientTemps = iServicePatientTempService.selectServicePatientTempList(new ServicePatientTemp());
        }
    }


    /**
     * 长期任务执行（电话）
     * 长期任务执行
     */
    public void longTaskSend() {
        //获取任务信息
@@ -284,7 +301,7 @@
        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());
@@ -301,34 +318,26 @@
     * @return
     */
    public boolean isDateToday(Date date) {
        //如果给的日期小于当前日期，也直接发送
        LocalDateTime localDateTime = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
        if (localDateTime.isBefore(LocalDateTime.now())) {
            return true;
        if (date == null) {
            return false;
        }
        // 获取当前日期
        Calendar calendarNow = Calendar.getInstance();
        int todayYear = calendarNow.get(Calendar.YEAR);
        int todayMonth = calendarNow.get(Calendar.MONTH);
        int todayDay = calendarNow.get(Calendar.DAY_OF_MONTH);

        // 创建一个 Calendar 实例用于检查的日期
        Calendar calendarToCheck = Calendar.getInstance();
        calendarToCheck.setTime(date);

        // 比较年、月和日
        return (calendarToCheck.get(Calendar.YEAR) == todayYear && calendarToCheck.get(Calendar.MONTH) == todayMonth && calendarToCheck.get(Calendar.DAY_OF_MONTH) == todayDay);
        // 将 Date 转为 LocalDate
        LocalDate localDate = date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        // 获取今天的 LocalDate
        LocalDate today = LocalDate.now();
        // 如果日期早于或等于今天，返回 true
        return !localDate.isAfter(today);
    }

    public void sfHandlle(CommonTaskcallMQ commonTaskcallMQ, String ip) {
        log.error("sfHandlle进来了吗？{}", commonTaskcallMQ);
        log.info("【sfHandlle】开始处理任务，任务ID：{}", commonTaskcallMQ.getTaskid());
        //判断一下commonTaskcallMQ中的stopstate是否与ivr_task中的一致，不一致，则说明是暂停了
        ServiceTask ivrTask1 = serviceTaskMapper.selectServiceTaskByTaskid(commonTaskcallMQ.getTaskid());

        if (StringUtils.isNotEmpty(commonTaskcallMQ.getPreachform())) {
            //如何任务发送方式不为空
            String[] split = commonTaskcallMQ.getPreachform().split(",");
            log.error("split进来了吗？{}", split);
            log.info("【sfHandlle】任务发送方式：{}", Arrays.toString(split));
            for (String serviceFrom : split) {
                String descByCode = ServiceFromEnum.getDescByCode(Integer.valueOf(serviceFrom));
                //通过任务ID拿到患者信息
@@ -336,6 +345,15 @@
                ivrTaskcall.setTaskid(commonTaskcallMQ.getTaskid());
                ivrTaskcall.setSendstate(2L);
                List<ServiceSubtask> subtaskList = iServiceSubtaskService.selectServiceSubtaskList(ivrTaskcall);
                //丽水有的医院还没法做长期任务随访
                List<ServiceSubtask> subtaskList2 = new ArrayList<>();
                if (visitHosp == 2) {
                    for (ServiceSubtask serviceSubtask : subtaskList) {
                        Boolean b = VisitSendStateEnum.getDescByCode(serviceSubtask.getOrgid());
                        if (b) subtaskList2.add(serviceSubtask);
                    }
                    subtaskList = subtaskList2;
                }

                // 按照 endtime 离当前时间最近的排序
                List<ServiceSubtask> selectServiceSubtaskList = subtaskList.stream().sorted(Comparator.comparing(subtask -> Math.abs(subtask.getEndtime().getTime() - new Date().getTime()))).collect(Collectors.toList());
@@ -346,14 +364,14 @@
                    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());
//                            serviceSubtask.setFinishtime(new Date());
                            serviceSubtaskMapper.updateServiceSubtask(serviceSubtask);
                            continue;
                        }
@@ -385,6 +403,7 @@
                    if (list.size() > 0) {
//                        redisCache.setCacheListLeft("cache-0", list);
                        redisCache.setCacheListLeftAndDistinct("cache-0", list);
                        log.info("【sfHandlle】电话任务已加入队列，数量：{}", list.size());
                    }
                } else if (descByCode.equals("多媒体")) {
                    //多媒体
@@ -392,7 +411,7 @@
                    //纸质
                } else if (descByCode.equals("微信小程序")) {
                    //微信小程序
                    log.error("ivrTask1的值为：{}", ivrTask1);
                    log.info("【sfHandlle】处理微信小程序任务，任务信息：{}", ivrTask1);
                    if (ObjectUtils.isNotEmpty(ivrTask1) && ivrTask1.getPatCycle() == 1) {
                        //说明该任务的患者是循环执行的
                        ServiceSubtaskVO serviceSubtaskVO = new ServiceSubtaskVO();
@@ -437,7 +456,7 @@
                    RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
                    String taskId = rsaPublicKeyExample.encryptedData(ivrTask1.getTaskid().toString(), pub_key);
                    for (ServiceSubtask serviceSubtask : selectServiceSubtaskList) {
                        log.error("短信长期任务发送---------进来了吗？{}", serviceSubtask);
                        log.info("【sfHandlle】处理短信长期任务，患者ID：{}", serviceSubtask.getPatid());
                        boolean dateToday = isDateToday(serviceSubtask.getLongSendTime());
                        if (dateToday) {
                            try {
@@ -448,7 +467,7 @@
                                    serviceSubtask.setResult("error");
                                    serviceSubtask.setRemark(patArchive.getNotrequiredreason());
                                    serviceSubtask.setSendstate(4L);
                                    serviceSubtask.setFinishtime(new Date());
//                                    serviceSubtask.setFinishtime(new Date());
                                    iServiceSubtaskService.insertServiceSubtask(serviceSubtask);
                                    continue;
                                }
@@ -470,10 +489,36 @@
                                sendMagParam.setPhone(serviceSubtask.getPhone());
                                sendMagParam.setUrl(ip + ":" + req_path + "/wt?p=" + format);
                                sendMagParam.setContent("【新华医院】您好，邀请您填写出院调查表，请点击" + sendMagParam.getUrl() + "填写。感谢您配合！");
                                Map<String, String> req = new HashMap<>();
                                req.put("phone", sendMagParam.getPhone());
                                req.put("content", sendMagParam.getContent());
                                String isSuccess = HttpUtil.postJsonRequest(xhsmsPath, new Gson().toJson(req));
                                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.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";
                                    }
                                }
                                //任务发送记录
                                ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
                                serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
@@ -499,23 +544,23 @@
                                iServiceSubtaskService.updateServiceSubtask(serviceSubtask);
                            } catch (Exception e) {
                                String guid = UUID.randomUUID().toString();
                                log.error("长期任务，短信发送失败原因：{},{}", e.getMessage(), guid);
                                log.error("【sfHandlle】长期任务短信发送失败，原因：{}，GUID：{}", e.getMessage(), guid);
                                serviceSubtask.setResult("error");
                                serviceSubtask.setRemark("系统错误");
                                serviceSubtask.setSendstate(5L);
                                serviceSubtask.setFinishtime(new Date());
//                                serviceSubtask.setFinishtime(new Date());
                                serviceSubtask.setGuid(guid);
                                iServiceSubtaskService.updateServiceSubtask(serviceSubtask);
                            }
                        }
                    }
                } else if (descByCode.equals("公众号")) {
                    log.error("公众号进来了吗？{}", descByCode);
                    log.info("【sfHandlle】处理公众号任务，任务信息：{}", ivrTask1);
                    //公众号
                    RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
                    String taskId = rsaPublicKeyExample.encryptedData(ivrTask1.getTaskid().toString(), pub_key);
                    for (ServiceSubtask serviceSubtask : selectServiceSubtaskList) {
                        log.error("serviceSubtask---------进来了吗？{}", serviceSubtask);
                        //  log.error("serviceSubtask---------进来了吗？{}", serviceSubtask);
                        boolean dateToday = isDateToday(serviceSubtask.getLongSendTime());
                        if (dateToday) {
                            try {
@@ -526,7 +571,7 @@
                                    serviceSubtask.setResult("error");
                                    serviceSubtask.setRemark(patArchive.getNotrequiredreason());
                                    serviceSubtask.setSendstate(4L);
                                    serviceSubtask.setFinishtime(new Date());
//                                    serviceSubtask.setFinishtime(new Date());
                                    iServiceSubtaskService.insertServiceSubtask(serviceSubtask);
                                    continue;
                                }
@@ -535,10 +580,32 @@
                                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(), "无");

                                String wxCode = getWXCode(serviceSubtask.getSfzh(), url, serviceSubtask.getTaskName(), serviceSubtask.getTaskDesc(), patArchive.getTelcode(), serviceSubtask.getSendname(), patArchive.getPatientno());
                                //获取微信公众号请求信息根据机构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());
@@ -556,6 +623,7 @@
                                if ((Boolean) map.get("succ") == true) {
                                    serviceSubtask.setResult("success");
                                } else {
                                    log.error("【sfHandlle】公众号发送失败，患者信息：{}，错误信息：{}", serviceSubtask, map.get("msg"));
                                    serviceSubtask.setResult("error");
                                    serviceSubtask.setSendstate(5L);
                                    serviceSubtask.setRemark(map.get("msg").toString());
@@ -563,11 +631,11 @@
                                iServiceSubtaskService.updateServiceSubtask(serviceSubtask);
                            } catch (Exception e) {
                                String guid = UUID.randomUUID().toString();
                                log.error("长期任务，公众号发送失败原因：{},{}", e.getMessage(), guid);
                                log.error("【sfHandlle】长期任务公众号发送失败，原因：{}，GUID：{}", e.getMessage(), guid);
                                serviceSubtask.setResult("error");
                                serviceSubtask.setRemark("系统错误");
                                serviceSubtask.setSendstate(5L);
                                serviceSubtask.setFinishtime(new Date());
//                                serviceSubtask.setFinishtime(new Date());
                                serviceSubtask.setGuid(guid);
                                iServiceSubtaskService.updateServiceSubtask(serviceSubtask);
                            }
@@ -581,186 +649,382 @@


    /**
     * 获出院患者信息
     * cry    出入院： 0 入院   1 出院
     * 获取患者出入院信息
     * @param cry 出入院类型：0-入院，1-出院
     * @param startTime 开始时间
     * @param endTime 结束时间
     */
    @Transactional
    public void getInHospInfo(String cry, LocalDateTime startTime, LocalDateTime endTime) {
        // 定义日期时间格式
        String typeName = "0".equals(cry) ? "入院" : "出院";
        log.info("【getInHospInfo】开始获取{}患者信息，时间范围：{} ~ {}", typeName, startTime, endTime);
        long startTimeMillis = System.currentTimeMillis();
        
        try {
            // 第一步：构建请求参数并调用HIS接口
            List<ThiedInhospInfo> thiedInhospInfoList = fetchHisData(cry, startTime, endTime);
            
            if (CollectionUtils.isEmpty(thiedInhospInfoList)) {
                log.info("【getInHospInfo】{}患者信息为空，跳过处理", typeName);
                return;
            }
            
            log.info("【getInHospInfo】获取到{}条{}患者信息", thiedInhospInfoList.size(), typeName);
            
            // 第二步：保存原始数据到文件（用于备份）
            saveRawDataToFile(cry, thiedInhospInfoList);
            
            // 第三步：处理患者数据
            processPatientData(thiedInhospInfoList, cry);
            
            long endTimeMillis = System.currentTimeMillis();
            log.info("【getInHospInfo】{}患者信息处理完成，耗时：{}ms", typeName, endTimeMillis - startTimeMillis);
            
        } catch (Exception e) {
            log.error("【getInHospInfo】获取{}患者信息异常", typeName, e);
            throw new RuntimeException("获取" + typeName + "患者信息失败", e);
        }
    }
    
    /**
     * 第一步：调用HIS接口获取数据
     */
    private List<ThiedInhospInfo> fetchHisData(String cry, LocalDateTime startTime, LocalDateTime endTime) {
        try {
            // 构建请求参数
            Map<String, String> requestParams = buildRequestParams(cry, startTime, endTime);
            
            // 构建请求头
            Map<String, String> headers = buildRequestHeaders(startTime);
            
            // 发送HTTP请求
            String result = HttpUtils.sendPostByHeader(hospInfoUrl, new Gson().toJson(requestParams), headers);
            
            // 解析响应数据
            return parseResponseData(result);
            
        } catch (Exception e) {
            log.error("【fetchHisData】调用HIS接口异常", e);
            throw e;
        }
    }
    
    /**
     * 构建请求参数
     */
    private Map<String, String> buildRequestParams(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")) {
        
        if ("1".equals(cry)) {
            // 出院参数
            req.put("cashStartDate", startTime.format(formatter));
            req.put("cashEndDate", endTime.format(formatter));
            req.put("currStatus", "4");
        } else if (cry.equals("0")) {
        } else {
            // 入院参数
            req.put("admissStartDate", startTime.format(formatter));
            req.put("admissEndDate", endTime.format(formatter));
            req.put("currStatus", "2");
        }
        
        return req;
    }
    
    /**
     * 构建请求头
     */
    private Map<String, String> buildRequestHeaders(LocalDateTime startTime) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.S");
        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();
            }
        }
        // 将数据写入到文件中
        return header;
    }
    
    /**
     * 解析响应数据
     */
    private List<ThiedInhospInfo> parseResponseData(String result) {
        try {
            FileWriter writer = new FileWriter(file);
            writer.write(result);
        } catch (IOException e) {
            e.printStackTrace();
            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();
            return gson.fromJson(resultArray, resultType);
        } catch (Exception e) {
            log.error("【parseResponseData】解析响应数据异常，原始数据：{}", result, e);
            throw e;
        }

        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);
    }
    
    /**
     * 第二步：保存原始数据到文件
     */
    private void saveRawDataToFile(String cry, List<ThiedInhospInfo> dataList) {
        try {
            String typeName = "0".equals(cry) ? "入院信息" : "出院信息";
            String filename = typeName + "_" + System.currentTimeMillis() + ".json";
            String filePath = "D:\\public\\HIS数据采集\\" + filename;
            
            File file = new File(filePath);
            File parentDir = file.getParentFile();
            if (!parentDir.exists()) {
                parentDir.mkdirs();
            }
            
            if (!file.exists()) {
                file.createNewFile();
            }
            
            // 将数据写入文件
            try (FileWriter writer = new FileWriter(file)) {
                writer.write(new Gson().toJson(dataList));
            }
            
            log.info("【saveRawDataToFile】原始数据已保存到文件：{}", filePath);
            
        } catch (Exception e) {
            log.error("【saveRawDataToFile】保存原始数据到文件异常", e);
            // 文件保存失败不影响主流程，只记录日志
        }
    }
    
    /**
     * 第三步：处理患者数据
     */
    private void processPatientData(List<ThiedInhospInfo> thiedInhospInfoList, String cry) {
        int successCount = 0;
        int skipCount = 0;
        int errorCount = 0;
        
        for (ThiedInhospInfo thiedInhospInfo : thiedInhospInfoList) {
            try {
                if (processSinglePatient(thiedInhospInfo, cry)) {
                    successCount++;
                } else {
                    //患者信息为空，直接 下一个
                    continue;
                    skipCount++;
                }
                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()));
                    } else {
                        patArchive.setAge(null);
                    }
                    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);
                }

                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);
                }

            } catch (Exception e) {
                errorCount++;
                log.error("【processPatientData】处理患者数据异常，患者ID：{}", 
                    thiedInhospInfo.getPatiMediaNo(), e);
            }
        }
        
        log.info("【processPatientData】患者数据处理完成，成功：{}，跳过：{}，失败：{}", 
            successCount, skipCount, errorCount);
    }
    
    /**
     * 处理单个患者数据
     */
    private boolean processSinglePatient(ThiedInhospInfo thiedInhospInfo, String cry) {
        // 验证身份证号
        if (StringUtils.isEmpty(thiedInhospInfo.getPatiIdCardNo())) {
            log.warn("【processSinglePatient】患者身份证号为空，跳过处理，患者编号：{}", 
                thiedInhospInfo.getPatiMediaNo());
            return false;
        }
        
        // 处理患者档案信息
        PatArchive patArchive = processPatientArchive(thiedInhospInfo, cry);
        
        // 处理患者住院信息
        processPatientInhospInfo(thiedInhospInfo, patArchive, cry);
        
        return true;
    }
    
    /**
     * 处理患者档案信息
     */
    private PatArchive processPatientArchive(ThiedInhospInfo thiedInhospInfo, String cry) {
        // 查询患者是否已存在
        PatArchive queryArchive = new PatArchive();
        queryArchive.setIdcardno(thiedInhospInfo.getPatiIdCardNo().trim());
        List<PatArchive> existingArchives = patArchiveService.selectPatArchiveList(queryArchive);
        
        // 构建患者档案信息
        PatArchive patArchive = buildPatientArchive(thiedInhospInfo, cry);
        
        // 保存或更新患者档案
        if (CollectionUtils.isEmpty(existingArchives)) {
            patArchiveService.insertPatArchive(patArchive);
            log.debug("【processPatientArchive】新增患者档案，患者编号：{}", patArchive.getPatientno());
        } else {
            patArchive.setId(existingArchives.get(0).getId());
            patArchiveService.updateArchive(patArchive);
            log.debug("【processPatientArchive】更新患者档案，患者编号：{}", patArchive.getPatientno());
        }
        
        return patArchive;
    }
    
    /**
     * 构建患者档案信息
     */
    private PatArchive buildPatientArchive(ThiedInhospInfo thiedInhospInfo, String cry) {
        PatArchive patArchive = new PatArchive();
        
        // 基本信息
        patArchive.setPatientno(thiedInhospInfo.getPatiMediaNo());
        patArchive.setIdcardno(thiedInhospInfo.getPatiIdCardNo().trim());
        patArchive.setName(thiedInhospInfo.getPatiRecordName());
        patArchive.setSourcefrom(2);
        patArchive.setPattype("2");
        
        // 性别
        patArchive.setSex("男".equals(thiedInhospInfo.getPatiRecordGender()) ? 1L : 2L);
        
        // 民族和籍贯
        patArchive.setNation(thiedInhospInfo.getPatiNation());
        patArchive.setNativePlace(thiedInhospInfo.getPatiNationality());
        
        // 居住地址
        String homeAddr = thiedInhospInfo.getPatiHomeAddr();
        patArchive.setPlaceOfResidence(StringUtils.isNotEmpty(homeAddr) ? homeAddr.replace("null", "") : "");
        
        // 出生日期
        if (StringUtils.isNotEmpty(thiedInhospInfo.getPatiBirthday())) {
            try {
                patArchive.setBirthdate(new SimpleDateFormat("yyyy-MM-dd").parse(thiedInhospInfo.getPatiBirthday()));
            } catch (ParseException e) {
                log.warn("【buildPatientArchive】解析出生日期失败：{}", thiedInhospInfo.getPatiBirthday(), e);
            }
        }
        
        // 年龄
        if (thiedInhospInfo.getTreateAge() != null) {
            patArchive.setAge(Long.valueOf(thiedInhospInfo.getTreateAge()));
        }
        patArchive.setAgeUnit(thiedInhospInfo.getTreatAgeunit());
        
        // 联系方式
        patArchive.setTelcode(thiedInhospInfo.getCompanyTelNum());
        patArchive.setRelativetelcode(thiedInhospInfo.getContactPersonPhone());
        
        // 出院方式处理（死亡等特殊情况）
        if (StringUtils.isNotEmpty(thiedInhospInfo.getOutWayId()) && "4".equals(thiedInhospInfo.getOutWayId())) {
            patArchive.setNotrequiredFlag("1");
            patArchive.setNotrequiredreason(thiedInhospInfo.getOutWayName());
        }
        if ("1".equals(cry) && StringUtils.isEmpty(thiedInhospInfo.getOutWayId())) {
            patArchive.setNotrequiredFlag("1");
            patArchive.setNotrequiredreason("出院方式为空");
        }
        
        // 系统字段
        patArchive.setDelFlag("0");
        patArchive.setCreateTime(new Date());
        patArchive.setUpdateTime(new Date());
        
        return patArchive;
    }
    
    /**
     * 处理患者住院信息
     */
    private void processPatientInhospInfo(ThiedInhospInfo thiedInhospInfo, PatArchive patArchive, String cry) {
        // 构建住院信息
        PatMedInhosp patMedInhosp = buildPatientInhospInfo(thiedInhospInfo, patArchive, cry);
        
        // 查询是否已存在住院记录
        PatMedInhosp queryInhosp = new PatMedInhosp();
        queryInhosp.setPatno(patArchive.getPatientno());
        queryInhosp.setSerialnum(patMedInhosp.getSerialnum());
        List<PatMedInhosp> existingInhosps = patMedInhospService.selectPatMedInhospList(queryInhosp);
        
        // 保存或更新住院信息
        if (CollectionUtils.isNotEmpty(existingInhosps)) {
            patMedInhosp.setInhospid(existingInhosps.get(0).getInhospid());
            patMedInhospService.updatePatMedInhosp(patMedInhosp);
            log.debug("【processPatientInhospInfo】更新住院信息，患者编号：{}，流水号：{}", 
                patArchive.getPatientno(), patMedInhosp.getSerialnum());
        } else {
            patMedInhospService.insertPatMedInhosp(patMedInhosp);
            log.debug("【processPatientInhospInfo】新增住院信息，患者编号：{}，流水号：{}", 
                patArchive.getPatientno(), patMedInhosp.getSerialnum());
        }
    }
    
    /**
     * 构建患者住院信息
     */
    private PatMedInhosp buildPatientInhospInfo(ThiedInhospInfo thiedInhospInfo, PatArchive patArchive, String cry) {
        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");
        patMedInhosp.setInhospstate("0".equals(cry) ? "0" : "1");
        
        // 医院和科室信息
        patMedInhosp.setHospitalcode(thiedInhospInfo.getAreaId());
        patMedInhosp.setDeptcode(thiedInhospInfo.getAdmissDeptId());
        patMedInhosp.setDeptid(thiedInhospInfo.getAdmissDeptId());
        patMedInhosp.setDeptname(thiedInhospInfo.getAdmissDeptName());
        patMedInhosp.setBedNo(thiedInhospInfo.getAdmissBedNo());
        
        // 诊断信息
        patMedInhosp.setIcd10code(thiedInhospInfo.getDiagIcd10());
        patMedInhosp.setDiagname(thiedInhospInfo.getDiagName());
        
        // 时间信息
        if (StringUtils.isNotEmpty(thiedInhospInfo.getAdmissDate())) {
            try {
                patMedInhosp.setStarttime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(thiedInhospInfo.getAdmissDate()));
            } catch (ParseException e) {
                log.warn("【buildPatientInhospInfo】解析入院时间失败：{}", thiedInhospInfo.getAdmissDate(), e);
            }
        }
        
        if (StringUtils.isNotEmpty(thiedInhospInfo.getOutDate())) {
            try {
                patMedInhosp.setEndtime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(thiedInhospInfo.getOutDate()));
            } catch (ParseException e) {
                log.warn("【buildPatientInhospInfo】解析出院时间失败：{}", thiedInhospInfo.getOutDate(), e);
            }
        }
        
        // 出院信息
        patMedInhosp.setLeaveldeptcode(thiedInhospInfo.getCurrDeptId());
        patMedInhosp.setLeaveldeptname(thiedInhospInfo.getCurrDeptName());
        patMedInhosp.setLeavediagname(thiedInhospInfo.getDiagName());
        patMedInhosp.setLeaveicd10code(thiedInhospInfo.getDiagIcd10());
        patMedInhosp.setOutWayId(thiedInhospInfo.getOutWayId());
        patMedInhosp.setOutWayName(thiedInhospInfo.getOutWayName());
        
        // 医生信息
        patMedInhosp.setDrname(thiedInhospInfo.getDoctName());
        patMedInhosp.setDrcode(thiedInhospInfo.getDoctId());
        
        // 病区信息
        patMedInhosp.setLeavehospitaldistrictid(thiedInhospInfo.getCurrWardCode());
        patMedInhosp.setLeavehospitaldistrictcode(thiedInhospInfo.getCurrWardId());
        patMedInhosp.setLeavehospitaldistrictname(thiedInhospInfo.getCurrWardName());
        patMedInhosp.setLeaveldeptid(thiedInhospInfo.getCurrDeptCode());
        
        // 状态信息
        patMedInhosp.setSchemestatus("0".equals(cry) ? 1L : 2L);
        
        // 系统字段
        patMedInhosp.setDelFlag("0");
        patMedInhosp.setOrgid("1");
        
        return patMedInhosp;
    }


@@ -792,7 +1056,38 @@
        return key;
    }

    private String getWXCode(String idcard, String url, String taskName, String taskDesc, String phone, String setPatientname, String setPatientid) {
    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<>();

        Map<String, Object> YeWuXX = new LinkedHashMap<>();
        Map<String, Object> DuanXinXX = new LinkedHashMap<>();
        DuanXinXX.put("ShouJiHM", ShouJiHM);
        DuanXinXX.put("FaSongNR", FaSongNR);
        DuanXinXX.put("FaSongRID", FaSongRID);
        DuanXinXX.put("FaSongRXM", FaSongRXM);
        YeWuXX.put("DuanXinXX", DuanXinXX);

        map.put("XiaoXiTou", headerMap);
        map.put("YeWuXX", YeWuXX);

        String body = new Gson().toJson(map);

//        String result = HttpUtils.sendPost(address, body);
        String result = null;
        try {
            result = OkHttpExample.sendPostRequest(address, body, token);
        } catch (IOException e) {
            e.printStackTrace();
        }
        log.info("【getDXCode】短信发送结果：{}", result);

        JSONObject jsonObject = JSONObject.parseObject(result);
        String code = (String) jsonObject.toString();
        return code;
    }


    private String getWXCode(String idcard, String url, String taskName, String taskDesc, String phone, String setPatientname, String setPatientid, List<String> wxqqxx) {
        XinHuaWXReq xinHuaWXReq = new XinHuaWXReq();
        xinHuaWXReq.setIdcard(idcard);
        xinHuaWXReq.setUrl(url);
@@ -802,17 +1097,31 @@
        xinHuaWXReq.setMedcardno(null);
        xinHuaWXReq.setTitlename(taskName);
        xinHuaWXReq.setContent(taskDesc);
        xinHuaWXReq.setAppid(appid);
        log.error("----getWXCode---xinHuaWXReq的出参为：{}", xinHuaWXReq);
        String result = HttpUtils.sendPost(thirdWXUrl, new Gson().toJson(xinHuaWXReq));
        xinHuaWXReq.setAppid(wxqqxx.get(1));
        log.info("【getWXCode】微信公众号请求参数：{}", xinHuaWXReq);
        String body = new Gson().toJson(xinHuaWXReq);
        String encode = encode(wxqqxx.get(2).concat(body));
        Map<String, String> headerMap = new HashMap<>();
        headerMap.put("sign", encode);
        String result = HttpUtils.sendPostByHeader(wxqqxx.get(3), body, headerMap);

        JSONObject jsonObject = JSONObject.parseObject(result);
        String code = (String) jsonObject.toString();
        return code;
    }
//    public static void main(String[] args) {
//        LocalDateTime originalDateTime = LocalDateTime.now();
//        LocalDateTime startOfDay = originalDateTime.with(LocalTime.MIN);
//        System.out.println("Original DateTime: " + originalDateTime);
//        System.out.println("Start of Day: " + startOfDay);
//    }


    public String encode(String arg) {
        if (arg == null) {
            arg = "";
        }
        MessageDigest md5 = null;
        try {
            md5 = MessageDigest.getInstance("MD5");
            md5.update(arg.getBytes("UTF-8"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return toHex(md5.digest());
    }
}